Linux进程的内存管理之缺页异常

喜欢ヅ旅行 2022-11-15 01:10 298阅读 0赞

通过《[Linux进程的内存管理之malloc和mmap][Linux_malloc_mmap]》我们知道，这两个函数只是建立了进程的vma，但还没有建立虚拟地址和物理地址的映射关系。

当进程访问这些还没建立映射关系的虚拟地址时，处理器会自动触发缺页异常。

ARM64把异常分为同步异常和异步异常，通常异步异常指的是中断（可看《[上帝视角看中断][Link 1]》），同步异常指的是异常。关于ARM异常处理的文章可参考《[ARMv8异常处理简介][ARMv8]》。

## ARM64处理 ##

当处理器有异常发生时，处理器会先跳转到ARM64的异常向量表中：

ENTRY(vectors)
     kernel_ventry 1, sync_invalid   // Synchronous EL1t
     kernel_ventry 1, irq_invalid   // IRQ EL1t
     kernel_ventry 1, fiq_invalid   // FIQ EL1t
     kernel_ventry 1, error_invalid  // Error EL1t
    
     kernel_ventry 1, sync    // Synchronous EL1h
     kernel_ventry 1, irq    // IRQ EL1h
     kernel_ventry 1, fiq_invalid   // FIQ EL1h
     kernel_ventry 1, error_invalid  // Error EL1h
    
     kernel_ventry 0, sync    // Synchronous 64-bit EL0
     kernel_ventry 0, irq    // IRQ 64-bit EL0
     kernel_ventry 0, fiq_invalid   // FIQ 64-bit EL0
     kernel_ventry 0, error_invalid  // Error 64-bit EL0
    
    #ifdef CONFIG_COMPAT
     kernel_ventry 0, sync_compat, 32  // Synchronous 32-bit EL0
     kernel_ventry 0, irq_compat, 32  // IRQ 32-bit EL0
     kernel_ventry 0, fiq_invalid_compat, 32 // FIQ 32-bit EL0
     kernel_ventry 0, error_invalid_compat, 32 // Error 32-bit EL0
    #else
     kernel_ventry 0, sync_invalid, 32  // Synchronous 32-bit EL0
     kernel_ventry 0, irq_invalid, 32  // IRQ 32-bit EL0
     kernel_ventry 0, fiq_invalid, 32  // FIQ 32-bit EL0
     kernel_ventry 0, error_invalid, 32  // Error 32-bit EL0
    #endif
    END(vectors)

以el1下的异常为例，当跳转到el1\_sync函数时，读取ESR的值以判断异常类型。根据类型跳转到不同的处理函数里，如果是data abort的话跳转到el1\_da函数里，instruction abort的话跳转到el1\_ia函数里：

el1_sync:
     kernel_entry 1
     mrs x1, esr_el1   // read the syndrome register
     lsr x24, x1, #ESR_ELx_EC_SHIFT // exception class
     cmp x24, #ESR_ELx_EC_DABT_CUR // data abort in EL1
     b.eq el1_da
     cmp x24, #ESR_ELx_EC_IABT_CUR // instruction abort in EL1
     b.eq el1_ia
     cmp x24, #ESR_ELx_EC_SYS64  // configurable trap
     b.eq el1_undef
     cmp x24, #ESR_ELx_EC_SP_ALIGN // stack alignment exception
     b.eq el1_sp_pc
     cmp x24, #ESR_ELx_EC_PC_ALIGN // pc alignment exception
     b.eq el1_sp_pc
     cmp x24, #ESR_ELx_EC_UNKNOWN // unknown exception in EL1
     b.eq el1_undef
     cmp x24, #ESR_ELx_EC_BREAKPT_CUR // debug exception in EL1
     b.ge el1_dbg
     b el1_inv

流程图如下：

![bd37c9b6ee4d5a28dd2467b2f087da00.png][]

asmlinkage void __exception do_mem_abort(unsigned long addr, unsigned int esr,
          struct pt_regs *regs)
    {
     const struct fault_info *inf = esr_to_fault_info(esr);
     struct siginfo info;
    
     if (!inf->fn(addr, esr, regs))
      return;
    
     pr_alert("Unhandled fault: %s (0x%08x) at 0x%016lx\n",
       inf->name, esr, addr);
    
     mem_abort_decode(esr);
    
     info.si_signo = inf->sig;
     info.si_errno = 0;
     info.si_code  = inf->code;
     info.si_addr  = (void __user *)addr;
     arm64_notify_die("", regs, &info, esr);
    }

该函数主要是根据传进来的esr获取fault\_info信息，从而去调用函数inf->fn.

static const struct fault_info fault_info[] = {
     { do_bad,  SIGBUS,  0,  "ttbr address size fault" },
     { do_bad,  SIGBUS,  0,  "level 1 address size fault" },
     { do_bad,  SIGBUS,  0,  "level 2 address size fault" },
     { do_bad,  SIGBUS,  0,  "level 3 address size fault" },
     { do_translation_fault, SIGSEGV, SEGV_MAPERR, "level 0 translation fault" },
     { do_translation_fault, SIGSEGV, SEGV_MAPERR, "level 1 translation fault" },
     { do_translation_fault, SIGSEGV, SEGV_MAPERR, "level 2 translation fault" },
     { do_translation_fault, SIGSEGV, SEGV_MAPERR, "level 3 translation fault" },
     { do_bad,  SIGBUS,  0,  "unknown 8"   },
     { do_page_fault, SIGSEGV, SEGV_ACCERR, "level 1 access flag fault" },
     { do_page_fault, SIGSEGV, SEGV_ACCERR, "level 2 access flag fault" },
     { do_page_fault, SIGSEGV, SEGV_ACCERR, "level 3 access flag fault" },
      ......
    }

*  do\_translation\_fault: 出现0/1/2/3级页表转换错误时调用
 *  do\_page\_fault：出现1/2/3级页表访问权限时调用
 *  do\_bad：其它错误

以do\_translation\_fault为例：

static int __kprobes do_translation_fault(unsigned long addr,
           unsigned int esr,
           struct pt_regs *regs)
    {
     if (addr < TASK_SIZE)
      return do_page_fault(addr, esr, regs); //用户空间
    
     do_bad_area(addr, esr, regs); //内核空间或非法空间
     return 0;
    }

## do\_page\_fault ##

主要调用\_\_do\_page\_fault

static int __do_page_fault(struct mm_struct *mm, unsigned long addr,
          unsigned int mm_flags, unsigned long vm_flags,
          struct task_struct *tsk)
    {
     struct vm_area_struct *vma;
     int fault;
    
     vma = find_vma(mm, addr);
     fault = VM_FAULT_BADMAP; //没有找到vma区域，说明addr还没有在进程的地址空间中
     if (unlikely(!vma))
      goto out;
     if (unlikely(vma->vm_start > addr))
      goto check_stack;
    
     /*
      * Ok, we have a good vm_area for this memory access, so we can handle
      * it.
      */
    good_area://一个好的vma
     /*
      * Check that the permissions on the VMA allow for the fault which
      * occurred.
      */
     if (!(vma->vm_flags & vm_flags)) {//权限检查
      fault = VM_FAULT_BADACCESS; 
      goto out;
     }
    
     //重新建立物理页面到VMA的映射关系
     return handle_mm_fault(vma, addr & PAGE_MASK, mm_flags);
    
    check_stack:
     if (vma->vm_flags & VM_GROWSDOWN && !expand_stack(vma, addr))
      goto good_area;
    out:
     return fault;
    }

从\_\_do\_page\_fault函数能看出来，当触发异常的虚拟地址属于某个vma，并且拥有触发页错误异常的权限时，会调用到handle\_mm\_fault函数来建立vma和物理地址的映射，而handle\_mm\_fault函数的主要逻辑是通过\_\_handle\_mm\_fault来实现的。

## \_\_handle\_mm\_fault ##

static int __handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
      unsigned int flags)
    {
      ......
     //查找页全局目录，获取地址对应的表项
     pgd = pgd_offset(mm, address);
     //查找页四级目录表项，没有则创建
     p4d = p4d_alloc(mm, pgd, address);
     if (!p4d)
      return VM_FAULT_OOM;
    
     //查找页上级目录表项，没有则创建
     vmf.pud = pud_alloc(mm, p4d, address);
     ......
     //查找页中级目录表项，没有则创建
     vmf.pmd = pmd_alloc(mm, vmf.pud, address);
      ......
     //处理pte页表
     return handle_pte_fault(&vmf);
    }

static int handle_pte_fault(struct vm_fault *vmf)
    {
      ......
     //页表项不存在
     if (!vmf->pte) {
      //判断是否是匿名页
      if (vma_is_anonymous(vmf->vma))
       //处理匿名页   
       return do_anonymous_page(vmf); //malloc/mmap分配了vma，但是没有进行映射处理，在首次访问时触发
      else
       //处理文件页，匿名共享页
       return do_fault(vmf); 
     }
    
     //页表项存在，但页不在内存中
     if (!pte_present(vmf->orig_pte))
      return do_swap_page(vmf);
    
     if (pte_protnone(vmf->orig_pte) && vma_is_accessible(vmf->vma))
      return do_numa_page(vmf); //NUMA自动平衡处理
      ......
     if (vmf->flags & FAULT_FLAG_WRITE) {
      if (!pte_write(entry))
       return do_wp_page(vmf); //页在内存中，但是没有写权限位，写时复制
      entry = pte_mkdirty(entry);
     }
      ......
    }

![3afe8cb7f7fe884f481b094785bf3ac4.png][]

## do\_anonymous\_page    ##

匿名页缺页异常，对于匿名映射，**映射完成之后，只是获得了一块虚拟内存，并没有分配物理内存**，当第一次访问的时候：

1.  如果是读访问，会将虚拟页映射到**０页**，以减少不必要的内存分配
2.  如果是写访问，用alloc\_zeroed\_user\_highpage\_movable分配新的物理页，并用０填充，然后映射到虚拟页上去
3.  如果是先读后写访问，则会发生两次缺页异常：第一次是匿名页缺页异常的读的处理（虚拟页到0页的映射），第二次是**写时复制**缺页异常处理。

从上面的总结我们知道，第一次访问匿名页时有三种情况，其中第一种和第三种情况都会涉及到**0页**。

/*
     * Empty_zero_page is a special page that is used for zero-initialized data
     * and COW.
     */
    unsigned long empty_zero_page[PAGE_SIZE / sizeof(unsigned long)] __page_aligned_bss;
    EXPORT_SYMBOL(empty_zero_page);

可以看到定义了一个全局变量，大小为一页，页对齐到 bss 段，所有这段数据内核初始化的时候会被清零，所有称之为**０页**。

下面我们结合代码看下匿名页如何针对上面三种情况操作：

**1. 第一次读匿名页情况**

//是否为写内存导致的缺页异常
     if (!(vmf->flags & FAULT_FLAG_WRITE) &&
       !mm_forbids_zeropage(vma->vm_mm)) {
      //异常由读操作触发，并允许使用0页。设置页表项的值映射到０页。
      entry = pte_mkspecial(pfn_pte(my_zero_pfn(vmf->address),
          vma->vm_page_prot));
      vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd,
        vmf->address, &vmf->ptl);
      if (!pte_none(*vmf->pte))
       goto unlock;
      ret = check_stable_address_space(vma->vm_mm);
      if (ret)
       goto unlock;
      /* Deliver the page fault to userland, check inside PT lock */
      if (userfaultfd_missing(vma)) {
       pte_unmap_unlock(vmf->pte, vmf->ptl);
       return handle_userfault(vmf, VM_UFFD_MISSING);
      }
      goto setpte;
     }
      ......
    setpte:
     //设置页表项
     set_pte_at(vma->vm_mm, vmf->address, vmf->pte, entry);
    
     /* No need to invalidate - it was non-present before */
     //更新cpu的tlb页表缓存
     update_mmu_cache(vma, vmf->address, vmf->pte);

pte\_mkspecial 是主要函数，设置页表项的值映射到０页。my\_zero\_pfn就是内核初始化设置的empty\_zero\_page这个０页得到页帧号。

**2. 第一次写匿名页的情况**

//分配一个高端可迁移的被０填充的物理页
     page = alloc_zeroed_user_highpage_movable(vma, vmf->address);
     if (!page)
      goto oom;
      ......
     //设置page的标志位，PG_uptodate
     __SetPageUptodate(page);
    
     //根据vma的权限位和page描述符，生成页表项
     entry = mk_pte(page, vma->vm_page_prot);
     if (vma->vm_flags & VM_WRITE)
      //如果有写权限，设置页表项值为脏且可写
      entry = pte_mkwrite(pte_mkdirty(entry));
      ......
     //增加匿名页面计数
     inc_mm_counter_fast(vma->vm_mm, MM_ANONPAGES);
     //建立物理页到虚拟页的反向映射，添加到rmap链表中
     page_add_new_anon_rmap(page, vma, vmf->address, false);
     mem_cgroup_commit_charge(page, memcg, false, false);
     //把物理页添加到lru链表中
     lru_cache_add_active_or_unevictable(page, vma);

通过alloc\_zeroed\_user\_highpage\_movable分配物理页面

**3. 读之后写匿名页**

见 do\_wp\_page

## do\_fault ##

文件页缺页异常

![ee696dad1431ae726f8c675cc418fbc7.png][]

## do\_swap\_page ##

上面已经讲过，pte对应的内容不为0(页表项存在)，但是pte所对应的page不在内存中时，表示此时pte的内容所对应的页面在swap空间中，缺页异常时会通过do\_swap\_page()函数来分配页面。

### 在讲do\_swap\_page之前，我们先看下什么是swap cache？ ###

由于内存和磁盘的读写性能差异较大，Linux会在内存充裕时将空闲内存当作swap cache，用来缓存磁盘数据，以提高I/O性能。相对的在内存紧张时Linux会将这些缓存回收，将脏页回写到磁盘中。

内核中使用swap\_info\_struct结构体来管理swap分区，一个swap\_info\_struct对应一个swap分区。如下图所示，swap分区内部会以page大小为单位划分出多个swap slot，同时通过swap\_map对每个slot的使用情况进行记录，为0代表空闲，大于0则代表该slot被map的进程数量。

![591b1c394c4d51a744236d8d3a072d3b.png][]

发生内存回收时，一个内存页会被回收到一个slot中，同时会修改pte内容为slot对应的swp\_entry\_t。swp\_entry\_t是一个64位的变量，其结构如下图所示，其中2-7位存放swap分区的type，8-57位存放slot在分区内的offset。内存换入时，通过pte的内容即可在磁盘上找到对应的slot。

![b4c70a7a5716708fa92fee222a3f77bb.png][]

### 正式进入do\_swap\_page    ###

do\_swap\_page发生在swap in的时候，即查找磁盘上的slot，并将数据读回。

换入的过程如下：

1.  查找swap cache中是否存在所查找的页面，如果存在，则根据swap cache引用的内存页，重新映射并更新页表；如果不存在，则分配新的内存页，并添加到swap cache的引用中，更新内存页内容完成后，更新页表。
2.  换入操作结束后，对应swap area的页引用减1，当减少到0时，代表没有任何进程引用了该页，可以进行回收。

int do_swap_page(struct vm_fault *vmf)
    {
      ......
     //根据pte找到swap entry, swap entry和pte有一个对应关系
     entry = pte_to_swp_entry(vmf->orig_pte);
      ......
     if (!page)
      //根据entry从swap缓存中查找页, 在swapcache里面寻找entry对应的page
      //Lookup a swap entry in the swap cache
      page = lookup_swap_cache(entry, vma_readahead ? vma : NULL,
          vmf->address);
     //没有找到页
     if (!page) {
      if (vma_readahead)
       page = do_swap_page_readahead(entry,
        GFP_HIGHUSER_MOVABLE, vmf, &swap_ra);
      else
       //如果swapcache里面找不到就在swap area里面找，分配新的内存页并从swap area中读入
       page = swapin_readahead(entry,
        GFP_HIGHUSER_MOVABLE, vma, vmf->address);
      ......
     //获取一个pte的entry，重新建立映射
     vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, vmf->address,
       &vmf->ptl);
      ......
     //anonpage数加1，匿名页从swap空间交换出来，所以加1
     //swap page个数减1，由page和VMA属性创建一个新的pte
     inc_mm_counter_fast(vma->vm_mm, MM_ANONPAGES);
     dec_mm_counter_fast(vma->vm_mm, MM_SWAPENTS);
     pte = mk_pte(page, vma->vm_page_prot);
      ......
     flush_icache_page(vma, page);
     if (pte_swp_soft_dirty(vmf->orig_pte))
      pte = pte_mksoft_dirty(pte);
     //将新生成的PTE entry添加到硬件页表中
     set_pte_at(vma->vm_mm, vmf->address, vmf->pte, pte);
     vmf->orig_pte = pte;
     //根据page是否为swapcache
     if (page == swapcache) {
      //如果是，将swap缓存页用作anon页，添加反向映射rmap中
      do_page_add_anon_rmap(page, vma, vmf->address, exclusive);
      mem_cgroup_commit_charge(page, memcg, true, false);
      //并添加到active链表中
      activate_page(page);
     //如果不是
     } else { /* ksm created a completely new copy */
      //使用新页面并复制swap缓存页，添加反向映射rmap中
      page_add_new_anon_rmap(page, vma, vmf->address, false);
      mem_cgroup_commit_charge(page, memcg, false, false);
      //并添加到lru链表中
      lru_cache_add_active_or_unevictable(page, vma);
     }
    
     //释放swap entry
     swap_free(entry);
      ......
     if (vmf->flags & FAULT_FLAG_WRITE) {
      //有写请求则写时复制
      ret |= do_wp_page(vmf);
      if (ret & VM_FAULT_ERROR)
       ret &= VM_FAULT_ERROR;
      goto out;
     }
      ......
      return ret;
    }

![019e850002b9da1dc7c76394dfdba27e.png][]

## do\_wp\_page ##

走到这里说明页面在内存中，只是PTE只有读权限，而又要写内存的时候就会触发do\_wp\_page。

do\_wp\_page函数用于处理写时复制（copy on write），其流程比较简单，主要是**分配新的物理页，拷贝原来页的内容到新页，然后修改页表项内容指向新页并修改为可写(vma具备可写属性)。**

static int do_wp_page(struct vm_fault *vmf)
     __releases(vmf->ptl)
    {
     struct vm_area_struct *vma = vmf->vma;
    
     //从页表项中得到页帧号，再得到页描述符，发生异常时地址所在的page结构
     vmf->page = vm_normal_page(vma, vmf->address, vmf->orig_pte);
     if (!vmf->page) {
      //没有page结构是使用页帧号的特殊映射
      /*
       * VM_MIXEDMAP !pfn_valid() case, or VM_SOFTDIRTY clear on a
       * VM_PFNMAP VMA.
       *
       * We should not cow pages in a shared writeable mapping.
       * Just mark the pages writable and/or call ops->pfn_mkwrite.
       */
      if ((vma->vm_flags & (VM_WRITE|VM_SHARED)) ==
             (VM_WRITE|VM_SHARED))
       //处理共享可写映射
       return wp_pfn_shared(vmf);
    
      pte_unmap_unlock(vmf->pte, vmf->ptl);
      //处理私有可写映射
      return wp_page_copy(vmf);
     }
    
     /*
      * Take out anonymous pages first, anonymous shared vmas are
      * not dirty accountable.
      */
     if (PageAnon(vmf->page) && !PageKsm(vmf->page)) {
      int total_map_swapcount;
      if (!trylock_page(vmf->page)) {
       //添加原来页的引用计数，方式被释放
       get_page(vmf->page);
       //释放页表锁
       pte_unmap_unlock(vmf->pte, vmf->ptl);
       lock_page(vmf->page);
       vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd,
         vmf->address, &vmf->ptl);
       if (!pte_same(*vmf->pte, vmf->orig_pte)) {
        unlock_page(vmf->page);
        pte_unmap_unlock(vmf->pte, vmf->ptl);
        put_page(vmf->page);
        return 0;
       }
       put_page(vmf->page);
      }
      //单身匿名页面的处理
      if (reuse_swap_page(vmf->page, &total_map_swapcount)) {
       if (total_map_swapcount == 1) {
        /*
         * The page is all ours. Move it to
         * our anon_vma so the rmap code will
         * not search our parent or siblings.
         * Protected against the rmap code by
         * the page lock.
         */
        page_move_anon_rmap(vmf->page, vma);
       }
       unlock_page(vmf->page);
       wp_page_reuse(vmf);
       return VM_FAULT_WRITE;
      }
      unlock_page(vmf->page);
     } else if (unlikely((vma->vm_flags & (VM_WRITE|VM_SHARED)) ==
         (VM_WRITE|VM_SHARED))) {
      //共享可写，不需要复制物理页，设置页表权限即可
      return wp_page_shared(vmf);
     }
    
     /*
      * Ok, we need to copy. Oh, well..
      */
     get_page(vmf->page);
    
     pte_unmap_unlock(vmf->pte, vmf->ptl);
     //私有可写，复制物理页，将虚拟页映射到物理页
     return wp_page_copy(vmf);
    }

![虚线阴影分割线][4cf0facea8e1e1eaf560adc089c2228c.png]

![2f61a75498071c5d34048bdbd72f2d64.png][]

5T技术资源大放送！包括但不限于：C/C++，Arm, Linux，Android，人工智能，单片机，树莓派，等等。在公众号内回复「peter」，即可免费获取！！

![e1c0b9e1b8d7738cb860318e7cbaa656.gif][] **记得点击****分享****、****赞****和****在看****，给我充点儿电吧**

[Linux_malloc_mmap]: http://mp.weixin.qq.com/s?__biz=MzIxMjE1MzU4OA%3D%3D&chksm=8f5d9bb6b82a12a0cf0994ee8753a1607f73236cf5050456888187a7ce77d425d611bf3a0856&idx=1&mid=2648923693&scene=21&sn=88ddbf9c001cda17b9d23c7238704897#wechat_redirect
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzIxMjE1MzU4OA%3D%3D&chksm=8f5d9882b82a1194b90aaa8f3180e1035514e94b46975a9dcac608e5681cc7bf064de379a08f&idx=1&mid=2648923417&scene=21&sn=2140220c11c921d9efacc38338e19505#wechat_redirect
[ARMv8]: http://mp.weixin.qq.com/s?__biz=MzIxMjE1MzU4OA%3D%3D&chksm=8f5d971db82a1e0bf28f685a166677d5f5989b1ead5deb30a9b7af3207ad4d83a940f8ccfd6c&idx=1&mid=2648920710&scene=21&sn=1b8e993fc34275964b8f3883345bc258#wechat_redirect
[bd37c9b6ee4d5a28dd2467b2f087da00.png]: /images/20221022/7906a4f0597f4e5ebe20d57dbaa2947b.png
[3afe8cb7f7fe884f481b094785bf3ac4.png]: /images/20221022/38d75adccb9f43098fc0fc1cae8f44ce.png
[ee696dad1431ae726f8c675cc418fbc7.png]: /images/20221022/22bfc33b17734f0c80749952c8a0d664.png
[591b1c394c4d51a744236d8d3a072d3b.png]: /images/20221022/00cf3f5a51284beda9514201aaaa6931.png
[b4c70a7a5716708fa92fee222a3f77bb.png]: /images/20221022/0daa55bfee644467808fd30152e8e1a4.png
[019e850002b9da1dc7c76394dfdba27e.png]: /images/20221022/2f9ea632519647d9b65fefcbe65cbfc3.png
[4cf0facea8e1e1eaf560adc089c2228c.png]: /images/20221022/896d6a8e85a04d26a71760a79212802b.png
[2f61a75498071c5d34048bdbd72f2d64.png]: /images/20221022/bd333345f6ba4e0bb93f2810cdca1089.png
[e1c0b9e1b8d7738cb860318e7cbaa656.gif]: /images/20221022/010cc3336a194a5c8b64f6dc5f64adef.png