Linux kernel 3.10内核源码分析--slab原理及相关代码

1、基本原理

我们知道，Linux保护模式下，采用分页机制，内核中物理内存使用buddy system(伙伴系统)进行管理，管理的内存单元大小为一页，也就是说使用buddy system分配内存最少需要分配一页大小。那如果需要分配小于一页的内存该怎么办呢？

另一方面，内核中经常需要大量的数据结构(比如struct task_strcut)，这些数据结构的频繁分配和释放对性能影响较大。

Slab正是用于解决上述的两个问题，Slab 分配器源于 Solaris 2.4的分配算法，工作于buddy system之上，用于管理特定大小对象的缓存，提高小块内存或特定对象内存分配效率。

Slab的两个用途如前面所述：1、缓存和管理内核中经常使用的数据结构对象，内核中使用slab提供的专用的接口，可以实现数据结构对象的快速分配，大大减少相关开销，提升效率。2、缓存和管理小块内存，也称通用缓存，用于kmalloc的底层实现和支撑。小块内存即小于一页大小的内存，以2^n字节对齐，比如512B、128B、64B、32B等。

2、slab管理结构图

3、缓冲区(kmem_cache)

Slab分配器为每种内核对象建立单独的缓冲区(kmem_cache)，每个缓冲区包含多个 slab ，每个 slab包含一组连续的物理内存页，这些内存页被划分成固定数目的对象。根据对象大小的不同，缺省情况下一个 slab 最多可以由 1024个物理内存页框构成。充分利用硬件特性，需要对每个对象进行一定的对齐处理(比如cache line对齐)，所以slab中分配给对象的内存可能大于用户要求的对象实际大小，可能会有一定的内存浪费。

内核使用 kmem_cache数据结构管理缓冲区。每个缓冲区中，对每个NUMA node都有三个slab链表：

   Full链表，该链表中的所有slab中的对象都已经被完全分配，没有空闲对象。

   Partial链表，该链表中的slab中还有空闲对象，从slab中分配对象时，优先从此链表中分配。当 slab 的最后一个已分配对象被释放时，该 slab将从 Partial链表移入free链表；当 slab的最后一个空闲对象被分配时，该 slab将从Partial链表移入Full链表里。

   Free链表，该链表中的slab中全是空闲对象，当partial链表中slab用尽时，从这里分配，并将相应的slab从free链表移入partial链表。

当缓冲区中空闲对象总数不足时，则按需从伙伴系统中分配更多的page，用于slab；当空闲对象比较富余，free链表中的的部分 slab 可能被定期回收。

由于 kmem_cache自身也是一种内核对象，所以需要一个专门的缓冲区。所有缓冲区的 kmem_cache控制结构被组织成以 cache_chain为队列头的一个双向循环队列，同时 cache_cache全局变量指向kmem_cache对象缓冲区的 kmem_cache对象。
kmem_cache结构定义如下：

点击(此处)折叠或打开

1. /*用于存放slab的缓存(kmem_cache)描述符*/
   
2. struct kmem_cache {
   
3. /* 1) Cache tunables. Protected by cache_chain_mutex*/
   
4.     /*当per-CPU缓存列表为空时，从slab中获取对象的数目；或者cache_grow时一次分配的对象数目*/
   
5.     unsigned int batchcount;
   
6.     /*per-CPU缓存列表(array?)中保存的最大对象数目*/
   
7.     unsigned int limit;
   
8.     /*是否存在共享CPU高速缓存*/
   
9.     unsigned int shared;
   
10.     /*slab中管理对象的长度(包括对齐填充字节)*/
    
11.     unsigned int size;
    
12.     /*为提升对象索引效率，使用Newton-Raphson方法使用的参数。*/
    
13.     u32 reciprocal_buffer_size;
    
14. /* 2) touched by every alloc& free from the backend */
    
15.     /*定义kmem_cache的性质，当前只使用了一个标志:CFLAG_OFF_SLAB，表示slab描述符位于slab数据区之外*/
    
16.     unsigned int flags;        /* constant flags*/
    
17.     /*每个kmem_cache(?)中可容纳的最大对象数目*/
    
18.     unsigned int num;        /* # of objs per slab*/
    
19. 
    
20. /* 3) cache_grow/shrink*/
    
21.     /* order of pgs per slab(2^n) */
    
22.     /*cache_grow或shrink时，一次性申请或释放的page order*/
    
23.     unsigned int gfporder;
    
24. 
    
25.     /* force GFP flags, e.g. GFP_DMA*/
    
26.     /*从buddy system中分配page时，使用的分配标志*/
    
27.     gfp_t allocflags;
    
28.     /*着色使用。最大的颜色数目*/
    
29.     size_t colour;            /* cache colouring range*/
    
30.     /*着色使用。着色偏移*/
    
31.     unsigned int colour_off;    /* colour offset*/
    
32.     /*当slab描述符(头部管理数据)存储在slab外部时，slabp_cache指向用于分配slab描述符的"通用缓存"(即用于分配kmalloc数据的slab缓存)*/
    
33.     struct kmem_cache *slabp_cache;
    
34.     /*单个slab头部管理数据的大小，包括slab描述符自身和kmem_bufctl_t数组的大小*/
    
35.     unsigned int slab_size;
    
36. 
    
37.     /* constructor func*/
    
38.     /*构造函数*/
    
39.     void (*ctor)(void*obj);
    
40. 
    
41. /* 4) cache creation/removal*/
    
42.     /*kmem_cache名称，在/proc/slabinfo中可以看到*/
    
43.     const char *name;
    
44.     /*将所有的kmem_cache链入到全局链表中:cache_chain*/
    
45.     struct list_head list;
    
46.     /*引用计数*/
    
47.     int refcount;
    
48.     /*缓存中对象的长度，跟前面的size有何区别?*/
    
49.     int object_size;
    
50.     /*对齐使用*/
    
51.     int align;
    
52. 
    
53. /* 5) statistics*/
    
54.     /*统计信息，打开slab调试开关时使用*/
    
55. #ifdef CONFIG_DEBUG_SLAB
    
56.     unsigned long num_active;
    
57.     unsigned long num_allocations;
    
58.     unsigned long high_mark;
    
59.     unsigned long grown;
    
60.     unsigned long reaped;
    
61.     unsigned long errors;
    
62.     unsigned long max_freeable;
    
63.     unsigned long node_allocs;
    
64.     unsigned long node_frees;
    
65.     unsigned long node_overflow;
    
66.     atomic_t allochit;
    
67.     atomic_t allocmiss;
    
68.     atomic_t freehit;
    
69.     atomic_t freemiss;
    
70. 
    
71.     /*
    
72.      * If debuggingis enabled,then the allocator can add additional
    
73.      * fields and/or paddingto every object. size contains the total
    
74.      * object size including these internal fields, the following two
    
75.      * variables contain the offset to the user object and its size.
    
76.      */
    
77.     int obj_offset;
    
78. #endif /* CONFIG_DEBUG_SLAB*/
    
79. #ifdef CONFIG_MEMCG_KMEM
    
80.     struct memcg_cache_params *memcg_params;
    
81. #endif
    
82. 
    
83. /* 6) per-cpu/per-node data, touched during every alloc/free */
    
84.     /*
    
85.      * We put array[] at theend of kmem_cache, because we wantto size
    
86.      * this arrayto nr_cpu_ids slots instead of NR_CPUS
    
87.      * (see kmem_cache_init())
    
88.      * We still use [NR_CPUS] andnot [1]or [0] because cache_cache
    
89.      * is statically defined, so we reserve the max number of cpus.
    
90.      *
    
91.      * We also need to guarantee that the list is able to accomodate a
    
92.      * pointer for each node since "nodelists" uses the remainder of
    
93.      * available pointers.
    
94.      */
    
95.     /*用于管理slab链表(full、partial、free)的表头，每个node对应一个*/
    
96.     struct kmem_cache_node **node;
    
97.     /*per-CPU缓存列表(结构体末尾entry[]数组用于存放被释放的slab对象)，当slab对象被释放时，先释放到该列表中*/
    
98.     struct array_cache *array[NR_CPUS+ MAX_NUMNODES];
    
99.     /*
    
100.      * Donot add fields after array[]
     
101.      */
     
102. }

4、 slab 描述符

Slab使用 struct slab数据结构(slab描述符)来描述其状态及进行相关管理。Slab描述符位于每个slab区域的起始，在为slab分配内存时，会先从buddy system中分配预定义数量的page作为slab区域，为充分利用硬件高速缓存，使用了着色机制，在slab区域的首部保留一定字节(通常根据cache line)长度的区域作为着色偏移，而slab描述符就位于此偏移之后(当slab管理数据位于slab内时)。
slab数据结构定义如下：

点击(此处)折叠或打开

1. struct slab {
   
2.     union {
   
3.         struct {
   
4.             /*链入kmem_cache中的 slab_full 或者slab_patial 或者 slab_free链表中*/
   
5.             struct list_head list;
   
6.             /*着色偏移(包括了slab描述符和kmem_bufctl_t数组的长度)，slab起始地址+colouroff=s_mem(object区起始地址)*/
   
7.             unsigned long colouroff;
   
8.             /*
   
9.              * object区起始地址=slab起始地址+colouroff，即实际slab缓存对象所处的起始地址，所有对象在slab区中
   
10.              * 连续分布，但有做cacheline对齐处理
    
11.              */
    
12.             void *s_mem;        /* including colour offset*/
    
13.             unsigned int inuse;    /* num of objs activein slab */
    
14.             /*
    
15.              * kmem_bufctl_t数组中第一个空闲object在kmem_bufctl_t数组中的索引号，使用此索引，内核无需使用复杂
    
16.              * 的结构体(比如SunOS中使用的链表)，即可遍历所有空闲的slab对象。
    
17.              */
    
18.             kmem_bufctl_t free;
    
19.             /*用于在kmem_cache中索引指定node对应的slab链表*/
    
20.             unsigned short nodeid;
    
21.         };
    
22.         struct slab_rcu __slab_cover_slab_rcu;
    
23. }

从内存分布情况看，紧接着 slab 描述符存放的是一个 kmem_bufctl_t 对象数组，该数组用于管理该 slab 中的空闲对象，稍后描述。

Slab描述符和kmem_bufctl_t对象数组一起组成了slab的管理数据。Slab管理数据可以直接存放于slab区域内，也可以单独放置。单独放置即放到用kmalloc分配的不同的slab区域中。内核如何选择，取决于slab对象的长度和已用对象的数量，简单算法如下：如果slab对象不超过 1/8 个物理内存页框的大小，那么slab管理数据直接存放于slab区域首部(着色偏移之后)；否则的话，存放在slab区域外部，位于由 kmalloc 分配的通用对象缓冲区中。

在kmem_bufctl_t对象数组之后，就是存放真正的slab对象(object)的区域，由slab->s_mem指向。slab->coloroff即为slab区域首部到slab->s_mem的偏移。slab->free中存放了该slab中第一个空闲对象的索引。

5、空闲对象管理

slab中的对象有 2 种状态：已用或空闲。Slab中使用了一个静态数组来管理空闲对象，该数组元素为kmem_bufctl_t对象(定义为无符号整数)，每个数组元素对应一个slab对象，数组元素中存放下一个空闲对象的索引，该slab中的第一个空闲对象的索引保存在slab->free中，而该数组最后一个元素中总是几个结束标记：BUFCTL_END，如此，slab中利用此巧妙而简洁的方式有效的管理了slab中的空闲对象。相比SunOS中使用链表来管理slab空闲对象，Linux中的设计更巧妙和简洁、效率更高。
kmem_bufctl_t定义如下：

点击(此处)折叠或打开

1. typedef unsigned int kmem_bufctl_t;

7、slab着色
为了充分利用硬件高速缓存，Slab分配器允许对象在L1硬件高速缓存中对齐，同时使用着色(color)机制。简单说，就是让同一缓冲区内不同 slab 中相同编号的对象的地址相互错开，以便将数据定位到不同的CPU cache line中，从而避免它们被放入同一个cache line中，导致颠簸，最终导致性能损失。

7、per-CPU slab对象缓存

为更好的利用CPU高速缓存，slab实现中，为每个CPU分配了一个slab对象的per-CPU缓存。当slab对象被释放时，会首先放入该缓存，当该缓存中的对象数目超限时，会将其移入相应的slab链表中；当分配slab时，也会首先冲该缓存中查找，如果找到直接返回，如果未找到，才从partial链表中开始查找。当该缓存为空时，会从slab中批量分配对象到该缓存。使用该per-CPU缓存，能进一步提升slab的分配和释放效率。

该缓存由kmem_cache->array[]管理，kmem_cache->array定义为array_cache结构(数组缓存)。array_cache结构定义如下：

点击(此处)折叠或打开

1. /*
   
2.   * slab中per-CPU缓存列表，当slab对象释放时会先放入此列表中，新对象分配时也会优先从此列表中分配，
   
3.   * 如果此列表中没有可用的对象，再从相应的slab链表中分配，分配后会一次性填充batchcount个对象到此列表中
   
4.   */
   
5. struct array_cache {
   
6.     unsigned int avail;/*列表中当前可用的对象数目*/
   
7.     unsigned int limit;/*列表中最大的对象数目，跟kmem_cache->limit一样*/
   
8.     unsigned int batchcount;/*跟kmem_cache->batchcount一样*/
   
9.     unsigned int touched;/*表示缓存收缩后是否被访问过，在内存回收时需要检查此标记*/
   
10.     spinlock_t lock;
    
11.     /*用于存放被释放的slab对象的数组*/
    
12.     void *entry[];    /*
    
13.              * Must have this definition in here for the proper
    
14.              * alignment of array_cache. Also simplifies accessing
    
15.              * the entries.
    
16.              *
    
17.              * Entries should not be directly dereferenced as
    
18.              * entries belonging to slabs marked pfmemalloc will
    
19.              * have the lower bits set SLAB_OBJ_PFMEMALLOC
    
20.              */
    
21. };

该结构中的entry数组用于存放slab对象指针，用于指向最近释放的slab对象。

8、代码分析
主要分析slab对象的分配流程：kmem_cache_alloc()

点击(此处)折叠或打开

1. /*分配slab对象(object)*/
   
2. void *kmem_cache_alloc(struct kmem_cache*cachep, gfp_t flags)
   
3. {
   
4.     /*实际入口*/
   
5.     void *ret = slab_alloc(cachep, flags, _RET_IP_);
   
6.     /*调试使用*/
   
7.     trace_kmem_cache_alloc(_RET_IP_, ret,
   
8.              cachep->object_size, cachep->size, flags);
   
9. 
   
10.     return ret;
    
11. }

kmem_cache_alloc()->slab_alloc()

点击(此处)折叠或打开

1. /*分配slab对象，内联函数*/
   
2. static __always_inline void *
   
3. slab_alloc(struct kmem_cache *cachep, gfp_t flags, unsigned long caller)
   
4. {
   
5.     unsigned long save_flags;
   
6.     void *objp;
   
7. 
   
8.     flags &= gfp_allowed_mask;
   
9.     /*死锁检测相关*/
   
10.     lockdep_trace_alloc(flags);
    
11. 
    
12.     if (slab_should_failslab(cachep, flags))
    
13.         return NULL;
    
14. 
    
15.     cachep = memcg_kmem_get_cache(cachep, flags);
    
16.     /*相关标记检查*/
    
17.     cache_alloc_debugcheck_before(cachep, flags);
    
18.     /*实际分配操作执行之前，关中断*/
    
19.     local_irq_save(save_flags);
    
20.     /*执行实际的slab对象分配操作*/
    
21.     objp = __do_cache_alloc(cachep, flags);
    
22.     /*开中断*/
    
23.     local_irq_restore(save_flags);
    
24.     objp = cache_alloc_debugcheck_after(cachep, flags, objp, caller);
    
25.     kmemleak_alloc_recursive(objp, cachep->object_size, 1, cachep->flags,
    
26.                  flags);
    
27.     prefetchw(objp);
    
28. 
    
29.     if (likely(objp))
    
30.         kmemcheck_slab_alloc(cachep, flags, objp, cachep->object_size);
    
31.     /*如果设置了__GFP_ZERO标记，则对象数据清零*/
    
32.     if (unlikely((flags& __GFP_ZERO)&& objp))
    
33.         memset(objp, 0, cachep->object_size);
    
34. 
    
35.     return objp;
    
36. }

kmem_cache_alloc()->slab_alloc()->__do_cache_alloc()

点击(此处)折叠或打开

1. /*执行实际的slab对象分配操作，此处为非NUMA架构下的入口*/
   
2. __do_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
   
3. {
   
4.     /*从local node上分配*/
   
5.     return ____cache_alloc(cachep, flags);
   
6. }

kmem_cache_alloc()->slab_alloc()->__do_cache_alloc()->____cache_allc()

点击(此处)折叠或打开

1. /*slab对象实际分配函数*/
   
2. static inline void *____cache_alloc(struct kmem_cache*cachep, gfp_t flags)
   
3. {
   
4.     void *objp;
   
5.     struct array_cache *ac;
   
6.     bool force_refill = false;
   
7.     /*确认中断已关*/
   
8.     check_irq_off();
   
9.     /*取得当前处理器所在array_cache(即per-CPU缓存列表，简称为AC)*/
   
10.     ac = cpu_cache_get(cachep);
    
11.     /*如果ac中有可用的slab对象*/
    
12.     if (likely(ac->avail)){
    
13.         /*设置touched标志，表明最近该ac被访问过，在内存回收时会检查该标记确认相应的缓存是否可回收*/
    
14.         ac->touched= 1;
    
15.         /*从ac中获取一个slab对象*/
    
16.         objp = ac_get_obj(cachep, ac, flags,false);
    
17. 
    
18.         /*
    
19.          * Allow for the possibility all avail objects are not allowed
    
20.          * by the current flags
    
21.          */
    
22.         /*如果成功，更新命中计数，并返回*/
    
23.         if (objp){
    
24.             STATS_INC_ALLOCHIT(cachep);
    
25.             goto out;
    
26.         }
    
27.         force_refill = true;
    
28.     }
    
29.     /*如果ac中没有可用的对象，或者从ac中分配对象失败，更新miss计数*/
    
30.     STATS_INC_ALLOCMISS(cachep);
    
31.     /*从slab列表中获取对象*/
    
32.     objp = cache_alloc_refill(cachep, flags, force_refill);
    
33.     /*
    
34.      * the 'ac' may be updated by cache_alloc_refill(),
    
35.      * and kmemleak_erase() requires its correct value.
    
36.      */
    
37.     ac = cpu_cache_get(cachep);
    
38. 
    
39. out:
    
40.     /*
    
41.      * To avoid afalse negative,if an object that is in one of the
    
42.      * per-CPU cachesis leaked, we needto make sure kmemleak doesn't
    
43.      * treat the array pointers as a reference to the object.
    
44.      */
    
45.     if (objp)
    
46.         kmemleak_erase(&ac->entry[ac->avail]);
    
47.     return objp;
    
48. }

kmem_cache_alloc()->slab_alloc()->__do_cache_alloc()->____cache_allc()->cache_alloc_refill()

点击(此处)折叠或打开

1. /*从slab列表中获取slab对象，当现有的slab中的空间不足时，调用cache_grow对齐进行扩展*/
   
2. static void *cache_alloc_refill(struct kmem_cache*cachep, gfp_t flags,
   
3.                             bool force_refill)
   
4. {
   
5.     int batchcount;
   
6.     struct kmem_cache_node *n;
   
7.     struct array_cache *ac;
   
8.     int node;
   
9.     /*再次确认中断已关*/
   
10.     check_irq_off();
    
11.     /*获取当前node id*/
    
12.     node = numa_mem_id();
    
13.     /*是否强制grow*/
    
14.     if (unlikely(force_refill))
    
15.         goto force_grow;
    
16. retry:
    
17.     /*获取当前ac*/
    
18.     ac = cpu_cache_get(cachep);
    
19.     batchcount = ac->batchcount;
    
20.     /*如果最近该ac不活跃，则需要部分填充*/
    
21.     if (!ac->touched&& batchcount> BATCHREFILL_LIMIT){
    
22.         /*
    
23.          * If there was little recent activityon this cache,then
    
24.          * perform only a partial refill. Otherwise we could generate
    
25.          * refill bouncing.
    
26.          */
    
27.         batchcount = BATCHREFILL_LIMIT;
    
28.     }
    
29.     /*或者针对每个node的slab链表管理结构*/
    
30.     n = cachep->node[node];
    
31. 
    
32.     BUG_ON(ac->avail> 0 ||!n);
    
33.     spin_lock(&n->list_lock);
    
34. 
    
35.     /* Seeif we can refill from the shared array */
    
36.     if (n->shared&& transfer_objects(ac, n->shared, batchcount)){
    
37.         n->shared->touched= 1;
    
38.         goto alloc_done;
    
39.     }
    
40. 
    
41.     while (batchcount> 0) {
    
42.         struct list_head *entry;
    
43.         struct slab *slabp;
    
44.         /*Get slab alloc isto come from.*/
    
45.         /*从partial列表中分配*/
    
46.         entry = n->slabs_partial.next;
    
47.         /*当partial列表为空时，从free列表中分配*/
    
48.         if (entry== &n->slabs_partial){
    
49.             n->free_touched= 1;
    
50.             entry = n->slabs_free.next;
    
51.             /*free列表为空，则必须grow cache了*/
    
52.             if (entry ==&n->slabs_free)
    
53.                 goto must_grow;
    
54.         }
    
55. 
    
56.         slabp = list_entry(entry, struct slab, list);
    
57.         check_slabp(cachep, slabp);
    
58.         check_spinlock_acquired(cachep);
    
59. 
    
60.         /*
    
61.          * The slab was either on partial or free list so
    
62.          * there must be at least one object availablefor
    
63.          * allocation.
    
64.          */
    
65.         BUG_ON(slabp->inuse>= cachep->num);
    
66.         /*将新找到的slab中的batchcount个对象放入ac(即per-CPU缓存列表中)*/
    
67.         while (slabp->inuse< cachep->num&& batchcount--){
    
68.             STATS_INC_ALLOCED(cachep);
    
69.             STATS_INC_ACTIVE(cachep);
    
70.             STATS_SET_HIGH(cachep);
    
71. 
    
72.             ac_put_obj(cachep, ac, slab_get_obj(cachep, slabp,
    
73.                                     node));
    
74.         }
    
75.         check_slabp(cachep, slabp);
    
76. 
    
77.         /* move slabpto correct slabp list:*/
    
78.         /*将从中分配对象的slab(此slab可能在partial或free的链表中)重新加入到合适的列表中*/
    
79.         list_del(&slabp->list);/*Fixme:先删除再添加，有在同一个列表中删除后添加的可能，会不会效率太低了?*/
    
80.         /*如果该slab中已经没有空闲对象了slabp->free指向下一个空闲对象，BUFCTL_END表示最后一个空闲对象*/
    
81.         if (slabp->free== BUFCTL_END)
    
82.             list_add(&slabp->list,&n->slabs_full);
    
83.         /*如果该slab中还有空闲对象，则加入partial链表中*/
    
84.         else
    
85.             list_add(&slabp->list,&n->slabs_partial);
    
86.     }
    
87. 
    
88. must_grow:
    
89.     n->free_objects-= ac->avail;
    
90. alloc_done:
    
91.     spin_unlock(&n->list_lock);
    
92. 
    
93.     if (unlikely(!ac->avail)){
    
94.         int x;
    
95. /*partial和free链表中都没有可用的slab了，则必须新分配内存对kmem_cache进行扩充*/
    
96. force_grow:
    
97.         x = cache_grow(cachep, flags| GFP_THISNODE, node,NULL);
    
98. 
    
99.         /* cache_grow can reenable interrupts,then ac could change.*/
    
100.         ac = cpu_cache_get(cachep);
     
101.         /*Fixme:这里node获取后没有再使用呢?*/
     
102.         node = numa_mem_id();
     
103. 
     
104.         /*cache grow失败*/
     
105.         /* no objectsin sight? abort*/
     
106.         if (!x&& (ac->avail== 0 || force_refill))
     
107.             return NULL;
     
108.         /*
     
109.          * 第一次grow后，通常ac->avail为0，然后会跳转到retry，重新从链表中选择slab，
     
110.          * 然后重新将其添加到ac中。
     
111.          * Fixme:这样效率是否也太低了?直接添加到ac中不行么? 有可能在refill的过程中由于开中断导致ac中有了新的slab?
     
112.          */
     
113.         if (!ac->avail)        /* objects refilled by interrupt? */
     
114.             goto retry;
     
115.     }
     
116.     ac->touched= 1;
     
117.     /*grow的流程中，由于前面已经retry，所以这里能保证ac中一定有需要的对象。另外没有grow的流程也会从这返回，此时ac中也一定是有对象可用的*/
     
118.     return ac_get_obj(cachep, ac, flags, force_refill);
     
119. }

kmem_cache_alloc()->slab_alloc()->__do_cache_alloc()->____cache_allc()->cache_alloc_refill()->cache_grow()

点击(此处)折叠或打开

1. /*kmem_cache增长，每次新增一个slab，当kmem_cache_alloc()中时，发现原有kmem_cache中没有可用的对象时，进入此流程进行扩展*/
   
2. static int cache_grow(struct kmem_cache*cachep,
   
3.         gfp_t flags, int nodeid, void *objp)
   
4. {
   
5.     struct slab *slabp;
   
6.     size_t offset;
   
7.     gfp_t local_flags;
   
8.     struct kmem_cache_node *n;
   
9. 
   
10.     /*
    
11.      * Be lazy and only check for valid flags here, keeping it out of the
    
12.      * critical path in kmem_cache_alloc().
    
13.      */
    
14.     BUG_ON(flags & GFP_SLAB_BUG_MASK);
    
15.     local_flags = flags & (GFP_CONSTRAINT_MASK|GFP_RECLAIM_MASK);
    
16. 
    
17.     /* Take the node list lockto change the colour_next on this node */
    
18.     /*再次检查中断是否关闭*/
    
19.     check_irq_off();
    
20.     /*获取指定node对应的slab链表管理对象*/
    
21.     n = cachep->node[nodeid];
    
22.     /*加锁*/
    
23.     spin_lock(&n->list_lock);
    
24. 
    
25.     /* Get colour for the slab,and cal the next value.*/
    
26.     /*着色处理*/
    
27.     offset = n->colour_next;
    
28.     n->colour_next++;
    
29.     if (n->colour_next>= cachep->colour)
    
30.         n->colour_next= 0;
    
31.     spin_unlock(&n->list_lock);
    
32. 
    
33.     offset *= cachep->colour_off;
    
34.     /*如果设置了__GFP_WAIT标志，需要开中断，允许高优先级任务先执行*/
    
35.     if (local_flags& __GFP_WAIT)
    
36.         local_irq_enable();
    
37. 
    
38.     /*
    
39.      * The test for missing atomic flag is performed here, rather than
    
40.      * the more obvious place, simplyto reduce the critical path length
    
41.      * in kmem_cache_alloc().If a caller is seriously mis-behaving they
    
42.      * will eventually be caught here (where it matters).
    
43.      */
    
44.     /*检查内存分配标记*/
    
45.     kmem_flagcheck(cachep, flags);
    
46. 
    
47.     /*
    
48.      * Get memfor the objs. Attemptto allocate a physical page from
    
49.      * 'nodeid'.
    
50.      */
    
51.     /*从伙伴系统中分配物理内存页，用于slab*/
    
52.     if (!objp)
    
53.         objp = kmem_getpages(cachep, local_flags, nodeid);
    
54.     if (!objp)
    
55.         goto failed;
    
56. 
    
57.     /* Get slab management. */
    
58.     /*Slab头部管理数据创建，分On-Slab 和 Off-Slab*/
    
59.     slabp = alloc_slabmgmt(cachep, objp, offset,
    
60.             local_flags & ~GFP_CONSTRAINT_MASK, nodeid);
    
61.     if (!slabp)
    
62.         goto opps1;
    
63.     /*创建slab的各页与slab或缓冲区(kmem_cache)之间的关联*/
    
64.     slab_map_pages(cachep, slabp, objp);
    
65.     /*调用各slab对象的构造函数(如果有的话)，初始化新slab中的对象。通常都没有。*/
    
66.     cache_init_objs(cachep, slabp);
    
67. 
    
68.     if (local_flags& __GFP_WAIT)
    
69.         local_irq_disable();
    
70.     check_irq_off();
    
71.     spin_lock(&n->list_lock);
    
72. 
    
73.     /* Make slab active.*/
    
74.     /*将新分配的slab加入到free链表中，之前需要拿锁，并关中断*/
    
75.     list_add_tail(&slabp->list,&(n->slabs_free));
    
76.     /*更新相关计数*/
    
77.     STATS_INC_GROWN(cachep);
    
78.     n->free_objects+= cachep->num;
    
79.     spin_unlock(&n->list_lock);
    
80.     return 1;
    
81. opps1:
    
82.     kmem_freepages(cachep, objp);
    
83. failed:
    
84.     if (local_flags& __GFP_WAIT)
    
85.         local_irq_disable();
    
86.     return 0;
    
87. }

 

原文地址： http://blog.chinaunix.net/uid-14528823-id-4634134.html