码迷,mamicode.com
首页 > 系统相关 > 详细

进程间通信---mmap详解(与system V ipc通信对照)

时间:2019-07-13 18:38:48      阅读:151      评论:0      收藏:0      [点我收藏+]

标签:写入文件   com   eve   mic   font   调用   自动   原型   父子进程通信   

目前,进程间通信主要集中在管道和共享内存上使用,共享内存是总所周知的直接对内存映射操作,速度最快的通信方式,缺点,可能就是数据同步没有提供同步机制

共享存储映射

存储映射I/O 

存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射于是当从缓冲区中取数据就相当于读文件中的相应字节于此类似将数据存入缓冲区则相应的字节就自动写入文件这样,就可在不使用readwrite函数的情况下,使用地址(指针)完成I/O操作。

使用这种方法首先应通知内核将一个指定文件映射到存储区域中这个映射工作可以通过mmap函数来实现

技术图片

 

 

mmap函数

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

返回:成功:返回创建的映射区首地址;失败:MAP_FAILED

参数

  addr: 建立映射区的首地址,由Linux内核指定。使用时,直接传递NULL

  length: 欲创建映射区的大小

  prot 映射区权限PROT_READPROT_WRITEPROT_READ|PROT_WRITE

  flags 标志位参数(常用于设定更新物理区域、设置共享、创建匿名映射区)

       MAP_SHARED:  会将映射区所做的操作反映到物理设备(磁盘)上。

       MAP_PRIVATE: 映射区所做的修改不会反映到物理设备。

     fd 用来建立映射区的文件描述符

     offset 映射文件的偏移(4k的整数倍)

munmap函数

malloc函数申请内存空间类似的,mmap建立的映射区在使用结束后也应调用类似free的函数来释放

int munmap(void *addr, size_t length); 成功:0; 失败:-1

 

 

借鉴mallocfree函数原型,尝试装自定义函数smalloc,sfree来完成映射区的建立和释放。思考函数接口该如何设计?

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

void *smalloc(size_t size)
{
    void *p;

    p = mmap(NULL, size, PROT_READ|PROT_WRITE, 
            MAP_SHARED|MAP_ANON, -1, 0);
    if (p == MAP_FAILED) {        
        p = NULL;
    }

    return p;
}

void sfree(void *ptr, size_t size)
{
    munmap(ptr, size);
}

int main(void)
{
    int *p;
    pid_t pid;
    
    p = smalloc(4);

    pid = fork();                //创建子进程
    if (pid == 0) {
        *p = 2000;
        printf("child, *p = %d\n", *p);
    } else {
        sleep(1);
        printf("parent, *p = %d\n", *p);
    }

    sfree(p, 4);

    return 0;
}

 

 

mmap注意事项

mmap.c

 

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

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

int main(void)
{
    char *mem;
    int len = 0;

    int fd = open("hello678", O_RDWR|O_CREAT|O_TRUNC, 0644);
    if (fd < 0)
        sys_err("open error");
    len = lseek(fd, 3, SEEK_SET);   //获取文件大小,根据文件大小创建映射区
    write(fd, "\0", 1);              //实质性完成文件拓展
    len = lseek(fd, 0, SEEK_END);
    
    printf("The length of file = %d\n", len);

    mem = mmap(NULL, len, PROT_WRITE, MAP_PRIVATE, fd, 0);
    if (mem == MAP_FAILED)            //出错判断
        sys_err("mmap err: ");
    close(fd);

    strcpy(mem, "aaa");
    printf("%s\n", mem);

    if (munmap(mem,  len) < 0)
        sys_err("munmap");

    return 0;
}

//思考:
//1. 如果mem++,munmap可否成功?
//2. 如果open时O_RDONLY, mmap时PROT参数指定PROT_READ|PROT_WRITE会怎样?
//3. 如果文件偏移量为1000会怎样?
//4. 如果不检测mmap的返回值,会怎样?
//5. mmap什么情况下会调用失败?
//6. 对mem越界操作会怎样?
//7. 文件描述符先关闭,对mmap映射有没有影响?
//8. 可以open的时候O_CREAT一个新文件来创建映射区吗?

 

 

 

思考:

1. 如果mem++munmap可否成功?

2. 如果openO_RDONLY, mmapPROT参数指定PROT_READ|PROT_WRITE会怎样?

3. 如果文件偏移量为1000会怎样?

5. mmap什么情况下会调用失败?

6. mem越界操作会怎样?

7. 文件描述符先关闭,对mmap映射有没有影响?

4. 如果不检测mmap的返回值,会怎样?

8. 可以open的时候O_CREAT一个新文件来创建映射区吗?

总结使用mmap时务必注意以下事项

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

mmap父子进程通信

父子等有血缘关系的进程之间也可以通过mmap建立的映射区来完成数据通信。但相应的要在创建映射区的时候指定对应的标志位参数flags

MAP_PRIVATE:  (私有映射)  父子进程各自独占映射区;

MAP_SHARED:  (共享映射)  父子进程共享映射区;

  父进程创建映射区,然后fork子进程,子进程修改映射区内容,而后,父进程读取映射区内容,查验是否共享。

 

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.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);
    }
    unlink("temp");                //删除临时文件目录项,使之具备被释放条件.
    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 = 2000;
        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;
}

  

结论:父子进程共享:1. 打开的文件  2. mmap建立的映射区(但必须要使用MAP_SHARED)

匿名映射

通过使用我们发现使用映射区来完成文件读写操作十分方便父子进程间通信也较容易但缺陷是每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要open一个temp文件,创建好了再unlinkclose掉,比较麻烦。 可以直接使用匿名映射来代替。其实Linux系统给我们提供了创建匿名映射区的方法无需依赖一个文件即可创建映射区同样需要借助标志位参数flags来指定

使用MAP_ANONYMOUS (MAP_ANON), 如:

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

    "4"随意举例,该位置表大小,可依实际需要填写。

    fork_map_anon_linux.c

 

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

int main(void)
{
    int *p;
    pid_t pid;
    
    int fd = open("/dev/zero", O_RDWR);
    //p = mmap(NULL, 400, PROT_READ|PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
    p = mmap(NULL, 400, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if(p == MAP_FAILED){        //注意:不是p == NULL
        perror("mmap error");
        exit(1);
    }
    close(fd);

    pid = fork();                //创建子进程
    if(pid == 0){
        *p = 2000;
        printf("child, *p = %d\n", *p);
    } else {
        sleep(1);
        printf("parent, *p = %d\n", *p);
    }

    munmap(p, 400);                //释放映射区

    return 0;
}

 

 

 

需注意的是,MAP_ANONYMOUSMAP_ANON这两个宏是Linux操作系统特有的宏。在类Unix系统中如无该宏定义,可使用如下两步来完成匿名映射区的建立。

fd = open("/dev/zero", O_RDWR);

p = mmap(NULL, size, PROT_READ|PROT_WRITE, MMAP_SHARED, fd, 0);

    fork_map_anon.c

 

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

int main(void)
{
    int *p;
    pid_t pid;
    
    int fd;
    fd = open("/dev/zero", O_RDWR);

    p = mmap(NULL, 400, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);

    if(p == MAP_FAILED){        //注意:不是p == NULL
        perror("mmap error");
        exit(1);
    }

    pid = fork();                //创建子进程
    if(pid == 0){
        *p = 2000;
        printf("child, *p = %d\n", *p);
    } else {
        sleep(1);
        printf("parent, *p = %d\n", *p);
    }

    munmap(p, 4);                //释放映射区

    return 0;
}

 

结论:

MAP_PRIVATE:在父子进程间通信,映射的区域不能互相访问,或者不能读取父或子写入映射内存地址空间的数据

 

mmap无血缘关系进程间通信

实质上mmap是内核借助文件帮我们创建了一个映射区,多个进程之间利用该映射区完成数据传递。由于内核空间多进程共享,因此无血缘关系的进程间也可以使用mmap来完成通信。只要设置相应的标志位参数flags即可。若想实现共享,当然应该使用MAP_SHARED了。

例:

mmap_r.c

 

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

struct STU {
    int id;
    char name[20];
    char sex;
};

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

int main(int argc, char *argv[])
{
    int fd;
    struct STU student;
    struct STU *mm;

    if (argc < 2) {
        printf("./a.out file_shared\n");
        exit(-1);
    }

    fd = open(argv[1], O_RDONLY);
    if (fd == -1)
        sys_err("open error");

    mm = mmap(NULL, sizeof(student), PROT_READ, MAP_SHARED, fd, 0);
    if (mm == MAP_FAILED)
        sys_err("mmap error");
    
    close(fd);

    while (1) {
        printf("id=%d\tname=%s\t%c\n", mm->id, mm->name, mm->sex);
        usleep(10000);
    }

    munmap(mm, sizeof(student));

    return 0;
}

 

mmap_w.c

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

struct STU {
    int id;
    char name[20];
    char sex;
};

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

int main(int argc, char *argv[])
{
    int fd;
    struct STU student = {10, "xiaoming", m};
    char *mm;

    if (argc < 2) {
        printf("./a.out file_shared\n");
        exit(-1);
    }

    fd = open(argv[1], O_RDWR | O_CREAT, 0664);
    ftruncate(fd, sizeof(student));

    mm = mmap(NULL, sizeof(student), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (mm == MAP_FAILED)
        sys_err("mmap");

    close(fd);

    while (1) {
        memcpy(mm, &student, sizeof(student));
        student.id++;
        sleep(1);
    }

    munmap(mm, sizeof(student));

    return 0;
}

 

 

以上总结了mmap的用法,现在和ipc system V的共享内存比较一下

shm图示例:

技术图片

 

   

 

(1)通过int shmget(key_t key, size_t size, int shmflg);在物理内存创建一个共享内存,返回共享内存的编号。
(2)通过void *shmat(int shmid, constvoid shmaddr,int shmflg);连接成功后把共享内存区对象映射到调用进程的地址空间
(3)通过void *shmdt(constvoid* shmaddr);断开用户级页表到共享内存的那根箭头。
(4)通过int shmctl(int shmid, int cmd, struct shmid_ds* buf);释放物理内存中的那块共享内存。

总结mmap和shm:
1、mmap是在磁盘上建立一个文件,每个进程地址空间中开辟出一块空间进行映射。
而对于shm而言,shm每个进程最终会映射到同一块物理内存。shm保存在物理内存,这样读写的速度要比磁盘要快,但是存储量不是特别大。
2、相对于shm来说,mmap更加简单,调用更加方便,所以这也是大家都喜欢用的原因。
3、另外mmap有一个好处是当机器重启,因为mmap把文件保存在磁盘上,这个文件还保存了操作系统同步的映像,所以mmap不会丢失,但是shmget就会丢失。

 

具体的话请看这篇总结:

https://www.cnblogs.com/stevensfollower/p/4897711.html

 

进程间通信---mmap详解(与system V ipc通信对照)

标签:写入文件   com   eve   mic   font   调用   自动   原型   父子进程通信   

原文地址:https://www.cnblogs.com/bwbfight/p/11181631.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!