inode.c 138.2 KB
Newer Older
1
/*
2
 *  linux/fs/ext4/inode.c
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
 *
 * Copyright (C) 1992, 1993, 1994, 1995
 * Remy Card (card@masi.ibp.fr)
 * Laboratoire MASI - Institut Blaise Pascal
 * Universite Pierre et Marie Curie (Paris VI)
 *
 *  from
 *
 *  linux/fs/minix/inode.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 *
 *  64-bit file support on 64-bit platforms by Jakub Jelinek
 *	(jj@sunsite.ms.mff.cuni.cz)
 *
18
 *  Assorted race fixes, rewrite of ext4_get_block() by Al Viro, 2000
19 20 21 22
 */

#include <linux/fs.h>
#include <linux/time.h>
23
#include <linux/jbd2.h>
24 25 26 27 28 29
#include <linux/highuid.h>
#include <linux/pagemap.h>
#include <linux/quotaops.h>
#include <linux/string.h>
#include <linux/buffer_head.h>
#include <linux/writeback.h>
30
#include <linux/pagevec.h>
31
#include <linux/mpage.h>
32
#include <linux/namei.h>
33 34
#include <linux/uio.h>
#include <linux/bio.h>
35
#include <linux/workqueue.h>
36
#include <linux/kernel.h>
37
#include <linux/printk.h>
38
#include <linux/slab.h>
39
#include <linux/ratelimit.h>
40

41
#include "ext4_jbd2.h"
42 43
#include "xattr.h"
#include "acl.h"
44
#include "truncate.h"
45

46 47
#include <trace/events/ext4.h>

48 49
#define MPAGE_DA_EXTENT_TAIL 0x01

50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 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 115 116
static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw,
			      struct ext4_inode_info *ei)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	__u16 csum_lo;
	__u16 csum_hi = 0;
	__u32 csum;

	csum_lo = raw->i_checksum_lo;
	raw->i_checksum_lo = 0;
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
	    EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) {
		csum_hi = raw->i_checksum_hi;
		raw->i_checksum_hi = 0;
	}

	csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)raw,
			   EXT4_INODE_SIZE(inode->i_sb));

	raw->i_checksum_lo = csum_lo;
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
	    EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))
		raw->i_checksum_hi = csum_hi;

	return csum;
}

static int ext4_inode_csum_verify(struct inode *inode, struct ext4_inode *raw,
				  struct ext4_inode_info *ei)
{
	__u32 provided, calculated;

	if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
	    cpu_to_le32(EXT4_OS_LINUX) ||
	    !EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
		EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
		return 1;

	provided = le16_to_cpu(raw->i_checksum_lo);
	calculated = ext4_inode_csum(inode, raw, ei);
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
	    EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))
		provided |= ((__u32)le16_to_cpu(raw->i_checksum_hi)) << 16;
	else
		calculated &= 0xFFFF;

	return provided == calculated;
}

static void ext4_inode_csum_set(struct inode *inode, struct ext4_inode *raw,
				struct ext4_inode_info *ei)
{
	__u32 csum;

	if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
	    cpu_to_le32(EXT4_OS_LINUX) ||
	    !EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
		EXT4_FEATURE_RO_COMPAT_METADATA_CSUM))
		return;

	csum = ext4_inode_csum(inode, raw, ei);
	raw->i_checksum_lo = cpu_to_le16(csum & 0xFFFF);
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
	    EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))
		raw->i_checksum_hi = cpu_to_le16(csum >> 16);
}

117 118 119
static inline int ext4_begin_ordered_truncate(struct inode *inode,
					      loff_t new_size)
{
120
	trace_ext4_begin_ordered_truncate(inode, new_size);
121 122 123 124 125 126 127 128 129 130 131
	/*
	 * If jinode is zero, then we never opened the file for
	 * writing, so there's no need to call
	 * jbd2_journal_begin_ordered_truncate() since there's no
	 * outstanding writes we need to flush.
	 */
	if (!EXT4_I(inode)->jinode)
		return 0;
	return jbd2_journal_begin_ordered_truncate(EXT4_JOURNAL(inode),
						   EXT4_I(inode)->jinode,
						   new_size);
132 133
}

134
static void ext4_invalidatepage(struct page *page, unsigned long offset);
135 136 137 138 139 140
static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
				   struct buffer_head *bh_result, int create);
static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode);
static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate);
static int __ext4_journalled_writepage(struct page *page, unsigned int len);
static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh);
E
Eric Sandeen 已提交
141 142 143
static int ext4_discard_partial_page_buffers_no_lock(handle_t *handle,
		struct inode *inode, struct page *page, loff_t from,
		loff_t length, int flags);
144

145 146 147
/*
 * Test whether an inode is a fast symlink.
 */
148
static int ext4_inode_is_fast_symlink(struct inode *inode)
149
{
150
	int ea_blocks = EXT4_I(inode)->i_file_acl ?
151 152 153 154 155 156 157 158 159 160
		(inode->i_sb->s_blocksize >> 9) : 0;

	return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
}

/*
 * Restart the transaction associated with *handle.  This does a commit,
 * so before we call here everything must be consistently dirtied against
 * this transaction.
 */
161
int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode,
162
				 int nblocks)
163
{
164 165 166
	int ret;

	/*
167
	 * Drop i_data_sem to avoid deadlock with ext4_map_blocks.  At this
168 169 170 171
	 * moment, get_block can be called only for blocks inside i_size since
	 * page cache has been already dropped and writes are blocked by
	 * i_mutex. So we can safely drop the i_data_sem here.
	 */
172
	BUG_ON(EXT4_JOURNAL(inode) == NULL);
173
	jbd_debug(2, "restarting handle %p\n", handle);
174
	up_write(&EXT4_I(inode)->i_data_sem);
175
	ret = ext4_journal_restart(handle, nblocks);
176
	down_write(&EXT4_I(inode)->i_data_sem);
177
	ext4_discard_preallocations(inode);
178 179

	return ret;
180 181 182 183 184
}

/*
 * Called at the last iput() if i_nlink is zero.
 */
A
Al Viro 已提交
185
void ext4_evict_inode(struct inode *inode)
186 187
{
	handle_t *handle;
188
	int err;
189

190
	trace_ext4_evict_inode(inode);
191 192 193

	ext4_ioend_wait(inode);

A
Al Viro 已提交
194
	if (inode->i_nlink) {
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
		/*
		 * When journalling data dirty buffers are tracked only in the
		 * journal. So although mm thinks everything is clean and
		 * ready for reaping the inode might still have some pages to
		 * write in the running transaction or waiting to be
		 * checkpointed. Thus calling jbd2_journal_invalidatepage()
		 * (via truncate_inode_pages()) to discard these buffers can
		 * cause data loss. Also even if we did not discard these
		 * buffers, we would have no way to find them after the inode
		 * is reaped and thus user could see stale data if he tries to
		 * read them before the transaction is checkpointed. So be
		 * careful and force everything to disk here... We use
		 * ei->i_datasync_tid to store the newest transaction
		 * containing inode's data.
		 *
		 * Note that directories do not have this problem because they
		 * don't use page cache.
		 */
		if (ext4_should_journal_data(inode) &&
		    (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode))) {
			journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
			tid_t commit_tid = EXT4_I(inode)->i_datasync_tid;

			jbd2_log_start_commit(journal, commit_tid);
			jbd2_log_wait_commit(journal, commit_tid);
			filemap_write_and_wait(&inode->i_data);
		}
A
Al Viro 已提交
222 223 224 225
		truncate_inode_pages(&inode->i_data, 0);
		goto no_delete;
	}

226
	if (!is_bad_inode(inode))
227
		dquot_initialize(inode);
228

229 230
	if (ext4_should_order_data(inode))
		ext4_begin_ordered_truncate(inode, 0);
231 232 233 234 235
	truncate_inode_pages(&inode->i_data, 0);

	if (is_bad_inode(inode))
		goto no_delete;

236
	handle = ext4_journal_start(inode, ext4_blocks_for_truncate(inode)+3);
237
	if (IS_ERR(handle)) {
238
		ext4_std_error(inode->i_sb, PTR_ERR(handle));
239 240 241 242 243
		/*
		 * If we're going to skip the normal cleanup, we still need to
		 * make sure that the in-core orphan linked list is properly
		 * cleaned up.
		 */
244
		ext4_orphan_del(NULL, inode);
245 246 247 248
		goto no_delete;
	}

	if (IS_SYNC(inode))
249
		ext4_handle_sync(handle);
250
	inode->i_size = 0;
251 252
	err = ext4_mark_inode_dirty(handle, inode);
	if (err) {
253
		ext4_warning(inode->i_sb,
254 255 256
			     "couldn't mark inode dirty (err %d)", err);
		goto stop_handle;
	}
257
	if (inode->i_blocks)
258
		ext4_truncate(inode);
259 260 261 262 263 264 265

	/*
	 * ext4_ext_truncate() doesn't reserve any slop when it
	 * restarts journal transactions; therefore there may not be
	 * enough credits left in the handle to remove the inode from
	 * the orphan list and set the dtime field.
	 */
266
	if (!ext4_handle_has_enough_credits(handle, 3)) {
267 268 269 270
		err = ext4_journal_extend(handle, 3);
		if (err > 0)
			err = ext4_journal_restart(handle, 3);
		if (err != 0) {
271
			ext4_warning(inode->i_sb,
272 273 274
				     "couldn't extend journal (err %d)", err);
		stop_handle:
			ext4_journal_stop(handle);
275
			ext4_orphan_del(NULL, inode);
276 277 278 279
			goto no_delete;
		}
	}

280
	/*
281
	 * Kill off the orphan record which ext4_truncate created.
282
	 * AKPM: I think this can be inside the above `if'.
283
	 * Note that ext4_orphan_del() has to be able to cope with the
284
	 * deletion of a non-existent orphan - this is because we don't
285
	 * know if ext4_truncate() actually created an orphan record.
286 287
	 * (Well, we could do this if we need to, but heck - it works)
	 */
288 289
	ext4_orphan_del(handle, inode);
	EXT4_I(inode)->i_dtime	= get_seconds();
290 291 292 293 294 295 296 297

	/*
	 * One subtle ordering requirement: if anything has gone wrong
	 * (transaction abort, IO errors, whatever), then we can still
	 * do these next steps (the fs will already have been marked as
	 * having errors), but we can't free the inode if the mark_dirty
	 * fails.
	 */
298
	if (ext4_mark_inode_dirty(handle, inode))
299
		/* If that failed, just do the required in-core inode clear. */
A
Al Viro 已提交
300
		ext4_clear_inode(inode);
301
	else
302 303
		ext4_free_inode(handle, inode);
	ext4_journal_stop(handle);
304 305
	return;
no_delete:
A
Al Viro 已提交
306
	ext4_clear_inode(inode);	/* We must guarantee clearing of inode... */
307 308
}

309 310
#ifdef CONFIG_QUOTA
qsize_t *ext4_get_reserved_space(struct inode *inode)
311
{
312
	return &EXT4_I(inode)->i_reserved_quota;
313
}
314
#endif
315

316 317
/*
 * Calculate the number of metadata blocks need to reserve
318
 * to allocate a block located at @lblock
319
 */
320
static int ext4_calc_metadata_amount(struct inode *inode, ext4_lblk_t lblock)
321
{
322
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
323
		return ext4_ext_calc_metadata_amount(inode, lblock);
324

325
	return ext4_ind_calc_metadata_amount(inode, lblock);
326 327
}

328 329 330 331
/*
 * Called with i_data_sem down, which is important since we can call
 * ext4_discard_preallocations() from here.
 */
332 333
void ext4_da_update_reserve_space(struct inode *inode,
					int used, int quota_claim)
334 335
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
336 337 338
	struct ext4_inode_info *ei = EXT4_I(inode);

	spin_lock(&ei->i_block_reservation_lock);
339
	trace_ext4_da_update_reserve_space(inode, used, quota_claim);
340 341
	if (unlikely(used > ei->i_reserved_data_blocks)) {
		ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, used %d "
342
			 "with only %d reserved data blocks",
343 344 345 346 347
			 __func__, inode->i_ino, used,
			 ei->i_reserved_data_blocks);
		WARN_ON(1);
		used = ei->i_reserved_data_blocks;
	}
348

349 350 351
	/* Update per-inode reservations */
	ei->i_reserved_data_blocks -= used;
	ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks;
352
	percpu_counter_sub(&sbi->s_dirtyclusters_counter,
353
			   used + ei->i_allocated_meta_blocks);
354
	ei->i_allocated_meta_blocks = 0;
355

356 357 358 359 360 361
	if (ei->i_reserved_data_blocks == 0) {
		/*
		 * We can release all of the reserved metadata blocks
		 * only when we have written all of the delayed
		 * allocation blocks.
		 */
362
		percpu_counter_sub(&sbi->s_dirtyclusters_counter,
363
				   ei->i_reserved_meta_blocks);
364
		ei->i_reserved_meta_blocks = 0;
365
		ei->i_da_metadata_calc_len = 0;
366
	}
367
	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
368

369 370
	/* Update quota subsystem for data blocks */
	if (quota_claim)
371
		dquot_claim_block(inode, EXT4_C2B(sbi, used));
372
	else {
373 374 375
		/*
		 * We did fallocate with an offset that is already delayed
		 * allocated. So on delayed allocated writeback we should
376
		 * not re-claim the quota for fallocated blocks.
377
		 */
378
		dquot_release_reservation_block(inode, EXT4_C2B(sbi, used));
379
	}
380 381 382 383 384 385

	/*
	 * If we have done all the pending block allocations and if
	 * there aren't any writers on the inode, we can discard the
	 * inode's preallocations.
	 */
386 387
	if ((ei->i_reserved_data_blocks == 0) &&
	    (atomic_read(&inode->i_writecount) == 0))
388
		ext4_discard_preallocations(inode);
389 390
}

391
static int __check_block_validity(struct inode *inode, const char *func,
392 393
				unsigned int line,
				struct ext4_map_blocks *map)
394
{
395 396
	if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk,
				   map->m_len)) {
397 398 399 400
		ext4_error_inode(inode, func, line, map->m_pblk,
				 "lblock %lu mapped to illegal pblock "
				 "(length %d)", (unsigned long) map->m_lblk,
				 map->m_len);
401 402 403 404 405
		return -EIO;
	}
	return 0;
}

406
#define check_block_validity(inode, map)	\
407
	__check_block_validity((inode), __func__, __LINE__, (map))
408

409
/*
410 411
 * Return the number of contiguous dirty pages in a given inode
 * starting at page frame idx.
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
 */
static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx,
				    unsigned int max_pages)
{
	struct address_space *mapping = inode->i_mapping;
	pgoff_t	index;
	struct pagevec pvec;
	pgoff_t num = 0;
	int i, nr_pages, done = 0;

	if (max_pages == 0)
		return 0;
	pagevec_init(&pvec, 0);
	while (!done) {
		index = idx;
		nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
					      PAGECACHE_TAG_DIRTY,
					      (pgoff_t)PAGEVEC_SIZE);
		if (nr_pages == 0)
			break;
		for (i = 0; i < nr_pages; i++) {
			struct page *page = pvec.pages[i];
			struct buffer_head *bh, *head;

			lock_page(page);
			if (unlikely(page->mapping != mapping) ||
			    !PageDirty(page) ||
			    PageWriteback(page) ||
			    page->index != idx) {
				done = 1;
				unlock_page(page);
				break;
			}
445 446 447 448 449 450 451 452 453
			if (page_has_buffers(page)) {
				bh = head = page_buffers(page);
				do {
					if (!buffer_delay(bh) &&
					    !buffer_unwritten(bh))
						done = 1;
					bh = bh->b_this_page;
				} while (!done && (bh != head));
			}
454 455 456 457 458
			unlock_page(page);
			if (done)
				break;
			idx++;
			num++;
459 460
			if (num >= max_pages) {
				done = 1;
461
				break;
462
			}
463 464 465 466 467 468
		}
		pagevec_release(&pvec);
	}
	return num;
}

469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
/*
 * Sets the BH_Da_Mapped bit on the buffer heads corresponding to the given map.
 */
static void set_buffers_da_mapped(struct inode *inode,
				   struct ext4_map_blocks *map)
{
	struct address_space *mapping = inode->i_mapping;
	struct pagevec pvec;
	int i, nr_pages;
	pgoff_t index, end;

	index = map->m_lblk >> (PAGE_CACHE_SHIFT - inode->i_blkbits);
	end = (map->m_lblk + map->m_len - 1) >>
		(PAGE_CACHE_SHIFT - inode->i_blkbits);

	pagevec_init(&pvec, 0);
	while (index <= end) {
		nr_pages = pagevec_lookup(&pvec, mapping, index,
					  min(end - index + 1,
					      (pgoff_t)PAGEVEC_SIZE));
		if (nr_pages == 0)
			break;
		for (i = 0; i < nr_pages; i++) {
			struct page *page = pvec.pages[i];
			struct buffer_head *bh, *head;

			if (unlikely(page->mapping != mapping) ||
			    !PageDirty(page))
				break;

			if (page_has_buffers(page)) {
				bh = head = page_buffers(page);
				do {
					set_buffer_da_mapped(bh);
					bh = bh->b_this_page;
				} while (bh != head);
			}
			index++;
		}
		pagevec_release(&pvec);
	}
}

512
/*
513
 * The ext4_map_blocks() function tries to look up the requested blocks,
514
 * and returns if the blocks are already mapped.
515 516 517 518 519
 *
 * Otherwise it takes the write lock of the i_data_sem and allocate blocks
 * and store the allocated blocks in the result buffer head and mark it
 * mapped.
 *
520 521
 * If file type is extents based, it will call ext4_ext_map_blocks(),
 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
522 523 524 525 526 527 528 529
 * based files
 *
 * On success, it returns the number of blocks being mapped or allocate.
 * if create==0 and the blocks are pre-allocated and uninitialized block,
 * the result buffer head is unmapped. If the create ==1, it will make sure
 * the buffer head is mapped.
 *
 * It returns 0 if plain look up failed (blocks have not been allocated), in
530
 * that case, buffer head is unmapped
531 532 533
 *
 * It returns the error in case of allocation failure.
 */
534 535
int ext4_map_blocks(handle_t *handle, struct inode *inode,
		    struct ext4_map_blocks *map, int flags)
536 537
{
	int retval;
538

539 540 541 542
	map->m_flags = 0;
	ext_debug("ext4_map_blocks(): inode %lu, flag %d, max_blocks %u,"
		  "logical block %lu\n", inode->i_ino, flags, map->m_len,
		  (unsigned long) map->m_lblk);
543
	/*
544 545
	 * Try to see if we can get the block without requesting a new
	 * file system block.
546 547
	 */
	down_read((&EXT4_I(inode)->i_data_sem));
548
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
549 550
		retval = ext4_ext_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
551
	} else {
552 553
		retval = ext4_ind_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
554
	}
555
	up_read((&EXT4_I(inode)->i_data_sem));
556

557
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
558
		int ret = check_block_validity(inode, map);
559 560 561 562
		if (ret != 0)
			return ret;
	}

563
	/* If it is only a block(s) look up */
564
	if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)
565 566 567 568 569 570
		return retval;

	/*
	 * Returns if the blocks have already allocated
	 *
	 * Note that if blocks have been preallocated
571
	 * ext4_ext_get_block() returns the create = 0
572 573
	 * with buffer head unmapped.
	 */
574
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
575 576
		return retval;

577 578 579 580 581 582 583 584 585 586
	/*
	 * When we call get_blocks without the create flag, the
	 * BH_Unwritten flag could have gotten set if the blocks
	 * requested were part of a uninitialized extent.  We need to
	 * clear this flag now that we are committed to convert all or
	 * part of the uninitialized extent to be an initialized
	 * extent.  This is because we need to avoid the combination
	 * of BH_Unwritten and BH_Mapped flags being simultaneously
	 * set on the buffer_head.
	 */
587
	map->m_flags &= ~EXT4_MAP_UNWRITTEN;
588

589
	/*
590 591 592 593
	 * New blocks allocate and/or writing to uninitialized extent
	 * will possibly result in updating i_data, so we take
	 * the write lock of i_data_sem, and call get_blocks()
	 * with create == 1 flag.
594 595
	 */
	down_write((&EXT4_I(inode)->i_data_sem));
596 597 598 599 600 601 602

	/*
	 * if the caller is from delayed allocation writeout path
	 * we have already reserved fs blocks for allocation
	 * let the underlying get_block() function know to
	 * avoid double accounting
	 */
603
	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
604
		ext4_set_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);
605 606 607 608
	/*
	 * We need to check for EXT4 here because migrate
	 * could have changed the inode type in between
	 */
609
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
610
		retval = ext4_ext_map_blocks(handle, inode, map, flags);
611
	} else {
612
		retval = ext4_ind_map_blocks(handle, inode, map, flags);
613

614
		if (retval > 0 && map->m_flags & EXT4_MAP_NEW) {
615 616 617 618 619
			/*
			 * We allocated new blocks which will result in
			 * i_data's format changing.  Force the migrate
			 * to fail by clearing migrate flags
			 */
620
			ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
621
		}
622

623 624 625 626 627 628 629
		/*
		 * Update reserved blocks/metadata blocks after successful
		 * block allocation which had been deferred till now. We don't
		 * support fallocate for non extent files. So we can update
		 * reserve space here.
		 */
		if ((retval > 0) &&
630
			(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE))
631 632
			ext4_da_update_reserve_space(inode, retval, 1);
	}
633
	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
634
		ext4_clear_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);
635

636 637 638 639 640 641 642 643
		/* If we have successfully mapped the delayed allocated blocks,
		 * set the BH_Da_Mapped bit on them. Its important to do this
		 * under the protection of i_data_sem.
		 */
		if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
			set_buffers_da_mapped(inode, map);
	}

644
	up_write((&EXT4_I(inode)->i_data_sem));
645
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
646
		int ret = check_block_validity(inode, map);
647 648 649
		if (ret != 0)
			return ret;
	}
650 651 652
	return retval;
}

653 654 655
/* Maximum number of blocks we map for direct IO at once. */
#define DIO_MAX_BLOCKS 4096

656 657
static int _ext4_get_block(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int flags)
658
{
659
	handle_t *handle = ext4_journal_current_handle();
660
	struct ext4_map_blocks map;
J
Jan Kara 已提交
661
	int ret = 0, started = 0;
662
	int dio_credits;
663

664 665 666 667
	map.m_lblk = iblock;
	map.m_len = bh->b_size >> inode->i_blkbits;

	if (flags && !handle) {
J
Jan Kara 已提交
668
		/* Direct IO write... */
669 670 671
		if (map.m_len > DIO_MAX_BLOCKS)
			map.m_len = DIO_MAX_BLOCKS;
		dio_credits = ext4_chunk_trans_blocks(inode, map.m_len);
672
		handle = ext4_journal_start(inode, dio_credits);
J
Jan Kara 已提交
673
		if (IS_ERR(handle)) {
674
			ret = PTR_ERR(handle);
675
			return ret;
676
		}
J
Jan Kara 已提交
677
		started = 1;
678 679
	}

680
	ret = ext4_map_blocks(handle, inode, &map, flags);
J
Jan Kara 已提交
681
	if (ret > 0) {
682 683 684
		map_bh(bh, inode->i_sb, map.m_pblk);
		bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;
		bh->b_size = inode->i_sb->s_blocksize * map.m_len;
J
Jan Kara 已提交
685
		ret = 0;
686
	}
J
Jan Kara 已提交
687 688
	if (started)
		ext4_journal_stop(handle);
689 690 691
	return ret;
}

692 693 694 695 696 697 698
int ext4_get_block(struct inode *inode, sector_t iblock,
		   struct buffer_head *bh, int create)
{
	return _ext4_get_block(inode, iblock, bh,
			       create ? EXT4_GET_BLOCKS_CREATE : 0);
}

699 700 701
/*
 * `handle' can be NULL if create is zero
 */
702
struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
A
Aneesh Kumar K.V 已提交
703
				ext4_lblk_t block, int create, int *errp)
704
{
705 706
	struct ext4_map_blocks map;
	struct buffer_head *bh;
707 708 709 710
	int fatal = 0, err;

	J_ASSERT(handle != NULL || create == 0);

711 712 713 714
	map.m_lblk = block;
	map.m_len = 1;
	err = ext4_map_blocks(handle, inode, &map,
			      create ? EXT4_GET_BLOCKS_CREATE : 0);
715

716 717 718 719 720 721 722 723 724 725
	if (err < 0)
		*errp = err;
	if (err <= 0)
		return NULL;
	*errp = 0;

	bh = sb_getblk(inode->i_sb, map.m_pblk);
	if (!bh) {
		*errp = -EIO;
		return NULL;
726
	}
727 728 729
	if (map.m_flags & EXT4_MAP_NEW) {
		J_ASSERT(create != 0);
		J_ASSERT(handle != NULL);
730

731 732 733 734 735 736 737 738 739 740 741 742 743
		/*
		 * Now that we do not always journal data, we should
		 * keep in mind whether this should always journal the
		 * new buffer as metadata.  For now, regular file
		 * writes use ext4_get_block instead, so it's not a
		 * problem.
		 */
		lock_buffer(bh);
		BUFFER_TRACE(bh, "call get_create_access");
		fatal = ext4_journal_get_create_access(handle, bh);
		if (!fatal && !buffer_uptodate(bh)) {
			memset(bh->b_data, 0, inode->i_sb->s_blocksize);
			set_buffer_uptodate(bh);
744
		}
745 746 747 748 749 750 751
		unlock_buffer(bh);
		BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
		err = ext4_handle_dirty_metadata(handle, inode, bh);
		if (!fatal)
			fatal = err;
	} else {
		BUFFER_TRACE(bh, "not a new buffer");
752
	}
753 754 755 756 757 758
	if (fatal) {
		*errp = fatal;
		brelse(bh);
		bh = NULL;
	}
	return bh;
759 760
}

761
struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
A
Aneesh Kumar K.V 已提交
762
			       ext4_lblk_t block, int create, int *err)
763
{
764
	struct buffer_head *bh;
765

766
	bh = ext4_getblk(handle, inode, block, create, err);
767 768 769 770
	if (!bh)
		return bh;
	if (buffer_uptodate(bh))
		return bh;
771
	ll_rw_block(READ | REQ_META | REQ_PRIO, 1, &bh);
772 773 774 775 776 777 778 779
	wait_on_buffer(bh);
	if (buffer_uptodate(bh))
		return bh;
	put_bh(bh);
	*err = -EIO;
	return NULL;
}

780 781 782 783 784 785 786
static int walk_page_buffers(handle_t *handle,
			     struct buffer_head *head,
			     unsigned from,
			     unsigned to,
			     int *partial,
			     int (*fn)(handle_t *handle,
				       struct buffer_head *bh))
787 788 789 790 791 792 793
{
	struct buffer_head *bh;
	unsigned block_start, block_end;
	unsigned blocksize = head->b_size;
	int err, ret = 0;
	struct buffer_head *next;

794 795
	for (bh = head, block_start = 0;
	     ret == 0 && (bh != head || !block_start);
796
	     block_start = block_end, bh = next) {
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
		next = bh->b_this_page;
		block_end = block_start + blocksize;
		if (block_end <= from || block_start >= to) {
			if (partial && !buffer_uptodate(bh))
				*partial = 1;
			continue;
		}
		err = (*fn)(handle, bh);
		if (!ret)
			ret = err;
	}
	return ret;
}

/*
 * To preserve ordering, it is essential that the hole instantiation and
 * the data write be encapsulated in a single transaction.  We cannot
814
 * close off a transaction and start a new one between the ext4_get_block()
815
 * and the commit_write().  So doing the jbd2_journal_start at the start of
816 817
 * prepare_write() is the right place.
 *
818 819
 * Also, this function can nest inside ext4_writepage() ->
 * block_write_full_page(). In that case, we *know* that ext4_writepage()
820 821 822 823
 * has generated enough buffer credits to do the whole page.  So we won't
 * block on the journal in that case, which is good, because the caller may
 * be PF_MEMALLOC.
 *
824
 * By accident, ext4 can be reentered when a transaction is open via
825 826 827 828 829 830
 * quota file writes.  If we were to commit the transaction while thus
 * reentered, there can be a deadlock - we would be holding a quota
 * lock, and the commit would never complete if another thread had a
 * transaction open and was blocking on the quota lock - a ranking
 * violation.
 *
831
 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
832 833 834 835 836
 * will _not_ run commit under these circumstances because handle->h_ref
 * is elevated.  We'll still have enough credits for the tiny quotafile
 * write.
 */
static int do_journal_get_write_access(handle_t *handle,
837
				       struct buffer_head *bh)
838
{
839 840 841
	int dirty = buffer_dirty(bh);
	int ret;

842 843
	if (!buffer_mapped(bh) || buffer_freed(bh))
		return 0;
844
	/*
C
Christoph Hellwig 已提交
845
	 * __block_write_begin() could have dirtied some buffers. Clean
846 847
	 * the dirty bit as jbd2_journal_get_write_access() could complain
	 * otherwise about fs integrity issues. Setting of the dirty bit
C
Christoph Hellwig 已提交
848
	 * by __block_write_begin() isn't a real problem here as we clear
849 850 851 852 853 854 855 856 857
	 * the bit before releasing a page lock and thus writeback cannot
	 * ever write the buffer.
	 */
	if (dirty)
		clear_buffer_dirty(bh);
	ret = ext4_journal_get_write_access(handle, bh);
	if (!ret && dirty)
		ret = ext4_handle_dirty_metadata(handle, NULL, bh);
	return ret;
858 859
}

860 861
static int ext4_get_block_write(struct inode *inode, sector_t iblock,
		   struct buffer_head *bh_result, int create);
N
Nick Piggin 已提交
862
static int ext4_write_begin(struct file *file, struct address_space *mapping,
863 864
			    loff_t pos, unsigned len, unsigned flags,
			    struct page **pagep, void **fsdata)
865
{
866
	struct inode *inode = mapping->host;
867
	int ret, needed_blocks;
868 869
	handle_t *handle;
	int retries = 0;
870
	struct page *page;
871
	pgoff_t index;
872
	unsigned from, to;
N
Nick Piggin 已提交
873

874
	trace_ext4_write_begin(inode, pos, len, flags);
875 876 877 878 879
	/*
	 * Reserve one block more for addition to orphan list in case
	 * we allocate blocks but write fails for some reason
	 */
	needed_blocks = ext4_writepage_trans_blocks(inode) + 1;
880
	index = pos >> PAGE_CACHE_SHIFT;
881 882
	from = pos & (PAGE_CACHE_SIZE - 1);
	to = from + len;
883 884

retry:
885 886 887 888
	handle = ext4_journal_start(inode, needed_blocks);
	if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
		goto out;
889
	}
890

891 892 893 894
	/* We cannot recurse into the filesystem as the transaction is already
	 * started */
	flags |= AOP_FLAG_NOFS;

895
	page = grab_cache_page_write_begin(mapping, index, flags);
896 897 898 899 900 901 902
	if (!page) {
		ext4_journal_stop(handle);
		ret = -ENOMEM;
		goto out;
	}
	*pagep = page;

903
	if (ext4_should_dioread_nolock(inode))
904
		ret = __block_write_begin(page, pos, len, ext4_get_block_write);
905
	else
906
		ret = __block_write_begin(page, pos, len, ext4_get_block);
N
Nick Piggin 已提交
907 908

	if (!ret && ext4_should_journal_data(inode)) {
909 910 911
		ret = walk_page_buffers(handle, page_buffers(page),
				from, to, NULL, do_journal_get_write_access);
	}
N
Nick Piggin 已提交
912 913

	if (ret) {
914 915
		unlock_page(page);
		page_cache_release(page);
916
		/*
917
		 * __block_write_begin may have instantiated a few blocks
918 919
		 * outside i_size.  Trim these off again. Don't need
		 * i_size_read because we hold i_mutex.
920 921 922
		 *
		 * Add inode to orphan list in case we crash before
		 * truncate finishes
923
		 */
924
		if (pos + len > inode->i_size && ext4_can_truncate(inode))
925 926 927 928
			ext4_orphan_add(handle, inode);

		ext4_journal_stop(handle);
		if (pos + len > inode->i_size) {
929
			ext4_truncate_failed_write(inode);
930
			/*
931
			 * If truncate failed early the inode might
932 933 934 935 936 937 938
			 * still be on the orphan list; we need to
			 * make sure the inode is removed from the
			 * orphan list in that case.
			 */
			if (inode->i_nlink)
				ext4_orphan_del(NULL, inode);
		}
N
Nick Piggin 已提交
939 940
	}

941
	if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
942
		goto retry;
943
out:
944 945 946
	return ret;
}

N
Nick Piggin 已提交
947 948
/* For write_end() in data=journal mode */
static int write_end_fn(handle_t *handle, struct buffer_head *bh)
949 950 951 952
{
	if (!buffer_mapped(bh) || buffer_freed(bh))
		return 0;
	set_buffer_uptodate(bh);
953
	return ext4_handle_dirty_metadata(handle, NULL, bh);
954 955
}

956
static int ext4_generic_write_end(struct file *file,
957 958 959
				  struct address_space *mapping,
				  loff_t pos, unsigned len, unsigned copied,
				  struct page *page, void *fsdata)
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
{
	int i_size_changed = 0;
	struct inode *inode = mapping->host;
	handle_t *handle = ext4_journal_current_handle();

	copied = block_write_end(file, mapping, pos, len, copied, page, fsdata);

	/*
	 * No need to use i_size_read() here, the i_size
	 * cannot change under us because we hold i_mutex.
	 *
	 * But it's important to update i_size while still holding page lock:
	 * page writeout could otherwise come in and zero beyond i_size.
	 */
	if (pos + copied > inode->i_size) {
		i_size_write(inode, pos + copied);
		i_size_changed = 1;
	}

	if (pos + copied >  EXT4_I(inode)->i_disksize) {
		/* We need to mark inode dirty even if
		 * new_i_size is less that inode->i_size
		 * bu greater than i_disksize.(hint delalloc)
		 */
		ext4_update_i_disksize(inode, (pos + copied));
		i_size_changed = 1;
	}
	unlock_page(page);
	page_cache_release(page);

	/*
	 * Don't mark the inode dirty under page lock. First, it unnecessarily
	 * makes the holding time of page lock longer. Second, it forces lock
	 * ordering of page lock and transaction start for journaling
	 * filesystems.
	 */
	if (i_size_changed)
		ext4_mark_inode_dirty(handle, inode);

	return copied;
}

1002 1003 1004 1005
/*
 * We need to pick up the new inode size which generic_commit_write gave us
 * `file' can be NULL - eg, when called from page_symlink().
 *
1006
 * ext4 never places buffers on inode->i_mapping->private_list.  metadata
1007 1008
 * buffers are managed internally.
 */
N
Nick Piggin 已提交
1009
static int ext4_ordered_write_end(struct file *file,
1010 1011 1012
				  struct address_space *mapping,
				  loff_t pos, unsigned len, unsigned copied,
				  struct page *page, void *fsdata)
1013
{
1014
	handle_t *handle = ext4_journal_current_handle();
1015
	struct inode *inode = mapping->host;
1016 1017
	int ret = 0, ret2;

1018
	trace_ext4_ordered_write_end(inode, pos, len, copied);
1019
	ret = ext4_jbd2_file_inode(handle, inode);
1020 1021

	if (ret == 0) {
1022
		ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
N
Nick Piggin 已提交
1023
							page, fsdata);
1024
		copied = ret2;
1025
		if (pos + len > inode->i_size && ext4_can_truncate(inode))
1026 1027 1028 1029 1030
			/* if we have allocated more blocks and copied
			 * less. We will have blocks allocated outside
			 * inode->i_size. So truncate them
			 */
			ext4_orphan_add(handle, inode);
1031 1032
		if (ret2 < 0)
			ret = ret2;
1033 1034 1035
	} else {
		unlock_page(page);
		page_cache_release(page);
1036
	}
1037

1038
	ret2 = ext4_journal_stop(handle);
1039 1040
	if (!ret)
		ret = ret2;
N
Nick Piggin 已提交
1041

1042
	if (pos + len > inode->i_size) {
1043
		ext4_truncate_failed_write(inode);
1044
		/*
1045
		 * If truncate failed early the inode might still be
1046 1047 1048 1049 1050 1051 1052 1053
		 * on the orphan list; we need to make sure the inode
		 * is removed from the orphan list in that case.
		 */
		if (inode->i_nlink)
			ext4_orphan_del(NULL, inode);
	}


N
Nick Piggin 已提交
1054
	return ret ? ret : copied;
1055 1056
}

N
Nick Piggin 已提交
1057
static int ext4_writeback_write_end(struct file *file,
1058 1059 1060
				    struct address_space *mapping,
				    loff_t pos, unsigned len, unsigned copied,
				    struct page *page, void *fsdata)
1061
{
1062
	handle_t *handle = ext4_journal_current_handle();
1063
	struct inode *inode = mapping->host;
1064 1065
	int ret = 0, ret2;

1066
	trace_ext4_writeback_write_end(inode, pos, len, copied);
1067
	ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
N
Nick Piggin 已提交
1068
							page, fsdata);
1069
	copied = ret2;
1070
	if (pos + len > inode->i_size && ext4_can_truncate(inode))
1071 1072 1073 1074 1075 1076
		/* if we have allocated more blocks and copied
		 * less. We will have blocks allocated outside
		 * inode->i_size. So truncate them
		 */
		ext4_orphan_add(handle, inode);

1077 1078
	if (ret2 < 0)
		ret = ret2;
1079

1080
	ret2 = ext4_journal_stop(handle);
1081 1082
	if (!ret)
		ret = ret2;
N
Nick Piggin 已提交
1083

1084
	if (pos + len > inode->i_size) {
1085
		ext4_truncate_failed_write(inode);
1086
		/*
1087
		 * If truncate failed early the inode might still be
1088 1089 1090 1091 1092 1093 1094
		 * on the orphan list; we need to make sure the inode
		 * is removed from the orphan list in that case.
		 */
		if (inode->i_nlink)
			ext4_orphan_del(NULL, inode);
	}

N
Nick Piggin 已提交
1095
	return ret ? ret : copied;
1096 1097
}

N
Nick Piggin 已提交
1098
static int ext4_journalled_write_end(struct file *file,
1099 1100 1101
				     struct address_space *mapping,
				     loff_t pos, unsigned len, unsigned copied,
				     struct page *page, void *fsdata)
1102
{
1103
	handle_t *handle = ext4_journal_current_handle();
N
Nick Piggin 已提交
1104
	struct inode *inode = mapping->host;
1105 1106
	int ret = 0, ret2;
	int partial = 0;
N
Nick Piggin 已提交
1107
	unsigned from, to;
1108
	loff_t new_i_size;
1109

1110
	trace_ext4_journalled_write_end(inode, pos, len, copied);
N
Nick Piggin 已提交
1111 1112 1113
	from = pos & (PAGE_CACHE_SIZE - 1);
	to = from + len;

1114 1115
	BUG_ON(!ext4_handle_valid(handle));

N
Nick Piggin 已提交
1116 1117 1118 1119 1120
	if (copied < len) {
		if (!PageUptodate(page))
			copied = 0;
		page_zero_new_buffers(page, from+copied, to);
	}
1121 1122

	ret = walk_page_buffers(handle, page_buffers(page), from,
N
Nick Piggin 已提交
1123
				to, &partial, write_end_fn);
1124 1125
	if (!partial)
		SetPageUptodate(page);
1126 1127
	new_i_size = pos + copied;
	if (new_i_size > inode->i_size)
N
Nick Piggin 已提交
1128
		i_size_write(inode, pos+copied);
1129
	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
1130
	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1131 1132
	if (new_i_size > EXT4_I(inode)->i_disksize) {
		ext4_update_i_disksize(inode, new_i_size);
1133
		ret2 = ext4_mark_inode_dirty(handle, inode);
1134 1135 1136
		if (!ret)
			ret = ret2;
	}
N
Nick Piggin 已提交
1137

1138
	unlock_page(page);
1139
	page_cache_release(page);
1140
	if (pos + len > inode->i_size && ext4_can_truncate(inode))
1141 1142 1143 1144 1145 1146
		/* if we have allocated more blocks and copied
		 * less. We will have blocks allocated outside
		 * inode->i_size. So truncate them
		 */
		ext4_orphan_add(handle, inode);

1147
	ret2 = ext4_journal_stop(handle);
1148 1149
	if (!ret)
		ret = ret2;
1150
	if (pos + len > inode->i_size) {
1151
		ext4_truncate_failed_write(inode);
1152
		/*
1153
		 * If truncate failed early the inode might still be
1154 1155 1156 1157 1158 1159
		 * on the orphan list; we need to make sure the inode
		 * is removed from the orphan list in that case.
		 */
		if (inode->i_nlink)
			ext4_orphan_del(NULL, inode);
	}
N
Nick Piggin 已提交
1160 1161

	return ret ? ret : copied;
1162
}
1163

1164
/*
1165
 * Reserve a single cluster located at lblock
1166
 */
1167
static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock)
1168
{
A
Aneesh Kumar K.V 已提交
1169
	int retries = 0;
1170
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1171
	struct ext4_inode_info *ei = EXT4_I(inode);
1172
	unsigned int md_needed;
1173
	int ret;
1174 1175 1176 1177 1178 1179

	/*
	 * recalculate the amount of metadata blocks to reserve
	 * in order to allocate nrblocks
	 * worse case is one extent per block
	 */
A
Aneesh Kumar K.V 已提交
1180
repeat:
1181
	spin_lock(&ei->i_block_reservation_lock);
1182 1183
	md_needed = EXT4_NUM_B2C(sbi,
				 ext4_calc_metadata_amount(inode, lblock));
1184
	trace_ext4_da_reserve_space(inode, md_needed);
1185
	spin_unlock(&ei->i_block_reservation_lock);
1186

1187
	/*
1188 1189 1190
	 * We will charge metadata quota at writeout time; this saves
	 * us from metadata over-estimation, though we may go over by
	 * a small amount in the end.  Here we just reserve for data.
1191
	 */
1192
	ret = dquot_reserve_block(inode, EXT4_C2B(sbi, 1));
1193 1194
	if (ret)
		return ret;
1195 1196 1197 1198
	/*
	 * We do still charge estimated metadata to the sb though;
	 * we cannot afford to run out of free blocks.
	 */
1199
	if (ext4_claim_free_clusters(sbi, md_needed + 1, 0)) {
1200
		dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1));
A
Aneesh Kumar K.V 已提交
1201 1202 1203 1204
		if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
			yield();
			goto repeat;
		}
1205 1206
		return -ENOSPC;
	}
1207
	spin_lock(&ei->i_block_reservation_lock);
1208
	ei->i_reserved_data_blocks++;
1209 1210
	ei->i_reserved_meta_blocks += md_needed;
	spin_unlock(&ei->i_block_reservation_lock);
1211

1212 1213 1214
	return 0;       /* success */
}

1215
static void ext4_da_release_space(struct inode *inode, int to_free)
1216 1217
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1218
	struct ext4_inode_info *ei = EXT4_I(inode);
1219

1220 1221 1222
	if (!to_free)
		return;		/* Nothing to release, exit */

1223
	spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1224

L
Li Zefan 已提交
1225
	trace_ext4_da_release_space(inode, to_free);
1226
	if (unlikely(to_free > ei->i_reserved_data_blocks)) {
1227
		/*
1228 1229 1230 1231
		 * if there aren't enough reserved blocks, then the
		 * counter is messed up somewhere.  Since this
		 * function is called from invalidate page, it's
		 * harmless to return without any action.
1232
		 */
1233 1234
		ext4_msg(inode->i_sb, KERN_NOTICE, "ext4_da_release_space: "
			 "ino %lu, to_free %d with only %d reserved "
1235
			 "data blocks", inode->i_ino, to_free,
1236 1237 1238
			 ei->i_reserved_data_blocks);
		WARN_ON(1);
		to_free = ei->i_reserved_data_blocks;
1239
	}
1240
	ei->i_reserved_data_blocks -= to_free;
1241

1242 1243 1244 1245 1246
	if (ei->i_reserved_data_blocks == 0) {
		/*
		 * We can release all of the reserved metadata blocks
		 * only when we have written all of the delayed
		 * allocation blocks.
1247 1248
		 * Note that in case of bigalloc, i_reserved_meta_blocks,
		 * i_reserved_data_blocks, etc. refer to number of clusters.
1249
		 */
1250
		percpu_counter_sub(&sbi->s_dirtyclusters_counter,
1251
				   ei->i_reserved_meta_blocks);
1252
		ei->i_reserved_meta_blocks = 0;
1253
		ei->i_da_metadata_calc_len = 0;
1254
	}
1255

1256
	/* update fs dirty data blocks counter */
1257
	percpu_counter_sub(&sbi->s_dirtyclusters_counter, to_free);
1258 1259

	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
1260

1261
	dquot_release_reservation_block(inode, EXT4_C2B(sbi, to_free));
1262 1263 1264
}

static void ext4_da_page_release_reservation(struct page *page,
1265
					     unsigned long offset)
1266 1267 1268 1269
{
	int to_release = 0;
	struct buffer_head *head, *bh;
	unsigned int curr_off = 0;
1270 1271 1272
	struct inode *inode = page->mapping->host;
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	int num_clusters;
1273 1274 1275 1276 1277 1278 1279 1280 1281

	head = page_buffers(page);
	bh = head;
	do {
		unsigned int next_off = curr_off + bh->b_size;

		if ((offset <= curr_off) && (buffer_delay(bh))) {
			to_release++;
			clear_buffer_delay(bh);
1282
			clear_buffer_da_mapped(bh);
1283 1284 1285
		}
		curr_off = next_off;
	} while ((bh = bh->b_this_page) != head);
1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299

	/* If we have released all the blocks belonging to a cluster, then we
	 * need to release the reserved space for that cluster. */
	num_clusters = EXT4_NUM_B2C(sbi, to_release);
	while (num_clusters > 0) {
		ext4_fsblk_t lblk;
		lblk = (page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits)) +
			((num_clusters - 1) << sbi->s_cluster_bits);
		if (sbi->s_cluster_ratio == 1 ||
		    !ext4_find_delalloc_cluster(inode, lblk, 1))
			ext4_da_release_space(inode, 1);

		num_clusters--;
	}
1300
}
1301

1302 1303 1304 1305 1306 1307
/*
 * Delayed allocation stuff
 */

/*
 * mpage_da_submit_io - walks through extent of pages and try to write
1308
 * them with writepage() call back
1309 1310 1311 1312 1313 1314 1315 1316 1317 1318
 *
 * @mpd->inode: inode
 * @mpd->first_page: first page of the extent
 * @mpd->next_page: page after the last page of the extent
 *
 * By the time mpage_da_submit_io() is called we expect all blocks
 * to be allocated. this may be wrong if allocation failed.
 *
 * As pages are already locked by write_cache_pages(), we can't use it
 */
1319 1320
static int mpage_da_submit_io(struct mpage_da_data *mpd,
			      struct ext4_map_blocks *map)
1321
{
1322 1323 1324 1325 1326
	struct pagevec pvec;
	unsigned long index, end;
	int ret = 0, err, nr_pages, i;
	struct inode *inode = mpd->inode;
	struct address_space *mapping = inode->i_mapping;
1327
	loff_t size = i_size_read(inode);
1328 1329
	unsigned int len, block_start;
	struct buffer_head *bh, *page_bufs = NULL;
1330
	int journal_data = ext4_should_journal_data(inode);
1331
	sector_t pblock = 0, cur_logical = 0;
1332
	struct ext4_io_submit io_submit;
1333 1334

	BUG_ON(mpd->next_page <= mpd->first_page);
1335
	memset(&io_submit, 0, sizeof(io_submit));
1336 1337 1338
	/*
	 * We need to start from the first_page to the next_page - 1
	 * to make sure we also write the mapped dirty buffer_heads.
1339
	 * If we look at mpd->b_blocknr we would only be looking
1340 1341
	 * at the currently mapped buffer_heads.
	 */
1342 1343 1344
	index = mpd->first_page;
	end = mpd->next_page - 1;

1345
	pagevec_init(&pvec, 0);
1346
	while (index <= end) {
1347
		nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
1348 1349 1350
		if (nr_pages == 0)
			break;
		for (i = 0; i < nr_pages; i++) {
1351
			int commit_write = 0, skip_page = 0;
1352 1353
			struct page *page = pvec.pages[i];

1354 1355 1356
			index = page->index;
			if (index > end)
				break;
1357 1358 1359 1360 1361

			if (index == size >> PAGE_CACHE_SHIFT)
				len = size & ~PAGE_CACHE_MASK;
			else
				len = PAGE_CACHE_SIZE;
1362 1363 1364 1365 1366 1367
			if (map) {
				cur_logical = index << (PAGE_CACHE_SHIFT -
							inode->i_blkbits);
				pblock = map->m_pblk + (cur_logical -
							map->m_lblk);
			}
1368 1369 1370 1371 1372
			index++;

			BUG_ON(!PageLocked(page));
			BUG_ON(PageWriteback(page));

1373
			/*
1374 1375
			 * If the page does not have buffers (for
			 * whatever reason), try to create them using
1376
			 * __block_write_begin.  If this fails,
1377
			 * skip the page and move on.
1378
			 */
1379
			if (!page_has_buffers(page)) {
1380
				if (__block_write_begin(page, 0, len,
1381
						noalloc_get_block_write)) {
1382
				skip_page:
1383 1384 1385 1386 1387
					unlock_page(page);
					continue;
				}
				commit_write = 1;
			}
1388

1389 1390
			bh = page_bufs = page_buffers(page);
			block_start = 0;
1391
			do {
1392
				if (!bh)
1393
					goto skip_page;
1394 1395 1396
				if (map && (cur_logical >= map->m_lblk) &&
				    (cur_logical <= (map->m_lblk +
						     (map->m_len - 1)))) {
1397 1398 1399 1400
					if (buffer_delay(bh)) {
						clear_buffer_delay(bh);
						bh->b_blocknr = pblock;
					}
1401 1402
					if (buffer_da_mapped(bh))
						clear_buffer_da_mapped(bh);
1403 1404 1405 1406 1407 1408 1409
					if (buffer_unwritten(bh) ||
					    buffer_mapped(bh))
						BUG_ON(bh->b_blocknr != pblock);
					if (map->m_flags & EXT4_MAP_UNINIT)
						set_buffer_uninit(bh);
					clear_buffer_unwritten(bh);
				}
1410

1411 1412 1413 1414 1415
				/*
				 * skip page if block allocation undone and
				 * block is dirty
				 */
				if (ext4_bh_delay_or_unwritten(NULL, bh))
1416
					skip_page = 1;
1417 1418
				bh = bh->b_this_page;
				block_start += bh->b_size;
1419 1420
				cur_logical++;
				pblock++;
1421 1422
			} while (bh != page_bufs);

1423 1424
			if (skip_page)
				goto skip_page;
1425 1426 1427 1428 1429

			if (commit_write)
				/* mark the buffer_heads as dirty & uptodate */
				block_commit_write(page, 0, len);

1430
			clear_page_dirty_for_io(page);
1431 1432 1433 1434 1435 1436
			/*
			 * Delalloc doesn't support data journalling,
			 * but eventually maybe we'll lift this
			 * restriction.
			 */
			if (unlikely(journal_data && PageChecked(page)))
1437
				err = __ext4_journalled_writepage(page, len);
1438
			else if (test_opt(inode->i_sb, MBLK_IO_SUBMIT))
1439 1440
				err = ext4_bio_write_page(&io_submit, page,
							  len, mpd->wbc);
1441 1442 1443 1444 1445 1446
			else if (buffer_uninit(page_bufs)) {
				ext4_set_bh_endio(page_bufs, inode);
				err = block_write_full_page_endio(page,
					noalloc_get_block_write,
					mpd->wbc, ext4_end_io_buffer_write);
			} else
1447 1448
				err = block_write_full_page(page,
					noalloc_get_block_write, mpd->wbc);
1449 1450

			if (!err)
1451
				mpd->pages_written++;
1452 1453 1454 1455 1456 1457 1458 1459 1460
			/*
			 * In error case, we have to continue because
			 * remaining pages are still locked
			 */
			if (ret == 0)
				ret = err;
		}
		pagevec_release(&pvec);
	}
1461
	ext4_io_submit(&io_submit);
1462 1463 1464
	return ret;
}

1465
static void ext4_da_block_invalidatepages(struct mpage_da_data *mpd)
1466 1467 1468 1469 1470 1471 1472
{
	int nr_pages, i;
	pgoff_t index, end;
	struct pagevec pvec;
	struct inode *inode = mpd->inode;
	struct address_space *mapping = inode->i_mapping;

1473 1474
	index = mpd->first_page;
	end   = mpd->next_page - 1;
1475 1476 1477 1478 1479 1480
	while (index <= end) {
		nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
		if (nr_pages == 0)
			break;
		for (i = 0; i < nr_pages; i++) {
			struct page *page = pvec.pages[i];
1481
			if (page->index > end)
1482 1483 1484 1485 1486 1487 1488
				break;
			BUG_ON(!PageLocked(page));
			BUG_ON(PageWriteback(page));
			block_invalidatepage(page, 0);
			ClearPageUptodate(page);
			unlock_page(page);
		}
1489 1490
		index = pvec.pages[nr_pages - 1]->index + 1;
		pagevec_release(&pvec);
1491 1492 1493 1494
	}
	return;
}

1495 1496 1497
static void ext4_print_free_blocks(struct inode *inode)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1498 1499 1500
	struct super_block *sb = inode->i_sb;

	ext4_msg(sb, KERN_CRIT, "Total free blocks count %lld",
1501 1502
	       EXT4_C2B(EXT4_SB(inode->i_sb),
			ext4_count_free_clusters(inode->i_sb)));
1503 1504
	ext4_msg(sb, KERN_CRIT, "Free/Dirty block details");
	ext4_msg(sb, KERN_CRIT, "free_blocks=%lld",
1505 1506
	       (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
		percpu_counter_sum(&sbi->s_freeclusters_counter)));
1507
	ext4_msg(sb, KERN_CRIT, "dirty_blocks=%lld",
1508 1509
	       (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
		percpu_counter_sum(&sbi->s_dirtyclusters_counter)));
1510 1511 1512 1513
	ext4_msg(sb, KERN_CRIT, "Block reservation details");
	ext4_msg(sb, KERN_CRIT, "i_reserved_data_blocks=%u",
		 EXT4_I(inode)->i_reserved_data_blocks);
	ext4_msg(sb, KERN_CRIT, "i_reserved_meta_blocks=%u",
1514
	       EXT4_I(inode)->i_reserved_meta_blocks);
1515 1516 1517
	return;
}

1518
/*
1519 1520
 * mpage_da_map_and_submit - go through given space, map them
 *       if necessary, and then submit them for I/O
1521
 *
1522
 * @mpd - bh describing space
1523 1524 1525 1526
 *
 * The function skips space we know is already mapped to disk blocks.
 *
 */
1527
static void mpage_da_map_and_submit(struct mpage_da_data *mpd)
1528
{
1529
	int err, blks, get_blocks_flags;
1530
	struct ext4_map_blocks map, *mapp = NULL;
1531 1532 1533 1534
	sector_t next = mpd->b_blocknr;
	unsigned max_blocks = mpd->b_size >> mpd->inode->i_blkbits;
	loff_t disksize = EXT4_I(mpd->inode)->i_disksize;
	handle_t *handle = NULL;
1535 1536

	/*
1537 1538
	 * If the blocks are mapped already, or we couldn't accumulate
	 * any blocks, then proceed immediately to the submission stage.
1539
	 */
1540 1541 1542 1543 1544
	if ((mpd->b_size == 0) ||
	    ((mpd->b_state  & (1 << BH_Mapped)) &&
	     !(mpd->b_state & (1 << BH_Delay)) &&
	     !(mpd->b_state & (1 << BH_Unwritten))))
		goto submit_io;
1545 1546 1547 1548

	handle = ext4_journal_current_handle();
	BUG_ON(!handle);

1549
	/*
1550
	 * Call ext4_map_blocks() to allocate any delayed allocation
1551 1552 1553 1554 1555 1556 1557 1558
	 * blocks, or to convert an uninitialized extent to be
	 * initialized (in the case where we have written into
	 * one or more preallocated blocks).
	 *
	 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE to
	 * indicate that we are on the delayed allocation path.  This
	 * affects functions in many different parts of the allocation
	 * call path.  This flag exists primarily because we don't
1559
	 * want to change *many* call functions, so ext4_map_blocks()
1560
	 * will set the EXT4_STATE_DELALLOC_RESERVED flag once the
1561 1562 1563 1564 1565
	 * inode's allocation semaphore is taken.
	 *
	 * If the blocks in questions were delalloc blocks, set
	 * EXT4_GET_BLOCKS_DELALLOC_RESERVE so the delalloc accounting
	 * variables are updated after the blocks have been allocated.
1566
	 */
1567 1568
	map.m_lblk = next;
	map.m_len = max_blocks;
1569
	get_blocks_flags = EXT4_GET_BLOCKS_CREATE;
1570 1571
	if (ext4_should_dioread_nolock(mpd->inode))
		get_blocks_flags |= EXT4_GET_BLOCKS_IO_CREATE_EXT;
1572
	if (mpd->b_state & (1 << BH_Delay))
1573 1574
		get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE;

1575
	blks = ext4_map_blocks(handle, mpd->inode, &map, get_blocks_flags);
1576
	if (blks < 0) {
1577 1578
		struct super_block *sb = mpd->inode->i_sb;

1579
		err = blks;
1580
		/*
1581
		 * If get block returns EAGAIN or ENOSPC and there
1582 1583
		 * appears to be free blocks we will just let
		 * mpage_da_submit_io() unlock all of the pages.
1584 1585
		 */
		if (err == -EAGAIN)
1586
			goto submit_io;
1587

1588
		if (err == -ENOSPC && ext4_count_free_clusters(sb)) {
1589
			mpd->retval = err;
1590
			goto submit_io;
1591 1592
		}

1593
		/*
1594 1595 1596 1597 1598
		 * get block failure will cause us to loop in
		 * writepages, because a_ops->writepage won't be able
		 * to make progress. The page will be redirtied by
		 * writepage and writepages will again try to write
		 * the same.
1599
		 */
1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610
		if (!(EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED)) {
			ext4_msg(sb, KERN_CRIT,
				 "delayed block allocation failed for inode %lu "
				 "at logical offset %llu with max blocks %zd "
				 "with error %d", mpd->inode->i_ino,
				 (unsigned long long) next,
				 mpd->b_size >> mpd->inode->i_blkbits, err);
			ext4_msg(sb, KERN_CRIT,
				"This should not happen!! Data will be lost\n");
			if (err == -ENOSPC)
				ext4_print_free_blocks(mpd->inode);
A
Aneesh Kumar K.V 已提交
1611
		}
1612
		/* invalidate all the pages */
1613
		ext4_da_block_invalidatepages(mpd);
1614 1615 1616

		/* Mark this page range as having been completed */
		mpd->io_done = 1;
1617
		return;
1618
	}
1619 1620
	BUG_ON(blks == 0);

1621
	mapp = &map;
1622 1623 1624
	if (map.m_flags & EXT4_MAP_NEW) {
		struct block_device *bdev = mpd->inode->i_sb->s_bdev;
		int i;
1625

1626 1627
		for (i = 0; i < map.m_len; i++)
			unmap_underlying_metadata(bdev, map.m_pblk + i);
1628

1629 1630
		if (ext4_should_order_data(mpd->inode)) {
			err = ext4_jbd2_file_inode(handle, mpd->inode);
1631
			if (err) {
1632
				/* Only if the journal is aborted */
1633 1634 1635
				mpd->retval = err;
				goto submit_io;
			}
1636
		}
1637 1638 1639
	}

	/*
1640
	 * Update on-disk size along with block allocation.
1641 1642 1643 1644 1645 1646
	 */
	disksize = ((loff_t) next + blks) << mpd->inode->i_blkbits;
	if (disksize > i_size_read(mpd->inode))
		disksize = i_size_read(mpd->inode);
	if (disksize > EXT4_I(mpd->inode)->i_disksize) {
		ext4_update_i_disksize(mpd->inode, disksize);
1647 1648 1649 1650 1651
		err = ext4_mark_inode_dirty(handle, mpd->inode);
		if (err)
			ext4_error(mpd->inode->i_sb,
				   "Failed to mark inode %lu dirty",
				   mpd->inode->i_ino);
1652 1653
	}

1654
submit_io:
1655
	mpage_da_submit_io(mpd, mapp);
1656
	mpd->io_done = 1;
1657 1658
}

1659 1660
#define BH_FLAGS ((1 << BH_Uptodate) | (1 << BH_Mapped) | \
		(1 << BH_Delay) | (1 << BH_Unwritten))
1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671

/*
 * mpage_add_bh_to_extent - try to add one more block to extent of blocks
 *
 * @mpd->lbh - extent of blocks
 * @logical - logical number of the block in the file
 * @bh - bh of the block (used to access block's state)
 *
 * the function is used to collect contig. blocks in same state
 */
static void mpage_add_bh_to_extent(struct mpage_da_data *mpd,
1672 1673
				   sector_t logical, size_t b_size,
				   unsigned long b_state)
1674 1675
{
	sector_t next;
1676
	int nrblocks = mpd->b_size >> mpd->inode->i_blkbits;
1677

1678 1679 1680 1681
	/*
	 * XXX Don't go larger than mballoc is willing to allocate
	 * This is a stopgap solution.  We eventually need to fold
	 * mpage_da_submit_io() into this function and then call
1682
	 * ext4_map_blocks() multiple times in a loop
1683 1684 1685 1686
	 */
	if (nrblocks >= 8*1024*1024/mpd->inode->i_sb->s_blocksize)
		goto flush_it;

1687
	/* check if thereserved journal credits might overflow */
1688
	if (!(ext4_test_inode_flag(mpd->inode, EXT4_INODE_EXTENTS))) {
1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708
		if (nrblocks >= EXT4_MAX_TRANS_DATA) {
			/*
			 * With non-extent format we are limited by the journal
			 * credit available.  Total credit needed to insert
			 * nrblocks contiguous blocks is dependent on the
			 * nrblocks.  So limit nrblocks.
			 */
			goto flush_it;
		} else if ((nrblocks + (b_size >> mpd->inode->i_blkbits)) >
				EXT4_MAX_TRANS_DATA) {
			/*
			 * Adding the new buffer_head would make it cross the
			 * allowed limit for which we have journal credit
			 * reserved. So limit the new bh->b_size
			 */
			b_size = (EXT4_MAX_TRANS_DATA - nrblocks) <<
						mpd->inode->i_blkbits;
			/* we will do mpage_da_submit_io in the next loop */
		}
	}
1709 1710 1711
	/*
	 * First block in the extent
	 */
1712 1713 1714 1715
	if (mpd->b_size == 0) {
		mpd->b_blocknr = logical;
		mpd->b_size = b_size;
		mpd->b_state = b_state & BH_FLAGS;
1716 1717 1718
		return;
	}

1719
	next = mpd->b_blocknr + nrblocks;
1720 1721 1722
	/*
	 * Can we merge the block to our big extent?
	 */
1723 1724
	if (logical == next && (b_state & BH_FLAGS) == mpd->b_state) {
		mpd->b_size += b_size;
1725 1726 1727
		return;
	}

1728
flush_it:
1729 1730 1731 1732
	/*
	 * We couldn't merge the block to our extent, so we
	 * need to flush current  extent and start new one
	 */
1733
	mpage_da_map_and_submit(mpd);
1734
	return;
1735 1736
}

1737
static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
1738
{
1739
	return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh);
1740 1741
}

1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
/*
 * This function is grabs code from the very beginning of
 * ext4_map_blocks, but assumes that the caller is from delayed write
 * time. This function looks up the requested blocks and sets the
 * buffer delay bit under the protection of i_data_sem.
 */
static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
			      struct ext4_map_blocks *map,
			      struct buffer_head *bh)
{
	int retval;
	sector_t invalid_block = ~((sector_t) 0xffff);

	if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
		invalid_block = ~0;

	map->m_flags = 0;
	ext_debug("ext4_da_map_blocks(): inode %lu, max_blocks %u,"
		  "logical block %lu\n", inode->i_ino, map->m_len,
		  (unsigned long) map->m_lblk);
	/*
	 * Try to see if we can get the block without requesting a new
	 * file system block.
	 */
	down_read((&EXT4_I(inode)->i_data_sem));
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
		retval = ext4_ext_map_blocks(NULL, inode, map, 0);
	else
		retval = ext4_ind_map_blocks(NULL, inode, map, 0);

	if (retval == 0) {
		/*
		 * XXX: __block_prepare_write() unmaps passed block,
		 * is it OK?
		 */
		/* If the block was allocated from previously allocated cluster,
		 * then we dont need to reserve it again. */
		if (!(map->m_flags & EXT4_MAP_FROM_CLUSTER)) {
			retval = ext4_da_reserve_space(inode, iblock);
			if (retval)
				/* not enough space to reserve */
				goto out_unlock;
		}

		/* Clear EXT4_MAP_FROM_CLUSTER flag since its purpose is served
		 * and it should not appear on the bh->b_state.
		 */
		map->m_flags &= ~EXT4_MAP_FROM_CLUSTER;

		map_bh(bh, inode->i_sb, invalid_block);
		set_buffer_new(bh);
		set_buffer_delay(bh);
	}

out_unlock:
	up_read((&EXT4_I(inode)->i_data_sem));

	return retval;
}

1802
/*
1803 1804 1805
 * This is a special get_blocks_t callback which is used by
 * ext4_da_write_begin().  It will either return mapped block or
 * reserve space for a single block.
1806 1807 1808 1809 1810 1811 1812
 *
 * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
 * We also have b_blocknr = -1 and b_bdev initialized properly
 *
 * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
 * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
 * initialized properly.
1813 1814
 */
static int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
1815
				  struct buffer_head *bh, int create)
1816
{
1817
	struct ext4_map_blocks map;
1818 1819 1820
	int ret = 0;

	BUG_ON(create == 0);
1821 1822 1823 1824
	BUG_ON(bh->b_size != inode->i_sb->s_blocksize);

	map.m_lblk = iblock;
	map.m_len = 1;
1825 1826 1827 1828 1829 1830

	/*
	 * first, we need to know whether the block is allocated already
	 * preallocated blocks are unmapped but should treated
	 * the same as allocated blocks.
	 */
1831 1832
	ret = ext4_da_map_blocks(inode, iblock, &map, bh);
	if (ret <= 0)
1833
		return ret;
1834

1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
	map_bh(bh, inode->i_sb, map.m_pblk);
	bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;

	if (buffer_unwritten(bh)) {
		/* A delayed write to unwritten bh should be marked
		 * new and mapped.  Mapped ensures that we don't do
		 * get_block multiple times when we write to the same
		 * offset and new ensures that we do proper zero out
		 * for partial write.
		 */
		set_buffer_new(bh);
1846
		set_buffer_mapped(bh);
1847 1848
	}
	return 0;
1849
}
1850

1851 1852 1853
/*
 * This function is used as a standard get_block_t calback function
 * when there is no desire to allocate any blocks.  It is used as a
C
Christoph Hellwig 已提交
1854
 * callback function for block_write_begin() and block_write_full_page().
1855
 * These functions should only try to map a single block at a time.
1856 1857 1858 1859 1860
 *
 * Since this function doesn't do block allocations even if the caller
 * requests it by passing in create=1, it is critically important that
 * any caller checks to make sure that any buffer heads are returned
 * by this function are either all already mapped or marked for
1861 1862 1863
 * delayed allocation before calling  block_write_full_page().  Otherwise,
 * b_blocknr could be left unitialized, and the page write functions will
 * be taken by surprise.
1864 1865
 */
static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
1866 1867
				   struct buffer_head *bh_result, int create)
{
1868
	BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
1869
	return _ext4_get_block(inode, iblock, bh_result, 0);
1870 1871
}

1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893
static int bget_one(handle_t *handle, struct buffer_head *bh)
{
	get_bh(bh);
	return 0;
}

static int bput_one(handle_t *handle, struct buffer_head *bh)
{
	put_bh(bh);
	return 0;
}

static int __ext4_journalled_writepage(struct page *page,
				       unsigned int len)
{
	struct address_space *mapping = page->mapping;
	struct inode *inode = mapping->host;
	struct buffer_head *page_bufs;
	handle_t *handle = NULL;
	int ret = 0;
	int err;

1894
	ClearPageChecked(page);
1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907
	page_bufs = page_buffers(page);
	BUG_ON(!page_bufs);
	walk_page_buffers(handle, page_bufs, 0, len, NULL, bget_one);
	/* As soon as we unlock the page, it can go away, but we have
	 * references to buffers so we are safe */
	unlock_page(page);

	handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
	if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
		goto out;
	}

1908 1909
	BUG_ON(!ext4_handle_valid(handle));

1910 1911 1912 1913 1914 1915 1916
	ret = walk_page_buffers(handle, page_bufs, 0, len, NULL,
				do_journal_get_write_access);

	err = walk_page_buffers(handle, page_bufs, 0, len, NULL,
				write_end_fn);
	if (ret == 0)
		ret = err;
1917
	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1918 1919 1920 1921 1922
	err = ext4_journal_stop(handle);
	if (!ret)
		ret = err;

	walk_page_buffers(handle, page_bufs, 0, len, NULL, bput_one);
1923
	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
1924 1925 1926 1927
out:
	return ret;
}

1928 1929 1930
static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode);
static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate);

1931
/*
1932 1933 1934 1935
 * Note that we don't need to start a transaction unless we're journaling data
 * because we should have holes filled from ext4_page_mkwrite(). We even don't
 * need to file the inode to the transaction's list in ordered mode because if
 * we are writing back data added by write(), the inode is already there and if
L
Lucas De Marchi 已提交
1936
 * we are writing back data modified via mmap(), no one guarantees in which
1937 1938 1939 1940
 * transaction the data will hit the disk. In case we are journaling data, we
 * cannot start transaction directly because transaction start ranks above page
 * lock so we have to do some magic.
 *
1941 1942 1943 1944 1945
 * This function can get called via...
 *   - ext4_da_writepages after taking page lock (have journal handle)
 *   - journal_submit_inode_data_buffers (no journal handle)
 *   - shrink_page_list via pdflush (no journal handle)
 *   - grab_page_cache when doing write_begin (have journal handle)
1946 1947 1948 1949 1950 1951 1952 1953 1954
 *
 * We don't do any block allocation in this function. If we have page with
 * multiple blocks we need to write those buffer_heads that are mapped. This
 * is important for mmaped based write. So if we do with blocksize 1K
 * truncate(f, 1024);
 * a = mmap(f, 0, 4096);
 * a[0] = 'a';
 * truncate(f, 4096);
 * we have in the page first buffer_head mapped via page_mkwrite call back
1955
 * but other buffer_heads would be unmapped but dirty (dirty done via the
1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970
 * do_wp_page). So writepage should write the first block. If we modify
 * the mmap area beyond 1024 we will again get a page_fault and the
 * page_mkwrite callback will do the block allocation and mark the
 * buffer_heads mapped.
 *
 * We redirty the page if we have any buffer_heads that is either delay or
 * unwritten in the page.
 *
 * We can get recursively called as show below.
 *
 *	ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
 *		ext4_writepage()
 *
 * But since we don't do any block allocation we should not deadlock.
 * Page also have the dirty flag cleared so we don't get recurive page_lock.
1971
 */
1972
static int ext4_writepage(struct page *page,
1973
			  struct writeback_control *wbc)
1974
{
T
Theodore Ts'o 已提交
1975
	int ret = 0, commit_write = 0;
1976
	loff_t size;
1977
	unsigned int len;
1978
	struct buffer_head *page_bufs = NULL;
1979 1980
	struct inode *inode = page->mapping->host;

L
Lukas Czerner 已提交
1981
	trace_ext4_writepage(page);
1982 1983 1984 1985 1986
	size = i_size_read(inode);
	if (page->index == size >> PAGE_CACHE_SHIFT)
		len = size & ~PAGE_CACHE_MASK;
	else
		len = PAGE_CACHE_SIZE;
1987

T
Theodore Ts'o 已提交
1988 1989
	/*
	 * If the page does not have buffers (for whatever reason),
1990
	 * try to create them using __block_write_begin.  If this
T
Theodore Ts'o 已提交
1991 1992
	 * fails, redirty the page and move on.
	 */
1993
	if (!page_has_buffers(page)) {
1994
		if (__block_write_begin(page, 0, len,
T
Theodore Ts'o 已提交
1995 1996
					noalloc_get_block_write)) {
		redirty_page:
1997 1998 1999 2000
			redirty_page_for_writepage(wbc, page);
			unlock_page(page);
			return 0;
		}
T
Theodore Ts'o 已提交
2001 2002 2003 2004 2005
		commit_write = 1;
	}
	page_bufs = page_buffers(page);
	if (walk_page_buffers(NULL, page_bufs, 0, len, NULL,
			      ext4_bh_delay_or_unwritten)) {
2006
		/*
2007 2008 2009
		 * We don't want to do block allocation, so redirty
		 * the page and return.  We may reach here when we do
		 * a journal commit via journal_submit_inode_data_buffers.
2010 2011 2012
		 * We can also reach here via shrink_page_list but it
		 * should never be for direct reclaim so warn if that
		 * happens
2013
		 */
2014 2015
		WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) ==
								PF_MEMALLOC);
T
Theodore Ts'o 已提交
2016 2017 2018
		goto redirty_page;
	}
	if (commit_write)
2019
		/* now mark the buffer_heads as dirty and uptodate */
2020
		block_commit_write(page, 0, len);
2021

2022
	if (PageChecked(page) && ext4_should_journal_data(inode))
2023 2024 2025 2026
		/*
		 * It's mmapped pagecache.  Add buffers and journal it.  There
		 * doesn't seem much point in redirtying the page here.
		 */
2027
		return __ext4_journalled_writepage(page, len);
2028

T
Theodore Ts'o 已提交
2029
	if (buffer_uninit(page_bufs)) {
2030 2031 2032 2033
		ext4_set_bh_endio(page_bufs, inode);
		ret = block_write_full_page_endio(page, noalloc_get_block_write,
					    wbc, ext4_end_io_buffer_write);
	} else
2034 2035
		ret = block_write_full_page(page, noalloc_get_block_write,
					    wbc);
2036 2037 2038 2039

	return ret;
}

2040
/*
2041
 * This is called via ext4_da_writepages() to
L
Lucas De Marchi 已提交
2042
 * calculate the total number of credits to reserve to fit
2043 2044 2045
 * a single extent allocation into a single transaction,
 * ext4_da_writpeages() will loop calling this before
 * the block allocation.
2046
 */
2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057

static int ext4_da_writepages_trans_blocks(struct inode *inode)
{
	int max_blocks = EXT4_I(inode)->i_reserved_data_blocks;

	/*
	 * With non-extent format the journal credit needed to
	 * insert nrblocks contiguous block is dependent on
	 * number of contiguous block. So we will limit
	 * number of contiguous block to a sane value
	 */
2058
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) &&
2059 2060 2061 2062 2063
	    (max_blocks > EXT4_MAX_TRANS_DATA))
		max_blocks = EXT4_MAX_TRANS_DATA;

	return ext4_chunk_trans_blocks(inode, max_blocks);
}
2064

2065 2066
/*
 * write_cache_pages_da - walk the list of dirty pages of the given
2067
 * address space and accumulate pages that need writing, and call
2068 2069
 * mpage_da_map_and_submit to map a single contiguous memory region
 * and then write them.
2070 2071 2072
 */
static int write_cache_pages_da(struct address_space *mapping,
				struct writeback_control *wbc,
2073 2074
				struct mpage_da_data *mpd,
				pgoff_t *done_index)
2075
{
2076
	struct buffer_head	*bh, *head;
2077
	struct inode		*inode = mapping->host;
2078 2079 2080 2081 2082 2083
	struct pagevec		pvec;
	unsigned int		nr_pages;
	sector_t		logical;
	pgoff_t			index, end;
	long			nr_to_write = wbc->nr_to_write;
	int			i, tag, ret = 0;
2084

2085 2086 2087
	memset(mpd, 0, sizeof(struct mpage_da_data));
	mpd->wbc = wbc;
	mpd->inode = inode;
2088 2089 2090 2091
	pagevec_init(&pvec, 0);
	index = wbc->range_start >> PAGE_CACHE_SHIFT;
	end = wbc->range_end >> PAGE_CACHE_SHIFT;

2092
	if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
2093 2094 2095 2096
		tag = PAGECACHE_TAG_TOWRITE;
	else
		tag = PAGECACHE_TAG_DIRTY;

2097
	*done_index = index;
2098
	while (index <= end) {
2099
		nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
2100 2101
			      min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
		if (nr_pages == 0)
2102
			return 0;
2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113

		for (i = 0; i < nr_pages; i++) {
			struct page *page = pvec.pages[i];

			/*
			 * At this point, the page may be truncated or
			 * invalidated (changing page->mapping to NULL), or
			 * even swizzled back from swapper_space to tmpfs file
			 * mapping. However, page->index will not change
			 * because we have a reference on the page.
			 */
2114 2115
			if (page->index > end)
				goto out;
2116

2117 2118
			*done_index = page->index + 1;

2119 2120 2121 2122 2123 2124 2125 2126 2127 2128
			/*
			 * If we can't merge this page, and we have
			 * accumulated an contiguous region, write it
			 */
			if ((mpd->next_page != page->index) &&
			    (mpd->next_page != mpd->first_page)) {
				mpage_da_map_and_submit(mpd);
				goto ret_extent_tail;
			}

2129 2130 2131
			lock_page(page);

			/*
2132 2133 2134 2135 2136 2137
			 * If the page is no longer dirty, or its
			 * mapping no longer corresponds to inode we
			 * are writing (which means it has been
			 * truncated or invalidated), or the page is
			 * already under writeback and we are not
			 * doing a data integrity writeback, skip the page
2138
			 */
2139 2140 2141 2142
			if (!PageDirty(page) ||
			    (PageWriteback(page) &&
			     (wbc->sync_mode == WB_SYNC_NONE)) ||
			    unlikely(page->mapping != mapping)) {
2143 2144 2145 2146
				unlock_page(page);
				continue;
			}

2147
			wait_on_page_writeback(page);
2148 2149
			BUG_ON(PageWriteback(page));

2150
			if (mpd->next_page != page->index)
2151 2152 2153 2154 2155 2156
				mpd->first_page = page->index;
			mpd->next_page = page->index + 1;
			logical = (sector_t) page->index <<
				(PAGE_CACHE_SHIFT - inode->i_blkbits);

			if (!page_has_buffers(page)) {
2157 2158
				mpage_add_bh_to_extent(mpd, logical,
						       PAGE_CACHE_SIZE,
2159
						       (1 << BH_Dirty) | (1 << BH_Uptodate));
2160 2161
				if (mpd->io_done)
					goto ret_extent_tail;
2162 2163
			} else {
				/*
2164 2165
				 * Page with regular buffer heads,
				 * just add all dirty ones
2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180
				 */
				head = page_buffers(page);
				bh = head;
				do {
					BUG_ON(buffer_locked(bh));
					/*
					 * We need to try to allocate
					 * unmapped blocks in the same page.
					 * Otherwise we won't make progress
					 * with the page in ext4_writepage
					 */
					if (ext4_bh_delay_or_unwritten(NULL, bh)) {
						mpage_add_bh_to_extent(mpd, logical,
								       bh->b_size,
								       bh->b_state);
2181 2182
						if (mpd->io_done)
							goto ret_extent_tail;
2183 2184
					} else if (buffer_dirty(bh) && (buffer_mapped(bh))) {
						/*
2185 2186 2187 2188 2189 2190 2191 2192 2193
						 * mapped dirty buffer. We need
						 * to update the b_state
						 * because we look at b_state
						 * in mpage_da_map_blocks.  We
						 * don't update b_size because
						 * if we find an unmapped
						 * buffer_head later we need to
						 * use the b_state flag of that
						 * buffer_head.
2194 2195 2196 2197 2198 2199
						 */
						if (mpd->b_size == 0)
							mpd->b_state = bh->b_state & BH_FLAGS;
					}
					logical++;
				} while ((bh = bh->b_this_page) != head);
2200 2201 2202 2203 2204
			}

			if (nr_to_write > 0) {
				nr_to_write--;
				if (nr_to_write == 0 &&
2205
				    wbc->sync_mode == WB_SYNC_NONE)
2206 2207 2208 2209 2210 2211 2212 2213 2214 2215
					/*
					 * We stop writing back only if we are
					 * not doing integrity sync. In case of
					 * integrity sync we have to keep going
					 * because someone may be concurrently
					 * dirtying pages, and we might have
					 * synced a lot of newly appeared dirty
					 * pages, but have not synced all of the
					 * old dirty pages.
					 */
2216
					goto out;
2217 2218 2219 2220 2221
			}
		}
		pagevec_release(&pvec);
		cond_resched();
	}
2222 2223 2224
	return 0;
ret_extent_tail:
	ret = MPAGE_DA_EXTENT_TAIL;
2225 2226 2227
out:
	pagevec_release(&pvec);
	cond_resched();
2228 2229 2230 2231
	return ret;
}


2232
static int ext4_da_writepages(struct address_space *mapping,
2233
			      struct writeback_control *wbc)
2234
{
2235 2236
	pgoff_t	index;
	int range_whole = 0;
2237
	handle_t *handle = NULL;
2238
	struct mpage_da_data mpd;
2239
	struct inode *inode = mapping->host;
2240
	int pages_written = 0;
2241
	unsigned int max_pages;
2242
	int range_cyclic, cycled = 1, io_done = 0;
2243 2244
	int needed_blocks, ret = 0;
	long desired_nr_to_write, nr_to_writebump = 0;
2245
	loff_t range_start = wbc->range_start;
2246
	struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
2247
	pgoff_t done_index = 0;
2248
	pgoff_t end;
S
Shaohua Li 已提交
2249
	struct blk_plug plug;
2250

2251
	trace_ext4_da_writepages(inode, wbc);
2252

2253 2254 2255 2256 2257
	/*
	 * No pages to write? This is mainly a kludge to avoid starting
	 * a transaction for special inodes like journal inode on last iput()
	 * because that could violate lock ordering on umount
	 */
2258
	if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2259
		return 0;
2260 2261 2262 2263 2264

	/*
	 * If the filesystem has aborted, it is read-only, so return
	 * right away instead of dumping stack traces later on that
	 * will obscure the real source of the problem.  We test
2265
	 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2266 2267 2268 2269 2270
	 * the latter could be true if the filesystem is mounted
	 * read-only, and in that case, ext4_da_writepages should
	 * *never* be called, so if that ever happens, we would want
	 * the stack trace.
	 */
2271
	if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED))
2272 2273
		return -EROFS;

2274 2275
	if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
		range_whole = 1;
2276

2277 2278
	range_cyclic = wbc->range_cyclic;
	if (wbc->range_cyclic) {
2279
		index = mapping->writeback_index;
2280 2281 2282 2283 2284
		if (index)
			cycled = 0;
		wbc->range_start = index << PAGE_CACHE_SHIFT;
		wbc->range_end  = LLONG_MAX;
		wbc->range_cyclic = 0;
2285 2286
		end = -1;
	} else {
2287
		index = wbc->range_start >> PAGE_CACHE_SHIFT;
2288 2289
		end = wbc->range_end >> PAGE_CACHE_SHIFT;
	}
2290

2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307
	/*
	 * This works around two forms of stupidity.  The first is in
	 * the writeback code, which caps the maximum number of pages
	 * written to be 1024 pages.  This is wrong on multiple
	 * levels; different architectues have a different page size,
	 * which changes the maximum amount of data which gets
	 * written.  Secondly, 4 megabytes is way too small.  XFS
	 * forces this value to be 16 megabytes by multiplying
	 * nr_to_write parameter by four, and then relies on its
	 * allocator to allocate larger extents to make them
	 * contiguous.  Unfortunately this brings us to the second
	 * stupidity, which is that ext4's mballoc code only allocates
	 * at most 2048 blocks.  So we force contiguous writes up to
	 * the number of dirty blocks in the inode, or
	 * sbi->max_writeback_mb_bump whichever is smaller.
	 */
	max_pages = sbi->s_max_writeback_mb_bump << (20 - PAGE_CACHE_SHIFT);
2308 2309 2310 2311 2312 2313
	if (!range_cyclic && range_whole) {
		if (wbc->nr_to_write == LONG_MAX)
			desired_nr_to_write = wbc->nr_to_write;
		else
			desired_nr_to_write = wbc->nr_to_write * 8;
	} else
2314 2315 2316 2317 2318 2319 2320 2321 2322 2323
		desired_nr_to_write = ext4_num_dirty_pages(inode, index,
							   max_pages);
	if (desired_nr_to_write > max_pages)
		desired_nr_to_write = max_pages;

	if (wbc->nr_to_write < desired_nr_to_write) {
		nr_to_writebump = desired_nr_to_write - wbc->nr_to_write;
		wbc->nr_to_write = desired_nr_to_write;
	}

2324
retry:
2325
	if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
2326 2327
		tag_pages_for_writeback(mapping, index, end);

S
Shaohua Li 已提交
2328
	blk_start_plug(&plug);
2329
	while (!ret && wbc->nr_to_write > 0) {
2330 2331 2332 2333 2334 2335 2336 2337

		/*
		 * we  insert one extent at a time. So we need
		 * credit needed for single extent allocation.
		 * journalled mode is currently not supported
		 * by delalloc
		 */
		BUG_ON(ext4_should_journal_data(inode));
2338
		needed_blocks = ext4_da_writepages_trans_blocks(inode);
2339

2340 2341 2342 2343
		/* start a new transaction*/
		handle = ext4_journal_start(inode, needed_blocks);
		if (IS_ERR(handle)) {
			ret = PTR_ERR(handle);
2344
			ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
2345
			       "%ld pages, ino %lu; err %d", __func__,
2346
				wbc->nr_to_write, inode->i_ino, ret);
2347
			blk_finish_plug(&plug);
2348 2349
			goto out_writepages;
		}
2350 2351

		/*
2352
		 * Now call write_cache_pages_da() to find the next
2353
		 * contiguous region of logical blocks that need
2354
		 * blocks to be allocated by ext4 and submit them.
2355
		 */
2356
		ret = write_cache_pages_da(mapping, wbc, &mpd, &done_index);
2357
		/*
2358
		 * If we have a contiguous extent of pages and we
2359 2360 2361 2362
		 * haven't done the I/O yet, map the blocks and submit
		 * them for I/O.
		 */
		if (!mpd.io_done && mpd.next_page != mpd.first_page) {
2363
			mpage_da_map_and_submit(&mpd);
2364 2365
			ret = MPAGE_DA_EXTENT_TAIL;
		}
2366
		trace_ext4_da_write_pages(inode, &mpd);
2367
		wbc->nr_to_write -= mpd.pages_written;
2368

2369
		ext4_journal_stop(handle);
2370

2371
		if ((mpd.retval == -ENOSPC) && sbi->s_journal) {
2372 2373 2374 2375
			/* commit the transaction which would
			 * free blocks released in the transaction
			 * and try again
			 */
2376
			jbd2_journal_force_commit_nested(sbi->s_journal);
2377 2378
			ret = 0;
		} else if (ret == MPAGE_DA_EXTENT_TAIL) {
2379
			/*
2380 2381 2382
			 * Got one extent now try with rest of the pages.
			 * If mpd.retval is set -EIO, journal is aborted.
			 * So we don't need to write any more.
2383
			 */
2384
			pages_written += mpd.pages_written;
2385
			ret = mpd.retval;
2386
			io_done = 1;
2387
		} else if (wbc->nr_to_write)
2388 2389 2390 2391 2392 2393
			/*
			 * There is no more writeout needed
			 * or we requested for a noblocking writeout
			 * and we found the device congested
			 */
			break;
2394
	}
S
Shaohua Li 已提交
2395
	blk_finish_plug(&plug);
2396 2397 2398 2399 2400 2401 2402
	if (!io_done && !cycled) {
		cycled = 1;
		index = 0;
		wbc->range_start = index << PAGE_CACHE_SHIFT;
		wbc->range_end  = mapping->writeback_index - 1;
		goto retry;
	}
2403 2404

	/* Update index */
2405
	wbc->range_cyclic = range_cyclic;
2406 2407 2408 2409 2410
	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
		/*
		 * set the writeback_index so that range_cyclic
		 * mode will write it back later
		 */
2411
		mapping->writeback_index = done_index;
2412

2413
out_writepages:
2414
	wbc->nr_to_write -= nr_to_writebump;
2415
	wbc->range_start = range_start;
2416
	trace_ext4_da_writepages_result(inode, wbc, ret, pages_written);
2417
	return ret;
2418 2419
}

2420 2421 2422 2423 2424 2425 2426 2427 2428
#define FALL_BACK_TO_NONDELALLOC 1
static int ext4_nonda_switch(struct super_block *sb)
{
	s64 free_blocks, dirty_blocks;
	struct ext4_sb_info *sbi = EXT4_SB(sb);

	/*
	 * switch to non delalloc mode if we are running low
	 * on free block. The free block accounting via percpu
2429
	 * counters can get slightly wrong with percpu_counter_batch getting
2430 2431 2432 2433
	 * accumulated on each CPU without updating global counters
	 * Delalloc need an accurate free block accounting. So switch
	 * to non delalloc when we are near to error range.
	 */
2434 2435 2436
	free_blocks  = EXT4_C2B(sbi,
		percpu_counter_read_positive(&sbi->s_freeclusters_counter));
	dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);
2437
	if (2 * free_blocks < 3 * dirty_blocks ||
2438
		free_blocks < (dirty_blocks + EXT4_FREECLUSTERS_WATERMARK)) {
2439
		/*
2440 2441
		 * free block count is less than 150% of dirty blocks
		 * or free blocks is less than watermark
2442 2443 2444
		 */
		return 1;
	}
2445 2446 2447 2448 2449
	/*
	 * Even if we don't switch but are nearing capacity,
	 * start pushing delalloc when 1/2 of free blocks are dirty.
	 */
	if (free_blocks < 2 * dirty_blocks)
2450
		writeback_inodes_sb_if_idle(sb, WB_REASON_FS_FREE_SPACE);
2451

2452 2453 2454
	return 0;
}

2455
static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
2456 2457
			       loff_t pos, unsigned len, unsigned flags,
			       struct page **pagep, void **fsdata)
2458
{
2459
	int ret, retries = 0;
2460 2461 2462 2463 2464 2465
	struct page *page;
	pgoff_t index;
	struct inode *inode = mapping->host;
	handle_t *handle;

	index = pos >> PAGE_CACHE_SHIFT;
2466 2467 2468 2469 2470 2471 2472

	if (ext4_nonda_switch(inode->i_sb)) {
		*fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
		return ext4_write_begin(file, mapping, pos,
					len, flags, pagep, fsdata);
	}
	*fsdata = (void *)0;
2473
	trace_ext4_da_write_begin(inode, pos, len, flags);
2474
retry:
2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485
	/*
	 * With delayed allocation, we don't log the i_disksize update
	 * if there is delayed block allocation. But we still need
	 * to journalling the i_disksize update if writes to the end
	 * of file which has an already mapped buffer.
	 */
	handle = ext4_journal_start(inode, 1);
	if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
		goto out;
	}
2486 2487 2488
	/* We cannot recurse into the filesystem as the transaction is already
	 * started */
	flags |= AOP_FLAG_NOFS;
2489

2490
	page = grab_cache_page_write_begin(mapping, index, flags);
2491 2492 2493 2494 2495
	if (!page) {
		ext4_journal_stop(handle);
		ret = -ENOMEM;
		goto out;
	}
2496 2497
	*pagep = page;

2498
	ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep);
2499 2500 2501 2502
	if (ret < 0) {
		unlock_page(page);
		ext4_journal_stop(handle);
		page_cache_release(page);
2503 2504 2505 2506 2507 2508
		/*
		 * block_write_begin may have instantiated a few blocks
		 * outside i_size.  Trim these off again. Don't need
		 * i_size_read because we hold i_mutex.
		 */
		if (pos + len > inode->i_size)
2509
			ext4_truncate_failed_write(inode);
2510 2511
	}

2512 2513
	if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
		goto retry;
2514 2515 2516 2517
out:
	return ret;
}

2518 2519 2520 2521 2522
/*
 * Check if we should update i_disksize
 * when write to the end of file but not require block allocation
 */
static int ext4_da_should_update_i_disksize(struct page *page,
2523
					    unsigned long offset)
2524 2525 2526 2527 2528 2529 2530 2531 2532
{
	struct buffer_head *bh;
	struct inode *inode = page->mapping->host;
	unsigned int idx;
	int i;

	bh = page_buffers(page);
	idx = offset >> inode->i_blkbits;

2533
	for (i = 0; i < idx; i++)
2534 2535
		bh = bh->b_this_page;

2536
	if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
2537 2538 2539 2540
		return 0;
	return 1;
}

2541
static int ext4_da_write_end(struct file *file,
2542 2543 2544
			     struct address_space *mapping,
			     loff_t pos, unsigned len, unsigned copied,
			     struct page *page, void *fsdata)
2545 2546 2547 2548 2549
{
	struct inode *inode = mapping->host;
	int ret = 0, ret2;
	handle_t *handle = ext4_journal_current_handle();
	loff_t new_i_size;
2550
	unsigned long start, end;
2551 2552 2553
	int write_mode = (int)(unsigned long)fsdata;

	if (write_mode == FALL_BACK_TO_NONDELALLOC) {
2554 2555
		switch (ext4_inode_journal_mode(inode)) {
		case EXT4_INODE_ORDERED_DATA_MODE:
2556 2557
			return ext4_ordered_write_end(file, mapping, pos,
					len, copied, page, fsdata);
2558
		case EXT4_INODE_WRITEBACK_DATA_MODE:
2559 2560
			return ext4_writeback_write_end(file, mapping, pos,
					len, copied, page, fsdata);
2561
		default:
2562 2563 2564
			BUG();
		}
	}
2565

2566
	trace_ext4_da_write_end(inode, pos, len, copied);
2567
	start = pos & (PAGE_CACHE_SIZE - 1);
2568
	end = start + copied - 1;
2569 2570 2571 2572 2573 2574 2575 2576

	/*
	 * generic_write_end() will run mark_inode_dirty() if i_size
	 * changes.  So let's piggyback the i_disksize mark_inode_dirty
	 * into that.
	 */

	new_i_size = pos + copied;
2577
	if (copied && new_i_size > EXT4_I(inode)->i_disksize) {
2578 2579 2580 2581 2582 2583 2584 2585 2586 2587
		if (ext4_da_should_update_i_disksize(page, end)) {
			down_write(&EXT4_I(inode)->i_data_sem);
			if (new_i_size > EXT4_I(inode)->i_disksize) {
				/*
				 * Updating i_disksize when extending file
				 * without needing block allocation
				 */
				if (ext4_should_order_data(inode))
					ret = ext4_jbd2_file_inode(handle,
								   inode);
2588

2589 2590 2591
				EXT4_I(inode)->i_disksize = new_i_size;
			}
			up_write(&EXT4_I(inode)->i_data_sem);
2592 2593 2594 2595 2596
			/* We need to mark inode dirty even if
			 * new_i_size is less that inode->i_size
			 * bu greater than i_disksize.(hint delalloc)
			 */
			ext4_mark_inode_dirty(handle, inode);
2597
		}
2598
	}
2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619
	ret2 = generic_write_end(file, mapping, pos, len, copied,
							page, fsdata);
	copied = ret2;
	if (ret2 < 0)
		ret = ret2;
	ret2 = ext4_journal_stop(handle);
	if (!ret)
		ret = ret2;

	return ret ? ret : copied;
}

static void ext4_da_invalidatepage(struct page *page, unsigned long offset)
{
	/*
	 * Drop reserved blocks
	 */
	BUG_ON(!PageLocked(page));
	if (!page_has_buffers(page))
		goto out;

2620
	ext4_da_page_release_reservation(page, offset);
2621 2622 2623 2624 2625 2626 2627

out:
	ext4_invalidatepage(page, offset);

	return;
}

2628 2629 2630 2631 2632
/*
 * Force all delayed allocation blocks to be allocated for a given inode.
 */
int ext4_alloc_da_blocks(struct inode *inode)
{
2633 2634
	trace_ext4_alloc_da_blocks(inode);

2635 2636 2637 2638 2639 2640 2641 2642 2643 2644
	if (!EXT4_I(inode)->i_reserved_data_blocks &&
	    !EXT4_I(inode)->i_reserved_meta_blocks)
		return 0;

	/*
	 * We do something simple for now.  The filemap_flush() will
	 * also start triggering a write of the data blocks, which is
	 * not strictly speaking necessary (and for users of
	 * laptop_mode, not even desirable).  However, to do otherwise
	 * would require replicating code paths in:
2645
	 *
2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657
	 * ext4_da_writepages() ->
	 *    write_cache_pages() ---> (via passed in callback function)
	 *        __mpage_da_writepage() -->
	 *           mpage_add_bh_to_extent()
	 *           mpage_da_map_blocks()
	 *
	 * The problem is that write_cache_pages(), located in
	 * mm/page-writeback.c, marks pages clean in preparation for
	 * doing I/O, which is not desirable if we're not planning on
	 * doing I/O at all.
	 *
	 * We could call write_cache_pages(), and then redirty all of
2658
	 * the pages by calling redirty_page_for_writepage() but that
2659 2660
	 * would be ugly in the extreme.  So instead we would need to
	 * replicate parts of the code in the above functions,
L
Lucas De Marchi 已提交
2661
	 * simplifying them because we wouldn't actually intend to
2662 2663 2664
	 * write out the pages, but rather only collect contiguous
	 * logical block extents, call the multi-block allocator, and
	 * then update the buffer heads with the block allocations.
2665
	 *
2666 2667 2668 2669 2670 2671
	 * For now, though, we'll cheat by calling filemap_flush(),
	 * which will map the blocks, and start the I/O, but not
	 * actually wait for the I/O to complete.
	 */
	return filemap_flush(inode->i_mapping);
}
2672

2673 2674 2675 2676 2677
/*
 * bmap() is special.  It gets used by applications such as lilo and by
 * the swapper to find the on-disk block of a specific piece of data.
 *
 * Naturally, this is dangerous if the block concerned is still in the
2678
 * journal.  If somebody makes a swapfile on an ext4 data-journaling
2679 2680 2681 2682 2683 2684 2685 2686
 * filesystem and enables swap, then they may get a nasty shock when the
 * data getting swapped to that swapfile suddenly gets overwritten by
 * the original zero's written out previously to the journal and
 * awaiting writeback in the kernel's buffer cache.
 *
 * So, if we see any bmap calls here on a modified, data-journaled file,
 * take extra steps to flush any blocks which might be in the cache.
 */
2687
static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
2688 2689 2690 2691 2692
{
	struct inode *inode = mapping->host;
	journal_t *journal;
	int err;

2693 2694 2695 2696 2697 2698 2699 2700 2701 2702
	if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) &&
			test_opt(inode->i_sb, DELALLOC)) {
		/*
		 * With delalloc we want to sync the file
		 * so that we can make sure we allocate
		 * blocks for file
		 */
		filemap_write_and_wait(mapping);
	}

2703 2704
	if (EXT4_JOURNAL(inode) &&
	    ext4_test_inode_state(inode, EXT4_STATE_JDATA)) {
2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715
		/*
		 * This is a REALLY heavyweight approach, but the use of
		 * bmap on dirty files is expected to be extremely rare:
		 * only if we run lilo or swapon on a freshly made file
		 * do we expect this to happen.
		 *
		 * (bmap requires CAP_SYS_RAWIO so this does not
		 * represent an unprivileged user DOS attack --- we'd be
		 * in trouble if mortal users could trigger this path at
		 * will.)
		 *
2716
		 * NB. EXT4_STATE_JDATA is not set on files other than
2717 2718 2719 2720 2721 2722
		 * regular files.  If somebody wants to bmap a directory
		 * or symlink and gets confused because the buffer
		 * hasn't yet been flushed to disk, they deserve
		 * everything they get.
		 */

2723
		ext4_clear_inode_state(inode, EXT4_STATE_JDATA);
2724
		journal = EXT4_JOURNAL(inode);
2725 2726 2727
		jbd2_journal_lock_updates(journal);
		err = jbd2_journal_flush(journal);
		jbd2_journal_unlock_updates(journal);
2728 2729 2730 2731 2732

		if (err)
			return 0;
	}

2733
	return generic_block_bmap(mapping, block, ext4_get_block);
2734 2735
}

2736
static int ext4_readpage(struct file *file, struct page *page)
2737
{
2738
	trace_ext4_readpage(page);
2739
	return mpage_readpage(page, ext4_get_block);
2740 2741 2742
}

static int
2743
ext4_readpages(struct file *file, struct address_space *mapping,
2744 2745
		struct list_head *pages, unsigned nr_pages)
{
2746
	return mpage_readpages(mapping, pages, nr_pages, ext4_get_block);
2747 2748
}

2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768
static void ext4_invalidatepage_free_endio(struct page *page, unsigned long offset)
{
	struct buffer_head *head, *bh;
	unsigned int curr_off = 0;

	if (!page_has_buffers(page))
		return;
	head = bh = page_buffers(page);
	do {
		if (offset <= curr_off && test_clear_buffer_uninit(bh)
					&& bh->b_private) {
			ext4_free_io_end(bh->b_private);
			bh->b_private = NULL;
			bh->b_end_io = NULL;
		}
		curr_off = curr_off + bh->b_size;
		bh = bh->b_this_page;
	} while (bh != head);
}

2769
static void ext4_invalidatepage(struct page *page, unsigned long offset)
2770
{
2771
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);
2772

2773 2774
	trace_ext4_invalidatepage(page, offset);

2775 2776 2777 2778 2779
	/*
	 * free any io_end structure allocated for buffers to be discarded
	 */
	if (ext4_should_dioread_nolock(page->mapping->host))
		ext4_invalidatepage_free_endio(page, offset);
2780 2781 2782 2783 2784 2785
	/*
	 * If it's a full truncate we just forget about the pending dirtying
	 */
	if (offset == 0)
		ClearPageChecked(page);

2786 2787 2788 2789
	if (journal)
		jbd2_journal_invalidatepage(journal, page, offset);
	else
		block_invalidatepage(page, offset);
2790 2791
}

2792
static int ext4_releasepage(struct page *page, gfp_t wait)
2793
{
2794
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);
2795

2796 2797
	trace_ext4_releasepage(page);

2798 2799 2800
	WARN_ON(PageChecked(page));
	if (!page_has_buffers(page))
		return 0;
2801 2802 2803 2804
	if (journal)
		return jbd2_journal_try_to_free_buffers(journal, page, wait);
	else
		return try_to_free_buffers(page);
2805 2806
}

2807 2808 2809 2810 2811
/*
 * ext4_get_block used when preparing for a DIO write or buffer write.
 * We allocate an uinitialized extent if blocks haven't been allocated.
 * The extent will be converted to initialized after the IO is complete.
 */
2812
static int ext4_get_block_write(struct inode *inode, sector_t iblock,
2813 2814
		   struct buffer_head *bh_result, int create)
{
2815
	ext4_debug("ext4_get_block_write: inode %lu, create flag %d\n",
2816
		   inode->i_ino, create);
2817 2818
	return _ext4_get_block(inode, iblock, bh_result,
			       EXT4_GET_BLOCKS_IO_CREATE_EXT);
2819 2820 2821
}

static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
2822 2823
			    ssize_t size, void *private, int ret,
			    bool is_async)
2824
{
2825
	struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
2826 2827
        ext4_io_end_t *io_end = iocb->private;
	struct workqueue_struct *wq;
2828 2829
	unsigned long flags;
	struct ext4_inode_info *ei;
2830

2831 2832
	/* if not async direct IO or dio with 0 bytes write, just return */
	if (!io_end || !size)
2833
		goto out;
2834

2835
	ext_debug("ext4_end_io_dio(): io_end 0x%p "
2836
		  "for inode %lu, iocb 0x%p, offset %llu, size %zd\n",
2837 2838 2839
 		  iocb->private, io_end->inode->i_ino, iocb, offset,
		  size);

2840 2841
	iocb->private = NULL;

2842
	/* if not aio dio with unwritten extents, just free io and return */
2843
	if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) {
2844
		ext4_free_io_end(io_end);
2845 2846 2847
out:
		if (is_async)
			aio_complete(iocb, ret, 0);
2848
		inode_dio_done(inode);
2849
		return;
2850 2851
	}

2852 2853
	io_end->offset = offset;
	io_end->size = size;
2854 2855 2856 2857
	if (is_async) {
		io_end->iocb = iocb;
		io_end->result = ret;
	}
2858 2859
	wq = EXT4_SB(io_end->inode->i_sb)->dio_unwritten_wq;

2860
	/* Add the io_end to per-inode completed aio dio list*/
2861 2862 2863 2864
	ei = EXT4_I(io_end->inode);
	spin_lock_irqsave(&ei->i_completed_io_lock, flags);
	list_add_tail(&io_end->list, &ei->i_completed_io_list);
	spin_unlock_irqrestore(&ei->i_completed_io_lock, flags);
2865 2866

	/* queue the work to convert unwritten extents to written */
2867
	queue_work(wq, &io_end->work);
2868
}
2869

2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880
static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate)
{
	ext4_io_end_t *io_end = bh->b_private;
	struct workqueue_struct *wq;
	struct inode *inode;
	unsigned long flags;

	if (!test_clear_buffer_uninit(bh) || !io_end)
		goto out;

	if (!(io_end->inode->i_sb->s_flags & MS_ACTIVE)) {
2881 2882 2883
		ext4_msg(io_end->inode->i_sb, KERN_INFO,
			 "sb umounted, discard end_io request for inode %lu",
			 io_end->inode->i_ino);
2884 2885 2886 2887
		ext4_free_io_end(io_end);
		goto out;
	}

2888 2889 2890 2891
	/*
	 * It may be over-defensive here to check EXT4_IO_END_UNWRITTEN now,
	 * but being more careful is always safe for the future change.
	 */
2892
	inode = io_end->inode;
2893
	ext4_set_io_unwritten_flag(inode, io_end);
2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919

	/* Add the io_end to per-inode completed io list*/
	spin_lock_irqsave(&EXT4_I(inode)->i_completed_io_lock, flags);
	list_add_tail(&io_end->list, &EXT4_I(inode)->i_completed_io_list);
	spin_unlock_irqrestore(&EXT4_I(inode)->i_completed_io_lock, flags);

	wq = EXT4_SB(inode->i_sb)->dio_unwritten_wq;
	/* queue the work to convert unwritten extents to written */
	queue_work(wq, &io_end->work);
out:
	bh->b_private = NULL;
	bh->b_end_io = NULL;
	clear_buffer_uninit(bh);
	end_buffer_async_write(bh, uptodate);
}

static int ext4_set_bh_endio(struct buffer_head *bh, struct inode *inode)
{
	ext4_io_end_t *io_end;
	struct page *page = bh->b_page;
	loff_t offset = (sector_t)page->index << PAGE_CACHE_SHIFT;
	size_t size = bh->b_size;

retry:
	io_end = ext4_init_io_end(inode, GFP_ATOMIC);
	if (!io_end) {
2920
		pr_warn_ratelimited("%s: allocation fail\n", __func__);
2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938
		schedule();
		goto retry;
	}
	io_end->offset = offset;
	io_end->size = size;
	/*
	 * We need to hold a reference to the page to make sure it
	 * doesn't get evicted before ext4_end_io_work() has a chance
	 * to convert the extent from written to unwritten.
	 */
	io_end->page = page;
	get_page(io_end->page);

	bh->b_private = io_end;
	bh->b_end_io = ext4_end_io_buffer_write;
	return 0;
}

2939 2940 2941 2942 2943
/*
 * For ext4 extent files, ext4 will do direct-io write to holes,
 * preallocated extents, and those write extend the file, no need to
 * fall back to buffered IO.
 *
2944
 * For holes, we fallocate those blocks, mark them as uninitialized
2945
 * If those blocks were preallocated, we mark sure they are splited, but
2946
 * still keep the range to write as uninitialized.
2947
 *
2948 2949
 * The unwrritten extents will be converted to written when DIO is completed.
 * For async direct IO, since the IO may still pending when return, we
L
Lucas De Marchi 已提交
2950
 * set up an end_io call back function, which will do the conversion
2951
 * when async direct IO completed.
2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969
 *
 * If the O_DIRECT write will extend the file then add this inode to the
 * orphan list.  So recovery will truncate it back to the original size
 * if the machine crashes during the write.
 *
 */
static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
			      const struct iovec *iov, loff_t offset,
			      unsigned long nr_segs)
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
	ssize_t ret;
	size_t count = iov_length(iov, nr_segs);

	loff_t final_size = offset + count;
	if (rw == WRITE && final_size <= inode->i_size) {
		/*
2970 2971 2972
 		 * We could direct write to holes and fallocate.
		 *
 		 * Allocated blocks to fill the hole are marked as uninitialized
L
Lucas De Marchi 已提交
2973
 		 * to prevent parallel buffered read to expose the stale data
2974
 		 * before DIO complete the data IO.
2975 2976
		 *
 		 * As to previously fallocated extents, ext4 get_block
2977 2978 2979
 		 * will just simply mark the buffer mapped but still
 		 * keep the extents uninitialized.
 		 *
2980 2981 2982 2983 2984 2985 2986 2987
		 * for non AIO case, we will convert those unwritten extents
		 * to written after return back from blockdev_direct_IO.
		 *
		 * for async DIO, the conversion needs to be defered when
		 * the IO is completed. The ext4 end_io callback function
		 * will be called to take care of the conversion work.
		 * Here for async case, we allocate an io_end structure to
		 * hook to the iocb.
2988
 		 */
2989 2990 2991
		iocb->private = NULL;
		EXT4_I(inode)->cur_aio_dio = NULL;
		if (!is_sync_kiocb(iocb)) {
2992 2993 2994
			ext4_io_end_t *io_end =
				ext4_init_io_end(inode, GFP_NOFS);
			if (!io_end)
2995
				return -ENOMEM;
2996 2997
			io_end->flag |= EXT4_IO_END_DIRECT;
			iocb->private = io_end;
2998 2999
			/*
			 * we save the io structure for current async
3000
			 * direct IO, so that later ext4_map_blocks()
3001 3002 3003 3004 3005 3006 3007
			 * could flag the io structure whether there
			 * is a unwritten extents needs to be converted
			 * when IO is completed.
			 */
			EXT4_I(inode)->cur_aio_dio = iocb->private;
		}

3008
		ret = __blockdev_direct_IO(rw, iocb, inode,
3009 3010
					 inode->i_sb->s_bdev, iov,
					 offset, nr_segs,
3011
					 ext4_get_block_write,
3012 3013
					 ext4_end_io_dio,
					 NULL,
3014
					 DIO_LOCKING);
3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033
		if (iocb->private)
			EXT4_I(inode)->cur_aio_dio = NULL;
		/*
		 * The io_end structure takes a reference to the inode,
		 * that structure needs to be destroyed and the
		 * reference to the inode need to be dropped, when IO is
		 * complete, even with 0 byte write, or failed.
		 *
		 * In the successful AIO DIO case, the io_end structure will be
		 * desctroyed and the reference to the inode will be dropped
		 * after the end_io call back function is called.
		 *
		 * In the case there is 0 byte write, or error case, since
		 * VFS direct IO won't invoke the end_io call back function,
		 * we need to free the end_io structure here.
		 */
		if (ret != -EIOCBQUEUED && ret <= 0 && iocb->private) {
			ext4_free_io_end(iocb->private);
			iocb->private = NULL;
3034 3035
		} else if (ret > 0 && ext4_test_inode_state(inode,
						EXT4_STATE_DIO_UNWRITTEN)) {
3036
			int err;
3037 3038
			/*
			 * for non AIO case, since the IO is already
L
Lucas De Marchi 已提交
3039
			 * completed, we could do the conversion right here
3040
			 */
3041 3042 3043 3044
			err = ext4_convert_unwritten_extents(inode,
							     offset, ret);
			if (err < 0)
				ret = err;
3045
			ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
3046
		}
3047 3048
		return ret;
	}
3049 3050

	/* for write the the end of file case, we fall back to old way */
3051 3052 3053 3054 3055 3056 3057 3058 3059
	return ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
}

static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
			      const struct iovec *iov, loff_t offset,
			      unsigned long nr_segs)
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
3060
	ssize_t ret;
3061

3062 3063 3064 3065 3066 3067
	/*
	 * If we are doing data journalling we don't support O_DIRECT
	 */
	if (ext4_should_journal_data(inode))
		return 0;

3068
	trace_ext4_direct_IO_enter(inode, offset, iov_length(iov, nr_segs), rw);
3069
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3070 3071 3072 3073 3074 3075
		ret = ext4_ext_direct_IO(rw, iocb, iov, offset, nr_segs);
	else
		ret = ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
	trace_ext4_direct_IO_exit(inode, offset,
				iov_length(iov, nr_segs), rw, ret);
	return ret;
3076 3077
}

3078
/*
3079
 * Pages can be marked dirty completely asynchronously from ext4's journalling
3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090
 * activity.  By filemap_sync_pte(), try_to_unmap_one(), etc.  We cannot do
 * much here because ->set_page_dirty is called under VFS locks.  The page is
 * not necessarily locked.
 *
 * We cannot just dirty the page and leave attached buffers clean, because the
 * buffers' dirty state is "definitive".  We cannot just set the buffers dirty
 * or jbddirty because all the journalling code will explode.
 *
 * So what we do is to mark the page "pending dirty" and next time writepage
 * is called, propagate that into the buffers appropriately.
 */
3091
static int ext4_journalled_set_page_dirty(struct page *page)
3092 3093 3094 3095 3096
{
	SetPageChecked(page);
	return __set_page_dirty_nobuffers(page);
}

3097
static const struct address_space_operations ext4_ordered_aops = {
3098 3099
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3100
	.writepage		= ext4_writepage,
3101 3102 3103 3104 3105 3106 3107 3108
	.write_begin		= ext4_write_begin,
	.write_end		= ext4_ordered_write_end,
	.bmap			= ext4_bmap,
	.invalidatepage		= ext4_invalidatepage,
	.releasepage		= ext4_releasepage,
	.direct_IO		= ext4_direct_IO,
	.migratepage		= buffer_migrate_page,
	.is_partially_uptodate  = block_is_partially_uptodate,
3109
	.error_remove_page	= generic_error_remove_page,
3110 3111
};

3112
static const struct address_space_operations ext4_writeback_aops = {
3113 3114
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3115
	.writepage		= ext4_writepage,
3116 3117 3118 3119 3120 3121 3122 3123
	.write_begin		= ext4_write_begin,
	.write_end		= ext4_writeback_write_end,
	.bmap			= ext4_bmap,
	.invalidatepage		= ext4_invalidatepage,
	.releasepage		= ext4_releasepage,
	.direct_IO		= ext4_direct_IO,
	.migratepage		= buffer_migrate_page,
	.is_partially_uptodate  = block_is_partially_uptodate,
3124
	.error_remove_page	= generic_error_remove_page,
3125 3126
};

3127
static const struct address_space_operations ext4_journalled_aops = {
3128 3129
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3130
	.writepage		= ext4_writepage,
3131 3132 3133 3134 3135 3136
	.write_begin		= ext4_write_begin,
	.write_end		= ext4_journalled_write_end,
	.set_page_dirty		= ext4_journalled_set_page_dirty,
	.bmap			= ext4_bmap,
	.invalidatepage		= ext4_invalidatepage,
	.releasepage		= ext4_releasepage,
3137
	.direct_IO		= ext4_direct_IO,
3138
	.is_partially_uptodate  = block_is_partially_uptodate,
3139
	.error_remove_page	= generic_error_remove_page,
3140 3141
};

3142
static const struct address_space_operations ext4_da_aops = {
3143 3144
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3145
	.writepage		= ext4_writepage,
3146 3147 3148 3149 3150 3151 3152 3153 3154
	.writepages		= ext4_da_writepages,
	.write_begin		= ext4_da_write_begin,
	.write_end		= ext4_da_write_end,
	.bmap			= ext4_bmap,
	.invalidatepage		= ext4_da_invalidatepage,
	.releasepage		= ext4_releasepage,
	.direct_IO		= ext4_direct_IO,
	.migratepage		= buffer_migrate_page,
	.is_partially_uptodate  = block_is_partially_uptodate,
3155
	.error_remove_page	= generic_error_remove_page,
3156 3157
};

3158
void ext4_set_aops(struct inode *inode)
3159
{
3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173
	switch (ext4_inode_journal_mode(inode)) {
	case EXT4_INODE_ORDERED_DATA_MODE:
		if (test_opt(inode->i_sb, DELALLOC))
			inode->i_mapping->a_ops = &ext4_da_aops;
		else
			inode->i_mapping->a_ops = &ext4_ordered_aops;
		break;
	case EXT4_INODE_WRITEBACK_DATA_MODE:
		if (test_opt(inode->i_sb, DELALLOC))
			inode->i_mapping->a_ops = &ext4_da_aops;
		else
			inode->i_mapping->a_ops = &ext4_writeback_aops;
		break;
	case EXT4_INODE_JOURNAL_DATA_MODE:
3174
		inode->i_mapping->a_ops = &ext4_journalled_aops;
3175 3176 3177 3178
		break;
	default:
		BUG();
	}
3179 3180
}

3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200

/*
 * ext4_discard_partial_page_buffers()
 * Wrapper function for ext4_discard_partial_page_buffers_no_lock.
 * This function finds and locks the page containing the offset
 * "from" and passes it to ext4_discard_partial_page_buffers_no_lock.
 * Calling functions that already have the page locked should call
 * ext4_discard_partial_page_buffers_no_lock directly.
 */
int ext4_discard_partial_page_buffers(handle_t *handle,
		struct address_space *mapping, loff_t from,
		loff_t length, int flags)
{
	struct inode *inode = mapping->host;
	struct page *page;
	int err = 0;

	page = find_or_create_page(mapping, from >> PAGE_CACHE_SHIFT,
				   mapping_gfp_mask(mapping) & ~__GFP_FS);
	if (!page)
3201
		return -ENOMEM;
3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243

	err = ext4_discard_partial_page_buffers_no_lock(handle, inode, page,
		from, length, flags);

	unlock_page(page);
	page_cache_release(page);
	return err;
}

/*
 * ext4_discard_partial_page_buffers_no_lock()
 * Zeros a page range of length 'length' starting from offset 'from'.
 * Buffer heads that correspond to the block aligned regions of the
 * zeroed range will be unmapped.  Unblock aligned regions
 * will have the corresponding buffer head mapped if needed so that
 * that region of the page can be updated with the partial zero out.
 *
 * This function assumes that the page has already been  locked.  The
 * The range to be discarded must be contained with in the given page.
 * If the specified range exceeds the end of the page it will be shortened
 * to the end of the page that corresponds to 'from'.  This function is
 * appropriate for updating a page and it buffer heads to be unmapped and
 * zeroed for blocks that have been either released, or are going to be
 * released.
 *
 * handle: The journal handle
 * inode:  The files inode
 * page:   A locked page that contains the offset "from"
 * from:   The starting byte offset (from the begining of the file)
 *         to begin discarding
 * len:    The length of bytes to discard
 * flags:  Optional flags that may be used:
 *
 *         EXT4_DISCARD_PARTIAL_PG_ZERO_UNMAPPED
 *         Only zero the regions of the page whose buffer heads
 *         have already been unmapped.  This flag is appropriate
 *         for updateing the contents of a page whose blocks may
 *         have already been released, and we only want to zero
 *         out the regions that correspond to those released blocks.
 *
 * Returns zero on sucess or negative on failure.
 */
E
Eric Sandeen 已提交
3244
static int ext4_discard_partial_page_buffers_no_lock(handle_t *handle,
3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269
		struct inode *inode, struct page *page, loff_t from,
		loff_t length, int flags)
{
	ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT;
	unsigned int offset = from & (PAGE_CACHE_SIZE-1);
	unsigned int blocksize, max, pos;
	ext4_lblk_t iblock;
	struct buffer_head *bh;
	int err = 0;

	blocksize = inode->i_sb->s_blocksize;
	max = PAGE_CACHE_SIZE - offset;

	if (index != page->index)
		return -EINVAL;

	/*
	 * correct length if it does not fall between
	 * 'from' and the end of the page
	 */
	if (length > max || length < 0)
		length = max;

	iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);

3270 3271
	if (!page_has_buffers(page))
		create_empty_buffers(page, blocksize, 0);
3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283

	/* Find the buffer that contains "offset" */
	bh = page_buffers(page);
	pos = blocksize;
	while (offset >= pos) {
		bh = bh->b_this_page;
		iblock++;
		pos += blocksize;
	}

	pos = offset;
	while (pos < offset + length) {
3284 3285
		unsigned int end_of_block, range_to_discard;

3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370
		err = 0;

		/* The length of space left to zero and unmap */
		range_to_discard = offset + length - pos;

		/* The length of space until the end of the block */
		end_of_block = blocksize - (pos & (blocksize-1));

		/*
		 * Do not unmap or zero past end of block
		 * for this buffer head
		 */
		if (range_to_discard > end_of_block)
			range_to_discard = end_of_block;


		/*
		 * Skip this buffer head if we are only zeroing unampped
		 * regions of the page
		 */
		if (flags & EXT4_DISCARD_PARTIAL_PG_ZERO_UNMAPPED &&
			buffer_mapped(bh))
				goto next;

		/* If the range is block aligned, unmap */
		if (range_to_discard == blocksize) {
			clear_buffer_dirty(bh);
			bh->b_bdev = NULL;
			clear_buffer_mapped(bh);
			clear_buffer_req(bh);
			clear_buffer_new(bh);
			clear_buffer_delay(bh);
			clear_buffer_unwritten(bh);
			clear_buffer_uptodate(bh);
			zero_user(page, pos, range_to_discard);
			BUFFER_TRACE(bh, "Buffer discarded");
			goto next;
		}

		/*
		 * If this block is not completely contained in the range
		 * to be discarded, then it is not going to be released. Because
		 * we need to keep this block, we need to make sure this part
		 * of the page is uptodate before we modify it by writeing
		 * partial zeros on it.
		 */
		if (!buffer_mapped(bh)) {
			/*
			 * Buffer head must be mapped before we can read
			 * from the block
			 */
			BUFFER_TRACE(bh, "unmapped");
			ext4_get_block(inode, iblock, bh, 0);
			/* unmapped? It's a hole - nothing to do */
			if (!buffer_mapped(bh)) {
				BUFFER_TRACE(bh, "still unmapped");
				goto next;
			}
		}

		/* Ok, it's mapped. Make sure it's up-to-date */
		if (PageUptodate(page))
			set_buffer_uptodate(bh);

		if (!buffer_uptodate(bh)) {
			err = -EIO;
			ll_rw_block(READ, 1, &bh);
			wait_on_buffer(bh);
			/* Uhhuh. Read error. Complain and punt.*/
			if (!buffer_uptodate(bh))
				goto next;
		}

		if (ext4_should_journal_data(inode)) {
			BUFFER_TRACE(bh, "get write access");
			err = ext4_journal_get_write_access(handle, bh);
			if (err)
				goto next;
		}

		zero_user(page, pos, range_to_discard);

		err = 0;
		if (ext4_should_journal_data(inode)) {
			err = ext4_handle_dirty_metadata(handle, inode, bh);
3371
		} else
3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383
			mark_buffer_dirty(bh);

		BUFFER_TRACE(bh, "Partial buffer zeroed");
next:
		bh = bh->b_this_page;
		iblock++;
		pos += range_to_discard;
	}

	return err;
}

3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394
int ext4_can_truncate(struct inode *inode)
{
	if (S_ISREG(inode->i_mode))
		return 1;
	if (S_ISDIR(inode->i_mode))
		return 1;
	if (S_ISLNK(inode->i_mode))
		return !ext4_inode_is_fast_symlink(inode);
	return 0;
}

3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409
/*
 * ext4_punch_hole: punches a hole in a file by releaseing the blocks
 * associated with the given offset and length
 *
 * @inode:  File inode
 * @offset: The offset where the hole will begin
 * @len:    The length of the hole
 *
 * Returns: 0 on sucess or negative on failure
 */

int ext4_punch_hole(struct file *file, loff_t offset, loff_t length)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	if (!S_ISREG(inode->i_mode))
3410
		return -EOPNOTSUPP;
3411 3412 3413

	if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
		/* TODO: Add support for non extent hole punching */
3414
		return -EOPNOTSUPP;
3415 3416
	}

3417 3418
	if (EXT4_SB(inode->i_sb)->s_cluster_ratio > 1) {
		/* TODO: Add support for bigalloc file systems */
3419
		return -EOPNOTSUPP;
3420 3421
	}

3422 3423 3424
	return ext4_ext_punch_hole(file, offset, length);
}

3425
/*
3426
 * ext4_truncate()
3427
 *
3428 3429
 * We block out ext4_get_block() block instantiations across the entire
 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3430 3431
 * simultaneously on behalf of the same inode.
 *
3432
 * As we work through the truncate and commit bits of it to the journal there
3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445
 * is one core, guiding principle: the file's tree must always be consistent on
 * disk.  We must be able to restart the truncate after a crash.
 *
 * The file's tree may be transiently inconsistent in memory (although it
 * probably isn't), but whenever we close off and commit a journal transaction,
 * the contents of (the filesystem + the journal) must be consistent and
 * restartable.  It's pretty simple, really: bottom up, right to left (although
 * left-to-right works OK too).
 *
 * Note that at recovery time, journal replay occurs *before* the restart of
 * truncate against the orphan inode list.
 *
 * The committed inode has the new, desired i_size (which is the same as
3446
 * i_disksize in this case).  After a crash, ext4_orphan_cleanup() will see
3447
 * that this inode's truncate did not complete and it will again call
3448 3449
 * ext4_truncate() to have another go.  So there will be instantiated blocks
 * to the right of the truncation point in a crashed ext4 filesystem.  But
3450
 * that's fine - as long as they are linked from the inode, the post-crash
3451
 * ext4_truncate() run will find them and release them.
3452
 */
3453
void ext4_truncate(struct inode *inode)
3454
{
3455 3456
	trace_ext4_truncate_enter(inode);

3457
	if (!ext4_can_truncate(inode))
3458 3459
		return;

3460
	ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
3461

3462
	if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
3463
		ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
3464

3465
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3466
		ext4_ext_truncate(inode);
3467 3468
	else
		ext4_ind_truncate(inode);
3469

3470
	trace_ext4_truncate_exit(inode);
3471 3472 3473
}

/*
3474
 * ext4_get_inode_loc returns with an extra refcount against the inode's
3475 3476 3477 3478
 * underlying buffer_head on success. If 'in_mem' is true, we have all
 * data in memory that is needed to recreate the on-disk version of this
 * inode.
 */
3479 3480
static int __ext4_get_inode_loc(struct inode *inode,
				struct ext4_iloc *iloc, int in_mem)
3481
{
3482 3483 3484 3485 3486 3487
	struct ext4_group_desc	*gdp;
	struct buffer_head	*bh;
	struct super_block	*sb = inode->i_sb;
	ext4_fsblk_t		block;
	int			inodes_per_block, inode_offset;

A
Aneesh Kumar K.V 已提交
3488
	iloc->bh = NULL;
3489 3490
	if (!ext4_valid_inum(sb, inode->i_ino))
		return -EIO;
3491

3492 3493 3494
	iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
	gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
	if (!gdp)
3495 3496
		return -EIO;

3497 3498 3499
	/*
	 * Figure out the offset within the block group inode table
	 */
3500
	inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
3501 3502 3503 3504 3505 3506
	inode_offset = ((inode->i_ino - 1) %
			EXT4_INODES_PER_GROUP(sb));
	block = ext4_inode_table(sb, gdp) + (inode_offset / inodes_per_block);
	iloc->offset = (inode_offset % inodes_per_block) * EXT4_INODE_SIZE(sb);

	bh = sb_getblk(sb, block);
3507
	if (!bh) {
3508 3509
		EXT4_ERROR_INODE_BLOCK(inode, block,
				       "unable to read itable block");
3510 3511 3512 3513
		return -EIO;
	}
	if (!buffer_uptodate(bh)) {
		lock_buffer(bh);
3514 3515 3516 3517 3518 3519 3520 3521 3522 3523

		/*
		 * If the buffer has the write error flag, we have failed
		 * to write out another inode in the same block.  In this
		 * case, we don't have to read the block because we may
		 * read the old inode data successfully.
		 */
		if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
			set_buffer_uptodate(bh);

3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536
		if (buffer_uptodate(bh)) {
			/* someone brought it uptodate while we waited */
			unlock_buffer(bh);
			goto has_buffer;
		}

		/*
		 * If we have all information of the inode in memory and this
		 * is the only valid inode in the block, we need not read the
		 * block.
		 */
		if (in_mem) {
			struct buffer_head *bitmap_bh;
3537
			int i, start;
3538

3539
			start = inode_offset & ~(inodes_per_block - 1);
3540

3541 3542
			/* Is the inode bitmap in cache? */
			bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554
			if (!bitmap_bh)
				goto make_io;

			/*
			 * If the inode bitmap isn't in cache then the
			 * optimisation may end up performing two reads instead
			 * of one, so skip it.
			 */
			if (!buffer_uptodate(bitmap_bh)) {
				brelse(bitmap_bh);
				goto make_io;
			}
3555
			for (i = start; i < start + inodes_per_block; i++) {
3556 3557
				if (i == inode_offset)
					continue;
3558
				if (ext4_test_bit(i, bitmap_bh->b_data))
3559 3560 3561
					break;
			}
			brelse(bitmap_bh);
3562
			if (i == start + inodes_per_block) {
3563 3564 3565 3566 3567 3568 3569 3570 3571
				/* all other inodes are free, so skip I/O */
				memset(bh->b_data, 0, bh->b_size);
				set_buffer_uptodate(bh);
				unlock_buffer(bh);
				goto has_buffer;
			}
		}

make_io:
3572 3573 3574 3575 3576 3577 3578 3579 3580
		/*
		 * If we need to do any I/O, try to pre-readahead extra
		 * blocks from the inode table.
		 */
		if (EXT4_SB(sb)->s_inode_readahead_blks) {
			ext4_fsblk_t b, end, table;
			unsigned num;

			table = ext4_inode_table(sb, gdp);
T
Theodore Ts'o 已提交
3581
			/* s_inode_readahead_blks is always a power of 2 */
3582 3583 3584 3585 3586
			b = block & ~(EXT4_SB(sb)->s_inode_readahead_blks-1);
			if (table > b)
				b = table;
			end = b + EXT4_SB(sb)->s_inode_readahead_blks;
			num = EXT4_INODES_PER_GROUP(sb);
3587
			if (ext4_has_group_desc_csum(sb))
3588
				num -= ext4_itable_unused_count(sb, gdp);
3589 3590 3591 3592 3593 3594 3595
			table += num / inodes_per_block;
			if (end > table)
				end = table;
			while (b <= end)
				sb_breadahead(sb, b++);
		}

3596 3597 3598 3599 3600
		/*
		 * There are other valid inodes in the buffer, this inode
		 * has in-inode xattrs, or we don't have this inode in memory.
		 * Read the block from disk.
		 */
3601
		trace_ext4_load_inode(inode);
3602 3603
		get_bh(bh);
		bh->b_end_io = end_buffer_read_sync;
3604
		submit_bh(READ | REQ_META | REQ_PRIO, bh);
3605 3606
		wait_on_buffer(bh);
		if (!buffer_uptodate(bh)) {
3607 3608
			EXT4_ERROR_INODE_BLOCK(inode, block,
					       "unable to read itable block");
3609 3610 3611 3612 3613 3614 3615 3616 3617
			brelse(bh);
			return -EIO;
		}
	}
has_buffer:
	iloc->bh = bh;
	return 0;
}

3618
int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
3619 3620
{
	/* We have all inode data except xattrs in memory here. */
3621
	return __ext4_get_inode_loc(inode, iloc,
3622
		!ext4_test_inode_state(inode, EXT4_STATE_XATTR));
3623 3624
}

3625
void ext4_set_inode_flags(struct inode *inode)
3626
{
3627
	unsigned int flags = EXT4_I(inode)->i_flags;
3628 3629

	inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
3630
	if (flags & EXT4_SYNC_FL)
3631
		inode->i_flags |= S_SYNC;
3632
	if (flags & EXT4_APPEND_FL)
3633
		inode->i_flags |= S_APPEND;
3634
	if (flags & EXT4_IMMUTABLE_FL)
3635
		inode->i_flags |= S_IMMUTABLE;
3636
	if (flags & EXT4_NOATIME_FL)
3637
		inode->i_flags |= S_NOATIME;
3638
	if (flags & EXT4_DIRSYNC_FL)
3639 3640 3641
		inode->i_flags |= S_DIRSYNC;
}

3642 3643 3644
/* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
void ext4_get_inode_flags(struct ext4_inode_info *ei)
{
3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664
	unsigned int vfs_fl;
	unsigned long old_fl, new_fl;

	do {
		vfs_fl = ei->vfs_inode.i_flags;
		old_fl = ei->i_flags;
		new_fl = old_fl & ~(EXT4_SYNC_FL|EXT4_APPEND_FL|
				EXT4_IMMUTABLE_FL|EXT4_NOATIME_FL|
				EXT4_DIRSYNC_FL);
		if (vfs_fl & S_SYNC)
			new_fl |= EXT4_SYNC_FL;
		if (vfs_fl & S_APPEND)
			new_fl |= EXT4_APPEND_FL;
		if (vfs_fl & S_IMMUTABLE)
			new_fl |= EXT4_IMMUTABLE_FL;
		if (vfs_fl & S_NOATIME)
			new_fl |= EXT4_NOATIME_FL;
		if (vfs_fl & S_DIRSYNC)
			new_fl |= EXT4_DIRSYNC_FL;
	} while (cmpxchg(&ei->i_flags, old_fl, new_fl) != old_fl);
3665
}
3666

3667
static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
3668
				  struct ext4_inode_info *ei)
3669 3670
{
	blkcnt_t i_blocks ;
A
Aneesh Kumar K.V 已提交
3671 3672
	struct inode *inode = &(ei->vfs_inode);
	struct super_block *sb = inode->i_sb;
3673 3674 3675 3676 3677 3678

	if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
				EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
		/* we are using combined 48 bit field */
		i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
					le32_to_cpu(raw_inode->i_blocks_lo);
3679
		if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) {
A
Aneesh Kumar K.V 已提交
3680 3681 3682 3683 3684
			/* i_blocks represent file system block size */
			return i_blocks  << (inode->i_blkbits - 9);
		} else {
			return i_blocks;
		}
3685 3686 3687 3688
	} else {
		return le32_to_cpu(raw_inode->i_blocks_lo);
	}
}
3689

3690
struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
3691
{
3692 3693
	struct ext4_iloc iloc;
	struct ext4_inode *raw_inode;
3694 3695
	struct ext4_inode_info *ei;
	struct inode *inode;
3696
	journal_t *journal = EXT4_SB(sb)->s_journal;
3697
	long ret;
3698 3699
	int block;

3700 3701 3702 3703 3704 3705 3706
	inode = iget_locked(sb, ino);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;

	ei = EXT4_I(inode);
3707
	iloc.bh = NULL;
3708

3709 3710
	ret = __ext4_get_inode_loc(inode, &iloc, 0);
	if (ret < 0)
3711
		goto bad_inode;
3712
	raw_inode = ext4_raw_inode(&iloc);
3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745

	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
		ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
		if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
		    EXT4_INODE_SIZE(inode->i_sb)) {
			EXT4_ERROR_INODE(inode, "bad extra_isize (%u != %u)",
				EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize,
				EXT4_INODE_SIZE(inode->i_sb));
			ret = -EIO;
			goto bad_inode;
		}
	} else
		ei->i_extra_isize = 0;

	/* Precompute checksum seed for inode metadata */
	if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
			EXT4_FEATURE_RO_COMPAT_METADATA_CSUM)) {
		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
		__u32 csum;
		__le32 inum = cpu_to_le32(inode->i_ino);
		__le32 gen = raw_inode->i_generation;
		csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum,
				   sizeof(inum));
		ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen,
					      sizeof(gen));
	}

	if (!ext4_inode_csum_verify(inode, raw_inode, ei)) {
		EXT4_ERROR_INODE(inode, "checksum invalid");
		ret = -EIO;
		goto bad_inode;
	}

3746 3747 3748
	inode->i_mode = le16_to_cpu(raw_inode->i_mode);
	inode->i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
	inode->i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
3749
	if (!(test_opt(inode->i_sb, NO_UID32))) {
3750 3751 3752
		inode->i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
		inode->i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
	}
M
Miklos Szeredi 已提交
3753
	set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
3754

3755
	ext4_clear_state_flags(ei);	/* Only relevant on 32-bit archs */
3756 3757 3758 3759 3760 3761 3762 3763 3764
	ei->i_dir_start_lookup = 0;
	ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
	/* We now have enough fields to check if the inode was active or not.
	 * This is needed because nfsd might try to access dead inodes
	 * the test is that same one that e2fsck uses
	 * NeilBrown 1999oct15
	 */
	if (inode->i_nlink == 0) {
		if (inode->i_mode == 0 ||
3765
		    !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
3766
			/* this inode is deleted */
3767
			ret = -ESTALE;
3768 3769 3770 3771 3772 3773 3774 3775
			goto bad_inode;
		}
		/* The only unlinked inodes we let through here have
		 * valid i_mode and are being read by the orphan
		 * recovery code: that's fine, we're about to complete
		 * the process of deleting those. */
	}
	ei->i_flags = le32_to_cpu(raw_inode->i_flags);
3776
	inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
3777
	ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
3778
	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT))
B
Badari Pulavarty 已提交
3779 3780
		ei->i_file_acl |=
			((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
3781
	inode->i_size = ext4_isize(raw_inode);
3782
	ei->i_disksize = inode->i_size;
3783 3784 3785
#ifdef CONFIG_QUOTA
	ei->i_reserved_quota = 0;
#endif
3786 3787
	inode->i_generation = le32_to_cpu(raw_inode->i_generation);
	ei->i_block_group = iloc.block_group;
3788
	ei->i_last_alloc_group = ~0;
3789 3790 3791 3792
	/*
	 * NOTE! The in-memory inode i_data array is in little-endian order
	 * even on big-endian machines: we do NOT byteswap the block numbers!
	 */
3793
	for (block = 0; block < EXT4_N_BLOCKS; block++)
3794 3795 3796
		ei->i_data[block] = raw_inode->i_block[block];
	INIT_LIST_HEAD(&ei->i_orphan);

3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807
	/*
	 * Set transaction id's of transactions that have to be committed
	 * to finish f[data]sync. We set them to currently running transaction
	 * as we cannot be sure that the inode or some of its metadata isn't
	 * part of the transaction - the inode could have been reclaimed and
	 * now it is reread from disk.
	 */
	if (journal) {
		transaction_t *transaction;
		tid_t tid;

3808
		read_lock(&journal->j_state_lock);
3809 3810 3811 3812 3813 3814 3815 3816
		if (journal->j_running_transaction)
			transaction = journal->j_running_transaction;
		else
			transaction = journal->j_committing_transaction;
		if (transaction)
			tid = transaction->t_tid;
		else
			tid = journal->j_commit_sequence;
3817
		read_unlock(&journal->j_state_lock);
3818 3819 3820 3821
		ei->i_sync_tid = tid;
		ei->i_datasync_tid = tid;
	}

3822
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
3823 3824
		if (ei->i_extra_isize == 0) {
			/* The extra space is currently unused. Use it. */
3825 3826
			ei->i_extra_isize = sizeof(struct ext4_inode) -
					    EXT4_GOOD_OLD_INODE_SIZE;
3827 3828
		} else {
			__le32 *magic = (void *)raw_inode +
3829
					EXT4_GOOD_OLD_INODE_SIZE +
3830
					ei->i_extra_isize;
3831
			if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC))
3832
				ext4_set_inode_state(inode, EXT4_STATE_XATTR);
3833
		}
3834
	}
3835

K
Kalpak Shah 已提交
3836 3837 3838 3839 3840
	EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode);
	EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode);
	EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode);
	EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);

3841 3842 3843 3844 3845 3846 3847
	inode->i_version = le32_to_cpu(raw_inode->i_disk_version);
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
		if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
			inode->i_version |=
			(__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
	}

3848
	ret = 0;
3849
	if (ei->i_file_acl &&
3850
	    !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
3851 3852
		EXT4_ERROR_INODE(inode, "bad extended attribute block %llu",
				 ei->i_file_acl);
3853 3854
		ret = -EIO;
		goto bad_inode;
3855
	} else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
3856 3857 3858 3859 3860
		if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
		    (S_ISLNK(inode->i_mode) &&
		     !ext4_inode_is_fast_symlink(inode)))
			/* Validate extent which is part of inode */
			ret = ext4_ext_check_inode(inode);
3861
	} else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
3862 3863
		   (S_ISLNK(inode->i_mode) &&
		    !ext4_inode_is_fast_symlink(inode))) {
3864
		/* Validate block references which are part of inode */
3865
		ret = ext4_ind_check_inode(inode);
3866
	}
3867
	if (ret)
3868
		goto bad_inode;
3869

3870
	if (S_ISREG(inode->i_mode)) {
3871 3872 3873
		inode->i_op = &ext4_file_inode_operations;
		inode->i_fop = &ext4_file_operations;
		ext4_set_aops(inode);
3874
	} else if (S_ISDIR(inode->i_mode)) {
3875 3876
		inode->i_op = &ext4_dir_inode_operations;
		inode->i_fop = &ext4_dir_operations;
3877
	} else if (S_ISLNK(inode->i_mode)) {
3878
		if (ext4_inode_is_fast_symlink(inode)) {
3879
			inode->i_op = &ext4_fast_symlink_inode_operations;
3880 3881 3882
			nd_terminate_link(ei->i_data, inode->i_size,
				sizeof(ei->i_data) - 1);
		} else {
3883 3884
			inode->i_op = &ext4_symlink_inode_operations;
			ext4_set_aops(inode);
3885
		}
3886 3887
	} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
	      S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
3888
		inode->i_op = &ext4_special_inode_operations;
3889 3890 3891 3892 3893 3894
		if (raw_inode->i_block[0])
			init_special_inode(inode, inode->i_mode,
			   old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
		else
			init_special_inode(inode, inode->i_mode,
			   new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
3895 3896
	} else {
		ret = -EIO;
3897
		EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode);
3898
		goto bad_inode;
3899
	}
3900
	brelse(iloc.bh);
3901
	ext4_set_inode_flags(inode);
3902 3903
	unlock_new_inode(inode);
	return inode;
3904 3905

bad_inode:
3906
	brelse(iloc.bh);
3907 3908
	iget_failed(inode);
	return ERR_PTR(ret);
3909 3910
}

3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923
static int ext4_inode_blocks_set(handle_t *handle,
				struct ext4_inode *raw_inode,
				struct ext4_inode_info *ei)
{
	struct inode *inode = &(ei->vfs_inode);
	u64 i_blocks = inode->i_blocks;
	struct super_block *sb = inode->i_sb;

	if (i_blocks <= ~0U) {
		/*
		 * i_blocks can be represnted in a 32 bit variable
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
3924
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
3925
		raw_inode->i_blocks_high = 0;
3926
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
3927 3928 3929 3930 3931 3932
		return 0;
	}
	if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE))
		return -EFBIG;

	if (i_blocks <= 0xffffffffffffULL) {
3933 3934 3935 3936
		/*
		 * i_blocks can be represented in a 48 bit variable
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
3937
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
3938
		raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
3939
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
3940
	} else {
3941
		ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE);
A
Aneesh Kumar K.V 已提交
3942 3943 3944 3945
		/* i_block is stored in file system block size */
		i_blocks = i_blocks >> (inode->i_blkbits - 9);
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
		raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
3946
	}
3947
	return 0;
3948 3949
}

3950 3951 3952 3953 3954 3955 3956
/*
 * Post the struct inode info into an on-disk inode location in the
 * buffer-cache.  This gobbles the caller's reference to the
 * buffer_head in the inode location struct.
 *
 * The caller must have write access to iloc->bh.
 */
3957
static int ext4_do_update_inode(handle_t *handle,
3958
				struct inode *inode,
3959
				struct ext4_iloc *iloc)
3960
{
3961 3962
	struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
	struct ext4_inode_info *ei = EXT4_I(inode);
3963 3964 3965 3966 3967
	struct buffer_head *bh = iloc->bh;
	int err = 0, rc, block;

	/* For fields not not tracking in the in-memory inode,
	 * initialise them to zero for new inodes. */
3968
	if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
3969
		memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
3970

3971
	ext4_get_inode_flags(ei);
3972
	raw_inode->i_mode = cpu_to_le16(inode->i_mode);
3973
	if (!(test_opt(inode->i_sb, NO_UID32))) {
3974 3975 3976 3977 3978 3979
		raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
		raw_inode->i_gid_low = cpu_to_le16(low_16_bits(inode->i_gid));
/*
 * Fix up interoperability with old kernels. Otherwise, old inodes get
 * re-used with the upper 16 bits of the uid/gid intact
 */
3980
		if (!ei->i_dtime) {
3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997
			raw_inode->i_uid_high =
				cpu_to_le16(high_16_bits(inode->i_uid));
			raw_inode->i_gid_high =
				cpu_to_le16(high_16_bits(inode->i_gid));
		} else {
			raw_inode->i_uid_high = 0;
			raw_inode->i_gid_high = 0;
		}
	} else {
		raw_inode->i_uid_low =
			cpu_to_le16(fs_high2lowuid(inode->i_uid));
		raw_inode->i_gid_low =
			cpu_to_le16(fs_high2lowgid(inode->i_gid));
		raw_inode->i_uid_high = 0;
		raw_inode->i_gid_high = 0;
	}
	raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
K
Kalpak Shah 已提交
3998 3999 4000 4001 4002 4003

	EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode);
	EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode);
	EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
	EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);

4004 4005
	if (ext4_inode_blocks_set(handle, raw_inode, ei))
		goto out_brelse;
4006
	raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
4007
	raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF);
4008 4009
	if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
	    cpu_to_le32(EXT4_OS_HURD))
B
Badari Pulavarty 已提交
4010 4011
		raw_inode->i_file_acl_high =
			cpu_to_le16(ei->i_file_acl >> 32);
4012
	raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028
	ext4_isize_set(raw_inode, ei->i_disksize);
	if (ei->i_disksize > 0x7fffffffULL) {
		struct super_block *sb = inode->i_sb;
		if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
				EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
				EXT4_SB(sb)->s_es->s_rev_level ==
				cpu_to_le32(EXT4_GOOD_OLD_REV)) {
			/* If this is the first large file
			 * created, add a flag to the superblock.
			 */
			err = ext4_journal_get_write_access(handle,
					EXT4_SB(sb)->s_sbh);
			if (err)
				goto out_brelse;
			ext4_update_dynamic_rev(sb);
			EXT4_SET_RO_COMPAT_FEATURE(sb,
4029
					EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4030
			ext4_handle_sync(handle);
4031
			err = ext4_handle_dirty_super_now(handle, sb);
4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045
		}
	}
	raw_inode->i_generation = cpu_to_le32(inode->i_generation);
	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
		if (old_valid_dev(inode->i_rdev)) {
			raw_inode->i_block[0] =
				cpu_to_le32(old_encode_dev(inode->i_rdev));
			raw_inode->i_block[1] = 0;
		} else {
			raw_inode->i_block[0] = 0;
			raw_inode->i_block[1] =
				cpu_to_le32(new_encode_dev(inode->i_rdev));
			raw_inode->i_block[2] = 0;
		}
4046 4047 4048
	} else
		for (block = 0; block < EXT4_N_BLOCKS; block++)
			raw_inode->i_block[block] = ei->i_data[block];
4049

4050 4051 4052 4053 4054
	raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
	if (ei->i_extra_isize) {
		if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
			raw_inode->i_version_hi =
			cpu_to_le32(inode->i_version >> 32);
4055
		raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
4056 4057
	}

4058 4059
	ext4_inode_csum_set(inode, raw_inode, ei);

4060
	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
4061
	rc = ext4_handle_dirty_metadata(handle, NULL, bh);
4062 4063
	if (!err)
		err = rc;
4064
	ext4_clear_inode_state(inode, EXT4_STATE_NEW);
4065

4066
	ext4_update_inode_fsync_trans(handle, inode, 0);
4067
out_brelse:
4068
	brelse(bh);
4069
	ext4_std_error(inode->i_sb, err);
4070 4071 4072 4073
	return err;
}

/*
4074
 * ext4_write_inode()
4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090
 *
 * We are called from a few places:
 *
 * - Within generic_file_write() for O_SYNC files.
 *   Here, there will be no transaction running. We wait for any running
 *   trasnaction to commit.
 *
 * - Within sys_sync(), kupdate and such.
 *   We wait on commit, if tol to.
 *
 * - Within prune_icache() (PF_MEMALLOC == true)
 *   Here we simply return.  We can't afford to block kswapd on the
 *   journal commit.
 *
 * In all cases it is actually safe for us to return without doing anything,
 * because the inode has been copied into a raw inode buffer in
4091
 * ext4_mark_inode_dirty().  This is a correctness thing for O_SYNC and for
4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107
 * knfsd.
 *
 * Note that we are absolutely dependent upon all inode dirtiers doing the
 * right thing: they *must* call mark_inode_dirty() after dirtying info in
 * which we are interested.
 *
 * It would be a bug for them to not do this.  The code:
 *
 *	mark_inode_dirty(inode)
 *	stuff();
 *	inode->i_size = expr;
 *
 * is in error because a kswapd-driven write_inode() could occur while
 * `stuff()' is running, and the new i_size will be lost.  Plus the inode
 * will no longer be on the superblock's dirty inode list.
 */
4108
int ext4_write_inode(struct inode *inode, struct writeback_control *wbc)
4109
{
4110 4111
	int err;

4112 4113 4114
	if (current->flags & PF_MEMALLOC)
		return 0;

4115 4116 4117 4118 4119 4120
	if (EXT4_SB(inode->i_sb)->s_journal) {
		if (ext4_journal_current_handle()) {
			jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
			dump_stack();
			return -EIO;
		}
4121

4122
		if (wbc->sync_mode != WB_SYNC_ALL)
4123 4124 4125 4126 4127
			return 0;

		err = ext4_force_commit(inode->i_sb);
	} else {
		struct ext4_iloc iloc;
4128

4129
		err = __ext4_get_inode_loc(inode, &iloc, 0);
4130 4131
		if (err)
			return err;
4132
		if (wbc->sync_mode == WB_SYNC_ALL)
4133 4134
			sync_dirty_buffer(iloc.bh);
		if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
4135 4136
			EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr,
					 "IO error syncing inode");
4137 4138
			err = -EIO;
		}
4139
		brelse(iloc.bh);
4140 4141
	}
	return err;
4142 4143 4144
}

/*
4145
 * ext4_setattr()
4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158
 *
 * Called from notify_change.
 *
 * We want to trap VFS attempts to truncate the file as soon as
 * possible.  In particular, we want to make sure that when the VFS
 * shrinks i_size, we put the inode on the orphan list and modify
 * i_disksize immediately, so that during the subsequent flushing of
 * dirty pages and freeing of disk blocks, we can guarantee that any
 * commit will leave the blocks being flushed in an unused state on
 * disk.  (On recovery, the inode will get truncated and the blocks will
 * be freed, so we have a strong guarantee that no future commit will
 * leave these blocks visible to the user.)
 *
4159 4160 4161 4162 4163 4164 4165 4166
 * Another thing we have to assure is that if we are in ordered mode
 * and inode is still attached to the committing transaction, we must
 * we start writeout of all the dirty pages which are being truncated.
 * This way we are sure that all the data written in the previous
 * transaction are already on disk (truncate waits for pages under
 * writeback).
 *
 * Called with inode->i_mutex down.
4167
 */
4168
int ext4_setattr(struct dentry *dentry, struct iattr *attr)
4169 4170 4171
{
	struct inode *inode = dentry->d_inode;
	int error, rc = 0;
4172
	int orphan = 0;
4173 4174 4175 4176 4177 4178
	const unsigned int ia_valid = attr->ia_valid;

	error = inode_change_ok(inode, attr);
	if (error)
		return error;

4179
	if (is_quota_modification(inode, attr))
4180
		dquot_initialize(inode);
4181 4182 4183 4184 4185 4186
	if ((ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
		(ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
		handle_t *handle;

		/* (user+group)*(old+new) structure, inode write (sb,
		 * inode block, ? - but truncate inode update has it) */
D
Dmitry Monakhov 已提交
4187
		handle = ext4_journal_start(inode, (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
4188
					EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb))+3);
4189 4190 4191 4192
		if (IS_ERR(handle)) {
			error = PTR_ERR(handle);
			goto err_out;
		}
4193
		error = dquot_transfer(inode, attr);
4194
		if (error) {
4195
			ext4_journal_stop(handle);
4196 4197 4198 4199 4200 4201 4202 4203
			return error;
		}
		/* Update corresponding info in inode so that everything is in
		 * one transaction */
		if (attr->ia_valid & ATTR_UID)
			inode->i_uid = attr->ia_uid;
		if (attr->ia_valid & ATTR_GID)
			inode->i_gid = attr->ia_gid;
4204 4205
		error = ext4_mark_inode_dirty(handle, inode);
		ext4_journal_stop(handle);
4206 4207
	}

4208
	if (attr->ia_valid & ATTR_SIZE) {
4209 4210
		inode_dio_wait(inode);

4211
		if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4212 4213
			struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

4214 4215
			if (attr->ia_size > sbi->s_bitmap_maxbytes)
				return -EFBIG;
4216 4217 4218
		}
	}

4219
	if (S_ISREG(inode->i_mode) &&
4220
	    attr->ia_valid & ATTR_SIZE &&
4221
	    (attr->ia_size < inode->i_size)) {
4222 4223
		handle_t *handle;

4224
		handle = ext4_journal_start(inode, 3);
4225 4226 4227 4228
		if (IS_ERR(handle)) {
			error = PTR_ERR(handle);
			goto err_out;
		}
4229 4230 4231 4232
		if (ext4_handle_valid(handle)) {
			error = ext4_orphan_add(handle, inode);
			orphan = 1;
		}
4233 4234
		EXT4_I(inode)->i_disksize = attr->ia_size;
		rc = ext4_mark_inode_dirty(handle, inode);
4235 4236
		if (!error)
			error = rc;
4237
		ext4_journal_stop(handle);
4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249

		if (ext4_should_order_data(inode)) {
			error = ext4_begin_ordered_truncate(inode,
							    attr->ia_size);
			if (error) {
				/* Do as much error cleanup as possible */
				handle = ext4_journal_start(inode, 3);
				if (IS_ERR(handle)) {
					ext4_orphan_del(NULL, inode);
					goto err_out;
				}
				ext4_orphan_del(handle, inode);
4250
				orphan = 0;
4251 4252 4253 4254
				ext4_journal_stop(handle);
				goto err_out;
			}
		}
4255 4256
	}

4257
	if (attr->ia_valid & ATTR_SIZE) {
4258
		if (attr->ia_size != i_size_read(inode))
4259
			truncate_setsize(inode, attr->ia_size);
4260
		ext4_truncate(inode);
4261
	}
4262

C
Christoph Hellwig 已提交
4263 4264 4265 4266 4267 4268 4269 4270 4271
	if (!rc) {
		setattr_copy(inode, attr);
		mark_inode_dirty(inode);
	}

	/*
	 * If the call to ext4_truncate failed to get a transaction handle at
	 * all, we need to clean up the in-core orphan list manually.
	 */
4272
	if (orphan && inode->i_nlink)
4273
		ext4_orphan_del(NULL, inode);
4274 4275

	if (!rc && (ia_valid & ATTR_MODE))
4276
		rc = ext4_acl_chmod(inode);
4277 4278

err_out:
4279
	ext4_std_error(inode->i_sb, error);
4280 4281 4282 4283 4284
	if (!error)
		error = rc;
	return error;
}

4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303
int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
		 struct kstat *stat)
{
	struct inode *inode;
	unsigned long delalloc_blocks;

	inode = dentry->d_inode;
	generic_fillattr(inode, stat);

	/*
	 * We can't update i_blocks if the block allocation is delayed
	 * otherwise in the case of system crash before the real block
	 * allocation is done, we will have i_blocks inconsistent with
	 * on-disk file blocks.
	 * We always keep i_blocks updated together with real
	 * allocation. But to not confuse with user, stat
	 * will return the blocks that include the delayed allocation
	 * blocks for this file.
	 */
4304 4305
	delalloc_blocks = EXT4_C2B(EXT4_SB(inode->i_sb),
				EXT4_I(inode)->i_reserved_data_blocks);
4306 4307 4308 4309

	stat->blocks += (delalloc_blocks << inode->i_sb->s_blocksize_bits)>>9;
	return 0;
}
4310

4311 4312
static int ext4_index_trans_blocks(struct inode *inode, int nrblocks, int chunk)
{
4313
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
4314
		return ext4_ind_trans_blocks(inode, nrblocks, chunk);
4315
	return ext4_ext_index_trans_blocks(inode, nrblocks, chunk);
4316
}
4317

4318
/*
4319 4320 4321
 * Account for index blocks, block groups bitmaps and block group
 * descriptor blocks if modify datablocks and index blocks
 * worse case, the indexs blocks spread over different block groups
4322
 *
4323
 * If datablocks are discontiguous, they are possible to spread over
4324
 * different block groups too. If they are contiuguous, with flexbg,
4325
 * they could still across block group boundary.
4326
 *
4327 4328
 * Also account for superblock, inode, quota and xattr blocks
 */
4329
static int ext4_meta_trans_blocks(struct inode *inode, int nrblocks, int chunk)
4330
{
4331 4332
	ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
	int gdpblocks;
4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358
	int idxblocks;
	int ret = 0;

	/*
	 * How many index blocks need to touch to modify nrblocks?
	 * The "Chunk" flag indicating whether the nrblocks is
	 * physically contiguous on disk
	 *
	 * For Direct IO and fallocate, they calls get_block to allocate
	 * one single extent at a time, so they could set the "Chunk" flag
	 */
	idxblocks = ext4_index_trans_blocks(inode, nrblocks, chunk);

	ret = idxblocks;

	/*
	 * Now let's see how many group bitmaps and group descriptors need
	 * to account
	 */
	groups = idxblocks;
	if (chunk)
		groups += 1;
	else
		groups += nrblocks;

	gdpblocks = groups;
4359 4360
	if (groups > ngroups)
		groups = ngroups;
4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373
	if (groups > EXT4_SB(inode->i_sb)->s_gdb_count)
		gdpblocks = EXT4_SB(inode->i_sb)->s_gdb_count;

	/* bitmaps and block group descriptor blocks */
	ret += groups + gdpblocks;

	/* Blocks for super block, inode, quota and xattr blocks */
	ret += EXT4_META_TRANS_BLOCKS(inode->i_sb);

	return ret;
}

/*
L
Lucas De Marchi 已提交
4374
 * Calculate the total number of credits to reserve to fit
4375 4376
 * the modification of a single pages into a single transaction,
 * which may include multiple chunks of block allocations.
4377
 *
4378
 * This could be called via ext4_write_begin()
4379
 *
4380
 * We need to consider the worse case, when
4381
 * one new block per extent.
4382
 */
A
Alex Tomas 已提交
4383
int ext4_writepage_trans_blocks(struct inode *inode)
4384
{
4385
	int bpp = ext4_journal_blocks_per_page(inode);
4386 4387
	int ret;

4388
	ret = ext4_meta_trans_blocks(inode, bpp, 0);
A
Alex Tomas 已提交
4389

4390
	/* Account for data blocks for journalled mode */
4391
	if (ext4_should_journal_data(inode))
4392
		ret += bpp;
4393 4394
	return ret;
}
4395 4396 4397 4398 4399

/*
 * Calculate the journal credits for a chunk of data modification.
 *
 * This is called from DIO, fallocate or whoever calling
4400
 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
4401 4402 4403 4404 4405 4406 4407 4408 4409
 *
 * journal buffers for data blocks are not included here, as DIO
 * and fallocate do no need to journal data buffers.
 */
int ext4_chunk_trans_blocks(struct inode *inode, int nrblocks)
{
	return ext4_meta_trans_blocks(inode, nrblocks, 1);
}

4410
/*
4411
 * The caller must have previously called ext4_reserve_inode_write().
4412 4413
 * Give this, we know that the caller already has write access to iloc->bh.
 */
4414
int ext4_mark_iloc_dirty(handle_t *handle,
4415
			 struct inode *inode, struct ext4_iloc *iloc)
4416 4417 4418
{
	int err = 0;

4419
	if (IS_I_VERSION(inode))
4420 4421
		inode_inc_iversion(inode);

4422 4423 4424
	/* the do_update_inode consumes one bh->b_count */
	get_bh(iloc->bh);

4425
	/* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
4426
	err = ext4_do_update_inode(handle, inode, iloc);
4427 4428 4429 4430 4431 4432 4433 4434 4435 4436
	put_bh(iloc->bh);
	return err;
}

/*
 * On success, We end up with an outstanding reference count against
 * iloc->bh.  This _must_ be cleaned up later.
 */

int
4437 4438
ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
			 struct ext4_iloc *iloc)
4439
{
4440 4441 4442 4443 4444 4445 4446 4447 4448
	int err;

	err = ext4_get_inode_loc(inode, iloc);
	if (!err) {
		BUFFER_TRACE(iloc->bh, "get_write_access");
		err = ext4_journal_get_write_access(handle, iloc->bh);
		if (err) {
			brelse(iloc->bh);
			iloc->bh = NULL;
4449 4450
		}
	}
4451
	ext4_std_error(inode->i_sb, err);
4452 4453 4454
	return err;
}

4455 4456 4457 4458
/*
 * Expand an inode by new_extra_isize bytes.
 * Returns 0 on success or negative error number on failure.
 */
A
Aneesh Kumar K.V 已提交
4459 4460 4461 4462
static int ext4_expand_extra_isize(struct inode *inode,
				   unsigned int new_extra_isize,
				   struct ext4_iloc iloc,
				   handle_t *handle)
4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474
{
	struct ext4_inode *raw_inode;
	struct ext4_xattr_ibody_header *header;

	if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
		return 0;

	raw_inode = ext4_raw_inode(&iloc);

	header = IHDR(inode, raw_inode);

	/* No extended attributes present */
4475 4476
	if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
	    header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487
		memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0,
			new_extra_isize);
		EXT4_I(inode)->i_extra_isize = new_extra_isize;
		return 0;
	}

	/* try to expand with EAs present */
	return ext4_expand_extra_isize_ea(inode, new_extra_isize,
					  raw_inode, handle);
}

4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508
/*
 * What we do here is to mark the in-core inode as clean with respect to inode
 * dirtiness (it may still be data-dirty).
 * This means that the in-core inode may be reaped by prune_icache
 * without having to perform any I/O.  This is a very good thing,
 * because *any* task may call prune_icache - even ones which
 * have a transaction open against a different journal.
 *
 * Is this cheating?  Not really.  Sure, we haven't written the
 * inode out, but prune_icache isn't a user-visible syncing function.
 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
 * we start and wait on commits.
 *
 * Is this efficient/effective?  Well, we're being nice to the system
 * by cleaning up our inodes proactively so they can be reaped
 * without I/O.  But we are potentially leaving up to five seconds'
 * worth of inodes floating about which prune_icache wants us to
 * write out.  One way to fix that would be to get prune_icache()
 * to do a write_super() to free up some memory.  It has the desired
 * effect.
 */
4509
int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
4510
{
4511
	struct ext4_iloc iloc;
4512 4513 4514
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	static unsigned int mnt_count;
	int err, ret;
4515 4516

	might_sleep();
4517
	trace_ext4_mark_inode_dirty(inode, _RET_IP_);
4518
	err = ext4_reserve_inode_write(handle, inode, &iloc);
4519 4520
	if (ext4_handle_valid(handle) &&
	    EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize &&
4521
	    !ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND)) {
4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534
		/*
		 * We need extra buffer credits since we may write into EA block
		 * with this same handle. If journal_extend fails, then it will
		 * only result in a minor loss of functionality for that inode.
		 * If this is felt to be critical, then e2fsck should be run to
		 * force a large enough s_min_extra_isize.
		 */
		if ((jbd2_journal_extend(handle,
			     EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) {
			ret = ext4_expand_extra_isize(inode,
						      sbi->s_want_extra_isize,
						      iloc, handle);
			if (ret) {
4535 4536
				ext4_set_inode_state(inode,
						     EXT4_STATE_NO_EXPAND);
A
Aneesh Kumar K.V 已提交
4537 4538
				if (mnt_count !=
					le16_to_cpu(sbi->s_es->s_mnt_count)) {
4539
					ext4_warning(inode->i_sb,
4540 4541 4542
					"Unable to expand inode %lu. Delete"
					" some EAs or run e2fsck.",
					inode->i_ino);
A
Aneesh Kumar K.V 已提交
4543 4544
					mnt_count =
					  le16_to_cpu(sbi->s_es->s_mnt_count);
4545 4546 4547 4548
				}
			}
		}
	}
4549
	if (!err)
4550
		err = ext4_mark_iloc_dirty(handle, inode, &iloc);
4551 4552 4553 4554
	return err;
}

/*
4555
 * ext4_dirty_inode() is called from __mark_inode_dirty()
4556 4557 4558 4559 4560
 *
 * We're really interested in the case where a file is being extended.
 * i_size has been changed by generic_commit_write() and we thus need
 * to include the updated inode in the current transaction.
 *
4561
 * Also, dquot_alloc_block() will always dirty the inode when blocks
4562 4563 4564 4565 4566 4567
 * are allocated to the file.
 *
 * If the inode is marked synchronous, we don't honour that here - doing
 * so would cause a commit on atime updates, which we don't bother doing.
 * We handle synchronous inodes at the highest possible level.
 */
4568
void ext4_dirty_inode(struct inode *inode, int flags)
4569 4570 4571
{
	handle_t *handle;

4572
	handle = ext4_journal_start(inode, 2);
4573 4574
	if (IS_ERR(handle))
		goto out;
4575 4576 4577

	ext4_mark_inode_dirty(handle, inode);

4578
	ext4_journal_stop(handle);
4579 4580 4581 4582 4583 4584 4585 4586
out:
	return;
}

#if 0
/*
 * Bind an inode's backing buffer_head into this transaction, to prevent
 * it from being flushed to disk early.  Unlike
4587
 * ext4_reserve_inode_write, this leaves behind no bh reference and
4588 4589 4590
 * returns no iloc structure, so the caller needs to repeat the iloc
 * lookup to mark the inode dirty later.
 */
4591
static int ext4_pin_inode(handle_t *handle, struct inode *inode)
4592
{
4593
	struct ext4_iloc iloc;
4594 4595 4596

	int err = 0;
	if (handle) {
4597
		err = ext4_get_inode_loc(inode, &iloc);
4598 4599
		if (!err) {
			BUFFER_TRACE(iloc.bh, "get_write_access");
4600
			err = jbd2_journal_get_write_access(handle, iloc.bh);
4601
			if (!err)
4602
				err = ext4_handle_dirty_metadata(handle,
4603
								 NULL,
4604
								 iloc.bh);
4605 4606 4607
			brelse(iloc.bh);
		}
	}
4608
	ext4_std_error(inode->i_sb, err);
4609 4610 4611 4612
	return err;
}
#endif

4613
int ext4_change_inode_journal_flag(struct inode *inode, int val)
4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628
{
	journal_t *journal;
	handle_t *handle;
	int err;

	/*
	 * We have to be very careful here: changing a data block's
	 * journaling status dynamically is dangerous.  If we write a
	 * data block to the journal, change the status and then delete
	 * that block, we risk forgetting to revoke the old log record
	 * from the journal and so a subsequent replay can corrupt data.
	 * So, first we make sure that the journal is empty and that
	 * nobody is changing anything.
	 */

4629
	journal = EXT4_JOURNAL(inode);
4630 4631
	if (!journal)
		return 0;
4632
	if (is_journal_aborted(journal))
4633
		return -EROFS;
4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644
	/* We have to allocate physical blocks for delalloc blocks
	 * before flushing journal. otherwise delalloc blocks can not
	 * be allocated any more. even more truncate on delalloc blocks
	 * could trigger BUG by flushing delalloc blocks in journal.
	 * There is no delalloc block in non-journal data mode.
	 */
	if (val && test_opt(inode->i_sb, DELALLOC)) {
		err = ext4_alloc_da_blocks(inode);
		if (err < 0)
			return err;
	}
4645

4646
	jbd2_journal_lock_updates(journal);
4647 4648 4649 4650 4651 4652 4653 4654 4655 4656

	/*
	 * OK, there are no updates running now, and all cached data is
	 * synced to disk.  We are now in a completely consistent state
	 * which doesn't have anything in the journal, and we know that
	 * no filesystem updates are running, so it is safe to modify
	 * the inode's in-core data-journaling state flag now.
	 */

	if (val)
4657
		ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
4658 4659
	else {
		jbd2_journal_flush(journal);
4660
		ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
4661
	}
4662
	ext4_set_aops(inode);
4663

4664
	jbd2_journal_unlock_updates(journal);
4665 4666 4667

	/* Finally we can mark the inode as dirty. */

4668
	handle = ext4_journal_start(inode, 1);
4669 4670 4671
	if (IS_ERR(handle))
		return PTR_ERR(handle);

4672
	err = ext4_mark_inode_dirty(handle, inode);
4673
	ext4_handle_sync(handle);
4674 4675
	ext4_journal_stop(handle);
	ext4_std_error(inode->i_sb, err);
4676 4677 4678

	return err;
}
4679 4680 4681 4682 4683 4684

static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh)
{
	return !buffer_mapped(bh);
}

4685
int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
4686
{
4687
	struct page *page = vmf->page;
4688 4689
	loff_t size;
	unsigned long len;
4690
	int ret;
4691 4692 4693
	struct file *file = vma->vm_file;
	struct inode *inode = file->f_path.dentry->d_inode;
	struct address_space *mapping = inode->i_mapping;
4694 4695 4696
	handle_t *handle;
	get_block_t *get_block;
	int retries = 0;
4697 4698

	/*
4699 4700
	 * This check is racy but catches the common case. We rely on
	 * __block_page_mkwrite() to do a reliable check.
4701
	 */
4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712
	vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
	/* Delalloc case is easy... */
	if (test_opt(inode->i_sb, DELALLOC) &&
	    !ext4_should_journal_data(inode) &&
	    !ext4_nonda_switch(inode->i_sb)) {
		do {
			ret = __block_page_mkwrite(vma, vmf,
						   ext4_da_get_block_prep);
		} while (ret == -ENOSPC &&
		       ext4_should_retry_alloc(inode->i_sb, &retries));
		goto out_ret;
4713
	}
4714 4715

	lock_page(page);
4716 4717 4718 4719 4720 4721
	size = i_size_read(inode);
	/* Page got truncated from under us? */
	if (page->mapping != mapping || page_offset(page) > size) {
		unlock_page(page);
		ret = VM_FAULT_NOPAGE;
		goto out;
4722
	}
4723 4724 4725 4726 4727

	if (page->index == size >> PAGE_CACHE_SHIFT)
		len = size & ~PAGE_CACHE_MASK;
	else
		len = PAGE_CACHE_SIZE;
4728
	/*
4729 4730
	 * Return if we have all the buffers mapped. This avoids the need to do
	 * journal_start/journal_stop which can block and take a long time
4731
	 */
4732 4733
	if (page_has_buffers(page)) {
		if (!walk_page_buffers(NULL, page_buffers(page), 0, len, NULL,
4734
					ext4_bh_unmapped)) {
4735 4736 4737 4738
			/* Wait so that we don't change page under IO */
			wait_on_page_writeback(page);
			ret = VM_FAULT_LOCKED;
			goto out;
4739
		}
4740
	}
4741
	unlock_page(page);
4742 4743 4744 4745 4746 4747 4748 4749
	/* OK, we need to fill the hole... */
	if (ext4_should_dioread_nolock(inode))
		get_block = ext4_get_block_write;
	else
		get_block = ext4_get_block;
retry_alloc:
	handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
	if (IS_ERR(handle)) {
4750
		ret = VM_FAULT_SIGBUS;
4751 4752 4753 4754 4755 4756 4757 4758
		goto out;
	}
	ret = __block_page_mkwrite(vma, vmf, get_block);
	if (!ret && ext4_should_journal_data(inode)) {
		if (walk_page_buffers(handle, page_buffers(page), 0,
			  PAGE_CACHE_SIZE, NULL, do_journal_get_write_access)) {
			unlock_page(page);
			ret = VM_FAULT_SIGBUS;
4759
			ext4_journal_stop(handle);
4760 4761 4762 4763 4764 4765 4766 4767 4768 4769
			goto out;
		}
		ext4_set_inode_state(inode, EXT4_STATE_JDATA);
	}
	ext4_journal_stop(handle);
	if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
		goto retry_alloc;
out_ret:
	ret = block_page_mkwrite_return(ret);
out:
4770 4771
	return ret;
}