浅谈内存映射

CV发烧友

已于 2022-06-23 16:16:04 修改

阅读量4k

点赞数 4

CC 4.0 BY-SA版权

分类专栏： Linux 文章标签： servlet java 开发语言

于 2022-06-23 16:03:39 首次发布

本文链接：https://blog.youkuaiyun.com/Boss_peng/article/details/125419791

Linux 专栏收录该内容

13 篇文章

订阅专栏

本文深入探讨内存映射的概念，阐述其在进程间通信、文件复制等方面的应用，并讲解相关API和注意事项，包括父子进程通信、不同进程通信及文件拷贝的实例。同时，讨论了匿名映射的特点和限制。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、概念

内存映射（ Memory mapped I/O ）是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件（修改内存的同时，磁盘文件也会发生相同修改）。如下图所示，

二、内存映射的作用

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

1.有关系的进程（父子进程）
- 还没有子进程的时候
        - 通过唯一的父进程，先创建内存映射区
- 有了内存映射区以后，创建子进程
- 父子进程共享创建的内存映射区

2.没有关系的进程间通信
- 准备一个大小不是0的磁盘文件
- 进程1 通过磁盘文件创建内存映射区
        - 得到一个操作这块内存的指针
- 进程2 通过磁盘文件创建内存映射区
        - 得到一个操作这块内存的指针
- 使用内存映射区通信

注意：内存映射区通信，是非阻塞。

使用内存映射实现文件复制的功能

思路：

1.对原始的文件进行内存映射
2.创建一个新文件（拓展该文件）
3.把新文件的数据映射到内存中
4.通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中
5.释放资源

三、相关API

内存映射的实现过程主要是通过 Linux 系统下的系统调用函数：mmap（）

#include <sys/mman.h>

void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);
    - 功能：将一个文件或者设备的数据映射到内存中
    - 参数：
        - void *addr: NULL, 由内核指定
        - length : 要映射的数据的长度，这个值不能为0。建议使用文件的长度。
                   获取文件的长度：stat 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参数有冲突。
                prot: PROT_READ                open:只读/读写 
                prot: PROT_READ | PROT_WRITE   open:读写
        - offset：偏移量，一般不用。必须指定的是4k的整数倍，0表示不便宜。
    - 返回值：返回创建的内存的首地址
        失败返回MAP_FAILED，即(void *) -1

int munmap(void *addr, size_t length);
    - 功能：释放内存映射
    - 参数：
        - addr : 要释放的内存的首地址
        - length : 要释放的内存的大小，要和mmap函数中的length参数的值一样。

四、案例

1、使用内存映射实现父子进程之间的通信

/**************** 子进程写数据，父进程读数据 ********************/
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!!!");
    }

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

    return 0;
}

注：1、没有 wait(NULL) 也不一定是父进程优先，这个有进程竞争，谁竞争到谁先，所以父进程和子进程谁先执行都有可能。加了 wait(NULL) 之后，父进程被阻塞，只有当子进程执行完，父进程才能够执行，所以这种情况下是先 son 后 parent

2、text.c 文件随意；

2、使用内存映射实现不同进程之间的通信

#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>

void Process1(){
    // 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);
    }

    strcpy((char *)ptr, "nihao a, son!!!");

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

void Process2(){
    // 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);
    }

    char buf[64];
    strcpy(buf, (char *)ptr);
    printf("read data : %s\n", buf);

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

int main(){
    Process1();
    Process2();
    return 0;
}

注：主要是利用 “ 内存映射，改变内存的同时会改变磁盘文件 ”，然后进程 2 将磁盘文件映射到内存时，打印的就是改变后的文件内容；

3、使用内存映射实现文件拷贝的功能

#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>

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("cpy.txt", O_RDWR | O_CREAT, 0664);
    if(fd1 == -1) {
        perror("open");
        exit(0);
    }
    
    // 对新创建的文件进行拓展
    truncate("cpy.txt", len);
    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 的返回值 (ptr) 做 ++ 操作 (ptr++), munmap 是否能够成功?

void * ptr = mmap(...);
ptr++; 可以对其进行++操作
munmap(ptr, len); // 错误，要保存++前的地址

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

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

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

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

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

- 第二个参数：length = 0
- 第三个参数：prot
- 只指定了写权限
- prot PROT_READ | PROT_WRITE
第 5 个参数 fd 通过 open 函数时指定的 O_RDONLY / O_WRONLY

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

- 可以的，但是创建的文件的大小如果为 0 的话，肯定不行
- 可以对新的文件进行扩展
- lseek()
- truncate()

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

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

对 ptr 越界操作会怎样？

void * ptr = mmap(NULL, 100,,,,,);
4K
越界操作操作的是非法的内存 -> 段错误

六、匿名映射

上面的映射指的是文件映射，即将文件映射到内存。匿名影射是不需要文件实体进程的一个内存映射。匿名影射只能做父子进程间的通信，不能做不同进程间的通信。

#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;
}