arm64内存-paging_init-early_pgtable_alloc-fixmap pgd pud pmd pte idx
作者：互联网
本文对应 https://www.cnblogs.com/zhangzhiwei122/p/16085238.html 中的“七、看到内存” 。
了解到了当前的物理内存的布局，但是内核仍然只是能够访问部分内存（kernel image mapping和DTB那两段内存，上图中黄色block），大部分的内存仍然处于黑暗中，等待光明的到来，也就是说需要创建这些内存的地址映射。
当前物理内存的布局的建立，见 前一篇： https://www.cnblogs.com/zhangzhiwei122/p/16086677.html
本文描述， 创建这些内存的地址映射。
arch/arm64/mm/mmu.c
paging_init
709void __init paging_init(void)
710{
711 pgd_t *pgdp = pgd_set_fixmap(__pa_symbol(swapper_pg_dir));
712
713 map_kernel(pgdp);
714 map_mem(pgdp);
715
716 pgd_clear_fixmap();
717
718 cpu_replace_ttbr1(lm_alias(swapper_pg_dir));
719 init_mm.pgd = swapper_pg_dir;
720
721 memblock_free(__pa_symbol(init_pg_dir),
722 __pa_symbol(init_pg_end) - __pa_symbol(init_pg_dir));
723
724 memblock_allow_resize();
725}
711 行，pgd_set_fixmap ，使用 fixmap 中的 pgd idx 对应的 虚拟地址 来映射 __pa_symbol(swapper_pg_dir)) 这个物理地址。 这个物理地址里面存放 pgd 页表。
713 行，同文件中的 static 函数， create fine-grained mappings for the kernel 。 即对 内核镜像 占用的区域，创建 属性合适的 （只读，读写、执行）映射。
714 行，同文件中的 static 函数， map_mem( pgd table pointer )
472static void __init map_mem(pgd_t *pgdp)
473{
474 phys_addr_t kernel_start = __pa_symbol(_text);
475 phys_addr_t kernel_end = __pa_symbol(__init_begin);
476 phys_addr_t start, end;
477 int flags = 0;
478 u64 i;
480 if (rodata_full || debug_pagealloc_enabled())
481 flags = NO_BLOCK_MAPPINGS | NO_CONT_MAPPINGS;
482
483 /*
484 * Take care not to create a writable alias for the
485 * read-only text and rodata sections of the kernel image.
486 * So temporarily mark them as NOMAP to skip mappings in
487 * the following for-loop
488 */
489 memblock_mark_nomap(kernel_start, kernel_end - kernel_start);
495
496 /* map all the memory banks */
497 for_each_mem_range(i, &start, &end) {
498 if (start >= end)
499 break;
500 /*
501 * The linear map must allow allocation tags reading/writing
502 * if MTE is present. Otherwise, it has the same attributes as
503 * PAGE_KERNEL.
504 */
505 __map_memblock(pgdp, start, end, PAGE_KERNEL_TAGGED, flags);
506 }
507
508 /*
509 * Map the linear alias of the [_text, __init_begin) interval
510 * as non-executable now, and remove the write permission in
511 * mark_linear_text_alias_ro() below (which will be called after
512 * alternative patching has completed). This makes the contents
513 * of the region accessible to subsystems such as hibernate,
514 * but protects it from inadvertent modification or execution.
515 * Note that contiguous mappings cannot be remapped in this way,
516 * so we should avoid them here.
517 */
518 __map_memblock(pgdp, kernel_start, kernel_end,
519 PAGE_KERNEL, NO_CONT_MAPPINGS);
520 memblock_clear_nomap(kernel_start, kernel_end - kernel_start);
521
536}
537
kernel_start ~ kernel_end 这段区域，需要 建立的页表属性为 read only ，其他的 页表属性为 通常 为 reading & writing 【 例外情况就是 480 ～ 481 行的， 配置了 readonly full 或者 debug page alloc 】
489 行，将 kernel_start ~ kernel_end 这段区域 设置为 no map, 防止 下面的for 循环对其 建立映射页表。
497 ～ 506 行，对 memblock 中的内存，建立映射页表。flags 使用 0 或者 480 ～ 481 行设置的值。
518 行，对 kernel_start ~ kernel_end 这段区域 建立页表，使用 NO_CONT_MAPPINGS
519 行，使用memblock 函数，clear no map ，清掉 489 行设置的 no map 属性。
使用到的函数，__map_memblock ， 利用 early_pgtable_alloc 这个 辅助函数，建立页表。如下
455static void __init __map_memblock(pgd_t *pgdp, phys_addr_t start,
456 phys_addr_t end, pgprot_t prot, int flags)
457{
458 __create_pgd_mapping(pgdp, start, __phys_to_virt(start), end - start,
459 prot, early_pgtable_alloc, flags);
460}
创建映射，需要 分配空间时，使用 early_pgtable_alloc 来分配。 这个函数也在 同文件中。
97 行，使用 memblock 函数，找到一页空闲的物理内存，地址是 phys
106 行，将97 行找到的物理地址，映射到 fixmap 总 pte idx 对应的 VA 地址处。
108 行，使用 memset 函数进行填充。
116 行返回物理地址。
92static phys_addr_t __init early_pgtable_alloc(int shift)
93{
94 phys_addr_t phys;
95 void *ptr;
96
97 phys = memblock_phys_alloc(PAGE_SIZE, PAGE_SIZE);
98 if (!phys)
99 panic("Failed to allocate page table page\n");
100
101 /*
102 * The FIX_{PGD,PUD,PMD} slots may be in active use, but the FIX_PTE
103 * slot will be free, so we can (ab)use the FIX_PTE slot to initialise
104 * any level of table.
105 */
106 ptr = pte_set_fixmap(phys);
107
108 memset(ptr, 0, PAGE_SIZE);
109
110 /*
111 * Implicit barriers also ensure the zeroed page is visible to the page
112 * table walker
113 */
114 pte_clear_fixmap();
115
116 return phys;
117}
背景说明：
1、fixmap 中，pgd pud pmd 对应的 虚拟地址可能正在被使用，但是 pte 对应的 虚拟地址 肯定是 可以被 覆盖的。
因为 修改地址转换页表时，需要 使用 虚拟地址，因为已经使能了 MMU ，CPU 操作的地址都时VA 地址。
但是 ，修改完成后，MMU工作时，就仅仅依赖页表里面填写的 物理地址了。
所以，FIXMAP 中的 pte 这个 VA 地址，哪里需要就 映射到哪里，然后就 可以使用这个VA 地址，填充里面的值。
示例：
__create_pgd_mapping 传入的参数 pgd 页表，基地址 pgdir , 查找到 页表 项 pgdp . 这个页表 项 VA 地址是可以访问的。
因为这个 pgdir 就是 paging_init 的 711 行，传入的 pgd_t *pgdp = pgd_set_fixmap(__pa_symbol(swapper_pg_dir)); fixmap 的 pgd idx 对应VA 映射到 swapper_pg_dir PA 上面。
349static void __create_pgd_mapping(pgd_t *pgdir, phys_addr_t phys,
350 unsigned long virt, phys_addr_t size,
351 pgprot_t prot,
352 phys_addr_t (*pgtable_alloc)(int),
353 int flags)
354{
355 unsigned long addr, end, next;
356 pgd_t *pgdp = pgd_offset_pgd(pgdir, virt);
369 do {
371 alloc_init_pud(pgdp, addr, next, phys, prot, pgtable_alloc,
372 flags);
374 } while (pgdp++, addr = next, addr != end);
375}
由于 349 行传入的 pgdir 已经是 711 行建立过映射的，所以 356 行的 pgdp 可以被访问，这个地址在371行传入 alloc_init_pud 函数，在这个函数里面会 检查和 填充这个 pgdp 指针指向的 页表项
297
298static void alloc_init_pud(pgd_t *pgdp, unsigned long addr, unsigned long end,
299 phys_addr_t phys, pgprot_t prot,
300 phys_addr_t (*pgtable_alloc)(int),
301 int flags)
302{
303 unsigned long next;
304 pud_t *pudp;
305 p4d_t *p4dp = p4d_offset(pgdp, addr);
306 p4d_t p4d = READ_ONCE(*p4dp);
307
308 if (p4d_none(p4d)) {
311 pud_phys = pgtable_alloc(PUD_SHIFT);
312 __p4d_populate(p4dp, pud_phys, PUD_TYPE_TABLE);
313 p4d = READ_ONCE(*p4dp);
314 }
316
317 pudp = pud_set_fixmap_offset(p4dp, addr);
318 do {
326 if (use_1G_block(addr, next, phys) &&
336 } else {
337 alloc_init_cont_pmd(pudp, addr, next, phys, prot,
338 pgtable_alloc, flags);
339
342 }
344 } while (pudp++, addr = next, addr != end);
345
305 行由 pgdp, addr 得到 p4dp , 可以简单理解为 p4dp = pgdp .
308 行就访问到 p4dp 这个地址了，幸好它在 711 行建立 了映射，所以现在可以被 read & check , 312 行，对其进行 write 操作。
312行，写入 p4dp 页表 项的内容是 pud 表 物理 起始地址，通过 pgtable_alloc 分配（也就是 92 行的 early_pgtable_alloc ，分配一页），物理地址填入 p4dp 页表项。
317 行， pud_set_fixmap_offset(p4dp, addr ) 这个函数，读出 p4dp 页表项里面的物理地址（312 行刚填写进入的），结合 addr，找到 pud 页表里面的 表项的物理地址， 然后将这个物理地址，映射到 fixmap 的 PUD IDX 对应的slot 上面
pudp 这个地址就是 映射后的 VA 地址了，可以访问，将它填入到 337 行的 alloc_init_cont_pmd 里面，在它里面，会 访问 pudp 这个指针指向的内存。
249static void alloc_init_cont_pmd(pud_t *pudp, unsigned long addr,
250 unsigned long end, phys_addr_t phys,
251 pgprot_t prot,
252 phys_addr_t (*pgtable_alloc)(int), int flags)
253{
255 pud_t pud = READ_ONCE(*pudp);
261 if (pud_none(pud)) {
264 pmd_phys = pgtable_alloc(PMD_SHIFT);
265 __pud_populate(pudp, pmd_phys, PUD_TYPE_TABLE);
267 }
270 do {
276 if ((((addr | next | phys) & ~CONT_PMD_MASK) == 0) &&
277 (flags & NO_CONT_MAPPINGS) == 0)
280 init_pmd(pudp, addr, next, phys, __prot, pgtable_alloc, flags);
281
282 phys += next - addr;
283 } while (addr = next, addr != end);
284}
255 行就 read 这个地址，读出 页表项 内容，pud
261 行检查，如果为空，就在264 行申请 物理地址，然后265 行，写入 pud 页表 表项里面。
280 行，继续将 pudp 指针，传递给 init_pmd 函数。
212static void init_pmd(pud_t *pudp, unsigned long addr, unsigned long end,
213 phys_addr_t phys, pgprot_t prot,
214 phys_addr_t (*pgtable_alloc)(int), int flags)
215{
219 pmdp = pmd_set_fixmap_offset(pudp, addr);
220 do {
221 pmd_t old_pmd = READ_ONCE(*pmdp);
222
226 if (((addr | next | phys) & ~SECTION_MASK) == 0 &&
227 (flags & NO_BLOCK_MAPPINGS) == 0) {
236 } else {
237 alloc_init_cont_pte(pmdp, addr, next, phys, prot,
238 pgtable_alloc, flags);
242 }
243 phys += next - addr;
244 } while (pmdp++, addr = next, addr != end);
247}
248
219 行，pmd_set_fixmap_offset 函数，使用 pudp 页表项里面的物理地址，前面 264 行分配，265行填入的，结合 addr，找到 pmd 页表 里面对应的 表项 的物理地址，然后将这个物理地址映射到 fixmap 的 PMD IDX slot 对应的 VA 地址上面
221 就立刻使用了 219 行映射的 VA 地址， read once .
237 行，将映射后的VA 地址，交给 alloc_init_cont_pte 函数，它里面会访问 pmdp 这个VA 地址，读，检查，写，类似 249 行， alloc_init_cont_pmd 函数里面。
177static void alloc_init_cont_pte(pmd_t *pmdp, unsigned long addr,
178 unsigned long end, phys_addr_t phys,
179 pgprot_t prot,
180 phys_addr_t (*pgtable_alloc)(int),
181 int flags)
182{
184 pmd_t pmd = READ_ONCE(*pmdp);
185
187 if (pmd_none(pmd)) {
190 pte_phys = pgtable_alloc(PAGE_SHIFT);
191 __pmd_populate(pmdp, pte_phys, PMD_TYPE_TABLE);
192 pmd = READ_ONCE(*pmdp);
193 }
195
196 do {
202 if ((((addr | next | phys) & ~CONT_PTE_MASK) == 0) &&
203 (flags & NO_CONT_MAPPINGS) == 0)
206 init_pte(pmdp, addr, next, phys, __prot);
207
209 } while (addr = next, addr != end);
210}
类似249 行， alloc_init_cont_pmd 函数，187 ～ 193 行，检查，如果为空，就设置。206 行，将pmdp VA地址传入 init_pte 函数
153static void init_pte(pmd_t *pmdp, unsigned long addr, unsigned long end,
154 phys_addr_t phys, pgprot_t prot)
155{
158 ptep = pte_set_fixmap_offset(pmdp, addr);
159 do {
162 set_pte(ptep, pfn_pte(__phys_to_pfn(phys), prot));
163
172 } while (ptep++, addr += PAGE_SIZE, addr != end);
173
174 pte_clear_fixmap();
175}
158 行，类似前面 219 行。 从pmdp 页表 项中取出物理地址，这个物理地址时 191 行填入，然后依据 addr 找到 pte 页表中，表项的 物理地址，然后将物理地址，映射到 fixmap 的 PTE IDX slot 上面
163 行，就使用刚才映射的 ptep VA 地址。
这样，使用fixmap 的 pgd pud pmp pte 4个 slot ，和 early_pgtable_alloc 函数（使用 memblock 分 一页 物理地址）， 就可以 对 memblock 中所有 记录的 内存进行映射表的创建和填写了。
标签：__,alloc,phys,addr,idx,pmd,init,end 来源： https://www.cnblogs.com/zhangzhiwei122/p/16087825.html