Linux 内存管理（4）paging_init（2）

1. bootmem_init

内核代码像是一个美丽的女人，把最美丽的地方放在最神秘的位置。在跋山涉水之后，终于到了揭开面纱的时刻。

arch/arm64/mm/init.c

180 void __init bootmem_init(void)
181 {
182         unsigned long min, max;
183
184         min = PFN_UP(memblock_start_of_DRAM());
185         max = PFN_DOWN(memblock_end_of_DRAM());
186
187         /*
188          * Sparsemem tries to allocate bootmem in memory_present(), so must be
189          * done after the fixed reservations.
190          */
191         arm64_memory_present();
192
193         sparse_init();
194         zone_sizes_init(min, max);
195
196         high_memory = __va((max << PAGE_SHIFT) - 1) + 1;
197         max_pfn = max_low_pfn = max;
198 }
199

paging_init的主要功能，由 191，193，194行的函数实现。

CONFIG_SPARSEMEM在内核编译中有设置。

124 static void arm64_memory_present(void)
125 {
126         struct memblock_region *reg;
127
128         for_each_memblock(memory, reg)
129                 memory_present(0, memblock_region_memory_base_pfn(reg),
130                                memblock_region_memory_end_pfn(reg));
131 }

mm/sparse.c

/* Record a memory area against a node. */
void __init memory_present(int nid, unsigned long start, unsigned long end)
{
        unsigned long pfn;

        start &= PAGE_SECTION_MASK;
        mminit_validate_memmodel_limits(&start, &end);
        for (pfn = start; pfn < end; pfn += PAGES_PER_SECTION) {
                unsigned long section = pfn_to_section_nr(pfn);
                struct mem_section *ms;

                sparse_index_init(section, nid);
                set_section_nid(section, nid);

                ms = __nr_to_section(section);
                if (!ms->section_mem_map)
                        ms->section_mem_map = sparse_encode_early_nid(nid) |
                                                        SECTION_MARKED_PRESENT;
        }
}

2 sparse_init

468 void __init sparse_init(void)
469 {


579
580         for (pnum = 0; pnum < NR_MEM_SECTIONS; pnum++) {
581                 if (!present_section_nr(pnum))
582                         continue;
583
584                 usemap = usemap_map[pnum];
585                 if (!usemap)
586                         continue;
587
588 #ifdef CONFIG_SPARSEMEM_ALLOC_MEM_MAP_TOGETHER
589                 map = map_map[pnum];
590 #else
591                 map = sparse_early_mem_map_alloc(pnum);
592 #endif
593                 if (!map)
594                         continue;
595
596                 sparse_init_one_section(__nr_to_section(pnum), pnum, map,
597                                                                 usemap);
598         }
599
600         vmemmap_populate_print_last();
601
602 #ifdef CONFIG_SPARSEMEM_ALLOC_MEM_MAP_TOGETHER
603         free_bootmem(__pa(map_map), size2);
604 #endif
605         free_bootmem(__pa(usemap_map), size);
606 }
607

sparse_init是一个相当复杂的函数，591行分配mem_map.

443 static struct page __init *sparse_early_mem_map_alloc(unsigned long pnum)
444 {
445         struct page *map;
446         struct mem_section *ms = __nr_to_section(pnum);
447         int nid = sparse_early_nid(ms);
448
449         map = sparse_mem_map_populate(pnum, nid);
450         if (map)
451                 return map;
452
453         printk(KERN_ERR "%s: sparsemem memory map backing failed "
454                         "some memory will not be available.\n", __func__);
455         ms->section_mem_map = 0;
456         return NULL;
457 }

mm/sparse-vmemmap.c

struct page * __meminit sparse_mem_map_populate(unsigned long pnum, int nid)
{
        unsigned long start;
        unsigned long end;
        struct page *map;

        map = pfn_to_page(pnum * PAGES_PER_SECTION);
        start = (unsigned long)map;
        end = (unsigned long)(map + PAGES_PER_SECTION);

        if (vmemmap_populate(start, end, nid))
                return NULL;

        return map;
}

arch/arm64/mm/mmu.c

399 int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node)
400 {
401         unsigned long addr = start;
402         unsigned long next;
403         pgd_t *pgd;
404         pud_t *pud;
405         pmd_t *pmd;
406
407         do {
408                 next = pmd_addr_end(addr, end);
409
410                 pgd = vmemmap_pgd_populate(addr, node);
411                 if (!pgd)
412                         return -ENOMEM;
413
414                 pud = vmemmap_pud_populate(pgd, addr, node);
415                 if (!pud)
416                         return -ENOMEM;
417
418                 pmd = pmd_offset(pud, addr);
419                 if (pmd_none(*pmd)) {
420                         void *p = NULL;
421
422                         p = vmemmap_alloc_block_buf(PMD_SIZE, node);
423                         if (!p)
424                                 return -ENOMEM;
425
426                         set_pmd(pmd, __pmd(__pa(p) | prot_sect_kernel));
427                 } else
428                         vmemmap_verify((pte_t *)pmd, node, addr, next);
429         } while (addr = next, addr != end);
430
431         return 0;
432 }

422行 分配一个物理内存页，把物理地址放到PMD中

 49 void * __meminit vmemmap_alloc_block(unsigned long size, int node)
 50 {
 51         /* If the main allocator is up use that, fallback to bootmem. */
 52         if (slab_is_available()) {
 53                 struct page *page;
 54
 55                 if (node_state(node, N_HIGH_MEMORY))
 56                         page = alloc_pages_node(
 57                                 node, GFP_KERNEL | __GFP_ZERO | __GFP_REPEAT,
 58                                 get_order(size));
 59                 else
 60                         page = alloc_pages(
 61                                 GFP_KERNEL | __GFP_ZERO | __GFP_REPEAT,
 62                                 get_order(size));
 63                 if (page)
 64                         return page_address(page);
 65                 return NULL;
 66         } else
 67                 return __earlyonly_bootmem_alloc(node, size, size,
 68                                 __pa(MAX_DMA_ADDRESS));
 69 }
 70
 71 /* need to make sure size is all the same during early stage */
 72 void * __meminit vmemmap_alloc_block_buf(unsigned long size, int node)
 73 {
 74         void *ptr;
 75
 76         if (!vmemmap_buf)
 77                 return vmemmap_alloc_block(size, node);
 78
 79         /* take the from buf */
 80         ptr = (void *)ALIGN((unsigned long)vmemmap_buf, size);
 81         if (ptr + size > vmemmap_buf_end)
 82                 return vmemmap_alloc_block(size, node);
 83
 84         vmemmap_buf = ptr + size;
 85
 86         return ptr;
 87 }

 38 static void * __init_refok __earlyonly_bootmem_alloc(int node,
 39                                 unsigned long size,
 40                                 unsigned long align,
 41                                 unsigned long goal)
 42 {
 43         return __alloc_bootmem_node_high(NODE_DATA(node), size, align, goal);
 44 }

如果你对着个内存分配十分感兴趣，在mm/nobootmem.c中可以找到函数定义，最终会调用到memblock_alloc.

sparse_init完成，每个物理页面均分配了相应的页表。

3. zone_sizes_init

arch/arm64/mm/init.c

 72 static void __init zone_sizes_init(unsigned long min, unsigned long max)
 73 {
 74         struct memblock_region *reg;
 75         unsigned long zone_size[MAX_NR_ZONES], zhole_size[MAX_NR_ZONES];
 76         unsigned long max_dma32 = min;
 77
 78         memset(zone_size, 0, sizeof(zone_size));
 79
 80 #ifdef CONFIG_ZONE_DMA32
 81         /* 4GB maximum for 32-bit only capable devices */
 82         max_dma32 = max(min, min(max, MAX_DMA32_PFN));
 83         zone_size[ZONE_DMA32] = max_dma32 - min;
 84 #endif
 85         zone_size[ZONE_NORMAL] = max - max_dma32;
 86
 87         memcpy(zhole_size, zone_size, sizeof(zhole_size));
 88
 89         for_each_memblock(memory, reg) {
 90                 unsigned long start = memblock_region_memory_base_pfn(reg);
 91                 unsigned long end = memblock_region_memory_end_pfn(reg);
 92
 93                 if (start >= max)
 94                         continue;
 95 #ifdef CONFIG_ZONE_DMA32
 96                 if (start < max_dma32) {
 97                         unsigned long dma_end = min(end, max_dma32);
 98                         zhole_size[ZONE_DMA32] -= dma_end - start;
 99                 }
100 #endif
101                 if (end > max_dma32) {
102                         unsigned long normal_end = min(end, max);
103                         unsigned long normal_start = max(start, max_dma32);
104                         zhole_size[ZONE_NORMAL] -= normal_end - normal_start;
105                 }
106         }
107
108         free_area_init_node(0, zone_size, min, zhole_size);
109 }
110

73-107行，主要是设置zone_size， zhole_size两个变量。

mm/page_alloc.c

4887 void __paginginit free_area_init_node(int nid, unsigned long *zones_size,
4888                 unsigned long node_start_pfn, unsigned long *zholes_size)
4889 {
4890         pg_data_t *pgdat = NODE_DATA(nid);
4891
4892         /* pg_data_t should be reset to zero when it's allocated */
4893         WARN_ON(pgdat->nr_zones || pgdat->classzone_idx);
4894
4895         pgdat->node_id = nid;
4896         pgdat->node_start_pfn = node_start_pfn;
4897         init_zone_allows_reclaim(nid);
4898         calculate_node_totalpages(pgdat, zones_size, zholes_size);
4899
4900         alloc_node_mem_map(pgdat);
4901 #ifdef CONFIG_FLAT_NODE_MEM_MAP
4902         printk(KERN_DEBUG "free_area_init_node: node %d, pgdat %08lx, node_mem_map %08lx\n",
4903                 nid, (unsigned long)pgdat,
4904                 (unsigned long)pgdat->node_mem_map);
4905 #endif
4906
4907         free_area_init_core(pgdat, zones_size, zholes_size);
4908 }

4888-4906对Node的pgdat的部分变量进行设置。4907完成主要工作。

4754 static void __paginginit free_area_init_core(struct pglist_data *pgdat,
4755                 unsigned long *zones_size, unsigned long *zholes_size)
4756 {
4757         enum zone_type j;
4758         int nid = pgdat->node_id;
4759         unsigned long zone_start_pfn = pgdat->node_start_pfn;
4760         int ret;
4761
4762         pgdat_resize_init(pgdat);
4763 #ifdef CONFIG_NUMA_BALANCING
4764         spin_lock_init(&pgdat->numabalancing_migrate_lock);
4765         pgdat->numabalancing_migrate_nr_pages = 0;
4766         pgdat->numabalancing_migrate_next_window = jiffies;
4767 #endif
4768         init_waitqueue_head(&pgdat->kswapd_wait);
4769         init_waitqueue_head(&pgdat->pfmemalloc_wait);
4770         pgdat_page_cgroup_init(pgdat);
4771
4772         for (j = 0; j < MAX_NR_ZONES; j++) {
4773                 struct zone *zone = pgdat->node_zones + j;
4774                 unsigned long size, realsize, freesize, memmap_pages;
4775
4776                 size = zone_spanned_pages_in_node(nid, j, zones_size);
4777                 realsize = freesize = size - zone_absent_pages_in_node(nid, j,
4778                                                                 zholes_size);
4779
4780                 /*
4781                  * Adjust freesize so that it accounts for how much memory
4782                  * is used by this zone for memmap. This affects the watermark
4783                  * and per-cpu initialisations
4784                  */
4785                 memmap_pages = calc_memmap_size(size, realsize);
4786                 if (freesize >= memmap_pages) {
4787                         freesize -= memmap_pages;
4788                         if (memmap_pages)
4789                                 printk(KERN_DEBUG
4790                                        "  %s zone: %lu pages used for memmap\n",
4791                                        zone_names[j], memmap_pages);
4792                 } else
4793                         printk(KERN_WARNING
4794                                 "  %s zone: %lu pages exceeds freesize %lu\n",
4795                                 zone_names[j], memmap_pages, freesize);
4796
4797                 /* Account for reserved pages */
4798                 if (j == 0 && freesize > dma_reserve) {
4799                         freesize -= dma_reserve;
4800                         printk(KERN_DEBUG "  %s zone: %lu pages reserved\n",
4801                                         zone_names[0], dma_reserve);
4802                 }

4803
4804                 if (!is_highmem_idx(j))
4805                         nr_kernel_pages += freesize;
4806                 /* Charge for highmem memmap if there are enough kernel pages */
4807                 else if (nr_kernel_pages > memmap_pages * 2)
4808                         nr_kernel_pages -= memmap_pages;
4809                 nr_all_pages += freesize;
4810
4811                 zone->spanned_pages = size;
4812                 zone->present_pages = realsize;
4813                 /*
4814                  * Set an approximate value for lowmem here, it will be adjusted
4815                  * when the bootmem allocator frees pages into the buddy system.
4816                  * And all highmem pages will be managed by the buddy system.
4817                  */
4818                 zone->managed_pages = is_highmem_idx(j) ? realsize : freesize;
4819 #ifdef CONFIG_NUMA
4820                 zone->node = nid;
4821                 zone->min_unmapped_pages = (freesize*sysctl_min_unmapped_ratio)
4822                                                 / 100;
4823                 zone->min_slab_pages = (freesize * sysctl_min_slab_ratio) / 100;
4824 #endif
4825                 zone->name = zone_names[j];
4826                 spin_lock_init(&zone->lock);
4827                 spin_lock_init(&zone->lru_lock);
4828                 zone_seqlock_init(zone);
4829                 zone->zone_pgdat = pgdat;
4830
4831                 zone_pcp_init(zone);
4832                 lruvec_init(&zone->lruvec);
4833                 if (!size)
4834                         continue;
4835
4836                 set_pageblock_order();
4837                 setup_usemap(pgdat, zone, zone_start_pfn, size);
4838                 ret = init_currently_empty_zone(zone, zone_start_pfn,
4839                                                 size, MEMMAP_EARLY);
4840                 BUG_ON(ret);
4841                 memmap_init(size, nid, j, zone_start_pfn);
4842                 zone_start_pfn += size;
4843         }
4844 }

至此Node的pgdat和Zone设置完毕。