linux 核心 記憶體管理 bootmem alloctor 申請記憶體__linux

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