Linux内存管理之slab分配器分析(二 初始化 kmem_cache_init_late)

start_kernel的在mm_init->kmem_cache_init之后，还调用了kmem_cache_init_late函数。

该函数接着kmem_cache_init的处理进度，继续展开，如下：

点击(此处)折叠或打开

1. void __init kmem_cache_init_late(void)
   
2. {
   
3.     struct kmem_cache *cachep;
   
4. 
   
5.     /* 6) resize the head arrays to their final sizes */
   
6.     /× 之前的函数处理到5），这里紧接着从6）继续，遍历cache_chain上的所有的cache ×/
   
7.     mutex_lock(&cache_chain_mutex);
   
8.     list_for_each_entry(cachep, &cache_chain, next)
   
9.         /* 初始化阶段local_cache的大小是固定的，现在要根据对象的大小重新计算 */
   
10.         if (enable_cpucache(cachep, GFP_NOWAIT))
    
11.             BUG();
    
12.     mutex_unlock(&cache_chain_mutex);
    
13. 
    
14.     /* 至此，普通cache已经建立起来了 */
    
15.     g_cpucache_up = FULL;
    
16. 
    
17.     /* Annotate slab for lockdep -- annotate the malloc caches */
    
18.     init_lock_keys();
    
19. 
    
20.     /*
    
21.      * Register a cpu startup notifier callback that initializes
    
22.      * cpu_cache_get for all new cpus
    
23.      */
    
24.     /× 注册CPU up的回调函数，用于在cpu up时配置local cache ×/
    
25.     register_cpu_notifier(&cpucache_notifier);
    
26. 
    
27. #ifdef CONFIG_NUMA
    
28.     /*
    
29.      * Register a memory hotplug callback that initializes and frees
    
30.      * nodelists.
    
31.      */
    
32.     hotplug_memory_notifier(slab_memory_callback, SLAB_CALLBACK_PRI);
    
33. #endif
    
34. 
    
35.     /*
    
36.      * The reap timers are started later, with a module init call: That part
    
37.      * of the kernel is not yet operational.
    
38.      */
    
39. }

点击(此处)折叠或打开

1. /* Called with cache_chain_mutex held always */
   
2. /* 初始化local cache */
3. static int enable_cpucache(struct kmem_cache *cachep, gfp_t gfp)
   
4. {
   
5.     int err;
   
6.     int limit, shared;
   
7. 
   
8.     /*
   
9.      * The head array serves three purposes:
   
10.      * - create a LIFO ordering, i.e. return objects that are cache-warm
    
11.      * - reduce the number of spinlock operations.
    
12.      * - reduce the number of linked list operations on the slab and
    
13.      * bufctl chains: array operations are cheaper.
    
14.      * The numbers are guessed, we should auto-tune as described by
    
15.      * Bonwick.
    
16.      */
    
17.     /* 根据对象的大小计算local cache中对象的数量 */
    
18.     if (cachep->buffer_size > 131072)
    
19.         limit = 1;
    
20.     else if (cachep->buffer_size > PAGE_SIZE)
    
21.         limit = 8;
    
22.     else if (cachep->buffer_size > 1024)
    
23.         limit = 24;
    
24.     else if (cachep->buffer_size > 256)
    
25.         limit = 54;
    
26.     else
    
27.         limit = 120;
    
28. 
    
29.     /*
    
30.      * CPU bound tasks (e.g. network routing) can exhibit cpu bound
    
31.      * allocation behaviour: Most allocs on one cpu, most free operations
    
32.      * on another cpu. For these cases, an efficient object passing between
    
33.      * cpus is necessary. This is provided by a shared array. The array
    
34.      * replaces Bonwick's magazine layer.
    
35.      * On uniprocessor, it's functionally equivalent (but less efficient)
    
36.      * to a larger limit. Thus disabled by default.
    
37.      */
    
38.     shared = 0;
    
39.     /× 多核下设置share local cache中的对象数目 ×/
    
40.     if (cachep->buffer_size <= PAGE_SIZE && num_possible_cpus() > 1)
    
41.         shared = 8;
    
42. 
    
43. #if DEBUG
    
44.     /*
    
45.      * With debugging enabled, large batchcount lead to excessively long
    
46.      * periods with disabled local interrupts. Limit the batchcount
    
47.      */
    
48.     if (limit > 32)
    
49.         limit = 32;
    
50. #endif
    
51.     /× 配置local cache ×/
    
52.     err = do_tune_cpucache(cachep, limit, (limit + 1) / 2, shared, gfp);
    
53.     if (err)
    
54.         printk(KERN_ERR "enable_cpucache failed for %s, error %d.\n",
    
55.          cachep->name, -err);
    
56.     return err;
    
57. }

点击(此处)折叠或打开

1. /* Always called with the cache_chain_mutex held */
   
2. /* 设置local cache, share local cache和slab的三个链表 */
3. static int do_tune_cpucache(struct kmem_cache *cachep, int limit,
   
4.                 int batchcount, int shared, gfp_t gfp)
   
5. {
   
6.     struct ccupdate_struct *new;
   
7.     int i;
   
8. 
   
9.     new = kzalloc(sizeof(*new), gfp);
   
10.     if (!new)
    
11.         return -ENOMEM;
    
12. 
    
13.     for_each_online_cpu(i) {
    
14.         /* 为每个cpu分配新的struct array_cache对象 */
    
15.         new->new[i] = alloc_arraycache(cpu_to_node(i), limit,
    
16.                         batchcount, gfp);
    
17.         if (!new->new[i]) {
    
18.             for (i--; i >= 0; i--)
    
19.                 kfree(new->new[i]);
    
20.             kfree(new);
    
21.             return -ENOMEM;
    
22.         }
    
23.     }
    
24.     new->cachep = cachep;
    
25. 
    
26.     on_each_cpu(do_ccupdate_local, (void *)new, 1);
    
27. 
    
28.     check_irq_on();
    
29.     cachep->batchcount = batchcount;
    
30.     cachep->limit = limit;
    
31.     cachep->shared = shared;
    
32. 
    
33.     /× 释放旧的local cache ×/
    
34.     for_each_online_cpu(i) {
    
35.         struct array_cache *ccold = new->new[i];
    
36.         if (!ccold)
    
37.             continue;
    
38.         spin_lock_irq(&cachep->nodelists[cpu_to_node(i)]->list_lock);
    
39.         /* 释放旧的local cache中的对象 */
    
40.         free_block(cachep, ccold->entry, ccold->avail, cpu_to_node(i));
    
41.         spin_unlock_irq(&cachep->nodelists[cpu_to_node(i)]->list_lock);
    
42.         /× 释放旧的struct array_cache对象 ×/
    
43.         kfree(ccold);
    
44.     }
    
45.     kfree(new);
    
46.     /× 初始化shared local cache和slab三个链表 ×/
    
47.     return alloc_kmemlist(cachep, gfp);
    
48. }

点击(此处)折叠或打开

1. /× 更新每个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. }

点击(此处)折叠或打开

1. /*
   
2.  * This initializes kmem_list3 or resizes various caches for all nodes.
   
3.  */
   
4. /× 初始化shared local cache和slab的三个链表 ×/
5. static int alloc_kmemlist(struct kmem_cache *cachep, gfp_t gfp)
   
6. {
   
7.     int node;
   
8.     struct kmem_list3 *l3;
   
9.     struct array_cache *new_shared;
   
10.     struct array_cache **new_alien = NULL;
    
11. 
    
12.     for_each_online_node(node) {
    
13. 
    
14.                 if (use_alien_caches) {
    
15.                         new_alien = alloc_alien_cache(node, cachep->limit, gfp);
    
16.                         if (!new_alien)
    
17.                                 goto fail;
    
18.                 }
    
19. 
    
20.         new_shared = NULL;
    
21.         /× 分配shared local cache ×/
    
22.         if (cachep->shared) {
    
23.             new_shared = alloc_arraycache(node,
    
24.                 cachep->shared*cachep->batchcount,
    
25.                     0xbaadf00d, gfp);
    
26.             if (!new_shared) {
    
27.                 free_alien_cache(new_alien);
    
28.                 goto fail;
    
29.             }
    
30.         }
    
31.         /* 获取旧的slab三个链表 */
    
32.         l3 = cachep->nodelists[node];
    
33.         if (l3) {
    
34.             struct array_cache *shared = l3->shared;
    
35. 
    
36.             spin_lock_irq(&l3->list_lock);
    
37.             /× 释放旧的shared local cache中的对象 ×/
    
38.             if (shared)
    
39.                 free_block(cachep, shared->entry,
    
40.                         shared->avail, node);
    
41.             /× 指向新的share local cache ×/
    
42.             l3->shared = new_shared;
    
43.             if (!l3->alien) {
    
44.                 l3->alien = new_alien;
    
45.                 new_alien = NULL;
    
46.             }
    
47.             /* 计算cache中空闲对象的上限 */
    
48.             l3->free_limit = (1 + nr_cpus_node(node)) *
    
49.                     cachep->batchcount + cachep->num;
    
50.             spin_unlock_irq(&l3->list_lock);
    
51.             kfree(shared);
    
52.             free_alien_cache(new_alien);
    
53.             continue;
    
54.         }
    
55.         /× 分配新的slab 三链 ×/
    
56.         l3 = kmalloc_node(sizeof(struct kmem_list3), gfp, node);
    
57.         if (!l3) {
    
58.             free_alien_cache(new_alien);
    
59.             kfree(new_shared);
    
60.             goto fail;
    
61.         }
    
62.         /× 进行初始化 ×/
    
63.         kmem_list3_init(l3);
    
64.         l3->next_reap = jiffies + REAPTIMEOUT_LIST3 +
    
65.                 ((unsigned long)cachep) % REAPTIMEOUT_LIST3;
    
66.         l3->shared = new_shared;
    
67.         l3->alien = new_alien;
    
68.         l3->free_limit = (1 + nr_cpus_node(node)) *
    
69.                     cachep->batchcount + cachep->num;
    
70.         cachep->nodelists[node] = l3;
    
71.     }
    
72.     return 0;
    
73. 
    
74. fail:
    
75.     if (!cachep->next.next) {
    
76.         /* Cache is not active yet. Roll back what we did */
    
77.         node--;
    
78.         while (node >= 0) {
    
79.             if (cachep->nodelists[node]) {
    
80.                 l3 = cachep->nodelists[node];
    
81. 
    
82.                 kfree(l3->shared);
    
83.                 free_alien_cache(l3->alien);
    
84.                 kfree(l3);
    
85.                 cachep->nodelists[node] = NULL;
    
86.             }
    
87.             node--;
    
88.         }
    
89.     }
    
90.     return -ENOMEM;
    
91. }