linux内存管理--伙伴系统分配内存准备工作

linux内核内存管理的代码改变的有点大，主要是细节方面；

首先从 __get_free_pages()开始总结起：

unsigned long  __get_free_pages(grp_t  gfp_mask, unsigned int order)

/*
* Common helper functions.
*/
unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order)
{
struct page *page;

/*
* __get_free_pages() returns a 32-bit address, which cannot represent
* a highmem page
*/
VM_BUG_ON((gfp_mask & __GFP_HIGHMEM) != 0);//返回逻辑地址，所以不能用highmem区域未映射的地址

page = alloc_pages(gfp_mask, order);
if (!page)
return 0;
return (unsigned long) page_address(page);//物理page转换为线性逻辑地址
}

struct page*  alloc_pages()

static inline struct page *
alloc_pages(gfp_t gfp_mask, unsigned int order)//alloc_pages()函数可以分配任何zone的页
{
return alloc_pages_current(gfp_mask, order);
}

struct page *alloc_pages_current(gfp_t gfp, unsigned order)
{
struct mempolicy *pol = get_task_policy(current);//得到current中的mempolicy,如果为空，则得到&preferred_node_policy[node]中的mempolicy
struct page *page;
unsigned int cpuset_mems_cookie;

if (!pol || in_interrupt() || (gfp & __GFP_THISNODE))//pol空，在中断上下文，指定到本地上获取page，则用默认的策略
pol = &default_policy;

retry_cpuset:
cpuset_mems_cookie = get_mems_allowed();

/*
* No reference counting needed for current->mempolicy
* nor system default_policy
*/
if (pol->mode == MPOL_INTERLEAVE)//交错策略
page = alloc_page_interleave(gfp, order, interleave_nodes(pol));
else
page = __alloc_pages_nodemask(gfp, order,
policy_zonelist(gfp, pol, numa_node_id()),
policy_nodemask(gfp, pol));

if (unlikely(!put_mems_allowed(cpuset_mems_cookie) && !page))
goto retry_cpuset;

return page;
}

上面代码中：
cpuset_mems_cookie = get_mems_allowed();

xxx
if (unlikely(!put_mems_allowed(cpuset_mems_cookie) && !page))

        goto retry_cpuset;

是成对出现的；这是个顺序锁，这里锁住的应该是 current->mems_allowed 成员，因为在分配内存页时都要考虑到该cpu是否可以在某个节点上分配。如果在分配期间修改了mems_allowed，就算分配到了该page，那该cpu也不一定能使用；在分配完内存页后还要再判断下该mems_allowed是否已经改变；如果改变了，那分配的页也就失效了，要重新再分配一次；

下面说下分配策略，这个分配策略主要是获取到节点的编号（也就是得到 pgdat 结构体）；下面是分配策略的结构体

struct mempolicy {
atomic_t refcnt;
unsigned short mode;    /* See MPOL_* above */
unsigned short flags;   /* See set_mempolicy() MPOL_F_* above */
union {
short        preferred_node; /* preferred */
nodemask_t   nodes;     /* interleave/bind */
/* undefined for default */
} v;
union {
nodemask_t cpuset_mems_allowed; /* relative to these nodes */
nodemask_t user_nodemask;   /* nodemask passed by user */
} w;
};

成员的含义，注释已经说的比较明白了；

有几种分配策略
enum {
MPOL_DEFAULT,
MPOL_PREFERRED,
MPOL_BIND,
MPOL_INTERLEAVE,
MPOL_LOCAL,
MPOL_MAX,   /* always last member of enum */
};

交错策略：

接着上代码  pol->mode == MPOL_INTERLEAVE  

page = alloc_page_interleave(gfp, order, interleave_nodes(pol));

static unsigned interleave_nodes(struct mempolicy *policy)
{
unsigned nid, next;
struct task_struct *me = current;

nid = me->il_next;
next = next_node(nid, policy->v.nodes);//policy->v.nodes是一个表示nid是否存在的bit映射，从nid位置开始再找出下一个为1的bit位
if (next >= MAX_NUMNODES)//如果超出nid节点最大编号范围，则从头再找
next = first_node(policy->v.nodes);
if (next < MAX_NUMNODES)
me->il_next = next;
return nid;
}

static struct page *alloc_page_interleave(gfp_t gfp, unsigned order,
unsigned nid)
{
struct zonelist *zl;
struct page *page;

zl = node_zonelist(nid, gfp);// NODE_DATA(nid)->node_zonelists + gfp_zonelist(flags); 如果指定了__GFP_THISNODE，则用pgdat(nid)->zonelists[1]，否则用zonelists[0]
page = __alloc_pages(gfp, order, zl);//这是主要分析的
if (page && page_zone(page) == zonelist_zone(&zl->_zonerefs[0]))
inc_zone_page_state(page, NUMA_INTERLEAVE_HIT);
return page;
}

alloc_page_interleave()函数：
    首选通过 interleave_nodes()从current中得到nid，也就是内存节点编号；

    再根据nid 和gfp 得到zonelist； 其中 zonelist[0]是按离当前cpu节点的远近顺序存放的各个内存节点的zone，而zonelist[1]则是存放自己当前节点的zone（可以看初始化zonelist部分）
    最后调用：__alloc_pages_nodemask(gfp_mask, order, zonelist, NULL);

绑定策略、首选策略：

page = __alloc_pages_nodemask(gfp, order,
policy_zonelist(gfp, pol, numa_node_id()),
policy_nodemask(gfp, pol));

static struct zonelist *policy_zonelist(gfp_t gfp, struct mempolicy *policy,
int nd)
{
switch (policy->mode) {
case MPOL_PREFERRED://首选模式
if (!(policy->flags & MPOL_F_LOCAL))
nd = policy->v.preferred_node;//这时候mempolicy中的v成员就代表一个节点了，其他模式下则代表节点的mask
break;
case MPOL_BIND:
/*
* Normally, MPOL_BIND allocations are node-local within the
* allowed nodemask.  However, if __GFP_THISNODE is set and the
* current node isn't part of the mask, we use the zonelist for
* the first node in the mask instead.
*/
if (unlikely(gfp & __GFP_THISNODE) &&
unlikely(!node_isset(nd, policy->v.nodes)))//指定本地分配，并且nd是不存在
nd = first_node(policy->v.nodes);//从v中得到可用的node所在的bit位
break;
default:
BUG();
}
return node_zonelist(nd, gfp);//和上面一样得到zonelists[]
}

static nodemask_t *policy_nodemask(gfp_t gfp, struct mempolicy *policy)
{
/* Lower zones don't get a nodemask applied for MPOL_BIND */
if (unlikely(policy->mode == MPOL_BIND) &&
apply_policy_zone(policy, gfp_zone(gfp)) &&
cpuset_nodemask_valid_mems_allowed(&policy->v.nodes))//和current->mems_allowed是否相交
*if policy->v.nodes has movable memory only,
* we apply policy when gfp_zone(gfp) = ZONE_MOVABLE only.
*
* policy->v.nodes is intersect with node_states[N_MEMORY].
* so if the following test faile, it implies
* policy->v.nodes has movable memory only.中
return &policy->v.nodes;

return NULL;
}

policy_zonelist(gfp, pol, numa_node_id())：
    首选，如果是首选模式，那policy->v.preferred_node就代表了一个节点，而不是节点的mask；
    然后，如果是绑定模式，如果指定了本地分配，并且当前节点又不可用，则从policy中找到第一个可用节点；
    最后，其他情况都使用numa_node_id()获取的节点

struct page * __alloc_pages_nodemask(gfp_t  gfp_mask, unsigned int order,  struct  zonelist *zonelist, nodemask_t  *nodemask)

/*
* This is the 'heart' of the zoned buddy allocator.
*/
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);//获取允许zone的最大的zone，一般是从high--normal--dma
struct zone *preferred_zone;
struct page *page = NULL;
int migratetype = allocflags_to_migratetype(gfp_mask);<span style="font-family: Arial, Helvetica, sans-serif;">//迁移类型，主要是zone->free_area.free_list[迁移类型]</span>

unsigned int cpuset_mems_cookie;
int alloc_flags = ALLOC_WMARK_LOW|ALLOC_CPUSET;//设置分配标识，<span style="font-family: Arial, Helvetica, sans-serif;">low水位，内存节点要对应cpu集合</span>
struct mem_cgroup *memcg = NULL;

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))//备用列表中没有zone
return NULL;

/*
* Will only have any effect when __GFP_KMEMCG is set.  This is
* verified in the (always inline) callee
*/
if (!memcg_kmem_newpage_charge(gfp_mask, &memcg, order))
return NULL;

retry_cpuset:
cpuset_mems_cookie = get_mems_allowed();

/* The preferred zone is used for statistics later *///循环备用列表中的所有zone，找到一个最合适的zone
first_zones_zonelist(zonelist, high_zoneidx,
nodemask ? : &cpuset_current_mems_allowed,
&preferred_zone);
if (!preferred_zone)
goto out;

#ifdef CONFIG_CMA
if (allocflags_to_migratetype(gfp_mask) == MIGRATE_MOVABLE)
alloc_flags |= ALLOC_CMA;
#endif
/* First allocation attempt *///快速分配内存页
page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, nodemask, order,
zonelist, high_zoneidx, alloc_flags,
preferred_zone, migratetype);
if (unlikely(!page)) {
/*
* Runtime PM, block IO and its error handling path
* can deadlock because I/O on the device might not
* complete.
*/
gfp_mask = memalloc_noio_flags(gfp_mask);
page = __alloc_pages_slowpath(gfp_mask, order,//这个是慢速的分配
zonelist, high_zoneidx, nodemask,
preferred_zone, migratetype);
}

trace_mm_page_alloc(page, order, gfp_mask, migratetype);

out:
/*
* When updating a task's mems_allowed, it is possible to race with
* parallel threads in such a way that an allocation can fail while
* the mask is being updated. If a page allocation is about to fail,
* check if the cpuset changed during allocation and if so, retry.
*/
if (unlikely(!put_mems_allowed(cpuset_mems_cookie) && !page))
goto retry_cpuset;

memcg_kmem_commit_charge(page, memcg, order);

return page;
}

下面是反内存碎片设置的，改变了以前的zone->free_area.free_list[迁移类型]，以前free_list就直接链接page块，而现在是各种迁移类型链表的数组了。

int migratetype = allocflags_to_migratetype(gfp_mask);

/* Convert GFP flags to their corresponding migrate type */
static inline int allocflags_to_migratetype(gfp_t gfp_flags)
{
WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK);//GFP_MOVABLE包含可回收的和可移动的页

if (unlikely(page_group_by_mobility_disabled))//这表示是否开启反内存碎片，内存少的一般就不开启
return MIGRATE_UNMOVABLE;//其实就是0

/* Group based on mobility */
return (((gfp_flags & __GFP_MOVABLE) != 0) << 1) |
((gfp_flags & __GFP_RECLAIMABLE) != 0);//返回 回收或可移动 的标识位数，在分配内存是使用
}

static inline struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
enum zone_type highest_zoneidx,
nodemask_t *nodes,
struct zone **zone){
return next_zones_zonelist(zonelist->_zonerefs, highest_zoneidx, nodes,
zone);
}

/* Returns the next zone at or below highest_zoneidx in a zonelist */由于highest_zoneidx是最大的区域，所以只要小于该区域就是首选zone
struct zoneref *next_zones_zonelist(struct zoneref *z,//这时候z里面包含了一系列的内存区域zones
enum zone_type highest_zoneidx,
nodemask_t *nodes,
struct zone **zone){
/*
* Find the next suitable zone to use for the allocation.
* Only filter based on nodemask if it's set
*/
if (likely(nodes == NULL))//交错策略，其实表示所有zone都是有效的
while (zonelist_zone_idx(z) > highest_zoneidx)//得到首选节点
z++;
else
while (zonelist_zone_idx(z) > highest_zoneidx ||
(z->zone && !zref_in_nodemask(z, nodes)))
z++;

*zone = zonelist_zone(z);
return z;       }//这应该可以说是得到zonelists中的首选节点