Linux 内存管理框架

最新推荐文章于 2022-04-17 08:15:31 发布

chenying126

最新推荐文章于 2022-04-17 08:15:31 发布

阅读量2.4k

点赞数 2

本文链接：https://blog.csdn.net/chenying126/article/details/78311230

版权

1. 内存管理框架概览 2

1.1. 内存管理各个数据结构之间关系 2

5. 创建zonelists与冷热页链表 14

内存管理框架概览
1. 内存管理各个数据结构之间关系

主要数据结构说明

struct pglist_data
struct zone node_zones[MAX_NR_ZONES]	节点中包含的所有内存域
sstruct zonelist node_zonelists[MAX_ZONELISTS]	包含ZONELIST_FALLBACK和ZONELIST_NOFALLBACK两个链表，设置如果在一个内存域中分配失败的备用zone列表
int nr_zones	节点中包含的zone个数
struct page *node_mem_map	Page map，节点上所有页的struct page数组
struct bootmem_data *bdata	如果使用了自举分配器指向struct bootmem_data
unsigned long node_start_pfn	节点的起始页帧号
unsigned long node_present_pages	节点上包含的页数，不包含空洞
unsigned long node_spanned_pages	节点上所有页数包含空洞
int node_id	节点编号
struct task_struct *kswapd	内存交换进程
struct task_struct *kcompactd	内存压缩进程
unsigned long totalreserve_pages	每个节点预留的页，这些页不能用于应用程序内存分配
unsigned long min_unmapped_pages	内存回收的阀值，如果unmapped 页达到这个值
unsigned long min_slab_pages	如果用于slab的页达到这个值就缓存收缩
struct lruvec lruvec	活动/不活动链表用于内存回收页扫描
atomic_long_t vm_stat[NR_VM_NODE_STAT_ITEMS]	节点上各种类型页的统计

struct zone
unsigned long watermark[NR_WMARK]	内存域的三个水印值：WMARK_MIN,WMARK_LOW,WMARK_HIGH
long lowmem_reserve[MAX_NR_ZONES]	用于指定预留内存页用于无论如何都不能分配失败的操作
int node	指定内存域所属的节点
struct pglist_data *zone_pgdat	指向内存域所属的节点
struct per_cpu_pageset __percpu *pageset	冷热页缓存
unsigned long *pageblock_flags	位表，每4个bits用于标识一个pageblock_order 的迁移类型
unsigned long zone_start_pfn	内存域的起始页帧号
unsigned long managed_pages	伙伴系统中管理的页数
unsigned long spanned_pages	内存域中所有页包含空洞
unsigned long present_pages	内存域中页数不包含空洞
const char *name	内存域名"DMA"'HITGHMEM'等
struct free_area free_area[MAX_ORDER]	伙伴系统链表
atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS]	内存域中各种类型页统计

MEMEBLOCK
1. memblock数据结构

memblock用于开机阶段的内存管理。系统定义了连个静态数组memblock_memory和memblock_reserved用于管理内存。这个阶段内存以内存区块来管理，内存区块由结构体struct memblock_region来描述。其中memblock_memory中包含系统中所内存区块，数组memblock_reserve中包含系统中保留的或者被分配出去的内存区块。

memblock.h
#define INIT_MEMBLOCK_REGIONS   128 
//数组最大容纳128个区块，如果超过这个限制将重新分配和一个区块管理数组并且是原来
//的两倍大小
struct memblock_region {//描述一个内存区块    
    phys_addr_t base; //区块起始地址 
    phys_addr_t size;//区块大小
    unsigned long flags;
};
memblock.c
static struct memblock_region memblock_memory_init_regions[INIT_MEMBLOCK_REGIONS] 
static struct memblock_region memblock_reserved_init_regions[INIT_MEMBLOCK_REGIONS] 
    
struct memblock memblock __initdata_memblock = {
    .memory.regions     = memblock_memory_init_regions,
    .memory.cnt     = 1,  //表示内存块的数量，还没有插入内存块设置为1
    .memory.max     = INIT_MEMBLOCK_REGIONS, //数组最大容纳区块数
    .memory.name        = "memory",//内存数组名

    .reserved.regions   = memblock_reserved_init_regions,
    .reserved.cnt       = 1,  
    .reserved.max       = INIT_MEMBLOCK_REGIONS,
    .reserved.name      = "reserved",
	……
    .bottom_up      = false,
    .current_limit      = MEMBLOCK_ALLOC_ANYWHERE,
};

内存信息获取

系统启动阶段BootLoader将fdt存放起始地址传递到内核。进入内核之后fdt起始地址将被保存到全局变量__fdt_pointer中

__fdt_pointer中
__primary_switched:
    adrp    x4, init_thread_union
    add sp, x4, #THREAD_SIZE
    adr_l   x5, init_task
    msr sp_el0, x5          // Save thread_info

    adr_l   x8, vectors         // load VBAR_EL1 with virtual
    msr vbar_el1, x8            // vector table address
    isb
    stp xzr, x30, [sp, #-16]!
    mov x29, sp

    str_l   x21, __fdt_pointer, x5      // Save FDT pointer 保存fdt起始地址到__fdt_pointer中

启动阶段内核会解析fdt，其中包含解析内存信息，其流程如下：

setup_machine_fdt：传入参数__fdt_pointer，从fdt中解析机器相关的一些信息
fixmap_remap_fdt：将__fdt_pointer到fdt末尾的物理地址区间映射到内核虚拟地址空间 FIX_FDT到
__end_of_permanent_fixed_addresses中
early_init_dt_scan:解析一些启动阶段必要的信息，比如cmdline，memory等信息
of_flat_dt_get_machine_name：解析出机器名

MEMBLOCK函数接口

memblock_add(phys_addr_t base, phys_addr_t size) ：将内存区块base到base+size添加到内存区间管理数
    组memblock.memory.regions中
memblock_remove(phys_addr_t base, phys_addr_t size)：将内存区块base到base+size从内存区间管理数组
    memblock.memory.regions中删除
memblock_free(phys_addr_t base, phys_addr_t size)：将内存区块base到base+size从内存区间管理数组
    memblock.reserved.regions中移除
memblock_reserve(phys_addr_t base, phys_addr_t size)：将内存区块base到base+size添加到内存区间管理数
    组memblock.reserved.regions中
memblock_is_reserved(phys_addr_t addr)：查询addr是否包含在memblock.reserved.regions中
memblock_is_memory(phys_addr_t addr)：查询addr是否包含在memblock.memory.regions中
memblock_isolate_range(type, base, size, &start_rgn, &end_rgn)：返回base到base+size涵盖的起始区块
    start_rgn和结束区块end_rgn，如果base到base+size与原有区块由重叠就截断。

void __init arm64_memblock_init(void)
{
    const s64 linear_region_size = -(s64)PAGE_OFFSET;

    memstart_addr = round_down(memblock_start_of_DRAM(),
                   ARM64_MEMSTART_ALIGN); 

    memblock_remove(max_t(u64, memstart_addr + linear_region_size,
            __pa_symbol(_end)), ULLONG_MAX); //移除不会使用到去内存区域
    ......
    if (IS_ENABLED(CONFIG_BLK_DEV_INITRD) && initrd_start) {
        u64 base = initrd_start & PAGE_MASK;
        u64 size = PAGE_ALIGN(initrd_end) - base;

        if (WARN(base < memblock_start_of_DRAM() ||
             base + size > memblock_start_of_DRAM() +
                       linear_region_size,
            "initrd not fully accessible via the linear mapping -- please check your bootloader ...\n")) {
            initrd_start = 0;
        } else {
            memblock_remove(base, size); /* clear MEMBLOCK_ flags */
            memblock_add(base, size);
            memblock_reserve(base, size); //将用于initrd的区间插入memblock.reserved.regions
        }
    }

    if (IS_ENABLED(CONFIG_RANDOMIZE_BASE)) {
        extern u16 memstart_offset_seed;
        u64 range = linear_region_size -
                (memblock_end_of_DRAM() - memblock_start_of_DRAM());

        if (memstart_offset_seed > 0 && range >= ARM64_MEMSTART_ALIGN) {
            range = range / ARM64_MEMSTART_ALIGN + 1;
            memstart_addr -= ARM64_MEMSTART_ALIGN *
                     ((range * memstart_offset_seed) >> 16);//给内存起始位置随机
        }
    }
//将内核代码区设置为保留
    memblock_reserve(__pa_symbol(_text), _end - _text);
    ......
}

内核页表
1. 页表结构

页表就是一个多维数组，TTBR就是用于存放这个数组起始地址的寄存器。D_Table表示这一条描述符指向下一级页表；D_Block表示这一条描述符指向一个内存块；D_Page表示这一条描述符指向一个物理页。

表描述符/页描述符/块描述符其结构都是基地址加属性的模式,这些基地址都是物理地址，属性包含读写执行等等：

内核页表建立过程

arch/arm64/kernel/head.S
__primary_switch:
	……    
// 使能mmu，需要关注的是加载ttbr1: adrp x2, swapper_pg_dir； msr ttbr1_el1, x2
    bl  __enable_mmu 
	…….
    adrp    x0, __PHYS_OFFSET
    blr x8

    msr sctlr_el1, x20          // disable the MMU
    isb
    bl  __create_page_tables  //创建kernel占用区域的映射

    tlbi    vmalle1             // Remove any stale TLB entries
    dsb nsh
	……
    ldr x8, =__primary_switched
    adrp    x0, __PHYS_OFFSET
    br  x8
ENDPROC(__primary_switch)




__create_page_tables:
    mov x28, lr

    adrp    x0, idmap_pg_dir
    adrp    x1, swapper_pg_dir + SWAPPER_DIR_SIZE + RESERVED_TTBR0_SIZE
    bl  __inval_cache_range
  //清除swapper_pg_dir和idmap_pg_dir
    adrp    x0, idmap_pg_dir
    adrp    x6, swapper_pg_dir + SWAPPER_DIR_SIZE + RESERVED_TTBR0_SIZE
1:  stp xzr, xzr, [x0], #16
    stp xzr, xzr, [x0], #16
    stp xzr, xzr, [x0], #16
    stp xzr, xzr, [x0], #16
    cmp x0, x6
    b.lo    1b

    mov x7, SWAPPER_MM_MMUFLAGS //页表属性
    ......
    adrp    x0, swapper_pg_dir
    mov_q   x5, KIMAGE_VADDR + TEXT_OFFSET  // 获取内核起始位置对应的虚拟地址
add x5, x5, x23         // add KASLR displacement
/*
这里是创建早期的内核页表，在开机的后续流程中这个页表将被清除重新建立
这里只建立内核代码空间的页表映射，这里的映射是按照block来映射的，一个block 2M大小
宏create_pgd_entry是创建内核起始虚拟地址在pgd中的rentry并指向下一级table PMD
符号swapper_pg_dir在vmlinux.lds.S中定义，以swapper_pg_dir为起点预留了两页内存第一页为
PGD第二页为PMD，宏create_pgd_entry的工作就是根据内核起始虚拟地址找到其在PGD中的entry
用PMD的基地址以及属性设置到这个entry中
*/
    create_pgd_entry x0, x5, x3, x6
    adrp    x6, _end            // runtime __pa(_end)
    adrp    x3, _text           // runtime __pa(_text)
    sub x6, x6, x3          // _end - _text
add x6, x6, x5          // runtime __va(_end)
//创建内核代码空间的映射
    create_block_map x0, x7, x3, x5, x6
    adrp    x0, idmap_pg_dir
    adrp    x1, swapper_pg_dir + SWAPPER_DIR_SIZE + RESERVED_TTBR0_SIZE
    dmb sy
    bl  __inval_cache_range
    ret x28
ENDPROC(__create_page_tables)

下面是第二阶段内核建立流程，下面流程中将清除之前的页表重新建立新的页表：

函数early_fixmap_init做了一项很重要的工作就是建立固定映射，固定映射区包含内核参数区（将内核参数内存区映射到这个位置），和三个page用于创建页表的时候映射PGD page/PMD page/PTE page以便通过虚拟地址访问page table。建立固定映射的各级页表是静态定义的如下
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; //linux使用的3级页表没有pud

下面函数paging_init实现了重建内核页表：

void __init paging_init(void)
{
    phys_addr_t pgd_phys = early_pgtable_alloc(); //分配一个page作为临时pgd
    pgd_t *pgd = pgd_set_fixmap(pgd_phys);//将前面分配的临时pgd page映射到FIX_PGD

    map_kernel(pgd); //从新映射内核代码区和以FIXADDR_START为起始地址的固定映射区
    map_mem(pgd);//映射一直映射内存，64位系统则是映射所有全部物理内存
    cpu_replace_ttbr1(__va(pgd_phys)); //将临时pgd_phys写入ttbr1
    memcpy(swapper_pg_dir, pgd, PGD_SIZE);//覆盖之前的pgd
    cpu_replace_ttbr1(lm_alias(swapper_pg_dir));//将swapper_pg_dir的物理地址写入ttbr1

    pgd_clear_fixmap();//清除FIX_PGD
    memblock_free(pgd_phys, PAGE_SIZE); //释放临时pgd page
    memblock_free(__pa_symbol(swapper_pg_dir) + PAGE_SIZE,
              SWAPPER_DIR_SIZE - PAGE_SIZE);//释放掉预留多余的page
}

内存节点的建立

start_kernel--->setup_arch--->bootmem_init

dummy_numa_init：为memblock.memory.regions中每一个内存区块设置内存节点编号

get_pfn_range_for_nid：计算节点的起始页帧号和结束页帧号

setup_node_data：分配节点描述结构pg_data_t并做基本初始化，后续代码详解
find_zone_movable_pfns_for_nodes：查找zone_movable的起始页帧
calculate_node_totalpages：计算每一个zone的总页数和实际页数（不包含空洞），以及内存节点的总页数
和实际页数（不包含空洞）
alloc_node_mem_map：分配struct page数组（节点中每个页对应有个struct page）并由
pgdat->node_mem_map指向该数组
free_area_init_core：初始化每个zone的起始成员，并初始化每一个zone包含页的struct page结构

内存节点分配

start_kernel--->setup_arch--->bootmem_init---> arm64_numa_init---> numa_init---> numa_register_nodes---> setup_node_data

static void __init setup_node_data(int nid, u64 start_pfn, u64 end_pfn)
{
    const size_t nd_size = roundup(sizeof(pg_data_t), SMP_CACHE_BYTES);
    u64 nd_pa;
    void *nd;
    int tnid;
	……
    nd_pa = memblock_alloc_try_nid(nd_size, SMP_CACHE_BYTES, nid); //分配内存节点管理结构pg_data_t
    nd = __va(nd_pa);
    
    tnid = early_pfn_to_nid(nd_pa >> PAGE_SHIFT);
    if (tnid != nid)
        pr_info("NODE_DATA(%d) on node %d\n", nid, tnid);

    node_data[nid] = nd; //全局数组node_data[]包含系统所有内存节点指针，通常情况下只有一个节点
    memset(NODE_DATA(nid), 0, sizeof(pg_data_t));
    NODE_DATA(nid)->node_id = nid; //设置节点编号
    NODE_DATA(nid)->node_start_pfn = start_pfn;//本节点起始页帧
    NODE_DATA(nid)->node_spanned_pages = end_pfn - start_pfn;//本节点包含的页帧数，包含空洞
}

内存zone&节点页帧数的计算

start_kernel--->setup_arch--->bootmem_init---> zone_sizes_init---> free_area_init_nodes---> free_area_init_node---> calculate_node_totalpages

static void __meminit calculate_node_totalpages(struct pglist_data *pgdat,
                        unsigned long node_start_pfn,
                        unsigned long node_end_pfn,
                        unsigned long *zones_size,
                        unsigned long *zholes_size)
{
    unsigned long realtotalpages = 0, totalpages = 0;
    enum zone_type i;

    for (i = 0; i < MAX_NR_ZONES; i++) { //遍历节点中多有zone
        struct zone *zone = pgdat->node_zones + i;
        unsigned long zone_start_pfn, zone_end_pfn;
        unsigned long size, real_size;

        size = zone_spanned_pages_in_node(pgdat->node_id, i,
                          node_start_pfn,
                          node_end_pfn,
                          &zone_start_pfn,
                          &zone_end_pfn,
                          zones_size);//计算zone的起始页帧和结束页帧以及zone包含的总页帧数
//计算去掉空洞之后的页帧数，通过查询page是否在memblock.memory.regions可知页是否为空洞
        real_size = size - zone_absent_pages_in_node(pgdat->node_id, i,
                          node_start_pfn, node_end_pfn,
                          zholes_size);
        if (size)
            zone->zone_start_pfn = zone_start_pfn;//设置zone的起始页帧
        else
            zone->zone_start_pfn = 0;
        zone->spanned_pages = size;//zone包含的页帧总数，包含空洞
        zone->present_pages = real_size;//zone的实际页帧数，不包含空洞

        totalpages += size; //系统的总页帧数
        realtotalpages += real_size;//系统实际页帧数，不包含空洞
    }

    pgdat->node_spanned_pages = totalpages;//重新设置节点管理的页帧数
    pgdat->node_present_pages = realtotalpages;//节点实际页帧数
    printk(KERN_DEBUG "On node %d totalpages: %lu\n", pgdat->node_id,
                            realtotalpages);
}

struct page数组分配
start_kernel--->setup_arch--->bootmem_init---> zone_sizes_init---> free_area_init_nodes---> free_area_init_node---> alloc_node_mem_map

static void __ref alloc_node_mem_map(struct pglist_data *pgdat)
{
    unsigned long __maybe_unused start = 0;
    unsigned long __maybe_unused offset = 0;
    
    start = pgdat->node_start_pfn & ~(MAX_ORDER_NR_PAGES - 1);
    offset = pgdat->node_start_pfn - start;
    if (!pgdat->node_mem_map) {
        unsigned long size, end;
        struct page *map;
        end = pgdat_end_pfn(pgdat);
        end = ALIGN(end, MAX_ORDER_NR_PAGES);
        size =  (end - start) * sizeof(struct page);//计算page map数组的大小
        map = alloc_remap(pgdat->node_id, size); //分配page map数组
        if (!map)
            map = memblock_virt_alloc_node_nopanic(size,
                                   pgdat->node_id);
        pgdat->node_mem_map = map + offset; //节点page map的起始叶框位置
    }
    if (pgdat == NODE_DATA(0)) {
        mem_map = NODE_DATA(0)->node_mem_map;
        if (page_to_pfn(mem_map) != pgdat->node_start_pfn)
            mem_map -= offset;
    }
}

ZONE初始化

start_kernel--->setup_arch--->bootmem_init---> zone_sizes_init---> free_area_init_nodes---> free_area_init_node---> free_area_init_core

static void __paginginit free_area_init_core(struct pglist_data *pgdat)
{
    enum zone_type j;
    int nid = pgdat->node_id;
    int ret;
    ......
    lruvec_init(node_lruvec(pgdat));

    for (j = 0; j < MAX_NR_ZONES; j++) {//遍历每一个zone初始化zone结构
        struct zone *zone = pgdat->node_zones + j;
        unsigned long size, realsize, freesize, memmap_pages;
        unsigned long zone_start_pfn = zone->zone_start_pfn;

        size = zone->spanned_pages;
        realsize = freesize = zone->present_pages;

        memmap_pages = calc_memmap_size(size, realsize);
        if (!is_highmem_idx(j)) {
            if (freesize >= memmap_pages) {
                freesize -= memmap_pages; //空闲内存数需要减去page map占用的内存
                if (memmap_pages)
                    printk(KERN_DEBUG
                           "  %s zone: %lu pages used for memmap\n",
                           zone_names[j], memmap_pages);
            } else
                pr_warn("  %s zone: %lu pages exceeds freesize %lu\n",
                    zone_names[j], memmap_pages, freesize);
        }

        if (j == 0 && freesize > dma_reserve) {
            freesize -= dma_reserve;
            printk(KERN_DEBUG "  %s zone: %lu pages reserved\n",
                    zone_names[0], dma_reserve);
        }

        if (!is_highmem_idx(j))
            nr_kernel_pages += freesize;//内核空闲页数
        else if (nr_kernel_pages > memmap_pages * 2)
            nr_kernel_pages -= memmap_pages;//page map分配在low memory
        nr_all_pages += freesize; //系统总空闲页数
        
        zone->managed_pages = is_highmem_idx(j) ? realsize : freesize;//highmem还现在处于空闲状态
#ifdef CONFIG_NUMA 
        zone->node = nid; //设置zone所属节点
#endif  
        zone->name = zone_names[j]; //” Normal”, “HighMem”,”DMA”等等
        zone->zone_pgdat = pgdat; //指向所属的节点
        spin_lock_init(&zone->lock);
        zone_seqlock_init(zone);
        zone_pcp_init(zone); //设置zone->pageset = &boot_pageset
        
        set_pageblock_order();
//分配zone->pageblock_flags 每个pageblock_order 4个bits，用于设置每个块的迁移类型
        setup_usemap(pgdat, zone, zone_start_pfn, size);
//设置zone的起始页帧，初始化伙伴系统链表等等
        ret = init_currently_empty_zone(zone, zone_start_pfn, size);
        BUG_ON(ret);
//初始化zone包含的每个页帧的page map
        memmap_init(size, nid, j, zone_start_pfn);
    }
}

内存域中每一个page的Struct page结构初始化

start_kernel--->setup_arch--->bootmem_init---> zone_sizes_init---> free_area_init_nodes---> free_area_init_node---> free_area_init_core---> memmap_init---> memmap_init_zone

start_kernel--->setup_arch--->bootmem_init---> zone_sizes_init---> free_area_init_nodes---> free_area_init_node---> free_area_init_core---> memmap_init---> memmap_init_zone

void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
        unsigned long start_pfn, enum memmap_context context)
{
    struct vmem_altmap *altmap = to_vmem_altmap(__pfn_to_phys(start_pfn));
    unsigned long end_pfn = start_pfn + size;
    pg_data_t *pgdat = NODE_DATA(nid);
    unsigned long pfn;
    unsigned long nr_initialised = 0;

    for (pfn = start_pfn; pfn < end_pfn; pfn++) {
        ......
        if (!(pfn & (pageblock_nr_pages - 1))) {//如果是块的起始页帧
            struct page *page = pfn_to_page(pfn);//根据页帧号在page map中查找page

            __init_single_page(page, pfn, zone, nid);//设置page flags和初始化一些链表
//找到也块在zone->pageblock_flags中的位置并将整块设置为MIGRATE_MOVABLE类型
            set_pageblock_migratetype(page, MIGRATE_MOVABLE);//
        } else {
            __init_single_pfn(pfn, zone, nid); //如果不是页块的起始页就只初始化struct page本身
        }
    }
}

创建zonelists与冷热页链表

5.1主要代码流程

build_zonelists ：创建ZONELIST_FALLBACK和ZONELIST_NOFALLBACK，后面细讲
pageset_init：初始化每个zone的per_cpu_pageset

mem_init: 将memblock.reserved.regions中的页标记为已分配SetPageReserved(page)，将存在于
memblock.memory.regions不存在memblock.reserved.regions中的页释放到伙伴系统。

kmem_cache_init：初始化高速缓存，后面单独章节讲解

percpu_init_late：percpu内存初始化，后面单独章节讲解

vmalloc_init：初始化vmalloc相关结构，后面单独章节讲解

kmem_cache_init_late：创建通用缓存，后面单独章节讲解

setup_per_cpu_pageset：初始化per_cpu_pageset，设置pcp->batch和pcp->high

5.2创建zonelists

static void build_zonelists(pg_data_t *pgdat)
{
    int i, node, load;
    nodemask_t used_mask;
    int local_node, prev_node;
    struct zonelist *zonelist;
    unsigned int order = current_zonelist_order;
	……
    local_node = pgdat->node_id; 
    load = nr_online_nodes;
    prev_node = local_node; 
    nodes_clear(used_mask);

    memset(node_order, 0, sizeof(node_order));
    i = 0;
//计算node与local_node的距离（分配代价），根据距离由近到远依次放到node_order[]
    while ((node = find_next_best_node(local_node, &used_mask)) >= 0) {
        if (node_distance(local_node, node) !=
            node_distance(local_node, prev_node))
            node_load[node] = load;

        prev_node = node;
        load--;
        if (order == ZONELIST_ORDER_NODE)
            build_zonelists_in_node_order(pgdat, node);
        else
            node_order[i++] = node; 
    }

if (order == ZONELIST_ORDER_ZONE) {
//创建pgdat->node_zonelists[ZONELIST_FALLBACK];
        build_zonelists_in_zone_order(pgdat, i);
    }
//创建pgdat->node_zonelists[ZONELIST_NOFALLBACK];
    build_thisnode_zonelists(pgdat);
}

创建之后如下图所示：

5.3创建冷热页链表

static void __meminit setup_zone_pageset(struct zone *zone)
{
    int cpu;
    zone->pageset = alloc_percpu(struct per_cpu_pageset); //分配per cpu pageset指针
    for_each_possible_cpu(cpu)
        zone_pageset_init(zone, cpu);//初始化每个CPU对应的struct per_cpu_pageset
}

static void __meminit zone_pageset_init(struct zone *zone, int cpu)
{
    struct per_cpu_pageset *pcp = per_cpu_ptr(zone->pageset, cpu);

    pageset_init(pcp);//初始化链表pcp->lists
    pageset_set_high_and_batch(zone, pcp);//设置batch和high，high为6 * batch
}
batch计算
static int zone_batchsize(struct zone *zone)
{   
    int batch;
    batch = zone->managed_pages / 1024;  //内存域总内存的千分之一
    if (batch * PAGE_SIZE > 512 * 1024)
        batch = (512 * 1024) / PAGE_SIZE; //不能超过512M
    batch /= 4;     //冷热页占总内存的0.25‰
    if (batch < 1)
        batch = 1;

    batch = rounddown_pow_of_two(batch + batch/2) - 1; //batch变为2的次方
        
    return batch;
	……
}

watermark设置

6.1水印设置

static void __setup_per_zone_wmarks(void)
{
	unsigned long pages_min = min_free_kbytes >> (PAGE_SHIFT - 10);
    unsigned long lowmem_pages = 0;
    struct zone *zone;
    unsigned long flags;
    //计算lowmem_pages，不包含空洞
    for_each_zone(zone) {
        if (!is_highmem(zone))
            lowmem_pages += zone->managed_pages;
    }
    for_each_zone(zone) {
        u64 tmp;
        spin_lock_irqsave(&zone->lock, flags);
// pages_min * zone->managed_pages / lowmem_pages，根据每个zone占总内存大小均摊min_free_kbytes
        tmp = (u64)pages_min * zone->managed_pages;
        do_div(tmp, lowmem_pages);
        if (is_highmem(zone)) {
            unsigned long min_pages;
            //计算highmem的min_pages不超过128 pages
            min_pages = zone->managed_pages / 1024;
            min_pages = clamp(min_pages, SWAP_CLUSTER_MAX, 128UL);
            zone->watermark[WMARK_MIN] = min_pages;
        } else {
            zone->watermark[WMARK_MIN] = tmp;
        }
		……
        zone->watermark[WMARK_LOW]  = min_wmark_pages(zone) + tmp;
        zone->watermark[WMARK_HIGH] = min_wmark_pages(zone) + tmp * 2;
        spin_unlock_irqrestore(&zone->lock, flags);
    }
calculate_totalreserve_pages();
……
}

6.2设置预留内存页

static void setup_per_zone_lowmem_reserve(void)
{
    struct pglist_data *pgdat;
    enum zone_type j, idx;
    for_each_online_pgdat(pgdat) {
        for (j = 0; j < MAX_NR_ZONES; j++) {
            struct zone *zone = pgdat->node_zones + j;
            unsigned long managed_pages = zone->managed_pages;
            zone->lowmem_reserve[j] = 0;
            idx = j;
            while (idx) {
                struct zone *lower_zone;
                idx--;
                if (sysctl_lowmem_reserve_ratio[idx] < 1)
                    sysctl_lowmem_reserve_ratio[idx] = 1;
                lower_zone = pgdat->node_zones + idx;
//为每个zone设置预留内存页用于无论如何也不能失败的内存分配
                lower_zone->lowmem_reserve[j] = managed_pages /
                    sysctl_lowmem_reserve_ratio[idx];
                managed_pages += lower_zone->managed_pages;
            }
        }
    }
    calculate_totalreserve_pages();
}

chenying126

关注

2
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
Linux 内存管理框架

目录1. 内存管理框架概览 2 1.1. 内存管理各个数据结构之间关系 2 1.2. 主要数据结构说明 3 2. MEMEBLOCK 4 2.1. memblock数据结构 4 2.2. 内存信息获取 4 2.3. MEMBLOCK函数接口 5 3. 内核页表
复制链接

扫一扫