[linux.git] / mm / page_io.c

/*
 *  linux/mm/page_io.c
 *
 *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
 *
 *  Swap reorganised 29.12.95, 
 *  Asynchronous swapping added 30.12.95. Stephen Tweedie
 *  Removed race in async swapping. 14.4.1996. Bruno Haible
 *  Add swap of shared pages through the page cache. 20.2.1998. Stephen Tweedie
 *  Always use brw_page, life becomes simpler. 12 May 1998 Eric Biederman
 */

#include <linux/mm.h>
#include <linux/kernel_stat.h>
#include <linux/gfp.h>
#include <linux/pagemap.h>
#include <linux/swap.h>
#include <linux/bio.h>
#include <linux/swapops.h>
#include <linux/writeback.h>
#include <linux/frontswap.h>
#include <asm/pgtable.h>

static struct bio *get_swap_bio(gfp_t gfp_flags,
				struct page *page, bio_end_io_t end_io)
{
	struct bio *bio;

	bio = bio_alloc(gfp_flags, 1);
	if (bio) {
		bio->bi_sector = map_swap_page(page, &bio->bi_bdev);
		bio->bi_sector <<= PAGE_SHIFT - 9;
		bio->bi_io_vec[0].bv_page = page;
		bio->bi_io_vec[0].bv_len = PAGE_SIZE;
		bio->bi_io_vec[0].bv_offset = 0;
		bio->bi_vcnt = 1;
		bio->bi_idx = 0;
		bio->bi_size = PAGE_SIZE;
		bio->bi_end_io = end_io;
	}
	return bio;
}

static void end_swap_bio_write(struct bio *bio, int err)
{
	const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
	struct page *page = bio->bi_io_vec[0].bv_page;

	if (!uptodate) {
		SetPageError(page);
		/*
		 * We failed to write the page out to swap-space.
		 * Re-dirty the page in order to avoid it being reclaimed.
		 * Also print a dire warning that things will go BAD (tm)
		 * very quickly.
		 *
		 * Also clear PG_reclaim to avoid rotate_reclaimable_page()
		 */
		set_page_dirty(page);
		printk(KERN_ALERT "Write-error on swap-device (%u:%u:%Lu)\n",
				imajor(bio->bi_bdev->bd_inode),
				iminor(bio->bi_bdev->bd_inode),
				(unsigned long long)bio->bi_sector);
		ClearPageReclaim(page);
	}
	end_page_writeback(page);
	bio_put(bio);
}

void end_swap_bio_read(struct bio *bio, int err)
{
	const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
	struct page *page = bio->bi_io_vec[0].bv_page;

	if (!uptodate) {
		SetPageError(page);
		ClearPageUptodate(page);
		printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",
				imajor(bio->bi_bdev->bd_inode),
				iminor(bio->bi_bdev->bd_inode),
				(unsigned long long)bio->bi_sector);
	} else {
		SetPageUptodate(page);
	}
	unlock_page(page);
	bio_put(bio);
}

/*
 * We may have stale swap cache pages in memory: notice
 * them here and get rid of the unnecessary final write.
 */
int swap_writepage(struct page *page, struct writeback_control *wbc)
{
	struct bio *bio;
	int ret = 0, rw = WRITE;

	if (try_to_free_swap(page)) {
		unlock_page(page);
		goto out;
	}
	if (frontswap_store(page) == 0) {
		set_page_writeback(page);
		unlock_page(page);
		end_page_writeback(page);
		goto out;
	}
	bio = get_swap_bio(GFP_NOIO, page, end_swap_bio_write);
	if (bio == NULL) {
		set_page_dirty(page);
		unlock_page(page);
		ret = -ENOMEM;
		goto out;
	}
	if (wbc->sync_mode == WB_SYNC_ALL)
		rw |= REQ_SYNC;
	count_vm_event(PSWPOUT);
	set_page_writeback(page);
	unlock_page(page);
	submit_bio(rw, bio);
out:
	return ret;
}

int swap_readpage(struct page *page)
{
	struct bio *bio;
	int ret = 0;

	VM_BUG_ON(!PageLocked(page));
	VM_BUG_ON(PageUptodate(page));
	if (frontswap_load(page) == 0) {
		SetPageUptodate(page);
		unlock_page(page);
		goto out;
	}
	bio = get_swap_bio(GFP_KERNEL, page, end_swap_bio_read);
	if (bio == NULL) {
		unlock_page(page);
		ret = -ENOMEM;
		goto out;
	}
	count_vm_event(PSWPIN);
	submit_bio(READ, bio);
out:
	return ret;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* linux/mm/page_io.c
	3	*
	4	* Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
	5	*
	6	* Swap reorganised 29.12.95,
	7	* Asynchronous swapping added 30.12.95. Stephen Tweedie
	8	* Removed race in async swapping. 14.4.1996. Bruno Haible
	9	* Add swap of shared pages through the page cache. 20.2.1998. Stephen Tweedie
	10	* Always use brw_page, life becomes simpler. 12 May 1998 Eric Biederman
	11	*/
	12
	13	#include <linux/mm.h>
	14	#include <linux/kernel_stat.h>
5a0e3ad6	15	#include <linux/gfp.h>
1da177e4 LT	16	#include <linux/pagemap.h>
	17	#include <linux/swap.h>
	18	#include <linux/bio.h>
	19	#include <linux/swapops.h>
	20	#include <linux/writeback.h>
38b5faf4	21	#include <linux/frontswap.h>
1da177e4 LT	22	#include <asm/pgtable.h>
1da177e4 LT	23
f29ad6a9	24	static struct bio *get_swap_bio(gfp_t gfp_flags,
1da177e4 LT	25	struct page *page, bio_end_io_t end_io)
	26	{
	27	struct bio *bio;
	28
	29	bio = bio_alloc(gfp_flags, 1);
	30	if (bio) {
d4906e1a	31	bio->bi_sector = map_swap_page(page, &bio->bi_bdev);
f29ad6a9	32	bio->bi_sector <<= PAGE_SHIFT - 9;
1da177e4 LT	33	bio->bi_io_vec[0].bv_page = page;
	34	bio->bi_io_vec[0].bv_len = PAGE_SIZE;
	35	bio->bi_io_vec[0].bv_offset = 0;
	36	bio->bi_vcnt = 1;
	37	bio->bi_idx = 0;
	38	bio->bi_size = PAGE_SIZE;
	39	bio->bi_end_io = end_io;
	40	}
	41	return bio;
	42	}
	43
6712ecf8	44	static void end_swap_bio_write(struct bio *bio, int err)
1da177e4 LT	45	{
	46	const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
	47	struct page *page = bio->bi_io_vec[0].bv_page;
	48
6ddab3b9	49	if (!uptodate) {
1da177e4	50	SetPageError(page);
6ddab3b9 PZ	51	/*
	52	* We failed to write the page out to swap-space.
	53	* Re-dirty the page in order to avoid it being reclaimed.
	54	* Also print a dire warning that things will go BAD (tm)
	55	* very quickly.
	56	*
	57	* Also clear PG_reclaim to avoid rotate_reclaimable_page()
	58	*/
	59	set_page_dirty(page);
	60	printk(KERN_ALERT "Write-error on swap-device (%u:%u:%Lu)\n",
	61	imajor(bio->bi_bdev->bd_inode),
	62	iminor(bio->bi_bdev->bd_inode),
	63	(unsigned long long)bio->bi_sector);
	64	ClearPageReclaim(page);
	65	}
1da177e4 LT	66	end_page_writeback(page);
1da177e4 LT	67	bio_put(bio);
1da177e4 LT	68	}
1da177e4 LT	69
6712ecf8	70	void end_swap_bio_read(struct bio *bio, int err)
1da177e4 LT	71	{
	72	const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
	73	struct page *page = bio->bi_io_vec[0].bv_page;
	74
1da177e4 LT	75	if (!uptodate) {
	76	SetPageError(page);
	77	ClearPageUptodate(page);
6ddab3b9 PZ	78	printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",
	79	imajor(bio->bi_bdev->bd_inode),
	80	iminor(bio->bi_bdev->bd_inode),
	81	(unsigned long long)bio->bi_sector);
1da177e4 LT	82	} else {
	83	SetPageUptodate(page);
	84	}
	85	unlock_page(page);
	86	bio_put(bio);
1da177e4 LT	87	}
	88
	89	/*
	90	* We may have stale swap cache pages in memory: notice
	91	* them here and get rid of the unnecessary final write.
	92	*/
	93	int swap_writepage(struct page page, struct writeback_control wbc)
	94	{
	95	struct bio *bio;
	96	int ret = 0, rw = WRITE;
	97
a2c43eed	98	if (try_to_free_swap(page)) {
1da177e4 LT	99	unlock_page(page);
	100	goto out;
	101	}
165c8aed	102	if (frontswap_store(page) == 0) {
38b5faf4 DM	103	set_page_writeback(page);
	104	unlock_page(page);
	105	end_page_writeback(page);
	106	goto out;
	107	}
f29ad6a9	108	bio = get_swap_bio(GFP_NOIO, page, end_swap_bio_write);
1da177e4 LT	109	if (bio == NULL) {
	110	set_page_dirty(page);
	111	unlock_page(page);
	112	ret = -ENOMEM;
	113	goto out;
	114	}
	115	if (wbc->sync_mode == WB_SYNC_ALL)
721a9602	116	rw \|= REQ_SYNC;
f8891e5e	117	count_vm_event(PSWPOUT);
1da177e4 LT	118	set_page_writeback(page);
	119	unlock_page(page);
	120	submit_bio(rw, bio);
	121	out:
	122	return ret;
	123	}
	124
aca8bf32	125	int swap_readpage(struct page *page)
1da177e4 LT	126	{
	127	struct bio *bio;
	128	int ret = 0;
	129
51726b12 HD	130	VM_BUG_ON(!PageLocked(page));
51726b12 HD	131	VM_BUG_ON(PageUptodate(page));
165c8aed	132	if (frontswap_load(page) == 0) {
38b5faf4 DM	133	SetPageUptodate(page);
	134	unlock_page(page);
	135	goto out;
	136	}
f29ad6a9	137	bio = get_swap_bio(GFP_KERNEL, page, end_swap_bio_read);
1da177e4 LT	138	if (bio == NULL) {
	139	unlock_page(page);
	140	ret = -ENOMEM;
	141	goto out;
	142	}
f8891e5e	143	count_vm_event(PSWPIN);
1da177e4 LT	144	submit_bio(READ, bio);
	145	out:
	146	return ret;
	147	}