【内存管理】页表映射基础知识

#define pgd_offset_k(addr) pgd_offset(&init_mm,addr) //由虚拟地址来获取内核页表的PGD页表的相应的页表项 
#define pgd_offset(mm,addr) ((mm)->pgd + pgd_index(addr)) //由虚拟地址来获取用户进程的页表中相应的PGD表项
pgd_index(addr) //由虚拟地址找到PGD页表的索引
pte_index(addr) //由虚拟地址找到PT页表的索引
pte_offset_kernel(pmd,addr) //查找内核页表中对应的PT页表的表项 

#define pte_none(pte)  (!pte_val(pte)) //pte是否存在
#define pte_present(pte) (pte_isset((pte), L_PTE_PRESENT)) //present比特位
#define pte_valid(pte)  (pte_isset((pte), L_PTE_VALID)) //pte是否有效
#define pte_accessible(mm, pte) (mm_tlb_flush_pending(mm) ? pte_present(pte) : pte_valid(pte))
#define pte_write(pte)  (pte_isclear((pte), L_PTE_RDONLY)) //pte是否可写
#define pte_dirty(pte)  (pte_isset((pte), L_PTE_DIRTY)) //pte是否有脏数据
#define pte_young(pte)  (pte_isset((pte), L_PTE_YOUNG)) //
#define pte_exec(pte)  (pte_isclear((pte), L_PTE_XN))

mk_pte() //创建的相应的页表项
pte_mkdirty() // 设置dirty标志位
pte_mkold() // 清除Accessed标志位
pte_mkclean() //清除dirty标志位
pte_mkwrite()// 设置读写标志位
pte_wrprotect() //清除读写标志位
pte_mkyoung()//设置Accessed标志位
set_pte_at()// 设置页表项到硬件中

/*
 * Create the page directory entries and any necessary
 * page tables for the mapping specified by `md'.  We
 * are able to cope here with varying sizes and address
 * offsets, and we take full advantage of sections and
 * supersections.
 */
static void __init create_mapping(struct map_desc *md)
{
 if (md->virtual != vectors_base() && md->virtual < TASK_SIZE) {
  pr_warn("BUG: not creating mapping for 0x%08llx at 0x%08lx in user region\n",
   (long long)__pfn_to_phys((u64)md->pfn), md->virtual);
  return;
 }

 if (md->type == MT_DEVICE &&
     md->virtual >= PAGE_OFFSET && md->virtual < FIXADDR_START &&
     (md->virtual < VMALLOC_START || md->virtual >= VMALLOC_END)) {
  pr_warn("BUG: mapping for 0x%08llx at 0x%08lx out of vmalloc space\n",
   (long long)__pfn_to_phys((u64)md->pfn), md->virtual);
 }

 __create_mapping(&init_mm, md, early_alloc, false);
}

/*
 * Create a mapping for the given map descriptor, md. The function
 * __create_mapping is used for both kernel and user mode mappings.
 *
 * @mm:         the mm structure where the mapping will be created
 * @md:        the map descriptor with the details of the mapping
 * @alloc:      a pointer to a function used to allocate pages for the mapping
 * @ng:         a boolean flag indicating if the mapping is non-global
 */
static void __init __create_mapping(struct mm_struct *mm, struct map_desc *md,
        void *(*alloc)(unsigned long sz),
        bool ng)
{
 unsigned long addr, length, end;
 phys_addr_t phys;
 const struct mem_type *type;
 pgd_t *pgd;

 type = &mem_types[md->type];

#ifndef CONFIG_ARM_LPAE----------------------(1)
 /*
  * Catch 36-bit addresses
  */
 if (md->pfn >= 0x100000) {
  create_36bit_mapping(mm, md, type, ng);
  return;
 }
#endif

 addr = md->virtual & PAGE_MASK;----------------------(2)
 phys = __pfn_to_phys(md->pfn);
 length = PAGE_ALIGN(md->length + (md->virtual & ~PAGE_MASK));

 /*
  * Check if the mapping can be made using pages.
  * If not, print a warning and ignore the request.
  */
 if (type->prot_l1 == 0 && ((addr | phys | length) & ~SECTION_MASK)) {----------------------(3)
  pr_warn("BUG: map for 0x%08llx at 0x%08lx can not be mapped using pages, ignoring.\n",
   (long long)__pfn_to_phys(md->pfn), addr);
  return;
 }

 pgd = pgd_offset(mm, addr);
 end = addr + length;----------------------(4)
 do {
  unsigned long next = pgd_addr_end(addr, end);----------------------(5)

  /*
   * Allocate a page directory entry for this range.
   * Initialize it with the appropriate page table
   * and make the mapping.
   */
  alloc_init_p4d(pgd, addr, next, phys, type, alloc, ng);----------------------(6)

  /*
   * Update the phys value with the end of the last mapped
   * page so that the next range can be allocated properly.
   */
  phys += next - addr;
  addr = next;----------------------(7)
 } while (pgd++, addr != end);
}

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;
 unsigned long end = addr + PAGE_ALIGN(size);
 struct mm_struct *mm = vma->vm_mm;//从VMA获取当前进程的mm_struct结构
 unsigned long remap_pfn = pfn;
 int err;

 if (WARN_ON_ONCE(!PAGE_ALIGNED(addr)))
  return -EINVAL;

 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;//设置vm_flags，remap_pfn_range直接使用物理内存。Linux内核对物理页面分为两类：normal mapping，special mapping。special mapping就是内核不希望该页面参与到内核的页面回收等活动中。

 BUG_ON(addr >= end);
 pfn -= addr >> PAGE_SHIFT;
 pgd = pgd_offset(mm, addr);//找到页表项
 flush_cache_range(vma, addr, end);
    //以PGD_SIZE为步长遍历页表
 do {
  next = pgd_addr_end(addr, end);//获取下一个PGD页表项的管辖的地址范围的起始地址
  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;
}

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;
 int err;

 pfn -= addr >> PAGE_SHIFT;
 pud = pud_alloc(mm, p4d, addr);//找到pud页表项。对于二级页表来说，PUD指向PGD
 if (!pud)
  return -ENOMEM;
    //以PUD_SIZE为步长遍历页表
 do {
  next = pud_addr_end(addr, end);//获取下一个PUD页表项的管辖的地址范围的起始地址
  err = remap_pmd_range(mm, pud, addr, next,
    pfn + (addr >> PAGE_SHIFT), prot);//继续遍历下一级页表
  if (err)
   return err;
 } while (pud++, addr = next, addr != end);
 return 0;
}

/* Find an entry in the second-level page table.. */
#ifndef pmd_offset
static inline pmd_t *pmd_offset(pud_t *pud, unsigned long address)
{
 return (pmd_t *)pud_page_vaddr(*pud) + pmd_index(address);
}
#define pmd_offset pmd_offset
#endif

#ifndef pud_offset
static inline pud_t *pud_offset(p4d_t *p4d, unsigned long address)
{
 return (pud_t *)p4d_page_vaddr(*p4d) + pud_index(address);
}
#define pud_offset pud_offset
#endif

static inline int ioremap_pmd_range(pud_t *pud, unsigned long addr,
  unsigned long end, phys_addr_t phys_addr, pgprot_t prot,
  pgtbl_mod_mask *mask)
{
 pmd_t *pmd;
 unsigned long next;

 pmd = pmd_alloc_track(&init_mm, pud, addr, mask);//找到对应的pmd页表项，对于二级页表来说，pmd指向pud
 if (!pmd)
  return -ENOMEM;
    //以PMD_SIZE为步长遍历页表
 do {
  next = pmd_addr_end(addr, end);//获取下一个PMD页表项的管辖的地址范围的起始地址

  if (ioremap_try_huge_pmd(pmd, addr, next, phys_addr, prot)) {
   *mask |= PGTBL_PMD_MODIFIED;
   continue;
  }
 //继续遍历下一级页表
  if (ioremap_pte_range(pmd, addr, next, phys_addr, prot, mask))
   return -ENOMEM;
 } while (pmd++, phys_addr += (next - addr), addr = next, addr != end);
 return 0;
}

/*
 * maps a range of physical memory into the requested pages. the old
 * mappings are removed. any references to nonexistent pages results
 * in null mappings (currently treated as "copy-on-access")
 */
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, *mapped_pte;
 spinlock_t *ptl;
 int err = 0;

 mapped_pte = pte = pte_alloc_map_lock(mm, pmd, addr, &ptl);//寻找相应的pte页表项。注意这里需要申请一个spinlock锁用来保护修改pte页表
 if (!pte)
  return -ENOMEM;
 arch_enter_lazy_mmu_mode();
    //以PAGE_SIZE为步长遍历PT页表
 do {
  BUG_ON(!pte_none(*pte));
  if (!pfn_modify_allowed(pfn, prot)) {
   err = -EACCES;
   break;
  }
        /*
        *pte_none()判断这个pte是否存在
        *pfn_pte()由页帧号pfn得到pte
        *pte_mkspecial()设置软件的PTE_SPECIAL标志位（三级页表才会用该标志位）
        *set_pte_at() 把pte设置到硬件页表中
        */
  set_pte_at(mm, addr, pte, pte_mkspecial(pfn_pte(pfn, prot)));
  pfn++;
 } while (pte++, addr += PAGE_SIZE, addr != end);
 arch_leave_lazy_mmu_mode();
 pte_unmap_unlock(mapped_pte, ptl);//PT页表设置完成后，需要把spinlock 释放
 return err;
}

/*
 * We enter with non-exclusive mmap_lock (to exclude vma changes,
 * but allow concurrent faults), and pte mapped but not yet locked.
 * We return with mmap_lock still held, but pte unmapped and unlocked.
 */
static vm_fault_t do_anonymous_page(struct vm_fault *vmf)
{
 struct vm_area_struct *vma = vmf->vma;
 struct page *page;
 vm_fault_t ret = 0;
 pte_t entry;

 /* File mapping without ->vm_ops ? */
 if (vma->vm_flags & VM_SHARED)-----------------(1)
  return VM_FAULT_SIGBUS;

 /*
  * Use pte_alloc() instead of pte_alloc_map().  We can't run
  * pte_offset_map() on pmds where a huge pmd might be created
  * from a different thread.
  *
  * pte_alloc_map() is safe to use under mmap_write_lock(mm) or when
  * parallel threads are excluded by other means.
  *
  * Here we only have mmap_read_lock(mm).
  */
 if (pte_alloc(vma->vm_mm, vmf->pmd))-----------------(2)
  return VM_FAULT_OOM;

 /* See the comment in pte_alloc_one_map() */
 if (unlikely(pmd_trans_unstable(vmf->pmd)))
  return 0;

 /* Use the zero-page for reads */
 if (!(vmf->flags & FAULT_FLAG_WRITE) &&
   !mm_forbids_zeropage(vma->vm_mm)) {-----------------(3)
  entry = pte_mkspecial(pfn_pte(my_zero_pfn(vmf->address),-----------------(4)
      vma->vm_page_prot));
  vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd,-----------------(5)
    vmf->address, &vmf->ptl);
  if (!pte_none(*vmf->pte)) {-----------------(6)
   update_mmu_tlb(vma, vmf->address, vmf->pte);
   goto unlock;
  }
  ret = check_stable_address_space(vma->vm_mm);-----------------(7)
  if (ret)
   goto unlock;
  /* Deliver the page fault to userland, check inside PT lock */
  if (userfaultfd_missing(vma)) {-----------------(8)
   pte_unmap_unlock(vmf->pte, vmf->ptl);
   return handle_userfault(vmf, VM_UFFD_MISSING);
  }
  goto setpte;
 }

 /* Allocate our own private page. */
 if (unlikely(anon_vma_prepare(vma)))-----------------(9)
  goto oom;
 page = alloc_zeroed_user_highpage_movable(vma, vmf->address);-----------------(10)
 if (!page)
  goto oom;

 if (mem_cgroup_charge(page, vma->vm_mm, GFP_KERNEL))-----------------(11)
  goto oom_free_page;
 cgroup_throttle_swaprate(page, GFP_KERNEL);

 /*
  * The memory barrier inside __SetPageUptodate makes sure that
  * preceding stores to the page contents become visible before
  * the set_pte_at() write.
  */
 __SetPageUptodate(page);-----------------(12)

 entry = mk_pte(page, vma->vm_page_prot);-----------------(13)
 entry = pte_sw_mkyoung(entry);
 if (vma->vm_flags & VM_WRITE)
  entry = pte_mkwrite(pte_mkdirty(entry));-----------------(14)

 vmf->pte = pte_offset_map_lock(vma->vm_mm, vmf->pmd, vmf->address,
   &vmf->ptl);-----------------(15)
 if (!pte_none(*vmf->pte)) {
  update_mmu_cache(vma, vmf->address, vmf->pte);-----------------(16)
  goto release;
 }

 ret = check_stable_address_space(vma->vm_mm);-----------------(17)
 if (ret)
  goto release;

 /* Deliver the page fault to userland, check inside PT lock */
 if (userfaultfd_missing(vma)) {
  pte_unmap_unlock(vmf->pte, vmf->ptl);
  put_page(page);
  return handle_userfault(vmf, VM_UFFD_MISSING);
 }

 inc_mm_counter_fast(vma->vm_mm, MM_ANONPAGES);-----------------(18)
 page_add_new_anon_rmap(page, vma, vmf->address, false);-----------------(19)
 lru_cache_add_inactive_or_unevictable(page, vma);-----------------(20)
setpte:
 set_pte_at(vma->vm_mm, vmf->address, vmf->pte, entry);-----------------(21)

 /* No need to invalidate - it was non-present before */
 update_mmu_cache(vma, vmf->address, vmf->pte);-----------------(22)
unlock:
 pte_unmap_unlock(vmf->pte, vmf->ptl);
 return ret;
release:
 put_page(page);
 goto unlock;
oom_free_page:
 put_page(page);
oom:
 return VM_FAULT_OOM;
}

/*
 * "Linux" PTE definitions for LPAE.
 *
 * These bits overlap with the hardware bits but the naming is preserved for
 * consistency with the classic page table format.
 */
#define L_PTE_VALID  (_AT(pteval_t, 1) << 0)  /* Valid */
#define L_PTE_PRESENT  (_AT(pteval_t, 3) << 0)  /* Present */
#define L_PTE_USER  (_AT(pteval_t, 1) << 6)  /* AP[1] */
#define L_PTE_SHARED  (_AT(pteval_t, 3) << 8)  /* SH[1:0], inner shareable */
#define L_PTE_YOUNG  (_AT(pteval_t, 1) << 10) /* AF */
#define L_PTE_XN  (_AT(pteval_t, 1) << 54) /* XN */
#define L_PTE_DIRTY  (_AT(pteval_t, 1) << 55)
#define L_PTE_SPECIAL  (_AT(pteval_t, 1) << 56)
#define L_PTE_NONE  (_AT(pteval_t, 1) << 57) /* PROT_NONE */
#define L_PTE_RDONLY  (_AT(pteval_t, 1) << 58) /* READ ONLY */

#define L_PMD_SECT_VALID (_AT(pmdval_t, 1) << 0)
#define L_PMD_SECT_DIRTY (_AT(pmdval_t, 1) << 55)
#define L_PMD_SECT_NONE  (_AT(pmdval_t, 1) << 57)
#define L_PMD_SECT_RDONLY (_AT(pteval_t, 1) << 58)

/*
 *   - extended small page/tiny page
 */
#define PTE_EXT_XN  (_AT(pteval_t, 1) << 0)  /* v6 */
#define PTE_EXT_AP_MASK  (_AT(pteval_t, 3) << 4)
#define PTE_EXT_AP0  (_AT(pteval_t, 1) << 4)
#define PTE_EXT_AP1  (_AT(pteval_t, 2) << 4)
#define PTE_EXT_AP_UNO_SRO (_AT(pteval_t, 0) << 4)
#define PTE_EXT_AP_UNO_SRW (PTE_EXT_AP0)
#define PTE_EXT_AP_URO_SRW (PTE_EXT_AP1)
#define PTE_EXT_AP_URW_SRW (PTE_EXT_AP1|PTE_EXT_AP0)
#define PTE_EXT_TEX(x)  (_AT(pteval_t, (x)) << 6) /* v5 */
#define PTE_EXT_APX  (_AT(pteval_t, 1) << 9)  /* v6 */
#define PTE_EXT_COHERENT (_AT(pteval_t, 1) << 9)  /* XScale3 */
#define PTE_EXT_SHARED  (_AT(pteval_t, 1) << 10) /* v6 */
#define PTE_EXT_NG  (_AT(pteval_t, 1) << 11) /* v6 */