伙伴系统分配器 - __alloc_pages
kernel可以通过几个分配函数从伙伴系统分配页面：
alloc_pages
get_zeroed_page
get_dma_pages
这几个函数都是通过alloc_pages来实现页面分配的，而alloc_pages的核心实现就是__alloc_pages。
alloc_pages
在gfp.h中定义
#define alloc_pages(gfp_mask, order) \ alloc_pages_node(numa_node_id(), gfp_mask, order)
两个参数：@gfp_mask 申请标志位；@order 申请页面的阶数
MAX_ORDER是一个宏，定义了buddy系统最大的阶数，大于这个阶数的申请是注定失败的。系统缺省定义是11，也就是说2^11 = 2048个pages。这个值可以通过架构特定的配置FORCE_MAX_ZONEORDER来修改缺省值，一般来说我们不需要更改这个值。要注意的是GPU VPU等申请的连续内存区比较大，并且这些驱动不会频繁分配释放，系统不会通过buddy系统分配内存，而是使用预留内存的方式。
@gfp_mask可参看 伙伴系统分配器 分配掩码
numa_node_id获得当前执行CPU对应的node id
alloc_page_node
static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
unsigned int order)
{
if (unlikely(order >= MAX_ORDER))
return NULL;
/* Unknown node is current node */
if (nid < 0)
nid = numa_node_id();
return __alloc_pages(gfp_mask, order,
NODE_DATA(nid)->node_zonelists + gfp_zone(gfp_mask));
}
在alloc_pages_node中做了一件很重要的事，计算__alloc_pages的第三个参数NODE_DATA(nid)->node_zonelists + gfp_zone(gfp_mask)
第三个参数是用来通知__alloc_pages首先从该node的哪一个zone进行分配，node_zonelists是节点的zone链表，一般顺序是DMA, Normal, Highmem；
gfp_zone(gfp_mask)计算给定的分配域（包含在gfp_mask）中，所对应的zone偏移。这个偏移加上node_zonelists就是选择的内存域。
__alloc_pages
文件mm/page_alloc.c中实现，是zone buddy的核心分配函数，分析该函数前，我们先了解一些可能的标记和重要的辅助函数
辅助标记
kenel定义了一些函数需要使用的标记，用来控制内存区空闲页面数达到不同watermark时的分配行为
#define ALLOC_NO_WATERMARKS 0x01 /* don't check watermarks at all */ #define ALLOC_WMARK_MIN 0x02 /* use pages_min watermark */ #define ALLOC_WMARK_LOW 0x04 /* use pages_low watermark */ #define ALLOC_WMARK_HIGH 0x08 /* use pages_high watermark */ #define ALLOC_HARDER 0x10 /* try to alloc harder */ #define ALLOC_HIGH 0x20 /* __GFP_HIGH set */ #define ALLOC_CPUSET 0x40 /* check for correct cpuset */
这些标志用来表示也分配过程中，需要考虑当前内存区的哪些分配水印。内存区的三个水印：zone->pages_min, zone->page_low, zone->page_high
默认情况下，仅有内存域包含的页数大于page_high时，才会进行分配。
ALLOC_NO_WATERMARKS 完全不检查水印，也就是略过分配页的选择过程，直接调用buffered_rmqueue进行分配。
ALLOC_WMARK_MIN 在当前分配区使用zone->pages_min进行检查。
ALLOC_WMARK_LOW 在当前分配区使用zone->pages_low进行检查。
ALLOC_WMAEK_HIGH 在当前分配区使用zone->pages_high进行检查
ALLOC_HARDER 通知伙伴系统放宽检查限制，其实就是对水印给定的值乘以一个系数 3/4
ALLOC_HIGH 比HARDER更紧急的分配请求，进一步放宽限制
ALLOC_CPUSET 只能在当前节点相关连的内存节点进行分配。
zone_watermark_ok
上诉标志会在函数zone_watermark_ok中检查
1215 /*
1216 * Return 1 if free pages are above 'mark'. This takes into account the order
1217 * of the allocation.
1218 */
1219 int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
1220 int classzone_idx, int alloc_flags)
1221 {
1222 /* free_pages my go negative - that's OK */
1223 long min = mark;
1224 long free_pages = zone_page_state(z, NR_FREE_PAGES) - (1 << order) + 1;
1225 int o;
1226
1227 if (alloc_flags & ALLOC_HIGH)
1228 min -= min / 2;
1229 if (alloc_flags & ALLOC_HARDER)
1230 min -= min / 4;
1231
1232 if (free_pages <= min + z->lowmem_reserve[classzone_idx])
1233 return 0;
1234 for (o = 0; o < order; o++) {
1235 /* At the next order, this order's pages become unavailable */
1236 free_pages -= z->free_area[o].nr_free << o;
1237
1238 /* Require fewer higher order pages to be free */
1239 min >>= 1;
1240
1241 if (free_pages <= min)
1242 return 0;
1243 }
1244 return 1;
1245 }
返回1 表示满足给定的水印，0表示不满足。
zone_page_state返回给定zone的free pages数目。
1232 首先要判断空闲页面数目，分配给定的free_pages是否还能满足min 和z->lowmem_reserver[]，从这个可以看出lowmem_reserve是不包含min的。lowmem_reserve的作用有点小复杂，可以参考另外一篇文章lowmem_reserve的理解
1234 ~ 1243做循环，对于小于给定参数@order的buddy链表，要把他们的容量从free_pages中减去，因为这些页面对当前分配请求来说和非空闲页面没有区别，
1239 每一次循环，所需空闲页的最小值折半，这也是个经验算法。
1241 如果发现空闲页面小于mark，那么说明已经剩余的页面无法满足分配了，直接失败退出。
1244 表明当前内存zone满足分配的请求。
get_page_from_freelist
/*
* get_page_from_freelist goes through the zonelist trying to allocate
* a page.
*/
static struct page *
get_page_from_freelist(gfp_t gfp_mask, unsigned int order,
struct zonelist *zonelist, int alloc_flags)
{
struct zone **z;
struct page *page = NULL;
int classzone_idx = zone_idx(zonelist->zones[0]);
struct zone *zone;
nodemask_t *allowednodes = NULL;/* zonelist_cache approximation */
int zlc_active = 0; /* set if using zonelist_cache */
int did_zlc_setup = 0; /* just call zlc_setup() one time */
enum zone_type highest_zoneidx = -1; /* Gets set for policy zonelists */
zonelist_scan:
/*
* Scan zonelist, looking for a zone with enough free.
* See also cpuset_zone_allowed() comment in kernel/cpuset.c.
*/
z = zonelist->zones;
do {
/*
* In NUMA, this could be a policy zonelist which contains
* zones that may not be allowed by the current gfp_mask.
* Check the zone is allowed by the current flags
*/
if (unlikely(alloc_should_filter_zonelist(zonelist))) {
if (highest_zoneidx == -1)
highest_zoneidx = gfp_zone(gfp_mask);
if (zone_idx(*z) > highest_zoneidx)
continue;
}
if (NUMA_BUILD && zlc_active &&
!zlc_zone_worth_trying(zonelist, z, allowednodes))
continue;
zone = *z;
if ((alloc_flags & ALLOC_CPUSET) &&
!cpuset_zone_allowed_softwall(zone, gfp_mask))
goto try_next_zone;
if (!(alloc_flags & ALLOC_NO_WATERMARKS)) {
unsigned long mark;
if (alloc_flags & ALLOC_WMARK_MIN)
mark = zone->pages_min;
else if (alloc_flags & ALLOC_WMARK_LOW)
mark = zone->pages_low;
else
mark = zone->pages_high;
if (!zone_watermark_ok(zone, order, mark,
classzone_idx, alloc_flags)) {
if (!zone_reclaim_mode ||
!zone_reclaim(zone, gfp_mask, order))
goto this_zone_full;
}
}
page = buffered_rmqueue(zonelist, zone, order, gfp_mask);
if (page)
break;
this_zone_full:
if (NUMA_BUILD)
zlc_mark_zone_full(zonelist, z);
try_next_zone:
if (NUMA_BUILD && !did_zlc_setup) {
/* we do zlc_setup after the first zone is tried */
allowednodes = zlc_setup(zonelist, alloc_flags);
zlc_active = 1;
did_zlc_setup = 1;
}
} while (*(++z) != NULL);
if (unlikely(NUMA_BUILD && page == NULL && zlc_active)) {
/* Disable zlc cache for second zonelist scan */
zlc_active = 0;
goto zonelist_scan;
}
return page;
}这个函数分为两个步骤：
1. 选择要分配的页
2. 移除步骤1中选择的页，主要由buffered_rmqueue实现
参数@zonelist指向备用内存区链表的指针。在预期内存区中（zonelist->zone[0]）没有足够空闲空间的情况下，该列表确定了扫描系统其他内存域的顺序。
do循环是遍历zonelist，找到一个满足分配条件的内存区，如果成功，则调用buffer_rmqueue试图分配需要的页面。
__alloc_pages
在了解可用标记和辅助函数后，我们可以开始分析__alloc_pages函数了。该函数实现比较复杂，尤其是在可用内存不充足的情况下；如果可用内存重组，该函数的流程还是非常简单的。
/*
* This is the 'heart' of the zoned buddy allocator.
*/
struct page * fastcall
__alloc_pages(gfp_t gfp_mask, unsigned int order,
struct zonelist *zonelist)
{
const gfp_t wait = gfp_mask & __GFP_WAIT;
struct zone **z;
struct page *page;
struct reclaim_state reclaim_state;
struct task_struct *p = current;
int do_retry;
int alloc_flags;
int did_some_progress;
might_sleep_if(wait);
if (should_fail_alloc_page(gfp_mask, order))
return NULL;
restart:
z = zonelist->zones; /* the list of zones suitable for gfp_mask */
if (unlikely(*z == NULL)) {
/*
* Happens if we have an empty zonelist as a result of
* GFP_THISNODE being used on a memoryless node
*/
return NULL;
}
page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, order,
zonelist, ALLOC_WMARK_LOW|ALLOC_CPUSET);
if (page)
goto got_pg;
在最简单的情况下，只调用一次get_page_from_freelist就成功的获得了分配的页面，直接通过跳转指令到got_pg处。
for (z = zonelist->zones; *z; z++)
wakeup_kswapd(*z, order);
/*
* OK, we're below the kswapd watermark and have kicked background
* reclaim. Now things get more complex, so set up alloc_flags according
* to how we want to proceed.
*
* The caller may dip into page reserves a bit more if the caller
* cannot run direct reclaim, or if the caller has realtime scheduling
* policy or is asking for __GFP_HIGH memory. GFP_ATOMIC requests will
* set both ALLOC_HARDER (!wait) and ALLOC_HIGH (__GFP_HIGH).
*/
alloc_flags = ALLOC_WMARK_MIN;
if ((unlikely(rt_task(p)) && !in_interrupt()) || !wait)
alloc_flags |= ALLOC_HARDER;
if (gfp_mask & __GFP_HIGH)
alloc_flags |= ALLOC_HIGH;
if (wait)
alloc_flags |= ALLOC_CPUSET;
/*
* Go through the zonelist again. Let __GFP_HIGH and allocations
* coming from realtime tasks go deeper into reserves.
*
* This is the last chance, in general, before the goto nopage.
* Ignore cpuset if GFP_ATOMIC (!wait) rather than fail alloc.
* See also cpuset_zone_allowed() comment in kernel/cpuset.c.
*/
page = get_page_from_freelist(gfp_mask, order, zonelist, alloc_flags);
if (page)
goto got_pg;
内核再一次遍历所有的内存zone，对每个zone都调用wakeup_kswapd，该函数唤醒负责换出页的内核守护进程。交换守护进程通过缩减内核缓存和页面回收来获得更多的空闲内存，缩减内核缓存和页面回涉及到页面写回或者换出很少使用的页面。这两种措施都是由守护进程发起的。
唤醒守护进程后，内核开始重新尝试从内存zones中查找合适的内存块。这一次搜索更为积极，对分配标志做了调整，修改为在一些特定情况下需要的分配标记，因此也减小了水印。
如果再次失败，内核会使用更积极的分配措施：
rebalance:
if (((p->flags & PF_MEMALLOC) || unlikely(test_thread_flag(TIF_MEMDIE)))
&& !in_interrupt()) {
if (!(gfp_mask & __GFP_NOMEMALLOC)) {
nofail_alloc:
/* go through the zonelist yet again, ignoring mins */
page = get_page_from_freelist(gfp_mask, order,
zonelist, ALLOC_NO_WATERMARKS);
if (page)
goto got_pg;
if (gfp_mask & __GFP_NOFAIL) {
congestion_wait(WRITE, HZ/50);
goto nofail_alloc;
}
}
goto nopage;
}
TIF_MEMDIE表示该进程已经被oom killer选择中，而PF_MEMALLOC比较复杂，我们单独讨论，PF_MEMALLOC表示当前进程是内存管理程序，需要一点点额外的内存，以便能继续执行下去。
__GFP_NOMMEALLOC表示禁止使用紧急分配链表，因此无法再尝试禁止水印的情况下调用get_page_from_freelist，此时只能失败。
如果允许使用紧急分配链表，则使用标志ALLOC_NO_WATERMAERKS尝试分配，如果失败，还要看分配标志是否有__GFP_NOFAIL，该标志表示不允许失败，首先调用conestion_wait等待，然后再尝试分配，直到成功。
1560 p->flags |= PF_MEMALLOC; 1561 reclaim_state.reclaimed_slab = 0; 1562 p->reclaim_state = &reclaim_state; 1563 1564 did_some_progress = try_to_free_pages(zonelist->zones, order, gfp_mask); 1565 1566 p->reclaim_state = NULL; 1567 p->flags &= ~PF_MEMALLOC;
在调用try_to_free_pages之前，先设置PF_MEMALLOC保证try_to_free_pages可以分配预留内存，try_to_free_pages不仅会把不常用页面交换到交换空间，还会shrink各种cache
1574 if (likely(did_some_progress)) {
1575 page = get_page_from_freelist(gfp_mask, order,
1576 zonelist, alloc_flags);
1577 if (page)
1578 goto got_pg;
1579 } else if ((gfp_mask & __GFP_FS) && !(gfp_mask & __GFP_NORETRY)) {
1580 if (!try_set_zone_oom(zonelist)) {
1581 schedule_timeout_uninterruptible(1);
1582 goto restart;
1583 }
1584
1585 /*
1586 * Go through the zonelist yet one more time, keep
1587 * very high watermark here, this is only to catch
1588 * a parallel oom killing, we must fail if we're still
1589 * under heavy pressure.
1590 */
1591 page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, order,
1592 zonelist, ALLOC_WMARK_HIGH|ALLOC_CPUSET);
1593 if (page) {
1594 clear_zonelist_oom(zonelist);
1595 goto got_pg;
1596 }
1597
1598 /* The OOM killer will not help higher order allocs so fail */
1599 if (order > PAGE_ALLOC_COSTLY_ORDER) {
1600 clear_zonelist_oom(zonelist);
1601 goto nopage;
1602 }
1603
1604 out_of_memory(zonelist, gfp_mask, order);
1605 clear_zonelist_oom(zonelist);
1606 goto restart;
1607 }
did_some_progress表示的确释放了一些页面，那么再尝试进行分配；否则内核正在做VFS层的操作，同时又没有设置GFP_NORETRY，那么调用OOM killer
1599行表示如果分配的阶数很大，那么即便调用OOM很大的几率仍然无法满足2^order分配，所以不执行oom killer。这个解释听起来不那么合理的，因为有时候一个进程可能占据几十M的内存空间，杀掉它，必然会释放很大的内存空间，获得连续空间的几率应该也很大的。
1609 /*
1610 * Don't let big-order allocations loop unless the caller explicitly
1611 * requests that. Wait for some write requests to complete then retry.
1612 *
1613 * In this implementation, __GFP_REPEAT means __GFP_NOFAIL for order
1614 * <= 3, but that may not be true in other implementations.
1615 */
1616 do_retry = 0;
1617 if (!(gfp_mask & __GFP_NORETRY)) {
1618 if ((order <= PAGE_ALLOC_COSTLY_ORDER) ||
1619 (gfp_mask & __GFP_REPEAT))
1620 do_retry = 1;
1621 if (gfp_mask & __GFP_NOFAIL)
1622 do_retry = 1;
1623 }
1624 if (do_retry) {
1625 congestion_wait(WRITE, HZ/50);
1626 goto rebalance;
1627 }
看注释，意思是说在分配标志没有NORETRY的情况下，要考虑几种情况，没什么可分析的。