kk Blog —— 通用基础

static void 
shrink_zone(struct zone *zone, struct scan_control *sc) 
{ 
	unsigned long nr_active; 
	unsigned long nr_inactive; 

	//根据优先级，得到可以扫描的页面数，优先级越高， 
	//代表越不急迫，可以扫描的页面数也最少 
	zone->nr_scan_active += (zone->nr_active >> sc->priority) + 1; 
	nr_active = zone->nr_scan_active; 
	if (nr_active >= SWAP_CLUSTER_MAX) 
		zone->nr_scan_active = 0; 
	else 
		nr_active = 0; 

	zone->nr_scan_inactive += (zone->nr_inactive >> sc->priority) + 1; 
	nr_inactive = zone->nr_scan_inactive; 
	//非活动页比较少的话，可以先忽略过去，将跳过的页面记录到nr_scan_inactive中 
	//留待下一次再处理 
	if (nr_inactive >= SWAP_CLUSTER_MAX) 
		zone->nr_scan_inactive = 0; 
	else 
		nr_inactive = 0; 

	//设置需要回收的页面数为32个 
	sc->nr_to_reclaim = SWAP_CLUSTER_MAX; 

	//开始回收页面，每次扫描32个页面，多了不干噢!!! 
	while (nr_active || nr_inactive) { 
		if (nr_active) { 
			//设置每次要扫描的非活动页面数，需要将其放 
			//入到inactive list里面 
			sc->nr_to_scan = min(nr_active, 
			(unsigned long)SWAP_CLUSTER_MAX); 
			nr_active -= sc->nr_to_scan; 
			//补充inactive list中的页面 
			refill_inactive_zone(zone, sc); 
		} 

		if (nr_inactive) { 
			//设置每次将要扫描的页面，最多也就32个页面 
			sc->nr_to_scan = min(nr_inactive, 
			(unsigned long)SWAP_CLUSTER_MAX); 

			nr_inactive -= sc->nr_to_scan; 
			//开始正式回收inactive list中的页面 
			shrink_cache(zone, sc); 
			//32个页面被回收完毕，大功告成了!!! 
			if (sc->nr_to_reclaim <= 0) 
				break; 
		}
	} 
} 

static int shrink_list(struct list_head *page_list, struct scan_control *sc) 
{ 
	LIST_HEAD(ret_pages);
	struct pagevec freed_pvec;
	int pgactivate = 0;
	int reclaimed = 0;
	//有进程需要调度，先进行调度 
	cond_resched();

	pagevec_init(&freed_pvec, 1); 
	//对于page_list 链表上的每一个页面试图进行回收 
	while (!list_empty(page_list)) { 
		struct address_space *mapping; 
		struct page *page; 
		int may_enter_fs; 
		int referenced; 

		//获取一个页面 
		page = lru_to_page(page_list); 
		//从lru上摘除 
		list_del(&page->lru); 
		//page被锁定，不能回收 
		if (TestSetPageLocked(page))//page is locked? 
			goto keep; 

		BUG_ON(PageActive(page)); 
		//page正在被writeback，不能回收 
		if (PageWriteback(page))//page is writeback? 
			goto keep_locked; 

		sc->nr_scanned++; 
		/* Double the slab pressure for mapped and swapcache pages */ 

		if (page_mapped(page) || PageSwapCache(page)) 
			sc->nr_scanned++; 
		//查看最近该页面有无被访问过 
		referenced = page_referenced(page, 1, sc->priority <= 0); 
		/* In active use or really unfreeable?  Activate it. */ 
		//1页面被访问过，2页面在用户态空间，页面是文件映射页面， 
		//页面在交换高速缓存中，同时满足这两个条件的话，页面不被回收 
		if (referenced && page_mapping_inuse(page)) 
			goto activate_locked; 

		#ifdef CONFIG_SWAP
		//page is anon and page has not been add to swapcache 
		//该页面是匿名映射的页面，且该页面不在swapcache中 
		if (PageAnon(page) && !PageSwapCache(page)) { 
			//将页面加入到swap cache中 
			if (!add_to_swap(page)) 
				goto activate_locked; 
		}
		#endif /* CONFIG_SWAP */ 
		//得到对应的address_space，有可能是对应文件的address_space,或者是 
		//swap cache的address_space 
		mapping = page_mapping(page); 
		may_enter_fs = (sc->gfp_mask & __GFP_FS) || 
				(PageSwapCache(page) && (sc->gfp_mask & __GFP_IO)); 

		//该页面被映射到某个用户页表中 
		if (page_mapped(page) && mapping) { 
			//将该页面在用户页表中的页表项通通清除 
			switch (try_to_unmap(page)) { 
				case SWAP_FAIL: 
				goto activate_locked; 
				case SWAP_AGAIN: 
				goto keep_locked; 
				case SWAP_SUCCESS: 
				; /* try to free the page below */ 
			} 
		} 
		//页面是脏的，哈哈，准备往文件或swapcache里面写硬盘吧 
		if (PageDirty(page)) { 
			if (referenced) 
				goto keep_locked; 
			if (!may_enter_fs) 
				goto keep_locked; 
			if (laptop_mode && !sc->may_writepage) 
				goto keep_locked; 

			/* Page is dirty, try to write it out here */ 
			//往磁盘上写页面 
			switch(pageout(page, mapping)) { 
				case PAGE_KEEP: 
					goto keep_locked; 
				case PAGE_ACTIVATE: 
					goto activate_locked; 
				case PAGE_SUCCESS: 
					if (PageWriteback(page) || PageDirty(page)) 
						goto keep; 

					if (TestSetPageLocked(page)) 
						goto keep; 
					if (PageDirty(page) || PageWriteback(page)) 
						goto keep_locked; 
					mapping = page_mapping(page); 
				case PAGE_CLEAN: 
					; /* try to free the page below */ 
			} 
		}

		//若页面是缓冲区页面，将对应的buffer_head给释放掉 
		if (PagePrivate(page)) { 
			if (!try_to_release_page(page, sc->gfp_mask)) 
				goto activate_locked; 
			if (!mapping && page_count(page) == 1) 
				goto free_it; 
		} 

		if (!mapping) 
			goto keep_locked; 
		/* truncate got there first */ 

		spin_lock_irq(&mapping->tree_lock); 

		//页面为脏页面或者page的引用计数为2，都是不可以回收的  
		if (page_count(page) != 2 || PageDirty(page)) { 
			spin_unlock_irq(&mapping->tree_lock); 
			goto keep_locked; 
		}

		#ifdef CONFIG_SWAP 
			//到达这里，说明该page只被swap cache或者页高速缓存及 
			//fpra所共有，需要将其从swap cache上或者页高速缓存上删除。 
		if (PageSwapCache(page)) { 
			swp_entry_t swap = { .val = page->private }; 
			//从swap cache上进行删除 
			__delete_from_swap_cache(page); 
			spin_unlock_irq(&mapping->tree_lock); 
			swap_free(swap); 
			__put_page(page); 
			/* The pagecache ref */ 
			goto free_it; 
		} 
		#endif /* CONFIG_SWAP */ 

		//从页面高速缓存中将该页面删除 
		__remove_from_page_cache(page); 
		spin_unlock_irq(&mapping->tree_lock); 
		__put_page(page); 

		free_it: 
			unlock_page(page); 
			reclaimed++; 
			if (!pagevec_add(&freed_pvec, page)) 
				__pagevec_release_nonlru(&freed_pvec); 
			continue; 

		activate_locked: 
			//将页面设为active页面，等回去将其放入lru的active链表 
			SetPageActive(page); 
			pgactivate++; 
		keep_locked: 
			//保持页面的状态不变，放入对应的lru active或inactive链表中 
			unlock_page(page); 
		keep: 
			//将该无法回收的页面，放入到ret_pages链表中 
			list_add(&page->lru, &ret_pages); 
			BUG_ON(PageLRU(page)); 
	} 
	//此处将无法回收的页面放入page_list中，在函数返回后，去其进行处理 
	list_splice(&ret_pages, page_list); 
	//此处将可以释放的页面通通给释放掉，回收了^_^ 

	if (pagevec_count(&freed_pvec)) 
		__pagevec_release_nonlru(&freed_pvec); 
	mod_page_state(pgactivate, pgactivate); 
	sc->nr_reclaimed += reclaimed; 
	return reclaimed; 
}