【项目进程8】 2.17 内存映射（1） 2.18内存映射（2）

文章目录

- 2.17 内存映射（1）
- - 内存映射
  - 内存映射相关系统调用
  - 使用内存映射实现父子进程间通信
  - 使用内存映射实现没有关系的进程间的通信
- 2.18内存映射（2）
- - 内存映射的注意事项
  - 使用内存映射实现内存拷贝的功能
  - 匿名映射

2.17 内存映射（1）

内存映射

在这里插入图片描述 mmap()函数的作用就是建立一个映射关系，它将文件在磁盘上的一段连续存储空间与进程的一段连续虚拟地址空间建立一对一的对应关系，然后返回这段虚拟地址空间的首地址。

所以，当你使用mmap()对一个文件进行映射时，addr是映射区的起始地址，这个地址是在进程的虚拟地址空间内的，不是文件在磁盘或者内存上的实际物理地址。当你访问这个地址区间时，操作系统负责将你的访问请求转换为对应文件在磁盘上的位置的访问。

这就是为什么你可以将mmap()返回的地址当作一个指向文件内容的指针来使用。你的进程实际上是在访问自己的虚拟地址空间，而操作系统将这些访问转换为对文件内容的访问。

同样地，对于匿名映射（没有关联的文件），mmap()函数返回的还是在进程的虚拟地址空间中的一个地址，而这个地址对应的实际内存存储位置由操作系统管理。当你访问这个地址时，你实际上是在访问一块物理内存，操作系统负责为你管理这个过程。

内存映射相关系统调用

在这里插入图片描述

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写时拷贝，同fork()函数）
        - fd: 需要映射的那个文件的文件描述符
            - 通过open得到，open的是一个磁盘文件
            - 注意：文件的大小不能为0，open指定的权限不能和prot参数有冲突。(open时候的权限要大于等于port的)
                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.有关系的进程（父子进程）
-还没有子进程的时候：通过唯一的父进程，先创建内存映射区

有了内存映射区以后，创建子进程
父子进程共享创建的内存映射区

#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);  //nihao a, son!!!
       
    }else if(pid == 0){
        // 子进程写数据
        strcpy((char *)ptr, "nihao a, son!!!");
    }

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

    return 0;
}

当子进程使用strcpy((char *)ptr, "nihao a, son!!!");时，这行代码将字符串 “nihao a, son!!!” 复制到了映射区域的开始位置。由于映射区域是映射到物理内存的文件test.txt，所以文件的内容也会被修改。
当父进程使用strcpy(buf, (char *)ptr);时，这行代码尝试将映射区域开始的内容复制到buf中。这个复制操作会在遇到第一个 null 字符（\0）时停止。
由于strcpy()函数在复制字符串 “nihao a, son!!!” 时会在末尾添加一个 null 字符（\0），所以当父进程读取字符串时，它只会读取到 “nihao a, son!!!”，并在此处停止，而不会继续读取后面的内容。

在C语言中，字符串以 null 字符（\0）结尾，当strcpy()遇到这个字符时，它会认为字符串已经结束，所以不会读取之后的内容，而与空格无关。所以，父进程只会读取到 “nihao a, son!!!”，并不会继续读取之后的 “hellohellohello”。

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

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.进程1通过磁盘文件创建内存映射区，得到一个操作这块内存的指针
    void *ptr1 = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(ptr1 == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    // 3.进程2通过磁盘文件创建内存映射区，得到一个操作这块内存的指针
    void *ptr2 = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if(ptr2 == MAP_FAILED) {
        perror("mmap");
        exit(0);
    }

    // 4.使用内存映射区通信：进程1写数据，进程2读数据
    strcpy((char *)ptr1, "nihao ,mmap_ipc!!!");

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

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

    return 0;
}

2.18内存映射（2）

内存映射的注意事项

1、如果对mmap的返回值(ptr)做++操作(ptr++), munmap是否能够成功?
void * ptr = mmap(…);
ptr++; 可以对其进行++操作，不建议
munmap(ptr, len); // 错误,要保存内存首地址类比：new/delete

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

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

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

第二个参数：length = 0
第三个参数：prot
只指定了写权限
prot PROT_READ | PROT_WRITE
第5个参数fd 通过open函数时指定的 O_RDONLY / O_WRONLY
-偏移量不是4KB的整数倍

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，…);长度为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);
  // lseek(fd1,len,SEEK_END)
  // write(fd1, " ", 1);//写入一个空数据 没必要
  // trncate 已经拓展了文件大小，而lseek只是移动了文件指针，并没有实际拓展，所以才需要写一个空字节

    // 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.创建匿名内存映射区，MAP_ANONYMOUS：匿名映射
    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;
}