Linux内存管理: 物理内存的分配与回收
接上文
大段代码警告
本文主要讲物理页面的分配以代码为主
有以下四个函数
- __alloc_pages
- rmqueue
- expand
- balance_classzone
请主要关注前三个函数. 特别是rmqueue与expand函数.
物理页面的分配
核心流程: __alloc_pages → \rightarrow →rmqueue → \rightarrow →expend
__alloc_pages
/*
* This is the 'heart' of the zoned buddy allocator:
* 函数参数
1.gfp_mask : 分配请求标志
2.order : 大小, 根据order 分配 2^order个物理页帧
3.zonelist : 指向node的node_zonelists某个元素, 里面指定了寻找要分配物理页的zone次序
* 函数功能:
分配2^order个页面
* 函数返回值
返回物理页帧描述符page, page指向页面块中第一个页面的起始地址。
*/
struct page * __alloc_pages(unsigned int gfp_mask, unsigned int order, zonelist_t *zonelist)
{
unsigned long min;
zone_t **zone, * classzone;
struct page * page;
int freed;
/*
1.zone指向zones数组,
2.classzone指向zones数组第一个元素
3.根据order计算实际分配页数(最少分配一个)
*/
zone = zonelist->zones;
classzone = *zone;
min = 1UL << order; //1UL代表 unsigned long(无符号长整型数)
/*
从第一个zone开始, 将请求大小与zone水位比较.
如果zone中的空闲页数大于 水位 pages_low+min
那么调用rmqueue分配物理页,
分配成功,返回第一个物理页的描述符地址
否则, 查询下一个zone
*/
for (;;) {
zone_t *z = *(zone++); // 相当于zone_t *z = *(zone[i])
if (!z)
// 循环结束, 即遍历完数组,退出循环
break;
min += z->pages_low; //累加计算水位
if (z->free_pages > min) { // 空闲页面足够多, 即 z->free_pages > ((1UL<< order) + z->pages_low + 之前pages->low的累加和)
page = rmqueue(z, order);// 从z中分配 2^order个页帧
if (page) // 分配成功
return page; //返回物理页帧描述符page, page指向页面块中第一个页面的起始地址。
}
}
/*
上面分配未成功,即各zone都超过水位pages_low了,设置classzone的need_balance标志
同时唤醒 kswapd, 期待它能将某些物理页交换出去
*/
classzone->need_balance = 1;
mb();
if (waitqueue_active(&kswapd_wait))
//唤醒 kswapd
wake_up_interruptible(&kswapd_wait);
/*
1.kswapd唤醒后, 重新检查有没有空闲页
2.重新顺序遍历zonelist中的各个zone
3.如果zone的空闲页数大于请求大小+水位pages_min,调用rmqueue分配
其中如果请求标志为不可等, 那么将水位暂时除以4再比较
4.若分配成功,则返回首页描述符
*/
zone = zonelist->zones;
min = 1UL << order;
for (;;) {
unsigned long local_min;
zone_t *z = *(zone++); // 相当于zone_t *z = *(zone[i])
if (!z)
// 循环结束, 即遍历完数组,退出循环
break;
local_min = z->pages_min;
if (!(gfp_mask & __GFP_WAIT)) //请求标志不可等待
local_min >>= 2; // local_min=(local_min/4)
min += local_min; //累加水位
if (z->free_pages > min) { //足够的空闲页面
page = rmqueue(z, order);// 从z中分配 2^order个页帧
if (page)
//分配成功,返回page, page指向页面块中第一个页面的起始地址。
return page;
}
}
/* here we're in the low on memory slow path */
rebalance:
/*
上述分配未成功, 检查当前进程标志,
如果具有PF_MEMALLOC 或 PF_MEMDIE其中的一个, 直接调用rmqueue分配
通常情况下, 进程标志为PF_MEMALLOC 或 PF_MEMDIE的 可能是 kswapd, oom killers
*/
if (current->flags & (PF_MEMALLOC | PF_MEMDIE)) {
// 具有PF_MEMALLOC 或 PF_MEMDIE其中的一个, 直接调用rmqueue分配
zone = zonelist->zones; //zones数组
for (;;) {
zone_t *z = *(zone++);//遍历数组
if (!z)
//数据遍历完成,跳出循环
break;
//直接从z中分配 2^order个页帧
page = rmqueue(z, order);
if (page)
//分配成功,返回page, page指向页面块中第一个页面的起始地址。
return page;
}
//分配不成功, 返回NULL
return NULL;
}
/*
没有足够的空闲物理页满足请求
如果请求标志又是不可等, 直接返回NULL
*/
/* Atomic allocations - we can't balance anything */
if (!(gfp_mask & __GFP_WAIT))
//没有足够的物理页帧满足请求, 且请求标志是不可等待
//直接返回NULL
return NULL;
//1.尝试将classzone中的物理页释放
page = balance_classzone(classzone, gfp_mask, order, &freed);
if (page)
//1.1释放成功, 返回page
return page;
//1.2 这里即,balance_classzone释放未成功
/*
再次查看水位 pages_min,如果空闲页数够了,调用rmqueue分配
再次查看原因, 上面操作可能释放了某些物理页
*/
zone = zonelist->zones;
min = 1UL << order;
for (;;) {
zone_t *z = *(zone++); //遍历数组
if (!z)
//遍历完成
break;
//累加水位
min += z->pages_min;
if (z->free_pages > min) {
//有足够的空闲页面, 分配2^order个页面
page = rmqueue(z, order);
if (page)
//返回page, page指向页面块中第一个页面的起始地址。
return page;
}
}
/*请求太大了 kswapd操作代价很高, 即不分配连续的大块内存
Don't let big-order allocations loop */
if (order > 3)
return NULL;
/*等待CPU调度, 跳转到rebalance执行代码
Yield for kswapd, and try again */
current->policy |= SCHED_YIELD; //调度策略为等待调度
__set_current_state(TASK_RUNNING); //设置当前进程为运行状态
schedule(); //进行调度
goto rebalance;//回到rebalance标志再次分配页框
}
rmqueue
还记得free_area数组吗?
static struct page * rmqueue(zone_t *zone, unsigned int order){
free_area_t * area = zone->free_area + order; // 根据order将area指向相应的内存分组
unsigned int curr_order = order;
struct list_head *head, *curr;
unsigned long flags;
struct page *page;
spin_lock_irqsave(&zone->lock, flags); //上锁
do {
//指定的order没有页面了, 依次向高order的area遍历
// head指向free_list头部, curr指向第一个物理页
head = &area->free_list;
curr = memlist_next(head);
if (curr != head) { // 还有页面可以分配
unsigned int index;
//free_list不空, 从list中得到描述符
page = memlist_entry(curr, struct page, list);
//1.如果该物理页非法, 出错
if (BAD_RANGE(zone,page))
BUG();
//2.否则将该物理页从free_list中删除
memlist_del(curr);
index = page - zone->zone_mem_map; //得到当前 page在zone_mem_map数组中的下标
if (curr_order != MAX_ORDER-1)
/*如果不是在最大那组分配的, 将area的map相应位设为1*/
MARK_USED(index, curr_order, area);
zone->free_pages -= 1UL << order; //减少被分配的页数
//把大块连续物理内存分配到 小的连续的物理内存
page = expand(zone, page, index, order, curr_order, area);
spin_unlock_irqrestore(&zone->lock, flags); //释放锁
set_page_count(page, 1); //设置count为1,即page的引用计数为1
//对page进行合法性检查
if (BAD_RANGE(zone,page))
BUG();
if (PageLRU(page)) //page在active链表或者inactive链表中
BUG();
if (PageActive(page)) //page在active链表中
BUG();
return page;
}
/*
若该组没有找到连续的物理页来满足分配,尝试从更大的组中分配,
重复遍历直到遍历完最大组*/
curr_order++;
area++;
} while (curr_order < MAX_ORDER);
spin_unlock_irqrestore(&zone->lock, flags); //释放锁
//一直没有找到, 返回NULL
return NULL;
}
expend
大块连续物理内存拆分为小块物理内存
/*
*Buddy 核心函数
*函数功能:
当指定的order,low无页面可以分配的时候
将从order大的area一次一半拆分为 order小的area
*函数参数
low : 目标order
high : 当前free_area数组的下标
page : order为high的页面组
index: page组在order为high的area中的位图索引
*/
static inline struct page * expand (zone_t *zone, struct page *page,
unsigned long index, int low, int high, free_area_t * area)
{
unsigned long size = 1 << high;//high对应的连续物理内存的页框数
while (high > low) {
//从高order到低order遍历 for(int i=high;i>low;i--)
if (BAD_RANGE(zone,page)) //合法性检查
BUG();
area--; // 此时high对应的low area
high--; //从高order 向low order遍历
size >>= 1;//大块物理内存拆分为小块物理内存(一次一半)
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;
}
balance_classzone
分配不出来了, 需要平衡一下
static struct page * balance_classzone(zone_t * classzone, unsigned int gfp_mask, unsigned int order, int * freed)
{
struct page * page = NULL;
int __freed = 0;
// 1.不允许等待
if (!(gfp_mask & __GFP_WAIT))
goto out;//2.跳转到out, 退出函数
//3.若在中断中, 出错
if (in_interrupt())
BUG();
current->allocation_order = order; //设置当前进程的order
current->flags |= PF_MEMALLOC | PF_FREE_PAGES; //设置current的标志位
// 直接从classzone中释放页
__freed = try_to_free_pages(classzone, gfp_mask, order);
//再次清除标志位, 来保证free functions 不会继续把paes加入local_pages链表
current->flags &= ~(PF_MEMALLOC | PF_FREE_PAGES);
//判断pages是否在local_pages链表
if (current->nr_local_pages) {
//在local_pages链表
struct list_head * entry, * local_pages;
struct page * tmp;
int nr_pages;
//从链表头开始
local_pages = ¤t->local_pages;
if (likely(__freed)) { //分支预测优化...
// pages 被try_to_free_pages_zones()释放
/* pick from the last inserted so we're lifo */
entry = local_pages->next;
do { /* 循环, 直到找到一个tmp->index==order,且
tmp->zone等于classzone*/
//从链表中获得页帧
tmp = list_entry(entry, struct page, list);
/*
1.找到想要的的页面
2.判断tmp->index与order,且tmp属于正确的zone
*/
if (tmp->index == order && memclass(tmp->zone, classzone)) {
list_del(entry); // 从链表中删除
current->nr_local_pages--; //包含页帧减1
set_page_count(tmp, 1); // 设置tmp的count为1,准备释放
page = tmp;// 设置page准备返回, tmp要释放在local_pages中剩下的页帧
//保证释放的安全性
if (page->buffers) // 如果page存在缓冲区
BUG();
if (page->mapping)// 如果page存在文件映射
BUG();
if (!VALID_PAGE(page)) //如果page失效
BUG();
if (PageSwapCache(page)) //page属于交换区
BUG();
if (PageLocked(page)) //如果page被上锁
BUG();
if (PageLRU(page)) //如果page在active链表或者inactive链表中
BUG();
if (PageActive(page))//如果page在active链表
BUG();
if (PageDirty(page))//如果page为脏页
BUG();
break;
}
//循环, 找到下一个page继续检查
} while ((entry = entry->next) != local_pages);
}
//得到准备释放页帧的数量
nr_pages = current->nr_local_pages;
/* free in reverse order so that the global order will be lifo */
//遍历完local_pages链表
while ((entry = local_pages->prev) != local_pages) {
// 将entry从链表删除
list_del(entry);
//从entry中得到页帧
tmp = list_entry(entry, struct page, list);
//释放页帧
__free_pages_ok(tmp, tmp->index);
/*
如果nr_pages==0 但是此时list中还有物理页帧,
说明有人向local_pages中加入页帧,所以调用BUG(),
即如果nr_pages小于0,即有人向local_pages加入页帧,
所以要调用BUG()
*/
if (!nr_pages--)
BUG();
}
//表示页帧都被释放了
current->nr_local_pages = 0;
}
out:
//更新freed,说明释放页与否
*freed = __freed;
return page;//返回根据order与classzone找到的页帧
}