Linux內核版本：5.0
架構：ARM64
Linux 5.0內核源碼注釋倉庫地址：
zhangzihengya/LinuxSourceCode_v5.0_study (http://github.com)

// kmem_cache數(shù)據(jù)結構是 slab 分配器中的核心成員，每個 slab 描述符都用一個 kmem_cache 數(shù)據(jù)結構來抽象描述
struct kmem_cache {
	// Per-cpu 變量的 array_cache 數(shù)據(jù)結構，每個CPU一個，表示本地 CPU 的對象緩沖池
	struct array_cache __percpu *cpu_cache;

/* 1) Cache tunables. Protected by slab_mutex */
	// 表示在當前 CPU 的本地對象緩沖池 array_cache 為空時，從共享對象緩沖池或 slabs_partial/slabs_free 列表中獲取的對象的數(shù)目
	unsigned int batchcount;
	// 當本地對象緩沖池中的空閑對象的數(shù)目大于 limit 時，會主動釋放 batchcount 個對象，便于內核回收和銷毀 slab
	unsigned int limit;
	// 用于多核系統(tǒng)
	unsigned int shared;

	// 對象的長度，這個長度要加上 align 對齊字節(jié)
	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 */
	// 著色區(qū)的長度，和 L1 緩存行大小相同
	unsigned int colour_off;	/* colour offset */
	struct kmem_cache *freelist_cache;
	// 每個對象要占用 1 字節(jié)來存放 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 節(jié)點
	// 在 NUMA 系統(tǒng)中，每個節(jié)點有一個 kmem_cache_node 數(shù)據(jù)結構
	// 在 ARM Vexpress 平臺上，只有一個節(jié)點
	struct kmem_cache_node *node[MAX_NUMNODES];
};

struct kmem_cache_node {
	// 用于保護 slab 節(jié)點中的 slab 鏈表
	spinlock_t list_lock;

#ifdef CONFIG_SLAB
	// slab 鏈表，表示 slab 節(jié)點中有部分空閑對象
	struct list_head slabs_partial;	/* partial list first, better asm code */
	// slab 鏈表，表示 slab 節(jié)點中沒有空閑對象
	struct list_head slabs_full;
	// slab 鏈表，表示 slab 節(jié)點中全部都是空閑對象
	struct list_head slabs_free;
	// 表示 slab 節(jié)點中有多少個 slab 對象
	unsigned long total_slabs;	/* length of all slab lists */
	// 表示 slab 節(jié)點中有多少個全是空閑對象的 slab 對象
	unsigned long free_slabs;	/* length of free slab list only */
	// 空閑對象的數(shù)目
	unsigned long free_objects;
	// 表示 slab 節(jié)點中所有空閑對象的最大閾值，即 slab 節(jié)點中可容許的空閑對象數(shù)目最大閾值
	unsigned int free_limit;
	// 記錄當前著色區(qū)的編號。所有 slab 節(jié)點都按照著色編號來計算著色區(qū)的大小，達到最大值后又從 0 開始計算
	unsigned int colour_next;	/* Per-node cache coloring */
	// 共享對象緩沖區(qū)。在多核 CPU 中，除了本地 CPU 外，slab 節(jié)點中還有一個所有 CPU 都共享的對象緩沖區(qū)
	struct array_cache *shared;	/* shared per node */
	// 用于 NUMA 系統(tǒng)
	struct alien_cache **alien;	/* on other nodes */
	// 下一次收割 slab 節(jié)點的時間
	unsigned long next_reap;	/* updated without locking */
	// 表示訪問了 slabs_free 的 slab 節(jié)點
	int free_touched;		/* updated without locking */
#endif

...

};

// slab 描述符會給每個 CPU 提供一個對象緩沖池（array_cache）
// array_cache 可以描述本地對象緩沖池，也可以描述共享對象緩沖池
struct array_cache {
	// 對象緩沖池中可用對象的數(shù)目
	unsigned int avail;
	// 對象緩沖池中可用對象數(shù)目的最大閾值
	unsigned int limit;
	// 遷移對象的數(shù)目，如從共享對象緩沖池或者其他 slab 中遷移空閑對象到該對象緩沖池的數(shù)量
	unsigned int batchcount;
	// 從緩沖池中移除一個對象時，將 touched 置為 1 ；
	// 當收縮緩沖池時，將 touched 置為 0；
	unsigned int touched;
	// 保存對象的實體
	// 指向存儲對象的變長數(shù)組，每一個成員存放一個對象的指針。這個數(shù)組最初最多有 limit 個成員
	void *entry[];
};

// 創(chuàng)建 slab 描述符
// kmem_cache_create() 函數(shù)用于創(chuàng)建自己的緩存描述符；kmalloc() 函數(shù)用于創(chuàng)建通用的緩存
// name：slab 描述符的名稱
// size：緩沖對象的大小
// align：緩沖對象需要對齊的字節(jié)數(shù)
// flags：分配掩碼
// ctor：對象的構造函數(shù)
struct kmem_cache *
kmem_cache_create(const char *name, unsigned int size, unsigned int align,
		slab_flags_t flags, void (*ctor)(void *))

// 創(chuàng)建 slab 緩存描述符
int __kmem_cache_create(struct kmem_cache *cachep, slab_flags_t flags)
{
    ...
	// 讓 slab 描述符的大小和系統(tǒng)的 word 長度對齊（BYTES_PER_WORD）
	// 當創(chuàng)建的 slab 描述符的 size 小于 word 長度時，slab 分配器會最終按 word 長度來創(chuàng)建
	size = ALIGN(size, BYTES_PER_WORD);

	// SLAB_RED_ZONE 檢查是否溢出，實現(xiàn)調試功能
	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 表示一個著色區(qū)的長度，它和 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 系統(tǒng)中的狀態(tài)，如 DOWN、PARTIAL、PARTIAL_NODE、UP 和 FULL 等。當 slab 機制完全初始化完成后狀態(tài)變成 FULL
	// slab_is_available() 表示當 slab 分配器處于 UP 或者 FULL 狀態(tài)時，分配掩碼可以使用 GFP_KERNEL；否則，只能使用 GFP_NOWAIT
	if (slab_is_available())
		gfp = GFP_KERNEL;
	else
		gfp = GFP_NOWAIT;

...

	// slab 對象的大小按照 cachep->align 大小來對齊
	size = ALIGN(size, cachep->align);
	
    ...

	// 若數(shù)組 freelist 小于一個 slab 對象的大小并且沒有指定構造函數(shù)，那么 slab 分配器就可以采用 OBJFREELIST_SLAB 模式
	if (set_objfreelist_slab_cache(cachep, size, flags)) {
		flags |= CFLGS_OBJFREELIST_SLAB;
		goto done;
	}

	// 若一個 slab 分配器的剩余空間小于 freelist 數(shù)組的大小，那么使用 OFF_SLAB 模式
	if (set_off_slab_cache(cachep, size, flags)) {
		flags |= CFLGS_OFF_SLAB;
		goto done;
	}

	// 若一個 slab 分配器的剩余空間大于 slab 管理數(shù)組大小，那么使用正常模式
	if (set_on_slab_cache(cachep, size, flags))
		goto done;

	return -E2BIG;

done:
	// freelist_size 表示一個 slab 分配器中管理區(qū)————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);

...

	// 繼續(xù)配置 slab 描述符
	err = setup_cpu_cache(cachep, gfp);
	if (err) {
		__kmem_cache_release(cachep);
		return err;
	}

	return 0;
}

// slab_alloc() 函數(shù)在 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;
}

// 獲取 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() 函數(shù)中
	objp = cache_alloc_refill(cachep, flags);
	...
    
	return objp;
}

static void *cache_alloc_refill(struct kmem_cache *cachep, gfp_t flags)
{
	...
	
	// 獲取本地對象緩沖池 ac
	ac = cpu_cache_get(cachep);
	...
	// 獲取 slab 節(jié)點
	n = get_node(cachep, node);

	BUG_ON(ac->avail > 0 || !n);
	// shared 表示共享對象緩沖池
	shared = READ_ONCE(n->shared);
	// 若 slab 節(jié)點沒有空閑對象并且共享對象緩沖池 shared 為空或者共享對象緩沖池里也沒有空閑對象，那么直接跳轉到 direct_grow 標簽處
	if (!n->free_objects && (!shared || !shared->avail))
		goto direct_grow;

	...
	
	// 若共享對象緩沖池里有空閑對象，那么嘗試遷移 batchcount 個空閑對象到本地對象緩沖池 ac 中
	// transfer_objects() 函數(shù)用于從共享對象緩沖池遷移空閑對象到本地對象緩沖池
	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() 函數(shù)會查看 slab 節(jié)點中的 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 節(jié)點中的 free_objects 計數(shù)值
	n->free_objects -= ac->avail;
alloc_done:
	spin_unlock(&n->list_lock);
	fixup_objfreelist_debug(cachep, &list);

// 表示 slab 節(jié)點沒有空閑對象并且共享對象緩沖池中也沒有空閑對象，這說明整個內存節(jié)點里沒有 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];
}

void ___cache_free(struct kmem_cache *cachep, void *objp,
		unsigned long caller)
{
	struct array_cache *ac = cpu_cache_get(cachep);
	...
	// 當本地對象緩沖池的空閑對象數(shù)量 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;
}

struct sample_struct {
    int id;
    char name[20];
    char address[50];
};

static struct kmem_cache *sample_struct_cachep;
static void init_sample_struct_cache( void ){
    sample_struct_cachep = kmem_cache_create(
        "sample_struct_cachep",  /* Name */
        sizeof(struct sample_struct), /* Object Size */
        0,     /* Alignment */
        SLAB_HWCACHE_ALIGN,  /* Flags */
        NULL);  /* Constructor */
    return;
}

int slab_test( void ){
    struct sample_struct *object;
    printk( "Cache name is %s\n", kmem_cache_name( sample_struct_cachep ) );
    printk( "Cache object size is %d\n", kmem_cache_size( sample_struct_cachep ) );
    object = kmem_cache_alloc(sample_struct_cachep, GFP_KERNEL);
    if (object) {
        // 使用 object...
        kmem_cache_free(sample_struct_cachep, object);
    }
    return 0;
}

void kmem_cache_destroy(struct kmem_cache *cachep){
    BUG_ON(!cachep || in_interrupt());
    /* Find the cache in the chain of caches. */
    get_online_cpus();
    mutex_lock(&cache_chain_mutex);
    /** the chain is never empty, cache_cache is never destroyed*//*將 cache 從 cache_chain 中刪除*/
    list_del(&cachep->next);
    /*釋放完 free 鏈表,如果 FULL 鏈表或 partial 鏈表中還有 slab,說明還有對象處于分配狀態(tài)因此不能銷毀該緩存!*/
    if (__cache_shrink(cachep)) {
        slab_error(cachep, "Can't free all objects");
        /*重新將緩存添加到 cache_chain 鏈表中*/
        list_add(&cachep->next, &cache_chain);
        mutex_unlock(&cache_chain_mutex);
        put_online_cpus();
        return;
    }
    if (unlikely(cachep->flags & SLAB_DESTROY_BY_RCU))
        rcu_barrier();
    /*釋放 cache 所涉及到的各個描述符的存儲對象*/
    __kmem_cache_destroy(cachep);
    mutex_unlock(&cache_chain_mutex);
    put_online_cpus();
}

static int __cache_shrink(struct kmem_cache *cachep){
    int ret = 0, i = 0;
    struct kmem_list3 *l3;
    /*將本地高速緩存，share 本地高速緩存以及 alien 高速緩存的空閑對象釋放 slab*/
    drain_cpu_caches(cachep);
    check_irq_on();
    for_each_online_node(i) {
        l3 = cachep->nodelists[i];
        if (!l3) continue;
        /*銷毀空閑鏈表中的 slab*/
        drain_freelist(cachep, l3, l3->free_objects);
        /*判斷 full 和 partial 是否為空，有一個不為空則 ret 就為 1*/
        ret +=!list_empty(&l3->slabs_full) ||!list_empty(&l3->slabs_partial);
    }
    return (ret? 1 : 0);
}

drain_cpu_caches()的最終落腳在 free_block()函數(shù)上，該函數(shù)在前面已做過分析，在此不再列出。

static int drain_freelist(struct kmem_cache *cache, struct kmem_list3 *l3, int tofree){
    struct list_head *p;
    int nr_freed;
    struct slab *slabp;
    nr_freed = 0;
    /*slab 中的對象還未釋放完并且 free 鏈表不為空*/
    while (nr_freed < tofree &&!list_empty(&l3->slabs_free)) {
        spin_lock_irq(&l3->list_lock);
        p = l3->slabs_free.prev;
        if (p == &l3->slabs_free) {/*鏈表中已無元素*/
            spin_unlock_irq(&l3->list_lock);
            goto out;
        }
        /*從 free 鏈表中取出一個 slab*/
        slabp = list_entry(p, struct slab, list);
#if DEBUG
        BUG_ON(slabp->inuse);
#endif
        /*從鏈表中刪除*/
        list_del(&slabp->list);
        /** Safe to drop the lock. The slab is no longer linked* to the cache.*//*空閑對象數(shù)量總數(shù)減去 num*/
        l3->free_objects -= cache->num;
        spin_unlock_irq(&l3->list_lock);
        /*銷毀 slab*/
        slab_destroy(cache, slabp);
        nr_freed++;
    }
out:
    return nr_freed;
}

slab_destroy()函數(shù)已在前文中分析。

static void __kmem_cache_destroy(struct kmem_cache *cachep){
    int i;
    struct kmem_list3 *l3;
    /*釋放存儲本地高速緩存描述符的對象*/
    for_each_online_cpu(i)
        kfree(cachep->array[i]);
    /* NUMA: free the list3 structures */
    for_each_online_node(i) {
        l3 = cachep->nodelists[i];
        if (l3) {
            /*釋放存儲共享本地高速緩存描述符的對象*/
            kfree(l3->shared);
            /*釋放存儲 alien 本地高速緩存描述符的對象*/
            free_alien_cache(l3->alien);
            /*釋放存儲 kmem_list3 描述符的對象*/
            kfree(l3);
        }
        /*釋放存儲緩存描述符的對象*/
        kmem_cache_free(&cache_cache, cachep);
    }}