Kernel那些事儿之内存管理(8) --- Slab（中）
上篇讲了Slab中的数据结构，这篇该讲Slab中的操作了。
既然是内存管理，那操作无非就两点：allocate 和 free。
1. 申请一个object
在Slab中，申请一个object是通过函数 kmem_cache_alloc() 来完成的。
3618 void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
3619 {
3620 return __cache_alloc(cachep, flags, __builtin_return_address(0));
3621 }
该函数有两个参数：
cachep指定了要从哪个cache中申请object.
flags: 如果该cache中所有的slab都已经满了，那就不得不向buddy system求救。flags指定了此时从buddy system中申请page frame时要使用的标志。
其实函数 kmem_cache_alloc() 只是一个wapper，经过层层调用，除去必要的锁操作，最终真正干活的是函数 ____cache_alloc()。
3190 static inline void *____cache_alloc(struct kmem_cache *cachep, gfp_t flags)
3191 {
3192 void *objp;
3193 struct array_cache *ac;
3194
3195 check_irq_off();
3196
3197 ac = cpu_cache_get(cachep);
3198 if (likely(ac->avail)) {
3199 STATS_INC_ALLOCHIT(cachep);
3200 ac->touched = 1;
3201 objp = ac->entry[--ac->avail];
3202 } else {
3203 STATS_INC_ALLOCMISS(cachep);
3204 objp = cache_alloc_refill(cachep, flags);
3205 }
3206 return objp;
3207 }
该函数看起来唬人，其实其武功招式总结起来就三招，人称“分配三板斧”。
第一板斧：per-cpu object cache.
3197 ~ 3201: 首先找到当前CPU的object cache，然后检查cache中有没有可用的object，有的话就拿出一个来。然后完活收工。
定位object cache是通过以下函数完成的：
760 static inline struct array_cache *cpu_cache_get(struct kmem_cache *cachep)
761 {
762 return cachep->array[smp_processor_id()];
763 }
上篇讲过，object cache实际上是一个LIFO的栈结构，其中成员变量 avail 即代表了可用object的个数，又作为索引值指出了栈顶位置。
所以从object cache中拿出一个object的操作，可以通过 3201 行的语句来完成。
3201 objp = ac->entry[--ac->avail];
第二板斧：Slab中的空闲object
如果object cache中没有可用的object，那就要先填充object cache。如果不考虑 shared object cache，填充cache的object来自于Slab页面。
该操作由函数 cache_alloc_refill() 完成。
2957 static void *cache_alloc_refill(struct kmem_cache *cachep, gfp_t flags)
2958 {
2959 int batchcount;
2960 struct kmem_list3 *l3;
2961 struct array_cache *ac;
2962 int node;
2963
2964 node = numa_node_id();
2965
2966 check_irq_off();
2967 ac = cpu_cache_get(cachep);
2968 retry:
2969 batchcount = ac->batchcount;
2978 l3 = cachep->nodelists[node];
2979
2980 BUG_ON(ac->avail > 0 || !l3);
2981 spin_lock(&l3->list_lock);
2982
2983 /* See if we can refill from the shared array */
2984 if (l3->shared && transfer_objects(ac, l3->shared, batchcount))
2985 goto alloc_done;
2986
2987 while (batchcount > 0) {
2988 struct list_head *entry;
2989 struct slab *slabp;
2990 /* Get slab alloc is to come from. */
2991 entry = l3->slabs_partial.next;
2992 if (entry == &l3->slabs_partial) {
2993 l3->free_touched = 1;
2994 entry = l3->slabs_free.next;
2995 if (entry == &l3->slabs_free)
2996 goto must_grow;
2997 }
2998
2999 slabp = list_entry(entry, struct slab, list);
3000 check_slabp(cachep, slabp);
3001 check_spinlock_acquired(cachep);
3002
3003 /*
3004 * The slab was either on partial or free list so
3005 * there must be at least one object available for
3006 * allocation.
3007 */
3008 BUG_ON(slabp->inuse < 0 || slabp->inuse >= cachep->num);
3009
3010 while (slabp->inuse < cachep->num && batchcount--) {
3011 STATS_INC_ALLOCED(cachep);
3012 STATS_INC_ACTIVE(cachep);
3013 STATS_SET_HIGH(cachep);
3014
3015 ac->entry[ac->avail++] = slab_get_obj(cachep, slabp,
3016 node);
3017 }
3018 check_slabp(cachep, slabp);
3019
3020 /* move slabp to correct slabp list: */
3021 list_del(&slabp->list);
3022 if (slabp->free == BUFCTL_END)
3023 list_add(&slabp->list, &l3->slabs_full);
3024 else
3025 list_add(&slabp->list, &l3->slabs_partial);
3026 }
3027
3028 must_grow:
3029 l3->free_objects -= ac->avail;
3030 alloc_done:
3031 spin_unlock(&l3->list_lock);
3032
3033 if (unlikely(!ac->avail)) {
3034 int x;
3035 x = cache_grow(cachep, flags | GFP_THISNODE, node, NULL);
3036
3037 /* cache_grow can reenable interrupts, then ac could change. */
3038 ac = cpu_cache_get(cachep);
3039 if (!x && ac->avail == 0) /* no objects in sight? abort */
3040 return NULL;
3041
3042 if (!ac->avail) /* objects refilled by interrupt? */
3043 goto retry;
3044 }
3045 ac->touched = 1;
3046 return ac->entry[--ac->avail];
3047 }
2984行先检查一下能否从shared object cache中拿一些object填充到我们的object cache中。该操作其实就是一个memory copy的过程。
2987 ~ 3026 是从Slab页面中填充object cache的操作。
该操作首先遍历所有partial的slab，然后再遍历所有free的slab。对每个slab，拿出其中的free objects，填充到object cache中。
从slab中拿出一个free object的操作由函数 slab_get_obj() 完成。
2695 static void *slab_get_obj(struct kmem_cache *cachep, struct slab *slabp,
2696 int nodeid)
2697 {
2698 void *objp = index_to_obj(cachep, slabp, slabp->free);
2699 kmem_bufctl_t next;
2700
2701 slabp->inuse++;
2702 next = slab_bufctl(slabp)[slabp->free];
2707 slabp->free = next;
2708
2709 return objp;
2710 }
我们上篇讲过，slab中所有空闲的object 的描述符组成了一个简单的链表。该函数从这个链表中取下头部的一个空闲object。
把拿出的空闲object填充到object cache的操作是由3015行完成的。
3015 ac->entry[ac->avail++] = slab_get_obj(cachep, slabp, 3016 node);
第三板斧：buddy system
如果所有的slab都满了，即每个slab都没有空闲object了，那怎么办？这个时候就得求助于buddy system了。
从buddy system中申请新的page frame，创建新的slab，从而创建出一批新的object。该操作由函数 cache_grow() 完成。
2760 static int cache_grow(struct kmem_cache *cachep,
2761 gfp_t flags, int nodeid, void *objp)
2762 {
2763 struct slab *slabp;
2764 size_t offset;
2765 gfp_t local_flags;
2766 struct kmem_list3 *l3;
2767
2768 /*
2769 * Be lazy and only check for valid flags here, keeping it out of the
2770 * critical path in kmem_cache_alloc().
2771 */
2772 BUG_ON(flags & GFP_SLAB_BUG_MASK);
2773 local_flags = flags & (GFP_CONSTRAINT_MASK|GFP_RECLAIM_MASK);
2774
2775 /* Take the l3 list lock to change the colour_next on this node */
2776 check_irq_off();
2777 l3 = cachep->nodelists[nodeid];
2778 spin_lock(&l3->list_lock);
2779
2780 /* Get colour for the slab, and cal the next value. */
2781 offset = l3->colour_next;
2782 l3->colour_next++;
2783 if (l3->colour_next >= cachep->colour)
2784 l3->colour_next = 0;
2785 spin_unlock(&l3->list_lock);
2786
2787 offset *= cachep->colour_off;
2780 ~ 2787，该函数首先确定新建slab的color值。
上篇讲过，结构体kmem_list3的成员变量colour_next，保存了下一个要使用的color值。cache描述符中的colour，保存了可用的color 数。cache描述符中的colour_off， 保存了对齐字节数。
2781 ~ 2784行把colour_next的值赋值给变量offset，然后更新colour_next的值。如果colour_next的值达到了最大值，则重置为0。
2787行用color值乘以字节对齐数，算出来的就是slab开始位置的偏移量。
确定了color值后，下一步就是要向buddy system申请page frame了。
2804 if (!objp) 2805 objp = kmem_getpages(cachep, local_flags, nodeid); 2806 if (!objp) 2807 goto failed;
为新slab申请page frame的操作由函数 kmem_getpages() 完成。
1653 static void *kmem_getpages(struct kmem_cache *cachep, gfp_t flags, int nodeid)
1654 {
1655 struct page *page;
1656 int nr_pages;
1657 int i;
1667 flags |= cachep->gfpflags;
1668 if (cachep->flags & SLAB_RECLAIM_ACCOUNT)
1669 flags |= __GFP_RECLAIMABLE;
1670
1671 page = alloc_pages_node(nodeid, flags, cachep->gfporder);
1672 if (!page)
1673 return NULL;
1674
1675 nr_pages = (1 << cachep->gfporder);
1682 for (i = 0; i < nr_pages; i++)
1683 __SetPageSlab(page + i);
1684 return page_address(page);
1685 }
函数 kmem_getpages() 首先确定分配flags。至此，调用 kmem_cache_alloc() 时传递的参数 flags 终于被用到了。但是这个flags还要再加上cache本身的flag，才会被用来申请page frame。
然后1671行调用了我们前面讲的alloc_pages函数，从buddy system中申请page frame。申请的page frame order为cachep->gfporder。
1682 ~ 1683行，为每个申请到的page frame的描述符设置 PG_slab 标志。
最后返回第一个page frame的线性地址。
好，申请到page frame了，那下一步做什么？让我们回到函数 cache_grow() 继续跟踪。
2810 slabp = alloc_slabmgmt(cachep, objp, offset, 2811 local_flags & ~GFP_CONSTRAINT_MASK, nodeid); 2812 if (!slabp) 2813 goto opps1;
2810 ~ 2813为新建的slab 分配并初始化slab描述符，由函数 alloc_slabmgmt() 完成。
2609 static struct slab *alloc_slabmgmt(struct kmem_cache *cachep, void *objp,
2610 int colour_off, gfp_t local_flags,
2611 int nodeid)
2612 {
2613 struct slab *slabp;
2614
2615 if (OFF_SLAB(cachep)) {
2616 /* Slab management obj is off-slab. */
2617 slabp = kmem_cache_alloc_node(cachep->slabp_cache,
2618 local_flags & ~GFP_THISNODE, nodeid);
2619 if (!slabp)
2620 return NULL;
2621 } else {
2622 slabp = objp + colour_off;
2623 colour_off += cachep->slab_size;
2624 }
2625 slabp->inuse = 0;
2626 slabp->colouroff = colour_off;
2627 slabp->s_mem = objp + colour_off;
2628 slabp->nodeid = nodeid;
2629 return slabp;
2630 }
2615 ~ 2620：针对external slab，从cachep->slabp_cache中分配slab描述符（以及object描述符）。
2622 ~ 2623：针对internal slab，在slab页面内指定slab描述符的地址。考虑进去slab coloring， slab描述符放在 (color*aln) 位置处。
2625 ~ 2628：初始化新建的slab描述符。正如上篇讲到的，第一个object的偏移量定义为(color * aln) + dsize。
有了slab描述符后，让我们回到函数 cache_grow() 继续跟踪。
2816 slab_map_pages(cachep, slabp, objp); 2817 2818 cache_init_objs(cachep, slabp); 2819
2816行建立page frame与cache和slab描述符之间的关联。
2737 static void slab_map_pages(struct kmem_cache *cache, struct slab *slab,
2738 void *addr)
2739 {
2740 int nr_pages;
2741 struct page *page;
2742
2743 page = virt_to_page(addr);
2744
2745 nr_pages = 1;
2746 if (likely(!PageCompound(page)))
2747 nr_pages <<= cache->gfporder;
2748
2749 do {
2750 page_set_cache(page, cache);
2751 page_set_slab(page, slab);
2752 page++;
2753 } while (--nr_pages);
2754 }
建立关联的方式就是重用了page描述符中的成员变量lru。
583 static inline void page_set_cache(struct page *page, struct kmem_cache *cache)
584 {
585 page->lru.next = (struct list_head *)cache;
586 }
595 static inline void page_set_slab(struct page *page, struct slab *slab)
596 {
597 page->lru.prev = (struct list_head *)slab;
598 }
2818行初始化新建slab中的objects.
2637 static void cache_init_objs(struct kmem_cache *cachep,
2638 struct slab *slabp)
2639 {
2640 int i;
2641
2642 for (i = 0; i < cachep->num; i++) {
2643 void *objp = index_to_obj(cachep, slabp, i);
2676 if (cachep->ctor)
2677 cachep->ctor(cachep, objp);
2679 slab_bufctl(slabp)[i] = i + 1;
2680 }
2681 slab_bufctl(slabp)[i - 1] = BUFCTL_END;
2682 slabp->free = 0;
2683 }
这个初始化做了两件事：
如果该cache定义了构造函数，则对每个新建的object执行构造函数。
初始化object描述符，构造出空闲object链表。
建立了关联，初始化了object，继续跟踪 cache_grow()。
2823 spin_lock(&l3->list_lock); 2824 2825 /* Make slab active. */ 2826 list_add_tail(&slabp->list, &(l3->slabs_free)); 2827 STATS_INC_GROWN(cachep); 2828 l3->free_objects += cachep->num; 2829 spin_unlock(&l3->list_lock); 2830 return 1; 2831 opps1: 2832 kmem_freepages(cachep, objp); 2833 failed: 2834 if (local_flags & __GFP_WAIT) 2835 local_irq_disable(); 2836 return 0; 2837 }
把新建的slab添加到cache的free slab链表中，更新kmem_list3中free_objects的值，然后完活收工。
第三板斧使出来之后，该cache新增了一slab的free object。于是重新使用第二板斧。
2. 释放一个object
释放一个object的API是函数 kmem_cache_free().
3760 void kmem_cache_free(struct kmem_cache *cachep, void *objp)
3761 {
3762 unsigned long flags;
3763
3764 local_irq_save(flags);
3765 debug_check_no_locks_freed(objp, obj_size(cachep));
3766 __cache_free(cachep, objp);
3767 local_irq_restore(flags);
3768 }
该函数也是一个wrapper，最终干活的是函数 __cache_free()。
3582 static inline void __cache_free(struct kmem_cache *cachep, void *objp)
3583 {
3584 struct array_cache *ac = cpu_cache_get(cachep);
3598
3599 if (likely(ac->avail < ac->limit)) {
3600 STATS_INC_FREEHIT(cachep);
3601 ac->entry[ac->avail++] = objp;
3602 return;
3603 } else {
3604 STATS_INC_FREEMISS(cachep);
3605 cache_flusharray(cachep, ac);
3606 ac->entry[ac->avail++] = objp;
3607 }
3608 }
相对应的，该函数也是三板斧，人称“释放三板斧”，而且这三板斧与“申请三板斧”一一对应，真是一对生死冤家。
第一板斧：per-cpu object cache
3599 ~ 3602，如果当前CPU的object cache没有满，则直接把要释放的object放到object cache中，然后完活收工。
第二板斧：Slab页面
如果object cache满了，则要刷一批object到slab页面中。该操作由函数 cache_flusharray() 完成。
3527 static void cache_flusharray(struct kmem_cache *cachep, struct array_cache *ac)
3528 {
3529 int batchcount;
3530 struct kmem_list3 *l3;
3531 int node = numa_node_id();
3532
3533 batchcount = ac->batchcount;
3537 check_irq_off();
3538 l3 = cachep->nodelists[node];
3539 spin_lock(&l3->list_lock);
3540 if (l3->shared) {
3541 struct array_cache *shared_array = l3->shared;
3542 int max = shared_array->limit - shared_array->avail;
3543 if (max) {
3544 if (batchcount > max)
3545 batchcount = max;
3546 memcpy(&(shared_array->entry[shared_array->avail]),
3547 ac->entry, sizeof(void *) * batchcount);
3548 shared_array->avail += batchcount;
3549 goto free_done;
3550 }
3551 }
3552
3553 free_block(cachep, ac->entry, batchcount, node);
3554 free_done:
3573 spin_unlock(&l3->list_lock);
3574 ac->avail -= batchcount;
3575 memmove(ac->entry, &(ac->entry[batchcount]), sizeof(void *)*ac->avail);
3576 }
3540 ~ 3551：如果shared object cache没有满额，则转移一批object到shared cache中。
3553行：利用函数 free_block() 刷一批object到slab页面中。
3575行：把object cache中剩下的object上移。为了保证object cache是LIFO的结构，会把最早放入object cache的那些object刷掉，因此需要把剩下的object向上移动。
3483 static void free_block(struct kmem_cache *cachep, void **objpp, int nr_objects,
3484 int node)
3485 {
3486 int i;
3487 struct kmem_list3 *l3;
3488
3489 for (i = 0; i < nr_objects; i++) {
3490 void *objp = objpp[i];
3491 struct slab *slabp;
3492
3493 slabp = virt_to_slab(objp);
3494 l3 = cachep->nodelists[node];
3495 list_del(&slabp->list);
3496 check_spinlock_acquired_node(cachep, node);
3497 check_slabp(cachep, slabp);
3498 slab_put_obj(cachep, slabp, objp, node);
3499 STATS_DEC_ACTIVE(cachep);
3500 l3->free_objects++;
3501 check_slabp(cachep, slabp);
3502
3503 /* fixup slab chains */
3504 if (slabp->inuse == 0) {
3505 if (l3->free_objects > l3->free_limit) {
3506 l3->free_objects -= cachep->num;
3507 /* No need to drop any previously held
3508 * lock here, even if we have a off-slab slab
3509 * descriptor it is guaranteed to come from
3510 * a different cache, refer to comments before
3511 * alloc_slabmgmt.
3512 */
3513 slab_destroy(cachep, slabp);
3514 } else {
3515 list_add(&slabp->list, &l3->slabs_free);
3516 }
3517 } else {
3518 /* Unconditionally move a slab to the end of the
3519 * partial list on free - maximum time for the
3520 * other objects to be freed, too.
3521 */
3522 list_add_tail(&slabp->list, &l3->slabs_partial);
3523 }
3524 }
3525 }
3493行根据object的地址，确定出slab描述符的地址。这里就用到我们在创建slab时建立的关联了。
612 static inline struct slab *virt_to_slab(const void *obj)
613 {
614 struct page *page = virt_to_head_page(obj);
615 return page_get_slab(page);
616 }
600 static inline struct slab *page_get_slab(struct page *page)
601 {
602 BUG_ON(!PageSlab(page));
603 return (struct slab *)page->lru.prev;
604 }
3498行把一个object放回到slab中。
2712 static void slab_put_obj(struct kmem_cache *cachep, struct slab *slabp,
2713 void *objp, int nodeid)
2714 {
2715 unsigned int objnr = obj_to_index(cachep, slabp, objp);
2727 slab_bufctl(slabp)[objnr] = slabp->free;
2728 slabp->free = objnr;
2729 slabp->inuse--;
2730 }
3504 ~ 3523：放回一个object后，就要检查该slab的状态：
partial：把slab挂到slabs_partial链表上。
free：检查cache中free object的数量有没有超过限制。
没有超过：把slab挂到slabs_free链表中。
超过了：删掉该slab，把其page frame还给buddy system。
第三板斧：buddy system
删除一个slab的操作是由函数 slab_destroy() 完成的。
1944 static void slab_destroy(struct kmem_cache *cachep, struct slab *slabp)
1945 {
1946 void *addr = slabp->s_mem - slabp->colouroff;
1947
1957 kmem_freepages(cachep, addr);
1958 if (OFF_SLAB(cachep))
1959 kmem_cache_free(cachep->slabp_cache, slabp);
1961 }
该函数首先释放slab所用的page frame，然后对于external slab，把slab描述符占用的空间释放掉。
释放slab所用page frame的操作是由函数 kmem_freepages() 完成的。
1690 static void kmem_freepages(struct kmem_cache *cachep, void *addr)
1691 {
1692 unsigned long i = (1 << cachep->gfporder);
1693 struct page *page = virt_to_page(addr);
1702 while (i--) {
1703 BUG_ON(!PageSlab(page));
1704 __ClearPageSlab(page);
1705 page++;
1706 }
1709 free_pages((unsigned long)addr, cachep->gfporder);
1710 }
1702 ~ 1706：对slab所用的每个page frame，清除其描述符中的 PG_slab 标志。
1709：调用函数 free_pages() 把slab所用的page frame还给buddy system。