Linux内存管理之slab机制（初始化） 3...........

三里屯摇滚

Linux内存管理之slab机制（初始化） 3...........

第二阶段代码分析

1. Start_kernel()->kmem_cache_init_late()
   
2. 
   
3. view plaincopy to clipboardprint?/*Slab系统初始化分两个部分，先初始化一些基本的，待系统初始化工作进行的差不多时，再配置一些特殊功能。*/  
   
4. void __init kmem_cache_init_late(void)  
   
5. {  
   
6.     struct kmem_cache *cachep;  
   
7.     /* 初始化阶段local cache的大小是固定的，要根据对象大小重新计算 */  
   
8.     /* 6) resize the head arrays to their final sizes */  
   
9.     mutex_lock(&cache_chain_mutex);  
   
10.     list_for_each_entry(cachep, &cache_chain, next)  
    
11.         if (enable_cpucache(cachep, GFP_NOWAIT))  
    
12.             BUG();  
    
13.     mutex_unlock(&cache_chain_mutex);  
    
14.   
    
15.     /* Done! */  
    
16.     /* 大功告成，general cache终于全部建立起来了 */  
    
17.     g_cpucache_up = FULL;  
    
18.   
    
19.     /* Annotate slab for lockdep -- annotate the malloc caches */  
    
20.     init_lock_keys();  
    
21.   
    
22.     /*
    
23.      * Register a cpu startup notifier callback that initializes
    
24.      * cpu_cache_get for all new cpus
    
25.      */  
    
26.      /* 注册cpu up回调函数，cpu up时配置local cache */  
    
27.     register_cpu_notifier(&cpucache_notifier);  
    
28.   
    
29.     /*
    
30.      * The reap timers are started later, with a module init call: That part
    
31.      * of the kernel is not yet operational.
    
32.      */  
    
33. }  
    
34. /*Slab系统初始化分两个部分，先初始化一些基本的，待系统初始化工作进行的差不多时，再配置一些特殊功能。*/
    
35. void __init kmem_cache_init_late(void)
    
36. {
    
37.         struct kmem_cache *cachep;
    
38.         /* 初始化阶段local cache的大小是固定的，要根据对象大小重新计算 */
    
39.         /* 6) resize the head arrays to their final sizes */
    
40.         mutex_lock(&cache_chain_mutex);
    
41.         list_for_each_entry(cachep, &cache_chain, next)
    
42.                 if (enable_cpucache(cachep, GFP_NOWAIT))
    
43.                         BUG();
    
44.         mutex_unlock(&cache_chain_mutex);
    
45. 
    
46.         /* Done! */
    
47.         /* 大功告成，general cache终于全部建立起来了 */
    
48.         g_cpucache_up = FULL;
    
49. 
    
50.         /* Annotate slab for lockdep -- annotate the malloc caches */
    
51.         init_lock_keys();
    
52. 
    
53.         /*
    
54.          * Register a cpu startup notifier callback that initializes
    
55.          * cpu_cache_get for all new cpus
    
56.          */
    
57.          /* 注册cpu up回调函数，cpu up时配置local cache */
    
58.         register_cpu_notifier(&cpucache_notifier);
    
59. 
    
60.         /*
    
61.          * The reap timers are started later, with a module init call: That part
    
62.          * of the kernel is not yet operational.
    
63.          */
    
64. }view plaincopy to clipboardprint?/* Called with cache_chain_mutex held always */  
    
65. /*local cache 初始化*/  
    
66. static int enable_cpucache(struct kmem_cache *cachep, gfp_t gfp)  
    
67. {  
    
68.     int err;  
    
69.     int limit, shared;  
    
70.   
    
71.     /*
    
72.      * The head array serves three purposes:
    
73.      * - create a LIFO ordering, i.e. return objects that are cache-warm
    
74.      * - reduce the number of spinlock operations.
    
75.      * - reduce the number of linked list operations on the slab and
    
76.      *   bufctl chains: array operations are cheaper.
    
77.      * The numbers are guessed, we should auto-tune as described by
    
78.      * Bonwick.
    
79.      */ /* 根据对象大小计算local cache中对象数目上限 */  
    
80.     if (cachep->buffer_size > 131072)  
    
81.         limit = 1;  
    
82.     else if (cachep->buffer_size > PAGE_SIZE)  
    
83.         limit = 8;  
    
84.     else if (cachep->buffer_size > 1024)  
    
85.         limit = 24;  
    
86.     else if (cachep->buffer_size > 256)  
    
87.         limit = 54;  
    
88.     else  
    
89.         limit = 120;  
    
90.   
    
91.     /*
    
92.      * CPU bound tasks (e.g. network routing) can exhibit cpu bound
    
93.      * allocation behaviour: Most allocs on one cpu, most free operations
    
94.      * on another cpu. For these cases, an efficient object passing between
    
95.      * cpus is necessary. This is provided by a shared array. The array
    
96.      * replaces Bonwick's magazine layer.
    
97.      * On uniprocessor, it's functionally equivalent (but less efficient)
    
98.      * to a larger limit. Thus disabled by default.
    
99.      */  
    
100.     shared = 0;  
     
101.     /* 多核系统，设置shared local cache中对象数目 */  
     
102.     if (cachep->buffer_size <= PAGE_SIZE && num_possible_cpus() > 1)  
     
103.         shared = 8;  
     
104.   
     
105. #if DEBUG   
     
106.     /*
     
107.      * With debugging enabled, large batchcount lead to excessively long
     
108.      * periods with disabled local interrupts. Limit the batchcount
     
109.      */  
     
110.     if (limit > 32)  
     
111.         limit = 32;  
     
112. #endif   
     
113.     /* 配置local cache */  
     
114.     err = do_tune_cpucache(cachep, limit, (limit + 1) / 2, shared, gfp);  
     
115.     if (err)  
     
116.         printk(KERN_ERR "enable_cpucache failed for %s, error %d.\n",  
     
117.                cachep->name, -err);  
     
118.     return err;  
     
119. }  
     
120. /* Called with cache_chain_mutex held always */
     
121. /*local cache 初始化*/
     
122. static int enable_cpucache(struct kmem_cache *cachep, gfp_t gfp)
     
123. {
     
124.         int err;
     
125.         int limit, shared;
     
126. 
     
127.         /*
     
128.          * The head array serves three purposes:
     
129.          * - create a LIFO ordering, i.e. return objects that are cache-warm
     
130.          * - reduce the number of spinlock operations.
     
131.          * - reduce the number of linked list operations on the slab and
     
132.          *   bufctl chains: array operations are cheaper.
     
133.          * The numbers are guessed, we should auto-tune as described by
     
134.          * Bonwick.
     
135.          */ /* 根据对象大小计算local cache中对象数目上限 */
     
136.         if (cachep->buffer_size > 131072)
     
137.                 limit = 1;
     
138.         else if (cachep->buffer_size > PAGE_SIZE)
     
139.                 limit = 8;
     
140.         else if (cachep->buffer_size > 1024)
     
141.                 limit = 24;
     
142.         else if (cachep->buffer_size > 256)
     
143.                 limit = 54;
     
144.         else
     
145.                 limit = 120;
     
146. 
     
147.         /*
     
148.          * CPU bound tasks (e.g. network routing) can exhibit cpu bound
     
149.          * allocation behaviour: Most allocs on one cpu, most free operations
     
150.          * on another cpu. For these cases, an efficient object passing between
     
151.          * cpus is necessary. This is provided by a shared array. The array
     
152.          * replaces Bonwick's magazine layer.
     
153.          * On uniprocessor, it's functionally equivalent (but less efficient)
     
154.          * to a larger limit. Thus disabled by default.
     
155.          */
     
156.         shared = 0;
     
157.         /* 多核系统，设置shared local cache中对象数目 */
     
158.         if (cachep->buffer_size <= PAGE_SIZE && num_possible_cpus() > 1)
     
159.                 shared = 8;
     
160. 
     
161. #if DEBUG
     
162.         /*
     
163.          * With debugging enabled, large batchcount lead to excessively long
     
164.          * periods with disabled local interrupts. Limit the batchcount
     
165.          */
     
166.         if (limit > 32)
     
167.                 limit = 32;
     
168. #endif
     
169.         /* 配置local cache */
     
170.         err = do_tune_cpucache(cachep, limit, (limit + 1) / 2, shared, gfp);
     
171.         if (err)
     
172.                 printk(KERN_ERR "enable_cpucache failed for %s, error %d.\n",
     
173.                        cachep->name, -err);
     
174.         return err;
     
175. }view plaincopy to clipboardprint?/* Always called with the cache_chain_mutex held */  
     
176. /*配置local cache、shared local cache和slab三链*/  
     
177. static int do_tune_cpucache(struct kmem_cache *cachep, int limit,  
     
178.                 int batchcount, int shared, gfp_t gfp)  
     
179. {  
     
180.     struct ccupdate_struct *new;  
     
181.     int i;  
     
182.   
     
183.     new = kzalloc(sizeof(*new), gfp);  
     
184.     if (!new)  
     
185.         return -ENOMEM;  
     
186.     /* 为每个cpu分配新的struct array_cache对象 */  
     
187.     for_each_online_cpu(i) {  
     
188.         new->new[i] = alloc_arraycache(cpu_to_node(i), limit,  
     
189.                         batchcount, gfp);  
     
190.         if (!new->new[i]) {  
     
191.             for (i--; i >= 0; i--)  
     
192.                 kfree(new->new[i]);  
     
193.             kfree(new);  
     
194.             return -ENOMEM;  
     
195.         }  
     
196.     }  
     
197.     new->cachep = cachep;  
     
198.     /* 用新的struct array_cache对象替换旧的struct array_cache对象
     
199.     ，在支持cpu热插拔的系统上，离线cpu可能没有释放local cache
     
200.     ，使用的仍是旧local cache，参见__kmem_cache_destroy函数
     
201.     。虽然cpu up时要重新配置local cache，也无济于事。考虑下面的情景
     
202.     ：共有Cpu A和Cpu B，Cpu B down后，destroy Cache X，由于此时Cpu B是down状态
     
203.     ，所以Cache X中Cpu B的local cache未释放，过一段时间Cpu B又up了
     
204.     ，更新cache_chain 链中所有cache的local cache，但此时Cache X对象已经释放回
     
205.     cache_cache中了，其Cpu B local cache并未被更新。又过了一段时间
     
206.     ，系统需要创建新的cache，将Cache X对象分配出去，其Cpu B仍然是旧的
     
207.     local cache，需要进行更新。
     
208.     */  
     
209.     on_each_cpu(do_ccupdate_local, (void *)new, 1);  
     
210.   
     
211.     check_irq_on();  
     
212.     cachep->batchcount = batchcount;  
     
213.     cachep->limit = limit;  
     
214.     cachep->shared = shared;  
     
215.     /* 释放旧的local cache */  
     
216.     for_each_online_cpu(i) {  
     
217.         struct array_cache *ccold = new->new[i];  
     
218.         if (!ccold)  
     
219.             continue;  
     
220.         spin_lock_irq(&cachep->nodelists[cpu_to_node(i)]->list_lock);  
     
221.         /* 释放旧local cache中的对象 */  
     
222.         free_block(cachep, ccold->entry, ccold->avail, cpu_to_node(i));  
     
223.         spin_unlock_irq(&cachep->nodelists[cpu_to_node(i)]->list_lock);  
     
224.         /* 释放旧的struct array_cache对象 */  
     
225.         kfree(ccold);  
     
226.     }  
     
227.     kfree(new);  
     
228.     /* 初始化shared local cache 和slab三链 */  
     
229.     return alloc_kmemlist(cachep, gfp);  
     
230. }  
     
231. /* Always called with the cache_chain_mutex held */
     
232. /*配置local cache、shared local cache和slab三链*/
     
233. static int do_tune_cpucache(struct kmem_cache *cachep, int limit,
     
234.                                 int batchcount, int shared, gfp_t gfp)
     
235. {
     
236.         struct ccupdate_struct *new;
     
237.         int i;
     
238. 
     
239.         new = kzalloc(sizeof(*new), gfp);
     
240.         if (!new)
     
241.                 return -ENOMEM;
     
242.         /* 为每个cpu分配新的struct array_cache对象 */
     
243.         for_each_online_cpu(i) {
     
244.                 new->new[i] = alloc_arraycache(cpu_to_node(i), limit,
     
245.                                                 batchcount, gfp);
     
246.                 if (!new->new[i]) {
     
247.                         for (i--; i >= 0; i--)
     
248.                                 kfree(new->new[i]);
     
249.                         kfree(new);
     
250.                         return -ENOMEM;
     
251.                 }
     
252.         }
     
253.         new->cachep = cachep;
     
254.         /* 用新的struct array_cache对象替换旧的struct array_cache对象
     
255.         ，在支持cpu热插拔的系统上，离线cpu可能没有释放local cache
     
256.         ，使用的仍是旧local cache，参见__kmem_cache_destroy函数
     
257.         。虽然cpu up时要重新配置local cache，也无济于事。考虑下面的情景
     
258.         ：共有Cpu A和Cpu B，Cpu B down后，destroy Cache X，由于此时Cpu B是down状态
     
259.         ，所以Cache X中Cpu B的local cache未释放，过一段时间Cpu B又up了
     
260.         ，更新cache_chain 链中所有cache的local cache，但此时Cache X对象已经释放回
     
261.         cache_cache中了，其Cpu B local cache并未被更新。又过了一段时间
     
262.         ，系统需要创建新的cache，将Cache X对象分配出去，其Cpu B仍然是旧的
     
263.         local cache，需要进行更新。
     
264.         */
     
265.         on_each_cpu(do_ccupdate_local, (void *)new, 1);
     
266. 
     
267.         check_irq_on();
     
268.         cachep->batchcount = batchcount;
     
269.         cachep->limit = limit;
     
270.         cachep->shared = shared;
     
271.         /* 释放旧的local cache */
     
272.         for_each_online_cpu(i) {
     
273.                 struct array_cache *ccold = new->new[i];
     
274.                 if (!ccold)
     
275.                         continue;
     
276.                 spin_lock_irq(&cachep->nodelists[cpu_to_node(i)]->list_lock);
     
277.                 /* 释放旧local cache中的对象 */
     
278.                 free_block(cachep, ccold->entry, ccold->avail, cpu_to_node(i));
     
279.                 spin_unlock_irq(&cachep->nodelists[cpu_to_node(i)]->list_lock);
     
280.                 /* 释放旧的struct array_cache对象 */
     
281.                 kfree(ccold);
     
282.         }
     
283.         kfree(new);
     
284.         /* 初始化shared local cache 和slab三链 */
     
285.         return alloc_kmemlist(cachep, gfp);
     
286. }

复制代码

更新本地cache

1. view plaincopy to clipboardprint?/*更新每个cpu的struct array_cache对象*/  
   
2. static void do_ccupdate_local(void *info)  
   
3. {  
   
4.     struct ccupdate_struct *new = info;  
   
5.     struct array_cache *old;  
   
6.   
   
7.     check_irq_off();  
   
8.     old = cpu_cache_get(new->cachep);  
   
9.      /* 指向新的struct array_cache对象 */  
   
10.     new->cachep->array[smp_processor_id()] = new->new[smp_processor_id()];  
    
11.         /* 保存旧的struct array_cache对象 */  
    
12.     new->new[smp_processor_id()] = old;  
    
13. }  
    
14. /*更新每个cpu的struct array_cache对象*/
    
15. static void do_ccupdate_local(void *info)
    
16. {
    
17.         struct ccupdate_struct *new = info;
    
18.         struct array_cache *old;
    
19. 
    
20.         check_irq_off();
    
21.         old = cpu_cache_get(new->cachep);
    
22.          /* 指向新的struct array_cache对象 */
    
23.         new->cachep->array[smp_processor_id()] = new->new[smp_processor_id()];
    
24.             /* 保存旧的struct array_cache对象 */
    
25.         new->new[smp_processor_id()] = old;
    
26. }view plaincopy to clipboardprint?/*初始化shared local cache和slab三链，初始化完成后，slab三链中没有任何slab*/  
    
27. static int alloc_kmemlist(struct kmem_cache *cachep, gfp_t gfp)  
    
28. {  
    
29.     int node;  
    
30.     struct kmem_list3 *l3;  
    
31.     struct array_cache *new_shared;  
    
32.     struct array_cache **new_alien = NULL;  
    
33.   
    
34.     for_each_online_node(node) {  
    
35.          /* NUMA相关 */  
    
36.                 if (use_alien_caches) {  
    
37.                         new_alien = alloc_alien_cache(node, cachep->limit, gfp);  
    
38.                         if (!new_alien)  
    
39.                                 goto fail;  
    
40.                 }  
    
41.   
    
42.         new_shared = NULL;  
    
43.         if (cachep->shared) {  
    
44.             /* 分配shared local cache */  
    
45.             new_shared = alloc_arraycache(node,  
    
46.                 cachep->shared*cachep->batchcount,  
    
47.                     0xbaadf00d, gfp);  
    
48.             if (!new_shared) {  
    
49.                 free_alien_cache(new_alien);  
    
50.                 goto fail;  
    
51.             }  
    
52.         }  
    
53.         /* 获得旧的slab三链 */  
    
54.         l3 = cachep->nodelists[node];  
    
55.         if (l3) {  
    
56.             /* 就slab三链指针不为空，需要先释放旧的资源 */  
    
57.             struct array_cache *shared = l3->shared;  
    
58.   
    
59.             spin_lock_irq(&l3->list_lock);  
    
60.             /* 释放旧的shared local cache中的对象 */  
    
61.             if (shared)  
    
62.                 free_block(cachep, shared->entry,  
    
63.                         shared->avail, node);  
    
64.             /* 指向新的shared local cache */  
    
65.             l3->shared = new_shared;  
    
66.             if (!l3->alien) {  
    
67.                 l3->alien = new_alien;  
    
68.                 new_alien = NULL;  
    
69.             }/* 计算cache中空闲对象的上限 */  
    
70.             l3->free_limit = (1 + nr_cpus_node(node)) *  
    
71.                     cachep->batchcount + cachep->num;  
    
72.             spin_unlock_irq(&l3->list_lock);  
    
73.             /* 释放旧shared local cache的struct array_cache对象 */  
    
74.             kfree(shared);  
    
75.             free_alien_cache(new_alien);  
    
76.             continue;/*访问下一个节点*/  
    
77.         }  
    
78.          /* 如果没有旧的l3，分配新的slab三链 */  
    
79.         l3 = kmalloc_node(sizeof(struct kmem_list3), gfp, node);  
    
80.         if (!l3) {  
    
81.             free_alien_cache(new_alien);  
    
82.             kfree(new_shared);  
    
83.             goto fail;  
    
84.         }  
    
85.          /* 初始化slab三链 */  
    
86.         kmem_list3_init(l3);  
    
87.         l3->next_reap = jiffies + REAPTIMEOUT_LIST3 +  
    
88.                 ((unsigned long)cachep) % REAPTIMEOUT_LIST3;  
    
89.         l3->shared = new_shared;  
    
90.         l3->alien = new_alien;  
    
91.         l3->free_limit = (1 + nr_cpus_node(node)) *  
    
92.                     cachep->batchcount + cachep->num;  
    
93.         cachep->nodelists[node] = l3;  
    
94.     }  
    
95.     return 0;  
    
96.   
    
97. fail:  
    
98.     if (!cachep->next.next) {  
    
99.         /* Cache is not active yet. Roll back what we did */  
    
100.         node--;  
     
101.         while (node >= 0) {  
     
102.             if (cachep->nodelists[node]) {  
     
103.                 l3 = cachep->nodelists[node];  
     
104.   
     
105.                 kfree(l3->shared);  
     
106.                 free_alien_cache(l3->alien);  
     
107.                 kfree(l3);  
     
108.                 cachep->nodelists[node] = NULL;  
     
109.             }  
     
110.             node--;  
     
111.         }  
     
112.     }  
     
113.     return -ENOMEM;  
     
114. }  
     
115. /*初始化shared local cache和slab三链，初始化完成后，slab三链中没有任何slab*/
     
116. static int alloc_kmemlist(struct kmem_cache *cachep, gfp_t gfp)
     
117. {
     
118.         int node;
     
119.         struct kmem_list3 *l3;
     
120.         struct array_cache *new_shared;
     
121.         struct array_cache **new_alien = NULL;
     
122. 
     
123.         for_each_online_node(node) {
     
124.                  /* NUMA相关 */
     
125.                 if (use_alien_caches) {
     
126.                         new_alien = alloc_alien_cache(node, cachep->limit, gfp);
     
127.                         if (!new_alien)
     
128.                                 goto fail;
     
129.                 }
     
130. 
     
131.                 new_shared = NULL;
     
132.                 if (cachep->shared) {
     
133.                         /* 分配shared local cache */
     
134.                         new_shared = alloc_arraycache(node,
     
135.                                 cachep->shared*cachep->batchcount,
     
136.                                         0xbaadf00d, gfp);
     
137.                         if (!new_shared) {
     
138.                                 free_alien_cache(new_alien);
     
139.                                 goto fail;
     
140.                         }
     
141.                 }
     
142.                 /* 获得旧的slab三链 */
     
143.                 l3 = cachep->nodelists[node];
     
144.                 if (l3) {
     
145.                         /* 就slab三链指针不为空，需要先释放旧的资源 */
     
146.                         struct array_cache *shared = l3->shared;
     
147. 
     
148.                         spin_lock_irq(&l3->list_lock);
     
149.                         /* 释放旧的shared local cache中的对象 */
     
150.                         if (shared)
     
151.                                 free_block(cachep, shared->entry,
     
152.                                                 shared->avail, node);
     
153.                         /* 指向新的shared local cache */
     
154.                         l3->shared = new_shared;
     
155.                         if (!l3->alien) {
     
156.                                 l3->alien = new_alien;
     
157.                                 new_alien = NULL;
     
158.                         }/* 计算cache中空闲对象的上限 */
     
159.                         l3->free_limit = (1 + nr_cpus_node(node)) *
     
160.                                         cachep->batchcount + cachep->num;
     
161.                         spin_unlock_irq(&l3->list_lock);
     
162.                         /* 释放旧shared local cache的struct array_cache对象 */
     
163.                         kfree(shared);
     
164.                         free_alien_cache(new_alien);
     
165.                         continue;/*访问下一个节点*/
     
166.                 }
     
167.                  /* 如果没有旧的l3，分配新的slab三链 */
     
168.                 l3 = kmalloc_node(sizeof(struct kmem_list3), gfp, node);
     
169.                 if (!l3) {
     
170.                         free_alien_cache(new_alien);
     
171.                         kfree(new_shared);
     
172.                         goto fail;
     
173.                 }
     
174.                  /* 初始化slab三链 */
     
175.                 kmem_list3_init(l3);
     
176.                 l3->next_reap = jiffies + REAPTIMEOUT_LIST3 +
     
177.                                 ((unsigned long)cachep) % REAPTIMEOUT_LIST3;
     
178.                 l3->shared = new_shared;
     
179.                 l3->alien = new_alien;
     
180.                 l3->free_limit = (1 + nr_cpus_node(node)) *
     
181.                                         cachep->batchcount + cachep->num;
     
182.                 cachep->nodelists[node] = l3;
     
183.         }
     
184.         return 0;
     
185. 
     
186. fail:
     
187.         if (!cachep->next.next) {
     
188.                 /* Cache is not active yet. Roll back what we did */
     
189.                 node--;
     
190.                 while (node >= 0) {
     
191.                         if (cachep->nodelists[node]) {
     
192.                                 l3 = cachep->nodelists[node];
     
193. 
     
194.                                 kfree(l3->shared);
     
195.                                 free_alien_cache(l3->alien);
     
196.                                 kfree(l3);
     
197.                                 cachep->nodelists[node] = NULL;
     
198.                         }
     
199.                         node--;
     
200.                 }
     
201.         }
     
202.         return -ENOMEM;
     
203. }

复制代码

看一个辅助函数

1. view plaincopy to clipboardprint?/*分配struct array_cache对象。*/  
   
2. static struct array_cache *alloc_arraycache(int node, int entries,  
   
3.                         int batchcount, gfp_t gfp)  
   
4. {  
   
5.     /* struct array_cache后面紧接着的是entry数组，合在一起申请内存 */  
   
6.     int memsize = sizeof(void *) * entries + sizeof(struct array_cache);  
   
7.     struct array_cache *nc = NULL;  
   
8.     /* 分配一个local cache对象，kmalloc从general cache中分配 */  
   
9.     nc = kmalloc_node(memsize, gfp, node);  
   
10.     /*
    
11.      * The array_cache structures contain pointers to free object.
    
12.      * However, when such objects are allocated or transfered to another
    
13.      * cache the pointers are not cleared and they could be counted as
    
14.      * valid references during a kmemleak scan. Therefore, kmemleak must
    
15.      * not scan such objects.
    
16.      */  
    
17.     kmemleak_no_scan(nc);  
    
18.      /* 初始化local cache */  
    
19.     if (nc) {  
    
20.         nc->avail = 0;  
    
21.         nc->limit = entries;  
    
22.         nc->batchcount = batchcount;  
    
23.         nc->touched = 0;  
    
24.         spin_lock_init(&nc->lock);  
    
25.     }  
    
26.     return nc;  
    
27. }  
    
28. /*分配struct array_cache对象。*/
    
29. static struct array_cache *alloc_arraycache(int node, int entries,
    
30.                                             int batchcount, gfp_t gfp)
    
31. {
    
32.         /* struct array_cache后面紧接着的是entry数组，合在一起申请内存 */
    
33.         int memsize = sizeof(void *) * entries + sizeof(struct array_cache);
    
34.         struct array_cache *nc = NULL;
    
35.         /* 分配一个local cache对象，kmalloc从general cache中分配 */
    
36.         nc = kmalloc_node(memsize, gfp, node);
    
37.         /*
    
38.          * The array_cache structures contain pointers to free object.
    
39.          * However, when such objects are allocated or transfered to another
    
40.          * cache the pointers are not cleared and they could be counted as
    
41.          * valid references during a kmemleak scan. Therefore, kmemleak must
    
42.          * not scan such objects.
    
43.          */
    
44.         kmemleak_no_scan(nc);
    
45.          /* 初始化local cache */
    
46.         if (nc) {
    
47.                 nc->avail = 0;
    
48.                 nc->limit = entries;
    
49.                 nc->batchcount = batchcount;
    
50.                 nc->touched = 0;
    
51.                 spin_lock_init(&nc->lock);
    
52.         }
    
53.         return nc;
    
54. }

复制代码

源代码中涉及了slab的分配、释放等操作在后面分析中陆续总结。slab相关数据结构、工作机制以及整体框架在分析完了slab的创建、释放工作后再做总结，这样可能会对slab机制有更好的了解。当然，从代码中看运行机制会更有说服了，也是一种习惯。

在我心中舞动

谢谢分享