swapper_pg_dir的作用

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

static void __init pagetable_init(void)
{
    pgd_t *pgd_base = swapper_pg_dir;

    permanent_kmaps_init(pgd_base);
}

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

/*
 * Build a proper pagetable for the kernel mappings.  Up until this
 * point, we've been running on some set of pagetables constructed by
 * the boot process.
 *
 * If we're booting on native hardware, this will be a pagetable
 * constructed in arch/x86/kernel/head_32.S.  The root of the
 * pagetable will be swapper_pg_dir.
 *
 * If we're booting paravirtualized under a hypervisor, then there are
 * more options: we may already be running PAE, and the pagetable may
 * or may not be based in swapper_pg_dir.  In any case,
 * paravirt_pagetable_setup_start() will set up swapper_pg_dir
 * appropriately for the rest of the initialization to work.
 *
 * In general, pagetable_init() assumes that the pagetable may already
 * be partially populated, and so it avoids stomping on any existing
 * mappings.
 */
void __init early_ioremap_page_table_range_init(void)
{
    pgd_t *pgd_base = swapper_pg_dir;
    unsigned long vaddr, end;

    /*
     * Fixed mappings, only the page table structure has to be
     * created - mappings will be set by set_fixmap():
     */
    vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;
    end = (FIXADDR_TOP + PMD_SIZE - 1) & PMD_MASK;
    page_table_range_init(vaddr, end, pgd_base);
    early_ioremap_reset();
}

---

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

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

/*
 * BSS section
 */
__PAGE_ALIGNED_BSS
    .align PAGE_SIZE
#ifdef CONFIG_X86_PAE
initial_pg_pmd:
    .fill 1024*KPMDS,4,0
#else
ENTRY(initial_page_table)
    .fill 1024,4,0
#endif
initial_pg_fixmap:
    .fill 1024,4,0
ENTRY(empty_zero_page)
    .fill 4096,1,0
ENTRY(swapper_pg_dir)
    .fill 1024,4,0

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

/*
 * Enable paging
 */
    movl $pa(initial_page_table), %eax
    movl %eax,%cr3        /* set the page table pointer.. */
    movl %cr0,%eax
    orl  $X86_CR0_PG,%eax
    movl %eax,%cr0        /* ..and set paging (PG) bit */
    ljmp $__BOOT_CS,$1f    /* Clear prefetch and normalize %eip */

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

void __init setup_arch(char **cmdline_p)
{

......
/* max_pfn_mapped is updated here */
max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT);
max_pfn_mapped = max_low_pfn_mapped;
......
x86_init.paging.pagetable_setup_start(swapper_pg_dir);
paging_init();
x86_init.paging.pagetable_setup_done(swapper_pg_dir);

......
}

init_memory_mapping调用了kernel_physical_mapping_init，初始化swapper_pg_dir

/*
 * This maps the physical memory to kernel virtual address space, a total
 * of max_low_pfn pages, by creating page tables starting from address
 * PAGE_OFFSET:
 */
unsigned long __init
kernel_physical_mapping_init(unsigned long start,
                 unsigned long end,
                 unsigned long page_size_mask)
{
    int use_pse = page_size_mask == (1<<PG_LEVEL_2M);
    unsigned long last_map_addr = end;
    unsigned long start_pfn, end_pfn;
    pgd_t *pgd_base = swapper_pg_dir;
    int pgd_idx, pmd_idx, pte_ofs;
    unsigned long pfn;
    pgd_t *pgd;
    pmd_t *pmd;
    pte_t *pte;
    unsigned pages_2m, pages_4k;
    int mapping_iter;

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

    /*
     * First iteration will setup identity mapping using large/small pages
     * based on use_pse, with other attributes same as set by
     * the early code in head_32.S
     *
     * Second iteration will setup the appropriate attributes (NX, GLOBAL..)
     * as desired for the kernel identity mapping.
     *
     * This two pass mechanism conforms to the TLB app note which says:
     *
     *     "Software should not write to a paging-structure entry in a way
     *      that would change, for any linear address, both the page size
     *      and either the page frame or attributes."
     */
    mapping_iter = 1;

    if (!cpu_has_pse)
        use_pse = 0;

    at:
    pages_2m = pages_4k = 0;
    pfn = start_pfn;
    pgd_idx = pgd_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);
    pgd = pgd_base + pgd_idx;
    for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {
        pmd = one_md_table_init(pgd);

        if (pfn >= end_pfn)
            continue;
    ef CONFIG_X86_PAE
        pmd_idx = pmd_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);
        pmd += pmd_idx;
    e
        pmd_idx = 0;
    if
        for (; pmd_idx < PTRS_PER_PMD && pfn < end_pfn;
             pmd++, pmd_idx++) {
            unsigned int addr = pfn * PAGE_SIZE + PAGE_OFFSET;

            /*
             * Map with big pages if possible, otherwise
             * create normal page tables:
             */
            if (use_pse) {
                unsigned int addr2;
                pgprot_t prot = PAGE_KERNEL_LARGE;
                /*
                 * first pass will use the same initial
                 * identity mapping attribute + _PAGE_PSE.
                 */
                pgprot_t init_prot =
                    __pgprot(PTE_IDENT_ATTR |
                         _PAGE_PSE);

                addr2 = (pfn + PTRS_PER_PTE-1) * PAGE_SIZE +
                    PAGE_OFFSET + PAGE_SIZE-1;

                if (is_kernel_text(addr) ||
                    is_kernel_text(addr2))
                    prot = PAGE_KERNEL_LARGE_EXEC;

                pages_2m++;
                if (mapping_iter == 1)
                    set_pmd(pmd, pfn_pmd(pfn, init_prot));
                else
                    set_pmd(pmd, pfn_pmd(pfn, prot));

                pfn += PTRS_PER_PTE;
                continue;
            }
            pte = one_page_table_init(pmd);

            pte_ofs = pte_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);
            pte += pte_ofs;
            for (; pte_ofs < PTRS_PER_PTE && pfn < end_pfn;
                 pte++, pfn++, pte_ofs++, addr += PAGE_SIZE) {
                pgprot_t prot = PAGE_KERNEL;
                /*
                 * first pass will use the same initial
                 * identity mapping attribute.
                 */
                pgprot_t init_prot = __pgprot(PTE_IDENT_ATTR);

                if (is_kernel_text(addr))
                    prot = PAGE_KERNEL_EXEC;

                pages_4k++;
                if (mapping_iter == 1) {
                    set_pte(pte, pfn_pte(pfn, init_prot));
                    last_map_addr = (pfn << PAGE_SHIFT) + PAGE_SIZE;
                } else
                    set_pte(pte, pfn_pte(pfn, prot));
            }
        }
    }
    if (mapping_iter == 1) {
        /*
         * update direct mapping page count only in the first
         * iteration.
         */
        update_page_count(PG_LEVEL_2M, pages_2m);
        update_page_count(PG_LEVEL_4K, pages_4k);

        /*
         * local global flush tlb, which will flush the previous
         * mappings present in both small and large page TLB's.
         */
        __flush_tlb_all();

        /*
         * Second iteration will set the actual desired PTE attributes.
         */
        mapping_iter = 2;
        goto repeat;
    }
    return last_map_addr;
}

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<<PAGE_SHIFT) + PAGE_OFFSET);
    pgd = pgd_base + pgd_idx;

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

pgprot_t prot = PAGE_KERNEL;
/*
 * first pass will use the same initial
 * identity mapping attribute.
 */
pgprot_t init_prot = __pgprot(PTE_IDENT_ATTR);

if (is_kernel_text(addr))
    prot = PAGE_KERNEL_EXEC;

pages_4k++;
if (mapping_iter == 1) {
    set_pte(pte, pfn_pte(pfn, init_prot));
    last_map_addr = (pfn << PAGE_SHIFT) + PAGE_SIZE;
} else
    set_pte(pte, pfn_pte(pfn, prot));

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