Merge "mm: remove compressed copy from zram in-memory"

#include <linux/writeback.h>

#include <linux/frontswap.h>

#include <linux/aio.h>

#include <linux/blkdev.h>

#include <asm/pgtable.h>

static struct bio *get_swap_bio(gfp_t gfp_flags,

				imajor(bio->bi_bdev->bd_inode),

				iminor(bio->bi_bdev->bd_inode),

				(unsigned long long)bio->bi_sector);

	} else {

		goto out;

	}

	SetPageUptodate(page);

	/*

	 * There is no guarantee that the page is in swap cache - the software

	 * suspend code (at least) uses end_swap_bio_read() against a non-

	 * swapcache page.  So we must check PG_swapcache before proceeding with

	 * this optimization.

	 */

	if (likely(PageSwapCache(page))) {

		struct swap_info_struct *sis;

		sis = page_swap_info(page);

		if (sis->flags & SWP_BLKDEV) {

			/*

			 * The swap subsystem performs lazy swap slot freeing,

			 * expecting that the page will be swapped out again.

			 * So we can avoid an unnecessary write if the page

			 * isn't redirtied.

			 * This is good for real swap storage because we can

			 * reduce unnecessary I/O and enhance wear-leveling

			 * if an SSD is used as the as swap device.

			 * But if in-memory swap device (eg zram) is used,

			 * this causes a duplicated copy between uncompressed

			 * data in VM-owned memory and compressed data in

			 * zram-owned memory.  So let's free zram-owned memory

			 * and make the VM-owned decompressed page *dirty*,

			 * so the page should be swapped out somewhere again if

			 * we again wish to reclaim it.

			 */

			struct gendisk *disk = sis->bdev->bd_disk;

			if (disk->fops->swap_slot_free_notify) {

				swp_entry_t entry;

				unsigned long offset;

				entry.val = page_private(page);

				offset = swp_offset(entry);

				SetPageDirty(page);

				disk->fops->swap_slot_free_notify(sis->bdev,

						offset);

			}

		}

	}

out:

	unlock_page(page);

	bio_put(bio);

}