Chinaunix首页 | 论坛 | 博客

RoadLee

首页　| 　博文目录　| 　关于我

Roadlee

  • 博客访问： 43062
  • 博文数量： 14
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 165
  • 用 户 组： 普通用户
  • 注册时间： 2022-11-22 23:41
个人简介

将分享技术博文作为一种快乐，提升自己帮助他人

文章分类

全部博文（14）

文章存档

2023年（9）

2022年（5）

我的朋友
最近访客
推荐博文
相关博文
进程间通信(六)：共享内存之POSIX mmap文件映射和memfd_create匿名文件共享

分类： LINUX

2023-05-11 23:57:43

研读DPDK框架代码时，发现有多处用到mmap和memfd_create()调用进行内存共享。若想深入理解这些功能代码，就很有两必要了解这种内存共享的实现方式。以下是对POSIX mmap文件映射和memfd_create()+fd跨进程共享的总结介绍。

一、POSIX mmap文件

POSIX open()/shm_open()，mmap文件来共享内存的使用方式比SYS V中的那些ftok、shmget、shmat、shmdt、shmctl等系列API，更方便，更易使用。

以下两个小程序，分别完成数据的写和读操作。

写端：

点击(此处)折叠或打开

  1. #include <sys/mman.h>
  2. #include <sys/stat.h> /* For mode constants */
  3. #include <fcntl.h> /* For O_* constants */
  4. #include <unistd.h>
  5. #include <stdio.h>

  7. #define SHARE_MEMORY_NAME    "POSIX_SHM"

  9. typedef struct {
  10.     int data1;
  11.     int data2;
  12.     int data3;
  13.     int data4;
  14. } share_data;

  16. int main(void)
  17. {
  18.     share_data *sdata;
  19.     int fd;

  21.     shm_unlink(SHARE_MEMORY_NAME);
  22.     fd = shm_open(SHARE_MEMORY_NAME, O_RDWR | O_CREAT, 0666);
  23.     if (fd == -1) {
  24.         printf("create posix shared memory failed.\n");
  25.         return -1;
  26.     }
  27.     ftruncate(fd, sizeof(share_data));

  29.     sdata = mmap(NULL, sizeof(share_data),
  30.          PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  31.     if (sdata == MAP_FAILED) {
  32.         printf("mmap failed\n");
  33.         return -1;
  34.     }

  36.     sdata->data1 = 12;
  37.     sdata->data2 = 13;
  38.     sdata->data3 = 14;
  39.     sdata->data4 = 15;
  40.     munmap(sdata, sizeof(share_data));

  42.     return 0;
  43. }
读端：

点击(此处)折叠或打开

  1. #include <sys/mman.h>
  2. #include <sys/stat.h> /* For mode constants */
  3. #include <fcntl.h> /* For O_* constants */
  4. #include <stdio.h>
  5. #include <unistd.h>

  7. #define SHARE_MEMORY_NAME    "POSIX_SHM"

  9. typedef struct {
  10.     int data1;
  11.     int data2;
  12.     int data3;
  13.     int data4;
  14. } share_data;

  16. int main(void)
  17. {
  18.     share_data *sdata;
  19.     int fd;

  21.     fd = shm_open(SHARE_MEMORY_NAME, O_RDONLY, 0666);
  22.     if (fd == -1) {
  23.         printf("open posix shared memory failed.\n");
  24.         return -1;
  25.     }
  26.     ftruncate(fd, sizeof(share_data));

  28.     sdata = mmap(NULL, sizeof(share_data), PROT_READ, MAP_SHARED, fd, 0);
  29.     if (sdata == MAP_FAILED) {
  30.         printf("mmap failed\n");
  31.         return -1;
  32.     }

  34.     printf("share memory: data1=%d, data2=%d, data3=%d, data4=%d\n",
  35.         sdata->data1, sdata->data2, sdata->data3, sdata->data4);
  36.     munmap(sdata, sizeof(share_data));

  38.     return 0;
  39. }
编译和执行结果：

读端程序，获取到的数据为写端程序所写入的值。
运行完后，会在/dev/shm/、/run/shm下面看到一个文件：

POSIX mmap方式，读写进程通过打开相同路径下的文件，得到共享文件的fd，再通过ftruncate()设置共享文件的大小，使用mmap的方式进行文件映射到进程得到进程中的虚拟地址 ，进程通过直接操作虚拟地址从而操作共享内存。以上生成的文件在OS中都有具体的文件名。

二、memfd_create匿名文件

使用memfd_create()不同于open()或者shm_open()，它会创建一个匿名文件，在OS下没有确切的文件，而是存在于RAM中。该调用会返回一个可引用的文件描述符，可进行类似于regular文件的操作。它的manual page描述如下图：

注意其中的描述，当所有的引用关闭后，它将自动释放。
当进行Linux应用编程时，需要一个fd类似于文件操作，但又不希望文件系统中可见，此时就可以使用memfd_create的方式。

有了这个指向的匿名内存的文件描述符，再加上UNIX Socket的控制消息cmsg，将此文件描述符传递给另外一个不相关的进程(可支持多个fd的传输)。从而另外一个进程对该fd进行mmap操作就得共享内存的虚拟地址，如此就可实现内存的共享。

使用UNIX Socket的控制消息传送多个描述符实现：
发送多个描述符接口：

接收多个描述符的接口：

注意：进程透过UNIX Socket把一个或多个fds发送给另一个进程。fd是一个进程级的概念，每个进程有自己的fds列表。当使用cmsg传递文件描述符时，若传送的文件描述符在另一个进程中已被占用，则该文件描述符可能会变成另一个未使用的文件描述符，其同样与该匿名内存关联。

memfd_create()+fd跨进程共享实操

共享内存写端：shmfd_create_write.c

点击(此处)折叠或打开

  1. #define _GNU_SOURCE

  3. #include <sys/mman.h>
  4. #include <sys/syscall.h>
  5. #include <linux/memfd.h>
  6. #include <sys/socket.h>
  7. #include <sys/un.h>

  9. #include <fcntl.h> /* For O_* constants */
  10. #include <unistd.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <stdio.h>


  16. #define SHARE_MEMORY_NAME1    "MEMFD_SHM1"
  17. #define SHARE_MEMORY_NAME2    "MEMFD_SHM2"

  19. #define SOCKET_PATH "my-socket"


  22. typedef struct {
  23.     int data1;
  24.     int data2;
  25.     int data3;
  26.     int data4;
  27. } share_data;

  29. static int send_fd(int socket, int *fds, int n)
  30. {
  31.     char buf[CMSG_SPACE(n * sizeof(int))];
  32.     struct msghdr msg = {0};
  33.     struct cmsghdr *cmsg;
  34.     struct iovec io[2];
  35.     char data[2];

  37.     io[0].iov_base = &data[0];
  38.     io[0].iov_len = sizeof(char);
  39.     io[1].iov_base = &data[1];
  40.     io[1].iov_len = sizeof(char);
  41.     msg.msg_iov = io;
  42.     msg.msg_iovlen = 2;

  44.     /* TCP时name为NULL，长度为0，数据报套接字UDP需填充 */
  45.     msg.msg_name = NULL;
  46.     msg.msg_namelen = 0;
  47.     /*设置缓冲区和长度*/
  48.     msg.msg_control = buf;
  49.     msg.msg_controllen = sizeof(buf);

  51.     cmsg = CMSG_FIRSTHDR(&msg);
  52.     cmsg->cmsg_level = SOL_SOCKET;
  53.     cmsg->cmsg_type = SCM_RIGHTS; // 指明发送的消息类型为描述符
  54.     cmsg->cmsg_len = CMSG_LEN(n * sizeof(int));

  56.     memcpy((int *)CMSG_DATA(cmsg), fds, n * sizeof(int));

  58.     if (sendmsg(socket, &msg, 0) < 0) {
  59.         printf("send msg failed\n");
  60.         return -1;
  61.     }

  63.     return 0;
  64. }

  66. int main(void)
  67. {
  68.     struct sockaddr_un addr = {0};
  69.     share_data *sdata;
  70.     int sfd, fd[2];
  71.     int ret;

  73.     fd[0] = syscall(__NR_memfd_create, SHARE_MEMORY_NAME1, MFD_CLOEXEC);
  74.     if (fd[0] == -1) {
  75.         printf("open posix shared memory failed.\n");
  76.         return -1;
  77.     }
  78.     ftruncate(fd[0], sizeof(share_data));
  79.     fd[1] = syscall(__NR_memfd_create, SHARE_MEMORY_NAME2, MFD_CLOEXEC);
  80.     if (fd[1] == -1) {
  81.         printf("open posix shared memory failed.\n");
  82.         return -1;
  83.     }

  85.     sdata = mmap(NULL, sizeof(share_data),
  86.          PROT_READ | PROT_WRITE, MAP_SHARED, fd[0], 0);
  87.     if (sdata == MAP_FAILED) {
  88.         printf("mmap failed\n");
  89.         return -1;
  90.     }

  92.     sdata->data1 = 125;
  93.     sdata->data2 = 130;
  94.     sdata->data3 = 140;
  95.     sdata->data4 = 150;

  97.     sfd = socket(AF_UNIX, SOCK_STREAM, 0);
  98.     if (sfd == -1) {
  99.         printf("create socket failed\n");
  100.         return -1;
  101.     }
  102.     printf("cfd=%d fd[0]=%d fd[1]=%d\n", sfd, fd[0], fd[1]);
  103.     addr.sun_family = AF_UNIX;
  104.     strcpy(addr.sun_path, SOCKET_PATH);

  106.     ret = connect(sfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_un));
  107.     if (ret == -1) {
  108.         printf("connect error\n");
  109.         return -1;
  110.     }

  112.     if (send_fd(sfd, fd, 2) < 0) {
  113.         printf("send fds failed\n");
  114.         return -1;
  115.     }

  117.     munmap(sdata, sizeof(share_data));

  119.     return 0;
  120. }
共享内存读端：shmfd_create_read.c

点击(此处)折叠或打开

  1. #define _GNU_SOURCE

  3. #include <sys/mman.h>
  4. #include <sys/syscall.h>
  5. #include <linux/memfd.h>
  6. #include <sys/socket.h>
  7. #include <sys/un.h>

  9. #include <fcntl.h> /* For O_* constants */
  10. #include <unistd.h>
  11. #include <stdlib.h>
  12. #include <string.h>
  13. #include <stdio.h>


  16. #define SHARE_MEMORY_NAME    "MEMFD_SHM"
  17. #define SOCKET_PATH "my-socket"

  19. typedef struct {
  20.     int data1;
  21.     int data2;
  22.     int data3;
  23.     int data4;
  24. } share_data;

  26. static int* recv_fd(int socket, int n)
  27. {
  28.     char buf[CMSG_SPACE(n * sizeof(int))];
  29.     struct msghdr msg = {0};
  30.     struct cmsghdr *cmsg;
  31.     struct iovec io;
  32.     char data[2];
  33.     int *fds;

  35.     io.iov_base = data;
  36.     io.iov_len = 1;

  38.     msg.msg_iov = &io;
  39.     msg.msg_iovlen = 1;
  40.     msg.msg_control = buf;
  41.     msg.msg_controllen = sizeof(buf);

  43.     if (recvmsg(socket, &msg, 0) < 0) {
  44.         printf("failed to receive messag\n");
  45.         return NULL;
  46.     }
  47.     cmsg = CMSG_FIRSTHDR(&msg);

  49.     fds = calloc(n, sizeof(int));
  50.     memcpy(fds, (int *)CMSG_DATA(cmsg), n * sizeof(int));

  52.     return fds;
  53. }

  55. static int create_socket(void)
  56. {
  57.     struct sockaddr_un addr = {0};
  58.     int sfd;

  60.     sfd = socket(AF_UNIX, SOCK_STREAM, 0);
  61.     if (sfd == -1) {
  62.         printf("create socket failed\n");
  63.         return -1;
  64.     }

  66.     unlink(SOCKET_PATH);
  67.     memset(&addr, 0, sizeof(struct sockaddr_un));
  68.     addr.sun_family = AF_UNIX;
  69.     strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path) - 1);

  71.     if (bind(sfd, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) == -1) {
  72.         printf("failed to bind socket\n");
  73.         return -1;
  74.     }

  76.     if (listen(sfd, 5) == -1) {
  77.         printf("failed to listen socket.");
  78.         return -1;
  79.     }

  81.     return sfd;
  82. }

  84. int main(void)
  85. {
  86.     share_data *sdata;
  87.     int sfd, cfd;
  88.     int *fd;

  90.     sfd = create_socket();
  91.     if (sfd == -1) {
  92.         printf("create socket failed\n");
  93.         return -1;
  94.     }
  95.     cfd = accept(sfd, NULL, NULL);
  96.     if (cfd == -1) {
  97.         printf("accept fd failed\n");
  98.         return -1;
  99.     }

  101.     printf("cfd=%d\n", cfd);
  102.     fd = recv_fd(cfd, 2);
  103.     if (fd == NULL) {
  104.         printf("receive fds failed\n");
  105.         return -1;
  106.     }

  108.     sdata = mmap(NULL, sizeof(share_data), PROT_READ, MAP_SHARED, fd[0], 0);
  109.     if (sdata == MAP_FAILED) {
  110.         printf("mmap failed\n");
  111.         return -1;
  112.     }

  114.     printf("fd[1]=%d, fd[1]=%d\n", fd[0], fd[1]);
  115.     printf("share memory from fd[0]=%d: data1=%d, data2=%d, data3=%d, data4=%d\n",
  116.         fd[0], sdata->data1, sdata->data2, sdata->data3, sdata->data4);

  118.     close(cfd);
  119.     munmap(sdata, sizeof(share_data));
  120.     free(fd);

  122.     return 0;
  123. }
编译：
gcc memfd_create_write.c -o memfd_w
gcc memfd_create_read.c -o memfd_r


先运行读端，创建socket，再运行写端，写端向共享memory写入125、120、140和150。读端再从共享memory中读取数据，读取的结果为写进程的数据。


阅读(2359) | 评论(0) | 转发(0) |
0

上一篇：Linux进程间通信（五）：共享内存 shmget()、shmat()、shmdt()、shmctl()

下一篇：没有了

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6