又是一个国庆七天假，之前有很多打算

可是到最后，只有linux愿意陪我。

介绍pageing_init之前，我们了解几个定义

pte_t 页表项

pmd_t 页中间目录项

pud_t 页上级目录

pgd_t 页全局目录项

我的arm平台

#define PMD_SHIFT                21

#define PGDIR_SHIFT               21

 

下面这个函数paging_init每个平台实现不一样，我的根本就没有用PUD_SHIFT

arm最多用二级

void __init paging_init(struct machine_desc*mdesc)

{

       void *zero_page;

 

       memblock_set_current_limit(lowmem_limit);

       就是

       memblock.current_limit = limit;

lowmem_limit = bank->start + bank->size;高端内存初始化时记录的我的是0x34000000

 

        build_mem_type_table();这个函数很大，主要就是根据cpu类型记录内存信息，大的原因就是可虑了所以现有的arm类型

        printk("Memory policy: ECC%sabled, Data cache %s\n",

                ecc_mask ? "en" :"dis", cp->policy);

我的平台Memory policy: ECC disabled, Data cache writeback关闭ecc数据缓存为回写

       prepare_page_table();

我们看看准备什么

static inline void prepare_page_table(void)

{

        unsigned longaddr;

        phys_addr_t end;

 

        /*

         * Clear out allthe mappings below the kernel image.

         */

清除内核下所有的映射

我的MODULES_VADDR=0xbf000000 PMD_SIZE=0x2000000

MODULES_VADDR是动态模块映射区起始地址，

PMD_SIZE宏用于计算由页中间目录的一个单独表项所映射的区域大小，也就是一个页表的大小

我的平台启动打印

    vector  : 0xffff0000 - 0xffff1000   (   4kB)

    fixmap  : 0xfff00000 - 0xfffe0000   ( 896 kB)

    vmalloc : 0xc4800000 -0xf6000000   ( 792 MB)

    lowmem  : 0xc0000000 - 0xc4000000   (  64MB)

    pkmap   : 0xbfe00000 - 0xc0000000   (   2MB)

modules : 0xbf000000 -0xbfe00000   (  14 MB)

        for (addr = 0;addr < MODULES_VADDR; addr += PMD_SIZE)

               pmd_clear(pmd_off_k(addr));

pmd_off_k(addr)就是(pmd_t *)addr

#definepmd_clear(pmdp)                         \

         do{                             \

                  pmdp[0] = __pmd(0);       \

                  pmdp[1] = __pmd(0);       \

                  clean_pmd_entry(pmdp);        \

         } while (0)

#define __pmd(x)        (x)

 

 staticinline void clean_pmd_entry(pmd_t *pmd)

{

说一下pmd传入此函数就是存在寄存器r0中

        const unsigned int__tlb_flag = __cpu_tlb_flags;由cpu决定

 

        if (tlb_flag(TLB_DCLEAN))先判断cpu内存类型

               asm("mcr        p15, 0, %0,c7, c10, 1  @ flush_pmd"

                        :: "r" (pmd) : "cc");

就是mcr p15 0 r0 c7 c10 1

清除数据缓冲区Line使用的装换的虚拟地址r0(就是pmd)。

 

        if(tlb_flag(TLB_L2CLEAN_FR))

                asm("mcr        p15, 1, %0, c15, c9, 1  @ L2 flush_pmd"

                        :: "r" (pmd) : "cc");

清除L2 cache

}

 

上面以说过XIP。内

#ifdef CONFIG_XIP_KERNEL

        /* The XIP kernelis mapped in the module area -- skip over it */

        addr = ((unsignedlong)_etext + PMD_SIZE - 1) & PMD_MASK;

#endif

此时addr是内核空间地址开始

        for ( ; addr <PAGE_OFFSET; addr += PMD_SIZE)

               pmd_clear(pmd_off_k(addr));

从上面可以知道这个清除了动态模块空间、pkmap(高端内存的永久固定区)、内核低端内存空间

        /*

         * Find the end ofthe first block of lowmem.

         */

        end =memblock.memory.regions[0].base + memblock.memory.regions[0].size;

        if (end >=lowmem_limit)

                end =lowmem_limit;

end设为低端内存空间结尾地址或第一个bank结尾地址

        /*

         * Clear out allthe kernel space mappings, except for the first

         * memory bank, upto the end of the vmalloc region.

         */

当然是跳过第一个bank 的所以内核空间

VMALLOC_END=0xf6000000

        for (addr =__phys_to_virt(end);

             addr <VMALLOC_END; addr += PMD_SIZE)

                pmd_clear(pmd_off_k(addr));

}

 

       map_lowmem();

低端内存映射

static void __init map_lowmem(void)

{

        structmemblock_region *reg;

 

        /* Map all thelowmem memory banks. */

       for_each_memblock(memory, reg) {

                phys_addr_tstart = reg->base;

               phys_addr_t end = start + reg->size;

                structmap_desc map;

 

                if (end> lowmem_limit)

                       end = lowmem_limit;

                if (start>= end)

                        break;

 

                map.pfn =__phys_to_pfn(start);页号

#define     __phys_to_pfn(paddr)    ((unsignedlong)((paddr) >> PAGE_SHIFT))

((unsigned long)((paddr) >>12))就是除以4096 即页大小

               map.virtual = __phys_to_virt(start);

                map.length= end - start;

                map.type =MT_MEMORY;

 

               create_mapping(&map);

生成目录项和必要的页表，这是一个重要的函数

static void __init create_mapping(struct map_desc *md)

{

        unsigned longaddr, length, end;

        phys_addr_t phys;

        const struct mem_type *type;

        pgd_t *pgd;

 

        if (md->virtual!= vectors_base() && md->virtual < TASK_SIZE) {不是中断向量表地址也不是在内核空间

#if __LINUX_ARM_ARCH__ >= 4

#define vectors_high() (cr_alignment & CR_V)

#else

#define vectors_high()  (0)

#endif

 

:#define vectors_base()      (vectors_high() ? 0xffff0000 : 0)

中断向量表地址，我的是0xffff0000

 

#define TASK_SIZE               (UL(CONFIG_PAGE_OFFSET) - UL(0x01000000))

0x01000000：16M就是动态模块空间+pkmap空间

TASK_SIZE就是内核空间地址开始

               printk(KERN_WARNING "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->type == MT_ROM) &&

            md->virtual>= PAGE_OFFSET && md->virtual < VMALLOC_END) {

重叠的虚拟空间

               printk(KERN_WARNING "BUG: mapping for 0x%08llx"

                      " at 0x%08lx overlaps vmalloc space\n",

                      (long long)__pfn_to_phys((u64)md->pfn), md->virtual);

        }

 

        type =&mem_types[md->type];

 

        /*

         * Catch 36-bitaddresses

         */

36位地址

        if (md->pfn>= 0x100000) {

               create_36bit_mapping(md, type);这个我们不看了，我还没有用过36位地址的

                return;

        }

#define PAGE_MASK (~(PAGE_SIZE-1)) 即~0xfff

        addr =md->virtual & PAGE_MASK; 这样就是屏蔽页内偏移值

        phys =__pfn_to_phys(md->pfn); 物理地址

        length =PAGE_ALIGN(md->length + (md->virtual & ~PAGE_MASK));对齐

第12位为长度，高20位为页表和页目录

#define SECTION_SHIFT          20

#define SECTION_SIZE           (1UL << SECTION_SHIFT) 段大小为1M

#define SECTION_MASK           (~(SECTION_SIZE-1))

 

        if(type->prot_l1 == 0 && ((addr | phys | length) & ~SECTION_MASK)){

此条件是即不是l1又是和1M对齐

下面细说这个判断

在下面的alloc_init_section（）看到此条件的应用

               printk(KERN_WARNING "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_k(addr);

#define PGDIR_SHIFT             21

#define pgd_index(addr)        ((addr) >> PGDIR_SHIFT) 右移21位正好的页目录地址

#define pgd_offset(mm, addr)   ((mm)->pgd + pgd_index(addr))

#define pgd_offset_k(addr)     pgd_offset(&init_mm, addr)

我懒得算直接打印把

        printk(KERN_NOTICE"md->virtual = 0x%lx md->pfn = 0x%lx md->length = 0x%lx\n",(unsigned long)md->virtual, (unsigned long)md->pfn, (unsignedlong)md->length);

        printk(KERN_NOTICE"addr = 0x%lx phys = 0x%lx length = 0x%lx init_mm.pgd = 0x%lx pgd =0x%lx\n", (unsigned long)addr, (unsigned long)phys, (unsigned long)length,(unsigned long)init_mm.pgd, (unsigned long)pgd);

 

此时打印结果

md->virtual = 0xc0000000 md->pfn = 0x30000 md->length =0x4000000

addr = 0xc0000000 phys = 0x30000000 length = 0x4000000 init_mm.pgd= 0xc0004000 pgd = 0xc0007000

        end = addr +length;

        do {

                unsignedlong next = pgd_addr_end(addr, end);

#define pgd_addr_end(addr, end)                                        \

({      unsigned long__boundary = ((addr) + PGDIR_SIZE) & PGDIR_MASK;  \

        (__boundary - 1 <(end) - 1)? __boundary: (end);               \

})

#define PGDIR_SIZE              (1UL << PGDIR_SHIFT)

1 << 21 2M

#define PGDIR_MASK               (~(PGDIR_SIZE-1)) 即屏蔽21位

这个就是找到下一个页目录

               alloc_init_pud(pgd, addr, next, phys, type);

static void alloc_init_pud(pgd_t *pgd, unsigned long addr, unsignedlong end,

        unsigned long phys,const struct mem_type *type)

{

传入的参数说明

pgd 页目录地址

addr 要映射的虚拟空间起始地址

end要映射的虚拟空间结束地址

phys 要映射的虚拟空间对应的物理空间起始地址

type mem类型

        pud_t *pud =pud_offset(pgd, addr);

typedef struct { pgd_t pgd; } pud_t;

pud_offset() 就是转换为pgd_t因为我说过此平台没有pud

        unsigned long next;

 

#define pud_addr_end(addr, end)                      (end)

        do {

                next =pud_addr_end(addr, end);

               alloc_init_section(pud, addr, next, phys, type);这个函数我们在下面贴

                phys += next - addr;

        } while (pud++, addr= next, addr != end);

}

                phys +=next - addr;

                addr =next;

        } while (pgd++,addr != end);

}

上面看似是pgd循环加上pud循环，在此实质就是pdg循环

 

        }

}

下面重点看alloc_init_section

#definepmd_offset(dir, addr)   ((pmd_t *)(dir))

在ARM处理器上，如果是整个段都有映射，则采用单层映射，如果不是整个段都有映射，则采用两层映射。页面大小采用的是4KB，使页面目录对应于ARM的首层映射表，中间目录设置成与页面目录相同，从而把概念上的三层映射转换成了物理上的两层映射。采用两层映射会降低系统的相应速度，因为从虚拟地址到物理地址之间的转换多了一步，会浪费时间，但是会增加内存的利用率，除非进程用完了3GB的地址空间。这种可能性是很小的。对于某些外设的操作，希望它反应迅速，因此需要将其进行单层映射，因此将IO寄存器所在的区域进行单层映射。

http://blog.csdn.net/zhaohc_nj/article/details/7977011

这个微博分析了alloc_init_section，可以看看，我也分析一下吧

static void __init alloc_init_section(pud_t *pud, unsigned longaddr,

                                     unsignedlong end, phys_addr_t phys,

                                      conststruct mem_type *type)

{

        pmd_t *pmd =pmd_offset(pud, addr);

这个有让我们看到好像是pud循环下的pmd循环，其实都是pgd

        /*

         * Try a section mapping - end, addr and physmust all be aligned

         * to a sectionboundary.  Note that PMDs refer to theindividual

         * L1 entries,whereas PGDs refer to a group of L1 entries making

         * up one logicalpointer to an L2 table.

         */

        解释的很清楚一个section映射。条件就是end, addr and physmust all be aligned

         to a sectionboundary

        if (((addr | end |phys) & ~SECTION_MASK) == 0) {

                pmd_t *p =pmd;

 

                if (addr& SECTION_SIZE)

                        pmd++;

 

                do {

                       *pmd = __pmd(phys | type->prot_sect);

这里或上prot_sect和arm的mmu工作原理有关

                       phys += SECTION_SIZE;

可以看出就是把每个section的起始物理地址存入页目录地址

可以看出线性的概念。单层映射没有使用页框这个东西。就用了pgd.

                } while (pmd++, addr += SECTION_SIZE,addr != end);

 

               flush_pmd_entry(p);

flush_pmd_entry主要就是

               asm("mcr        p15, 0, %0,c7, c10, 1  @ flush_pmd"

                        : :"r" (pmd) : "cc");

就是r0 = p

mcr p15, 0, r0, c7, c10, 1

清除数据缓冲区Line使用的装换的虚拟地址

 

        } else {

                /*

                 * No needto loop; pte's aren't interested in the

                 *individual L1 entries.

                 */

               alloc_init_pte(pmd, addr, end, __phys_to_pfn(phys), type);

static void __init alloc_init_pte(pmd_t *pmd, unsigned long addr,

                                 unsigned long end, unsigned long pfn,

                                 const struct mem_type *type)

{

        pte_t *pte =early_pte_alloc(pmd, addr, type->prot_l1);

static pte_t * __init early_pte_alloc(pmd_t *pmd, unsigned longaddr, unsigned long prot)

{

        if (pmd_none(*pmd)) {

pte_t *pte =early_alloc(PTE_HWTABLE_OFF + PTE_HWTABLE_SIZE);

值为0即一级为空，此时要求pte分配空间512*sizof(pte_t) +512*sizeof(u32)

对于这个大小我们看看linux给我们的解释。arch/arm/include/asm/pgtable-2level.h

* Hardware-wise, we have a two level page table structure, wherethe first

 * level has 4096 entries,and the second level has 256 entries. Each entry

 * is one 32-bit word..Mostof the bits in the second level entry are used

 * by hardware, and therearen't any "accessed" and "dirty" bits.

硬件方面，我们有一个两级页表结构，其中第一级有4096个条目，第二级有256个条目。每个条目是一个32-bit字。第二级有很多位被硬件用，它们中没有”accessed”和”dirty”位

 

* Linux on the other hand has a three level page table structure,which can

 * be wrapped to fit a twolevel page table structure easily - using the PGD

 * and PTE only.  However, Linux also expects one"PTE" table per page, and

 * at least a"dirty" bit.

另一方面Linux上有三级页表结构，它可以很容易包裹，以适应一个两级页表结构 -使用PGD和PTE。然而，Linux还预计，一个PTE表，每页至少一个“dirty”位。

* Therefore, we tweak the implementation slightly - we tell Linuxthat we

 * have 2048 entries in thefirst level, each of which is 8 bytes (iow, two

 * hardware pointers to thesecond level.)  The second level containstwo

 * hardware PTE tablesarranged contiguously, preceded by Linux versions

 * which contain the stateinformation Linux needs.  We, therefore,end up

 * with 512 entries in the"PTE" level.

因此，我们小幅调整的实施 - 我们告诉Linux，我们有2048个条目，其中每8个字节（IOW，两个硬件指针到第二级）第二个等级包含两个硬件PTE表相邻排列，前面带有Linux版本，其中包含的Linux需要的状态信息。因此，我们有512个条目中的“pte”。

 

因此，linux在构造页表时，制造了一个假象：
1) 硬件PGD还是4096项，每项4字节；但是linux按照PGD共2048项，每项8字节来计算，计算得来的每项中实际都含有两个pgd项。
2) 硬件PTE还是256项，每项4字节；但是linux每次分配pte表时，都分配4K大小的页，页的前2048字节折合512个pte项，即折合两个硬件的pte表；页的后2048字节留作它用，折合为虚拟的512个pte项，即折合两个虚拟的pte表，与前半页对应。

 

这样，前半页折合出来的两个硬件pte表，正好填入2个pgd项中。

而且:
前半页折合出来的两个硬件pte表中，每项都包含一些页的属性bit，如是否present，是否可写....这些属性均为ARM硬件支持的属性，命名为PTE_xxx
后半页折合出来的两个虚拟pte表中，每项都包含一些页的属性bit，如是否accessed,是否dirty....这些属性均为ARM硬件不能支持的属性，命名为L_PTE_xxx

这样，就能模拟出来诸如accessed,dirty.....这样硬件还不支持的属性。       

启动内存分配我在下次搞个单独微博再说

               __pmd_populate(pmd, __pa(pte), prot);

static inline void __pmd_populate(pmd_t *pmdp, phys_addr_t pte,

                                 pmdval_t prot)

{

        pmdval_t pmdval =(pte + PTE_HWTABLE_OFF) | prot;

pmd 值为(pte + PTE_HWTABLE_OFF) | prot，这也是mmu工作原理决定的

        pmdp[0] =__pmd(pmdval);第一个硬件pte表

        pmdp[1] =__pmd(pmdval + 256 * sizeof(pte_t))第二个硬件pte表;

       flush_pmd_entry(pmdp);已说过

}

        }

       BUG_ON(pmd_bad(*pmd));

        returnpte_offset_kernel(pmd, addr);

}

        do {

               set_pte_ext(pte, pfn_pte(pfn, __pgprot(type->prot_pte)), 0);

pte的值也是和mmu硬件有关

#define set_pte_ext(ptep,pte,ext) cpu_set_pte_ext(ptep,pte,ext)

#define cpu_set_pte_ext                      __glue(CPU_NAME,_set_pte_ext)

#define __glue(name,fn)           ____glue(name,fn)

#define ____glue(name,fn) name##fn

我的就是，真佩服linux内核开发者的用法

cpu_arm920_set_pte_ext(pfn, __pgprot(type->prot_pte)), 0);

这是汇编

/*

 * cpu_arm920_set_pte(ptep,pte, ext)

 *

 * Set a PTE and flush it out设置并刷新

 */

        .align  5

ENTRY(cpu_arm920_set_pte_ext)

#ifdef CONFIG_MMU

        armv3_set_pte_ext

        mov     r0, r0

由于d cache打开， 这一条指令实际并没有写回内存，而是写到cache中 

        mcr     p15, 0, r0, c7, c10, 1          @ clean D entry清除D入口

把cache中地址r0对应的内容写回内存中， 这一条语句实际是写到了write buffer中, 
还没有真正写回内存。 

        mcr     p15, 0, r0, c7, c10, 4          @ drain WBWB开漏

等待把writebuffer中的内容写回内存。

之前这个物理址可能已经与别的虚拟地址建立了映射，而且刚对该地址进行过操作，会出现在数据缓存中，因此除了要更新内存中的pte外，还要删除写缓冲器中与该中间目录项相对应的项和沥干写缓冲器，防止下一次进行存取时发生误操

#endif

        mov     pc, lr

 

                pfn++;

        } while (pte++, addr+= PAGE_SIZE, addr != end);

循环填写

}

        }

}

       devicemaps_init(mdesc);

/*

 *Set up device the mappings.  Since weclear out the page tables for all

 *mappings above VMALLOC_END, we will remove any debug device mappings.

 *This means you have to be careful how you debug this function, or any

 *called function.  This means you can'tuse any function or debugging

 *method which may touch any device, otherwise the kernel _will_ crash.

 */

设置设备的映射。由于我们清除掉所有VMALLOC_END以上映射，我们将删除任何调试设备映射。这意味着你必须要小心调试此函数，或任何调用。这意味着你不能使用任何可能会碰触到任何设备的函数或调试方法，否则内核_will_崩溃。

这段话很好理解，比如我们用的硬件寄存器映射就是在vmalloc_end以上，当你在访问时，这个映射已被清除了，当然会崩溃。

static void __init devicemaps_init(structmachine_desc *mdesc)

{

        struct map_desc map;

        unsigned long addr;

 

        /*

         * Allocate the vector page early.

         */

        vectors_page = early_alloc(PAGE_SIZE);

 

        for (addr = VMALLOC_END; addr; addr +=PMD_SIZE)

                pmd_clear(pmd_off_k(addr));

这个就是我们上面看的清除掉所有VMALLOC_END以上映射

#definepmd_clear(pmdp)                 \

        do {                            \

                pmdp[0] = __pmd(0);     \

                pmdp[1] = __pmd(0);     \

                clean_pmd_entry(pmdp);  \

        } while (0)

clean_pmd_entry()不贴了，就是利用cp15去操作pmd clear。

        /*

         * Map the kernel if it is XIP.

         * It is always first in themodulearea.

         */

已说过xip，它代码段是运行在flash rom上，如norflash.

MODULES_VADDR=0xbf000000

从这看，内存也可以是flash啊

上面的英文已说的很清楚，xip总是从modulearea开始

我的平台没有这个

#ifdef CONFIG_XIP_KERNEL

        map.pfn =__phys_to_pfn(CONFIG_XIP_PHYS_ADDR & SECTION_MASK);

        map.virtual = MODULES_VADDR;

        map.length = ((unsigned long)_etext -map.virtual + ~SECTION_MASK) & SECTION_MASK;

        map.type = MT_ROM;

        create_mapping(&map);

#endif

 

        /*

         * Map the cache flushing regions.

         */

Cache映射

#ifdef FLUSH_BASE

        map.pfn =__phys_to_pfn(FLUSH_BASE_PHYS);

        map.virtual = FLUSH_BASE;

        map.length = SZ_1M;

        map.type = MT_CACHECLEAN;

        create_mapping(&map);

#endif

Minicache映射

#ifdefFLUSH_BASE_MINICACHE

        map.pfn = __phys_to_pfn(FLUSH_BASE_PHYS+ SZ_1M);

        map.virtual = FLUSH_BASE_MINICACHE;

        map.length = SZ_1M;

        map.type = MT_MINICLEAN;

        create_mapping(&map);

#endif

上面的我的平台都没有

下面是向量表映射

        /*

         * Create a mapping for the machinevectors at the high-vectors

         * location (0xffff0000).  If we aren't using high-vectors, also

         * create a mapping at the low-vectorsvirtual address.

         */

        map.pfn =__phys_to_pfn(virt_to_phys(vectors_page));

        map.virtual = 0xffff0000;

        map.length = PAGE_SIZE;

        map.type = MT_HIGH_VECTORS;

 

  create_mapping(&map);

还记得我在此函数加的打印吧

打印结果

md->virtual = 0xffff0000 md->pfn = 0x33fff md->length =0x1000

addr = 0xffff0000 phys = 0x33fff000 length = 0x1000 init_mm.pgd =0xc0004000 pgd = 0xc0007ff8中断向量表的页目录地址

 

 

        if (!vectors_high()) {

上面的英文说：如果不能用高端向量表，就映射个低端的，

从虚拟地址0开始

我们看看vectors_high()

 

#if__LINUX_ARM_ARCH__ >= 4

#definevectors_high()  (cr_alignment & CR_V)

#else

#definevectors_high()  (0)

#endif

这个是由arm架构来决定的

                map.virtual = 0;

                map.type = MT_LOW_VECTORS;

                create_mapping(&map);

        }

 

        /*

         * Ask the machine support to map inthe statically mapped devices.

         */

 

        if (mdesc->map_io)

                mdesc->map_io();

 

静态映射：这个玩意就是我们说的io静态映射用法，我的平台有

        .map_io         = mini2440_map_io,

static void __initmini2440_map_io(void)

{

        s3c24xx_init_io(mini2440_iodesc,ARRAY_SIZE(mini2440_iodesc));

}

static structmap_desc mini2440_iodesc[] __initdata = {

        /* nothing to declare, move along */

};

这个我们只看两句

        iotable_init(mach_desc, size);

        iotable_init(s3c_iodesc,ARRAY_SIZE(s3c_iodesc));

 

static structmap_desc s3c_iodesc[] __initdata = {

        IODESC_ENT(GPIO),

        IODESC_ENT(IRQ),

        IODESC_ENT(MEMCTRL),

        IODESC_ENT(UART)

};

 

#define IODESC_ENT(x){ (unsigned long)S3C24XX_VA_##x, __phys_to_pfn(S3C24XX_PA_##x), S3C24XX_SZ_##x,MT_DEVICE }

 

void __initiotable_init(struct map_desc *io_desc, int nr)

{

        int i;

 

        for (i = 0; i < nr; i++)

                create_mapping(io_desc + i);

}

应该有四个打印

GPIO：

md->virtual = 0xfd000000 md->pfn = 0x56000 md->length =0x100000

addr = 0xfd000000 phys = 0x56000000 length = 0x100000 init_mm.pgd =0xc0004000 pgd = 0xc0007f40

IRQ：终端控制器

md->virtual = 0xf6000000 md->pfn = 0x4a000 md->length =0x100000

addr = 0xf6000000 phys = 0x4a000000 length = 0x100000 init_mm.pgd =0xc0004000 pgd = 0xc0007d80

MEMCTRL：存储控制器

md->virtual = 0xf6200000 md->pfn = 0x48000 md->length =0x100000

addr = 0xf6200000 phys = 0x48000000 length = 0x100000 init_mm.pgd =0xc0004000 pgd = 0xc0007d88

UART：

md->virtual = 0xf7000000 md->pfn = 0x50000 md->length =0x100000

addr = 0xf7000000 phys = 0x50000000 length = 0x100000 init_mm.pgd =0xc0004000 pgd = 0xc0007dc0

 

        /*

         * Finally flush the caches and tlb toensure that we're in a

         * consistent state wrt thewritebuffer.  This also ensures that

         * any write-allocated cache lines inthe vector page are written

         * back.  After this point, we can start to touchdevices again.

         */

最后刷新caches和tlb以确保我们处于一致的writebuffer缓存。这也保证了任何写矢量页分配的cache lines被写回。这一点后，我们就可以开始再次触摸设备

        local_flush_tlb_all();

        flush_cache_all();

这两个都是汇编，我不在细看了

}

 

       kmap_init();

这个函数时pkmap的初始化

这个就是我们说的高端内存中的永久内核映射，永久内存映射也是线性映射，它使用了散列表来记录页信息，此表的地址在PKMAP_BASE下，

#definePKMAP_BASE              (PAGE_OFFSET -PMD_SIZE)

可以看出在0xc0000000下2M的地方0xbfe00000

static void __init kmap_init(void)

{

#ifdef CONFIG_HIGHMEM

        pkmap_page_table =early_pte_alloc(pmd_off_k(PKMAP_BASE),

               PKMAP_BASE, _PAGE_KERNEL_TABLE);

#endif

}

 

       top_pmd = pmd_off_k(0xffff0000);

 

       /* allocate the zero page. */

       zero_page = early_alloc(PAGE_SIZE);

 

       bootmem_init();

bootmem_init下一篇微博单独看

       empty_zero_page = virt_to_page(zero_page);

       __flush_dcache_page(NULL, empty_zero_page);

不细看

}