内存映射（Memory-mapped I/O）实现进程间通信和文件拷贝

傲慢与偏见L

已于 2023-12-18 15:43:39 修改

阅读量1.1k

点赞数 23

文章标签：算法 linux

于 2023-12-17 17:05:10 首次发布

本文链接：https://blog.csdn.net/qq_45586192/article/details/134599168

版权

基本概念

内存映射（Memory-mapped I/O）是将磁盘文件中的数据映射到内存中，用户通过修改内存就能够修改磁盘文件。

使用内存映射实现进程之间的通信，1和2表示进程的虚拟地址空间（存在于内存中），这两个进程与同一个磁盘文件建立联系既可以实现两个进程之间的通信。

mmap和munmap函数

可以通过命令 man 2 mmap 查看mmap函数的描述。

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

功能：将磁盘中的一个文件或者设备映射到内存中。

参数：

void *addr: 映射到内存空间中的首地址，通常传入NULL，由操作系统内核指定；

length： 要映射的数据的长度，这个值不能为0，通常使用文件的长度。（可以通过lseek函数获取）；

prot: 对申请的内存映射区的操作权限，通常有以下几种形式：

-PROT_EXEC ：可执行的权限

-PROT_READ ：读权限

-PROT_WRITE ：写权限

-PROT_NONE ：没有权限

要操作所映射的内存空间，必须要有读的权限。比如：PROT_READ和PROT_READ|PROT_WRITE;

flags:

- MAP_SHARED : 内存映射区的数据会自动地和磁盘文件进行同步，进程间通信，必须要设置这个选项。

- MAP_PRIVATE ：不同步，内存映射区的数据改变了，对原来的磁盘文件不会修改，会重新创建一个新的文件。（copy on write）；

fd: 映射到内存中的那个磁盘中的文件的文件描述符，这个文件描述符使用open函数获得，当然，open的是一个磁盘中的文件。

需要注意的是，文件的大小不能为0，open指定的文件权限不能和prot指定的权限有冲突。通常来讲，port的权限小于等于open的权限，比如：

prot: PROT_READ open:只读/读写

prot: PROT_READ | PROT_WRITE open:读写

offect： 偏移量，一般不用。必须指定的是4k的整数倍，0表示不偏移。

函数返回值

创建成功返回创建的内存的首地址

失败则返回一个宏值MAP_FAILED，它是-1强转成void*类型。

int munmap(void *addr, size_t length);

功能：释放由mmap函数创建的内存映射

参数：

addr : 要释放的内存的首地址；

length : 要释放的内存的大小，要和mmap函数中的length参数的值一样。

返回值：

成功返回0，失败返回-1，并设置errno。

使用内存映射实现进程之间的通信

父子进程之间的通信

还没有子进程的时候，通过唯一的父进程先创建出内存映射区。

有了内存映射区以后，通过fork函数创建子进程，实现子进程写，父进程读。

测试代码：

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

int main() {

    // 1.打开一个文件
    int fd = open("test.txt", O_RDWR);
    int size = lseek(fd, 0, SEEK_END);  // 获取文件的大小

    // 2.创建内存映射区
    void *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(ptr == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    // 3.创建子进程，共享父进程的内存映射区
    pid_t pid = fork();
    if(pid > 0) {
        wait(NULL);  //阻塞等待子进程写入
        // 父进程读
        char buf[64];
        strcpy(buf, (char *)ptr);
        printf("read data : %s\n", buf);
       
    }else if(pid == 0){
        // 子进程写
        strcpy((char *)ptr, "nihao a, son!!!");  //per为void*类型，强制转成char*类型 Copy SRC to DEST.
    }

    // 关闭内存映射区
    munmap(ptr, size);

    return 0;
}

test.txt中的数据原来是：

运行测试代码之后，再一次查看：

内存映射实现没有关系的进程间的通信

首先创建一个大小不是0的磁盘文件，test2.txt，里面的内容如下，就是有好多hello：

进程1和进程2 通过于这个磁盘文件建立联系来实现通信。

执行写进程，打开test2.txt发现内容已经写进去了；

执行读进程，发现可以正常输出内容：

mmap-ipc-write.c代码：

//向内存映射区写入的进程
#include <stdio.h> //perror

#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h> //open

#include <sys/mman.h> //mmap

#include <unistd.h> //lseek  +<sys/types.h>

#include <stdlib.h> //exit

#include <string.h>

int main()

{
    int fd = open("test2.txt", O_RDWR);  //打开磁盘中的文件获取到文件的描述符
    if (fd == -1)
    {
        perror("open");
        exit(0);
    }

    //获取文件大小
    int size = lseek(fd, 0, SEEK_END);

    //创建内存映射区
    void *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (ptr == MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }
    
    //写数据
    strcpy((char *)ptr, "nihao,123456");

    close(fd);

    return 0;
}

mmap-ipc-read.c代码

//从内存映射区读数据的进程
#include <stdio.h> //perror

#include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h> //open

#include <sys/mman.h> //mmap

#include <unistd.h> //lseek  +<sys/types.h>

#include <stdlib.h> //exit

#include <string.h>

int main()

{
    int fd = open("test2.txt", O_RDWR);  //打开磁盘中的文件获取到文件的描述符
    if (fd == -1)
    {
        perror("open");
        exit(0);
    }

    //获取文件大小
    int size = lseek(fd, 0, SEEK_END);

    //创建内存映射区
    void *ptr = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (ptr == MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }
    
    //读数据
    char buf[128];
    strcpy(buf, (char *)ptr);
    printf("the read data: %s\n", buf);

    //关闭内存映射区
    munmap(ptr, size);

    close(fd);

    return 0;
}

内存映射的注意事项

1. 如果对mmap的返回值（void *ptr）做++操作（ptr++），munmap是否能够成功？

void *ptr = mmap(...);

prt++;

可以对per进行++操作，但是在调用munmap的时候，munmap(ptr, len)会出现错误，需要将第一次的首地址进行保存，然后调用munmap的时候传入这个保存的首地址。

2. 如果open时O_RDONLY, mmap时prot参数指定PROT_READ | PROT_WRITE会怎样?

返回 MAP_FAILED错误，open()函数中的权限建议和prot参数的权限保持一致。

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

偏移量必须是4K的整数倍，返回MAP_FAILED。

4. mmap调用失败的其他情况?

-第二个参数length为0

-prot只写了写权限，没有读权限

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

可以的，但是创建的文件的大小如果为0的话，肯定不行，可以对新的文件进行扩展，比如使用lseek函数和truncate函数。

6. mmap后关闭文件描述符，对mmap映射有没有影响？

int fd = open("XXX");
mmap(,,,,fd,0);
close(fd);
映射区还存在，创建映射区的fd被关闭，没有任何影响。mmap会对fd进行拷贝

7. 对ptr越界操作会怎样？

越界操作的是非法内存，产生段错误。

使用内存映射实现文件的拷贝

要求：使用内存映射将一个文件a.txt中的内容拷贝到b.txt中

步骤：

1.对原始的a.txt文件进行内存映射

2.创建一个新的文件b.txt并进行扩展

3.对新文件b.txt进行内存映射

4.通过内存拷贝函数memcpy将第一个文件的内存数据拷贝到新的内存文件中

5.释放资源

测试代码：

// 使用内存映射实现文件拷贝的功能
#include <stdio.h>
#include <sys/mman.h>  //mmap

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>  //open

#include <unistd.h> //lseek
#include <string.h> //memopy
#include <stdlib.h> //exit

int main() {

    // 1.对原始的文件进行内存映射
    int fd = open("english.txt", O_RDWR);
    if(fd == -1) {
        perror("open");
        exit(0);
    }

    // 获取原始文件的大小
    int len = lseek(fd, 0, SEEK_END);

    // 2.创建一个新文件（拓展该文件）
    int fd1 = open("copy.txt", O_RDWR | O_CREAT, 0664);
    if(fd1 == -1) {
        perror("open");
        exit(0);
    }
    
    // 对新创建的文件进行拓展 truncate和lseek函数都可以，扩展后要写入一个空数据才能成功
    //truncate("copy.txt", len);

    int len1 = lseek(fd1, len, SEEK_END);
    write(fd1, " ", 1);

    // 3.分别做内存映射
    void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    void * ptr1 = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd1, 0);

    if(ptr == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    if(ptr1 == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    // 内存拷贝
    memcpy(ptr1, ptr, len);
    
    // 释放资源
    munmap(ptr1, len);
    munmap(ptr, len);

    close(fd1);
    close(fd);

    return 0;
}

匿名映射

之前都是通过一个磁盘文件创建内存映射，现在，不需要文件实体，也可以创建一个内存映射。

通过匿名映射实现父子进程之间的通信：

主要区别就是在mmap函数中，flags参数要写成MAP_SHARED | MAP_ANONYMOUS。此外由于没有文件实体，文件描述符通常写成-1，偏移量为0。

测试代码：

/*
    匿名映射：不需要文件实体进程一个内存映射
*/

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

int main() {

    // 1.创建匿名内存映射区
    int len = 4096;
    void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if(ptr == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    // 父子进程间通信
    pid_t pid = fork();

    if(pid > 0) {
        // 父进程
        strcpy((char *) ptr, "hello, world");
        wait(NULL);  //回收子进程的资源
    }else if(pid == 0) {
        // 子进程
        sleep(1);
        printf("%s\n", (char *)ptr);
    }

    // 释放内存映射区
    int ret = munmap(ptr, len);

    if(ret == -1) {
        perror("munmap");
        exit(0);
    }
    return 0;
}

执行成功终端输出hello world。