2006-6-1
mm/page_alloc.c
纵观这个模块,实际上是buddy算法的核心所在.除了buddy算法的几个核心函数,
其余都是简单的再封装.
I) 全局量,概述
从头到尾的看吧.首先是几个变量的声明,这些变量是lru表的关键组成部分:
nt nr_swap_pages; /*可用(空闲)的swap page 数量*/
int nr_active_pages;/*active_list 中的ram页面个数*/
int nr_inactive_dirty_pages; /*inactive_dirty_list 中ram页面的个数*/
pg_data_t *pgdat_list; /*node 表*/
struct list_head active_list; /*像那些被频繁访问的页面*/
struct list_head inactive_dirty_list; /*修改过的，看起来最近不会被访问到
的一般已经从进程的页表中脱离*/
在分析mm/filemap.c的时候分析过lru. mm/memory.c中也稍有涉及,主要是从lru
表中恢复页面映射.
这里再次用一个图表看一下lru队列和操作lru的几个关键函数的作用:
mm->rss *********************************
|swap_out->try_to_swap_out
active_list->******************************* |
/\ | refill_inactive_scan
|page_launder \ / \ /
inactive_dirty_list->*****************************************************
| page_launder
\ / (wite back to disk if necessary)
zone_t->inactive_clean_pages->************* --- reclaim_page->直接使用
| kreclaimd->reclaim_page
\ /
zone_t->free_area(buddy)->***********************
这里除了定义lru的几个队列再无其他和lru相关的东西了,我也就是这样简单
提提.
接下来是关于zone的一组参数:(没有什么好解释的)
/*zone 参数*/
static char *zone_names[MAX_NR_ZONES] = { "DMA", "Normal", "HighMem" };
static int zone_balance_ratio[MAX_NR_ZONES] = { 32, 128, 128, };
static int zone_balance_min[MAX_NR_ZONES] = { 10 , 10, 10, };
static int zone_balance_max[MAX_NR_ZONES] = { 255 , 255, 255, };
II)Buddy 算法核心
最后开始理解最终要的buddy系统,为了说明白算法到底如何工作,我们先来引入
几个重要的概念:
1)某组page:
假设order是2,则page_idx是0-3的是一组,4-7是一组.组中最低地址的那个页
面代表这个组连接进area的list链表，并且组内其他page不会存在于其他任何area
的list。
2)组对(相关组):
area中有两个重要的数据结构:
(1)list : 属于此order(area)的pgae,或者page组的链表
(2)*map : 每一位代表一对相关组(buddy)。所谓相关组就是可以合并成更高
order的两个连续page组,我们也称之为相关组.
map中的组对bit位的意义我们暂且不说,当释放时0代表这对相关组的其中一组还
在使用,无法合并,如果释放是1则代表可以合并。初始值是0,对应的list也为空。
map中bit的意义对于理解buddy算法很有好处,可惜一直未能彻底搞明白,这次希
望运气好些.
通过对初始化的分析看看map中bit位的变化:
1)初始为0,也代表配对page无法合并吗?(显然不是)list也为空.内存初始化调用所
有页面的释放函数,挂入area0 的list,对应位置1.
2)配对的page释放后对应位又变成0,从list摘出先释放的那个一齐放入area1.(如果
重复释放某个page,page组,就会出现严重错误)
3)分配的时候,从areaX的list中出队,mapbit从0变成1,如果这时释放刚分配的page,
1代表可以合并.如果另一个组也分配出去了,位图又变成0,代表释放的时候不能合并.
此时不会在分配这两个组了,因为list中这两个组都已经出队.
所以,操作顺序,bitmap,和list相互配合完成buddy的管理.
仔细考虑,总结一下,map中的bit含义其实是:
0,相关组的状态一致
1,相关组的状态不同
(god,是个异或)
所以分配的时候反转两次,释放的时候反转两次.在看上面的分析:
1)初始为0,连个页面都处于使用中. 释放其中一个的时候,bit为0,代表状态相同,即
都在使用中(我们是在释放啊),我们释放完成后当然无法合并.同时我们释放其中一个
后反转bit,bit变成1,代表现在状态不同了.
2)当配对的一个释放时,发现bit是1,代表状态不同.因为这在使用中,所以另一个已经
释放,故这个释放后就可以合并了.这就是为什么释放时bit为0代表可以合并.
3)请自己分析。
Buddy算法的核心函数之一，__free_pages_ok:释放page组,根据bitmap判断buddy
page组的状态,合并buddy page组到更高的order.
/*
* Buddy system. Hairy. You really aren't expected to understand this
* (真的不期望你们理解这段代码---原作者)
* Hint: -mask = 1+~mask
*/
static void FASTCALL(__free_pages_ok (struct page *page, unsigned long order));
static void __free_pages_ok (struct page *page, unsigned long order)
{
unsigned long index, page_idx, mask, flags;
free_area_t *area;
struct page *base;
zone_t *zone;
//要释放的页面不能再有任何人使用了
if (page->buffers)
BUG();
..........//省略
//清除ref,diry位,恢复其初始生命值
page->flags &= ~((1<<PG_referenced) | (1<<PG_dirty));
page->age = PAGE_AGE_START;
zone = page->zone;
mask = (~0UL) << order; // like: 111111110000,此order的mask
base = mem_map + zone->offset;
page_idx = page - base;
if (page_idx & ~mask) //~mask: 0000000001111,
BUG();// page_idx 必须是2^order的整倍数, xxxxxxxx0000
index = page_idx >> (1 + order); //index是指代表page_idx所指组对
//的位图索引,所以是idx>>order>>1
area = zone->free_area + order;
spin_lock_irqsave(&zone->lock, flags);
zone->free_pages -= mask; //-mask :00010000,2^order
while (mask + (1 << (MAX_ORDER-1))) {// 11xxxx00+001000000=000xxx00
struct page *buddy1, *buddy2;
if (area >= zone->free_area + MAX_ORDER)
BUG();
if (!test_and_change_bit(index, area->map))
//释放时如果为0，代表另一组还在使用中,并反转对应位
/*
* the buddy page is still allocated.
*/
break;
/*
* Move the buddy up one level.
*/
buddy1 = base + (page_idx ^ -mask);//-mask:00010000,疑惑取得另一个组
buddy2 = base + page_idx;
if (BAD_RANGE(zone,buddy1))
BUG();
if (BAD_RANGE(zone,buddy2))
BUG();
memlist_del(&buddy1->list);
mask <<= 1; //11xxxx00->11xxx000,更大的一个order
area++;
index >>= 1;
page_idx &= mask;//新order下代表组对的页面索引
//(清除一个bit,既,idx值小的那个组)
}
memlist_add_head(&(base + page_idx)->list, &area->free_list);
spin_unlock_irqrestore(&zone->lock, flags);
......
}
Buddy系统的另一个核心函数,expand:当指定的order,low无页面可以分配的时候
从oredr为high的area分配,将high中一个页面组依次向低order的area拆分,一次一
半,直至order为low的那个area为止.如,我们要order为1的页面组,从order为3的开
始分配, 8=4+2+(2),(2)代表我们所要的页面组.
static inline struct page * expand (zone_t *zone, struct page *page,
unsigned long index, int low, int high, free_area_t * area)
{
//low :目标order high: 从此order的area分配
//page: order为high 的页面组
//index:page组在order为high的area中的位图索引
unsigned long size = 1 << high;
while (high > low) {//分解到low
if (BAD_RANGE(zone,page))
BUG();
area--; //lower area
high--; //lower order
size >>= 1;//size 减半
memlist_add_head(&(page)->list, &(area)->free_list);//将拆分的头一个组
//入低级别的area
MARK_USED(index, high, area);//在此低级别的area中反转状态
index += size;//低一个order的位图索引
page += size; //留下同一对的后一个组分配给用户
}
if (BAD_RANGE(zone,page))
BUG();
return page;
}
分析完expand后对于rmqueue应该不难了:
static struct page * rmqueue(zone_t *zone, unsigned long order)
{
free_area_t * area = zone->free_area + order;
unsigned long curr_order = order;
struct list_head *head, *curr;
unsigned long flags;
struct page *page;
spin_lock_irqsave(&zone->lock, flags); /*only __free_pages_ok show_free_areas_core and this */
do {//指定的order可能没有页面了,要依次向高order的area遍历
head = &area->free_list;
curr = memlist_next(head);
if (curr != head) {//还有页面可以分配
unsigned int index;
page = memlist_entry(curr, struct page, list);
if (BAD_RANGE(zone,page))
BUG();
memlist_del(curr);
index = (page - mem_map) - zone->offset;
MARK_USED(index, curr_order, area);//反转状态
zone->free_pages -= 1 << order;
page = expand(zone, page, index, order, curr_order, area);
spin_unlock_irqrestore(&zone->lock, flags);
set_page_count(page, 1);
if (BAD_RANGE(zone,page))
BUG();
DEBUG_ADD_PAGE
return page;
}
//如果此order的area无页面就试试高一个order的area
curr_order++;
area++;
} while (curr_order < MAX_ORDER);
spin_unlock_irqrestore(&zone->lock, flags);
return NULL;
}
III) __alloc_pages:基于zone的buddy系统分配的核心策略
先看一个内部接口函数,按照指定的可回收页面(free+inactive clean)的水
位寻找合适的zone分配page:
static struct page * __alloc_pages_limit(zonelist_t *zonelist,
unsigned long order, int limit, int direct_reclaim)
{
//limit指定按照什么水位寻找zone,有三种标准,PAGES_MIN,PAGES_LOW,PAGES_HIGH
zone_t **zone = zonelist->zones;
for (;;) {
zone_t *z = *(zone++);
unsigned long water_mark;
if (!z)
break;
if (!z->size)
BUG();
/*
* We allocate if the number of free + inactive_clean
* pages is above the watermark.
*/
switch (limit) {
default:
case PAGES_MIN: //只要拥有z->pages_min这么多的空闲页面即可
water_mark = z->pages_min;
break;
case PAGES_LOW:
water_mark = z->pages_low;
break;
case PAGES_HIGH:
water_mark = z->pages_high;
}
if (z->free_pages + z->inactive_clean_pages > water_mark) {
struct page *page = NULL;
/* If possible, reclaim a page directly. */
if (direct_reclaim && z->free_pages < z->pages_min + 8)
page = reclaim_page(z);
/* If that fails, fall back to rmqueue. */
if (!page)
page = rmqueue(z, order);
if (page)
return page;
}
}
/* Found nothing. */
return NULL;
}
这里说的可回收页面包括两个部分即:free_pages+inactive_clean_pages.
__alloc_pages处于内核内存管理的最底层,无论slab,vmallc,kmalloc,mmap,brk
还是page cache,buffer都要通过__alloc_pages获取最基本的物理内存pages.
linux执行这样一种内存管理策略:
a)充分利用物理内存,建立各种cache,优化程序性能,减少磁盘操作.这一点和win
dows系统不同,windows系统中总是有很多内存空闲,即便是进行了大量的磁盘操作后.
而linux中真正空闲的物理内存几乎就看不到.
b)保证有足够的潜在物理内存(页面),可以立即加以回收,或称潜在可分配页面.通
过内核的守护进程kswapd,bdflush,kreclaimd的定期处理,加上每次内存分配对系统
的调整,即通过__alloc_pages所遇到的各种内存分配压力,不断的调整守护进程的工
作方向,保证系统拥有足够的潜在可回收内存.
先看看对内存页面有些什么样的保有量要求:
1)可分配页面的保有量要求:inactive_clean+free pages(in buddy pages)
系统的期望值是freepages.high + inactive_target / 3,inactive_target就是
min((memory_pressure >> INACTIVE_SHIFT),num_physpages / 4)).可见期望的保
有量有动态的因素在内.
现在的保有量是nr_free_pages() + nr_inactive_clean_pages();
mm/vmscan.c中的函数free_shortage,计算期望的可分配页面和现实之差距.如果
保有量合格,但看zone中的inbuddy free pages是比期望值少.只要有一个保有量不
合格,就必须立即加以调整.free_shortage请自己阅读.
2)潜在可分配页面的保有量要求:(buddyfree+inactiveclean+inactive_dirty)
期望保有量:freepages.high+inactive_target
现存量:
nr_free_pages()+nr_inactive_clean_pages()+nr_inactive_dirty_pages.
所做分析已注入代码:
/*
* 基于区的buddy 系统的核心策略
* This is the 'heart' of the zoned buddy allocator:
*/
struct page * __alloc_pages(zonelist_t *zonelist, unsigned long order)
{
zone_t **zone;
int direct_reclaim = 0;
unsigned int gfp_mask = zonelist->gfp_mask;
struct page * page;
/*
* Allocations put pressure on the VM subsystem.
*/
memory_pressure++;
/*
* (If anyone calls gfp from interrupts nonatomically then it
* will sooner or later tripped up by a schedule().)
*
* We are falling back to lower-level zones if allocation
* in a higher zone fails.
*/
/*
* Can we take pages directly from the inactive_clean
* list?
*/
/* PF_MEMALLOC 代表是为管理目的而请求分配pages */
if (order == 0 && (gfp_mask & __GFP_WAIT) &&
!(current->flags & PF_MEMALLOC))
direct_reclaim = 1;
/*
* If we are about to get low on free pages and we also have
* an inactive page shortage, wake up kswapd.
*/
if (inactive_shortage() > inactive_target / 2 && free_shortage())
wakeup_kswapd(0);/*用各种办法保持潜在可分配页面的数量*/
/*
* If we are about to get low on free pages and cleaning
* the inactive_dirty pages would fix the situation,
* wake up bdflush.
*/
else if (free_shortage() && nr_inactive_dirty_pages > free_shortage()
&& nr_inactive_dirty_pages >= freepages.high)
wakeup_bdflush(0);/*加速将buffer中的数据写入磁盘的过程*/
try_again:
/*
* 首先,选取那些拥有许多的空闲内存的zone
* We allocate free memory first because it doesn't contain
* any data ... DUH!
*/
/* 这轮分配只看绝对空闲页的水位*/
zone = zonelist->zones;
for (;;) {
zone_t *z = *(zone++);
if (!z)
break;
if (!z->size)
BUG();
if (z->free_pages >= z->pages_low) {//空闲页面保有量合格
page = rmqueue(z, order);
if (page)
return page;
} else if (z->free_pages < z->pages_min &&
waitqueue_active(&kreclaimd_wait)) {
wake_up_interruptible(&kreclaimd_wait);
/* kreclaimd:从zone_t->inactive_clean_list 队列中回收页面 */
}
}
/* If there is a lot of activity, inactive_target
* will be high and we'll have a good chance of
* finding a page using the HIGH limit.
*/
/*既然找不到空闲页面较多的zone,就找inactive_clean页面很
*丰富的zone试试
*/
page = __alloc_pages_limit(zonelist, order, PAGES_HIGH, direct_reclaim);
if (page)
return page;
/*
* 还不行就找inactive_clean页面还行的zone
* zone->pages_low < free + inactive_clean
* When the working set is very large and VM activity
* is low, we're most likely to have our allocation
* succeed here.
*/
page = __alloc_pages_limit(zonelist, order, PAGES_LOW, direct_reclaim);
if (page)
return page;
/*
* 没有zone 的空闲页面(buddy+inactive clean)能够满足需求了
*
* We wake up kswapd, in the hope that kswapd will
* resolve this situation before memory gets tight.
*
* We also yield the CPU, because that:
* - gives kswapd a chance to do something
* - slows down allocations, in particular the
* allocations from the fast allocator that's
* causing the problems ...
* - ... which minimises the impact the "bad guys"
* have on the rest of the system
* - if we don't have __GFP_IO set, kswapd may be
* able to free some memory we can't free ourselves
*/
wakeup_kswapd(0); /* 参数0, 代表不睡眠*/
/* kswapd -->致力于保持潜在可分配页面的保有量*/
if (gfp_mask & __GFP_WAIT) {
__set_current_state(TASK_RUNNING);
current->policy |= SCHED_YIELD;
schedule();
}
/*
* After waking up kswapd, we try to allocate a page
* from any zone which isn't critical yet.
*
* 也许我们不能等Kswapd 完成他的工作
* 先以更低的水位要求试试
*/
page = __alloc_pages_limit(zonelist, order, PAGES_MIN, direct_reclaim);
if (page)
return page;
/*
* Damn, we didn't succeed.
*
*/
/* 对于普通进程还有情况我们可以 考虑到*/
if (!(current->flags & PF_MEMALLOC)) {
if (order > 0 && (gfp_mask & __GFP_WAIT)) {
/* 我们在处理 higher order 的分配,并且可以等待 */
zone = zonelist->zones;
/*将dirty页面写入磁盘*/
current->flags |= PF_MEMALLOC; //page_launder 也可能分配页面
page_launder(gfp_mask, 1); //这个进程作为调用环境,提升其
current->flags &= ~PF_MEMALLOC;//优先级避免递归运行到这里
for (;;) {
zone_t *z = *(zone++);
if (!z)
break;
if (!z->size)
continue;
while (z->inactive_clean_pages) {
/*补充空闲页面到buddy*/
struct page * page;
/* Move one page to the free list. */
page = reclaim_page(z);
if (!page)
break;
__free_page(page); //释放到buddy
/*也许就有连续页面了*/
/* Try if the allocation succeeds. */
page = rmqueue(z, order); //再试试high_order 的分配
if (page)
return page;
}
}
}
/*
* We have to do this because something else might eat
* the memory kswapd frees for us and we need to be
* reliable.
*/
if ((gfp_mask & (__GFP_WAIT|__GFP_IO)) == (__GFP_WAIT|__GFP_IO)) {
/* 如果容许io操作,并可以等待,唤醒kswapd
* 并等待kswapd 恢复内存的平衡状态
*/
wakeup_kswapd(1); /* 参数1, 代表可以阻塞*/
memory_pressure++;
if (!order) //* 主意:我们在higher order 时不'again',
// 因为,可能kswapd 永远( *ever* )不能为我们
// 释放出一个大的连续区域.
goto try_again;
/*
* If __GFP_IO isn't set, we can't wait on kswapd because
* kswapd just might need some IO locks /we/ are holding ...
*
* SUBTLE: The scheduling point above makes sure that
* kswapd does get the chance to free memory we can't
* free ourselves...
*/
} else if (gfp_mask & __GFP_WAIT) {
//不能进行io的情况下代替kswapd做些
//不进行io 努力
try_to_free_pages(gfp_mask);
memory_pressure++;
if (!order)
goto try_again;
}
}
/*
* Final phase: allocate anything we can!
*
* Higher order allocations, GFP_ATOMIC allocations and
* recursive allocations (PF_MEMALLOC) end up here.
*
* Only recursive allocations can use the very last pages
* in the system, otherwise it would be just too easy to
* deadlock the system...
*/
zone = zonelist->zones;
for (;;) {
zone_t *z = *(zone++);
struct page * page = NULL;
if (!z)
break;
if (!z->size)
BUG();
/*
* SUBTLE: direct_reclaim is only possible if the task
* becomes PF_MEMALLOC while looping above. This will
* happen when the OOM killer selects this task for
* instant execution...(看英文吧)
*/
if (direct_reclaim) {
page = reclaim_page(z);
if (page)
return page;
}
/* XXX: is pages_min/4 a good amount to reserve for this? */
if (z->free_pages < z->pages_min / 4 &&
!(current->flags & PF_MEMALLOC))
continue;
page = rmqueue(z, order);
if (page)
return page;
}
/* No luck.. */
printk(KERN_ERR "__alloc_pages: %lu-order allocation failed.\n", order);
return NULL;
}
与内存分配有关的函数还有:
unsigned long get_zeroed_page(int gfp_mask)
void __free_pages(struct page *page, unsigned long order)
void free_pages(unsigned long addr, unsigned long order)
另外还有几个用于统计内存压力的函数:
unsigned int nr_free_pages (void)
unsigned int nr_inactive_clean_pages (void)
unsigned int nr_free_buffer_pages (void)
unsigned int nr_free_highpages (void)
这些函数较为简单,不再分析.
IV)zone 初始化的相关函数
重点来看看2.4的zonelist.不知道你是否有疑问,其实2.4的zonelist用处不是
想象的那么大,还没有成熟,或者说还没有写完.
2.4的pgdata,zonelist的关系如下图:
+---------+ zone_list
pgdat->node_zonelist |zone_list|-----> +--------+
+---------+ | normal?+
256个 + dma? +
+---------+ | high? +
+--------+
zone_list中第一个zone的类型是由zone_list在node_zonelist中的索引所决定
的,即由GFP_XXX决定.
可惜看GFP的定义,根本不能够有256个,这是其一. 其次,pgdat中的zone_list都
是指向本node的zone,而不是依据距node的距离排列,这就起不到node分区的本意.看
函数 alloc_pages(mm/numa.c),是在pgdat之间遍历而已,并无优先级的考虑.
再看mm/page_alloc.c中的build_zonelists:
static inline void build_zonelists(pg_data_t *pgdat)
{
int i, j, k;
for (i = 0; i < NR_GFPINDEX; i++) {//依次设置pgdat->node_zonelist[GPF]
zonelist_t *zonelist;
zone_t *zone;
zonelist = pgdat->node_zonelists + i;
memset(zonelist, 0, sizeof(*zonelist));
zonelist->gfp_mask = i;
j = 0;
k = ZONE_NORMAL;
if (i & __GFP_HIGHMEM)
k = ZONE_HIGHMEM;
if (i & __GFP_DMA)
k = ZONE_DMA;
switch (k) {
default:
BUG();
/*
* fallthrough:(注意没有break,若请求dma无可替代)
*/
case ZONE_HIGHMEM:
zone = pgdat->node_zones + ZONE_HIGHMEM;
if (zone->size) {
#ifndef CONFIG_HIGHMEM
BUG();
#endif
zonelist->zones[j++] = zone;
}
case ZONE_NORMAL:
zone = pgdat->node_zones + ZONE_NORMAL;
if (zone->size)
zonelist->zones[j++] = zone;
case ZONE_DMA:
zone = pgdat->node_zones + ZONE_DMA;
if (zone->size)
zonelist->zones[j++] = zone;
}
zonelist->zones[j++] = NULL;
}
}
和2.6的内核对比一下,2.6中结构变成:
+---------+ zone_list
pgdat->node_zonelist |zone_list|-----> +--------+
+---------+ | nodes*3+
3个 + +
+---------+ | +
| n.d.h | +--------+
不详细分析2.6中的相关代码了.
最后剩下函数free_area_init_core,在分析mm/memory.c的时候曾详细讨论过他
设置mem_map的方式,请参考理解free_area_init_core对mem_map的初始化,这里简
单讨论对zone和buddy的初始化,就不列出详细的代码了:
/*
* 设置一个节点的zone:
* - 所有的页面标记为保留 reserved
* - page 中所以内存队列为空
* - 清空区内buddy系统位图
* nid 节点号 pgdat 节点
* gmap 全局mem map zones_size 节点区大小数组
* zone_start_paddr 节点开始的物理地址
* zholes_size 节点空洞大小数组
* lmem_map 节点本地mem map数组
*/
void __init free_area_init_core(int nid, pg_data_t *pgdat,
struct page **gmap, unsigned long *zones_size ,
unsigned long zone_start_paddr, unsigned long *zholes_size,
struct page *lmem_map)
{
/* NON_NUMA:(like i386) pgdat:contig_page_data,gmap:&mem_map, lmem_map:0
* NUMA:(like i64-sn1): pgdat:NOD_PGDAT , gmap:&discard, lmem_map:0
* mem_map 恒定为PAGE_OFFSET
*/
struct page *p;
unsigned long i, j;
unsigned long map_size;
unsigned long totalpages, offset, realtotalpages;
unsigned int cumulative = 0;
/*计算总页面数目*/
....
/*总页面数减去每个区的空洞大小*/
...
/*
* 对lmem_map和全局mem_map的初始化,参考mm/memory.c的分析
*/
map_size = (totalpages + 1)*sizeof(struct page);
if (lmem_map == (struct page *)0) {
lmem_map = (struct page *) alloc_bootmem_node(pgdat, map_size);
lmem_map = (struct page *)(PAGE_OFFSET +
MAP_ALIGN((unsigned long)lmem_map - PAGE_OFFSET));
}
*gmap = pgdat->node_mem_map = lmem_map;
pgdat->node_size = totalpages;
pgdat->node_start_paddr = zone_start_paddr;
pgdat->node_start_mapnr = (lmem_map - mem_map);
/*
* 初始状态下所有的页面都是保留的 - 空闲页面在早期初始化完成之后
* 由 free_all_bootmem() 一次性统一释放.
*/
for (p = lmem_map; p < lmem_map + totalpages; p++) {
set_page_count(p, 0);
SetPageReserved(p);
init_waitqueue_head(&p->wait);
memlist_init(&p->list);
}
offset = lmem_map - mem_map;
for (j = 0; j < MAX_NR_ZONES; j++) {//初始化zone,3个
zone_t *zone = pgdat->node_zones + j;
unsigned long mask;
unsigned long size, realsize;
realsize = size = zones_size[j];
if (zholes_size)
realsize -= zholes_size[j];
printk("zone(%lu): %lu pages.\n", j, size);
zone->size = size;
........//初始化各个变量,省略
zone->zone_mem_map = mem_map + offset;
zone->zone_start_mapnr = offset;
zone->zone_start_paddr = zone_start_paddr;
/*
* 初始化本区内的page 的虚拟地址和所属区
*/
for (i = 0; i < size; i++) {
struct page *page = mem_map + offset + i;
page->zone = zone;
if (j != ZONE_HIGHMEM) {
page->virtual = __va(zone_start_paddr);
zone_start_paddr += PAGE_SIZE;
}
}
/*
* 初始化区内的buddy 系统
*/
offset += size;
mask = -1; //FFFFffff
for (i = 0; i < MAX_ORDER; i++) {
unsigned long bitmap_size;
memlist_init(&zone->free_area[i].free_list);
mask += mask;// 11110,11100,11000...
size = (size + ~mask) & mask;//向上对齐,是2^order的整倍数
bitmap_size = size >> i;
bitmap_size = (bitmap_size + 7) >> 3;
bitmap_size = LONG_ALIGN(bitmap_size);
zone->free_area[i].map =
(unsigned int *) alloc_bootmem_node(pgdat, bitmap_size);
}
}
build_zonelists(pgdat); //建立2.4的zonelist.
}
|
