内存管理器（十五）kernel内存管理---slab设计与实现2（初始化与创建）

矫情吗；* 2022-08-10 04:50 219阅读 0赞

## 内存管理器（十五）kernel内存管理---slab设计与实现2 ##

## 前言 ##

上一篇博文主要写了slab的设计与主要的数据结构，但是依然有很多的问题没有解决，在这里先标记下。

1.着色这个动作到底干了什么?是否只是为了减少内存碎片？

2.slab 结构体并没有再内核源码中定义，它是如何实现对不同类型对象的分配的？

带着这两个问题我们进入slab 实现的探索

## slab 实现 ##

### 首先一个应用实例 ###

本来想要先从初始化开始，但是又觉得直接开始分析实现不是很直观，不如先学会如何使用然后再回头看看如何实现，这也是一个正常且正确的认知过程。

还是使用我们最常用的工具内核模块

我们首先在自己的内核开发树中建立一个自己的例字结构体

\[c\]

\#ifndef \_TEST\_H  
\#define \_TEST\_H  
typedef struct TEST\{  
int num;  
char \*name;  
\}TEST;

\#endif

\[/c\]

\[c\]

开始看我们的内核模块

\#include<linux/module.h>  
\#include<linux/slab.h>  
\#include<linux/mm.h>  
\#include<linux/gfp.h>  
\#include<linux/mm\_types.h>  
\#include<linux/list.h>  
\#include<linux/types.h>  
\#include<linux/test.h>

MODULE\_LICENSE("GPL");  
MODULE\_AUTHOR("zmrlinux");  
MODULE\_DESCRIPTION("something about slab\_create");  
static struct kmem\_cache \*test;

static int \_\_init slab\_create(void)\{  
struct TEST \*pos;  /\*三个示例\*/  
struct TEST \*temp;  
struct TEST \*p;  
printk("\\n\\n");  
test = kmem\_cache\_create("TEST",sizeof(struct TEST),8,SLAB\_RED\_ZONE,((void \*) 0));

/\*kmem\_cache\_create 这个函数用来创建我们这个结构体的高速缓存节点\*/  
if(!test)\{  
printk("create failed ");  
return -1;  
\}else\{  
printk("I create a kmem\_cache is ok ,i feel good\\n");  
\}  
printk("create a test slab of test\\n");  
pos = kmem\_cache\_alloc(test,GFP\_KERNEL);

/\*从我们的高速缓存区中分配一个结构体\*/  
if(NULL == pos)\{  
printk("alloc new slab is failed\\n");  
return -1;  
\}else\{  
printk("create pos is ok\\n");  
printk("pos :%p\\n",pos);  
\}  
temp = kmem\_cache\_alloc(test,GFP\_KERNEL);  
if(NULL == temp)\{  
printk("alloc new slab is failed\\n");  
return -1;  
\}else\{  
printk("create temp is ok \\n");  
printk("temp :%p\\n",temp);  
\}  
p = kmem\_cache\_alloc(test,GFP\_KERNEL);  
if(NULL == p)\{  
printk("alloc new slab is failed\\n");  
return -1;  
\}else\{  
printk("create temp is ok\\n");  
printk("p :%p\\n",p);  
\}  
printk("betewn size is %ld\\n",(temp-pos));  
/\*打印两个节点的距离\*/

kmem\_cache\_free(test,pos);  
kmem\_cache\_free(test,temp);

return 0;  
\}

static void \_\_exit slab\_out(void)\{

printk("BYBY :)\\n");

module\_init(slab\_create);  
module\_exit(slab\_out);

\[/c\]

效果如下：

[![2015-11-09 21:45:59 的屏幕截图][2015-11-09 21_45_59]][2015-11-09 21_45_59]

可以看到我们已经成功的创建了高速缓存节点，并且从中获得了节点实例。

下来我们看看实现

### \_init 初始化 ###

这里首先说一个问题，在初始化这个slab 的时候，内核需要若干小与一个整页的内存块，这些最适合kmalloc分配但是，只有在slab系统启动后才能启动kmalloc 所以，这里需要一些技巧，我们接着网下看。

\[c\]

/\*  
\* Initialisation. Called after the page allocator have been initialised and  
\* before smp\_init().  
\*/

/\*在伙伴系统启动后，多个CPU启动之前开始初始化，所以到这里启动的时候只有一个启动CPU能工作，其他处理器还没启动，明确它的启动时机之后我们就可以看下一步了\*/  
void \_\_init kmem\_cache\_init(void)  
\{  
int i;

BUILD\_BUG\_ON(sizeof(((struct page \*)NULL)->lru) <  
sizeof(struct rcu\_head));  
kmem\_cache = &kmem\_cache\_boot; /\*第一个高速缓存开始建立\*/

if (num\_possible\_nodes() == 1) /\*如果可能使用的节点为0，使用了位图\*/  
use\_alien\_caches = 0; /\*可用的节点为0\*/  
for (i = 0; i < NUM\_INIT\_LISTS; i++)  
kmem\_cache\_node\_init(&init\_kmem\_cache\_node\[i\]);  
/\*这里的循环主要是对于NUMA体系架构的，循环初始化每个CPU的私有高速缓存，但是对于SMP架构的暂时不说\*/  
/\*  
\* Fragmentation (碎片） resistance(阻力） on low（低） memory - only use bigger  
\* page orders on(命令） machines with more than 32MB of memory if  
\* not overridden on the command line.  
\*/ /\*确定最大的slab大小\*/  
if (!slab\_max\_order\_set && totalram\_pages > (32 << 20) >> PAGE\_SHIFT)  
slab\_max\_order = SLAB\_MAX\_ORDER\_HI;

/\* Bootstrap is tricky, because several objects are allocated  
\* from caches that do not exist yet:引导时需要技巧的，尤其是对象还没有创建  
\* 1) initialize the kmem\_cache cache: it contains(包含） the struct  
\* kmem\_cache structures of all caches, except kmem\_cache itself:  
\* kmem\_cache is statically allocated.  首先创建的高速缓存是静态的  
\* Initially an \_\_init data area is used for the head array and the  
\* kmem\_cache\_node structures, it's replaced with a kmalloc allocated  
\* array at the end of the bootstrap. 最初的时候创建slab的头部数组就是kmem\_cache\_no\*de 结构体，这个数组将会被kmalloc分配的数组所替换，在自举的最后阶段  
\* 2) Create the first kmalloc cache. 创建第一个kmalloc的存储空间，这个时候kmalloc  
\* 还不能适用，这里首先期望kmalloc 可以被使用。  
\* The struct kmem\_cache for the new cache is allocated normally.这个高速缓存是普\* 通创建的。  
\* An \_\_init data area is used for the head array.(be used for用来做，最初的数据  
\* 域被用来做头数组  
\* 3) Create the remaining kmalloc caches, with minimally sized  
\* head arrays.  使用静态数组的剩下的空间创建剩下的缓存  
\* 4) Replace the \_\_init data head arrays for kmem\_cache and the first  
\* kmalloc cache with kmalloc allocated arrays.将头部数组替换成kmem\_cache 控制结构\* 体，将第一次为kmalloc 分配的cache 替换为kmalloc 分配的数组。  
\* 5) Replace the \_\_init data for kmem\_cache\_node for kmem\_cache and  
\* the other cache's with kmalloc allocated memory.将最初的数据逐步替换为kmem\_cach\* e  
\* 6) Resize the head arrays of the kmalloc caches to their final sizes.  
\*/  /\*逐步替换\*/ 调整头数组的最终大小

/\* 1) create the kmem\_cache \*/

/\*  
\* struct kmem\_cache size depends on nr\_node\_ids & nr\_cpu\_ids  
\*/

/\*创建第一个高速缓存实例，很多东西都是静态写好的，他的大小却绝于CPU等信息\*/  
create\_boot\_cache(kmem\_cache, "kmem\_cache",  
offsetof(struct kmem\_cache, node) +  
nr\_node\_ids \* sizeof(struct kmem\_cache\_node \*),  
SLAB\_HWCACHE\_ALIGN);  
/\*创建kmem\_cache 最终调用了\_\_kmem\_cache\_create()函数，这个函数在下边有介绍\*/  
list\_add(&kmem\_cache->list, &slab\_caches);/\*将kmem\_cache 加入kmem\_caches链表\*/  
slab\_state = PARTIAL;  
/\*将缓存创建后，设置缓存的出状态\*/  
/\*  
\* Initialize the caches that provide memory for the kmem\_cache\_node  
\* structures first. Without this, further allocations will bug.  
\*/ /\*为高速缓存节点创建提供内存而初始化一部分缓存\*/  
kmalloc\_caches\[INDEX\_NODE\] = create\_kmalloc\_cache("kmalloc-node",  
kmalloc\_size(INDEX\_NODE), ARCH\_KMALLOC\_FLAGS);  
slab\_state = PARTIAL\_NODE;

/\*修改标记\*/

slab\_early\_init = 0;

/\* 5) Replace the bootstrap kmem\_cache\_node \*/  
\{ /\*替换启动时的kmem\_cache\_node\*/  
int nid;

for\_each\_online\_node(nid) \{  
init\_list(kmem\_cache, &init\_kmem\_cache\_node\[CACHE\_CACHE + nid\], nid);

init\_list(kmalloc\_caches\[INDEX\_NODE\],  
&init\_kmem\_cache\_node\[SIZE\_NODE + nid\], nid);  
\}  
\}

create\_kmalloc\_caches(ARCH\_KMALLOC\_FLAGS);  
\}

\[/c\]

\[c\]

void \_\_init kmem\_cache\_init\_late(void)  
\{  
struct kmem\_cache \*cachep;    /\*高速缓存节点\*/

slab\_state = UP;

/\* 6) resize the head arrays to their final sizes \*/  
mutex\_lock(&slab\_mutex);  /\*获取锁，遍历一边寻找是否初始化过这个节点，如果有直接BUG\*/  
list\_for\_each\_entry(cachep, &slab\_caches, list)  
if (enable\_cpucache(cachep, GFP\_NOWAIT))  
BUG();  
mutex\_unlock(&slab\_mutex); /\*解锁\*/

/\* Done! \*/  
slab\_state = FULL;  /\*初始化完成\*/

/\*  
\* Register a cpu startup notifier callback that initializes  
\* cpu\_cache\_get for all new cpus  
\*/  
register\_cpu\_notifier(&cpucache\_notifier);

\#ifdef CONFIG\_NUMA  
/\*  
\* Register a memory hotplug callback that initializes and frees  
\* node.  
\*/  
hotplug\_memory\_notifier(slab\_memory\_callback, SLAB\_CALLBACK\_PRI);  
\#endif

/\*  
\* The reap timers are started later, with a module init call: That part  
\* of the kernel is not yet operational.  
\*/  
\}

static int \_\_init cpucache\_init(void)  /\*初始化CPU的缓存，将不需要的页返回\*/  
\{  
int cpu;

/\*  
\* Register the timers that return unneeded pages to the page allocator  
\*/  
for\_each\_online\_cpu(cpu)  
start\_cpu\_timer(cpu);

/\* Done! \*/  
slab\_state = FULL;  
return 0;

\[/c\]

创建一个高速缓存，就是我们上边用的kmem\_cache\_create

\[c\]

/\*  
\* kmem\_cache\_create - Create a cache.  
\* @name: A string which is used in /proc/slabinfo to identify this cache.  
\* @size: The size of objects to be created in this cache.  
\* @align: The required alignment for the objects.  
\* @flags: SLAB flags  
\* @ctor: A constructor for the objects.  
\*以上是参数列表，分别是名称，大小，对齐，SLAB 标识，构造函数（现在不太用了）  
\* Returns a ptr to the cache on success, NULL on failure.  
\* Cannot beint called within a inerrupt, but can be interrupted.  
\* 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(const char \*name, size\_t size, size\_t align,  
unsigned long flags, void (\*ctor)(void \*))  
\{  
struct kmem\_cache \*s; /\*分配目标变量\*/  
const char \*cache\_name; /\*需要分配缓存区的名字\*/  
int err;

get\_online\_cpus();  /\*关掉内核抢占，防并发访问,并且给CPU引用计数+1\*/  
get\_online\_mems();  
memcg\_get\_cache\_ids(); /\*获得内存节点ID\*/

mutex\_lock(&slab\_mutex);/\*获得slab的锁\*/

err = kmem\_cache\_sanity\_check(name, size); /\*name 冲突检查\*/  
if (err) \{  
s = NULL; /\* suppress uninit var warning \*/  
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;   /\*设置过干净的基本的标志后开始进行分配操作了\*/

s = \_\_kmem\_cache\_alias(name, size, align, flags, ctor);/\*第一次分配请看下边详细分解\*/  
if (s)\{ /\*分配成功直接返回地址，并且处理一些后序工作\*/  
goto out\_unlock;  
\}  
cache\_name = kstrdup\_const(name, GFP\_KERNEL); /\*寻找一块空间保存这个名字的字符串\*/  
if (!cache\_name) \{ /\*如果名字保存失败，就退出,这里注意一个函数\_\_do\_kmalloc(分配内存)可以看出这里已经可以使用kmalloc 来分配内存了\*/  
err = -ENOMEM;  
goto out\_unlock;  
\}

s = do\_kmem\_cache\_create(cache\_name, size, size,  
calculate\_alignment(flags, align, size),  
flags, ctor, NULL, NULL); /\*创建一个高速缓存,并且初始化信息\*/  
if (IS\_ERR(s)) \{  
err = PTR\_ERR(s);  
kfree\_const(cache\_name);  
\}

out\_unlock:  
mutex\_unlock(&slab\_mutex); /\*解锁高速缓存链表锁\*/  
memcg\_put\_cache\_ids(); /\*释放之前持有的资源\*/  
put\_online\_mems();  
put\_online\_cpus();

if (err) \{  
if (flags & SLAB\_PANIC)  
panic("kmem\_cache\_create: Failed to create slab '%s'. Error %d\\n",  
name, err);  
else \{  
printk(KERN\_WARNING "kmem\_cache\_create(%s) failed with error %d",  
name, err);  
dump\_stack();  
\}  
return NULL;  
\}  
return s;  
\}

\[/c\]

#### \_\_kmem\_cache\_alias 第一次详细分配 ####

\[c\]

struct kmem\_cache \*  
\_\_kmem\_cache\_alias(const char \*name, size\_t size, size\_t align,  
unsigned long flags, void (\*ctor)(void \*))  
\{  
struct kmem\_cache \*cachep;

cachep = find\_mergeable(size, align, flags, name, ctor);  /\*尝试在高速缓存的链表中寻找一个给出来，这个函数的详细过程看下边\*/  
if (cachep) \{/\*如果分配好了引用计数+1，并且调整最后的大小\*/  
cachep->refcount++;

/\*  
\* Adjust the object sizes so that we clear  
\* the complete object on kzalloc.  
\*/  
cachep->object\_size = max\_t(int, cachep->object\_size, size);  
\}  
return cachep;  
\}

\[/c\]

\[c\]

/\*这里进行参数处理，并且准备从已经存在的缓存中找出东西\*/

struct kmem\_cache \*find\_mergeable(size\_t size, size\_t align,  
unsigned long flags, const char \*name, void (\*ctor)(void \*))  
\{  
struct kmem\_cache \*s;

if (slab\_nomerge || (flags & SLAB\_NEVER\_MERGE))  
return NULL;

if (ctor)  
return NULL;

size = ALIGN(size, sizeof(void \*));   /\*对齐算出我们需要的大小,宏用法同下\*/  
align = calculate\_alignment(flags, align, size);/\*对齐，虽然有默认的对齐值，内核会一直将对齐值处以2，井可能多的将对象放入行缓存中\*/  
size = ALIGN(size, align); /\*我只想说这个宏有毒，（x,(typeof(x))(a)-1) ==>  (((x) + (mask)) & ~(mask)),我是被这个宏的用法惊呆了\*/

flags = kmem\_cache\_flags(size, flags, name, NULL);  
/\*尝试从slab\_caches中获取一个可以使用的kmem\_cache\*/  
list\_for\_each\_entry\_reverse(s, &slab\_caches, list) \{  
if (slab\_unmergeable(s)) /\*寻找一个可以合并的slab cache\*/  
continue;

if (size > s->size) /\*其大小应当大与等与我们需要的大小\*/  
continue;

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; /\*必须是对齐的\*/

if (s->size - size >= sizeof(void \*))  
continue; /\*两个大小的差值必须在体系结构之内\*/

if (IS\_ENABLED(CONFIG\_SLAB) && align &&  
(align > s->align || s->align % align))  
continue;

return s;  
\}  
return NULL;  
\}

\[/c\]

\*\*\*\_\_kmem\_cache\_create(s,flags)\*\*\*  
看这个函数，在初始化时候的调用的函数,在调用这个函数之前其实还调用了create\_boot\_cache(),下边我删除一些DEBUG的东西。便于看清结构。

\[c\]  
int  
\_\_kmem\_cache\_create (struct kmem\_cache \*cachep, unsigned long flags)  
\{ /\*首先对齐到处理器字长的步数\*/  
size\_t left\_over, freelist\_size;  
size\_t ralign = BYTES\_PER\_WORD;  
gfp\_t gfp;  
int err;  
size\_t size = cachep->size;

/\*  
\* Check that size is in terms of words. This is needed to avoid  
\* unaligned accesses for some archs when redzoning is used, and makes  
\* sure any on-slab bufctl's are also correctly aligned.  
\*/  
if (size & (BYTES\_PER\_WORD - 1)) \{  
size += (BYTES\_PER\_WORD - 1);  
size &= ~(BYTES\_PER\_WORD - 1);  
\}

if (flags & SLAB\_RED\_ZONE) \{  
ralign = REDZONE\_ALIGN;  
/\* If redzoning, ensure that the second redzone is suitably  
\* aligned, by adjusting the object size accordingly. \*/  
size += REDZONE\_ALIGN - 1;  
size &= ~(REDZONE\_ALIGN - 1);  
\}

/\* 3) caller mandated alignment \*/  
if (ralign < cachep->align) \{  
ralign = cachep->align;  
\}  
/\* disable debug if necessary \*/  
if (ralign > \_\_alignof\_\_(unsigned long long))  
flags &= ~(SLAB\_RED\_ZONE | SLAB\_STORE\_USER);  
/\*  
\* 4) Store it. /\*计算出对齐值并保存\*/  
\*/  
cachep->align = ralign;

if (slab\_is\_available())  
gfp = GFP\_KERNEL;  
else  
gfp = GFP\_NOWAIT;

/\*  
\* Determine if the slab management is 'on' or 'off' slab.  
\* (bootstrapping cannot cope with offslab caches so don't do  
\* it too early on. Always use on-slab management when  
\* SLAB\_NOLEAKTRACE to avoid recursive calls into kmemleak)  
\*/  
if ((size >= (PAGE\_SIZE >> 5)) && !slab\_early\_init &&  
!(flags & SLAB\_NOLEAKTRACE))  
/\*  
\* Size is large, assume best to place the slab management obj  
\* off-slab (should allow better packing of objs).  
\*/  
flags |= CFLGS\_OFF\_SLAB;

size = ALIGN(size, cachep->align);  
/\*  
\* We should restrict the number of objects in a slab to implement  
\* byte sized index. Refer comment on SLAB\_OBJ\_MIN\_SIZE definition.  
\*/  
if (FREELIST\_BYTE\_INDEX && size < SLAB\_OBJ\_MIN\_SIZE)  
size = ALIGN(SLAB\_OBJ\_MIN\_SIZE, cachep->align);

left\_over = calculate\_slab\_order(cachep, size, cachep->align, flags);  
/\*计算出理想的slab长度，太小增加开销。太大则想对的降低了伙伴算法的效果，这是一个迭代的过程\*/  
if (!cachep->num)  
return -E2BIG;

freelist\_size = calculate\_freelist\_size(cachep->num, cachep->align);

/\*  
\* If the slab has been placed off-slab, and we have enough space then  
\* move it on-slab. This is at the expense of any extra colouring.  
\*/  
/\*确定到底是将slab的头部放到slab的外边还是里边\*/  
if (flags & CFLGS\_OFF\_SLAB && left\_over >= freelist\_size) \{  
flags &= ~CFLGS\_OFF\_SLAB;  
left\_over -= freelist\_size;  
\}

if (flags & CFLGS\_OFF\_SLAB) \{  
/\* really off slab. No need for manual alignment \*/  
freelist\_size = calculate\_freelist\_size(cachep->num, 0);

\#ifdef CONFIG\_PAGE\_POISONING  
/\* If we're going to use the generic kernel\_map\_pages()  
\* poisoning, then it's going to smash the contents of  
\* the redzone and userword anyhow, so switch them off.  
\*/  
if (size % PAGE\_SIZE == 0 && flags & SLAB\_POISON)  
flags &= ~(SLAB\_RED\_ZONE | SLAB\_STORE\_USER);  
\#endif  
\}

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;  
cachep->colour = left\_over / cachep->colour\_off;  
cachep->freelist\_size = freelist\_size;  
cachep->flags = flags;  
cachep->allocflags = \_\_GFP\_COMP;  
if (CONFIG\_ZONE\_DMA\_FLAG && (flags & SLAB\_CACHE\_DMA))  
cachep->allocflags |= GFP\_DMA;  
cachep->size = size;  
cachep->reciprocal\_buffer\_size = reciprocal\_value(size);

if (flags & CFLGS\_OFF\_SLAB) \{  
cachep->freelist\_cache = kmalloc\_slab(freelist\_size, 0u);  
/\*  
\* This is a possibility for one of the kmalloc\_\{dma,\}\_caches.  
\* But since we go off slab only for object size greater than  
\* PAGE\_SIZE/8, and kmalloc\_\{dma,\}\_caches get created  
\* in ascending order,this should not happen at all.  
\* But leave a BUG\_ON for some lucky dude.  
\*/  
BUG\_ON(ZERO\_OR\_NULL\_PTR(cachep->freelist\_cache));  
\}

err = setup\_cpu\_cache(cachep, gfp);  
if (err) \{  
\_\_kmem\_cache\_shutdown(cachep);  
return err;  
\}  
/\*创建cachep缓存完\*/  
return 0;  
\}

\[/c\]

关于likely 与 unlikely 的一点说明：  
在linux kernel 中，我们经常可以看到likely和unlikely，这其实是两个宏。  
\#define likely(x) (\_\_builtin\_constant\_p(x) ?!!(x) :\_\_branch\_check\_\_(x,1))  
\#define unlikely(x) (\_\_builtin\_constant\_p(x)?!!(x) :\_\_branch\_check\_\_(x,0))  
这里其实是对编译的一个优化，这里指出了哪一种情况发生的概率更大，对于编译器来说，编译器会将最可能发生的以种情况直接放在判断语句的下方，以求模拟出最真实的一种效果：最可能的条件最快执行不发生指令跳转。

查看原文：[http://zmr.lezifang.cn/2015/11/11/%e5%86%85%e5%ad%98%e7%ae%a1%e7%90%86%e5%99%a8%ef%bc%88%e5%8d%81%e4%ba%94%ef%bc%89kernel%e5%86%85%e5%ad%98%e7%ae%a1%e7%90%86-slab%e8%ae%be%e8%ae%a1%e4%b8%8e%e5%ae%9e%e7%8e%b02%ef%bc%88%e5%88%9d/][http_zmr.lezifang.cn_2015_11_11_e5_86_85_e5_ad_98_e7_ae_a1_e7_90_86_e5_99_a8_ef_bc_88_e5_8d_81_e4_ba_94_ef_bc_89kernel_e5_86_85_e5_ad_98_e7_ae_a1_e7_90_86-slab_e8_ae_be_e8_ae_a1_e4_b8_8e_e5_ae_9e_e7_8e_b02_ef_bc_88_e5_88_9d]

[2015-11-09 21_45_59]: http://zmr.lezifang.cn/wp-content/uploads/2015/11/2015-11-09-214559-的屏幕截图.png
[http_zmr.lezifang.cn_2015_11_11_e5_86_85_e5_ad_98_e7_ae_a1_e7_90_86_e5_99_a8_ef_bc_88_e5_8d_81_e4_ba_94_ef_bc_89kernel_e5_86_85_e5_ad_98_e7_ae_a1_e7_90_86-slab_e8_ae_be_e8_ae_a1_e4_b8_8e_e5_ae_9e_e7_8e_b02_ef_bc_88_e5_88_9d]: http://zmr.lezifang.cn/2015/11/11/%e5%86%85%e5%ad%98%e7%ae%a1%e7%90%86%e5%99%a8%ef%bc%88%e5%8d%81%e4%ba%94%ef%bc%89kernel%e5%86%85%e5%ad%98%e7%ae%a1%e7%90%86-slab%e8%ae%be%e8%ae%a1%e4%b8%8e%e5%ae%9e%e7%8e%b02%ef%bc%88%e5%88%9d/