mmap的详细使用及函数参数意义

忘是亡心i 2022-08-27 13:46 223阅读 0赞

mmap

功能描述：

mmap将一个文件或者其它对象映射进内存。文件被映射到多个页上，如果文件的大小不是所有页的大小之和，最后一个页不被使用的空间将会清零。munmap执行相反的操作，删除特定地址区域的对象映射。

基于文件的映射，在mmap和munmap执行过程的任何时刻，被映射文件的st\_atime可能被更新。如果st\_atime字段在前述的情况下没有得到更新，首次对映射区的第一个页索引时会更新该字段的值。用PROT\_WRITE 和 MAP\_SHARED标志建立起来的文件映射，其st\_ctime 和 st\_mtime

在对映射区写入之后，但在msync()通过MS\_SYNC 和 MS\_ASYNC两个标志调用之前会被更新。

用法：

\#include <sys/mman.h>

void \*mmap(void \*start, size\_t length, int prot, int flags,

int fd, off\_t offset);

int munmap(void \*start, size\_t length);

参数：

start：映射区的开始地址。

length：映射区的长度。

prot：期望的内存保护标志，不能与文件的打开模式冲突。是以下的某个值，可以通过or运算合理地组合在一起

PROT\_EXEC //页内容可以被执行

PROT\_READ //页内容可以被读取

PROT\_WRITE //页可以被写入

PROT\_NONE //页不可访问

flags：指定映射对象的类型，映射选项和映射页是否可以共享。它的值可以是一个或者多个以下位的组合体

MAP\_FIXED //使用指定的映射起始地址，如果由start和len参数指定的内存区重叠于现存的映射空间，重叠部分将会被丢弃。如果指定的起始地址不可用，操作将会失败。并且起始地址必须落在页的边界上。

MAP\_SHARED //与其它所有映射这个对象的进程共享映射空间。对共享区的写入，相当于输出到文件。直到msync()或者munmap()被调用，文件实际上不会被更新。

MAP\_PRIVATE //建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件。这个标志和以上标志是互斥的，只能使用其中一个。

MAP\_DENYWRITE //这个标志被忽略。

MAP\_EXECUTABLE //同上

MAP\_NORESERVE //不要为这个映射保留交换空间。当交换空间被保留，对映射区修改的可能会得到保证。当交换空间不被保留，同时内存不足，对映射区的修改会引起段违例信号。

MAP\_LOCKED //锁定映射区的页面，从而防止页面被交换出内存。

MAP\_GROWSDOWN //用于堆栈，告诉内核VM系统，映射区可以向下扩展。

MAP\_ANONYMOUS //匿名映射，映射区不与任何文件关联。

MAP\_ANON //MAP\_ANONYMOUS的别称，不再被使用。

MAP\_FILE //兼容标志，被忽略。

MAP\_32BIT //将映射区放在进程地址空间的低2GB，MAP\_FIXED指定时会被忽略。当前这个标志只在x86-64平台上得到支持。

MAP\_POPULATE //为文件映射通过预读的方式准备好页表。随后对映射区的访问不会被页违例阻塞。

MAP\_NONBLOCK //仅和MAP\_POPULATE一起使用时才有意义。不执行预读，只为已存在于内存中的页面建立页表入口。

fd：有效的文件描述词。如果MAP\_ANONYMOUS被设定，为了兼容问题，其值应为-1。

offset：被映射对象内容的起点。

返回说明：

成功执行时，mmap()返回被映射区的指针，munmap()返回0。失败时，mmap()返回MAP\_FAILED\[其值为(void \*)-1\]，munmap返回-1。errno被设为以下的某个值

EACCES：访问出错

EAGAIN：文件已被锁定，或者太多的内存已被锁定

EBADF：fd不是有效的文件描述词

EINVAL：一个或者多个参数无效

ENFILE：已达到系统对打开文件的限制

ENODEV：指定文件所在的文件系统不支持内存映射

ENOMEM：内存不足，或者进程已超出最大内存映射数量

EPERM：权能不足，操作不允许

ETXTBSY：已写的方式打开文件，同时指定MAP\_DENYWRITE标志

SIGSEGV：试着向只读区写入

SIGBUS：试着访问不属于进程的内存区

共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式。两个不同进程A、B共享内存的意思是，同一块物理内存被映射到进程A、B各自的进程地址空间。进程A可以即时看到进程B对共享内存中数据的更新，反之亦然。由于多个进程共享同一块内存区域，必然需要某种同步机制，互斥锁和信号量都可以。  
  
采用共享内存通信的一个显而易见的好处是效率高，因为进程可以直接读写内存，而不需要任何数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则只拷贝两次数据\[1\]：一次从输入文件到共享内存区，另一次从共享内存区到输出文件。实际上，进程之间在共享内存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建立共享内存区域。而是保持共享区域，直到通信完毕为止，这样，数据内容一直保存在共享内存中，并没有写回文件。共享内存中的内容往往是在解除映射时才写回文件的。因此，采用共享内存的通信方式效率是非常高的。  
  
Linux的2.2.x 内核支持多种共享内存方式，如mmap()系统调用，Posix共享内存，以及系统V共享内存。linux发行版本如Redhat 8.0支持mmap()系统调用及系统V共享内存，但还没实现Posix共享内存，本文将主要介绍mmap()系统调用及系统V共享内存API的原理及应用。  
  
一、内核怎样保证各个进程寻址到同一个共享内存区域的内存页面  
  
1、 page cache及swap cache中页面的区分：一个被访问文件的物理页面都驻留在page cache或swap cache中，一个页面的所有信息由struct page来描述。struct page中有一个域为指针mapping ，它指向一个struct address\_space类型结构。page cache或swap cache中的所有页面就是根据address\_space结构以及一个偏移量来区分的。  
  
2、文件与 address\_space结构的对应：一个具体的文件在打开后，内核会在内存中为之建立一个struct inode结构，其中的i\_mapping域指向一个address\_space结构。这样，一个文件就对应一个address\_space结构，一个 address\_space与一个偏移量能够确定一个page cache 或swap cache中的一个页面。因此，当要寻址某个数据时，很容易根据给定的文件及数据在文件内的偏移量而找到相应的页面。  
  
3、进程调用mmap()时，只是在进程空间内新增了一块相应大小的缓冲区，并设置了相应的访问标识，但并没有建立进程空间到物理页面的映射。因此，第一次访问该空间时，会引发一个缺页异常。  
  
4、对于共享内存映射情况，缺页异常处理程序首先在swap cache中寻找目标页（符合address\_space以及偏移量的物理页），如果找到，则直接返回地址；如果没有找到，则判断该页是否在交换区 (swap area)，如果在，则执行一个换入操作；如果上述两种情况都不满足，处理程序将分配新的物理页面，并把它插入到page cache中。进程最终将更新进程页表。  
注：对于映射普通文件情况（非共享映射），缺页异常处理程序首先会在page cache中根据address\_space以及数据偏移量寻找相应的页面。如果没有找到，则说明文件数据还没有读入内存，处理程序会从磁盘读入相应的页面，并返回相应地址，同时，进程页表也会更新。  
  
5、所有进程在映射同一个共享内存区域时，情况都一样，在建立线性地址与物理地址之间的映射之后，不论进程各自的返回地址如何，实际访问的必然是同一个共享内存区域对应的物理页面。  
注：一个共享内存区域可以看作是特殊文件系统shm中的一个文件，shm的安装点在交换区上。  
  
上面涉及到了一些数据结构，围绕数据结构理解问题会容易一些。  
  
  
  
  
回页首  
  
  
二、mmap()及其相关系统调用  
  
mmap()系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以向访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。  
  
注：实际上，mmap()系统调用并不是完全为了用于共享内存而设计的。它本身提供了不同于一般对普通文件的访问方式，进程可以像读写内存一样对普通文件的操作。而Posix或系统V的共享内存IPC则纯粹用于共享目的，当然mmap()实现共享内存也是其主要应用之一。  
  
1、mmap()系统调用形式如下：  
  
void\* mmap ( void \* addr , size\_t len , int prot , int flags , int fd , off\_t offset )  
参数fd为即将映射到进程空间的文件描述字，一般由open()返回，同时，fd可以指定为-1，此时须指定flags参数中的MAP\_ANON，表明进行的是匿名映射（不涉及具体的文件名，避免了文件的创建及打开，很显然只能用于具有亲缘关系的进程间通信）。len是映射到调用进程地址空间的字节数，它从被映射文件开头offset个字节开始算起。prot 参数指定共享内存的访问权限。可取如下几个值的或：PROT\_READ（可读） , PROT\_WRITE （可写）, PROT\_EXEC （可执行）, PROT\_NONE（不可访问）。flags由以下几个常值指定：MAP\_SHARED , MAP\_PRIVATE , MAP\_FIXED，其中，MAP\_SHARED , MAP\_PRIVATE必选其一，而MAP\_FIXED则不推荐使用。offset参数一般设为0，表示从文件头开始映射。参数addr指定文件应被映射到进程空间的起始地址，一般被指定一个空指针，此时选择起始地址的任务留给内核来完成。函数的返回值为最后文件映射到进程空间的地址，进程可直接操作起始地址为该值的有效地址。这里不再详细介绍mmap()的参数，读者可参考mmap()手册页获得进一步的信息。  
  
2、系统调用mmap()用于共享内存的两种方式：  
  
（1）使用普通文件提供的内存映射：适用于任何进程之间；此时，需要打开或创建一个文件，然后再调用mmap()；典型调用代码如下：  
  
  
fd=open(name, flag, mode);  
if(fd<0)  
...  
  
  
  
ptr=mmap(NULL, len , PROT\_READ|PROT\_WRITE, MAP\_SHARED , fd , 0); 通过mmap()实现共享内存的通信方式有许多特点和要注意的地方，我们将在范例中进行具体说明。  
  
（2）使用特殊文件提供匿名内存映射：适用于具有亲缘关系的进程之间；由于父子进程特殊的亲缘关系，在父进程中先调用mmap()，然后调用fork()。那么在调用fork()之后，子进程继承父进程匿名映射后的地址空间，同样也继承mmap()返回的地址，这样，父子进程就可以通过映射区域进行通信了。注意，这里不是一般的继承关系。一般来说，子进程单独维护从父进程继承下来的一些变量。而mmap()返回的地址，却由父子进程共同维护。  
对于具有亲缘关系的进程实现共享内存最好的方式应该是采用匿名内存映射的方式。此时，不必指定具体的文件，只要设置相应的标志即可，参见范例2。  
  
3、系统调用munmap()  
  
int munmap( void \* addr, size\_t len )  
该调用在进程地址空间中解除一个映射关系，addr是调用mmap()时返回的地址，len是映射区的大小。当映射关系解除后，对原来映射地址的访问将导致段错误发生。  
  
4、系统调用msync()  
  
int msync ( void \* addr , size\_t len, int flags)  
一般说来，进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，往往在调用munmap（）后才执行该操作。可以通过调用msync()实现磁盘上文件内容与共享内存区的内容一致。  
  
  
  
  
回页首  
  
  
三、mmap()范例  
  
下面将给出使用mmap()的两个范例：范例1给出两个进程通过映射普通文件实现共享内存通信；范例2给出父子进程通过匿名映射实现共享内存。系统调用 mmap()有许多有趣的地方，下面是通过mmap（）映射普通文件实现进程间的通信的范例，我们通过该范例来说明mmap()实现共享内存的特点及注意事项。  
  
范例1：两个进程通过映射普通文件实现共享内存通信  
  
范例1包含两个子程序：map\_normalfile1.c及map\_normalfile2.c。编译两个程序，可执行文件分别为 map\_normalfile1及map\_normalfile2。两个程序通过命令行参数指定同一个文件来实现共享内存方式的进程间通信。 map\_normalfile2试图打开命令行参数指定的一个普通文件，把该文件映射到进程的地址空间，并对映射后的地址空间进行写操作。 map\_normalfile1把命令行参数指定的文件映射到进程地址空间，然后对映射后的地址空间执行读操作。这样，两个进程通过命令行参数指定同一个文件来实现共享内存方式的进程间通信。  
  
下面是两个程序代码：  
  
  
/\*-------------map\_normalfile1.c-----------\*/  
\#include <sys/mman.h>  
\#include <sys/types.h>  
\#include <fcntl.h>  
\#include <unistd.h>  
typedef struct\{  
char name\[4\];  
int age;  
\}people;  
  
main(int argc, char\*\* argv) // map a normal file as shared mem:  
\{  
int fd,i;  
people \*p\_map;  
char temp;  
  
fd=open(argv\[1\],O\_CREAT|O\_RDWR|O\_TRUNC,00777);  
lseek(fd,sizeof(people)\*5-1,SEEK\_SET);  
write(fd,"",1);  
  
p\_map = (people\*) mmap( NULL,sizeof(people)\*10,PROT\_READ|PROT\_WRITE,MAP\_SHARED,fd,0 );  
close( fd );  
temp = 'a';  
for(i=0; i<10; i++)  
\{  
temp += 1;  
memcpy( ( \*(p\_map+i) ).name, &temp,2 );  
( \*(p\_map+i) ).age = 20+i;  
\}  
printf(" initialize over /n ")；  
sleep(10);  
  
munmap( p\_map, sizeof(people)\*10 );  
printf( "umap ok /n" );  
\}  
  
/\*-------------map\_normalfile2.c-----------\*/  
\#include <sys/mman.h>  
\#include <sys/types.h>  
\#include <fcntl.h>  
\#include <unistd.h>  
typedef struct\{  
char name\[4\];  
int age;  
\}people;  
  
main(int argc, char\*\* argv) // map a normal file as shared mem:  
\{  
int fd,i;  
people \*p\_map;  
fd=open( argv\[1\],O\_CREAT|O\_RDWR,00777 );  
p\_map = (people\*)mmap(NULL,sizeof(people)\*10,PROT\_READ|PROT\_WRITE,MAP\_SHARED,fd,0);  
for(i = 0;i<10;i++)  
\{  
printf( "name: %s age %d;/n",(\*(p\_map+i)).name, (\*(p\_map+i)).age );  
  
\}  
munmap( p\_map,sizeof(people)\*10 );  
\}  
  
  
map\_normalfile1.c 首先定义了一个people数据结构，（在这里采用数据结构的方式是因为，共享内存区的数据往往是有固定格式的，这由通信的各个进程决定，采用结构的方式有普遍代表性）。map\_normfile1首先打开或创建一个文件，并把文件的长度设置为5个people结构大小。然后从mmap()的返回地址开始，设置了10个people结构。然后，进程睡眠10秒钟，等待其他进程映射同一个文件，最后解除映射。  
  
map\_normfile2.c只是简单的映射一个文件，并以people数据结构的格式从mmap()返回的地址处读取10个people结构，并输出读取的值，然后解除映射。  
  
分别把两个程序编译成可执行文件map\_normalfile1和map\_normalfile2后，在一个终端上先运行./map\_normalfile2 /tmp/test\_shm，程序输出结果如下：  
  
  
initialize over  
umap ok  
  
  
在map\_normalfile1输出initialize over 之后，输出umap ok之前，在另一个终端上运行map\_normalfile2 /tmp/test\_shm，将会产生如下输出(为了节省空间，输出结果为稍作整理后的结果)：  
  
  
name: b age 20; name: c age 21; name: d age 22; name: e age 23; name: f age 24;  
name: g age 25; name: h age 26; name: I age 27; name: j age 28; name: k age 29;  
  
  
在map\_normalfile1 输出umap ok后，运行map\_normalfile2则输出如下结果：  
  
  
name: b age 20; name: c age 21; name: d age 22; name: e age 23; name: f age 24;  
name: age 0; name: age 0; name: age 0; name: age 0; name: age 0;  
  
  
从程序的运行结果中可以得出的结论  
  
1、 最终被映射文件的内容的长度不会超过文件本身的初始大小，即映射不能改变文件的大小；  
  
2、可以用于进程通信的有效地址空间大小大体上受限于被映射文件的大小，但不完全受限于文件大小。打开文件被截短为5个people结构大小，而在 map\_normalfile1中初始化了10个people数据结构，在恰当时候（map\_normalfile1输出initialize over 之后，输出umap ok之前）调用map\_normalfile2会发现map\_normalfile2将输出全部10个people结构的值，后面将给出详细讨论。  
注：在linux中，内存的保护是以页为基本单位的，即使被映射文件只有一个字节大小，内核也会为映射分配一个页面大小的内存。当被映射文件小于一个页面大小时，进程可以对从mmap()返回地址开始的一个页面大小进行访问，而不会出错；但是，如果对一个页面以外的地址空间进行访问，则导致错误发生，后面将进一步描述。因此，可用于进程间通信的有效地址空间大小不会超过文件大小及一个页面大小的和。  
  
3、文件一旦被映射后，调用mmap()的进程对返回地址的访问是对某一内存区域的访问，暂时脱离了磁盘上文件的影响。所有对mmap()返回地址空间的操作只在内存中有意义，只有在调用了munmap()后或者msync()时，才把内存中的相应内容写回磁盘文件，所写内容仍然不能超过文件的大小。  
  
范例2：父子进程通过匿名映射实现共享内存  
  
  
\#include <sys/mman.h>  
\#include <sys/types.h>  
\#include <fcntl.h>  
\#include <unistd.h>  
typedef struct\{  
char name\[4\];  
int age;  
\}people;  
main(int argc, char\*\* argv)  
\{  
int i;  
people \*p\_map;  
char temp;  
p\_map=(people\*)mmap(NULL,sizeof(people)\*10,PROT\_READ|PROT\_WRITE,MAP\_SHARED|MAP\_ANONYMOUS,-1,0);  
if(fork() == 0)  
\{  
sleep(2);  
for(i = 0;i<5;i++)  
printf("child read: the %d people's age is %d/n",i+1,(\*(p\_map+i)).age);  
(\*p\_map).age = 100;  
munmap(p\_map,sizeof(people)\*10); //实际上，进程终止时，会自动解除映射。  
exit();  
\}  
temp = 'a';  
for(i = 0;i<5;i++)  
\{  
temp += 1;  
memcpy((\*(p\_map+i)).name, &temp,2);  
(\*(p\_map+i)).age=20+i;  
\}  
  
sleep(5);  
printf( "parent read: the first people,s age is %d/n",(\*p\_map).age );  
printf("umap/n");  
munmap( p\_map,sizeof(people)\*10 );  
printf( "umap ok/n" );  
\}  
  
  
考察程序的输出结果，体会父子进程匿名共享内存：  
  
  
child read: the 1 people's age is 20  
child read: the 2 people's age is 21  
child read: the 3 people's age is 22  
child read: the 4 people's age is 23  
child read: the 5 people's age is 24  
  
parent read: the first people,s age is 100  
umap  
umap ok  
  
  
  
  
  
  
回页首  
  
  
四、对mmap()返回地址的访问  
  
前面对范例运行结构的讨论中已经提到，linux采用的是页式管理机制。对于用mmap()映射普通文件来说，进程会在自己的地址空间新增一块空间，空间大小由mmap()的len参数指定，注意，进程并不一定能够对全部新增空间都能进行有效访问。进程能够访问的有效地址大小取决于文件被映射部分的大小。简单的说，能够容纳文件被映射部分大小的最少页面个数决定了进程从mmap()返回的地址开始，能够有效访问的地址空间大小。超过这个空间大小，内核会根据超过的严重程度返回发送不同的信号给进程。可用如下图示说明：  
  
  
注意：文件被映射部分而不是整个文件决定了进程能够访问的空间大小，另外，如果指定文件的偏移部分，一定要注意为页面大小的整数倍。下面是对进程映射地址空间的访问范例：  
  
  
\#include <sys/mman.h>  
\#include <sys/types.h>  
\#include <fcntl.h>  
\#include <unistd.h>  
typedef struct\{  
char name\[4\];  
int age;  
\}people;  
  
main(int argc, char\*\* argv)  
\{  
int fd,i;  
int pagesize,offset;  
people \*p\_map;  
  
pagesize = sysconf(\_SC\_PAGESIZE);  
printf("pagesize is %d/n",pagesize);  
fd = open(argv\[1\],O\_CREAT|O\_RDWR|O\_TRUNC,00777);  
lseek(fd,pagesize\*2-100,SEEK\_SET);  
write(fd,"",1);  
offset = 0; //此处offset = 0编译成版本1；offset = pagesize编译成版本2  
p\_map = (people\*)mmap(NULL,pagesize\*3,PROT\_READ|PROT\_WRITE,MAP\_SHARED,fd,offset);  
close(fd);  
  
for(i = 1; i<10; i++)  
\{  
(\*(p\_map+pagesize/sizeof(people)\*i-2)).age = 100;  
printf("access page %d over/n",i);  
(\*(p\_map+pagesize/sizeof(people)\*i-1)).age = 100;  
printf("access page %d edge over, now begin to access page %d/n",i, i+1);  
(\*(p\_map+pagesize/sizeof(people)\*i)).age = 100;  
printf("access page %d over/n",i+1);  
\}  
munmap(p\_map,sizeof(people)\*10);  
\}  
  
  
如程序中所注释的那样，把程序编译成两个版本，两个版本主要体现在文件被映射部分的大小不同。文件的大小介于一个页面与两个页面之间（大小为：pagesize\*2-99），版本1的被映射部分是整个文件，版本2的文件被映射部分是文件大小减去一个页面后的剩余部分，不到一个页面大小(大小为：pagesize-99)。程序中试图访问每一个页面边界，两个版本都试图在进程空间中映射pagesize\*3的字节数。  
  
版本1的输出结果如下：  
  
  
pagesize is 4096  
access page 1 over  
access page 1 edge over, now begin to access page 2  
access page 2 over  
access page 2 over  
access page 2 edge over, now begin to access page 3  
Bus error //被映射文件在进程空间中覆盖了两个页面，此时，进程试图访问第三个页面  
  
  
版本2的输出结果如下：  
  
  
pagesize is 4096  
access page 1 over  
access page 1 edge over, now begin to access page 2  
Bus error //被映射文件在进程空间中覆盖了一个页面，此时，进程试图访问第二个页面  
  
  
结论：采用系统调用mmap()实现进程间通信是很方便的，在应用层上接口非常简洁。内部实现机制区涉及到了linux存储管理以及文件系统等方面的内容，可以参考一下相关重要数据结构来加深理解。在本专题的后面部分，将介绍系统v共享内存的实现。