linux启动内存分配器2。。。。。。。。。。。。

中关村村草

linux启动内存分配器2。。。。。。。。。。。。

view plaincopy to clipboardprint?void __init setup_bootmem_allocator(void)  
{

1.   
   
2.     int nodeid;  
   
3.     unsigned long bootmap_size, bootmap;  
   
4.     /*
   
5.      * Initialize the boot-time allocator (with low memory only):
   
6.      */  
   
7.      /*计算所需要的映射页面大小一个字节一位，
   
8.      所以需要对总的页面大小除以8*/  
   
9.     bootmap_size = bootmem_bootmap_pages(max_low_pfn)<<PAGE_SHIFT;  
   
10.     /*直接中e820中找到一个大小合适的内存块，返回基址*/  
    
11.     bootmap = find_e820_area(0, max_pfn_mapped<<PAGE_SHIFT, bootmap_size,  
    
12.                  PAGE_SIZE);  
    
13.     if (bootmap == -1L)  
    
14.         panic("Cannot find bootmem map of size %ld\n", bootmap_size);  
    
15.     /*将用于位图映射的页面保留*/  
    
16.     reserve_early(bootmap, bootmap + bootmap_size, "BOOTMAP");  
    
17.   
    
18.     printk(KERN_INFO "  mapped low ram: 0 - %08lx\n",  
    
19.          max_pfn_mapped<<PAGE_SHIFT);  
    
20.     printk(KERN_INFO "  low ram: 0 - %08lx\n", max_low_pfn<<PAGE_SHIFT);  
    
21.     /*对每一个在线的node*/  
    
22.     for_each_online_node(nodeid) {  
    
23.          unsigned long start_pfn, end_pfn;  
    
24.   
    
25. #ifdef CONFIG_NEED_MULTIPLE_NODES/*not set*/   
    
26.         start_pfn = node_start_pfn[nodeid];  
    
27.         end_pfn = node_end_pfn[nodeid];  
    
28.         if (start_pfn > max_low_pfn)  
    
29.             continue;  
    
30.         if (end_pfn > max_low_pfn)  
    
31.             end_pfn = max_low_pfn;  
    
32. #else   
    
33.         start_pfn = 0;  
    
34.         end_pfn = max_low_pfn;  
    
35. #endif   
    
36.         /*对指定节点安装启动分配器*/  
    
37.         bootmap = setup_node_bootmem(nodeid, start_pfn, end_pfn,  
    
38.                          bootmap);  
    
39.     }  
    
40.     /*bootmem的分配制度到这里就已经建立完成，把after_bootmem
    
41.     变量置成1，标识*/  
    
42.     after_bootmem = 1;  
    
43. }  
    
44. void __init setup_bootmem_allocator(void)
    
45. {
    
46.         int nodeid;
    
47.         unsigned long bootmap_size, bootmap;
    
48.         /*
    
49.          * Initialize the boot-time allocator (with low memory only):
    
50.          */
    
51.          /*计算所需要的映射页面大小一个字节一位，
    
52.          所以需要对总的页面大小除以8*/
    
53.         bootmap_size = bootmem_bootmap_pages(max_low_pfn)<<PAGE_SHIFT;
    
54.         /*直接中e820中找到一个大小合适的内存块，返回基址*/
    
55.         bootmap = find_e820_area(0, max_pfn_mapped<<PAGE_SHIFT, bootmap_size,
    
56.                                  PAGE_SIZE);
    
57.         if (bootmap == -1L)
    
58.                 panic("Cannot find bootmem map of size %ld\n", bootmap_size);
    
59.         /*将用于位图映射的页面保留*/
    
60.         reserve_early(bootmap, bootmap + bootmap_size, "BOOTMAP");
    
61. 
    
62.         printk(KERN_INFO "  mapped low ram: 0 - %08lx\n",
    
63.                  max_pfn_mapped<<PAGE_SHIFT);
    
64.         printk(KERN_INFO "  low ram: 0 - %08lx\n", max_low_pfn<<PAGE_SHIFT);
    
65.         /*对每一个在线的node*/
    
66.         for_each_online_node(nodeid) {
    
67.                  unsigned long start_pfn, end_pfn;
    
68. 
    
69. #ifdef CONFIG_NEED_MULTIPLE_NODES/*not set*/
    
70.                 start_pfn = node_start_pfn[nodeid];
    
71.                 end_pfn = node_end_pfn[nodeid];
    
72.                 if (start_pfn > max_low_pfn)
    
73.                         continue;
    
74.                 if (end_pfn > max_low_pfn)
    
75.                         end_pfn = max_low_pfn;
    
76. #else
    
77.                 start_pfn = 0;
    
78.                 end_pfn = max_low_pfn;
    
79. #endif
    
80.                 /*对指定节点安装启动分配器*/
    
81.                 bootmap = setup_node_bootmem(nodeid, start_pfn, end_pfn,
    
82.                                                  bootmap);
    
83.         }
    
84.         /*bootmem的分配制度到这里就已经建立完成，把after_bootmem
    
85.         变量置成1，标识*/
    
86.         after_bootmem = 1;
    
87. }view plaincopy to clipboardprint?static unsigned long __init setup_node_bootmem(int nodeid,  
    
88.                  unsigned long start_pfn,  
    
89.                  unsigned long end_pfn,  
    
90.                  unsigned long bootmap)  
    
91. {  
    
92.     unsigned long bootmap_size;  
    
93.   
    
94.     /* don't touch min_low_pfn */  
    
95.     /*初始化映射位图，将位图中的所有位置1*/  
    
96.     bootmap_size = init_bootmem_node(NODE_DATA(nodeid),  
    
97.                      bootmap >> PAGE_SHIFT,  
    
98.                      start_pfn, end_pfn);  
    
99.     printk(KERN_INFO "  node %d low ram: %08lx - %08lx\n",  
    
100.         nodeid, start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT);  
     
101.     printk(KERN_INFO "  node %d bootmap %08lx - %08lx\n",  
     
102.          nodeid, bootmap, bootmap + bootmap_size);  
     
103.     /*将活动内存区对应位图相关位置0，表示可被分配的*/  
     
104.     free_bootmem_with_active_regions(nodeid, end_pfn);  
     
105.     /*对置保留位的相关页面对应的位图设置为1，表示已经分配
     
106.     或者不可用(不能被分配)*/  
     
107.     early_res_to_bootmem(start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT);  
     
108.     /*返回映射页面的最后地址，下次映射即可以从这里开始*/  
     
109.     return bootmap + bootmap_size;  
     
110. }  
     
111. static unsigned long __init setup_node_bootmem(int nodeid,
     
112.                                  unsigned long start_pfn,
     
113.                                  unsigned long end_pfn,
     
114.                                  unsigned long bootmap)
     
115. {
     
116.         unsigned long bootmap_size;
     
117. 
     
118.         /* don't touch min_low_pfn */
     
119.         /*初始化映射位图，将位图中的所有位置1*/
     
120.         bootmap_size = init_bootmem_node(NODE_DATA(nodeid),
     
121.                                          bootmap >> PAGE_SHIFT,
     
122.                                          start_pfn, end_pfn);
     
123.         printk(KERN_INFO "  node %d low ram: %08lx - %08lx\n",
     
124.                 nodeid, start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT);
     
125.         printk(KERN_INFO "  node %d bootmap %08lx - %08lx\n",
     
126.                  nodeid, bootmap, bootmap + bootmap_size);
     
127.         /*将活动内存区对应位图相关位置0，表示可被分配的*/
     
128.         free_bootmem_with_active_regions(nodeid, end_pfn);
     
129.         /*对置保留位的相关页面对应的位图设置为1，表示已经分配
     
130.         或者不可用(不能被分配)*/
     
131.         early_res_to_bootmem(start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT);
     
132.         /*返回映射页面的最后地址，下次映射即可以从这里开始*/
     
133.         return bootmap + bootmap_size;
     
134. }
     
135. 对于初始化映射位图，最终调用init_bootmem_core()
     
136. 
     
137. 
     
138. view plaincopy to clipboardprint?/*
     
139. * Called once to set up the allocator itself.
     
140. */  
     
141. static unsigned long __init init_bootmem_core(bootmem_data_t *bdata,  
     
142.     unsigned long mapstart, unsigned long start, unsigned long end)  
     
143. {  
     
144.     unsigned long mapsize;  
     
145.   
     
146.     mminit_validate_memmodel_limits(&start, &end);  
     
147.     bdata->node_bootmem_map = phys_to_virt(PFN_PHYS(mapstart));  
     
148.     bdata->node_min_pfn = start;  
     
149.     bdata->node_low_pfn = end;  
     
150.     /*添加bdata变量到链表中*/  
     
151.     link_bootmem(bdata);  
     
152.   
     
153.     /*
     
154.      * Initially all pages are reserved - setup_arch() has to
     
155.      * register free RAM areas explicitly.
     
156.      */  
     
157.      /*计算本bdata的mapsize，也就是内存页面大小的1/8*/  
     
158.     mapsize = bootmap_bytes(end - start);  
     
159.     /*将所有map置1*/  
     
160.     memset(bdata->node_bootmem_map, 0xff, mapsize);  
     
161.   
     
162.     bdebug("nid=%td start=%lx map=%lx end=%lx mapsize=%lx\n",  
     
163.         bdata - bootmem_node_data, start, mapstart, end, mapsize);  
     
164.   
     
165.     return mapsize;  
     
166. }  
     
167. /*
     
168. * Called once to set up the allocator itself.
     
169. */
     
170. static unsigned long __init init_bootmem_core(bootmem_data_t *bdata,
     
171.         unsigned long mapstart, unsigned long start, unsigned long end)
     
172. {
     
173.         unsigned long mapsize;
     
174. 
     
175.         mminit_validate_memmodel_limits(&start, &end);
     
176.         bdata->node_bootmem_map = phys_to_virt(PFN_PHYS(mapstart));
     
177.         bdata->node_min_pfn = start;
     
178.         bdata->node_low_pfn = end;
     
179.         /*添加bdata变量到链表中*/
     
180.         link_bootmem(bdata);
     
181. 
     
182.         /*
     
183.          * Initially all pages are reserved - setup_arch() has to
     
184.          * register free RAM areas explicitly.
     
185.          */
     
186.          /*计算本bdata的mapsize，也就是内存页面大小的1/8*/
     
187.         mapsize = bootmap_bytes(end - start);
     
188.         /*将所有map置1*/
     
189.         memset(bdata->node_bootmem_map, 0xff, mapsize);
     
190. 
     
191.         bdebug("nid=%td start=%lx map=%lx end=%lx mapsize=%lx\n",
     
192.                 bdata - bootmem_node_data, start, mapstart, end, mapsize);
     
193. 
     
194.         return mapsize;
     
195. }
     
196. view plaincopy to clipboardprint?/*
     
197. * link bdata in order
     
198. */  
     
199. /*添加到链表，由添加的代码可知
     
200. 链表中的数据开始位置为递增的*/  
     
201. static void __init link_bootmem(bootmem_data_t *bdata)  
     
202. {  
     
203.     struct list_head *iter;  
     
204.     /*添加到全局链表bdata_list中*/  
     
205.     list_for_each(iter, &bdata_list) {  
     
206.         bootmem_data_t *ent;  
     
207.   
     
208.         ent = list_entry(iter, bootmem_data_t, list);  
     
209.         if (bdata->node_min_pfn < ent->node_min_pfn)  
     
210.             break;  
     
211.     }  
     
212.     list_add_tail(&bdata->list, iter);  
     
213. }  
     
214. /*
     
215. * link bdata in order
     
216. */
     
217. /*添加到链表，由添加的代码可知
     
218. 链表中的数据开始位置为递增的*/
     
219. static void __init link_bootmem(bootmem_data_t *bdata)
     
220. {
     
221.         struct list_head *iter;
     
222.         /*添加到全局链表bdata_list中*/
     
223.         list_for_each(iter, &bdata_list) {
     
224.                 bootmem_data_t *ent;
     
225. 
     
226.                 ent = list_entry(iter, bootmem_data_t, list);
     
227.                 if (bdata->node_min_pfn < ent->node_min_pfn)
     
228.                         break;
     
229.         }
     
230.         list_add_tail(&bdata->list, iter);
     
231. }view plaincopy to clipboardprint?/**
     
232. * free_bootmem_with_active_regions - Call free_bootmem_node for each active range
     
233. * @nid: The node to free memory on. If MAX_NUMNODES, all nodes are freed.
     
234. * @max_low_pfn: The highest PFN that will be passed to free_bootmem_node
     
235. *
     
236. * If an architecture guarantees that all ranges registered with
     
237. * add_active_ranges() contain no holes and may be freed, this
     
238. * this function may be used instead of calling free_bootmem() manually.
     
239. */  
     
240. /*用active_region来初始化bootmem分配器，基于低端内存区*/  
     
241. void __init free_bootmem_with_active_regions(int nid,  
     
242.                         unsigned long max_low_pfn)  
     
243. {  
     
244.     int i;  
     
245.     /*对每个节点上得活动内存区*/  
     
246.     for_each_active_range_index_in_nid(i, nid) {  
     
247.         unsigned long size_pages = 0;  
     
248.         unsigned long end_pfn = early_node_map[i].end_pfn;  
     
249.   
     
250.         if (early_node_map[i].start_pfn >= max_low_pfn)  
     
251.             continue;  
     
252.   
     
253.         if (end_pfn > max_low_pfn)  
     
254.             end_pfn = max_low_pfn;  
     
255.         /*计算活动区的页面数*/  
     
256.         size_pages = end_pfn - early_node_map[i].start_pfn;  
     
257.         /*释放这部分内存，起始就是对应位图值0*/  
     
258.         free_bootmem_node(NODE_DATA(early_node_map[i].nid),  
     
259.                 PFN_PHYS(early_node_map[i].start_pfn),  
     
260.                 size_pages << PAGE_SHIFT);  
     
261.     }  
     
262. }  
     
263. /**
     
264. * free_bootmem_with_active_regions - Call free_bootmem_node for each active range
     
265. * @nid: The node to free memory on. If MAX_NUMNODES, all nodes are freed.
     
266. * @max_low_pfn: The highest PFN that will be passed to free_bootmem_node
     
267. *
     
268. * If an architecture guarantees that all ranges registered with
     
269. * add_active_ranges() contain no holes and may be freed, this
     
270. * this function may be used instead of calling free_bootmem() manually.
     
271. */
     
272. /*用active_region来初始化bootmem分配器，基于低端内存区*/
     
273. void __init free_bootmem_with_active_regions(int nid,
     
274.                                                 unsigned long max_low_pfn)
     
275. {
     
276.         int i;
     
277.         /*对每个节点上得活动内存区*/
     
278.         for_each_active_range_index_in_nid(i, nid) {
     
279.                 unsigned long size_pages = 0;
     
280.                 unsigned long end_pfn = early_node_map[i].end_pfn;
     
281. 
     
282.                 if (early_node_map[i].start_pfn >= max_low_pfn)
     
283.                         continue;
     
284. 
     
285.                 if (end_pfn > max_low_pfn)
     
286.                         end_pfn = max_low_pfn;
     
287.                 /*计算活动区的页面数*/
     
288.                 size_pages = end_pfn - early_node_map[i].start_pfn;
     
289.                 /*释放这部分内存，起始就是对应位图值0*/
     
290.                 free_bootmem_node(NODE_DATA(early_node_map[i].nid),
     
291.                                 PFN_PHYS(early_node_map[i].start_pfn),
     
292.                                 size_pages << PAGE_SHIFT);
     
293.         }
     
294. }view plaincopy to clipboardprint?/**
     
295. * free_bootmem_node - mark a page range as usable
     
296. * @pgdat: node the range resides on
     
297. * @physaddr: starting address of the range
     
298. * @size: size of the range in bytes
     
299. *
     
300. * Partial pages will be considered reserved and left as they are.
     
301. *
     
302. * The range must reside completely on the specified node.
     
303. */  
     
304. void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,  
     
305.                   unsigned long size)  
     
306. {  
     
307.     unsigned long start, end;  
     
308.     /*相关宏进行控制,调试用*/  
     
309.     kmemleak_free_part(__va(physaddr), size);  
     
310.   
     
311.     start = PFN_UP(physaddr);/*取上界*/  
     
312.     end = PFN_DOWN(physaddr + size);/*取下界*/  
     
313.   
     
314.       
     
315.     /*调用此函数对相关bit位清0，表示没有分配，这里保留位为0*/  
     
316.     mark_bootmem_node(pgdat->bdata, start, end, 0, 0);  
     
317. }  
     
318. /**
     
319. * free_bootmem_node - mark a page range as usable
     
320. * @pgdat: node the range resides on
     
321. * @physaddr: starting address of the range
     
322. * @size: size of the range in bytes
     
323. *
     
324. * Partial pages will be considered reserved and left as they are.
     
325. *
     
326. * The range must reside completely on the specified node.
     
327. */
     
328. void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
     
329.                               unsigned long size)
     
330. {
     
331.         unsigned long start, end;
     
332.         /*相关宏进行控制,调试用*/
     
333.         kmemleak_free_part(__va(physaddr), size);
     
334. 
     
335.         start = PFN_UP(physaddr);/*取上界*/
     
336.         end = PFN_DOWN(physaddr + size);/*取下界*/
     
337. 
     
338.        
     
339.         /*调用此函数对相关bit位清0，表示没有分配，这里保留位为0*/
     
340.         mark_bootmem_node(pgdat->bdata, start, end, 0, 0);
     
341. }view plaincopy to clipboardprint?static int __init mark_bootmem_node(bootmem_data_t *bdata,  
     
342.                 unsigned long start, unsigned long end,  
     
343.                 int reserve, int flags)  
     
344. {  
     
345.     unsigned long sidx, eidx;  
     
346.   
     
347.     bdebug("nid=%td start=%lx end=%lx reserve=%d flags=%x\n",  
     
348.         bdata - bootmem_node_data, start, end, reserve, flags);  
     
349.   
     
350.     BUG_ON(start < bdata->node_min_pfn);  
     
351.     BUG_ON(end > bdata->node_low_pfn);  
     
352.     /*此两个变量为到节点最小内存页面的偏移量*/  
     
353.     sidx = start - bdata->node_min_pfn;  
     
354.     eidx = end - bdata->node_min_pfn;  
     
355.   
     
356.     if (reserve)/*如果设置了保留位*/  
     
357.         return __reserve(bdata, sidx, eidx, flags);  
     
358.     else/*相关的map位清0*/  
     
359.         __free(bdata, sidx, eidx);  
     
360.     return 0;  
     
361. }  
     
362. static int __init mark_bootmem_node(bootmem_data_t *bdata,
     
363.                                 unsigned long start, unsigned long end,
     
364.                                 int reserve, int flags)
     
365. {
     
366.         unsigned long sidx, eidx;
     
367. 
     
368.         bdebug("nid=%td start=%lx end=%lx reserve=%d flags=%x\n",
     
369.                 bdata - bootmem_node_data, start, end, reserve, flags);
     
370. 
     
371.         BUG_ON(start < bdata->node_min_pfn);
     
372.         BUG_ON(end > bdata->node_low_pfn);
     
373.         /*此两个变量为到节点最小内存页面的偏移量*/
     
374.         sidx = start - bdata->node_min_pfn;
     
375.         eidx = end - bdata->node_min_pfn;
     
376. 
     
377.         if (reserve)/*如果设置了保留位*/
     
378.                 return __reserve(bdata, sidx, eidx, flags);
     
379.         else/*相关的map位清0*/
     
380.                 __free(bdata, sidx, eidx);
     
381.         return 0;
     
382. }view plaincopy to clipboardprint?/*bootmem分配器的保留操作*/  
     
383. static int __init __reserve(bootmem_data_t *bdata, unsigned long sidx,  
     
384.             unsigned long eidx, int flags)  
     
385. {  
     
386.     unsigned long idx;  
     
387.     int exclusive = flags & BOOTMEM_EXCLUSIVE;  
     
388.   
     
389.     bdebug("nid=%td start=%lx end=%lx flags=%x\n",  
     
390.         bdata - bootmem_node_data,  
     
391.         sidx + bdata->node_min_pfn,  
     
392.         eidx + bdata->node_min_pfn,  
     
393.         flags);  
     
394.     /*对连续的几个页面设置为保留*/  
     
395.     for (idx = sidx; idx < eidx; idx++)  
     
396.         if (test_and_set_bit(idx, bdata->node_bootmem_map)) {  
     
397.             if (exclusive) {  
     
398.                 __free(bdata, sidx, idx);  
     
399.                 return -EBUSY;  
     
400.             }  
     
401.             bdebug("silent double reserve of PFN %lx\n",  
     
402.                 idx + bdata->node_min_pfn);  
     
403.         }  
     
404.     return 0;  
     
405. }  
     
406. /*bootmem分配器的保留操作*/
     
407. static int __init __reserve(bootmem_data_t *bdata, unsigned long sidx,
     
408.                         unsigned long eidx, int flags)
     
409. {
     
410.         unsigned long idx;
     
411.         int exclusive = flags & BOOTMEM_EXCLUSIVE;
     
412. 
     
413.         bdebug("nid=%td start=%lx end=%lx flags=%x\n",
     
414.                 bdata - bootmem_node_data,
     
415.                 sidx + bdata->node_min_pfn,
     
416.                 eidx + bdata->node_min_pfn,
     
417.                 flags);
     
418.         /*对连续的几个页面设置为保留*/
     
419.         for (idx = sidx; idx < eidx; idx++)
     
420.                 if (test_and_set_bit(idx, bdata->node_bootmem_map)) {
     
421.                         if (exclusive) {
     
422.                                 __free(bdata, sidx, idx);
     
423.                                 return -EBUSY;
     
424.                         }
     
425.                         bdebug("silent double reserve of PFN %lx\n",
     
426.                                 idx + bdata->node_min_pfn);
     
427.                 }
     
428.         return 0;
     
429. }view plaincopy to clipboardprint?/*bootmem分配器中释放内存*/  
     
430. static void __init __free(bootmem_data_t *bdata,  
     
431.             unsigned long sidx, unsigned long eidx)  
     
432. {  
     
433.     unsigned long idx;  
     
434.   
     
435.     bdebug("nid=%td start=%lx end=%lx\n", bdata - bootmem_node_data,  
     
436.         sidx + bdata->node_min_pfn,  
     
437.         eidx + bdata->node_min_pfn);  
     
438.   
     
439.     if (bdata->hint_idx > sidx)  
     
440.         bdata->hint_idx = sidx;/*更新变量hint_idx，用于分配*/  
     
441.   
     
442.     for (idx = sidx; idx < eidx; idx++)/*对应位清0*/  
     
443.         if (!test_and_clear_bit(idx, bdata->node_bootmem_map))  
     
444.             BUG();  
     
445. }  
     
446. /*bootmem分配器中释放内存*/
     
447. static void __init __free(bootmem_data_t *bdata,
     
448.                         unsigned long sidx, unsigned long eidx)
     
449. {
     
450.         unsigned long idx;
     
451. 
     
452.         bdebug("nid=%td start=%lx end=%lx\n", bdata - bootmem_node_data,
     
453.                 sidx + bdata->node_min_pfn,
     
454.                 eidx + bdata->node_min_pfn);
     
455. 
     
456.         if (bdata->hint_idx > sidx)
     
457.                 bdata->hint_idx = sidx;/*更新变量hint_idx，用于分配*/
     
458. 
     
459.         for (idx = sidx; idx < eidx; idx++)/*对应位清0*/
     
460.                 if (!test_and_clear_bit(idx, bdata->node_bootmem_map))
     
461.                         BUG();
     
462. }view plaincopy to clipboardprint?void __init early_res_to_bootmem(u64 start, u64 end)  
     
463. {  
     
464.     int i, count;  
     
465.     u64 final_start, final_end;  
     
466.   
     
467.     count  = 0;  
     
468.     for (i = 0; i < MAX_EARLY_RES && early_res[i].end; i++)  
     
469.         count++;/*计算保留块的个数*/  
     
470.   
     
471.     printk(KERN_INFO "(%d early reservations) ==> bootmem [%010llx - %010llx]\n",  
     
472.              count, start, end);  
     
473.     for (i = 0; i < count; i++) {  
     
474.         struct early_res *r = &early_res[i];  
     
475.         printk(KERN_INFO "  #%d [%010llx - %010llx] %16s", i,  
     
476.             r->start, r->end, r->name);  
     
477.         final_start = max(start, r->start);  
     
478.         final_end = min(end, r->end);  
     
479.         if (final_start >= final_end) {  
     
480.             printk(KERN_CONT "\n");  
     
481.             continue;  
     
482.         }  
     
483.         printk(KERN_CONT " ==> [%010llx - %010llx]\n",  
     
484.             final_start, final_end);  
     
485.         /*将指定区间置为保留*/  
     
486.         reserve_bootmem_generic(final_start, final_end - final_start,  
     
487.                 BOOTMEM_DEFAULT);  
     
488.     }  
     
489. }  
     
490. void __init early_res_to_bootmem(u64 start, u64 end)
     
491. {
     
492.         int i, count;
     
493.         u64 final_start, final_end;
     
494. 
     
495.         count  = 0;
     
496.         for (i = 0; i < MAX_EARLY_RES && early_res[i].end; i++)
     
497.                 count++;/*计算保留块的个数*/
     
498. 
     
499.         printk(KERN_INFO "(%d early reservations) ==> bootmem [%010llx - %010llx]\n",
     
500.                          count, start, end);
     
501.         for (i = 0; i < count; i++) {
     
502.                 struct early_res *r = &early_res[i];
     
503.                 printk(KERN_INFO "  #%d [%010llx - %010llx] %16s", i,
     
504.                         r->start, r->end, r->name);
     
505.                 final_start = max(start, r->start);
     
506.                 final_end = min(end, r->end);
     
507.                 if (final_start >= final_end) {
     
508.                         printk(KERN_CONT "\n");
     
509.                         continue;
     
510.                 }
     
511.                 printk(KERN_CONT " ==> [%010llx - %010llx]\n",
     
512.                         final_start, final_end);
     
513.                 /*将指定区间置为保留*/
     
514.                 reserve_bootmem_generic(final_start, final_end - final_start,
     
515.                                 BOOTMEM_DEFAULT);
     
516.         }
     
517. }

复制代码

上面的保留指定区间reserve_bootmem_generic()函数最终调用如下函数


]

第一夫人

谢谢分享