mmap

---

title: mmap
date: 2021-07-03 00:52:17
tags: [Linux, C++]

---

mmap

mmap 基础概念

mmap 是一种磁盘文件映射的方法。即将一个文件或者其它对象映射到进程的地址空间，实现文件磁盘地址和进程虚拟地址空间中一段虚拟地址的一一对映关系。实现这样的映射关系后，进程就可以采用指针的方式读写操作这一段内存，而系统会自动回写脏页面到对应的文件磁盘上，即完成了对文件的操作而不必再调用 read，write 等系统调用函数。相反，内核空间对这段区域的修改也直接反映用户空间，从而可以实现不同进程间的文件共享。

mmap内存映射原理

mmap内存映射的实现过程，总的来说可以分为三个阶段：

（一）进程启动映射过程，并在虚拟地址空间中为映射创建虚拟映射区域

• 进程在用户空间调用库函数 mmap

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

• 在当前进程的虚拟地址空间中，寻找一段空闲的满足要求的连续的虚拟地址

• 为此虚拟区分配一个 vm_area_struct 结构，接着对这个结构的各个域进行了初始化

• 将新建的虚拟区结构 vm_area_struct 插入进程的虚拟地址区域链表或树中

（二）调用内核空间的系统调用函数 mmap（不同于用户空间函数），实现文件物理地址和进程虚拟地址的一一映射关系

• 为映射分配了新的虚拟地址区域后，通过待映射的文件指针，在文件描述符表中找到对应的文件描述符，通过文件描述符，链接到内核已打开文件集中该文件的文件结构体（struct file），每个文件结构体维护着和这个已打开文件相关各项信息。

• 通过该文件的文件结构体，链接到 file_operations 模块，调用内核函数 mmap

  int mmap(struct file *filp, struct vm_area_struct *vma) // 不同于用户空间库函数。
  

• 内核 mmap 函数通过虚拟文件系统 inode 模块定位到文件磁盘物理地址。

• 通过 remap_pfn_range 函数建立页表，即实现了文件地址和虚拟地址区域的映射关系。此时，这片虚拟地址并没有任何数据关联到主存中。

（三）进程发起对这片映射空间的访问，引发缺页异常，实现文件内容到物理内存（主存）的拷贝

注：前两个阶段仅在于创建虚拟区间并完成地址映射，但是并没有将任何文件数据的拷贝至主存。真正的文件读取是当进程发起读或写操作时。

• 进程的读或写操作访问虚拟地址空间这一段映射地址，通过查询页表，发现这一段地址并不在物理页面上。因为目前只建立了地址映射，真正的硬盘数据还没有拷贝到内存中，因此引发缺页异常。
• 缺页异常进行一系列判断，确定无非法操作后，内核发起请求调页过程。
• 调页过程先在交换缓存空间（swap cache）中寻找需要访问的内存页，如果没有则调用 nopage 函数把所缺的页从磁盘装入到主存中。
• 之后进程即可对这片主存进行读或者写的操作，如果写操作改变了其内容，一定时间后系统会自动回写脏页面到对应磁盘地址，也即完成了写入到文件的过程。

注：修改过的脏页面并不会立即更新回文件中，而是有一段时间的延迟，可以调用msync()来强制同步, 这样所写的内容就能立即保存到文件里了。

mmap 的优点

1. 对文件的读取操作跨过了页缓存，减少了数据的拷贝次数，用内存读写取代 I/O 读写，提高了文件读取效率。

2. 实现了用户空间和内核空间的高效交互方式。两空间的各自修改操作可以直接反映在映射的区域内，从而被对方空间及时捕捉。

3. 提供进程间共享内存及相互通信的方式。不管是父子进程还是无亲缘关系的进程，都可以将自身用户空间映射到同一个文件或匿名映射到同一片区域。从而通过各自对映射区域的改动，达到进程间通信和进程间共享的目的。

   例如：如果进程 A 和进程 B 都映射了区域 C，当 A 第一次读取 C 时通过缺页从磁盘复制文件页到内存中；但当 B 再读 C 的相同页面时，虽然也会产生缺页异常，但是不再需要从磁盘中复制文件过来，而可直接使用已经保存在内存中的文件数据。

4. 可用于实现高效的大规模数据传输。内存空间不足，是制约大数据操作的一个方面，解决方案往往是借助硬盘空间协助操作，补充内存的不足。但是进一步会造成大量的文件 I/O 操作，极大影响效率。这个问题可以通过 mmap 映射很好的解决。换句话说，但凡是需要用磁盘空间代替内存的时候，mmap 都可以发挥其功效。

mmap相关函数

mmap

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

start：映射区的开始地址。

length：映射区的长度。

prot：期望的内存保护标志，不能与文件的打开模式冲突。是以下的某个值，可以通过 or 运算合理地组合在一起。

内存保护标志	含义
PROT_EXEC	页内容可以被执行
PROT_READ	页内容可以被读取
PROT_WRITE	页可以被写入
PROT_NONE	页不可访问

flags：指定映射对象的类型，映射选项和映射页是否可以共享。它的值可以是一个或者多个以下位的组合体

MAP_FIXED //使用指定的映射起始地址，如果由start和len参数指定的内存区重叠于现存的映射空间，重叠部分将会被丢弃。如果指定的起始地址不可用，操作将会失败。并且起始地址必须落在页的边界上。
MAP_SHARED //与其它所有映射这个对象的进程共享映射空间。对共享区的写入，相当于输出到文件，除非msync()或者munmap()被调用，否则文件实际上不会被更新。
MAP_PRIVATE //建立一个写入时拷贝的私有映射。内存区域的写入不会影响到原文件。这个标志和以上标志是互斥的，只能使用其中一个。
MAP_DENYWRITE //这个标志被忽略。
MAP_EXECUTABLE //同上
MAP_NORESERVE //不要为这个映射保留交换空间。当交换空间被保留，对映射区修改的可能会得到保证。当交换空间不被保留，同时内存不足，对映射区的修改会引起段违例信号。
MAP_LOCKED //锁定映射区的页面，从而防止页面被交换出内存。
MAP_GROWSDOWN //用于堆栈，告诉内核VM系统，映射区可以向下扩展。
MAP_ANONYMOUS //匿名映射，映射区不与任何文件关联。
MAP_ANON //MAP_ANONYMOUS的别称，不再被使用。
MAP_FILE //兼容标志，被忽略。
MAP_32BIT //将映射区放在进程地址空间的低2GB，MAP_FIXED指定时会被忽略。当前这个标志只在x86-64平台上得到支持。
MAP_POPULATE //为文件映射通过预读的方式准备好页表。随后对映射区的访问不会被页违例阻塞。
MAP_NONBLOCK //仅和MAP_POPULATE一起使用时才有意义。不执行预读，只为已存在于内存中的页面建立页表入口。

fd：有效的文件描述词。如果MAP_ANONYMOUS 被设定，为了兼容问题，其值应为-1

offset：被映射对象内容的起点

成功执行时，mmap() 返回被映射区的指针。失败时，mmap() 返回 MAP_FAILED，error 被设为以下的某个值：

返回值	含义
EACCES	访问出错
EAGAIN	文件已被锁定，或者太多的内存已被锁定
EBADF	fd 不是有效的文件描述词
EINVAL	一个或者多个参数无效
ENFILE	已达到系统对打开文件的限制
ENODEV	指定文件所在的文件系统不支持内存映射
ENOMEM	内存不足，或者进程已超出最大内存映射数量
EPERM	权能不足，操作不允许
ETXTBSY	已写的方式打开文件，同时指定 MAP_DENYWRITE 标志
SIGSEGV	试着向只读区写入
SIGBUS	试着访问不属于进程的内存区

munmap

int munmap( void * addr, size_t len ) 

成功执行时，munmap() 返回 0。失败时，munmap 返回 -1，error 返回标志和 mmap 一致。

该调用在进程地址空间中解除一个映射关系，addr 是调用 mmap() 时返回的地址，len 是映射区的大小。

当映射关系解除后，对原来映射地址的访问将导致段错误发生。

msync

int msync( void *addr, size_t len, int flags )

一般说来，进程在映射空间的对共享内容的改变并不直接写回到磁盘文件中，往往在调用 munmap() 后才执行写操作。当需要同步时，可以通过调用 msync() 实现磁盘上文件内容与共享内存区的内容一致。

mmap使用细节

• 使用 mmap 需要注意的一个关键点是，mmap 映射区域大小必须是物理页大小的整倍数（32位系统中通常是4k字节）。原因是，内存的最小粒度是页，而进程虚拟地址空间和内存的映射也是以页为单位。为了匹配内存的操作，mmap 从磁盘到虚拟地址空间的映射也必须是页。
• 内核可以跟踪被内存映射的底层对象（文件）的大小，进程可以合法的访问在当前文件大小以内又在内存映射区以内的那些字节。也就是说，如果文件的大小一直在扩张，只要在映射区域范围内的数据，进程都可以合法得到，这和映射建立时文件的大小无关。具体情形参见“情形三”。
• 映射建立之后，即使文件关闭，映射依然存在。因为映射的是磁盘的地址，不是文件本身，和文件句柄无关。同时可用于进程间通信的有效地址空间不完全受限于被映射文件的大小，因为是按页映射。

在上面的知识前提下，我们下面看看如果大小不是页的整倍数的具体情况

情形一：一个文件的大小是5000字节，mmap函数从一个文件的起始位置开始，映射5000字节到虚拟内存中。

分析：因为单位物理页面的大小是4096字节，虽然被映射的文件只有5000字节，但是对应到进程虚拟地址区域的大小需要满足整页大小，因此mmap函数执行后，实际映射到虚拟内存区域8192个 字节，5000~8191的字节部分用零填充。映射后的对应关系如下图所示：

此时：

（1）读/写前 5000 个字节（0~4999），会返回操作文件内容。

（2）读字节 5000-8191 时，结果全为 0。写 5000-8191 时，进程不会报错，但是所写的内容不会写入原文件中 。

（3）读/写 8192 以外的磁盘部分，会返回一个 SIGSECV 错误。

情形二：一个文件的大小是5000字节，mmap函数从一个文件的起始位置开始，映射15000字节到虚拟内存中，即映射大小超过了原始文件的大小。

分析：由于文件的大小是5000字节，和情形一一样，其对应的两个物理页。那么这两个物理页都是合法可以读写的，只是超出5000的部分不会体现在原文件中。由于程序要求映射15000字节，而文件只占两个物理页，因此8192字节~15000字节都不能读写，操作时会返回异常。如下图所示：

此时：

（1）进程可以正常读/写被映射的前5000字节(0~4999)，写操作的改动会在一定时间后反映在原文件中。

（2）对于5000~8191字节，进程可以进行读写过程，不会报错。但是内容在写入前均为0，另外，写入后不会反映在文件中。

（3）对于8192~14999字节，进程不能对其进行读写，会报SIGBUS错误。

（4）对于15000以外的字节，进程不能对其读写，会引发SIGSEGV错误。

情形三：一个文件初始大小为0，使用mmap操作映射了1000*4K的大小，即1000个物理页大约4M字节空间，mmap返回指针ptr。

分析：如果在映射建立之初，就对文件进行读写操作，由于文件大小为 0，并没有合法的物理页对应，如同情形二一样，会返回 SIGBUS 错误。

但是如果，每次操作 ptr 读写前，先增加文件的大小，那么 ptr 在文件大小内部的操作就是合法的。例如，文件扩充 4096 字节，ptr 就能操作 ptr ~ [ (char)ptr + 4095] 的空间。只要文件扩充的范围在 1000 个物理页（映射范围）内，ptr 都可以对应操作相同的大小。

这样，方便随时扩充文件空间，随时写入文件，不造成空间浪费。

范例1：两个进程通过映射普通文件实现共享内存通信

#include <iostream>
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <cstring>
typedef struct {
    char name[4];
    int age;
}people;
int main() {
    int fd;

    if ((fd = open("./test.txt", O_CREAT | O_RDWR | O_TRUNC, 00777)) < 0) {
        std::cout << "error open" << std::endl;
        exit(1);
    }

    lseek(fd, sizeof(people) * 10, SEEK_END);
    write(fd, "", 1);
    people* p_map = (people*)mmap(nullptr, sizeof(people) * 10, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    close(fd);

    for (int i = 0; i < 10; i++)
    {
        char temp = ('a' + i);
        memcpy((*(p_map + i)).name, &temp, 2);
        (*(p_map + i)).age = i;
    }
    std::cout << "initialize over" << std::endl;
    munmap(p_map, sizeof(people) * 10);
    std::cout << "finish munmap" << std::endl;

    return 0;
}

#include <iostream>
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
typedef struct {
    char name[4];
    int age;
}people;
int main()
{
    int fd;
    if ((fd = open("./test.txt", O_CREAT | O_RDWR, 00777)) < 0) {
        std::cout << "open error" << std::endl;
    }

    people* p_map = (people*)mmap(NULL, sizeof(people) * 10, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    for (int i = 0; i < 10; i++)
    {
        std::cout << "name:" << (*(p_map + i)).name << " age:" << (*(p_map + i)).age << std::endl;
    }
    munmap(p_map, sizeof(people) * 10);

    return 0;
}

输出：

name:a age:0
name:b age:1
name:c age:2
name:d age:3
name:e age:4
name:f age:5
name:g age:6
name:h age:7
name:i age:8
name:j age:9

范例2：父子进程通过匿名映射实现共享内存

#include <cstring>
#include <cstdio>
#include <sys/mman.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
typedef struct {
    char name[4];
    int  age;
}people;
int main() {
    people* p_map;
    p_map = (people*)mmap(NULL, sizeof(people) * 10, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0);
    if (fork() == 0)
    {
        sleep(1);
        for (int i = 0; i < 5; i++)
            printf("child read: the %d people's age is %d\n", i, (*(p_map + i)).age);
        (*p_map).age = 100;
        munmap(p_map, sizeof(people) * 10); //实际上，进程终止时，会自动解除映射。
        _exit(0);
    }
    for (int i = 0; i < 5; i++)
    {
        char temp = ('a' + i);
        memcpy((*(p_map + i)).name, &temp, 2);
        (*(p_map + i)).age = i;
    }
    sleep(3);
    printf("parent read: the first people,s age is %d\n", (*p_map).age);
    printf("umap\n");
    munmap(p_map, sizeof(people) * 10);
    printf("umap ok\n");

    return 0;
}

输出：

child read: the 0 people's age is 0
child read: the 1 people's age is 1
child read: the 2 people's age is 2
child read: the 3 people's age is 3
child read: the 4 people's age is 4
parent read: the first people,s age is 100
umap
umap ok