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

    转自：http://blog.csdn.net/zmxiangde_88/article/details/8041040

    版权声明：本文为博主原创文章，未经博主允许不得转载。

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

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

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

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

    一，前提

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

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

    [cpp] view plain copy
     
    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
     
    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
     
    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
     
    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
     
    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
     
    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
       
      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
       
      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
     
    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) disabling initrd ",  
    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
     
    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
     
    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
     
    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. ", i*PAGE_SIZE);  
    32. #endif  
    33.         }  
    34. }  


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

    五，内核分配内存

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

    [cpp] view plain copy
     
    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! ", size);  
    12.     panic("Out of memory");  
    13.     return NULL;  
    14. }  
    这个函数也是__alloc_bootmem_nopanic函数的一个前端。
    [cpp] view plain copy
     
    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
     
    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 ");  
    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
       
      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;  
     
    顶
    0
    踩
  • 相关阅读:
    杀毒软件工作原理
    IP地址
    网络操作系统功能和基本任务
    计算机网络技术知识点总结
    对称密钥密码体制的主要特点
    无线局域网（WLAN）
    文件传输协议（FTP）
    万维网(WWW)
    简单网络管理协议（SNMP）
    防火墙技术
  • 原文地址：https://www.cnblogs.com/sky-heaven/p/6307622.html
Copyright © 2020-2023  润新知