Memory Allocation API In Linux Kernel && Linux Userspace、kmalloc vmalloc Difference、Kernel Large Sec

時間 2019-11-25

標籤 memory allocation api linux kernel userspace kmalloc vmalloc difference large sec 欄目 C&C++ 简体版

原文原文鏈接

目錄html

1. 內核態(ring0)內存申請和用戶態(ring3)內存申請
2. 內核態(ring0)內存申請：kmalloc/kfree、vmalloc/vfree
3. 用戶態(ring3)內存申請：malloc/free
4. 內核內存申請原則
5. 內核中分配物理地址連續的大段內存

1. 內核態(ring0)內存申請和用戶態(ring3)內存申請 node

0x1: 差別點linux

在內核中申請內存和在用戶空間中申請內存不一樣，有如下因素引發了複雜性，包括編程

1. 內核的虛擬和物理地址被限制到1GB 
2. 內核的內存不能PAGEABLE
3. 內核一般須要連續的物理地址 
4. 一般內核申請內存是不能睡眠 
5. 內核中的錯誤比其餘地方的錯誤有更多的代價

內核態的內存申請API和用戶態的內存申請API使用方法很相似，所不一樣的是，由於內核態常駐運行的特殊性，內核的內存申請在可交換型、空間連續性方面會有一些差異，咱們接下來深刻學習一下它們api

Relevant Link:數組

http://blog.csdn.net/newfeicui/article/details/6437917

2. 內核態(ring0)內存申請：kmalloc/kfree、vmalloc/vfreeide

0x1: kmalloc函數原型函數

\linux-3.15.5\include\linux\slab.h性能

void *__kmalloc(size_t size, gfp_t flags);

參數說明，linux-3.15.5\include\linux\gfp.h學習

1. size_t size: 要分配的塊的大小
2. gfp_t flags: 分配標誌(flags)，用於指定kmalloc的行爲 
    1) ___GFP_DMA: #define ___GFP_DMA 0x01u: 要求分配在可以 DMA 的內存區
    2) ___GFP_HIGHMEM: #define ___GFP_HIGHMEM 0x02u: 指示分配的內存能夠位於高端內存
    3) ___GFP_DMA32: #define ___GFP_DMA32 0x04u: 
    4) ___GFP_MOVABLE: #define ___GFP_MOVABLE 0x08u: 
    5) ___GFP_WAIT: #define ___GFP_WAIT 0x10u: Allocation will not sleep.
    6) ___GFP_HIGH: #define ___GFP_HIGH 0x20u: 標識了一個高優先級請求, 它被容許來消耗甚至被內核保留給緊急情況的最後的內存頁
    7) ___GFP_IO: #define ___GFP_IO 0x40u: The allocator can start disk I/O.
    8) ___GFP_FS: #define ___GFP_FS 0x80u: The allocator can start filesystem I/O.
    9) ___GFP_COLD: #define ___GFP_COLD 0x100u: The allocator should use cache cold pages.
    10) ___GFP_NOWARN: #define ___GFP_NOWARN 0x200u: 阻止內核來發出警告(使用 printk )，當一個分配沒法知足
    11) ___GFP_REPEAT: #define ___GFP_REPEAT 0x400u: The allocator will repeat the allocation if it fails, but the allocation can potentially fail.
    12) ___GFP_NOFAIL: #define ___GFP_NOFAIL 0x800u: The allocator will indefinitely repeat the allocation. The allocation cannot fail.
    13) ___GFP_NORETRY: #define ___GFP_NORETRY 0x1000u: The allocator will never retry if the allocation fails.
    14) ___GFP_MEMALLOC: #define ___GFP_MEMALLOC 0x2000u: 
    15) ___GFP_COMP: #define ___GFP_COMP 0x4000u: Add compound page metadata. Used internally by the hugetlb code.
    16) ___GFP_ZERO: #define ___GFP_ZERO 0x8000u: 
    17) ___GFP_NOMEMALLOC: #define ___GFP_NOMEMALLOC 0x10000u
    18) ___GFP_HARDWALL #define ___GFP_HARDWALL 0x20000u
    19) ___GFP_THISNODE: #define ___GFP_THISNODE 0x40000u
    20) ___GFP_RECLAIMABLE: #define ___GFP_RECLAIMABLE 0x80000u
    21) ___GFP_KMEMCG: #define ___GFP_KMEMCG 0x100000u
    22) ___GFP_NOTRACK: #define ___GFP_NOTRACK 0x200000u
    23) ___GFP_NO_KSWAPD: #define ___GFP_NO_KSWAPD 0x400000u
    24) ___GFP_OTHER_NODE: #define ___GFP_OTHER_NODE 0x800000u
    25) ___GFP_WRITE: #define ___GFP_WRITE 0x1000000u
    /*
    除了系統默認的標誌位以後，實際編程中最經常使用的是多個宏定義"異或疊加"的標誌位
    */
    1) GFP_KERNEL: #define GFP_KERNEL (__GFP_WAIT | __GFP_IO | __GFP_FS)
    2) GFP_ATOMIC: #define GFP_ATOMIC (__GFP_HIGH): 用來從中斷處理和進程上下文以外的其餘代碼中分配內存. 從不睡眠
    3) GFP_USER: #define GFP_USER    (__GFP_WAIT | __GFP_IO | __GFP_FS | __GFP_HARDWALL): 用來爲用戶空間頁來分配內存; 它可能睡眠.

0x2: kmalloc使用方法

1. kmalloc()分配的內存處於3GB~high_memory之間的一段連續內存，這段內核空間與物理內存的映射一一對應
2. Linux處理內存分配經過建立一套固定大小的內存對象池。分配請求被這樣來處理，進入一個持有足夠大的對象的池子而且將整個內存塊遞交給請求者。驅動開發者應當記住的一件事情是，內核只能分配某些預約義的，固定大小的字節數組
3. kmalloc 可以處理的最小分配是 32 或者 64 字節(或者是其整數倍)，依賴系統的體系所使用的頁大小，因此使用kmalloc申請一個任意數量內存，咱們可能獲得稍微多於請求的，至可能是 2 倍數量
4. kmalloc 可以分配的內存塊的大小有一個上限。這個限制隨着體系和內核配置選項而變化。爲了提升咱們的LKM代碼的兼容性和可移植性，咱們能夠申請分配的內存最大隻能 128 KB
5. kmalloc特殊之處在於它分配的內存是"物理上連續"的，這對於要進行DMA的設備十分重要 
6. kmalloc最大隻能開闢(128k-16)KB，16個字節是被頁描述符結構佔用了 
7. 不少硬件須要一塊比較大的連續內存用做DMA傳送。這塊內存須要一直駐留在內存，不能被交換到文件中去。可是kmalloc最多隻能開闢大小爲32xPAGE_SIZE的內存，通常的PAGE_SIZE = 4kB，也就是kmalloc最多隻能申請128kB的大小的內存

Relevant Link:

http://oss.org.cn/kernel-book/ldd3/ch08.html
http://people.netfilter.org/rusty/unreliable-guides/kernel-hacking/routines-kmalloc.html
http://www.makelinux.net/books/lkd2/ch11lev1sec4
https://www.kernel.org/doc/htmldocs/kernel-api/API-kmalloc.html

0x3: vmalloc函數原型

\linux-3.15.5\include\linux\vmalloc.h

void * vmalloc(unsigned long size)

source/mm/vmalloc.c

*__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
{
    return __vmalloc_node(size, 1, gfp_mask, prot, NUMA_NO_NODE, __builtin_return_address(0));
}

__vmalloc_node

static void *__vmalloc_node(unsigned long size, unsigned long align, gfp_t gfp_mask, pgprot_t prot, int node, const void *caller)
{
    return __vmalloc_node_range(size, align, VMALLOC_START, VMALLOC_END, gfp_mask, prot, node, caller);
}

__vmalloc_node_range

void *__vmalloc_node_range(unsigned long size, unsigned long align,
            unsigned long start, unsigned long end, gfp_t gfp_mask,
            pgprot_t prot, int node, const void *caller)
{
    struct vm_struct *area;
    void *addr;
    unsigned long real_size = size;

    size = PAGE_ALIGN(size);
    if (!size || (size >> PAGE_SHIFT) > totalram_pages)
        goto fail;

    area = __get_vm_area_node(size, align, VM_ALLOC | VM_UNINITIALIZED,
                  start, end, node, gfp_mask, caller);
    if (!area)
        goto fail;

    addr = __vmalloc_area_node(area, gfp_mask, prot, node);
    if (!addr)
        return NULL;

    /*
     * In this function, newly allocated vm_struct has VM_UNINITIALIZED
     * flag. It means that vm_struct is not fully initialized.
     * Now, it is fully initialized, so remove this flag here.
     */
    clear_vm_uninitialized_flag(area);

    /*
     * A ref_count = 2 is needed because vm_struct allocated in
     * __get_vm_area_node() contains a reference to the virtual address of
     * the vmalloc'ed block.
     */
    kmemleak_alloc(addr, real_size, 2, gfp_mask);

    return addr;

fail:
    warn_alloc_failed(gfp_mask, 0,
              "vmalloc: allocation failure: %lu bytes\n",
              real_size);
    return NULL;
}

__vmalloc_area_node

static void *__vmalloc_area_node(struct vm_struct *area, gfp_t gfp_mask,
                 pgprot_t prot, int node)
{
    const int order = 0;
    struct page **pages;
    unsigned int nr_pages, array_size, i;
    gfp_t nested_gfp = (gfp_mask & GFP_RECLAIM_MASK) | __GFP_ZERO;

    nr_pages = get_vm_area_size(area) >> PAGE_SHIFT;
    array_size = (nr_pages * sizeof(struct page *));

    area->nr_pages = nr_pages;
    /* Please note that the recursion is strictly bounded. */
    if (array_size > PAGE_SIZE) {
        pages = __vmalloc_node(array_size, 1, nested_gfp|__GFP_HIGHMEM,
                PAGE_KERNEL, node, area->caller);
        area->flags |= VM_VPAGES;
    } else {
        pages = kmalloc_node(array_size, nested_gfp, node);
    }
    area->pages = pages;
    if (!area->pages) {
        remove_vm_area(area->addr);
        kfree(area);
        return NULL;
    }

    for (i = 0; i < area->nr_pages; i++) {
        struct page *page;
        gfp_t tmp_mask = gfp_mask | __GFP_NOWARN;

        if (node == NUMA_NO_NODE)
            page = alloc_page(tmp_mask);
        else
            page = alloc_pages_node(node, tmp_mask, order);

        if (unlikely(!page)) {
            /* Successfully allocated i pages, free them in __vunmap() */
            area->nr_pages = i;
            goto fail;
        }
        area->pages[i] = page;
    }

    if (map_vm_area(area, prot, &pages))
        goto fail;
    return area->addr;

fail:
    warn_alloc_failed(gfp_mask, order,
              "vmalloc: allocation failure, allocated %ld of %ld bytes\n",
              (area->nr_pages*PAGE_SIZE), area->size);
    vfree(area->addr);
    return NULL;
}

從內核源代碼中能夠看出，vmalloc複用了kmalloc的內存申請的代碼

0x4: vmalloc函數使用方法

char *buf;

buf = vmalloc(16 * PAGE_SIZE); /* get 16 pages */
if (!buf)
        /* error! failed to allocate memory */

/*
 * buf now points to at least a 16*PAGE_SIZE bytes
 * of virtually contiguous block of memory
 */

Relevant Link:

http://www.makelinux.net/books/lkd2/ch11lev1sec5
http://www.kerneltravel.net/journal/v/mem.htm

3. 用戶態(ring3)內存申請：malloc/free

Relevant Link:

http://www.cnblogs.com/hanyonglu/archive/2011/04/28/2031271.html

4. 內核內存申請原則

0x1: kmalloc

1. 要特別注意根據當前"CPU中斷上下文"，使用正確的標誌位申請內存
    1) 判斷申請內存的時候能否睡眠，也就是調用kmalloc的時候可否被阻塞
    2) 若是在一箇中斷處理，在中斷處理的下半部分，或者有一個鎖的時候，就不能被阻塞
    3) 若是在一個進程上下文，也沒有鎖，則通常能夠睡眠
    4) 在kprobe的回調handle中，當前CPU處於"關中斷"狀態，這個時候就不能使用"GFP_KERNEL"標誌位進行kmalloc內存申請，不然可能會由於發生kmalloc暫時申請不到內存而產生睡眠等待，繼而繼續產生CPU中斷，然而在CPU關中斷狀況下，CPU是沒法響應新的中斷的，這個時候就會引發內核panic

2. 若是能夠睡眠(CPU能夠響應新的中斷)，指定GFP_KERNEL 

3. 若是不能睡眠(CPU當前沒法響應新的中斷)，就指定GFP_ATOMIC 
GFP_KERNEL是linux內存分配器的標誌，標識着內存分配器將要採起的行爲。分配器標誌分爲行爲修飾符，區修飾符及類型。行爲修飾符表示內核應當如何分配所需的內存。區修飾符表示內存區應當從何處分配。類型就是行爲修飾符和區修飾符的合體
/*
#define GFP_KERNEL(__GFP_WAIT | __GFP_IO | __GFP_FS)
__GFP_WAIT: 缺內存頁的時候能夠睡眠
__GFP_IO: 容許啓動磁盤IO
__GFP_FS: 容許啓動文件系統IO
*/
其中，缺頁中斷的處理涉及到硬盤外設的硬件中斷的響應，可是在關中斷狀況下，CPU是沒法響應硬盤外設的中斷請求的，這時候有可能致使發生缺頁中斷的內存永遠不可用

4. 若是須要DMA能夠訪問的內存，好比ISA或者有些PCI設備，就須要指定GFP_DMA 

5. 須要對kmalloc返回的值檢查NULL 

6. 爲了沒有內存泄漏，須要用kfree()來釋放內存

0x2: vmalloc

1. vmalloc()分配的內存在 VMALLOC_START~4GB之間的一段非連續內存區域，這段非連續內存區映射到物理內存也多是非連續的
2. 在內核空間中調用kmalloc()分配連續物理空間，而調用vmalloc()分配非物理連續空間 
3. 把kmalloc()所分配內核空間中的地址稱爲"內核邏輯地址"
4. 把vmalloc()分配的內核空間中的地址稱"內核虛擬地址"
5. vmalloc()在分配過程當中須更新內核頁表

0x3: kmalloc和vmalloc的區別

1. kmalloc保證分配的內存在物理上是連續的，kmalloc()分配的內存在0xBFFFFFFF－0xFFFFFFFF以上的內存中
    1) kmalloc分配的是一段"非分頁內存(not pageable memory)"
    2) vmalloc分配的是一段"可分頁內存(pageable memory)"

2. vmalloc保證的是
    1) 在虛擬地址空間上的連續
    2) 物理地址非連續
起始位置由VMALLOL_START來決定，通常做爲交換區(可被交換到磁盤swap中)、模塊的分配

3. kmalloc能分配的大小有限，vmalloc和malloc能分配的大小相對較大(由於vmalloc還能夠處理交換空間)

4. vmalloc使用的正確場合是分配一大塊，連續的，只在軟件中存在的，用於緩衝的內存區域。不能在微處理器以外使用 

5. vmalloc 中調用了 kmalloc(GFP—KERNEL)，所以也不能應用於原子上下文 

6. kmalloc分配內存是基於slab，所以slab的一些特性包括着色，對齊等都具有，性能較好。物理地址和邏輯地址都是連續的

Relevant Link:

http://blog.csdn.net/newfeicui/article/details/6437917
http://blog.csdn.net/tigerjibo/article/details/6412881

5. 內核中分配物理地址連續的大段內存

在內核編程中，咱們經常須要臨時分配一塊任意大小的物理地址連續的內存空間，下面介紹可使用到的方法

0x1: kmalloc

因爲採用了SLUB做爲默認內存分配器, 因此 kmalloc 工做於 SLUB 分配器之上。內核初始化時，建立一組共 13 個通用對象的緩衝區。值得注意的是，kmalloc() 的底層實現也是基於 __get_free_pages() 來進行的，也正由於如此，kmalloc申請的是一段和物理內存一一對應的連續內存地址

0x2: __get_free_pages

#include <linux/gfp.h>
__get_free_pages (unsigned int gfp_mask, unsigned int order);

參數說明

1. gfp_mask 
能夠直接使用 kmalloc() 函數中使用的參數

2. order 
第二個變量不是指定大小，而表示 2^order 次方個頁，如是 0 就分配一個頁，是 3 就分配 8 個頁

若是想爲分配一塊內存空間，但嫌計算所需多少頁比較麻煩，那可使用 get_order() 函數來獲取 order 值

char *buff;
int order;

order = get_order (8192);
buff = __get_free_pages (GFP_KERNEL, order);
if (buff != NULL) 
{ 
    ... 
    free_pages (buff, order);
}

使用該函數時，必定要注意 order 最大值，該最大值定義爲 MAX_ORDER ，一般爲 11 ，也多是 10 ，這根據平臺的不一樣而不一樣。若是 order 的值國大，則分配失敗的概率就較高，一般使用小於 5 的值，即只分配 32 x PAGE_SIZE 大小的內存

0x3: static/全局變量數組

使用static或全局變量數組, 直接定義變量大小爲所需數據大小

static char buffer[ 512 * 1024 * 1024 ];

定義512M大小數組. 不過此方法應用到LKM模塊中話，會致使加載模塊速度奇慢

0x4: alloc_bootmem

alloc_bootmem()是一種內核內存預留的方式，使用alloc_bootmem系列API在start_kernel調用mem_init()以前申請所需的連續大內存。此段內存也就永久保留，除非直接引用所分配的內存地址

code example

unsigned long long pf_buf_len = 0x0;
EXPORT_SYMBOL( pf_buf_len );

void *pf_buf_addr = NULL;
EXPORT_SYMBOL( pf_buf_addr );

static int __init pf_buf_len_setup(char *str)
{
    unsigned long long size;
    unsigned int       nid = 0;
    void              *pbuff = NULL;
 // 分析參數
    size = memparse( str, &str );
    if ( *str == '@' ){
        str ++;
        get_option( &str, &nid );
    }
    //printk( KERN_INFO "pf_buf_len: Allocating %llu bytes/n", size );
 // 分配內存
    pbuff = alloc_bootmem( size );
    if ( likely( NULL != pbuff ) ) {
        printk( KERN_INFO "pf_buf_len: Allocated %llu bytes at 0x%p(0x%p) on node %u/n",
            size, pbuff, (void *)virt_to_phys(pbuff), nid);
        pf_buf_addr = pbuff;
        pf_buf_len  = size;
        goto out;
    }
    printk( KERN_ERR "pf_buf_len: Allocated %llu bytes fail./n", size );
out:
    return 1;

}
__setup( "pf_buf_len=", pf_buf_len_setup);

Relevant Link:

http://oss.org.cn/kernel-book/ldd3/ch08s03.html
http://www.groad.net/bbs/thread-1113-1-1.html
http://blog.csdn.net/force_eagle/article/details/5275572
http://www.linuxidc.com/Linux/2011-10/45459.htm

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。