关于per-cpu的疑问。。。

chishanmingshen

静态和动态的per-cpu变量存储在一段（貌似同一段？！）连续的虚拟空间？

如果上面猜测是对的，就需要在vmalloc空间预留一段连续空间啊，code在哪里？

希望结合pcpu_get_vm_areas这个函数 （3.12以上）指点下啊，谢谢！


3.12

1. 
   
2. /**
   
3. * pcpu_get_vm_areas - allocate vmalloc areas for percpu allocator
   
4. * @offsets: array containing offset of each area
   
5. * @sizes: array containing size of each area
   
6. * @nr_vms: the number of areas to allocate
   
7. * @align: alignment, all entries in @offsets and @sizes must be aligned to this
   
8. *
   
9. * Returns: kmalloc'd vm_struct pointer array pointing to allocated
   
10. *            vm_structs on success, %NULL on failure
    
11. *
    
12. * Percpu allocator wants to use congruent vm areas so that it can
    
13. * maintain the offsets among percpu areas.  This function allocates
    
14. * congruent vmalloc areas for it with GFP_KERNEL.  These areas tend to
    
15. * be scattered pretty far, distance between two areas easily going up
    
16. * to gigabytes.  To avoid interacting with regular vmallocs, these
    
17. * areas are allocated from top.
    
18. *
    
19. * Despite its complicated look, this allocator is rather simple.  It
    
20. * does everything top-down and scans areas from the end looking for
    
21. * matching slot.  While scanning, if any of the areas overlaps with
    
22. * existing vmap_area, the base address is pulled down to fit the
    
23. * area.  Scanning is repeated till all the areas fit and then all
    
24. * necessary data structres are inserted and the result is returned.
    
25. */
    
26. struct vm_struct **pcpu_get_vm_areas(const unsigned long *offsets,
    
27.                                      const size_t *sizes, int nr_vms,
    
28. 
    
29. /**
    
30. * pcpu_get_vm_areas - allocate vmalloc areas for percpu allocator
    
31. * @offsets: array containing offset of each area
    
32. * @sizes: array containing size of each area
    
33. * @nr_vms: the number of areas to allocate
    
34. * @align: alignment, all entries in @offsets and @sizes must be aligned to this
    
35. *
    
36. * Returns: kmalloc'd vm_struct pointer array pointing to allocated
    
37. *            vm_structs on success, %NULL on failure
    
38. *
    
39. * Percpu allocator wants to use congruent vm areas so that it can
    
40. * maintain the offsets among percpu areas.  This function allocates
    
41. * congruent vmalloc areas for it with GFP_KERNEL.  These areas tend to
    
42. * be scattered pretty far, distance between two areas easily going up
    
43. * to gigabytes.  To avoid interacting with regular vmallocs, these
    
44. * areas are allocated from top.
    
45. *
    
46. * Despite its complicated look, this allocator is rather simple.  It
    
47. * does everything top-down and scans areas from the end looking for
    
48. * matching slot.  While scanning, if any of the areas overlaps with
    
49. * existing vmap_area, the base address is pulled down to fit the
    
50. * area.  Scanning is repeated till all the areas fit and then all
    
51. * necessary data structres are inserted and the result is returned.
    
52. */
    
53. struct vm_struct **pcpu_get_vm_areas(const unsigned long *offsets,
    
54.                                      const size_t *sizes, int nr_vms,
    
55.                                      size_t align)
    
56. {
    
57.         const unsigned long vmalloc_start = ALIGN(VMALLOC_START, align);
    
58.         const unsigned long vmalloc_end = VMALLOC_END & ~(align - 1);
    
59.         struct vmap_area **vas, *prev, *next;
    
60.         struct vm_struct **vms;
    
61.         int area, area2, last_area, term_area;
    
62.         unsigned long base, start, end, last_end;
    
63.         bool purged = false;
    
64. 
    
65.         /* verify parameters and allocate data structures */
    
66.         BUG_ON(align & ~PAGE_MASK || !is_power_of_2(align));
    
67.         for (last_area = 0, area = 0; area < nr_vms; area++) {
    
68.                 start = offsets[area];
    
69.                 end = start + sizes[area];
    
70. 
    
71.                 /* is everything aligned properly? */
    
72.                 BUG_ON(!IS_ALIGNED(offsets[area], align));
    
73.                 BUG_ON(!IS_ALIGNED(sizes[area], align));
    
74. 
    
75.                 /* detect the area with the highest address */
    
76.                 if (start > offsets[last_area])
    
77.                         last_area = area;
    
78. 
    
79.                 for (area2 = 0; area2 < nr_vms; area2++) {
    
80.                         unsigned long start2 = offsets[area2];
    
81.                         unsigned long end2 = start2 + sizes[area2];
    
82. 
    
83.                         if (area2 == area)
    
84.                                 continue;
    
85. 
    
86.                         BUG_ON(start2 >= start && start2 < end);
    
87.                         BUG_ON(end2 <= end && end2 > start);
    
88.                 }
    
89.         }
    
90.         last_end = offsets[last_area] + sizes[last_area];
    
91. 
    
92.         if (vmalloc_end - vmalloc_start < last_end) {
    
93.                 WARN_ON(true);
    
94.                 return NULL;
    
95.         }
    
96. 
    
97.         vms = kcalloc(nr_vms, sizeof(vms[0]), GFP_KERNEL);
    
98.         vas = kcalloc(nr_vms, sizeof(vas[0]), GFP_KERNEL);
    
99.         if (!vas || !vms)
    
100.                 goto err_free2;
     
101. 
     
102.         for (area = 0; area < nr_vms; area++) {
     
103.                 vas[area] = kzalloc(sizeof(struct vmap_area), GFP_KERNEL);
     
104.                 vms[area] = kzalloc(sizeof(struct vm_struct), GFP_KERNEL);
     
105.                 if (!vas[area] || !vms[area])
     
106.                         goto err_free;
     
107.         }
     
108. retry:
     
109.         spin_lock(&vmap_area_lock);
     
110. 
     
111.         /* start scanning - we scan from the top, begin with the last area */
     
112.         area = term_area = last_area;
     
113.         start = offsets[area];
     
114.         end = start + sizes[area];
     
115. 
     
116.         if (!pvm_find_next_prev(vmap_area_pcpu_hole, &next, &prev)) {
     
117.                 base = vmalloc_end - last_end;
     
118.                 goto found;
     
119.         }
     
120.         base = pvm_determine_end(&next, &prev, align) - end;
     
121. 
     
122.         while (true) {
     
123.                 BUG_ON(next && next->va_end <= base + end);
     
124.                 BUG_ON(prev && prev->va_end > base + end);
     
125. 
     
126.                 /*
     
127.                  * base might have underflowed, add last_end before
     
128.                  * comparing.
     
129.                  */
     
130.                 if (base + last_end < vmalloc_start + last_end) {
     
131.                         spin_unlock(&vmap_area_lock);
     
132.                         if (!purged) {
     
133.                                 purge_vmap_area_lazy();
     
134.                                 purged = true;
     
135.                                 goto retry;
     
136.                         }
     
137.                         goto err_free;
     
138.                 }
     
139. 
     
140.                 /*
     
141.                  * If next overlaps, move base downwards so that it's
     
142.                  * right below next and then recheck.
     
143.                  */
     
144.                 if (next && next->va_start < base + end) {
     
145.                         base = pvm_determine_end(&next, &prev, align) - end;
     
146.                         term_area = area;
     
147.                         continue;
     
148.                 }
     
149. 
     
150.                 /*
     
151.                  * If prev overlaps, shift down next and prev and move
     
152.                  * base so that it's right below new next and then
     
153.                  * recheck.
     
154.                  */
     
155.                 if (prev && prev->va_end > base + start)  {
     
156.                         next = prev;
     
157.                         prev = node_to_va(rb_prev(&next->rb_node));
     
158.                         base = pvm_determine_end(&next, &prev, align) - end;
     
159.                         term_area = area;
     
160.                         continue;
     
161.                 }
     
162. 
     
163.                 /*
     
164.                  * This area fits, move on to the previous one.  If
     
165.                  * the previous one is the terminal one, we're done.
     
166.                  */
     
167.                 area = (area + nr_vms - 1) % nr_vms;
     
168.                 if (area == term_area)
     
169.                         break;
     
170.                 start = offsets[area];
     
171.                 end = start + sizes[area];
     
172.                 pvm_find_next_prev(base + end, &next, &prev);
     
173.         }
     
174. found:
     
175.         /* we've found a fitting base, insert all va's */
     
176.         for (area = 0; area < nr_vms; area++) {
     
177.                 struct vmap_area *va = vas[area];
     
178. 
     
179.                 va->va_start = base + offsets[area];
     
180.                 va->va_end = va->va_start + sizes[area];
     
181.                 __insert_vmap_area(va);
     
182.         }
     
183. 
     
184.         vmap_area_pcpu_hole = base + offsets[last_area];
     
185. 
     
186.         spin_unlock(&vmap_area_lock);
     
187. 
     
188.         /* insert all vm's */
     
189.         for (area = 0; area < nr_vms; area++)
     
190.                 setup_vmalloc_vm(vms[area], vas[area], VM_ALLOC,
     
191.                                  pcpu_get_vm_areas);
     
192. 
     
193.         kfree(vas);
     
194.         return vms;
     
195. 
     
196. err_free:
     
197.         for (area = 0; area < nr_vms; area++) {
     
198.                 kfree(vas[area]);
     
199.                 kfree(vms[area]);
     
200.         }
     
201. err_free2:
     
202.         kfree(vas);
     
203.         kfree(vms);
     
204.         return NULL;
     
205. }

复制代码

arm-linux-gcc

动态的是一段连续的空间
alloc_percpu的底层实现是用alloc_page
同一个per-CPU变量的各个副本是不连续的

静态的，在编译时只有一份，即在vmlinux中就只有一份。
在内核启动时，会做拷贝，但是对于同一个静态per-CPU的各个副本是不连续的
内核初始化过程中，会将__per_cpu_start ~ __per_cpu_end（所有静态定义的per-CPU变量的编译阶段生产的副本都在这个区域）拷贝到另外一处动态分配到的地方（使用的是bootmem分配器得到的），pcpu_unit_offsets[]中会记录副本之间的地址间隔。
内核最后会释放__per_cpu_start ~ __per_cpu_end这些内存，因为他们是位于__init_begin ~ __init_end的

chishanmingshen

回复 2# arm-linux-gcc

谢谢。
静态比较容易理解，我不理解的是动态的。。

wth0722

動態的話 2F就回答很清楚啦

每個cpu各自擁有phy mem一個連續的空間

至於怎麼要得到一個連續空間就是利用kmalloc

linuxfellow

应该是动态好理解,静态不好理解。静态变量应该只是为每个核规定一些配额,告诉每个核该为多少变量预留空间。初始化时,每个核会根据配额动态分配per-cpu变量内存空间。分配完后,静态变量就被回收了。

chishanmingshen

希望结合pcpu_get_vm_areas这个函数 分析。。。

chishanmingshen

回复 4# wth0722
不是kmalloc！kmalloc的仅仅是管理相关结构体

   

wth0722

回复 7# chishanmingshen

那能請問你覺的是用那個方式要記憶體？


   

chishanmingshen

回复 8# wth0722

1楼中我列出了代码了，只是没看明白

   

Tinnal

回复 1# chishanmingshen

你从哪看出静态和动态PERCPU变量是同一段内存这个结论的？
我看了一个2.6.34.10内核 X86体系的代码。

静态PERCPU是在setup_per_cpu_areas->pcpu_embed_first_chunk 函数里分配的。
面这个函数里面采用alloc_bootmem_nopanic进行内存的分配。这时候正式的内存管理系统还不有起来。

而动态的PERCPU是在函数alloc_pcpu_chunk中vmalloc出来的。

1. 两处都是动态分配的，都不是静态预留的。
2. 一个是bootmem分配器分出来的，属低端内存。一个是vmalloc出来的，属高端内存。


另外，对于你贴出来的函数，别人注释也写得很清楚：
* Returns: kmalloc'd vm_struct pointer array pointing to allocated
*            vm_structs on success, %NULL on failure
*
* Percpu allocator wants to use congruent vm areas so that it can
* maintain the offsets among percpu areas.  This function allocates
* congruent vmalloc areas for it.  These areas tend to be scattered
* pretty far, distance between two areas easily going up to
* gigabytes.  To avoid interacting with regular vmallocs, these areas
* are allocated from top.


晚上看到你这个问题才翻的代码，以前也就直接用alloc_percpu，没有看实现。有什么理解错的，请多多包涵。