swapper_pg_dir的作用

在内存系统初始化过程中，有如下代码：

   1: static void __init pagetable_init(void)

   2: {

   3:     pgd_t *pgd_base = swapper_pg_dir;

   4:  

   5:     permanent_kmaps_init(pgd_base);

   6: }

这里，我们看到了神秘的swapper_pg_dir，全局搜索一下，发现了

   1: /*

   2:  * Build a proper pagetable for the kernel mappings.  Up until this

   3:  * point, we've been running on some set of pagetables constructed by

   4:  * the boot process.

   5:  *

   6:  * If we're booting on native hardware, this will be a pagetable

   7:  * constructed in arch/x86/kernel/head_32.S.  The root of the

   8:  * pagetable will be swapper_pg_dir.

   9:  *

  10:  * If we're booting paravirtualized under a hypervisor, then there are

  11:  * more options: we may already be running PAE, and the pagetable may

  12:  * or may not be based in swapper_pg_dir.  In any case,

  13:  * paravirt_pagetable_setup_start() will set up swapper_pg_dir

  14:  * appropriately for the rest of the initialization to work.

  15:  *

  16:  * In general, pagetable_init() assumes that the pagetable may already

  17:  * be partially populated, and so it avoids stomping on any existing

  18:  * mappings.

  19:  */

  20: void __init early_ioremap_page_table_range_init(void)

  21: {

  22:     pgd_t *pgd_base = swapper_pg_dir;

  23:     unsigned long vaddr, end;

  24:  

  25:     /*

  26:      * Fixed mappings, only the page table structure has to be

  27:      * created - mappings will be set by set_fixmap():

  28:      */

  29:     vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;

  30:     end = (FIXADDR_TOP + PMD_SIZE - 1) & PMD_MASK;

  31:     page_table_range_init(vaddr, end, pgd_base);

  32:     early_ioremap_reset();

  33: }

---

在head_32.S中，定义了如下的BSS段，BSS段是在内核映像文件中不占空间，但是在内核被加载到内存时，会保留相应的空间。

在BSS段，一共保留了4个页面的空间，分别用initial_page_table, initial_pg_fixmap, empty_zero_page和swapper_pg_dir来标志其地址。

   1: /*

   2:  * BSS section

   3:  */

   4: __PAGE_ALIGNED_BSS

   5:     .align PAGE_SIZE

   6: #ifdef CONFIG_X86_PAE

   7: initial_pg_pmd:

   8:     .fill 1024*KPMDS,4,0

   9: #else

  10: ENTRY(initial_page_table)

  11:     .fill 1024,4,0

  12: #endif

  13: initial_pg_fixmap:

  14:     .fill 1024,4,0

  15: ENTRY(empty_zero_page)

  16:     .fill 4096,1,0

  17: ENTRY(swapper_pg_dir)

  18:     .fill 1024,4,0

通过如下代码，将initial_page_table设置为初始页目录

   1: /*

   2:  * Enable paging

   3:  */

   4:     movl $pa(initial_page_table), %eax

   5:     movl %eax,%cr3        /* set the page table pointer.. */

   6:     movl %cr0,%eax

   7:     orl  $X86_CR0_PG,%eax

   8:     movl %eax,%cr0        /* ..and set paging (PG) bit */

   9:     ljmp $__BOOT_CS,$1f    /* Clear prefetch and normalize %eip */

在内核初始化阶段，setup_arch调用了如下的函数：

   1: void __init setup_arch(char **cmdline_p)

   2: {

   3:  

   4: ......

   5: /* max_pfn_mapped is updated here */

   6: max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn< 
     
   7: max_pfn_mapped = max_low_pfn_mapped;
 
     
   8: ......
 
     
   9: x86_init.paging.pagetable_setup_start(swapper_pg_dir);
 
     
  10: paging_init();
 
     
  11: x86_init.paging.pagetable_setup_done(swapper_pg_dir);
 
     
  12:  
 
     
  13: ......
 
     
  14: }
 
    

init_memory_mapping调用了kernel_physical_mapping_init，初始化swapper_pg_dir

   1: /*

   2:  * This maps the physical memory to kernel virtual address space, a total

   3:  * of max_low_pfn pages, by creating page tables starting from address

   4:  * PAGE_OFFSET:

   5:  */

   6: unsigned long __init

   7: kernel_physical_mapping_init(unsigned long start,

   8:                  unsigned long end,

   9:                  unsigned long page_size_mask)

  10: {

  11:     int use_pse = page_size_mask == (1< 
     
  12:     unsigned long last_map_addr = end;
 
     
  13:     unsigned long start_pfn, end_pfn;
 
     
  14:     pgd_t *pgd_base = swapper_pg_dir;
 
     
  15:     int pgd_idx, pmd_idx, pte_ofs;
 
     
  16:     unsigned long pfn;
 
     
  17:     pgd_t *pgd;
 
     
  18:     pmd_t *pmd;
 
     
  19:     pte_t *pte;
 
     
  20:     unsigned pages_2m, pages_4k;
 
     
  21:     int mapping_iter;
 
     
  22:     
 
     
  23:     start_pfn = start >> PAGE_SHIFT;
 
     
  24:     end_pfn = end >> PAGE_SHIFT;
 
     
  25:     
 
     
  26:     /*
 
     
  27:      * First iteration will setup identity mapping using large/small pages
 
     
  28:      * based on use_pse, with other attributes same as set by
 
     
  29:      * the early code in head_32.S
 
     
  30:      *
 
     
  31:      * Second iteration will setup the appropriate attributes (NX, GLOBAL..)
 
     
  32:      * as desired for the kernel identity mapping.
 
     
  33:      *
 
     
  34:      * This two pass mechanism conforms to the TLB app note which says:
 
     
  35:      *
 
     
  36:      *     "Software should not write to a paging-structure entry in a way
 
     
  37:      *      that would change, for any linear address, both the page size
 
     
  38:      *      and either the page frame or attributes."
 
     
  39:      */
 
     
  40:     mapping_iter = 1;
 
     
  41:     
 
     
  42:     if (!cpu_has_pse)
 
     
  43:         use_pse = 0;
 
     
  44:     
 
     
  45:     at:
 
     
  46:     pages_2m = pages_4k = 0;
 
     
  47:     pfn = start_pfn;
 
     
  48:     pgd_idx = pgd_index((pfn< 
     
  49:     pgd = pgd_base + pgd_idx;
 
     
  50:     for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {
 
     
  51:         pmd = one_md_table_init(pgd);
 
     
  52:     
 
     
  53:         if (pfn >= end_pfn)
 
     
  54:             continue;
 
     
  55:     ef CONFIG_X86_PAE
 
     
  56:         pmd_idx = pmd_index((pfn< 
     
  57:         pmd += pmd_idx;
 
     
  58:     e
 
     
  59:         pmd_idx = 0;
 
     
  60:     if
 
     
  61:         for (; pmd_idx < PTRS_PER_PMD && pfn < end_pfn;
 
     
  62:              pmd++, pmd_idx++) {
 
     
  63:             unsigned int addr = pfn * PAGE_SIZE + PAGE_OFFSET;
 
     
  64:     
 
     
  65:             /*
 
     
  66:              * Map with big pages if possible, otherwise
 
     
  67:              * create normal page tables:
 
     
  68:              */
 
     
  69:             if (use_pse) {
 
     
  70:                 unsigned int addr2;
 
     
  71:                 pgprot_t prot = PAGE_KERNEL_LARGE;
 
     
  72:                 /*
 
     
  73:                  * first pass will use the same initial
 
     
  74:                  * identity mapping attribute + _PAGE_PSE.
 
     
  75:                  */
 
     
  76:                 pgprot_t init_prot =
 
     
  77:                     __pgprot(PTE_IDENT_ATTR |
 
     
  78:                          _PAGE_PSE);
 
     
  79:     
 
     
  80:                 addr2 = (pfn + PTRS_PER_PTE-1) * PAGE_SIZE +
 
     
  81:                     PAGE_OFFSET + PAGE_SIZE-1;
 
     
  82:     
 
     
  83:                 if (is_kernel_text(addr) ||
 
     
  84:                     is_kernel_text(addr2))
 
     
  85:                     prot = PAGE_KERNEL_LARGE_EXEC;
 
     
  86:     
 
     
  87:                 pages_2m++;
 
     
  88:                 if (mapping_iter == 1)
 
     
  89:                     set_pmd(pmd, pfn_pmd(pfn, init_prot));
 
     
  90:                 else
 
     
  91:                     set_pmd(pmd, pfn_pmd(pfn, prot));
 
     
  92:     
 
     
  93:                 pfn += PTRS_PER_PTE;
 
     
  94:                 continue;
 
     
  95:             }
 
     
  96:             pte = one_page_table_init(pmd);
 
     
  97:     
 
     
  98:             pte_ofs = pte_index((pfn< 
     
  99:             pte += pte_ofs;
 
     
 100:             for (; pte_ofs < PTRS_PER_PTE && pfn < end_pfn;
 
     
 101:                  pte++, pfn++, pte_ofs++, addr += PAGE_SIZE) {
 
     
 102:                 pgprot_t prot = PAGE_KERNEL;
 
     
 103:                 /*
 
     
 104:                  * first pass will use the same initial
 
     
 105:                  * identity mapping attribute.
 
     
 106:                  */
 
     
 107:                 pgprot_t init_prot = __pgprot(PTE_IDENT_ATTR);
 
     
 108:     
 
     
 109:                 if (is_kernel_text(addr))
 
     
 110:                     prot = PAGE_KERNEL_EXEC;
 
     
 111:     
 
     
 112:                 pages_4k++;
 
     
 113:                 if (mapping_iter == 1) {
 
     
 114:                     set_pte(pte, pfn_pte(pfn, init_prot));
 
     
 115:                     last_map_addr = (pfn << PAGE_SHIFT) + PAGE_SIZE;
 
     
 116:                 } else
 
     
 117:                     set_pte(pte, pfn_pte(pfn, prot));
 
     
 118:             }
 
     
 119:         }
 
     
 120:     }
 
     
 121:     if (mapping_iter == 1) {
 
     
 122:         /*
 
     
 123:          * update direct mapping page count only in the first
 
     
 124:          * iteration.
 
     
 125:          */
 
     
 126:         update_page_count(PG_LEVEL_2M, pages_2m);
 
     
 127:         update_page_count(PG_LEVEL_4K, pages_4k);
 
     
 128:     
 
     
 129:         /*
 
     
 130:          * local global flush tlb, which will flush the previous
 
     
 131:          * mappings present in both small and large page TLB's.
 
     
 132:          */
 
     
 133:         __flush_tlb_all();
 
     
 134:     
 
     
 135:         /*
 
     
 136:          * Second iteration will set the actual desired PTE attributes.
 
     
 137:          */
 
     
 138:         mapping_iter = 2;
 
     
 139:         goto repeat;
 
     
 140:     }
 
     
 141:     return last_map_addr;
 
     
 142: }
 
    

pgd_t *pgd_base = swapper_pg_dir;

 

将swapper_pg_dir作为页目录地址，赋给pgd_base

    start_pfn = start >> PAGE_SHIFT;
    end_pfn = end >> PAGE_SHIFT;

start和end代表着，内核直接映射的虚拟地址区域的开始物理地址和结束物理地址，通过右移PAGE_SHIFT位，再加上PAGE_OFFSET，得到其对应的页表项索引。

    pgd_idx = pgd_index((pfn<    pgd = pgd_base + pgd_idx;

pgd_idx,pgd代表着在页目录中的索引，以及相应的页目录项

   1: pgprot_t prot = PAGE_KERNEL;

   2: /*

   3:  * first pass will use the same initial

   4:  * identity mapping attribute.

   5:  */

   6: pgprot_t init_prot = __pgprot(PTE_IDENT_ATTR);

   7:  

   8: if (is_kernel_text(addr))

   9:     prot = PAGE_KERNEL_EXEC;

  10:  

  11: pages_4k++;

  12: if (mapping_iter == 1) {

  13:     set_pte(pte, pfn_pte(pfn, init_prot));

  14:     last_map_addr = (pfn << PAGE_SHIFT) + PAGE_SIZE;

  15: } else

  16:     set_pte(pte, pfn_pte(pfn, prot));

最后，通过两个回合的遍历，将属性设置到对应的页表项上去。

转载于:https://www.cnblogs.com/long123king/p/3510297.html