e820初始化相关暂时不看，只看伙伴系统、slab初始化相关。e820就是探测可用内存

1、初始化pglist_data

struct pglist_data *node_data[MAX_NUMNODES] __read_mostly;

1.1、initmem_init（初始化每个node节点的管理内存大小）

arch -> x86 -> mm -> numa.c

  1. void __init initmem_init(unsigned long start_pfn, unsigned long last_pfn,
  2.                 int acpi, int k8)
  3. {
  4.     // 前后均删除代码，我们只关心k8 scan成功的情况
  5.     if (!numa_off && k8 && !k8_scan_nodes())
  6.         return;
  7. }
  9. // nodes_parsed 为初始化的时候探测到的node id，本质上是一个bitmap
  10. // 探测到一个node id，则对应node id索引的字节为1
  11. // 比如：nodes_parsed初始化为0000
  12. // 探测到的node id为0/1/3，则nodes_parsed为0111
  13. int __init k8_scan_nodes(void)
  14. {
  15.     // acpi的相关逻辑先删除，不知道是啥玩意
  16.     int i;
  18.     node_possible_map = nodes_parsed;
  20.     // 计算memnode_shift逻辑先删除，不知道干啥用的
  22.     // 遍历node_possible_map，此处本质上就是nodes_parsed
  23.     for_each_node_mask(i, node_possible_map) {
  24.         // 通过和扫描到的node内存范围和e820实际内存范围做比对
  25.         // 将实际可用(非空洞)内存加入到early_node_map中
  26.         // early_node_map就是nid和起止页框号的映射关系
  27.         e820_register_active_regions(i,
  28.                 nodes[i].start >> PAGE_SHIFT,
  29.                 nodes[i].end >> PAGE_SHIFT);
  30.         // 设置每个node的bootmem
  31.         setup_node_bootmem(i, nodes[i].start, nodes[i].end);
  32.     }
  33.     numa_init_array();
  34.     return 0;
  35. }

1.2、setup_node_bootmem（设置node的bootmem）

arch -> x86 -> mm -> numa_64.c

  1. // __pa把虚拟地址转换为物理地址
  2. // __va把虚物理地址转换为虚拟地址
  3. // reserve_early将已经分配的内存记录下来
  4. void __init setup_node_bootmem(int nodeid, unsigned long start, unsigned long end)
  5. {
  6.     // 开始页框号/终止页框号/notedata物理地址
  7.     unsigned long start_pfn, last_pfn, nodedata_phys;
  9.     // 按照页大小取整获取pgdat_size
  10.     const int pgdat_size = roundup(sizeof(pg_data_t), PAGE_SIZE);
  12.     // node id
  13.     int nid;
  15.     unsigned long bootmap_start, bootmap_pages, bootmap_size;
  16.     void *bootmap;
  18.     if (!end)
  19.         return;
  21.     /*
  22.      * Don't confuse VM with a node that doesn't have the
  23.      * minimum amount of memory:
  24.      */
  25.     if (end && (end - start) < NODE_MIN_SIZE)
  26.         return;
  28.     // start按照能够整除最大order页面大小取整
  29.     start = roundup(start, ZONE_ALIGN);
  30.     start_pfn = start >> PAGE_SHIFT;
  31.     last_pfn = end >> PAGE_SHIFT;
  33.     // 给pgdata分配内存，静态分配的是指针
  34.     // 此处需要分配实际内存
  35.     node_data[nodeid] = early_node_mem(nodeid, start, end, pgdat_size,
  36.                        SMP_CACHE_BYTES);
  37.     if (node_data[nodeid] == NULL)
  38.         return;
  40.     // 获取分配地址的物理地址
  41.     nodedata_phys = __pa(node_data[nodeid]);
  42.     reserve_early(nodedata_phys, nodedata_phys + pgdat_size, "NODE_DATA");
  44.     // 根据物理地址获取node id
  45.     // nid可能会和node id不一样
  46.     // 因为会优先分配到node id为0的id上面
  47.     nid = phys_to_nid(nodedata_phys);
  49.     // 初始化pgdata
  50.     memset(NODE_DATA(nodeid), 0, sizeof(pg_data_t));
  51.     NODE_DATA(nodeid)->node_id = nodeid;
  52.     NODE_DATA(nodeid)->node_start_pfn = start_pfn;
  53.     NODE_DATA(nodeid)->node_spanned_pages = last_pfn - start_pfn;
  54.     NODE_DATA(nodeid)->bdata = &bootmem_node_data[nodeid];
  56.     // 计算给定数目的页框需要多大的bitmap size
  57.     bootmap_pages = bootmem_bootmap_pages(last_pfn - start_pfn);
  58.     // 将bootmap其实地址在node data之后按照page_size对齐
  59.     bootmap_start = roundup(nodedata_phys + pgdat_size, PAGE_SIZE);
  60.     // 给bootmap分配内存
  61.     bootmap = early_node_mem(nodeid, bootmap_start, end,
  62.                  bootmap_pages<<PAGE_SHIFT, PAGE_SIZE);
  63.     if (bootmap == NULL)  {
  64.         free_early(nodedata_phys, nodedata_phys + pgdat_size);
  65.         node_data[nodeid] = NULL;
  66.         return;
  67.     }
  68.     bootmap_start = __pa(bootmap);
  69.     reserve_early(bootmap_start, bootmap_start+(bootmap_pages<<PAGE_SHIFT),
  70.             "BOOTMAP");
  72.     // 初始化bootmem
  73.     bootmap_size = init_bootmem_node(NODE_DATA(nodeid),
  74.                      bootmap_start >> PAGE_SHIFT,
  75.                      start_pfn, last_pfn);
  77.     // 根据物理地址获取node id
  78.     // nid可能会和node id不一样
  79.     // 因为会优先分配到node id为0的id上面
  80.     nid = phys_to_nid(bootmap_start);
  82.     free_bootmem_with_active_regions(nodeid, end);
  84.     // 设置node online
  85.     node_set_online(nodeid);
  86. }
  88. // early_node_mem为早期分配内存的函数
  89. // 本质上是基于e820进行的内存分配
  90. // start/end为该node管理的内存范围
  91. // size为要分配的大小
  92. // align为对其大小
  93. static void * __init early_node_mem(int nodeid, unsigned long start,
  94.                     unsigned long end, unsigned long size,
  95.                     unsigned long align)
  96. {
  97.     unsigned long mem;
  99.     if (start < (MAX_DMA_PFN<<PAGE_SHIFT))
  100.         start = MAX_DMA_PFN<<PAGE_SHIFT;
  101.     if (start < (MAX_DMA32_PFN<<PAGE_SHIFT) &&
  102.         end > (MAX_DMA32_PFN<<PAGE_SHIFT))
  103.         start = MAX_DMA32_PFN<<PAGE_SHIFT;
  104.     mem = find_e820_area(start, end, size, align);
  105.     if (mem != -1L)
  106.         return __va(mem);
  108.     end = max_pfn_mapped << PAGE_SHIFT;
  109.     if (end > (MAX_DMA32_PFN<<PAGE_SHIFT))
  110.         start = MAX_DMA32_PFN<<PAGE_SHIFT;
  111.     else
  112.         start = MAX_DMA_PFN<<PAGE_SHIFT;
  113.     mem = find_e820_area(start, end, size, align);
  114.     if (mem != -1L)
  115.         return __va(mem);
  116.     return NULL;
  117. }

1.3、init_bootmem_node（初始化bootmem核心函数）

  1. /**
  2.  * init_bootmem_node - register a node as boot memory
  3.  * @pgdat: node to register
  4.  * @freepfn: pfn where the bitmap for this node is to be placed
  5.  * @startpfn: first pfn on the node
  6.  * @endpfn: first pfn after the node
  7.  *
  8.  * Returns the number of bytes needed to hold the bitmap for this node.
  9.  */
  10. unsigned long __init init_bootmem_node(pg_data_t *pgdat, unsigned long freepfn,
  11.                 unsigned long startpfn, unsigned long endpfn)
  12. {
  13.     return init_bootmem_core(pgdat->bdata, freepfn, startpfn, endpfn);
  14. }
  16. static unsigned long __init init_bootmem_core(bootmem_data_t *bdata,
  17.     unsigned long mapstart, unsigned long start, unsigned long end)
  18. {
  19.     unsigned long mapsize;
  21.     // 本函数在bootmem模式下啥也不干
  22.     mminit_validate_memmodel_limits(&start, &end);
  24.     // 初始化bdata值
  25.     // node_bootmem_map为数组起始地址
  26.     bdata->node_bootmem_map = phys_to_virt(PFN_PHYS(mapstart));
  27.     bdata->node_min_pfn = start;
  28.     bdata->node_low_pfn = end;
  30.     // 将bdata链接到bdata_list
  31.     link_bootmem(bdata);
  32.     mapsize = bootmap_bytes(end - start);
  33.     memset(bdata->node_bootmem_map, 0xff, mapsize);
  34.     return mapsize;
  35. }

1.4、free_bootmem_with_active_regions（释放可用的page到bootmem）

  1. void __init free_bootmem_with_active_regions(int nid, unsigned long max_low_pfn)
  2. {
  3.     int i;
  5.     // 遍历给定nid的所有range
  6.     for_each_active_range_index_in_nid(i, nid) {
  7.         unsigned long size_pages = 0;
  8.         unsigned long end_pfn = early_node_map[i].end_pfn;
  10.         if (early_node_map[i].start_pfn >= max_low_pfn)
  11.             continue;
  13.         if (end_pfn > max_low_pfn)
  14.             end_pfn = max_low_pfn;
  16.         size_pages = end_pfn - early_node_map[i].start_pfn;
  18.         // 释放给定起始位置和大小的页面
  19.         free_bootmem_node(NODE_DATA(early_node_map[i].nid),
  20.                 PFN_PHYS(early_node_map[i].start_pfn),
  21.                 size_pages << PAGE_SHIFT);
  22.     }
  23. }
  25. void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
  26.                   unsigned long size)
  27. {
  28.     unsigned long start, end;
  29.     kmemleak_free_part(__va(physaddr), size);
  30.     start = PFN_UP(physaddr);
  31.     end = PFN_DOWN(physaddr + size);
  32.     mark_bootmem_node(pgdat->bdata, start, end, 0, 0);
  33. }

2、初始化pg_data_t和zone相关数据结构

arch -> x86 -> mm -> int_64.c

  1. void __init paging_init(void)
  2. {
  3.     unsigned long max_zone_pfns[MAX_NR_ZONES];
  5.     memset(max_zone_pfns, 0, sizeof(max_zone_pfns));
  6.     max_zone_pfns[ZONE_DMA] = MAX_DMA_PFN;
  7.     max_zone_pfns[ZONE_DMA32] = MAX_DMA32_PFN;
  8.     max_zone_pfns[ZONE_NORMAL] = max_pfn;
  10.     // ??????,先待定
  11.     sparse_memory_present_with_active_regions(MAX_NUMNODES);
  12.     sparse_init();
  14.     // 此函数当前啥也不干，跳过
  15.     node_clear_state(0, N_NORMAL_MEMORY);
  17.     free_area_init_nodes(max_zone_pfns);
  18. }
  20. // max_zone_pfn是一个数组地址，代表每个zone最大的页框号
  21. // {10, 20, 40} 则代表:
  22. // ZONE_DMA最大10个页框
  23. // ZONE_DMA32最大20个页框
  24. // ZONE_NORMAL最大40个页框
  25. void __init free_area_init_nodes(unsigned long *max_zone_pfn)
  26. {
  27.     unsigned long nid;
  28.     int i;
  30.     // 按照start_pfn给early_node_map排序
  31.     sort_node_map();
  33.     // 记录不同zone的边界
  34.     memset(arch_zone_lowest_possible_pfn, 0,
  35.                 sizeof(arch_zone_lowest_possible_pfn));
  36.     memset(arch_zone_highest_possible_pfn, 0,
  37.                 sizeof(arch_zone_highest_possible_pfn));
  39.     // find_min_pfn_with_active_regions 遍历所有的 early_node_map 元素
  40.     // 找到最小的start_pfn
  41.     arch_zone_lowest_possible_pfn[0] = find_min_pfn_with_active_regions();
  42.     // max_zone_pfn[0] 为 MAX_DMA_PFN
  43.     arch_zone_highest_possible_pfn[0] = max_zone_pfn[0];
  44.     for (i = 1; i < MAX_NR_ZONES; i++) {
  45.         if (i == ZONE_MOVABLE)
  46.             continue;
  47.         arch_zone_lowest_possible_pfn[i] =
  48.             arch_zone_highest_possible_pfn[i-1];
  49.         arch_zone_highest_possible_pfn[i] =
  50.             max(max_zone_pfn[i], arch_zone_lowest_possible_pfn[i]);
  51.     }
  52.     arch_zone_lowest_possible_pfn[ZONE_MOVABLE] = 0;
  53.     arch_zone_highest_possible_pfn[ZONE_MOVABLE] = 0;
  54.     // 经过上述代码，则arch_zone_lowest_possible_pfn/arch_zone_highest_possible_pfn
  55.     // 可以有以下情况
  56.     // arch_zone_lowest_possible_pfn  {1, 4, 6}
  57.     // arch_zone_highest_possible_pfn {4, 6, 8}
  58.     // DMA pfn {1, 4}, DMA_32 pfn {4, 6}, NORMAL pfn {6, 8}
  60.     // 计算每个node movable 内存区间的起始 pfn
  61.     memset(zone_movable_pfn, 0, sizeof(zone_movable_pfn));
  62.     find_zone_movable_pfns_for_nodes(zone_movable_pfn);
  64.     // print mem 代码删除
  66.     // debug用，跳过
  67.     mminit_verify_pageflags_layout();
  69.     // 设置最大的node id
  70.     setup_nr_node_ids();
  72.     // 遍历所有在线的node
  73.     // 进行zone的初始化
  74.     for_each_online_node(nid) {
  75.         pg_data_t *pgdat = NODE_DATA(nid);
  76.         free_area_init_node(nid, NULL, find_min_pfn_for_node(nid), NULL);
  77.         if (pgdat->node_present_pages)
  78.             node_set_state(nid, N_HIGH_MEMORY);
  79.         check_for_regular_memory(pgdat);
  80.     }
  81. }
  83. void __paginginit free_area_init_node(int nid, unsigned long *zones_size,
  84.         unsigned long node_start_pfn, unsigned long *zholes_size)
  85. {
  86.     pg_data_t *pgdat = NODE_DATA(nid);
  87.     pgdat->node_id = nid;
  88.     pgdat->node_start_pfn = node_start_pfn;
  90.     // 计算所有页。包括包含hole和不包含hole
  91.     // 填充pgdat->node_spanned_pages和pgdat->node_present_pages
  92.     calculate_node_totalpages(pgdat, zones_size, zholes_size);
  94.     // 给node_mem_map分配内存，使用bootmem内存分配器
  95.     // 本质上是分配该node所有page的数组
  96.     alloc_node_mem_map(pgdat);
  98.     // 填充zone
  99.     free_area_init_core(pgdat, zones_size, zholes_size);
  100. }

2.1、free_area_init_core（核心逻辑）

  1. // 目前看zones_size/zholes_size均为NULL
  2. static void __paginginit free_area_init_core(struct pglist_data *pgdat,
  3.         unsigned long *zones_size, unsigned long *zholes_size)
  4. {
  5.     enum zone_type j;
  6.     int nid = pgdat->node_id;
  7.     unsigned long zone_start_pfn = pgdat->node_start_pfn;
  8.     int ret;
  10.     // 初始化node_size_lock
  11.     pgdat_resize_init(pgdat);
  13.     pgdat->nr_zones = 0;
  14.     init_waitqueue_head(&pgdat->kswapd_wait);
  15.     pgdat->kswapd_max_order = 0;
  17.     // cgroup先忽略
  18.     pgdat_page_cgroup_init(pgdat);
  20.     for (j = 0; j < MAX_NR_ZONES; j++) {
  21.         struct zone *zone = pgdat->node_zones + j;
  22.         unsigned long size, realsize, memmap_pages;
  23.         enum lru_list l;
  25.         // 分别计算该zone的所有页面和不包含hole的页面
  26.         // size指的是页框号数量
  27.         size = zone_spanned_pages_in_node(nid, j, zones_size);
  28.         realsize = size - zone_absent_pages_in_node(nid, j,
  29.                                 zholes_size);
  31.         // 计算所有page需要的内存大小
  32.         memmap_pages = PAGE_ALIGN(size * sizeof(struct page)) >> PAGE_SHIFT;
  33.         // 此处考虑了内存小的情况，我们此处不考虑，代码已删除
  35.         // 除去dma预留
  36.         if (j == 0 && realsize > dma_reserve) {
  37.             realsize -= dma_reserve;
  38.         }
  40.         // nr_kernel_pages/nr_all_pages分别++
  41.         if (!is_highmem_idx(j))
  42.             // 不配置highmem则内核可用页++
  43.             nr_kernel_pages/ += realsize;
  44.         nr_all_pages += realsize;
  46.         zone->spanned_pages = size;
  47.         zone->present_pages = realsize;
  48.         zone->node = nid;
  49.         // 超过这么多数量的可回收页面，才进行页面回收
  50.         zone->min_unmapped_pages = (realsize*sysctl_min_unmapped_ratio) / 100;
  51.         // 超过这么多可回收的slab页面才进行回收
  52.         zone->min_slab_pages = (realsize * sysctl_min_slab_ratio) / 100;
  53.         zone->name = zone_names[j];
  54.         spin_lock_init(&zone->lock);
  55.         spin_lock_init(&zone->lru_lock);
  57.         // 内存热插拔相关
  58.         zone_seqlock_init(zone);
  60.         zone->zone_pgdat = pgdat;
  61.         zone->prev_priority = DEF_PRIORITY;
  63.         // ？？？？？？
  64.         zone_pcp_init(zone);
  66.         // 初始化一坨坨变量
  67.         for_each_lru(l) {
  68.             INIT_LIST_HEAD(&zone->lru[l].list);
  69.             zone->reclaim_stat.nr_saved_scan[l] = 0;
  70.         }
  71.         zone->reclaim_stat.recent_rotated[0] = 0;
  72.         zone->reclaim_stat.recent_rotated[1] = 0;
  73.         zone->reclaim_stat.recent_scanned[0] = 0;
  74.         zone->reclaim_stat.recent_scanned[1] = 0;
  75.         zap_zone_vm_stats(zone);
  76.         zone->flags = 0;
  77.         if (!size)
  78.             continue;
  80.         // ？？？？？？
  81.         set_pageblock_order(pageblock_default_order());
  82.         setup_usemap(pgdat, zone, size);
  84.         // 初始化其实页框号和free_list链表
  85.         ret = init_currently_empty_zone(zone, zone_start_pfn,
  86.                         size, MEMMAP_EARLY);
  88.         // 初始化page
  89.         memmap_init(size, nid, j, zone_start_pfn);
  90.         zone_start_pfn += size;
  91.     }
  92. }

2.2、helper func

2.2.1、memmap_init_zone（初始化所有预留的页面）

  1. /*
  2.  * Initially all pages are reserved - free ones are freed
  3.  * up by free_all_bootmem() once the early boot process is
  4.  * done. Non-atomic initialization, single-pass.
  5.  */
  6. void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
  7.         unsigned long start_pfn, enum memmap_context context)
  8. {
  9.     struct page *page;
  10.     unsigned long end_pfn = start_pfn + size;
  11.     unsigned long pfn;
  12.     struct zone *z;
  14.     if (highest_memmap_pfn < end_pfn - 1)
  15.         highest_memmap_pfn = end_pfn - 1;
  17.     z = &NODE_DATA(nid)->node_zones[zone];
  18.     for (pfn = start_pfn; pfn < end_pfn; pfn++) {
  19.         /*
  20.          * There can be holes in boot-time mem_map[]s
  21.          * handed to this function.  They do not
  22.          * exist on hotplugged memory.
  23.          */
  24.         if (context == MEMMAP_EARLY) {
  25.             if (!early_pfn_valid(pfn))
  26.                 continue;
  27.             if (!early_pfn_in_nid(pfn, nid))
  28.                 continue;
  29.         }
  30.         page = pfn_to_page(pfn);
  32.         // 设置page flags，zone/node/section
  33.         set_page_links(page, zone, nid, pfn);
  35.         // 一些校验
  36.         mminit_verify_page_links(page, zone, nid, pfn);
  38.         // 设置page->_count为1
  39.         init_page_count(page);
  41.         // 设置page->mapcount为1
  42.         reset_page_mapcount(page);
  44.         SetPageReserved(page);
  45.         /*
  46.          * Mark the block movable so that blocks are reserved for
  47.          * movable at startup. This will force kernel allocations
  48.          * to reserve their blocks rather than leaking throughout
  49.          * the address space during boot when many long-lived
  50.          * kernel allocations are made. Later some blocks near
  51.          * the start are marked MIGRATE_RESERVE by
  52.          * setup_zone_migrate_reserve()
  53.          *
  54.          * bitmap is created for zone's valid pfn range. but memmap
  55.          * can be created for invalid pages (for alignment)
  56.          * check here not to call set_pageblock_migratetype() against
  57.          * pfn out of zone.
  58.          */
  59.         if ((z->zone_start_pfn <= pfn)
  60.             && (pfn < z->zone_start_pfn + z->spanned_pages)
  61.             && !(pfn & (pageblock_nr_pages - 1)))
  62.             set_pageblock_migratetype(page, MIGRATE_MOVABLE);
  64.         // 初始化lru
  65.         INIT_LIST_HEAD(&page->lru);
  66. #ifdef WANT_PAGE_VIRTUAL
  67.         /* The shift won't overflow because ZONE_NORMAL is below 4G. */
  68.         if (!is_highmem_idx(zone))
  69.             set_page_address(page, __va(pfn << PAGE_SHIFT));
  70. #endif
  71.     }
  72. }

2.2.2、find_zone_movable_pfns_for_nodes（看不懂啊）

  1. /*
  2.  * Find the PFN the Movable zone begins in each node. Kernel memory
  3.  * is spread evenly between nodes as long as the nodes have enough
  4.  * memory. When they don't, some nodes will have more kernelcore than
  5.  * others
  6.  */
  7. static void __init find_zone_movable_pfns_for_nodes(unsigned long *movable_pfn)
  8. {
  9.     int i, nid;
  10.     unsigned long usable_startpfn;
  11.     unsigned long kernelcore_node, kernelcore_remaining;
  12.     /* save the state before borrow the nodemask */
  13.     nodemask_t saved_node_state = node_states[N_HIGH_MEMORY];
  14.     unsigned long totalpages = early_calculate_totalpages();
  15.     int usable_nodes = nodes_weight(node_states[N_HIGH_MEMORY]);
  17.     /*
  18.      * If movablecore was specified, calculate what size of
  19.      * kernelcore that corresponds so that memory usable for
  20.      * any allocation type is evenly spread. If both kernelcore
  21.      * and movablecore are specified, then the value of kernelcore
  22.      * will be used for required_kernelcore if it's greater than
  23.      * what movablecore would have allowed.
  24.      */
  25.     if (required_movablecore) {
  26.         unsigned long corepages;
  28.         /*
  29.          * Round-up so that ZONE_MOVABLE is at least as large as what
  30.          * was requested by the user
  31.          */
  32.         required_movablecore =
  33.             roundup(required_movablecore, MAX_ORDER_NR_PAGES);
  34.         corepages = totalpages - required_movablecore;
  36.         required_kernelcore = max(required_kernelcore, corepages);
  37.     }
  40.     /* If kernelcore was not specified, there is no ZONE_MOVABLE */
  41.     if (!required_kernelcore)
  42.         goto out;
  44.     /* usable_startpfn is the lowest possible pfn ZONE_MOVABLE can be at */
  45.     find_usable_zone_for_movable();
  46.     usable_startpfn = arch_zone_lowest_possible_pfn[movable_zone];
  48. restart:
  49.     /* Spread kernelcore memory as evenly as possible throughout nodes */
  50.     kernelcore_node = required_kernelcore / usable_nodes;
  51.     for_each_node_state(nid, N_HIGH_MEMORY) {
  52.         /*
  53.          * Recalculate kernelcore_node if the division per node
  54.          * now exceeds what is necessary to satisfy the requested
  55.          * amount of memory for the kernel
  56.          */
  57.         if (required_kernelcore < kernelcore_node)
  58.             kernelcore_node = required_kernelcore / usable_nodes;
  60.         /*
  61.          * As the map is walked, we track how much memory is usable
  62.          * by the kernel using kernelcore_remaining. When it is
  63.          * 0, the rest of the node is usable by ZONE_MOVABLE
  64.          */
  65.         kernelcore_remaining = kernelcore_node;
  67.         /* Go through each range of PFNs within this node */
  68.         for_each_active_range_index_in_nid(i, nid) {
  69.             unsigned long start_pfn, end_pfn;
  70.             unsigned long size_pages;
  72.             start_pfn = max(early_node_map[i].start_pfn,
  73.                         zone_movable_pfn[nid]);
  74.             end_pfn = early_node_map[i].end_pfn;
  75.             if (start_pfn >= end_pfn)
  76.                 continue;
  78.             /* Account for what is only usable for kernelcore */
  79.             if (start_pfn < usable_startpfn) {
  80.                 unsigned long kernel_pages;
  81.                 kernel_pages = min(end_pfn, usable_startpfn)
  82.                                 - start_pfn;
  84.                 kernelcore_remaining -= min(kernel_pages,
  85.                             kernelcore_remaining);
  86.                 required_kernelcore -= min(kernel_pages,
  87.                             required_kernelcore);
  89.                 /* Continue if range is now fully accounted */
  90.                 if (end_pfn <= usable_startpfn) {
  92.                     /*
  93.                      * Push zone_movable_pfn to the end so
  94.                      * that if we have to rebalance
  95.                      * kernelcore across nodes, we will
  96.                      * not double account here
  97.                      */
  98.                     zone_movable_pfn[nid] = end_pfn;
  99.                     continue;
  100.                 }
  101.                 start_pfn = usable_startpfn;
  102.             }
  104.             /*
  105.              * The usable PFN range for ZONE_MOVABLE is from
  106.              * start_pfn->end_pfn. Calculate size_pages as the
  107.              * number of pages used as kernelcore
  108.              */
  109.             size_pages = end_pfn - start_pfn;
  110.             if (size_pages > kernelcore_remaining)
  111.                 size_pages = kernelcore_remaining;
  112.             zone_movable_pfn[nid] = start_pfn + size_pages;
  114.             /*
  115.              * Some kernelcore has been met, update counts and
  116.              * break if the kernelcore for this node has been
  117.              * satisified
  118.              */
  119.             required_kernelcore -= min(required_kernelcore,
  120.                                 size_pages);
  121.             kernelcore_remaining -= size_pages;
  122.             if (!kernelcore_remaining)
  123.                 break;
  124.         }
  125.     }
  127.     /*
  128.      * If there is still required_kernelcore, we do another pass with one
  129.      * less node in the count. This will push zone_movable_pfn[nid] further
  130.      * along on the nodes that still have memory until kernelcore is
  131.      * satisified
  132.      */
  133.     usable_nodes--;
  134.     if (usable_nodes && required_kernelcore > usable_nodes)
  135.         goto restart;
  137.     /* Align start of ZONE_MOVABLE on all nids to MAX_ORDER_NR_PAGES */
  138.     for (nid = 0; nid < MAX_NUMNODES; nid++)
  139.         zone_movable_pfn[nid] =
  140.             roundup(zone_movable_pfn[nid], MAX_ORDER_NR_PAGES);
  142. out:
  143.     /* restore the node_state */
  144.     node_states[N_HIGH_MEMORY] = saved_node_state;
  145. }

3、构建zonelist

  1. void build_all_zonelists(void)
  2. {
  3.     // 默认可以认为按照ZONELIST_ORDER_NODE来排序
  4.     set_zonelist_order();
  6.     if (system_state == SYSTEM_BOOTING) {
  7.         __build_all_zonelists(NULL);
  8.         mminit_verify_zonelist();
  9.         cpuset_init_current_mems_allowed();
  10.     } else {
  11.         /* we have to stop all cpus to guarantee there is no user
  12.            of zonelist */
  13.         stop_machine(__build_all_zonelists, NULL, NULL);
  14.         /* cpuset refresh routine should be here */
  15.     }
  16.     vm_total_pages = nr_free_pagecache_pages();
  17.     /*
  18.      * Disable grouping by mobility if the number of pages in the
  19.      * system is too low to allow the mechanism to work. It would be
  20.      * more accurate, but expensive to check per-zone. This check is
  21.      * made on memory-hotadd so a system can start with mobility
  22.      * disabled and enable it later
  23.      */
  24.     if (vm_total_pages < (pageblock_nr_pages * MIGRATE_TYPES))
  25.         page_group_by_mobility_disabled = 1;
  26.     else
  27.         page_group_by_mobility_disabled = 0;
  28. }
  30. static int __build_all_zonelists(void *dummy)
  31. {
  32.     int nid;
  33.     int cpu;
  35.     memset(node_load, 0, sizeof(node_load));
  36.     for_each_online_node(nid) {
  37.         pg_data_t *pgdat = NODE_DATA(nid);
  38.         build_zonelists(pgdat);
  39.         build_zonelist_cache(pgdat);
  40.     }
  41.     /*
  42.      * Initialize the boot_pagesets that are going to be used
  43.      * for bootstrapping processors. The real pagesets for
  44.      * each zone will be allocated later when the per cpu
  45.      * allocator is available.
  46.      *
  47.      * boot_pagesets are used also for bootstrapping offline
  48.      * cpus if the system is already booted because the pagesets
  49.      * are needed to initialize allocators on a specific cpu too.
  50.      * F.e. the percpu allocator needs the page allocator which
  51.      * needs the percpu allocator in order to allocate its pagesets
  52.      * (a chicken-egg dilemma).
  53.      */
  54.     for_each_possible_cpu(cpu)
  55.         setup_pageset(&per_cpu(boot_pageset, cpu), 0);
  57.     return 0;
  58. }

3.1、helper func

3.1.1、build_zonelists

static int node_order[MAX_NUMNODES]

  1. static void build_zonelists(pg_data_t *pgdat)
  2. {
  3.     int j, node, load;
  4.     enum zone_type i;
  5.     nodemask_t used_mask;
  6.     int local_node, prev_node;
  7.     struct zonelist *zonelist;
  8.     int order = current_zonelist_order;
  10.     for (i = 0; i < MAX_ZONELISTS; i++) {
  11.         zonelist = pgdat->node_zonelists + i;
  12.         zonelist->_zonerefs[0].zone = NULL;
  13.         zonelist->_zonerefs[0].zone_idx = 0;
  14.     }
  16.     local_node = pgdat->node_id;
  17.     load = nr_online_nodes;
  18.     prev_node = local_node;
  19.     nodes_clear(used_mask);
  21.     memset(node_order, 0, sizeof(node_order));
  22.     j = 0;
  24.     // 依次寻找距离local_node最近的node
  25.     while ((node = find_next_best_node(local_node, &used_mask)) >= 0) {
  26.         int distance = node_distance(local_node, node);
  28.         /*
  29.          * If another node is sufficiently far away then it is better
  30.          * to reclaim pages in a zone before going off node.
  31.          */
  32.         if (distance > RECLAIM_DISTANCE)
  33.             zone_reclaim_mode = 1;
  35.         /*
  36.          * We don't want to pressure a particular node.
  37.          * So adding penalty to the first node in same
  38.          * distance group to make it round-robin.
  39.          */
  40.         if (distance != node_distance(local_node, prev_node))
  41.             node_load[node] = load;
  43.         prev_node = node;
  44.         load--;
  45.         if (order == ZONELIST_ORDER_NODE)
  46.             build_zonelists_in_node_order(pgdat, node);
  47.         else
  48.             node_order[j++] = node;    /* remember order */
  49.     }
  51.     if (order == ZONELIST_ORDER_ZONE) {
  52.         /* calculate node order -- i.e., DMA last! */
  53.         build_zonelists_in_zone_order(pgdat, j);
  54.     }
  56.     build_thisnode_zonelists(pgdat);
  57. }
  1. /*
  2.  * Build zonelists ordered by node and zones within node.
  3.  * This results in maximum locality--normal zone overflows into local
  4.  * DMA zone, if any--but risks exhausting DMA zone.
  5.  */
  6. static void build_zonelists_in_node_order(pg_data_t *pgdat, int node)
  7. {
  8.     int j;
  9.     struct zonelist *zonelist;
  11.     zonelist = &pgdat->node_zonelists[0];
  12.     for (j = 0; zonelist->_zonerefs[j].zone != NULL; j++)
  13.         ;
  14.     j = build_zonelists_node(NODE_DATA(node), zonelist, j,
  15.                             MAX_NR_ZONES - 1);
  16.     zonelist->_zonerefs[j].zone = NULL;
  17.     zonelist->_zonerefs[j].zone_idx = 0;
  18. }
  1. /*
  2.  * Build gfp_thisnode zonelists
  3.  */
  4. static void build_thisnode_zonelists(pg_data_t *pgdat)
  5. {
  6.     int j;
  7.     struct zonelist *zonelist;
  9.     zonelist = &pgdat->node_zonelists[1];
  10.     j = build_zonelists_node(pgdat, zonelist, 0, MAX_NR_ZONES - 1);
  11.     zonelist->_zonerefs[j].zone = NULL;
  12.     zonelist->_zonerefs[j].zone_idx = 0;
  13. }
  1. /**
  2.  * find_next_best_node - find the next node that should appear in a given node's fallback list
  3.  * @node: node whose fallback list we're appending
  4.  * @used_node_mask: nodemask_t of already used nodes
  5.  *
  6.  * We use a number of factors to determine which is the next node that should
  7.  * appear on a given node's fallback list.  The node should not have appeared
  8.  * already in @node's fallback list, and it should be the next closest node
  9.  * according to the distance array (which contains arbitrary distance values
  10.  * from each node to each node in the system), and should also prefer nodes
  11.  * with no CPUs, since presumably they'll have very little allocation pressure
  12.  * on them otherwise.
  13.  * It returns -1 if no node is found.
  14.  */
  15. static int find_next_best_node(int node, nodemask_t *used_node_mask)
  16. {
  17.     int n, val;
  18.     int min_val = INT_MAX;
  19.     int best_node = -1;
  20.     const struct cpumask *tmp = cpumask_of_node(0);
  22.     // 先返回local _node
  23.     if (!node_isset(node, *used_node_mask)) {
  24.         node_set(node, *used_node_mask);
  25.         return node;
  26.     }
  28.     for_each_node_state(n, N_HIGH_MEMORY) {
  30.         // 设置过则不再设置
  31.         if (node_isset(n, *used_node_mask))
  32.             continue;
  34.         /* Use the distance array to find the distance */
  35.         val = node_distance(node, n);
  37.         /* Penalize nodes under us ("prefer the next node") */
  38.         val += (n < node);
  40.         /* Give preference to headless and unused nodes */
  41.         tmp = cpumask_of_node(n);
  42.         if (!cpumask_empty(tmp))
  43.             val += PENALTY_FOR_NODE_WITH_CPUS;
  45.         /* Slight preference for less loaded node */
  46.         val *= (MAX_NODE_LOAD*MAX_NUMNODES);
  47.         val += node_load[n];
  49.         if (val < min_val) {
  50.             min_val = val;
  51.             best_node = n;
  52.         }
  53.     }
  55.     if (best_node >= 0)
  56.         node_set(best_node, *used_node_mask);
  57.     return best_node;
  58. }

4、初始化伙伴系统

  1. static unsigned long __init free_all_bootmem_core(bootmem_data_t *bdata)
  2. {
  3.     int aligned;
  4.     struct page *page;
  5.     unsigned long start, end, pages, count = 0;
  7.     if (!bdata->node_bootmem_map)
  8.         return 0;
  10.     start = bdata->node_min_pfn;
  11.     end = bdata->node_low_pfn;
  13.     aligned = !(start & (BITS_PER_LONG - 1));
  15.     while (start < end) {
  16.         unsigned long *map, idx, vec;
  18.         map = bdata->node_bootmem_map;
  19.         idx = start - bdata->node_min_pfn;
  20.         vec = ~map[idx / BITS_PER_LONG];
  22.         if (aligned && vec == ~0UL && start + BITS_PER_LONG < end) {
  23.             int order = ilog2(BITS_PER_LONG);
  24.             __free_pages_bootmem(pfn_to_page(start), order);
  25.             count += BITS_PER_LONG;
  26.         } else {
  27.             unsigned long off = 0;
  28.             while (vec && off < BITS_PER_LONG) {
  29.                 if (vec & 1) {
  30.                     page = pfn_to_page(start + off);
  31.                     __free_pages_bootmem(page, 0);
  32.                     count++;
  33.                 }
  34.                 vec >>= 1;
  35.                 off++;
  36.             }
  37.         }
  38.         start += BITS_PER_LONG;
  39.     }
  41.     page = virt_to_page(bdata->node_bootmem_map);
  42.     pages = bdata->node_low_pfn - bdata->node_min_pfn;
  43.     pages = bootmem_bootmap_pages(pages);
  44.     count += pages;
  45.     while (pages--)
  46.         __free_pages_bootmem(page++, 0);
  47.     return count;
  48. }
  50. void __meminit __free_pages_bootmem(struct page *page, unsigned int order)
  51. {
  52.     if (order == 0) {
  53.         __ClearPageReserved(page);
  54.         set_page_count(page, 0);
  55.         set_page_refcounted(page);
  56.         __free_page(page);
  57.     } else {
  58.         int loop;
  60.         prefetchw(page);
  61.         for (loop = 0; loop < BITS_PER_LONG; loop++) {
  62.             struct page *p = &page[loop];
  64.             if (loop + 1 < BITS_PER_LONG)
  65.                 prefetchw(p + 1);
  66.             __ClearPageReserved(p);
  67.             set_page_count(p, 0);
  68.         }
  69.         set_page_refcounted(page);
  70.         __free_pages(page, order);
  71.     }
  72. }
  74. void __free_pages(struct page *page, unsigned int order)
  75. {
  76.     if (put_page_testzero(page)) {
  77.         if (order == 0)
  78.             free_hot_cold_page(page, 0);
  79.         else
  80.             __free_pages_ok(page, order);
  81.     }
  82. }
  84. static void __free_pages_ok(struct page *page, unsigned int order)
  85. {
  86.     unsigned long flags;
  87.     int i;
  88.     int bad = 0;
  89.     int wasMlocked = __TestClearPageMlocked(page);
  91.     trace_mm_page_free_direct(page, order);
  92.     kmemcheck_free_shadow(page, order);
  94.     for (i = 0 ; i < (1 << order) ; ++i)
  95.         bad += free_pages_check(page + i);
  96.     if (bad)
  97.         return;
  99.     if (!PageHighMem(page)) {
  100.         debug_check_no_locks_freed(page_address(page),PAGE_SIZE<<order);
  101.         debug_check_no_obj_freed(page_address(page),
  102.                        PAGE_SIZE << order);
  103.     }
  104.     arch_free_page(page, order);
  105.     kernel_map_pages(page, 1 << order, 0);
  107.     local_irq_save(flags);
  108.     if (unlikely(wasMlocked))
  109.         free_page_mlock(page);
  110.     __count_vm_events(PGFREE, 1 << order);
  111.     free_one_page(page_zone(page), page, order,
  112.                     get_pageblock_migratetype(page));
  113.     local_irq_restore(flags);
  114. }

4.1、free_one_page（core func）

  1. static void free_one_page(struct zone *zone, struct page *page, int order,
  2.                 int migratetype)
  3. {
  4.     spin_lock(&zone->lock);
  5.     zone->all_unreclaimable = 0;
  6.     zone->pages_scanned = 0;
  8.     __mod_zone_page_state(zone, NR_FREE_PAGES, 1 << order);
  9.     __free_one_page(page, zone, order, migratetype);
  10.     spin_unlock(&zone->lock);
  11. }
  13. /*
  14.  * Freeing function for a buddy system allocator.
  15.  *
  16.  * The concept of a buddy system is to maintain direct-mapped table
  17.  * (containing bit values) for memory blocks of various "orders".
  18.  * The bottom level table contains the map for the smallest allocatable
  19.  * units of memory (here, pages), and each level above it describes
  20.  * pairs of units from the levels below, hence, "buddies".
  21.  * At a high level, all that happens here is marking the table entry
  22.  * at the bottom level available, and propagating the changes upward
  23.  * as necessary, plus some accounting needed to play nicely with other
  24.  * parts of the VM system.
  25.  * At each level, we keep a list of pages, which are heads of continuous
  26.  * free pages of length of (1 << order) and marked with PG_buddy. Page's
  27.  * order is recorded in page_private(page) field.
  28.  * So when we are allocating or freeing one, we can derive the state of the
  29.  * other.  That is, if we allocate a small block, and both were   
  30.  * free, the remainder of the region must be split into blocks.   
  31.  * If a block is freed, and its buddy is also free, then this
  32.  * triggers coalescing into a block of larger size.            
  33.  *
  34.  * -- wli
  35.  */
  37. static inline void __free_one_page(struct page *page,
  38.         struct zone *zone, unsigned int order,
  39.         int migratetype)
  40. {
  41.     unsigned long page_idx;
  43.     if (unlikely(PageCompound(page)))
  44.         if (unlikely(destroy_compound_page(page, order)))
  45.             return;
  47.     VM_BUG_ON(migratetype == -1);
  49.     page_idx = page_to_pfn(page) & ((1 << MAX_ORDER) - 1);
  51.     VM_BUG_ON(page_idx & ((1 << order) - 1));
  52.     VM_BUG_ON(bad_range(zone, page));
  54.     while (order < MAX_ORDER-1) {
  55.         unsigned long combined_idx;
  56.         struct page *buddy;
  58.         buddy = __page_find_buddy(page, page_idx, order);
  59.         if (!page_is_buddy(page, buddy, order))
  60.             break;
  62.         /* Our buddy is free, merge with it and move up one order. */
  63.         list_del(&buddy->lru);
  64.         zone->free_area[order].nr_free--;
  65.         rmv_page_order(buddy);
  66.         combined_idx = __find_combined_index(page_idx, order);
  67.         page = page + (combined_idx - page_idx);
  68.         page_idx = combined_idx;
  69.         order++;
  70.     }
  71.     set_page_order(page, order);
  72.     list_add(&page->lru,
  73.         &zone->free_area[order].free_list[migratetype]);
  74.     zone->free_area[order].nr_free++;
  75. }