mmap映射文件至内存( 实现 共享内存 与 文件的另类访问 )

Linux提供了内存映射函数mmap, 它把文件内容映射到一段内存上(准确说是虚拟内存上), 通过对这段内存的读取和修改, 实现对文件的读取和修改, 先来看一下mmap的函数声明:

• 头文件:
  • <unistd.h>
  • <sys/mman.h>
• 原型: void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);//offset: 以文件开始处的偏移量, 必须是分页大小的整数倍, 通常为0, 表示从文件头开始映射.
• 返回值: 成功则返回映射区起始地址, 失败则返回MAP_FAILED(-1).
• 参数:
  • addr: 指定映射的起始地址, 通常设为NULL, 由系统指定.
  • length: 将文件的多大长度映射到内存，不该超过文件大小.
  • prot: 映射区的保护方式, 可以是:
    • PROT_EXEC: 映射区可被执行.
    • PROT_READ: 映射区可被读取.
    • PROT_WRITE: 映射区可被写入.
    • PROT_NONE: 映射区不能存取.
  • flags: 映射区的特性, 可以是:
    • MAP_SHARED: 对映射区域的写入数据会复制回文件(由守护进程自动完成), 且允许其他映射该文件的进程共享.
    • MAP_PRIVATE: 对映射区域的写入操作会产生一个映射的复制(copy-on-write), 对此区域所做的修改不会写回原文件.
    • 此外还有其他几个flags不很常用, 具体查看linux C函数说明.
  • fd: 由open返回的文件描述符, 代表要映射的文件，在映射完后就可以马上关闭文件了，对映射区域的访问与文件是否打开无关.
  • offset:以文件开始处的偏移量, 必须是分页大小的整数倍, 通常为0, 表示从文件头开始映射.

         mmap返回的是用户进程空间的虚拟地址，在stack和heap 之间的空闲逻辑空间(虚拟空间) 就是用来提供映射的，文件将会被映射到这一区域的某块虚拟内存上，具体哪一块若是用户没有指定，则由内核来分配。一般上，用户不该去指定这个映射的起始地址，因为栈和堆都是在向块区域进行扩展的，所以这块区域的大小会一直在变化，若是用户指定，用户根本就无法知道这块地址是否被堆用去了还是被栈用去了。

下面说一下内存映射的步骤:

• 用open系统调用打开文件, 并返回描述符fd.
• 用mmap建立内存映射, 并返回映射首地址指针start.
• 对映射(文件)进行各种操作, 显示(printf), 修改(sprintf).
• 用munmap(void *start, size_t lenght)关闭内存映射.
• 用close系统调用关闭文件fd（只要保证在mmap成功了之后就都可以）.

注意事项:

在修改映射的文件时, 只能在原长度上修改, 不能增加文件长度, 因为内存是已经分配好的.

mmap的用地：

1、共享内存：可以说是最有用的进程间通信方式，也是最快的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的原理及应 用。

 2、文件访问方式：mmap函数是unix/linux下的系统调用，mmap系统调用并不是完全为了用于共享内存而设计的。它本身提供了不同于一般对普通文件的访问方式，进程可以像读写内存一样对普通文件的操作。而Posix或系统V的共享内存IPC则纯粹用于共享目的，当然mmap()实现共享内存也是其主要应用之一。

    mmap系统调用使得进程之间通过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程可以像访问普通内存一样对文件进行访问，不必再调用read()，write（）等操作。
    我们的程序中大量运用了mmap，用到的正是mmap的这种“像访问普通内存一样对文件进行访问”的功能。实践证明，当要对一个文件频繁的进行访问，并且指针来回移动时，调用mmap比用常规的方法快很多。

一、内核怎样保证各个进程寻址到同一个共享内存区域的内存页面

---------------------------------看不懂，属于内核的问题，只要记得共享内存在进程间是即时可见的就可以了！！

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、munmap、msync

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是将文件的多大长度进行映射。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()返回的地址，却由父子进程共同维护。 
对于具有亲缘关系的进程实现共享内存最好的方式应该是采用匿名内存映射（可以使用fd =-1 的方式，也可以用fd = open("dev/zero",)的方式）的方式。此时，不必指定具体的文件，只要设置相应的标志即可，参见范例

3、系统调用munmap()

int munmap( void * addr, size_t len ) 
该调用在进程地址空间中解除一个映射关系，addr是调用mmap()时返回的地址，len是映射区的大小。当映射关系解除后，对原来映射地址的访问将导致段错误发生。注意，munmap并不会将映射区的内容写入磁盘文件，它完成的仅仅只是释放映射区包括其上的内容。

4、系统调用msync()---------此“冲洗”非彼冲洗，不同于用户缓冲区，此时的冲洗不会洗掉映射存储区的内容，会保留，此冲洗更像是复制写入文件的同步！

int msync ( void * addr , size_t len, int flags) 
这个是手动冲洗映射区到文件中，然而实际上内核会维护一个守护进程定时对映射存储区进行冲洗，所以我们对mmap返回的内存进行操作就相当于对文件操作，此守护进程满足了内存映射与文件的实时性。但是因为munmap是不会对映射内存进行冲洗的，它只会直接释放映射内存，所以在当我们调用munmap之前，还是最好手动调用msync手动冲洗一下，因为守护进程是定时冲洗，所以它的实时性也只是相对的，要想可靠保险，还是要自己勤快点！

另外，对映射内存的冲洗和对用户标准I/O缓冲区的冲洗不同，对映射内存的冲洗并不会洗掉其内存存储的内容，依然还在，只是将内容“复制"到文件里。而用户缓冲区的冲洗则是真正的清空写入，缓冲区中的内容在冲洗后会变不见，但会写入文件。

 

回页首

三、mmap()范例

下 面将给出使用mmap()的两个范例：范例1给出两个进程通过映射普通文件实现共享内存通信；范例2给出父子进程通过匿名映射实现共享内存。系统调用 mmap()有许多有趣的地方，下面是通过mmap（）映射普通文件实现进程间的通信的范例，我们通过该范例来说明mmap()实现共享内存的特点及注意事项。

范例1：两个进程通过映射普通文件实现共享内存通信-------映射大小、读写大小 与文件实际大小的关系

-------映射大小不应该超过文件的实际大小，否则在对映射内存进行写的时候就有可能写到其它文件的数据中去了，也许就会报错，读的话若越界就读到其它无用数据去了，有可能像这次返回的是0（说明被映射的磁盘在溢出区域上还没有文件） 一样，也有可能返回其它文件的值，至于是否报错，那就看运气了，看你映射的文件周围的存储区域是个什么情况了。

范例1包含两个子程序：map_normalfile1.c及map_normalfile2.c。编译两个程序，可执行文件分别为 map_normalfile1及map_normalfile2。两个程序通过命令行参数指定同一个文件来实现共享内存方式的进程间通信。 map_normalfile2试图打开命令行参数指定的一个普通文件，把该文件映射到进程的地址空间，并对映射后的地址空间进行写操作。 map_normalfile1把命令行参数指定的文件映射到进程地址空间，然后对映射后的地址空间执行读操作。这样，两个进程通过命令行参数指定同一个 文件来实现共享内存方式的进程间通信。

下面是两个程序代码：

[cpp] view plain copy

1. <span style="font-family:Courier New;"><span style="font-weight: normal;">/*-------------map_normalfile1.c-----------*/  
2. #include <stdio.h>  
3. #include <stdlib.h>  
4. #include <string.h>  
5. #include <sys/mman.h>  
6. #include <sys/types.h>  
7. #include <fcntl.h>  
8. #include <unistd.h>  
9. typedef struct{  
10.     char name[4];  
11.     int age;  
12. }people;  
13.   
14. main(int argc, char** argv) // map a normal file as shared mem:  
15. {  
16.     int fd,i;  
17.     people *p_map;  
18.     char temp;  
19.        
20.     fd=open(argv[1],O_CREAT|O_RDWR|O_TRUNC,00777);//<span style="font-family: 宋体;font-size:12px; ">O_TRUNC 若文件存在并且以可写的方式打开时，此旗标会令文件长度清为0，而原来存于该文件的资料也会消失。</span>  
21.     people *sp = (people *)malloc(sizeof(people));  
22.     i = 5;  
23.     temp = '1';  
24.     while(i--)  
25.     {  
26.         memcpy(sp->name,&temp,1);  
27.         sp->age = 10+i;  
28.         temp++;  
29.         write(fd,sp,sizeof(people));  
30.     }  
31.     //映射内存的大小为实际文件的大小，对于新创建的文件，除了像上面那样实际写入来扩展文件大小以外，  
32.     //也可以通过lseek来快捷扩展文件大小:  
33.     //lseek(fd,sizeof(people)*5-1,SEEK_CUR);  
34.     //write(fd,"",1);  
35.        
36.     p_map = (people*) mmap( NULL,sizeof(people)*10,<span style="color:#3333ff;">PROT_READ|PROT_WRITE,MAP_SHARED</span>,fd,0 );  
37.     close( fd );//在映射完后就可以立刻关闭文件了，打开文件是为了获取文件秒速符来映射文件，文件是否打开对映射内存的操作没有关系  
38.   
39.     //最后一个参数offset 必须为页的整数倍，此处为0 表示从文件头开始，那么后面通过映射的返回地址写入的  
40.     //10个结构体也就会将之前写入的5 个结构体给覆盖了。  
41.     //sizeof(people)*10 为从文件开始的10个结构的大小。  
42.     //将返回的地址p_map 强制转换为结构体类型指针。  
43.   
44.     temp = 'a';  
45.     for(i=0; i<10; i++)  //写10个结构体大小  
46.     {  
47.         memcpy( ( *(p_map+i) ).name, &temp,1 );  
48.         ( *(p_map+i) ).age = 20+i;  
49.         temp += 1;  
50.   
51.     }  
52.     printf(" initialize over  ");  
53.     sleep(10);  
54.     munmap( p_map, sizeof(people)*10 );  
55.     printf( "umap ok  " );  
56. }</span>  
57. </span>  

[cpp] view plain copy

1. <span style="font-weight: normal;"><span style="font-family:Courier New;">/*-------------map_normalfile2.c-----------*/  
2. #include <sys/mman.h>  
3. #include <sys/types.h>  
4. #include <fcntl.h>  
5. #include<stdio.h>  
6. #include <unistd.h>  
7. typedef struct{  
8. char name[4];  
9. int age;  
10. }people;  
11.   
12. main(int argc, char** argv) // map a normal file as shared mem:  
13. {  
14.     int fd,i;  
15.     people *p_map;  
16.     fd=open( argv[1],O_CREAT|O_RDWR,00777 );//不可用<span style="font-size: 10px; ">O_TRUNC，因为这里你是打开读的</span>  
17.   
18.     p_map = (people*)mmap(NULL,sizeof(people)*15,<span style="color:#3333ff;">PROT_READ|PROT_WRITE,MAP_SHARED</span>,fd,0);//映射15 个结构体大小实际已经是超出了  
19.     //这边是读15 的大小，虽然也可读，可实际已经超出文件5个结构体的大小了，  
20.     //只是编译器没报出错而已，就像数组一样，只是读出界而已没关系，只有  
21.     //写出界写到了系统数据时才会出错。  
22.   
23.     close(fd);  
24.     //在映射完后就可以立刻关闭文件了，打开文件是为了获取文件秒速符来映射文件，  
25.     //文件是否打开对映射内存的操作没有关系。  
26.       
27.     for(i = 0;i<15;i++)    
28.         printf( "name: %s age %d ",(*(p_map+i)).name, (*(p_map+i)).age );  
29.   
30.     munmap( p_map,sizeof(people)*10 );  
31. }  

file1.c首先定义了一个 people数据结构，（在这里采用数据结构的方式是因为，共享内存区的数据往往是有固定格式的，这由通信的各个进程决定，采用结构的方式有普遍代表 性）。map_normfile1首先打开或创建一个文件，并把文件的长度设置为5个people结构大小。然后从mmap()的返回地址开始，设置了 10个people结构。然后，进程睡眠10秒钟，等待其他进程映射同一个文件，最后解除映射，否则程序一结束映射就解除了，内容就写入文件，这样即使另一个程序也映射了此文件，可操作意义就不是共享内存的事了，而是使用映射内存来读写文件的事了。映射内存只有在双都同时映射向同一个文件时才为共享内存，共享内存也就是一映射的虚拟内存(存在于各自的进程空间)，映射虚拟内存不是一直都存在的，当调用了munmap或程序结束时，映射内存都会被结束映射，但映射指向的物理内存一直都存在，文件也一直存在，同时会将进程映射的共享虚拟内存上的内容写入文件，只是虚拟内存不存在了，也就是共享内存不再具有立即读写可见的共享性了，因为另一方已经解除映射了，而这块共享内存也就变成了另一方的独角戏了，但文件仍存在，还在映射着的那方仍可以通过映射来读取文件，来读取之前解除方在共享内存上的写入的内容，所谓的共享内存实质就是通过一个文件来共享而已，只是将该文件映射到内存中，将文件的存在形式从磁盘搬到内存中而已。虽然说共享内存要在解除共享时才会写入文件，但共享者双方在共享内存上的操作时即时可见的，即不用一方写完后解除映射将共享内存的内容写入文件(然后在映射准备下一次的通信)，另一方再通过映射从文件中读出，不用这样，虽然是映射是映射到各自的进程虚拟内存空间，且映射的虚拟内存与磁盘上的文件也不同步，而且各个进程的进程虚拟内存空间是独立，但就是可以实现在两个进程间的映射向同一个磁盘文件的共享内存（各自的映射内存）上实时看见，这到底是为什么呢——在一、中有解释了，只是涉及内核看不懂而已！

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( munmap解除映射)之前，在另一个终端上运行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：父子进程通过匿名映射实现共享内存

[cpp] view plain copy

1. <pre name="code" class="cpp"><span style="font-family:Courier New;">#include<stdio.h>  
2. #include<stdlib.h>  
3. #include<string.h>  
4. #include <sys/mman.h>  
5. #include <sys/types.h>  
6. #include <fcntl.h>  
7. #include <unistd.h>  
8. typedef struct{  
9. char name[4];  
10. int age;  
11. }people;  
12.   
13. main(int argc, char** argv)  
14. {  
15.     int i;  
16.     people *p_map;  
17.     char temp;  
18.     pid_t child_pid;  
19.     p_map=(people*)mmap(NULL,sizeof(people)*10,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-1,0); //此处为 MAP_ANONYMOUS 和-1  
20.     if((child_pid = fork())== 0)  
21.     {  
22.         sleep(2);  
23.         printf("the child pid read the shared : ");  
24.         for(i = 0;i<5;i++)  
25.         {  
26.             printf("child read: the %d people's age is %d ",i+1,(*(p_map+i)).age);  
27.             (*p_map).age = 100;  
28.         }  
29.             munmap(p_map,sizeof(people)*10); //实际上，进程终止时，会自动解除映射。  
30.     }  
31.     else  
32.     {  
33.         printf("the father pid write the shared : ");  
34.         temp = 'a';  
35.         for(i = 0;i<5;i++)  
36.         {  
37.             temp += 1;  
38.             memcpy((*(p_map+i)).name, &temp,2);  
39.             (*(p_map+i)).age=20+i;  
40.         }  
41.         wait(0);//等待子进程结束后，父进程才接触映射  
42.         printf("the child over  ");  
43.         printf("umap ");  
44.         munmap( p_map,sizeof(people)*10 );  
45.         printf( "umap ok " );  
46.     }  
47. }  
48. /*结果: 
49.     the father pid write the shared : 
50.     the child pid read the shared : 
51.     child read: the 1 people's age is 20 
52.     child read: the 2 people's age is 21 
53.     child read: the 3 people's age is 22 
54.     child read: the 4 people's age is 23 
55.     child read: the 5 people's age is 24 
56.     the child over  
57.     umap 
58.     umap ok 
59. */</span>  

四、对mmap()返回地址的访问

前 面对范例运行结构的讨论中已经提到，linux采用的是页式管理机制。对于用mmap()映射普通文件来说，进程会在自己的地址空间新增一块空间，空间大 小由mmap()的len参数指定，注意，进程并不一定能够对全部新增空间都能进行有效访问。进程能够访问的有效地址大小取决于文件被映射部分的大小。简 单的说，能够容纳文件被映射部分大小的最少页面个数决定了进程从mmap()返回的地址开始，能够有效访问的地址空间大小。超过这个空间大小，内核会根据 超过的严重程度返回发送不同的信号给进程。可用如下图示说明：

注意：文件被映射部分而不是整个文件决定了进程能够访问的空间大小，另外，如果指定文件的偏移部分，一定要注意为页面大小的整数倍。下面是对进程映射地址空间的访问范例：

[cpp] view plain copy

1. <span style="font-weight: normal;"><span style="font-family:Courier New;">#include <sys/mman.h>  
2. #include <sys/types.h>  
3. #include <fcntl.h>  
4. #include <unistd.h>  
5. typedef struct{  
6. char name[4];  
7. int age;  
8. }people;  
9. main(int argc, char** argv)  
10. {  
11.     int fd,i;  
12.     int pagesize,offset;  
13.     people *p_map;  
14.        
15.     pagesize = sysconf(_SC_PAGESIZE);  
16.     printf("pagesize is %d/n",pagesize);  
17.     fd = open(argv[1],O_CREAT|O_RDWR|O_TRUNC,00777);  
18.     lseek(fd,pagesize*2-100,SEEK_SET);  
19.     write(fd,"",1);  
20.     offset = 0; //此处offset = 0编译成版本1；offset = pagesize编译成版本2  
21.     p_map = (people*)mmap(NULL,pagesize*3,PROT_READ|PROT_WRITE,MAP_SHARED,fd,offset);  
22.     close(fd);  
23.        
24.     for(i = 1; i<10; i++)  
25.     {  
26.         (*(p_map+pagesize/sizeof(people)*i-2)).age = 100;  
27.         printf("access page %d over/n",i);  
28.         (*(p_map+pagesize/sizeof(people)*i-1)).age = 100;  
29.         printf("access page %d edge over, now begin to access page %d/n",i, i+1);  
30.         (*(p_map+pagesize/sizeof(people)*i)).age = 100;  
31.         printf("access page %d over/n",i+1);  
32.     }  
33.     munmap(p_map,sizeof(people)*10);  
34. }</span></span>  

如程序中所注释的那样，把程序编译成两个版本，两个版 本主要体现在文件被映射部分的大小不同。文件的大小介于一个页面与两个页面之间（大小为：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共享内存的实现。

 

参考资料

[1] Understanding the Linux Kernel, 2nd Edition, By Daniel P. Bovet, Marco Cesati , 对各主题阐述得重点突出，脉络清晰。

[2] UNIX网络编程第二卷：进程间通信，作者：W.Richard Stevens，译者：杨继张，清华大学出版社。对mmap()有详细阐述。

[3] Linux内核源代码情景分析（上），毛德操、胡希明著，浙江大学出版社，给出了mmap()相关的源代码分析。

[4]mmap()手册