[内核内存] [arm64] 内存初始化3---page_init

末蓝、 2022-11-17 14:51 852阅读 0赞

linux内核版本：linux4.9.115（arm64）

### 文章目录 ###

*  paging\_init
 *   *  Step1
     *   *  early\_pgtable\_alloc
     *  Step2
     *   *  map\_kernel
         *  map\_kernel\_segment
         *   *  \_\_create\_pgd\_mapping
             *   *  alloc\_init\_pud
                 *  alloc\_init\_pmd
                 *  alloc\_init\_pte
             *  vm\_area\_add\_early
         *  step2小结
     *  Step3
     *   *  map\_mem
     *  Step4
 *  附件

Arm64架构的linux内核在经历前面介绍的两阶段初始化后，回过头来总结一下目前内存所处的状态：

1.  在整个物理内存空间中，系统获取了一段或几段的内存区域并被记录在了memblock模块的memory type类型数组中。数组中的每一个内存区域（memory region）都描述了一段内存信息（base，size，node id）。
2.  在memblock模块获取的内存信息中（memory type中保存的内存区域），那些已经被使用或者是被内核定义需要保留的内存区域，将从memory type数组中提取出来并定义在模块的reserved type数组中（reserved type数组是memory type数组的真子集）。
3.  在内核初始化的整个阶段都需要暂时使用memory block模块来对内核内存进行管理，收集内存信息只是该模块的一个副业。在此阶段内核分配内存都是在模块的reserved type数组中增加一个item或者是扩展其中一个内存区域的大小.在memory收集的内存信息中，只有两段内存区域是可以访问的kernel image段和fdt段。因为在内存初始化的前两阶段对其进行了地址映射.而其他大部分的内存区域并不能通过虚拟地址进行访问，需要进行地址映射.
4.  memory type数组并不是代表整个内核系统的内存空间，因为部分驱动会保留一段内存区域供自己单独使用并且不想linux内核管理这段内存,因此它自己创建该段内存的地址映射对os并不可见。在dts文件中具有no-map属性的reserved-memory节点，在内存初始化过程中解析reserved-memory节点都会将他们从memblock模块中移除，不会由内核创建地址映射，因此不在os的控制域内

# paging\_init #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA5MjMwODM_size_16_color_FFFFFF_t_70_pic_center]

1.arm64内存布局图(39位--4K)

内核在paging\_init前，物理内存通过memblock模块添加进了系统。但是此时只有dtb和Image所在的两段物理内存可以访问。其他区域的物理内存还没建立映射，可以用memblock\_alloc分配物理内存，但是不能被访问。因此需要通过paging\_init建立不能访问的物理区域最终的页表，才能通过虚拟地址去分配和申请对应的物理地址。图(1)就是pageing\_init执行后arm64内存最终的布局图。由此可见pageing\_init是内核内存初始化的最核心的一步，下面分析paging\_intit代码细节：

void __init paging_init(void)  
    {   
       //分配4k大小的物理内存，存放pgd 
        //物理区域填0,填充完后静态定义的虚拟地址（FIX_PTE）马上就会被解除与物理地址间的映射关系
        phys_addr_t pgd_phys = early_pgtable_alloc();
        //通过fixmap为pgd_phys分配一个虚拟地址
        pgd_t *pgd = pgd_set_fixmap(pgd_phys);  
        //映射内核各个内存段 
        map_kernel(pgd);  
        //映射memblock子系统添加的内存区域 
        map_mem(pgd);  
        //将pgd页表的内容全切换到swapper_pgd_dir页表（全覆盖） 
        //将ttbr1的值设置为pgd页表的物理地址
        cpu_replace_ttbr1(__va(pgd_phys));  
        //拷贝
        memcpy(swapper_pg_dir, pgd, PGD_SIZE);  
        //在把ttbr1的值设置位swapper_pg_dir
        cpu_replace_ttbr1(swapper_pg_dir);
        //解除fix区域pgd虚拟地址映射 
        pgd_clear_fixmap();  
        //释放pgd临时页表的物理内存
        memblock_free(pgd_phys, PAGE_SIZE); 
        //释放掉 swapper_pg_dir下面的几个页表
        memblock_free(__pa(swapper_pg_dir) + PAGE_SIZE,  
                  SWAPPER_DIR_SIZE - PAGE_SIZE);  
    }

从paging\_init代码中看出其主要分4步来建立内核的最终页表,相应的流程图如图2所示：

*  Step1：分配4k大小物理内存，存放临时pgd
 *  Step2：映射内核各个内存段
 *  Step3：映射memblock子系统添加的内存区域
 *  Step4：将临时pgd拷贝到swapper\_pgd\_dir页表

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA5MjMwODM_size_16_color_FFFFFF_t_70_pic_center 1]

2.paging\_init执行流程

## Step1 ##

### early\_pgtable\_alloc ###

static phys_addr_t __init early_pgtable_alloc(void)  
    {   
        phys_addr_t phys;  
        void *ptr;  
        /*通过memblock_alloc分配PAGE_SIZE大小的页并按照PAGE_SIZE对齐，将物理地址存 储在phys */
        phys = memblock_alloc(PAGE_SIZE, PAGE_SIZE);
      
        /* * The FIX_{PGD,PUD,PMD} slots may be in active use, but the FIX_PTE * slot will be free, so we can (ab)use the FIX_PTE slot to initialise * any level of table. */  
        //返回一个虚拟地址,静态定义的，有FIX_PTE和物理地址的后12位构成（若page大小4K）
        ptr = pte_set_fixmap(phys); 
      
        memset(ptr, 0, PAGE_SIZE);
      
         /* *解除虚拟地址ptr到物理地址pyhs间的映射，即删除pte页表的中entry，还要刷新 *tlb，因为映射完成后，该页表的内容可能被加载到tlb中，若不刷新tlb会导致tlb *中的内容与实际的页表不一致. * Implicit barriers also ensure the zeroed page is visible to the page * table walker */  
        pte_clear_fixmap();
      
        return phys;  
    }

函数首先通过memblock\_alloc申请页对齐的一页内存，然后通过memset函数把该页内存初始化为0.内核要想在此阶段单纯完成上诉操作仍然存在一定难度。因为membloc\_alloc申请的内存返回的是它的物理地址，而memset函数初始化内存区域需要传递内存区域的虚拟地址。所以内存利用fixed map机制中的pte\_set\_fixmap函数来获取phys对应的虚拟地址，该函数还会完成虚拟地址到物理地址页表的映射填充工作（否则后续通过虚拟地址访问内存区域会发生page fault）。下面详细分析下pte\_set\_fixmap该函数，先展示代码：

//获取fixmap地址区域中某个虚拟地址的index
    #define pte_set_fixmap(addr) ((pte_t *)set_fixmap_offset(FIX_PTE, addr))
    //映射使用的flag是PAGE_KERNEL 
    #define FIXMAP_PAGE_NORMAL PAGE_KERNEL 
      
    #define set_fixmap_offset(idx, phys) \ __set_fixmap_offset(idx, phys, FIXMAP_PAGE_NORMAL)
      
    /* *返回一个虚拟地址________addr,该虚拟地址时用PIX_PTE标志，通过fix_to_virt计算，然后有__set_fixmap完成虚拟地址到 *物理地址的映射 */  
    /* Return a pointer with offset calculated */  
    #define __set_fixmap_offset(idx, phys, flags) \ 
    ({                                   \  
        unsigned long ________addr;                 \  
        __set_fixmap(idx, phys, flags);                 \  
        ________addr = fix_to_virt(idx) + ((phys) & (PAGE_SIZE - 1));   \  
        ________addr;                           \  
    })  
    //将bm_pte[x]指向对应的物理地址，用set_pte完成，其它页表entry的设定已经在early_fixmap_init中完成 
    void __set_fixmap(enum fixed_addresses idx,  
                       phys_addr_t phys, pgprot_t flags)  
    {   
        unsigned long addr = __fix_to_virt(idx);  ......(1)
        pte_t *pte;  
      
        BUG_ON(idx <= FIX_HOLE || idx >= __end_of_fixed_addresses);  
      
        pte = fixmap_pte(addr);  .  
        if (pgprot_val(flags)) {   
            set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags)); ......(2) 
        } else {   
            pte_clear(&init_mm, addr, pte);  
            flush_tlb_kernel_range(addr, addr+PAGE_SIZE);  
        }  
    }

pte\_set\_fixmap：

1.  (1)此处物理地址作为输入参数，输出其映射的的虚拟地址。虚拟地址是固定的根据FIX\_PTE通过fix\_to\_virt得到。
2.  (2)此处完成虚拟地址到物理地址的映射，将物理地址对应的entry填入到pm\_pte页表对应的位置中。这里映射的大小就一个page的大小，虚拟地址—>物理地址这一映射过程就是pgd,pmd和pte页表的存储和内容填写过程：
    
    1.  pgd使用的是swapper\_pg\_dir页表，该页表支持内核所有的虚拟地址空间映射，相较于\_\_creat\_page\_tables,因为fixmap的虚拟地址空间离vmalloc较远，它使用的是swapper\_pg\_dir中的另外一个entry.
    2.  而pmd转换表和pte页表并不能和\_\_create\_page\_table那边的共用，原因是section map只有一个page来存储pmd，还有就是先前的pmd已经被占用了并不能共用。解决方式是fixmap机制自己静态申请了两个page，从下列代码可以看出bm\_pmd和pm\_pud有做\_\_maybe\_unsed标记，这表示它们会根据页表的具体状态定义，在39bit，三级页表的页表分配情况下就会去掉bm\_pud。
        
            static pte_t bm_pte[PTRS_PER_PTE] __page_aligned_bss;  
            static pmd_t bm_pmd[PTRS_PER_PMD] __page_aligned_bss __maybe_unused;  
            static pud_t bm_pud[PTRS_PER_PUD] __page_aligned_bss __maybe_unused;

\*\*PS:\*\*上面解决了页表存放的位置，但是需要建立三个页表间的联系。即:

(a) swapper\_pg\_dir\[vaddr(39:31)\]指向bm\_pmd

(b) bm\_pmd\[vaddr(30:22)\]指向bm\_pte

其中(a),(b)这部分工作已经在early\_fixmap\_init中完成，而©正是在pte\_set\_fixmap中的set\_pte中完成。

从pet\_set\_fixmap中我们可以总结出fixmap只适用于临时申请一个page，它可以帮你完成映射，允许你操作这个page。但是操作之后就需要释放掉这个映射，之后又会建立其它临时page的映射。如果你还想再访问原来的物理地址，那没办法了，再使用这个虚拟地址访问的空间已经是新申请的物理地址了。所以，它只是提供了临时读写一个物理页的方法。这对于map时是有用的，比如我为了创建线性映射区的映射，需要不停地申请页表然后填充信息，但是填充完成后，软件上不需要再访问这些申请的页表，那是硬件MMU去做的，对MMU而言，只要这个页表中内容有效就可以，MMU可不需要建立映射再访问。

再回到paging\_init函数，发现内核利用pgd\_set\_fixmap函数给刚刚申请一页物理地(0填充)址再次分配了一个静态定义的虚拟地址pgd\_t \*pgd（虚拟地址仍然来源于fixmap 临时区域）。pgd\_set\_fixmap和pte\_set\_fixmap函数的区别是前者返回的静态虚拟地址在fixmap区域的位置idx是FIX\_PGD，而后者的位置idx是FIX\_PTE.

## Step2 ##

### map\_kernel ###

该步骤工作是映射内核image各个内存片段，内核image的地址位于线性映射区域，它的映射和普通映射有一些区别。因为内核包含代码段，数据段和只读数据段。这些段在内存中的访问权限不同（代码段只读且可执行，数据段可读可写不可执行，只读数据段只可读）。基于以上特性内核image的各个段的页表需要分开创建，通过在PTE entry中设置不同的flag来对其进行权限的管控.代码如下：

static void __init map_kernel(pgd_t *pgd)  
    {   
        static struct vm_struct vmlinux_text, vmlinux_rodata, vmlinux_init, vmlinux_data;  
      
        map_kernel_segment(pgd, _text, _etext, PAGE_KERNEL_EXEC, &vmlinux_text);  
        map_kernel_segment(pgd, __start_rodata, __init_begin, PAGE_KERNEL, &vmlinux_rodata);  
        map_kernel_segment(pgd, __init_begin, __init_end, PAGE_KERNEL_EXEC,  
                   &vmlinux_init);  ---->(1)
        map_kernel_segment(pgd, _data, _end, PAGE_KERNEL, &vmlinux_data);  
      
        if (!pgd_val(*pgd_offset_raw(pgd, FIXADDR_START))) {   
                set_pgd(pgd_offset_raw(pgd, FIXADDR_START),  
                				*pgd_offset_k(FIXADDR_START));  ----->(2)
        } else if (CONFIG_PGTABLE_LEVELS > 3) {    
            BUG_ON(!IS_ENABLED(CONFIG_ARM64_16K_PAGES));  
            set_pud(pud_set_fixmap_offset(pgd, FIXADDR_START),  
                __pud(__pa(bm_pmd) | PUD_TYPE_TABLE));  
            pud_clear_fixmap();  ----->(3)
        } else {   
            BUG();  
        }  
      
        kasan_copy_shadow(pgd);  ----->(4)
    }

1.  (1)处分别映射内核的代码段，只读数据段，init段和数据段.pgd是前面临时分配的pgd，flag为该段地址的权限，后面会结合代码详细介绍map\_kernel\_segment函数.
2.  (2)处pgd\_offset\_raw(pgd,FIXADDR\_START)用于获取fixmap基地址对应的pgd entry地址，而\*pgd\_offset\_raw(pgd,FIXADDR\_START)表示页表中该entry的内容。这里是判断fixmap对应的虚拟地址在pgd页表中是否被设置过对应的entry。因为上面页表只设置了image的地址，因此pgd目前只设置了一个entry（原因是39位虚拟地址，4Kpage页面时一个pgd entry能映射1G的地址空间,而内核的大小小于1G）。所以如fixmap基地址对应的pgd entry已经被设置，则fixmap和kernel image将位于同一个pgd entry，若没被设置则它们位于不同的pgd entry。在arm64架构39位虚拟地址–4K页面–3级页表的虚拟地址内存布局的前提条件下，上述两段位于不同的pgd entry中，则可以直接将swapper页表中fixmap pgd entry的内容直接拷贝到临时的pgd entry中。因为swapper页表中fixmap的各级页表都已经完成了设置，所以拷贝完成后新的pgd对应的页表中fixmap页表也将与原来一致。这样就实现了fixmap页表的切换。
3.  (3)处代码处理另外一种arm64架构虚拟内存布局情况下fixmap段在pgd表中entry的设置工作。此时布局情况是48位地址–64k页–4级页表。这种情况下pgd只占虚拟地址的48位，于是所有虚拟地址共享一个pgd entry，因此fixmap的pgd entry不需要进行设置。但是pud页表中只有kernel image对应的entry被设置，由（2）分析方式可知fixmap和kernel image的地址一定不再一个pud entry中。于是直接复用以前静态定义的fixmap的pud entry内容到新创建的pud页表中。
4.  将kasam shadow在swapper 映射中的pgd entry拷贝到当前相应的pgd entry中.

### map\_kernel\_segment ###

static void __init map_kernel_segment(pgd_t *pgd, void *va_start, void *va_end,  
                          pgprot_t prot, struct vm_struct *vma)  
    {   
        phys_addr_t pa_start = __pa(va_start); 
        unsigned long size = va_end - va_start;  
      
        BUG_ON(!PAGE_ALIGNED(pa_start));  
        BUG_ON(!PAGE_ALIGNED(size));  
      
        __create_pgd_mapping(pgd, pa_start, (unsigned long)va_start, size, prot,  
                     early_pgtable_alloc, !debug_pagealloc_enabled());  
      
        vma->addr    = va_start;  
        vma->phys_addr   = pa_start;  
        vma->size    = size;  
        vma->flags   = VM_MAP;  
        vma->caller  = __builtin_return_address(0);  
    
        vm_area_add_early(vma);  
    }

由函数代码可知，该函数通过虚拟地址的起始地址和长度逐级地去填充pgd,pud,pmd和pte entry(4k页大小3级页表情况下pgd和pud指向同一页表)。函数主要流程是通过调研\_\_create\_pgd\_mapping函数实现.函数也支持section block map。此处介绍非section map的流程：

#### \_\_create\_pgd\_mapping ####

static void __create_pgd_mapping(pgd_t *pgdir, phys_addr_t phys,  
                     unsigned long virt, phys_addr_t size,  
                     pgprot_t prot,  
                     phys_addr_t (*pgtable_alloc)(void),  
                     bool allow_block_mappings)  
    {   
        unsigned long addr, length, end, next;  
        //计算区域起始虚拟地址在pgd中entry的位置 
        pgd_t *pgd = pgd_offset_raw(pgdir, virt);  
      
        /* * If the virtual and physical address don't have the same offset * within a page, we cannot map the region as the caller expects. */  
        if (WARN_ON((phys ^ virt) & ~PAGE_MASK))  
            return;  
        //页表以页为单位创建，起始地址和长度需要页对齐 
        phys &= PAGE_MASK;  
        addr = virt & PAGE_MASK;  
        length = PAGE_ALIGN(size + (virt & ~PAGE_MASK));  
        //虚拟地址结束位置 
        end = addr + length;  
        do {   
            /* *计算下一个pgd entry对应的虚拟地址值，当end小于下一个pgd entry的起始地址时返回end，否则返回下一个 *pgd entry的起始虚拟地址 */  
            next = pgd_addr_end(addr,end);  
            /* *因为pgd entry中保存的是pud页表的物理地址，此处先创建一页大小的pud表，然后将pud的物理地址赋值个 *pgd entry */  
            alloc_init_pud(pgd, addr, next, phys, prot, pgtable_alloc,  
                       allow_block_mappings);  
            phys += next - addr;  
        } while (pgd++, addr = next, addr != end);//循环pgd entry 
    }

##### alloc\_init\_pud #####

alloc\_init\_pud执行流程：（1）先分配一个存储pud页表的物理内存.(2)再将用来存储pud页表的物理地址赋值给对应的pgd entry.(3)最后while循环填充pud页表中每个pud entry的内容,其中每个pud entry内容的填充是通过函数alloc\_init\_pmd来完成.

static void alloc_init_pud(pgd_t *pgd, unsigned long addr, unsigned long end,  
                      phys_addr_t phys, pgprot_t prot,  
                      phys_addr_t (*pgtable_alloc)(void),  
                      bool allow_block_mappings)  
    {   
        pud_t *pud;  
        unsigned long next;  
        //pgd中的entry内容为空，则需要创建一个pud页表，并将页表物理地址赋值个pgd entry 
        if (pgd_none(*pgd)) {   
            phys_addr_t pud_phys;  
            //当pgtable_alloc未传入指针，无法分配内存,退出 
            BUG_ON(!pgtable_alloc);  
            //实际是调用early_pgtable_alloc函数分配一页内存，并将内存内容清0,并返回物理地。 
            pud_phys = pgtable_alloc();  
            //将pud物理地址写到pgd entry，完成pgd entry设置 
            __pgd_populate(pgd, pud_phys, PUD_TYPE_TABLE);  
        }  
        BUG_ON(pgd_bad(*pgd));  
        /*计算虚拟地址在pud页表中对应的pgd entry的虚拟地址。 * （1）读取pgd entry获取pud页表基地址的物理地址 * （2）根据虚拟地址与pud相关的域计算pud index * （3）根据（1）（2）的结果获取pud entry的物理地址 * （4）利用fixmap中的FIX_PUD映射其虚拟地址，该虚拟 * 地址就是addr虚拟地址对应第一个pud entry的指针，指针进行+1操作 * 会自动跳转到下一个pgd entry指针 */  
        pud = pud_set_fixmap_offset(pgd, addr);  
      
        do {   
            //计算下一个pud entry虚拟地址 
            next = pud_addr_end(addr, end);  
      
            /* * For 4K granule only, attempt to put down a 1GB block * 代码为是否要执行section map的判断条件。只有在传入了allow_block_mappings * 标志，才允许执行section map操作。 若为pud级的section map，则其虚拟地址，物 * 理地址和下一个entry的虚拟地址都必须PUD SIZE对齐。 */  
            if (use_1G_block(addr, next, phys) && allow_block_mappings) {   
                pud_t old_pud = *pud;  
                /* *若满足section map的条件，则在pud entry中直接设置起始物理地址与flags组合后 *的值，显然这就是末级页表，故后面的pmd，pte也就不再需要设置 */  
                pud_set_huge(pud, phys, prot);  
      
                /* * If we have an old value for a pud, it will * be pointing to a pmd table that we no longer * need (from swapper_pg_dir). * * Look up the old pmd table and free it. *主要作用是释放老的pud entry指向的pmd页表内存。若在设置section map前， *pud entry 已经设置了直接指向pmd页表基地址的值，则需要将其释放。 */  
                if (!pud_none(old_pud)) {   
                    /* *由于被替换的old entry内容，可能已被加载到tlb中。因此，为了保持tlb和页表内容的一致，需要刷新 *tlb。 */  
                    flush_tlb_all();  
                    if (pud_table(old_pud)) {   
                        phys_addr_t table = pud_page_paddr(old_pud);  
                        if (!WARN_ON_ONCE(slab_is_available()))  
                            memblock_free(table, PAGE_SIZE);  
                    }  
                }  
            }  
            //else里是非section map 
            else {   
                /*和__create_pgd_mapping函数中alloc_init_pud类似，它会对地址范围内的所有 *pud entry执行循环操作，分别调用alloc_init_pmd函数实现pud entry的填充和 *下一级页表的创建 */  
                alloc_init_pmd(pud, addr, next, phys, prot,  
                           pgtable_alloc, allow_block_mappings);  
            }  
            phys += next - addr;  
        } while (pud++, addr = next, addr != end);  
        //解除FIX_PUD映射，释放该虚拟地址 
        pud_clear_fixmap();  
    }

alloc\_init\_pud函数主要工作是分配pud页表并设置pgd页表entry（跳过section maping）。需要注意的是当虚拟地址页表映射机制是39位虚拟地址+3级页表+4K页大小的时候PUD就是PGD，这里的PUD=PGD.

##### alloc\_init\_pmd #####

函数的实现流程和alloc\_init\_pud基本一致：（1）先分配一个存储pmd页表的物理内存.(2)再将用来存储pmd页表的物理地址赋值给对应的pud entry.(3)最后while循环填充pmd页表中每个pmd entry的内容,其中每个pmd entry内容的填充是通过函数alloc\_init\_pte来完成.(若pmd页表是转换表则pmd entry内容是用于获取下一级pte页表的物理地址，若pmd是最后一级页表，则pmd entry存储的是对应物理地址高位地址和该物理地址对应内存区域的权限信息)

static void alloc_init_pmd(pud_t *pud, unsigned long addr, unsigned long end,
    				  phys_addr_t phys, pgprot_t prot,
    				  phys_addr_t (*pgtable_alloc)(void),
    				  bool allow_block_mappings)
    { 
    	pmd_t *pmd;
    	unsigned long next;
    
    	/* * Check for initial section mappings in the pgd/pud and remove them. */
    	BUG_ON(pud_sect(*pud));
    	if (pud_none(*pud)) { 
    		phys_addr_t pmd_phys;
    		BUG_ON(!pgtable_alloc);
            //分配pmd页表
    		pmd_phys = pgtable_alloc();
    		pmd = pmd_set_fixmap(pmd_phys);
    		__pud_populate(pud, pmd_phys, PUD_TYPE_TABLE);
    		pmd_clear_fixmap();
    	}
    	BUG_ON(pud_bad(*pud));
    
    	pmd = pmd_set_fixmap_offset(pud, addr);
    	do { 
    		next = pmd_addr_end(addr, end);
    		/* try section mapping first */
    		if (((addr | next | phys) & ~SECTION_MASK) == 0 &&
    		      allow_block_mappings) { 
    			pmd_t old_pmd =*pmd;
    			pmd_set_huge(pmd, phys, prot);
    			/* * Check for previous table entries created during * boot (__create_page_tables) and flush them. */
    			if (!pmd_none(old_pmd)) { 
    				flush_tlb_all();
    				if (pmd_table(old_pmd)) { 
    					phys_addr_t table = pmd_page_paddr(old_pmd);
    					if (!WARN_ON_ONCE(slab_is_available()))
    						memblock_free(table, PAGE_SIZE);
    				}
    			}
    		} else { 
    			alloc_init_pte(pmd, addr, next, __phys_to_pfn(phys),
    				       prot, pgtable_alloc);
    		}
    		phys += next - addr;
    	} while (pmd++, addr = next, addr != end);
    	//解除FIX_PMD虚拟地址映射
    	pmd_clear_fixmap();
    }

##### alloc\_init\_pte #####

alloc\_init\_pte函数是用来创建pte页表并填充pte entry的函数.因为pte页表与pgd，pud和pmd页表不一样。pgd，pud和pmd页表的页表项(entry)是用来存储下一级页表的物理地址，而pte页表的pte entry是用来存储对应虚拟地址映射的物理地址的物理页框号(pfn)，以及其对应page的权限信息的.所以alloc\_init\_pte函数执行流程:(1)先分配一个内存页用来存储pte页表内容，（2）然后将存储pte页表内存空间的物理地址赋值给对应的pmd entry。（3）通过while循环填充pte页表中所有的pte entry,每个pte entry的填充通过函数set\_pte来完成（set\_pte主要将pte entry对应的虚拟地址指向的页的页框号存储在pte entry中，同时还会将对应物理的的权限数据prot保存在pte entry中）

static void alloc_init_pte(pmd_t *pmd, unsigned long addr,
    				  unsigned long end, unsigned long pfn,
    				  pgprot_t prot,
    				  phys_addr_t (*pgtable_alloc)(void))
    { 
    	pte_t *pte;
    
    	BUG_ON(pmd_sect(*pmd));
        //分配一个page的内容用来存储本pte页表,并将该页的物理地址赋值给对应的pmd entry
    	if (pmd_none(*pmd)) { 
    		phys_addr_t pte_phys;
    		BUG_ON(!pgtable_alloc);
    		pte_phys = pgtable_alloc();
    		pte = pte_set_fixmap(pte_phys);
    		__pmd_populate(pmd, pte_phys, PMD_TYPE_TABLE);
    		pte_clear_fixmap();
    	}
    	BUG_ON(pmd_bad(*pmd));
    	//通过fixmap机制给pte物理地址分配一个虚拟地址，用于cpu能访问到pte页表的每个pte entry
    	pte = pte_set_fixmap_offset(pmd, addr);
        //填充pte页表中512个pte entry
    	do { 
            //给每个pte entry填充数据（对应页的页框号和该页的权限信息），一个pte entry对应一个物理页
    		set_pte(pte, pfn_pte(pfn, prot));
    		pfn++;
    	} while (pte++, addr += PAGE_SIZE, addr != end);
    	//解除FIX_PTE虚拟地址映射
    	pte_clear_fixmap();
    }

#### vm\_area\_add\_early ####

回到map\_kernel\_segment：struct vm\_struct结构用于管理一段连续内存虚拟地址和物理页之间的映射关系.函数此处将kernel image这一段区域的相关信息记录在vma这个vm\_struct变量中。然后通过vm\_area\_add\_early函数将vma添加到一个全局struct vm\_struct链表中。该链表的链表头定义在mm/vmalloc的全局变量vmlist中。该链表管理vmalloc区域中建立的各个子区域，会在后续的vmalloc\_init中使用。

static struct vm_struct *vmlist __initdata;

### step2小结 ###

map\_kernel函数执行完后各个段的虚拟地址分布情如下表(nxp-1046单板–虚拟地址39位–3级页表)。此时的内核虚拟地址在vmalloc区域

<table> 
 <thead> 
  <tr> 
   <th align="center">…</th> 
   <th align="center">…</th> 
   <th align="center">…</th> 
   <th></th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">_text–&gt;_etext</td> 
   <td align="center">0xffffff80_08080000</td> 
   <td align="center">0xffffff80_08f70000</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">__start_rodata–&gt;__end_rodata</td> 
   <td align="center">0xffffff80_08f70000</td> 
   <td align="center">0xffffff80_095d1000</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">…</td> 
   <td align="center">…</td> 
   <td align="center">…</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">__ini_begin--&gt;__init_end</td> 
   <td align="center">0xffffff80_095e0000</td> 
   <td align="center">0xffffff80_097e0000</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">__data–&gt;edata</td> 
   <td align="center">0xffffff80_097e0000</td> 
   <td align="center">0xffffff80_09a1b200</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">__bss_start--&gt;__bss_stop</td> 
   <td align="center">0xffffff80_09a1b200</td> 
   <td align="center">0xffffff80_09a87768</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">idmap_pg_dir</td> 
   <td align="center">…</td> 
   <td align="center">…</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">tramp_pg_dir</td> 
   <td align="center"><em><strong>…</strong></em></td> 
   <td align="center">…</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">swapper_pg_dir</td> 
   <td align="center">…</td> 
   <td align="center">…</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td align="center">…</td> 
   <td align="center">…</td> 
   <td align="center">…</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

## Step3 ##

### map\_mem ###

static void __init map_mem(pgd_t *pgd)  
    {   
        unsigned long kernel_start = __pa(_text);  
        unsigned long kernel_end = __pa(__init_begin);      
        struct memblock_region *reg;  
      
        /* * Take care not to create a writable alias for the * read-only text and rodata sections of the kernel image. * So temporarily mark them as NOMAP to skip mappings in * the following for-loop *临时将内核的text段和rodata段打上nomap标志，防止进入下面的循环映射 *因为该段设置的权限和普通的区域不一样为只读不可执行.后面会解除nomap标志 */  
        memblock_mark_nomap(kernel_start, kernel_end - kernel_start);  
        /*猜测此处是为了二次加载提供的特殊操作保留内存，该内存区域不允许section map，因 *此也需要跳过循环 */  
    #ifdef CONFIG_KEXEC_CORE 
        if (crashk_res.end)  
            memblock_mark_nomap(crashk_res.start,  
                        resource_size(&crashk_res));  
    #endif 
      
        /* map all the memory banks */  
        /*映射membloc 中的所有memory区域，跳过内核的text段和rodata段*/  
        for_each_memblock(memory, reg) {   
            phys_addr_t start = reg->base;  
            phys_addr_t end = start + reg->size;  
     
            if (start >= end)  
                break;  
            if (memblock_is_nomap(reg))  
                continue;  
      
            __map_memblock(pgd, start, end,  
                       PAGE_KERNEL, !debug_pagealloc_enabled());  
        }  
      
        /* * Map the linear alias of the [_text, __init_begin) interval as * read-only/non-executable. This makes the contents of the * region accessible to subsystems such as hibernate, but * protects it from inadvertent modification or execution. */  
        //将内核的text段和rodata段以只读进行映射，权限为只读，同时解除nomap标志 
        __map_memblock(pgd, kernel_start, kernel_end,  
                   PAGE_KERNEL_RO, !debug_pagealloc_enabled());  
        memblock_clear_nomap(kernel_start, kernel_end - kernel_start);  
      
    #ifdef CONFIG_KEXEC_CORE 
        /* * Use page-level mappings here so that we can shrink the region * in page granularity and put back unused memory to buddy system * through /sys/kernel/kexec_crash_size interface. */  
        if (crashk_res.end) {   
            __map_memblock(pgd, crashk_res.start, crashk_res.end + 1,  
                       PAGE_KERNEL, false);  
            memblock_clear_nomap(crashk_res.start,  
                         resource_size(&crashk_res));  
        }  
    #endif 
    }

前面memblock模块添加了许多物理内存到系统中，map\_mem主要是完成这部分的物理内存的映射（若添加了MEMBLOCK\_NOMAP标志就不会进行映射）。函数会遍历memblock中的各个块，最后调用\_\_map\_memblock来完成实际映射操作。map\_mem是将物理地址映射到线性区域中。其中内核中的text和rodata段会再次被映射在了另外一个虚拟地址上，映射的时候也会限制成只读不可执行防止意外修改（其它子系统会映射到线性区域中也许会需要线性区域的地址来引用内核的text和rodata）。

\_\_map\_memblock对内存区域物理地址的映射还是通过上面介绍的\_\_craete\_pgd\_mapping函数来实现的这里就不重复介绍。map\_mem后内核内存布局效果如图3所示。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA5MjMwODM_size_16_color_FFFFFF_t_70_pic_center 2]

3.arm64内存布局图(39位--4K页--3级页表)

从上图中可以看出内核部分的物理地址被映到了两个虚拟地址，那么内核函数\_\_pa(x)函数是如何实现输入两个不同的虚拟地址得到一个物理地址的呢？

#define KERNEL_START _text
    #define __PHYS_OFFSET (KERNEL_START - TEXT_OFFSET)
    ENTRY(kimage_vaddr)
    .quad _text - TEXT_OFFSET
    
    
    #define __pa(x) __virt_to_phys((unsigned long)(x)) 
    #define __va(x) ((void *)__phys_to_virt((phys_addr_t)(x))) 
    #define __virt_to_phys(x) ({ \ 
        phys_addr_t __x = (phys_addr_t)(x);             \    
        __x & BIT(VA_BITS - 1) ? (__x & ~PAGE_OFFSET) + PHYS_OFFSET :   \    
                     (__x - kimage_voffset); })    
        
    #define __phys_to_virt(x) ((unsigned long)((x) - PHYS_OFFSET) | PAGE_OFFSET) 
    #define __phys_to_kimg(x) ((unsigned long)((x) + kimage_voffset))

从代码中我们可以发现\_\_virt\_to\_phys(x)宏的小窍门。通过传入虚拟地址的次高位，判断该位是否为1，是1的代表此时虚拟地址位于线性映射区域,虚拟地址和物理地址的偏差是memstart\_addr（PHYS\_OFFSET）.而是0则代表此时虚拟地址位于kernel image区域（vmalloc） ,此时虚拟地址和物理地址的偏差是kimage\_vaddr.

PS：memstart\_addr是kernel选取的物理基地址，memstart\_addr在arm64\_memblock\_init函数中设置。当memstart\_addr确定以后虚拟地址和物理地址创建线性映射区域都是以memstart\_addr为偏移。

## Step4 ##

此阶段工作主要是将新建立好的pgd页表内容拷贝到swapper\_pd\_dir页表。然后把临时pgd页表内存给释放掉，最后将swapper\_pg\_dir页表后面连续存放pud，pmd页表给释放了（因为他们对应的pgd页表是swapper\_pg\_dir，该表内存已经被替换，这些表也没有存在的意义）。

# 附件 #

AArch64 Linux memory layout with 4KB pages + 3 levels: Start End Size Use 
    ----------------------------------------------------------------------- 
    0000000000000000 0000007fffffffff 512GB user 
    ffffff8000000000 ffffffffffffffff 512GB kernel

#define __pa(x) __virt_to_phys((unsigned long)(x))
    #define __va(x) ((void *)__phys_to_virt((phys_addr_t)(x)))
    
    PTRS_PER_PGD = 0x200    //PGD表项为512项
    PTRS_PER_PMD = 0x200    //PMD表项为512项
    PTRS_PER_PTE = 0x200    //PTE表项为512项
    //PGD中一个页表项代表的地址范围是1GB
    PGDIR_SHIFT = 30
    PGDIR_SIZE = 0x40000000 //(2^PGDIR_SHIFT)
    PGDIR_MASK = 0x3FFFFFFF
    //PMD中一个表项代表的地址范围是2MB
    PMD_SHIFT = 21
    PMD_SIZE = 0x200000     //(2^PMD_SHIFT)
    PMD_MASK = 0x1FFFFF
    //物理页的大小为4KB，同时也是PTE中一个页表项代表的地址范围
    PAGE_SHIFT = 12
    PAGE_SIZE = 0x1000      //(2^PAGE_SHIFT)
    PAGE_MASK = 0xFFFFFFFFFFFFF000
    
    SECTION_SHIFT = 21 
    BLOCK_SHIFT = 21
    KERNEL_RAM_VADDR = 0xFFFFFFC000800000
    PAGE_OFFSET: 内核态的起始地址。
    PAGE_OFFSET + TEXT_OFFSET: 内核代码(stext)的起始地址。
    PHYS_OFFSET: 是PAGE_OFFSET这个虚拟地址对应的物理地址
    
    #define VA_BITS (CONFIG_ARM64_VA_BITS)
    #define VA_START (UL(0xffffffffffffffff) - (UL(1) << VA_BITS) + 1)
    #define PAGE_OFFSET (UL(0xffffffffffffffff) - (UL(1) << (VA_BITS - 1)) + 1)
    #define KIMAGE_VADDR (MODULES_END)
    #define VMALLOC_START (MODULES_END)
    #define VMALLOC_END (PAGE_OFFSET - PUD_SIZE - VMEMMAP_SIZE - SZ_64K)
    #define MODULES_END (MODULES_VADDR + MODULES_VSIZE)
    #define MODULES_VADDR (VA_START + KASAN_SHADOW_SIZE)
    #define MODULES_VSIZE (SZ_128M)
    #define VMEMMAP_START (PAGE_OFFSET - VMEMMAP_SIZE)
    #define PCI_IO_END (VMEMMAP_START - SZ_2M)
    #define PCI_IO_START (PCI_IO_END - PCI_IO_SIZE)
    #define FIXADDR_TOP (PCI_IO_START - SZ_2M)
    #define TASK_SIZE_64 (UL(1) << VA_BITS)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA5MjMwODM_size_16_color_FFFFFF_t_70_pic_center]: /images/20221022/46e0e898b86849a7b3208a1b417e1a5c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA5MjMwODM_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221022/fe589621d8cf4ef8a19c60b592b1a568.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTA5MjMwODM_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221022/405e776f6a674332b7bce6cfced1404c.png