Linux 内核之旅（二十）：内核视角下的共享内存

struct vm_area_struct {
    unsigned long vm_flags; 	//标记为 MAP_SHARED 共享映射
    struct file * vm_file;      /* File we map to (can be NULL). */
    unsigned long vm_pgoff;     /* Offset (within vm_file) in PAGE_SIZE */
}

struct vm_area_struct {
    unsigned long vm_pgoff;     /* Offset (within vm_file) in PAGE_SIZE */
}

static inline struct page *find_get_page(struct address_space *mapping,
     pgoff_t offset)
{
   return pagecache_get_page(mapping, offset, 0, 0);
}

//https://elixir.bootlin.com/linux/v4.11.6/source/arch/x86/kernel/sys_x86_64.c#L87
//mmap 系统调用的本质其实就是在进程虚拟内存空间中划分出一段未映射的虚拟内存区域，随后内核会为这段映射出来的虚拟内存区域创建 vma 结构，并初始化 vma 结构的相关属性
SYSCALL_DEFINE6(mmap, unsigned long, addr, unsigned long, len,
		unsigned long, prot, unsigned long, flags,
		unsigned long, fd, unsigned long, off)
{
	long error;
	error = -EINVAL;
	if (off & ~PAGE_MASK)
		goto out;

	// 重要：这里，用户态的参数offset会通过`off >> PAGE_SHIFT`转换为页数
	// 后面内核都使用页数作为计算参数
	error = sys_mmap_pgoff(addr, len, prot, flags, fd, off >> PAGE_SHIFT);
out:
	return error;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/arch/x86/kernel/sys_x86_64.c#L87
// 注意：参数pgoff就是按照PAGE_SHIFT对齐之后的（原始用户传入的）offset
SYSCALL_DEFINE6(mmap_pgoff, unsigned long, addr, unsigned long, len,
		unsigned long, prot, unsigned long, flags,
		unsigned long, fd, unsigned long, pgoff)
{
	struct file *file = NULL;
	unsigned long retval;

	if (!(flags & MAP_ANONYMOUS)) {	// 预处理文件映射
		audit_mmap_fd(fd, flags);
		// 通过文件 fd 获取映射文件的 struct file 结构
		// 从而获取 inode 信息，关联磁盘文件，后面关闭 fd，仍然可以用 mmap 操作
		file = fget(fd);
		if (!file)
			return -EBADF;
		if (is_file_hugepages(file))
			len = ALIGN(len, huge_page_size(hstate_file(file)));
		retval = -EINVAL;
		if (unlikely(flags & MAP_HUGETLB && !is_file_hugepages(file)))
			goto out_fput;
	} else if (flags & MAP_HUGETLB) {
		//MAP_HUGETLB 只能支持 MAP_ANONYMOUS 匿名映射的方式使用 HugePage
		struct user_struct *user = NULL;
		struct hstate *hs;	// 内核中的大页池（预先创建）
		// 选取指定大页尺寸的大页池（内核中存在不同尺寸的大页池）
		hs = hstate_sizelog((flags >> MAP_HUGE_SHIFT) & SHM_HUGE_MASK);
		if (!hs)
			return -EINVAL;
		
		// 映射长度 len 必须与大页尺寸对齐
		len = ALIGN(len, huge_page_size(hs));
		/*
		 * VM_NORESERVE is used because the reservations will be
		 * taken when vm_ops->mmap() is called
		 * A dummy user value is used because we are not locking
		 * memory so no accounting is necessary
		 */
		// 在 hugetlbfs 中创建 anon_hugepage 文件，并预留大页内存（禁止其他进程申请）
		file = hugetlb_file_setup(HUGETLB_ANON_FILE, len,
				VM_NORESERVE,
				&user, HUGETLB_ANONHUGE_INODE,
				(flags >> MAP_HUGE_SHIFT) & MAP_HUGE_MASK);
		if (IS_ERR(file))
			return PTR_ERR(file);
	}

	flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
	//核心：开始内存映射
	retval = vm_mmap_pgoff(file, addr, len, prot, flags, pgoff);
out_fput:
	if (file)
		fput(file);
	return retval;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/util.c#L296
unsigned long vm_mmap_pgoff(struct file *file, unsigned long addr,
	unsigned long len, unsigned long prot,
	unsigned long flag, unsigned long pgoff)
{
	unsigned long ret;
	// 获取进程虚拟内存空间
	struct mm_struct *mm = current->mm;
	// 是否需要为映射的 vma，提前分配物理内存页，避免后续的缺页
	// 取决于 flag 是否设置了 MAP_POPULATE 或者 MAP_LOCKED
	// 这里的 populate 表示需要分配物理内存的大小
	unsigned long populate;
	// 初始化 userfaultfd 链表
	LIST_HEAD(uf);

	// security钩子
	ret = security_mmap_file(file, prot, flag);
	if (!ret) {
		// 对进程虚拟内存空间加写锁保护，防止多线程并发修改
		if (down_write_killable(&mm->mmap_sem))
			return -EINTR;
        // 开始 mmap 内存映射，在进程虚拟内存空间中分配一段 vma，并建立相关映射关系
        // 返回值 ret 为映射虚拟内存区域的起始地址
		ret = do_mmap_pgoff(file, addr, len, prot, flag, pgoff,
				    &populate, &uf);
		
		// 释放写锁
		up_write(&mm->mmap_sem);
		// 等待 userfaultfd 处理完成
		userfaultfd_unmap_complete(mm, &uf);
		if (populate){	
			// 提前分配物理内存页面，后续访问不会缺页，为 [ret , ret + populate] 这段虚拟内存立即分配物理内存
			// 分析见下文
			mm_populate(ret, populate);
		}
	}
	return ret;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/include/linux/mm.h#L2118
static inline unsigned long
do_mmap_pgoff(struct file *file, unsigned long addr,
	unsigned long len, unsigned long prot, unsigned long flags,
	unsigned long pgoff, unsigned long *populate,
	struct list_head *uf)
{
	return do_mmap(file, addr, len, prot, flags, 0, pgoff, populate, uf);
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/mmap.c#L1306
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 list_head *uf)
{
	struct mm_struct *mm = current->mm;
	int pkey = 0;

	*populate = 0;

	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.)
	 */
	// 如果进程带有 READ_IMPLIES_EXEC 标记且文件系统是可执行的，则这段内存空间使用 READ 的属性会附带增加 EXEC 属性
	if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))
		if (!(file && path_noexec(&file->f_path)))
			prot |= PROT_EXEC;
		
	// 合理：如果不是使用固定地址，则使用的 addr 会进行向下页对齐
	if (!(flags & MAP_FIXED))
		addr = round_hint_to_min(addr);

	/* Careful about overflows.. */
	// 申请内存大小页对齐，注意不要溢出
	len = PAGE_ALIGN(len);
	if (!len)
		return -ENOMEM;

	/* offset overflow? */
	// 判断申请的内存是否溢出
	if ((pgoff + (len >> PAGE_SHIFT)) < pgoff)
		return -EOVERFLOW;

	/* Too many mappings? */
	// 一个进程虚拟内存空间内所能包含的虚拟内存区域 vma 是有数量限制的
    // sysctl_max_map_count 规定了进程虚拟内存空间所能包含 vma 的最大个数
    // 可以通过 /proc/sys/vm/max_map_count 内核参数调整 sysctl_max_map_count
    // mmap 需要在进程虚拟内存空间中创建映射的 vma，这里需要检查已有 vma 的个数是否超过最大限制
	if (mm->map_count > sysctl_max_map_count)
		return -ENOMEM;

	/* Obtain the address to map to. we verify (or select) it and ensure
	 * that it represents a valid section of the address space.
	 */
	// 在进程虚拟内存空间中寻找一块未映射的虚拟内存区域，这段虚拟内存区域后续将会用于 mmap 内存映射
	addr = get_unmapped_area(file, addr, len, pgoff, flags);
	if (offset_in_page(addr))	// 如果返回的地址不是按照page对齐的，则直接返回
		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.
	 */
	// 简单的检查，通过 calc_vm_prot_bits 和 calc_vm_flag_bits 将 mmap 参数 prot , flag 中   
    // 设置的访问权限以及映射方式等枚举值转换为统一的 vm_flags，后续一起映射进 VMA 的相应属性中，相应前缀转换为 VM_
	vm_flags |= calc_vm_prot_bits(prot, pkey) | calc_vm_flag_bits(flags) |
			mm->def_flags | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC;

	// 设置了 MAP_LOCKED，表示用户期望 mmap 背后映射的物理内存锁定在内存中，不允许 swap
	if (flags & MAP_LOCKED)
		if (!can_do_mlock())	// 检查是否可以将本次映射的物理内存锁定
			return -EPERM;
	// 进一步检查锁定的内存页数是否超过了内核限制
	if (mlock_future_check(mm, vm_flags, len))
		return -EAGAIN;

	if (file) {
		// 分支一：文件映射
		struct inode *inode = file_inode(file);

		switch (flags & MAP_TYPE) {
		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;	 // 忽略 pgoff
			vm_flags |= VM_SHARED | VM_MAYSHARE;
			break;
		case MAP_PRIVATE:
			/*
			 * Set pgoff according to addr for anon_vma.
			 */
			// 根据匿名 vma 的 addr 设置 pgoff
			pgoff = addr >> PAGE_SHIFT;
			break;
		default:
			return -EINVAL;
		}
	}

	/*
	 * Set 'VM_NORESERVE' if we should not account for the
	 * memory use of this mapping.
	 */
	// 通常内核会为 mmap 申请虚拟内存的时候会综合考虑 ram 以及 swap space 的总体大小。当映射的虚拟内存过大
	// 而没有足够的 swap space 的时候， mmap 就会失败,设置 MAP_NORESERVE，内核将不会考虑上面的限制因素
    // 这样当通过 mmap 申请大量的虚拟内存，并且当前系统没有足够的 swap space 的时候，mmap 系统调用依然能够成功
	if (flags & MAP_NORESERVE) {
		// 设置 MAP_NORESERVE 的目的是为了应用可以申请过量的虚拟内存，如果内核本身是禁止 overcommit 的
		// 那么设置 MAP_NORESERVE 是无意义的，如果内核允许过量申请虚拟内存时（overcommit 为 0 或者 1）
        // 无论映射多大的虚拟内存，mmap 将会始终成功，但缺页的时候会容易导致 oom
		/* We honor MAP_NORESERVE if allowed to overcommit */
		if (sysctl_overcommit_memory != OVERCOMMIT_NEVER)
			vm_flags |= VM_NORESERVE;	// 设置 VM_NORESERVE 表示无论申请多大的虚拟内存，内核总会答应

		/* hugetlb applies strict overcommit unless MAP_NORESERVE */
		// 大页内存是提前预留出来的，并且本身就不会被 swap，所以不需要像普通内存页那样考虑 swap space 的限制因素
		if (file && is_file_hugepages(file))
			vm_flags |= VM_NORESERVE;
	}

	//重要：内存映射的核心，创建和初始化虚拟内存区域，并加入红黑树管理
	addr = mmap_region(file, addr, len, vm_flags, pgoff, uf);

	// 假如没有设置 MAP_POPULATE 标志位内核并不在调用 mmap 时就为进程分配物理内存空间，而是直到下次真正访问
	// 地址空间时发现数据不存在于物理内存空间时才触发 Page Fault 将缺失的 Page 换入内存空间 
	if (!IS_ERR_VALUE(addr) &&
	    ((vm_flags & VM_LOCKED) ||
	     (flags & (MAP_POPULATE | MAP_NONBLOCK)) == MAP_POPULATE))
		*populate = len; // 设置需要分配的物理内存大小
	return addr;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/mmap.c#L2053

unsigned long
get_unmapped_area(struct file *file, unsigned long addr, unsigned long len,
		unsigned long pgoff, unsigned long flags)
{
		// 在进程虚拟空间中寻找还未被映射的 VMA 这段核心逻辑是被内核实现在特定于体系结构的函数中
    // 该函数指针用于指向真正的 get_unmapped_area 函数，在经典布局下，真正的实现函数为 arch_get_unmapped_area
	unsigned long (*get_area)(struct file *, unsigned long,
				  unsigned long, unsigned long, unsigned long);

	unsigned long error = arch_mmap_check(addr, len, flags);
	if (error)
		return error;

	/* Careful about overflows.. */
	// 映射的虚拟内存区域长度不能超过进程的地址空间
	if (len > TASK_SIZE)
		return -ENOMEM;
	
	// 如果是匿名映射，则采用 mm_struct 中保存的特定于体系结构的 arch_get_unmapped_area 函数
	get_area = current->mm->get_unmapped_area;
	if (file) {
		// 如果是文件映射，则需要使用 file->f_op 中的 get_unmapped_area 指向的函数来为文件映射申请虚拟内存
		// file->f_op 保存的是特定于文件系统中文件的相关操作，如 ext4 文件系统下的 thp_get_unmapped_area 函数
		if (file->f_op->get_unmapped_area)
			get_area = file->f_op->get_unmapped_area;
	} else if (flags & MAP_SHARED) {
		/*
		 * mmap_region() will call shmem_zero_setup() to create a file,
		 * so use shmem's get_unmapped_area in case it can be huge.
		 * do_mmap_pgoff() will clear pgoff, so match alignment.
		 */
		pgoff = 0;
		// 共享匿名映射是通过在 tmpfs 中创建的匿名文件实现的，所以这里也有其专有的 get_unmapped_area 函数
		// 共享匿名映射的情况下 get_unmapped_area 指向 shmem_get_unmapped_area 函数
		get_area = shmem_get_unmapped_area;
	}

	// 在进程虚拟内存空间中，根据指定的 addr，len 查找合适的 vma
	addr = get_area(file, addr, len, pgoff, flags);
	if (IS_ERR_VALUE(addr))
		return addr;
	
	// vma 区域不能超过进程地址空间
	if (addr > TASK_SIZE - len)
		return -ENOMEM;
	// addr 需要与 page size 对齐
	if (offset_in_page(addr))
		return -EINVAL;

	error = security_mmap_addr(addr);
	return error ? error : addr;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/mmap.c#L1966
unsigned long
arch_get_unmapped_area(struct file *filp, unsigned long addr,
		unsigned long len, unsigned long pgoff, unsigned long flags)
{
	struct mm_struct *mm = current->mm;
	struct vm_area_struct *vma;
	struct vm_unmapped_area_info info;

	// 进程虚拟内存空间的末尾 TASK_SIZE

	// 映射区域长度是否超过进程虚拟内存空间
	if (len > TASK_SIZE - mmap_min_addr)
		return -ENOMEM;
	
	// 如果指定了 MAP_FIXED 表示必须要从指定的 addr 开始映射 len 长度的区域
    // 如果这块区域已经存在映射关系，那么后续内核会把旧的映射关系覆盖掉
	if (flags & MAP_FIXED){
		//直接返回addr
		return addr;
	}
	
	// 没有指定 MAP_FIXED，但指定了 addr，内核从指定的 addr 地址开始映射，内核这里会检查指定的这块虚拟内存范围是否有效
	if (addr) {
		// addr 先保证与 page size 对齐
		addr = PAGE_ALIGN(addr);
		// 内核这里需要确认一下指定的 [addr, addr+len] 这段虚拟内存区域是否存在已有的映射关系
		// 若[addr, addr+len] 地址范围内已经存在映射关系，则不能按照指定的 addr 作为映射起始地址
		// 在进程地址空间中查找第一个符合 addr < vma->vm_end  条件的 vma
		// 如果不存在这样一个 vma（!vma）, 则表示 [addr, addr+len] 这段范围的虚拟内存是可以使用的，内核将会从指定的 addr 开始映射
        // 如果存在这样一个 vma ，则表示  [addr, addr+len] 这段范围的虚拟内存区域目前已经存在映射关系了，不能采用 addr 作为映射起始地址
        // 这里还有一种情况是 addr 落在 prev 和 vma 之间的一块未映射区域
        // 如果这块未映射区域的长度满足 len 大小，那么这段未映射区域可以被本次使用，内核也会从指定的 addr 开始映射
		vma = find_vma(mm, addr);
		if (TASK_SIZE - len >= addr && addr >= mmap_min_addr &&
		    (!vma || addr + len <= vma->vm_start))
			return addr;
	}
	// 如果明确指定 addr 但是指定的虚拟内存范围是一段无效的区域或者已经存在映射关系
    // 那么内核会自动在地址空间中寻找一段合适的虚拟内存范围出来，这段虚拟内存范围的起始地址就不是指定的 addr
	info.flags = 0;
	// vma 区域长度
	info.length = len;
	// 定义从哪里开始查找 vma, mmap_base 表示从文件映射与匿名映射区开始查找
	info.low_limit = mm->mmap_base;
	// 查找结束位置为进程地址空间的末尾 TASK_SIZE
	info.high_limit = TASK_SIZE;
	info.align_mask = 0;

	//见下
	return vm_unmapped_area(&info);
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/mmap.c#L2097
struct vm_area_struct *find_vma(struct mm_struct *mm, unsigned long addr)
{
	struct rb_node *rb_node;
	struct vm_area_struct *vma;

	/* Check the cache first. */
	// 进程地址空间中缓存了最近访问过的 vma，首先从进程地址空间中 vma 缓存中开始查找，缓存命中率通常大约为 35%
    // 查找条件为：vma->vm_start <= addr && vma->vm_end > addr
	vma = vmacache_find(mm, addr);
	if (likely(vma))
		return vma;
	
	// 进程地址空间中的所有 vma 被组织在一颗红黑树中，为了方便内核在进程地址空间中快速查找特定的 vma
    // 这里首先需要获取红黑树的根节点，内核会从根节点开始查找
	rb_node = mm->mm_rb.rb_node;

	while (rb_node) {
		struct vm_area_struct *tmp;
		// 获取位于根节点的 vma
		tmp = rb_entry(rb_node, struct vm_area_struct, vm_rb);
		
		if (tmp->vm_end > addr) {
			vma = tmp;
			// 判断 addr 是否恰好落在根节点 vma 中： vm_start <= addr < vm_end
			if (tmp->vm_start <= addr)
				break;
			rb_node = rb_node->rb_left;	// 如果不存在，则继续到左子树中查找
		} else{
			// 如果根节点的 vm_end <= addr，说明 addr 在根节点 vma 的后边，这种情况则到右子树中继续查找
			rb_node = rb_node->rb_right;
		}
	}

	if (vma){	
		// 更新 vma 缓存
		vmacache_update(addr, vma);
	}
	// 返回查找到的 vma，如果没有查找到，则返回 null，表示进程空间中目前还没有这样一个 vma，后续需要新建
	return vma;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/include/linux/mm.h#L2169
static inline unsigned long
vm_unmapped_area(struct vm_unmapped_area_info *info)
{	
	// 按照进程虚拟内存空间中文件映射与匿名映射区的地址增长方向分为两个函数，用来在进程地址空间中查找未映射的 vma
	if (info->flags & VM_UNMAPPED_AREA_TOPDOWN)
		// 当文件映射与匿名映射区的地址增长方向是从上到下逆向增长时（新式布局），采用 topdown 查找
		return unmapped_area_topdown(info);
	else
		// 地址增长方向为从下倒上正向增长（经典布局），采用该函数查找，本文主要分析此函数的实现
		// 在 AMD64 体系结构下，文件映射与匿名映射区的布局采用的是经典布局，地址的增长方向从低地址到高地址增长
		return unmapped_area(info);
}

unsigned long unmapped_area(struct vm_unmapped_area_info *info)
{
	/*
	 * We implement the search by looking for an rbtree node that
	 * immediately follows a suitable gap. That is,
	 * - gap_start = vma->vm_prev->vm_end <= info->high_limit - length;
	 * - gap_end   = vma->vm_start        >= info->low_limit  + length;
	 * - gap_end - gap_start >= length
	 */

	struct mm_struct *mm = current->mm;
	// 寻找未映射区域的参考 vma (该区域已存在映射关系)
	struct vm_area_struct *vma;
	// 未映射区域产生在 vma->vm_prev 与 vma 这两个虚拟内存区域中的间隙 gap 中，length 表示本次映射区域的长度
    // low_limit ，high_limit 表示在进程地址空间中哪段地址范围内查找，一个地址下限（mm->mmap_base），另一个标识地址上限（TASK_SIZE）
    // gap_start, gap_end 表示 vma->vm_prev 与 vma 之间的 gap 范围，unmapped_area 将会在这里产生
	unsigned long length, low_limit, high_limit, gap_start, gap_end;

	/* Adjust search length to account for worst case alignment overhead */
	// 调整搜索长度以考虑最坏情况下的对齐开销
	length = info->length + info->align_mask;
	if (length < info->length)
		return -ENOMEM;

	/* Adjust search limits by the desired length */
	// 根据需要的长度调整搜索限制
	if (info->high_limit < length)
		return -ENOMEM;

	// gap_start 需要满足的条件：gap_start =  vma->vm_prev->vm_end <= info->high_limit - length
    // 否则 unmapped_area 将会超出 high_limit 的限制
	high_limit = info->high_limit - length;

	if (info->low_limit > high_limit)
		return -ENOMEM;

	// gap_end 需要满足的条件：gap_end = vma->vm_start >= info->low_limit + length
    // 否则 unmapped_area 将会超出 low_limit 的限制
	low_limit = info->low_limit + length;

	/* Check if rbtree root looks promising */
	// 首先将 vma 红黑树的根节点作为 gap 的参考 vma，检查根节点是否符合
	if (RB_EMPTY_ROOT(&mm->mm_rb))
		goto check_highest;
	
	// 获取红黑树根节点的 vma
	vma = rb_entry(mm->mm_rb.rb_node, struct vm_area_struct, vm_rb);

	// rb_subtree_gap 为当前 vma 及其左右子树中所有 vma 与其对应 vm_prev 之间最大的虚拟内存地址 gap
    // 最大的 gap 如果都不能满足映射长度 length 则跳转到 check_highest 处理
	if (vma->rb_subtree_gap < length)
		goto check_highest;	// 从进程地址空间最后一个 vma->vm_end 地址处开始映射

	while (true) {
		/* Visit left subtree if it looks promising */
		// 左子树，获取当前 vma 的 vm_start 起始虚拟内存地址作为 gap_end
		gap_end = vma->vm_start;
		// gap_end 需要满足：gap_end >= low_limit，否则 unmapped_area 将会超出 low_limit 的限制
        // 如果存在左子树，则需要继续到左子树中去查找，因为需要按照地址从低到高的优先级来查看合适的未映射区域
		if (gap_end >= low_limit && vma->vm_rb.rb_left) {
			struct vm_area_struct *left =
				rb_entry(vma->vm_rb.rb_left,
					 struct vm_area_struct, vm_rb);
			// 如果左子树中存在合适的 gap，则继续左子树的查找
            // 否则查找结束，gap 为当前 vma 与其 vm_prev 之间的间隙
			if (left->rb_subtree_gap >= length) {
				vma = left;
				continue;
			}
		}

		// 获取当前 vma->vm_prev 的 vm_end 作为 gap_start
		gap_start = vma->vm_prev ? vma->vm_prev->vm_end : 0;
check_current:
		/* Check if current node has a suitable gap */
		// gap_start 需要满足：gap_start <= high_limit，否则 unmapped_area 将会超出 high_limit 的限制
		if (gap_start > high_limit)
			return -ENOMEM;
		if (gap_end >= low_limit && gap_end - gap_start >= length)
			goto found;	// 找到了合适的 unmapped_area 跳转到 found 处理

		/* Visit right subtree if it looks promising */
		// 当前 vma 与其左子树中的所有 vma 均不存在一个合理的 gap，那么从 vma 的右子树中继续查找
		if (vma->vm_rb.rb_right) {
			struct vm_area_struct *right =
				rb_entry(vma->vm_rb.rb_right,
					 struct vm_area_struct, vm_rb);
			if (right->rb_subtree_gap >= length) {
				vma = right;
				continue;
			}
		}

		/* Go back up the rbtree to find next candidate node */
		// 如果在当前 vma 以及它的左右子树中均无法找到一个合适的 gap
        // 那么这里会从当前 vma 节点向上回溯整颗红黑树，在它的父节点中尝试查找是否有合适的 gap
        // 因为这时候有可能会有新的 vma 插入到红黑树中，可能会产生新的 gap
		while (true) {
			struct rb_node *prev = &vma->vm_rb;
			if (!rb_parent(prev))
				goto check_highest;
			vma = rb_entry(rb_parent(prev),
				       struct vm_area_struct, vm_rb);
			if (prev == vma->vm_rb.rb_left) {
				gap_start = vma->vm_prev->vm_end;
				gap_end = vma->vm_start;
				goto check_current;
			}
		}
	}

check_highest:
	/* Check highest gap, which does not precede any rbtree node */
	// 流程走到这里表示在当前进程虚拟内存空间的所有 vma 中都无法找到一个合适的 gap 来作为 unmapped_area
    // 那么就从进程地址空间中最后一个 vma->vm_end 开始映射
    // mm->highest_vm_end 表示当前进程虚拟内存空间中，地址最高的一个 vma 的结束地址位置
	gap_start = mm->highest_vm_end;
	gap_end = ULONG_MAX;  /* Only for VM_BUG_ON below */
	if (gap_start > high_limit)	// 这里最后需要检查剩余虚拟内存空间是否满足映射长度
		return -ENOMEM;

found:
	/* We found a suitable gap. Clip it with the original low_limit. */
	// 流程走到这里表示已经找到了一个合适的 gap 来作为 unmapped_area，直接返回 gap_start（需要与 4K 对齐）作为映射的起始地址
	if (gap_start < info->low_limit)
		gap_start = info->low_limit;

	/* Adjust gap address to the desired alignment */
	// 调整间隙地址到所需的对齐方式
	gap_start += (info->align_offset - gap_start) & info->align_mask;

	VM_BUG_ON(gap_start + info->length > info->high_limit);
	VM_BUG_ON(gap_start + info->length > gap_end);
	return gap_start;	// 返回找到的地址间隙 gap 
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/mmap.c#L1588
unsigned long mmap_region(struct file *file, unsigned long addr,
		unsigned long len, vm_flags_t vm_flags, unsigned long pgoff,
		struct list_head *uf)
{
	struct mm_struct *mm = current->mm;
	struct vm_area_struct *vma, *prev;
	int error;
	struct rb_node **rb_link, *rb_parent;
	unsigned long charged = 0;

	/* Check against address space limit. */
	// 再次检查本次映射是否超过了进程虚拟内存空间中的虚拟内存容量的限制，超过则返回 false
	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.
		 */
		// 如果 mmap 指定了 MAP_FIXED，表示内核必须要按照用户指定的映射区来进行映射
        // 这种情况下就会导致，指定的映射区 [addr, addr + len] 有一部分可能与现有映射重叠
        // 内核将会覆盖掉这段已有的映射，重新按照用户指定的映射关系进行映射
        // 所以这里需要计算进程地址空间中与指定映射区[addr, addr + len]重叠的虚拟内存页数 nr_pages
		nr_pages = count_vma_pages_range(mm, addr, addr + len);

		// 由于这里的 nr_pages 表示重叠的虚拟内存部分，将会被覆盖，所以这部分被覆盖的虚拟内存不需要额外申请
        // 这里通过 len >> PAGE_SHIFT 减去这段可以被覆盖的 nr_pages 在重新检查是否超过虚拟内存相关区域的限额
		if (!may_expand_vm(mm, vm_flags,
					(len >> PAGE_SHIFT) - nr_pages))
			return -ENOMEM;
	}

	/* Clear old maps */
	// 如果当前进程虚拟内存地址空间中存在指定映射区域 [addr, addr + len] 重叠的部分
	while (find_vma_links(mm, addr, addr + len, &prev, &rb_link,
			      &rb_parent)) {
		// 调用 do_munmap 将这段重叠的映射部分解除掉，后续会重新映射这部分
		if (do_munmap(mm, addr, len, uf))
			return -ENOMEM;
	}

	/*
	 * Private writable mapping: check memory availability
	*/
	// 判断将来是否会为这段虚拟内存 vma 申请新的物理内存，比如:私有、可写(private writable)的映射方式，内核将来会通过 cow 重新为其分配新的物理内存。
    // 私有、只读（private readonly）的映射方式，内核则会共享原来映射的物理内存，而不会申请新的物理内存
    // 如果将来需要申请新的物理内存则会根据当前系统的 overcommit 策略以及当前物理内存的使用情况来  
    // 综合判断是否允许本次虚拟内存的申请。如果虚拟内存不足，则返回 ENOMEM，这样的话可以防止缺页的时候发生 OOM
	if (accountable_mapping(file, vm_flags)) {
		charged = len >> PAGE_SHIFT;
		// 根据内核 overcommit 策略以及当前物理内存的使用情况综合判断，是否能够通过本次虚拟内存的申请
        // 虚拟内存的申请一旦这里通过之后，后续发生缺页，内核将会有足够的物理内存为其分配，不会发生 OOM
		if (security_vm_enough_memory_mm(mm, charged))
			return -ENOMEM;

		// 凡是设置了 VM_ACCOUNT 的 vma，表示这段虚拟内存均已经过 vm_enough_memory 的检测
        // 当虚拟内存发生缺页的时候，内核会有足够的物理内存分配，而不会导致 OOM 
        // 其虚拟内存的用量都会被统计在 /proc/meminfo 的 Committed_AS 字段中    
		vm_flags |= VM_ACCOUNT;
	}

	/*
	 * Can we just expand an old mapping?
	 */
	// 为了精细化的控制内存的开销，内核这里首先需要尝试看能不能和地址空间中已有的 vma 进行合并，尝试将当前 vma 合并到已有的 vma 中
	vma = vma_merge(mm, prev, addr, addr + len, vm_flags,
			NULL, file, pgoff, NULL, NULL_VM_UFFD_CTX);
	if (vma)
		goto out;	 // 如果可以合并，则虚拟内存分配过程结束

	/*
	 * Determine the object being mapped and call the appropriate
	 * specific mapper. the address has already been validated, but
	 * not unmapped, but the maps are removed from the list.
	 */
	// 如果无法合并，则只能从 slab 中取出一个新的 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);

	// 重要：经过PAGE_SHIFT对齐的用户传入的offset参数，最终会存储在vma结构的vm_pgoff成员中
	// 注意：这个单位是页数（按PAGE_SHIFT）
	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;
		}

		/* ->mmap() can change vma->vm_file, but must guarantee that
		 * vma_link() below can deny write-access if VM_DENYWRITE is set
		 * and map writably if VM_SHARED is set. This usually means the
		 * new file must not have been exposed to user-space, yet.
		 */
        //重要：将文件与虚拟内存映射起来（vma关联struct file对象）
		// 递增 file 的引用次数，返回 file 赋给 vma
		vma->vm_file = get_file(file);

		//重要：
		// 将虚拟内存区域 vma 的操作函数 vm_ops 映射成文件的操作函数（和具体文件系统有关）
        // ext4 文件系统中的操作函数为 ext4_file_vm_ops，此刻开始，读写内存就和读写文件是一样的了
		// call_mmap：调用内核的mmap函数
		error = call_mmap(file, vma);
		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);
		// 文件系统提供的mmap函数可能会修改映射的一些参数。在这里需要在调用 vma_link 前回置
		addr = vma->vm_start;
		vm_flags = vma->vm_flags;
	} else if (vm_flags & VM_SHARED) {
		// 重要：共享匿名映射
		// 共享匿名映射依赖于 tmpfs 文件系统中的匿名文件 /dev/zero，父子进程通过这个匿名文件进行通讯
        // 该函数用于在 tmpfs 中创建匿名文件，并映射进当前共享匿名映射区 vma 中
		error = shmem_zero_setup(vma);
		if (error)
			goto free_vma;
	}
	/*
	else { // 私有匿名映射
        // 将 vma->vm_ops 设置为 null，只有文件映射才需要 vm_ops 这样才能将内存与文件映射起来
		vma_set_anonymous(vma);
	}
	*/


	// 重要：将当前 vma 按照地址的增长方向插入到进程虚拟内存空间的 mm_struct->mmap 链表
	// 以及 mm_struct->mm_rb 红黑树中，并建立文件与 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);
	// 进程内存状态统计，在开启了 perf 时才会有
	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;
	// 更新地址空间 mm_struct 中的相关统计变量
	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;
}

struct mm_struct {
	......
    // 进程地址空间中所有已经映射的虚拟内存页总数
    unsigned long total_vm;    /* Total pages mapped */
    // 进程地址空间中所有私有，可写的虚拟内存页总数
    unsigned long data_vm;     /* VM_WRITE & ~VM_SHARED & ~VM_STACK */
	......
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/mmap.c#L3102
bool may_expand_vm(struct mm_struct *mm, vm_flags_t flags, unsigned long npages)
{
	// mm->total_vm 表示当前进程地址空间中映射的虚拟内存页总数
    // npages 表示此次要映射的虚拟内存页个数
    // rlimit(RLIMIT_AS) 表示进程地址空间中允许映射的虚拟内存总量，单位为字节
	if (mm->total_vm + npages > rlimit(RLIMIT_AS) >> PAGE_SHIFT)
		// 如果映射的虚拟内存页总数超出了内核的限制，那么就返回 false 表示虚拟内存不足
		return false;

	// 检查本次映射是否属于数据区域的映射，这里的数据区域指的是私有，可写的虚拟内存区域（栈区除外）
    // 如果是则需要检查数据区域里的虚拟内存页是否超过了内核的限制
    // rlimit(RLIMIT_DATA) 表示进程地址空间中允许映射的私有，可写的虚拟内存总量，单位为字节
    // 如果超过则返回 false，表示数据区虚拟内存不足
	if (is_data_mapping(flags) &&
	    mm->data_vm + npages > rlimit(RLIMIT_DATA) >> PAGE_SHIFT) {
		/* Workaround for Valgrind */
		if (rlimit(RLIMIT_DATA) == 0 &&
		    mm->data_vm + npages <= rlimit_max(RLIMIT_DATA) >> PAGE_SHIFT)
			return true;
		if (!ignore_rlimit_data) {
			pr_warn_once("%s (%d): VmData %lu exceed data ulimit %lu. Update limits or use boot option ignore_rlimit_data.\n",
				     current->comm, current->pid,
				     (mm->data_vm + npages) << PAGE_SHIFT,
				     rlimit(RLIMIT_DATA));
			return false;
		}
	}

	return true;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/mmap.c#L475
static int find_vma_links(struct mm_struct *mm, unsigned long addr,
		unsigned long end, struct vm_area_struct **pprev,
		struct rb_node ***rb_link, struct rb_node **rb_parent)
{
	struct rb_node **__rb_link, *__rb_parent, *rb_prev;

	// 获取红黑树的根节点
	__rb_link = &mm->mm_rb.rb_node;
	rb_prev = __rb_parent = NULL;

	// 遍历整棵红黑树，为[addr,addr+len]这段内存区域查找合适的插入位置
	while (*__rb_link) {
		struct vm_area_struct *vma_tmp;

		__rb_parent = *__rb_link;
		vma_tmp = rb_entry(__rb_parent, struct vm_area_struct, vm_rb);
		// 插入的 vma 起始地址小于当前红黑树节点 vma 结束地址，则遍历红黑树左子树
		if (vma_tmp->vm_end > addr) {
			// 如果红黑树中现有 vma 与该映射区域重叠，则返回失败
			/* Fail if an existing vma overlaps the area */
			if (vma_tmp->vm_start < end)
				return -ENOMEM;
			__rb_link = &__rb_parent->rb_left;	// 向左走，循环遍历查找左子树
		} else {
			//当 vma_tmp->vm_end <= addr时，说明
			// 插入的 vma 起始地址大于当前红黑树节点 vma 结束地址，则遍历红黑树右子树，说明红黑树左子节点到右子节点的VMA区域程递增趋势

			// 更新待插入 vma 节点的前一个节点，即其父节点
			rb_prev = __rb_parent;
			// 向右走循环遍历查找右子树
			__rb_link = &__rb_parent->rb_right;
		}
	}

	//走完了
	// pprev 待插入 vma 节点的前一个节点的 vma，如果 rb_prev 为空，说明待插入节点是最左子节点，在链表mm->mmap中是头节点
	*pprev = NULL;
	if (rb_prev)
		*pprev = rb_entry(rb_prev, struct vm_area_struct, vm_rb);
	*rb_link = __rb_link;	// 查找到的待插入 vma 节点位置
	*rb_parent = __rb_parent;	 // 待插入位置节点的父节点
	return 0;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/mmap.c#L1084
struct vm_area_struct *vma_merge(struct mm_struct *mm,
			struct vm_area_struct *prev, unsigned long addr,
			unsigned long end, unsigned long vm_flags,
			struct anon_vma *anon_vma, struct file *file,
			pgoff_t pgoff, struct mempolicy *policy,
			struct vm_userfaultfd_ctx vm_userfaultfd_ctx)
{
	// pglen：本次需要创建的 vma 区域大小
	pgoff_t pglen = (end - addr) >> PAGE_SHIFT;
	// area 表示当前要创建的 vma，next 表示 area 的下一个 vma
    // 事实上 area 会在其 prev 前一个 vma 和 next 后一个 vma 之间的间隙 gap 中创建产生
	struct vm_area_struct *area, *next;
	int err;

	/*
	 * We later require that vma->vm_flags == vm_flags,
	 * so this tests vma->vm_flags & VM_SPECIAL, too.
	 */
	// 设置了 VM_SPECIAL 表示 area 区域是不可以被合并的，只能重新创建 vma，并直接退出合并流程
	if (vm_flags & VM_SPECIAL)
		return NULL;
	
	// 根据 prev vma 是否存在，设置 area 的 next vma
	if (prev){
		// area 将在 prev vma 和 next vma 的间隙 gap 中产生
		next = prev->vm_next;
	}
	else{
		// 如果 prev 不存在，那么 next 就设置为地址空间中的第一个 vma
		next = mm->mmap;
	}
	area = next;

	// 新 vma 的 end 与 next->vm_end 相等，表示新 vma 与 next vma 是重合的
    // 那么 next 指向下一个 vma，prev 和 next 这里的语义是始终指向 area 区域的前一个和后一个 vma
	if (area && area->vm_end == end)		/* cases 6, 7, 8 */
		next = next->vm_next;

	/* verify some invariant that must be enforced by the caller */
	VM_WARN_ON(prev && addr <= prev->vm_start);
	VM_WARN_ON(area && end > area->vm_end);
	VM_WARN_ON(addr >= end);

	/*
	 * Can it merge with the predecessor?
	 */
	// 判断 area 是否能够和 prev 进行合并
	if (prev && prev->vm_end == addr &&
			mpol_equal(vma_policy(prev), policy) &&
			can_vma_merge_after(prev, vm_flags,
					    anon_vma, file, pgoff,
					    vm_userfaultfd_ctx)) {
		/*
		 * OK, it can.  Can we now merge in the successor as well?
		 */
		// 如果 area 可以和 prev 进行合并，那么这里继续判断 area 能够与 next 进行合并
        // 内核这里需要保证 vma 合并程度的最大化
		if (next && end == next->vm_start &&
				mpol_equal(policy, vma_policy(next)) &&
				can_vma_merge_before(next, vm_flags,
						     anon_vma, file,
						     pgoff+pglen,
						     vm_userfaultfd_ctx) &&
				is_mergeable_anon_vma(prev->anon_vma,
						      next->anon_vma, NULL)) {
							/* cases 1, 6 */
			// 到此则表示 area 可以和它的 prev，next 区域进行合并  
            // __vma_adjust 是真正执行 vma 合并操作的函数，会重新调整已有 vma 的相关属性，比如：vm_start,vm_end,vm_pgoff。
            // 以及涉及到相关数据结构的改变
			err = __vma_adjust(prev, prev->vm_start,
					 next->vm_end, prev->vm_pgoff, NULL,
					 prev);
		} else{					/* cases 2, 5, 7 */
			// 流程到此则表示 area 只能和 prev 进行合并
			err = __vma_adjust(prev, prev->vm_start,
					 end, prev->vm_pgoff, NULL, prev);
		}
		if (err)
			return NULL;
		khugepaged_enter_vma_merge(prev, vm_flags);
		// 返回最终合并好的 vma
		return prev;	
	}

	/*
	 * Can this new request be merged in front of next?
	 */
	// 下面这种情况属于，area 的结束地址 end 与 next 的起始地址是重合的
    // 但是 area 的起始地址 start 和 prev 的结束地址不是重合的
	if (next && end == next->vm_start &&
			mpol_equal(policy, vma_policy(next)) &&
			can_vma_merge_before(next, vm_flags,
					     anon_vma, file, pgoff+pglen,
					     vm_userfaultfd_ctx)) {

		// area 区域前半部分和 prev 区域的后半部分重合
        // 那么就缩小 prev 区域，然后将 area 合并到 next 区域
		if (prev && addr < prev->vm_end)	/* case 4 */
			err = __vma_adjust(prev, prev->vm_start,
					 addr, prev->vm_pgoff, NULL, next);
		else {					/* cases 3, 8 */
			// area 区域前半部分和 prev 区域是有间隙 gap 的
            // 那么这种情况下 prev 不变，area 合并到 next 中
			err = __vma_adjust(area, addr, next->vm_end,
					 next->vm_pgoff - pglen, NULL, next);
			/*
			 * In case 3 area is already equal to next and
			 * this is a noop, but in case 8 "area" has
			 * been removed and next was expanded over it.
			 */
			// 合并后的 area
			area = next;
		}
		if (err)
			return NULL;
		khugepaged_enter_vma_merge(area, vm_flags);
		return area;	// 返回合并后的 vma
	}
	// prev 的结束地址不与 area 的起始地址重合，并且 area 的结束地址不与 next 的起始地址重合
	  
    // 这种情况就不能执行合并，需要为 area 重新创建新的 vma 结构
	return NULL;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/mmap.c#L589
static void vma_link(struct mm_struct *mm, struct vm_area_struct *vma,
			struct vm_area_struct *prev, struct rb_node **rb_link,
			struct rb_node *rb_parent)
{	
	// 文件 page cache
	struct address_space *mapping = NULL;

	if (vma->vm_file) {
		// 文件映射场景：
		// 获取映射文件的 page cache
		mapping = vma->vm_file->f_mapping;
		i_mmap_lock_write(mapping);
	}

	// 将 vma 插入到地址空间中的 vma 链表 mm_struct->mmap 以及红黑树 mm_struct->mm_rb 中
	__vma_link(mm, vma, prev, rb_link, rb_parent);
	// 建立文件与 vma 的反向映射（TODO）
	__vma_link_file(vma);

	if (mapping)
		i_mmap_unlock_write(mapping);
	
	// map_count 表示进程地址空间中 vma 的个数
	mm->map_count++;
	validate_mm(mm);
}

//i_mmap指向的是一颗红黑树，这颗红黑树正是文件页反向映射的核心数据结构，反向映射关系就保存在这里
struct address_space {
	......
    struct inode        *host;      /* owner: inode, block_device */
    // page cache
    struct radix_tree_root  i_pages;    /* cached pages */
    atomic_t        i_mmap_writable;/* count VM_SHARED mappings */
    // 文件与 vma 反向映射的核心数据结构，i_mmap 也是一颗红黑树
    // 在所有进程的地址空间中，只要与该文件发生映射的 vma 均挂在 i_mmap 中
    struct rb_root_cached   i_mmap;     /* tree of private and shared mappings */
	......
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/mmap.c#L561
static void __vma_link_file(struct vm_area_struct *vma)
{
	struct file *file;

	file = vma->vm_file;
	if (file) {
		struct address_space *mapping = file->f_mapping;
		......

		flush_dcache_mmap_lock(mapping);
		// address_space->i_mmap 也是一颗红黑树，上面挂着的是与该文件映射的所有 vma（所有进程地址空间）
        // 这里将 vma 插入到 i_mmap 中，实现文件与 vma 的反向映射
		vma_interval_tree_insert(vma, &mapping->i_mmap);
		flush_dcache_mmap_unlock(mapping);
	}
}

//https://elixir.bootlin.com/linux/v4.11.6/source/include/linux/fs.h#L1736
static inline int call_mmap(struct file *file, struct vm_area_struct *vma)
{
    //对ext4系统而言，mmap对应于ext4_file_mmap函数
	//核心功能是完成将vma的vm_ops成员与ext4文件系统实现的ext4_file_vm_ops绑定
	return file->f_op->mmap(file, vma);
}

struct file_operations {
	......
	int (*mmap) (struct file *, struct vm_area_struct *); 
	// mmap 函数用于将将设备的内存映射到进程空间中(也就是用户空间)，以避免在用户空间和内核空间之间来回复制
	......
} __randomize_layout;

static const struct vm_operations_struct ext4_file_vm_ops = {
	.fault		= ext4_filemap_fault,
	.map_pages	= filemap_map_pages,
	.page_mkwrite   = ext4_page_mkwrite,
};

// mmap 系统调用
void *mmap(void *addr,     // 期望的起始地址（可以为NULL）
           size_t length,  // 映射长度
           int prot,       // 保护标志
           int flags,      // 映射标志
           int fd,         // 文件描述符
           off_t offset);  // 文件偏移
           
// remap_pfn_range 函数
int remap_pfn_range(struct vm_area_struct *vma,  // 内核VMA结构
                    unsigned long addr,           // 实际映射起始地址
                    unsigned long pfn,            // 物理页帧号
                    unsigned long size,           // 映射大小
                    pgprot_t prot);               // 保护标志

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/memory.c#L1876

/**
 * remap_pfn_range - remap kernel memory to userspace
 * @vma: user vma to map to：虚拟内存区域结构体指针，描述了要进行映射的虚拟内存区域。
 * @addr: target user address to start at：用户空间中要映射的虚拟地址的起始地址。
 * @pfn: physical address of kernel memory：物理页帧号的起始地址，即要映射的物理页面在内存中的索引。
 * @size: size of map area：要映射的内存区域大小。
 * @prot: page protection flags for this mapping：要应用于映射区域的页面保护标志，通常使用 vm_page_prot 定义。
*/
int remap_pfn_range(struct vm_area_struct *vma, unsigned long addr,
		    unsigned long pfn, unsigned long size, pgprot_t prot)
{
	pgd_t *pgd;
	unsigned long next;
	// 需要映射的虚拟地址尾部：注意要页对齐，因为cpu硬件是以页为单位管理内存的
	unsigned long end = addr + PAGE_ALIGN(size);
	struct mm_struct *mm = vma->vm_mm;
	unsigned long remap_pfn = pfn;
	int err;

	// 判断该页是否支持写时复制 cow
	if (is_cow_mapping(vma->vm_flags)) {
		if (addr != vma->vm_start || end != vma->vm_end)
			return -EINVAL;
		vma->vm_pgoff = pfn;
	}

	err = track_pfn_remap(vma, &prot, remap_pfn, addr, PAGE_ALIGN(size));
	if (err)
		return -EINVAL;
	
	// 改变虚拟地址的标志
	vma->vm_flags |= VM_IO | VM_PFNMAP | VM_DONTEXPAND | VM_DONTDUMP;

	BUG_ON(addr >= end);
	pfn -= addr >> PAGE_SHIFT;
	// 查找 addr 在页全局目录项中对应的页表项的地址（很熟悉吧）
	pgd = pgd_offset(mm, addr);

	// 刷新 TLB 缓存，这个缓存和 CPU 的L1、L2、L3的缓存思想一致，既然进行地址转换需要的内存 IO 次数多，且耗时，
    // 那么干脆就在 CPU 里把页表尽可能地 cache 起来不就行了么，所以就有了 TLB(Translation Lookaside Buffer)
    // 专门用于改进虚拟地址到物理地址转换速度的缓存，其访问速度非常快，和寄存器相当，比 L1 访问还快
	flush_cache_range(vma, addr, end);
	do {
		// 计算下一个将要被映射的虚拟地址，如果 addr 到 end 可以被一个 pgd 映射的话，那么返回 end 的值
		next = pgd_addr_end(addr, end);

		// 核心：完成虚拟内存和物理内存映射，本质就是填写完 CR3 指向的页表
        // 过程就是逐级完成：1级是pgd，上面pgd_offset已经完成；2级是pud，3级是pmd，4级是pte
		err = remap_p4d_range(mm, pgd, addr, next,
				pfn + (addr >> PAGE_SHIFT), prot);
		if (err)
			break;
	} while (pgd++, addr = next, addr != end);

	if (err)
		untrack_pfn(vma, remap_pfn, PAGE_ALIGN(size));

	return err;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/memory.c#L1846
static inline int remap_p4d_range(struct mm_struct *mm, pgd_t *pgd,
			unsigned long addr, unsigned long end,
			unsigned long pfn, pgprot_t prot)
{
	// p4d 在五级页表下会使用，在四级页表下 p4d 与 pgd 的值一样
	p4d_t *p4d;
	unsigned long next;

	pfn -= addr >> PAGE_SHIFT;
	// 在四级页表下，这里只是将 pgd 赋值给 p4d，后续均以 p4d 作为全局页目录项
	p4d = p4d_alloc(mm, pgd, addr);
	if (!p4d)
		return -ENOMEM;
	do {
		// 计算下一个将要被映射的虚拟地址，如果 addr 到 end 可以被一个 pud 映射的话，那么返回 end 的值
		next = p4d_addr_end(addr, end);
		// 完成虚拟内存和物理内存映射，补齐页全局目录表
		if (remap_pud_range(mm, p4d, addr, next,
				pfn + (addr >> PAGE_SHIFT), prot))
			return -ENOMEM;
	} while (p4d++, addr = next, addr != end);
	return 0;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/memory.c#L1826
static inline int remap_pud_range(struct mm_struct *mm, p4d_t *p4d,
			unsigned long addr, unsigned long end,
			unsigned long pfn, pgprot_t prot)
{
	pud_t *pud;
	unsigned long next;

	pfn -= addr >> PAGE_SHIFT;
	// 首先 p4d_none 判断全局页目录项 p4d 是否是空的
    // 如果 p4d 是空的，则调用 __pud_alloc 分配一个新的页上级目录表 PUD，然后填充 p4d
    // 如果 p4d 不是空的，则调用 pud_offset 获取 address 在页上级目录 PUD 中的目录项 pud
	pud = pud_alloc(mm, p4d, addr);
	if (!pud)
		return -ENOMEM;
	do {
		// 计算下一个将要被映射的虚拟地址，如果 addr 到 end 可以被一个 pud 映射的话，那么返回 end 的值
		next = pud_addr_end(addr, end);
		// 完成虚拟内存和物理内存映射，补齐页上级目录表
		if (remap_pmd_range(mm, pud, addr, next,
				pfn + (addr >> PAGE_SHIFT), prot))
			return -ENOMEM;
	} while (pud++, addr = next, addr != end);
	return 0;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/memory.c#L1805
static inline int remap_pmd_range(struct mm_struct *mm, pud_t *pud,
			unsigned long addr, unsigned long end,
			unsigned long pfn, pgprot_t prot)
{
	pmd_t *pmd;
	unsigned long next;

	pfn -= addr >> PAGE_SHIFT;
	// 首先 pud_none 判断页上级目录项 pud 是不是空的
    // 如果 pud 是空的，则调用 __pmd_alloc 分配一个新的页中间目录表 PMD，然后填充 pud
    // 如果 pud 不是空的，则调用 pmd_offset 获取 address 在页中间目录 PMD 中的目录项 pmd
	pmd = pmd_alloc(mm, pud, addr);
	if (!pmd)
		return -ENOMEM;
	VM_BUG_ON(pmd_trans_huge(*pmd));
	do {
		// 计算下一个将要被映射的虚拟地址，如果 addr 到 end 可以被一个 pmd 映射的话，那么返回 end 的值
		next = pmd_addr_end(addr, end);
		// 完成虚拟内存和物理内存映射，补齐页中间目录表
		if (remap_pte_range(mm, pmd, addr, next,
				pfn + (addr >> PAGE_SHIFT), prot))
			return -ENOMEM;
	} while (pmd++, addr = next, addr != end);
	return 0;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/memory.c#L1784
static int remap_pte_range(struct mm_struct *mm, pmd_t *pmd,
			unsigned long addr, unsigned long end,
			unsigned long pfn, pgprot_t prot)
{
	pte_t *pte;
	spinlock_t *ptl;

	// 首先 pte_alloc 判断页中间目录项 pmd 是不是空的
	// 如果 pmd 是空的，则调用 __pte_alloc 分配一个新的页表 pt，然后填充 pmd
	// 如果 pmd 不是空的，则调用 pte_offset_map_lock 获取 address 在页表 PT 中的页表项 pte
	pte = pte_alloc_map_lock(mm, pmd, addr, &ptl);
	if (!pte)
		return -ENOMEM;
	arch_enter_lazy_mmu_mode();
	do {
		BUG_ON(!pte_none(*pte));
		// 这是映射的最后一级：把物理地址的值填写到 pte 表项
		// pte_mkspecial 函数构造页表项的内容，set_pte_at 函数将构造的页表项赋值给页表中的 pte
		set_pte_at(mm, addr, pte, pte_mkspecial(pfn_pte(pfn, prot)));
		// 页帧号加 1，即下一个将要被映射的物理页帧号
		pfn++;
	} while (pte++, addr += PAGE_SIZE, addr != end);	// 计算页表中下一个将要被填充的页表项的地址
	arch_leave_lazy_mmu_mode();
	pte_unmap_unlock(pte - 1, ptl);
	return 0;
}

const struct file_operations ext4_file_operations = {
	......
	.mmap		= ext4_file_mmap,
	.get_unmapped_area = thp_get_unmapped_area,
    ......
};

static int ext4_file_mmap(struct file *file, struct vm_area_struct *vma)
{
	struct inode *inode = file->f_mapping->host;

	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
		return -EIO;

	if (ext4_encrypted_inode(inode)) {
		int err = fscrypt_get_encryption_info(inode);
		if (err)
			return 0;
		if (!fscrypt_has_encryption_key(inode))
			return -ENOKEY;
	}
	file_accessed(file);
	if (IS_DAX(file_inode(file))) {
		vma->vm_ops = &ext4_dax_vm_ops;
		vma->vm_flags |= VM_MIXEDMAP | VM_HUGEPAGE;
	} else {
		// 将ext4_file_vm_ops实现绑定到vma->vm_ops 
		vma->vm_ops = &ext4_file_vm_ops;
	}
	return 0;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/shmem.c#L4216
int shmem_zero_setup(struct vm_area_struct *vma)
{
    struct file *file;
    loff_t size = vma->vm_end - vma->vm_start;
    // tmpfs 中获取一个匿名文件
    file = shmem_kernel_file_setup("dev/zero", size, vma->vm_flags);
    if (IS_ERR(file))
        return PTR_ERR(file);

    if (vma->vm_file)
        // 如果 vma 中已存在其他文件，则解除与其他文件的映射关系
        fput(vma->vm_file);
    
    // 将 tmpfs 中的匿名文件映射进虚拟内存区域 vma 中
    // 后续 fork 子进程的时候，父子进程就可以通过这个匿名文件实现共享匿名映射 
    vma->vm_file = file;
    // 对这块共享匿名映射区相关操作这里直接映射成 shmem_vm_ops
    vma->vm_ops = &shmem_vm_ops;

    return 0;
}

static const struct vm_operations_struct shmem_vm_ops = {
	.fault		= shmem_fault,
	.map_pages	= filemap_map_pages,
#ifdef CONFIG_NUMA
	.set_policy     = shmem_set_policy,
	.get_policy     = shmem_get_policy,
#endif
};

// vma
struct vm_area_struct {
    unsigned long vm_pgoff;        // 重要：在映射文件中的偏移（页为单位）
    struct file * vm_file;         // 映射的文件指针
    const struct vm_operations_struct *vm_ops;  // 操作集，包含fault函数
    ......
};

// vm_fault
struct vm_fault {
    pgoff_t pgoff;                 // 缺页地址在文件中的页偏移
    unsigned long address;         // 缺页的虚拟地址
    struct vm_area_struct *vma;    // 对应的VMA
    ......
};

//https://elixir.bootlin.com/linux/v4.11.6/source/arch/x86/mm/fault.c#L1446
dotraplinkage void notrace
do_page_fault(struct pt_regs *regs, unsigned long error_code)
{
	unsigned long address = read_cr2(); /* Get the faulting address */
	enum ctx_state prev_state;

	prev_state = exception_enter();
	//重要：address即触发缺页中断的虚拟内存地址
	__do_page_fault(regs, error_code, address);
	exception_exit(prev_state);
}

//https://elixir.bootlin.com/linux/v4.11.6/source/arch/x86/mm/fault.c#L1215
static noinline void
__do_page_fault(struct pt_regs *regs, unsigned long error_code,
		unsigned long address)
{
	struct vm_area_struct *vma;
	struct task_struct *tsk;
	struct mm_struct *mm;
	int fault, major = 0;
	unsigned int flags = FAULT_FLAG_ALLOW_RETRY | FAULT_FLAG_KILLABLE;

	tsk = current;
	mm = tsk->mm;
	......
	
	// 根据虚拟内存地址找到vma
	vma = find_vma(mm, address);
	if (unlikely(!vma)) {
		bad_area(regs, error_code, address);
		return;
	}

	// 合法的vma校验
	if (likely(vma->vm_start <= address))
		goto good_area;
	if (unlikely(!(vma->vm_flags & VM_GROWSDOWN))) {
		bad_area(regs, error_code, address);
		return;
	}
	......
	/*
	 * Ok, we have a good vm_area for this memory access, so
	 * we can handle it..
	 */
good_area:
	if (unlikely(access_error(error_code, vma))) {
		bad_area_access_error(regs, error_code, address, vma);
		return;
	}

	// 核心：处理缺页中断的函数
	fault = handle_mm_fault(vma, address, flags);
	major |= fault & VM_FAULT_MAJOR;

	......
	check_v8086_mode(regs, address, tsk);
}

//https://elixir.bootlin.com/linux/v4.11.6/source/include/linux/pagemap.h#L423
static inline pgoff_t linear_page_index(struct vm_area_struct *vma,
					unsigned long address)
{
	pgoff_t pgoff;
	......
	pgoff = (address - vma->vm_start) >> PAGE_SHIFT;
	pgoff += vma->vm_pgoff;
	return pgoff;
}

static int __handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
		unsigned int flags)
{
	struct vm_fault vmf = {
		.vma = vma,
		.address = address & PAGE_MASK,
		.flags = flags,
		.pgoff = linear_page_index(vma, address),	//重要：计算文件页偏移（见下文分析）
		.gfp_mask = __get_fault_gfp_mask(vma),
	};
	struct mm_struct *mm = vma->vm_mm;
	pgd_t *pgd;
	p4d_t *p4d;
	int ret;

	pgd = pgd_offset(mm, address);
	p4d = p4d_alloc(mm, pgd, address);
	if (!p4d)
		return VM_FAULT_OOM;

	vmf.pud = pud_alloc(mm, p4d, address);
	if (!vmf.pud)
		return VM_FAULT_OOM;
	if (pud_none(*vmf.pud) && transparent_hugepage_enabled(vma)) {
		ret = create_huge_pud(&vmf);
		if (!(ret & VM_FAULT_FALLBACK))
			return ret;
	} else {
		pud_t orig_pud = *vmf.pud;

		barrier();
		if (pud_trans_huge(orig_pud) || pud_devmap(orig_pud)) {
			unsigned int dirty = flags & FAULT_FLAG_WRITE;

			/* NUMA case for anonymous PUDs would go here */

			if (dirty && !pud_write(orig_pud)) {
				ret = wp_huge_pud(&vmf, orig_pud);
				if (!(ret & VM_FAULT_FALLBACK))
					return ret;
			} else {
				huge_pud_set_accessed(&vmf, orig_pud);
				return 0;
			}
		}
	}

	vmf.pmd = pmd_alloc(mm, vmf.pud, address);
	if (!vmf.pmd)
		return VM_FAULT_OOM;
	if (pmd_none(*vmf.pmd) && transparent_hugepage_enabled(vma)) {
		ret = create_huge_pmd(&vmf);
		if (!(ret & VM_FAULT_FALLBACK))
			return ret;
	} else {
		pmd_t orig_pmd = *vmf.pmd;

		barrier();
		if (pmd_trans_huge(orig_pmd) || pmd_devmap(orig_pmd)) {
			if (pmd_protnone(orig_pmd) && vma_is_accessible(vma))
				return do_huge_pmd_numa_page(&vmf, orig_pmd);

			if ((vmf.flags & FAULT_FLAG_WRITE) &&
					!pmd_write(orig_pmd)) {
				ret = wp_huge_pmd(&vmf, orig_pmd);
				if (!(ret & VM_FAULT_FALLBACK))
					return ret;
			} else {
				huge_pmd_set_accessed(&vmf, orig_pmd);
				return 0;
			}
		}
	}

	return handle_pte_fault(&vmf);
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/memory.c#L3699
static int handle_pte_fault(struct vm_fault *vmf)
{
	......
	if (!vmf->pte) {
		if (vma_is_anonymous(vmf->vma)){
			// 匿名映射的缺页
			return do_anonymous_page(vmf);
		}
		else{
			// 文件映射的缺页
			return do_fault(vmf);
		}
	}
	......
}

// do_fault：缺页映射的核心实现
static int do_fault(struct vm_fault *vmf)
{
	struct vm_area_struct *vma = vmf->vma;
	int ret;

	/* The VMA was not fully populated on mmap() or missing VM_DONTEXPAND */
	if (!vma->vm_ops->fault)
		ret = VM_FAULT_SIGBUS;
	else if (!(vmf->flags & FAULT_FLAG_WRITE))	//只读
		ret = do_read_fault(vmf);
	else if (!(vma->vm_flags & VM_SHARED))
		ret = do_cow_fault(vmf);
	else
		ret = do_shared_fault(vmf);	// 共享+读写

	/* preallocated pagetable is unused: free it */
	if (vmf->prealloc_pte) {
		pte_free(vma->vm_mm, vmf->prealloc_pte);
		vmf->prealloc_pte = NULL;
	}
	return ret;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/memory.c#L3397
static int do_read_fault(struct vm_fault *vmf)
{
	struct vm_area_struct *vma = vmf->vma;
	int ret = 0;

	......
	//__do_fault
	ret = __do_fault(vmf);
	if (unlikely(ret & (VM_FAULT_ERROR | VM_FAULT_NOPAGE | VM_FAULT_RETRY)))
		return ret;

	ret |= finish_fault(vmf);
	unlock_page(vmf->page);
	if (unlikely(ret & (VM_FAULT_ERROR | VM_FAULT_NOPAGE | VM_FAULT_RETRY)))
		put_page(vmf->page);
	return ret;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/memory.c#L3006
static int __do_fault(struct vm_fault *vmf)
{
	struct vm_area_struct *vma = vmf->vma;
	int ret;

	//CALL ext4_filemap_fault->filemap_fault
	ret = vma->vm_ops->fault(vmf);
	......

	return ret;
}

// ext4文件系统的mmap文件映射
int ext4_filemap_fault(struct vm_fault *vmf)
{
	struct inode *inode = file_inode(vmf->vma->vm_file);
	int err;

	//调用filemap_fault，先加锁
	down_read(&EXT4_I(inode)->i_mmap_sem);
	// 最终调用filemap_fault实现
	// 包含了查找 address_space 和 新建 Page 的过程
	err = filemap_fault(vmf);
	up_read(&EXT4_I(inode)->i_mmap_sem);

	return err;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/filemap.c#L2174
// filemap_fault：核心任务是根据偏移量（pgoff）在 Page Cache 中拿到一个 struct page
int filemap_fault(struct vm_fault *vmf)
{
	int error;
	struct file *file = vmf->vma->vm_file;		// 获取mmap映射的文件
	struct address_space *mapping = file->f_mapping;	// 文件对应的地址空间（找到radix树即page cache管理入口）
	struct file_ra_state *ra = &file->f_ra;	 	// 预读状态
	struct inode *inode = mapping->host;		// 文件inode
	pgoff_t offset = vmf->pgoff;	
	// 重要：这就是从vm_area_struct获取的偏移（页数）
	// 在下面对本文件inode->address_space指向radix树进行查找时，使用的offset查找参数

	struct page *page;
	loff_t size;
	int ret = 0;

	// 边界检查，检查请求的页偏移是否超出文件大小
	size = round_up(i_size_read(inode), PAGE_SIZE);
	if (offset >= size >> PAGE_SHIFT)
		return VM_FAULT_SIGBUS;

	/*
	 * Do we have something in the page cache already?
	 */
	// 1. 首先在page cache中查找（第一次查找），首先尝试在page cache中查找指定偏移的页
	/*
	参数：vmf->pgoff是单个页面的偏移，只返回这一个页面的指针
	函数返回值vmf->page也指向单个页面
	*/
	page = find_get_page(mapping, offset);
	if (likely(page) && !(vmf->flags & FAULT_FLAG_TRIED)) {
		/*
		 * We found the page, so try async readahead before
		 * waiting for the lock.
		 */
		// 页面在cache中找到，页面命中处理
		// 执行异步预读，预读后续页面
		do_async_mmap_readahead(vmf->vma, ra, file, page, offset);
	} else if (!page) {
		// 2. 页面不在cache中，进行同步预读（页面未命中处理）
		/* No page in the page cache at all */
		do_sync_mmap_readahead(vmf->vma, ra, file, offset);

		//记录主要缺页事件（PGMAJFAULT）
		count_vm_event(PGMAJFAULT);
		mem_cgroup_count_vm_event(vmf->vma->vm_mm, PGMAJFAULT);
		
		//设置返回码为VM_FAULT_MAJOR（表示需要磁盘I/O）
		ret = VM_FAULT_MAJOR;
retry_find:
		// 3. 再次查找（重新尝试查找页面）
		page = find_get_page(mapping, offset);
		if (!page){
			// 4. 如果仍然没有，从磁盘读取
			goto no_cached_page;
		}
	}

	// 5. 等待页面就绪（尝试锁定页面），防止并发修改
	if (!lock_page_or_retry(page, vmf->vma->vm_mm, vmf->flags)) {
		put_page(page);
		return ret | VM_FAULT_RETRY;
	}

	// 6. 页面一致性检查
	//检查页面是否仍然属于同一个address_space，验证页面索引是否匹配请求的偏移
	if (unlikely(page->mapping != mapping)) {
		unlock_page(page);
		put_page(page);
		goto retry_find;	//如果不匹配，回退跳转到重新查找
	}
	VM_BUG_ON_PAGE(page->index != offset, page);

	// 7. 检查页面是否最新（是否与磁盘同步），如果不是最新，跳转到重新读取逻辑
	if (unlikely(!PageUptodate(page)))
		goto page_not_uptodate;

	/*
	 * Found the page and have a reference on it.
	 * We must recheck i_size under page lock.
	 */

	// 8. 再次边界检查，在获取页面锁后再次检查文件大小，防止在锁定期间文件被截断
	size = round_up(i_size_read(inode), PAGE_SIZE);
	if (unlikely(offset >= size >> PAGE_SHIFT)) {
		unlock_page(page);
		put_page(page);
		return VM_FAULT_SIGBUS;
	}

	// 成功情况下返回，将找到的页面存入vmf->page，另外返回VM_FAULT_LOCKED表示页面已锁定

	// 注意：这里仅设置单个页面
	vmf->page = page;
	return ret | VM_FAULT_LOCKED;

	//下面是缺页处理的错误路径：
	//1、页面不在缓存中
	//2、页面非最新
no_cached_page:
	/*
	 * We're only likely to ever get here if MADV_RANDOM is in
	 * effect.
	 */
	// 如果页面不在page cache，调用page_cache_read分配新页并触发读取
	// 如果成功，跳回retry_find重新查找
	// page_cache_read的主要功能是申请page，并把page加入全局链表
	error = page_cache_read(file, offset, vmf->gfp_mask);

	/*
	 * The page we want has now been added to the page cache.
	 * In the unlikely event that someone removed it in the
	 * meantime, we'll just come back here and read it again.
	 */
	if (error >= 0)
		goto retry_find;

	/*
	 * An error return from page_cache_read can result if the
	 * system is low on memory, or a problem occurs while trying
	 * to schedule I/O.
	 */
	if (error == -ENOMEM)
		return VM_FAULT_OOM;
	return VM_FAULT_SIGBUS;

page_not_uptodate:
	/*
	 * Umm, take care of errors if the page isn't up-to-date.
	 * Try to re-read it _once_. We do this synchronously,
	 * because there really aren't any performance issues here
	 * and we need to check for errors.
	 */
	//如果页面不是最新，需要调用文件系统的readpage方法重新读取
	ClearPageError(page);
	error = mapping->a_ops->readpage(file, page);
	if (!error) {
		//等待读取完成
		//如果读取成功，重新查找页面（retry_find的部分）
		wait_on_page_locked(page);
		if (!PageUptodate(page))
			error = -EIO;
	}
	put_page(page);

	if (!error || error == AOP_TRUNCATED_PAGE)
		goto retry_find;

	/* Things didn't work out. Return zero to tell the mm layer so. */
	shrink_readahead_size_eio(file, ra);
	return VM_FAULT_SIGBUS;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/filemap.c#L2074
/*
file: 指向打开的文件结构体指针
offset: 文件中的页偏移（页为单位）
gfp_mask: 内存分配标志
*/
static int page_cache_read(struct file *file, pgoff_t offset, gfp_t gfp_mask)
{
	struct address_space *mapping = file->f_mapping;
	struct page *page;
	int ret;

	do {
		//使用__page_cache_alloc分配一个页面
		page = __page_cache_alloc(gfp_mask|__GFP_COLD);
		if (!page)
			return -ENOMEM;

		//1. 将页面插入页缓存的radix树
		//2. 同时将页面添加到LRU链表中
		ret = add_to_page_cache_lru(page, mapping, offset, gfp_mask & GFP_KERNEL);
		if (ret == 0){
			//情况1：插入成功 (ret == 0)时，调用文件系统的readpage方法读取文件数据，这是一个异步操作，启动磁盘I/O
			//页面在I/O完成前保持锁定状态
			ret = mapping->a_ops->readpage(file, page);
		}
		else if (ret == -EEXIST)	//竞态，其他线程已成功插入同一页面
			ret = 0; /* losing race to add is OK */

		put_page(page);

	} while (ret == AOP_TRUNCATED_PAGE);

	return ret;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/memory.c#L3261
int finish_fault(struct vm_fault *vmf)
{
	struct page *page;
	int ret;

	/* Did we COW the page? */
	//验证权限：检查 VMA 权限是否允许读/写
	if ((vmf->flags & FAULT_FLAG_WRITE) &&
	    !(vmf->vma->vm_flags & VM_SHARED))
		page = vmf->cow_page;	//for cow：使用新分配的匿名页（COW 副本）
	else
		page = vmf->page;	//使用 Page Cache 中的原始文件页
	// 
	ret = alloc_set_pte(vmf, vmf->memcg, page);
	if (vmf->pte)
		pte_unmap_unlock(vmf->pte, vmf->ptl);
	return ret;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/memory.c#L3196
int alloc_set_pte(struct vm_fault *vmf, struct mem_cgroup *memcg,
		struct page *page)
{
	struct vm_area_struct *vma = vmf->vma;
	bool write = vmf->flags & FAULT_FLAG_WRITE;
	pte_t entry;
	int ret;

	......
	//生成 PTE 内容：使用 mk_pte(page, vma->vm_page_prot) 将物理页地址转换为页表项格式
	entry = mk_pte(page, vma->vm_page_prot);
	
	/*
	下面这段代码有些意思：
	写时复制 (COW) 产生的匿名页 和 共享的文件页/只读页
	*/
	if (write)
		entry = maybe_mkwrite(pte_mkdirty(entry), vma);
	/* copy-on-write page */
	if (write && !(vma->vm_flags & VM_SHARED)) {
		//分支1：私有可写映射 （Private Writable Mapping）

		//因为这是 COW 出来的页，它已经脱离了原来的文件映射，变成了匿名页 (Anonymous Page)，所以增加进程的匿名页计数
		inc_mm_counter_fast(vma->vm_mm, MM_ANONPAGES);
		//为这个新生成的匿名页建立反向映射
		page_add_new_anon_rmap(page, vma, vmf->address, false);
		//将该页面的内存消耗计入当前进程所在的 cgroup
		mem_cgroup_commit_charge(page, memcg, false, false);
		//将该页加入 LRU 链表，以便内核进行内存回收管理
		lru_cache_add_active_or_unevictable(page, vma);
	} else {
		//分支2：共享映射 （Shared Mapping） 或者 只读映射 ）（Read-only Mapping）

		//增加进程的文件页 （File-backed Page） 计数
		inc_mm_counter_fast(vma->vm_mm, mm_counter_file(page));
		//建立文件页的反向映射
		page_add_file_rmap(page, false);
	}

	//设置页表：调用 set_pte_at。这一步执行完，虚拟地址到物理地址的映射正式在硬件层面打通
	//真正将物理页的地址写入进程页表（PTE）的动作。从此以后，虚拟地址就指向了相应的物理地址
	set_pte_at(vma->vm_mm, vmf->address, vmf->pte, entry);

	/* no need to invalidate: a not-present page won't be cached */

	// 重要：设置MMU缓存
	update_mmu_cache(vma, vmf->address, vmf->pte);

	//set_pte_at && update_mmu_cache结束：CPU 重新执行指令
	return 0;
}

unsigned long vm_mmap_pgoff(struct file *file, unsigned long addr,
    unsigned long len, unsigned long prot,
    unsigned long flag, unsigned long pgoff)
{
    unsigned long ret;
    // 获取进程虚拟内存空间
    struct mm_struct *mm = current->mm;
    // 是否需要为映射的 VMA，提前分配物理内存页，避免后续的缺页
    // 取决于 flag 是否设置了 MAP_POPULATE 或者 MAP_LOCKED，这里的 populate 表示需要分配物理内存的大小
    unsigned long populate;

    ret = security_mmap_file(file, prot, flag);
    if (!ret) {
        // 对进程虚拟内存空间加写锁保护，防止多线程并发修改
        if (down_write_killable(&mm->mmap_sem))
            return -EINTR;
        // 开始 mmap 内存映射，在进程虚拟内存空间中分配一段 vma，并建立相关映射关系
        // ret 为映射虚拟内存区域的起始地址
        ret = do_mmap_pgoff(file, addr, len, prot, flag, pgoff,
                    &populate, &uf);
        // 释放写锁
        up_write(&mm->mmap_sem);
        if (populate)
            // 提前分配物理内存页面，后续访问不会缺页
            // 为 [ret , ret + populate] 这段虚拟内存立即分配物理内存
            mm_populate(ret, populate);
    }
    return ret;
}

//https://elixir.bootlin.com/linux/v4.11.6/source/mm/gup.c#L1069
int __mm_populate(unsigned long start, unsigned long len, int ignore_errors)
{
	struct mm_struct *mm = current->mm;
	unsigned long end, nstart, nend;
	struct vm_area_struct *vma = NULL;
	int locked = 0;
	long ret = 0;

	VM_BUG_ON(start & ~PAGE_MASK);
	VM_BUG_ON(len != PAGE_ALIGN(len));
	end = start + len;
	// 依次遍历进程地址空间中 [start , end] 这段虚拟内存范围的所有 vma
	for (nstart = start; nstart < end; nstart = nend) {
		/*
		 * We want to fault in pages for [nstart; end) address range.
		 * Find first corresponding VMA.
		 */
		if (!locked) {
			locked = 1;
			down_read(&mm->mmap_sem);
			vma = find_vma(mm, nstart);
		} else if (nstart >= vma->vm_end)
			vma = vma->vm_next;
		if (!vma || vma->vm_start >= end)
			break;
		/*
		 * Set [nstart; nend) to intersection of desired address
		 * range with the first VMA. Also, skip undesirable VMA types.
		 */
		nend = min(end, vma->vm_end);
		if (vma->vm_flags & (VM_IO | VM_PFNMAP))
			continue;
		if (nstart < vma->vm_start)
			nstart = vma->vm_start;
		/*
		 * Now fault in a range of pages. populate_vma_page_range()
		 * double checks the vma flags, so that it won't mlock pages
		 * if the vma was already munlocked.
		 */

		//上面是查找指定地址范围内 vma 

		// 为这段地址范围内的所有 vma 分配物理内存
		ret = populate_vma_page_range(vma, nstart, nend, &locked);
		if (ret < 0) {
			if (ignore_errors) {
				ret = 0;
				continue;	/* continue at next VMA */
			}
			break;
		}
		// 继续为下一个 vma （如果有的话）分配物理内存
		nend = nstart + ret * PAGE_SIZE;
		ret = 0;
	}
	if (locked)
		up_read(&mm->mmap_sem);
	return ret;	/* 0 or negative error code */
}