diff --git a/drivers/staging/ramzswap/ramzswap_drv.c b/drivers/staging/ramzswap/ramzswap_drv.c
index ee5eb12b9285..167f8d17a808 100644
--- a/drivers/staging/ramzswap/ramzswap_drv.c
+++ b/drivers/staging/ramzswap/ramzswap_drv.c
@@ -36,13 +36,6 @@
 static int ramzswap_major;
 static struct ramzswap *devices;
 
-/*
- * Pages that compress to larger than this size are
- * forwarded to backing swap, if present or stored
- * uncompressed in memory otherwise.
- */
-static unsigned int max_zpage_size;
-
 /* Module params (documentation at end) */
 static unsigned int num_devices;
 
@@ -79,52 +72,6 @@ static int page_zero_filled(void *ptr)
 	return 1;
 }
 
-/*
- * memlimit cannot be greater than backing disk size.
- */
-static void ramzswap_set_memlimit(struct ramzswap *rzs, size_t totalram_bytes)
-{
-	int memlimit_valid = 1;
-
-	if (!rzs->memlimit) {
-		pr_info("Memory limit not set.\n");
-		memlimit_valid = 0;
-	}
-
-	if (rzs->memlimit > rzs->disksize) {
-		pr_info("Memory limit cannot be greater than "
-			"disksize: limit=%zu, disksize=%zu\n",
-			rzs->memlimit, rzs->disksize);
-		memlimit_valid = 0;
-	}
-
-	if (!memlimit_valid) {
-		size_t mempart, disksize;
-		pr_info("Using default: smaller of (%u%% of RAM) and "
-			"(backing disk size).\n",
-			default_memlimit_perc_ram);
-		mempart = default_memlimit_perc_ram * (totalram_bytes / 100);
-		disksize = rzs->disksize;
-		rzs->memlimit = mempart > disksize ? disksize : mempart;
-	}
-
-	if (rzs->memlimit > totalram_bytes / 2) {
-		pr_info(
-		"Its not advisable setting limit more than half of "
-		"size of memory since we expect a 2:1 compression ratio. "
-		"Limit represents amount of *compressed* data we can keep "
-		"in memory!\n"
-		"\tMemory Size: %zu kB\n"
-		"\tLimit you selected: %zu kB\n"
-		"Continuing anyway ...\n",
-		totalram_bytes >> 10, rzs->memlimit >> 10
-		);
-	}
-
-	rzs->memlimit &= PAGE_MASK;
-	BUG_ON(!rzs->memlimit);
-}
-
 static void ramzswap_set_disksize(struct ramzswap *rzs, size_t totalram_bytes)
 {
 	if (!rzs->disksize) {
@@ -156,80 +103,22 @@ static void ramzswap_set_disksize(struct ramzswap *rzs, size_t totalram_bytes)
 
 /*
  * Swap header (1st page of swap device) contains information
- * to indentify it as a swap partition. Prepare such a header
- * for ramzswap device (ramzswap0) so that swapon can identify
- * it as swap partition. In case backing swap device is provided,
- * copy its swap header.
+ * about a swap file/partition. Prepare such a header for the
+ * given ramzswap device so that swapon can identify it as a
+ * swap partition.
  */
-static int setup_swap_header(struct ramzswap *rzs, union swap_header *s)
+static void setup_swap_header(struct ramzswap *rzs, union swap_header *s)
 {
-	int ret = 0;
-	struct page *page;
-	struct address_space *mapping;
-	union swap_header *backing_swap_header;
-
-	/*
-	 * There is no backing swap device. Create a swap header
-	 * that is acceptable by swapon.
-	 */
-	if (!rzs->backing_swap) {
-		s->info.version = 1;
-		s->info.last_page = (rzs->disksize >> PAGE_SHIFT) - 1;
-		s->info.nr_badpages = 0;
-		memcpy(s->magic.magic, "SWAPSPACE2", 10);
-		return 0;
-	}
-
-	/*
-	 * We have a backing swap device. Copy its swap header
-	 * to ramzswap device header. If this header contains
-	 * invalid information (backing device not a swap
-	 * partition, etc.), swapon will fail for ramzswap
-	 * which is correct behavior - we don't want to swap
-	 * over filesystem partition!
-	 */
-
-	/* Read the backing swap header (code from sys_swapon) */
-	mapping = rzs->swap_file->f_mapping;
-	if (!mapping->a_ops->readpage) {
-		ret = -EINVAL;
-		goto out;
-	}
-
-	page = read_mapping_page(mapping, 0, rzs->swap_file);
-	if (IS_ERR(page)) {
-		ret = PTR_ERR(page);
-		goto out;
-	}
-
-	backing_swap_header = kmap(page);
-	memcpy(s, backing_swap_header, sizeof(*s));
-	if (s->info.nr_badpages) {
-		pr_info("Cannot use backing swap with bad pages (%u)\n",
-			s->info.nr_badpages);
-		ret = -EINVAL;
-	}
-	/*
-	 * ramzswap disksize equals number of usable pages in backing
-	 * swap. Set last_page in swap header to match this disksize
-	 * ('last_page' means 0-based index of last usable swap page).
-	 */
+	s->info.version = 1;
 	s->info.last_page = (rzs->disksize >> PAGE_SHIFT) - 1;
-	kunmap(page);
-
-out:
-	return ret;
+	s->info.nr_badpages = 0;
+	memcpy(s->magic.magic, "SWAPSPACE2", 10);
 }
 
 static void ramzswap_ioctl_get_stats(struct ramzswap *rzs,
 			struct ramzswap_ioctl_stats *s)
 {
-	strncpy(s->backing_swap_name, rzs->backing_swap_name,
-		MAX_SWAP_NAME_LEN - 1);
-	s->backing_swap_name[MAX_SWAP_NAME_LEN - 1] = '\0';
-
 	s->disksize = rzs->disksize;
-	s->memlimit = rzs->memlimit;
 
 #if defined(CONFIG_RAMZSWAP_STATS)
 	{
@@ -265,333 +154,10 @@ static void ramzswap_ioctl_get_stats(struct ramzswap *rzs,
 	s->orig_data_size = rs->pages_stored << PAGE_SHIFT;
 	s->compr_data_size = rs->compr_size;
 	s->mem_used_total = mem_used;
-
-	s->bdev_num_reads = rzs_stat64_read(rzs, &rs->bdev_num_reads);
-	s->bdev_num_writes = rzs_stat64_read(rzs, &rs->bdev_num_writes);
 	}
 #endif /* CONFIG_RAMZSWAP_STATS */
 }
 
-static int add_backing_swap_extent(struct ramzswap *rzs,
-				pgoff_t phy_pagenum,
-				pgoff_t num_pages)
-{
-	unsigned int idx;
-	struct list_head *head;
-	struct page *curr_page, *new_page;
-	unsigned int extents_per_page = PAGE_SIZE /
-				sizeof(struct ramzswap_backing_extent);
-
-	idx = rzs->num_extents % extents_per_page;
-	if (!idx) {
-		new_page = alloc_page(__GFP_ZERO);
-		if (!new_page)
-			return -ENOMEM;
-
-		if (rzs->num_extents) {
-			curr_page = virt_to_page(rzs->curr_extent);
-			head = &curr_page->lru;
-		} else {
-			head = &rzs->backing_swap_extent_list;
-		}
-
-		list_add(&new_page->lru, head);
-		rzs->curr_extent = page_address(new_page);
-	}
-
-	rzs->curr_extent->phy_pagenum = phy_pagenum;
-	rzs->curr_extent->num_pages = num_pages;
-
-	pr_debug("add_extent: idx=%u, phy_pgnum=%lu, num_pgs=%lu, "
-		"pg_last=%lu, curr_ext=%p\n", idx, phy_pagenum, num_pages,
-		phy_pagenum + num_pages - 1, rzs->curr_extent);
-
-	if (idx != extents_per_page - 1)
-		rzs->curr_extent++;
-
-	return 0;
-}
-
-static int setup_backing_swap_extents(struct ramzswap *rzs,
-				struct inode *inode, unsigned long *num_pages)
-{
-	int ret = 0;
-	unsigned blkbits;
-	unsigned blocks_per_page;
-	pgoff_t contig_pages = 0, total_pages = 0;
-	pgoff_t pagenum = 0, prev_pagenum = 0;
-	sector_t probe_block = 0;
-	sector_t last_block;
-
-	blkbits = inode->i_blkbits;
-	blocks_per_page = PAGE_SIZE >> blkbits;
-
-	last_block = i_size_read(inode) >> blkbits;
-	while (probe_block + blocks_per_page <= last_block) {
-		unsigned block_in_page;
-		sector_t first_block;
-
-		first_block = bmap(inode, probe_block);
-		if (first_block == 0)
-			goto bad_bmap;
-
-		/* It must be PAGE_SIZE aligned on-disk */
-		if (first_block & (blocks_per_page - 1)) {
-			probe_block++;
-			goto probe_next;
-		}
-
-		/* All blocks within this page must be contiguous on disk */
-		for (block_in_page = 1; block_in_page < blocks_per_page;
-					block_in_page++) {
-			sector_t block;
-
-			block = bmap(inode, probe_block + block_in_page);
-			if (block == 0)
-				goto bad_bmap;
-			if (block != first_block + block_in_page) {
-				/* Discontiguity */
-				probe_block++;
-				goto probe_next;
-			}
-		}
-
-		/*
-		 * We found a PAGE_SIZE length, PAGE_SIZE aligned
-		 * run of blocks.
-		 */
-		pagenum = first_block >> (PAGE_SHIFT - blkbits);
-
-		if (total_pages && (pagenum != prev_pagenum + 1)) {
-			ret = add_backing_swap_extent(rzs, prev_pagenum -
-					(contig_pages - 1), contig_pages);
-			if (ret < 0)
-				goto out;
-			rzs->num_extents++;
-			contig_pages = 0;
-		}
-		total_pages++;
-		contig_pages++;
-		prev_pagenum = pagenum;
-		probe_block += blocks_per_page;
-
-probe_next:
-		continue;
-	}
-
-	if (contig_pages) {
-		pr_debug("adding last extent: pagenum=%lu, "
-			"contig_pages=%lu\n", pagenum, contig_pages);
-		ret = add_backing_swap_extent(rzs,
-			prev_pagenum - (contig_pages - 1), contig_pages);
-		if (ret < 0)
-			goto out;
-		rzs->num_extents++;
-	}
-	if (!rzs->num_extents) {
-		pr_err("No swap extents found!\n");
-		ret = -EINVAL;
-	}
-
-	if (!ret) {
-		*num_pages = total_pages;
-		pr_info("Found %lu extents containing %luk\n",
-			rzs->num_extents, *num_pages << (PAGE_SHIFT - 10));
-	}
-	goto out;
-
-bad_bmap:
-	pr_err("Backing swapfile has holes\n");
-	ret = -EINVAL;
-out:
-	while (ret && !list_empty(&rzs->backing_swap_extent_list)) {
-		struct page *page;
-		struct list_head *entry = rzs->backing_swap_extent_list.next;
-		page = list_entry(entry, struct page, lru);
-		list_del(entry);
-		__free_page(page);
-	}
-	return ret;
-}
-
-static void map_backing_swap_extents(struct ramzswap *rzs)
-{
-	struct ramzswap_backing_extent *se;
-	struct page *table_page, *se_page;
-	unsigned long num_pages, num_table_pages, entry;
-	unsigned long se_idx, span;
-	unsigned entries_per_page = PAGE_SIZE / sizeof(*rzs->table);
-	unsigned extents_per_page = PAGE_SIZE / sizeof(*se);
-
-	/* True for block device */
-	if (!rzs->num_extents)
-		return;
-
-	se_page = list_entry(rzs->backing_swap_extent_list.next,
-					struct page, lru);
-	se = page_address(se_page);
-	span = se->num_pages;
-	num_pages = rzs->disksize >> PAGE_SHIFT;
-	num_table_pages = DIV_ROUND_UP(num_pages * sizeof(*rzs->table),
-							PAGE_SIZE);
-
-	entry = 0;
-	se_idx = 0;
-	while (num_table_pages--) {
-		table_page = vmalloc_to_page(&rzs->table[entry]);
-		while (span <= entry) {
-			se_idx++;
-			if (se_idx == rzs->num_extents)
-				BUG();
-
-			if (!(se_idx % extents_per_page)) {
-				se_page = list_entry(se_page->lru.next,
-						struct page, lru);
-				se = page_address(se_page);
-			} else
-				se++;
-
-			span += se->num_pages;
-		}
-		table_page->mapping = (struct address_space *)se;
-		table_page->private = se->num_pages - (span - entry);
-		pr_debug("map_table: entry=%lu, span=%lu, map=%p, priv=%lu\n",
-			entry, span, table_page->mapping, table_page->private);
-		entry += entries_per_page;
-	}
-}
-
-/*
- * Check if value of backing_swap module param is sane.
- * Claim this device and set ramzswap size equal to
- * size of this block device.
- */
-static int setup_backing_swap(struct ramzswap *rzs)
-{
-	int ret = 0;
-	size_t disksize;
-	unsigned long num_pages = 0;
-	struct inode *inode;
-	struct file *swap_file;
-	struct address_space *mapping;
-	struct block_device *bdev = NULL;
-
-	if (!rzs->backing_swap_name[0]) {
-		pr_debug("backing_swap param not given\n");
-		goto out;
-	}
-
-	pr_info("Using backing swap device: %s\n", rzs->backing_swap_name);
-
-	swap_file = filp_open(rzs->backing_swap_name,
-				O_RDWR | O_LARGEFILE, 0);
-	if (IS_ERR(swap_file)) {
-		pr_err("Error opening backing device: %s\n",
-			rzs->backing_swap_name);
-		ret = -EINVAL;
-		goto out;
-	}
-
-	mapping = swap_file->f_mapping;
-	inode = mapping->host;
-
-	if (S_ISBLK(inode->i_mode)) {
-		bdev = I_BDEV(inode);
-		ret = bd_claim(bdev, setup_backing_swap);
-		if (ret < 0) {
-			bdev = NULL;
-			goto bad_param;
-		}
-		disksize = i_size_read(inode);
-		/*
-		 * Can happen if user gives an extended partition as
-		 * backing swap or simply a bad disk.
-		 */
-		if (!disksize) {
-			pr_err("Error reading backing swap size.\n");
-			goto bad_param;
-		}
-	} else if (S_ISREG(inode->i_mode)) {
-		bdev = inode->i_sb->s_bdev;
-		if (IS_SWAPFILE(inode)) {
-			ret = -EBUSY;
-			goto bad_param;
-		}
-		ret = setup_backing_swap_extents(rzs, inode, &num_pages);
-		if (ret < 0)
-			goto bad_param;
-		disksize = num_pages << PAGE_SHIFT;
-	} else {
-		goto bad_param;
-	}
-
-	rzs->swap_file = swap_file;
-	rzs->backing_swap = bdev;
-	rzs->disksize = disksize;
-
-	return 0;
-
-bad_param:
-	if (bdev)
-		bd_release(bdev);
-	filp_close(swap_file, NULL);
-
-out:
-	rzs->backing_swap = NULL;
-	return ret;
-}
-
-/*
- * Map logical page number 'pagenum' to physical page number
- * on backing swap device. For block device, this is a nop.
- */
-static u32 map_backing_swap_page(struct ramzswap *rzs, u32 pagenum)
-{
-	u32 skip_pages, entries_per_page;
-	size_t delta, se_offset, skipped;
-	struct page *table_page, *se_page;
-	struct ramzswap_backing_extent *se;
-
-	if (!rzs->num_extents)
-		return pagenum;
-
-	entries_per_page = PAGE_SIZE / sizeof(*rzs->table);
-
-	table_page = vmalloc_to_page(&rzs->table[pagenum]);
-	se = (struct ramzswap_backing_extent *)table_page->mapping;
-	se_page = virt_to_page(se);
-
-	skip_pages = pagenum - (pagenum / entries_per_page * entries_per_page);
-	se_offset = table_page->private + skip_pages;
-
-	if (se_offset < se->num_pages)
-		return se->phy_pagenum + se_offset;
-
-	skipped = se->num_pages - table_page->private;
-	do {
-		struct ramzswap_backing_extent *se_base;
-		u32 se_entries_per_page = PAGE_SIZE / sizeof(*se);
-
-		/* Get next swap extent */
-		se_base = (struct ramzswap_backing_extent *)
-						page_address(se_page);
-		if (se - se_base == se_entries_per_page - 1) {
-			se_page = list_entry(se_page->lru.next,
-						struct page, lru);
-			se = page_address(se_page);
-		} else {
-			se++;
-		}
-
-		skipped += se->num_pages;
-	} while (skipped < skip_pages);
-
-	delta = skipped - skip_pages;
-	se_offset = se->num_pages - delta;
-
-	return se->phy_pagenum + se_offset;
-}
-
 static void ramzswap_free_page(struct ramzswap *rzs, size_t index)
 {
 	u32 clen;
@@ -678,38 +244,12 @@ static int handle_uncompressed_page(struct ramzswap *rzs, struct bio *bio)
 
 /*
  * Called when request page is not present in ramzswap.
- * Its either in backing swap device (if present) or
- * this is an attempt to read before any previous write
+ * This is an attempt to read before any previous write
  * to this location - this happens due to readahead when
  * swap device is read from user-space (e.g. during swapon)
  */
 static int handle_ramzswap_fault(struct ramzswap *rzs, struct bio *bio)
 {
-	/*
-	 * Always forward such requests to backing swap
-	 * device (if present)
-	 */
-	if (rzs->backing_swap) {
-		u32 pagenum;
-		rzs_stat64_dec(rzs, &rzs->stats.num_reads);
-		rzs_stat64_inc(rzs, &rzs->stats.bdev_num_reads);
-		bio->bi_bdev = rzs->backing_swap;
-
-		/*
-		 * In case backing swap is a file, find the right offset within
-		 * the file corresponding to logical position 'index'. For block
-		 * device, this is a nop.
-		 */
-		pagenum = bio->bi_sector >> SECTORS_PER_PAGE_SHIFT;
-		bio->bi_sector = map_backing_swap_page(rzs, pagenum)
-					<< SECTORS_PER_PAGE_SHIFT;
-		return 1;
-	}
-
-	/*
-	 * Its unlikely event in case backing dev is
-	 * not present
-	 */
 	pr_debug("Read before write on swap device: "
 		"sector=%lu, size=%u, offset=%u\n",
 		(ulong)(bio->bi_sector), bio->bi_size,
@@ -781,7 +321,7 @@ out:
 
 static int ramzswap_write(struct ramzswap *rzs, struct bio *bio)
 {
-	int ret, fwd_write_request = 0;
+	int ret;
 	u32 offset, index;
 	size_t clen;
 	struct zobj_header *zheader;
@@ -817,14 +357,6 @@ static int ramzswap_write(struct ramzswap *rzs, struct bio *bio)
 		return 0;
 	}
 
-	if (rzs->backing_swap &&
-		(rzs->stats.compr_size > rzs->memlimit - PAGE_SIZE)) {
-		kunmap_atomic(user_mem, KM_USER0);
-		mutex_unlock(&rzs->lock);
-		fwd_write_request = 1;
-		goto out;
-	}
-
 	ret = lzo1x_1_compress(user_mem, PAGE_SIZE, src, &clen,
 				rzs->compress_workmem);
 
@@ -838,18 +370,11 @@ static int ramzswap_write(struct ramzswap *rzs, struct bio *bio)
 	}
 
 	/*
-	 * Page is incompressible. Forward it to backing swap
-	 * if present. Otherwise, store it as-is (uncompressed)
+	 * Page is incompressible. Store it as-is (uncompressed)
 	 * since we do not want to return too many swap write
 	 * errors which has side effect of hanging the system.
 	 */
 	if (unlikely(clen > max_zpage_size)) {
-		if (rzs->backing_swap) {
-			mutex_unlock(&rzs->lock);
-			fwd_write_request = 1;
-			goto out;
-		}
-
 		clen = PAGE_SIZE;
 		page_store = alloc_page(GFP_NOIO | __GFP_HIGHMEM);
 		if (unlikely(!page_store)) {
@@ -875,8 +400,6 @@ static int ramzswap_write(struct ramzswap *rzs, struct bio *bio)
 		pr_info("Error allocating memory for compressed "
 			"page: %u, size=%zu\n", index, clen);
 		rzs_stat64_inc(rzs, &rzs->stats.failed_writes);
-		if (rzs->backing_swap)
-			fwd_write_request = 1;
 		goto out;
 	}
 
@@ -914,31 +437,6 @@ memstore:
 	return 0;
 
 out:
-	if (fwd_write_request) {
-		rzs_stat64_inc(rzs, &rzs->stats.bdev_num_writes);
-		bio->bi_bdev = rzs->backing_swap;
-#if 0
-		/*
-		 * TODO: We currently have linear mapping of ramzswap and
-		 * backing swap sectors. This is not desired since we want
-		 * to optimize writes to backing swap to minimize disk seeks
-		 * or have effective wear leveling (for SSDs). Also, a
-		 * non-linear mapping is required to implement compressed
-		 * on-disk swapping.
-		 */
-		 bio->bi_sector = get_backing_swap_page()
-					<< SECTORS_PER_PAGE_SHIFT;
-#endif
-		/*
-		 * In case backing swap is a file, find the right offset within
-		 * the file corresponding to logical position 'index'. For block
-		 * device, this is a nop.
-		 */
-		bio->bi_sector = map_backing_swap_page(rzs, index)
-					<< SECTORS_PER_PAGE_SHIFT;
-		return 1;
-	}
-
 	bio_io_error(bio);
 	return 0;
 }
@@ -996,19 +494,11 @@ static int ramzswap_make_request(struct request_queue *queue, struct bio *bio)
 
 static void reset_device(struct ramzswap *rzs)
 {
-	int is_backing_blkdev = 0;
-	size_t index, num_pages;
-	unsigned entries_per_page;
-	unsigned long num_table_pages, entry = 0;
+	size_t index;
 
 	/* Do not accept any new I/O request */
 	rzs->init_done = 0;
 
-	if (rzs->backing_swap && !rzs->num_extents)
-		is_backing_blkdev = 1;
-
-	num_pages = rzs->disksize >> PAGE_SHIFT;
-
 	/* Free various per-device buffers */
 	kfree(rzs->compress_workmem);
 	free_pages((unsigned long)rzs->compress_buffer, 1);
@@ -1017,7 +507,7 @@ static void reset_device(struct ramzswap *rzs)
 	rzs->compress_buffer = NULL;
 
 	/* Free all pages that are still in this ramzswap device */
-	for (index = 0; index < num_pages; index++) {
+	for (index = 0; index < rzs->disksize >> PAGE_SHIFT; index++) {
 		struct page *page;
 		u16 offset;
 
@@ -1033,51 +523,16 @@ static void reset_device(struct ramzswap *rzs)
 			xv_free(rzs->mem_pool, page, offset);
 	}
 
-	entries_per_page = PAGE_SIZE / sizeof(*rzs->table);
-	num_table_pages = DIV_ROUND_UP(num_pages * sizeof(*rzs->table),
-					PAGE_SIZE);
-	/*
-	 * Set page->mapping to NULL for every table page.
-	 * Otherwise, we will hit bad_page() during free.
-	 */
-	while (rzs->num_extents && num_table_pages--) {
-		struct page *page;
-		page = vmalloc_to_page(&rzs->table[entry]);
-		page->mapping = NULL;
-		entry += entries_per_page;
-	}
 	vfree(rzs->table);
 	rzs->table = NULL;
 
 	xv_destroy_pool(rzs->mem_pool);
 	rzs->mem_pool = NULL;
 
-	/* Free all swap extent pages */
-	while (!list_empty(&rzs->backing_swap_extent_list)) {
-		struct page *page;
-		struct list_head *entry;
-		entry = rzs->backing_swap_extent_list.next;
-		page = list_entry(entry, struct page, lru);
-		list_del(entry);
-		__free_page(page);
-	}
-	INIT_LIST_HEAD(&rzs->backing_swap_extent_list);
-	rzs->num_extents = 0;
-
-	/* Close backing swap device, if present */
-	if (rzs->backing_swap) {
-		if (is_backing_blkdev)
-			bd_release(rzs->backing_swap);
-		filp_close(rzs->swap_file, NULL);
-		rzs->backing_swap = NULL;
-		memset(rzs->backing_swap_name, 0, MAX_SWAP_NAME_LEN);
-	}
-
 	/* Reset stats */
 	memset(&rzs->stats, 0, sizeof(rzs->stats));
 
 	rzs->disksize = 0;
-	rzs->memlimit = 0;
 }
 
 static int ramzswap_ioctl_init_device(struct ramzswap *rzs)
@@ -1092,14 +547,7 @@ static int ramzswap_ioctl_init_device(struct ramzswap *rzs)
 		return -EBUSY;
 	}
 
-	ret = setup_backing_swap(rzs);
-	if (ret)
-		goto fail;
-
-	if (rzs->backing_swap)
-		ramzswap_set_memlimit(rzs, totalram_pages << PAGE_SHIFT);
-	else
-		ramzswap_set_disksize(rzs, totalram_pages << PAGE_SHIFT);
+	ramzswap_set_disksize(rzs, totalram_pages << PAGE_SHIFT);
 
 	rzs->compress_workmem = kzalloc(LZO1X_MEM_COMPRESS, GFP_KERNEL);
 	if (!rzs->compress_workmem) {
@@ -1126,8 +574,6 @@ static int ramzswap_ioctl_init_device(struct ramzswap *rzs)
 	}
 	memset(rzs->table, 0, num_pages * sizeof(*rzs->table));
 
-	map_backing_swap_extents(rzs);
-
 	page = alloc_page(__GFP_ZERO);
 	if (!page) {
 		pr_err("Error allocating swap header page\n");
@@ -1138,23 +584,13 @@ static int ramzswap_ioctl_init_device(struct ramzswap *rzs)
 	rzs_set_flag(rzs, 0, RZS_UNCOMPRESSED);
 
 	swap_header = kmap(page);
-	ret = setup_swap_header(rzs, swap_header);
+	setup_swap_header(rzs, swap_header);
 	kunmap(page);
-	if (ret) {
-		pr_err("Error setting swap header\n");
-		goto fail;
-	}
 
 	set_capacity(rzs->disk, rzs->disksize >> SECTOR_SHIFT);
 
-	/*
-	 * We have ident mapping of sectors for ramzswap and
-	 * and the backing swap device. So, this queue flag
-	 * should be according to backing dev.
-	 */
-	if (!rzs->backing_swap ||
-			blk_queue_nonrot(rzs->backing_swap->bd_disk->queue))
-		queue_flag_set_unlocked(QUEUE_FLAG_NONROT, rzs->disk->queue);
+	/* ramzswap devices sort of resembles non-rotational disks */
+	queue_flag_set_unlocked(QUEUE_FLAG_NONROT, rzs->disk->queue);
 
 	rzs->mem_pool = xv_create_pool();
 	if (!rzs->mem_pool) {
@@ -1163,17 +599,6 @@ static int ramzswap_ioctl_init_device(struct ramzswap *rzs)
 		goto fail;
 	}
 
-	/*
-	 * Pages that compress to size greater than this are forwarded
-	 * to physical swap disk (if backing dev is provided)
-	 * TODO: make this configurable
-	 */
-	if (rzs->backing_swap)
-		max_zpage_size = max_zpage_size_bdev;
-	else
-		max_zpage_size = max_zpage_size_nobdev;
-	pr_debug("Max compressed page size: %u bytes\n", max_zpage_size);
-
 	rzs->init_done = 1;
 
 	pr_debug("Initialization done!\n");
@@ -1198,7 +623,7 @@ static int ramzswap_ioctl(struct block_device *bdev, fmode_t mode,
 			unsigned int cmd, unsigned long arg)
 {
 	int ret = 0;
-	size_t disksize_kb, memlimit_kb;
+	size_t disksize_kb;
 
 	struct ramzswap *rzs = bdev->bd_disk->private_data;
 
@@ -1217,36 +642,6 @@ static int ramzswap_ioctl(struct block_device *bdev, fmode_t mode,
 		pr_info("Disk size set to %zu kB\n", disksize_kb);
 		break;
 
-	case RZSIO_SET_MEMLIMIT_KB:
-		if (rzs->init_done) {
-			/* TODO: allow changing memlimit */
-			ret = -EBUSY;
-			goto out;
-		}
-		if (copy_from_user(&memlimit_kb, (void *)arg,
-						_IOC_SIZE(cmd))) {
-			ret = -EFAULT;
-			goto out;
-		}
-		rzs->memlimit = memlimit_kb << 10;
-		pr_info("Memory limit set to %zu kB\n", memlimit_kb);
-		break;
-
-	case RZSIO_SET_BACKING_SWAP:
-		if (rzs->init_done) {
-			ret = -EBUSY;
-			goto out;
-		}
-
-		if (copy_from_user(&rzs->backing_swap_name, (void *)arg,
-						_IOC_SIZE(cmd))) {
-			ret = -EFAULT;
-			goto out;
-		}
-		rzs->backing_swap_name[MAX_SWAP_NAME_LEN - 1] = '\0';
-		pr_info("Backing swap set to %s\n", rzs->backing_swap_name);
-		break;
-
 	case RZSIO_GET_STATS:
 	{
 		struct ramzswap_ioctl_stats *stats;
@@ -1306,7 +701,6 @@ static int create_device(struct ramzswap *rzs, int device_id)
 
 	mutex_init(&rzs->lock);
 	spin_lock_init(&rzs->stat64_lock);
-	INIT_LIST_HEAD(&rzs->backing_swap_extent_list);
 
 	rzs->queue = blk_alloc_queue(GFP_KERNEL);
 	if (!rzs->queue) {
@@ -1336,10 +730,7 @@ static int create_device(struct ramzswap *rzs, int device_id)
 	rzs->disk->private_data = rzs;
 	snprintf(rzs->disk->disk_name, 16, "ramzswap%d", device_id);
 
-	/*
-	 * Actual capacity set using RZSIO_SET_DISKSIZE_KB ioctl
-	 * or set equal to backing swap device (if provided)
-	 */
+	/* Actual capacity set using RZSIO_SET_DISKSIZE_KB ioctl */
 	set_capacity(rzs->disk, 0);
 
 	blk_queue_physical_block_size(rzs->disk->queue, PAGE_SIZE);
diff --git a/drivers/staging/ramzswap/ramzswap_drv.h b/drivers/staging/ramzswap/ramzswap_drv.h
index c7e0e767c223..63c30420df21 100644
--- a/drivers/staging/ramzswap/ramzswap_drv.h
+++ b/drivers/staging/ramzswap/ramzswap_drv.h
@@ -31,8 +31,7 @@ static const unsigned max_num_devices = 32;
  * Stored at beginning of each compressed object.
  *
  * It stores back-reference to table entry which points to this
- * object. This is required to support memory defragmentation or
- * migrating compressed pages to backing swap disk.
+ * object. This is required to support memory defragmentation.
  */
 struct zobj_header {
 #if 0
@@ -44,27 +43,17 @@ struct zobj_header {
 
 /* Default ramzswap disk size: 25% of total RAM */
 static const unsigned default_disksize_perc_ram = 25;
-static const unsigned default_memlimit_perc_ram = 15;
 
 /*
- * Max compressed page size when backing device is provided.
- * Pages that compress to size greater than this are sent to
- * physical swap disk.
- */
-static const unsigned max_zpage_size_bdev = PAGE_SIZE / 2;
-
-/*
- * Max compressed page size when there is no backing dev.
  * Pages that compress to size greater than this are stored
  * uncompressed in memory.
  */
-static const unsigned max_zpage_size_nobdev = PAGE_SIZE / 4 * 3;
+static const unsigned max_zpage_size = PAGE_SIZE / 4 * 3;
 
 /*
- * NOTE: max_zpage_size_{bdev,nobdev} sizes must be
- * less than or equal to:
+ * NOTE: max_zpage_size must be less than or equal to:
  *   XV_MAX_ALLOC_SIZE - sizeof(struct zobj_header)
- * since otherwise xv_malloc would always return failure.
+ * otherwise, xv_malloc() would always return failure.
  */
 
 /*-- End of configurable params */
@@ -98,15 +87,6 @@ struct table {
 	u8 flags;
 } __attribute__((aligned(4)));
 
-/*
- * Swap extent information in case backing swap is a regular
- * file. These extent entries must fit exactly in a page.
- */
-struct ramzswap_backing_extent {
-	pgoff_t phy_pagenum;
-	pgoff_t num_pages;
-} __attribute__((aligned(4)));
-
 struct ramzswap_stats {
 	/* basic stats */
 	size_t compr_size;	/* compressed size of pages stored -
@@ -123,8 +103,6 @@ struct ramzswap_stats {
 	u32 pages_stored;	/* no. of pages currently stored */
 	u32 good_compress;	/* % of pages with compression ratio<=50% */
 	u32 pages_expand;	/* % of incompressible pages */
-	u64 bdev_num_reads;	/* no. of reads on backing dev */
-	u64 bdev_num_writes;	/* no. of writes on backing dev */
 #endif
 };
 
@@ -138,11 +116,6 @@ struct ramzswap {
 	struct request_queue *queue;
 	struct gendisk *disk;
 	int init_done;
-	/*
-	 * This is limit on compressed data size (stats.compr_size)
-	 * Its applicable only when backing swap device is present.
-	 */
-	size_t memlimit;	/* bytes */
 	/*
 	 * This is limit on amount of *uncompressed* worth of data
 	 * we can hold. When backing swap device is provided, it is
@@ -151,14 +124,6 @@ struct ramzswap {
 	size_t disksize;	/* bytes */
 
 	struct ramzswap_stats stats;
-
-	/* backing swap device info */
-	struct ramzswap_backing_extent *curr_extent;
-	struct list_head backing_swap_extent_list;
-	unsigned long num_extents;
-	char backing_swap_name[MAX_SWAP_NAME_LEN];
-	struct block_device *backing_swap;
-	struct file *swap_file;
 };
 
 /*-- */
@@ -182,13 +147,6 @@ static void rzs_stat64_inc(struct ramzswap *rzs, u64 *v)
 	spin_unlock(&rzs->stat64_lock);
 }
 
-static void rzs_stat64_dec(struct ramzswap *rzs, u64 *v)
-{
-	spin_lock(&rzs->stat64_lock);
-	*v = *v - 1;
-	spin_unlock(&rzs->stat64_lock);
-}
-
 static u64 rzs_stat64_read(struct ramzswap *rzs, u64 *v)
 {
 	u64 val;
@@ -203,7 +161,6 @@ static u64 rzs_stat64_read(struct ramzswap *rzs, u64 *v)
 #define rzs_stat_inc(v)
 #define rzs_stat_dec(v)
 #define rzs_stat64_inc(r, v)
-#define rzs_stat64_dec(r, v)
 #define rzs_stat64_read(r, v)
 #endif /* CONFIG_RAMZSWAP_STATS */
 
diff --git a/drivers/staging/ramzswap/ramzswap_ioctl.h b/drivers/staging/ramzswap/ramzswap_ioctl.h
index d26076d41bde..db94bcb42967 100644
--- a/drivers/staging/ramzswap/ramzswap_ioctl.h
+++ b/drivers/staging/ramzswap/ramzswap_ioctl.h
@@ -15,11 +15,7 @@
 #ifndef _RAMZSWAP_IOCTL_H_
 #define _RAMZSWAP_IOCTL_H_
 
-#define MAX_SWAP_NAME_LEN 128
-
 struct ramzswap_ioctl_stats {
-	char backing_swap_name[MAX_SWAP_NAME_LEN];
-	u64 memlimit;		/* only applicable if backing swap present */
 	u64 disksize;		/* user specified or equal to backing swap
 				 * size (if present) */
 	u64 num_reads;		/* failed + successful */
@@ -36,15 +32,11 @@ struct ramzswap_ioctl_stats {
 	u64 orig_data_size;
 	u64 compr_data_size;
 	u64 mem_used_total;
-	u64 bdev_num_reads;	/* no. of reads on backing dev */
-	u64 bdev_num_writes;	/* no. of writes on backing dev */
 } __attribute__ ((packed, aligned(4)));
 
 #define RZSIO_SET_DISKSIZE_KB	_IOW('z', 0, size_t)
-#define RZSIO_SET_MEMLIMIT_KB	_IOW('z', 1, size_t)
-#define RZSIO_SET_BACKING_SWAP	_IOW('z', 2, unsigned char[MAX_SWAP_NAME_LEN])
-#define RZSIO_GET_STATS		_IOR('z', 3, struct ramzswap_ioctl_stats)
-#define RZSIO_INIT		_IO('z', 4)
-#define RZSIO_RESET		_IO('z', 5)
+#define RZSIO_GET_STATS		_IOR('z', 1, struct ramzswap_ioctl_stats)
+#define RZSIO_INIT		_IO('z', 2)
+#define RZSIO_RESET		_IO('z', 3)
 
 #endif