Linux进程间通信-内存映射

内存映射（Memory Mapping）是一种高效的文件访问技术，它将文件的一部分或全部映射到进程的地址空间。通过这种方式，文件可以像访问内存一样进行读写操作，这通常由操作系统来管理。内存映射提供了对文件的高效随机访问，并能显著提高大量数据处理的性能。

基本概念

内存映射通过将磁盘上的文件内容映射到进程的虚拟内存区域来工作。这样，对这一内存区域的读写操作将直接影响对文件的读写，无需调用传统的文件I/O函数（如 read() 或 write()）。

使用场景

• 大文件处理：对于需要频繁访问的大型文件，内存映射可以减少读写次数，提高效率。
• 进程间通信：通过映射同一个文件到不同进程的地址空间，多个进程可以通过内存共享数据。

mmap

mmap 函数是一个 UNIX 和类 UNIX 操作系统中的系统调用，用于在进程的虚拟地址空间中创建一个新的映射区域，将文件或其他对象映射到该区域中。

基本语法

#include <sys/mman.h>

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

• addr: 建议映射区的起始地址，通常设置为 NULL，由系统决定。
• length: 映射区的长度，以字节为单位。
• prot: 映射区的保护权限，可以是 PROT_READ（可读）、PROT_WRITE（可写）、PROT_EXEC（可执行）或它们的组合。
• flags: 控制映射区域的行为，如 MAP_SHARED（对映射区的修改会反映到文件上，共享映射）、MAP_PRIVATE（对映射区的修改不会写回文件，而是创建一个私有拷贝）、MAP_FIXED（要求操作系统将映射区域放置在确切的地址）、MAP_ANONYMOUS（创建匿名映射，不映射文件而是分配一段内存）、MAP_LOCKED（锁定映射区域，防止被交换到磁盘）等。
• fd: 文件描述符，用于指定要映射的文件。如果创建匿名映射，则应该将此参数设置为 -1。
• offset: 文件中的偏移量，从该位置开始映射，需要是系统页大小的整数倍。对于匿名映射，通常将此值设置为 0。

返回值

• 成功：返回新映射区域的起始地址。
• 失败：返回 MAP_FAILED（通常为 (void *)-1），并设置全局变量 errno 表示错误类型。

示例

以下示例演示了如何将文件映射到内存，并读取其中的内容：

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

int main() {
    int fd;
    char *mapped;
    struct stat file_stat;

    // 打开文件
    fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // 获取文件大小
    if (fstat(fd, &file_stat) == -1) {
        perror("fstat");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // 映射文件到内存
    mapped = mmap(NULL, file_stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
    if (mapped == MAP_FAILED) {
        perror("mmap");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // 读取并打印文件内容
    printf("File content:\n%s", mapped);

    // 解除映射并关闭文件
    if (munmap(mapped, file_stat.st_size) == -1) {
        perror("munmap");
        close(fd);
        exit(EXIT_FAILURE);
    }
    close(fd);

    return EXIT_SUCCESS;
}

这个示例程序打开一个名为 example.txt 的文件，然后将其映射到内存中并打印文件的内容。最后，解除映射并关闭文件。

munmap

munmap 函数用于撤销通过 mmap 函数创建的内存映射。当一个内存区域不再需要时，应使用 munmap 函数来释放相关资源。这个函数是 UNIX 和类 UNIX 操作系统中的系统调用，常见于高效的文件处理和内存管理程序中。

基本语法

#include <sys/mman.h>

int munmap(void *addr, size_t length);

• addr: 要撤销映射的内存区域的起始地址，这应该是之前 mmap 调用返回的地址。
• length: 要撤销映射的内存区域的长度，通常与原始 mmap 调用时指定的长度相同。

返回值

• 成功：返回 0。
• 失败：返回 -1 并设置 errno 来指示错误原因。

使用示例

在之前的 mmap 示例中，文件被映射到了内存中。使用 munmap 来撤销这个映射看起来如下：

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

int main() {
    int fd;
    char *mapped;
    struct stat file_stat;

    // 打开文件
    fd = open("example.txt", O_RDONLY);
    if (fd == -1) {
        perror("open");
        exit(EXIT_FAILURE);
    }

    // 获取文件大小
    if (fstat(fd, &file_stat) == -1) {
        perror("fstat");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // 映射文件到内存
    mapped = mmap(NULL, file_stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
    if (mapped == MAP_FAILED) {
        perror("mmap");
        close(fd);
        exit(EXIT_FAILURE);
    }

    // 读取并打印文件内容
    printf("File content:\n%s", mapped);

    // 解除映射并关闭文件
    if (munmap(mapped, file_stat.st_size) == -1) {
        perror("munmap");
        close(fd);
        exit(EXIT_FAILURE);
    }
    close(fd);

    return EXIT_SUCCESS;
}

在这个示例中，munmap 被用于在打印完文件内容后释放映射的内存区域。正确地调用 munmap 是很重要的，因为它确保了不再需要的内存得到释放，避免内存泄露。

/*
    #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.有关系的进程（父子进程）
        - 还没有子进程的时候
            - 通过唯一的父进程，先创建内存映射区
        - 有了内存映射区以后，创建子进程
        - 父子进程共享创建的内存映射区
    
    2.没有关系的进程间通信
        - 准备一个大小不是0的磁盘文件
        - 进程1 通过磁盘文件创建内存映射区
            - 得到一个操作这块内存的指针
        - 进程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>

// 作业:使用内存映射实现没有关系的进程间的通信。
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.如果对mmap的返回值(ptr)做++操作(ptr++), munmap是否能够成功?
void * ptr = mmap(…);
ptr++; 可以对其进行++操作
munmap(ptr, len); // 错误,要保存地址

2.如果open时O_RDONLY, mmap时prot参数指定PROT_READ | PROT_WRITE会怎样?
错误，返回MAP_FAILED
open()函数中的权限建议和prot参数的权限保持一致。

3.如果文件偏移量为1000会怎样?
偏移量必须是4K的整数倍，返回MAP_FAILED

4.mmap什么情况下会调用失败?
- 第二个参数：length = 0
- 第三个参数：prot
- 只指定了写权限
- prot PROT_READ | PROT_WRITE
第5个参数fd 通过open函数时指定的 O_RDONLY / O_WRONLY

5.可以open的时候O_CREAT一个新文件来创建映射区吗?
- 可以的，但是创建的文件的大小如果为0的话，肯定不行
- 可以对新的文件进行扩展
- lseek()
- truncate()

6.mmap后关闭文件描述符，对mmap映射有没有影响？
int fd = open(“XXX”);
mmap(,fd,0);
close(fd);
映射区还存在，创建映射区的fd被关闭，没有任何影响。

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

通过内存映射进行文件拷贝

// 使用内存映射实现文件拷贝的功能
/*
    思路：
        1.对原始的文件进行内存映射
        2.创建一个新文件（拓展该文件）
        3.把新文件的数据映射到内存中
        4.通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中
        5.释放资源
*/
#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;
}

匿名映射

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

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