[linux kernel]slub内存管理分析(2.5) slab重用
文章目录
-
- 背景
-
- 前情回顾
- 描述方法约定
- SLAB重用总览
-
- 省流总结
- 简介
- 自定义slab 初始化流程
-
- 调用栈
- kmem_cache_create-kmem_cache_create_usercopy
- __kmem_cache_alias
-
- find_mergeable
-
- slab_unmergeable
- create_cache
- 通用slab "kmalloc-xx" 初始化流程
-
- 调用栈
- 总结
背景
前情回顾
关于slab几个结构体的关系和初始化的逻辑请见：
[linux kernel]slub内存管理分析(0) 导读
[linux kernel]slub内存管理分析(1) 结构体
[linux kernel]slub内存管理分析(2) 初始化
描述方法约定
PS：为了方便描述，这里我们将一个用来切割分配内存的page 称为一个slab page，而struct kmem_cache我们这里称为slab管理结构，它管理的真个slab 体系成为slab cache，struct kmem_cache_node这里就叫node。单个堆块称为object或者堆块或内存对象。
SLAB重用总览
省流总结
开启CONFIG_SLAB_MERGE_DEFAULT 则户出现创建一个新的slab cache 的时候不创建新的而是重用已有slab cache 的情况。要求对方要满足条件才可重用：
- 对方slab cache 和自己的
flag都不开启SLAB_NEVER_MERGE - 对方slab cache 和自己都没有构造函数
- 对方的slab cache和自己的
usersize都为0 - 自己的slab 大小和对方相同、对齐相同
名为"kmalloc-xx"的通用slab 由于初始化的时候usersize不为0，则无法被重用。
简介
内核开启CONFIG_SLAB_MERGE_DEFAULT编译选项的时候可能会造成slab 的重用，也就是对于创建新的slab缓存(struct kmem_cache)的时候可能会找一个大小和目前新建的相同的slab 来重用，但也并不是无脑重用的，下面从代码逻辑查看如何重用。
自定义slab 初始化流程
除了默认slab cache，linux内核支持各种结构体或内核模块自定义自己的特定slab cache，有些结构体如struct file 会分配自己的slab 专门用于struct file结构体的申请。以免和其他slab cache通用导致另外的结构体出现漏洞可以复写struct file来漏洞利用。
调用栈
对于用户想要创建一个自己的slab，可以通过kmem_cache_create 函数拉创建：
kmem_cache_create指定名字、大小等信息，初始化一个slab cachekmem_cache_create_usercopy相较于上面多指定了几个参数如usersize、useroffset__kmem_cache_alias查找是否有可重用的slab cachefind_mergeable寻找可重用的slab cache
create_cache没有可重用的slab cache 则创建新的kmem_cache_zalloc__kmem_cache_create
如struct file 的slab "filp_cachep"初始化部分：
fs\file_table.c : files_init
void __init files_init(void)
{
filp_cachep = kmem_cache_create("filp", sizeof(struct file), 0,
SLAB_HWCACHE_ALIGN | SLAB_PANIC | SLAB_ACCOUNT, NULL);
percpu_counter_init(&nr_files, 0, GFP_KERNEL);
}
其他内核模块可以调用kmem_cache_create 来创建自己的slab cache。
kmem_cache_create-kmem_cache_create_usercopy
kmem_cache_create 函数就是直接调用kmem_cache_create_usercopy函数：
mm\slab_common.c : 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_usercopykmem_cache_create_usercopy(name, size, align, flags, 0, 0,
ctor);
//[1] 调用kmem_cache_create_usercopy完成初始化。不过usersize和useroffset都是0
}
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;
··· ···
if (!usersize)//[2]如果传入usersize 为0,调用__kmem_cache_alias 查看是否有可重用的slab cache
s = __kmem_cache_alias(name, size, align, flags, ctor);
if (s)//[2.1] 找到可重用的slab cache 之后直接返回
goto out_unlock;
··· ···
s = create_cache(cache_name, size,//[3]否则调用create_cache 创建一个新slab cache
calculate_alignment(flags, align, size),
flags, useroffset, usersize, ctor, NULL);
if (IS_ERR(s)) {
err = PTR_ERR(s);
kfree_const(cache_name);
}
out_unlock:
··· ···
}
[1] kmem_cache_create 函数中直接调用kmem_cache_create_usercopy 函数申请新的slab cache，但useroffset 和usersize 参数都是0。
[2] 在kmem_cache_create_usercopy中药先调用__kmem_cache_alias 函数寻找是否有可重用的slab cache
[2.1] 如果找到可重用的，直接返回即可，重用该slab cache
[3] 否则调用create_cache 进行初始化
__kmem_cache_alias
__kmem_cache_alias 函数检查是否有可重用的slab cache，有的话则直接返回该slab cache：
mm\slub.c : __kmem_cache_alias
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;
s = find_mergeable(size, align, flags, name, ctor);//[1]寻找可重用的slab cache
if (s) {//[2]如果找到的话
s->refcount++;//[2.1] 增加引用计数
/*
* Adjust the object sizes so that we clear
* the complete object on kzalloc.
*/
s->object_size = max(s->object_size, size);//object_size 为使用这个slab cache 的结构体中最大的
s->inuse = max(s->inuse, ALIGN(size, sizeof(void *)));
if (sysfs_slab_alias(s, name)) {
s->refcount--;
s = NULL;
}
}
return s;
}
[1] 调用find_mergeable 函数寻找一个可以重用的slab cache，下面会分析该函数
[2] 如果找到可重用的slab cache，则会更改一些成员
[2.1] 首先引用计数要增加
[2.2] 然后object_size 代表使用这个slab cache 的结构体大小，应修改为重用这个slab cache 的结构体中最大的大小。
find_mergeable
该函数寻找一个可以直接重用的slab cache，找到直接返回，否则返回NULL
mm\slab_common.c : find_mergeable
struct kmem_cache *find_mergeable(unsigned int size, unsigned int align,
slab_flags_t flags, const char *name, void (*ctor)(void *))
{
struct kmem_cache *s;
if (slab_nomerge) //[1] 首先的开启CONFIG_SLAB_MERGE_DEFAULT
return NULL;
if (ctor)//[1] 必须不传入构造函数才能重用其他slab cache
return NULL;
size = ALIGN(size, sizeof(void *));
align = calculate_alignment(flags, align, size);
size = ALIGN(size, align);
flags = kmem_cache_flags(size, flags, name);
if (flags & SLAB_NEVER_MERGE)//[1] 如果flag 制定了never merge则不会重用
return NULL;
list_for_each_entry_reverse(s, &slab_caches, list) {//[2] 通过slab_caches列表遍历所有slab cache
if (slab_unmergeable(s))//[2.1] 查看是否可以被重用
continue;
if (size > s->size)//[2.2] 当前slab 大小不能大于重用的slab
continue;
if ((flags & SLAB_MERGE_SAME) != (s->flags & SLAB_MERGE_SAME))//[2.2] flag也得一样才行
continue;
/*
* Check if alignment is compatible.
* Courtesy of Adrian Drzewiecki
*/
if ((s->size & ~(align - 1)) != s->size)//[2.2] 对齐满足要求
continue;
if (s->size - size >= sizeof(void *))//[2.2] size得一样，要么浪费太多内存
continue;
if (IS_ENABLED(CONFIG_SLAB) && align &&//slub不涉及
(align > s->align || s->align % align))
continue;
return s;//[3] 通过以上的检查才算成功
}
return NULL;
}
[1] 首先进行一些全局检查是否可以重用：需要开启CONFIG_SLAB_MERGE_DEFAULT；该slab cache不能有构造函数；flag 不设置SLAB_NEVER_MERGE才行。
[2] 然后遍历slab_caches全局列表(之前提到过，所有的slab cache都会被链入该链表)，寻找可以重用的
[2.1] 调用slab_unmergeable 函数挨个被遍历的slab cache看是否可以被重用
[2.2] 即便规则上允许被重用，但能否重用还要看下面几点是否匹配：大小需要一样，小了没法重用，大了浪费内存；flag也要相同；对齐满足要求。
[3] 满足上面的所有要求之后，就算是可以重用，返回。
slab_unmergeable
该函数查看一个slab cache是否可以被重用：
mm\slab_common.c : slab_unmergeable
int slab_unmergeable(struct kmem_cache *s)
{
if (slab_nomerge || (s->flags & SLAB_NEVER_MERGE flag))
return 1;//没开启CONFIG_SLAB_MERGE_DEFAULT并且该slab cache有SLAB_NEVER_MERGE flag的话无法重用
if (s->ctor)//该slab cache 有构造函数无法重用
return 1;
if (s->usersize)//该slab 设置了usersize 无法重用
return 1;
/*
* We may have set a slab to be unmergeable during bootstrap.
*/
if (s->refcount < 0) //该slab 已经准备释放了无法重用
return 1;
return 0;//否则可以重用
}
create_cache
create_cache 函数创建一个新的slab cache：
mm\slab_common.c : create_cache
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 kmem_cache *root_cache)
{
struct kmem_cache *s;
int err;
if (WARN_ON(useroffset + usersize > object_size))
useroffset = usersize = 0;
err = -ENOMEM;
s = kmem_cache_zalloc(kmem_cache, GFP_KERNEL);//分配一个slab 管理结构体
if (!s)
goto out;
s->name = name;//设置基本信息
s->size = s->object_size = object_size;
s->align = align;
s->ctor = ctor;
s->useroffset = useroffset;//这里设置useroffset 和usersize ，从kmem_cache_create走过来的则是0
s->usersize = usersize;
err = __kmem_cache_create(s, flags);//然后初始化。上一章分析过了
if (err)
goto out_free_cache;
s->refcount = 1;
list_add(&s->list, &slab_caches);
out:
if (err)
return ERR_PTR(err);
return s;
out_free_cache:
kmem_cache_free(kmem_cache, s);
goto out;
}
如果在上面的流程中没有找到可重用的，则会调用create_cache 申请新的slab cache，这里使用的kmem_cache_zalloc 和__kmem_cache_create都在上一章分析过了。
这里的创建函数我们需要注意的是，如果是通过kmem_cache_create 函数流程走到这里，则设置usersize 和useroffset 的值是0，而之前slab_unmergeable函数中我们知道usersize 不为0的话是无法被重用的。所以至少在通过kmem_cache_create 创建的slab cache 是默认可重用的。
通用slab “kmalloc-xx” 初始化流程
调用栈
在第二章中我们介绍过slab 的总体初始化流程，其中初始化了通用slab也就是名为"kmalloc-xx"的slab 的初始化过程，调用栈回顾：
create_kmalloc_caches初始化每一个通用slabnew_kmalloc_cache根据下标初始化相应的kmalloc_cachescreate_kmalloc_cache具体初始化操作，主要调用下面两个kmem_cache_zalloc->…->slab_alloc_node从slab 中分配一段内存，参考正常申请流程create_boot_cache初始化这两个slab 结构体__kmem_cache_create核心初始化函数
create_kmalloc_cache(if CONFIG_ZONE_DMA)初始化DAM相关空间
init_freelist_randomization是CONFIG_SLAB_FREELIST_RANDOM的初始化
整体流程我们熟悉了，我们只关注是否有和CONFIG_SLAB_MERGE_DEFAULT 相关的影响slab 重用逻辑的部分，其实只有一处：
mm\slab_common.c : new_kmalloc_cache
static void __init
new_kmalloc_cache(int idx, enum kmalloc_cache_type type, slab_flags_t flags)
{
if (type == KMALLOC_RECLAIM)
flags |= SLAB_RECLAIM_ACCOUNT;
kmalloc_caches[type][idx] = create_kmalloc_cache(
kmalloc_info[idx].name[type],
kmalloc_info[idx].size, flags, 0,
kmalloc_info[idx].size);//这里将usersize 设置为了slab size
}
struct kmem_cache *__init create_kmalloc_cache(const char *name,
unsigned int size, slab_flags_t flags,
unsigned int useroffset, unsigned int usersize);
在new_kmalloc_cache 函数对每个通用slab cache进行初始化的时候，调用create_kmalloc_cache 函数的时候，传入的usersize 并非是0，而是kmalloc_info[idx].size，也就是和slab size一样大。之前我们分析过，如果usersize 非0，则该slab cache无法被重用，也就是说，通用slab 无法被重用。
总结
开启CONFIG_SLAB_MERGE_DEFAULT 则户出现创建一个新的slab cache 的时候不创建新的而是重用已有slab cache 的情况。要求对方要满足条件才可重用：
- 对方slab cache 和自己的
flag都不开启SLAB_NEVER_MERGE - 对方slab cache 和自己都没有构造函数
- 对方的slab cache和自己的
usersize都为0 - 自己的slab 大小和对方相同、对齐相同
名为"kmalloc-xx"的通用slab 由于初始化的时候usersize不为0，则无法被重用。