mmap内存映射

最新推荐文章于 2024-09-09 17:51:49 发布
最新推荐文章于 2024-09-09 17:51:49 发布
阅读量2.4k 收藏 15
点赞数 2
分类专栏： linux 文章标签： c++ c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45205160/article/details/127058517
版权

内存映射通信

一、mmap (memory_map)

1.1 简介

存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据，就相当于读文件中的相应字节。于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。

在这里插入图片描述

1.2 mmap函数
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);

参数：
	addr： 指定映射区的首地址。通常传 NULL，表示让系统自动分配
	length：共享内存映射区的大小。（<= 文件的实际大小）
    *如果使用length > 文件大小，那么就会出现总线错误*
	prot： 共享内存映射区的读写属性。PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE
	flags： 标注共享内存的共享属性。MAP_SHARED、MAP_PRIVATE  
    		shared 意思是修改会反映到磁盘上
			private 表示修改不反映到磁盘上
	fd: 用于创建共享内存映射区的那个文件的 文件描述符。
offset：默认 0，表示映射文件全部。偏移位置。需是 4k 的整数倍。
返回值：
	成功：映射区的首地址。
	失败：MAP_FAILED (void*(-1))， errno

二、程序例程

2.1 mmap建立映射区
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

void sys_err(const char* str){
    perror(str);
    exit(1);
}

/*
mmap:memorty_map 内存映射试验
*/
int main(int argc,char* argv[]){

    char *p = NULL; //用于接收mmap的返回地址
    int fd; //用于文件的接收

    fd = open("testmmap", O_RDWR | O_CREAT | O_TRUNC, 0664);

    if(fd == -1){//打开失败
        sys_err("open error");
    }
	/*
    lseek(fd, 9, SEEK_END);  //将文件给扩展长度到10
    write(fd, "\0", 1);
    */
    ftruncate(fd,10); //将文件给扩展长度到10

    int len = lseek(fd, 0, SEEK_END);//获取文件的长度
    //将文件全部进行内存映射
    p = (char*)mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

    if(p == MAP_FAILED){
        sys_err("mmap error");
    }
    
    close(fd);

    strcpy(p, "hello\n");//进行写操作
    printf("------%s\n",p);//打印

    int ret = munmap(p,len);//解除映射

    if(ret == -1){
        sys_err("munmap error");
    }

    return 0;
}

运行结果

haitu@ubuntu:/opt/modbus_test/linux_test/mmap$ ls
makefile  mmap_test  mmap_test.c  testmmap
haitu@ubuntu:/opt/modbus_test/linux_test/mmap$ cat testmmap 
hello
haitu@ubuntu:/opt/modbus_test/linux_test/mmap$ ./mmap_test 
------hello

haitu@ubuntu:/opt/modbus_test/linux_test/mmap$
2.2 使用注意事项

  1. 用于创建映射区的文件大小为 0，实际指定非 0 大小创建映射区，出 “总线错误”。

  2. 用于创建映射区的文件大小为 0，实际制定 0 大小创建映射区， 出 “无效参数”。

  3. 用于创建映射区的文件读写属性为，只读。映射区属性为 读、写。 出 “无效参数”。

  4. 创建映射区，需要 read 权限。当访问权限指定为 “共享”MAP_SHARED 时， mmap 的读写权

限，应该 <=文件的 open 权限。

只写不行。

  1. 文件描述符 fd，在 mmap 创建映射区完成即可关闭。后续访问文件，用 地址访问。

  2. offset 必须是 4096 的整数倍。（MMU 映射的最小单位 4k ）

  3. 对申请的映射区内存，不能越界访问。

  4. munmap 用于释放的 地址，必须是 mmap 申请返回的地址。

  5. 映射区访问权限为 “私有”MAP_PRIVATE, 对内存所做的所有修改，只在内存有效，不会反

应到物理磁盘上。

  1. 映射区访问权限为 “私有”MAP_PRIVATE, 只需要 open 文件时，有读权限，用于创建映射

区即可。

3.3 进行函数封装

借鉴malloc和free函数原型，写自定义函数smalloc，sfree来完成映射区的建立和释放

#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

void sys_err(const char* str){
    perror(str);
    exit(1);
}

//实现类似c语言中的malloc
/**
 * len：创建内存映射的长度
 * filename:文件名
 * void* 返回值，内存映射的首地址
 */
void *smalloc(int len,char *filename){
    void *p = NULL;
    int fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0664);
    if(fd == -1){
        perror("open error");  //文件打开失败
        return NULL;
    }

    ftruncate(fd,len); //对文件进行扩展

    int fileLen = lseek(fd, 0, SEEK_END); //获取文件的长度
    //对文件的全部进行处理成全映射
    p = (char*)mmap(NULL, fileLen, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

    if(p == MAP_FAILED){ //如果没有实现映射的话
        sys_err("mmap error");
        return MAP_FAILED;//实际上就是(void*)(-1)
    }

    return p;
}

/**
 * p:创建的内存映射首地址
 * len:创建内存映射的长度
 */
int sfree(void * p,int len){
    int ret = munmap(p,len);
    if(ret == -1){
        perror("munmap error");
        return -1;
    }
    return 1;
}

int main(int argc,char* argv[]){

    char *p = NULL; //用于接收mmap的返回地址
    //int fd; //用于文件的接收

    p = (char *)smalloc(20, "smallocTest");

    strcpy(p, "hello nihao\n");

    printf("--------%s", p);

    int ret = sfree((void *)p,20);

    if(ret == 1){
        printf("munmap success");
    }else{
        printf("munmap error");
    }

    return 0;
}

函数执行结果：

haitu@ubuntu:/opt/modbus_test/linux_test/mmap$ ./smalloc 
--------hello nihao
munmap successhaitu@ubuntu:/opt/modbus_test/linux_test/mmap$ ls
makefile  mmap_test  mmap_test.c  smalloc  smalloc.c  smallocTest  testmmap
haitu@ubuntu:/opt/modbus_test/linux_test/mmap$ cat smallocTest 
hello nihao
haitu@ubuntu:/opt/modbus_test/linux_test/mmap$

三、父子进程之间的mmap通信

父子进程使用 mmap 进程间通信：

父进程 先 创建映射区。 open（ O_RDWR） mmap( MAP_SHARED );

指定 MAP_SHARED 权限 fork() 创建子进程。

一个进程读， 另外一个进程写。

#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

void sys_err(const char* str){
    perror(str);
    exit(1);
}

int var = 100;

/*
mmap:memorty_map 内存映射试验
*/
int main(int argc,char* argv[]){

    char *p = NULL; //用于接收mmap的返回地址
    int fd; //用于文件的接收
	pid_t pid;

    fd = open("testmmap", O_RDWR | O_CREAT | O_TRUNC, 0664);

    if(fd == -1){//打开失败
        sys_err("open error");
    }
    /*
    lseek(fd, 9, SEEK_END);  //将文件给扩展长度到10
    write(fd, "\0", 1);
    */
    ftruncate(fd,10); //将文件给扩展长度到10

    int len = lseek(fd, 0, SEEK_END);//获取文件的长度
    //将文件全部进行内存映射
    p = (char*)mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

    if(p == MAP_FAILED){
        sys_err("mmap error");
    }
	close(fd);
    /*
    int flag = unlink("testmmap");  //--将文件删除
    if(flag == -1){
    	perror("unlink error");
    	exit(1);
    }
    */

	pid = fork();//创建子进程

	if(pid == 0){
		*p = 20;  //写共享内存
		var = 1000;
		printf("child ,*p=%d,var=%d\n",*p,var);
	}
	else{
		sleep(1);
		printf("parent,*p=%d,var = %d\n",*p,var);
	}

    int ret = munmap(p,len);//解除映射

    if(ret == -1){
        sys_err("munmap error");
    }

    return 0;
}

执行结果：

haitu@ubuntu:/opt/modbus_test/linux_test/mmap$ ./mmap_parent_son 
child ,*p=20,var=1000
parent,*p=20,var = 100
haitu@ubuntu:/opt/modbus_test/linux_test/mmap$ 
    
注意：如果上面的p = (char*)mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
改为：p = (char*)mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);那么就无法进行父子进程之间的通信。

四、无血缘关系之间的通信

就上面的程序进行更改

4.1 写进程 mmap_w.c程序
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

void sys_err(const char* str){
    perror(str);
    exit(1);
}

int var = 100;
/*
mmap:memorty_map 内存映射试验
*/
int main(int argc,char* argv[]){

    char *p = NULL; //用于接收mmap的返回地址
    int fd; //用于文件的接收

    fd = open("testmmap", O_RDWR | O_CREAT | O_TRUNC, 0664);  //打开文件testmmap用作映射

    if(fd == -1){//打开失败
        sys_err("open error");
    }
    /*
    lseek(fd, 9, SEEK_END);  //将文件给扩展长度到10
    write(fd, "\0", 1);
    */
    ftruncate(fd,10); //将文件给扩展长度到10

    int len = lseek(fd, 0, SEEK_END);//获取文件的长度
    //将文件全部进行内存映射
    p = (char*)mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

    if(p == MAP_FAILED){
        sys_err("mmap error");
    }
	close(fd);
	
	while(1){
		memcpy(p,&var,sizeof(var));  //往里面写var值
		var++;  //var值时刻变化
		sleep(1);
	}

    int ret = munmap(p,len);//解除映射

    if(ret == -1){
        sys_err("munmap error");
    }

    return 0;
}
4.2 读进程 mmap_r.c
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

void sys_err(const char* str){
    perror(str);
    exit(1);
}

int var = 100;

/*
mmap:memorty_map 内存映射试验
*/
int main(int argc,char* argv[]){

    char *p = NULL; //用于接收mmap的返回地址
    int fd; //用于文件的接收

    fd = open("testmmap", O_RDONLY);

    if(fd == -1){//打开失败
        sys_err("open error");
    }
    /*
    lseek(fd, 9, SEEK_END);  //将文件给扩展长度到10
    write(fd, "\0", 1);
    */
    //ftruncate(fd,10); //将文件给扩展长度到10

    int len = lseek(fd, 0, SEEK_END);//获取文件的长度
    //将文件全部进行内存映射
    p = (char*)mmap(NULL, len, PROT_READ , MAP_SHARED, fd, 0);

    if(p == MAP_FAILED){
        sys_err("mmap error");
    }
	close(fd);

	while(1){
		printf("%d\n",*p);
		sleep(2);
	}

    int ret = munmap(p,len);//解除映射

    if(ret == -1){
        sys_err("munmap error");
    }

    return 0;
}
4.3 结果
写进程打开
haitu@ubuntu:/opt/modbus_test/linux_test/mmap$ ./mmap_w
读进程显示
haitu@ubuntu:/opt/modbus_test/linux_test/mmap$ ./mmap_r
0
104
106
108
110
112
114
116
118
120
122
124
126
^C
haitu@ubuntu:/opt/modbus_test/linux_test/mmap$ 

注意：多个写端一个读端也没问题，打开多个写进程即可，读进程会读到所有写进程写入的内容。这里要特别注意，内容被读走之后不会消失，所以如果读进程的读取时间间隔短，它会读到很多重复内容，就是因为写进程没来得及写入新内容，内容没有被覆盖掉。

五、匿名映射

实质上mmap是内核借助文件帮我们创建了一个映射区，多个进程之间利用该映射区完成数据传递。由于内核空间多进程共享，因此无血缘关系的进程间也可以使用mmap来完成通信。只要设置相应的标志位参数flags即可。若想实现共享，当然应该使用MAP_SHARED了

int *p = NULL;
p = (int *)mmap(NULL, 40, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);//创建映射
//----- 内存映射内容
munmap(p,40) //清除映射
注意：匿名映射：只能用于 血缘关系进程间通信。

例子程序:

#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>

void sys_err(const char* str){
    perror(str);
    exit(1);
}

int var = 100;

/*
mmap:memorty_map 内存映射试验
*/
int main(int argc,char* argv[]){

    char *p = NULL; //用于接收mmap的返回地址
	pid_t pid;
    
    p = (char*)mmap(NULL, 40, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);

    if(p == MAP_FAILED){
        sys_err("mmap error");
    }

	pid = fork();//创建子进程

	if(pid == 0){
		*p = 20;  //写共享内存
		var = 1000;
		printf("child ,*p=%d,var=%d\n",*p,var);
	}
	else{
		sleep(1);
		printf("parent,*p=%d,var = %d\n",*p,var);
	}

    int ret = munmap(p,40);//解除映射

    if(ret == -1){
        sys_err("munmap error");
    }

    return 0;
}
东方欲晓w
关注
专栏目录
mmap 内存映射详解
m0_74282605的博客
11-07 2048
mmap是一种内存映射的方法，这一功能可以用在文件的处理上，即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。原因是，内存的最小粒度是页，而进程虚拟地址空间和内存的映射也是以页为单位。因此mmap效率更高。5. 为映射分配了新的虚拟地址区域后，通过待映射的文件指针，在文件描述符表中找到对应的文件描述符，通过文件描述符，链接到内核“已打开文件集”中该文件的文件结构体（struct file），每个文件结构体维护着和这个已打开文件相关各项信息。
Linux mmap内存映射
m0_74282605的博客
03-13 659
mmap除了可以减少read,write等系统调用以外，还可以减少内存的拷贝次数，比如在read调用时，一个完整的流程是操作系统读磁盘文件到页缓存，再从页缓存将数据拷贝到read传递的buffer里，而如果使用mmap之后，操作系统只需要将磁盘读到页缓存，然后用户就可以直接通过指针的方式操作mmap映射的内存，减少了从内核态到用户态的数据拷贝。（1）实际拷贝数据前，需要建立映射信息，内存文件映射已经提前准备好了映射关系，内核调度好了进程内的内存块，交付给内核进行了预先处理，内存文件映射会消耗掉一些时间。
I2C总线协议/地址详解
热门推荐
dyx1993的博客
02-07 2万+
IIC总线 1.1. 概述 IIC开发于1982年，当时是为了给电视机内的CPU和外围芯片提供更简易的互连方式。电视机是最早的嵌入式系统之一，而最初的嵌入系统是使用内存映射（memory-mapped I/O）的方式来互连微控制器和外围设备的。要实现内存映射，设备必须并行连入微控制器的数据线和地址线，这种方式在连接多个外设时需大量线路和额外地址解码芯片，很不方便并且成本高。 为了节省微控制器的引脚和和额外的逻辑芯片，使印刷电路板更简单，成本更低，位于荷兰的Philips实验室开发了IIC...
linux mmap文件内存映射机制
10-16
mmap系统调用并不是完全为了用于共享内存而设计的。它本身提供了不同于一般对普通文件的访问方式，进程可以像读写内存一样对普通文件的操作。而 Posix或系统V的共享内存IPC则纯粹用于共享目的，当然mmap()实现共享内存也是其主要应用之一。 　　mmap系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以像访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。
UEFI——获取UEFI MemoryMap
最新发布
qq_44807736的博客
09-09 977
内存映射（Memory Mapping）是一种将文件内容映射到进程的虚拟地址空间的技术。在这种机制下，文件可以视为内存的一部分，从而允许程序直接对这部分内存进行读写操作，而无需传统的I/O调用。内存映射缓冲区利用虚拟内存机制，让操作系统将一部分磁盘文件映射到进程地址空间的一块连续区域当中。操作系统负责管理内存页的加载和卸载，应用程序只需要访问这块内存区域即可，从而避免了频繁的磁盘I/O操作和多余的系统调用。
内存映射mmap技术详解
大隐隐于野
06-03 4320
前面讲过，建立内存映射并没有实际拷贝数据，这时，MMU在地址映射表中是无法找到与ptr相对应的物理地址的，也就是MMU失败，将产生一个缺页中断，缺页中断的中断响应函数会在swap中寻找相对应的页面，如果找不到（也就是该文件从来没有被读入内存的情况），则会通过mmap()建立的映射关系，从硬盘上将文件读取到物理内存中，如图1中过程3所示。当进程发起读写操作时，会访问虚拟地址空间，通过查询页表，发现这段地址不在物理页上，因为只建立了地址映射，真正的数据还没有拷贝到内存，因此引发缺页异常。
内存映射mmap
m0_74936872的博客
04-13 422
flags：由以下几个常值指定：MAP_SHARED（共享的） MAP_PRIVATE（私有的）, MAP_FIXED（表示必须使用 start 参数作为开始地址，如果失败不进行修正），其中，MAP_SHARED , MAP_PRIVATE必选其一，而 MAP_FIXED 则不推荐使用。（4） 用于映射的文件大小必须>0，当映射文件大小为0时，指定非0大小创建映射区，访问映射地址会报总线错误，指定0大小创建映射区，报非法参数错误（Invalid argument）fd：表示要映射的文件句柄。
Python3 mmap内存映射文件示例解析
01-20
1. mmap内存映射文件 建立一个文件的内存映射将使用操作系统虚拟内存来直接访问文件系统上的数据，而不是使用常规的I/O函数访问数据。内存映射通常可以提供I/O性能，因为使用内存映射是，不需要对每个访问都建立一个...
Linux下得mmap内存映射机制分析
10-20
Linux下mmap内存映射机制分析 Linux操作系统中，mmap内存映射机制是一种高效的进程间通信方式。通过mmap机制，多个进程可以共享同一个文件的内存区域，从而实现高效的数据交换。下面是mmap机制的详细分析： 共享...
mmap 内存映射
勤能补拙，孰能生巧
08-22 309
#include <sys/mman.h> void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset); int munmap(void *addr, size_t length); prot: //区域保护,不能和文件打开mode冲突 PROT_EXEC //Pages m
mmap内存映射原理
xuanguqiufeng的专栏
05-11 1144
mmap内存映射的实现过程，总的来说可以分为三个阶段： （一）进程启动映射过程，并在虚拟地址空间中为映射创建虚拟映射区域 1、进程在用户空间调用库函数mmap，原型：void*mmap(void*start,size_tlength,intprot,intflags, intfd,off_toffset); 2、在当前进程的虚拟地址空间中，寻找一段空闲的满足要求的连续的虚拟地址 3、为此虚拟区分配一个vm_area_struct结构，接着对这个结构的各个域进行了初始化 4、将...
计算机底层知识拾遗（九）深入理解内存映射mmap
ITer_ZC的专栏
03-16 8484
内存映射mmap是Linux内核的一个重要机制，它和虚拟内存管理以及文件IO都有直接的关系，这篇细说一下mmap的一些要点。 mmap和虚拟内存管理 先来看看Linux内核的用户进程虚拟内存管理。内核定义了mm_struct结构来表示一个用户进程的虚拟内存地址空间。 1. start_code, end_code指定了进程的代码段的边界，start_data, end_dat
Linux的mmap文件内存映射机制
Tody Guo的专栏
04-03 3432
在讲述文件映射的概念时, 不可避免的要牵涉到虚存(SVR 4的VM). 实际上, 文件映射是虚存的中心概念, 文件映射一方面给用户提供了一组措施, 好似用户将文件映射到自己地址空间的某个部分, 使用简单的内存访问指令读写文件；另一方面, 它也可以用于内核的基本组织模式, 在这种模式种, 内核将整个地址空间视为诸如文件之类的一组不同对象的映射. 中的传统文件访问方式是, 首先用open系
linux内存映射 mmap munmap
jisongzdd的博客
11-24 818
我之前接触过windows下的内存映射文件，当时接触那个主要是要用它来实现程序crash之后的现场恢复。能恢复部分需要恢复部分内存的数据，这个时候内存映射文件就体现了作用，将需要的内存数据放到映射文件上，这样就可以实现了部分内存的持久化了，当然性能也是有很大的损失的。 现在有一个需求，需要linux的进程在遇到突发意外的时候能够恢复现场，读取之前的内存，这样意外重启之后能够让用户最小的损失体验。
Linux下的高效通信：mmap内存映射技术详解
"这篇文档详细介绍了Linux下的mmap内存映射机制，它是实现高效进程间通信（IPC）的一种方式，特别是在共享大块数据时。相比传统的文件访问方式，mmap减少了数据拷贝次数，提高了效率。传统的文件访问会导致每个进程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值