【Linux】IPC主题 二-------- 共享内存(mmap)

最新推荐文章于 2022-09-26 18:36:10 发布
最新推荐文章于 2022-09-26 18:36:10 发布
阅读量537 收藏 4
点赞数
分类专栏： Linux&&操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35396127/article/details/78750551
版权

一、mmap 函数

     1、函数原型：


   #include <sys/mman.h>

       void *mmap(void *addr, size_t length, int prot, int flags,
                  int fd, off_t offset);
     2、返回值：

                       若执行成功： 返回创建的映射区的首地址；

                       若执行失败： 返回 MAP_FAILED  宏 
      3、参数：

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

                      length：   欲创建的映射区大小。

                      prot    ：   映射权限   PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE

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

                                       MAP_SHARED：会将映射区所做的操作反映到物理设备上（磁盘上）

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


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

                     offset    ：  映射文件的偏移（4k的整数倍）

二、munmap 函数

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

        

       int munmap(void *addr, size_t length);
                    返回值：

                                 若成功，返回 0 ； 若失败，返回 -1。

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

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


int main(void)
{
    char *mem;
    int len = 0;
    int fd = open("hello123",O_RDONLY|O_CREAT|O_TRUNC,0644);
    if( fd == -1 )
        sys_error("open error");

    ftruncate(fd,20);
/*
    len = lseek(fd,3,SEEK_SET);    // 获取文件大小，根据文件大小建立映射区
    write(fd,"e",1);               // 实质性完成文件拓展
    printf("The length of file = %d\n",len);
*/

    mem = mmap(NULL,20,PROT_READ,MAP_SHARED,fd,0);

    if( mem == MAP_FAILED )        // 出错判断
        sys_error("mmap error");
    mem++;
    close(fd);

    strcpy(mem,"xxx");

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


    if( munmap(mem,4)<0 )
        sys_error("munmap error");

    return 0;
}


三、mmap 的使用注意事项

       1、创建映射区时，隐含着对映射文件的一次读操作。

       2、当 MAP_SHARED时，要求映射区的权限应 <= 文件的打开权限（出于对映射区的保护）。而 MAP_PRIVATE则无所谓，因为 mmap 中的权限是对内存的限制。

       3、映射区的释放与文件关闭无关。只要映射建立成功，则文件可以立即关闭。

       4、特别注意：当映射文件大小为 0 时，不能创建映射区。所以，用于映射的文件必须有实际大小！mmap 使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。

       5、munmap 传入的地址一定是 mmap 的返回地址。杜绝指针 ++ ，-- 操作。

       6、文件偏移量必须为 4k 的整数倍。

       7、mmap 创建映射区出错概率非常高，一定要检查返回值，确保映射区成功建立，并进行后续操作。

四、mmap 父子进程间通信

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

                 MAP_PROVATE（私有映射）：父子进程各自独占映射区

                 MAP_SHARED（共享进程）  ：父子进程共享映射区

        结论：

                 父子进程共享：

                                         (1)、打开的文件

                                         (2)、mmap 建立的映射区（但必须使用 MAP_SHARED）

#include<unistd.h>
#include<sys/mman.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.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 == -1 )
    {
        perror("open error");
        exit(1);
    }
  
    // 这里程序在运行期间 temp 文件还存在，运行完成后，推出进程后，temp文件被删除掉
    unlink("temp");  // 删除临时文件目录项，使之具备被释放的条件  

    ftruncate(fd,4);
    p =(int*)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);

    if( p == MAP_FAILED )
    {
        perror("mmap error");
        exit(1);
    }

    close(fd);       // 映射区建立完毕，即可关闭文件

    pid = fork();    // 创建子进程
    if( pid == 0 )
    {
        var = 1000;
        *p = 2000;
        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("munmao error");
            exit(1);
        }
    }

    return 0;
}


五、匿名映射

        使用 MAP_ANOYYMOUS（MAP_ANON），如：

        

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


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

int var = 100;

int main(void)
{
    int *p;
    pid_t pid;
 
    p =(int*)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANON,-1,0);

    if( p == MAP_FAILED )
    {
        perror("mmap error");
        exit(1);
    }

    pid = fork();    // 创建子进程
    if( pid == 0 )
    {
        var = 1000;
        *p = 2000;
        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("munmao error");
            exit(1);
        }
    }

    return 0;
}


       注意：

                  MAP_ANONYMOUS 和 MAP_ANON 这两个宏是 Linux操作系统特有的宏，在类 UNIX 系统中无该宏定义，可使用如下两步来完成匿名映射区的建立。

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

                  (2)、p = mmap(NULL,size,PROT_READ|PROT_WRTIE,MAP_SHARED,fd,0);


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

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


非血缘关系写进程：

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

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


void sys_err(char *error)
{
    perror(error);
    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,0644);
    if( fd == -1 )
        sys_err("open error");
    ftruncate(fd,sizeof(student));

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

    if( mm == MAP_FAILED )
        sys_err("mmap error");

    close(fd);

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

    int ret = munmap(mm,sizeof(student));
    if( ret == -1 )
        sys_err("munmap error");

    return 0;
}


非血缘关系读进程： 


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

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


void sys_err(char *error)
{
    perror(error);
    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);
        sleep(2);
    }

    int ret = munmap(mm,sizeof(student));
    if( ret == -1 )
        sys_err("munmap error");

    return 0;
}


七、文件通信

       两个非血缘关系的进程可以通过文件的方式来进行通信。

              strace + 文件名          能够追踪到当前程序执行过程中用到的系统调用。

          注意：文件的一些操作都是用 mmap 来实现的。


/*
    先执行，将数据写入文件 test.txt 
*/

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

#define N 5

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

int main(void)
{
    char buf[1024];

    char *str= "-------------successs--------------\n";
    int ret;

    int fd = open("test.txt",O_RDWR|O_TRUNC|O_CREAT,0644);

    if( fd == -1 )
        sys_err("open error");

    // 直接打开文件写数据

    write(fd,str,strlen(str));
    printf("test1 write into test.txt finish\n");

    sleep(N);

    lseek(fd,0,SEEK_SET);

    ret = read(fd,buf,sizeof(buf));

    if( ret <=0 )
        sys_err("read error");

    ret = write(STDOUT_FILENO,buf,ret);

    if( ret == -1 )
        sys_err("write error");

    close(fd);

    return 0;
}


/*
    先执行，将数据写入文件 test.txt 
*/

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

#define N 5

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

int main(void)
{
    char buf[1024];

    char *str= "-------------test2 write success--------------\n";
    int ret;

    sleep(2);   // 睡两秒，保证 test1 将数据写入 test.txt中
    int fd = open("test.txt",O_RDWR);

    if( fd == -1 )
        sys_err("open error");

    // 尝试读取 test.txt文件中 test1 写入数据

    ret = read(fd,buf,sizeof(buf));
    if( ret <= 0 )
        sys_err("read error");

    // 将读到的数据打入屏幕

    write(STDOUT_FILENO,buf,ret);

    // 写入数据到 test.txt 中，未修改读写位置

    write(fd,str,strlen(str));

    printf("test2 read/write finish\n");
    
    close(fd);

    return 0;
}

Julinus
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下IPC方法-内存映射区（二）mmap函数解析
linkvivi的博客
03-26 218
1、存储映射I/O的概念及为什么要用内存映射区？    存储映射I/O（memory-mapped I/O）：使一个磁盘文件与存储空间中的一个缓冲区相映射。于是从缓冲区中取数据就相当于读文件中的相应字节了。将数据存入缓冲区则相应的字节就写入到文件。这样就可以在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。2、内存映射区的特点？    既可以在有血缘关系进程间，也可以在非血...
使用内存映射实现文件拷贝的功能
干啥啥不行，但是也要干的博客
05-28 437
思路 1.对原始文件进行内存映射 2 创建一个新文件 3 把新文件的数据映射到内存中 4 通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中 5 释放资源 #include<stdio.h> #include<sys/mman.h> #include<fcntl.h> #include<unistd.h> #include<string.h> #include<stdlib.h> #include<wait.h> int
共享内存映射之mmap()函数详解
qq_33441035的博客
04-15 1072
转 共享内存映射之mmap()函数详解 /span> ...
linux中如何进行读写,如何在Linux系统上使用mmap()进行读写
weixin_42140716的博客
05-13 522
我需要在Linux中使用mmap()创建一些流入和派出类.为此,我尝试制作一些测试代码,将一些整数写入文件,保存,再次加载并将文件中的数据写入cout.如果该测试代码有效,那么之后将流输入和输出不会成为问题.当我刚开始时,我遇到了段错误,如果我没有得到任何结果,那么我用谷歌搜索了一下.我发现这本书http://www.advancedlinuxprogramming.com/alp-folder/...
mmap内存映射
最新发布
weixin_45205160的博客
09-26 2309
存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据，就相当于读文件中的相应字节。于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。
【Linux 进程间通信（IPC）详解 · 第二篇】内存映射的原理与共享内存
idiot5lie的博客
05-23 553
目录&索引1 概述2 内存映射3 共享内存3.1 共享内存代码（互斥锁、条件变量同步）3.2 测试结果4 mmap 与 shm 的区别5 小结 1 概述 Linux 中的两种共享内存——一种是我们的 IPC 通信 System V 版本的共享内存（shm），另外的一种就是内存映射（mmap）。 2 内存映射 内存映射的结果——通过直接操作虚拟内存来实现对文件的操作，进而不需要从用户态陷入内核态，以及不需要从内核态回归用户态，故可以加快执行速度。 不是专门用来进行数据通信的，但它也可以用于进程间的
进程间通信(4)---共享内存
方池安夏的博客
03-13 1349
目录共享内存机制两种常用共享内存方式System V版本的共享内存 shmm文件映射 mmap共享内存操作ftok()shmget()shmat() 共享内存机制 是允许两个或多个进程（不相关或有亲缘关系）访问同一个逻辑内存的机制。它是共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排为同一段物理内存。 两种常用共享内存方式 System V版本的共享内存 shmm 1.多个进程直接共享内存 原理: 利用共享内存完成进程间通信,两个进程都通过虚拟地址空间到用户页表,然后通过用户级页表映射到
商业编程-源码-共享内存封装类.zip
06-23
- **共享内存模型**：共享内存是进程间通信（IPC）的一种方式，不同进程通过映射到同一块物理内存区域实现数据交换。 - **优点**：高速、直接访问，无需复制数据，特别适合大量数据传输。 - **挑战**：同步和互斥...
linux-c-api-ref.zip_linux api_linux-c-api-ref
09-24
以上只是Linux C API中的一部分核心知识点，实际的API包含更多内容，如进程间通信（IPC）、定时器、共享内存、管道等。深入理解和熟练使用这些API是开发高效、可靠的Linux应用程序的关键。通过阅读“linux-c-api-ref...
linux-systems-programming-with-c：有关C，Linux和系统编程的免费编程书籍
02-04
4. **进程与线程**：学习如何创建、管理进程（fork、execve）和线程（pthread库），以及进程间通信（IPC）机制，如管道、信号、共享内存和消息队列。 5. **内存管理**：探索动态内存分配（malloc、calloc、realloc...
LINUX编程白皮书001-03
04-14
除此之外，Linux系统编程还包括权限控制、文件系统操作、设备驱动编程、内存管理、进程间通信（IPC）、时间与定时器等方面的内容。每一部分都需要深入学习和实践才能真正掌握。 总的来说，《LINUX编程白皮书001-03...
Unix-Linux编程实践教程各章源代码
11-23
这部分可能包含管道（`pipe()`, `fifo()`）、消息队列、共享内存、信号量等IPC机制的示例代码。 通过这些源代码，学习者不仅可以理解Unix/Linux编程的基本概念，还能亲自动手实践，从而提升实际编程能力。每章的...
mmap函数使用
菜鸟成长轨迹
01-22 1万+
UNIX网络编程第二卷进程间通信对mmap函数进行了说明。该函数主要用途有三个：1、将一个普通文件映射到内存中，通常在需要对文件进行频繁读写时使用，这样用内存读写取代I/O读写，以获得较高的性能；2、将特殊文件进行匿名内存映射，可以为关联进程提供共享内存空间；3、为无关联的进程提供共享内存空间，一般也是将一个普通文件映射到内存中。函数：void *mmap(void *start,size_t l
mmap详解
The time is passing
09-02 1133
  共享内存可以说是最有用的进程间通信方式，也是最快的IPC形式, 因为进程可以直接读写内存，而不需要任何 数据的拷贝。对于像管道和消息队列等通信方式，则需要在内核和用户空间进行四次的数据拷贝，而共享内存则 只拷贝两次数据: 一次从输入文件到共享内存区，另一次从共享内存区到输出文件。实际上，进程之间在共享内 存时，并不总是读写少量数据后就解除映射，有新的通信时，再重新建立共享内存区域。而是...
python中的mmap和array
crazy_fire
04-25 2532
原文链接     需要在Python程序中存取一个很大的数组，数组的每一项是(int, int, float, int)的记录。如果直接用list来存放，占据的内存巨大（因为不仅所有这些数都是对象，且tuple本身也是对象）。Python提供了一个array模块，以更有效地存取数字值，但是它只支持单一的数据类型，例如你无法创建这样的array对象：a = array.array('2lfl'
linux 数组 mmap,使用mmap共享一个结构数组
weixin_39792475的博客
05-16 207
我想创建一个在父进程和子进程之间共享的结构数组。尝试访问阵列数据时出现分段错误。使用mmap共享一个结构数组我觉得这个问题与我使用指针的方式有关，因为这是一个我不太舒服的地方。请注意，我编辑了大部分看起来不相关的代码。/* structure of Registration Table */struct registrationTable{int port;char name[MAXNAME];i...
【Linux】进程间同步（进程间互斥锁、文件锁）
热门推荐
ARRAYLI_博客
12-31 3万+
一、互斥量 mutex         进程间也可以使用互斥锁 ，来达到同步的目的。但应在 pthread_mutex_init 初始化之前，修改其属性为进程间共享。mutex 的属性修改函数主要有以下几个。        主要应用函数：                1、pthread_mutexattr_t   mutexattr 类型： 用于定义互斥锁的属性。            
获取文件属性—stat、lstat、fstat
ARRAYLI_博客
11-14 1万+
一、函数原型                 #include                 #include                 #include                 int stat(const char *path, struct stat *buf);                 int fstat(int fd, struct stat
【Linux】Ubuntu 14.04下搭建 C/C++开发环境
ARRAYLI_博客
11-25 1万+
之前写代码都是在 Windows操作系统下开发程序的，也用过很多编辑器例如 Visual Studio 2015/2013/201/2012,Dev,VC6.0,NetBeans。当然前几个是在Windows下的C++开发环境。最后一个是Java的开发环境。但是，使用Linux搭建C/C++环境，好多人都为配置Ubuntu而烦恼。小编之前使用Linux写程序是在 VirtualBox 下搭建的 C
Linux进程间通信详解：管道、信号、消息队列与共享内存
本文档深入探讨了Linux进程间通信（IPC）的关键概念和技术，涵盖了多个主要的通信机制，包括管道、信号、消息队列、信号量以及共享内存。以下是对每个部分的详细解读： 1. **管道** - 管道是Linux中最基础的IPC手段...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值