linux 进程通信之 mmap

一，管道PIPE

二，FIFO通信

三，mmap通信

创建内存映射区。

#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 fileint srcfd = open(argv[2], O_RDONLY);//create target filechar 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 processif (fork() == 0) {break;}}//子进程的处理if (i < pCnt) {//last timeif (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);}}