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 munmap(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 id;
  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* src = 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);

  }
}

c/c++ 学习互助QQ群：877684253

本人微信：xiaoshitou5854