linux 进程通信之 mmap

迈不过友情╰ 2022-12-26 04:45 158阅读 0赞

## 一，[管道PIPE][PIPE] ##

## 二，[FIFO通信][PIPE] ##

## 三，mmap通信 ##

创建内存映射区。

![b179a7871dfacb6bba16da289c1e1eb0.png][]

#include <sys/mman.h>
    void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
    int mmap(void *addr, size_t length);

函数mmap：打开一个文件，指定一个文件的区域，作为一个区域，映射到内存中，以后就直接操作那个内存，就能够实现进程间的通信。因为是内存操作，所以速度最快。

*  addr:固定NULL
 *  length: 拿出文件中的多长的一段，映射到内存。
 *  offset: 从文件内容中的哪个位置开始拿。
 *  prot

> PROT\_EXEC Pages may be executed
> 
> PROT\_READ Pages may be read.
> 
> PROT\_WRITE Pages may be written
> 
> PROT\_NONE Pages may not be accessed

*  flags

> MAP\_SHARED: 对内存里的值进行修改，会反映到文件，也就是文件也被修改。
> 
> MAP\_PRIVATE:对内存里的值进行修改，不会反映到文件，文件不会被修改。

*  offset: 起始位置
 *  返回值:

> 成功:可用的内存的首地址
> 
> 失败:MAP\_FAILED(that is, (void \*) -1)

释放内存映射区.

#include <sys/mman.h>
    int munmap(void *addr, size_t length);

*  addr: mmap的返回值;
 *  length: mmap创建的长度;
 *  返回值: 成功0, 失败-1.

例子：

#include <sys/mman.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <stdio.h>
    #include <string.h>
    #include <unistd.h>
    
    int main() {
        int fd = open("mem", O_RDWR);
        // char *buf = mmap(NULL, 8, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
        char *buf = mmap(NULL, 8, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
        printf("%s\n", buf);
        strcpy(buf, "FFFFF");
        //释放映射区
        munmap(buf, 8);
        close(fd);
    }

mmap的七个问题:

*  如果更改上面例子里变量buf的地址，释放的时候munmap,还能成功吗?

不能成功，错误信息: \[Invalid argument\]

*  对映射区的操作，越界了怎么样？

open文件size > 要写入的size > mmap参数的length: 能够全部写入文件。

open文件size < 要写入的size > mmap参数的length: 不能全部写入文件，能够给写入的size是open文件的size

*  偏移量随便填个数字会怎么样?

mmap函数出错，错误信息: \[Invalid argument\]

offset必须是4K的整数倍，\[0, 4\*1024......\]

用\[stat\]命令查看文件，发现文件的size实际小于4096，但是\[IO Block: 4096\]

> File: pi2.c
> 
> Size: 442 Blocks: 8 IO Block: 4096 regular file
> 
> Device: 801h/2049d Inode: 424247 Links: 1
> 
> Access: (0664/-rw-rw-r--) Uid: ( 1000/ ys) Gid: ( 1000/ ys)
> 
> Access: 2019-05-02 12:54:13.812282158 +0800
> 
> Modify: 2019-04-29 13:49:42.489004001 +0800
> 
> Change: 2019-04-29 13:49:42.489004001 +0800

*  如果文件描述符先关闭，对mmap映射有没有影响。

没有影响。

*  open的时候，可以用新创建一个文件的方式，来创建映射区吗?

错误:Bus error(core dumped).

错误理由是:创建的文件的size为0，所以出上面的错误。新创建一个文件后，马上把文件大小扩展一下就不会发生错误了。

int fd = open("mem", O_RDWR|O_CREAT, 0666);
    ftruncate(fd, 8); //把新创建的文件mem的大小扩展为8.

*  open文件时，选择O\_WRONLY，可以吗

mmap函数出错，错误: \[Permission denied\]。

因为要把文件的内容读到内存，所以隐含一次读取操作，所有没有读的权限的话，就出这个错误。

*  当选择MAP\_SHARED的时候，open文件选择O\_RDONLY,prot可以选择\[PROT\_READ|PROT\_WRITE\]吗

mmap函数出错，错误： 【Permission denied】.

MAP\_SHARED的时候会去写文件，但是open的时候只有读权限，所以权限不够。

用mmap实现父子进程间通信的例子:

注意:参数flags必须是MAP\_SHARED,因为2个进程间通信，需要互相读写，所以必须是MAP\_SHARED

#include <stdio.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <sys/mman.h>
    #include <sys/wait.h>
    
    int main() {
        int fd = open("mem", O_RDWR);
        int* mem = mmap(NULL, 4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        if (mem == MAP_FAILED) {
            perror("mmap");
            return -1;
        }
        pid_t pid = fork();
    
        if (pid == 0) {
            *mem = 100;
            printf("child:mem=%d\n", *mem);
            sleep(3);
            printf("child:mem=%d\n", *mem);
        }
        else if (pid > 0) {
            sleep(1);
            printf("parent:mem=%d\n", *mem);
            *mem = 200;
            printf("parent:mem=%d\n", *mem);
            wait(NULL);
        }
    
        munmap(mem, 4);
        close(fd);
    }

执行结果:

> child:mem=100
> 
> parent:mem=100
> 
> parent:mem=200
> 
> child:mem=200

不知道读者同学们发现了没有，用mmap有个非常鸡肋的地方，就是必须要使用一个文件，其实这个文件对程序没有什么作用。所以linux给我们提供了一个方法，叫做\[匿名映射\]。

匿名映射:在调用mmap函数时候，在flags参数那里，设置\[MAP\_ANON\],并在fd参数那里设置\[-1\]。

int* mem = mmap(NULL, 4, PROT_READ | PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);

有个问题，在有些unix系统里是没有\[MAP\_ANON\]\[MAP\_ANONYMOUS\]这2个宏的，这2个宏的作用是一样的，其中一个是简写。那怎么办呢?

使用下面2个文件去映射，因为要用文件，所以必须还得有open的调用，但好处是不用事先做出一个大小合适的文件了。

*  /dev/zero: 可以随意映射，size无限大，诨名为\[聚宝盆\]
 *  /dev/null:可以随意映射，size无限大，但映射完后，文件里不会存有任何内容，所以也叫\[无底洞\],一般错误日志太多，而且不想保留的时候，会重定向到这个文件。

匿名映射的弱点:不能实现无血缘关系进程间的通信。

用mmap实现无血缘关系的进程间通信的例子:

写入端:

#include <stdio.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <sys/mman.h>
    #include <sys/wait.h>
    
    typedef struct _student {
        int id;
        char name[20];
    } Student;
    
    int main(int argc, char *argv[]) {
        int fd = open("aaa", O_RDWR|O_TRUNC|O_CREAT, 0666);
        int length = sizeof(Student);
        ftruncate(fd, length);
        Student *std = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        
        if (std == MAP_FAILED) {
            perror("mmap");
            return -1;
        }
    
        int num = 0;
        while (1) {
            std->id = num;
            sprintf(std->name, "xiaoming-%03d", num++);
            sleep(1);
        }
    
        munmap(std, length);
        close(fd);
    }

读入端:

#include <stdio.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <sys/mman.h>
    #include <sys/wait.h>
    
    typedef struct _student{
        int fd;
        char name[20];
    } Student;
    
    int main(int argc, char *argv[]) {
        int fd = open("aaa", O_RDWR);
        int length = sizeof(Student);
        Student *std = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    
        if (std == MAP_FAILED) {
            perror("mmap");
            return -1;
        }
    
        while (1) {
            printf("id:%03d, name:%s\n", std->id, std->name);
            sleep(1);
        }
    
        munmap(std, length);
        close(fd);
    }

利用mmap实现用多个进程拷贝一个文件的例子

核心思想:把要拷贝的文件和目标文件都映射成内存映射区，然后在各自的子进程里做拷贝，拷贝时，注意起点和大小。

#include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <fcntl.h>
    #include <sys/wait.h>
    #include <string.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <sys/mman.h>
    
    //argv[1]: 进程的数量
    //argv[2]: 要拷贝的文件
    int main(int argc, char *argv[]) {
        if (argc < 3) {
            printf("bad argv, need 3 arg\n");
            return -1;
        }
    
        //用stat函数取得文件的大小
        struct stat sbuf;
        int ret = stat(argv[2], &sbuf);
        if (ret < 0) {
            perror("stat");
            return -1;
        }
    
        //文件的大小
        off_t sz = sbuf.st_size;
    
        //余数
        off_t yu = sz % atoi(argv[1]);
        //每个进程拷贝的大小
        off_t proSz = (sz - yu) / atoi(argv[1]);
    
        //open src file
        int srcfd = open(argv[2], O_RDONLY);
    
        //create target file
        char wk[20] = {0};
        sprintf(wk, "%s.copy", argv[2]);
        int decfd = open(wk, O_RDWR|O_CREAT|O_TRUNC, 0766);
        //创建和src文件同等大小的目标文件
        ret = ftruncate(decfd, sz);
        if (ret < 0) {
            perror("ftruncate");
            return -1;
        }
    
        //打开要被拷贝文件的内存映射区
        void *dst = mmap(NULL, sz, PROT_READ, MAP_SHARED, srcfd, 0);
        if (src == MAP_FAILED) {
            perror("mmap src:");
            return -1;
        }
        
        //打开要目标文件的内存映射区
        void *dst = mmap(NULL, sz, PROT_READ|PROT_WRITE, MAP_SHARED, decfd, 0);
        if (dst == MAP_FAILED) {
            perror("mmap dst:");
            return -1;
        }
    
        int i;
        int pCnt = atoi(argv[1]);
    
        //创建子进程，都是这些子进程都是本程序的子进程
        for (i=0; i<pCnt; ++i) {
            //in child process
            if (fork() == 0) {
                break;
            }
        }
    
        //子进程的处理
        if (i < pCnt) {
            //last time
            if (i == pCnt - 1) {
                memcpy(dst+i*proSz, src+i*proSz, proSz+yu);
            }
            else {
                memcpy(dst+i*proSz, src+i*proSz, proSz);
            }
        }
    
        //父进程的处理
        else {
            for (int i=0; i<pCnt; ++i) {
                wait(NULL);
            }
            //printf("parent pid=%d\n", getpid());
            if (munmap(src, sz) == -1) {
                perror(munmap src");
            }
            if (munmap(dst, sz) == -1) {
                perror("munmap dsc");
            }
            close(srcfd);
            close(decfd);
    
        }
    
    }

[PIPE]: https://www.cnblogs.com/xiaoshiwang/p/10794806.html
[b179a7871dfacb6bba16da289c1e1eb0.png]: /images/20221120/dab8fa63bd284e41a354a2a598b0401e.png