内存分配之快速路径和慢速路径源码学习（3）

接前一篇文章：内存分配之快速路径和慢速路径源码学习（2）

三、快速路径分配

1. 详解alloc_pages()

1.1 分析调用关系

//调用关系：alloc_pages() --> alloc_pages_node()
#define alloc_pages(gfp_mask, order) \
    alloc_pages_node(numa_node_id(), gfp_mask, order)


//调用关系：alloc_pages_node() --> __alloc_pages_node()
static inline struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
    unsigned int order)
{
    if (nid == NUMA_NO_NODE)
        nid = numa_mem_id();

    return __alloc_pages_node(nid, gfp_mask, order);
}

//调用关系：__alloc_pages_node() --> __alloc_pages()
static inline struct page * __alloc_pages_node(int nid, gfp_t gfp_mask, unsigned int order)
{
    VM_BUG_ON(nid < 0 || nid >= MAX_NUMNODES);
    VM_WARN_ON((gfp_mask & __GFP_THISNODE) && !node_online(nid));

    return __alloc_pages(gfp_mask, order, nid);
}

//调用关系：__alloc_pages() --> __alloc_pages_nodemask()
static inline struct page *__alloc_pages(gfp_t gfp_mask, unsigned int order, int preferred_nid)
{
    return __alloc_pages_nodemask(gfp_mask, order, preferred_nid, NULL);
}

//由此看出，alloc_pages()最终调用的是__alloc_pages_nodemask()函数

1.2 __alloc_pages_nodemask()

/*
 * __alloc_pages_nodemask() 函数是伙伴系统的核心函数
 */
struct page *
__alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order, int preferred_nid,
        nodemask_t *nodemask)
{
    struct page *page;

    //alloc_flags 用于表示页面分配的行为和属性，这里初始化值表示分配内存的判断条件为低水位
    unsigned int alloc_flags = ALLOC_WMARK_LOW;
    gfp_t alloc_mask; /* The gfp_t that was actually used for allocation */
    struct alloc_context ac = { };

    //这里表示order最多为10，因为MAX_ORDER=11，则分配最多不内存块为2^10 * 4KB = 4MB
    if (unlikely(order >= MAX_ORDER)) {
        WARN_ON_ONCE(!(gfp_mask & __GFP_NOWARN));
        return NULL;
    }

    gfp_mask &= gfp_allowed_mask;
    alloc_mask = gfp_mask;

    //prepare_alloc_pages()函数会计算相关信息保存到ac
    //ac类型为alloc_context，这个数据结构体在伙伴系统分配函数中用于保存相关的参数
    if (!prepare_alloc_pages(gfp_mask, order, preferred_nid, nodemask, &ac, &alloc_mask, &alloc_flags))
        return NULL;

    //finalise_ac()函数确定首选的zone
    finalise_ac(gfp_mask, &ac);

    //alloc_flags_nofragment() 是用于内存碎片化方面的一个优化
    alloc_flags |= alloc_flags_nofragment(ac.preferred_zoneref->zone, gfp_mask);

    /* 第一次尝试分配，从伙伴系统的空闲链表中分配内存 */
    page = get_page_from_freelist(alloc_mask, order, alloc_flags, &ac);
    //若分配成功，则返回内存块的第一个页面的page数据结构
    if (likely(page))
        goto out;

    alloc_mask = current_gfp_context(gfp_mask);
    ac.spread_dirty_pages = false;

    if (unlikely(ac.nodemask != nodemask))
        ac.nodemask = nodemask;
    //若分配不成功，则最终调用__alloc_pages_slowpath()进入分配的慢速路径
    page = __alloc_pages_slowpath(alloc_mask, order, &ac);

out:
    if (memcg_kmem_enabled() && (gfp_mask & __GFP_ACCOUNT) && page &&
        unlikely(__memcg_kmem_charge(page, gfp_mask, order) != 0)) {
        __free_pages(page, order);
        page = NULL;
    }

    trace_mm_page_alloc(page, order, alloc_mask, ac.migratetype);

    return page;
}

1.3 相关数据结构

• alloc_context 数据结构

alloc_context结构体是一个内部临时使用的结构体。

struct alloc_context {
    struct zonelist *zonelist; //指向每一个内存节点中对应的zonelist
    nodemask_t *nodemask; //表示内存节点掩码
    struct zoneref *preferred_zoneref; //表示首选的zone的zoneref
    int migratetype; //表示迁移类型
    enum zone_type high_zoneidx; //分配掩码计算zone的zoneidx，即允许内存分配的最高的zone
    bool spread_dirty_pages; //表示是否允许传播脏页
};

• zonelist结构

zonelist结构体是内核管理一个内存节点zone的数据结构，定义如下：

struct zonelist {
    struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
};

• zoneref结构

每个zoneref描述一个zone，struct zoneref的定义如下：

struct zoneref {
    struct zone *zone; //指向真实的zone
    int zone_idx; //根据zone_idx函数获取的idx，0表示最低
};

zonelist是所有可用的zone的链表，其中排在第一个的zone是首选zone，通常一个内存节点有两个zonelist，一个本地（包含备选zone），一个远端（用于NUMA系统，指向远端的内存节点zone）。

zonelist在初始化的时候通过build_zonelists函数建立。遍历zonelist的宏有如下几个：

 first_zones_zonelist()
 for_each_zone_zonelist_nodemask ()
 for_next_zone_zonelist_nodemask ()

1.4 prepare_alloc_pages()

prepare_alloc_pages函数主要是用于初始化页面分配器中用到的参数，这些参数会临时保存到 alloc_context 数据结构。

static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order,
    int preferred_nid, nodemask_t *nodemask,
    struct alloc_context *ac, gfp_t *alloc_mask,
    unsigned int *alloc_flags)
{
    //gfp_zone() 根据分配掩码计算zone的zoneidx，存放在ac结构体的high_zoneidx
    ac->high_zoneidx = gfp_zone(gfp_mask);

    //node_zonelist() 函数返回首选内存节点preferred_nid对应的zonelist。通常一个内存节点有两个zonelist，一个本地，一个远端
    ac->zonelist = node_zonelist(preferred_nid, gfp_mask);

    ac->nodemask = nodemask;
    //gfpflags_to_migratetype()根据分配掩码来获取内存的迁移类型
    ac->migratetype = gfpflags_to_migratetype(gfp_mask);

    if (cpusets_enabled()) {
        *alloc_mask |= __GFP_HARDWALL;
        if (!ac->nodemask)
            ac->nodemask = &cpuset_current_mems_allowed;
        else
            *alloc_flags |= ALLOC_CPUSET;
    }

    fs_reclaim_acquire(gfp_mask);
    fs_reclaim_release(gfp_mask);

    might_sleep_if(gfp_mask & __GFP_DIRECT_RECLAIM);

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

    if (IS_ENABLED(CONFIG_CMA) && ac->migratetype == MIGRATE_MOVABLE)
        *alloc_flags |= ALLOC_CMA;

    return true;
}

更多内容请看下回。