Linux内存管理--slab及其代码解析

struct kmem_cache {   
    struct array_cache   *array[NR_CPUS];//为了提高效率，每个cpu都有一个slab空闲对象缓存   
/* 2) Cache tunables. Protected by cache_chain_mutex */   
    unsigned int batchcount;//从本地高速缓存批量移入或移出对象的数目   
    unsigned int limit;//本地高速缓存空闲对象的***数目   
    unsigned int shared;   
    unsigned int buffer_size;   
    struct kmem_list3 *nodelists[MAX_NUMNODES];//slab高速缓存空闲，部分空闲，无空闲slab的三个链表   
   
    unsigned int flags;     /* constant flags */   
    unsigned int num;//每个slab obj的个数   
    unsigned int gfporder;//每个slab中连续页框的数目   
    gfp_t gfpflags;//分配页框时，传递给伙伴系统的标志   
    size_t colour;//slab使用的颜色个数   
    unsigned int colour_off; //slab的颜色偏移   
    struct kmem_cache *slabp_cache;  //指向存放slab描述符的chache，内部slab此字段为null   
    unsigned int slab_size;//单个slab的大小   
    unsigned int dflags;        /* dynamic flags */   
    //对象创建的构建函数   
    void (*ctor) (void *, struct kmem_cache *, unsigned long);   
    //对象的析构函数   
    void (*dtor) (void *, struct kmem_cache *, unsigned long);   
    const char *name;//slab高速缓存的名称   
    struct list_head next;//通过该字段，将该cachep链接到cachep链表上   
}   
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.

struct slab {   
    struct list_head list;  //将slab链接到各个slab链表上面，slabs_full, slabs_paril, slabs_free   
    unsigned long colouroff;//slab中***个对象的偏移   
    void *s_mem; //slab中***个对象的地址           
    unsigned int inuse; //有多少对象正在被使用   
    kmem_bufctl_t free; //表明接下来使用哪个空闲对象   
    unsigned short nodeid;//该slab属于哪个内存节点   
} 
1.
2.
3.
4.
5.
6.
7.
8.

struct kmem_list3 {   
    struct list_head slabs_partial; //对象被使用了一部分的slab描述符的链表   
    struct list_head slabs_full;//对象都被占用了的slab描述符的链表   
    struct list_head slabs_free;//只包含空闲对象的slab描述符的链表   
    unsigned long free_objects;//高速缓存中空闲对象的个数   
    unsigned int free_limit;   
    unsigned int colour_next;   /* Per-node cache coloring */   
    spinlock_t list_lock;   
    struct array_cache *shared; //指向所有cpu所共享的一个本地高速缓存   
    struct array_cache **alien; /* on other nodes */   
    unsigned long next_reap;    //由slab的页回收算法使用   
    int free_touched;       //由slab的页回收算法使用   
} 
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.

typedef unsigned int kmem_bufctl_t; 
1.

struct array_cache {   
    unsigned int avail;//本地高速缓存中可用对象的个数，也是空闲数组位置的索引   
    unsigned int limit;//本地高速缓存的大小   
    unsigned int batchcount;//本地高速缓存填充或者清空时使用到的对象个数   
    unsigned int touched;//如果本地高速缓存最近被使用过，置成1   
    spinlock_t lock;   
    void *entry[0];    
} 
1.
2.
3.
4.
5.
6.
7.
8.

static inline void *____cache_alloc(struct kmem_cache *cachep, gfp_t flags)   
{   
    void *objp;   
    struct array_cache *ac;   
   
    check_irq_off();   
    //通过进程所在的cpu的id获取slab的本地高速缓存   
    ac = cpu_cache_get(cachep);   
    //本地高速缓存中是否有空闲的slab对象   
    if (likely(ac->avail)) {   
        //有空闲对象的话，从本地高速缓存数组上取一个空闲的对象来使用   
        STATS_INC_ALLOCHIT(cachep);   
        //标记一下该本地高速缓存最近被使用过   
        ac->touched = 1;   
        //从数组的***面先取一个未使用的对象，HOHO   
        objp = ac->entry[--ac->avail];   
    } else {   
        STATS_INC_ALLOCMISS(cachep);   
        //本地高速缓存中已经没有空闲对象，需要填充本地高速缓存   
        objp = cache_alloc_refill(cachep, flags);   
    }   
    return objp;   
}   
   
    cache_alloc_refill()用来填充本地高速缓存，也是slab分配精华的地方，代码解析如下：   
static void *cache_alloc_refill(struct kmem_cache *cachep, gfp_t flags)   
{   
    int batchcount;   
    struct kmem_list3 *l3;   
    struct array_cache *ac;   
   
    check_irq_off();   
    //根据cpu id得到slab本地高速缓存的数据结构   
    ac = cpu_cache_get(cachep);   
retry:   
    //batchcount记录了此次需要填充多少个空闲对象   
    batchcount = ac->batchcount;   
    if (!ac->touched && batchcount > BATCHREFILL_LIMIT) {   
        batchcount = BATCHREFILL_LIMIT;   
    }   
    //获取到相对应的内存节点上的slab链表kmem_list3,每个内存节点都有自己的一套空闲，部分空闲，非空闲slab链表   
    //因为相应cpu访问自己所属的内存节点的速度是最快的   
    l3 = cachep->nodelists[numa_node_id()];   
   
    BUG_ON(ac->avail > 0 || !l3);   
    spin_lock(&l3->list_lock);   
   
    //从本地共享高速缓存中往本地高速缓存中填充空闲对象，要注意对于numa   
    //系统来说，往本地高速缓存上填充的空闲对象也都是该内存节点上的空闲对象   
    if (l3->shared && transfer_objects(ac, l3->shared, batchcount))   
        goto alloc_done;   
   
    while (batchcount > 0) {   
        struct list_head *entry;   
        struct slab *slabp;   
        //先从部分空闲的slab里面分配空闲对象，保留完全空闲的slab，因为空闲的   
        //slab在内存不足时是可以回收的   
        entry = l3->slabs_partial.next;   
        //如果没有了部分空闲的slab，就只能去完全空闲的slab中分配了   
        if (entry == &l3->slabs_partial) {   
            l3->free_touched = 1;   
            entry = l3->slabs_free.next;   
            //如果完全空闲的slab也没有了，就必须要为slab高速缓存分配新的slab了   
            if (entry == &l3->slabs_free)   
                goto must_grow;   
        }   
   
        slabp = list_entry(entry, struct slab, list);   
        check_slabp(cachep, slabp);   
        check_spinlock_acquired(cachep);   
        //从slab中分配空闲对象，直到slab中空闲对象不存在了，或者已经分配   
        //了足够的空闲对象了   
        while (slabp->inuse < cachep->num && batchcount--) {   
            STATS_INC_ALLOCED(cachep);   
            STATS_INC_ACTIVE(cachep);   
            STATS_SET_HIGH(cachep);   
            //此处获取空闲对象   
            ac->entry[ac->avail++] = slab_get_obj(cachep, slabp,   
                                numa_node_id());   
        }   
        check_slabp(cachep, slabp);   
   
        /* move slabp to correct slabp list: */   
        list_del(&slabp->list);   
        //若相应slab的空闲内存分配完毕，将其挂入slabs_full的slab链表中   
        if (slabp->free == BUFCTL_END)   
            list_add(&slabp->list, &l3->slabs_full);   
        else   
            list_add(&slabp->list, &l3->slabs_partial);   
    }   
   
must_grow:   
    l3->free_objects -= ac->avail;   
alloc_done:   
    spin_unlock(&l3->list_lock);   
    //没有分配到任何的对象   
    if (unlikely(!ac->avail)) {   
        int x;   
        //为高速缓存申请新的slab   
        x = cache_grow(cachep, flags, numa_node_id());   
   
        /* cache_grow can reenable interrupts, then ac could change. */   
        ac = cpu_cache_get(cachep);   
        if (!x && ac->avail == 0)    /* no objects in sight? abort */   
            return NULL;   
        //重新从头填充本地高速缓存   
        if (!ac->avail)      /* objects refilled by interrupt? */   
            goto retry;   
    }   
    ac->touched = 1;   
    //返回本地高速缓存***一个空闲对象的地址   
    return ac->entry[--ac->avail];   
}   
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
95.
96.
97.
98.
99.
100.
101.
102.
103.
104.
105.
106.
107.
108.
109.
110.
111.
112.
113.

static inline void __cache_free(struct kmem_cache *cachep, void *objp)   
{   
    struct array_cache *ac = cpu_cache_get(cachep);   
    check_irq_off();   
    objp = cache_free_debugcheck(cachep, objp, __builtin_return_address(0));   
    if (cache_free_alien(cachep, objp))   
        return;   
    //本地高速缓存可用的空闲对象尚未达到限制，将空闲对象放入本地高速缓存   
    if (likely(ac->avail < ac->limit)) {   
        STATS_INC_FREEHIT(cachep);   
        ac->entry[ac->avail++] = objp;   
        return;   
    } else {   
        //cache_flusharray()会将本地高速缓存的一些空闲对象放入到slab中   
        cache_flusharray(cachep, ac);   
        ac->entry[ac->avail++] = objp;   
    }   
}   
   
static void cache_flusharray(struct kmem_cache *cachep, struct array_cache *ac)   
{   
    int batchcount;   
    struct kmem_list3 *l3;   
    int node = numa_node_id();   
    //一次应该将batchcount个空闲对象归还到slab中   
    batchcount = ac->batchcount;   
    check_irq_off();   
    //得到对应内存节点的slab list3,上面记录着该节点的slab链表   
    l3 = cachep->nodelists[node];   
    spin_lock(&l3->list_lock);   
    //优先先归还到本地共享高速缓存中，注意本地共享高速缓存中的   
    //空闲对象是仅供该内存节点上的各个cpu分配使用的，这样可以使内存访问的效率***。   
    if (l3->shared) {   
        struct array_cache *shared_array = l3->shared;   
        int max = shared_array->limit - shared_array->avail;   
        if (max) {   
            if (batchcount > max)   
                batchcount = max;   
            //将batchcount个数组元素copy到本地高速缓存中   
            memcpy(&(shared_array->entry[shared_array->avail]),   
                   ac->entry, sizeof(void *) * batchcount);   
            shared_array->avail += batchcount;   
            goto free_done;   
        }   
    }   
    //在没有本地高速缓存的情况下，释放回slab中   
    free_block(cachep, ac->entry, batchcount, node);   
free_done:   
    spin_unlock(&l3->list_lock);   
    ac->avail -= batchcount;   
    //将删除后剩下的空闲对象往前移动一下，hoho,可能还剩下些空闲对象   
    memmove(ac->entry, &(ac->entry[batchcount]), sizeof(void *)*ac->avail);   
}   
   
static void free_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;   
        //先从对象获取到其所在的page，再从page得到其所属的slab   
        //page->lru.prev中记录了page所属的slab   
        slabp = virt_to_slab(objp);   
        l3 = cachep->nodelists[node];   
        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);   
   
        /* fixup slab chains */   
        //slab所有的对象都已经被归还   
        if (slabp->inuse == 0) {   
            //slab高速缓存的空闲对象数超过了限制，可以释放掉该slab，以   
            //释放其所占有的内存   
            if (l3->free_objects > l3->free_limit) {   
                l3->free_objects -= cachep->num;   
                slab_destroy(cachep, slabp);   
            } else {   
                //加入到完全空闲slab链表中   
                list_add(&slabp->list, &l3->slabs_free);   
            }   
        } else {   
            //加入到部分空闲的slab链表中   
            list_add_tail(&slabp->list, &l3->slabs_partial);   
        }   
    }   
}  
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.