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

int add_to_swap(struct page *page){	swp_entry_t entry;	int err;	VM_BUG_ON(!PageLocked(page));	VM_BUG_ON(!PageUptodate(page));	entry = get_swap_page();	if (!entry.val)		return 0;	if (unlikely(PageTransHuge(page)))		if (unlikely(split_huge_page(page))) {			swapcache_free(entry, NULL);			return 0;		}	err = add_to_swap_cache(page, entry,			__GFP_HIGH|__GFP_NOMEMALLOC|__GFP_NOWARN);	if (!err) {			SetPageDirty(page);		return 1;	} else {			swapcache_free(entry, NULL);		return 0;	}}

/** * 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){	swp_entry_t entry;	int err;	VM_BUG_ON(!PageLocked(page));	VM_BUG_ON(!PageUptodate(page));#ifdef CONFIG_HSWAP	if (!current_is_kswapd())		entry = get_lowest_prio_swap_page();	else#endif	entry = get_swap_page();	if (!entry.val)		return 0;	if (unlikely(PageTransHuge(page)))		if (unlikely(split_huge_page(page))) {			swapcache_free(entry, NULL);			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_HIGH|__GFP_NOMEMALLOC|__GFP_NOWARN);	if (!err) {	/* Success */		SetPageDirty(page);		return 1;	} else {	/* -ENOMEM radix-tree allocation failure */		/*		 * add_to_swap_cache() doesn't return -EEXIST, so we can safely		 * clear SWAP_HAS_CACHE flag.		 */		swapcache_free(entry, NULL);		return 0;	}}

/** * 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, struct list_head *list){    swp_entry_t entry;    int err;    VM_BUG_ON_PAGE(!PageLocked(page), page);    VM_BUG_ON_PAGE(!PageUptodate(page), page);    entry = get_swap_page();    if (!entry.val)        return 0;    if (mem_cgroup_try_charge_swap(page, entry)) {        swapcache_free(entry);        return 0;    }    if (unlikely(PageTransHuge(page)))        if (unlikely(split_huge_page_to_list(page, list))) {            swapcache_free(entry);            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.     */    err = add_to_swap_cache(page, entry,                            __GFP_HIGH|__GFP_NOMEMALLOC|__GFP_NOWARN);    if (!err) {        return 1;    } else {	/* -ENOMEM radix-tree allocation failure */        /*         * add_to_swap_cache() doesn't return -EEXIST, so we can safely         * clear SWAP_HAS_CACHE flag.         */        swapcache_free(entry);        return 0;    }}

/** * delete_from_swap_cache:page从交换区高速缓存中删除 */void delete_from_swap_cache(struct page *page){	swp_entry_t entry;	entry.val = page_private(page);	spin_lock_irq(&swapper_space.tree_lock);	__delete_from_swap_cache(page);	spin_unlock_irq(&swapper_space.tree_lock);	swapcache_free(entry, page);	page_cache_release(page);}

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 {		found_page = find_get_page(&swapper_space, entry.val);		if (found_page)			break;		if (!new_page) {			new_page = alloc_page_vma(gfp_mask, vma, addr);			if (!new_page)				break;				}		err = radix_tree_preload(gfp_mask & GFP_KERNEL);		if (err)			break;		err = swapcache_prepare(entry);		if (err == -EEXIST) {				radix_tree_preload_end();			continue;		}		if (err) {					radix_tree_preload_end();			break;		}				__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);			swap_readpage(new_page);			return new_page;		}		radix_tree_preload_end();		ClearPageSwapBacked(new_page);		__clear_page_locked(new_page);		swapcache_free(entry, NULL);	} while (err != -ENOMEM);	if (new_page)		page_cache_release(new_page);	return found_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);}

/*  * 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(&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_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;}

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;}