Linux启动内存分配器

Linux启动内存分配器是在伙伴系统、slab机制实现之前，为满足内核中内存的分配而建立的。本身的机制比较简单，使用位图来进行标志分配和释放。

一、数据结构介绍

1，保留区间

因为在建立启动内存分配器的时候，会涉及保留内存。也就是说，之前保留给页表、分配器本身（用于映射的位图）、io等得内存在分配器建立后，当用它来分配内存空间时，保留出来的那些部分就不能再分配了。linux中对保留内存空间的部分用下列数据结构表示

[cpp]

1. /* 


2.  * Early reserved memory areas. 


3.  */  


4. #define MAX_EARLY_RES 20/*保留空间最大块数*/   


5.   


6. struct early_res {/*保留空间结构*/  


7.     u64 start, end;  


8.     char name[16];  


9.     char overlap_ok;  


10. };  


11. /*保留内存空间全局变量*/  


12. static struct early_res early_res[MAX_EARLY_RES] __initdata = {  


13.     { 0, PAGE_SIZE, “BIOS data page” }, /* BIOS data page */  


14.     {}  


15. };  

[cpp]

1. /* 


2.  * node_bootmem_map is a map pointer – the bits represent all physical  


3.  * memory pages (including holes) on the node. 


4.  */  


5.  /*用于bootmem分配器的节点数据结构*/  


6. typedef struct bootmem_data {  


7.     unsigned long node_min_pfn;/*存放bootmem位图的第一个页面（即内核映象结束处的第一个页面）。*/  


8.     unsigned long node_low_pfn;/*物理内存的顶点，最高不超过896MB。*/  


9.     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;  

[cpp]

1. static struct list_head bdata_list __initdata = LIST_HEAD_INIT(bdata_list);  

二、启动分配器的建立

启动分配器的建立主要的流程为初始化映射位图、活动内存区的映射位置0（表示可用）、保留内存区域处理，其中保留区存放在上面介绍的全局数组中，这里只是将分配器中对应映射位图值1，表示已经分配。

下面我们看内核中具体的初始化流程。

start_kernel()->setup_arch()->initmem_init()

[html]

1. void __init setup_arch(char **cmdline_p)  


2. {  


3.           …….  


4. /*此函数在开始对bootmem分配制度建立做些准备工作  


5.     然后调用相关函数建立bootmem分配制度*/  


6.     initmem_init(0, max_pfn);  


7.           …….  


8. }              

[html]

1. void __init initmem_init(unsigned long start_pfn,  


2.                   unsigned long end_pfn)  


3. {  


4. #ifdef CONFIG_HIGHMEM  


5.     highstart_pfn = highend_pfn = max_pfn;  


6.     if (max_pfn > max_low_pfn)  


7.         highstart_pfn = max_low_pfn;  


8.     /*将活动内存放到early_node_map中,前面已经分析过了*/  


9.     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. }  

[cpp]

1. void __init setup_bootmem_allocator(void)  


2. {  


3.     int nodeid;  


4.     unsigned long bootmap_size, bootmap;  


5.     /* 


6.      * Initialize the boot-time allocator (with low memory only): 


7.      */  


8.      /*计算所需要的映射页面大小一个字节一位， 


9.      所以需要对总的页面大小除以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[nodeid];  


28.         end_pfn = node_end_pfn[nodeid];  


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. }  

[cpp]

1. static unsigned long __init setup_node_bootmem(int nodeid,  


2.                  unsigned long start_pfn,  


3.                  unsigned long end_pfn,  


4.                  unsigned long bootmap)  


5. {  


6.     unsigned long bootmap_size;  


7.   


8.     /* don’t touch min_low_pfn */  


9.     /*初始化映射位图，将位图中的所有位置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. }  

[cpp]

1. /* 


2.  * Called once to set up the allocator itself. 


3.  */  


4. static unsigned long __init init_bootmem_core(bootmem_data_t *bdata,  


5.     unsigned long mapstart, unsigned long start, unsigned long end)  


6. {  


7.     unsigned long mapsize;  


8.   


9.     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. }  

[cpp]

1. /* 


2.  * link bdata in order 


3.  */  


4.  /*添加到链表，由添加的代码可知 


5.  链表中的数据开始位置为递增的*/  


6. static void __init link_bootmem(bootmem_data_t *bdata)  


7. {  


8.     struct list_head *iter;  


9.     /*添加到全局链表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. }  

[cpp]

1. /** 


2.  * free_bootmem_with_active_regions – Call free_bootmem_node for each active range 


3.  * @nid: The node to free memory on. If MAX_NUMNODES, all nodes are freed. 


4.  * @max_low_pfn: The highest PFN that will be passed to free_bootmem_node 


5.  * 


6.  * If an architecture guarantees that all ranges registered with 


7.  * add_active_ranges() contain no holes and may be freed, this 


8.  * this function may be used instead of calling free_bootmem() manually. 


9.  */  


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[i].end_pfn;  


19.   


20.         if (early_node_map[i].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[i].start_pfn;  


27.         /*释放这部分内存，起始就是对应位图值0*/  


28.         free_bootmem_node(NODE_DATA(early_node_map[i].nid),  


29.                 PFN_PHYS(early_node_map[i].start_pfn),  


30.                 size_pages << PAGE_SHIFT);  


31.     }  


32. }  

[cpp]

1. /** 


2.  * free_bootmem_node – mark a page range as usable 


3.  * @pgdat: node the range resides on 


4.  * @physaddr: starting address of the range 


5.  * @size: size of the range in bytes 


6.  * 


7.  * Partial pages will be considered reserved and left as they are. 


8.  * 


9.  * 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. }  

[cpp]

1. static int __init mark_bootmem_node(bootmem_data_t *bdata,  


2.                 unsigned long start, unsigned long end,  


3.                 int reserve, int flags)  


4. {  


5.     unsigned long sidx, eidx;  


6.   


7.     bdebug(“nid=%td start=%lx end=%lx reserve=%d flags=%x\n”,  


8.         bdata – bootmem_node_data, start, end, reserve, flags);  


9.   


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. }  

[cpp]

1. /*bootmem分配器的保留操作*/  


2. static int __init __reserve(bootmem_data_t *bdata, unsigned long sidx,  


3.             unsigned long eidx, int flags)  


4. {  


5.     unsigned long idx;  


6.     int exclusive = flags & BOOTMEM_EXCLUSIVE;  


7.   


8.     bdebug(“nid=%td start=%lx end=%lx flags=%x\n”,  


9.         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. }  

[cpp]

1. /*bootmem分配器中释放内存*/  


2. static void __init __free(bootmem_data_t *bdata,  


3.             unsigned long sidx, unsigned long eidx)  


4. {  


5.     unsigned long idx;  


6.   


7.     bdebug(“nid=%td start=%lx end=%lx\n”, bdata – bootmem_node_data,  


8.         sidx + bdata->node_min_pfn,  


9.         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. }  

[cpp]

1. void __init early_res_to_bootmem(u64 start, u64 end)  


2. {  


3.     int i, count;  


4.     u64 final_start, final_end;  


5.   


6.     count  = 0;  


7.     for (i = 0; i < MAX_EARLY_RES && early_res[i].end; i++)  


8.         count++;/*计算保留块的个数*/  


9.   


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[i];  


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. }  

[cpp]

1. /** 


2.  * reserve_bootmem – mark a page range as usable 


3.  * @addr: starting address of the range 


4.  * @size: size of the range in bytes 


5.  * @flags: reservation flags (see linux/bootmem.h) 


6.  * 


7.  * Partial pages will be reserved. 


8.  * 


9.  * 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. }  

[cpp]

1. /*保留指定内存区间*/  


2. static int __init mark_bootmem(unsigned long start, unsigned long end,  


3.                 int reserve, int flags)  


4. {  


5.     unsigned long pos;  


6.     bootmem_data_t *bdata;  


7.   


8.     pos = start;  


9.     /*通过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，释放过程相反。

[cpp]

1. /*分配size大小的空间*/  


2. static void * __init alloc_bootmem_core(struct bootmem_data *bdata,  


3.                     unsigned long size, unsigned long align,  


4.                     unsigned long goal, unsigned long limit)  


5. {  


6.     unsigned long fallback = 0;  


7.     unsigned long min, max, start, sidx, midx, step;  


8.   


9.     bdebug(“nid=%td size=%lx [%lu pages] align=%lx goal=%lx limit=%lx\n”,  


10.         bdata – bootmem_node_data, size, PAGE_ALIGN(size) >> PAGE_SHIFT,  


11.         align, goal, limit);  


12.   


13.     BUG_ON(!size);  


14.     BUG_ON(align & (align – 1));  


15.     BUG_ON(limit && goal + size > limit);  


16.     /*如果没有映射位图返回空，分配失败*/  


17.     if (!bdata->node_bootmem_map)  


18.         return NULL;  


19.   


20.     min = bdata->node_min_pfn;  


21.     max = bdata->node_low_pfn;  


22.   


23.     goal >>= PAGE_SHIFT;  


24.     limit >>= PAGE_SHIFT;  


25.   


26.     if (limit && max > limit)  


27.         max = limit;  


28.     if (max <= min)  


29.         return NULL;  


30.     /*step为需要对齐于页面数*/  


31.     step = max(align >> PAGE_SHIFT, 1UL);  


32.     /*计算起始页面*/  


33.     if (goal && min < goal && goal < max)  


34.         start = ALIGN(goal, step);  


35.     else  


36.         start = ALIGN(min, step);  


37.     /*计算分配页面区间*/  


38.     sidx = start – bdata->node_min_pfn;  


39.     midx = max – bdata->node_min_pfn;  


40.     /*前一次分配的页号比这次开始分配的页面号大 


41.     那么，如果第一次没有分配到，回退到这次的 


42.     开始重新试，因为第一次分配是从上一次分配 


43.     的位置开始的*/  


44.     if (bdata->hint_idx > sidx) {       


45.          * Handle the valid case of sidx being zero and still  


46.          * catch the fallback below.  


47.          */  


48.         fallback = sidx + 1;  


49.         /*从上一次分配的位置开始，对齐与页面*/  


50.         sidx = align_idx(bdata, bdata->hint_idx, step);  


51.     }  


52.   


53.     while (1) {  


54.         int merge;  


55.         void *region;  


56.         unsigned long eidx, i, start_off, end_off;  


57. find_block:  


58.         /*查找第一个为0的位*/  


59.         sidx = find_next_zero_bit(bdata->node_bootmem_map, midx, sidx);  


60.         sidx = align_idx(bdata, sidx, step);  


61.         eidx = sidx + PFN_UP(size);/*结束位置*/  


62.   


63.         if (sidx >= midx || eidx > midx)/*找到结束了*/  


64.             break;  


65.   


66.         for (i = sidx; i < eidx; i++)/*检查这段区域是否空闲*/  


67.             if (test_bit(i, bdata->node_bootmem_map)) {/*如果不是，将跳过这段继续查找*/  


68.                 sidx = align_idx(bdata, i, step);  


69.                 if (sidx == i)  


70.                     sidx += step;  


71.                 goto find_block;  


72.             }  


73.   


74.         if (bdata->last_end_off & (PAGE_SIZE – 1) &&/*如果为相邻的页面，也就是说上次分配的页面和这次分配的开始页面为相邻的*/  


75.                 PFN_DOWN(bdata->last_end_off) + 1 == sidx)  


76.             start_off = align_off(bdata, bdata->last_end_off, align);  


77.         else  


78.             start_off = PFN_PHYS(sidx);  


79.   


80.         /*merge==1表示上次结束和这次开始不在同一个页面上*/  


81.         merge = PFN_DOWN(start_off) < sidx;  


82.         end_off = start_off + size;  


83.         /*更新数据*/  


84.         bdata->last_end_off = end_off;  


85.         bdata->hint_idx = PFN_UP(end_off);  


86.   


87.         /* 


88.          * Reserve the area now: 


89.          */  


90.          /*设定新加入的页面为保留,就是将对应的映射位置1*/  


91.         if (__reserve(bdata, PFN_DOWN(start_off) + merge,  


92.                 PFN_UP(end_off), BOOTMEM_EXCLUSIVE))  


93.             BUG();  


94.         /*对应开始地址的虚拟地址返回*/  


95.         region = phys_to_virt(PFN_PHYS(bdata->node_min_pfn) +  


96.                 start_off);  


97.         memset(region, 0, size);/*分配的大小*/  


98.         /* 


99.          * The min_count is set to 0 so that bootmem allocated blocks 


100.          * are never reported as leaks. 


101.          */  


102.          /*调试用*/  


103.         kmemleak_alloc(region, size, 0, 0);  


104.         return region;  


105.     }  


106.   


107.     if (fallback) {/*回退，重新查看*/  


108.         sidx = align_idx(bdata, fallback – 1, step);  


109.         fallback = 0;  


110.         goto find_block;  


111.     }  


112.   


113.     return NULL;  


114. }