mpage.c 21.1 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5 6 7 8 9
/*
 * fs/mpage.c
 *
 * Copyright (C) 2002, Linus Torvalds.
 *
 * Contains functions related to preparing and submitting BIOs which contain
 * multiple pagecache pages.
 *
10
 * 15May2002	Andrew Morton
Linus Torvalds's avatar
Linus Torvalds committed
11 12 13 14 15 16
 *		Initial version
 * 27Jun2002	axboe@suse.de
 *		use bio_add_page() to build bio's just the right size
 */

#include <linux/kernel.h>
17
#include <linux/export.h>
Linus Torvalds's avatar
Linus Torvalds committed
18 19
#include <linux/mm.h>
#include <linux/kdev_t.h>
20
#include <linux/gfp.h>
Linus Torvalds's avatar
Linus Torvalds committed
21 22 23 24 25 26 27
#include <linux/bio.h>
#include <linux/fs.h>
#include <linux/buffer_head.h>
#include <linux/blkdev.h>
#include <linux/highmem.h>
#include <linux/prefetch.h>
#include <linux/mpage.h>
28
#include <linux/mm_inline.h>
Linus Torvalds's avatar
Linus Torvalds committed
29 30 31
#include <linux/writeback.h>
#include <linux/backing-dev.h>
#include <linux/pagevec.h>
32
#include <linux/cleancache.h>
33
#include "internal.h"
Linus Torvalds's avatar
Linus Torvalds committed
34 35 36 37 38 39 40 41 42 43 44 45 46

/*
 * I/O completion handler for multipage BIOs.
 *
 * The mpage code never puts partial pages into a BIO (except for end-of-file).
 * If a page does not map to a contiguous run of blocks then it simply falls
 * back to block_read_full_page().
 *
 * Why is this?  If a page's completion depends on a number of different BIOs
 * which can complete in any order (or at the same time) then determining the
 * status of that page is hard.  See end_buffer_async_read() for the details.
 * There is no point in duplicating all that complexity.
 */
47
static void mpage_end_io(struct bio *bio)
Linus Torvalds's avatar
Linus Torvalds committed
48
{
49
	struct bio_vec *bv;
50
	struct bvec_iter_all iter_all;
Linus Torvalds's avatar
Linus Torvalds committed
51

52
	bio_for_each_segment_all(bv, bio, iter_all) {
53
		struct page *page = bv->bv_page;
54 55
		page_endio(page, bio_op(bio),
			   blk_status_to_errno(bio->bi_status));
56 57
	}

Linus Torvalds's avatar
Linus Torvalds committed
58 59 60
	bio_put(bio);
}

61
static struct bio *mpage_bio_submit(int op, int op_flags, struct bio *bio)
Linus Torvalds's avatar
Linus Torvalds committed
62
{
Hai Shan's avatar
Hai Shan committed
63
	bio->bi_end_io = mpage_end_io;
64 65
	bio_set_op_attrs(bio, op, op_flags);
	guard_bio_eod(op, bio);
66
	submit_bio(bio);
Linus Torvalds's avatar
Linus Torvalds committed
67 68 69 70 71 72
	return NULL;
}

static struct bio *
mpage_alloc(struct block_device *bdev,
		sector_t first_sector, int nr_vecs,
73
		gfp_t gfp_flags)
Linus Torvalds's avatar
Linus Torvalds committed
74 75 76
{
	struct bio *bio;

77 78
	/* Restrict the given (page cache) mask for slab allocations */
	gfp_flags &= GFP_KERNEL;
Linus Torvalds's avatar
Linus Torvalds committed
79 80 81 82 83 84 85 86
	bio = bio_alloc(gfp_flags, nr_vecs);

	if (bio == NULL && (current->flags & PF_MEMALLOC)) {
		while (!bio && (nr_vecs /= 2))
			bio = bio_alloc(gfp_flags, nr_vecs);
	}

	if (bio) {
87
		bio_set_dev(bio, bdev);
88
		bio->bi_iter.bi_sector = first_sector;
Linus Torvalds's avatar
Linus Torvalds committed
89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
	}
	return bio;
}

/*
 * support function for mpage_readpages.  The fs supplied get_block might
 * return an up to date buffer.  This is used to map that buffer into
 * the page, which allows readpage to avoid triggering a duplicate call
 * to get_block.
 *
 * The idea is to avoid adding buffers to pages that don't already have
 * them.  So when the buffer is up to date and the page size == block size,
 * this marks the page up to date instead of adding new buffers.
 */
static void 
map_buffer_to_page(struct page *page, struct buffer_head *bh, int page_block) 
{
	struct inode *inode = page->mapping->host;
	struct buffer_head *page_bh, *head;
	int block = 0;

	if (!page_has_buffers(page)) {
		/*
		 * don't make any buffers if there is only one buffer on
		 * the page and the page just needs to be set up to date
		 */
115
		if (inode->i_blkbits == PAGE_SHIFT &&
Linus Torvalds's avatar
Linus Torvalds committed
116 117 118 119
		    buffer_uptodate(bh)) {
			SetPageUptodate(page);    
			return;
		}
Fabian Frederick's avatar
Fabian Frederick committed
120
		create_empty_buffers(page, i_blocksize(inode), 0);
Linus Torvalds's avatar
Linus Torvalds committed
121 122 123 124 125 126 127 128 129 130 131 132 133 134 135
	}
	head = page_buffers(page);
	page_bh = head;
	do {
		if (block == page_block) {
			page_bh->b_state = bh->b_state;
			page_bh->b_bdev = bh->b_bdev;
			page_bh->b_blocknr = bh->b_blocknr;
			break;
		}
		page_bh = page_bh->b_this_page;
		block++;
	} while (page_bh != head);
}

136 137 138 139
struct mpage_readpage_args {
	struct bio *bio;
	struct page *page;
	unsigned int nr_pages;
140
	bool is_readahead;
141 142 143 144 145 146
	sector_t last_block_in_bio;
	struct buffer_head map_bh;
	unsigned long first_logical_block;
	get_block_t *get_block;
};

147 148 149 150 151 152 153 154 155
/*
 * This is the worker routine which does all the work of mapping the disk
 * blocks and constructs largest possible bios, submits them for IO if the
 * blocks are not contiguous on the disk.
 *
 * We pass a buffer_head back and forth and use its buffer_mapped() flag to
 * represent the validity of its disk mapping and to decide when to do the next
 * get_block() call.
 */
156
static struct bio *do_mpage_readpage(struct mpage_readpage_args *args)
Linus Torvalds's avatar
Linus Torvalds committed
157
{
158
	struct page *page = args->page;
Linus Torvalds's avatar
Linus Torvalds committed
159 160
	struct inode *inode = page->mapping->host;
	const unsigned blkbits = inode->i_blkbits;
161
	const unsigned blocks_per_page = PAGE_SIZE >> blkbits;
Linus Torvalds's avatar
Linus Torvalds committed
162
	const unsigned blocksize = 1 << blkbits;
163
	struct buffer_head *map_bh = &args->map_bh;
Linus Torvalds's avatar
Linus Torvalds committed
164 165
	sector_t block_in_file;
	sector_t last_block;
166
	sector_t last_block_in_file;
Linus Torvalds's avatar
Linus Torvalds committed
167 168 169 170 171 172
	sector_t blocks[MAX_BUF_PER_PAGE];
	unsigned page_block;
	unsigned first_hole = blocks_per_page;
	struct block_device *bdev = NULL;
	int length;
	int fully_mapped = 1;
173
	int op_flags;
174 175
	unsigned nblocks;
	unsigned relative_block;
176 177 178 179 180 181 182 183 184
	gfp_t gfp;

	if (args->is_readahead) {
		op_flags = REQ_RAHEAD;
		gfp = readahead_gfp_mask(page->mapping);
	} else {
		op_flags = 0;
		gfp = mapping_gfp_constraint(page->mapping, GFP_KERNEL);
	}
Linus Torvalds's avatar
Linus Torvalds committed
185 186 187 188

	if (page_has_buffers(page))
		goto confused;

189
	block_in_file = (sector_t)page->index << (PAGE_SHIFT - blkbits);
190
	last_block = block_in_file + args->nr_pages * blocks_per_page;
191 192 193 194 195 196 197 198 199
	last_block_in_file = (i_size_read(inode) + blocksize - 1) >> blkbits;
	if (last_block > last_block_in_file)
		last_block = last_block_in_file;
	page_block = 0;

	/*
	 * Map blocks using the result from the previous get_blocks call first.
	 */
	nblocks = map_bh->b_size >> blkbits;
200 201 202 203
	if (buffer_mapped(map_bh) &&
			block_in_file > args->first_logical_block &&
			block_in_file < (args->first_logical_block + nblocks)) {
		unsigned map_offset = block_in_file - args->first_logical_block;
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
		unsigned last = nblocks - map_offset;

		for (relative_block = 0; ; relative_block++) {
			if (relative_block == last) {
				clear_buffer_mapped(map_bh);
				break;
			}
			if (page_block == blocks_per_page)
				break;
			blocks[page_block] = map_bh->b_blocknr + map_offset +
						relative_block;
			page_block++;
			block_in_file++;
		}
		bdev = map_bh->b_bdev;
	}

	/*
	 * Then do more get_blocks calls until we are done with this page.
	 */
	map_bh->b_page = page;
	while (page_block < blocks_per_page) {
		map_bh->b_state = 0;
		map_bh->b_size = 0;
Linus Torvalds's avatar
Linus Torvalds committed
228 229

		if (block_in_file < last_block) {
230
			map_bh->b_size = (last_block-block_in_file) << blkbits;
231
			if (args->get_block(inode, block_in_file, map_bh, 0))
Linus Torvalds's avatar
Linus Torvalds committed
232
				goto confused;
233
			args->first_logical_block = block_in_file;
Linus Torvalds's avatar
Linus Torvalds committed
234 235
		}

236
		if (!buffer_mapped(map_bh)) {
Linus Torvalds's avatar
Linus Torvalds committed
237 238 239
			fully_mapped = 0;
			if (first_hole == blocks_per_page)
				first_hole = page_block;
240 241
			page_block++;
			block_in_file++;
Linus Torvalds's avatar
Linus Torvalds committed
242 243 244 245 246 247 248 249 250
			continue;
		}

		/* some filesystems will copy data into the page during
		 * the get_block call, in which case we don't want to
		 * read it again.  map_buffer_to_page copies the data
		 * we just collected from get_block into the page's buffers
		 * so readpage doesn't have to repeat the get_block call
		 */
251 252
		if (buffer_uptodate(map_bh)) {
			map_buffer_to_page(page, map_bh, page_block);
Linus Torvalds's avatar
Linus Torvalds committed
253 254 255 256 257 258 259
			goto confused;
		}
	
		if (first_hole != blocks_per_page)
			goto confused;		/* hole -> non-hole */

		/* Contiguous blocks? */
260
		if (page_block && blocks[page_block-1] != map_bh->b_blocknr-1)
Linus Torvalds's avatar
Linus Torvalds committed
261
			goto confused;
262 263 264 265 266 267 268 269 270 271 272 273
		nblocks = map_bh->b_size >> blkbits;
		for (relative_block = 0; ; relative_block++) {
			if (relative_block == nblocks) {
				clear_buffer_mapped(map_bh);
				break;
			} else if (page_block == blocks_per_page)
				break;
			blocks[page_block] = map_bh->b_blocknr+relative_block;
			page_block++;
			block_in_file++;
		}
		bdev = map_bh->b_bdev;
Linus Torvalds's avatar
Linus Torvalds committed
274 275 276
	}

	if (first_hole != blocks_per_page) {
277
		zero_user_segment(page, first_hole << blkbits, PAGE_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
278 279 280 281 282 283 284 285 286
		if (first_hole == 0) {
			SetPageUptodate(page);
			unlock_page(page);
			goto out;
		}
	} else if (fully_mapped) {
		SetPageMappedToDisk(page);
	}

287 288 289 290 291 292
	if (fully_mapped && blocks_per_page == 1 && !PageUptodate(page) &&
	    cleancache_get_page(page) == 0) {
		SetPageUptodate(page);
		goto confused;
	}

Linus Torvalds's avatar
Linus Torvalds committed
293 294 295
	/*
	 * This page will go to BIO.  Do we need to send this BIO off first?
	 */
296
	if (args->bio && (args->last_block_in_bio != blocks[0] - 1))
297
		args->bio = mpage_bio_submit(REQ_OP_READ, op_flags, args->bio);
Linus Torvalds's avatar
Linus Torvalds committed
298 299

alloc_new:
300
	if (args->bio == NULL) {
301 302 303 304 305
		if (first_hole == blocks_per_page) {
			if (!bdev_read_page(bdev, blocks[0] << (blkbits - 9),
								page))
				goto out;
		}
306 307 308
		args->bio = mpage_alloc(bdev, blocks[0] << (blkbits - 9),
					min_t(int, args->nr_pages,
					      BIO_MAX_PAGES),
309
					gfp);
310
		if (args->bio == NULL)
Linus Torvalds's avatar
Linus Torvalds committed
311 312 313 314
			goto confused;
	}

	length = first_hole << blkbits;
315
	if (bio_add_page(args->bio, page, length, 0) < length) {
316
		args->bio = mpage_bio_submit(REQ_OP_READ, op_flags, args->bio);
Linus Torvalds's avatar
Linus Torvalds committed
317 318 319
		goto alloc_new;
	}

320
	relative_block = block_in_file - args->first_logical_block;
321 322 323
	nblocks = map_bh->b_size >> blkbits;
	if ((buffer_boundary(map_bh) && relative_block == nblocks) ||
	    (first_hole != blocks_per_page))
324
		args->bio = mpage_bio_submit(REQ_OP_READ, op_flags, args->bio);
Linus Torvalds's avatar
Linus Torvalds committed
325
	else
326
		args->last_block_in_bio = blocks[blocks_per_page - 1];
Linus Torvalds's avatar
Linus Torvalds committed
327
out:
328
	return args->bio;
Linus Torvalds's avatar
Linus Torvalds committed
329 330

confused:
331
	if (args->bio)
332
		args->bio = mpage_bio_submit(REQ_OP_READ, op_flags, args->bio);
Linus Torvalds's avatar
Linus Torvalds committed
333
	if (!PageUptodate(page))
334
		block_read_full_page(page, args->get_block);
Linus Torvalds's avatar
Linus Torvalds committed
335 336 337 338 339
	else
		unlock_page(page);
	goto out;
}

340
/**
341
 * mpage_readpages - populate an address space with some pages & start reads against them
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360
 * @mapping: the address_space
 * @pages: The address of a list_head which contains the target pages.  These
 *   pages have their ->index populated and are otherwise uninitialised.
 *   The page at @pages->prev has the lowest file offset, and reads should be
 *   issued in @pages->prev to @pages->next order.
 * @nr_pages: The number of pages at *@pages
 * @get_block: The filesystem's block mapper function.
 *
 * This function walks the pages and the blocks within each page, building and
 * emitting large BIOs.
 *
 * If anything unusual happens, such as:
 *
 * - encountering a page which has buffers
 * - encountering a page which has a non-hole after a hole
 * - encountering a page with non-contiguous blocks
 *
 * then this code just gives up and calls the buffer_head-based read function.
 * It does handle a page which has holes at the end - that is a common case:
361
 * the end-of-file on blocksize < PAGE_SIZE setups.
362 363 364 365 366 367 368 369 370
 *
 * BH_Boundary explanation:
 *
 * There is a problem.  The mpage read code assembles several pages, gets all
 * their disk mappings, and then submits them all.  That's fine, but obtaining
 * the disk mappings may require I/O.  Reads of indirect blocks, for example.
 *
 * So an mpage read of the first 16 blocks of an ext2 file will cause I/O to be
 * submitted in the following order:
371
 *
372
 * 	12 0 1 2 3 4 5 6 7 8 9 10 11 13 14 15 16
373
 *
374 375 376 377 378 379 380 381 382 383
 * because the indirect block has to be read to get the mappings of blocks
 * 13,14,15,16.  Obviously, this impacts performance.
 *
 * So what we do it to allow the filesystem's get_block() function to set
 * BH_Boundary when it maps block 11.  BH_Boundary says: mapping of the block
 * after this one will require I/O against a block which is probably close to
 * this one.  So you should push what I/O you have currently accumulated.
 *
 * This all causes the disk requests to be issued in the correct order.
 */
Linus Torvalds's avatar
Linus Torvalds committed
384 385 386 387
int
mpage_readpages(struct address_space *mapping, struct list_head *pages,
				unsigned nr_pages, get_block_t get_block)
{
388 389
	struct mpage_readpage_args args = {
		.get_block = get_block,
390
		.is_readahead = true,
391
	};
Linus Torvalds's avatar
Linus Torvalds committed
392 393 394
	unsigned page_idx;

	for (page_idx = 0; page_idx < nr_pages; page_idx++) {
395
		struct page *page = lru_to_page(pages);
Linus Torvalds's avatar
Linus Torvalds committed
396 397 398

		prefetchw(&page->flags);
		list_del(&page->lru);
Nick Piggin's avatar
Nick Piggin committed
399
		if (!add_to_page_cache_lru(page, mapping,
400
					page->index,
401
					readahead_gfp_mask(mapping))) {
402 403 404
			args.page = page;
			args.nr_pages = nr_pages - page_idx;
			args.bio = do_mpage_readpage(&args);
Linus Torvalds's avatar
Linus Torvalds committed
405
		}
406
		put_page(page);
Linus Torvalds's avatar
Linus Torvalds committed
407 408
	}
	BUG_ON(!list_empty(pages));
409
	if (args.bio)
410
		mpage_bio_submit(REQ_OP_READ, REQ_RAHEAD, args.bio);
Linus Torvalds's avatar
Linus Torvalds committed
411 412 413 414 415 416 417 418 419
	return 0;
}
EXPORT_SYMBOL(mpage_readpages);

/*
 * This isn't called much at all
 */
int mpage_readpage(struct page *page, get_block_t get_block)
{
420 421 422 423 424 425 426 427 428
	struct mpage_readpage_args args = {
		.page = page,
		.nr_pages = 1,
		.get_block = get_block,
	};

	args.bio = do_mpage_readpage(&args);
	if (args.bio)
		mpage_bio_submit(REQ_OP_READ, 0, args.bio);
Linus Torvalds's avatar
Linus Torvalds committed
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448
	return 0;
}
EXPORT_SYMBOL(mpage_readpage);

/*
 * Writing is not so simple.
 *
 * If the page has buffers then they will be used for obtaining the disk
 * mapping.  We only support pages which are fully mapped-and-dirty, with a
 * special case for pages which are unmapped at the end: end-of-file.
 *
 * If the page has no buffers (preferred) then the page is mapped here.
 *
 * If all blocks are found to be contiguous then the page can go into the
 * BIO.  Otherwise fall back to the mapping's writepage().
 * 
 * FIXME: This code wants an estimate of how many pages are still to be
 * written, so it can intelligently allocate a suitably-sized BIO.  For now,
 * just allocate full-size (16-page) BIOs.
 */
449

450 451 452 453 454 455 456
struct mpage_data {
	struct bio *bio;
	sector_t last_block_in_bio;
	get_block_t *get_block;
	unsigned use_writepage;
};

457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
/*
 * We have our BIO, so we can now mark the buffers clean.  Make
 * sure to only clean buffers which we know we'll be writing.
 */
static void clean_buffers(struct page *page, unsigned first_unmapped)
{
	unsigned buffer_counter = 0;
	struct buffer_head *bh, *head;
	if (!page_has_buffers(page))
		return;
	head = page_buffers(page);
	bh = head;

	do {
		if (buffer_counter++ == first_unmapped)
			break;
		clear_buffer_dirty(bh);
		bh = bh->b_this_page;
	} while (bh != head);

	/*
	 * we cannot drop the bh if the page is not uptodate or a concurrent
	 * readpage would fail to serialize with the bh and it would read from
	 * disk before we reach the platter.
	 */
	if (buffer_heads_over_limit && PageUptodate(page))
		try_to_free_buffers(page);
}

486 487 488 489 490 491 492 493 494 495
/*
 * For situations where we want to clean all buffers attached to a page.
 * We don't need to calculate how many buffers are attached to the page,
 * we just need to specify a number larger than the maximum number of buffers.
 */
void clean_page_buffers(struct page *page)
{
	clean_buffers(page, ~0U);
}

496
static int __mpage_writepage(struct page *page, struct writeback_control *wbc,
497
		      void *data)
Linus Torvalds's avatar
Linus Torvalds committed
498
{
499 500
	struct mpage_data *mpd = data;
	struct bio *bio = mpd->bio;
Linus Torvalds's avatar
Linus Torvalds committed
501 502 503 504
	struct address_space *mapping = page->mapping;
	struct inode *inode = page->mapping->host;
	const unsigned blkbits = inode->i_blkbits;
	unsigned long end_index;
505
	const unsigned blocks_per_page = PAGE_SIZE >> blkbits;
Linus Torvalds's avatar
Linus Torvalds committed
506 507 508 509 510 511 512 513 514 515 516 517
	sector_t last_block;
	sector_t block_in_file;
	sector_t blocks[MAX_BUF_PER_PAGE];
	unsigned page_block;
	unsigned first_unmapped = blocks_per_page;
	struct block_device *bdev = NULL;
	int boundary = 0;
	sector_t boundary_block = 0;
	struct block_device *boundary_bdev = NULL;
	int length;
	struct buffer_head map_bh;
	loff_t i_size = i_size_read(inode);
518
	int ret = 0;
519
	int op_flags = wbc_to_write_flags(wbc);
Linus Torvalds's avatar
Linus Torvalds committed
520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574

	if (page_has_buffers(page)) {
		struct buffer_head *head = page_buffers(page);
		struct buffer_head *bh = head;

		/* If they're all mapped and dirty, do it */
		page_block = 0;
		do {
			BUG_ON(buffer_locked(bh));
			if (!buffer_mapped(bh)) {
				/*
				 * unmapped dirty buffers are created by
				 * __set_page_dirty_buffers -> mmapped data
				 */
				if (buffer_dirty(bh))
					goto confused;
				if (first_unmapped == blocks_per_page)
					first_unmapped = page_block;
				continue;
			}

			if (first_unmapped != blocks_per_page)
				goto confused;	/* hole -> non-hole */

			if (!buffer_dirty(bh) || !buffer_uptodate(bh))
				goto confused;
			if (page_block) {
				if (bh->b_blocknr != blocks[page_block-1] + 1)
					goto confused;
			}
			blocks[page_block++] = bh->b_blocknr;
			boundary = buffer_boundary(bh);
			if (boundary) {
				boundary_block = bh->b_blocknr;
				boundary_bdev = bh->b_bdev;
			}
			bdev = bh->b_bdev;
		} while ((bh = bh->b_this_page) != head);

		if (first_unmapped)
			goto page_is_mapped;

		/*
		 * Page has buffers, but they are all unmapped. The page was
		 * created by pagein or read over a hole which was handled by
		 * block_read_full_page().  If this address_space is also
		 * using mpage_readpages then this can rarely happen.
		 */
		goto confused;
	}

	/*
	 * The page has no buffers: map it to disk
	 */
	BUG_ON(!PageUptodate(page));
575
	block_in_file = (sector_t)page->index << (PAGE_SHIFT - blkbits);
Linus Torvalds's avatar
Linus Torvalds committed
576 577 578 579 580
	last_block = (i_size - 1) >> blkbits;
	map_bh.b_page = page;
	for (page_block = 0; page_block < blocks_per_page; ) {

		map_bh.b_state = 0;
581
		map_bh.b_size = 1 << blkbits;
582
		if (mpd->get_block(inode, block_in_file, &map_bh, 1))
Linus Torvalds's avatar
Linus Torvalds committed
583 584
			goto confused;
		if (buffer_new(&map_bh))
585
			clean_bdev_bh_alias(&map_bh);
Linus Torvalds's avatar
Linus Torvalds committed
586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
		if (buffer_boundary(&map_bh)) {
			boundary_block = map_bh.b_blocknr;
			boundary_bdev = map_bh.b_bdev;
		}
		if (page_block) {
			if (map_bh.b_blocknr != blocks[page_block-1] + 1)
				goto confused;
		}
		blocks[page_block++] = map_bh.b_blocknr;
		boundary = buffer_boundary(&map_bh);
		bdev = map_bh.b_bdev;
		if (block_in_file == last_block)
			break;
		block_in_file++;
	}
	BUG_ON(page_block == 0);

	first_unmapped = page_block;

page_is_mapped:
606
	end_index = i_size >> PAGE_SHIFT;
Linus Torvalds's avatar
Linus Torvalds committed
607 608 609
	if (page->index >= end_index) {
		/*
		 * The page straddles i_size.  It must be zeroed out on each
610
		 * and every writepage invocation because it may be mmapped.
Linus Torvalds's avatar
Linus Torvalds committed
611 612 613 614 615
		 * "A file is mapped in multiples of the page size.  For a file
		 * that is not a multiple of the page size, the remaining memory
		 * is zeroed when mapped, and writes to that region are not
		 * written out to the file."
		 */
616
		unsigned offset = i_size & (PAGE_SIZE - 1);
Linus Torvalds's avatar
Linus Torvalds committed
617 618 619

		if (page->index > end_index || !offset)
			goto confused;
620
		zero_user_segment(page, offset, PAGE_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
621 622 623 624 625
	}

	/*
	 * This page will go to BIO.  Do we need to send this BIO off first?
	 */
626
	if (bio && mpd->last_block_in_bio != blocks[0] - 1)
627
		bio = mpage_bio_submit(REQ_OP_WRITE, op_flags, bio);
Linus Torvalds's avatar
Linus Torvalds committed
628 629 630

alloc_new:
	if (bio == NULL) {
631 632
		if (first_unmapped == blocks_per_page) {
			if (!bdev_write_page(bdev, blocks[0] << (blkbits - 9),
633
								page, wbc))
634 635
				goto out;
		}
Linus Torvalds's avatar
Linus Torvalds committed
636
		bio = mpage_alloc(bdev, blocks[0] << (blkbits - 9),
637
				BIO_MAX_PAGES, GFP_NOFS|__GFP_HIGH);
Linus Torvalds's avatar
Linus Torvalds committed
638 639
		if (bio == NULL)
			goto confused;
640

641
		wbc_init_bio(wbc, bio);
642
		bio->bi_write_hint = inode->i_write_hint;
Linus Torvalds's avatar
Linus Torvalds committed
643 644 645 646 647 648 649
	}

	/*
	 * Must try to add the page before marking the buffer clean or
	 * the confused fail path above (OOM) will be very confused when
	 * it finds all bh marked clean (i.e. it will not write anything)
	 */
650
	wbc_account_cgroup_owner(wbc, page, PAGE_SIZE);
Linus Torvalds's avatar
Linus Torvalds committed
651 652
	length = first_unmapped << blkbits;
	if (bio_add_page(bio, page, length, 0) < length) {
653
		bio = mpage_bio_submit(REQ_OP_WRITE, op_flags, bio);
Linus Torvalds's avatar
Linus Torvalds committed
654 655 656
		goto alloc_new;
	}

657
	clean_buffers(page, first_unmapped);
Linus Torvalds's avatar
Linus Torvalds committed
658 659 660 661 662

	BUG_ON(PageWriteback(page));
	set_page_writeback(page);
	unlock_page(page);
	if (boundary || (first_unmapped != blocks_per_page)) {
663
		bio = mpage_bio_submit(REQ_OP_WRITE, op_flags, bio);
Linus Torvalds's avatar
Linus Torvalds committed
664 665 666 667 668
		if (boundary_block) {
			write_boundary_block(boundary_bdev,
					boundary_block, 1 << blkbits);
		}
	} else {
669
		mpd->last_block_in_bio = blocks[blocks_per_page - 1];
Linus Torvalds's avatar
Linus Torvalds committed
670 671 672 673 674
	}
	goto out;

confused:
	if (bio)
675
		bio = mpage_bio_submit(REQ_OP_WRITE, op_flags, bio);
Linus Torvalds's avatar
Linus Torvalds committed
676

677 678
	if (mpd->use_writepage) {
		ret = mapping->a_ops->writepage(page, wbc);
Linus Torvalds's avatar
Linus Torvalds committed
679
	} else {
680
		ret = -EAGAIN;
Linus Torvalds's avatar
Linus Torvalds committed
681 682 683 684 685
		goto out;
	}
	/*
	 * The caller has a ref on the inode, so *mapping is stable
	 */
686
	mapping_set_error(mapping, ret);
Linus Torvalds's avatar
Linus Torvalds committed
687
out:
688 689
	mpd->bio = bio;
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
690 691 692
}

/**
693
 * mpage_writepages - walk the list of dirty pages of the given address space & writepage() all of them
Linus Torvalds's avatar
Linus Torvalds committed
694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
 * @mapping: address space structure to write
 * @wbc: subtract the number of written pages from *@wbc->nr_to_write
 * @get_block: the filesystem's block mapper function.
 *             If this is NULL then use a_ops->writepage.  Otherwise, go
 *             direct-to-BIO.
 *
 * This is a library function, which implements the writepages()
 * address_space_operation.
 *
 * If a page is already under I/O, generic_writepages() skips it, even
 * if it's dirty.  This is desirable behaviour for memory-cleaning writeback,
 * but it is INCORRECT for data-integrity system calls such as fsync().  fsync()
 * and msync() need to guarantee that all the data which was dirty at the time
 * the call was made get new I/O started against them.  If wbc->sync_mode is
 * WB_SYNC_ALL then we were called for data integrity and we must wait for
 * existing IO to complete.
 */
int
mpage_writepages(struct address_space *mapping,
		struct writeback_control *wbc, get_block_t get_block)
{
715
	struct blk_plug plug;
716 717
	int ret;

718 719
	blk_start_plug(&plug);

720 721 722 723 724 725 726 727 728 729 730
	if (!get_block)
		ret = generic_writepages(mapping, wbc);
	else {
		struct mpage_data mpd = {
			.bio = NULL,
			.last_block_in_bio = 0,
			.get_block = get_block,
			.use_writepage = 1,
		};

		ret = write_cache_pages(mapping, wbc, __mpage_writepage, &mpd);
731
		if (mpd.bio) {
732
			int op_flags = (wbc->sync_mode == WB_SYNC_ALL ?
733
				  REQ_SYNC : 0);
734
			mpage_bio_submit(REQ_OP_WRITE, op_flags, mpd.bio);
735
		}
Linus Torvalds's avatar
Linus Torvalds committed
736
	}
737
	blk_finish_plug(&plug);
Linus Torvalds's avatar
Linus Torvalds committed
738 739 740 741 742 743 744
	return ret;
}
EXPORT_SYMBOL(mpage_writepages);

int mpage_writepage(struct page *page, get_block_t get_block,
	struct writeback_control *wbc)
{
745 746 747 748 749 750 751
	struct mpage_data mpd = {
		.bio = NULL,
		.last_block_in_bio = 0,
		.get_block = get_block,
		.use_writepage = 0,
	};
	int ret = __mpage_writepage(page, wbc, &mpd);
752
	if (mpd.bio) {
753
		int op_flags = (wbc->sync_mode == WB_SYNC_ALL ?
754
			  REQ_SYNC : 0);
755
		mpage_bio_submit(REQ_OP_WRITE, op_flags, mpd.bio);
756
	}
Linus Torvalds's avatar
Linus Torvalds committed
757 758 759
	return ret;
}
EXPORT_SYMBOL(mpage_writepage);