关于mmap不为人知的秘密

Pika
3,979 阅读11分钟

携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第1天，点击查看活动详情

mmap初入

我们常说的mmap，其实是一种内存映射文件的方法，mmap将一个文件或者其它对象映射进内存。但是更加确切的来说，其实是linux中的线性区提供的可以和基于磁盘文件系统的普通文件的某一个部分相关联的操作。线性区其实是由进程中连续的一块虚拟文件区域，由struct vm_area_struct结构体表示，我们的mmap操作，其实就是最本质的，就是通过其进行的内存操作。

按照归类的思想，其实mmap主要用到的分为两类（还有其他标识不讨论）

  1. 共享的：即对该线性区中的页（注意是以页为单位）的任何写操作，都会修改磁盘上的文件，并且如果一个进程对进行了mmap的页进行了写操作，那么对于其他进程（同样也通过mmap进行了映射），同样也是可见的
  2. 私有的：对于私有映射页的任何写操作，都会使linux内核停止映射该文件的页（注意，假如有进程a，b同时映射了该页，a对页进行了修改，此时这个页就相当于复制出来了一份，a以后的操作就在复制的该页进行操作，b还是引用原来的页，原来的页就可以继续参与内存映射，而复制出来的页，就被停止映射了），因此，在私有情况下，写操作是不会改变磁盘上的文件，同时所做的修改对于其他进程来说，就是不可见的。

我们看一下图片 共享模式下

image.png 私有模式下

image.png

mmap分析

概念我们有了，我们看一下代码mmap定义

#if defined(__USE_FILE_OFFSET64)
void* mmap(void* __addr, size_t __size, int __prot, int __flags, int __fd, off_t __offset) __RENAME(mmap64);
#else
void* mmap(void* __addr, size_t __size, int __prot, int __flags, int __fd, off_t __offset);
#endif

#if __ANDROID_API__ >= 21
/**
 * mmap64() is a variant of mmap() that takes a 64-bit offset even on LP32.
 *
 * See https://android.googlesource.com/platform/bionic/+/master/docs/32-bit-abi.md
 *
 * mmap64 wasn't really around until L, but we added an inline for it since it
 * allows a lot more code to compile with _FILE_OFFSET_BITS=64.
 */
void* mmap64(void* __addr, size_t __size, int __prot, int __flags, int __fd, off64_t __offset) __INTRODUCED_IN(21);
#endif

mmap分为好多个版本，但是其他的也是根据不同的Android版本或者abi进行部分的区分，我们来看一下具体含义：

  1. addr:参数addr指定文件应被映射到进程空间的起始地址，一般被指定一个空指针，此时选择起始地址的任务留给内核来完成。当然，我们也可以设定一个自己的地址，但是如果flag中设定起来MAP_FIXED标志，且内核也没办法从我们指定的线性地址开始分配新线性区的话，就会产生调用失败
  2. size:映射到调用进程地址空间的字节数，它从被映射文件开头offset个字节开始算起
  3. prot:指定对线性区的一组权限，比如读权限（PROT_READ）,写权限（PROT_WRITE），执行权限（PROT_EXEC）
  4. flags:一组标志，比如我们上面说的共享模式（MAP_SHARED）或者私有模式（MAP_PRIVATE）等
  5. fd：文件描述符，要映射的文件
  6. offset：要映射的文件的偏移量（比如我想要从文件的某部分开始映射）

使用例子

下面是demo例子


#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
#define TRUE 1
#define FALSE -1
#define FILE_SIZE 100
 
#define MMAP_FILE_PATH "./mmap.txt"

 
int main(int argc, char **argv) 
{
    int fd = -1;
    //char buff[100] = {0};
    void *result;
    int lseek_result = -1;
    int file_length = -1;
    
    // 1. open the file
    fd = open(MMAP_FILE_PATH, O_RDWR|O_CREAT, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
    if (-1 == fd) {
        printf("open failed\n");
        printf("%s\n", strerror(errno));
        return FALSE;
    }

    //2. call mmap 这里可以尝试一下其他的flag，比如MAP_PRIVATE
    result = mmap(0, 100（这里是demo文件长度）, \
                PROT_READ|PROT_WRITE, \
                MAP_SHARED, \
                fd, 0);
    if (result == (void *)-1) {
        printf("mmap failed\n");
        printf("%s\n", strerror(errno));
        return FALSE;
    }
 
    //3. release the file descriptor
    close(fd);
 
    //4. write something to mmap addr,
    strncpy(result, "test balabala...", file_length);
 
    //5. call munmap
    munmap(0, file_length);
 
    return 0;
}

深入了解mmap

不得不说，mmap的函数实现非常复杂，首先会调用到do_mmap_pgoff进行平台无关的代码分支，然后会调用到do_mmap里面，这个函数非常长！！！

我们挑几个关键的步骤：

  1. 先检查要映射的文件是否定义了mmap文件操作，（如果是目录就不存在mmap文件操作了）如果没有的话就直接调用失败
  2. 检查一系列的一致性检查，同时根据mmap的参数与打开文件的权限标志进行对比：比如检查当前文件是否有文件锁，如果是以MAP_SHARED模式打开进行写入的话，也要检查文件是否有可写的权限，正所谓权限要一致
  3. 设置线性区的vm_flag字段，因为我们mmap返回的地址肯定也是要给到当前进程的，这个线性区的权限所以也要设置，比如VM_READ,VM_WRITE等标识，表明了这块内存的权限
  4. 增加文件的引用计数，因为我们进程mmap用到了该文件对吧，所以计数器也要加一，这样系统才会知道当前文件被多少个进程引用了
  5. 对文件进行映射操作，并且初始化该线性区的页，注意这个时候并没有对页进行操作，因为有可能申请了这个页而没有操作，所以这个时候是以no_page标识的，这里不得不感慨linux的写时复制思想用到了各处！只有真正访问的时候，就会产生一个缺页异常，由内核调度请求完成对该页的填充
unsigned long do_mmap(struct file *file, unsigned long addr,
   unsigned long len, unsigned long prot,
   unsigned long flags, vm_flags_t vm_flags,
   unsigned long pgoff, unsigned long *populate)
{
 struct mm_struct *mm = current->mm;        //获取该进程的memory descriptor
 int pkey = 0;

 *populate = 0;
 //函数对传入的参数进行一系列检查, 假如任一参数出错，都会返回一个errno
 if (!len)
  return -EINVAL;

 /*
  * Does the application expect PROT_READ to imply PROT_EXEC?
  *
  * (the exception is when the underlying filesystem is noexec
  *  mounted, in which case we dont add PROT_EXEC.)
  */
 if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))
  if (!(file && path_noexec(&file->f_path)))
   prot |= PROT_EXEC;
 //假如没有设置MAP_FIXED标志，且addr小于mmap_min_addr, 因为可以修改addr, 所以就需要将addr设为mmap_min_addr的页对齐后的地址
 if (!(flags & MAP_FIXED))
  addr = round_hint_to_min(addr);

 /* Careful about overflows.. */
 len = PAGE_ALIGN(len);         //进行Page大小的对齐
 if (!len)
  return -ENOMEM;

 /* offset overflow? */
 if ((pgoff + (len >> PAGE_SHIFT)) < pgoff)
  return -EOVERFLOW;

 /* Too many mappings? */
 if (mm->map_count > sysctl_max_map_count)    //判断该进程的地址空间的虚拟区间数量是否超过了限制
  return -ENOMEM;

 //get_unmapped_area从当前进程的用户空间获取一个未被映射区间的起始地址
 addr = get_unmapped_area(file, addr, len, pgoff, flags);
 if (offset_in_page(addr))        //检查addr是否有效
  return addr;

 if (prot == PROT_EXEC) {
  pkey = execute_only_pkey(mm);
  if (pkey < 0)
   pkey = 0;
 }

 /* Do simple checking here so the lower-level routines won't have
  * to. we assume access permissions have been handled by the open
  * of the memory object, so we don't do any here.
  */
 vm_flags |= calc_vm_prot_bits(prot, pkey) | calc_vm_flag_bits(flags) |
   mm->def_flags | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC;
 //假如flags设置MAP_LOCKED，即类似于mlock()将申请的地址空间锁定在内存中, 检查是否可以进行lock
 if (flags & MAP_LOCKED)
  if (!can_do_mlock())
   return -EPERM;

 if (mlock_future_check(mm, vm_flags, len))
  return -EAGAIN;

 if (file) {          // file指针不为nullptr, 即从文件到虚拟空间的映射
  struct inode *inode = file_inode(file);   //获取文件的inode

  switch (flags & MAP_TYPE) {       //根据标志指定的map种类，把为文件设置的访问权考虑进去
  case MAP_SHARED:
   if ((prot&PROT_WRITE) && !(file->f_mode&FMODE_WRITE))
    return -EACCES;

   /*
    * Make sure we don't allow writing to an append-only
    * file..
    */
   if (IS_APPEND(inode) && (file->f_mode & FMODE_WRITE))
    return -EACCES;

   /*
    * Make sure there are no mandatory locks on the file.
    */
   if (locks_verify_locked(file))
    return -EAGAIN;

   vm_flags |= VM_SHARED | VM_MAYSHARE;
   if (!(file->f_mode & FMODE_WRITE))
    vm_flags &= ~(VM_MAYWRITE | VM_SHARED);

   /* fall through */
  case MAP_PRIVATE:
   if (!(file->f_mode & FMODE_READ))
    return -EACCES;
   if (path_noexec(&file->f_path)) {
    if (vm_flags & VM_EXEC)
     return -EPERM;
    vm_flags &= ~VM_MAYEXEC;
   }

   if (!file->f_op->mmap)
    return -ENODEV;
   if (vm_flags & (VM_GROWSDOWN|VM_GROWSUP))
    return -EINVAL;
   break;

  default:
   return -EINVAL;
  }
 } else {
  switch (flags & MAP_TYPE) {
  case MAP_SHARED:
   if (vm_flags & (VM_GROWSDOWN|VM_GROWSUP))
    return -EINVAL;
   /*
    * Ignore pgoff.
    */
   pgoff = 0;
   vm_flags |= VM_SHARED | VM_MAYSHARE;
   break;
  case MAP_PRIVATE:
   /*
    * Set pgoff according to addr for anon_vma.
    */
   pgoff = addr >> PAGE_SHIFT;
   break;
  default:
   return -EINVAL;
  }
 }

 /*
  * Set 'VM_NORESERVE' if we should not account for the
  * memory use of this mapping.
  */
 if (flags & MAP_NORESERVE) {
  /* We honor MAP_NORESERVE if allowed to overcommit */
  if (sysctl_overcommit_memory != OVERCOMMIT_NEVER)
   vm_flags |= VM_NORESERVE;

  /* hugetlb applies strict overcommit unless MAP_NORESERVE */
  if (file && is_file_hugepages(file))
   vm_flags |= VM_NORESERVE;
 }
 //一顿检查和配置，调用核心的代码mmap_region
 addr = mmap_region(file, addr, len, vm_flags, pgoff);
 if (!IS_ERR_VALUE(addr) &&
     ((vm_flags & VM_LOCKED) ||
      (flags & (MAP_POPULATE | MAP_NONBLOCK)) == MAP_POPULATE))
  *populate = len;
 return addr;
}
do_mmap() 根据用户传入的参数做了一系列的检查，然后根据参数初始化 vm_area_struct 的标志 vm_flags，vma->vm_file = get_file(file) 建立文件与vma的映射, mmap_region() 负责创建虚拟内存区域:

unsigned long mmap_region(struct file *file, unsigned long addr,
  unsigned long len, vm_flags_t vm_flags, unsigned long pgoff)
{
 struct mm_struct *mm = current->mm;     //获取该进程的memory descriptor
 struct vm_area_struct *vma, *prev;
 int error;
 struct rb_node **rb_link, *rb_parent;
 unsigned long charged = 0;

 /* 检查申请的虚拟内存空间是否超过了限制 */
 if (!may_expand_vm(mm, vm_flags, len >> PAGE_SHIFT)) {
  unsigned long nr_pages;

  /*
   * MAP_FIXED may remove pages of mappings that intersects with
   * requested mapping. Account for the pages it would unmap.
   */
  nr_pages = count_vma_pages_range(mm, addr, addr + len);

  if (!may_expand_vm(mm, vm_flags,
     (len >> PAGE_SHIFT) - nr_pages))
   return -ENOMEM;
 }

 /* 检查[addr, addr+len)的区间是否存在映射空间，假如存在重合的映射空间需要munmap  */
 while (find_vma_links(mm, addr, addr + len, &prev, &rb_link,
         &rb_parent)) {
  if (do_munmap(mm, addr, len))
   return -ENOMEM;
 }

 /*
  * Private writable mapping: check memory availability
  */
 if (accountable_mapping(file, vm_flags)) {
  charged = len >> PAGE_SHIFT;
  if (security_vm_enough_memory_mm(mm, charged))
   return -ENOMEM;
  vm_flags |= VM_ACCOUNT;
 }

 //检查是否可以合并[addr, addr+len)区间内的虚拟地址空间vma
 vma = vma_merge(mm, prev, addr, addr + len, vm_flags,
   NULL, file, pgoff, NULL, NULL_VM_UFFD_CTX);
 if (vma)       //假如合并成功，即使用合并后的vma, 并跳转至out
  goto out;
 //如果不能和已有的虚拟内存区域合并，通过Memory Descriptor来申请一个vma
 vma = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);
 if (!vma) {
  error = -ENOMEM;
  goto unacct_error;
 }
 //初始化vma
 vma->vm_mm = mm;
 vma->vm_start = addr;
 vma->vm_end = addr + len;
 vma->vm_flags = vm_flags;
 vma->vm_page_prot = vm_get_page_prot(vm_flags);
 vma->vm_pgoff = pgoff;
 INIT_LIST_HEAD(&vma->anon_vma_chain);

 if (file) { //假如指定了文件映射 
  if (vm_flags & VM_DENYWRITE) {   //映射的文件不允许写入，调用deny_write_accsess(file)排斥常规的文件操作
   error = deny_write_access(file);
   if (error)
    goto free_vma;
  }
  if (vm_flags & VM_SHARED) {   //映射的文件允许其他进程可见, 标记文件为可写
   error = mapping_map_writable(file->f_mapping);
   if (error)
    goto allow_write_and_free_vma;
  }

  //递增File的引用次数，返回File赋给vma
  vma->vm_file = get_file(file);
  error = file->f_op->mmap(file, vma);  //调用文件系统指定的mmap函数
  if (error)
   goto unmap_and_free_vma;

  /* Can addr have changed??
   *
   * Answer: Yes, several device drivers can do it in their
   *         f_op->mmap method. -DaveM
   * Bug: If addr is changed, prev, rb_link, rb_parent should
   *      be updated for vma_link()
   */
  WARN_ON_ONCE(addr != vma->vm_start);

  addr = vma->vm_start;
  vm_flags = vma->vm_flags;
 } else if (vm_flags & VM_SHARED) {
  error = shmem_zero_setup(vma);  //假如标志为VM_SHARED，但没有指定映射文件，需要调用shmem_zero_setup(),实际映射的文件是dev/zero
  if (error)
   goto free_vma;
 }
 //将申请的新vma加入mm中的vma链表
 vma_link(mm, vma, prev, rb_link, rb_parent);
 /* Once vma denies write, undo our temporary denial count */
 if (file) {
  if (vm_flags & VM_SHARED)
   mapping_unmap_writable(file->f_mapping);
  if (vm_flags & VM_DENYWRITE)
   allow_write_access(file);
 }
 file = vma->vm_file;
out:
 perf_event_mmap(vma);
 //更新进程的虚拟地址空间mm
 vm_stat_account(mm, vm_flags, len >> PAGE_SHIFT);
 if (vm_flags & VM_LOCKED) {
  if (!((vm_flags & VM_SPECIAL) || is_vm_hugetlb_page(vma) ||
     vma == get_gate_vma(current->mm)))
   mm->locked_vm += (len >> PAGE_SHIFT);
  else
   vma->vm_flags &= VM_LOCKED_CLEAR_MASK;
 }

 if (file)
  uprobe_mmap(vma);

 /*
  * New (or expanded) vma always get soft dirty status.
  * Otherwise user-space soft-dirty page tracker won't
  * be able to distinguish situation when vma area unmapped,
  * then new mapped in-place (which must be aimed as
  * a completely new data area).
  */
 vma->vm_flags |= VM_SOFTDIRTY;

 vma_set_page_prot(vma);

 return addr;

unmap_and_free_vma:
 vma->vm_file = NULL;
 fput(file);

 /* Undo any partial mapping done by a device driver. */
 unmap_region(mm, vma, prev, vma->vm_start, vma->vm_end);
 charged = 0;
 if (vm_flags & VM_SHARED)
  mapping_unmap_writable(file->f_mapping);
allow_write_and_free_vma:
 if (vm_flags & VM_DENYWRITE)
  allow_write_access(file);
free_vma:
 kmem_cache_free(vm_area_cachep, vma);
unacct_error:
 if (charged)
  vm_unacct_memory(charged);
 return error;
}

munmap

当进程准备清除一个mmap映射时，就可以调用munmap函数

int munmap(void* __addr, size_t __size);

如demo例子所示，第一个函数是要删除的线性地址的第一个单元的地址，第二个函数是线性区的长度，由于这个函数比较简单，就是系统调用do_munmap函数，这里就不详细分析啦！

数据写回磁盘

经过上面的mmap操作，我们也知道了mmap的使用了，不知道大家有没有留意一个细节，就是上面图中我们内存写入的下一步是页高速缓存，这个时候真正的数据保存，其实还是没有真正写入到磁盘里面的，真正写入其实是靠系统调用写入，即msync函数

int msync(void* __addr, size_t __size, int __flags);

mmap的数据写入依靠着这个系统调用保证，即当前进程被异常销毁了，也可以通过这个系统级别的调用，把属于内存映射的脏页数据写回去磁盘。参数1跟2需要写回去的头地址跟大小，我们重点看一下最后一个参数flags，它有以下几个参数选择：

  • MS_SYNC:要求系统挂起调用进程，直到I/O操作完成
  • MS_ASYNC:可以系统调用立即返回，不用挂起调用进程（大多数使用到mmap库选择）
  • MS_INVALLDATE:要求系统调用从进程地址空间删除mmap映射的所有页 这个函数主要功能是进行脏页标记，并进行真正的磁盘写入，大概的路径就是通过调用flush_tlb_page把缓冲器标记为脏页标识，同时获取文件对应的索引节点i_sem信号量，进行写入时的上锁，然后刷新到磁盘！

这里可以看到，mmap依靠系统调用，把数据刷新回到磁盘！虽然这个刷新动作是由linux系统进行刷入的，保证了进程出问题的时候，也能够在系统级别刷入数据，比如MMKV的设计就采用了这点，但是这个也不是百分百可靠的，因为这个刷入操作是没有备份操作的/异常容灾处理，如果系统异常或者断电的情况，就会出现错误数据或者没有完全刷入磁盘的数据，造成数据异常，我们也可以看到mmkv介绍

image.png

mmap不足

mmap最大的不足，就是被映射的线性区只能是按照页的整数倍进行计算，如果说我们要映射的内存少于这个数，也是按照一个页进行映射的，当然，一个页长度会根据不同架构而不同，比如常见的4kb等，同时也要时刻注意映射区的生命周期，不然无脑映射也很容易造成oom

扩展

当然，说到mmap，肯定也离不开对mmkv的介绍，虽然mmkv很优秀，但是也不能无脑就使用，这方面可以参考朱凯大佬发布的文章Android 的键值对存储有没有最优解？，这里就不再赘述，按照自己所需的使用，当然，jetpack的DataStore也是很香啊！有机会的话也出一篇解析文！

avatar
文章
阅读
粉丝
相关推荐
异构计算关键技术之mmap(二)
218阅读
 · 
0点赞
异构计算关键技术之mmap
241阅读
 · 
0点赞
Android 音频低延时mmap介绍(2)
422阅读
 · 
0点赞
python mmap进程内存共享实现原理
203阅读
 · 
1点赞
从内核世界透视 mmap 内存映射的本质（源码实现篇）
834阅读
 · 
4点赞
【万字长文】深入浅出线程池,从内核世界透视 mmap 内存映射的本质 | 酱酱的下午茶第288期
4.1k阅读
 · 
6点赞
从内核世界透视 mmap 内存映射的本质（原理篇）
911阅读
 · 
13点赞
MIT 6.s081 Lab10: mmap
931阅读
 · 
4点赞
聊聊Java中的mmap
729阅读
 · 
13点赞
🐟 沸点养鱼计划第四期-二十四节气的秘密
21k阅读
 · 
146点赞

友情链接：