Linux内存管理：(二)slab分配器

文章说明：

• Linux内核版本：5.0

• 架构：ARM64

• 参考资料及图片来源：《奔跑吧Linux内核》

• Linux 5.0内核源码注释仓库地址：

  zhangzihengya/LinuxSourceCode_v5.0_study (github.com)

1. slab分配器产生的背景

伙伴系统在分配内存时是以物理页面为单位的，在实际中有很多内存需求是以字节为单位的，那么如果我们需要分配以字节为单位的小内存块，该如何分配呢？slab分配器就是用来解决小内存块分配问题的，也是内存分配中非常重要的角色之一。

slab分配器最终还使用伙伴系统来分配实际的物理页面，只不过slab分配器在这些连续的物理页面上实现了自己的机制，以此来对小内存块进行管理。

slab机制如下图所示：

其中每个slab描述符都会建立共享对象缓冲池和本地对象缓冲池。slab机制有如下特性：

• 把分配的内存块当作对象（object）来看待。对象可以自定义构造函数（constructor） 和析构函数（destructor）来初始化对象的内容并释放对象的内容。
• slab对象被释放之后不会马上丢弃而是继续保留在内存中，可能稍后会被用到，这样不需要重新向伙伴系统申请内存。
• slab机制可以根据特定大小的内存块来创建slab描述符，如内存中常见的数据结构、打开文件对象等，这样可以有效地避免内存碎片的产生，也可以快速获得频繁访问的数据结构。另外，slab机制也支持按2的n次方字节大小分配内存块。
• slab机制创建了多层的缓冲池，充分利用了空间换时间的思想，未雨绸谬，有效地解决了效率问题。
  • 每个CPU有本地对象缓冲池，避免了多核之间的锁争用问题。
  • 每个内存节点有共享对象缓冲池。

2. 宏观了解

为了更好地理解slab分配器的细节，我们先从宏观上大致了解下slab系统的架构，如下图所示：

slab系统由slab描述符、slab节点、本地对象缓冲池、共享对象缓冲池、3个slab链表、n个slab分配器，以及众多slab缓存对象组成，相关数据结构的注解如下。

slab描述符：

// kmem_cache数据结构是 slab 分配器中的核心成员，每个 slab 描述符都用一个 kmem_cache 数据结构来抽象描述
struct kmem_cache {
    
    
	// Per-cpu 变量的 array_cache 数据结构，每个CPU一个，表示本地 CPU 的对象缓冲池
	struct array_cache __percpu *cpu_cache;

/* 1) Cache tunables. Protected by slab_mutex */
	// 表示在当前 CPU 的本地对象缓冲池 array_cache 为空时，从共享对象缓冲池或 slabs_partial/slabs_free 列表中获取的对象的数目
	unsigned int batchcount;
	// 当本地对象缓冲池中的空闲对象的数目大于 limit 时，会主动释放 batchcount 个对象，便于内核回收和销毁 slab
	unsigned int limit;
	// 用于多核系统
	unsigned int shared;

	// 对象的长度，这个长度要加上 align 对齐字节
	unsigned int size;
	struct reciprocal_value reciprocal_buffer_size;
/* 2) touched by every alloc & free from the backend */

	// 对象的分配掩码
	slab_flags_t flags;		/* constant flags */
	// 一个 slab 中最多有多少个对象
	unsigned int num;		/* # of objs per slab */

/* 3) cache_grow/shrink */
	/* order of pgs per slab (2^n) */
	unsigned int gfporder;

	/* force GFP flags, e.g. GFP_DMA */
	gfp_t allocflags;

	// 一个 slab 中可以有多少个不同的缓存行
	size_t colour;			/* cache colouring range */
	// 着色区的长度，和 L1 缓存行大小相同
	unsigned int colour_off;	/* colour offset */
	struct kmem_cache *freelist_cache;
	// 每个对象要占用 1 字节来存放 freelist
	unsigned int freelist_size;

	/* constructor func */
	void (*ctor)(void *obj);

/* 4) cache creation/removal */
	// slab 描述符的名称
	const char *name;
	struct list_head list;
	int refcount;
	// 对象的实际大小
	int object_size;
	// 对齐的长度
	int align;

...

	// slab 节点
	// 在 NUMA 系统中，每个节点有一个 kmem_cache_node 数据结构
	// 在 ARM Vexpress 平台上，只有一个节点
	struct kmem_cache_node *node[MAX_NUMNODES];
};

slab节点：

struct kmem_cache_node {
    
    
	// 用于保护 slab 节点中的 slab 链表
	spinlock_t list_lock;

#ifdef CONFIG_SLAB
	// slab 链表，表示 slab 节点中有部分空闲对象
	struct list_head slabs_partial;	/* partial list first, better asm code */
	// slab 链表，表示 slab 节点中没有空闲对象
	struct list_head slabs_full;
	// slab 链表，表示 slab 节点中全部都是空闲对象
	struct list_head slabs_free;
	// 表示 slab 节点中有多少个 slab 对象
	unsigned long total_slabs;	/* length of all slab lists */
	// 表示 slab 节点中有多少个全是空闲对象的 slab 对象
	unsigned long free_slabs;	/* length of free slab list only */
	// 空闲对象的数目
	unsigned long free_objects;
	// 表示 slab 节点中所有空闲对象的最大阈值，即 slab 节点中可容许的空闲对象数目最大阈值
	unsigned int free_limit;
	// 记录当前着色区的编号。所有 slab 节点都按照着色编号来计算着色区的大小，达到最大值后又从 0 开始计算
	unsigned int colour_next;	/* Per-node cache coloring */
	// 共享对象缓冲区。在多核 CPU 中，除了本地 CPU 外，slab 节点中还有一个所有 CPU 都共享的对象缓冲区
	struct array_cache *shared;	/* shared per node */
	// 用于 NUMA 系统
	struct alien_cache **alien;	/* on other nodes */
	// 下一次收割 slab 节点的时间
	unsigned long next_reap;	/* updated without locking */
	// 表示访问了 slabs_free 的 slab 节点
	int free_touched;		/* updated without locking */
#endif

...

};

对象缓冲池：

// slab 描述符会给每个 CPU 提供一个对象缓冲池（array_cache）
// array_cache 可以描述本地对象缓冲池，也可以描述共享对象缓冲池
struct array_cache {
    
    
	// 对象缓冲池中可用对象的数目
	unsigned int avail;
	// 对象缓冲池中可用对象数目的最大阈值
	unsigned int limit;
	// 迁移对象的数目，如从共享对象缓冲池或者其他 slab 中迁移空闲对象到该对象缓冲池的数量
	unsigned int batchcount;
	// 从缓冲池中移除一个对象时，将 touched 置为 1 ；
	// 当收缩缓冲池时，将 touched 置为 0；
	unsigned int touched;
	// 保存对象的实体
	// 指向存储对象的变长数组，每一个成员存放一个对象的指针。这个数组最初最多有 limit 个成员
	void *entry[];
};

对象缓冲池的数据结构中采用了GCC编译器的零长数组，entry[]数组用于存放多个对象，如下图所示：

通过对slab系统架构图有了宏观的认识之后，我们下一步进行细节上的学习。

3. 细节描述

3.1 slab分配器的内存布局

slab分配器的内存布局通常由如下3部分组成：

• 着色区
• n个slab对象
• 管理区。管理区可以看作一个freelist数组，数组的每个成员占用1字节，每个成员代表一个slab对象

Linux 5.0内核支持如下3种slab分配器布局模式：

• OBJFREELIST_SLAB模式。这是Linux 4.6内核新增的—个优化，其目的是高效利用slab分配器中的内存。使用slab分配器中最后一个slab对象的空间作为管理区，如下图所示

  

• OFF_SLAB模式。slab分配器的管理数据不在sIab分配器中，额外分配的内存用于管理，如下图所示

  

• 正常模式。传统的布局模式，如下图所示

  

3.2 创建slab描述符

在内核中，创建slab描述符使用kmem_cache_create()函数，同样先上图为敬，kmem_cache_create()函数的流程如下图所示：

为了使读者有更真切的理解，下文将根据流程图围绕源代码进行讲解这个过程：

kmem_cache_create

// 创建 slab 描述符
// kmem_cache_create() 函数用于创建自己的缓存描述符；kmalloc() 函数用于创建通用的缓存
// name：slab 描述符的名称
// size：缓冲对象的大小
// align：缓冲对象需要对齐的字节数
// flags：分配掩码
// ctor：对象的构造函数
struct kmem_cache *
kmem_cache_create(const char *name, unsigned int size, unsigned int align,
		slab_flags_t flags, void (*ctor)(void *))

kmem_cache_create->...->__kmem_cache_create

// 创建 slab 缓存描述符
int __kmem_cache_create(struct kmem_cache *cachep, slab_flags_t flags)
{
    
    
    ...
	// 让 slab 描述符的大小和系统的 word 长度对齐（BYTES_PER_WORD）
	// 当创建的 slab 描述符的 size 小于 word 长度时，slab 分配器会最终按 word 长度来创建
	size = ALIGN(size, BYTES_PER_WORD);

	// SLAB_RED_ZONE 检查是否溢出，实现调试功能
	if (flags & SLAB_RED_ZONE) {
    
    
		ralign = REDZONE_ALIGN;
		size = ALIGN(size, REDZONE_ALIGN);
	}

	/* 3) caller mandated alignment */
	// 调用方强制对齐
	if (ralign < cachep->align) {
    
    
		ralign = cachep->align;
	}
	...
	 * 4) Store it.
	 */
	cachep->align = ralign;
	// colour_off 表示一个着色区的长度，它和 L1 高速缓存行大小相同
	cachep->colour_off = cache_line_size();
	/* Offset must be a multiple of the alignment. */
	if (cachep->colour_off < cachep->align)
		cachep->colour_off = cachep->align;

	// 枚举类型 slab_state 用来表示 slab 系统中的状态，如 DOWN、PARTIAL、PARTIAL_NODE、UP 和 FULL 等。当 slab 机制完全初始化完成后状态变成 FULL
	// slab_is_available() 表示当 slab 分配器处于 UP 或者 FULL 状态时，分配掩码可以使用 GFP_KERNEL；否则，只能使用 GFP_NOWAIT
	if (slab_is_available())
		gfp = GFP_KERNEL;
	else
		gfp = GFP_NOWAIT;

...

	// slab 对象的大小按照 cachep->align 大小来对齐
	size = ALIGN(size, cachep->align);
	
    ...

	// 若数组 freelist 小于一个 slab 对象的大小并且没有指定构造函数，那么 slab 分配器就可以采用 OBJFREELIST_SLAB 模式
	if (set_objfreelist_slab_cache(cachep, size, flags)) {
    
    
		flags |= CFLGS_OBJFREELIST_SLAB;
		goto done;
	}

	// 若一个 slab 分配器的剩余空间小于 freelist 数组的大小，那么使用 OFF_SLAB 模式
	if (set_off_slab_cache(cachep, size, flags)) {
    
    
		flags |= CFLGS_OFF_SLAB;
		goto done;
	}

	// 若一个 slab 分配器的剩余空间大于 slab 管理数组大小，那么使用正常模式
	if (set_on_slab_cache(cachep, size, flags))
		goto done;

	return -E2BIG;

done:
	// freelist_size 表示一个 slab 分配器中管理区————freelist 大小
	cachep->freelist_size = cachep->num * sizeof(freelist_idx_t);
	cachep->flags = flags;
	cachep->allocflags = __GFP_COMP;
	if (flags & SLAB_CACHE_DMA)
		cachep->allocflags |= GFP_DMA;
	if (flags & SLAB_RECLAIM_ACCOUNT)
		cachep->allocflags |= __GFP_RECLAIMABLE;
	// size 表示一个 slab 对象的大小
	cachep->size = size;
	cachep->reciprocal_buffer_size = reciprocal_value(size);

...

	// 继续配置 slab 描述符
	err = setup_cpu_cache(cachep, gfp);
	if (err) {
    
    
		__kmem_cache_release(cachep);
		return err;
	}

	return 0;
}

3.3 分配slab对象

kmem_cache_alloc()是分配slab缓存对象的核心函数，它内部调用slab_alloc()函数。在slab 对象分配过程中是全程关闭本地中断的。kmem_cache_alloc() 函数的流程图如下所示：

为了使读者有更真切的理解，下文将根据流程图围绕源代码进行讲解这个过程：

kmem_cache_alloc->slab_alloc

// slab_alloc() 函数在 slab 对象分配过程中是全程关闭本地中断的
static __always_inline void *
slab_alloc(struct kmem_cache *cachep, gfp_t flags, unsigned long caller)
{
    
    
	...
    local_irq_save(save_flags);
	// 获取 slab 对象
	objp = __do_cache_alloc(cachep, flags);
	local_irq_restore(save_flags);
	...

	// 如果分配时设置了 __GFP_ZERO 标志位，那么使用 memset() 把 slab 对象的内容清零
	if (unlikely(flags & __GFP_ZERO) && objp)
		memset(objp, 0, cachep->object_size);

	slab_post_alloc_hook(cachep, flags, 1, &objp);
	return objp;
}

kmem_cache_alloc->slab_alloc->...->____cache_alloc

// 获取 slab 对象
static inline void *____cache_alloc(struct kmem_cache *cachep, gfp_t flags)
{
    
    
	void *objp;
	struct array_cache *ac;

	check_irq_off();

	// 获取 slab 描述符 cachep 中的本地对象缓冲池 ac
	ac = cpu_cache_get(cachep);
	// 判断本地对象缓冲池中有没有空闲的对象
	if (likely(ac->avail)) {
    
    
		ac->touched = 1;
		// 获取 slab 对象
		objp = ac->entry[--ac->avail];

		STATS_INC_ALLOCHIT(cachep);
		goto out;
	}

	STATS_INC_ALLOCMISS(cachep);
	// 第一次分配缓存对象时 ac->avail 值为 0，所以它应该在 cache_alloc_refill() 函数中
	objp = cache_alloc_refill(cachep, flags);
	...
    
	return objp;
}

kmem_cache_alloc->slab_alloc->__do_cache_alloc->____cache_alloc->cache_alloc_refill

static void *cache_alloc_refill(struct kmem_cache *cachep, gfp_t flags)
{
    
    
	...
	
	// 获取本地对象缓冲池 ac
	ac = cpu_cache_get(cachep);
	...
	// 获取 slab 节点
	n = get_node(cachep, node);

	BUG_ON(ac->avail > 0 || !n);
	// shared 表示共享对象缓冲池
	shared = READ_ONCE(n->shared);
	// 若 slab 节点没有空闲对象并且共享对象缓冲池 shared 为空或者共享对象缓冲池里也没有空闲对象，那么直接跳转到 direct_grow 标签处
	if (!n->free_objects && (!shared || !shared->avail))
		goto direct_grow;

	...
	
	// 若共享对象缓冲池里有空闲对象，那么尝试迁移 batchcount 个空闲对象到本地对象缓冲池 ac 中
	// transfer_objects() 函数用于从共享对象缓冲池迁移空闲对象到本地对象缓冲池
	if (shared && transfer_objects(ac, shared, batchcount)) {
    
    
		shared->touched = 1;
		goto alloc_done;
	}

	while (batchcount > 0) {
    
    
		/* Get slab alloc is to come from. */
		// 如果共享对象缓冲池中没有空闲对象，那么 get_first_slab() 函数会查看 slab 节点中的 slabs_partial 链表和 slabs_free 链表
		page = get_first_slab(n, false);
		if (!page)
			goto must_grow;

		check_spinlock_acquired(cachep);

		// 从 slab 分配器中迁移 batchcount 个空闲对象到本地对象缓冲池中
		batchcount = alloc_block(cachep, ac, page, batchcount);
		fixup_slab_list(cachep, n, page, &list);
	}

must_grow:
	// 更新 slab 节点中的 free_objects 计数值
	n->free_objects -= ac->avail;
alloc_done:
	spin_unlock(&n->list_lock);
	fixup_objfreelist_debug(cachep, &list);

// 表示 slab 节点没有空闲对象并且共享对象缓冲池中也没有空闲对象，这说明整个内存节点里没有 slab 空闲对象
// 这种情况下只能重新分配 slab 分配器，这就是一开始初始化和配置 slab 描述符的情景
direct_grow:
	if (unlikely(!ac->avail)) {
    
    
		/* Check if we can use obj in pfmemalloc slab */
		if (sk_memalloc_socks()) {
    
    
			void *obj = cache_alloc_pfmemalloc(cachep, n, flags);

			if (obj)
				return obj;
		}

		// 分配一个 slab 分配器
		page = cache_grow_begin(cachep, gfp_exact_node(flags), node);

		/*
		 * cache_grow_begin() can reenable interrupts,
		 * then ac could change.
		 */
		ac = cpu_cache_get(cachep);
		if (!ac->avail && page)
			// 从刚分配的 slab 分配器的空闲对象中迁移 batchcount 个空闲对象到本地对象缓冲池中
			alloc_block(cachep, ac, page, batchcount);
		// 把刚分配的 slab 分配器添加到合适的队列中，这个场景下应该添加到 slabs_partial 链表中
		cache_grow_end(cachep, page);

		if (!ac->avail)
			return NULL;
	}
	// 设置本地对象缓冲池的 touched 为 1，表示刚刚使用过本地对象缓冲池
	ac->touched = 1;

	// 返回一个空闲对象
	return ac->entry[--ac->avail];
}

3.4 释放slab缓存对象

释放slab缓存对象的接口函数是kmem_cache_free()，该流程如下所示：

为了使读者有更真切的理解，下文将根据流程图围绕源代码进行讲解这个过程：

kmem_cache_free->__cache_free->___cache_free

void ___cache_free(struct kmem_cache *cachep, void *objp,
		unsigned long caller)
{
    
    
	struct array_cache *ac = cpu_cache_get(cachep);
	...
	// 当本地对象缓冲池的空闲对象数量 ac->avail 大于或等于 ac->limit 阈值时，就会调用 cache_flusharray() 做刷新动作，尝试回收空闲对象
	if (ac->avail < ac->limit) {
    
    
		STATS_INC_FREEHIT(cachep);
	} else {
    
    
		STATS_INC_FREEMISS(cachep);
		// 主要用于回收 slab 分配器
		cache_flusharray(cachep, ac);
	}
	...
	// 把对象释放到本地对象缓冲池 ac 中
	ac->entry[ac->avail++] = objp;
}