Linux页表机制初始化

最新推荐文章于 2023-01-15 00:30:00 发布
最新推荐文章于 2023-01-15 00:30:00 发布
阅读量854 收藏 3
点赞数
分类专栏： 内存管理

Linux启动并建立一套完整的页表机制要经过以下几个步骤：

1.临时内核页表的初始化(setup_32.s)

2.启动分页机制(head_32.s)

3.建立低端内存和高端内存固定映射区的页表( init_memory_mapping())

4.建立高端内存永久映射区的页表并获取固定映射区的临时映射区页表(paging_init())

下面主要介绍3和4

 

 

一、低端内存页表的建立

在setup_arch()中内核通过调用init_memory_mapping()来建立低端内存页表

[cpp]  view plain copy
  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<<PAGE_SHIFT);   
  7.    max_pfn_mapped = max_low_pfn_mapped;    
  8.    ...  
  9.    ...   

内核将低端内存的起始地址(0)，和低端内存的结束地址(max_low_pfn<<PAGE_SHIFT)传递给init_memory_mapping(),下面来看Init_memory_mapping()的具体实现，简单起见，只分析32位系统的情况

[cpp]  view plain copy
  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. unsigned long __init_refok init_memory_mapping(unsigned long start,  
  7.                            unsigned long end)  
  8. {  
  9.     unsigned long page_size_mask = 0;  
  10.     unsigned long start_pfn, end_pfn;  
  11.     unsigned long ret = 0;  
  12.     unsigned long pos;  
  13.   
  14.     struct map_range mr[NR_RANGE_MR];  
  15.     int nr_range, i;  
  16.     int use_pse, use_gbpages;  
  17.   
  18.     printk(KERN_INFO "init_memory_mapping: %016lx-%016lx\n", start, end);  
  19.   
  20. #if defined(CONFIG_DEBUG_PAGEALLOC) || defined(CONFIG_KMEMCHECK)  
  21.     /* 
  22.      * For CONFIG_DEBUG_PAGEALLOC, identity mapping will use small pages. 
  23.      * This will simplify cpa(), which otherwise needs to support splitting 
  24.      * large pages into small in interrupt context, etc. 
  25.      */  
  26.     use_pse = use_gbpages = 0;  
  27. #else  
  28.     use_pse = cpu_has_pse;  
  29.     use_gbpages = direct_gbpages;  
  30. #endif  
  31.   
  32.     set_nx();  
  33.     if (nx_enabled)  
  34.         printk(KERN_INFO "NX (Execute Disable) protection: active\n");  
  35.   
  36.     /* Enable PSE if available */  
  37.     if (cpu_has_pse)  
  38.         set_in_cr4(X86_CR4_PSE);  
  39.   
  40.     /* Enable PGE if available */  
  41.     if (cpu_has_pge) {  
  42.         set_in_cr4(X86_CR4_PGE);  
  43.         __supported_pte_mask |= _PAGE_GLOBAL;  
  44.     }  
  45.   
  46.     /*这里确定是否使用大型页*/  
  47.     if (use_gbpages)  
  48.         page_size_mask |= 1 << PG_LEVEL_1G;  
  49.     if (use_pse)  
  50.         page_size_mask |= 1 << PG_LEVEL_2M;  
  51.   
  52.     memset(mr, 0, sizeof(mr));  
  53.     nr_range = 0;  
  54.   
  55.     /* head if not big page alignment ? */  
  56.     start_pfn = start >> PAGE_SHIFT;/*得到起始页框的编号*/  
  57.     pos = start_pfn << PAGE_SHIFT;   /*得到起始物理地址，取按PAGE_SHIFT位对齐后的结果*/  
  58. #ifdef CONFIG_X86_32  
  59.     /* 
  60.      * Don't use a large page for the first 2/4MB of memory 
  61.      * because there are often fixed size MTRRs in there 
  62.      * and overlapping MTRRs into large pages can cause 
  63.      * slowdowns. 
  64.      */  
  65.     /*设定结束页框与起始页框的距离为2M/4K = 512K个页框*/  
  66.     if (pos == 0)  
  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.                                         则将结束页框下调*/  
  77.         end_pfn = end >> PAGE_SHIFT;  
  78.     if (start_pfn < end_pfn) {        /*如果起始页框小于结束页框，则将该段保存， 
  79.                                                     这个段使用的都是小型页，即4K大小*/  
  80.         nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0);  
  81.         pos = end_pfn << PAGE_SHIFT;  /*将起始地址移到结束地址处*/  
  82.     }  
  83.   
  84.     /* big page (2M) range */  
  85.     start_pfn = ((pos + (PMD_SIZE - 1))>>PMD_SHIFT)/*将起始地址右移2M*/  
  86.              << (PMD_SHIFT - PAGE_SHIFT);  
  87. #ifdef CONFIG_X86_32  
  88.     end_pfn = (end>>PMD_SHIFT) << (PMD_SHIFT - PAGE_SHIFT);/*end_pfn设为指定的end对应的页框， 
  89.                                                                                 取按PMD_SHIFT位对齐后的结果*/  
  90. #else /* CONFIG_X86_64 */  
  91.     end_pfn = ((pos + (PUD_SIZE - 1))>>PUD_SHIFT)  
  92.              << (PUD_SHIFT - PAGE_SHIFT);  
  93.     if (end_pfn > ((end>>PMD_SHIFT)<<(PMD_SHIFT - PAGE_SHIFT)))  
  94.         end_pfn = ((end>>PMD_SHIFT)<<(PMD_SHIFT - PAGE_SHIFT));  
  95. #endif  
  96.   
  97.     if (start_pfn < end_pfn) {/*如果start_pfn小于end_pfn则保存该内存段*/  
  98.         nr_range = save_mr(mr, nr_range, start_pfn, end_pfn,  
  99.                 page_size_mask & (1<<PG_LEVEL_2M));/*这里确保如果2M的PG_LEVEL被置位的话，该段按2M的大型页分页*/  
  100.         pos = end_pfn << PAGE_SHIFT;/*同样将起始位置调整至该段的结束页框*/  
  101.     }  
  102.   
  103. #ifdef CONFIG_X86_64  
  104.     /* big page (1G) range */  
  105.     start_pfn = ((pos + (PUD_SIZE - 1))>>PUD_SHIFT)  
  106.              << (PUD_SHIFT - PAGE_SHIFT);  
  107.     end_pfn = (end >> PUD_SHIFT) << (PUD_SHIFT - PAGE_SHIFT);  
  108.     if (start_pfn < end_pfn) {  
  109.         nr_range = save_mr(mr, nr_range, start_pfn, end_pfn,  
  110.                 page_size_mask &  
  111.                  ((1<<PG_LEVEL_2M)|(1<<PG_LEVEL_1G)));  
  112.         pos = end_pfn << PAGE_SHIFT;  
  113.     }  
  114.   
  115.     /* tail is not big page (1G) alignment */  
  116.     start_pfn = ((pos + (PMD_SIZE - 1))>>PMD_SHIFT)  
  117.              << (PMD_SHIFT - PAGE_SHIFT);  
  118.     end_pfn = (end >> PMD_SHIFT) << (PMD_SHIFT - PAGE_SHIFT);  
  119.     if (start_pfn < end_pfn) {  
  120.         nr_range = save_mr(mr, nr_range, start_pfn, end_pfn,  
  121.                 page_size_mask & (1<<PG_LEVEL_2M));  
  122.         pos = end_pfn << PAGE_SHIFT;  
  123.     }  
  124. #endif  
  125.   
  126.     /* tail is not big page (2M) alignment */  
  127.     /*将非对齐的末端进行保存为一个段*/  
  128.     start_pfn = pos>>PAGE_SHIFT;  
  129.     end_pfn = end>>PAGE_SHIFT;  
  130.     nr_range = save_mr(mr, nr_range, start_pfn, end_pfn, 0);  
  131.   
  132.     /* try to merge same page size and continuous */  
  133.     for (i = 0; nr_range > 1 && i < nr_range - 1; i++) {  
  134.         unsigned long old_start;  
  135.         if (mr[i].end != mr[i+1].start ||  /*如果前内存段的地址和后内存段的地址相同，并且页面大小相同*/  
  136.             mr[i].page_size_mask != mr[i+1].page_size_mask)  
  137.             continue;  
  138.         /* move it */  
  139.         old_start = mr[i].start;  
  140.         memmove(&mr[i], &mr[i+1],  
  141.             (nr_range - 1 - i) * sizeof(struct map_range));  
  142.         mr[i--].start = old_start;  
  143.         nr_range--;  
  144.     }  
  145.   
  146.     for (i = 0; i < nr_range; i++)  
  147.         printk(KERN_DEBUG " %010lx - %010lx page %s\n",  
  148.                 mr[i].start, mr[i].end,  
  149.             (mr[i].page_size_mask & (1<<PG_LEVEL_1G))?"1G":(  
  150.              (mr[i].page_size_mask & (1<<PG_LEVEL_2M))?"2M":"4k"));  
  151.   
  152.     /* 
  153.      * Find space for the kernel direct mapping tables. 
  154.      * 
  155.      * Later we should allocate these tables in the local node of the 
  156.      * memory mapped. Unfortunately this is done currently before the 
  157.      * nodes are discovered. 
  158.      */  
  159.      /*如果还未建立bootmem allocator,则直接通过e820获取的信息来得到一个连续的空闲内存段保留内核页表*/  
  160.     if (!after_bootmem)  
  161.         find_early_table_space(end, use_pse, use_gbpages);  
  162.   
  163. #ifdef CONFIG_X86_32  
  164.     for (i = 0; i < nr_range; i++)/*遍历每个段，建立页表完成低端内存虚拟地址到物理地址的映射*/  
  165.         kernel_physical_mapping_init(mr[i].start, mr[i].end,  
  166.                          mr[i].page_size_mask);  
  167.     ret = end;  
  168. #else /* CONFIG_X86_64 */  
  169.     for (i = 0; i < nr_range; i++)  
  170.         ret = kernel_physical_mapping_init(mr[i].start, mr[i].end,  
  171.                            mr[i].page_size_mask);  
  172. #endif  
  173.   
  174. #ifdef CONFIG_X86_32  
  175.     early_ioremap_page_table_range_init();/*为内核的固定映射区分配页表*/  
  176.   
  177.     load_cr3(swapper_pg_dir);  
  178. #endif  
  179.   
  180. #ifdef CONFIG_X86_64  
  181.     if (!after_bootmem && !start) {  
  182.         pud_t *pud;  
  183.         pmd_t *pmd;  
  184.   
  185.         mmu_cr4_features = read_cr4();  
  186.   
  187.         /* 
  188.          * _brk_end cannot change anymore, but it and _end may be 
  189.          * located on different 2M pages. cleanup_highmap(), however, 
  190.          * can only consider _end when it runs, so destroy any 
  191.          * mappings beyond _brk_end here. 
  192.          */  
  193.         pud = pud_offset(pgd_offset_k(_brk_end), _brk_end);  
  194.         pmd = pmd_offset(pud, _brk_end - 1);  
  195.         while (++pmd <= pmd_offset(pud, (unsigned long)_end - 1))  
  196.             pmd_clear(pmd);  
  197.     }  
  198. #endif  
  199.     __flush_tlb_all();  
  200.   
  201.     if (!after_bootmem && e820_table_end > e820_table_start)  
  202.         reserve_early(e820_table_start << PAGE_SHIFT,  
  203.                  e820_table_end << PAGE_SHIFT, "PGTABLE");  
  204.   
  205.     if (!after_bootmem)  
  206.         early_memtest(start, end);  
  207.   
  208.     return ret >> PAGE_SHIFT;  
  209. }  

将init_memory_mapping()中的几个比较关键的部分提取出来进行分析

用来保存内存段信息的struct map_range结构体的定义如下

[cpp]  view plain copy
  1. struct map_range {  
  2.     unsigned long start;  
  3.     unsigned long end;  
  4.     unsigned page_size_mask;  
  5. };  


其包含了一个段的起始地址，结束地址，以及该段是按多大的页面进行分页(4K,2M,1G)

而save_mr()函数的工作就是初始化这三项

[cpp]  view plain copy
  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. }  


完成分段工作后，内核对每个段调用关键函数kernel_physical_mapping_init()来完成虚拟地址到物理地址的映射，在看这个函数之前先介绍一些关于LINUX分页的基本概念和一些关键的宏

在2.6.11后，Linux采用四级分页模型，这四级页目录分别为

  • 页全局目录(Page Global Directory)
  • 页上级目录(Page Upper Directory)
  • 页中间目录(Page Middle Directory)
  • 页表(Page Table)

对于没有启动PAE的32位系统，Linux虽然也采用四级分页模型，但本质上只用到了两级分页，Linux通过将"页上级目录"位域和“页中间目录”位域全为0来达到使用两级分页的目的，但为了保证程序能32位和64系统上都能运行，内核保留了页上级目录和页中间目录在指针序列中的位置，它们的页目录数都被内核置为1，并把这2个页目录项映射到适合的全局目录项。

 

PAGE_SHIFT,PMD_SHIFT,PUD_SHIFT,PGDIR_SHIFT

对应相应的页目录所能映射的区域大小的位数，如PAGE_SHIFT为12，即页面大小为4k，PMD_SHIFT为线性地址的offset和table字段的总位数，未启用PAE的32位系统下，为22.

 

PTRS_PER_PTE,   PTRS_PER_PMD,   PTRS_PER_PUD,   PTRS_PER_PGD

对应相应页目录中的表项数。32位系统下，当PAE被禁止时，他们的值分别为1024,，1，1和1024，也就是说只使用两级分页。

 

pgd_index(addr),  pud_index,  pmd_index(addr),  pte_index(addr)

取addr在该目录中的索引。 

pte_index(addr)的实现：

[cpp]  view plain copy
  1. static inline unsigned long pte_index(unsigned long address)  
  2. {  
  3.     return (address >> PAGE_SHIFT) & (PTRS_PER_PTE - 1);  
  4. }  


 

pud_offset(pgd,addr),   pmd_offset(pud,addr),   pte_offset(pmd,addr)

以pmd_offset为例，线性地址addr对应的pmd索引在在pud指定的pmd表的偏移地址。在两级或三级分页系统中，pmd_offset和pud_offset都返回页全局目录的地址

 

[cpp]  view plain copy
  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<<PG_LEVEL_2M);  
  12.     unsigned long start_pfn, end_pfn;  
  13.     pgd_t *pgd_base = swapper_pg_dir;  
  14.     int pgd_idx, pmd_idx, pte_ofs;  
  15.     unsigned long pfn;  
  16.     pgd_t *pgd;  
  17.     pmd_t *pmd;  
  18.     pte_t *pte;  
  19.     unsigned pages_2m, pages_4k;  
  20.     int mapping_iter;  
  21.   
  22.     start_pfn = start >> PAGE_SHIFT;  
  23.     end_pfn = end >> PAGE_SHIFT;  
  24.   
  25.     /* 
  26.      * First iteration will setup identity mapping using large/small pages 
  27.      * based on use_pse, with other attributes same as set by 
  28.      * the early code in head_32.S 
  29.      * 
  30.      * Second iteration will setup the appropriate attributes (NX, GLOBAL..) 
  31.      * as desired for the kernel identity mapping. 
  32.      * 
  33.      * This two pass mechanism conforms to the TLB app note which says: 
  34.      * 
  35.      *     "Software should not write to a paging-structure entry in a way 
  36.      *      that would change, for any linear address, both the page size 
  37.      *      and either the page frame or attributes." 
  38.      */  
  39.     mapping_iter = 1;  
  40.   
  41.     if (!cpu_has_pse)  
  42.         use_pse = 0;  
  43.   
  44. repeat:  
  45.     pages_2m = pages_4k = 0;  
  46.     pfn = start_pfn;         /*pfn保存起始页框号*/  
  47.     pgd_idx = pgd_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);/*低端内存的虚拟起始地址对应的pgd的偏移*/  
  48.     pgd = pgd_base + pgd_idx;/*得到起始页框对应的pgd*/  
  49.   
  50.     /*由pgd开始遍历*/  
  51.     for (; pgd_idx < PTRS_PER_PGD; pgd++, pgd_idx++) {  
  52.         pmd = one_md_table_init(pgd);/*得到一个pmd表*/  
  53.   
  54.         if (pfn >= end_pfn)  
  55.             continue;  
  56. #ifdef CONFIG_X86_PAE  
  57.         pmd_idx = pmd_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);  
  58.         pmd += pmd_idx;  
  59. #else  
  60.         pmd_idx = 0;  
  61. #endif  
  62.         /*遍历pmd表,对于未激活PAE的32位系统，PTRS_PER_PMD为1，激活PAE则为512*/  
  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.             pte = one_page_table_init(pmd);/*创建一个page table*/  
  99.   
  100.             /*得到pfn在page table中的偏移并定位到具体的pte*/  
  101.             pte_ofs = pte_index((pfn<<PAGE_SHIFT) + PAGE_OFFSET);  
  102.             pte += pte_ofs;  
  103.             /*由pte开始遍历page table*/  
  104.             for (; pte_ofs < PTRS_PER_PTE && pfn < end_pfn;  
  105.                  pte++, pfn++, pte_ofs++, addr += PAGE_SIZE) {  
  106.                 pgprot_t prot = PAGE_KERNEL;  
  107.                 /* 
  108.                  * first pass will use the same initial 
  109.                  * identity mapping attribute. 
  110.                  */  
  111.                 pgprot_t init_prot = __pgprot(PTE_IDENT_ATTR);  
  112.   
  113.                 if (is_kernel_text(addr)) /*如果处于内核代码段，权限设为可执行*/  
  114.                     prot = PAGE_KERNEL_EXEC;  
  115.   
  116.                 pages_4k++;  
  117.                 /*！！设置pte，与pfn关联*/  
  118.                   
  119.                 if (mapping_iter == 1)/*第一次执行将权限位设为init_prot*/  
  120.                     set_pte(pte, pfn_pte(pfn, init_prot));  
  121.                 else                 /*第二次执行将权限位置为prot*/  
  122.                     set_pte(pte, pfn_pte(pfn, prot));  
  123.             }  
  124.         }  
  125.     }  
  126.     if (mapping_iter == 1) {  
  127.         /* 
  128.          * update direct mapping page count only in the first 
  129.          * iteration. 
  130.          */  
  131.         update_page_count(PG_LEVEL_2M, pages_2m);  
  132.         update_page_count(PG_LEVEL_4K, pages_4k);  
  133.   
  134.         /* 
  135.          * local global flush tlb, which will flush the previous 
  136.          * mappings present in both small and large page TLB's. 
  137.          */  
  138.         __flush_tlb_all();  
  139.   
  140.         /* 
  141.          * Second iteration will set the actual desired PTE attributes. 
  142.          */  
  143.         mapping_iter = 2;  
  144.         goto repeat;  
  145.     }  
  146.     return 0;  
  147. }  


至此，低端内存的物理地址和虚拟地址之间的映射关系已全部建立起来！

 

二、高端内存固定映射区的建立

       在init_memory_mapping()中完成了低端内存映射后，其将调用early_ioremap_page_table_range_init()来建立高端内存的固定映射区页表。与低端内存的页表初始化不同的是，固定映射区的页表只是被分配，相应的PTE项并未初始化，这个工作交由后面的各个固定映射区部分的相关代码调用set_fixmap()来将相关的固定映射区页表与物理内存关联。

           每个固定映射区索引都以枚举类型的形式定义在enum fixed_addresses中

       

[cpp]  view plain copy
  1. <span style="font-size:12px;">enum fixed_addresses {  
  2. #ifdef CONFIG_X86_32  
  3.     FIX_HOLE,  
  4.     FIX_VDSO,  
  5. #else  
  6.     VSYSCALL_LAST_PAGE,  
  7.     VSYSCALL_FIRST_PAGE = VSYSCALL_LAST_PAGE  
  8.                 + ((VSYSCALL_END-VSYSCALL_START) >> PAGE_SHIFT) - 1,  
  9.     VSYSCALL_HPET,  
  10. #endif  
  11.     FIX_DBGP_BASE,  
  12.     FIX_EARLYCON_MEM_BASE,  
  13. #ifdef CONFIG_PROVIDE_OHCI1394_DMA_INIT  
  14.     FIX_OHCI1394_BASE,  
  15. #endif  
  16. #ifdef CONFIG_X86_LOCAL_APIC  
  17.     FIX_APIC_BASE,  /* local (CPU) APIC) -- required for SMP or not */  
  18. #endif  
  19. #ifdef CONFIG_X86_IO_APIC  
  20.     FIX_IO_APIC_BASE_0,  
  21.     FIX_IO_APIC_BASE_END = FIX_IO_APIC_BASE_0 + MAX_IO_APICS - 1,  
  22. #endif  
  23. #ifdef CONFIG_X86_VISWS_APIC  
  24.     FIX_CO_CPU, /* Cobalt timer */  
  25.     FIX_CO_APIC,    /* Cobalt APIC Redirection Table */  
  26.     FIX_LI_PCIA,    /* Lithium PCI Bridge A */  
  27.     FIX_LI_PCIB,    /* Lithium PCI Bridge B */  
  28. #endif  
  29. #ifdef CONFIG_X86_F00F_BUG  
  30.     FIX_F00F_IDT,   /* Virtual mapping for IDT */  
  31. #endif  
  32. #ifdef CONFIG_X86_CYCLONE_TIMER  
  33.     FIX_CYCLONE_TIMER, /*cyclone timer register*/  
  34. #endif  
  35. #ifdef CONFIG_X86_32  
  36.     FIX_KMAP_BEGIN, /* reserved pte's for temporary kernel mappings */  
  37.     FIX_KMAP_END = FIX_KMAP_BEGIN+(KM_TYPE_NR*NR_CPUS)-1,  
  38. #ifdef CONFIG_PCI_MMCONFIG  
  39.     FIX_PCIE_MCFG,  
  40. #endif  
  41. #endif  
  42. #ifdef CONFIG_PARAVIRT  
  43.     FIX_PARAVIRT_BOOTMAP,  
  44. #endif  
  45.     FIX_TEXT_POKE1, /* reserve 2 pages for text_poke() */  
  46.     FIX_TEXT_POKE0, /* first page is last, because allocation is backward */  
  47.     __end_of_permanent_fixed_addresses,  
  48.     /* 
  49.      * 256 temporary boot-time mappings, used by early_ioremap(), 
  50.      * before ioremap() is functional. 
  51.      * 
  52.      * We round it up to the next 256 pages boundary so that we 
  53.      * can have a single pgd entry and a single pte table: 
  54.      */  
  55. #define NR_FIX_BTMAPS       64  
  56. #define FIX_BTMAPS_SLOTS    4  
  57.     FIX_BTMAP_END = __end_of_permanent_fixed_addresses + 256 -  
  58.             (__end_of_permanent_fixed_addresses & 255),  
  59.     FIX_BTMAP_BEGIN = FIX_BTMAP_END + NR_FIX_BTMAPS*FIX_BTMAPS_SLOTS - 1,  
  60. #ifdef CONFIG_X86_32  
  61.     FIX_WP_TEST,  
  62. #endif  
  63. #ifdef CONFIG_INTEL_TXT  
  64.     FIX_TBOOT_BASE,  
  65. #endif  
  66.     __end_of_fixed_addresses  
  67. };</span>  

一个索引对应一个4KB的页框，固定映射区的结束地址为FIXADDR_TOP，即0xfffff000(4G-4K),固定映射区是反向生长的，也就是说第一个索引对应的地址离FIXADDR_TOP最近。宏__fix_to_virt(idx)通过索引来计算相应的固定映射区域的线性地址

[cpp]  view plain copy
  1. <span style="font-size:12px;">#define __fix_to_virt(x)  (FIXADDR_TOP - ((x) << PAGE_SHIFT))</span>  

 

[cpp]  view plain copy
  1. <span style="font-size:12px;">void __init early_ioremap_page_table_range_init(void)  
  2. {  
  3.     pgd_t *pgd_base = swapper_pg_dir;  
  4.     unsigned long vaddr, end;  
  5.   
  6.     /* 
  7.      * Fixed mappings, only the page table structure has to be 
  8.      * created - mappings will be set by set_fixmap(): 
  9.      */  
  10.     vaddr = __fix_to_virt(__end_of_fixed_addresses - 1) & PMD_MASK;  
  11.     end = (FIXADDR_TOP + PMD_SIZE - 1) & PMD_MASK;  
  12.     page_table_range_init(vaddr, end, pgd_base);  
  13.     early_ioremap_reset();  
  14. }</span>  

 

[cpp]  view plain copy
  1. <span style="font-size:12px;">/* 
  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);/*得到vaddr对应的pgd索引*/  
  21.     pmd_idx = pmd_index(vaddr);/*得到vaddr对应的pmd索引*/  
  22.     pgd = pgd_base + pgd_idx;  /*得到pgd项*/  
  23.   
  24.     for ( ; (pgd_idx < PTRS_PER_PGD) && (vaddr != end); pgd++, pgd_idx++) {  
  25.         pmd = one_md_table_init(pgd); /*得到pmd起始项*/  
  26.         pmd = pmd + pmd_index(vaddr); /*得到偏移后的pmd*/  
  27.         for (; (pmd_idx < PTRS_PER_PMD) && (vaddr != end);  
  28.                             pmd++, pmd_idx++) {  
  29.             /*建立pte表项并检查是vaddr是否对应内核临时映射区,若是则重新申请一个页表来保存pte表*/  
  30.             pte = page_table_kmap_check(one_page_table_init(pmd),  
  31.                                         pmd, vaddr, pte);  
  32.   
  33.             vaddr += PMD_SIZE;  
  34.         }  
  35.         pmd_idx = 0;  
  36.     }  
  37. }  
  38. </span>  



 

[cpp]  view plain copy
  1. <span style="font-size:12px;">static pte_t *__init page_table_kmap_check(pte_t *pte, pmd_t *pmd,  
  2.                        unsigned long vaddr, pte_t *lastpte)  
  3. {  
  4. #ifdef CONFIG_HIGHMEM  
  5.     /* 
  6.      * Something (early fixmap) may already have put a pte 
  7.      * page here, which causes the page table allocation 
  8.      * to become nonlinear. Attempt to fix it, and if it 
  9.      * is still nonlinear then we have to bug. 
  10.      */  
  11.   
  12.     /*得到内核固定映射区的临时映射区的起始和结束虚拟页框号*/  
  13.     int pmd_idx_kmap_begin = fix_to_virt(FIX_KMAP_END) >> PMD_SHIFT;  
  14.     int pmd_idx_kmap_end = fix_to_virt(FIX_KMAP_BEGIN) >> PMD_SHIFT;  
  15.   
  16.     /*如果:1.kmap_begin和kmap_end没有重叠 
  17.            2.vaddr处于kmap区间 
  18.            3.相应的pte没处在低端内存页表保存区间*/  
  19.     if (pmd_idx_kmap_begin != pmd_idx_kmap_end  
  20.         && (vaddr >> PMD_SHIFT) >= pmd_idx_kmap_begin  
  21.         && (vaddr >> PMD_SHIFT) <= pmd_idx_kmap_end  
  22.         && ((__pa(pte) >> PAGE_SHIFT) < e820_table_start  
  23.         || (__pa(pte) >> PAGE_SHIFT) >= e820_table_end)) {  
  24.         pte_t *newpte;  
  25.         int i;  
  26.   
  27.         BUG_ON(after_bootmem);  
  28.         newpte = alloc_low_page();  /*新申请一个页作为pte表以保证连续性*/  
  29.         for (i = 0; i < PTRS_PER_PTE; i++) /*将pte表的内容拷贝到newpte表*/  
  30.             set_pte(newpte + i, pte[i]);  
  31.   
  32.         paravirt_alloc_pte(&init_mm, __pa(newpte) >> PAGE_SHIFT);  
  33.         set_pmd(pmd, __pmd(__pa(newpte)|_PAGE_TABLE));/*pmd与newpte表进行关联*/  
  34.         BUG_ON(newpte != pte_offset_kernel(pmd, 0));  
  35.         __flush_tlb_all();  
  36.   
  37.         paravirt_release_pte(__pa(pte) >> PAGE_SHIFT);  
  38.         pte = newpte;  
  39.     }  
  40.     BUG_ON(vaddr < fix_to_virt(FIX_KMAP_BEGIN - 1)  
  41.            && vaddr > fix_to_virt(FIX_KMAP_END)  
  42.            && lastpte && lastpte + PTRS_PER_PTE != pte);  
  43. #endif  
  44.     return pte;  
  45. }  
  46. </span>  



至此高端内存的固定映射区的页表分配完成!

 

三、高端内存永久映射区页表的建立和临时映射区页表的获取

paging_init()负责完成剩下的页表建立工作

[cpp]  view plain copy
  1. void __init paging_init(void)  
  2. {  
  3.     pagetable_init();  
  4.   
  5.     __flush_tlb_all();  
  6.   
  7.     kmap_init();  
  8.   
  9.     /* 
  10.      * NOTE: at this point the bootmem allocator is fully available. 
  11.      */  
  12.     sparse_init();  
  13.     zone_sizes_init();  
  14. }  


 

[cpp]  view plain copy
  1. static void __init pagetable_init(void)  
  2. {  
  3.     pgd_t *pgd_base = swapper_pg_dir;  
  4.   
  5.     permanent_kmaps_init(pgd_base);  
  6. }  


 

[cpp]  view plain copy
  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;/*保存永久内存区的起始页表项*/  
  18. }  

permanent_kmaps_init()完成了永久内存区的页表分配

 

[cpp]  view plain copy
  1. <span style="font-size:12px;">static void __init kmap_init(void)  
  2. {  
  3.     unsigned long kmap_vstart;  
  4.   
  5.     /* 
  6.      * Cache the first kmap pte: 
  7.      */  
  8.     kmap_vstart = __fix_to_virt(FIX_KMAP_BEGIN);/*得到固定映射区的临时映射区的虚拟地址*/  
  9.     kmap_pte = kmap_get_fixmap_pte(kmap_vstart);/*得到固定映射区中的临时映射区的起始页表项*/  
  10.   
  11.     kmap_prot = PAGE_KERNEL;  
  12. }</span>  


kmap_init()获取了之前已经分配了的临时映射区的页表，把起始页表项保存在kmap_pte中。

唐古拉在高歌
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Linux内存初始化之页表映射
m0_74282605的博客
02-02 170
if (pgd_none(*pgd)) {//如果PGD里没有填充PUD,则通过memblock接口分配PUD数组内存，这里我们没有用到PUD,所以PGD=PUD。alloc_init_pte(pmd, addr, next, __phys_to_pfn(phys)，//给PMD建立PTE表项。
Linux内核机制笔记
最新发布
10-02
驱动程序通常包括初始化、数据传输和中断处理等功能，以实现对硬件设备的操作。 5. 网络协议栈：Linux内核包含了完整的TCP/IP协议栈，负责网络通信。它包括数据包的接收、发送、路由选择和错误处理。内核提供了套接...
Linux页表初始化
wangqi20100903的博客
07-27 191
Linux页表初始化
Linux内核代码之初始化内核临时页表---经典至极(转)
sploving的专栏
11-23 1173
<br /> <br /><br />漫长而黑暗的史前时代终于到了setup。在setup汇编函数中，linux通过设置cr0寄存器的PE位（从实模式切换到保护模式）完成了史前文明到现代文明的转变。在setup时期，linux已经了解到世上可用的内存资源远远不止1MB。此时linux的欲望开始膨胀，最为满足它欲望的第一步，它开始抢占内存资源的前8MB。 初始化临时内核页表是在startup_32汇编语言函数中完成的。在ULK所述中，假设内核能容纳于RAM的前8MB空间，然后对RAM的前8MB进行恒等映
linux内核启动设置页表,Linux内核页表初始化
weixin_39728544的博客
04-30 205
Linux在内核启动过程中start_kernel->setup_arch会调用如下两个函数对页表进行初始化和建立。static inline void prepare_page_table(void){unsigned long addr;/** Clear out all the mappings below the kernel image.*///初始化0~MODULES_VADDR...
第7章初始化程序（main.c）.rar_Linux的初始化程序main.c
09-23
在Linux系统中，初始化程序是启动过程中的关键部分，它负责设置硬件环境，加载必要的内核模块，并为用户空间的应用程序提供运行平台。本章主要聚焦于“main.c”文件，这是Linux内核启动流程中的一部分，用于实现系统...
任务一-进程内存初始化与页表建立1
08-03
任务一：进程内存初始化与页表建立 本资源主要介绍操作系统中进程内存初始化和页表建立的知识点，涵盖了虚拟内存映射结构、页表建立、进程内存管理等方面的内容。 一、虚拟内存映射结构 虚拟内存（Virtual Memory...
Linux 内存管理系统：初始化
01-24
在Linux系统启动过程中，内存管理的初始化是一个关键步骤，确保后续的系统运行和内存分配的高效性。本文将详细解析Linux内存管理初始化的三个主要阶段。 首先，**激活页内存管理**阶段涉及到初始化内核的页表。页表...
Armlinux内核移植及系统初始化过程分析.pdf
11-04
这个阶段会初始化内核的基本服务，如中断处理、定时器、内存分配机制等，同时还会加载必要的硬件驱动。 3. 第三阶段：高层次初始化。在这个阶段，根文件系统会被挂载，设备驱动继续初始化，网络接口、设备树等高级...
linux 内核页表初始化源码分析2.4.22
D&T的博客
07-06 753
一 静态页表初始化 如下图，swapper_pg_dir 代表着一级页表，pg0,pg1，分别为这个页表的前两个页表项，包含8m空间，存储内核镜像， 由于vmlinux 的编译基址址是PAGE_OFFSET + 1MiB，所以，这里这三个虚拟地址分别为 swapper_pg_dir：PAGE_OFFSET + 1MiB +0x1000 arch/i386/kernel/head.S ............
Linux内核页表初始化
glmwu的专栏
02-23 2130
Linux在内核启动过程中start_kernel->setup_arch会调用如下两个函数对页表进行初始化和建立。 static inline void prepare_page_table(void) { unsigned long addr; /* * Clear out all the mappings below the kernel image.
linux内存管理解析----linux物理，线性内存布局及页表的初始化
pi9nc的专栏
04-08 6557
linux内存管理解析----linux物理，线性内存布局及页表的初始化 分类： linux内核2013-08-02 17:50 459人阅读 评论(0) 收藏 举报 linux内存管理页表初始化内存布局 主要议题： 1分页，分段模式及实模式 2Linux分页  3linux内存线性地址空间布局及物理内存空间布局 4linux页表初始化及代码解析 1.1
Linux开机启动过程（6）：页表的初始化、避开保留的内存、地址随机化
RToax
03-17 1272
内核引导过程. Part 6. 简介 这是内核引导过程系列文章的第六部分。在前一部分，我们已经看到了内核引导过程的结尾，但是我们跳过了一些高级部分。 你可能还记得，Linux内核的入口点是 main.c 的start_kernel函数，它在LOAD_PHYSICAL_ADDR地址开始执行。这个地址依赖于CONFIG_PHYSICAL_START内核配置选项，默认为0x1000000: config PHYSICAL_START hex "Physical address where the kernel
linux 内存管理---分页系统之页表初始化（四）
whuzm08的专栏
05-03 809
arch_mem_init（）在调用bootmem_init（）函数完成bootmem的初始化之后调用paging_init（）进行分页系统的初始化。分页系统就是将物理内存按页为单位进行描述，管理和映射。注意这里是mips cpu，不同的arch cpu初始化顺序可能不同， linux-3.3.8[arch/mips/mm/init.c]void __init paging_init(void){...
linux 页表管理代码,Linux页表机制管理初始化
weixin_33212263的博客
05-12 136
/**SetupthedirectmappingofthephysicalmemoryatPAGE_OFFSET.*Thisrunsbeforebootmemisinitializedandgetspagesdirectlyfrom*thephysicalmemory.Toaccessthemtheyaretemporarilymapp...
Linux——页表的分页机制
weixin_61857742的博客
01-15 1591
以32位机器为例，页框的个数为4GB / 4KB也就是2^20次方个，假设一个表项占有4Byte，总共有4MB的连续空间需要使用，也就是说，每次调度进程时，这4MB的空间都要被使用。每个页框4KB，共有4x1024个地址，即2^12次方，页内偏移即虚拟地址后12位，也是2^12次方，正好可以偏移出一个页框中全部地址。虚拟地址前20位是两级页表的索引，共能索引出2^20次方个页框，内存共4GB即2^20次方个页框，因此正好与之一一对应。linux将虚拟地址的32位分为前10位、中间10位、后置12位。
Linux内存初始化之页表映射(一)
bin_linux96的专栏
10-24 1602
内存初始化主要在start_kernel函数中，主要内容有: 1. 从dts中扫描所有物理内存和预留内存，并添加到memblock子系统 2. 给memblock中的所有非预留memory region建立页表映射 3. sparse内存模型初始化 4. 计算每个zone管理内存的大小以及每个zone的free list初始化 5. 释放所有空闲内存块到伙伴系统 ６.初始化slab和v...
Linux 内核页表管理
小立仔
10-14 2732
Linux x86_64系统下的内核页表管理

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值