内核的bootmem内存分配器【转】

r囧r小猫 2022-02-02 14:43 387阅读 0赞

转自：[http://blog.csdn.net/zmxiangde\_88/article/details/8041040][http_blog.csdn.net_zmxiangde_88_article_details_8041040]

在内核启动期间，伙伴系统内存管理器还没有建立之前，内核此时也要分配内存以及创建一些用于建立内存管理等机制的[数据结构][Link 1]，此时内存分配和管理就是由bootmem内存分配器来完成的。

bootmem的建立要求就是简单，越简单越好，因为一旦伙伴系统建立之后，就不需要bootmem了，因此对性能和通用性等要服从一切从简的原则。在了解这个分配器之后，就会知道它真的很简单。

该分配器使用一个位图来管理页，位图比特位的数目与系统中物理内存页的数目相同，比特位为1时，表示这个页已经分配，为0时，表示当前指示的页是空闲的。在需要分配内存时，分配器扫描整个位图，直到找到一个能够提供足够连续页的位置。

下面分析一下这个分配器。

一，前提

在这个分配器被建立之前，先了解一下内核此时是一个什么样的状态，主要说内存方面的。

内存在检测系统可用内存之后，被存入一个数组之中，其结构如下：

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **struct e820map\{  **
2.      \_u32 nr\_map;  
3.      **struct e820entry map\[E820MAX\];  **
4.  \}  
5.  **struct e820entry\{  **
6.      \_u64 addr;  
7.      \_u64 size;  
8.      \_u32 type;  
9.  \} \_\_attribute\_\_((packed));

在用中断检测可用内存之后，内存被存入e820map e820变量中，然后根据这个数组，确定下面一些值：

1.  min\_low\_pfn ：表示RAM 中在内核映像后第一个可用页框的页框号，因为内存映像所占用的页肯定不能用于分配的。
2.  max\_pfn：表示最后一个可用页框的页框号，包括可端内存。
3.  max\_low\_pfn：被内核直接映射的，低地址内存的最后一个页框的页框号。

在确定好了这些值之后，调用setup\_bootmem\_allocator函数，完成bootmem分配的建立工作，这是本博文的重点。

二，数据结构

用于维护该分配器的数据结构如下

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **typedef struct bootmem\_data \{  **
2.      unsigned long node\_boot\_start;  
3.      unsigned long node\_low\_pfn;  
4.      **void \*node\_bootmem\_map;  **
5.      unsigned long last\_offset;  
6.      unsigned long last\_pos;  
7.      unsigned long last\_success; /\* Previous allocation point.  To speed 
8.                       \* up searching \*/  
9.      **struct list\_head list;  **
10. \} bootmem\_data\_t;

node\_boot\_start：这个字段保存了系统中第一个页的编号，这一般都是0；

node\_low\_pfn：可以被直接管理的物理地址空间中最后一页的编号；

node\_bootmem\_map：指向分配位图的内存指针，前面说这种分配方式主要是维护一个大的位图。

last\_offset：上一次分配的页内的偏移，上一次分配的页的编号由last\_pos指定，而last\_offset指定个页内已经分配的偏移。

last\_success：指定位图中上一次成功分配内存的位置，下一个分配从这里开始分配。

list：因为内存并不是都是连续的，对于不连续的内存，系统需要多个bootmem分配器，所有的分配器都保存一个链表中，表头由一个全局变量指定。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **void \_\_init setup\_bootmem\_allocator(void)  **
2.  \{  
3.      unsigned long bootmap\_size;  
4.      /\* 
5.       \* Initialize the boot-time allocator (with low memory only): 
6.       \*/  
7.      bootmap\_size = init\_bootmem(min\_low\_pfn, max\_low\_pfn);

调用init\_bootmem函数完成初始化，这个函数会调用init\_bootmem\_core函数完成初始化。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  unsigned long \_\_init init\_bootmem(unsigned long start, unsigned long pages)  
2.  \{  
3.      max\_low\_pfn = pages;  
4.      min\_low\_pfn = start;  
5.      **return init\_bootmem\_core(NODE\_DATA(0), start, 0, pages);  **
6.  \}

这里的两个参数需要注意，是由min\_low\_pfn和max\_low\_pfn传递而来，表示低内存域的最小和最大的页帧编号。

在下面的函数实现中，可以看到mapstart的值就是min\_log\_pfn，end的值是max\_low\_pfn，而start的值为0，这个值要赋给bootmem\_data\_t结构的node\_boot\_start字段，参数中的NODE\_DATA(0)，表示当前内存结点。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **static unsigned long \_\_init init\_bootmem\_core(pg\_data\_t \*pgdat,  **
2.      unsigned long mapstart, unsigned long start, unsigned long end)  
3.  \{  
4.      bootmem\_data\_t \*bdata = pgdat->bdata;  
5.      unsigned long mapsize;  
6.    
7.      bdata->node\_bootmem\_map = phys\_to\_virt(PFN\_PHYS(mapstart));//内存的最开始，由分配位图占用一部分  
8.      bdata->node\_boot\_start = PFN\_PHYS(start);  
9.      bdata->node\_low\_pfn = end;//注意这个赋值  
10.     link\_bootmem(bdata);  
11.   
12.     /\* 
13.      \* Initially all pages are reserved - setup\_arch() has to 
14.      \* register free RAM areas explicitly. 
15.      \*/  
16.     mapsize = get\_mapsize(bdata);  
17.     memset(bdata->node\_bootmem\_map, 0xff, mapsize);  
18.   
19.     **return mapsize;  **
20. \}

PFN\_PHYS宏是将页帧的编号转换为对应的页内的物理地址，该操作通过左移页内偏移的位数来达到。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#define PFN\_PHYS(x) ((x) << PAGE\_SHIFT)//在这里是左移12位

init\_bootmem\_core完成以下操作：

1.  给内存结点的bdata域，就是bootmem\_data\_t类型字段的值赋值。一个内存结点的数据结构中包含由这个分配器指针。
2.  将bootmem\_data\_t添加到全局变量为表头的链表上，这个通过调用link\_bootmem完成，将其添加到分局变量bdata\_list上。  
    
    
    **\[cpp\]**  [view plain][]   [copy][view plain]
    
     
    
    1.  **static void \_\_init link\_bootmem(bootmem\_data\_t \*bdata)  **
    2.  \{  
    3.      bootmem\_data\_t \*ent;  
    4.    
    5.      **if (list\_empty(&bdata\_list)) \{  **
    6.          list\_add(&bdata->list, &bdata\_list);  
    7.          **return;  **
    8.      \}  
    9.      /\* insert in order \*/  
    10.     list\_for\_each\_entry(ent, &bdata\_list, list) \{  
    11.         **if (bdata->node\_boot\_start < ent->node\_boot\_start) \{  **
    12.             list\_add\_tail(&bdata->list, &ent->list);  
    13.             **return;  **
    14.         \}  
    15.     \}  
    16.     list\_add\_tail(&bdata->list, &bdata\_list);  
    17. \}  
3.  get\_mapsize函数计算分配器中可用的内存页所需的BIT位数，就是一个页占用一个BIT的话，需要多少个bit位,然后按字对齐。注意这个函数会将从第0页开始进行管理，但是第0页至少已经被作为内核映射了。  
    
    
    **\[cpp\]**  [view plain][]   [copy][view plain]
    
     
    
    1.  **static unsigned long \_\_init get\_mapsize(bootmem\_data\_t \*bdata)  **
    2.  \{  
    3.      unsigned long mapsize;  
    4.      unsigned long start = PFN\_DOWN(bdata->node\_boot\_start);  
    5.      unsigned long end = bdata->node\_low\_pfn;  
    6.    
    7.      mapsize = ((end - start) + 7) / 8;  
    8.      **return ALIGN(mapsize, sizeof(long));  **
    9.  \}  
4.  调用memset将所有的页标识为已经使用。接下来肯定要完成哪些页能够被用来分配内存，

三，释放可用的内存

在前面已经初始化了一个位图，该位图的位置从min\_low\_pfn开始占用，其实就是被内核映射之后的第一个页。但是标记了所有的内存页都是已经被使用了，这时系统中就不存在可用的内存了，需要从刚标识的内存位图中释放一些潜在的、可用的内存。这通过调用register\_bootmem\_low\_pages函数完成。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.      register\_bootmem\_low\_pages(max\_low\_pfn);  
2.    
3.      /\* 
4.       \* Reserve the bootmem bitmap itself as well. We do this in two 
5.       \* steps (first step was init\_bootmem()) because this catches 
6.       \* the (very unlikely) case of us accidentally initializing the 
7.       \* bootmem allocator with an invalid RAM area. 
8.       \*/  
9.      reserve\_bootmem(\_\_pa\_symbol(\_text), (PFN\_PHYS(min\_low\_pfn) +  
10.              bootmap\_size + PAGE\_SIZE-1) - \_\_pa\_symbol(\_text));  
11.   
12.     /\* 
13.      \* reserve physical page 0 - it's a special BIOS page on many boxes, 
14.      \* enabling clean reboots, SMP operation, laptop functions. 
15.      \*/  
16.     reserve\_bootmem(0, PAGE\_SIZE);  
17.   
18.     /\* reserve EBDA region, it's a 4K region \*/  
19.     reserve\_ebda\_region();  
20.   
21.     /\* could be an AMD 768MPX chipset. Reserve a page  before VGA to prevent 
22.        PCI prefetch into it (errata \#56). Usually the page is reserved anyways, 
23.        unless you have no PS/2 mouse plugged in. \*/  
24.     **if (boot\_cpu\_data.x86\_vendor == X86\_VENDOR\_AMD &&  **
25.         boot\_cpu\_data.x86 == 6)  
26.          reserve\_bootmem(0xa0000 - 4096, 4096);  
27.   
28. \#ifdef CONFIG\_SMP  
29.     /\* 
30.      \* But first pinch a few for the stack/trampoline stuff 
31.      \* FIXME: Don't need the extra page at 4K, but need to fix 
32.      \* trampoline before removing it. (see the GDT stuff) 
33.      \*/  
34.     reserve\_bootmem(PAGE\_SIZE, PAGE\_SIZE);  
35. \#endif  
36. \#ifdef CONFIG\_ACPI\_SLEEP  
37.     /\* 
38.      \* Reserve low memory region for sleep support. 
39.      \*/  
40.     acpi\_reserve\_bootmem();  
41. \#endif  
42. \#ifdef CONFIG\_X86\_FIND\_SMP\_CONFIG  
43.     /\* 
44.      \* Find and reserve possible boot-time SMP configuration: 
45.      \*/  
46.     find\_smp\_config();  
47. \#endif  
48.     numa\_kva\_reserve();  
49. \#ifdef CONFIG\_BLK\_DEV\_INITRD  
50.     **if (boot\_params.hdr.type\_of\_loader && boot\_params.hdr.ramdisk\_image) \{  **
51.         unsigned long ramdisk\_image = boot\_params.hdr.ramdisk\_image;  
52.         unsigned long ramdisk\_size  = boot\_params.hdr.ramdisk\_size;  
53.         unsigned long ramdisk\_end   = ramdisk\_image + ramdisk\_size;  
54.         unsigned long end\_of\_lowmem = max\_low\_pfn << PAGE\_SHIFT;  
55.   
56.         **if (ramdisk\_end <= end\_of\_lowmem) \{  **
57.             reserve\_bootmem(ramdisk\_image, ramdisk\_size);  
58.             initrd\_start = ramdisk\_image + PAGE\_OFFSET;  
59.             initrd\_end = initrd\_start+ramdisk\_size;  
60.         \} **else \{  **
61.             printk(KERN\_ERR "initrd extends beyond end of memory "  
62.                    "(0x%08lx > 0x%08lx)\\ndisabling initrd\\n",  
63.                    ramdisk\_end, end\_of\_lowmem);  
64.             initrd\_start = 0;  
65.         \}  
66.     \}  
67. \#endif  
68.     reserve\_crashkernel();  
69. \}

下面是register\_bootmem\_low\_pages的代码。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **void \_\_init register\_bootmem\_low\_pages(unsigned long max\_low\_pfn)  **
2.  \{  
3.      int i;  
4.    
5.      **if (efi\_enabled) \{  **
6.          efi\_memmap\_walk(free\_available\_memory, NULL);  
7.          **return;  **
8.      \}  
9.      **for (i = 0; i < e820.nr\_map; i++) \{  **
10.         unsigned long curr\_pfn, last\_pfn, size;  
11.         /\* 
12.          \* Reserve usable low memory 
13.          \*/  
14.         **if (e820.map\[i\].type != E820\_RAM)  **
15.             **continue;  **
16.         /\* 
17.          \* We are rounding up the start address of usable memory: 
18.          \*/  
19.         curr\_pfn = PFN\_UP(e820.map\[i\].addr);  
20.         **if (curr\_pfn >= max\_low\_pfn)  **
21.             **continue;  **
22.         /\* 
23.          \* ... and at the end of the usable range downwards: 
24.          \*/  
25.         last\_pfn = PFN\_DOWN(e820.map\[i\].addr + e820.map\[i\].size);  
26.   
27.         **if (last\_pfn > max\_low\_pfn)  **
28.             last\_pfn = max\_low\_pfn;  
29.   
30.         /\* 
31.          \* .. finally, did all the rounding and playing 
32.          \* around just make the area go away? 
33.          \*/  
34.         **if (last\_pfn <= curr\_pfn)  **
35.             **continue;  **
36.   
37.         size = last\_pfn - curr\_pfn;  
38.         free\_bootmem(PFN\_PHYS(curr\_pfn), PFN\_PHYS(size));  
39.     \}  
40. \}

前面说了由BIOS的中断给我们提供了可用的内存区列表，并且存在变量e820中，那么我们应该要将e820中标识的可用的内存列表都在内存分配器中标识为可用的内存。这个函数就是完成这个功能的，它通过对列表的遍历，找到每一个可用的内存域所在的页，然后标识该页可用。标记为可用是通过调用free\_bootmem函数完成的。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **void \_\_init free\_bootmem(unsigned long addr, unsigned long size)  **
2.  \{  
3.      free\_bootmem\_core(NODE\_DATA(0)->bdata, addr, size);  
4.  \}  
5.  **static void \_\_init free\_bootmem\_core(bootmem\_data\_t \*bdata, unsigned long addr,  **
6.                       unsigned long size)  
7.  \{  
8.      unsigned long sidx, eidx;  
9.      unsigned long i;  
10.   
11.   
12.     /\* 
13.      \* round down end of usable mem, partially free pages are 
14.      \* considered reserved. 
15.      \*/  
16.     BUG\_ON(!size);  
17.     BUG\_ON(PFN\_DOWN(addr + size) > bdata->node\_low\_pfn);  
18.   
19.   
20.     **if (addr < bdata->last\_success)  **
21.         bdata->last\_success = addr;  
22.   
23.   
24.     /\* 
25.      \* Round up the beginning of the address. 
26.      \*/  
27.     sidx = PFN\_UP(addr) - PFN\_DOWN(bdata->node\_boot\_start);  
28.     eidx = PFN\_DOWN(addr + size - bdata->node\_boot\_start);  
29.   
30.   
31.     **for (i = sidx; i < eidx; i++) \{  **
32.         **if (unlikely(!test\_and\_clear\_bit(i, bdata->node\_bootmem\_map)))  **
33.             BUG();  
34.     \}  
35. \}

这个函数其实是释放内存的函数，就是释放从addr开始的内存页

1.  先检查所需要释放的内存是否超过了分配器的最大内存页。
2.  然后要注意的是：这里只释放内存中的整页。由sidx和eidx的计算可以知道，它会计算完全包含在该内存中的、将被释放的页，如果只有部分包含在内存区中的页是被忽略的。这个过程肯定是有风险的，如果页包含在两个不同的内存区中，那么连续释放这些内存区，却无法释放这个页的内存，在释放所有的页后，分配器无法知道这个页是否还在使用，也没办法再去释放它了，因为这个页的状态一直都是标记为使用。所以这个分配器是简单的，但它是可行的，为什么呢？因为它只用于系统初始化期间，并且系统初始化期间所分配的大多数内存都会一直被使用，直到这个分配器停止使用，新的分配器开始工作，就是伙伴系统了。
3.  调用test\_and\_clear\_bit函数将这个BIT位标记为0。

四，预留内存

在上面把系统的可用内存都标记为可用，但此时系统正在使用一些内存，需要把这些内存相应的标记出来，这通过调用reserve\_bootmem函数完成。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  \#define reserve\_bootmem(addr, size) \\  
2.      reserve\_bootmem\_node(NODE\_DATA(0), (addr), (size))  
3.  **void \_\_init reserve\_bootmem\_node(pg\_data\_t \*pgdat, unsigned long physaddr,  **
4.                   unsigned long size)  
5.  \{  
6.      reserve\_bootmem\_core(pgdat->bdata, physaddr, size);  
7.  \}  
8.  **static void \_\_init reserve\_bootmem\_core(bootmem\_data\_t \*bdata, unsigned long addr,  **
9.                      unsigned long size)  
10. \{  
11.     unsigned long sidx, eidx;  
12.     unsigned long i;  
13.   
14.   
15.     /\* 
16.      \* round up, partially reserved pages are considered 
17.      \* fully reserved. 
18.      \*/  
19.     BUG\_ON(!size);  
20.     BUG\_ON(PFN\_DOWN(addr) >= bdata->node\_low\_pfn);  
21.     BUG\_ON(PFN\_UP(addr + size) > bdata->node\_low\_pfn);  
22.   
23.   
24.     sidx = PFN\_DOWN(addr - bdata->node\_boot\_start);  
25.     eidx = PFN\_UP(addr + size - bdata->node\_boot\_start);  
26.   
27.   
28.     **for (i = sidx; i < eidx; i++)  **
29.         **if (test\_and\_set\_bit(i, bdata->node\_bootmem\_map)) \{  **
30. \#ifdef CONFIG\_DEBUG\_BOOTMEM  
31.             printk("hm, page %08lx reserved twice.\\n", i\*PAGE\_SIZE);  
32. \#endif  
33.         \}  
34. \}

这个函数和前面的有些类似，就是将对应的页标记为已经使用。注意这个内存区域的计算，和前面的计算是相反的，前面是计算完全包含在内存中的内存页，这个计算是被完全包含在内存页中那些内存页。

五，内核分配内存

内核提供一些函数，用于向bootmem分配器索要内存，提供了很多系列的接口，如alloc\_bootmem(size)、alloc\_bootmem\_pages(size)等等，这些接口最终调用\_\_alloc\_bootmem函数完成分配。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **void \* \_\_init \_\_alloc\_bootmem(unsigned long size, unsigned long align,  **
2.                    unsigned long goal)  
3.  \{  
4.      **void \*mem = \_\_alloc\_bootmem\_nopanic(size,align,goal);  **
5.    
6.      **if (mem)  **
7.          **return mem;  **
8.      /\* 
9.       \* Whoops, we cannot satisfy the allocation request. 
10.      \*/  
11.     printk(KERN\_ALERT "bootmem alloc of %lu bytes failed!\\n", size);  
12.     panic("Out of memory");  
13.     **return NULL;  **
14. \}

这个函数也是\_\_alloc\_bootmem\_nopanic函数的一个前端。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **void \* \_\_init \_\_alloc\_bootmem\_nopanic(unsigned long size, unsigned long align,  **
2.                        unsigned long goal)  
3.  \{  
4.      bootmem\_data\_t \*bdata;  
5.      **void \*ptr;  **
6.    
7.      list\_for\_each\_entry(bdata, &bdata\_list, list) \{  
8.          ptr = \_\_alloc\_bootmem\_core(bdata, size, align, goal, 0);  
9.          **if (ptr)  **
10.             **return ptr;  **
11.     \}  
12.     **return NULL;  **
13. \}

这个函数会实际的分配，之前我们知道多个分配器被一个全局变量链接到一个链表上，这里会遍历整个链表，调用\_\_alloc\_bootmem\_core来分配内存，这个函数比较长，函数所需要参数有

1.  分配器指针，表示从这个分配器上分配。
2.  分配的大小。
3.  对齐方式，如果需要分配页，此时分配的对齐方式就是页对齐了。
4.  goal，表示从哪开始扫描这个分配器的位图。
5.  内存分配的限制，表示不能分配limit指定的后面的页。

**\[cpp\]**  [view plain][]   [copy][view plain]

1.  **void \* \_\_init  **
2.  \_\_alloc\_bootmem\_core(**struct bootmem\_data \*bdata, unsigned long size,  **
3.            unsigned long align, unsigned long goal, unsigned long limit)  
4.  \{  
5.      unsigned long offset, remaining\_size, areasize, preferred;  
6.      unsigned long i, start = 0, incr, eidx, end\_pfn;  
7.      **void \*ret;  **
8.    
9.      **if (!size) \{  **
10.         printk("\_\_alloc\_bootmem\_core(): zero-sized request\\n");  
11.         BUG();  
12.     \}  
13.     BUG\_ON(align & (align-1));  
14.   
15.     **if (limit && bdata->node\_boot\_start >= limit)  **
16.         **return NULL;  **
17.   
18.     /\* on nodes without memory - bootmem\_map is NULL \*/  
19.     **if (!bdata->node\_bootmem\_map)  **
20.         **return NULL;  **
21.   
22.     end\_pfn = bdata->node\_low\_pfn;  
23.     limit = PFN\_DOWN(limit);  
24.     **if (limit && end\_pfn > limit)  **
25.         end\_pfn = limit;  
26.   
27.     eidx = end\_pfn - PFN\_DOWN(bdata->node\_boot\_start);  
28.     offset = 0;  
29.     **if (align && (bdata->node\_boot\_start & (align - 1UL)) != 0)  **
30.         offset = align - (bdata->node\_boot\_start & (align - 1UL));  
31.     offset = PFN\_DOWN(offset);  
32.   
33.     /\* 
34.      \* We try to allocate bootmem pages above 'goal' 
35.      \* first, then we try to allocate lower pages. 
36.      \*/  
37.     **if (goal && goal >= bdata->node\_boot\_start && PFN\_DOWN(goal) < end\_pfn) \{  **
38.         preferred = goal - bdata->node\_boot\_start;  
39.   
40.         **if (bdata->last\_success >= preferred)  **
41.             **if (!limit || (limit && limit > bdata->last\_success))  **
42.                 preferred = bdata->last\_success;  
43.     \} **else  **
44.         preferred = 0;  
45.   
46.     preferred = PFN\_DOWN(ALIGN(preferred, align)) + offset;  
47.     areasize = (size + PAGE\_SIZE-1) / PAGE\_SIZE;  
48.     incr = align >> PAGE\_SHIFT ? : 1;  
49.   
50. restart\_scan:  
51.     **for (i = preferred; i < eidx; i += incr) \{  **
52.         unsigned long j;  
53.         i = find\_next\_zero\_bit(bdata->node\_bootmem\_map, eidx, i);  
54.         i = ALIGN(i, incr);  
55.         **if (i >= eidx)  **
56.             **break;  **
57.         **if (test\_bit(i, bdata->node\_bootmem\_map))  **
58.             **continue;  **
59.         **for (j = i + 1; j < i + areasize; ++j) \{  **
60.             **if (j >= eidx)  **
61.                 **goto fail\_block;  **
62.             **if (test\_bit(j, bdata->node\_bootmem\_map))  **
63.                 **goto fail\_block;  **
64.         \}  
65.         start = i;  
66.         **goto found;  **
67.     fail\_block:  
68.         i = ALIGN(j, incr);  
69.     \}  
70.   
71.     **if (preferred > offset) \{  **
72.         preferred = offset;  
73.         **goto restart\_scan;  **
74.     \}  
75.     **return NULL;  **
76.   
77. found:  
78.     bdata->last\_success = PFN\_PHYS(start);  
79.     BUG\_ON(start >= eidx);  
80.   
81.     /\* 
82.      \* Is the next page of the previous allocation-end the start 
83.      \* of this allocation's buffer? If yes then we can 'merge' 
84.      \* the previous partial page with this allocation. 
85.      \*/  
86.     **if (align < PAGE\_SIZE &&  **
87.         bdata->last\_offset && bdata->last\_pos+1 == start) \{  
88.         offset = ALIGN(bdata->last\_offset, align);  
89.         BUG\_ON(offset > PAGE\_SIZE);  
90.         remaining\_size = PAGE\_SIZE - offset;  
91.         **if (size < remaining\_size) \{  **
92.             areasize = 0;  
93.             /\* last\_pos unchanged \*/  
94.             bdata->last\_offset = offset + size;  
95.             ret = phys\_to\_virt(bdata->last\_pos \* PAGE\_SIZE +  
96.                        offset +  
97.                        bdata->node\_boot\_start);  
98.         \} **else \{  **
99.             remaining\_size = size - remaining\_size;  
100.             areasize = (remaining\_size + PAGE\_SIZE-1) / PAGE\_SIZE;  
101.             ret = phys\_to\_virt(bdata->last\_pos \* PAGE\_SIZE +  
102.                        offset +  
103.                        bdata->node\_boot\_start);  
104.             bdata->last\_pos = start + areasize - 1;  
105.             bdata->last\_offset = remaining\_size;  
106.         \}  
107.         bdata->last\_offset &= ~PAGE\_MASK;  
108.     \} **else \{  **
109.         bdata->last\_pos = start + areasize - 1;  
110.         bdata->last\_offset = size & ~PAGE\_MASK;  
111.         ret = phys\_to\_virt(start \* PAGE\_SIZE + bdata->node\_boot\_start);  
112.     \}  
113.   
114.     /\* 
115.      \* Reserve the area now: 
116.      \*/  
117.     **for (i = start; i < start + areasize; i++)  **
118.         **if (unlikely(test\_and\_set\_bit(i, bdata->node\_bootmem\_map)))  **
119.             BUG();  
120.     memset(ret, 0, size);  
121.     **return ret;  **
122. \}

这个函数的中心思想是从指定的位置开始扫描位图，如果找到了满足分配要求的，就马上分配。执行以下一些操作：

1.  从goal所指定的位置开始扫描位图，找到满足条件的空闲内存区域。
2.  如果目标页紧接着上一次分配的页，即bootmem\_data->last\_pos所指定的页，那么内核会检查bootmem\_data->last\_offset，判断这次请求的内存能不能从上一个页开始分配。
3.  新分配的页在位图对应的比特位设置为1，最后一页的数目也保存在bootmem\_data->lastpos中，如果这个页没有完全分配，那么保存分配的偏移至last\_offset中，否则将这个值表示为0。注意，如果分配的时候，要求是页对齐的，此时不能从偏移开始分配，页要从新页开始分配。
4.  分配成功之后，返回分配的内存域的起始地址。

六，内存的释放

内存的释放在前面已经介绍过了，通过调用free\_bootmem函数完成，前面也说了，这个函数一般很少使用。原因也是上面的原因。

七，停用bootmem分配器

这个分配器因为简单，所以用于系统的初期，在伙伴系统开始接手内存管理工作之后，这个分配器的历史使命就完成了，此时需要停止这个分配器。可以通过函数free\_all\_bootmem等来完成。基本的步骤是：

1.  扫描分配器中的页位图，释放没有使用的页，此时释放页是通过调用\_free\_pages\_bootmem函数，为什么呢？因为这时释放的内存需要释放到伙伴系统中，而不是这个分配器中，\_free\_pages\_bootmem函数会调用\_\_free\_pages函数，而后者是伙伴系统的标准内核接口函数，在这释放之后，伙伴系统就可以使用刚刚被从这个分配器中释放的页了。
2.  然后释放分配器本身的内存占用，其实主要是位图所占用的内存。  
    
    
    **\[cpp\]**  [view plain][]   [copy][view plain]
    
     
    
    1.  page = virt\_to\_page(bdata->node\_bootmem\_map);  
    2.  count = 0;  
    3.  idx = (get\_mapsize(bdata) + PAGE\_SIZE-1) >> PAGE\_SHIFT;  
    4.  **for (i = 0; i < idx; i++, page++) \{  **
    5.      \_\_free\_pages\_bootmem(page, 0);  
    6.      count++;  
    7.  \}  
    8.  total += count;  
    9.  bdata->node\_bootmem\_map = NULL;

顶

踩  
  
  
  
  
  
  
  
  
  
  
  
 本文转自张昺华-sky博客园博客，原文链接：http://www.cnblogs.com/sky-heaven/p/6307622.html ，如需转载请自行联系原作者

[http_blog.csdn.net_zmxiangde_88_article_details_8041040]: http://blog.csdn.net/zmxiangde_88/article/details/8041040
[Link 1]: http://lib.csdn.net/base/datastructure
[view plain]: http://blog.csdn.net/zmxiangde_88/article/details/8041040#