linux 3.4.10 内核内存管理源代码分析7:Slab块的管理

法律声明：《linux
3.4.10 内核内存管理源代码分析》系列文章由机器人（ancjf@163.com）发表于http://blog.csdn.net/ancjf，文章遵循GPL协议。欢迎转载，转载请注明作者和此条款。

Slab块的管理=========================

从slab中分配出去的内存实际都是slab从伙伴系统申请一块内存，然后分割成若干小块，再分配出去。一个slab块被划分为长度相等的若干小块，第零个小块的首地址保存在struct slab的成员s_mem中，每个小块都有个编号，在一个slab块中是唯一的。一块从伙伴系统申请的内存块用structslab描述，一块slab的控制数据并不完全是保存在struct slab中，因为还需要一些数据来保存空闲小块的信息，不同的slab缓存中的slab块可能包含小块的数量不一样。空闲小块实际是以单向编号链表的方式管理的，对每个小块有一个编号，每个编号在编号链表中有一项用来保存指向下一项的编号。当分配内存时从链表头取下一项，但释放内存时把释放项加入链表头。空闲链表总是保存在struct
slab结构之后。下图是一个包含6个小块，3个空闲小块的slab块的控制数据示例图，最前面方格保存struct slab结构，后面是slab空闲编号链表。

获取Slab块的空闲编号链表的地址的函数是slab_bufctl，在mm/slab.c中实现，代码如下：

2804 static inline kmem_bufctl_t*slab_bufctl(struct slab *slabp)

2805 {

2806 return (kmem_bufctl_t *) (slabp + 1);

2807 }

index_to_obj和obj_to_index函数

小块编号到小块的虚拟地址的转换由index_to_obj实现，小块的虚拟地址到小块编号由obj_to_index实现，这两个函数都在mm/slab.c中实现，代码如下：

532 static inline void *index_to_obj(structkmem_cache *cache, struct slab *slab,

533 unsigned intidx)

534{

535 return slab->s_mem + cache->buffer_size * idx;

536}

537

538/*

539 *We want to avoid an expensive divide : (offset / cache->buffer_size)

540 * Using the fact thatbuffer_size is a constant for a particular cache,

541 * we can replace (offset /cache->buffer_size) by

542 * reciprocal_divide(offset,cache->reciprocal_buffer_size)

543 */

544static inline unsigned int obj_to_index(const struct kmem_cache *cache,

545 conststruct slab *slab, void *obj)

546{

547 u32 offset = (obj - slab->s_mem);

548 return reciprocal_divide(offset, cache->reciprocal_buffer_size);

549}

编号和地址的转换需要小块的长度信息，slab缓存中小块的长度保存在structkmem_cache的成员buffer_size中。index_to_obj比较简单，下面只说说obj_to_index

reciprocal_buffer_size的计算方法在mm/slab.c中的kmem_cache_init中

1563 cache_cache.reciprocal_buffer_size =

1564 reciprocal_value(cache_cache.buffer_size);

reciprocal_value的代码中lib/reciprocal_div.c中，如下：

5u32 reciprocal_value(u32 k)

6 {

7 u64 val = (1LL <<32) + (k - 1);

8 do_div(val, k);

9 return (u32)val;

10 }

reciprocal_divide的代码在include/linux/reciprocal_div.h中，如下

28 static inline u32 reciprocal_divide(u32A, u32 R)

29 {

30 return (u32)(((u64)A * R) >> 32);

31 }

综合起来obj_to_index的计算公式就是(((2^32+(buffer_size-1))/buffer_size)* offset)/2^32

由(((2^32+(buffer_size-1))/ buffer_size)* offset)/2^32 <= (((2^32+(buffer_size-1)) * offset)/ buffer_size)/2^32 == (((2^32+(buffer_size-1)) * offset) /2^32) / buffer_size ==( (2^32 * offset + (buffer_size-1) * offset) / 2^32)/ buffer_size=
(2^32 * offset) / 2^32 / buffer_size = offset/ buffer_size,这样就得到了(((2^32+(buffer_size-1))/ buffer_size)* offset)/2^32 <= offset/ buffer_size,这个推导使用了条件(buffer_size-1) * offset < 2^32

另外有offset/ buffer_size <= (((2^32+(buffer_size-1))/ buffer_size)* offset)/2^32

只要offset * 2^32 <= ((2^32+(buffer_size-1))/buffer_size)* offset) * buffer_size

只要offset * 2^32 <= ((2^32+(buffer_size-1))/buffer_size)* buffer_size) * offset

只要2^32 <= ((2^32+(buffer_size-1))/buffer_size)* buffer_size)，这个条件总是满足的，所以offset/buffer_size <= (((2^32+(buffer_size-1))/ buffer_size)*offset)/2^32也成立。

这样我们得到了offset/ buffer_size == (((2^32+(buffer_size-1))/ buffer_size)* offset)/2^32

正如obj_to_index所注释的，obj_to_index的计算结果是offset/ buffer_size，这样实现只是为了避免使用除法，因为除法指令执行比较慢。

slab_get_obj和slab_put_obj函数

从slab块分配对象的函数是slab_get_obj，在mm/slab.c中实现，代码如下：

2866static void *slab_get_obj(struct kmem_cache *cachep, struct slab *slabp,

2867 int nodeid)

2868 {

2869 void *objp = index_to_obj(cachep, slabp, slabp->free);

2870 kmem_bufctl_t next;

2871

2872 slabp->inuse++;

2873 next = slab_bufctl(slabp)[slabp->free];

2874 #if DEBUG

2875 slab_bufctl(slabp)[slabp->free] = BUFCTL_FREE;

2876 WARN_ON(slabp->nodeid != nodeid);

2877 #endif

2878 slabp->free = next;

2879

2880 return objp;

2881 }

2869行获得空闲编号链表头的指针，2872行更新使用的分配出去的对象计数，2873行获得下一个空闲编号，2878把下一个空闲编号作为链表头保存起来。

释放小块内存到slab块的函数是slab_put_obj，在mm/slab.c中实现，代码如下：

2883 static void slab_put_obj(structkmem_cache *cachep, struct slab *slabp,

2884 void *objp,int nodeid)

2885 {

2886 unsigned int objnr = obj_to_index(cachep, slabp, objp);

2887

2888 #if DEBUG

2889 /* Verify that the slab belongs to the intended node */

2890 WARN_ON(slabp->nodeid != nodeid);

2891

2892 if (slab_bufctl(slabp)[objnr] + 1 <= SLAB_LIMIT + 1) {

2893 printk(KERN_ERR "slab:double free detected in cache "

2894 "'%s',objp %p\n", cachep->name, objp);

2895 BUG();

2896 }

2897 #endif

2898 slab_bufctl(slabp)[objnr] = slabp->free;

2899 slabp->free = objnr;

2900 slabp->inuse--;

2901 }

2886行求得编号，2898-2899行把新的编号作为链表头，并行链表头的项指向以前的链表头，2900减少对象使用计算。

cache_init_objs函数

Slab块的空闲编号链表的初始化函数是cache_init_objs，在mm/slab.c中实现，代码如下：

2809static void cache_init_objs(struct kmem_cache *cachep,

2810 struct slab*slabp)

2811 {

2812 int i;

2813

2814 for (i = 0; i < cachep->num; i++) {

2815 void *objp =index_to_obj(cachep, slabp, i);

2816 #if DEBUG

2817 /* need to poison the objs? */

2818 if (cachep->flags &SLAB_POISON)

2819 poison_obj(cachep,objp, POISON_FREE);

2820 if (cachep->flags& SLAB_STORE_USER)

2821 *dbg_userword(cachep,objp) = NULL;

2822

2823 if (cachep->flags &SLAB_RED_ZONE) {

2824 *dbg_redzone1(cachep,objp) = RED_INACTIVE;

2825 *dbg_redzone2(cachep,objp) = RED_INACTIVE;

2826 }

2827 /*

2828 * Constructors are notallowed to allocate memory from the same

2829 * cache which they are aconstructor for. Otherwise, deadlock.

2830 * They must also be threaded.

2831 */

2832 if (cachep->ctor &&!(cachep->flags & SLAB_POISON))

2833 cachep->ctor(objp +obj_offset(cachep));

2834

2835 if (cachep->flags &SLAB_RED_ZONE) {

2836 if(*dbg_redzone2(cachep, objp) != RED_INACTIVE)

2837 slab_error(cachep, "constructor overwrote the"

2838 " end of an object");

2839 if(*dbg_redzone1(cachep, objp) != RED_INACTIVE)

2840 slab_error(cachep, "constructor overwrote the"

2841 " start of an object");

2842 }

2843 if ((cachep->buffer_size %PAGE_SIZE) == 0 &&

2844 OFF_SLAB(cachep)&& cachep->flags & SLAB_POISON)

2845 kernel_map_pages(virt_to_page(objp),

2846 cachep->buffer_size/ PAGE_SIZE, 0);

2847 #else

2848 if (cachep->ctor)

2849 cachep->ctor(objp);

2850 #endif

2851 slab_bufctl(slabp)[i] = i + 1;

2852 }

2853 slab_bufctl(slabp)[i - 1] = BUFCTL_END;

2854 }

如果不考虑DEBUG宏，cache_init_objs函数初始化空闲编号链表，并调用了对象的构造函数。