2017-03-02
在Linux下的物理内存管理中，对SLAB机制大致做了介绍，对SLAB管理结构对象也做了介绍，但是对于小内存块的分配没有介绍，本节重点介绍下slab对小内存块的管理。
内核中使用全局的kmem_cache数组kmalloc_caches组织不同大小的缓存块，每个缓存块由一个kmem_cache结构描述，缓存块大小一般是按8字节递增，分配时不足8字节按照8字节算，依次向上舍入。内核有两种方式根据size获取对应的阶
1、使用一个size_index数组保存对应内存块的阶，当size小于192时，使用此数组。
static s8 size_index[] = {
, /* 8 */
, /* 16 */
, /* 24 */
, /* 32 */
, /* 40 */
, /* 48 */
, /* 56 */
, /* 64 */
, /* 72 */
, /* 80 */
, /* 88 */
, /* 96 */
, /* 104 */
, /* 112 */
, /* 120 */
, /* 128 */
, /* 136 */
, /* 144 */
, /* 152 */
, /* 160 */
, /* 168 */
, /* 176 */
, /* 184 */
/* 192 */
};
2,、当size大于192时，使用fls函数。
小内存块的总体分配架构如下图所示：
根据请求分配的内存的size，通过size_index_elem(size)获取该size对应的index，上篇文章介绍过，块的大小按照2的阶计算。kmalloc_caches数组中的下标其实也是表示了块的大小即2^n字节。
下面结合内核kmalloc函数执行流程，分析下具体的小内存块的分配。正常情况下会调用到__kmalloc函数，该函数主体可分为两部分：根据size得到对应的缓存块结构kmem_cache；从缓存块中取对象；
前者使用kmalloc_slab函数，而后者调用slab_alloc函数。从这里我们仔细深入分析：
struct kmem_cache *kmalloc_slab(size_t size, gfp_t flags)
{
int index;
/*如果size大于最大值，则返回NULL*/ if (size > KMALLOC_MAX_SIZE) {
WARN_ON_ONCE(!(flags & __GFP_NOWARN));
return NULL;
} if (size <= ) {
if (!size)
return ZERO_SIZE_PTR; index = size_index[size_index_elem(size)];
} else
index = fls(size - ); #ifdef CONFIG_ZONE_DMA
if (unlikely((flags & GFP_DMA)))
return kmalloc_dma_caches[index]; #endif
return kmalloc_caches[index];
}
kmalloc_slab代码本身比较简单，先对size做了判断，看是否符合要求，如果size小于等于192，则从size_index数组中获取对应的阶；否则调用fls函数获取对应的阶。最后根据此阶作为下标，获取对应的kmem_cache对象。而内存分配的重点在slab_alloc函数，该函数中直接调用了slab_alloc_node函数
static __always_inline void *
slab_alloc_node(struct kmem_cache *cachep, gfp_t flags, int nodeid,
unsigned long caller)
{
unsigned long save_flags;
void *ptr;
int slab_node = numa_mem_id(); flags &= gfp_allowed_mask; lockdep_trace_alloc(flags); if (slab_should_failslab(cachep, flags))
return NULL; cachep = memcg_kmem_get_cache(cachep, flags); cache_alloc_debugcheck_before(cachep, flags);
local_irq_save(save_flags); if (nodeid == NUMA_NO_NODE)
nodeid = slab_node; if (unlikely(!cachep->node[nodeid])) {
/* Node not bootstrapped yet */
ptr = fallback_alloc(cachep, flags);
goto out;
} if (nodeid == slab_node) {
/*
* Use the locally cached objects if possible.
* However ____cache_alloc does not allow fallback
* to other nodes. It may fail while we still have
* objects on other nodes available.
*/
ptr = ____cache_alloc(cachep, flags);
if (ptr)
goto out;
}
/* ___cache_alloc_node can fall back to other nodes */
ptr = ____cache_alloc_node(cachep, flags, nodeid);
out:
local_irq_restore(save_flags);
ptr = cache_alloc_debugcheck_after(cachep, flags, ptr, caller);
kmemleak_alloc_recursive(ptr, cachep->object_size, , cachep->flags,
flags); if (likely(ptr))
kmemcheck_slab_alloc(cachep, flags, ptr, cachep->object_size); if (unlikely((flags & __GFP_ZERO) && ptr))
memset(ptr, , cachep->object_size); return ptr;
}
函数u首先获取了节点ID即slab_node，如果参数中未指定具体的node，默认从当前节点开始分配。中间是复杂的检查机制，而实质性的工作在____cache_alloc函数中
static inline void *____cache_alloc(struct kmem_cache *cachep, gfp_t flags)
{
void *objp;
struct array_cache *ac;
bool force_refill = false; check_irq_off();
/*先从CPU 缓存中取*/
ac = cpu_cache_get(cachep);
/**/
if (likely(ac->avail)) {
ac->touched = ;
objp = ac_get_obj(cachep, ac, flags, false); /*
* Allow for the possibility all avail objects are not allowed
* by the current flags
*/
if (objp) {
STATS_INC_ALLOCHIT(cachep);
goto out;
}
force_refill = true;
} STATS_INC_ALLOCMISS(cachep);
objp = cache_alloc_refill(cachep, flags, force_refill);
/*
* the 'ac' may be updated by cache_alloc_refill(),
* and kmemleak_erase() requires its correct value.
*/
ac = cpu_cache_get(cachep); out:
/*
* To avoid a false negative, if an object that is in one of the
* per-CPU caches is leaked, we need to make sure kmemleak doesn't
* treat the array pointers as a reference to the object.
*/
if (objp)
kmemleak_erase(&ac->entry[ac->avail]);
return objp;
}
可以看到，该函数中首先根据参数中的kmem_cache获取当前CPU对应的array_cache,array_cache结构如下：
struct array_cache {
unsigned int avail;//可用对象的数目
unsigned int limit;//可拥有的最大对象的数目
unsigned int batchcount;//
unsigned int touched;
spinlock_t lock;
void *entry[]; /*主要是为了访问后面的对象
* Must have this definition in here for the proper
* alignment of array_cache. Also simplifies accessing
* the entries.
*
* Entries should not be directly dereferenced as
* entries belonging to slabs marked pfmemalloc will
* have the lower bits set SLAB_OBJ_PFMEMALLOC
*/
};
这个结构per_CPU 缓存，每个CPU都有对应的缓存，其中avail对应当前缓存中可用对象的数目，limit表示可拥有的最大对象的数目，batchcount表示在缓存为空时，需要填充的对象的数量，touched是一个活动位，表示当前缓存的活跃程度，便于后续的收缩操作。entry指向该缓存的对象数组，数组中保存的是对象的地址，这里就表示缓存块的地址。有一点就是从这里分配缓存对象不是从数组起始位置分配，而是从数组末尾分配，avail就表示分配的对象在entry数组中的下标，这里发现设计的还真是巧妙。
回到____cache_alloc函数中，如果当前CPU缓存中有可用对象，则设置首先设置活跃位，然后调用ac_get_obj函数从缓存中获取一个对象。如果没有可用的对象，则调用cache_alloc_refill函数填充缓存，之后再次调用cpu_cache_get获取对象。获取对象之后需要调用kmemleak_erase函数设置entry数组中的对应指针为NULL。到这里发现主要有两个操作，获取对象，填充缓存。
先看获取对象ac_get_obj
static inline void *ac_get_obj(struct kmem_cache *cachep,
struct array_cache *ac, gfp_t flags, bool force_refill)
{
void *objp; if (unlikely(sk_memalloc_socks()))
objp = __ac_get_obj(cachep, ac, flags, force_refill);
else
objp = ac->entry[--ac->avail]; return objp;
}
sk_memalloc_socks意思暂不清楚，从unlikely可以看到这里大部分都可以直接通过entry得到对象，所以获取对象的方式还是挺简单的，直接从根据avail从entry数组中获的一个对象地址即可。并且这里avail应该指向首个为NULL的entry。
如果缓存中没有呢，就需要填充per_CPU 缓存了，这里看cache_alloc_refill函数
static void *cache_alloc_refill(struct kmem_cache *cachep, gfp_t flags,
bool force_refill)
{
int batchcount;
struct kmem_cache_node *n;
struct array_cache *ac;
int node; check_irq_off();
/*获取当前节点kmem_cache_node*/
node = numa_mem_id();
if (unlikely(force_refill))
goto force_grow;
retry:
ac = cpu_cache_get(cachep);
/*要填充对象的数目*/
batchcount = ac->batchcount;
/*如果当前缓存访问并不频繁，且要填充的数目较多，减少分配的数目*/
if (!ac->touched && batchcount > BATCHREFILL_LIMIT) {
/*
* If there was little recent activity on this cache, then
* perform only a partial refill. Otherwise we could generate
* refill bouncing.
*/
batchcount = BATCHREFILL_LIMIT;
}
/**/
n = cachep->node[node]; BUG_ON(ac->avail > || !n);
/*枷锁*/
spin_lock(&n->list_lock); /* See if we can refill from the shared array */
if (n->shared && transfer_objects(ac, n->shared, batchcount)) {
n->shared->touched = ;
goto alloc_done;
} while (batchcount > ) {
struct list_head *entry;
struct slab *slabp;
/* Get slab alloc is to come from. */
/*首先从slabs_partial链表中分配*/
entry = n->slabs_partial.next;
/*如果半分配的slab链表为空*/
if (entry == &n->slabs_partial) {
n->free_touched = ;
/*从free链表分配*/
entry = n->slabs_free.next;
/*如果free链表满，则增长*/
if (entry == &n->slabs_free)
goto must_grow;
}
/*由entry定位slab的地址*/
slabp = list_entry(entry, struct slab, list);
check_slabp(cachep, slabp);
check_spinlock_acquired(cachep); /*
* The slab was either on partial or free list so
* there must be at least one object available for
* allocation.
*/
BUG_ON(slabp->inuse >= cachep->num);
/*循环从slab获取对象*/
while (slabp->inuse < cachep->num && batchcount--) {
STATS_INC_ALLOCED(cachep);
STATS_INC_ACTIVE(cachep);
STATS_SET_HIGH(cachep);
/*填充缓存*/
ac_put_obj(cachep, ac, slab_get_obj(cachep, slabp,
node));
}
check_slabp(cachep, slabp); /* move slabp to correct slabp list: */
/*把slab移除链表*/
list_del(&slabp->list);
/*根据情况添加到对应的链表*/
if (slabp->free == BUFCTL_END)
list_add(&slabp->list, &n->slabs_full);
else
list_add(&slabp->list, &n->slabs_partial);
} must_grow:
n->free_objects -= ac->avail;
alloc_done:
spin_unlock(&n->list_lock); if (unlikely(!ac->avail)) {
int x;
force_grow:
x = cache_grow(cachep, flags | GFP_THISNODE, node, NULL); /* cache_grow can reenable interrupts, then ac could change. */
ac = cpu_cache_get(cachep);
node = numa_mem_id(); /* no objects in sight? abort */
if (!x && (ac->avail == || force_refill))
return NULL; if (!ac->avail) /* objects refilled by interrupt? */
goto retry;
}
ac->touched = ; return ac_get_obj(cachep, ac, flags, force_refill);
}
代码部分并不难理解，首先获取当前NUMA节点ID，从而在后面获取对应的kmem_cache_node结构，该结构中保存了与其关联的slab，然后获取当前CPU的缓存对象array_cache。根据其中的touched字段判断是否该缓存是否活跃，如果不活跃且要求充填的对象数还比较多，就把填充对象数设置成BATCHREFILL_LIMIT。然后即根据NUMA ID 从kmem_cache结构的node数组中获取kmem_cache_node结构。首先尝试从共享数组中分配，这相当于又添加了一层缓存。如果共享数组为NULL或者从共享数组填充失败，则走正规途径即从slab链表中分配。进入while循环
前面提到过NUMA架构下，每个NODE关联三条SLAB链表，分别表示full,partial,free的slab.这里首先尝试的是从未使用完的链表中分配，如果该链表为NULL，则从free链表中分配，如果free链表也为NULL，则必须must_grow的途径，从伙伴系统申请对象。到这里不管从哪里，已经获取一个slab了，接下来从该slab分配对象，再次进入一个while循环。这里重要的是首先通过slab_get_obj函数从slab中获取一个对象，然后通过ac_put_obj函数把对象填充到CPU关联的缓存数组中。看下两个函数
static void *slab_get_obj(struct kmem_cache *cachep, struct slab *slabp,
int nodeid)
{
void *objp = index_to_obj(cachep, slabp, slabp->free);
kmem_bufctl_t next; slabp->inuse++;
next = slab_bufctl(slabp)[slabp->free];
#if DEBUG
slab_bufctl(slabp)[slabp->free] = BUFCTL_FREE;
WARN_ON(slabp->nodeid != nodeid);
#endif
slabp->free = next; return objp;
}
首先从SLAB中取一个对象，更新计数器，然后获取下一个可用对象的索引，设置到slab的free字段，接着就返回了。
static inline void ac_put_obj(struct kmem_cache *cachep, struct array_cache *ac,
void *objp)
{
if (unlikely(sk_memalloc_socks()))
objp = __ac_put_obj(cachep, ac, objp); ac->entry[ac->avail++] = objp;
}
而put函数就更显简单，直接在对象地址和entry数组建立关联即可。从这里看avail同样是指首个为NULL的索引。这样while循环结束，填充per_CPU 缓存的工作节完成了，接来下要做的就是把SLAB从对应的链表摘下来。如果里面的对象已经用完，则假如到full链表，否则加入到slabs_partial链表。
最后会通过ac_get_obj从当前CPU的缓存entry数组中获取一个对象，返回。而在最终，需要设置entry中分配出去的对象位置为NULL。至此，小缓存块的分配工作就完成了！
总结：
其实小缓存块的管理和普通对象的管理方式基本类似，都是作为对象存储，不同的是一般对象的大小不确定，而小缓存块的大小由系统初始指定；一般对象的缓存可以自己创建，而小缓存块由系统维护。其余的分配流程、保存方式等都是使用相同的API。