Linux內存管理 - slab分配器和kmalloc

本文目的在於分析Linux內存管理機制的slab分配器。內核版本爲2.6.31。
1. SLAB分配器

內核須要常常分配內存，咱們在內核中最經常使用的分配內存的方式就是kmalloc了。前面講過的夥伴系統只支持按頁分配內存，但這個單位太大了，有時候咱們並不須要這麼大的內存，好比我想申請128字節的空間，若是直接使用夥伴系統則需分配4KB的一整頁，這顯然是浪費。

slab分配器將頁拆分爲更小的單位來管理，來知足小於一頁的內存需求。它將連續的幾個頁劃分出更小的部分拿來分配相同類型的內存對象，對象的位置儘可能作到某種對齊要求（如處理器的L1高速緩存行對齊）以便不對CPU高速緩存和TLB帶來顯著影響。slab把一類對象統一管理，例如，劃出兩個頁的內存，將其分紅n小份用來分配一類對象的實例，同時slab也維護一些通用的對象，用來供kmalloc使用。

提供小塊內存並非slab分配器的惟一任務，因爲結構上的特色，它也用做一個緩存，主要針對常常分配內存並釋放的對象。slab分配器將釋放的內存保存在一個內部列表中，並不立刻返還給夥伴系統。在請求爲該類對象分配一個實例時，會使用最近釋放的內存塊，這樣就沒必要觸及夥伴系統以縮短分配消耗的時間，另外因爲該內存塊是「新」的，其駐留在CPU高速緩存的機率也會較高。

在下面的代碼分析中，你會看到slab的這些「手段」是如何實現的。

先說一下「slab着色（slab coloring）」機制，是用來防止高速緩存衝突的：相同類型的slab、對象頗有可能被保存到相同的CPU cache的緩存行中，常用的對象被放到CPU cache中，這固然使咱們想要的，但若是兩個不一樣的對象每次都被放到相同的緩存行中，那交替的讀取這兩個對象，會致使緩存行的內容不斷的被更新，也就沒法體現緩存的好處了。不過個人內核版本是2.6.31，已經沒有slab着色機制了，因此你們看到coloring什麼的就不要再糾結了。

內核中還提供了slob和slub兩種替代品，由於slab的結構很複雜，而且須要使用太多額外的空間去管理一類對象。關於這兩個替代品我就很少說了，slub在性能和緩存佔用方面都要優於slab，而且在一些嵌入式設備上會看到內核使用slub。
2. SLAB分配器的實現
2.1 SLAB分配器初始化

系統啓動時slab分配器初始化的函數爲kmem_cache_init()和kmem_cache_init_late()。函數名中的「cache」是指slab分配器，咱們也稱做slab緩存，注意，它與CPU中的高速緩存沒有關係，但上面講到slab利用了高速緩存的特性。下面的分析中，我會使用「slab緩存」這種叫法。

kmem_cache_init()函數爲分配slab對象準備最基本的環境。在分析這個函數以前，咱們先看一個內核中建立slab緩存的例子：

    static struct kmem_cache *nf_conntrack_cachep __read_mostly;
     
    nf_conntrack_cachep= kmem_cache_create("nf_conntrack",
                         sizeof(struct nf_conn),
                         0, SLAB_DESTROY_BY_RCU, NULL);

上面的代碼在內核協議棧的連接跟蹤模塊中建立struct nf_conn的slab緩存，這個slab緩存用於分配struct nf_conn對象。

當想申請一個struct nf_conn結構的對象時，使用kmem_cache_alloc()函數進行分配。

    struct nf_conn *ct;
    ct =kmem_cache_alloc(nf_conntrack_cachep, gfp);

能夠看到，建立和使用slab緩存是很是方便的。在/proc/slabinfo文件中能夠看到內核中所建立的slab緩存。

kmem_cache_create()用於建立一個slab緩存，在哪裏建立呢，kmem_cache_init()函數的工做就是初始化用於建立slab緩存的slab緩存。也就是說，一個slab緩存也應該是經過函數kmem_cache_create()來建立的，可是很容易想到，內核中的第一個slab緩存確定不能經過這個函數來建立，在內核中使用一個編譯時生成的靜態變量做爲第一個slab緩存。

slab緩存用一個struct kmem_cache結構來描述。內核中的第一個slab緩存定義以下：

    static struct kmem_cache cache_cache = {
        .batchcount = 1,
        .limit = BOOT_CPUCACHE_ENTRIES,
        .shared = 1,
        .buffer_size = sizeof(struct kmem_cache),
        .name = "kmem_cache",
    };

系統中全部的slab緩存都被放入一個全局鏈表中：

staticstruct list_head cache_chain;

接下來咱們來分析kmem_cache_init()函數，它的實現分爲下面幾個步驟：

1.   建立cache_cache，它將用於分配系統中除了它自身之外的全部slab緩存的kmem_cache對象。

2.   建立能夠分配struct arraycache_init和struct kmem_list3的slab cache。先建立這兩個通用cache的緣由後面會講到，他們也供kmalloc使用。這兩個cache是經過kmem_cache_create()建立的，由於cache_cache已經可用了。這一步以後，將slab_early_init置爲0。

3.   使用kmem_cache_create()建立剩餘的通用cache，「剩餘」是相對第2步中的兩個cache，他們都是能夠供kmalloc使用的。這些通用cache的名字和對象大小見下面表格。

4.   爲cache_cache.array[]和malloc_sizes[INDEX_AC].cs_cachep->array[]從新分配空間。

5.   爲cache_cache.nodelists[]、malloc_sizes[INDEX_AC].cs_cachep-> nodelists[]和malloc_sizes[INDEX_L3].cs_cachep-> nodelists[]從新分配空間。

通用cache的名字和對象大小用兩個數組來記錄：malloc_sizes[]和cache_names[]。

cache_names[]
    

malloc_sizes[]

size-32
    

32

size-64
    

64

size-96
    

96

size-128
    

128

……
    

……

NULL
    

ULONG_MAX

對於數據結構的其餘細節先不作討論，在講到在一個cache上分配對象時會說明數據結構。

這部分須要注意一些靜態變量，在初始化cache_cache的時候只用到了靜態分配的變量，他們之間的關係以下圖，其中全局變量用紅色標出。


這時尚未用戶本身建立的slab cache，因此這裏看到的都是通用cache。這些通用cache主要供kmalloc使用。在這期間，不要使用kmalloc函數。
2.2 建立SLAB緩存

除了cache_cache自身，建立一個slab緩存的方法爲kmem_cache_create()。slab緩存分爲on-slab和off-slab兩種，on-slab就是slab管理信息和它所管理的對象放在一塊兒，off-slab就是slab管理信息和他所管理的對象分開存放，後面會看到爲何會區分這兩種類型的slab。

咱們先了解一下struct kmem_cache結構體的成員。

    struct kmem_cache {
    /* 1)per-cpu data, touched during every alloc/free */
        struct array_cache *array[NR_CPUS]; /*per-CPU緩存 */
    /* 2)Cache tunables. Protected by cache_chain_mutex */
        unsigned int batchcount;
        unsigned int limit;
        unsigned int shared;
     
       /*每次分配的大小，如nf_conn的cache的buffer_size爲sizeof(structnf_conn) */
        unsigned int buffer_size;
        u32 reciprocal_buffer_size;
    /* 3)touched by every alloc & free from the backend */
        unsigned int flags;      /* constant flags */
        unsigned int num;    /* # of objs per slab */
     
    /* 4)cache_grow/shrink */
        /* order of pgs per slab (2^n) */
        unsigned int gfporder;
     
        /* force GFP flags, e.g. GFP_DMA */
        gfp_t gfpflags;
     
        size_t colour;           /* cache colouring range */
        unsigned int colour_off; /* colour offset */
        /* 爲slab管理信息分配空間的cache。 */
        struct kmem_cache *slabp_cache;
        /* slab管理信息的size，即struct slab和n個kmem_bufctl_t */
        unsigned int slab_size;
        unsigned int dflags;     /* dynamic flags */
     
        /* constructor func */
        void (*ctor)(void *obj);
     
    /* 5) cache creation/removal */
        const char *name;
        struct list_head next;
     
        /*
        * We put nodelists[] at the end ofkmem_cache.
        * We still use [MAX_NUMNODES] and not [1] or[0] because cache_cache
        * is statically defined, so we reserve themax number of nodes.
        */
        struct kmem_list3 *nodelists[MAX_NUMNODES];
        /*
         * Donot add fields after nodelists[]
         */
    };

kmem_cache_create()函數的聲明以下：

    struct kmem_cache *
    kmem_cache_create(const char *name, size_t size, size_t align,
        unsigned long flags, void (*ctor)(void *));

五個參數分別爲：

name：要建立的cache的名字，將賦值給kmem_cache結構的name成員。

size：要建立的cache每次分配對象的大小，將賦值給kmem_cache結構的buffer_size成員。

align：分配對象以及slab管理信息的對齊量，基本上都爲0，即便用默認的對齊方式。

flags：標記，kmem_cache結構的flags成員。

ctor：分配新的slab的時候的構造函數，kmem_cache結構的ctor成員。

這個函數的工做以下：

1.   根據flags、CPU的cache line以及傳入的align參數，調整slab管理信息的的對齊量。

2.   用kmem_cache_zalloc(&cache_cache, gfp)在cache_cache上分配一個kmem_cache結構實例cachep。

3.   若是對象的size不小於(PAGE_SIZE >> 3)，而且全局標記slab_early_init=0，就強制給flags設置CFLGS_OFF_SLAB。

4.   根據align調整buffer_size大小，並調用calculate_slab_order()函數，該函數從order=0尋找最小的order知足2^order個頁的大小可用於分配至少一個對象，找到以後給cachep->num和cachep->gfporder賦值，num成員爲2^gfporder個頁可分配多少個對象，函數返回值left_over爲剩餘的空間。對於on slab的cache而言，知足cachep->num * cachep->buffer_size+ cachep->slab_size + left_over = (2 ^ cachep->gfporder) * PAGE_SIZE。而對於off slab的cache而言，知足cachep->num * cachep->buffer_size + left_over = (2 ^ cachep->gfporder)* PAGE_SIZE，即沒有slab管理信息的空間，由於off slab的cache的管理信息單獨放到另外一個地方。

5.   若是left_over比slab管理信息空間大，且cachep是off slab的，則把cachep改成on slab的，即清除CFLGS_OFF_SLAB標記。同時將left_over的值減掉slab管理信息的大小。

6.   給cachep的一些成員賦值：

        cachep->colour_off = cache_line_size();
        /* Offset must be a multiple of thealignment. */
        if (cachep->colour_off < align)
           cachep->colour_off = align;
        cachep->colour = left_over /cachep->colour_off;
        cachep->slab_size = slab_size;
        cachep->flags = flags;
        cachep->gfpflags = 0;
        if (CONFIG_ZONE_DMA_FLAG && (flags& SLAB_CACHE_DMA))
           cachep->gfpflags |= GFP_DMA;
        cachep->buffer_size = size;
        cachep->reciprocal_buffer_size =reciprocal_value(size);

7.   若是cachep是off slab的， slab管理信息單獨放在其餘一個地方。這個地方就是根據slab_size（slab管理信息的大小）在通用cache上選擇一個合適的cache，注意這裏只是選擇cache，沒有給slab信息分配空間。選好的cache賦值給cachep->slabp_cache。

8.   對cachep->nodelists[0]和cachep->array[0]賦值。調用的函數爲setup_cpu_cache()，這個函數中根據全局變量g_cpucache_up的值給cachep的兩個成員分配不一樣的值。最終結果就是爲cachep->array[0]分配sizeof(void *) * cachep->batchcount+ sizeof(struct array_cache)大小的空間，其中cachep->batchcount是struct array_cache中entry的數目。cachep->nodelists[0]中的三個鏈表都初始爲空。

9.   將cachep加入到全局鏈表：list_add(&cachep->next, &cache_chain);

g_cpucache_up變量：

這個變量記錄了在不一樣階段，slab緩存初始化的狀態，它可取的值有：

    static enum {
       NONE,
       PARTIAL_AC,
       PARTIAL_L3,
       EARLY,
       FULL
    } g_cpucache_up;

在kmem_cache_init()和kmem_cache_init_late()之間沒有調用過kmem_cache_create()，即在g_cpucache_up等於EARLY和FULL之間沒有建立過cache。也就是說，g_cpucache_up除了FULL以外的全部狀態都只在kmem_cache_init()中有用到，即只有建立通用cache有用到。

假定INDEX_AC=0，PARTIAL_L3=3。下表顯示了隨着建立不一樣的slab緩存，g_cpucache_up記錄的狀態的變化：

cache名稱
    

g_cpucache_up

cache_cache
    

NONE

size-32（array cache）
    

NONE

size-64（kmem_list3 structures）
    

PARTIAL_AC

其餘通用cache
    

PARTIAL_L3

自定義cache
    

FULL

 
2.3 在SLAB緩存分配空間

在slab緩存中分配對象，使用的函數是kmem_cache_alloc()或kmem_cache_zalloc()，函數返回void *類型指針。實際的分配工做由____cache_alloc()完成，它的函數體很簡單：

    static inline void *____cache_alloc(struct kmem_cache *cachep, gfp_t flags)
    {
        void *objp;
        struct array_cache *ac;
     
        ac = cpu_cache_get(cachep); /* ac =cachep->array[0] */
        if (likely(ac->avail)) {
            ac->touched= 1;
           objp = ac->entry[--ac->avail]; /* 最後一個entry */
        } else {
           objp = cache_alloc_refill(cachep, flags);
        }
        return objp;
    }

若是cachep->array[0]->avail不爲0，則直接從cachep->array[0]->entry[]末尾取一個對象返回，並將avail的值減1。

若是cachep->array[0]->avail爲0，即沒有可用對象可分配，則調用cache_alloc_refill()。

struct kmem_cache的array數組的每一個元素都是一個per-CPU緩存，slab分配一個對象，最終都是先填充到這個緩存中，再在這上面分配出去的。

    struct kmem_cache {
        /* 1) per-cpu data, touched during everyalloc/free */
        struct array_cache *array[NR_CPUS]; /*per-CPU緩存 */
        ……
    }

struct array_cache結構體定義以下：

    struct array_cache {
       unsigned int avail; /* 該緩存中可用對象的數目 */
       unsigned int limit; /* 對象數目的限制，在釋放緩存時使用 */
       /* 若是該緩存中沒有對象可分配了，每次須要向slab申請填充對象的數量 */
       unsigned int batchcount;
       unsigned int touched; /* 該緩存是不是活動的（最近分配過對象） */
       spinlock_t lock;
       void *entry[]; /* 實際的對象存放在這兒 */ /*
               * Must have thisdefinition in here for the proper
               * alignment ofarray_cache. Also simplifies accessing
               * the entries.
               */
    };

在per-CPU緩存上分配對象時，是從後往前分配的，每分配出一個對象，avail減1，因此avail除了表示可用的對象數量，仍是一個數組下標，能夠經過array.entry[avail]直接獲取對象。而在釋放對象時，則先放到per-CPU緩存的最後，由於內核假設剛釋放的對象仍然處在CPU高速緩存中，會盡快在此分配它。

per-CPU緩存的entry[]是一個指針數組，因此它只是存放對象的指針，真正的對象在slab緩存中。

咱們先看一下一個on slab的cache中每一個slab的結構：


圖中，slab中的對象總數由cachep->num記錄。colour爲着色區，咱們不去關注。slab管理信息部分包括一個struct slab結構，以及cachep->num個kmem_bufctl_t的值，方便來定位某個對象。淺藍色的對象區域存放實際的對象，每一個對象大小由cachep->buffer_size指出。能夠看出，一個slab緩存中，有不少空間用做了管理信息。

struct slab結構體定義以下，注意inuse和free兩個成員的含義：

    struct slab {
       struct list_head list;
       unsigned long colouroff;
       void *s_mem;
       /* 已經被使用的對象，最多爲cachep->num*/
       unsigned int inuse;
    /* 標識當前還未被分配的對象的kmem_bufctl_t區域偏移量 */
       kmem_bufctl_t free;
       unsigned short nodeid;
    };

咱們使用kmem_cache_alloc(cachep, flags)在cache上申請一個對象時的分配步驟以下：

1.   先試圖在array cache即cachep->array[0]->entry[]上獲取，它上面可分配的對象的數目由cachep->array[0]->avail記錄。若是這一步找到了可用對象，就返回ac->entry[--ac->avail]。注意，在kmem_cache_create的時候，沒有分配對象的空間，因此avail確定是0的。

2.   當avail=0的時候，則array cache已經用完。就試圖在kmem_list3即cachep->nodelists[0]上面分配，這就是cache_alloc_refill()函數須要作的事情。structkmem_list3中有三個雙向鏈表，分別指向「已部分使用的slab」、「已用盡的slab」和「徹底空閒的slab」。


1） cache_alloc_refill()先查找slabs_partial鏈表中有沒有slab，若是有則在這裏分配；若是沒有則查找slabs_free鏈表中有沒有slab，若是有則在這裏分配。在這兩個鏈表上分配對象的方式爲：將slab中的cachep->array[0]->batchcount數量的對象「分配」給cachep->array[0]->entry[]，這個「分配」的過程只是指針指向的操做。而後cachep->array[0]的inuse成員的值增長，free成員前移，同時更新cachep->array[0]->avail的值。這樣，array cache上又可分配對象了，因而返回ac->entry[--ac->avail]。

注意，在slab分配出去batchcount個對象後，須要判斷該slabs鏈表是否用盡，若是用盡就將其轉移到slabs_full鏈表中。

2） 若是在slabs_partial和slabs_free鏈表中都沒有slab對象了，就須要在內存中從新分配一個slab。這是cache_grow()函數的工做。

3.   cache_grow()函數的主要任務就是在夥伴系統中分配2^(cachep->gfporder)個頁，並給分配的頁都加上PG_slab標記使其爲slab使用。該函數具體實現以下：

a)     算出這次分配的slab的colour空間，其實這些結構體的colour相關的成員在內核中並無用到。下面代碼中cachep->colour是在建立cache的時候經過left_over計算的，爲顏色數量，l3->colour_next是當前選擇cachep->colour中的哪一個顏色，cachep->colour_off是每一個顏色佔用的空間大小。最後算出的offset便是上圖中最開始的colour區域的長度。

        l3 = cachep->nodelists[nodeid];
        spin_lock(&l3->list_lock);
        offset = l3->colour_next;/* init as 0 */
        l3->colour_next++;
        if (l3->colour_next >= cachep->colour)
           l3->colour_next = 0; /* 取值爲0 ~ colour-1 */
        spin_unlock(&l3->list_lock);
        offset *= cachep->colour_off;

例如若是一個cache的cachep->colour=3，即有三種顏色，則分配的slab開頭的colour區域的長度就可能爲0、cachep->colour_off和2 * cachep->colour_off。

b)    分配2^(cachep->gfporder)個頁，並給分配的頁加上PG_slab標記。分配成功後得到第一個頁的起始地址的指針objp。

c)     在objp中分配slab管理信息的空間。這裏分爲兩種狀況，若是cache是on slab的，則直接在objp的地址上非slab管理信息分配空間，並給struct slab的成員賦值。而若是是off slab的，即slab管理信息和slab對象不在一塊兒，這時slab管理信息對象是在cachep->slabp_cache上分配的，分配的函數依然是調用kmem_cache_alloc()。

d)    將分配的全部頁與所屬的slab和cache創建映射關係，具體作法爲，將objp開始的2^(cache->gfporder)個頁對應的struct page都進行如下賦值：

    page->lru.next = (structlist_head *)cache;
    page->lru.prev = (structlist_head *)slab;

其中cache和slab是當前的cache和剛分配的slab信息。這樣的目的是爲了能夠方便的找到一個對象所屬於的slab和cache。

e)    調用每一個對象的ctor方法，並給每一個對象對應的kmem_bufctl_t賦個值，這個值從1開始，直到cachep->num-1，最後一個kmem_bufctl_t賦值爲BUFCTL_END。

f)     將分配好的slab添加到l3的slabs_free列表中，即cachep->nodelists[0]->slabs_free列表。同時l3->free_objects += cachep->num，注意這個值是l3中的三個列表中可用對象的總數，但不是cachep中可用對象的總數，由於ac->entry[]中還有。

cache_grow()返回後，從新執行cache_alloc_refill()函數，這時即可以在上述的步驟中即可以找到一個對象來返回。

咱們再回過頭來看一下爲cachep分配slab管理信息的函數alloc_slabmgmt()。上面的c)步驟中講到在off slab的時候要在cachep->slabp_cache上分配slab管理信息，咱們知道這個slabp_cache是在kmem_cache_create的時候根據slab_size大小在通用cache上選擇的一個合適的cache。而在分配slab管理信息的時候，slab管理信息做爲cache的對象slabp_cache又會有它本身的slab管理信息，這樣又會重複這一分配動做，一定會致使遞歸，固然遞歸的前提是slabp_cache是off slab的，也就說，slabp_cache不能是off slab的。我實際看到的slabp_cache都是size-64或size-32，所以都是on slab的，我人爲的將size-64或size-32改成off slab的，不出所料，kernel就起不來了。

若是cache是off slab的，那它的slab結構分爲兩部分：


2.4 在SLAB緩存釋放空間

釋放slab對象使用kmem_cache_free()函數，它直接調用了__cache_free()函數。

釋放一個對象時，分爲兩種狀況：

1. 若是per-CPU緩存中可用對象數目小於其limit的限制，則直接將對象釋放到per-CPU緩存中。

2. 若是per-CPU緩存中可用對象數目達到其limit的限制，則須要先將batchcount數目的對象釋放到slab緩存中，這個釋放動做順序爲從前日後（即釋放下標爲0~batchcount-1的對象），由於這時最開始釋放的對象極可能已經不在高速緩存中了。而後再將咱們要釋放的對象釋放到per-CPU緩存中，而且將以前下標爲batchcount以及以後的對象前移。

    static inline void__cache_free(struct kmem_cache *cachep, void *objp)
    {
       struct array_cache *ac = cpu_cache_get(cachep);
     
       ……
     
       if (likely(ac->avail < ac->limit)) {
           ac->entry[ac->avail++] = objp;
           return;
       } else {
           cache_flusharray(cachep, ac);
           ac->entry[ac->avail++] = objp;
       }
    }

釋放部分對象到slab緩存中的函數爲cache_flusharray()，最終經過free_block()完成的，free_block()函數的工做是：

1. 獲取對象所在的slab緩存，這是經過virt_to_page()來完成的。前面在分析cache_grow()函數時講到過slab和page的關係。

2. 將獲得的slab從緩存鏈表中刪除。

3. 將對象放回到slab中。

4. 將slab從新添加到緩存鏈表中，分兩種狀況：若是這時slab中全部對象都是未使用的，就將其放到slabs_free鏈表中，不然將其放到slabs_partial鏈表中。另外，若是將slab放到slabs_free鏈表，會先檢查緩存中空閒對象數目總數是否超過了預約義的free_limit限制，若是超過了，則直接調用slab_destroy()釋放掉這個slab。

    static voidfree_block(struct kmem_cache *cachep, void **objpp, int nr_objects,
                  int node)
    {
       int i;
       struct kmem_list3 *l3;
     
       for (i = 0; i < nr_objects; i++) {
           void *objp = objpp[i];
           struct slab *slabp;
          
           /* 獲取對象所在的slab */
           slabp = virt_to_slab(objp);
           l3 = cachep->nodelists[node];
     
           /* 將slab刪除 */
           list_del(&slabp->list);
           check_spinlock_acquired_node(cachep, node);
           check_slabp(cachep, slabp);
     
           /* 將對象放回slab中 */
           slab_put_obj(cachep, slabp, objp, node);
           STATS_DEC_ACTIVE(cachep);
           l3->free_objects++;
           check_slabp(cachep, slabp);
     
           /* 將slab從新添加到緩存鏈表中 */
           if (slabp->inuse == 0) {
              /* 若是對象總數超出限制，釋放整個slab */
              if (l3->free_objects > l3->free_limit) {
                  l3->free_objects -= cachep->num;
                  /* No need to drop any previously held
                   * lock here,even if we have a off-slab slab
                   * descriptor itis guaranteed to come from
                   * a differentcache, refer to comments before
                   *alloc_slabmgmt.
                   */
                  slab_destroy(cachep, slabp);
              } else {
                  /* 添加到slabs_free鏈表中的開頭 */
                  list_add(&slabp->list, &l3->slabs_free);
              }
           } else {
              /* Unconditionally move a slab to the end of the
               * partial list onfree - maximum time for the
               * other objects tobe freed, too.
               */
              /* 添加到slabs_partial鏈表的末尾 */
              list_add_tail(&slabp->list,&l3->slabs_partial);
           }
       }
    }

2.5 銷燬SLAB緩存

要銷燬一個slab緩存（struct kmem_cache結構的實例），須要調用kmem_cache_destroy()函數，該函數刪除緩存的步驟爲：

1. 將cachep從cache_cache鏈表中刪除。

2. 將cachep中全部對象釋放掉，空間還給夥伴系統。若是該slab緩存是off-slab的，還要將slab管理信息從cachep->slabp_cache中釋放。

3. 將cachep的per-CPU緩存和struct kmem_list3結構釋放。

4. 因爲cachep是cache_cache的一個對象，因此須要將cache_cache中將該對象刪除，這一步使用了kmem_cache_free()函數，將slab緩存包括它管理的全部對象都釋放。
2. kmalloc

slab是kmalloc的基礎，kmalloc使用上面講到的通用slab緩存來分配空間。

void *kmalloc(size_t size,gfp_t flags);

kmalloc可分配的最大size由KMALLOC_MAX_SIZE定義，這個值在2^25B和buddy的最大分配階之間取一個小值。

    #defineKMALLOC_SHIFT_HIGH  ((MAX_ORDER +PAGE_SHIFT - 1) <= 25 ? \
                  (MAX_ORDER + PAGE_SHIFT - 1) : 25)
    #define KMALLOC_MAX_SIZE (1UL<< KMALLOC_SHIFT_HIGH)
    #defineKMALLOC_MAX_ORDER   (KMALLOC_SHIFT_HIGH -PAGE_SHIFT)

kmalloc的實現很簡單：

1.   根據size大小找到最小能裝下一個對象的通用cache。

2.   調用kmem_cache_alloc(cachep,flags)進行分配。

由此可知，kmalloc分配的空間是物理上連續的。

原文：https://blog.csdn.net/jasonchen_gbd/article/details/44024009