kmem_cache_create

kmem_cache_create_usercopy

__kmem_cache_alias

find_mergeable

create_cache

__kmem_cache_create

kmem_cache_open

kmem_cache_destroy

shutdown_cache

内核版本： kernel-4.19

kmem_cache是slub分配的基础，实际就是slub缓存；kmem_cache主要是描述如何管理一堆对象，其实就是slab的布局。每个对象都是固定字节的大小，并且分配的对象地址按照8字节(sizeof(void *))对齐；他是kmem_cache_create创建的，kmem_cache_destroy来进行销毁的；内核默认创建的kmem_cache有kmem_cache_node、kmalloc-128、kmalloc-256、net_namespace、pid_namespace等，当然我们自己也可以定义自己的kmem_cahce，很多驱动都会定义自己的kmem_cache，通过cat /proc/slabinfo可以查看kmem_cache的使用情况；注意，kmem_cache_create仅仅是创建了一个描述slab缓存池布局的数据结构，并没有从伙伴系统申请内存，具体的申请内存操作是在kmeme_cache_alloc中完成的。

这篇文章主要讲讲kmem_cache_create和kmem_cache_destroy的具体实现原理；

kmem_cache_create

从一个具体的inode_cache入手吧，这里创建一个名为inode_cache的kmem_cache作为分配inode的slub缓存，通过入参，可以知道其对象大小就是inode的结构体的大小，也就是说，通过此inode_cache缓存可以用于高效分配inode，还包含slab flag、对象构造函数init_once；

static struct kmem_cache *inode_cachep __read_mostly;

   inode_cachep = kmem_cache_create("inode_cache",sizeof(struct inode),0,(SLAB_RECLAIM_ACCOUNT|SLAB_PANIC|SLAB_MEM_SPREAD|SLAB_ACCOUNT),init_once);

首先是对函数的封装和导出：kmem_cache_create就是kmem_cache_create_usercopy的一个封装；

struct kmem_cache *
kmem_cache_create(const char *name, unsigned int size, unsigned int align,slab_flags_t flags, void (*ctor)(void *))
{return kmem_cache_create_usercopy(name, size, align, flags, 0, 0,ctor);
}
EXPORT_SYMBOL(kmem_cache_create);

核心调用关系图如下：

kmem_cache_create_usercopy

下来详细介绍下kmem_cache_create_usercopy函数；这个函数主要工作就是：

1）入参检查，主要对对象大小和对象名称做检查

2）合并现有的slub缓存

3）分配和初始化kmem_cache中的这三个管理结构和成员：kmem_cache，kmem_cache_node和kmem_cache_cpu。


/** kmem_cache_create_usercopy - Create a cache.* @name: A string which is used in /proc/slabinfo to identify this cache.//kmem_cache的名称* @size: The size of objects to be created in this cache.//cache中的对象大小* @align: The required alignment for the objects.//对象对齐方式,上层都是传入的0* @flags: SLAB flags* @useroffset: Usercopy： region offset // 传入0* @usersize: Usercopy region size   // 传入0* @ctor: A constructor for the objects. //对象构造函数,* //成功，返回一个指向kmem_cache的指针，失败返回NULL* Returns a ptr to the cache on success, NULL on failure.* Cannot be called within a interrupt, but can be interrupted.* //当新分配一个page的是否，通过ctor函数构造object* The @ctor is run when new pages are allocated by the cache.** The flags are** %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5)* to catch references to uninitialised memory.** %SLAB_RED_ZONE - Insert `Red' zones around the allocated memory to check* for buffer overruns.** %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware* cacheline.  This can be beneficial if you're counting cycles as closely* as davem.*/
struct kmem_cache *
kmem_cache_create_usercopy(const char *name,unsigned int size, unsigned int align,slab_flags_t flags,unsigned int useroffset, unsigned int usersize,void (*ctor)(void *))
{struct kmem_cache *s = NULL;const char *cache_name;int err;get_online_cpus();//获取cpu热插拔锁cpu_hotplug_lock,防止热插拔改变cpu_online_mapget_online_mems();//获取内存热插拔锁mem_hotplug_lock,防止内存热插拔memcg_get_cache_ids();//获取memcg读写信号量memcg_cache_ids_sem,保护memcg caches array大小 memcg_nr_cache_idsmutex_lock(&slab_mutex);//获取slab_mutex互斥锁err = kmem_cache_sanity_check(name, size);//入参检查，不能在中断中执行、cache名字不能为空,对象大小在8字节-KMALLOC_MAX_SIZE字节之间,kmalloc 一般情况下的上限是 128K ，但是如果打开了 KMALLOC_MAX_SIZE 这个宏，可以申请的内存会更大if (err) {goto out_unlock;}/* Refuse requests with allocator specific flags */if (flags & ~SLAB_FLAGS_PERMITTED) {//只支持指定的一些flagerr = -EINVAL;goto out_unlock;}/** Some allocators will constraint the set of valid flags to a subset* of all flags. We expect them to define CACHE_CREATE_MASK in this* case, and we'll just provide them with a sanitized version of the* passed flags.*/flags &= CACHE_CREATE_MASK;//设置组合标志集合SLAB_CORE_FLAGS | SLAB_DEBUG_FLAGS | SLAB_CACHE_FLAGS/* Fail closed on bad usersize of useroffset values. */if (WARN_ON(!usersize && useroffset) || //检查或纠正usersize、useroffsetWARN_ON(size < usersize || size - usersize < useroffset))usersize = useroffset = 0;if (!usersize)//判断是否有可合并的缓存，有的话合并返回现有的kmem_cache,同时更新kmem_cache的对象及其memcg缓存的对象大小等kmem_cache元数据，最后调用sysfs_slab_alias()在sysfs中添加别号。s = __kmem_cache_alias(name, size, align, flags, ctor);if (s)goto out_unlock;cache_name = kstrdup_const(name, GFP_KERNEL);//条件复制name字段到cache_nameif (!cache_name) {err = -ENOMEM;goto out_unlock;}/*1 通过名为kmem_cache的slub缓存，创建一个名为name的slub缓存*2 初始化kmem_cache slab缓存元数据 name、对象大小size、对齐方式align、对象构造函数ctor、useroffset、usersize*3 初始化->memcg_params相关成员等*4 进一步按需添加flag，然后更新设置slub缓存size(+freepointer + slub_debug)、min、oo、max、allocflags等成员*5 设置min_partial成员、根据对象大小来设置cpu_partial、初始化kmem_cache_node*6 初始化s->memcg_params.root_cache*7 添加此kmem_cahce 缓存到slab_cache全局list head中*/s = create_cache(cache_name, size,calculate_alignment(flags, align, size),flags, useroffset, usersize, ctor, NULL, NULL);if (IS_ERR(s)) {err = PTR_ERR(s);kfree_const(cache_name);}//下面是一些锁的恢复操作和错误处理，如果无错，返回keme_cache s，实际上这里的slub缓存并没有分配实际的slab和对象构
造，只是做了元数据的初始化操作
out_unlock:mutex_unlock(&slab_mutex);memcg_put_cache_ids();put_online_mems();put_online_cpus();//对cpu_online_map的解锁if (err) {if (flags & SLAB_PANIC)panic("kmem_cache_create: Failed to create slab '%s'. Error %d\n",name, err);else {pr_warn("kmem_cache_create(%s) failed with error %d\n",name, err);dump_stack();}return NULL;}return s;
}
EXPORT_SYMBOL(kmem_cache_create_usercopy);

memcg_get_cache_ids、kmem_cache_sanity_check比较简单，不做介绍，接下来介绍下

__kmem_cache_alias函数；

__kmem_cache_alias

关键调用链：

他的功能主要是：

1）通过find_mergeable发现可合并的slub缓存，然后更新对象大小s->size和按照word对齐的对象大小s->inuse;同时也要更新以s为root cache的所有的memcg缓存对象元数据。如果这里找到现有匹配的slub缓存，则直接返回现有的slab缓存，并在sysfs系统中增加别名；不用再创建新的slub缓存；

struct kmem_cache *
__kmem_cache_alias(const char *name, unsigned int size, unsigned int align,slab_flags_t flags, void (*ctor)(void *))
{struct kmem_cache *s, *c;s = find_mergeable(size, align, flags, name, ctor);//发现可合并的kmem_cacheif (s) {s->refcount++;//操作kmem_cache前，引用技术+1/** Adjust the object sizes so that we clear* the complete object on kzalloc.*/s->object_size = max(s->object_size, size);//取原缓存对象与当前指定对象大小的最大值为新对象大小s->inuse = max(s->inuse, ALIGN(size, sizeof(void *)));//同上，设置按照word对齐的的对象大小for_each_memcg_cache(c, s) {//轮询设置以s为root cache的所有的memcg缓存对象元数据c->object_size = s->object_size;c->inuse = max(c->inuse, ALIGN(size, sizeof(void *)));}if (sysfs_slab_alias(s, name)) {//在sysfs中添加别称，并还原引用计数s->refcount--;s = NULL;}}return s;
}

接下来看看发现可合并的slub缓存函数的实现；

find_mergeable

        slab_flags_t flags, const char *name, void (*ctor)(void *))
{struct kmem_cache *s;//检查内核slab merge控制配置if (slab_nomerge)return NULL;if (ctor)return NULL;//先以word对齐size = ALIGN(size, sizeof(void *));//综合考虑硬件缓存的对齐方式align = calculate_alignment(flags, align, size);//按照综合后的对其方式设置对象大小size = ALIGN(size, align);//按cmdline配置确认是否增加slub_debug flagflags = kmem_cache_flags(size, flags, name, NULL);if (flags & SLAB_NEVER_MERGE)return NULL;//遍历slab_root_caches链表slab_cache,里面包含所有的slab cache，root_caches_node实际是memcg_params.__root_caches_nodelist_for_each_entry_reverse(s, &slab_root_caches, root_caches_node) {if (slab_unmergeable(s))continue;if (size > s->size)continue;//判断当前的kmem_cache与查找的标识类型是否一致，不是则跳过if ((flags & SLAB_MERGE_SAME) != (s->flags & SLAB_MERGE_SAME))continue;/** Check if alignment is compatible.* Courtesy of Adrian Drzewiecki*///判断对齐量是否匹配if ((s->size & ~(align - 1)) != s->size)continue;//判断大小相差是否超过word大小,是则跳过if (s->size - size >= sizeof(void *))continue;//对齐格式需要大于等于align或者整除align，否则跳过if (IS_ENABLED(CONFIG_SLAB) && align &&(align > s->align || s->align % align))continue;//flag相同、对象大小相差一个字以内、对齐格式大于等于align或者整除align，则可以合并
,直接返回匹配现有的slub缓存return s;}return NULL;
}

如果没有找到可以复用的slub缓存，则调用create_cache创建新的slub缓存。

create_cache

核心调用链路：

该函数的作用如下：

/*1 通过名为kmem_cache的slub缓存，创建一个名为name的slub缓存
*2 初始化kmem_cache slab缓存元数据 name、对象大小size、对齐方式align、对象构造函数ctor、useroffset、usersize
*3 初始化->memcg_params相关成员等
*4 进一步按需添加flag，然后更新设置slub缓存size(+freepointer + slub_debug)、min、oo、
max、allocflags等成员
*5 设置min_partial成员、根据对象大小来设置cpu_partial、初始化kmem_cache_node
*6 初始化s->memcg_params.root_cache
*7 添加此kmem_cahce 缓存到slab_cache全局list head中
*/

static struct kmem_cache *create_cache(const char *name,unsigned int object_size, unsigned int align,slab_flags_t flags, unsigned int useroffset,unsigned int usersize, void (*ctor)(void *),struct mem_cgroup *memcg, struct kmem_cache *root_cache)
{struct kmem_cache *s;int err;if (WARN_ON(useroffset + usersize > object_size))useroffset = usersize = 0;err = -ENOMEM;//通过名为kmem_cache的slub缓存，创建一个名为name的slub缓存s = kmem_cache_zalloc(kmem_cache, GFP_KERNEL);if (!s)goto out;//初始化kmem_cache slab缓存元数据 name、对象大小size、对齐方式align、对象构造函数ctor、useroffset、usersizes->name = name;s->size = s->object_size = object_size;s->align = align;s->ctor = ctor;s->useroffset = useroffset;s->usersize = usersize;//初始化->memcg_params相关成员等err = init_memcg_params(s, memcg, root_cache);if (err)goto out_free_cache;/* 1 进一步按需添加flag，然后更新设置slub缓存size(+freepointer + slub_debug)、min、oo、max、allocflags等成员* 2 设置min_partial成员、根据对象大小来设置cpu_partial、初始化kmem_cache_node* 3 初始化s->memcg_params.root_cache*/err = __kmem_cache_create(s, flags);if (err)goto out_free_cache;//destroy之前需要确认为0s->refcount = 1;//将新建的slub缓存加入到全局链表slab_cacheslist_add(&s->list, &slab_caches);memcg_link_cache(s);
out:if (err)return ERR_PTR(err);return s;out_free_cache:destroy_memcg_params(s);kmem_cache_free(kmem_cache, s);goto out;
}

接下来讲一下核心结构成员的初始化函数__kmem_cache_create