[linux-2.6-block.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/pagemap.h>
#include <linux/swap.h>
#include <linux/bio.h>
#include <linux/swapops.h>
#include <linux/writeback.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;
	}
	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 |= (1 << BIO_RW_SYNCIO) | (1 << BIO_RW_UNPLUG);
	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));
	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>
	15	#include <linux/pagemap.h>
	16	#include <linux/swap.h>
	17	#include <linux/bio.h>
	18	#include <linux/swapops.h>
	19	#include <linux/writeback.h>
	20	#include <asm/pgtable.h>
	21
f29ad6a9	22	static struct bio *get_swap_bio(gfp_t gfp_flags,
1da177e4 LT	23	struct page *page, bio_end_io_t end_io)
	24	{
	25	struct bio *bio;
	26
	27	bio = bio_alloc(gfp_flags, 1);
	28	if (bio) {
d4906e1a	29	bio->bi_sector = map_swap_page(page, &bio->bi_bdev);
f29ad6a9	30	bio->bi_sector <<= PAGE_SHIFT - 9;
1da177e4 LT	31	bio->bi_io_vec[0].bv_page = page;
	32	bio->bi_io_vec[0].bv_len = PAGE_SIZE;
	33	bio->bi_io_vec[0].bv_offset = 0;
	34	bio->bi_vcnt = 1;
	35	bio->bi_idx = 0;
	36	bio->bi_size = PAGE_SIZE;
	37	bio->bi_end_io = end_io;
	38	}
	39	return bio;
	40	}
	41
6712ecf8	42	static void end_swap_bio_write(struct bio *bio, int err)
1da177e4 LT	43	{
	44	const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
	45	struct page *page = bio->bi_io_vec[0].bv_page;
	46
6ddab3b9	47	if (!uptodate) {
1da177e4	48	SetPageError(page);
6ddab3b9 PZ	49	/*
	50	* We failed to write the page out to swap-space.
	51	* Re-dirty the page in order to avoid it being reclaimed.
	52	* Also print a dire warning that things will go BAD (tm)
	53	* very quickly.
	54	*
	55	* Also clear PG_reclaim to avoid rotate_reclaimable_page()
	56	*/
	57	set_page_dirty(page);
	58	printk(KERN_ALERT "Write-error on swap-device (%u:%u:%Lu)\n",
	59	imajor(bio->bi_bdev->bd_inode),
	60	iminor(bio->bi_bdev->bd_inode),
	61	(unsigned long long)bio->bi_sector);
	62	ClearPageReclaim(page);
	63	}
1da177e4 LT	64	end_page_writeback(page);
1da177e4 LT	65	bio_put(bio);
1da177e4 LT	66	}
1da177e4 LT	67
6712ecf8	68	void end_swap_bio_read(struct bio *bio, int err)
1da177e4 LT	69	{
	70	const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
	71	struct page *page = bio->bi_io_vec[0].bv_page;
	72
1da177e4 LT	73	if (!uptodate) {
	74	SetPageError(page);
	75	ClearPageUptodate(page);
6ddab3b9 PZ	76	printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",
	77	imajor(bio->bi_bdev->bd_inode),
	78	iminor(bio->bi_bdev->bd_inode),
	79	(unsigned long long)bio->bi_sector);
1da177e4 LT	80	} else {
	81	SetPageUptodate(page);
	82	}
	83	unlock_page(page);
	84	bio_put(bio);
1da177e4 LT	85	}
	86
	87	/*
	88	* We may have stale swap cache pages in memory: notice
	89	* them here and get rid of the unnecessary final write.
	90	*/
	91	int swap_writepage(struct page page, struct writeback_control wbc)
	92	{
	93	struct bio *bio;
	94	int ret = 0, rw = WRITE;
	95
a2c43eed	96	if (try_to_free_swap(page)) {
1da177e4 LT	97	unlock_page(page);
	98	goto out;
	99	}
f29ad6a9	100	bio = get_swap_bio(GFP_NOIO, page, end_swap_bio_write);
1da177e4 LT	101	if (bio == NULL) {
	102	set_page_dirty(page);
	103	unlock_page(page);
	104	ret = -ENOMEM;
	105	goto out;
	106	}
	107	if (wbc->sync_mode == WB_SYNC_ALL)
93dbb393	108	rw \|= (1 << BIO_RW_SYNCIO) \| (1 << BIO_RW_UNPLUG);
f8891e5e	109	count_vm_event(PSWPOUT);
1da177e4 LT	110	set_page_writeback(page);
	111	unlock_page(page);
	112	submit_bio(rw, bio);
	113	out:
	114	return ret;
	115	}
	116
aca8bf32	117	int swap_readpage(struct page *page)
1da177e4 LT	118	{
	119	struct bio *bio;
	120	int ret = 0;
	121
51726b12 HD	122	VM_BUG_ON(!PageLocked(page));
51726b12 HD	123	VM_BUG_ON(PageUptodate(page));
f29ad6a9	124	bio = get_swap_bio(GFP_KERNEL, page, end_swap_bio_read);
1da177e4 LT	125	if (bio == NULL) {
	126	unlock_page(page);
	127	ret = -ENOMEM;
	128	goto out;
	129	}
f8891e5e	130	count_vm_event(PSWPIN);
1da177e4 LT	131	submit_bio(READ, bio);
	132	out:
	133	return ret;
	134	}