bootmem是内核启动时使用的物理内存分配器，根据e820map中的可用内存来初始化bootmem可用内存；
bootmem启动之前分配的内存放入early_res预留内存区间中，初始化bootmem时将已经分配出去的内存在bootmem系统中标识为已分配
bootmem管理的是页帧，而e820map和early_res管理的是区间
e820map注册进bootmem时会对区间做页对齐操作；区间起始地址roundup，区间终止地址rounddown，见e820_register_active_regions
early_res注入bootmem时会对区间做页对齐操作；区间起始地址rounddown，区间终止地址roundup，见early_res_to_bootmem->reserve_bootmem_generic->reserve_bootmem->reserve_bootmem
mm/bootmem.c:
1 /*
2 * bootmem - A boot-time physical memory allocator and configurator
3 *
4 * Copyright (C) 1999 Ingo Molnar
5 * 1999 Kanoj Sarcar, SGI
6 * 2008 Johannes Weiner
7 *
8 * Access to this subsystem has to be serialized externally (which is true
9 * for the boot process anyway).
10 */
I、bootmem数据结构
include/linux/bootmem.h:
26 /*
27 * node_bootmem_map is a map pointer - the bits represent all physical
28 * memory pages (including holes) on the node.
29 */
30 typedef struct bootmem_data {
31 unsigned long node_min_pfn;
32 unsigned long node_low_pfn;
33 void *node_bootmem_map;
34 unsigned long last_end_off;
35 unsigned long hint_idx;
36 struct list_head list;
37 } bootmem_data_t;
mm/bootmem.c:
35 bootmem_data_t bootmem_node_data[MAX_NUMNODES] __initdata;
36
37 static struct list_head bdata_list __initdata = LIST_HEAD_INIT(bdata_list);
bootmem_node_data通过list组成链表，链表头为bdata_list；每个NUMA的node一个对应一个链表节点。x86使用UMA内存模型，则只有一个节点。
node_min_pfn:起始页
node_low_pfn:终止页
node_bootmem_map:页帧位图
last_end_off：上次分配内存在最后一页的页偏移
hint_idx：分配内存起始位置索引，分配内存时从第hint_idx开始查找空闲位图块；如果没找到才从头开始查找
list：组成链表
bootmem使用位图表示页帧的使用情况，bit-1表示保留(不可用)内存，bit-0表示可用内存
bdata_list是按node_min_pfn大小递增的有序链表
II、bootmem启动
1.节点bootmem初始化
bootmem初始化时将位图所有位置1，表示所有的页都已经保留；由setup_arch显示的清空来表示可用内存，如setup_arch->initmem_init->setup_bootmem_allocator->setup_node_bootmem->free_bootmem_with_active_regions将可用内存页帧位置0
90 /*
91 * Called once to set up the allocator itself.
92 */
93 static unsigned long __init init_bootmem_core(bootmem_data_t *bdata,
94 unsigned long mapstart, unsigned long start, unsigned long end)
95 {
96 unsigned long mapsize;
97
98 mminit_validate_memmodel_limits(&start, &end);
99 bdata->node_bootmem_map = phys_to_virt(PFN_PHYS(mapstart));
100 bdata->node_min_pfn = start;
101 bdata->node_low_pfn = end;
102 link_bootmem(bdata);
103
104 /*
105 * Initially all pages are reserved - setup_arch() has to
106 * register free RAM areas explicitly.
107 */
108 mapsize = bootmap_bytes(end - start);
109 memset(bdata->node_bootmem_map, 0xff, mapsize);
110
111 bdebug("nid=%td start=%lx map=%lx end=%lx mapsize=%lx\n",
112 bdata - bootmem_node_data, start, mapstart, end, mapsize);
113
114 return mapsize;
115 }
116
117 /**
118 * init_bootmem_node - register a node as boot memory
119 * @pgdat: node to register
120 * @freepfn: pfn where the bitmap for this node is to be placed
121 * @startpfn: first pfn on the node
122 * @endpfn: first pfn after the node
123 *
124 * Returns the number of bytes needed to hold the bitmap for this node.
125 */
126 unsigned long __init init_bootmem_node(pg_data_t *pgdat, unsigned long freepfn,
127 unsigned long startpfn, unsigned long endpfn)
128 {
129 return init_bootmem_core(pgdat->bdata, freepfn, startpfn, endpfn);
130 }
2.e820map可用内存注入到bootmem中
当节点bootmem初始化完成后，所有页帧标识为已用；将e820map中可用内存注入到bootmem中；e820map先放入active_regions，再从active_regions注入到bootmem中
a.e820map->active_regions
setup_arch->initmem_init->e820_register_active_regions
1154 /*
1155 * Finds an active region in the address range from start_pfn to last_pfn and
1156 * returns its range in ei_startpfn and ei_endpfn for the e820 entry.
1157 */
1158 int __init e820_find_active_region(const struct e820entry *ei,
1159 unsigned long start_pfn,
1160 unsigned long last_pfn,
1161 unsigned long *ei_startpfn,
1162 unsigned long *ei_endpfn)
1163 {
1164 u64 align = PAGE_SIZE;
1165
1166 *ei_startpfn = round_up(ei->addr, align) >> PAGE_SHIFT;
1167 *ei_endpfn = round_down(ei->addr + ei->size, align) >> PAGE_SHIFT;
1168
1169 /* Skip map entries smaller than a page */
1170 if (*ei_startpfn >= *ei_endpfn)
1171 return 0;
1172
1173 /* Skip if map is outside the node */
1174 if (ei->type != E820_RAM || *ei_endpfn <= start_pfn ||
1175 *ei_startpfn >= last_pfn)
1176 return 0;
1177
1178 /* Check for overlaps */
1179 if (*ei_startpfn < start_pfn)
1180 *ei_startpfn = start_pfn;
1181 if (*ei_endpfn > last_pfn)
1182 *ei_endpfn = last_pfn;
1183
1184 return 1;
1185 }
1186
1187 /* Walk the e820 map and register active regions within a node */
1188 void __init e820_register_active_regions(int nid, unsigned long start_pfn,
1189 unsigned long last_pfn)
1190 {
1191 unsigned long ei_startpfn;
1192 unsigned long ei_endpfn;
1193 int i;
1194
1195 for (i = 0; i < e820.nr_map; i++)
1196 if (e820_find_active_region(&e820.map[i],
1197 start_pfn, last_pfn,
1198 &ei_startpfn, &ei_endpfn))
1199 add_active_range(nid, ei_startpfn, ei_endpfn);
b.active_regions->bootmem
setup_arch->initmem_init->setup_bootmem_allocator->setup_node_bootmem->free_bootmem_with_active_regions
3410 /**
3411 * free_bootmem_with_active_regions - Call free_bootmem_node for each active range
3412 * @nid: The node to free memory on. If MAX_NUMNODES, all nodes are freed.
3413 * @max_low_pfn: The highest PFN that will be passed to free_bootmem_node
3414 *
3415 * If an architecture guarantees that all ranges registered with
3416 * add_active_ranges() contain no holes and may be freed, this
3417 * this function may be used instead of calling free_bootmem() manually.
3418 */
3419 void __init free_bootmem_with_active_regions(int nid,
3420 unsigned long max_low_pfn)
3421 {
3422 int i;
3423
3424 for_each_active_range_index_in_nid(i, nid) {
3425 unsigned long size_pages = 0;
3426 unsigned long end_pfn = early_node_map[i].end_pfn;
3427
3428 if (early_node_map[i].start_pfn >= max_low_pfn)
3429 continue;
3430
3431 if (end_pfn > max_low_pfn)
3432 end_pfn = max_low_pfn;
3433
3434 size_pages = end_pfn - early_node_map[i].start_pfn;
3435 free_bootmem_node(NODE_DATA(early_node_map[i].nid),
3436 PFN_PHYS(early_node_map[i].start_pfn),
3437 size_pages << PAGE_SHIFT);
3438 }
3439 }}
3.early_res预留内存注入到bootmem中
将bootmem启动之前分配的内存放入early_res中，bootmem初始化时将预留的内存在bootmem中标识为1，表示已经分配。
setup_arch->initmem_init->setup_bootmem_allocator->setup_node_bootmem->early_res_to_bootmemarch/x86/kernel/e820.c:
917 void __init early_res_to_bootmem(u64 start, u64 end)
918 {
919 int i, count;
920 u64 final_start, final_end;
921
922 count = 0;
923 for (i = 0; i < MAX_EARLY_RES && early_res[i].end; i++)
924 count++;
925
926 printk(KERN_INFO "(%d early reservations) ==> bootmem [%010llx - %010llx]\n",
927 count, start, end);
928 for (i = 0; i < count; i++) {
929 struct early_res *r = &early_res[i];
930 printk(KERN_INFO " #%d [%010llx - %010llx] %16s", i,
931 r->start, r->end, r->name);
932 final_start = max(start, r->start);
933 final_end = min(end, r->end);
934 if (final_start >= final_end) {
935 printk(KERN_CONT "\n");
936 continue;
937 }
938 printk(KERN_CONT " ==> [%010llx - %010llx]\n",
939 final_start, final_end);
940 reserve_bootmem_generic(final_start, final_end - final_start,
941 BOOTMEM_DEFAULT);
942 }
943 }
III、bootmem内存分配
1、alloc_bootmem_core是核心bootmem分配内存函数；alloc_bootmem、alloc_bootmem_pages、alloc_bootmem_node等都是对他的封装
434 static void * __init alloc_bootmem_core(struct bootmem_data *bdata,
435 unsigned long size, unsigned long align,
436 unsigned long goal, unsigned long limit)
437 {
438 unsigned long fallback = 0;
439 unsigned long min, max, start, sidx, midx, step;
440
441 bdebug("nid=%td size=%lx [%lu pages] align=%lx goal=%lx limit=%lx\n",
442 bdata - bootmem_node_data, size, PAGE_ALIGN(size) >> PAGE_SHIFT,
443 align, goal, limit);
444
445 BUG_ON(!size);
446 BUG_ON(align & (align - 1));
447 BUG_ON(limit && goal + size > limit);
448
449 if (!bdata->node_bootmem_map)
450 return NULL;
451
452 min = bdata->node_min_pfn;
453 max = bdata->node_low_pfn;
454
455 goal >>= PAGE_SHIFT;
456 limit >>= PAGE_SHIFT;
457
458 if (limit && max > limit)
459 max = limit;
460 if (max <= min)
461 return NULL;
462
463 step = max(align >> PAGE_SHIFT, 1UL);
464
465 if (goal && min < goal && goal < max)
466 start = ALIGN(goal, step);
467 else
468 start = ALIGN(min, step);
469
470 sidx = start - bdata->node_min_pfn;
471 midx = max - bdata->node_min_pfn;
472
473 if (bdata->hint_idx > sidx) {
474 /*
475 * Handle the valid case of sidx being zero and still
476 * catch the fallback below.
477 */
478 fallback = sidx + 1;
479 sidx = align_idx(bdata, bdata->hint_idx, step);
480 }
481
482 while (1) {
483 int merge;
484 void *region;
485 unsigned long eidx, i, start_off, end_off;
486 find_block:
487 sidx = find_next_zero_bit(bdata->node_bootmem_map, midx, sidx);
488 sidx = align_idx(bdata, sidx, step);
489 eidx = sidx + PFN_UP(size);
490
491 if (sidx >= midx || eidx > midx)
492 break;
493
494 for (i = sidx; i < eidx; i++)
495 if (test_bit(i, bdata->node_bootmem_map)) {
496 sidx = align_idx(bdata, i, step);
497 if (sidx == i)
498 sidx += step;
499 goto find_block;
500 }
501
502 if (bdata->last_end_off & (PAGE_SIZE - 1) &&
503 PFN_DOWN(bdata->last_end_off) + 1 == sidx)
504 start_off = align_off(bdata, bdata->last_end_off, align);
505 else
506 start_off = PFN_PHYS(sidx);
507
508 merge = PFN_DOWN(start_off) < sidx;
509 end_off = start_off + size;
510
511 bdata->last_end_off = end_off;
512 bdata->hint_idx = PFN_UP(end_off);
513
514 /*
515 * Reserve the area now:
516 */
517 if (__reserve(bdata, PFN_DOWN(start_off) + merge,
518 PFN_UP(end_off), BOOTMEM_EXCLUSIVE))
519 BUG();
520
521 region = phys_to_virt(PFN_PHYS(bdata->node_min_pfn) +
522 start_off);
523 memset(region, 0, size);
524 /*
525 * The min_count is set to 0 so that bootmem allocated blocks
526 * are never reported as leaks.
527 */
528 kmemleak_alloc(region, size, 0, 0);
529 return region;
530 }
531
532 if (fallback) {
533 sidx = align_idx(bdata, fallback - 1, step);
534 fallback = 0;
535 goto find_block;
536 }
537
538 return NULL;
539 }
a、首先从hint_idx开始查找空闲内存块，如果没有找到从头开始（goal与node_min_pfn的较大值）
b、查找PFN_UP(size)个连续空闲的页帧；没找到后移PFN_UP(size)继续查找。
c、如果last_end_off在查找到空闲内存块的上一页内，则返回地址从last_end_off(align对齐后)开始；否则返回地址为空闲块起始页地址
d、保留页帧
e、申请内存块清空为全0
IV、bootmem内存回收
347 /**
348 * free_bootmem - mark a page range as usable
349 * @addr: starting address of the range
350 * @size: size of the range in bytes
351 *
352 * Partial pages will be considered reserved and left as they are.
353 *
354 * The range must be contiguous but may span node boundaries.
355 */
356 void __init free_bootmem(unsigned long addr, unsigned long size)
357 {
358 unsigned long start, end;
359
360 kmemleak_free_part(__va(addr), size);
361
362 start = PFN_UP(addr);
363 end = PFN_DOWN(addr + size);
364
365 mark_bootmem(start, end, 0, 0);
366 }
将起始地址向上页对齐，终止地址向下页对齐后，将这些页帧标为可用，将页帧释放
V、bootmem销毁
在伙伴系统启动后，将bootmem中的空闲内存释放到buddy系统中；在buddy系统启用后不再使用bootmem
146 static unsigned long __init free_all_bootmem_core(bootmem_data_t *bdata)
147 {
148 int aligned;
149 struct page *page;
150 unsigned long start, end, pages, count = 0;
151
152 if (!bdata->node_bootmem_map)
153 return 0;
154
155 start = bdata->node_min_pfn;
156 end = bdata->node_low_pfn;
157
158 /*
159 * If the start is aligned to the machines wordsize, we might
160 * be able to free pages in bulks of that order.
161 */
162 aligned = !(start & (BITS_PER_LONG - 1));
163
164 bdebug("nid=%td start=%lx end=%lx aligned=%d\n",
165 bdata - bootmem_node_data, start, end, aligned);
166
167 while (start < end) {
168 unsigned long *map, idx, vec;
169
170 map = bdata->node_bootmem_map;
171 idx = start - bdata->node_min_pfn;
172 vec = ~map[idx / BITS_PER_LONG];
173
174 if (aligned && vec == ~0UL && start + BITS_PER_LONG < end) {
175 int order = ilog2(BITS_PER_LONG);
176
177 __free_pages_bootmem(pfn_to_page(start), order);
178 count += BITS_PER_LONG;
179 } else {
180 unsigned long off = 0;
181
182 while (vec && off < BITS_PER_LONG) {
183 if (vec & 1) {
184 page = pfn_to_page(start + off);
185 __free_pages_bootmem(page, 0);
186 count++;
187 }
188 vec >>= 1;
189 off++;
190 }
191 }
192 start += BITS_PER_LONG;
193 }
194
195 page = virt_to_page(bdata->node_bootmem_map);
196 pages = bdata->node_low_pfn - bdata->node_min_pfn;
197 pages = bootmem_bootmap_pages(pages);
198 count += pages;
199 while (pages--)
200 __free_pages_bootmem(page++, 0);
201
202 bdebug("nid=%td released=%lx\n", bdata - bootmem_node_data, count);
203
204 return count;
205 }
219 /**
220 * free_all_bootmem - release free pages to the buddy allocator
221 *
222 * Returns the number of pages actually released.
223 */
224 unsigned long __init free_all_bootmem(void)
225 {
226 return free_all_bootmem_core(NODE_DATA(0)->bdata);
227 }1.将bootmem中的空闲内存释放到buddy系统中；如果bootmem起始页是字对齐的，则按批量方式注入到buddy系统，否则一页一页的注入到buddy系统
2.将bootmem用于标识内存使用情况的位图内存释放到buddy系统中
扫一扫
860
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
