共享内存

1、背景

当存在客户－服务程序中复制文件时候，其数据流如下，要经历四次数据复制，开销很大。具体如下：

进程调用read或是write后会陷入内核，因为这两个函数都是系统调用，进入系统调用后，内核开始读写文件，

• 假设内核在读取文件，内核首先把文件读入自己的内核空间，
• 读完之后进程在内核回归用户态，内核把读入内核内存的数据再copy进入进程的用户态内存空间。
• 实际上我们同一份文件内容相当于读了两次，先读入内核空间，再从内核空间读入用户空间。

如果采用共享内存的方式，那么将大大优化IO操作，数据流变成了如下，数据只复制两次，[1]：一次从输入文件到共享内存区，另一次从共享内存区到输出文件。

• Linux提供了内存映射函数mmap, 它把文件内容映射到一段内存上(准确说是虚拟内存上), 通过对这段内存的读取和修改,实现对文件的读取和修改；
• 普通文件映射到进程地址空间后，进程可以向访问内存的方式对文件进行访问，不需要其他系统调用(read,write)去操作。

2、定义

• 共享内存，顾名思义就是允许两个不相关的进程访问同一个逻辑内存
• 不同进程之间共享的内存通常为同一段物理内存。进程可以将同一段物理内存连接到他们自己的地址空间中，所有的进程都可以访问共享内存中的地址。
• 如果某个进程向共享内存写入数据，所做的改动将立即影响到可以访问同一段共享内存的任何其他进程。
• 这是最快的进程间通信方式，但是不提供同步功能（需要我们信号量实现）。

3、两种方式（shmget下一篇博客说明）

3.1、mmap

mmap是一种内存映射文件的方法，

• 即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一 一对映关系。
• 实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用read,write等系统调用函数。

由上图可以看出，进程的虚拟地址空间，由多个虚拟内存区域构成。虚拟内存区域是进程的虚拟地址空间中的一个同质区间，即具有同样特性的连续地址范围。上图中所示的text数据段（代码段）、初始数据段、BSS数据段、堆、栈和内存映射，都是一个独立的虚拟内存区域。而为内存映射服务的地址空间处在堆栈之间的空余部分。

linux内核使用vm_area_struct结构来表示一个独立的虚拟内存区域，由于每个不同质的虚拟内存区域功能和内部机制都不同，因此一个进程使用多个vm_area_struct结构来分别表示不同类型的虚拟内存区域。各个vm_area_struct结构使用链表或者树形结构链接，方便进程快速访问。

mmap函数就是要创建一个新的vm_area_struct结构，并将其与文件的物理磁盘地址相连。

3.1.1、调用过程

mmap内存映射的实现过程，总的来说可以分为三个阶段：
（一）进程启动映射过程，并在虚拟地址空间中为映射创建虚拟映射区域

• 1、进程在用户空间调用库函数mmap，原型：void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);
• 2、在当前进程的虚拟地址空间中，寻找一段空闲的满足要求的连续的虚拟地址
• 3、为此虚拟区分配一个vm_area_struct结构，接着对这个结构的各个域进行了初始化
• 4、将新建的虚拟区结构（vm_area_struct）插入进程的虚拟地址区域链表或树中

（二）调用内核空间的系统调用函数mmap（不同于用户空间函数），实现文件物理地址和进程虚拟地址的一一映射关系

• 5、为映射分配了新的虚拟地址区域后，通过待映射的文件指针，在文件描述符表中找到对应的文件描述符，通过文件描述符，链接到内核“已打开文件集”中该文件的文件结构体（struct file），每个文件结构体维护着和这个已打开文件相关各项信息。
• 6、通过该文件的文件结构体，链接到file_operations模块，调用内核函数mmap，其原型为：int mmap(struct file *filp, struct vm_area_struct *vma)，不同于用户空间库函数。
• 7、内核mmap函数通过虚拟文件系统inode模块定位到文件磁盘物理地址。
  8、通过remap_pfn_range函数建立页表，即实现了文件地址和虚拟地址区域的映射关系。此时，这片虚拟地址并没有任何数据关联到主存中。

（三）进程发起对这片映射空间的访问，引发缺页异常，实现文件内容到物理内存（主存）的拷贝
注：前两个阶段仅在于创建虚拟区间并完成地址映射，但是并没有将任何文件数据的拷贝至主存。真正的文件读取是当进程发起读或写操作时。

• 9、进程的读或写操作访问虚拟地址空间这一段映射地址，通过查询页表，发现这一段地址并不在物理页面上。因为目前只建立了地址映射，真正的硬盘数据还没有拷贝到内存中，因此引发缺页异常。
• 10、缺页异常进行一系列判断，确定无非法操作后，内核发起请求调页过程。
• 11、调页过程先在交换缓存空间（swap cache）中寻找需要访问的内存页，如果没有则调用nopage函数把所缺的页从磁盘装入到主存中。
• 12、之后进程即可对这片主存进行读或者写的操作，如果写操作改变了其内容，一定时间后系统会自动回写脏页面到对应磁盘地址，也即完成了写入到文件的过程。

3.1.2、优点总结

1、对文件的读取操作跨过了页缓存，减少了数据的拷贝次数，用内存读写取代I/O读写，提高了文件读取效率。

2、实现了用户空间和内核空间的高效交互方式。两空间的各自修改操作可以直接反映在映射的区域内，从而被对方空间及时捕捉。

3、提供进程间共享内存及相互通信的方式。不管是父子进程还是无亲缘关系的进程，都可以将自身用户空间映射到同一个文件或匿名映射到同一片区域。从而通过各自对映射区域的改动，达到进程间通信和进程间共享的目的。

• 如果进程A和进程B都映射了区域C，当A第一次读取C时通过缺页从磁盘复制文件页到内存中；但当B再读C的相同页面时，虽然也会产生缺页异常，但是不再需要从磁盘中复制文件过来，而可直接使用已经保存在内存中的文件数据。

4、可用于实现高效的大规模数据传输。内存空间不足，是制约大数据操作的一个方面，解决方案往往是借助硬盘空间协助操作，补充内存的不足。但是进一步会造成大量的文件I/O操作，极大影响效率。这个问题可以通过mmap映射很好的解决。换句话说，但凡是需要用磁盘空间代替内存的时候，mmap都可以发挥其功效。

3.1.3、API函数（mmap、munmap、msync()）

1、函数原型：

void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);

2、返回值：
成功执行时，mmap()返回被映射区的指针。失败时，mmap()返回MAP_FAILED[其值为(void *)-1]， error被设为以下的某个值：

 1 EACCES：访问出错
 2 EAGAIN：文件已被锁定，或者太多的内存已被锁定
 3 EBADF：fd不是有效的文件描述词
 4 EINVAL：一个或者多个参数无效
 5 ENFILE：已达到系统对打开文件的限制
 6 ENODEV：指定文件所在的文件系统不支持内存映射
 7 ENOMEM：内存不足，或者进程已超出最大内存映射数量
 8 EPERM：权能不足，操作不允许
 9 ETXTBSY：已写的方式打开文件，同时指定MAP_DENYWRITE标志
10 SIGSEGV：试着向只读区写入
11 SIGBUS：试着访问不属于进程的内存区

3、参数说明：

• 1、start：映射区的开始地址
• 2、length：映射区的长度
• 3、prot：期望的内存保护标志，不能与文件的打开模式冲突。是以下的某个值，可以通过or运算合理地组合在一起

prot参数	参数说明
PROT_READ	内存段可读
PROT_WRITE	内存段可写
PROT_EXEC	内存段可执行
PROT_NONE	内存段不能被访问

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

flags参数	参数说明
MAP_SHARED	进程间共享内存，对该内存段修改反映到映射文件中。提供了POSIX共享内存
MAP_PRIVATE	内存段为调用进程所私有。对该内存段的修改不会反映到映射文件
MAP_ANNOYMOUS	这段内存不是从文件映射而来的。内容被初始化为全0
MAP_FIXED	内存段必须位于start参数指定的地址处，start必须是页大小的整数倍（4K整数倍）
MAP_HUGETLB	按照大内存页面来分配内存空间

• 5、fd：有效的文件描述词。如果MAP_ANONYMOUS被设定，为了兼容问题，其值应为-1
• 6、offset：被映射对象内容的起点

4、使用细节：

1、使用mmap需要注意的一个关键点是，mmap映射区域大小必须是物理页大小(page_size)的整倍数（32位系统中通常是4k字节）。

• 原因是，内存的最小粒度是页，而进程虚拟地址空间和内存的映射也是以页为单位。为了匹配内存的操作，mmap从磁盘到虚拟地址空间的映射也必须是页。

2、内核可以跟踪被内存映射的底层对象（文件）的大小，进程可以合法的访问在当前文件大小以内又在内存映射区以内的那些字节。也就是说，如果文件的大小一直在扩张，只要在映射区域范围内的数据，进程都可以合法得到，这和映射建立时文件的大小无关。

3、映射建立之后，即使文件关闭，映射依然存在。

• 因为映射的是磁盘的地址，不是文件本身，和文件句柄无关。同时可用于进程间通信的有效地址空间不完全受限于被映射文件的大小，因为是按页映射。

4、大小为0的文件无法创建映射区
5、munmap函数参数应该与mmap返回值严格对应
6、需要对mmap返回值进行判断

5、其他API函数

int munmap( void * addr, size_t len ) 

该调用在进程地址空间中解除一个映射关系，addr是调用mmap()时返回的地址，len是映射区的大小；

当映射关系解除后，对原来映射地址的访问将导致段错误发生。 

成功执行时，munmap()返回0。失败时，munmap返回-1，error返回标志和mmap一致；

int msync( void *addr, size_t len, int flags )

一般说来，进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，往往在调用munmap（）后才执行该操作。

可以通过调用msync()实现磁盘上文件内容与共享内存区的内容一致。

3.1.4、应用实例

实例1：读取一个文件，并修改
首先创建一个data 文件，编辑内容：

然后创建一个C 文件，对data进行读取和修改：

#include <sys/mman.h>  
#include <sys/stat.h>  
#include <fcntl.h>  
#include <stdio.h>  
#include <stdlib.h>  
#include <unistd.h>  
#include <error.h>  
  
#define BUF_SIZE 100  
  
int main(int argc, char **argv)  
{  
    int fd, nread, i;  
    struct stat sb;  
    char *mapped, buf[BUF_SIZE];  
  
    for (i = 0; i < BUF_SIZE; i++) {  
        buf[i] = '#';  
    }  
  
    /* 打开文件 */  
    if ((fd = open(argv[1], O_RDWR)) < 0) {  
        perror("open");  
    }  
  
    /* 获取文件的属性 */  
    if ((fstat(fd, &sb)) == -1) {  
        perror("fstat");  
    }  
  
    /* 将文件映射至进程的地址空间 */  
    if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ |   
                    PROT_WRITE, MAP_SHARED, fd, 0)) == (void *)-1) {  
        perror("mmap");  
    }  
  
    /* 映射完后, 关闭文件也可以操纵内存 */  
    close(fd);  
  
    printf("%s", mapped);  
  
    /* 修改一个字符,同步到磁盘文件 */  
    mapped[6] = '8';  
    if ((msync((void *)mapped, sb.st_size, MS_SYNC)) == -1) {  
        perror("msync");  
    }  
    printf("%s", mapped);  
    
    /* 释放存储映射区 */  
    if ((munmap((void *)mapped, sb.st_size)) == -1) {  
        perror("munmap");  
    }  
  
    return 0;  
}  

实例2：使用共享映射实现两个进程之间的通信

两个程序映射到同一个文件到自己的地址空间，进程A先运行，看是否发生变化，进程B后运行，它修改映射区域，然后退出，此时进程A能够观察到存储映射区的变化。

进程A的代码：

//进程A的代码
    #include <sys/mman.h>  
    #include <sys/stat.h>  
    #include <fcntl.h>  
    #include <stdio.h>  
    #include <stdlib.h>  
    #include <unistd.h>  
    #include <error.h>  
      
    #define BUF_SIZE 100  
      
    int main(int argc, char **argv)  
    {  
        int fd, nread, i;  
        struct stat sb;  
        char *mapped;  
      
        /* 打开文件 */  
        if ((fd = open(argv[1], O_RDWR)) < 0) {  
            perror("open");  
        }  
      
        /* 获取文件的属性 */  
        if ((fstat(fd, &sb)) == -1) {  
            perror("fstat");  
        }  
      
        /* 将文件映射至进程的地址空间 */  
        if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ |   
                        PROT_WRITE, MAP_SHARED, fd, 0)) == (void *)-1) {  
            perror("mmap");  
        }  
      
        /* 文件已在内存, 关闭文件也可以操纵内存 */  
        close(fd);  
          
        /* 每隔两秒查看存储映射区是否被修改 */  
        while (1) {  
            printf("%s\n", mapped);  
            sleep(2);  
        }  
      
        return 0;  
    }  
}

进程B的代码

 //进程B的代码
    #include <sys/mman.h>  
    #include <sys/stat.h>  
    #include <fcntl.h>  
    #include <stdio.h>  
    #include <stdlib.h>  
    #include <unistd.h>  
    #include <error.h>  
      
    #define BUF_SIZE 100  
      
    int main(int argc, char **argv)  
    {  
        int fd, nread, i;  
        struct stat sb;  
        char *mapped;  
      
        /* 打开文件 */  
        if ((fd = open(argv[1], O_RDWR)) < 0) {  
            perror("open");  
        }  
      
        /* 获取文件的属性 */  
        if ((fstat(fd, &sb)) == -1) {  
            perror("fstat");  
        }  
      
        /* 私有文件映射将无法修改文件 */  
        if ((mapped = (char *)mmap(NULL, sb.st_size, PROT_READ |   
                        PROT_WRITE, MAP_SHARED, fd, 0)) == (void *)-1) {  
            perror("mmap");  
        }  
      
        /* 映射完后, 关闭文件也可以操纵内存 */  
        close(fd);  
      
        /* 修改一个字符 */  
        mapped[6] = '8';  
       if ((msync((void *)mapped, sb.st_size, MS_SYNC)) == -1) {  
        perror("msync");  
    }  
        return 0;  
    }  

分析：因为只创建一个结构体大小的共享内存，后面写入的数据把前面写入的数据覆盖了。也就是data文件中的8每次都是更新的8。

参考

1、https://blog.csdn.net/zhangye3017/article/details/80200648
2、https://www.ibm.com/developerworks/cn/linux/l-ipc/part5/index2.html
3、https://blog.csdn.net/ypt523/article/details/79958188
4、https://zhuanlan.zhihu.com/p/36113550
5、https://www.cnblogs.com/huxiao-tee/p/4660352.html
6、https://blog.csdn.net/mj813/article/details/52082499