Linux进程间通讯-------共享内存之mmap详解

时间  2019-11-12
标签 linux 进程 通讯 共享 内存 mmap 详解 栏目 Linux 繁體版
原文   原文链接

mmap()系统调用使得进程之间经过映射同一个普通文件实现共享内存。普通文件被映射到进程地址空间后，进程能够向访问普通内存同样对文件进行访问，没必要再调用read()，write（）等操做。linux

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

头文件：#include <sys/mman.h>缓存


具体参数含义
start ：  指向欲映射的内存起始地址，一般设为 NULL，表明让系统自动选定地址，映射成功后返回该地址。
length：  表明将文件中多大的部分映射到内存。
prot  ：  映射区域的保护方式。能够为如下几种方式的组合：
                    PROT_EXEC 映射区域可被执行
                    PROT_READ 映射区域可被读取
                    PROT_WRITE 映射区域可被写入
                    PROT_NONE 映射区域不能存取
flags ：  影响映射区域的各类特性。在调用mmap()时必需要指定MAP_SHARE或                    MAP_PRIVATE。
                    MAP_FIXED 若是参数start所指的地址没法成功创建映射时，则放弃映射，不对地址作修正。一般不鼓励用此旗标。
                    MAP_SHARED 对映射区域的写入数据会复制回文件内，并且容许其余映射该文件的进程共享。
                    MAP_PRIVATE 对映射区域的写入操做会产生一个映射文件的复制，即私人的“写入时复制”（copy on write）对此区域做的任何修改都不会写回原来的文件内容。
                    MAP_ANONYMOUS创建匿名映射。此时会忽略参数fd，不涉及文件，并且映射区域没法和其余进程共享。
                    MAP_DENYWRITE只容许对映射区域的写入操做，其余对文件直接写入的操做将会被拒绝。
                    MAP_LOCKED 将映射区域锁定住，这表示该区域不会被置换（swap）。
fd    ：  要映射到内存中的文件描述符。若是使用匿名内存映射时，即flags中设置了MAP_ANONYMOUS，fd设为-1。有些系统不支持匿名内存映射，则可使用fopen打开/dev/zero文件，
          而后对该文件进行映射，能够一样达到匿名内存映射的效果。
offset：文件映射的偏移量，一般设置为0，表明从文件最前方开始对应，offset必须是PAGE_SIZE的整数倍。

返回值：
      若映射成功则返回映射区的内存起始地址，不然返回MAP_FAILED(－1)，错误缘由存于errno 中。

错误代码：
            EBADF  参数fd 不是有效的文件描述词
            EACCES 存取权限有误。若是是MAP_PRIVATE 状况下文件必须可读，使用MAP_SHARED则要有PROT_WRITE以及该文件要能写入。
            EINVAL 参数start、length 或offset有一个不合法。
            EAGAIN 文件被锁住，或是有太多内存被锁住。
            ENOMEM 内存不足。
用户层的调用很简单，其具体功能就是直接将物理内存直接映射到用户虚拟内存，使用户空间能够直接对物理空间操做。可是对于内核层而言，其具体实现比较复杂。app

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

头文件： #include<sys/mman.h>函数

简介：测试

一、刷新变化函数msync()this

二、进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，每每在调用munmap()后才执行该操做。能够经过调用msync()函数来实现磁盘文件内容与共享内存区中的内容一致,即同步操做.spa

说明：
1. 当映射区数据被修改时，内核会稍后将其更新到文件。但有时候为了确保修改能被反映到文件，能够调用 msync 函数来进行同步操做。
2. addr：文件映射到进程空间的地址；len：映射空间的大小；。
3. 参数 flags 控制回写到文件的具体方式。MS_ASYNC 、MS_SYNC 必须指定其一。
1）MS_ASYNC ，只是将写操做排队，并不等待写操做完成就返回。
2）MS_SYNC ，等待写操做完成后才返回。
3）MS_INVALIDATE ，做废与实际文件内容不一致缓存页，有的实现则是做废整个映射区的缓存页。后续的引用将从文件获取数据。code

返回值：成功则返回0；失败则返回-1；htm

一、实例：blog

在目录新建一个文件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[20] = '9';  
    if ((msync((void *)mapped, sb.st_size, MS_SYNC)) == -1) {  
        perror("msync");  
    }  
  
    /* 释放存储映射区 */  
    if ((munmap((void *)mapped, sb.st_size)) == -1) {  
        perror("munmap");  
    }  
  
    return 0;  
}

测试结果：

二、使用共享映射实现两个进程之间的通讯：

仍是使用文件data做为测试：

两个程序映射同一个文件到本身的地址空间, 进程A先运行, 每隔两秒读取映射区域, 看是否发生变化. 进程B后运行, 它修改映射区域, 而后推出, 此时进程A可以观察到存储映射区的变化0.

代码：

//进程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, 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);  
          
        /* 每隔两秒查看存储映射区是否被修改 */  
        while (1) {  
            printf("%s\n", mapped);  
            sleep(2);  
        }  
      
        return 0;  
    }
//进程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, 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_PRIVATE, fd, 0)) == (void *)-1) {  
            perror("mmap");  
        }  
      
        /* 映射完后, 关闭文件也能够操纵内存 */  
        close(fd);  
      
        /* 修改一个字符 */  
        mapped[20] = '9';  
       
        return 0;  
    }

三、经过匿名映射实现父子进程通讯

#include <sys/mman.h>  
    #include <stdio.h>  
    #include <stdlib.h>  
    #include <unistd.h>  
      
    #define BUF_SIZE 100  
      
    int main(int argc, char** argv)  
    {  
        char    *p_map;  
      
        /* 匿名映射,建立一块内存供父子进程通讯 */  
        p_map = (char *)mmap(NULL, BUF_SIZE, PROT_READ | PROT_WRITE,  
                MAP_SHARED | MAP_ANONYMOUS, -1, 0);  
      
        if(fork() == 0) {  
            sleep(1);  
            printf("child got a message: %s\n", p_map);  
            sprintf(p_map, "%s", "hi, dad, this is son");  
            munmap(p_map, BUF_SIZE); //实际上，进程终止时，会自动解除映射。  
            exit(0);  
        }  
      
        sprintf(p_map, "%s", "hi, this is father");  
        sleep(2);  
        printf("parent got a message: %s\n", p_map);  
      
        return 0;  
    }

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

linux采用的是页式管理机制。对于用mmap()映射普通文件来讲，进程会在本身的地址空间新增一块空间，空间大小由mmap()的len参数指定，注意，进程并不必定可以对所有新增空间都能进行有效访问。进程可以访问的有效地址大小取决于文件被映射部分的大小。简单的说，可以容纳文件被映射部分大小的最少页面个数决定了进程从mmap()返回的地址开始，可以有效访问的地址空间大小。超过这个空间大小，内核会根据超过的严重程度返回发送不一样的信号给进程。可用以下图示说明：

http://dl2.iteye.com/upload/attachment/0054/8699/1be9f93e-d964-3b32-b0ff-611329940295.gif

总结一下就是, 文件大小, mmap的参数 len 都不能决定进程能访问的大小, 而是容纳文件被映射部分的最小页面数决定进程能访问的大小. 下面看一个实例:

#include <sys/mman.h>  
    #include <sys/types.h>  
    #include <sys/stat.h>  
    #include <fcntl.h>  
    #include <unistd.h>  
    #include <stdio.h>  
      
    int main(int argc, char** argv)  
    {  
        int fd,i;  
        int pagesize,offset;  
        char *p_map;  
        struct stat sb;  
      
        /* 取得page size */  
        pagesize = sysconf(_SC_PAGESIZE);  
        printf("pagesize is %d\n",pagesize);  
      
        /* 打开文件 */  
        fd = open(argv[1], O_RDWR, 00777);  
        fstat(fd, &sb);  
        printf("file size is %zd\n", (size_t)sb.st_size);  
      
        offset = 0;   
        p_map = (char *)mmap(NULL, pagesize * 2, PROT_READ|PROT_WRITE,   
                MAP_SHARED, fd, offset);  
        close(fd);  
          
        p_map[sb.st_size] = '9';  /* 致使总线错误 */  
        p_map[pagesize] = '9';    /* 致使段错误 */  
      
        munmap(p_map, pagesize * 2);  
      
        return 0;  
    }
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程