伙伴系统已经出现很长一段时间了，有了一些优化，看了一下，比想象中的复杂很多啊。
1 static void __init_refok alloc_node_mem_map(struct pglist_data *pgdat)
2 {
3 /* 如果这个节点没有page，那就直接跳过这个节点*/
4 if (!pgdat->node_spanned_pages)
5 return;
6
7 #ifdef CONFIG_FLAT_NODE_MEM_MAP
8 /* 用node_mem_map这个page用来管理mem_map */
9 if (!pgdat->node_mem_map) {
10 unsigned long size, start, end;
11 struct page *map;
12 /* 初始化start、end、size */
13 start = pgdat->node_start_pfn & ~(MAX_ORDER_NR_PAGES - 1);
14 end = pgdat->node_start_pfn + pgdat->node_spanned_pages;
15 end = ALIGN(end, MAX_ORDER_NR_PAGES);
16 size = (end - start) * sizeof(struct page);
17 /* 申请空间 */
18 map = alloc_remap(pgdat->node_id, size);
19 if (!map)
20 map = alloc_bootmem_node(pgdat, size);
21 pgdat->node_mem_map = map + (pgdat->node_start_pfn - start);
22 }
23 #ifndef CONFIG_NEED_MULTIPLE_NODES
24 /* 设置全局mem_map */
25 if (pgdat == NODE_DATA(0)) {
26 mem_map = NODE_DATA(0)->node_mem_map;
27 #ifdef CONFIG_ARCH_POPULATES_NODE_MAP
28 if (page_to_pfn(mem_map) != pgdat->node_start_pfn)
29 mem_map -= (pgdat->node_start_pfn - ARCH_PFN_OFFSET);
30 #endif /* CONFIG_ARCH_POPULATES_NODE_MAP */
31 }
32 #endif
33 #endif /* CONFIG_FLAT_NODE_MEM_MAP */
34 }
alloc_node_mem_map(struct pglist_data *pgdat)用来初始化page。
1 static void __paginginit free_area_init_core(struct pglist_data *pgdat, unsigned long *zones_size, unsigned long *zholes_size)
2 {
3 enum zone_type j;
4 int nid = pgdat->node_id;
5 unsigned long zone_start_pfn = pgdat->node_start_pfn;
6 int ret;
7
8 /* 在改版一些值的时候要上锁 */
9 pgdat_resize_init(pgdat);
10 pgdat->nr_zones = 0;
11 /* 初始化地kswapd等待队列（上锁） */
12 init_waitqueue_head(&pgdat->kswapd_wait);
13 pgdat->kswapd_max_order = 0;
14 /* 循环初始化每个zone结构 */
15 for (j = 0; j < MAX_NR_ZONES; j++) {
16 struct zone *zone = pgdat->node_zones + j;
17 unsigned long size, realsize, memmap_pages;
18 /* 计算这个zone上的page数量（包括hole） */
19 size = zone_spanned_pages_in_node(nid, j, zones_size);
20 /* 计算实际的值 */
21 realsize = size - zone_absent_pages_in_node(nid, j, zholes_size);
22 memmap_pages = (size * sizeof(struct page)) >> PAGE_SHIFT;
23 /* 去掉memmap占用的内存 */
24 if (realsize >= memmap_pages) {
25 realsize -= memmap_pages;
26 printk(KERN_DEBUG" %s zone: %lu pages used for memmap\n",zone_names[j], memmap_pages);
27 } else
28 printk(KERN_WARNING" %s zone: %lu pages exceeds realsize %lu\n", zone_names[j], memmap_pages, realsize);
29 /* 去掉用于DMA的内存 */
30 if (j == 0 && realsize > dma_reserve) {
31 realsize -= dma_reserve;
32 printk(KERN_DEBUG " %s zone: %lu pages reserved\n", zone_names[0], dma_reserve);
33 }
34 /* 更新nr_kernel_pages、nr_all_pages */
35 if (!is_highmem_idx(j))
36 nr_kernel_pages += realsize;
37 nr_all_pages += realsize;
38 /* 更新zone中的信息 */
39 zone->spanned_pages = size;
40 zone->present_pages = realsize;
41 #ifdef CONFIG_NUMA
42 zone->node = nid;
43 zone->min_unmapped_pages = (realsize*sysctl_min_unmapped_ratio) / 100;
44 zone->min_slab_pages = (realsize * sysctl_min_slab_ratio) / 100;
45 #endif
46 zone->name = zone_names[j];
47 spin_lock_init(&zone->lock);
48 spin_lock_init(&zone->lru_lock);
49 zone_seqlock_init(zone);
50 zone->zone_pgdat = pgdat;
51
52 zone->prev_priority = DEF_PRIORITY;
53
54 zone_pcp_init(zone);
55 INIT_LIST_HEAD(&zone->active_list);
56 INIT_LIST_HEAD(&zone->inactive_list);
57 zone->nr_scan_active = 0;
58 zone->nr_scan_inactive = 0;
59 /* 把zone中的状态全部初始化为0 */
60 zap_zone_vm_stats(zone);
61 zone->flags = 0;
62 /* 如果占用的内存大小为0，那就就此为止 */
63 if (!size)
64 continue;
65
66 set_pageblock_order(pageblock_default_order());
67 setup_usemap(pgdat, zone, size);
68 /* 初始化freelist */
69 ret = init_currently_empty_zone(zone, zone_start_pfn, size, MEMMAP_EARLY);
70 BUG_ON(ret);
71 /* 初始化内存域的页 */
72 memmap_init(size, nid, j, zone_start_pfn);
73 zone_start_pfn += size;
74 }
75 }
上面这段代码初始化了zone结构（其中的各个字段，详细的都在注释里了）。其中还有几个初始化per-CPU相关的数据结构（zone_pcp_init）、初始化freearea（init_currently_empty_zone）、初始化内存域的页（memmap_init）。zone_pcp_init函数的代码如下：
1 static __meminit void zone_pcp_init(struct zone *zone)
2 {
3 int cpu;
4 /* 批处理的大小，每次处理的大小是batch而不是单页 */
5 unsigned long batch = zone_batchsize(zone);
6 /* 依次处理每个CPU */
7 for (cpu = 0; cpu < NR_CPUS; cpu++) {
8 #ifdef CONFIG_NUMA
9 zone_pcp(zone, cpu) = &boot_pageset[cpu];
10 /* 设置pageset */
11 setup_pageset(&boot_pageset[cpu],0);
12 #else
13 setup_pageset(zone_pcp(zone,cpu), batch);
14 #endif
15 }
16 if (zone->present_pages)
17 printk(KERN_DEBUG " %s zone: %lu pages, LIFO batch:%lu\n",
18 zone->name, zone->present_pages, batch);
19 }
20 static int zone_batchsize(struct zone *zone)
21 {
22 int batch;
23 /* CPU页缓存的大小大约为zone大小的千分之一 */
24 batch = zone->present_pages / 1024;
25 if (batch * PAGE_SIZE > 512 * 1024) batch = (512 * 1024) / PAGE_SIZE;
26 batch /= 4;
27 if (batch < 1) batch = 1;
28 batch = (1 << (fls(batch + batch/2)-1)) - 1;
29 return batch;
30 }
其中热页CPU缓存的热页很可能现在就在CPU的硬件高速缓存中。
下面是init_currently_empty_zone的代码：
1 __meminit int init_currently_empty_zone(struct zone *zone, unsigned long zone_start_pfn, unsigned long
2
3 size, enum memmap_context context)
4 {
5 struct pglist_data *pgdat = zone->zone_pgdat;
6 int ret;
7 /* 初始化管理区的等待队列hash表和等待队列头,这个就没什么好说的了 */
8 ret = zone_wait_table_init(zone, size);
9 if (ret)
10 return ret;
11 pgdat->nr_zones = zone_idx(zone) + 1;
12 zone->zone_start_pfn = zone_start_pfn;
13 /* 初始化管理区的空闲块列表 */
14 zone_init_free_lists(zone);
15 return 0;
16 }
17 static void __meminit zone_init_free_lists(struct zone *zone)
18 {
19 int order, t;
20 /* 这里其实是一个双循环（建的应该是空的吧）,看下面 */
21 for_each_migratetype_order(order, t) {
22 INIT_LIST_HEAD(&zone->free_area[order].free_list[t]);
23 zone->free_area[order].nr_free = 0;
24 }
25 }
26 #define for_each_migratetype_order(order, type) \
27 for (order = 0; order < MAX_ORDER; order++) \
28 for (type = 0; type < MIGRATE_TYPES; type++)
这段代码比想象中的好理解吧（也许我想错了）。下面是初始化mem_map数组的代码（memmap_init）：
1 #define memmap_init(size, nid, zone, start_pfn) \
2 memmap_init_zone((size), (nid), (zone), (start_pfn), MEMMAP_EARLY)
3 #endif
4 void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
5 unsigned long start_pfn, enum memmap_context context)
6 {
7 struct page *page;
8 unsigned long end_pfn = start_pfn + size;
9 unsigned long pfn;
10 struct zone *z;
11
12 z = &NODE_DATA(nid)->node_zones[zone];
13 /* 遍历每个page */
14 for (pfn = start_pfn; pfn < end_pfn; pfn++) {
15 if (context == MEMMAP_EARLY) {
16 if (!early_pfn_valid(pfn))
17 continue;
18 if (!early_pfn_in_nid(pfn, nid))
19 continue;
20 }
21 /* 取得pfn对应的page */
22 page = pfn_to_page(pfn);
23 /* 设置page->flags */
24 set_page_links(page, zone, nid, pfn);
25 /* 设置page->_count为1 */
26 init_page_count(page);
27 /* 设置page->_mapcount为-1 */
28 reset_page_mapcount(page);
29 /* 设置page为保留的 */
30 SetPageReserved(page);
31 /* 检查一下是否可以设置为可移动的 */
32 if ((z->zone_start_pfn <= pfn)
33 && (pfn < z->zone_start_pfn + z->spanned_pages)
34 && !(pfn & (pageblock_nr_pages - 1)))
35 set_pageblock_migratetype(page, MIGRATE_MOVABLE);
36
37 INIT_LIST_HEAD(&page->lru);
38 #ifdef WANT_PAGE_VIRTUAL
39 /* 如果不是高端页 */
40 if (!is_highmem_idx(zone))
41 set_page_address(page, __va(pfn << PAGE_SHIFT));
42 #endif
43 }
44 }
通过上面这几步就建立了buddy system需要的数据结构。下面就开始用它来管理内存了。下面是分配页面的代码：
1 static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask, unsigned int order)
2 {
3 /* 分配不了这么大的页 */
4 if (unlikely(order >= MAX_ORDER))
5 return NULL;
6 /* 应该是如果没有确定从哪个节点分配就从现在的这个CPU对应的节点分配？？*/
7 if (nid < 0)
8 nid = numa_node_id();
9 /* 真正的分配函数（伙伴系统的心脏） */
10 return __alloc_pages(gfp_mask, order, NODE_DATA(nid)->node_zonelists + gfp_zone(gfp_mask));
11 }
12 struct page* __alloc_pages(gfp_t gfp_mask, unsigned int order, struct zonelist *zonelist)
13 {
14 const gfp_t wait = gfp_mask & __GFP_WAIT;
15 struct zone **z;
16 struct page *page;
17 struct reclaim_state reclaim_state;
18 struct task_struct *p = current;
19 int do_retry;
20 int alloc_flags;
21 int did_some_progress;
22
23 /* 自旋锁睡眠调试函数 */
24 might_sleep_if(wait);
25 /* 通过fail_page_alloc和标志位快速判断是否会失败 */
26 if (should_fail_alloc_page(gfp_mask, order))
27 return NULL;
28
29 restart:
30 z = zonelist->zones;
31 if (unlikely(*z == NULL)) {
32 return NULL;
33 }
34 /* 用get_page_from_freelist函数去取page */
35 page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, order, zonelist, ALLOC_WMARK_LOW|ALLOC_CPUSET);
36 if (page)
37 goto got_pg;
38 /* 判断是否需要进一步努力 */
39 if (NUMA_BUILD && (gfp_mask & GFP_THISNODE) == GFP_THISNODE)
40 goto nopage;
41 /* 依次唤醒kswapd守护进程来换页 */
42 for (z = zonelist->zones; *z; z++)
43 wakeup_kswapd(*z, order);
44
45 /* 修改标志位 */
46 alloc_flags = ALLOC_WMARK_MIN;
47 if ((unlikely(rt_task(p)) && !in_interrupt()) || !wait)
48 alloc_flags |= ALLOC_HARDER;
49 if (gfp_mask & __GFP_HIGH)
50 alloc_flags |= ALLOC_HIGH;
51 if (wait)
52 alloc_flags |= ALLOC_CPUSET;
53 /* 再次尝试 */
54 page = get_page_from_freelist(gfp_mask, order, zonelist, alloc_flags);
55 if (page)
56 goto got_pg;
57
58 rebalance:
59 if (((p->flags & PF_MEMALLOC) || unlikely(test_thread_flag(TIF_MEMDIE))) && !in_interrupt()) {
60 if (!(gfp_mask & __GFP_NOMEMALLOC)) {
61 nofail_alloc:
62 /* 忽略水印再来一次 */
63 page = get_page_from_freelist(gfp_mask, order, zonelist, ALLOC_NO_WATERMARKS);
64 if (page)
65 goto got_pg;
66 /* 如果设置不能分配失败 */
67 if (gfp_mask & __GFP_NOFAIL) {
68 congestion_wait(WRITE, HZ/50);
69 goto nofail_alloc;
70 }
71 }
72 goto nopage;
73 }
74
75 if (!wait)
76 goto nopage;
77 /* 主动放弃CPU提供给优先级更高的任务使用 */
78 cond_resched();
79
80 /* 开始同步回收 */
81 cpuset_memory_pressure_bump();
82 p->flags |= PF_MEMALLOC;
83 reclaim_state.reclaimed_slab = 0;
84 p->reclaim_state = &reclaim_state;
85 /* 尝试释放一些页 */
86 did_some_progress = try_to_free_pages(zonelist->zones, order, gfp_mask);
87
88 p->reclaim_state = NULL;
89 p->flags &= ~PF_MEMALLOC;
90
91 /* 主动放弃CPU提供给优先级更高的任务使用 */
92 cond_resched();
93 /* 释放pcp中的页 */
94 if (order != 0) drain_all_pages();
95 /* 如果释放了一些页就在此尝试 */
96 if (likely(did_some_progress)) {
97 page = get_page_from_freelist(gfp_mask, order, zonelist, alloc_flags);
98 if (page)
99 goto got_pg;
100 } else if ((gfp_mask & __GFP_FS) && !(gfp_mask & __GFP_NORETRY)) {
101 /* 想办法调用OOM killer（在内存不够用的时候选择性地出来干掉一些进程） */
102 if (!try_set_zone_oom(zonelist)) {
103 schedule_timeout_uninterruptible(1);
104 goto restart;
105 }
106 page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, order, zonelist, ALLOC_WMARK_HIGH|ALLOC_CPUSET);
107 if (page) {
108 /* 清楚标志避免调用OOM killer */
109 clear_zonelist_oom(zonelist);
110 goto got_pg;
111 }
112 /* 如果在分配一个很大的页分配不成功也是很正常的 */
113 if (order > PAGE_ALLOC_COSTLY_ORDER) {
114 /* 清楚标志避免调用OOM killer */
115 clear_zonelist_oom(zonelist);
116 goto nopage;
117 }
118 /* 找出一个进程干掉（不然的话系统会挂掉吧） */
119 out_of_memory(zonelist, gfp_mask, order);
120 clear_zonelist_oom(zonelist);
121 goto restart;
122 }
123
124 do_retry = 0;
125 if (!(gfp_mask & __GFP_NORETRY)) {
126 if ((order <= PAGE_ALLOC_COSTLY_ORDER) || (gfp_mask & __GFP_REPEAT))
127 do_retry = 1;
128 if (gfp_mask & __GFP_NOFAIL)
129 do_retry = 1;
130 }
131 /* 等待一些写操作完成的时候重试 */
132 if (do_retry) {
133 congestion_wait(WRITE, HZ/50);
134 goto rebalance;
135 }
136
137 nopage:
138 /* 承认这次分配失败 */
139 if (!(gfp_mask & __GFP_NOWARN) && printk_ratelimit()) {
140 printk(KERN_WARNING "%s: page allocation failure." " order:%d, mode:0x%x\n",p->comm, order, gfp_mask);
141 dump_stack();
142 show_mem();
143 }
144 got_pg:
145 return page;
146 }
可以好好研究这段代码，我们会发现内核在分配页面的时候真的尽力了。先是尝试一下（大部分的分配这个时候会成功），如果不行的话就开始进程调度、“没收”其他地方占用的内存，甚至不惜杀死进程。可以看出，如果没有内存了，我们找谁要？谁有就朝谁要（有点像《让子弹飞》里面的意思了）。下面是从buddy system中具体的分配页面的代码（很好理解，但是细节比较多）：
1 static struct page* get_page_from_freelist(gfp_t gfp_mask, unsigned int order, struct zonelist *zonelist, int alloc_flags)
2 {
3 struct zone **z;
4 struct page *page = NULL;
5 int classzone_idx = zone_idx(zonelist->zones[0]);
6 struct zone *zone;
7 nodemask_t *allowednodes = NULL;
8 int zlc_active = 0;
9 int did_zlc_setup = 0;
10 enum zone_type highest_zoneidx = -1;
11
12 zonelist_scan:
13 z = zonelist->zones;
14 /* 遍历zonelist来找到一个有足够空闲页的zone */
15 do {
16 /* 检查标志看是否能在这个节点分配 */
17 if (unlikely(alloc_should_filter_zonelist(zonelist))) {
18 if (highest_zoneidx == -1)
19 highest_zoneidx = gfp_zone(gfp_mask);
20 if (zone_idx(*z) > highest_zoneidx)
21 continue;
22 }
23
24 if (NUMA_BUILD && zlc_active && !zlc_zone_worth_trying(zonelist, z, allowednodes))
25 continue;
26 zone = *z;
27 /* 检查CPU限制 */
28 if ((alloc_flags & ALLOC_CPUSET) &&
29 !cpuset_zone_allowed_softwall(zone, gfp_mask))
30 goto try_next_zone;
31 /* 检查标志和限制 */
32 if (!(alloc_flags & ALLOC_NO_WATERMARKS)) {
33 unsigned long mark;
34 if (alloc_flags & ALLOC_WMARK_MIN)
35 mark = zone->pages_min;
36 else if (alloc_flags & ALLOC_WMARK_LOW)
37 mark = zone->pages_low;
38 else
39 mark = zone->pages_high;
40 if (!zone_watermark_ok(zone, order, mark, classzone_idx, alloc_flags)) {
41 if (!zone_reclaim_mode || !zone_reclaim(zone, gfp_mask, order))
42 goto this_zone_full;
43 }
44 }
45 /* 正在的分配 */
46 page = buffered_rmqueue(zonelist, zone, order, gfp_mask);
47 if (page)
48 break;
49 this_zone_full:
50 /* 标志为满？？ */
51 if (NUMA_BUILD)
52 zlc_mark_zone_full(zonelist, z);
53 try_next_zone:
54 /* 设置缓存的标志 */
55 if (NUMA_BUILD && !did_zlc_setup) {
56 allowednodes = zlc_setup(zonelist, alloc_flags);
57 zlc_active = 1;
58 did_zlc_setup = 1;
59 }
60 } while (*(++z) != NULL);
61 /* 禁用缓存再来一次，不行就放弃 */
62 if (unlikely(NUMA_BUILD && page == NULL && zlc_active)) {
63 zlc_active = 0;
64 goto zonelist_scan;
65 }
66 return page;
67 }
68 /* 在这里分成两种选择，是从缓存中取还是从伙伴系统中取？ */
69 static struct page *buffered_rmqueue(struct zonelist *zonelist, struct zone *zone, int order, gfp_t gfp_flags)
70 {
71 unsigned long flags;
72 struct page *page;
73 int cold = !!(gfp_flags & __GFP_COLD);
74 struct per_cpu_pageset *pset;
75 int migratetype = allocflags_to_migratetype(gfp_flags);
76 int this_cpu;
77 again:
78 /* 取到per_cpu_pageset */
79 pset = get_zone_pcp(zone, &flags, &this_cpu);
80 /* 如果分配单页，这种情况占大多数 */
81 if (likely(order == 0)) {
82 /* 取得pcp */
83 struct per_cpu_pages *pcp = &pset->pcp;
84 /* 如果缓存上没有页 */
85 if (!pcp->count) {
86 /* 分配batch的页来填充缓存 */
87 pcp->count = rmqueue_bulk(zone, 0, pcp->batch, &pcp->list, migratetype);
88 if (unlikely(!pcp->count))
89 goto failed;
90 }
91 /* 遍历缓存分配 */
92 if (cold) {
93 list_for_each_entry_reverse(page, &pcp->list, lru)
94 if (page_private(page) == migratetype)
95 break;
96 } else {
97 list_for_each_entry(page, &pcp->list, lru)
98 if (page_private(page) == migratetype)
99 break;
100 }
101
102 /* 如果需要的话分配更多的缓存 */
103 if (unlikely(&page->lru == &pcp->list)) {
104 pcp->count += rmqueue_bulk(zone, 0, pcp->batch, &pcp->list, migratetype);
105 page = list_entry(pcp->list.next, struct page, lru);
106 }
107
108 list_del(&page->lru);
109 pcp->count--;
110 } else {
111 /* 如果不是单页就不能从缓存上分配了 */
112 spin_lock(&zone->lock);
113 page = __rmqueue(zone, order, migratetype);
114 spin_unlock(&zone->lock);
115 if (!page)
116 goto failed;
117 }
118
119 __count_zone_vm_events(PGALLOC, zone, 1 << order);
120 /* 更新统计信息? */
121 zone_statistics(zonelist, zone);
122 /* 释放锁? */
123 put_zone_pcp(zone, flags, this_cpu);
124
125 VM_BUG_ON(bad_range(zone, page));
126 if (prep_new_page(page, order, gfp_flags))
127 goto again;
128 return page;
129 failed:
130 put_zone_pcp(zone, flags, this_cpu);
131 return NULL;
132 }
133 /* 从伙伴系统中remove一项 */
134 static struct page *__rmqueue(struct zone *zone, unsigned int order, int migratetype)
135 {
136 struct page *page;
137 /* 选择尽可能小的页移除 */
138 page = __rmqueue_smallest(zone, order, migratetype);
139 /* */
140 if (unlikely(!page))
141 page = __rmqueue_fallback(zone, order, migratetype);
142
143 return page;
144 }
145 /* 选择尽可能小的页移除 */
146 static struct page *__rmqueue_smallest(struct zone *zone, unsigned int order, int migratetype)
147 {
148 unsigned int current_order;
149 struct free_area * area;
150 struct page *page;
151
152 for (current_order = order; current_order < MAX_ORDER; ++current_order) {
153 area = &(zone->free_area[current_order]);
154 /* 如果这个free_area是空的，那就直接去从更大的order里面找 */
155 if (list_empty(&area->free_list[migratetype]))
156 continue;
157 /* 从free_area里面随便找一个删除 */
158 page = list_entry(area->free_list[migratetype].next, struct page, lru);
159 list_del(&page->lru);
160 /* 清除buddy标志并设置private为0 */
161 rmv_page_order(page);
162 area->nr_free--;
163 /* 在不能中断的时候使用 */
164 __mod_zone_page_state(zone, NR_FREE_PAGES, - (1UL << order));
165 /* 分割页 */
166 expand(zone, page, order, current_order, area, migratetype);
167 return page;
168 }
169 return NULL;
170 }
171 /* 如果是一个大页，就把剩下的放回 */
172 static inline void expand(struct zone *zone, struct page *page, int low, int high, struct free_area *area, int migratetype)
173 {
174 unsigned long size = 1 << high;
175
176 while (high > low) {
177 area--;
178 high--;
179 size >>= 1;
180 VM_BUG_ON(bad_range(zone, &page[size]));
181 /* 这个貌似是在尾部，其实是在在头部开刀，坑爹啊 */
182 list_add(&page[size].lru, &area->free_list[migratetype]);
183 area->nr_free++;
184 set_page_order(&page[size], high);
185 }
186 }
187 /* 从fallback list中找页（其实我看的也不是太懂，是不是如果我想分配一种但是没有了，就从其他的类型中分配？） */
188 static struct page *__rmqueue_fallback(struct zone *zone, int order, int start_migratetype)
189 {
190 struct free_area * area;
191 int current_order;
192 struct page *page;
193 int migratetype, i;
194 /* 这次改用从大到小遍历，应该能更快找到空闲页？ */
195 for (current_order = MAX_ORDER-1; current_order >= order; --current_order) {
196 /* 遍历所有类型 */
197 for (i = 0; i < MIGRATE_TYPES - 1; i++) {
198 migratetype = fallbacks[start_migratetype][i];
199 if (migratetype == MIGRATE_RESERVE)
200 continue;
201
202 area = &(zone->free_area[current_order]);
203 if (list_empty(&area->free_list[migratetype]))
204 continue;
205 /* 下面的内容就差不多了 */
206 page = list_entry(area->free_list[migratetype].next, struct page, lru);
207 area->nr_free--;
208
209 if (unlikely(current_order >= (pageblock_order >> 1)) || start_migratetype == MIGRATE_RECLAIMABLE) {
210 unsigned long pages;
211 pages = move_freepages_block(zone, page, start_migratetype);
212
213 if (pages >= (1 << (pageblock_order-1)))
214 set_pageblock_migratetype(page, start_migratetype);
215
216 migratetype = start_migratetype;
217 }
218
219 list_del(&page->lru);
220 rmv_page_order(page);
221 __mod_zone_page_state(zone, NR_FREE_PAGES, -(1UL << order));
222
223 if (current_order == pageblock_order)
224 set_pageblock_migratetype(page, start_migratetype);
225
226 expand(zone, page, order, current_order, area, migratetype);
227 return page;
228 }
229 }
230 /* 实在不行就。。。*/
231 return __rmqueue_smallest(zone, order, MIGRATE_RESERVE);
232 }
以前在看书的时候有个问题不怎么清楚，在释放page的时候怎么知道它在freearea中的位置？所有的答案都在代码中：
1 /* 释放页的入口 */
2 void __free_pages(struct page *page, unsigned int order)
3 {
4 if (put_page_testzero(page)) {
5 if (order == 0)
6 free_hot_page(page); /* 如果是单页就放到页缓存中 */
7 else
8 __free_pages_ok(page, order); /* 释放非单页 */
9 }
10 }
11 void free_hot_page(struct page *page)
12 {
13 free_hot_cold_page(page, 0);
14 }
15 /* 释放“冷页”或者“惹页” */
16 static void free_hot_cold_page(struct page *page, int cold)
17 {
18 struct zone *zone = page_zone(page);
19 struct per_cpu_pageset *pset;
20 struct per_cpu_pages *pcp;
21 unsigned long flags;
22 int this_cpu;
23 /* 检查是不是匿名页？ 没有映射过的？ */
24 if (PageAnon(page))
25 page->mapping = NULL;
26 /* 检查标志位 */
27 if (free_pages_check(page))
28 return;
29 /* 如果是highmem */
30 if (!PageHighMem(page))
31 debug_check_no_locks_freed(page_address(page), PAGE_SIZE);
32 arch_free_page(page, 0);
33 kernel_map_pages(page, 1, 0);
34
35 /* 取得pcp */
36 pset = get_zone_pcp(zone, &flags, &this_cpu);
37 pcp = &pset->pcp;
38
39 count_vm_event(PGFREE);
40
41 if (cold)
42 list_add_tail(&page->lru, &pcp->list);
43 else
44 list_add(&page->lru, &pcp->list);
45 set_page_private(page, get_pageblock_migratetype(page));
46 pcp->count++;
47 /* 如果已经超过阀值，那么就释放batch个页到伙伴系统 */
48 if (pcp->count >= pcp->high) {
49 free_pages_bulk(zone, pcp->batch, &pcp->list, 0);
50 pcp->count -= pcp->batch;
51 }
52 /* 释放锁? */
53 put_zone_pcp(zone, flags, this_cpu);
54 }
55 static void __free_pages_ok(struct page *page, unsigned int order)
56 {
57 unsigned long flags;
58 int reserved = 0;
59 int this_cpu;
60 int i;
61 /* 检查标志位 */
62 for (i = 0 ; i < (1 << order) ; ++i)
63 reserved += free_pages_check(page + i);
64 if (reserved)
65 return;
66 if (!PageHighMem(page))
67 debug_check_no_locks_freed(page_address(page),PAGE_SIZE<<order);
68 arch_free_page(page, order);
69 kernel_map_pages(page, 1 << order, 0);
70
71 lock_cpu_pcp(&flags, &this_cpu);
72 count_vm_events(PGFREE, 1 << order);
73 /* 释放页 */
74 free_one_page(page_zone(page), page, order);
75 unlock_cpu_pcp(flags, this_cpu);
76 }
77 static void free_one_page(struct zone *zone, struct page *page, int order)
78 {
79 spin_lock(&zone->lock);
80 zone_clear_flag(zone, ZONE_ALL_UNRECLAIMABLE);
81 zone->pages_scanned = 0;
82 __free_one_page(page, zone, order);
83 spin_unlock(&zone->lock);
84 }
85 /* 答案就在这里 */
86 static inline void __free_one_page(struct page *page, struct zone *zone, unsigned int order)
87 {
88 unsigned long page_idx;
89 int order_size = 1 << order;
90 /* 取得type */
91 int migratetype = get_pageblock_migratetype(page);
92 /* 如果是复合页 */
93 if (unlikely(PageCompound(page)))
94 destroy_compound_page(page, order);
95
96 page_idx = page_to_pfn(page) & ((1 << MAX_ORDER) - 1);
97
98 VM_BUG_ON(page_idx & (order_size - 1));
99 VM_BUG_ON(bad_range(zone, page));
100
101 __mod_zone_page_state(zone, NR_FREE_PAGES, order_size);
102 /* 从小到大遍历 */
103 while (order < MAX_ORDER-1) {
104 unsigned long combined_idx;
105 struct page *buddy;
106 /* 找到伙伴（只是找到位置） */
107 buddy = __page_find_buddy(page, page_idx, order);
108 /* 判断是不是伙伴 */
109 if (!page_is_buddy(page, buddy, order))
110 break;
111 /* 把buddy从所在的链表中删除 */
112 list_del(&buddy->lru);
113 zone->free_area[order].nr_free--;
114 /* 修改标志位 */
115 rmv_page_order(buddy);
116 /* 找到合并后的位置 */
117 combined_idx = __find_combined_index(page_idx, order);
118 page = page + (combined_idx - page_idx);
119 page_idx = combined_idx;
120 order++;
121 }
122 /* 最后设置page */
123 set_page_order(page, order);
124 list_add(&page->lru, &zone->free_area[order].free_list[migratetype]);
125 zone->free_area[order].nr_free++;
126 }
127 static inline struct page * __page_find_buddy(struct page *page, unsigned long page_idx, unsigned int order)
128 {
129 /* 找到伙伴（这个理解起来还是很简单的） */
130 unsigned long buddy_idx = page_idx ^ (1 << order);
131 return page + (buddy_idx - page_idx);
132 }
这里的代码都很好理解，看的过程也都做了注释。先是定下策略，怎么找？找不到怎么办？然后找的时候检查标志，看是否用缓存。最后就是找的过程了。看的匆忙，难免有错的地方。
----------------------------
个人理解，欢迎拍砖。