linux 内核 内存管理 bootmem alloctor 申请内存

alloc_bootmem_low_pages（）定义在：include/linux/bootmem.h中，定义如下：

#define alloc_bootmem_low_pages(x) \

    __alloc_bootmem_low(x, PAGE_SIZE, 0)

__alloc_bootmem_low()定义在：mm/bootmem.c，定义如下：

void * __init __alloc_bootmem_low(unsigned long size, unsigned long align,
                  unsigned long goal)
{
    bootmem_data_t *bdata;
    void *ptr;
    list_for_each_entry(bdata, &bdata_list, list) {
        ptr = __alloc_bootmem_core(bdata, size, align, goal,
                        ARCH_LOW_ADDRESS_LIMIT);
        if (ptr)
            return ptr;
    }
    printk(KERN_ALERT "low bootmem alloc of %lu bytes failed!\n", size);
    panic("Out of low memory");
    return NULL;
}

查找bdata链表上的每个节点，这每个节点代表一个bitmap，当然x86默认配置上只有一个节点，该节点在bootmem allocator初始化时创建，并添加到这个链表中。

核心函数还是__alloc_bootmem_core()，该函数定义于：mm/bootmem.c，定义如下：

void * __init
__alloc_bootmem_core(struct bootmem_data *bdata, unsigned long size,
          unsigned long align, unsigned long goal, unsigned long limit)
{
    unsigned long offset, remaining_size, areasize, preferred;
    unsigned long i, start = 0, incr, eidx, end_pfn;
    void *ret;

    if (!size) {
        printk("__alloc_bootmem_core(): zero-sized request\n");
        BUG();
    }
    BUG_ON(align & (align-1));

    if (limit && bdata->node_boot_start >= limit)
        return NULL;

    /* on nodes without memory - bootmem_map is NULL */
    if (!bdata->node_bootmem_map)
        return NULL;

    end_pfn = bdata->node_low_pfn;      // max_low_pfn
    limit = PFN_DOWN(limit);            // limit = 0xffffffff
    if (limit && end_pfn > limit)
        end_pfn = limit;

    /*
     * 处理node_boot_start不对齐的情况。
     * @offset: offset + PFN_DOWN(bdata->node_boot_start)是align对齐的
     */
    eidx = end_pfn - PFN_DOWN(bdata->node_boot_start); // eidx = max_low_pfn
    offset = 0;
    if (align && (bdata->node_boot_start & (align - 1UL)) != 0)
        offset = align - (bdata->node_boot_start & (align - 1UL));
    offset = PFN_DOWN(offset);

    /*
     * We try to allocate bootmem pages above 'goal'
     * first, then we try to allocate lower pages.
     */
    if (goal && goal >= bdata->node_boot_start && PFN_DOWN(goal) < end_pfn) {
        // 相对于node_boot_start的偏移量，只不过node_boot_start=0
        // 如果不是0，这里会出现歧义，因为在下面preferred将可能被赋值为last_success
        // 而这个success很显然不是某种偏移量，而是物理地址。
        preferred = goal - bdata->node_boot_start;

        if (bdata->last_success >= preferred)
            if (!limit || (limit && limit > bdata->last_success))
                // last_success中保存的是上次成功时的起始地址
                preferred = bdata->last_success;
    } else
        preferred = 0;

    /* 根据对齐调整要求，调整preferred, preferred是pfn */
    preferred = PFN_DOWN(ALIGN(preferred, align)) + offset;
    areasize = (size + PAGE_SIZE-1) / PAGE_SIZE;
    /* incr表示在查找内存时每次叠加几个页面 */
    incr = align >> PAGE_SHIFT ? : 1;

restart_scan:
    for (i = preferred; i < eidx; i += incr) {
        unsigned long j;
        i = find_next_zero_bit(bdata->node_bootmem_map, eidx, i);
        i = ALIGN(i, incr);
        if (i >= eidx)
            break;
        if (test_bit(i, bdata->node_bootmem_map))
            continue;

        /* for循环中判断从i是否有areasize个连续的空闲页面，
         * 如果没有，则跳转到fail_block继续下一次的搜索. */
        for (j = i + 1; j < i + areasize; ++j) {
            if (j >= eidx)
                goto fail_block;
            if (test_bit(j, bdata->node_bootmem_map))
                goto fail_block;
        }
        start = i; /*如果在for循环中没有退出，则说明从第i个页面起一共有areasize个连续的页面可供使用*/
        goto found;
    fail_block:
        i = ALIGN(j, incr);
    }
    if (preferred > offset) {
        preferred = offset;
       /* 如果大于goal的内存不符合要求，转到从offset开始的内存开始搜索 */
        goto restart_scan;
    }
    return NULL;

found:
    bdata->last_success = PFN_PHYS(start);
    BUG_ON(start >= eidx);

/*找到合适页面后并没有马上把写页面返回，而是尝试着把这次申请的页面和上次申请的页面进行合并，
 * 以减少这两次内存之间的空隙（内存碎片），这样做的前提是：上次申请内存的最后一页和这次申请
 * 内存的第一页是连续的，在下面的if里就是判断这个前提，如果不连续，就不能进行合并了*/    
/* if语句判断这次找到和上次找到的是相邻的两页，这样才可能合并，否则进入else */
    if (align < PAGE_SIZE &&
        bdata->last_offset && bdata->last_pos+1 == start) {
        offset = ALIGN(bdata->last_offset, align);
        BUG_ON(offset > PAGE_SIZE);
        remaining_size = PAGE_SIZE - offset;
        if (size < remaining_size) { /*上次申请页面剩余的内存足够这次使用*/
            areasize = 0;
            /* last_pos unchanged */
            bdata->last_offset = offset + size;
            ret = phys_to_virt(bdata->last_pos * PAGE_SIZE +
                       offset +
                       bdata->node_boot_start);
        } else {                 /*上次申请页面剩余的内存不够这次使用*/
            remaining_size = size - remaining_size;
            areasize = (remaining_size + PAGE_SIZE-1) / PAGE_SIZE;
            ret = phys_to_virt(bdata->last_pos * PAGE_SIZE +
                       offset +
                       bdata->node_boot_start);
            bdata->last_pos = start + areasize - 1;
            bdata->last_offset = remaining_size;
        }
        bdata->last_offset &= ~PAGE_MASK;
    } else {
        bdata->last_pos = start + areasize - 1;
        bdata->last_offset = size & ~PAGE_MASK;
        ret = phys_to_virt(start * PAGE_SIZE + bdata->node_boot_start);
    }

    for (i = start; i < start + areasize; i++)
        if (unlikely(test_and_set_bit(i, bdata->node_bootmem_map)))
            BUG();
    memset(ret, 0, size);
    return ret;
}