Linux节点和内存管理区的初始化

节点和管理区是内存管理中所涉及的重要概念，其数据结构在前文《linux物理内存概述》中已经介绍，现在让我们来看看linux是如何完成节点和管理区的。

在内核首先通过setup_arch()–>paging_init()–>zone_sizes_init()来初始化节点和管理区的一些数据项

1. static void __init zone_sizes_init(void)  
   
2. {  
   
3.     unsigned long max_zone_pfns[MAX_NR_ZONES];  
   
4.     memset(max_zone_pfns, 0, sizeof(max_zone_pfns));  
   
5.   
   
6.     /*分别获取三个管理区的页面数*/  
   
7.     max_zone_pfns[ZONE_DMA] =  
   
8.         virt_to_phys((char *)MAX_DMA_ADDRESS) >> PAGE_SHIFT;  
   
9.     max_zone_pfns[ZONE_NORMAL] = max_low_pfn;  
   
10. #ifdef CONFIG_HIGHMEM   
    
11.     max_zone_pfns[ZONE_HIGHMEM] = highend_pfn;  
    
12. #endif   
    
13.   
    
14.     free_area_init_nodes(max_zone_pfns);  
    
15. }  

在获取了三个管理区的页面数后，通过free_area_init_nodes()来完成后续工作

1. void __init free_area_init_nodes(unsigned long *max_zone_pfn)  
   
2. {  
   
3.     unsigned long nid;  
   
4.     int i;  
   
5.   
   
6.     /* Sort early_node_map as initialisation assumes it is sorted */  
   
7.     sort_node_map();/*将所有节点按起始页框号排序*/  
   
8.   
   
9.     /* Record where the zone boundaries are */  
   
10.     /*记录三个管理区的边界*/  
    
11.     memset(arch_zone_lowest_possible_pfn, 0,  
    
12.                 sizeof(arch_zone_lowest_possible_pfn));  
    
13.     memset(arch_zone_highest_possible_pfn, 0,  
    
14.                 sizeof(arch_zone_highest_possible_pfn));  
    
15.     arch_zone_lowest_possible_pfn[0] = find_min_pfn_with_active_regions();  
    
16.     arch_zone_highest_possible_pfn[0] = max_zone_pfn[0];  
    
17.     for (i = 1; i < MAX_NR_ZONES; i++) {  
    
18.         if (i == ZONE_MOVABLE) /*不处理ZONE_MOVABLE*/  
    
19.             continue;  
    
20.         /*将下一个管理区的起始页框置为上一个管理区的结束页框*/  
    
21.         arch_zone_lowest_possible_pfn[i] =  
    
22.             arch_zone_highest_possible_pfn[i-1];  
    
23.         arch_zone_highest_possible_pfn[i] =  
    
24.             max(max_zone_pfn[i], arch_zone_lowest_possible_pfn[i]);  
    
25.     }  
    
26.     arch_zone_lowest_possible_pfn[ZONE_MOVABLE] = 0;  
    
27.     arch_zone_highest_possible_pfn[ZONE_MOVABLE] = 0;  
    
28.   
    
29.     /* Find the PFNs that ZONE_MOVABLE begins at in each node */  
    
30.     memset(zone_movable_pfn, 0, sizeof(zone_movable_pfn));  
    
31.     find_zone_movable_pfns_for_nodes(zone_movable_pfn);  
    
32.   
    
33.     /* Print out the zone ranges */  
    
34.     printk(“Zone PFN ranges:\n”);  
    
35.     for (i = 0; i < MAX_NR_ZONES; i++) {  
    
36.         if (i == ZONE_MOVABLE)  
    
37.             continue;  
    
38.         printk(”  %-8s %0#10lx -> %0#10lx\n”,  
    
39.                 zone_names[i],  
    
40.                 arch_zone_lowest_possible_pfn[i],  
    
41.                 arch_zone_highest_possible_pfn[i]);  
    
42.     }  
    
43.   
    
44.     /* Print out the PFNs ZONE_MOVABLE begins at in each node */  
    
45.     printk(“Movable zone start PFN for each node\n”);  
    
46.     for (i = 0; i < MAX_NUMNODES; i++) {  
    
47.         if (zone_movable_pfn[i])  
    
48.             printk(”  Node %d: %lu\n”, i, zone_movable_pfn[i]);  
    
49.     }  
    
50.   
    
51.     /* Print out the early_node_map[] */  
    
52.     printk(“early_node_map[%d] active PFN ranges\n”, nr_nodemap_entries);  
    
53.     for (i = 0; i < nr_nodemap_entries; i++)  
    
54.         printk(”  %3d: %0#10lx -> %0#10lx\n”, early_node_map[i].nid,  
    
55.                         early_node_map[i].start_pfn,  
    
56.                         early_node_map[i].end_pfn);  
    
57.   
    
58.     /* Initialise every node */  
    
59.     mminit_verify_pageflags_layout();  
    
60.     setup_nr_node_ids();  
    
61.     for_each_online_node(nid) {/*遍历每个节点*/  
    
62.         pg_data_t *pgdat = NODE_DATA(nid);  
    
63.         /*初始化节点*/  
    
64.         free_area_init_node(nid, NULL,  
    
65.                 find_min_pfn_for_node(nid), NULL);  
    
66.   
    
67.         /* Any memory on that node */  
    
68.         if (pgdat->node_present_pages)  
    
69.             node_set_state(nid, N_HIGH_MEMORY);  
    
70.         check_for_regular_memory(pgdat);  
    
71.     }  
    
72. }  

其中核心函数为free_area_init_node(),用来针对特定的节点进行初始化

1. void __paginginit free_area_init_node(int nid, unsigned long *zones_size,  


2.         unsigned long node_start_pfn, unsigned long *zholes_size)  


3. {  


4.     pg_data_t *pgdat = NODE_DATA(nid);  


5.   


6.     pgdat->node_id = nid;  


7.     pgdat->node_start_pfn = node_start_pfn;  


8.     /*计算节点占用的总页面数和除去洞的实际总页面数*/  


9.     calculate_node_totalpages(pgdat, zones_size, zholes_size);  


10.   


11.     /*分配节点的mem_map*/  


12.     alloc_node_mem_map(pgdat);  


13. #ifdef CONFIG_FLAT_NODE_MEM_MAP   


14.     printk(KERN_DEBUG “free_area_init_node: node %d, pgdat %08lx, node_mem_map %08lx\n”,  


15.         nid, (unsigned long)pgdat,  


16.         (unsigned long)pgdat->node_mem_map);  


17. #endif   


18.          /*初始化节点中的关键数据*/  


19.     free_area_init_core(pgdat, zones_size, zholes_size);  


20. }  

1. static void __meminit calculate_node_totalpages(struct pglist_data *pgdat,  


2.         unsigned long *zones_size, unsigned long *zholes_size)  


3. {  


4.     unsigned long realtotalpages, totalpages = 0;  


5.     enum zone_type i;  


6.       


7.          /*遍历节点的所有管理区*/  


8.     for (i = 0; i < MAX_NR_ZONES; i++)  


9.         totalpages += zone_spanned_pages_in_node(pgdat->node_id, i,  


10.                                 zones_size);/*计算第i个管理区的页面数*/  


11.     pgdat->node_spanned_pages = totalpages;/*保存总页面数*/  


12.   


13.     realtotalpages = totalpages;  


14.     for (i = 0; i < MAX_NR_ZONES; i++)/*计算实际的总页面数(不包括洞)*/  


15.         realtotalpages -=  


16.             zone_absent_pages_in_node(pgdat->node_id, i,  


17.                                 zholes_size);  


18.     pgdat->node_present_pages = realtotalpages;/*保存可用页面数*/  


19.     printk(KERN_DEBUG “On node %d totalpages: %lu\n”, pgdat->node_id,  


20.                             realtotalpages);  


21. }  

1. /* 


2.  * Set up the zone data structures: 


3.  *   – mark all pages reserved 


4.  *   – mark all memory queues empty 


5.  *   – clear the memory bitmaps 


6.  */  


7. static void __paginginit free_area_init_core(struct pglist_data *pgdat,  


8.         unsigned long *zones_size, unsigned long *zholes_size)  


9. {  


10.     enum zone_type j;  


11.     int nid = pgdat->node_id;  


12.     unsigned long zone_start_pfn = pgdat->node_start_pfn;  


13.     int ret;  


14.   


15.     pgdat_resize_init(pgdat);/*初始化node_size_lock*/  


16.     pgdat->nr_zones = 0;  


17.     init_waitqueue_head(&pgdat->kswapd_wait);/*初始化页换出进程的等待队列*/  


18.     pgdat->kswapd_max_order = 0;          


19.     pgdat_page_cgroup_init(pgdat);  


20.       


21.     for (j = 0; j < MAX_NR_ZONES; j++) {  


22.         struct zone *zone = pgdat->node_zones + j;  


23.         unsigned long size, realsize, memmap_pages;  


24.         enum lru_list l;  


25.   


26.         /*计算该管理区的总页面数和实际可用页面数*/  


27.         size = zone_spanned_pages_in_node(nid, j, zones_size);  


28.         realsize = size – zone_absent_pages_in_node(nid, j,  


29.                                 zholes_size);  


30.   


31.         /* 


32.          * Adjust realsize so that it accounts for how much memory 


33.          * is used by this zone for memmap. This affects the watermark 


34.          * and per-cpu initialisations 


35.          */  


36.         memmap_pages = /*计算该管理区中要使用多少页面来完成映射*/  


37.             PAGE_ALIGN(size * sizeof(struct page)) >> PAGE_SHIFT;  


38.         /*如果实际可用页面大于或等于需要用来映射的页面，则用前者减去后者再保存*/                            


39.         if (realsize >= memmap_pages) {  


40.             realsize -= memmap_pages;  


41.             if (memmap_pages)  


42.                 printk(KERN_DEBUG  


43.                        ”  %s zone: %lu pages used for memmap\n”,  


44.                        zone_names[j], memmap_pages);  


45.         } else/*否则的话说明需要映射的页面太多超过了管理区可用内存的范围*/  


46.             printk(KERN_WARNING  


47.                 ”  %s zone: %lu pages exceeds realsize %lu\n”,  


48.                 zone_names[j], memmap_pages, realsize);  


49.   


50.         /* Account for reserved pages */  


51.         if (j == 0 && realsize > dma_reserve) {  


52.             realsize -= dma_reserve;  


53.             printk(KERN_DEBUG ”  %s zone: %lu pages reserved\n”,  


54.                     zone_names[0], dma_reserve);  


55.         }  


56.   


57.         if (!is_highmem_idx(j))/*如果不是高端内存管理区*/  


58.             nr_kernel_pages += realsize;  


59.         nr_all_pages += realsize;  


60.   


61.         zone->spanned_pages = size;     /*保存总页面数*/  


62.         zone->present_pages = realsize; /*保存剩余的可用页面数*/  


63. #ifdef CONFIG_NUMA   


64.         zone->node = nid;  


65.         zone->min_unmapped_pages = (realsize*sysctl_min_unmapped_ratio)  


66.                         / 100;  


67.         zone->min_slab_pages = (realsize * sysctl_min_slab_ratio) / 100;  


68. #endif   


69.         zone->name = zone_names[j];  


70.         spin_lock_init(&zone->lock);  


71.         spin_lock_init(&zone->lru_lock);  


72.         zone_seqlock_init(zone);  


73.         zone->zone_pgdat = pgdat; /*指向管理区所属节点*/  


74.   


75.         zone->prev_priority = DEF_PRIORITY;  


76.   


77.         zone_pcp_init(zone);  


78.         for_each_lru(l) {  


79.             INIT_LIST_HEAD(&zone->lru[l].list);  


80.             zone->reclaim_stat.nr_saved_scan[l] = 0;  


81.         }  


82.         /*回收状态中的各项都初始化为0*/  


83.         zone->reclaim_stat.recent_rotated[0] = 0;  


84.         zone->reclaim_stat.recent_rotated[1] = 0;  


85.         zone->reclaim_stat.recent_scanned[0] = 0;  


86.         zone->reclaim_stat.recent_scanned[1] = 0;  


87.         zap_zone_vm_stats(zone);  


88.         zone->flags = 0;  


89.         if (!size)  


90.             continue;  


91.   


92.         set_pageblock_order(pageblock_default_order());  


93.         setup_usemap(pgdat, zone, size);/*为pageblock_flags分配空间*/  


94.         /*初始化管理区的等待队列(wait table)和标识空闲块的结构(free_area)*/  


95.         ret = init_currently_empty_zone(zone, zone_start_pfn,  


96.                         size, MEMMAP_EARLY);  


97.         BUG_ON(ret);  


98.         /*设定管理区页面的相关信息*/  


99.         memmap_init(size, nid, j, zone_start_pfn);  


100.         zone_start_pfn += size;  


101.     }  


102. }  

至此，节点和管理区的关键数据已完成初始化，内核在后面为内存管理做得一个准备工作就是将所有节点的管理区都链入到zonelist中，便于后面内存分配工作的进行

内核在start_kernel()–>build_all_zonelist()中完成zonelist的初始化

1. void build_all_zonelists(void)  


2. {  


3.     /*设定zonelist的顺序，是按节点还是按管理区排序，只对NUMA有意义*/  


4.     set_zonelist_order();  


5.   


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.     /*得到所有管理区可分配的空闲页面数*/  


17.     vm_total_pages = nr_free_pagecache_pages();  


18.     /* 


19.      * Disable grouping by mobility if the number of pages in the 


20.      * system is too low to allow the mechanism to work. It would be 


21.      * more accurate, but expensive to check per-zone. This check is 


22.      * made on memory-hotadd so a system can start with mobility 


23.      * disabled and enable it later 


24.      */  


25.     if (vm_total_pages < (pageblock_nr_pages * MIGRATE_TYPES))  


26.         page_group_by_mobility_disabled = 1;  


27.     else  


28.         page_group_by_mobility_disabled = 0;  


29.   


30.     printk(“Built %i zonelists in %s order, mobility grouping %s.  “  


31.         “Total pages: %ld\n”,  


32.             nr_online_nodes,  


33.             zonelist_order_name[current_zonelist_order],  


34.             page_group_by_mobility_disabled ? “off” : “on”,  


35.             vm_total_pages);  


36. #ifdef CONFIG_NUMA   


37.     printk(“Policy zone: %s\n”, zone_names[policy_zone]);  


38. #endif   


39. }  

1. static int __build_all_zonelists(void *dummy)  


2. {  


3.     int nid;  


4.   


5. #ifdef CONFIG_NUMA   


6.     memset(node_load, 0, sizeof(node_load));  


7. #endif   


8.     for_each_online_node(nid) {/*遍历节点*/  


9.         pg_data_t *pgdat = NODE_DATA(nid);  


10.   


11.         build_zonelists(pgdat);  


12.         build_zonelist_cache(pgdat);  


13.     }  


14.     return 0;  


15. }  

UMA架构下的build_zonelists()函数为

1. static void build_zonelists(pg_data_t *pgdat)  


2. {  


3.     int node, local_node;  


4.     enum zone_type j;  


5.     struct zonelist *zonelist;  


6.   


7.     local_node = pgdat->node_id;  


8.   


9.     /*取node_zonelists[0]，将本节点和其他节点的管理区都链入其中*/  


10.     zonelist = &pgdat->node_zonelists[0];  


11.     /*将本节点的管理区链入zonelist*/  


12.     j = build_zonelists_node(pgdat, zonelist, 0, MAX_NR_ZONES – 1);  


13.   


14.     /* 


15.      * Now we build the zonelist so that it contains the zones 


16.      * of all the other nodes. 


17.      * We don’t want to pressure a particular node, so when 


18.      * building the zones for node N, we make sure that the 


19.      * zones coming right after the local ones are those from 


20.      * node N+1 (modulo N) 


21.      */  


22.      /*将本节点后面的节点的管理区链入zonelist*/  


23.     for (node = local_node + 1; node < MAX_NUMNODES; node++) {  


24.         if (!node_online(node))  


25.             continue;  


26.         j = build_zonelists_node(NODE_DATA(node), zonelist, j,  


27.                             MAX_NR_ZONES – 1);  


28.     }  


29.          /*将本节点前面的节点的管理区链入zonelist*/  


30.     for (node = 0; node < local_node; node++) {  


31.         if (!node_online(node))  


32.             continue;  


33.         j = build_zonelists_node(NODE_DATA(node), zonelist, j,  


34.                             MAX_NR_ZONES – 1);  


35.     }  


36.          /*zonelist的结束点置空*/  


37.     zonelist->_zonerefs[j].zone = NULL;  


38.     zonelist->_zonerefs[j].zone_idx = 0;  


39. }  

1. static int build_zonelists_node(pg_data_t *pgdat, struct zonelist *zonelist,  


2.                 int nr_zones, enum zone_type zone_type)  


3. {  


4.     struct zone *zone;  


5.   


6.     BUG_ON(zone_type >= MAX_NR_ZONES);  


7.     zone_type++;  


8.   


9.     do {  


10.         zone_type–;  


11.         zone = pgdat->node_zones + zone_type;  


12.         if (populated_zone(zone)) {/*如果管理区的可用页面数不为0*/  


13.             /*将zone添加进zonelist*/  


14.             zoneref_set_zone(zone,  


15.                 &zonelist->_zonerefs[nr_zones++]);  


16.             check_highest_zone(zone_type);  


17.         }  


18.   


19.     } while (zone_type);  


20.     return nr_zones;  


21. }  

zoneref_set_zone()就是对_zonerefs的设置

1. static void zoneref_set_zone(struct zone *zone, struct zoneref *zoneref)  


2. {  


3.     zoneref->zone = zone;  


4.     zoneref->zone_idx = zone_idx(zone);  


5. }  

到这里内存管理的前期准备工作已基本完成，包括页表的建立以及管理区的建立，接下来就可以建立伙伴系统和slab分配器来完成具体的内存管理工作了。