Linux内核源代码情形分析-内存管理之slab-回收

Linux内核源代码情景分析-内存管理之slab-回收

    在上一篇文章Linux内核源代码情景分析-内存管理之slab-分配与释放，最后形成了如下图的结构：

                                                                                                          图 1

    我们看到空闲slab块占用的若干页面，不会自己释放；我们是通过kmem_cache_reap和kmem_cache_shrink来回收的。他们的区别是：

   

    1、我们先看kmem_cache_shrink，代码如下：

int kmem_cache_shrink(kmem_cache_t *cachep)
{
	if (!cachep || in_interrupt() || !is_chained_kmem_cache(cachep))
		BUG();

	return __kmem_cache_shrink(cachep);
}

    __kmem_cache_shrink，代码如下：

static int __kmem_cache_shrink(kmem_cache_t *cachep)
{
	slab_t *slabp;
	int ret;

	drain_cpu_caches(cachep);

	spin_lock_irq(&cachep->spinlock);

	/* If the cache is growing, stop shrinking. */
	while (!cachep->growing) {//确定缓存区不在growing
		struct list_head *p;

		p = cachep->slabs.prev;//链表最后面的是空闲块，本例中就是第4个空闲块
		if (p == &cachep->slabs)//如果链表中没有slab块，就直接break
			break;

		slabp = list_entry(cachep->slabs.prev, slab_t, list);
		if (slabp->inuse)//如果不是空闲块，就break
			break;

		list_del(&slabp->list);//如果是空闲块就删除，这样下一次循环cachep->slabs.prev找的就是新的slab块
		if (cachep->firstnotfull == &slabp->list)//如果firstnotfull就是这个空闲块，那么系统中一定没有部分块或者空闲块可供分配了
			cachep->firstnotfull = &cachep->slabs;//指向cachep->slabs

		spin_unlock_irq(&cachep->spinlock);
		kmem_slab_destroy(cachep, slabp);//析构对象，并释放空闲slab块所在的所有页面
		spin_lock_irq(&cachep->spinlock);
	}
	ret = !list_empty(&cachep->slabs);
	spin_unlock_irq(&cachep->spinlock);
	return ret;
}

    kmem_slab_destroy，析构对象，并释放空闲slab块所在的所有页面，代码如下：

static void kmem_slab_destroy (kmem_cache_t *cachep, slab_t *slabp)
{
	if (cachep->dtor
        ......
	) {
		int i;
		for (i = 0; i < cachep->num; i++) {
			void* objp = slabp->s_mem+cachep->objsize*i;
                        ......
			if (cachep->dtor)
				(cachep->dtor)(objp, cachep, 0);//析构所有对象
                        ......
		}
	}

	kmem_freepages(cachep, slabp->s_mem-slabp->colouroff);//释放空闲slab块所占的所有页面
	if (OFF_SLAB(cachep))
		kmem_cache_free(cachep->slabp_cache, slabp);
}

    kmem_freepages，释放空闲slab块所占的所有页面，代码如下：

static inline void kmem_freepages (kmem_cache_t *cachep, void *addr)
{
	unsigned long i = (1<<cachep->gfporder);
	struct page *page = virt_to_page(addr);

	/* free_pages() does not clear the type bit - we do that.
	 * The pages have been unlinked from their cache-slab,
	 * but their 'struct page's might be accessed in
	 * vm_scan(). Shouldn't be a worry.
	 */
	while (i--) {
		PageClearSlab(page);
		page++;
	}
	free_pages((unsigned long)addr, cachep->gfporder);
}

    2、再看kmem_cache_reap，遍历cache_chain链表查找合适的缓存区，而且只释放了所选中的缓存区中最多80%的完全空闲slab块，代码如下：

void kmem_cache_reap (int gfp_mask)
{
	slab_t *slabp;
	kmem_cache_t *searchp;
	kmem_cache_t *best_cachep;
	unsigned int best_pages;
	unsigned int best_len;
	unsigned int scan;

	if (gfp_mask & __GFP_WAIT)
		down(&cache_chain_sem);
	else
		if (down_trylock(&cache_chain_sem))
			return;

	scan = REAP_SCANLEN;
	best_len = 0;
	best_pages = 0;
	best_cachep = NULL;
	searchp = clock_searchp;//上一次考察的缓存区
	do {
		unsigned int pages;
		struct list_head* p;
		unsigned int full_free;

		/* It's safe to test this without holding the cache-lock. */
		if (searchp->flags & SLAB_NO_REAP)
			goto next;
		spin_lock_irq(&searchp->spinlock);
		if (searchp->growing)//缓存区不能处于增长状态
			goto next_unlock;
		if (searchp->dflags & DFLGS_GROWN) {
			searchp->dflags &= ~DFLGS_GROWN;
			goto next_unlock;
		}
                ......

		full_free = 0;
		p = searchp->slabs.prev;//从空闲块开始
		while (p != &searchp->slabs) {
			slabp = list_entry(p, slab_t, list);
			if (slabp->inuse)
				break;
			full_free++;//有一个空闲块,full_free就加1
			p = p->prev;//往前继续搜索
		}

		/*
		 * Try to avoid slabs with constructors and/or
		 * more than one page per slab (as it can be difficult
		 * to get high orders from gfp()).
		 */
		pages = full_free * (1<<searchp->gfporder);//若干空闲块所占的页面数
		if (searchp->ctor)
			pages = (pages*4+1)/5;
		if (searchp->gfporder)
			pages = (pages*4+1)/5;//页面数的百分之80
		if (pages > best_pages) {//找到空闲块所占页面数最多的
			best_cachep = searchp;
			best_len = full_free;//空闲块的个数
			best_pages = pages;//若干空闲块所占的页面数的百分之80
			if (full_free >= REAP_PERFECT) {
				clock_searchp = list_entry(searchp->next.next,
							kmem_cache_t,next);
				goto perfect;
			}
		}
next_unlock:
		spin_unlock_irq(&searchp->spinlock);
next:
		searchp = list_entry(searchp->next.next,kmem_cache_t,next);
	} while (--scan && searchp != clock_searchp);//遍历cache_chain链表查找合适的缓存区

	clock_searchp = searchp;//这次考察的，也就是下次考察的开始

	if (!best_cachep)//没有找到
		/* couldn't find anything to reap */
		goto out;

	spin_lock_irq(&best_cachep->spinlock);
perfect:
	/* free only 80% of the free slabs */
	best_len = (best_len*4 + 1)/5;//空闲块个数的百分之80
	for (scan = 0; scan < best_len; scan++) {//依次释放空闲块
		struct list_head *p;

		if (best_cachep->growing)//不能处于增长状态
			break;
		p = best_cachep->slabs.prev;//因为刚才空闲slab块已经删除，所以又指向了新的空闲slab块
		if (p == &best_cachep->slabs)//说明所有slab块都已经被遍历过了,break
			break;
		slabp = list_entry(p,slab_t,list);
		if (slabp->inuse)//不是空闲块，break
			break;
		list_del(&slabp->list);//删除空闲slab
		if (best_cachep->firstnotfull == &slabp->list)//如果firstnotfull就是这个空闲块，那么系统中一定没有部分块或者空闲块可供分配了
			best_cachep->firstnotfull = &best_cachep->slabs;//指向cachep->slabs
		STATS_INC_REAPED(best_cachep);

		/* Safe to drop the lock. The slab is no longer linked to the
		 * cache.
		 */
		spin_unlock_irq(&best_cachep->spinlock);
		kmem_slab_destroy(best_cachep, slabp);//同上
		spin_lock_irq(&best_cachep->spinlock);
	}
	spin_unlock_irq(&best_cachep->spinlock);
out:
	up(&cache_chain_sem);
	return;
}