内存分区对象

Linux 会把进程虚拟内存空间划分为多个分区，在 Linux 内核中使用vm_area_struct对象来表示，其定义如下：

1struct vm_area_struct { 2   struct mm_struct *vm_mm;        // 分区所属的内存管理对象 3 4   unsigned long vm_start;         // 分区的开始地址 5   unsigned long vm_end;           // 分区的结束地址 6 7   struct vm_area_struct *vm_next; // 通过这个指针把进程所有的内存分区连接成一个链表 8  ... 9   struct rb_node vm_rb;           // 红黑树的节点, 用于保存到内存分区红黑树中10  ...11};

我们对vm_area_struct对象进行了简化，只保留了本文需要的字段。 内核就是使用 vm_area_struct 对象来记录一个内存分区（如 代码段、数据段 和 堆空间 等），下面介绍一下 vm_area_struct 对象各个字段的作用：

• vm_mm：指定了当前内存分区所属的内存管理对象。
• vm_start：内存分区的开始地址。
• vm_end：内存分区的结束地址。
• vm_next：通过这个指针把进程中所有的内存分区连接成一个链表。
• vm_rb：另外，为了快速查找内存分区，内核还把进程的所有内存分区保存到一棵红黑树中。vm_rb 就是红黑树的节点，用于把内存分区保存到红黑树中。

假如进程 A 现在有 4 个内存分区，它们的范围如下：

• 代码段：00400000 ~ 00401000
• 数据段：00600000 ~ 00601000
• 堆空间：00983000 ~ 009a4000
• 栈空间：7f37ce866000 ~ 7f3fce867000

那么这 4 个内存分区在内核中的结构如 图1 所示：

在 图1 中，我们可以看到有个mm_struct的对象，此对象每个进程都持有一个，是进程虚拟内存空间和物理内存空间的管理对象。我们简单介绍一下这个对象，其定义如下：

1struct mm_struct {2   struct vm_area_struct *mmap;  // 指向由进程内存分区连接成的链表3   struct rb_root mm_rb;         // 内核使用红黑树保存进程的所有内存分区, 这个是红黑树的根节点4   unsigned long start_brk, brk; // 堆空间的开始地址和结束地址5  ...6};

我们来介绍下 mm_struct 对象各个字段的作用：

• mmap：指向由进程所有内存分区连接成的链表。
• mm_rb：内核为了加快查找内存分区的速度，使用了红黑树保存所有内存分区，这个就是红黑树的根节点。
• start_brk：堆空间的开始内存地址。
• brk：堆空间的顶部内存地址。

我们来回顾一下进程虚拟内存空间的布局图，如 图2 所示：

start_brk和brk字段用来记录堆空间的范围， 如 图2 所示。一般来说，start_brk是不会变的，而brk会随着分配内存和释放内存而变化。

推荐

【Linux内核内存管理专题训练营】火热开营！！ 最新Linux内核技术详解 独家Linux内核内存管理干货分享 两天持续技术输出： -------------------- 第一天： 1.物理内存映射及空间划分 2.ARM32/64页表的映射过程 3.分配物理页面及Slab分配器 4.实战：VMA查找/插入/合并 -------------------- 第二天： 5.实战：mallocap系统调用实现 6.缺页中断处理/反向映射 7.回收页面/匿名页面生命周期 8.KSM实现/Dirty COW内存漏洞

原价“198”，现“0.02”特惠！

限时特价入营地址

Linux内核内存管理专题训练营-学习视频教程-腾讯课堂

立即抢购加入吧

虚拟内存分配

调用malloc申请内存时，最终会调用brk系统调用来从堆空间中分配内存。我们来分析一下brk系统调用的实现：

 1unsigned long sys_brk(unsigned long brk) 2{ 3   unsigned long rlim, retval; 4   unsigned long newbrk, oldbrk; 5   struct mm_struct *mm = current->mm; 6  ... 7   down_write(&mm->mmap_sem);  // 对内存管理对象进行上锁 8  ... 9   // 判断堆空间的大小是否超出限制, 如果超出限制, 就不进行处理10   rlim = current->signal->rlim[RLIMIT_DATA].rlim_cur;11   if (rlim < RLIM_INFINITY12       && (brk - mm->start_brk) + (mm->end_data - mm->start_data) > rlim)13       goto out;1415   newbrk = PAGE_ALIGN(brk);      // 新的brk值16   oldbrk = PAGE_ALIGN(mm->brk);  // 旧的brk值17   if (oldbrk == newbrk)          // 如果新旧的位置都一样, 就不需要进行处理18       goto set_brk;19  ...20   // 调用 do_brk 函数进行下一步处理21   if (do_brk(oldbrk, newbrk-oldbrk) != oldbrk)22       goto out;2324set_brk:25   mm->brk = brk; // 设置堆空间的顶部位置（brk指针）26out:27   retval = mm->brk;28   up_write(&mm->mmap_sem);29   return retval;30}

总结上面的代码，主要有以下几个步骤：

• 1、判断堆空间的大小是否超出限制，如果超出限制，就不作任何处理，直接返回旧的 brk 值。
• 2、如果新的 brk 值跟旧的 brk 值一致，那么也不用作任何处理。
• 3、如果新的 brk 值发生变化，那么就调用 do_brk 函数进行下一步处理。
• 4、设置进程的 brk 指针（堆空间顶部）为新的 brk 的值。

我们看到第 3 步调用了 do_brk 函数来处理，do_brk 函数的实现有点小复杂，所以这里介绍一下大概处理流程：

• 通过堆空间的起始地址 start_brk 从进程内存分区红黑树中找到其对应的内存分区对象（也就是 vm_area_struct）。
• 把堆空间的内存分区对象的 vm_end 字段设置为新的 brk 值。

至此，brk 系统调用的工作就完成了（上面没有分析释放内存的情况），总结来说，brk 系统调用的工作主要有两部分：

1. 把进程的 brk 指针设置为新的 brk 值。
2. 把堆空间的内存分区对象的 vm_end 字段设置为新的 brk 值。

物理内存分配

从上面的分析知道，brk 系统调用申请的是 虚拟内存，但存储数据只能使用 物理内存。所以，虚拟内存必须映射到物理内存才能被使用。

那么什么时候才进行内存映射呢？

当对没有映射的虚拟内存地址进行读写操作时，CPU 将会触发 缺页异常。内核接收到 缺页异常 后， 会调用 do_page_fault 函数进行修复。

我们来分析一下 do_page_fault 函数的实现（精简后）：

 1void do_page_fault(struct pt_regs *regs, unsigned long error_code) 2{ 3   struct vm_area_struct *vma; 4   struct task_struct *tsk; 5   unsigned long address; 6   struct mm_struct *mm; 7   int write; 8   int fault; 910   tsk = current;11   mm = tsk->mm;1213   address = read_cr2(); // 获取导致页缺失异常的虚拟内存地址14  ...15   vma = find_vma(mm, address); // 通过虚拟内存地址从进程内存分区中查找对应的内存分区对象16  ...17   if (likely(vma->vm_start <= address)) // 如果找到内存分区对象18       goto good_area;19  ...2021good_area:22   write = error_code & PF_WRITE;23  ...24   // 调用 handle_mm_fault 函数对虚拟内存地址进行映射操作25   fault = handle_mm_fault(mm, vma, address, write ? FAULT_FLAG_WRITE : 0);26  ...27}

do_page_fault 函数主要完成以下操作：

1. 获取导致页缺失异常的虚拟内存地址，保存到 address 变量中。
2. 调用 find_vma 函数从进程内存分区中查找异常的虚拟内存地址对应的内存分区对象。
3. 如果找到内存分区对象，那么调用 handle_mm_fault 函数对虚拟内存地址进行映射操作。

从上面的分析可知，对虚拟内存进行映射操作是通过 handle_mm_fault 函数完成的，而 handle_mm_fault 函数的主要工作就是完成对进程 页表 的填充。 我们通过 图3 来理解内存映射的原理，可以参考文章《一文读懂 HugePages的原理》：

下面我们来分析一下handle_mm_fault的实现，代码如下：

 1int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma, 2                   unsigned long address, unsigned int flags) 3{ 4   pgd_t *pgd;  // 页全局目录项 5   pud_t *pud;  // 页上级目录项 6   pmd_t *pmd;  // 页中间目录项 7   pte_t *pte;  // 页表项 8  ... 9   pgd = pgd_offset(mm, address);         // 获取虚拟内存地址对应的页全局目录项10   pud = pud_alloc(mm, pgd, address);     // 获取虚拟内存地址对应的页上级目录项11  ...12   pmd = pmd_alloc(mm, pud, address);     // 获取虚拟内存地址对应的页中间目录项13  ...14   pte = pte_alloc_map(mm, pmd, address); // 获取虚拟内存地址对应的页表项15  ...16   // 对页表项进行映射17   return handle_pte_fault(mm, vma, address, pte, pmd, flags);18}

handle_mm_fault 函数主要对每一级的页表进行映射（对照 图3 就容易理解），最终调用 handle_pte_fault 函数对 页表项 进行映射。

我们继续来分析 handle_pte_fault 函数的实现，代码如下：

 1static inline int 2handle_pte_fault(struct mm_struct *mm, struct vm_area_struct *vma, 3                unsigned long address, pte_t *pte, pmd_t *pmd, 4                unsigned int flags) 5{ 6   pte_t entry; 7 8   entry = *pte; 910   if (!pte_present(entry)) { // 还没有映射到物理内存11       if (pte_none(entry)) {12          ...13           // 调用 do_anonymous_page 函数进行匿名页映射（堆空间就是使用匿名页）14           return do_anonymous_page(mm, vma, address, pte, pmd, flags);15      }16      ...17  }18  ...19}

上面代码简化了很多与本文无关的逻辑。从上面代码可以看出，handle_pte_fault函数最终会调用do_anonymous_page来完成内存映射操作，我们接着来分析下do_anonymous_page函数的实现：

 1static int 2do_anonymous_page(struct mm_struct *mm, struct vm_area_struct *vma, 3                 unsigned long address, pte_t *page_table, pmd_t *pmd, 4                 unsigned int flags) 5{ 6   struct page *page; 7   spinlock_t *ptl; 8   pte_t entry; 910   if (!(flags & FAULT_FLAG_WRITE)) { // 如果是读操作导致的异常11       // 使用 `零页` 进行映射12       entry = pte_mkspecial(pfn_pte(my_zero_pfn(address), vma->vm_page_prot));13      ...14       goto setpte;15  }16  ...17   // 如果是写操作导致的异常18   // 申请一块新的物理内存页19   page = alloc_zeroed_user_highpage_movable(vma, address);20  ...21   // 根据物理内存页的地址生成映射关系22   entry = mk_pte(page, vma->vm_page_prot);23   if (vma->vm_flags & VM_WRITE)24       entry = pte_mkwrite(pte_mkdirty(entry));25  ...26setpte:27   set_pte_at(mm, address, page_table, entry); // 设置页表项为新的映射关系28  ...29   return 0;30}

do_anonymous_page 函数的实现比较有趣，它会根据 缺页异常 是由读操作还是写操作导致的，分为两个不同的处理逻辑，如下：

• 如果是读操作导致的，那么将会使用 零页 进行映射（零页 是 Linux 内核中一个比较特殊的内存页，所有读操作引起的 缺页异常 都会指向此页，从而可以减少物理内存的消耗），并且设置其为只读（因为 零页 是不能进行写操作）。如果下次对此页进行写操作，将会触发写操作的 缺页异常，从而进入下面步骤。
• 如果是写操作导致的，就申请一块新的物理内存页，然后根据物理内存页的地址生成映射关系，再对页表项进行填充（映射）。

总结

本文主要介绍了 Linux 内存分配的整个过程，当然只是介绍从堆空间分配的内存的过程。Linux 分配内存的方式还有很多，比如 mmap、HugePages 等，有兴趣的可以查阅相关的资料和书籍。

作者：JaydenLie 链接：https://juejin.cn/post/6959754877400514574 来源：掘金 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。