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

/* * 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);	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;}

/* * This must be called only on pages that have * been verified to be in the swap cache and locked. * It will never put the page into the free list, * the caller has a reference on the page. */void delete_from_swap_cache(struct page *page){    swp_entry_t entry;    struct address_space *address_space;    entry.val = page_private(page);    address_space = swap_address_space(entry);    spin_lock_irq(&address_space->tree_lock);    __delete_from_swap_cache(page);    spin_unlock_irq(&address_space->tree_lock);    swapcache_free(entry);    put_page(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){	int error, i, nr = hpage_nr_pages(page);	struct address_space *address_space;	pgoff_t idx = swp_offset(entry);	VM_BUG_ON_PAGE(!PageLocked(page), page);	VM_BUG_ON_PAGE(PageSwapCache(page), page);	VM_BUG_ON_PAGE(!PageSwapBacked(page), page);	page_ref_add(page, nr);	SetPageSwapCache(page);	address_space = swap_address_space(entry);	spin_lock_irq(&address_space->tree_lock);	for (i = 0; i < nr; i++) {		set_page_private(page + i, entry.val + i);		error = radix_tree_insert(&address_space->page_tree,					  idx + i, page + i);		if (unlikely(error))			break;	}	if (likely(!error)) {		address_space->nrpages += nr;		__mod_node_page_state(page_pgdat(page), NR_FILE_PAGES, nr);		ADD_CACHE_INFO(add_total, nr);	} else {		/*		 * 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 + i, 0UL);		while (i--) {			radix_tree_delete(&address_space->page_tree, idx + i);			set_page_private(page + i, 0UL);		}		ClearPageSwapCache(page);		page_ref_sub(page, nr);	}	spin_unlock_irq(&address_space->tree_lock);	return error;}

/* * 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(!PageLocked(page));	VM_BUG_ON(PageSwapCache(page));	VM_BUG_ON(!PageSwapBacked(page));	page_cache_get(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_zone_page_state(page, NR_SWAPCACHE);		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);		page_cache_release(page);	}	return error;}

/* * 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){	struct address_space *address_space;	int i, nr = hpage_nr_pages(page);	swp_entry_t entry;	pgoff_t idx;	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);	idx = swp_offset(entry);	for (i = 0; i < nr; i++) {		radix_tree_delete(&address_space->page_tree, idx + i);		set_page_private(page + i, 0);	}	ClearPageSwapCache(page);	address_space->nrpages -= nr;	__mod_node_page_state(page_pgdat(page), NR_FILE_PAGES, -nr);	ADD_CACHE_INFO(del_total, nr);}

struct page *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,                                     struct vm_area_struct *vma, unsigned long addr,                                     bool *new_page_allocated){    struct page *found_page, *new_page = NULL;    struct address_space *swapper_space = swap_address_space(entry);    int err;    *new_page_allocated = false;    do {        /*         * First check the swap cache.  Since this is normally         * called after lookup_swap_cache() failed, re-calling         * that would confuse statistics.         */        found_page = find_get_page(swapper_space, entry.val);        if (found_page)            break;        /*         * Get a new page to read into from swap.         */        if (!new_page) {            new_page = alloc_page_vma(gfp_mask, vma, addr);            if (!new_page)                break;		/* Out of memory */        }        /*         * call radix_tree_preload() while we can wait.         */        err = radix_tree_maybe_preload(gfp_mask & GFP_KERNEL);        if (err)            break;        /*         * Swap entry may have been freed since our caller observed it.         */        err = swapcache_prepare(entry);        if (err == -EEXIST) {            radix_tree_preload_end();            /*             * We might race against get_swap_page() and stumble             * across a SWAP_HAS_CACHE swap_map entry whose page             * has not been brought into the swapcache yet, while             * the other end is scheduled away waiting on discard             * I/O completion at scan_swap_map().             *             * In order to avoid turning this transitory state             * into a permanent loop around this -EEXIST case             * if !CONFIG_PREEMPT and the I/O completion happens             * to be waiting on the CPU waitqueue where we are now             * busy looping, we just conditionally invoke the             * scheduler here, if there are some more important             * tasks to run.             */            cond_resched();            continue;        }        if (err) {		/* swp entry is obsolete ? */            radix_tree_preload_end();            break;        }        /* May fail (-ENOMEM) if radix-tree node allocation failed. */        __SetPageLocked(new_page);        __SetPageSwapBacked(new_page);        err = __add_to_swap_cache(new_page, entry);        if (likely(!err)) {            radix_tree_preload_end();            /*             * Initiate read into locked page and return.             */            lru_cache_add_anon(new_page);            *new_page_allocated = true;            return new_page;        }        radix_tree_preload_end();        __ClearPageLocked(new_page);        /*         * add_to_swap_cache() doesn't return -EEXIST, so we can safely         * clear SWAP_HAS_CACHE flag.         */        swapcache_free(entry);    } while (err != -ENOMEM);    if (new_page)        put_page(new_page);    return found_page;}

/* * zswap_get_swap_cache_page * * This is an adaption of read_swap_cache_async() * * This function tries to find a page with the given swap entry * in the swapper_space address space (the swap cache).  If the page * is found, it is returned in retpage.  Otherwise, a page is allocated, * added to the swap cache, and returned in retpage. * * If success, the swap cache page is returned in retpage * Returns ZSWAP_SWAPCACHE_EXIST if page was already in the swap cache * Returns ZSWAP_SWAPCACHE_NEW if the new page needs to be populated, *     the new page is added to swapcache and locked * Returns ZSWAP_SWAPCACHE_FAIL on error */static int zswap_get_swap_cache_page(swp_entry_t entry,				struct page **retpage){	struct page *found_page, *new_page = NULL;	struct address_space *swapper_space = swap_address_space(entry);	int err;	*retpage = NULL;	do {		/*		 * First check the swap cache.  Since this is normally		 * called after lookup_swap_cache() failed, re-calling		 * that would confuse statistics.		 */		found_page = find_get_page(swapper_space, entry.val);		if (found_page)			break;		/*		 * Get a new page to read into from swap.		 */		if (!new_page) {			new_page = alloc_page(GFP_KERNEL);			if (!new_page)				break; /* Out of memory */		}		/*		 * call radix_tree_preload() while we can wait.		 */		err = radix_tree_preload(GFP_KERNEL);		if (err)			break;		/*		 * Swap entry may have been freed since our caller observed it.		 */		err = swapcache_prepare(entry);		if (err == -EEXIST) { /* seems racy */			radix_tree_preload_end();			continue;		}		if (err) { /* swp entry is obsolete ? */			radix_tree_preload_end();			break;		}		/* May fail (-ENOMEM) if radix-tree node allocation failed. */		__set_page_locked(new_page);		SetPageSwapBacked(new_page);		err = __add_to_swap_cache(new_page, entry);		if (likely(!err)) {			radix_tree_preload_end();			lru_cache_add_anon(new_page);			*retpage = new_page;			return ZSWAP_SWAPCACHE_NEW;		}		radix_tree_preload_end();		ClearPageSwapBacked(new_page);		__clear_page_locked(new_page);		/*		 * add_to_swap_cache() doesn't return -EEXIST, so we can safely		 * clear SWAP_HAS_CACHE flag.		 */		swapcache_free(entry, NULL);	} while (err != -ENOMEM);	if (new_page)		page_cache_release(new_page);	if (!found_page)		return ZSWAP_SWAPCACHE_FAIL;	*retpage = found_page;	return ZSWAP_SWAPCACHE_EXIST;}

struct page *__read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,			struct vm_area_struct *vma, unsigned long addr,			bool *new_page_allocated){	struct page *found_page, *new_page = NULL;	struct address_space *swapper_space = swap_address_space(entry);	int err;	*new_page_allocated = false;	do {		/*		 * First check the swap cache.  Since this is normally		 * called after lookup_swap_cache() failed, re-calling		 * that would confuse statistics.		 */		found_page = find_get_page(swapper_space, swp_offset(entry));		if (found_page)			break;		/*		 * Just skip read ahead for unused swap slot.		 * During swap_off when swap_slot_cache is disabled,		 * we have to handle the race between putting		 * swap entry in swap cache and marking swap slot		 * as SWAP_HAS_CACHE.  That's done in later part of code or		 * else swap_off will be aborted if we return NULL.		 */		if (!__swp_swapcount(entry) && swap_slot_cache_enabled)			break;		/*		 * Get a new page to read into from swap.		 */		if (!new_page) {			new_page = alloc_page_vma(gfp_mask, vma, addr);			if (!new_page)				break;		/* Out of memory */		}		/*		 * call radix_tree_preload() while we can wait.		 */		err = radix_tree_maybe_preload(gfp_mask & GFP_KERNEL);		if (err)			break;		/*		 * Swap entry may have been freed since our caller observed it.		 */		err = swapcache_prepare(entry);		if (err == -EEXIST) {			radix_tree_preload_end();			/*			 * We might race against get_swap_page() and stumble			 * across a SWAP_HAS_CACHE swap_map entry whose page			 * has not been brought into the swapcache yet.			 */			cond_resched();			continue;		}		if (err) {		/* swp entry is obsolete ? */			radix_tree_preload_end();			break;		}		/* May fail (-ENOMEM) if radix-tree node allocation failed. */		__SetPageLocked(new_page);		__SetPageSwapBacked(new_page);		err = __add_to_swap_cache(new_page, entry);		if (likely(!err)) {			radix_tree_preload_end();			/*			 * Initiate read into locked page and return.			 */			lru_cache_add_anon(new_page);			*new_page_allocated = true;			return new_page;		}		radix_tree_preload_end();		__ClearPageLocked(new_page);		/*		 * add_to_swap_cache() doesn't return -EEXIST, so we can safely		 * clear SWAP_HAS_CACHE flag.		 */		put_swap_page(new_page, entry);	} while (err != -ENOMEM);	if (new_page)		put_page(new_page);	return found_page;}

/*  * Locate a page of swap in physical memory, reserving swap cache space * and reading the disk if it is not already cached. * A failure return means that either the page allocation failed or that * the swap entry is no longer in use. */struct page *read_swap_cache_async(swp_entry_t entry, gfp_t gfp_mask,			struct vm_area_struct *vma, unsigned long addr){	struct page *found_page, *new_page = NULL;	int err;	do {		/*		 * First check the swap cache.  Since this is normally		 * called after lookup_swap_cache() failed, re-calling		 * that would confuse statistics.		 */		found_page = find_get_page(swap_address_space(entry),					entry.val);		if (found_page)			break;		/*		 * Get a new page to read into from swap.		 */		if (!new_page) {			new_page = alloc_page_vma(gfp_mask, vma, addr);			if (!new_page)				break;		/* Out of memory */		}		/*		 * call radix_tree_preload() while we can wait.		 */		err = radix_tree_preload(gfp_mask & GFP_KERNEL);		if (err)			break;		/*		 * Swap entry may have been freed since our caller observed it.		 */		err = swapcache_prepare(entry);		if (err == -EEXIST) {	/* seems racy */			radix_tree_preload_end();			continue;		}		if (err) {		/* swp entry is obsolete ? */			radix_tree_preload_end();			break;		}		/* May fail (-ENOMEM) if radix-tree node allocation failed. */		__set_page_locked(new_page);		SetPageSwapBacked(new_page);		err = __add_to_swap_cache(new_page, entry);		if (likely(!err)) {			radix_tree_preload_end();			/*			 * Initiate read into locked page and return.			 */			lru_cache_add_anon(new_page);			swap_readpage(new_page);			return new_page;		}		radix_tree_preload_end();		ClearPageSwapBacked(new_page);		__clear_page_locked(new_page);		/*		 * add_to_swap_cache() doesn't return -EEXIST, so we can safely		 * clear SWAP_HAS_CACHE flag.		 */		swapcache_free(entry, NULL);	} while (err != -ENOMEM);	if (new_page)		page_cache_release(new_page);	return found_page;}