Linux系统编程---进程间通信IPC(二)

一、存储映射I/O(Memory-mapped I/O)

• 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是从缓冲区中取数据，就相当于读文件中的相应字节。
• 与此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不使用read和write函数的情况下，使地址指针完成I/O操作。
• 使用这种方法，首先应该通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。

mmap函数 

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

创建共享内存映射

参数：

        addr： 指定映射区的首地址。通常传【NULL】，表示让系统自动分配

        length：共享内存映射区的大小。（【<= 】文件的实际大小）

        prot： 共享内存映射区的读写属性。

        PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE

        flags： 标注共享内存的共享属性。

        MAP_SHARED 修改会反映到磁盘上

        MAP_PRIVATE 修改不反映到磁盘上

        fd: 用于创建共享内存映射区的那个文件的 文件描述符。

        offset：默认0，表示映射文件全部。偏移位置。需是 【4k 的整数倍】。

返回值：

        成功：映射区的首地址。

        失败：MAP_FAILED (void*(-1))， errno

munmap函数

int munmap(void *addr, size_t length);

释放映射区。

addr：mmap 的返回值

length：大小

使用mmap创建一个映射区（共享内存），并往映射区里写入内容： 

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<errno.h>
#include<pthread.h>
#include<sys/mman.h>
#include<fcntl.h>

void sys_err(const char *str)
{
        perror(str);
        exit(1);
}

int main(int argc,char *argv[])
{
        char *p = NULL;
        int fd;

        fd = open("testmap",O_RDWR|O_CREAT|O_TRUNC,0644);
        if (fd == -1)
        {
                sys_err("open error");
        }

//      lseek(fd,10,SEEK_END);两个函数等价于ftruncate()函数
//      write(fd,"\0",1);

        ftruncate(fd,20);
        int len = lseek(fd,0,SEEK_END);

        p = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
        if (p == MAP_FAILED)
        {
                sys_err("mmap error");
        }

        //使用p对文件进行读写操作
        strcpy(p,"hello mmap\n");//写操作

        printf("---%s\n",p);

        int ret = munmap(p,len);
        if (ret == -1)
        {
                sys_err("munmap error");
        }

        return 0;
}

输出为：

---hello mmap

mmap使用注意事项 

1. 用于创建映射区的文件大小为 0，实际指定非0大小创建映射区，出 “总线错误”。

2. 用于创建映射区的文件大小为 0，实际制定0大小创建映射区， 出 “无效参数”。

3. 用于创建映射区的文件读写属性为，只读。映射区属性为 读、写。 出 “无效参数”。

4. 创建映射区，需要read权限。当访问权限指定为 “共享”MAP_SHARED时， mmap的读写权限，应该 <=文件的open权限。 只写不行。

5. 文件描述符fd，在mmap创建映射区完成即可关闭。后续访问文件，用 地址访问。

6. offset 必须是 4096的整数倍。（MMU 映射的最小单位 4k ）

7. 对申请的映射区内存，不能越界访问。

8. munmap用于释放的 地址，必须是mmap申请返回的地址。

9. 映射区访问权限为 “私有”MAP_PRIVATE, 对内存所做的所有修改，只在内存有效，不会反应到物理磁盘上。

10. 映射区访问权限为 “私有”MAP_PRIVATE, 只需要open文件时，有读权限，用于创建映射区即可。

mmap函数的保险调用方式：

1. fd = open（"文件名"， O_RDWR）;
2. mmap(NULL, 有效文件大小， PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);

mmap总结

1. 创建映射区的过程中，隐含着一次对映射文件的【读操作】
2. 当MAP_SHARED时，要求：映射区的权限应该<=文件打开的权限（出于对映射区的保护）。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制
3. 映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭
4. 特别注意，当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际大小！！mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。如，400字节大小的文件，在简历映射区时，offset4096字节，则会报出总线错误
5. munmap传入的地址一定是mmap返回的地址。坚决【杜绝指针++】操作
6. 文件偏移量必须为4K的整数倍
7. mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。

二、父子(有血缘关系)进程间mmap通信

父子进程使用 mmap 进程间通信，要求如下：

1. 父进程先创建映射区。 open(O_RDWR) mmap(MAP_SHARED);
2. 指定MAP_SHARED权限
3. fork() 创建子进程。
4. 一个进程读， 另外一个进程写

父子进程mmap通信，对比全局变量 ：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/wait.h>

int var = 100;
int main(void)
{
        int *p;
        pid_t pid;
         
        int fd;
        fd = open("temp",O_RDWR|O_CREAT|O_TRUNC,0644);
        if (fd < 0)
        {
                perror("open error");
                exit(1);
        }
        ftruncate(fd,4);
        p = (int *)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
//      p = (int *)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_PRIVATE,fd,0);
        if (p == MAP_FAILED)    //注意:不是p == NULL  
        {
                perror("mmap error");
                exit(1);
        }
        close(fd);      //映射区建立完毕,即可关闭文件

        pid = fork();//创建子进程
        if (pid == 0)
        {
                *p = 7000;               // 写共享内存  
                var = 1000;  
                printf("child, *p = %d, var = %d\n", *p, var);
        }
        else{
                sleep(1);  
                printf("parent, *p = %d, var = %d\n", *p, var);//读共享内存
                wait(NULL);

                int ret = munmap(p,4);//释放映射内存
                if (ret == -1)
                {
                        perror("munmap error");
                        exit(1);
                }
        }
        return 0;
}

 将以上代码写入fork_mmap.c文件中，执行代码输出为：

child, *p = 7000, var = 1000
parent, *p = 7000, var = 100

子进程修改p的值，也反映到了父进程上，这是因为共享内存定义为shared的(读时共享，写时复制)

如果将共享内存定义为private，输出结果如下：

child, *p = 7000, var = 1000
parent, *p = 0, var = 100

改为私有之后，映射区归父进程私有，父子进程通信中断

三、无血缘关系进程间mmap通信

要求：

        1. 两个进程打开同一个文件，创建映射区。

        2. 指定flags 为 MAP_SHARED。

        3. 一个进程写入，另外一个进程读出。

注意：无血缘关系进程间mmap通信

mmap：

• 数据可以重复读取。内容被读走之后不会消失，
• 如果读进程的读取时间间隔短，它会读到很多重复内容，因为写进程没来得及写入新内容。数据只能一次读取

fifo：

• 数据只能一次读取

以下是两个无血缘关系的通信代码，先是写进程：

写入时直接使用memcpy函数：参数一是指针，参数二是数据，参数三是字节数

#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>

struct student{
        int id;
        char name[256];
        int age;
};

void sys_err(const char *str)
{
        perror(str);
        exit(1);
}

int main(int argc,char *argv[])
{
        struct student stu = {1,"xiaoming",18};
        struct student *p;
        int fd;
        fd = open("test_map",O_RDWR|O_CREAT|O_TRUNC,0664);
        if (fd == -1)
        {
                sys_err("open error");
        }

        ftruncate(fd,sizeof(stu));

        p = mmap(NULL,sizeof(stu),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
        if (p == MAP_FAILED)
        {
                sys_err("mmap error");
        }

        close(fd);
        
        while(1)
        {
                memcpy(p,&stu,sizeof(stu));
                stu.id++;
                sleep(1);
        }       

        munmap(p,sizeof(stu));

        return 0;
}

然后是读进程：

#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys/mman.h>
#include<string.h>
#include<unistd.h>
#include<errno.h>

struct student{
        int id;
        char name[256];
        int age;
};

void sys_err(const char *str)
{
        perror(str);
        exit(1);
}

int main(int argc,char *argv[])
{
        struct student stu;
        struct student *p;
        int fd;
        fd = open("test_map",O_RDONLY);
        if (fd == -1)
        {
                sys_err("open error");
        }

        p = mmap(NULL,sizeof(stu),PROT_READ,MAP_SHARED,fd,0);
        if (p == MAP_FAILED)
        {
                sys_err("mmap error");
        }

        close(fd);
        
        while(1)
        {
                printf("id = %d,name = %s,age=%d",p->id,p->name,p->age);
                sleep(1);
        }       

        munmap(p,sizeof(stu));

        return 0;
}

运行阶段：

make mmap_w

make mmap_r

./mmap_w

另外一个终端执行：

./mmap_r

多个写端一个读端也是可以的，打开多个写进程之后读进程会读到所有写进程写入的内容。

*四、mmap匿名映射区

通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。可以直接使用匿名映射来代替。

匿名映射：只能用于血缘关系进程间通信。

p = (int *)mmap(NULL, 40, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);