关于页框分配函数的实现，前文中已经对主体实现函数和慢速分配函数作了简单说明。这两个函数主要的功能即根据系统内存实时的使用情况及时调整分配限制，并再次调用快速分配函数get_page_from_freelist()。

该函数可以看作是伙伴系统的前置函数，它通过传递进来的分配标志和分配阶，并结合系统当时的内存使用情况来判断是否可以进行内存分配。如果可以分配，那么进行实际的内存分配工作，既调用那些基于伙伴算法而实现的内存分配函数。

3.快速分配函数

static struct page *
get_page_from_freelist(gfp_t gfp_mask, nodemask_t *nodemask, unsigned int order,
		struct zonelist *zonelist, int high_zoneidx, int alloc_flags,
		struct zone *preferred_zone, int migratetype)
{
	struct zoneref *z;
	struct page *page = NULL;
	int classzone_idx;
	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 */

	classzone_idx = zone_idx(preferred_zone);

现在开始遍历指定zonelist上的zone。在通过for_each_zone_zonelist_nodemask()遍历时，该函数会过滤掉那些索引值大于high_zoneidx的zone。比如当前high_zoneidx所指定的zone为ZONE_NORMAL，那么当前遍历的zone只能为ZONE_DMA或ZONE_NORMAL类型，而不能是ZONE_HIGH，这些关系判断的依据即为这些类型对应的索引值。因为内存管理区的类型是通过枚举类型来描述的，因此索引值也就是这些类型对应的枚举值。

zonelist_scan:
	for_each_zone_zonelist_nodemask(zone, z, zonelist,
						high_zoneidx, nodemask) {
		if (NUMA_BUILD && zlc_active &&
			!zlc_zone_worth_trying(zonelist, z, allowednodes))
				continue;
		if ((alloc_flags & ALLOC_CPUSET) &&
			!cpuset_zone_allowed_softwall(zone, gfp_mask))
				goto try_next_zone;

即便当前zone的索引小于high_zoneidx，也不能急于分配内存，还要检查这个内存管理区是空闲的页框是否充足。这个过程通过上述两个if语句来完成。接下来，如果分配标志中设置了ALLOC_NO_WATERMARKS，即表明此刻不再考虑分配水位线。否则就要分析此刻内存的水位线。

通过分配标志从水位线数组中获得当前的水位线mark，再传入zone_watermark_ok()判断在当前的水位线下是否可以分配内存。如果可以分配内存则跳入try_this_zone。

		BUILD_BUG_ON(ALLOC_NO_WATERMARKS < NR_WMARK); 		if (!(alloc_flags & ALLOC_NO_WATERMARKS)) { 			unsigned long mark; 			int ret; 			mark = zone->watermark[alloc_flags & ALLOC_WMARK_MASK];
			if (zone_watermark_ok(zone, order, mark,
				    classzone_idx, alloc_flags))
				goto try_this_zone;

			if (zone_reclaim_mode == 0)
				goto this_zone_full;

如果运行到此处，说明此刻空闲内存不足，那么通过zone_reclaim()进行内存回收，回收的情况通过ret来描述。如果结果是ZONE_RECLAIM_NOSCAN，说明并没有进行回收，那么直接尝试下一个zone；如果结果是ZONE_RECLAIM_FULL，说明虽然进行了回收但是并没有回收到；默认的情况则是没有回收到足够多的内存。后两种情况均跳入this_zone_full处。

			ret = zone_reclaim(zone, gfp_mask, order);
			switch (ret) {
			case ZONE_RECLAIM_NOSCAN:
				/* did not scan */
				goto try_next_zone;
			case ZONE_RECLAIM_FULL:
				/* scanned but unreclaimable */
				goto this_zone_full;
			default:
				/* did we reclaim enough */
				if (!zone_watermark_ok(zone, order, mark,
						classzone_idx, alloc_flags))
					goto this_zone_full;
			}
		}

如果跳到此标号处说明可以在当前zone上分配内存，随即调用buffered_rmqueue()进入伙伴算法。

try_this_zone:
		page = buffered_rmqueue(preferred_zone, zone, order,
						gfp_mask, migratetype);
		if (page)
			break;

跳到此处说明当前zone的空闲内存不足，那么标记它。这样下次分配时直接将其忽略。

this_zone_full:
		if (NUMA_BUILD)
		        zlc_mark_zone_full(zonelist, z);

此处说明当前zone上的空闲内存不足，则需要在其他zone上尝试分配。

try_next_zone:
		if (NUMA_BUILD && !did_zlc_setup && nr_online_nodes > 1) {
			allowednodes = zlc_setup(zonelist, alloc_flags);
			zlc_active = 1;
			did_zlc_setup = 1;
		}
	}

此时，遍历zone的循环结束。如果第一次循环结束后page仍未空，则进行第二次分配，即跳入zonelist_scan重新遍历。当第二次分配结束后不管结果如何均返回。循环的次数由alc_active控制。

	if (unlikely(NUMA_BUILD && page == NULL && zlc_active)) {
		/* Disable zlc cache for second zonelist scan */
		zlc_active = 0;
		goto zonelist_scan;
	}
	return page;
}

至此，快速分配函数分析完毕。

内核中有六个基本的页框分配函数，它们内部经过封装，最终都会调用alloc_pages_node()。这个函数的参数比alloc_pages()多了一个nid，它用来指定节点id，如果nid小于0，则说明在当前节点上分配页框。正确获取到节点id后，接下来调用__alloc_pages()。

static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask, unsigned int order)
{
        if (nid < 0)
                nid = numa_node_id();

        return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask));
}

__alloc_pages()第三个参数根据nid和gfp_mask得到适当的zonelist链表，该过程通过node_zonelist()完成。该函数的实现比较简单，其中NODE_DATA()根据nid返回对应的内存节点描述符，而gfp_zonelist()根据flags标志选取对应的内存管理区链表。其实node_zonelist()就是根据flags在相应内存节点的node_zonelists数组中选择一个何时的内存管理区链表zonelist。

static inline int gfp_zonelist(gfp_t flags)
{
        if (NUMA_BUILD && unlikely(flags & __GFP_THISNODE))
                return 1;

        return 0;
}

由于node_zonelists数组的元素个数最大为2，因此gfp_zonelist()返回0或者1。如果flags中设置了__GFP_THISNODE并且NUMA被设置，则表明使用当前节点对应的zonelist，返回1。否则使用备用zonelist，也就是说当本地节点中zone不足时，在其他节点中申请页框。

static inline int gfp_zonelist(gfp_t flags)
{
        if (NUMA_BUILD && unlikely(flags & __GFP_THISNODE))
                return 1;

        return 0;
}

__alloc_pages()内部再次封装__alloc_pages_nodemask()。

static inline struct page *
__alloc_pages(gfp_t gfp_mask, unsigned int order, struct zonelist *zonelist)
{
        return __alloc_pages_nodemask(gfp_mask, order, zonelist, NULL);
}

1. 主体分配函数

现在进入__alloc_pages_nodemask()，它作为页框分配函数的核心部分。该函数可以通过get_page_from_freelist()快速分配所请求的内存，但是大多数情况下调用该函数都会失败，因为通常物理内存的使用情况都比较紧张，这一点从其后if语句中的unlikely就可以看出。

struct page *
__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order,struct zonelist *zonelist, nodemask_t *nodemask)
{
        enum zone_type high_zoneidx = gfp_zone(gfp_mask);
        struct zone *preferred_zone;
        struct page *page;
        int migratetype = allocflags_to_migratetype(gfp_mask);

        gfp_mask &= gfp_allowed_mask;

        lockdep_trace_alloc(gfp_mask);

        might_sleep_if(gfp_mask & __GFP_WAIT);

        if (should_fail_alloc_page(gfp_mask, order))
                return NULL; 

        if (unlikely(!zonelist->_zonerefs->zone))
                return NULL;            

        first_zones_zonelist(zonelist, high_zoneidx, nodemask, &preferred_zone);
        if (!preferred_zone)
                return NULL;

        page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, nodemask, order,
                        zonelist, high_zoneidx, ALLOC_WMARK_LOW|ALLOC_CPUSET,
                        preferred_zone, migratetype);
        if (unlikely(!page))
                page = __alloc_pages_slowpath(gfp_mask, order,
                                zonelist, high_zoneidx, nodemask,
                                preferred_zone, migratetype);

        trace_mm_page_alloc(page, order, gfp_mask, migratetype);
        return page;
}

首先，gfp_zone()根据gfp_mask选取适当类型的zone。在经过几项参数检查后，该函数通过zonelist->_zonerefs->zone判断zonelist是否为空，既至少需要一个zone可用。接着根据一开始选取的zone类型high_zoneidx，通过first_zones_zonelist()确定优先分配内存的内存管理区。

如果一切顺利，将会进入get_page_from_freelist()，这个函数可以看作是伙伴算法的前置函数，它通过分配标志和分配阶判断是否能进行此次内存分配。如果可以分配，则它进行实际的内存分配工作，既利用伙伴算法进行分配内存。否则，进入__alloc_pages_slowpath()，此时内核需要放宽一些分配条件，或回收一些系统的内存，然后再调用几次get_page_from_freelist()以申请所需内存。