Linux页表机制管理初始化

一、临时内核页表初始化

在setup_32.S中

[cpp]

1. page_pde_offset = (__PAGE_OFFSET >> 20);  


2.   


3.     movl $pa(__brk_base), %edi  


4.     movl $pa(swapper_pg_dir), %edx  


5.     movl $PTE_IDENT_ATTR, %eax  


6. 10:  


7.     leal PDE_IDENT_ATTR(%edi),%ecx      /* Create PDE entry */  


8.     movl %ecx,(%edx)            /* Store identity PDE entry */  


9.     movl %ecx,page_pde_offset(%edx)     /* Store kernel PDE entry */  


10.     addl $4,%edx  


11.     movl $1024, %ecx  


12. 11:  


13.     stosl  


14.     addl $0x1000,%eax  


15.     loop 11b  


16.     /* 


17.      * End condition: we must map up to the end + MAPPING_BEYOND_END. 


18.      */  


19.     movl $pa(_end) + MAPPING_BEYOND_END + PTE_IDENT_ATTR, %ebp  


20.     cmpl %ebp,%eax  


21.     jb 10b  


22.     addl $__PAGE_OFFSET, %edi  


23.     movl %edi, pa(_brk_end)  


24.     shrl $12, %eax  


25.     movl %eax, pa(max_pfn_mapped)  


26.   


27.     /* Do early initialization of the fixmap area */  


28.     movl $pa(swapper_pg_fixmap)+PDE_IDENT_ATTR,%eax  


29.     movl %eax,pa(swapper_pg_dir+0xffc)  

对于页表初始化的原理如果可以参考intel手册。

其中常量PTE_IDENT_ATTR定义在patable_types.h中。

[cpp]

1. #define PTE_IDENT_ATTR   0x003      /* PRESENT+RW */  

二、启动分页机制

实现代码在head_32.S中。

[cpp]

1. movl $pa(swapper_pg_dir),%eax  


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


3. movl %cr0,%eax  


4. orl  $X86_CR0_PG,%eax  


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

三、低端内存和高端内存固定映射区页表机制初始化

在start_kernle()->setup_arch()->init_memory_mapping()中实现具体的页表映射机制的建立。

[cpp]

1. void __init setup_arch(char **cmdline_p)  


2. {  


3.     ……  


4.       


5.      /* max_pfn_mapped is updated here */  


6.     /*建立分页机制，包括页表的内存分配，映射的建立包括低端内存的映射建立，高端内 存中固定映射区域的映射建立返回的值为低端内存的总共映射的内存大小，页面为单位  */  


7.     max_low_pfn_mapped = init_memory_mapping(0, max_low_pfn<<PAGE_SHIFT);  


8.     max_pfn_mapped = max_low_pfn_mapped;//将其保存到变量   


9.       


10.     ……  


11. }  

[cpp]

1. /* 


2.  * Setup the direct mapping of the physical memory at PAGE_OFFSET. 


3.  * This runs before bootmem is initialized and gets pages directly from 


4.  * the physical memory. To access them they are temporarily mapped. 


5.  */  


6.  /*建立页表映射。对于高端内存的固定映射区没有映射到实际的页面，只是这种 


7.  机制的初步建立，页表存储的空间保留*/  


8. unsigned long __init_refok init_memory_mapping(unsigned long start,  


9.                            unsigned long end)  


10. {  


11.     unsigned long page_size_mask = 0;  


12.     unsigned long start_pfn, end_pfn;  


13.     unsigned long ret = 0;  


14.     unsigned long pos;  


15.   


16.     struct map_range mr[NR_RANGE_MR];  


17.     int nr_range, i;  


18.     int use_pse, use_gbpages;  


19.   


20.     printk(KERN_INFO “init_memory_mapping: %016lx-%016lx\n”, start, end);  


21.   


22. #if defined(CONFIG_DEBUG_PAGEALLOC) || defined(CONFIG_KMEMCHECK)   


23.     /* 


24.      * For CONFIG_DEBUG_PAGEALLOC, identity mapping will use small pages. 


25.      * This will simplify cpa(), which otherwise needs to support splitting 


26.      * large pages into small in interrupt context, etc. 


27.      */  


28.     use_pse = use_gbpages = 0;  


29. #else   


30.     use_pse = cpu_has_pse;  


31.     use_gbpages = direct_gbpages;  


32. #endif   


33. //定义了X86_PAE模式后进行调用；   


34.     set_nx();  


35.     if (nx_enabled)  


36.         printk(KERN_INFO “NX (Execute Disable) protection: active\n”);  


37.   


38.     /* Enable PSE if available */  


39.     if (cpu_has_pse)  


40.         set_in_cr4(X86_CR4_PSE);  


41.   


42.     /* Enable PGE if available */  


43.     if (cpu_has_pge) {  


44.         set_in_cr4(X86_CR4_PGE);  


45.         __supported_pte_mask |= _PAGE_GLOBAL;  


46.     }  


47.     /*page_size_mask在这里更新，在后面对设置页表时用到*/  


48.     if (use_gbpages)  


49.         page_size_mask |= 1 << PG_LEVEL_1G;  


50.     if (use_pse)  


51.         page_size_mask |= 1 << PG_LEVEL_2M;  


52.   


53.     memset(mr, 0, sizeof(mr));  


54.     nr_range = 0;  


55.   


56.     /* head if not big page alignment ? */  


57.     start_pfn = start >> PAGE_SHIFT;/*在setup函数中调用时，这里为0*/  


58.     pos = start_pfn << PAGE_SHIFT;/*pos为0*/  


59. #ifdef CONFIG_X86_32   


60.     /* 


61.      * Don’t use a large page for the first 2/4MB of memory 


62.      * because there are often fixed size MTRRs in there 


63.      * and overlapping MTRRs into large pages can cause 


64.      * slowdowns. 


65.      */  


66.     if (pos == 0)/*end_pfn的大小为1k，也就是4M大小的内存*/  


67.         end_pfn = 1<<(PMD_SHIFT – PAGE_SHIFT);  


68.     else  


69.         end_pfn = ((pos + (PMD_SIZE – 1))>>PMD_SHIFT)  


70.                  << (PMD_SHIFT – PAGE_SHIFT);  


71. #else /* CONFIG_X86_64 */   


72.     end_pfn = ((pos + (PMD_SIZE – 1)) >> PMD_SHIFT)  


73.             << (PMD_SHIFT – PAGE_SHIFT);  


74. #endif   


75.     if (end_pfn > (end >> PAGE_SHIFT))  


76.         end_pfn = end >> PAGE_SHIFT;  


77.     if (start_pfn < end_pfn) {/*4M空间将这个区间存放在mr数组中；*/  


78.         nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0);  


79.         pos = end_pfn << PAGE_SHIFT;  


80.     }  


81.   


82.     /* big page (2M) range */  


83.   


84.     /*对齐到PMD，换算成页面的多少*/   


85.     start_pfn = ((pos + (PMD_SIZE – 1))>>PMD_SHIFT)  


86.              << (PMD_SHIFT – PAGE_SHIFT);  


87. #ifdef CONFIG_X86_32   


88.     /*这里的结束地址设置为调用的结束位页面数，也就是 


89.     所有的物理页面数*/  


90.     end_pfn = (end>>PMD_SHIFT) << (PMD_SHIFT – PAGE_SHIFT);  


91. #else /* CONFIG_X86_64 */   


92.     end_pfn = ((pos + (PUD_SIZE – 1))>>PUD_SHIFT)  


93.              << (PUD_SHIFT – PAGE_SHIFT);  


94.     if (end_pfn > ((end>>PMD_SHIFT)<<(PMD_SHIFT – PAGE_SHIFT)))  


95.         end_pfn = ((end>>PMD_SHIFT)<<(PMD_SHIFT – PAGE_SHIFT));  


96. #endif   


97.   


98.     if (start_pfn < end_pfn) {  


99.         /*将这段内存放入mr中，保存后面用到*/  


100.         nr_range = save_mr(mr, nr_range, start_pfn, end_pfn,  


101.                 page_size_mask & (1<<PG_LEVEL_2M));/*这里保证了运用PSE时为2M页面而不是PSE时， 


102.                 仍然为4K页面(上面的按位或和这里的按位与)*/  


103.         pos = end_pfn << PAGE_SHIFT;/*更新pos*/  


104.     }  


105.   


106. #ifdef CONFIG_X86_64   


107.     /* big page (1G) range */  


108.     start_pfn = ((pos + (PUD_SIZE – 1))>>PUD_SHIFT)  


109.              << (PUD_SHIFT – PAGE_SHIFT);  


110.     end_pfn = (end >> PUD_SHIFT) << (PUD_SHIFT – PAGE_SHIFT);  


111.     if (start_pfn < end_pfn) {  


112.         nr_range = save_mr(mr, nr_range, start_pfn, end_pfn,  


113.                 page_size_mask &  


114.                  ((1<<PG_LEVEL_2M)|(1<<PG_LEVEL_1G)));  


115.         pos = end_pfn << PAGE_SHIFT;  


116.     }  


117.   


118.     /* tail is not big page (1G) alignment */  


119.     start_pfn = ((pos + (PMD_SIZE – 1))>>PMD_SHIFT)  


120.              << (PMD_SHIFT – PAGE_SHIFT);  


121.     end_pfn = (end >> PMD_SHIFT) << (PMD_SHIFT – PAGE_SHIFT);  


122.     if (start_pfn < end_pfn) {  


123.         nr_range = save_mr(mr, nr_range, start_pfn, end_pfn,  


124.                 page_size_mask & (1<<PG_LEVEL_2M));  


125.         pos = end_pfn << PAGE_SHIFT;  


126.     }  


127. #endif   


128.   


129.     /* tail is not big page (2M) alignment */  


130.     start_pfn = pos>>PAGE_SHIFT;  


131.     end_pfn = end>>PAGE_SHIFT;  


132.     nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0);  


133.   


134.     /* try to merge same page size and continuous */  


135.     /*合并相同页面大小的连续的页面*/  


136.     for (i = 0; nr_range > 1 && i < nr_range – 1; i++) {  


137.         unsigned long old_start;  


138.         if (mr[i].end != mr[i+1].start ||  


139.             mr[i].page_size_mask != mr[i+1].page_size_mask)  


140.             continue;  


141.         /* move it */  


142.         old_start = mr[i].start;  


143.         memmove(&mr[i], &mr[i+1],  


144.             (nr_range – 1 – i) * sizeof(struct map_range));  


145.         mr[i–].start = old_start;  


146.         nr_range–;  


147.     }  


148.     /*打印相关的信息*/  


149.     for (i = 0; i < nr_range; i++)  


150.         printk(KERN_DEBUG ” %010lx – %010lx page %s\n”,  


151.                 mr[i].start, mr[i].end,  


152.             (mr[i].page_size_mask & (1<<PG_LEVEL_1G))?“1G”🙁  


153.              (mr[i].page_size_mask & (1<<PG_LEVEL_2M))?“2M”:“4k”));  


154.   


155.     /* 


156.      * Find space for the kernel direct mapping tables. 


157.      * 


158.      * Later we should allocate these tables in the local node of the 


159.      * memory mapped. Unfortunately this is done currently before the 


160.      * nodes are discovered. 


161.      */  


162.     if (!after_bootmem)/*如果内存启动分配器没有建立， 


163.         这里是直接总e820.map中找到合适的连续内存*/  


164.         /*找到存放页表机制中页表的空间 


165.         首地址为e820_table_start*/  


166.         find_early_table_space(end, use_pse, use_gbpages);  


167.   


168. #ifdef CONFIG_X86_32   


169.     /*设置页表映射，其中变量page_size_mask的值， 


170.     传入代换成了是否运用PSE来进行页表映射， 


171.     也就是说，当不用pse时，全部的物理页面都用 


172.     4K的形式映射，而运用PSE时，开始的4M用4K形式一个页面 


173.     后面的大块用2M形式作为一个页面映射；*/  


174.     for (i = 0; i < nr_range; i++)/*对每个保存的区域*/  


175.         kernel_physical_mapping_init(mr[i].start, mr[i].end,  


176.                          mr[i].page_size_mask);  


177.     ret = end;  


178. #else /* CONFIG_X86_64 */   


179.     for (i = 0; i < nr_range; i++)  


180.         ret = kernel_physical_mapping_init(mr[i].start, mr[i].end,  


181.                            mr[i].page_size_mask);  


182. #endif   


183.   


184. #ifdef CONFIG_X86_32   


185.     /*对高端内存区域的固定区域进行映射而建立了页表等，一般 


186.     高端固定内存区域为一个页表，具体的页面映射的建立需要set_fix函数*/  


187.     early_ioremap_page_table_range_init();  


188.     /*放入CR3寄存器*/  


189.     load_cr3(swapper_pg_dir);  


190. #endif   


191.   


192. #ifdef CONFIG_X86_64   


193.     if (!after_bootmem && !start) {  


194.         pud_t *pud;  


195.         pmd_t *pmd;  


196.   


197.         mmu_cr4_features = read_cr4();  


198.   


199.         /* 


200.          * _brk_end cannot change anymore, but it and _end may be 


201.          * located on different 2M pages. cleanup_highmap(), however, 


202.          * can only consider _end when it runs, so destroy any 


203.          * mappings beyond _brk_end here. 


204.          */  


205.         pud = pud_offset(pgd_offset_k(_brk_end), _brk_end);  


206.         pmd = pmd_offset(pud, _brk_end – 1);  


207.         while (++pmd <= pmd_offset(pud, (unsigned long)_end – 1))  


208.             pmd_clear(pmd);  


209.     }  


210. #endif   


211.     /*因为将基址放到了CR3寄存器中，所以这里要对其寄存器 


212.     刷新，以表示将内容放到内存中*/  


213.     __flush_tlb_all();  


214.     /*将分配给建立页表机制的内存空间保留*/  


215.     if (!after_bootmem && e820_table_end > e820_table_start)  


216.         reserve_early(e820_table_start << PAGE_SHIFT,  


217.                  e820_table_end << PAGE_SHIFT, “PGTABLE”);  


218.       


219.     /*下面的函数需要设置相关的宏没有设置*/  


220.     if (!after_bootmem)  


221.         early_memtest(start, end);  


222.   


223.     return ret >> PAGE_SHIFT;  


224. }  

[cpp]

1. static int __meminit save_mr(struct map_range *mr, int nr_range,  


2.                  unsigned long start_pfn, unsigned long end_pfn,  


3.                  unsigned long page_size_mask)  


4. {  


5.     if (start_pfn < end_pfn) {  


6.         if (nr_range >= NR_RANGE_MR)  


7.             panic(“run out of range for init_memory_mapping\n”);  


8.         mr[nr_range].start = start_pfn<<PAGE_SHIFT;  


9.         mr[nr_range].end   = end_pfn<<PAGE_SHIFT;  


10.         mr[nr_range].page_size_mask = page_size_mask;  


11.         nr_range++;  


12.     }  


13.   


14.     return nr_range;  


15. }  

[cpp]

1. /*查找页表需要的空间*/  


2. static void __init find_early_table_space(unsigned long end, int use_pse,  


3.                       int use_gbpages)  


4. {  


5.     unsigned long puds, pmds, ptes, tables, start;  


6.     /*计算需要用到多少pud,当没有pud存在的情况下pud=pgd*/  


7.     puds = (end + PUD_SIZE – 1) >> PUD_SHIFT;  


8.     tables = roundup(puds * sizeof(pud_t), PAGE_SIZE);  


9.   


10.     if (use_gbpages) {  


11.         unsigned long extra;  


12.   


13.         extra = end – ((end>>PUD_SHIFT) << PUD_SHIFT);  


14.         pmds = (extra + PMD_SIZE – 1) >> PMD_SHIFT;  


15.     } else  


16.         pmds = (end + PMD_SIZE – 1) >> PMD_SHIFT;  


17.     /*计算映射所有内存所要求的所有pmd的个数*/  


18.     tables += roundup(pmds * sizeof(pmd_t), PAGE_SIZE);  


19.   


20.     if (use_pse) {  


21.         unsigned long extra;  


22.   


23.         extra = end – ((end>>PMD_SHIFT) << PMD_SHIFT);  


24. #ifdef CONFIG_X86_32   


25.         extra += PMD_SIZE;  


26. #endif   


27.         ptes = (extra + PAGE_SIZE – 1) >> PAGE_SHIFT;  


28.     } else/*计算所有需要的pte个数*/  


29.         ptes = (end + PAGE_SIZE – 1) >> PAGE_SHIFT;  


30.   


31.     tables += roundup(ptes * sizeof(pte_t), PAGE_SIZE);  


32.   


33. #ifdef CONFIG_X86_32   


34.     /* for fixmap */  


35.     /*加上固定内存映射区的页表数量*/  


36.     tables += roundup(__end_of_fixed_addresses * sizeof(pte_t), PAGE_SIZE);  


37. #endif   


38.   


39.     /* 


40.      * RED-PEN putting page tables only on node 0 could 


41.      * cause a hotspot and fill up ZONE_DMA. The page tables 


42.      * need roughly 0.5KB per GB. 


43.      */  


44. #ifdef CONFIG_X86_32   


45.     start = 0x7000;/*页表存放的开始地址，这里为什么从这里开始???*/  


46. #else   


47.     start = 0x8000;  


48. #endif   


49.     /*从e820.map中找到连续的足够大小的内存来存放用于映射的页表 


50.     返回起始地址*/  


51.     e820_table_start = find_e820_area(start, max_pfn_mapped<<PAGE_SHIFT,  


52.                     tables, PAGE_SIZE);  


53.     if (e820_table_start == -1UL)  


54.         panic(“Cannot find space for the kernel page tables”);  


55.     /*将页表的起始地址的物理页面帧号保存到相关的全局变量中*/  


56.     e820_table_start >>= PAGE_SHIFT;  


57.     e820_table_end = e820_table_start;  


58.     e820_table_top = e820_table_start + (tables >> PAGE_SHIFT);  


59.   


60.     printk(KERN_DEBUG “kernel direct mapping tables up to %lx @ %lx-%lx\n”,  


61.         end, e820_table_start << PAGE_SHIFT, e820_table_top << PAGE_SHIFT);  


62. }  

[cpp]

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.  /*代码的作者已经写的很详细了，自己添加了一些 


7.  额外的注释*/  


8. unsigned long __init  


9. kernel_physical_mapping_init(unsigned long start,  


10.                  unsigned long end,  


11.                  unsigned long page_size_mask)  


12. {  


13.     int use_pse = page_size_mask == (1<<PG_LEVEL_2M);  


14.     unsigned long start_pfn, end_pfn;  


15.     pgd_t *pgd_base = swapper_pg_dir;  


16.     int pgd_idx, pmd_idx, pte_ofs;  


17.     unsigned long pfn;  


18.     pgd_t *pgd;  


19.     pmd_t *pmd;  


20.     pte_t *pte;  


21.     unsigned pages_2m, pages_4k;  


22.     int mapping_iter;  


23.     /*换成页面起始*/  


24.     start_pfn = start >> PAGE_SHIFT;  


25.     end_pfn = end >> PAGE_SHIFT;  


26.   


27.     /* 


28.      * First iteration will setup identity mapping using large/small pages 


29.      * based on use_pse, with other attributes same as set by 


30.      * the early code in head_32.S 


31.      * 


32.      * Second iteration will setup the appropriate attributes (NX, GLOBAL..) 


33.      * as desired for the kernel identity mapping. 


34.      * 


35.      * This two pass mechanism conforms to the TLB app note which says: 


36.      * 


37.      *     “Software should not write to a paging-structure entry in a way 


38.      *      that would change, for any linear address, both the page size 


39.      *      and either the page frame or attributes.” 


40.      */  


41.     mapping_iter = 1;  


42.   


43.     if (!cpu_has_pse)  


44.         use_pse = 0;  


45.   


46. repeat:  


47.     pages_2m = pages_4k = 0;  


48.     pfn = start_pfn;  


49.     /*返回页面在PGD中的索引*/  


50.     pgd_idx = pgd_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);  


51.     pgd = pgd_base + pgd_idx;  


52.     for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {  


53.         pmd = one_md_table_init(pgd);/*pgd对应的第一个pmd*/  


54.   


55.         if (pfn >= end_pfn)  


56.             continue;  


57. #ifdef CONFIG_X86_PAE   


58.         pmd_idx = pmd_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);  


59.         pmd += pmd_idx;  


60. #else   


61.         pmd_idx = 0;  


62. #endif   


63.         for (; pmd_idx < PTRS_PER_PMD && pfn < end_pfn;  


64.              pmd++, pmd_idx++) {  


65.             unsigned int addr = pfn * PAGE_SIZE + PAGE_OFFSET;  


66.   


67.             /* 


68.              * Map with big pages if possible, otherwise 


69.              * create normal page tables: 


70.              */  


71.             if (use_pse) {  


72.                 unsigned int addr2;  


73.                 pgprot_t prot = PAGE_KERNEL_LARGE;  


74.                 /* 


75.                  * first pass will use the same initial 


76.                  * identity mapping attribute + _PAGE_PSE. 


77.                  */  


78.                 pgprot_t init_prot =  


79.                     __pgprot(PTE_IDENT_ATTR |  


80.                          _PAGE_PSE);  


81.   


82.                 addr2 = (pfn + PTRS_PER_PTE-1) * PAGE_SIZE +  


83.                     PAGE_OFFSET + PAGE_SIZE-1;  


84.   


85.                 if (is_kernel_text(addr) ||  


86.                     is_kernel_text(addr2))  


87.                     prot = PAGE_KERNEL_LARGE_EXEC;  


88.   


89.                 pages_2m++;  


90.                 if (mapping_iter == 1)  


91.                     set_pmd(pmd, pfn_pmd(pfn, init_prot));  


92.                 else  


93.                     set_pmd(pmd, pfn_pmd(pfn, prot));  


94.   


95.                 pfn += PTRS_PER_PTE;  


96.                 continue;  


97.             }  


98.             /*返回PMD中第一个PTE*/  


99.             pte = one_page_table_init(pmd);  


100.             /*PTE的索引*/  


101.             pte_ofs = pte_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);  


102.             pte += pte_ofs;/*定位带具体的pte*/  


103.             for (; pte_ofs < PTRS_PER_PTE && pfn < end_pfn;  


104.                  pte++, pfn++, pte_ofs++, addr += PAGE_SIZE) {  


105.                 pgprot_t prot = PAGE_KERNEL;  


106.                 /* 


107.                  * first pass will use the same initial 


108.                  * identity mapping attribute. 


109.                  */  


110.                 pgprot_t init_prot = __pgprot(PTE_IDENT_ATTR);  


111.   


112.                 if (is_kernel_text(addr))/*是否为内核镜像中的地址空间*/  


113.                     prot = PAGE_KERNEL_EXEC;  


114.   


115.                 pages_4k++;/*没有PSE*/  


116.                 /*设置页表,根据MAPPING_ITER变量的不同 


117.                 对表设置不同的属性，*/  


118.                 if (mapping_iter == 1)/*第一次迭代，属性设置都一样*/  


119.                     set_pte(pte, pfn_pte(pfn, init_prot));  


120.                 else/*设置为具体的属性*/  


121.                     set_pte(pte, pfn_pte(pfn, prot));  


122.             }  


123.         }  


124.     }  


125.     if (mapping_iter == 1) {  


126.         /* 


127.          * update direct mapping page count only in the first 


128.          * iteration. 


129.          */  


130.         update_page_count(PG_LEVEL_2M, pages_2m);  


131.         update_page_count(PG_LEVEL_4K, pages_4k);  


132.   


133.         /* 


134.          * local global flush tlb, which will flush the previous 


135.          * mappings present in both small and large page TLB’s. 


136.          */  


137.         __flush_tlb_all();  


138.   


139.         /* 


140.          * Second iteration will set the actual desired PTE attributes. 


141.          */  


142.         mapping_iter = 2;  


143.         goto repeat;  


144.     }  


145.     return 0;/*迭代两次后返回*/  


146. }  

[cpp]

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.     /*这里是对临时映射区域进行映射而为页表等分配了空间， 


32.     但是没有建立实际的映射*/  


33.     page_table_range_init(vaddr, end, pgd_base);  


34.     /*置变量after_paging_init为1，表示启动了分业制度*/  


35.     early_ioremap_reset();  


36. }  

[cpp]

1. /* 


2.  * This function initializes a certain range of kernel virtual memory 


3.  * with new bootmem page tables, everywhere page tables are missing in 


4.  * the given range. 


5.  * 


6.  * NOTE: The pagetables are allocated contiguous on the physical space 


7.  * so we can cache the place of the first one and move around without 


8.  * checking the pgd every time. 


9.  */  


10. static void __init  


11. page_table_range_init(unsigned long start, unsigned long end, pgd_t *pgd_base)  


12. {  


13.     int pgd_idx, pmd_idx;  


14.     unsigned long vaddr;  


15.     pgd_t *pgd;  


16.     pmd_t *pmd;  


17.     pte_t *pte = NULL;  


18.   


19.     vaddr = start;  


20.     pgd_idx = pgd_index(vaddr);  


21.     pmd_idx = pmd_index(vaddr);  


22.     pgd = pgd_base + pgd_idx;  


23.   


24.     for ( ; (pgd_idx < PTRS_PER_PGD) && (vaddr != end); pgd++, pgd_idx++) {  


25.         pmd = one_md_table_init(pgd);  


26.         pmd = pmd + pmd_index(vaddr);  


27.         for (; (pmd_idx < PTRS_PER_PMD) && (vaddr != end);  


28.                             pmd++, pmd_idx++) {  


29.             /*early fixmap可能对临时映射区中的页表项已经分配了页表 


30.             为使页表分配的空间连续，需要对临时映射区的页表从 


31.             指定区间重新分配*/  


32.             pte = page_table_kmap_check(one_page_table_init(pmd),/*在这里已经对pte进行了分配和初始化*/  


33.                                         pmd, vaddr, pte);  


34.   


35.             vaddr += PMD_SIZE;  


36.         }  


37.         pmd_idx = 0;  


38.     }  


39. }  

[cpp]

1. /* 


2.  * Create a page table and place a pointer to it in a middle page 


3.  * directory entry: 


4.  */  


5. static pte_t * __init one_page_table_init(pmd_t *pmd)  


6. {  


7.     if (!(pmd_val(*pmd) & _PAGE_PRESENT)) {  


8.         pte_t *page_table = NULL;  


9.   


10.         if (after_bootmem) {  


11. #if defined(CONFIG_DEBUG_PAGEALLOC) || defined(CONFIG_KMEMCHECK)   


12.             page_table = (pte_t *) alloc_bootmem_pages(PAGE_SIZE);  


13. #endif   


14.             if (!page_table)  


15.                 page_table =  


16.                 (pte_t *)alloc_bootmem_pages(PAGE_SIZE);  


17.         } else/*如果启动分配制度还没有建立，那么 


18.             从刚才分配建立的表中分配空间*/  


19.             page_table = (pte_t *)alloc_low_page();  


20.         paravirt_alloc_pte(&init_mm, __pa(page_table) >> PAGE_SHIFT);  


21.         /*设置PMD，将对应的PMD项设置为页表*/  


22.         set_pmd(pmd, __pmd(__pa(page_table) | _PAGE_TABLE));  


23.         BUG_ON(page_table != pte_offset_kernel(pmd, 0));  


24.     }  


25.   


26.     return pte_offset_kernel(pmd, 0);  


27. }  

start_kernel()->setup_arch()->paging()->pagetable_init()建立对高端永久内存的初始化

此时，启动内存分配器已经建立，所有不用从上面找出的页面中分配了。况且，上面建立的连续内存块只够低端内存和高端固定内存映射大小。

最终由下面函数实现

[cpp]

1. static void __init permanent_kmaps_init(pgd_t *pgd_base)  


2. {  


3.     unsigned long vaddr;  


4.     pgd_t *pgd;  


5.     pud_t *pud;  


6.     pmd_t *pmd;  


7.     pte_t *pte;  


8.   


9.     vaddr = PKMAP_BASE;  


10.     /*该阶段，也就是永久内存映射区的内存的页表初始化*/  


11.     page_table_range_init(vaddr, vaddr + PAGE_SIZE*LAST_PKMAP, pgd_base);  


12.   


13.     pgd = swapper_pg_dir + pgd_index(vaddr);  


14.     pud = pud_offset(pgd, vaddr);  


15.     pmd = pmd_offset(pud, vaddr);  


16.     pte = pte_offset_kernel(pmd, vaddr);  


17.     pkmap_page_table = pte;/*将永久映射区间映射的第一个页表保存到pkmap_page_table中*/  


18. }  

start_kernel()->setup_arch()->paging()->kmap_init()

[cpp]

1. static void __init kmap_init(void)  


2. {  


3.     unsigned long kmap_vstart;  


4.   


5.     /* 


6.      * Cache the first kmap pte: 


7.      */  


8.      /*得到高端固定内存映射区域的起始内存的页表，将这个页表 


9.      放到kmap_pte变量中确切的说应该是固定内存中的临时内存映射区域*/  


10.     kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);  


11.     kmap_pte = kmap_get_fixmap_pte(kmap_vstart);  


12.   


13.     kmap_prot = PAGE_KERNEL;  


14. }