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

三里屯摇滚

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

1. #ifdef CONFIG_ZONE_DMA
   
2.                 sizes->cs_dmacachep = kmem_cache_create(
   
3.                                         names->name_dma,
   
4.                                         sizes->cs_size,
   
5.                                         ARCH_KMALLOC_MINALIGN,
   
6.                                         ARCH_KMALLOC_FLAGS|SLAB_CACHE_DMA|
   
7.                                                 SLAB_PANIC,
   
8.                                         NULL);
   
9. #endif
   
10.                 sizes++;
    
11.                 names++;
    
12.         }
    
13.         /* 至此，kmalloc general cache已经创建完毕，可以拿来使用了 */
    
14.         /* 4) Replace the bootstrap head arrays */
    
15.         /* 第四步，用kmalloc对象替换静态分配的全局变量
    
16.         。到目前为止一共使用了两个全局local cache
    
17.         ，一个是cache_cache的local cache指向initarray_cache.cache
    
18.         ，另一个是malloc_sizes[INDEX_AC].cs_cachep的local cache指向initarray_generic.cache
    
19.         ，参见setup_cpu_cache函数。这里替换它们。*/
    
20.         {
    
21.                 struct array_cache *ptr;
    
22.                 /* 申请cache_cache所用local cache的空间 */
    
23.                 ptr = kmalloc(sizeof(struct arraycache_init), GFP_NOWAIT);
    
24. 
    
25.                 BUG_ON(cpu_cache_get(&cache_cache) != &initarray_cache.cache);
    
26.                 /* 复制原cache_cache的local cache，即initarray_cache，到新的位置 */
    
27.                 memcpy(ptr, cpu_cache_get(&cache_cache),
    
28.                        sizeof(struct arraycache_init));
    
29.                 /*
    
30.                  * Do not assume that spinlocks can be initialized via memcpy:
    
31.                  */
    
32.                 spin_lock_init(&ptr->lock);
    
33.                 /* cache_cache的local cache指向新的位置 */
    
34.                 cache_cache.array[smp_processor_id()] = ptr;
    
35.                 /* 申请malloc_sizes[INDEX_AC].cs_cachep所用local cache的空间 */
    
36.                 ptr = kmalloc(sizeof(struct arraycache_init), GFP_NOWAIT);
    
37. 
    
38.                 BUG_ON(cpu_cache_get(malloc_sizes[INDEX_AC].cs_cachep)
    
39.                        != &initarray_generic.cache);
    
40.                 /* 复制原local cache到新分配的位置，注意此时local cache的大小是固定的 */
    
41.                 memcpy(ptr, cpu_cache_get(malloc_sizes[INDEX_AC].cs_cachep),
    
42.                        sizeof(struct arraycache_init));
    
43.                 /*
    
44.                  * Do not assume that spinlocks can be initialized via memcpy:
    
45.                  */
    
46.                 spin_lock_init(&ptr->lock);
    
47. 
    
48.                 malloc_sizes[INDEX_AC].cs_cachep->array[smp_processor_id()] =
    
49.                     ptr;
    
50.         }
    
51.         /* 5) Replace the bootstrap kmem_list3's */
    
52.         /* 第五步，与第四步类似，用kmalloc的空间替换静态分配的slab三链 */
    
53.         {
    
54.                 int nid;
    
55.           /* UMA只有一个节点 */
    
56.                 for_each_online_node(nid) {
    
57.                         /* 复制struct kmem_cache的slab三链 */
    
58.                         init_list(&cache_cache, &initkmem_list3[CACHE_CACHE + nid], nid);
    
59.                         /* 复制struct arraycache_init的slab三链 */
    
60.                         init_list(malloc_sizes[INDEX_AC].cs_cachep,
    
61.                                   &initkmem_list3[SIZE_AC + nid], nid);
    
62.                         /* 复制struct kmem_list3的slab三链 */
    
63.                         if (INDEX_AC != INDEX_L3) {
    
64.                                 init_list(malloc_sizes[INDEX_L3].cs_cachep,
    
65.                                           &initkmem_list3[SIZE_L3 + nid], nid);
    
66.                         }
    
67.                 }
    
68.         }
    
69.         /* 更新slab系统初始化进度 */
    
70.         g_cpucache_up = EARLY;
    
71. }

复制代码

]辅助操作

1，slab三链初始化

1. view plaincopy to clipboardprint?static void kmem_list3_init(struct kmem_list3 *parent)  
   
2. {  
   
3.     INIT_LIST_HEAD(&parent->slabs_full);  
   
4.     INIT_LIST_HEAD(&parent->slabs_partial);  
   
5.     INIT_LIST_HEAD(&parent->slabs_free);  
   
6.     parent->shared = NULL;  
   
7.     parent->alien = NULL;  
   
8.     parent->colour_next = 0;  
   
9.     spin_lock_init(&parent->list_lock);  
   
10.     parent->free_objects = 0;  
    
11.     parent->free_touched = 0;  
    
12. }  
    
13. static void kmem_list3_init(struct kmem_list3 *parent)
    
14. {
    
15.         INIT_LIST_HEAD(&parent->slabs_full);
    
16.         INIT_LIST_HEAD(&parent->slabs_partial);
    
17.         INIT_LIST_HEAD(&parent->slabs_free);
    
18.         parent->shared = NULL;
    
19.         parent->alien = NULL;
    
20.         parent->colour_next = 0;
    
21.         spin_lock_init(&parent->list_lock);
    
22.         parent->free_objects = 0;
    
23.         parent->free_touched = 0;
    
24. }

复制代码

2，slab三链静态数据初始化

1. view plaincopy to clipboardprint? /*设置cache的slab三链指向静态分配的全局变量*/  
   
2. static void __init set_up_list3s(struct kmem_cache *cachep, int index)  
   
3. {  
   
4.     int node;  
   
5.     /* UMA只有一个节点 */  
   
6.     for_each_online_node(node) {  
   
7.         /* 全局变量initkmem_list3是初始化阶段使用的slab三链 */  
   
8.         cachep->nodelists[node] = &initkmem_list3[index + node];  
   
9.         /* 设置回收时间 */  
   
10.         cachep->nodelists[node]->next_reap = jiffies +  
    
11.             REAPTIMEOUT_LIST3 +  
    
12.             ((unsigned long)cachep) % REAPTIMEOUT_LIST3;  
    
13.     }  
    
14. }  
    
15. /*设置cache的slab三链指向静态分配的全局变量*/
    
16. static void __init set_up_list3s(struct kmem_cache *cachep, int index)
    
17. {
    
18.         int node;
    
19.         /* UMA只有一个节点 */
    
20.         for_each_online_node(node) {
    
21.                 /* 全局变量initkmem_list3是初始化阶段使用的slab三链 */
    
22.                 cachep->nodelists[node] = &initkmem_list3[index + node];
    
23.                 /* 设置回收时间 */
    
24.                 cachep->nodelists[node]->next_reap = jiffies +
    
25.                     REAPTIMEOUT_LIST3 +
    
26.                     ((unsigned long)cachep) % REAPTIMEOUT_LIST3;
    
27.         }
    
28. }

复制代码

3，计算每个slab中对象的数目

view plaincopy to clipboardprint?/*

1. * Calculate the number of objects and left-over bytes for a given buffer size.
   
2. */  
   
3. /*计算每个slab中对象的数目。*/  
   
4. /*
   
5. 1)        gfporder：slab由2gfporder个页面组成。
   
6. 2)        buffer_size：对象的大小。
   
7. 3)        align：对象的对齐方式。
   
8. 4)        flags：内置式slab还是外置式slab。
   
9. 5)        left_over：slab中浪费空间的大小。
   
10. 6)        num：slab中的对象数目。
    
11. */  
    
12. static void cache_estimate(unsigned long gfporder, size_t buffer_size,  
    
13.                size_t align, int flags, size_t *left_over,  
    
14.                unsigned int *num)  
    
15. {  
    
16.     int nr_objs;  
    
17.     size_t mgmt_size;  
    
18.     /* slab大小为1<<order个页面 */  
    
19.     size_t slab_size = PAGE_SIZE << gfporder;  
    
20.   
    
21.     /*
    
22.      * The slab management structure can be either off the slab or
    
23.      * on it. For the latter case, the memory allocated for a
    
24.      * slab is used for:
    
25.      *
    
26.      * - The struct slab
    
27.      * - One kmem_bufctl_t for each object
    
28.      * - Padding to respect alignment of @align
    
29.      * - @buffer_size bytes for each object
    
30.      *
    
31.      * If the slab management structure is off the slab, then the
    
32.      * alignment will already be calculated into the size. Because
    
33.      * the slabs are all pages aligned, the objects will be at the
    
34.      * correct alignment when allocated.
    
35.      */  
    
36.     if (flags & CFLGS_OFF_SLAB) {  
    
37.         /* 外置式slab */  
    
38.         mgmt_size = 0;  
    
39.         /* slab页面不含slab管理对象，全部用来存储slab对象 */  
    
40.         nr_objs = slab_size / buffer_size;  
    
41.         /* 对象数不能超过上限 */  
    
42.         if (nr_objs > SLAB_LIMIT)  
    
43.             nr_objs = SLAB_LIMIT;  
    
44.     } else {  
    
45.         /*
    
46.          * Ignore padding for the initial guess. The padding
    
47.          * is at most @align-1 bytes, and @buffer_size is at
    
48.          * least @align. In the worst case, this result will
    
49.          * be one greater than the number of objects that fit
    
50.          * into the memory allocation when taking the padding
    
51.          * into account.
    
52.          *//* 内置式slab，slab管理对象与slab对象在一起
    
53.          ，此时slab页面中包含：一个struct slab对象，一个kmem_bufctl_t数组，slab对象。
    
54.          kmem_bufctl_t数组大小与slab对象数目相同 */  
    
55.         nr_objs = (slab_size - sizeof(struct slab)) /  
    
56.               (buffer_size + sizeof(kmem_bufctl_t));  
    
57.   
    
58.         /*
    
59.          * This calculated number will be either the right
    
60.          * amount, or one greater than what we want.
    
61.          *//* 计算cache line对齐后的大小，如果超出了slab总的大小，则对象数减一 */  
    
62.         if (slab_mgmt_size(nr_objs, align) + nr_objs*buffer_size  
    
63.                > slab_size)  
    
64.             nr_objs--;  
    
65.   
    
66.         if (nr_objs > SLAB_LIMIT)  
    
67.             nr_objs = SLAB_LIMIT;  
    
68.         /* 计算cache line对齐后slab管理对象的大小 */  
    
69.         mgmt_size = slab_mgmt_size(nr_objs, align);  
    
70.     }  
    
71.     *num = nr_objs;/* 保存slab对象数目 */  
    
72.     /* 计算浪费空间的大小 */  
    
73.     *left_over = slab_size - nr_objs*buffer_size - mgmt_size;  
    
74. }  
    
75. /*
    
76. * Calculate the number of objects and left-over bytes for a given buffer size.
    
77. */
    
78. /*计算每个slab中对象的数目。*/
    
79. /*
    
80. 1)        gfporder：slab由2gfporder个页面组成。
    
81. 2)        buffer_size：对象的大小。
    
82. 3)        align：对象的对齐方式。
    
83. 4)        flags：内置式slab还是外置式slab。
    
84. 5)        left_over：slab中浪费空间的大小。
    
85. 6)        num：slab中的对象数目。
    
86. */
    
87. static void cache_estimate(unsigned long gfporder, size_t buffer_size,
    
88.                            size_t align, int flags, size_t *left_over,
    
89.                            unsigned int *num)
    
90. {
    
91.         int nr_objs;
    
92.         size_t mgmt_size;
    
93.         /* slab大小为1<<order个页面 */
    
94.         size_t slab_size = PAGE_SIZE << gfporder;
    
95. 
    
96.         /*
    
97.          * The slab management structure can be either off the slab or
    
98.          * on it. For the latter case, the memory allocated for a
    
99.          * slab is used for:
    
100.          *
     
101.          * - The struct slab
     
102.          * - One kmem_bufctl_t for each object
     
103.          * - Padding to respect alignment of @align
     
104.          * - @buffer_size bytes for each object
     
105.          *
     
106.          * If the slab management structure is off the slab, then the
     
107.          * alignment will already be calculated into the size. Because
     
108.          * the slabs are all pages aligned, the objects will be at the
     
109.          * correct alignment when allocated.
     
110.          */
     
111.         if (flags & CFLGS_OFF_SLAB) {
     
112.                 /* 外置式slab */
     
113.                 mgmt_size = 0;
     
114.                 /* slab页面不含slab管理对象，全部用来存储slab对象 */
     
115.                 nr_objs = slab_size / buffer_size;
     
116.                 /* 对象数不能超过上限 */
     
117.                 if (nr_objs > SLAB_LIMIT)
     
118.                         nr_objs = SLAB_LIMIT;
     
119.         } else {
     
120.                 /*
     
121.                  * Ignore padding for the initial guess. The padding
     
122.                  * is at most @align-1 bytes, and @buffer_size is at
     
123.                  * least @align. In the worst case, this result will
     
124.                  * be one greater than the number of objects that fit
     
125.                  * into the memory allocation when taking the padding
     
126.                  * into account.
     
127.                  *//* 内置式slab，slab管理对象与slab对象在一起
     
128.                  ，此时slab页面中包含：一个struct slab对象，一个kmem_bufctl_t数组，slab对象。
     
129.                  kmem_bufctl_t数组大小与slab对象数目相同 */
     
130.                 nr_objs = (slab_size - sizeof(struct slab)) /
     
131.                           (buffer_size + sizeof(kmem_bufctl_t));
     
132. 
     
133.                 /*
     
134.                  * This calculated number will be either the right
     
135.                  * amount, or one greater than what we want.
     
136.                  *//* 计算cache line对齐后的大小，如果超出了slab总的大小，则对象数减一 */
     
137.                 if (slab_mgmt_size(nr_objs, align) + nr_objs*buffer_size
     
138.                        > slab_size)
     
139.                         nr_objs--;
     
140. 
     
141.                 if (nr_objs > SLAB_LIMIT)
     
142.                         nr_objs = SLAB_LIMIT;
     
143.                 /* 计算cache line对齐后slab管理对象的大小 */
     
144.                 mgmt_size = slab_mgmt_size(nr_objs, align);
     
145.         }
     
146.         *num = nr_objs;/* 保存slab对象数目 */
     
147.         /* 计算浪费空间的大小 */
     
148.         *left_over = slab_size - nr_objs*buffer_size - mgmt_size;
     
149. }

复制代码

辅助数据结构与变量

Linux内核中将所有的通用cache以不同的大小存放在数组中，以方便查找。其中malloc_sizes[]数组为cache_sizes类型的数组，存放各个cache的大小；cache_names[]数组为cache_names结构类型数组，存放各个cache大小的名称；malloc_sizes[]数组和cache_names[]数组下标对应，也就是说cache_names名称的cache对应的大小为malloc_sizes。

1. view plaincopy to clipboardprint?/* Size description struct for general caches. */  
   
2. struct cache_sizes {  
   
3.     size_t          cs_size;  
   
4.     struct kmem_cache   *cs_cachep;  
   
5. #ifdef CONFIG_ZONE_DMA   
   
6.     struct kmem_cache   *cs_dmacachep;  
   
7. #endif   
   
8. };  
   
9. /*
   
10. * These are the default caches for kmalloc. Custom caches can have other sizes.
    
11. */  
    
12. struct cache_sizes malloc_sizes[] = {  
    
13. #define CACHE(x) { .cs_size = (x) },   
    
14. #include <linux/kmalloc_sizes.h>   
    
15.     CACHE(ULONG_MAX)  
    
16. #undef CACHE   
    
17. };  
    
18. /* Size description struct for general caches. */
    
19. struct cache_sizes {
    
20.         size_t                         cs_size;
    
21.         struct kmem_cache        *cs_cachep;
    
22. #ifdef CONFIG_ZONE_DMA
    
23.         struct kmem_cache        *cs_dmacachep;
    
24. #endif
    
25. };
    
26. /*
    
27. * These are the default caches for kmalloc. Custom caches can have other sizes.
    
28. */
    
29. struct cache_sizes malloc_sizes[] = {
    
30. #define CACHE(x) { .cs_size = (x) },
    
31. #include <linux/kmalloc_sizes.h>
    
32.         CACHE(ULONG_MAX)
    
33. #undef CACHE
    
34. };view plaincopy to clipboardprint?/* Must match cache_sizes above. Out of line to keep cache footprint low. */  
    
35. struct cache_names {  
    
36.     char *name;  
    
37.     char *name_dma;  
    
38. };  
    
39.   
    
40. static struct cache_names __initdata cache_names[] = {  
    
41. #define CACHE(x) { .name = "size-" #x, .name_dma = "size-" #x "(DMA)" },   
    
42. #include <linux/kmalloc_sizes.h>   
    
43.     {NULL,}  
    
44. #undef CACHE   
    
45. };  
    
46. /* Must match cache_sizes above. Out of line to keep cache footprint low. */
    
47. struct cache_names {
    
48.         char *name;
    
49.         char *name_dma;
    
50. };
    
51. 
    
52. static struct cache_names __initdata cache_names[] = {
    
53. #define CACHE(x) { .name = "size-" #x, .name_dma = "size-" #x "(DMA)" },
    
54. #include <linux/kmalloc_sizes.h>
    
55.         {NULL,}
    
56. #undef CACHE
    
57. };

复制代码

二、内核启动末期初始化

1，根据对象大小计算local cache中对象数目上限；

2，借助数据结构ccupdate_struct操作cpu本地cache。为每个在线cpu分配cpu本地cache；

3，用新分配的cpu本地cache替换原有的cache；

4，更新slab三链以及cpu本地共享cache。

在我心中舞动

谢谢分享