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
轉載于:https://www.cnblogs.com/longchang/p/10749402.html
總結
以上是生活随笔為你收集整理的Linux内存管理 - slab分配器和kmalloc的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 三子棋（井字棋）的实现
- 下一篇： 利用C#编写象棋棋盘