linux 内存管理 - 分配页面

源码为 2.6.37内核，x86_64架构

Linux内核中分配页面使用了以下六个函数：

alloc_pages(gfp_mask, order)：用这个函数请求2order 个连续的页框。他返回第一个所分配页框描述符的地址，或者如果失败，则返回NULL。

alloc_page(gfp_mask)：用于获得一个单独页框的宏，它其实只是alloc_pages(gfp_mask, 0)。它返回所分配页框描述符的地址，或者如果分配失败，则返回NULL。

__get_free_pages(gfp_mask, order)：该函数类似于alloc_pages( )，只不过它返回第一个所分配页对应的内存线性地址。

__get_free_page(gfp_mask)：用于获得一个单独页框的宏，它也只是__get_free_pages(gfp_mask, 0)

get_zeroed_page(gfp_mask)：函数用来获取满是0的页面，它调用alloc_pages(gfp_mask | __GFP_ZERO, 0)，然后返回所获取页框的线性地址。

__get_dma_pages(gfp_mask, order)：该宏获取用于DMA的页框，它扩展调用__get_free_pages(gfp_mask | _ _GFP_DMA, order)。

这六个函数之间的调用关系如下：

所以这六个函数最后调用的还是alloc_pages()，接下来就只需要研究alloc_pages()这个函数。

而alloc_pages调用过程为：

alloc_pages()

   --> alloc_pages_node() 

      -->  __alloc_pages() 

         --> __alloc_pages_nodemask() 

               --> get_page_from_freelist() 

               --> buffered_rmqueue() 

                  --> __rmqueue()

具体为：

在include/linux/gfp.h中有这定义：

#define alloc_pages(gfp_mask, order) \             
   alloc_pages_node(numa_node_id(), gfp_mask, order)

其中numa_node_id() 返回0，指的是第0个节点。

alloc_pages_node()定义如下:

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


        return __alloc_pages(gfp_mask, order, node_zonelist(nid, gfp_mask)); /* node_zonelist函数返回节点nid对应的pg_data_t结构体中node_zonelists成员 */
}

__alloc_pages定义为：

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);
}  

__alloc_pages_nodemask定义为：

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); /* 根据gfp flag确定选择哪一个zone来分配内存 */
        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;


        /*
         * Check the zones suitable for the gfp_mask contain at least one
         * valid zone. It's possible to have an empty zonelist as a result
         * of GFP_THISNODE and a memoryless node
         */
if (unlikely(!zonelist->_zonerefs->zone))
                return NULL;




        get_mems_allowed();
        /* The preferred zone is used for statistics later */
        /* 根据nodemask,在zonelist中查找管理区类型不大于high_zoneidx的管理区，保存在preferred_zone中 */
        first_zones_zonelist(zonelist, high_zoneidx, nodemask, &preferred_zone);
        if (!preferred_zone) {
                put_mems_allowed();
                return NULL;
        }




        /* First allocation attempt */
        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);
        put_mems_allowed();




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

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, 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); /* zone_idx 返回preferred_zone管理区的idx,
                                                如ZONE_DMA返回0，ZONE_NORMAL返回1 等*/
zonelist_scan:
        /*
         * Scan zonelist, looking for a zone with enough free.
         * See also cpuset_zone_allowed() comment in kernel/cpuset.c.
         */
        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;


                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;


                        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;
                        }
                }


try_this_zone:
                /* buffered_rmqueue()函数返回第一个被分配的页框的页描述符；
                 * 如果内存管理区没有所请求大小的一组连续页框，则返回NULL */
                page = buffered_rmqueue(preferred_zone, zone, order,
                                                gfp_mask, migratetype);
                if (page)
                        break;
this_zone_full:
                if (NUMA_BUILD)
                        zlc_mark_zone_full(zonelist, z);
try_next_zone:
                if (NUMA_BUILD && !did_zlc_setup && nr_online_nodes > 1) {
                        /*
                         * we do zlc_setup after the first zone is tried but only
                         * if there are multiple nodes make it worthwhile
                         */
                        allowednodes = zlc_setup(zonelist, alloc_flags);
  zlc_active = 1;
                        did_zlc_setup = 1;
                }
        }


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

buffered_rmqueue() :

/*
 * Really, prep_compound_page() should be called from __rmqueue_bulk().  But
 * we cheat by calling it from here, in the order > 0 path.  Saves a branch
 * or two.
 */
/* buffered_rmqueue()函数在指定的内存管理区中分配页框 */
static inline
struct page *buffered_rmqueue(struct zone *preferred_zone,
                        struct zone *zone, int order, gfp_t gfp_flags,
                        int migratetype)
{
        unsigned long flags;
        struct page *page;
        int cold = !!(gfp_flags & __GFP_COLD);


again:
        if (likely(order == 0)) {
                struct per_cpu_pages *pcp;
                struct list_head *list;


                local_irq_save(flags);
                pcp = &this_cpu_ptr(zone->pageset)->pcp;
                list = &pcp->lists[migratetype];
                if (list_empty(list)) {
                        pcp->count += rmqueue_bulk(zone, 0,
                                        pcp->batch, list,
                                        migratetype, cold);
                        if (unlikely(list_empty(list)))
                                goto failed;
                }


                if (cold)
                        page = list_entry(list->prev, struct page, lru);
                else
                        page = list_entry(list->next, struct page, lru);


                list_del(&page->lru);
                pcp->count--;
        } else {
                if (unlikely(gfp_flags & __GFP_NOFAIL)) {
/*
                         * __GFP_NOFAIL is not to be used in new code.
                         *
                         * All __GFP_NOFAIL callers should be fixed so that they
                         * properly detect and handle allocation failures.
                         *
                         * We most definitely don't want callers attempting to
                         * allocate greater than order-1 page units with
                         * __GFP_NOFAIL.
                         */
                        WARN_ON_ONCE(order > 1);
                }
                spin_lock_irqsave(&zone->lock, flags);
                page = __rmqueue(zone, order, migratetype); /* 从伙伴系统中分配所请求的页框 */
                spin_unlock(&zone->lock);
                if (!page)
                        goto failed;
                __mod_zone_page_state(zone, NR_FREE_PAGES, -(1 << order));
        }


        __count_zone_vm_events(PGALLOC, zone, 1 << order);
        zone_statistics(preferred_zone, zone);
        local_irq_restore(flags);


        VM_BUG_ON(bad_range(zone, page));
        if (prep_new_page(page, order, gfp_flags))
                goto again;
        return page;


failed:
        local_irq_restore(flags);
        return NULL;
}

__rmqueue之后的内容参考伙伴系统。