[thirdparty/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/buffer_head.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;
	struct swap_info_struct *sis = page_swap_info(page);

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

	if (sis->flags & SWP_FILE) {
		struct kiocb kiocb;
		struct file *swap_file = sis->swap_file;
		struct address_space *mapping = swap_file->f_mapping;
		struct iovec iov = {
			.iov_base = page_address(page),
			.iov_len  = PAGE_SIZE,
		};

		init_sync_kiocb(&kiocb, swap_file);
		kiocb.ki_pos = page_file_offset(page);
		kiocb.ki_left = PAGE_SIZE;
		kiocb.ki_nbytes = PAGE_SIZE;

		unlock_page(page);
		ret = mapping->a_ops->direct_IO(KERNEL_WRITE,
						&kiocb, &iov,
						kiocb.ki_pos, 1);
		if (ret == PAGE_SIZE) {
			count_vm_event(PSWPOUT);
			ret = 0;
		}
		return ret;
	}

	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;
	struct swap_info_struct *sis = page_swap_info(page);

	VM_BUG_ON(!PageLocked(page));
	VM_BUG_ON(PageUptodate(page));
	if (frontswap_load(page) == 0) {
		SetPageUptodate(page);
		unlock_page(page);
		goto out;
	}

	if (sis->flags & SWP_FILE) {
		struct file *swap_file = sis->swap_file;
		struct address_space *mapping = swap_file->f_mapping;

		ret = mapping->a_ops->readpage(swap_file, page);
		if (!ret)
			count_vm_event(PSWPIN);
		return ret;
	}

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

int swap_set_page_dirty(struct page *page)
{
	struct swap_info_struct *sis = page_swap_info(page);

	if (sis->flags & SWP_FILE) {
		struct address_space *mapping = sis->swap_file->f_mapping;
		return mapping->a_ops->set_page_dirty(page);
	} else {
		return __set_page_dirty_no_writeback(page);
	}
}
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>
62c230bc	20	#include <linux/buffer_head.h>
1da177e4	21	#include <linux/writeback.h>
38b5faf4	22	#include <linux/frontswap.h>
1da177e4 LT	23	#include <asm/pgtable.h>
1da177e4 LT	24
f29ad6a9	25	static struct bio *get_swap_bio(gfp_t gfp_flags,
1da177e4 LT	26	struct page *page, bio_end_io_t end_io)
	27	{
	28	struct bio *bio;
	29
	30	bio = bio_alloc(gfp_flags, 1);
	31	if (bio) {
d4906e1a	32	bio->bi_sector = map_swap_page(page, &bio->bi_bdev);
f29ad6a9	33	bio->bi_sector <<= PAGE_SHIFT - 9;
1da177e4 LT	34	bio->bi_io_vec[0].bv_page = page;
	35	bio->bi_io_vec[0].bv_len = PAGE_SIZE;
	36	bio->bi_io_vec[0].bv_offset = 0;
	37	bio->bi_vcnt = 1;
	38	bio->bi_idx = 0;
	39	bio->bi_size = PAGE_SIZE;
	40	bio->bi_end_io = end_io;
	41	}
	42	return bio;
	43	}
	44
6712ecf8	45	static void end_swap_bio_write(struct bio *bio, int err)
1da177e4 LT	46	{
	47	const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
	48	struct page *page = bio->bi_io_vec[0].bv_page;
	49
6ddab3b9	50	if (!uptodate) {
1da177e4	51	SetPageError(page);
6ddab3b9 PZ	52	/*
	53	* We failed to write the page out to swap-space.
	54	* Re-dirty the page in order to avoid it being reclaimed.
	55	* Also print a dire warning that things will go BAD (tm)
	56	* very quickly.
	57	*
	58	* Also clear PG_reclaim to avoid rotate_reclaimable_page()
	59	*/
	60	set_page_dirty(page);
	61	printk(KERN_ALERT "Write-error on swap-device (%u:%u:%Lu)\n",
	62	imajor(bio->bi_bdev->bd_inode),
	63	iminor(bio->bi_bdev->bd_inode),
	64	(unsigned long long)bio->bi_sector);
	65	ClearPageReclaim(page);
	66	}
1da177e4 LT	67	end_page_writeback(page);
1da177e4 LT	68	bio_put(bio);
1da177e4 LT	69	}
1da177e4 LT	70
6712ecf8	71	void end_swap_bio_read(struct bio *bio, int err)
1da177e4 LT	72	{
	73	const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
	74	struct page *page = bio->bi_io_vec[0].bv_page;
	75
1da177e4 LT	76	if (!uptodate) {
	77	SetPageError(page);
	78	ClearPageUptodate(page);
6ddab3b9 PZ	79	printk(KERN_ALERT "Read-error on swap-device (%u:%u:%Lu)\n",
	80	imajor(bio->bi_bdev->bd_inode),
	81	iminor(bio->bi_bdev->bd_inode),
	82	(unsigned long long)bio->bi_sector);
1da177e4 LT	83	} else {
	84	SetPageUptodate(page);
	85	}
	86	unlock_page(page);
	87	bio_put(bio);
1da177e4 LT	88	}
	89
	90	/*
	91	* We may have stale swap cache pages in memory: notice
	92	* them here and get rid of the unnecessary final write.
	93	*/
	94	int swap_writepage(struct page page, struct writeback_control wbc)
	95	{
	96	struct bio *bio;
	97	int ret = 0, rw = WRITE;
62c230bc	98	struct swap_info_struct *sis = page_swap_info(page);
1da177e4	99
a2c43eed	100	if (try_to_free_swap(page)) {
1da177e4 LT	101	unlock_page(page);
	102	goto out;
	103	}
165c8aed	104	if (frontswap_store(page) == 0) {
38b5faf4 DM	105	set_page_writeback(page);
	106	unlock_page(page);
	107	end_page_writeback(page);
	108	goto out;
	109	}
62c230bc MG	110
	111	if (sis->flags & SWP_FILE) {
	112	struct kiocb kiocb;
	113	struct file *swap_file = sis->swap_file;
	114	struct address_space *mapping = swap_file->f_mapping;
	115	struct iovec iov = {
	116	.iov_base = page_address(page),
	117	.iov_len = PAGE_SIZE,
	118	};
	119
	120	init_sync_kiocb(&kiocb, swap_file);
	121	kiocb.ki_pos = page_file_offset(page);
	122	kiocb.ki_left = PAGE_SIZE;
	123	kiocb.ki_nbytes = PAGE_SIZE;
	124
	125	unlock_page(page);
	126	ret = mapping->a_ops->direct_IO(KERNEL_WRITE,
	127	&kiocb, &iov,
	128	kiocb.ki_pos, 1);
	129	if (ret == PAGE_SIZE) {
	130	count_vm_event(PSWPOUT);
	131	ret = 0;
	132	}
	133	return ret;
	134	}
	135
f29ad6a9	136	bio = get_swap_bio(GFP_NOIO, page, end_swap_bio_write);
1da177e4 LT	137	if (bio == NULL) {
	138	set_page_dirty(page);
	139	unlock_page(page);
	140	ret = -ENOMEM;
	141	goto out;
	142	}
	143	if (wbc->sync_mode == WB_SYNC_ALL)
721a9602	144	rw \|= REQ_SYNC;
f8891e5e	145	count_vm_event(PSWPOUT);
1da177e4 LT	146	set_page_writeback(page);
	147	unlock_page(page);
	148	submit_bio(rw, bio);
	149	out:
	150	return ret;
	151	}
	152
aca8bf32	153	int swap_readpage(struct page *page)
1da177e4 LT	154	{
	155	struct bio *bio;
	156	int ret = 0;
62c230bc	157	struct swap_info_struct *sis = page_swap_info(page);
1da177e4	158
51726b12 HD	159	VM_BUG_ON(!PageLocked(page));
51726b12 HD	160	VM_BUG_ON(PageUptodate(page));
165c8aed	161	if (frontswap_load(page) == 0) {
38b5faf4 DM	162	SetPageUptodate(page);
	163	unlock_page(page);
	164	goto out;
	165	}
62c230bc MG	166
	167	if (sis->flags & SWP_FILE) {
	168	struct file *swap_file = sis->swap_file;
	169	struct address_space *mapping = swap_file->f_mapping;
	170
	171	ret = mapping->a_ops->readpage(swap_file, page);
	172	if (!ret)
	173	count_vm_event(PSWPIN);
	174	return ret;
	175	}
	176
f29ad6a9	177	bio = get_swap_bio(GFP_KERNEL, page, end_swap_bio_read);
1da177e4 LT	178	if (bio == NULL) {
	179	unlock_page(page);
	180	ret = -ENOMEM;
	181	goto out;
	182	}
f8891e5e	183	count_vm_event(PSWPIN);
1da177e4 LT	184	submit_bio(READ, bio);
	185	out:
	186	return ret;
	187	}
62c230bc MG	188
	189	int swap_set_page_dirty(struct page *page)
	190	{
	191	struct swap_info_struct *sis = page_swap_info(page);
	192
	193	if (sis->flags & SWP_FILE) {
	194	struct address_space *mapping = sis->swap_file->f_mapping;
	195	return mapping->a_ops->set_page_dirty(page);
	196	} else {
	197	return __set_page_dirty_no_writeback(page);
	198	}
	199	}