linux相關視頻解析：
90分鐘瞭解Linux內存架構，numa的優勢，slab的實現，vmalloc的原理
5個方面分析linux內核架構，讓你對內核不再陌生
手把手帶你實現一個Linux內核文件系統
Linux有個叫夥伴系統的分配算法，這個算法主要解決分配連續個內存頁的問題。夥伴分配算法主要以內存頁（4KB）作爲分配單位，就是說夥伴分配算法每次可以分配 2order 個內存頁（order爲0、1、2…9）。但有時候我們只需要申請一個很小的內存區（如32字節），這時候使用夥伴分配算法就顯得浪費了。爲了解決小內存分配問題，Linux使用了slab分配算法。
相關數據結構
slab算法有兩個重要的數據結構，一個是kmem_cache_t，另外一個是slab_t。下面我們先來看看kmem_cache_t結構：
1. struct kmem_cache_s {
2. struct list_head slabs_full;
3. struct list_head slabs_partial;
4. struct list_head slabs_free;
5. unsigned int objsize;
6. unsigned int flags;
7. unsigned int num;
8. spinlock_t spinlock;
9.
10. /* 2) slab additions /removals */
11. /* order of pgs per slab (2^n) */
12. unsigned int gfporder;
13.
14. /* force GFP flags, e.g. GFP_DMA */
15. unsigned int gfpflags;
16.
17. size_t colour;
18. unsigned int colour_off;
19. unsigned int colour_next;
20. kmem_cache_t *slabp_cache;
21. ...
22. struct list_head next;
23. ...
24. };
下面介紹一下kmem_cache_t結構中比較重要的字段：
- slab_full：完全分配的slab
- slab_partial：部分分配的slab
- slab_free：沒有被分配過的slab
- objsize：存儲的對象大小
- num：一個slab能夠存儲的對象個數
- gfporder：一個slab由2gfporder個內存頁組成
- colour/colour_off/colour_next：着色區大小（後面會講到）
slab_t結構定義如下：
1. typedef struct slab_s {
2. struct list_head list;
3. unsigned long colouroff;
4. void *s_mem;
5. unsigned int inuse;
6. kmem_bufctl_t free;
7. } slab_t;
slab_t結構各個字段的用途如下：
- list：連接（全滿/部分/全空）鏈
- colouroff：着色補償
- s_mem：存儲對象的起始內存地址
- inuse：已經分配多少個對象
- free：用於連接空閒的對象
用圖來表示它們之間的關係，如下：
這裏需要解釋一下，一個slab會被劃分爲多個對象（可以理解爲結構體），這些對象是slab算法分配的最小單元，而一個slab一般有一個或者多個內存頁（但不能超過24個頁面）組成。
在kmem_cache_t結構中的slab_free鏈表的slab是內存回收的主要備選對象。由於對象是從slab中分配和釋放，所以單個slab可以在slab列表中進行一定。例如，當一個slab中所有對象被分配完時，就從slab_partial列表中移動到slab_full列表中。而當一個在slab_free列表中的slab被分配對象時，就會從slab_free列表中移動到slab_partial列表中。當一個slab中所有對象被釋放時，就會從slab_partial列表中移動到slab_free列表中。
【文章福利】需要C/C++ Linux服務器架構師學習資料加羣812855908（資料包括C/C++，Linux，golang技術，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒體，CDN，P2P，K8S，Docker，TCP/IP，協程，DPDK，ffmpeg等）
slab分配器初始化
slab分配器的初始化由kmem_cache_init()函數完成，如下：
1. void __init kmem_cache_init(void)
2. {
3. size_t left_over;
4.
5. init_MUTEX(&cache_chain_sem);
6. INIT_LIST_HEAD(&cache_chain);
7.
8. kmem_cache_estimate(0, cache_cache.objsize, 0,
9. &left_over, &cache_cache.num);
10. if (!cache_cache.num)
11. BUG();
12.
13. cache_cache.colour = left_over/cache_cache.colour_off;
14. cache_cache.colour_next = 0;
15. }
這個函數主要用來初始化cache_cache這個變量，cache_cache是一個類型爲kmem_cache_t的結構體變量，定義如下：
1. static kmem_cache_t cache_cache = {
2. slabs_full: LIST_HEAD_INIT(cache_cache.slabs_full),
3. slabs_partial: LIST_HEAD_INIT(cache_cache.slabs_partial),
4. slabs_free: LIST_HEAD_INIT(cache_cache.slabs_free),
5. objsize: sizeof(kmem_cache_t),
6. flags: SLAB_NO_REAP,
7. spinlock: SPIN_LOCK_UNLOCKED,
8. colour_off: L1_CACHE_BYTES,
9. name: "kmem_cache",
10. };
爲什麼需要一個這樣的對象呢？因爲本身kmem_cache_t結構體也是小內存對象，所以也應該有slab分配器來分配的，但這樣就出現“雞蛋和雞誰先出現”的問題。在系統初始化的時候，slab分配器還沒有初始化，所以並不能使用slab分配器來分配一個kmem_cache_t對象，這時候只能通過定義一個kmem_cache_t類型的靜態變量來來管理slab分配器了，所以cache_cache靜態變量就是用來管理slab分配器的。
從上面的代碼可知，cache_cache的objsize字段被設置爲sizeof(kmem_cache_t)的大小，所以這個對象主要是用來分配不同類型的kmem_cache_t對象的。
kmem_cache_init()函數調用了kmem_cache_estimate()函數來計算一個slab能夠保存多少個大小爲cache_cache.objsize的對象，並保存到cache_cache.num字段中。一個slab中不可能全部都用來分配對象的，舉個例子：一個4096字節大小的slab用來分配大小爲22字節的對象，可以劃分爲186個，但還剩餘4字節不能使用的，所以這部分內存用來作爲着色區。着色區的作用是爲了錯開不同的slab，讓CPU更有效的緩存slab。當然這屬於優化部分，對slab分配算法沒有多大的影響。就是說就算不對slab進行着色操作，slab分配算法還是可以工作起來的。
kmem_cache_t對象申請
kmem_cache_t是用來管理和分配對象的，所以要使用slab分配器時，必須先申請一個kmem_cache_t對象，申請kmem_cache_t對象由kmem_cache_create()函數進行：
1. kmem_cache_t *kmem_cache_create (
2. const char *name,
3. size_t size,
4. size_t offset,
5. unsigned long flags,
6. void (*ctor)(void*, kmem_cache_t *, unsigned long),
7. void (*dtor)(void*, kmem_cache_t *, unsigned long)
8. ) {
9. ...
10. cachep = (kmem_cache_t *) kmem_cache_alloc(&cache_cache, SLAB_KERNEL);
11. if (!cachep)
12. goto opps;
13. memset(cachep, 0, sizeof(kmem_cache_t));
14. ...
15. do {
16. unsigned int break_flag = 0;
17. cal_wastage:
18. kmem_cache_estimate(cachep->gfporder, size, flags,
19. &left_over, &cachep->num);
20. if (break_flag)
21. break;
22. if (cachep->gfporder >= MAX_GFP_ORDER)
23. break;
24. if (!cachep->num)
25. goto next;
26. if (flags & CFLGS_OFF_SLAB && cachep->num > offslab_limit) {
27. /* Oops, this num of objs will cause problems. */
28. cachep->gfporder--;
29. break_flag++;
30. goto cal_wastage;
31. }
32.
33. if (cachep->gfporder >= slab_break_gfp_order)
34. break;
35.
36. if ((left_over*8) <= (PAGE_SIZE<<cachep->gfporder))
37. break; /* Acceptable internal fragmentation. */
38. next:
39. cachep->gfporder++;
40. } while (1);
41.
42. if (flags & CFLGS_OFF_SLAB && left_over >= slab_size) {
43. flags &= ~CFLGS_OFF_SLAB;
44. left_over -= slab_size;
45. }
46.
47. /* Offset must be a multiple of the alignment. */
48. offset += (align-1);
49. offset &= ~(align-1);
50. if (!offset)
51. offset = L1_CACHE_BYTES;
52. cachep->colour_off = offset;
53. cachep->colour = left_over/offset;
54.
55. cachep->flags = flags;
56. cachep->gfpflags = 0;
57. if (flags & SLAB_CACHE_DMA)
58. cachep->gfpflags |= GFP_DMA;
59. spin_lock_init(&cachep->spinlock);
60. cachep->objsize = size;
61. INIT_LIST_HEAD(&cachep->slabs_full);
62. INIT_LIST_HEAD(&cachep->slabs_partial);
63. INIT_LIST_HEAD(&cachep->slabs_free);
64.
65. if (flags & CFLGS_OFF_SLAB)
66. cachep->slabp_cache = kmem_find_general_cachep(slab_size,0);
67. cachep->ctor = ctor;
68. cachep->dtor = dtor;
69. strcpy(cachep->name, name);
70.
71. down(&cache_chain_sem);
72. {
73. struct list_head *p;
74.
75. list_for_each(p, &cache_chain) {
76. kmem_cache_t *pc = list_entry(p, kmem_cache_t, next);
77. }
78. }
79.
80. list_add(&cachep->next, &cache_chain);
81. up(&cache_chain_sem);
82. opps:
83. return cachep;
84. }
kmem_cache_create()函數比較長，所以上面代碼去掉了一些不那麼重要的地方，使代碼更清晰的體現其原理。
在kmem_cache_create()函數中，首先調用kmem_cache_alloc()函數申請一個kmem_cache_t對象，我們看到調用kmem_cache_alloc()時，傳入的就是cache_cache變量。申請完kmem_cache_t對象後需要對其進行初始化操作，主要是對kmem_cache_t對象的所有字段進行初始化：1) 計算需要多少個頁面來作爲slab的大小。2) 計算一個slab能夠分配多少個對象。3) 計算着色區信息。4) 初始化slab_full / slab_partial / slab_free鏈表。5) 把申請的kmem_cache_t對象保存到cache_chain鏈表中。
對象分配
申請完kmem_cache_t對象後，就使用通過調用kmem_cache_alloc()函數來申請指定的對象。kmem_cache_alloc()函數代碼如下：
1. static inline void *
2. kmem_cache_alloc_one_tail (kmem_cache_t *cachep, slab_t *slabp)
3. {
4. void *objp;
5.
6. slabp->inuse++;
7. objp = slabp->s_mem + slabp->free*cachep->objsize;
8. slabp->free = slab_bufctl(slabp)[slabp->free];
9.
10. if (unlikely(slabp->free == BUFCTL_END)) {
11. list_del(&slabp->list);
12. list_add(&slabp->list, &cachep->slabs_full);
13. }
14. return objp;
15. }
16.
17. static inline void *
18. __kmem_cache_alloc(kmem_cache_t *cachep, int flags)
19. {
20. unsigned long save_flags;
21. void* objp;
22. struct list_head * slabs_partial, * entry;
23. slab_t *slabp;
24.
25. kmem_cache_alloc_head(cachep, flags);
26. try_again:
27. local_irq_save(save_flags);
28.
29. slabs_partial = &(cachep)->slabs_partial;
30. entry = slabs_partial->next;
31.
32. if (unlikely(entry == slabs_partial)) {
33. struct list_head * slabs_free;
34. slabs_free = &(cachep)->slabs_free;
35. entry = slabs_free->next;
36. if (unlikely(entry == slabs_free))
37. goto alloc_new_slab;
38. list_del(entry);
39. list_add(entry, slabs_partial);
40. }
41.
42. slabp = list_entry(entry, slab_t, list);
43. objp = kmem_cache_alloc_one_tail(cachep, slabp);
44.
45. local_irq_restore(save_flags);
46. return objp;
47.
48. alloc_new_slab:
49. local_irq_restore(save_flags);
50. if (kmem_cache_grow(cachep, flags))
51. goto try_again;
52. return NULL;
53. }
kmem_cache_alloc()函數被我展開之後如上代碼，kmem_cache_alloc()函數的主要步驟是：1) 從kmem_cache_t對象的slab_partial列表中查找是否有slab可用，如果有就直接從slab中分配一個對象。2) 如果slab_partial列表中沒有可用的slab，那麼就從slab_free列表中查找可用的slab，如果有可用slab，就從slab分配一個對象，並且把此slab放置到slab_partial列表中。3) 如果slab_free列表中沒有可用的slab，那麼就調用kmem_cache_grow()函數申請新的slab來進行對象的分配。
一個slab的結構如下圖：
灰色部分是着色區，綠色部分是slab管理結構，黃色部分是空閒對象鏈表的索引，紅色部分是對象的實體。我們可以看到slab結構的s_mem字段指向了對象實體列表的起始地址。
分配對象的時候就是先通過slab結構的free字段查看是否有空閒的對象可用，free字段保存了空閒對象鏈表的首節點索引。
對象釋放
對象的釋放比較簡單，主要通過調用kmem_cache_free()函數完成，而kmem_cache_free()函數最終會調用kmem_cache_free_one()函數，代碼如下：
1. static inline void
2. kmem_cache_free_one(kmem_cache_t *cachep, void *objp)
3. {
4. slab_t* slabp;
5.
6. {
7. unsigned int objnr = (objp-slabp->s_mem)/cachep->objsize;
8. slab_bufctl(slabp)[objnr] = slabp->free;
9. slabp->free = objnr;
10. }
11.
12. /* fixup slab chains */
13. {
14. int inuse = slabp->inuse;
15. if (unlikely(!--slabp->inuse)) {
16. /* Was partial or full, now empty. */
17. list_del(&slabp->list);
18. list_add(&slabp->list, &cachep->slabs_free);
19. } else if (unlikely(inuse == cachep->num)) {
20. /* Was full. */
21. list_del(&slabp->list);
22. list_add(&slabp->list, &cachep->slabs_partial);
23. }
24. }
25. }
對象釋放的時候首先會把對象的索引添加到slab的空閒對象鏈表中，然後根據slab的使用情況移動slab到合適的列表中。1) 如果slab所有對象都被釋放完時，把slab放置到slab_free列表中。2) 如果對象所在的slab原來在slab_full中，那麼就把slab移動到slab_partial中。