linux启动内存分配器
linux启动内存分配器
linux启动内存分配器是在伙伴系统、slab机制实现之前，为满足内核中内存的分配而建立的。本身的机制比较简单，使用位图来进行标志分配和释放。
一、数据结构介绍
1，保留区间
因为在建立启动内存分配器的时候，会涉及保留内存。也就是说，之前保留给页表、分配器本身（用于映射的位图）、io等得内存在分配器建立后，当用它来分配内存空间时，保留出来的那些部分就不能再分配了。linux中对保留内存空间的部分用下列数据结构表示
view plaincopy to clipboard01./*
02. * Early reserved memory areas.
03. */
04.#define MAX_EARLY_RES 20/*保留空间最大块数*/
05.
06.struct early_res {/*保留空间结构*/
07. u64 start, end;
08. char name;
09. char overlap_ok;
10.};
11./*保留内存空间全局变量*/
12.static struct early_res early_res __initdata = {
13. { 0, PAGE_SIZE, "BIOS data page" }, /* BIOS data page */
14. {}
15.};
2，bootmem分配器 view plaincopy to clipboard01./*
02. * node_bootmem_map is a map pointer - the bits represent all physical
03. * memory pages (including holes) on the node.
04. */
05. /*用于bootmem分配器的节点数据结构*/
06.typedef struct bootmem_data {
07. unsigned long node_min_pfn;/*存放bootmem位图的第一个页面（即内核映象结束处的第一个页面）。*/
08. unsigned long node_low_pfn;/*物理内存的顶点，最高不超过896MB。*/
09. void *node_bootmem_map;
10. unsigned long last_end_off;/*用来存放在前一次分配中所分配的最后一个字节相对于last_pos的位移量*/
11. unsigned long hint_idx;/*存放前一次分配的最后一个页面号*/
12. struct list_head list;
13.} bootmem_data_t; 全局链表
view plaincopy to clipboard01.static struct list_head bdata_list __initdata = LIST_HEAD_INIT(bdata_list);二、启动分配器的建立
启动分配器的建立主要的流程为初始化映射位图、活动内存区的映射位置0（表示可用）、保留内存区域处理，其中保留区存放在上面介绍的全局数组中，这里只是将分配器中对应映射位图值1，表示已经分配。
下面我们看内核中具体的初始化流程。start_kernel()->setup_arch()->initmem_init()view plaincopy to clipboard01.void __init setup_arch(char **cmdline_p)
02.{
03. .......
04.<span style="white-space: pre; "> </span>/*此函数在开始对bootmem分配制度建立做些准备工作
05. 然后调用相关函数建立bootmem分配制度*/
06. initmem_init(0, max_pfn);
07. .......
08.} view plaincopy to clipboard01.<span style="font-family: Arial, Verdana, sans-serif; "><span style="white-space: normal; "></span></span>view plaincopy to clipboard01.<span style="font-family: Arial, Verdana, sans-serif; "><span style="white-space: normal; "></span></span><pre name="code" class="cpp">void __init initmem_init(unsigned long start_pfn,
02. unsigned long end_pfn)
03.{
04.#ifdef CONFIG_HIGHMEM
05. highstart_pfn = highend_pfn = max_pfn;
06. if (max_pfn > max_low_pfn)
07. highstart_pfn = max_low_pfn;
08. /*将活动内存放到early_node_map中,前面已经分析过了*/
09. e820_register_active_regions(0, 0, highend_pfn);
10. /*设置上面变量中的内存为当前，在这里没有
11. 设置相关的宏*/
12. sparse_memory_present_with_active_regions(0);
13. printk(KERN_NOTICE "%ldMB HIGHMEM available.\n",
14. pages_to_mb(highend_pfn - highstart_pfn));
15. num_physpages = highend_pfn;
16. /*高端内存开始地址物理*/
17. high_memory = (void *) __va(highstart_pfn * PAGE_SIZE - 1) + 1;
18.#else
19. e820_register_active_regions(0, 0, max_low_pfn);
20. sparse_memory_present_with_active_regions(0);
21. num_physpages = max_low_pfn;
22. high_memory = (void *) __va(max_low_pfn * PAGE_SIZE - 1) + 1;
23.#endif
24.#ifdef CONFIG_FLATMEM
25. max_mapnr = num_physpages;
26.#endif
27. __vmalloc_start_set = true;
28.
29. printk(KERN_NOTICE "%ldMB LOWMEM available.\n",
30. pages_to_mb(max_low_pfn));
31. /*安装bootmem分配器，此分配器在伙伴系统起来之前
32. 用来进行承担内存的分配等管理*/
33. setup_bootmem_allocator();
34.}view plaincopy to clipboard01.void __init setup_bootmem_allocator(void)
02.{
03. int nodeid;
04. unsigned long bootmap_size, bootmap;
05. /*
06. * Initialize the boot-time allocator (with low memory only):
07. */
08. /*计算所需要的映射页面大小一个字节一位，
09. 所以需要对总的页面大小除以8*/
10. bootmap_size = bootmem_bootmap_pages(max_low_pfn)<<PAGE_SHIFT;
11. /*直接中e820中找到一个大小合适的内存块，返回基址*/
12. bootmap = find_e820_area(0, max_pfn_mapped<<PAGE_SHIFT, bootmap_size,
13. PAGE_SIZE);
14. if (bootmap == -1L)
15. panic("Cannot find bootmem map of size %ld\n", bootmap_size);
16. /*将用于位图映射的页面保留*/
17. reserve_early(bootmap, bootmap + bootmap_size, "BOOTMAP");
18.
19. printk(KERN_INFO "mapped low ram: 0 - %08lx\n",
20. max_pfn_mapped<<PAGE_SHIFT);
21. printk(KERN_INFO "low ram: 0 - %08lx\n", max_low_pfn<<PAGE_SHIFT);
22. /*对每一个在线的node*/
23. for_each_online_node(nodeid) {
24. unsigned long start_pfn, end_pfn;
25.
26.#ifdef CONFIG_NEED_MULTIPLE_NODES/*not set*/
27. start_pfn = node_start_pfn;
28. end_pfn = node_end_pfn;
29. if (start_pfn > max_low_pfn)
30. continue;
31. if (end_pfn > max_low_pfn)
32. end_pfn = max_low_pfn;
33.#else
34. start_pfn = 0;
35. end_pfn = max_low_pfn;
36.#endif
37. /*对指定节点安装启动分配器*/
38. bootmap = setup_node_bootmem(nodeid, start_pfn, end_pfn,
39. bootmap);
40. }
41. /*bootmem的分配制度到这里就已经建立完成，把after_bootmem
42. 变量置成1，标识*/
43. after_bootmem = 1;
44.}view plaincopy to clipboard01.static unsigned long __init setup_node_bootmem(int nodeid,
02. unsigned long start_pfn,
03. unsigned long end_pfn,
04. unsigned long bootmap)
05.{
06. unsigned long bootmap_size;
07.
08. /* don't touch min_low_pfn */
09. /*初始化映射位图，将位图中的所有位置1*/
10. bootmap_size = init_bootmem_node(NODE_DATA(nodeid),
11. bootmap >> PAGE_SHIFT,
12. start_pfn, end_pfn);
13. printk(KERN_INFO "node %d low ram: %08lx - %08lx\n",
14. nodeid, start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT);
15. printk(KERN_INFO "node %d bootmap %08lx - %08lx\n",
16. nodeid, bootmap, bootmap + bootmap_size);
17. /*将活动内存区对应位图相关位置0，表示可被分配的*/
18. free_bootmem_with_active_regions(nodeid, end_pfn);
19. /*对置保留位的相关页面对应的位图设置为1，表示已经分配
20. 或者不可用(不能被分配)*/
21. early_res_to_bootmem(start_pfn<<PAGE_SHIFT, end_pfn<<PAGE_SHIFT);
22. /*返回映射页面的最后地址，下次映射即可以从这里开始*/
23. return bootmap + bootmap_size;
24.}对于初始化映射位图，最终调用init_bootmem_core()
view plaincopy to clipboard01./*
02. * Called once to set up the allocator itself.
03. */
04.static unsigned long __init init_bootmem_core(bootmem_data_t *bdata,
05. unsigned long mapstart, unsigned long start, unsigned long end)
06.{
07. unsigned long mapsize;
08.
09. mminit_validate_memmodel_limits(&start, &end);
10. bdata->node_bootmem_map = phys_to_virt(PFN_PHYS(mapstart));
11. bdata->node_min_pfn = start;
12. bdata->node_low_pfn = end;
13. /*添加bdata变量到链表中*/
14. link_bootmem(bdata);
15.
16. /*
17. * Initially all pages are reserved - setup_arch() has to
18. * register free RAM areas explicitly.
19. */
20. /*计算本bdata的mapsize，也就是内存页面大小的1/8*/
21. mapsize = bootmap_bytes(end - start);
22. /*将所有map置1*/
23. memset(bdata->node_bootmem_map, 0xff, mapsize);
24.
25. bdebug("nid=%td start=%lx map=%lx end=%lx mapsize=%lx\n",
26. bdata - bootmem_node_data, start, mapstart, end, mapsize);
27.
28. return mapsize;
29.}view plaincopy to clipboard01./*
02. * link bdata in order
03. */
04. /*添加到链表，由添加的代码可知
05. 链表中的数据开始位置为递增的*/
06.static void __init link_bootmem(bootmem_data_t *bdata)
07.{
08. struct list_head *iter;
09. /*添加到全局链表bdata_list中*/
10. list_for_each(iter, &bdata_list) {
11. bootmem_data_t *ent;
12.
13. ent = list_entry(iter, bootmem_data_t, list);
14. if (bdata->node_min_pfn < ent->node_min_pfn)
15. break;
16. }
17. list_add_tail(&bdata->list, iter);
18.}view plaincopy to clipboard01./**
02. * free_bootmem_with_active_regions - Call free_bootmem_node for each active range
03. * @nid: The node to free memory on. If MAX_NUMNODES, all nodes are freed.
04. * @max_low_pfn: The highest PFN that will be passed to free_bootmem_node
05. *
06. * If an architecture guarantees that all ranges registered with
07. * add_active_ranges() contain no holes and may be freed, this
08. * this function may be used instead of calling free_bootmem() manually.
09. */
10. /*用active_region来初始化bootmem分配器，基于低端内存区*/
11.void __init free_bootmem_with_active_regions(int nid,
12. unsigned long max_low_pfn)
13.{
14. int i;
15. /*对每个节点上得活动内存区*/
16. for_each_active_range_index_in_nid(i, nid) {
17. unsigned long size_pages = 0;
18. unsigned long end_pfn = early_node_map.end_pfn;
19.
20. if (early_node_map.start_pfn >= max_low_pfn)
21. continue;
22.
23. if (end_pfn > max_low_pfn)
24. end_pfn = max_low_pfn;
25. /*计算活动区的页面数*/
26. size_pages = end_pfn - early_node_map.start_pfn;
27. /*释放这部分内存，起始就是对应位图值0*/
28. free_bootmem_node(NODE_DATA(early_node_map.nid),
29. PFN_PHYS(early_node_map.start_pfn),
30. size_pages << PAGE_SHIFT);
31. }
32.}view plaincopy to clipboard01./**
02. * free_bootmem_node - mark a page range as usable
03. * @pgdat: node the range resides on
04. * @physaddr: starting address of the range
05. * @size: size of the range in bytes
06. *
07. * Partial pages will be considered reserved and left as they are.
08. *
09. * The range must reside completely on the specified node.
10. */
11.void __init free_bootmem_node(pg_data_t *pgdat, unsigned long physaddr,
12. unsigned long size)
13.{
14. unsigned long start, end;
15. /*相关宏进行控制,调试用*/
16. kmemleak_free_part(__va(physaddr), size);
17.
18. start = PFN_UP(physaddr);/*取上界*/
19. end = PFN_DOWN(physaddr + size);/*取下界*/
20.
21.
22. /*调用此函数对相关bit位清0，表示没有分配，这里保留位为0*/
23. mark_bootmem_node(pgdat->bdata, start, end, 0, 0);
24.}
view plaincopy to clipboard01.static int __init mark_bootmem_node(bootmem_data_t *bdata,
02. unsigned long start, unsigned long end,
03. int reserve, int flags)
04.{
05. unsigned long sidx, eidx;
06.
07. bdebug("nid=%td start=%lx end=%lx reserve=%d flags=%x\n",
08. bdata - bootmem_node_data, start, end, reserve, flags);
09.
10. BUG_ON(start < bdata->node_min_pfn);
11. BUG_ON(end > bdata->node_low_pfn);
12. /*此两个变量为到节点最小内存页面的偏移量*/
13. sidx = start - bdata->node_min_pfn;
14. eidx = end - bdata->node_min_pfn;
15.
16. if (reserve)/*如果设置了保留位*/
17. return __reserve(bdata, sidx, eidx, flags);
18. else/*相关的map位清0*/
19. __free(bdata, sidx, eidx);
20. return 0;
21.}view plaincopy to clipboard01./*bootmem分配器的保留操作*/
02.static int __init __reserve(bootmem_data_t *bdata, unsigned long sidx,
03. unsigned long eidx, int flags)
04.{
05. unsigned long idx;
06. int exclusive = flags & BOOTMEM_EXCLUSIVE;
07.
08. bdebug("nid=%td start=%lx end=%lx flags=%x\n",
09. bdata - bootmem_node_data,
10. sidx + bdata->node_min_pfn,
11. eidx + bdata->node_min_pfn,
12. flags);
13. /*对连续的几个页面设置为保留*/
14. for (idx = sidx; idx < eidx; idx++)
15. if (test_and_set_bit(idx, bdata->node_bootmem_map)) {
16. if (exclusive) {
17. __free(bdata, sidx, idx);
18. return -EBUSY;
19. }
20. bdebug("silent double reserve of PFN %lx\n",
21. idx + bdata->node_min_pfn);
22. }
23. return 0;
24.}view plaincopy to clipboard01./*bootmem分配器中释放内存*/
02.static void __init __free(bootmem_data_t *bdata,
03. unsigned long sidx, unsigned long eidx)
04.{
05. unsigned long idx;
06.
07. bdebug("nid=%td start=%lx end=%lx\n", bdata - bootmem_node_data,
08. sidx + bdata->node_min_pfn,
09. eidx + bdata->node_min_pfn);
10.
11. if (bdata->hint_idx > sidx)
12. bdata->hint_idx = sidx;/*更新变量hint_idx，用于分配*/
13.
14. for (idx = sidx; idx < eidx; idx++)/*对应位清0*/
15. if (!test_and_clear_bit(idx, bdata->node_bootmem_map))
16. BUG();
17.}view plaincopy to clipboard01.void __init early_res_to_bootmem(u64 start, u64 end)
02.{
03. int i, count;
04. u64 final_start, final_end;
05.
06. count= 0;
07. for (i = 0; i < MAX_EARLY_RES && early_res.end; i++)
08. count++;/*计算保留块的个数*/
09.
10. printk(KERN_INFO "(%d early reservations) ==> bootmem [%010llx - %010llx]\n",
11. count, start, end);
12. for (i = 0; i < count; i++) {
13. struct early_res *r = &early_res;
14. printk(KERN_INFO "#%d [%010llx - %010llx] %16s", i,
15. r->start, r->end, r->name);
16. final_start = max(start, r->start);
17. final_end = min(end, r->end);
18. if (final_start >= final_end) {
19. printk(KERN_CONT "\n");
20. continue;
21. }
22. printk(KERN_CONT " ==> [%010llx - %010llx]\n",
23. final_start, final_end);
24. /*将指定区间置为保留*/
25. reserve_bootmem_generic(final_start, final_end - final_start,
26. BOOTMEM_DEFAULT);
27. }
28.}上面的保留指定区间reserve_bootmem_generic()函数最终调用如下函数
view plaincopy to clipboard01./**
02. * reserve_bootmem - mark a page range as usable
03. * @addr: starting address of the range
04. * @size: size of the range in bytes
05. * @flags: reservation flags (see linux/bootmem.h)
06. *
07. * Partial pages will be reserved.
08. *
09. * The range must be contiguous but may span node boundaries.
10. */
11.int __init reserve_bootmem(unsigned long addr, unsigned long size,
12. int flags)
13.{
14. unsigned long start, end;
15.
16. start = PFN_DOWN(addr);/*下界*/
17. end = PFN_UP(addr + size);/*上界*/
18.
19. return mark_bootmem(start, end, 1, flags);
20.}view plaincopy to clipboard01./*保留指定内存区间*/
02.static int __init mark_bootmem(unsigned long start, unsigned long end,
03. int reserve, int flags)
04.{
05. unsigned long pos;
06. bootmem_data_t *bdata;
07.
08. pos = start;
09. /*通过bdata_list链表找到在指定区间的bdata*/
10. list_for_each_entry(bdata, &bdata_list, list) {
11. int err;
12. unsigned long max;
13.
14. if (pos < bdata->node_min_pfn ||
15. pos >= bdata->node_low_pfn) {
16. BUG_ON(pos != start);
17. continue;
18. }
19.
20. max = min(bdata->node_low_pfn, end);
21. /*设置为保留*/
22. err = mark_bootmem_node(bdata, pos, max, reserve, flags);
23. if (reserve && err) {/*如果出错，递归调用*/
24. mark_bootmem(start, pos, 0, 0);
25. return err;
26. }
27.
28. if (max == end)
29. return 0;
30. pos = bdata->node_low_pfn;
31. }
32. BUG();
33.}三、内存的分配和释放
谢谢分享
页:
[1]