自学教程：C++ INC_CACHE_INFO函数代码示例

/* * Lookup a swap entry in the swap cache. A found page will be returned * unlocked and with its refcount incremented - we rely on the kernel * lock getting page table operations atomic even if we drop the page * lock before returning. */struct page * lookup_swap_cache(swp_entry_t entry){	struct page *page;	page = find_get_page(&swapper_space, entry.val);	if (page)		INC_CACHE_INFO(find_success);	INC_CACHE_INFO(find_total);	return page;}

/* * Lookup a swap entry in the swap cache. A found page will be returned * unlocked and with its refcount incremented - we rely on the kernel * lock getting page table operations atomic even if we drop the page * lock before returning. */struct page * lookup_swap_cache(swp_entry_t entry){    struct page *page;    page = find_get_page(swap_address_space(entry), entry.val);    if (page) {        INC_CACHE_INFO(find_success);        if (TestClearPageReadahead(page))            atomic_inc(&swapin_readahead_hits);    }    INC_CACHE_INFO(find_total);    return page;}

/* * Lookup a swap entry in the swap cache. A found page will be returned * unlocked and with its refcount incremented - we rely on the kernel * lock getting page table operations atomic even if we drop the page * lock before returning. */struct page * lookup_swap_cache(swp_entry_t entry){	struct page *page;	page = find_get_page(swap_address_space(entry), swp_offset(entry));	if (page && likely(!PageTransCompound(page))) {		INC_CACHE_INFO(find_success);		if (TestClearPageReadahead(page))			atomic_inc(&swapin_readahead_hits);	}	INC_CACHE_INFO(find_total);	return page;}

/* * add_to_swap_cache resembles add_to_page_cache_locked on swapper_space, * but sets SwapCache flag and private instead of mapping and index. */int add_to_swap_cache(struct page *page, swp_entry_t entry, gfp_t gfp_mask){	int error;	VM_BUG_ON(!PageLocked(page));	VM_BUG_ON(PageSwapCache(page));	VM_BUG_ON(!PageSwapBacked(page));	error = radix_tree_preload(gfp_mask);	if (!error) {		page_cache_get(page);		SetPageSwapCache(page);		set_page_private(page, entry.val);		spin_lock_irq(&swapper_space.tree_lock);		error = radix_tree_insert(&swapper_space.page_tree,						entry.val, page);		if (likely(!error)) {			total_swapcache_pages++;			__inc_zone_page_state(page, NR_FILE_PAGES);			INC_CACHE_INFO(add_total);		}		spin_unlock_irq(&swapper_space.tree_lock);		radix_tree_preload_end();		if (unlikely(error)) {			set_page_private(page, 0UL);			ClearPageSwapCache(page);			page_cache_release(page);		}	}	return error;}

/* * __add_to_swap_cache resembles add_to_page_cache_locked on swapper_space, * but sets SwapCache flag and private instead of mapping and index. */static int __add_to_swap_cache(struct page *page, swp_entry_t entry){	int error;	VM_BUG_ON(!PageLocked(page));	VM_BUG_ON(PageSwapCache(page));	VM_BUG_ON(!PageSwapBacked(page));	page_cache_get(page);	SetPageSwapCache(page);	set_page_private(page, entry.val);	spin_lock_irq(&swapper_space.tree_lock);	error = radix_tree_insert(&swapper_space.page_tree, entry.val, page);	if (likely(!error)) {		total_swapcache_pages++;		__inc_zone_page_state(page, NR_FILE_PAGES);		INC_CACHE_INFO(add_total);	}	spin_unlock_irq(&swapper_space.tree_lock);	if (unlikely(error)) {		/*		 * Only the context which have set SWAP_HAS_CACHE flag		 * would call add_to_swap_cache().		 * So add_to_swap_cache() doesn't returns -EEXIST.		 */		VM_BUG_ON(error == -EEXIST);		set_page_private(page, 0UL);		ClearPageSwapCache(page);		page_cache_release(page);	}	return error;}

/** * add_to_swap - allocate swap space for a page * @page: page we want to move to swap * * Allocate swap space for the page and add the page to the * swap cache.  Caller needs to hold the page lock.  */int add_to_swap(struct page * page, gfp_t gfp_mask){	swp_entry_t entry;	int err;	if (!PageLocked(page))		BUG();	for (;;) {		entry = get_swap_page();		if (!entry.val)			return 0;		/*		 * Radix-tree node allocations from PF_MEMALLOC contexts could		 * completely exhaust the page allocator. __GFP_NOMEMALLOC		 * stops emergency reserves from being allocated.		 *		 * TODO: this could cause a theoretical memory reclaim		 * deadlock in the swap out path.		 */		/*		 * Add it to the swap cache and mark it dirty		 */		err = __add_to_swap_cache(page, entry,				gfp_mask|__GFP_NOMEMALLOC|__GFP_NOWARN);		switch (err) {		case 0:				/* Success */			SetPageUptodate(page);			SetPageDirty(page);			INC_CACHE_INFO(add_total);			return 1;		case -EEXIST:			/* Raced with "speculative" read_swap_cache_async */			INC_CACHE_INFO(exist_race);			swap_free(entry);			continue;		default:			/* -ENOMEM radix-tree allocation failure */			swap_free(entry);			return 0;		}	}}

/** * __delete_from_swap_cache:page从交换区高速缓存中删去 */void __delete_from_swap_cache(struct page *page){	VM_BUG_ON(!PageLocked(page));	VM_BUG_ON(!PageSwapCache(page));	VM_BUG_ON(PageWriteback(page));	radix_tree_delete(&swapper_space.page_tree, page_private(page));	set_page_private(page, 0);	ClearPageSwapCache(page);	total_swapcache_pages--;	__dec_zone_page_state(page, NR_FILE_PAGES);	INC_CACHE_INFO(del_total);}

/* * This must be called only on pages that have * been verified to be in the swap cache. */void __delete_from_swap_cache(struct page *page){	BUG_ON(!PageLocked(page));	BUG_ON(!PageSwapCache(page));	BUG_ON(PageWriteback(page));	BUG_ON(PagePrivate(page));	radix_tree_delete(&swapper_space.page_tree, page_private(page));	set_page_private(page, 0);	ClearPageSwapCache(page);	total_swapcache_pages--;	pagecache_acct(-1);	INC_CACHE_INFO(del_total);}

/* * This must be called only on pages that have * been verified to be in the swap cache. */void __delete_from_swap_cache(struct page *page){    swp_entry_t entry;    struct address_space *address_space;    VM_BUG_ON_PAGE(!PageLocked(page), page);    VM_BUG_ON_PAGE(!PageSwapCache(page), page);    VM_BUG_ON_PAGE(PageWriteback(page), page);    entry.val = page_private(page);    address_space = swap_address_space(entry);    radix_tree_delete(&address_space->page_tree, page_private(page));    set_page_private(page, 0);    ClearPageSwapCache(page);    address_space->nrpages--;    __dec_zone_page_state(page, NR_FILE_PAGES);    INC_CACHE_INFO(del_total);}

/* * __add_to_swap_cache resembles add_to_page_cache_locked on swapper_space, * but sets SwapCache flag and private instead of mapping and index. */int __add_to_swap_cache(struct page *page, swp_entry_t entry){    int error;    struct address_space *address_space;    VM_BUG_ON_PAGE(!PageLocked(page), page);    VM_BUG_ON_PAGE(PageSwapCache(page), page);    VM_BUG_ON_PAGE(!PageSwapBacked(page), page);    get_page(page);    SetPageSwapCache(page);    set_page_private(page, entry.val);    address_space = swap_address_space(entry);    spin_lock_irq(&address_space->tree_lock);    error = radix_tree_insert(&address_space->page_tree,                              entry.val, page);    if (likely(!error)) {        address_space->nrpages++;        __inc_zone_page_state(page, NR_FILE_PAGES);        INC_CACHE_INFO(add_total);    }    spin_unlock_irq(&address_space->tree_lock);    if (unlikely(error)) {        /*         * Only the context which have set SWAP_HAS_CACHE flag         * would call add_to_swap_cache().         * So add_to_swap_cache() doesn't returns -EEXIST.         */        VM_BUG_ON(error == -EEXIST);        set_page_private(page, 0UL);        ClearPageSwapCache(page);        put_page(page);    }    return error;}