inode.c 141.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
static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
				   struct buffer_head *bh_result, int create);
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 已提交
139 140 141
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);
142

143 144 145
/*
 * Test whether an inode is a fast symlink.
 */
146
static int ext4_inode_is_fast_symlink(struct inode *inode)
147
{
148
	int ea_blocks = EXT4_I(inode)->i_file_acl ?
149 150 151 152 153 154 155 156 157 158
		(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.
 */
159
int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode,
160
				 int nblocks)
161
{
162 163 164
	int ret;

	/*
165
	 * Drop i_data_sem to avoid deadlock with ext4_map_blocks.  At this
166 167 168 169
	 * 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.
	 */
170
	BUG_ON(EXT4_JOURNAL(inode) == NULL);
171
	jbd_debug(2, "restarting handle %p\n", handle);
172
	up_write(&EXT4_I(inode)->i_data_sem);
173
	ret = ext4_journal_restart(handle, nblocks);
174
	down_write(&EXT4_I(inode)->i_data_sem);
175
	ext4_discard_preallocations(inode);
176 177

	return ret;
178 179 180 181 182
}

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

188
	trace_ext4_evict_inode(inode);
189 190 191

	ext4_ioend_wait(inode);

A
Al Viro 已提交
192
	if (inode->i_nlink) {
193 194 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
		/*
		 * 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 已提交
220 221 222 223
		truncate_inode_pages(&inode->i_data, 0);
		goto no_delete;
	}

224
	if (!is_bad_inode(inode))
225
		dquot_initialize(inode);
226

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

	if (is_bad_inode(inode))
		goto no_delete;

234 235 236 237 238
	/*
	 * Protect us against freezing - iput() caller didn't have to have any
	 * protection against it
	 */
	sb_start_intwrite(inode->i_sb);
239
	handle = ext4_journal_start(inode, ext4_blocks_for_truncate(inode)+3);
240
	if (IS_ERR(handle)) {
241
		ext4_std_error(inode->i_sb, PTR_ERR(handle));
242 243 244 245 246
		/*
		 * 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.
		 */
247
		ext4_orphan_del(NULL, inode);
248
		sb_end_intwrite(inode->i_sb);
249 250 251 252
		goto no_delete;
	}

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

	/*
	 * 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.
	 */
270
	if (!ext4_handle_has_enough_credits(handle, 3)) {
271 272 273 274
		err = ext4_journal_extend(handle, 3);
		if (err > 0)
			err = ext4_journal_restart(handle, 3);
		if (err != 0) {
275
			ext4_warning(inode->i_sb,
276 277 278
				     "couldn't extend journal (err %d)", err);
		stop_handle:
			ext4_journal_stop(handle);
279
			ext4_orphan_del(NULL, inode);
280
			sb_end_intwrite(inode->i_sb);
281 282 283 284
			goto no_delete;
		}
	}

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

	/*
	 * 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.
	 */
303
	if (ext4_mark_inode_dirty(handle, inode))
304
		/* If that failed, just do the required in-core inode clear. */
A
Al Viro 已提交
305
		ext4_clear_inode(inode);
306
	else
307 308
		ext4_free_inode(handle, inode);
	ext4_journal_stop(handle);
309
	sb_end_intwrite(inode->i_sb);
310 311
	return;
no_delete:
A
Al Viro 已提交
312
	ext4_clear_inode(inode);	/* We must guarantee clearing of inode... */
313 314
}

315 316
#ifdef CONFIG_QUOTA
qsize_t *ext4_get_reserved_space(struct inode *inode)
317
{
318
	return &EXT4_I(inode)->i_reserved_quota;
319
}
320
#endif
321

322 323
/*
 * Calculate the number of metadata blocks need to reserve
324
 * to allocate a block located at @lblock
325
 */
326
static int ext4_calc_metadata_amount(struct inode *inode, ext4_lblk_t lblock)
327
{
328
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
329
		return ext4_ext_calc_metadata_amount(inode, lblock);
330

331
	return ext4_ind_calc_metadata_amount(inode, lblock);
332 333
}

334 335 336 337
/*
 * Called with i_data_sem down, which is important since we can call
 * ext4_discard_preallocations() from here.
 */
338 339
void ext4_da_update_reserve_space(struct inode *inode,
					int used, int quota_claim)
340 341
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
342 343 344
	struct ext4_inode_info *ei = EXT4_I(inode);

	spin_lock(&ei->i_block_reservation_lock);
345
	trace_ext4_da_update_reserve_space(inode, used, quota_claim);
346 347
	if (unlikely(used > ei->i_reserved_data_blocks)) {
		ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, used %d "
348
			 "with only %d reserved data blocks",
349 350 351 352 353
			 __func__, inode->i_ino, used,
			 ei->i_reserved_data_blocks);
		WARN_ON(1);
		used = ei->i_reserved_data_blocks;
	}
354

355 356 357 358 359 360 361 362 363
	if (unlikely(ei->i_allocated_meta_blocks > ei->i_reserved_meta_blocks)) {
		ext4_msg(inode->i_sb, KERN_NOTICE, "%s: ino %lu, allocated %d "
			 "with only %d reserved metadata blocks\n", __func__,
			 inode->i_ino, ei->i_allocated_meta_blocks,
			 ei->i_reserved_meta_blocks);
		WARN_ON(1);
		ei->i_allocated_meta_blocks = ei->i_reserved_meta_blocks;
	}

364 365 366
	/* Update per-inode reservations */
	ei->i_reserved_data_blocks -= used;
	ei->i_reserved_meta_blocks -= ei->i_allocated_meta_blocks;
367
	percpu_counter_sub(&sbi->s_dirtyclusters_counter,
368
			   used + ei->i_allocated_meta_blocks);
369
	ei->i_allocated_meta_blocks = 0;
370

371 372 373 374 375 376
	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.
		 */
377
		percpu_counter_sub(&sbi->s_dirtyclusters_counter,
378
				   ei->i_reserved_meta_blocks);
379
		ei->i_reserved_meta_blocks = 0;
380
		ei->i_da_metadata_calc_len = 0;
381
	}
382
	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
383

384 385
	/* Update quota subsystem for data blocks */
	if (quota_claim)
386
		dquot_claim_block(inode, EXT4_C2B(sbi, used));
387
	else {
388 389 390
		/*
		 * We did fallocate with an offset that is already delayed
		 * allocated. So on delayed allocated writeback we should
391
		 * not re-claim the quota for fallocated blocks.
392
		 */
393
		dquot_release_reservation_block(inode, EXT4_C2B(sbi, used));
394
	}
395 396 397 398 399 400

	/*
	 * 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.
	 */
401 402
	if ((ei->i_reserved_data_blocks == 0) &&
	    (atomic_read(&inode->i_writecount) == 0))
403
		ext4_discard_preallocations(inode);
404 405
}

406
static int __check_block_validity(struct inode *inode, const char *func,
407 408
				unsigned int line,
				struct ext4_map_blocks *map)
409
{
410 411
	if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk,
				   map->m_len)) {
412 413 414 415
		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);
416 417 418 419 420
		return -EIO;
	}
	return 0;
}

421
#define check_block_validity(inode, map)	\
422
	__check_block_validity((inode), __func__, __LINE__, (map))
423

424
/*
425 426
 * Return the number of contiguous dirty pages in a given inode
 * starting at page frame idx.
427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
 */
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;
			}
460 461 462 463 464 465 466 467 468
			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));
			}
469 470 471 472 473
			unlock_page(page);
			if (done)
				break;
			idx++;
			num++;
474 475
			if (num >= max_pages) {
				done = 1;
476
				break;
477
			}
478 479 480 481 482 483
		}
		pagevec_release(&pvec);
	}
	return num;
}

484
/*
485
 * The ext4_map_blocks() function tries to look up the requested blocks,
486
 * and returns if the blocks are already mapped.
487 488 489 490 491
 *
 * 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.
 *
492 493
 * If file type is extents based, it will call ext4_ext_map_blocks(),
 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
494 495 496 497 498 499 500 501
 * 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
502
 * that case, buffer head is unmapped
503 504 505
 *
 * It returns the error in case of allocation failure.
 */
506 507
int ext4_map_blocks(handle_t *handle, struct inode *inode,
		    struct ext4_map_blocks *map, int flags)
508 509
{
	int retval;
510

511 512 513 514
	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);
515
	/*
516 517
	 * Try to see if we can get the block without requesting a new
	 * file system block.
518
	 */
519 520
	if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
		down_read((&EXT4_I(inode)->i_data_sem));
521
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
522 523
		retval = ext4_ext_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
524
	} else {
525 526
		retval = ext4_ind_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
527
	}
528 529
	if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
		up_read((&EXT4_I(inode)->i_data_sem));
530

531
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
532 533 534 535 536 537 538 539 540 541
		int ret;
		if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
			/* delayed alloc may be allocated by fallocate and
			 * coverted to initialized by directIO.
			 * we need to handle delayed extent here.
			 */
			down_write((&EXT4_I(inode)->i_data_sem));
			goto delayed_mapped;
		}
		ret = check_block_validity(inode, map);
542 543 544 545
		if (ret != 0)
			return ret;
	}

546
	/* If it is only a block(s) look up */
547
	if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)
548 549 550 551 552 553
		return retval;

	/*
	 * Returns if the blocks have already allocated
	 *
	 * Note that if blocks have been preallocated
554
	 * ext4_ext_get_block() returns the create = 0
555 556
	 * with buffer head unmapped.
	 */
557
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
558 559
		return retval;

560 561 562 563 564 565 566 567 568 569
	/*
	 * 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.
	 */
570
	map->m_flags &= ~EXT4_MAP_UNWRITTEN;
571

572
	/*
573 574 575 576
	 * 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.
577 578
	 */
	down_write((&EXT4_I(inode)->i_data_sem));
579 580 581 582 583 584 585

	/*
	 * 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
	 */
586
	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
587
		ext4_set_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);
588 589 590 591
	/*
	 * We need to check for EXT4 here because migrate
	 * could have changed the inode type in between
	 */
592
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
593
		retval = ext4_ext_map_blocks(handle, inode, map, flags);
594
	} else {
595
		retval = ext4_ind_map_blocks(handle, inode, map, flags);
596

597
		if (retval > 0 && map->m_flags & EXT4_MAP_NEW) {
598 599 600 601 602
			/*
			 * We allocated new blocks which will result in
			 * i_data's format changing.  Force the migrate
			 * to fail by clearing migrate flags
			 */
603
			ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
604
		}
605

606 607 608 609 610 611 612
		/*
		 * 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) &&
613
			(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE))
614 615
			ext4_da_update_reserve_space(inode, retval, 1);
	}
616
	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) {
617
		ext4_clear_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);
618

619 620 621 622 623 624 625 626 627
		if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
			int ret;
delayed_mapped:
			/* delayed allocation blocks has been allocated */
			ret = ext4_es_remove_extent(inode, map->m_lblk,
						    map->m_len);
			if (ret < 0)
				retval = ret;
		}
628 629
	}

630
	up_write((&EXT4_I(inode)->i_data_sem));
631
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
632
		int ret = check_block_validity(inode, map);
633 634 635
		if (ret != 0)
			return ret;
	}
636 637 638
	return retval;
}

639 640 641
/* Maximum number of blocks we map for direct IO at once. */
#define DIO_MAX_BLOCKS 4096

642 643
static int _ext4_get_block(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int flags)
644
{
645
	handle_t *handle = ext4_journal_current_handle();
646
	struct ext4_map_blocks map;
J
Jan Kara 已提交
647
	int ret = 0, started = 0;
648
	int dio_credits;
649

T
Tao Ma 已提交
650 651 652
	if (ext4_has_inline_data(inode))
		return -ERANGE;

653 654 655
	map.m_lblk = iblock;
	map.m_len = bh->b_size >> inode->i_blkbits;

656
	if (flags && !(flags & EXT4_GET_BLOCKS_NO_LOCK) && !handle) {
J
Jan Kara 已提交
657
		/* Direct IO write... */
658 659 660
		if (map.m_len > DIO_MAX_BLOCKS)
			map.m_len = DIO_MAX_BLOCKS;
		dio_credits = ext4_chunk_trans_blocks(inode, map.m_len);
661
		handle = ext4_journal_start(inode, dio_credits);
J
Jan Kara 已提交
662
		if (IS_ERR(handle)) {
663
			ret = PTR_ERR(handle);
664
			return ret;
665
		}
J
Jan Kara 已提交
666
		started = 1;
667 668
	}

669
	ret = ext4_map_blocks(handle, inode, &map, flags);
J
Jan Kara 已提交
670
	if (ret > 0) {
671 672 673
		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 已提交
674
		ret = 0;
675
	}
J
Jan Kara 已提交
676 677
	if (started)
		ext4_journal_stop(handle);
678 679 680
	return ret;
}

681 682 683 684 685 686 687
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);
}

688 689 690
/*
 * `handle' can be NULL if create is zero
 */
691
struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
A
Aneesh Kumar K.V 已提交
692
				ext4_lblk_t block, int create, int *errp)
693
{
694 695
	struct ext4_map_blocks map;
	struct buffer_head *bh;
696 697 698 699
	int fatal = 0, err;

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

700 701 702 703
	map.m_lblk = block;
	map.m_len = 1;
	err = ext4_map_blocks(handle, inode, &map,
			      create ? EXT4_GET_BLOCKS_CREATE : 0);
704

705 706 707
	/* ensure we send some value back into *errp */
	*errp = 0;

708 709 710 711 712 713
	if (err < 0)
		*errp = err;
	if (err <= 0)
		return NULL;

	bh = sb_getblk(inode->i_sb, map.m_pblk);
714
	if (unlikely(!bh)) {
715
		*errp = -ENOMEM;
716
		return NULL;
717
	}
718 719 720
	if (map.m_flags & EXT4_MAP_NEW) {
		J_ASSERT(create != 0);
		J_ASSERT(handle != NULL);
721

722 723 724 725 726 727 728 729 730 731 732 733 734
		/*
		 * 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);
735
		}
736 737 738 739 740 741 742
		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");
743
	}
744 745 746 747 748 749
	if (fatal) {
		*errp = fatal;
		brelse(bh);
		bh = NULL;
	}
	return bh;
750 751
}

752
struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
A
Aneesh Kumar K.V 已提交
753
			       ext4_lblk_t block, int create, int *err)
754
{
755
	struct buffer_head *bh;
756

757
	bh = ext4_getblk(handle, inode, block, create, err);
758 759 760 761
	if (!bh)
		return bh;
	if (buffer_uptodate(bh))
		return bh;
762
	ll_rw_block(READ | REQ_META | REQ_PRIO, 1, &bh);
763 764 765 766 767 768 769 770
	wait_on_buffer(bh);
	if (buffer_uptodate(bh))
		return bh;
	put_bh(bh);
	*err = -EIO;
	return NULL;
}

771 772 773 774 775 776 777
int ext4_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))
778 779 780 781 782 783 784
{
	struct buffer_head *bh;
	unsigned block_start, block_end;
	unsigned blocksize = head->b_size;
	int err, ret = 0;
	struct buffer_head *next;

785 786
	for (bh = head, block_start = 0;
	     ret == 0 && (bh != head || !block_start);
787
	     block_start = block_end, bh = next) {
788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804
		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
805
 * close off a transaction and start a new one between the ext4_get_block()
806
 * and the commit_write().  So doing the jbd2_journal_start at the start of
807 808
 * prepare_write() is the right place.
 *
809 810 811 812
 * Also, this function can nest inside ext4_writepage().  In that case, we
 * *know* that ext4_writepage() 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.
813
 *
814
 * By accident, ext4 can be reentered when a transaction is open via
815 816 817 818 819 820
 * 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.
 *
821
 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
822 823 824 825
 * will _not_ run commit under these circumstances because handle->h_ref
 * is elevated.  We'll still have enough credits for the tiny quotafile
 * write.
 */
826 827
int do_journal_get_write_access(handle_t *handle,
				struct buffer_head *bh)
828
{
829 830 831
	int dirty = buffer_dirty(bh);
	int ret;

832 833
	if (!buffer_mapped(bh) || buffer_freed(bh))
		return 0;
834
	/*
C
Christoph Hellwig 已提交
835
	 * __block_write_begin() could have dirtied some buffers. Clean
836 837
	 * the dirty bit as jbd2_journal_get_write_access() could complain
	 * otherwise about fs integrity issues. Setting of the dirty bit
C
Christoph Hellwig 已提交
838
	 * by __block_write_begin() isn't a real problem here as we clear
839 840 841 842 843 844 845 846 847
	 * 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;
848 849
}

850 851
static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
		   struct buffer_head *bh_result, int create);
N
Nick Piggin 已提交
852
static int ext4_write_begin(struct file *file, struct address_space *mapping,
853 854
			    loff_t pos, unsigned len, unsigned flags,
			    struct page **pagep, void **fsdata)
855
{
856
	struct inode *inode = mapping->host;
857
	int ret, needed_blocks;
858 859
	handle_t *handle;
	int retries = 0;
860
	struct page *page;
861
	pgoff_t index;
862
	unsigned from, to;
N
Nick Piggin 已提交
863

864
	trace_ext4_write_begin(inode, pos, len, flags);
865 866 867 868 869
	/*
	 * 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;
870
	index = pos >> PAGE_CACHE_SHIFT;
871 872
	from = pos & (PAGE_CACHE_SIZE - 1);
	to = from + len;
873

874 875 876 877 878 879 880 881 882 883 884
	if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
		ret = ext4_try_to_write_inline_data(mapping, inode, pos, len,
						    flags, pagep);
		if (ret < 0)
			goto out;
		if (ret == 1) {
			ret = 0;
			goto out;
		}
	}

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

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

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

903 904
	*pagep = page;

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

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

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

		ext4_journal_stop(handle);
		if (pos + len > inode->i_size) {
932
			ext4_truncate_failed_write(inode);
933
			/*
934
			 * If truncate failed early the inode might
935 936 937 938 939 940 941
			 * 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 已提交
942 943
	}

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

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

959
static int ext4_generic_write_end(struct file *file,
960 961 962
				  struct address_space *mapping,
				  loff_t pos, unsigned len, unsigned copied,
				  struct page *page, void *fsdata)
963 964 965 966 967
{
	int i_size_changed = 0;
	struct inode *inode = mapping->host;
	handle_t *handle = ext4_journal_current_handle();

968 969 970 971 972 973
	if (ext4_has_inline_data(inode))
		copied = ext4_write_inline_data_end(inode, pos, len,
						    copied, page);
	else
		copied = block_write_end(file, mapping, pos,
					 len, copied, page, fsdata);
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 1002 1003 1004 1005 1006 1007 1008 1009

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

1010 1011 1012 1013
/*
 * 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().
 *
1014
 * ext4 never places buffers on inode->i_mapping->private_list.  metadata
1015 1016
 * buffers are managed internally.
 */
N
Nick Piggin 已提交
1017
static int ext4_ordered_write_end(struct file *file,
1018 1019 1020
				  struct address_space *mapping,
				  loff_t pos, unsigned len, unsigned copied,
				  struct page *page, void *fsdata)
1021
{
1022
	handle_t *handle = ext4_journal_current_handle();
1023
	struct inode *inode = mapping->host;
1024 1025
	int ret = 0, ret2;

1026
	trace_ext4_ordered_write_end(inode, pos, len, copied);
1027
	ret = ext4_jbd2_file_inode(handle, inode);
1028 1029

	if (ret == 0) {
1030
		ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
N
Nick Piggin 已提交
1031
							page, fsdata);
1032
		copied = ret2;
1033
		if (pos + len > inode->i_size && ext4_can_truncate(inode))
1034 1035 1036 1037 1038
			/* 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);
1039 1040
		if (ret2 < 0)
			ret = ret2;
1041 1042 1043
	} else {
		unlock_page(page);
		page_cache_release(page);
1044
	}
1045

1046
	ret2 = ext4_journal_stop(handle);
1047 1048
	if (!ret)
		ret = ret2;
N
Nick Piggin 已提交
1049

1050
	if (pos + len > inode->i_size) {
1051
		ext4_truncate_failed_write(inode);
1052
		/*
1053
		 * If truncate failed early the inode might still be
1054 1055 1056 1057 1058 1059 1060 1061
		 * 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 已提交
1062
	return ret ? ret : copied;
1063 1064
}

N
Nick Piggin 已提交
1065
static int ext4_writeback_write_end(struct file *file,
1066 1067 1068
				    struct address_space *mapping,
				    loff_t pos, unsigned len, unsigned copied,
				    struct page *page, void *fsdata)
1069
{
1070
	handle_t *handle = ext4_journal_current_handle();
1071
	struct inode *inode = mapping->host;
1072 1073
	int ret = 0, ret2;

1074
	trace_ext4_writeback_write_end(inode, pos, len, copied);
1075
	ret2 = ext4_generic_write_end(file, mapping, pos, len, copied,
N
Nick Piggin 已提交
1076
							page, fsdata);
1077
	copied = ret2;
1078
	if (pos + len > inode->i_size && ext4_can_truncate(inode))
1079 1080 1081 1082 1083 1084
		/* 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);

1085 1086
	if (ret2 < 0)
		ret = ret2;
1087

1088
	ret2 = ext4_journal_stop(handle);
1089 1090
	if (!ret)
		ret = ret2;
N
Nick Piggin 已提交
1091

1092
	if (pos + len > inode->i_size) {
1093
		ext4_truncate_failed_write(inode);
1094
		/*
1095
		 * If truncate failed early the inode might still be
1096 1097 1098 1099 1100 1101 1102
		 * 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 已提交
1103
	return ret ? ret : copied;
1104 1105
}

N
Nick Piggin 已提交
1106
static int ext4_journalled_write_end(struct file *file,
1107 1108 1109
				     struct address_space *mapping,
				     loff_t pos, unsigned len, unsigned copied,
				     struct page *page, void *fsdata)
1110
{
1111
	handle_t *handle = ext4_journal_current_handle();
N
Nick Piggin 已提交
1112
	struct inode *inode = mapping->host;
1113 1114
	int ret = 0, ret2;
	int partial = 0;
N
Nick Piggin 已提交
1115
	unsigned from, to;
1116
	loff_t new_i_size;
1117

1118
	trace_ext4_journalled_write_end(inode, pos, len, copied);
N
Nick Piggin 已提交
1119 1120 1121
	from = pos & (PAGE_CACHE_SIZE - 1);
	to = from + len;

1122 1123
	BUG_ON(!ext4_handle_valid(handle));

1124 1125 1126 1127 1128 1129 1130 1131 1132
	if (ext4_has_inline_data(inode))
		copied = ext4_write_inline_data_end(inode, pos, len,
						    copied, page);
	else {
		if (copied < len) {
			if (!PageUptodate(page))
				copied = 0;
			page_zero_new_buffers(page, from+copied, to);
		}
1133

1134 1135 1136 1137 1138
		ret = ext4_walk_page_buffers(handle, page_buffers(page), from,
					     to, &partial, write_end_fn);
		if (!partial)
			SetPageUptodate(page);
	}
1139 1140
	new_i_size = pos + copied;
	if (new_i_size > inode->i_size)
N
Nick Piggin 已提交
1141
		i_size_write(inode, pos+copied);
1142
	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
1143
	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1144 1145
	if (new_i_size > EXT4_I(inode)->i_disksize) {
		ext4_update_i_disksize(inode, new_i_size);
1146
		ret2 = ext4_mark_inode_dirty(handle, inode);
1147 1148 1149
		if (!ret)
			ret = ret2;
	}
N
Nick Piggin 已提交
1150

1151
	unlock_page(page);
1152
	page_cache_release(page);
1153
	if (pos + len > inode->i_size && ext4_can_truncate(inode))
1154 1155 1156 1157 1158 1159
		/* 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);

1160
	ret2 = ext4_journal_stop(handle);
1161 1162
	if (!ret)
		ret = ret2;
1163
	if (pos + len > inode->i_size) {
1164
		ext4_truncate_failed_write(inode);
1165
		/*
1166
		 * If truncate failed early the inode might still be
1167 1168 1169 1170 1171 1172
		 * 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 已提交
1173 1174

	return ret ? ret : copied;
1175
}
1176

1177
/*
1178
 * Reserve a single cluster located at lblock
1179
 */
1180
static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock)
1181
{
A
Aneesh Kumar K.V 已提交
1182
	int retries = 0;
1183
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1184
	struct ext4_inode_info *ei = EXT4_I(inode);
1185
	unsigned int md_needed;
1186
	int ret;
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197
	ext4_lblk_t save_last_lblock;
	int save_len;

	/*
	 * 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.
	 */
	ret = dquot_reserve_block(inode, EXT4_C2B(sbi, 1));
	if (ret)
		return ret;
1198 1199 1200 1201 1202 1203

	/*
	 * 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 已提交
1204
repeat:
1205
	spin_lock(&ei->i_block_reservation_lock);
1206 1207 1208 1209 1210 1211
	/*
	 * ext4_calc_metadata_amount() has side effects, which we have
	 * to be prepared undo if we fail to claim space.
	 */
	save_len = ei->i_da_metadata_calc_len;
	save_last_lblock = ei->i_da_metadata_calc_last_lblock;
1212 1213
	md_needed = EXT4_NUM_B2C(sbi,
				 ext4_calc_metadata_amount(inode, lblock));
1214
	trace_ext4_da_reserve_space(inode, md_needed);
1215

1216 1217 1218 1219
	/*
	 * We do still charge estimated metadata to the sb though;
	 * we cannot afford to run out of free blocks.
	 */
1220
	if (ext4_claim_free_clusters(sbi, md_needed + 1, 0)) {
1221 1222 1223
		ei->i_da_metadata_calc_len = save_len;
		ei->i_da_metadata_calc_last_lblock = save_last_lblock;
		spin_unlock(&ei->i_block_reservation_lock);
A
Aneesh Kumar K.V 已提交
1224 1225 1226 1227
		if (ext4_should_retry_alloc(inode->i_sb, &retries)) {
			yield();
			goto repeat;
		}
1228
		dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1));
1229 1230
		return -ENOSPC;
	}
1231
	ei->i_reserved_data_blocks++;
1232 1233
	ei->i_reserved_meta_blocks += md_needed;
	spin_unlock(&ei->i_block_reservation_lock);
1234

1235 1236 1237
	return 0;       /* success */
}

1238
static void ext4_da_release_space(struct inode *inode, int to_free)
1239 1240
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1241
	struct ext4_inode_info *ei = EXT4_I(inode);
1242

1243 1244 1245
	if (!to_free)
		return;		/* Nothing to release, exit */

1246
	spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1247

L
Li Zefan 已提交
1248
	trace_ext4_da_release_space(inode, to_free);
1249
	if (unlikely(to_free > ei->i_reserved_data_blocks)) {
1250
		/*
1251 1252 1253 1254
		 * 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.
1255
		 */
1256 1257
		ext4_msg(inode->i_sb, KERN_NOTICE, "ext4_da_release_space: "
			 "ino %lu, to_free %d with only %d reserved "
1258
			 "data blocks", inode->i_ino, to_free,
1259 1260 1261
			 ei->i_reserved_data_blocks);
		WARN_ON(1);
		to_free = ei->i_reserved_data_blocks;
1262
	}
1263
	ei->i_reserved_data_blocks -= to_free;
1264

1265 1266 1267 1268 1269
	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.
1270 1271
		 * Note that in case of bigalloc, i_reserved_meta_blocks,
		 * i_reserved_data_blocks, etc. refer to number of clusters.
1272
		 */
1273
		percpu_counter_sub(&sbi->s_dirtyclusters_counter,
1274
				   ei->i_reserved_meta_blocks);
1275
		ei->i_reserved_meta_blocks = 0;
1276
		ei->i_da_metadata_calc_len = 0;
1277
	}
1278

1279
	/* update fs dirty data blocks counter */
1280
	percpu_counter_sub(&sbi->s_dirtyclusters_counter, to_free);
1281 1282

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

1284
	dquot_release_reservation_block(inode, EXT4_C2B(sbi, to_free));
1285 1286 1287
}

static void ext4_da_page_release_reservation(struct page *page,
1288
					     unsigned long offset)
1289 1290 1291 1292
{
	int to_release = 0;
	struct buffer_head *head, *bh;
	unsigned int curr_off = 0;
1293 1294 1295
	struct inode *inode = page->mapping->host;
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	int num_clusters;
1296
	ext4_fsblk_t lblk;
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308

	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);
		}
		curr_off = next_off;
	} while ((bh = bh->b_this_page) != head);
1309

1310 1311 1312 1313 1314
	if (to_release) {
		lblk = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
		ext4_es_remove_extent(inode, lblk, to_release);
	}

1315 1316 1317 1318 1319 1320 1321
	/* 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) {
		lblk = (page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits)) +
			((num_clusters - 1) << sbi->s_cluster_bits);
		if (sbi->s_cluster_ratio == 1 ||
1322
		    !ext4_find_delalloc_cluster(inode, lblk))
1323 1324 1325 1326
			ext4_da_release_space(inode, 1);

		num_clusters--;
	}
1327
}
1328

1329 1330 1331 1332 1333 1334
/*
 * Delayed allocation stuff
 */

/*
 * mpage_da_submit_io - walks through extent of pages and try to write
1335
 * them with writepage() call back
1336 1337 1338 1339 1340 1341 1342 1343 1344 1345
 *
 * @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
 */
1346 1347
static int mpage_da_submit_io(struct mpage_da_data *mpd,
			      struct ext4_map_blocks *map)
1348
{
1349 1350 1351 1352 1353
	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;
1354
	loff_t size = i_size_read(inode);
1355 1356
	unsigned int len, block_start;
	struct buffer_head *bh, *page_bufs = NULL;
1357
	int journal_data = ext4_should_journal_data(inode);
1358
	sector_t pblock = 0, cur_logical = 0;
1359
	struct ext4_io_submit io_submit;
1360 1361

	BUG_ON(mpd->next_page <= mpd->first_page);
1362
	memset(&io_submit, 0, sizeof(io_submit));
1363 1364 1365
	/*
	 * We need to start from the first_page to the next_page - 1
	 * to make sure we also write the mapped dirty buffer_heads.
1366
	 * If we look at mpd->b_blocknr we would only be looking
1367 1368
	 * at the currently mapped buffer_heads.
	 */
1369 1370 1371
	index = mpd->first_page;
	end = mpd->next_page - 1;

1372
	pagevec_init(&pvec, 0);
1373
	while (index <= end) {
1374
		nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
1375 1376 1377
		if (nr_pages == 0)
			break;
		for (i = 0; i < nr_pages; i++) {
1378
			int commit_write = 0, skip_page = 0;
1379 1380
			struct page *page = pvec.pages[i];

1381 1382 1383
			index = page->index;
			if (index > end)
				break;
1384 1385 1386 1387 1388

			if (index == size >> PAGE_CACHE_SHIFT)
				len = size & ~PAGE_CACHE_MASK;
			else
				len = PAGE_CACHE_SIZE;
1389 1390 1391 1392 1393 1394
			if (map) {
				cur_logical = index << (PAGE_CACHE_SHIFT -
							inode->i_blkbits);
				pblock = map->m_pblk + (cur_logical -
							map->m_lblk);
			}
1395 1396 1397 1398 1399
			index++;

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

1400
			/*
1401 1402
			 * If the page does not have buffers (for
			 * whatever reason), try to create them using
1403
			 * __block_write_begin.  If this fails,
1404
			 * skip the page and move on.
1405
			 */
1406
			if (!page_has_buffers(page)) {
1407
				if (__block_write_begin(page, 0, len,
1408
						noalloc_get_block_write)) {
1409
				skip_page:
1410 1411 1412 1413 1414
					unlock_page(page);
					continue;
				}
				commit_write = 1;
			}
1415

1416 1417
			bh = page_bufs = page_buffers(page);
			block_start = 0;
1418
			do {
1419
				if (!bh)
1420
					goto skip_page;
1421 1422 1423
				if (map && (cur_logical >= map->m_lblk) &&
				    (cur_logical <= (map->m_lblk +
						     (map->m_len - 1)))) {
1424 1425 1426 1427
					if (buffer_delay(bh)) {
						clear_buffer_delay(bh);
						bh->b_blocknr = pblock;
					}
1428 1429 1430 1431 1432 1433 1434
					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);
				}
1435

1436 1437 1438 1439 1440
				/*
				 * skip page if block allocation undone and
				 * block is dirty
				 */
				if (ext4_bh_delay_or_unwritten(NULL, bh))
1441
					skip_page = 1;
1442 1443
				bh = bh->b_this_page;
				block_start += bh->b_size;
1444 1445
				cur_logical++;
				pblock++;
1446 1447
			} while (bh != page_bufs);

1448 1449
			if (skip_page)
				goto skip_page;
1450 1451 1452 1453 1454

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

1455
			clear_page_dirty_for_io(page);
1456 1457 1458 1459 1460 1461
			/*
			 * Delalloc doesn't support data journalling,
			 * but eventually maybe we'll lift this
			 * restriction.
			 */
			if (unlikely(journal_data && PageChecked(page)))
1462
				err = __ext4_journalled_writepage(page, len);
1463
			else
1464 1465
				err = ext4_bio_write_page(&io_submit, page,
							  len, mpd->wbc);
1466
			if (!err)
1467
				mpd->pages_written++;
1468 1469 1470 1471 1472 1473 1474 1475 1476
			/*
			 * In error case, we have to continue because
			 * remaining pages are still locked
			 */
			if (ret == 0)
				ret = err;
		}
		pagevec_release(&pvec);
	}
1477
	ext4_io_submit(&io_submit);
1478 1479 1480
	return ret;
}

1481
static void ext4_da_block_invalidatepages(struct mpage_da_data *mpd)
1482 1483 1484 1485 1486 1487
{
	int nr_pages, i;
	pgoff_t index, end;
	struct pagevec pvec;
	struct inode *inode = mpd->inode;
	struct address_space *mapping = inode->i_mapping;
1488
	ext4_lblk_t start, last;
1489

1490 1491
	index = mpd->first_page;
	end   = mpd->next_page - 1;
1492 1493 1494 1495 1496

	start = index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
	last = end << (PAGE_CACHE_SHIFT - inode->i_blkbits);
	ext4_es_remove_extent(inode, start, last - start + 1);

1497
	pagevec_init(&pvec, 0);
1498 1499 1500 1501 1502 1503
	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];
1504
			if (page->index > end)
1505 1506 1507 1508 1509 1510 1511
				break;
			BUG_ON(!PageLocked(page));
			BUG_ON(PageWriteback(page));
			block_invalidatepage(page, 0);
			ClearPageUptodate(page);
			unlock_page(page);
		}
1512 1513
		index = pvec.pages[nr_pages - 1]->index + 1;
		pagevec_release(&pvec);
1514 1515 1516 1517
	}
	return;
}

1518 1519 1520
static void ext4_print_free_blocks(struct inode *inode)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1521 1522 1523
	struct super_block *sb = inode->i_sb;

	ext4_msg(sb, KERN_CRIT, "Total free blocks count %lld",
1524 1525
	       EXT4_C2B(EXT4_SB(inode->i_sb),
			ext4_count_free_clusters(inode->i_sb)));
1526 1527
	ext4_msg(sb, KERN_CRIT, "Free/Dirty block details");
	ext4_msg(sb, KERN_CRIT, "free_blocks=%lld",
1528 1529
	       (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
		percpu_counter_sum(&sbi->s_freeclusters_counter)));
1530
	ext4_msg(sb, KERN_CRIT, "dirty_blocks=%lld",
1531 1532
	       (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
		percpu_counter_sum(&sbi->s_dirtyclusters_counter)));
1533 1534 1535 1536
	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",
1537
	       EXT4_I(inode)->i_reserved_meta_blocks);
1538 1539 1540
	return;
}

1541
/*
1542 1543
 * mpage_da_map_and_submit - go through given space, map them
 *       if necessary, and then submit them for I/O
1544
 *
1545
 * @mpd - bh describing space
1546 1547 1548 1549
 *
 * The function skips space we know is already mapped to disk blocks.
 *
 */
1550
static void mpage_da_map_and_submit(struct mpage_da_data *mpd)
1551
{
1552
	int err, blks, get_blocks_flags;
1553
	struct ext4_map_blocks map, *mapp = NULL;
1554 1555 1556 1557
	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;
1558 1559

	/*
1560 1561
	 * If the blocks are mapped already, or we couldn't accumulate
	 * any blocks, then proceed immediately to the submission stage.
1562
	 */
1563 1564 1565 1566 1567
	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;
1568 1569 1570 1571

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

1572
	/*
1573
	 * Call ext4_map_blocks() to allocate any delayed allocation
1574 1575 1576 1577 1578 1579 1580 1581
	 * 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
1582
	 * want to change *many* call functions, so ext4_map_blocks()
1583
	 * will set the EXT4_STATE_DELALLOC_RESERVED flag once the
1584 1585 1586 1587 1588
	 * 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.
1589
	 */
1590 1591
	map.m_lblk = next;
	map.m_len = max_blocks;
1592
	get_blocks_flags = EXT4_GET_BLOCKS_CREATE;
1593 1594
	if (ext4_should_dioread_nolock(mpd->inode))
		get_blocks_flags |= EXT4_GET_BLOCKS_IO_CREATE_EXT;
1595
	if (mpd->b_state & (1 << BH_Delay))
1596 1597
		get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE;

1598
	blks = ext4_map_blocks(handle, mpd->inode, &map, get_blocks_flags);
1599
	if (blks < 0) {
1600 1601
		struct super_block *sb = mpd->inode->i_sb;

1602
		err = blks;
1603
		/*
1604
		 * If get block returns EAGAIN or ENOSPC and there
1605 1606
		 * appears to be free blocks we will just let
		 * mpage_da_submit_io() unlock all of the pages.
1607 1608
		 */
		if (err == -EAGAIN)
1609
			goto submit_io;
1610

1611
		if (err == -ENOSPC && ext4_count_free_clusters(sb)) {
1612
			mpd->retval = err;
1613
			goto submit_io;
1614 1615
		}

1616
		/*
1617 1618 1619 1620 1621
		 * 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.
1622
		 */
1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633
		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 已提交
1634
		}
1635
		/* invalidate all the pages */
1636
		ext4_da_block_invalidatepages(mpd);
1637 1638 1639

		/* Mark this page range as having been completed */
		mpd->io_done = 1;
1640
		return;
1641
	}
1642 1643
	BUG_ON(blks == 0);

1644
	mapp = &map;
1645 1646 1647
	if (map.m_flags & EXT4_MAP_NEW) {
		struct block_device *bdev = mpd->inode->i_sb->s_bdev;
		int i;
1648

1649 1650
		for (i = 0; i < map.m_len; i++)
			unmap_underlying_metadata(bdev, map.m_pblk + i);
1651 1652 1653
	}

	/*
1654
	 * Update on-disk size along with block allocation.
1655 1656 1657 1658 1659 1660
	 */
	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);
1661 1662 1663 1664 1665
		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);
1666 1667
	}

1668
submit_io:
1669
	mpage_da_submit_io(mpd, mapp);
1670
	mpd->io_done = 1;
1671 1672
}

1673 1674
#define BH_FLAGS ((1 << BH_Uptodate) | (1 << BH_Mapped) | \
		(1 << BH_Delay) | (1 << BH_Unwritten))
1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685

/*
 * 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,
1686 1687
				   sector_t logical, size_t b_size,
				   unsigned long b_state)
1688 1689
{
	sector_t next;
1690
	int nrblocks = mpd->b_size >> mpd->inode->i_blkbits;
1691

1692 1693 1694 1695
	/*
	 * 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
1696
	 * ext4_map_blocks() multiple times in a loop
1697 1698 1699 1700
	 */
	if (nrblocks >= 8*1024*1024/mpd->inode->i_sb->s_blocksize)
		goto flush_it;

1701
	/* check if thereserved journal credits might overflow */
1702
	if (!(ext4_test_inode_flag(mpd->inode, EXT4_INODE_EXTENTS))) {
1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722
		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 */
		}
	}
1723 1724 1725
	/*
	 * First block in the extent
	 */
1726 1727 1728 1729
	if (mpd->b_size == 0) {
		mpd->b_blocknr = logical;
		mpd->b_size = b_size;
		mpd->b_state = b_state & BH_FLAGS;
1730 1731 1732
		return;
	}

1733
	next = mpd->b_blocknr + nrblocks;
1734 1735 1736
	/*
	 * Can we merge the block to our big extent?
	 */
1737 1738
	if (logical == next && (b_state & BH_FLAGS) == mpd->b_state) {
		mpd->b_size += b_size;
1739 1740 1741
		return;
	}

1742
flush_it:
1743 1744 1745 1746
	/*
	 * We couldn't merge the block to our extent, so we
	 * need to flush current  extent and start new one
	 */
1747
	mpage_da_map_and_submit(mpd);
1748
	return;
1749 1750
}

1751
static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
1752
{
1753
	return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh);
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
/*
 * 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));
1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
	if (ext4_has_inline_data(inode)) {
		/*
		 * We will soon create blocks for this page, and let
		 * us pretend as if the blocks aren't allocated yet.
		 * In case of clusters, we have to handle the work
		 * of mapping from cluster so that the reserved space
		 * is calculated properly.
		 */
		if ((EXT4_SB(inode->i_sb)->s_cluster_ratio > 1) &&
		    ext4_find_delalloc_cluster(inode, map->m_lblk))
			map->m_flags |= EXT4_MAP_FROM_CLUSTER;
		retval = 0;
	} else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811
		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;
		}

1812 1813 1814 1815
		retval = ext4_es_insert_extent(inode, map->m_lblk, map->m_len);
		if (retval)
			goto out_unlock;

1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831
		/* 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;
}

1832
/*
1833 1834 1835
 * 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.
1836 1837 1838 1839 1840 1841 1842
 *
 * 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.
1843
 */
1844 1845
int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int create)
1846
{
1847
	struct ext4_map_blocks map;
1848 1849 1850
	int ret = 0;

	BUG_ON(create == 0);
1851 1852 1853 1854
	BUG_ON(bh->b_size != inode->i_sb->s_blocksize);

	map.m_lblk = iblock;
	map.m_len = 1;
1855 1856 1857 1858 1859 1860

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

1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875
	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);
1876
		set_buffer_mapped(bh);
1877 1878
	}
	return 0;
1879
}
1880

1881
/*
1882 1883 1884 1885
 * 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 callback function for
 * block_write_begin().  These functions should only try to map a single block
 * at a time.
1886 1887 1888 1889 1890
 *
 * 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
1891
 * delayed allocation before calling ext4_bio_write_page().  Otherwise,
1892 1893
 * b_blocknr could be left unitialized, and the page write functions will
 * be taken by surprise.
1894 1895
 */
static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
1896 1897
				   struct buffer_head *bh_result, int create)
{
1898
	BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
1899
	return _ext4_get_block(inode, iblock, bh_result, 0);
1900 1901
}

1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
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;
1919
	struct buffer_head *page_bufs = NULL;
1920
	handle_t *handle = NULL;
1921 1922 1923
	int ret = 0, err = 0;
	int inline_data = ext4_has_inline_data(inode);
	struct buffer_head *inode_bh = NULL;
1924

1925
	ClearPageChecked(page);
1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941

	if (inline_data) {
		BUG_ON(page->index != 0);
		BUG_ON(len > ext4_get_max_inline_size(inode));
		inode_bh = ext4_journalled_write_inline_data(inode, len, page);
		if (inode_bh == NULL)
			goto out;
	} else {
		page_bufs = page_buffers(page);
		if (!page_bufs) {
			BUG();
			goto out;
		}
		ext4_walk_page_buffers(handle, page_bufs, 0, len,
				       NULL, bget_one);
	}
1942 1943 1944 1945 1946 1947 1948 1949 1950 1951
	/* 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;
	}

1952 1953
	BUG_ON(!ext4_handle_valid(handle));

1954 1955
	if (inline_data) {
		ret = ext4_journal_get_write_access(handle, inode_bh);
1956

1957 1958 1959 1960 1961 1962 1963 1964 1965
		err = ext4_handle_dirty_metadata(handle, inode, inode_bh);

	} else {
		ret = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL,
					     do_journal_get_write_access);

		err = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL,
					     write_end_fn);
	}
1966 1967
	if (ret == 0)
		ret = err;
1968
	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1969 1970 1971 1972
	err = ext4_journal_stop(handle);
	if (!ret)
		ret = err;

1973 1974 1975
	if (!ext4_has_inline_data(inode))
		ext4_walk_page_buffers(handle, page_bufs, 0, len,
				       NULL, bput_one);
1976
	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
1977
out:
1978
	brelse(inode_bh);
1979 1980 1981
	return ret;
}

1982
/*
1983 1984 1985 1986
 * 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 已提交
1987
 * we are writing back data modified via mmap(), no one guarantees in which
1988 1989 1990 1991
 * 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.
 *
1992 1993 1994
 * This function can get called via...
 *   - ext4_da_writepages after taking page lock (have journal handle)
 *   - journal_submit_inode_data_buffers (no journal handle)
1995
 *   - shrink_page_list via the kswapd/direct reclaim (no journal handle)
1996
 *   - grab_page_cache when doing write_begin (have journal handle)
1997 1998 1999 2000 2001 2002 2003 2004 2005
 *
 * 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
2006
 * but other buffer_heads would be unmapped but dirty (dirty done via the
2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021
 * 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.
2022
 */
2023
static int ext4_writepage(struct page *page,
2024
			  struct writeback_control *wbc)
2025
{
T
Theodore Ts'o 已提交
2026
	int ret = 0, commit_write = 0;
2027
	loff_t size;
2028
	unsigned int len;
2029
	struct buffer_head *page_bufs = NULL;
2030
	struct inode *inode = page->mapping->host;
2031
	struct ext4_io_submit io_submit;
2032

L
Lukas Czerner 已提交
2033
	trace_ext4_writepage(page);
2034 2035 2036 2037 2038
	size = i_size_read(inode);
	if (page->index == size >> PAGE_CACHE_SHIFT)
		len = size & ~PAGE_CACHE_MASK;
	else
		len = PAGE_CACHE_SIZE;
2039

T
Theodore Ts'o 已提交
2040 2041
	/*
	 * If the page does not have buffers (for whatever reason),
2042
	 * try to create them using __block_write_begin.  If this
T
Theodore Ts'o 已提交
2043 2044
	 * fails, redirty the page and move on.
	 */
2045
	if (!page_has_buffers(page)) {
2046
		if (__block_write_begin(page, 0, len,
T
Theodore Ts'o 已提交
2047 2048
					noalloc_get_block_write)) {
		redirty_page:
2049 2050 2051 2052
			redirty_page_for_writepage(wbc, page);
			unlock_page(page);
			return 0;
		}
T
Theodore Ts'o 已提交
2053 2054 2055
		commit_write = 1;
	}
	page_bufs = page_buffers(page);
2056 2057
	if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL,
				   ext4_bh_delay_or_unwritten)) {
2058
		/*
2059 2060 2061
		 * 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.
2062 2063 2064
		 * We can also reach here via shrink_page_list but it
		 * should never be for direct reclaim so warn if that
		 * happens
2065
		 */
2066 2067
		WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) ==
								PF_MEMALLOC);
T
Theodore Ts'o 已提交
2068 2069 2070
		goto redirty_page;
	}
	if (commit_write)
2071
		/* now mark the buffer_heads as dirty and uptodate */
2072
		block_commit_write(page, 0, len);
2073

2074
	if (PageChecked(page) && ext4_should_journal_data(inode))
2075 2076 2077 2078
		/*
		 * It's mmapped pagecache.  Add buffers and journal it.  There
		 * doesn't seem much point in redirtying the page here.
		 */
2079
		return __ext4_journalled_writepage(page, len);
2080

2081 2082 2083
	memset(&io_submit, 0, sizeof(io_submit));
	ret = ext4_bio_write_page(&io_submit, page, len, wbc);
	ext4_io_submit(&io_submit);
2084 2085 2086
	return ret;
}

2087
/*
2088
 * This is called via ext4_da_writepages() to
L
Lucas De Marchi 已提交
2089
 * calculate the total number of credits to reserve to fit
2090 2091 2092
 * a single extent allocation into a single transaction,
 * ext4_da_writpeages() will loop calling this before
 * the block allocation.
2093
 */
2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104

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
	 */
2105
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) &&
2106 2107 2108 2109 2110
	    (max_blocks > EXT4_MAX_TRANS_DATA))
		max_blocks = EXT4_MAX_TRANS_DATA;

	return ext4_chunk_trans_blocks(inode, max_blocks);
}
2111

2112 2113
/*
 * write_cache_pages_da - walk the list of dirty pages of the given
2114
 * address space and accumulate pages that need writing, and call
2115 2116
 * mpage_da_map_and_submit to map a single contiguous memory region
 * and then write them.
2117
 */
2118 2119
static int write_cache_pages_da(handle_t *handle,
				struct address_space *mapping,
2120
				struct writeback_control *wbc,
2121 2122
				struct mpage_da_data *mpd,
				pgoff_t *done_index)
2123
{
2124
	struct buffer_head	*bh, *head;
2125
	struct inode		*inode = mapping->host;
2126 2127 2128 2129 2130 2131
	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;
2132

2133 2134 2135
	memset(mpd, 0, sizeof(struct mpage_da_data));
	mpd->wbc = wbc;
	mpd->inode = inode;
2136 2137 2138 2139
	pagevec_init(&pvec, 0);
	index = wbc->range_start >> PAGE_CACHE_SHIFT;
	end = wbc->range_end >> PAGE_CACHE_SHIFT;

2140
	if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
2141 2142 2143 2144
		tag = PAGECACHE_TAG_TOWRITE;
	else
		tag = PAGECACHE_TAG_DIRTY;

2145
	*done_index = index;
2146
	while (index <= end) {
2147
		nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
2148 2149
			      min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
		if (nr_pages == 0)
2150
			return 0;
2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161

		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.
			 */
2162 2163
			if (page->index > end)
				goto out;
2164

2165 2166
			*done_index = page->index + 1;

2167 2168 2169 2170 2171 2172 2173 2174 2175 2176
			/*
			 * 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;
			}

2177 2178 2179
			lock_page(page);

			/*
2180 2181 2182 2183 2184 2185
			 * 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
2186
			 */
2187 2188 2189 2190
			if (!PageDirty(page) ||
			    (PageWriteback(page) &&
			     (wbc->sync_mode == WB_SYNC_NONE)) ||
			    unlikely(page->mapping != mapping)) {
2191 2192 2193 2194
				unlock_page(page);
				continue;
			}

2195
			wait_on_page_writeback(page);
2196 2197
			BUG_ON(PageWriteback(page));

2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
			/*
			 * If we have inline data and arrive here, it means that
			 * we will soon create the block for the 1st page, so
			 * we'd better clear the inline data here.
			 */
			if (ext4_has_inline_data(inode)) {
				BUG_ON(ext4_test_inode_state(inode,
						EXT4_STATE_MAY_INLINE_DATA));
				ext4_destroy_inline_data(handle, inode);
			}

2209
			if (mpd->next_page != page->index)
2210 2211 2212 2213 2214 2215
				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)) {
2216 2217
				mpage_add_bh_to_extent(mpd, logical,
						       PAGE_CACHE_SIZE,
2218
						       (1 << BH_Dirty) | (1 << BH_Uptodate));
2219 2220
				if (mpd->io_done)
					goto ret_extent_tail;
2221 2222
			} else {
				/*
2223 2224
				 * Page with regular buffer heads,
				 * just add all dirty ones
2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239
				 */
				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);
2240 2241
						if (mpd->io_done)
							goto ret_extent_tail;
2242 2243
					} else if (buffer_dirty(bh) && (buffer_mapped(bh))) {
						/*
2244 2245 2246 2247 2248 2249 2250 2251 2252
						 * 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.
2253 2254 2255 2256 2257 2258
						 */
						if (mpd->b_size == 0)
							mpd->b_state = bh->b_state & BH_FLAGS;
					}
					logical++;
				} while ((bh = bh->b_this_page) != head);
2259 2260 2261 2262 2263
			}

			if (nr_to_write > 0) {
				nr_to_write--;
				if (nr_to_write == 0 &&
2264
				    wbc->sync_mode == WB_SYNC_NONE)
2265 2266 2267 2268 2269 2270 2271 2272 2273 2274
					/*
					 * 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.
					 */
2275
					goto out;
2276 2277 2278 2279 2280
			}
		}
		pagevec_release(&pvec);
		cond_resched();
	}
2281 2282 2283
	return 0;
ret_extent_tail:
	ret = MPAGE_DA_EXTENT_TAIL;
2284 2285 2286
out:
	pagevec_release(&pvec);
	cond_resched();
2287 2288 2289 2290
	return ret;
}


2291
static int ext4_da_writepages(struct address_space *mapping,
2292
			      struct writeback_control *wbc)
2293
{
2294 2295
	pgoff_t	index;
	int range_whole = 0;
2296
	handle_t *handle = NULL;
2297
	struct mpage_da_data mpd;
2298
	struct inode *inode = mapping->host;
2299
	int pages_written = 0;
2300
	unsigned int max_pages;
2301
	int range_cyclic, cycled = 1, io_done = 0;
2302 2303
	int needed_blocks, ret = 0;
	long desired_nr_to_write, nr_to_writebump = 0;
2304
	loff_t range_start = wbc->range_start;
2305
	struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
2306
	pgoff_t done_index = 0;
2307
	pgoff_t end;
S
Shaohua Li 已提交
2308
	struct blk_plug plug;
2309

2310
	trace_ext4_da_writepages(inode, wbc);
2311

2312 2313 2314 2315 2316
	/*
	 * 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
	 */
2317
	if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2318
		return 0;
2319 2320 2321 2322 2323

	/*
	 * 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
2324
	 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2325 2326 2327 2328 2329
	 * 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.
	 */
2330
	if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED))
2331 2332
		return -EROFS;

2333 2334
	if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
		range_whole = 1;
2335

2336 2337
	range_cyclic = wbc->range_cyclic;
	if (wbc->range_cyclic) {
2338
		index = mapping->writeback_index;
2339 2340 2341 2342 2343
		if (index)
			cycled = 0;
		wbc->range_start = index << PAGE_CACHE_SHIFT;
		wbc->range_end  = LLONG_MAX;
		wbc->range_cyclic = 0;
2344 2345
		end = -1;
	} else {
2346
		index = wbc->range_start >> PAGE_CACHE_SHIFT;
2347 2348
		end = wbc->range_end >> PAGE_CACHE_SHIFT;
	}
2349

2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366
	/*
	 * 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);
2367 2368 2369 2370 2371 2372
	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
2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
		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;
	}

2383
retry:
2384
	if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
2385 2386
		tag_pages_for_writeback(mapping, index, end);

S
Shaohua Li 已提交
2387
	blk_start_plug(&plug);
2388
	while (!ret && wbc->nr_to_write > 0) {
2389 2390 2391 2392 2393 2394 2395 2396

		/*
		 * 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));
2397
		needed_blocks = ext4_da_writepages_trans_blocks(inode);
2398

2399 2400 2401 2402
		/* start a new transaction*/
		handle = ext4_journal_start(inode, needed_blocks);
		if (IS_ERR(handle)) {
			ret = PTR_ERR(handle);
2403
			ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
2404
			       "%ld pages, ino %lu; err %d", __func__,
2405
				wbc->nr_to_write, inode->i_ino, ret);
2406
			blk_finish_plug(&plug);
2407 2408
			goto out_writepages;
		}
2409 2410

		/*
2411
		 * Now call write_cache_pages_da() to find the next
2412
		 * contiguous region of logical blocks that need
2413
		 * blocks to be allocated by ext4 and submit them.
2414
		 */
2415 2416
		ret = write_cache_pages_da(handle, mapping,
					   wbc, &mpd, &done_index);
2417
		/*
2418
		 * If we have a contiguous extent of pages and we
2419 2420 2421 2422
		 * 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) {
2423
			mpage_da_map_and_submit(&mpd);
2424 2425
			ret = MPAGE_DA_EXTENT_TAIL;
		}
2426
		trace_ext4_da_write_pages(inode, &mpd);
2427
		wbc->nr_to_write -= mpd.pages_written;
2428

2429
		ext4_journal_stop(handle);
2430

2431
		if ((mpd.retval == -ENOSPC) && sbi->s_journal) {
2432 2433 2434 2435
			/* commit the transaction which would
			 * free blocks released in the transaction
			 * and try again
			 */
2436
			jbd2_journal_force_commit_nested(sbi->s_journal);
2437 2438
			ret = 0;
		} else if (ret == MPAGE_DA_EXTENT_TAIL) {
2439
			/*
2440 2441 2442
			 * 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.
2443
			 */
2444
			pages_written += mpd.pages_written;
2445
			ret = mpd.retval;
2446
			io_done = 1;
2447
		} else if (wbc->nr_to_write)
2448 2449 2450 2451 2452 2453
			/*
			 * There is no more writeout needed
			 * or we requested for a noblocking writeout
			 * and we found the device congested
			 */
			break;
2454
	}
S
Shaohua Li 已提交
2455
	blk_finish_plug(&plug);
2456 2457 2458 2459 2460 2461 2462
	if (!io_done && !cycled) {
		cycled = 1;
		index = 0;
		wbc->range_start = index << PAGE_CACHE_SHIFT;
		wbc->range_end  = mapping->writeback_index - 1;
		goto retry;
	}
2463 2464

	/* Update index */
2465
	wbc->range_cyclic = range_cyclic;
2466 2467 2468 2469 2470
	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
		 */
2471
		mapping->writeback_index = done_index;
2472

2473
out_writepages:
2474
	wbc->nr_to_write -= nr_to_writebump;
2475
	wbc->range_start = range_start;
2476
	trace_ext4_da_writepages_result(inode, wbc, ret, pages_written);
2477
	return ret;
2478 2479
}

2480 2481 2482 2483 2484 2485 2486 2487
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
2488
	 * counters can get slightly wrong with percpu_counter_batch getting
2489 2490 2491 2492
	 * 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.
	 */
2493 2494 2495
	free_blocks  = EXT4_C2B(sbi,
		percpu_counter_read_positive(&sbi->s_freeclusters_counter));
	dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);
2496 2497 2498 2499 2500 2501 2502 2503 2504 2505
	/*
	 * Start pushing delalloc when 1/2 of free blocks are dirty.
	 */
	if (dirty_blocks && (free_blocks < 2 * dirty_blocks) &&
	    !writeback_in_progress(sb->s_bdi) &&
	    down_read_trylock(&sb->s_umount)) {
		writeback_inodes_sb(sb, WB_REASON_FS_FREE_SPACE);
		up_read(&sb->s_umount);
	}

2506
	if (2 * free_blocks < 3 * dirty_blocks ||
2507
		free_blocks < (dirty_blocks + EXT4_FREECLUSTERS_WATERMARK)) {
2508
		/*
2509 2510
		 * free block count is less than 150% of dirty blocks
		 * or free blocks is less than watermark
2511 2512 2513 2514 2515 2516
		 */
		return 1;
	}
	return 0;
}

2517
static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
2518 2519
			       loff_t pos, unsigned len, unsigned flags,
			       struct page **pagep, void **fsdata)
2520
{
2521
	int ret, retries = 0;
2522 2523 2524 2525 2526 2527
	struct page *page;
	pgoff_t index;
	struct inode *inode = mapping->host;
	handle_t *handle;

	index = pos >> PAGE_CACHE_SHIFT;
2528 2529 2530 2531 2532 2533 2534

	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;
2535
	trace_ext4_da_write_begin(inode, pos, len, flags);
2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548

	if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
		ret = ext4_da_write_inline_data_begin(mapping, inode,
						      pos, len, flags,
						      pagep, fsdata);
		if (ret < 0)
			goto out;
		if (ret == 1) {
			ret = 0;
			goto out;
		}
	}

2549
retry:
2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
	/*
	 * 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;
	}
2561 2562 2563
	/* We cannot recurse into the filesystem as the transaction is already
	 * started */
	flags |= AOP_FLAG_NOFS;
2564

2565
	page = grab_cache_page_write_begin(mapping, index, flags);
2566 2567 2568 2569 2570
	if (!page) {
		ext4_journal_stop(handle);
		ret = -ENOMEM;
		goto out;
	}
2571 2572
	*pagep = page;

2573
	ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep);
2574 2575 2576 2577
	if (ret < 0) {
		unlock_page(page);
		ext4_journal_stop(handle);
		page_cache_release(page);
2578 2579 2580 2581 2582 2583
		/*
		 * 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)
2584
			ext4_truncate_failed_write(inode);
2585 2586
	}

2587 2588
	if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
		goto retry;
2589 2590 2591 2592
out:
	return ret;
}

2593 2594 2595 2596 2597
/*
 * 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,
2598
					    unsigned long offset)
2599 2600 2601 2602 2603 2604 2605 2606 2607
{
	struct buffer_head *bh;
	struct inode *inode = page->mapping->host;
	unsigned int idx;
	int i;

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

2608
	for (i = 0; i < idx; i++)
2609 2610
		bh = bh->b_this_page;

2611
	if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
2612 2613 2614 2615
		return 0;
	return 1;
}

2616
static int ext4_da_write_end(struct file *file,
2617 2618 2619
			     struct address_space *mapping,
			     loff_t pos, unsigned len, unsigned copied,
			     struct page *page, void *fsdata)
2620 2621 2622 2623 2624
{
	struct inode *inode = mapping->host;
	int ret = 0, ret2;
	handle_t *handle = ext4_journal_current_handle();
	loff_t new_i_size;
2625
	unsigned long start, end;
2626 2627 2628
	int write_mode = (int)(unsigned long)fsdata;

	if (write_mode == FALL_BACK_TO_NONDELALLOC) {
2629 2630
		switch (ext4_inode_journal_mode(inode)) {
		case EXT4_INODE_ORDERED_DATA_MODE:
2631 2632
			return ext4_ordered_write_end(file, mapping, pos,
					len, copied, page, fsdata);
2633
		case EXT4_INODE_WRITEBACK_DATA_MODE:
2634 2635
			return ext4_writeback_write_end(file, mapping, pos,
					len, copied, page, fsdata);
2636
		default:
2637 2638 2639
			BUG();
		}
	}
2640

2641
	trace_ext4_da_write_end(inode, pos, len, copied);
2642
	start = pos & (PAGE_CACHE_SIZE - 1);
2643
	end = start + copied - 1;
2644 2645 2646 2647 2648 2649 2650

	/*
	 * 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;
2651
	if (copied && new_i_size > EXT4_I(inode)->i_disksize) {
2652 2653
		if (ext4_has_inline_data(inode) ||
		    ext4_da_should_update_i_disksize(page, end)) {
2654
			down_write(&EXT4_I(inode)->i_data_sem);
2655
			if (new_i_size > EXT4_I(inode)->i_disksize)
2656 2657
				EXT4_I(inode)->i_disksize = new_i_size;
			up_write(&EXT4_I(inode)->i_data_sem);
2658 2659 2660 2661 2662
			/* 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);
2663
		}
2664
	}
2665 2666 2667 2668 2669 2670 2671 2672

	if (write_mode != CONVERT_INLINE_DATA &&
	    ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA) &&
	    ext4_has_inline_data(inode))
		ret2 = ext4_da_write_inline_data_end(inode, pos, len, copied,
						     page);
	else
		ret2 = generic_write_end(file, mapping, pos, len, copied,
2673
							page, fsdata);
2674

2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693
	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;

2694
	ext4_da_page_release_reservation(page, offset);
2695 2696 2697 2698 2699 2700 2701

out:
	ext4_invalidatepage(page, offset);

	return;
}

2702 2703 2704 2705 2706
/*
 * Force all delayed allocation blocks to be allocated for a given inode.
 */
int ext4_alloc_da_blocks(struct inode *inode)
{
2707 2708
	trace_ext4_alloc_da_blocks(inode);

2709 2710 2711 2712 2713 2714 2715 2716 2717 2718
	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:
2719
	 *
2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731
	 * 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
2732
	 * the pages by calling redirty_page_for_writepage() but that
2733 2734
	 * 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 已提交
2735
	 * simplifying them because we wouldn't actually intend to
2736 2737 2738
	 * 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.
2739
	 *
2740 2741 2742 2743 2744 2745
	 * 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);
}
2746

2747 2748 2749 2750 2751
/*
 * 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
2752
 * journal.  If somebody makes a swapfile on an ext4 data-journaling
2753 2754 2755 2756 2757 2758 2759 2760
 * 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.
 */
2761
static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
2762 2763 2764 2765 2766
{
	struct inode *inode = mapping->host;
	journal_t *journal;
	int err;

T
Tao Ma 已提交
2767 2768 2769 2770 2771 2772
	/*
	 * We can get here for an inline file via the FIBMAP ioctl
	 */
	if (ext4_has_inline_data(inode))
		return 0;

2773 2774 2775 2776 2777 2778 2779 2780 2781 2782
	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);
	}

2783 2784
	if (EXT4_JOURNAL(inode) &&
	    ext4_test_inode_state(inode, EXT4_STATE_JDATA)) {
2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795
		/*
		 * 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.)
		 *
2796
		 * NB. EXT4_STATE_JDATA is not set on files other than
2797 2798 2799 2800 2801 2802
		 * 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.
		 */

2803
		ext4_clear_inode_state(inode, EXT4_STATE_JDATA);
2804
		journal = EXT4_JOURNAL(inode);
2805 2806 2807
		jbd2_journal_lock_updates(journal);
		err = jbd2_journal_flush(journal);
		jbd2_journal_unlock_updates(journal);
2808 2809 2810 2811 2812

		if (err)
			return 0;
	}

2813
	return generic_block_bmap(mapping, block, ext4_get_block);
2814 2815
}

2816
static int ext4_readpage(struct file *file, struct page *page)
2817
{
T
Tao Ma 已提交
2818 2819 2820
	int ret = -EAGAIN;
	struct inode *inode = page->mapping->host;

2821
	trace_ext4_readpage(page);
T
Tao Ma 已提交
2822 2823 2824 2825 2826 2827 2828 2829

	if (ext4_has_inline_data(inode))
		ret = ext4_readpage_inline(inode, page);

	if (ret == -EAGAIN)
		return mpage_readpage(page, ext4_get_block);

	return ret;
2830 2831 2832
}

static int
2833
ext4_readpages(struct file *file, struct address_space *mapping,
2834 2835
		struct list_head *pages, unsigned nr_pages)
{
T
Tao Ma 已提交
2836 2837 2838 2839 2840 2841
	struct inode *inode = mapping->host;

	/* If the file has inline data, no need to do readpages. */
	if (ext4_has_inline_data(inode))
		return 0;

2842
	return mpage_readpages(mapping, pages, nr_pages, ext4_get_block);
2843 2844
}

2845
static void ext4_invalidatepage(struct page *page, unsigned long offset)
2846
{
2847 2848
	trace_ext4_invalidatepage(page, offset);

2849 2850 2851 2852 2853 2854
	/* No journalling happens on data buffers when this function is used */
	WARN_ON(page_has_buffers(page) && buffer_jbd(page_buffers(page)));

	block_invalidatepage(page, offset);
}

2855 2856
static int __ext4_journalled_invalidatepage(struct page *page,
					    unsigned long offset)
2857 2858 2859 2860 2861
{
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);

	trace_ext4_journalled_invalidatepage(page, offset);

2862 2863 2864 2865 2866 2867
	/*
	 * If it's a full truncate we just forget about the pending dirtying
	 */
	if (offset == 0)
		ClearPageChecked(page);

2868 2869 2870 2871 2872 2873 2874 2875
	return jbd2_journal_invalidatepage(journal, page, offset);
}

/* Wrapper for aops... */
static void ext4_journalled_invalidatepage(struct page *page,
					   unsigned long offset)
{
	WARN_ON(__ext4_journalled_invalidatepage(page, offset) < 0);
2876 2877
}

2878
static int ext4_releasepage(struct page *page, gfp_t wait)
2879
{
2880
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);
2881

2882 2883
	trace_ext4_releasepage(page);

2884 2885 2886
	WARN_ON(PageChecked(page));
	if (!page_has_buffers(page))
		return 0;
2887 2888 2889 2890
	if (journal)
		return jbd2_journal_try_to_free_buffers(journal, page, wait);
	else
		return try_to_free_buffers(page);
2891 2892
}

2893 2894 2895 2896 2897
/*
 * 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.
 */
2898
int ext4_get_block_write(struct inode *inode, sector_t iblock,
2899 2900
		   struct buffer_head *bh_result, int create)
{
2901
	ext4_debug("ext4_get_block_write: inode %lu, create flag %d\n",
2902
		   inode->i_ino, create);
2903 2904
	return _ext4_get_block(inode, iblock, bh_result,
			       EXT4_GET_BLOCKS_IO_CREATE_EXT);
2905 2906
}

2907
static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
2908
		   struct buffer_head *bh_result, int create)
2909
{
2910 2911 2912 2913
	ext4_debug("ext4_get_block_write_nolock: inode %lu, create flag %d\n",
		   inode->i_ino, create);
	return _ext4_get_block(inode, iblock, bh_result,
			       EXT4_GET_BLOCKS_NO_LOCK);
2914 2915
}

2916
static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
2917 2918
			    ssize_t size, void *private, int ret,
			    bool is_async)
2919
{
2920
	struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
2921 2922
        ext4_io_end_t *io_end = iocb->private;

2923 2924
	/* if not async direct IO or dio with 0 bytes write, just return */
	if (!io_end || !size)
2925
		goto out;
2926

2927
	ext_debug("ext4_end_io_dio(): io_end 0x%p "
2928
		  "for inode %lu, iocb 0x%p, offset %llu, size %zd\n",
2929 2930 2931
 		  iocb->private, io_end->inode->i_ino, iocb, offset,
		  size);

2932 2933
	iocb->private = NULL;

2934
	/* if not aio dio with unwritten extents, just free io and return */
2935
	if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) {
2936
		ext4_free_io_end(io_end);
2937 2938 2939
out:
		if (is_async)
			aio_complete(iocb, ret, 0);
2940
		inode_dio_done(inode);
2941
		return;
2942 2943
	}

2944 2945
	io_end->offset = offset;
	io_end->size = size;
2946 2947 2948 2949
	if (is_async) {
		io_end->iocb = iocb;
		io_end->result = ret;
	}
2950

2951
	ext4_add_complete_io(io_end);
2952
}
2953

2954 2955 2956 2957 2958
/*
 * 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.
 *
2959
 * For holes, we fallocate those blocks, mark them as uninitialized
2960
 * If those blocks were preallocated, we mark sure they are split, but
2961
 * still keep the range to write as uninitialized.
2962
 *
2963
 * The unwritten extents will be converted to written when DIO is completed.
2964
 * For async direct IO, since the IO may still pending when return, we
L
Lucas De Marchi 已提交
2965
 * set up an end_io call back function, which will do the conversion
2966
 * when async direct IO completed.
2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980
 *
 * 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);
2981 2982 2983
	int overwrite = 0;
	get_block_t *get_block_func = NULL;
	int dio_flags = 0;
2984
	loff_t final_size = offset + count;
2985

2986 2987 2988
	/* Use the old path for reads and writes beyond i_size. */
	if (rw != WRITE || final_size > inode->i_size)
		return ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
2989

2990
	BUG_ON(iocb->private == NULL);
2991

2992 2993
	/* If we do a overwrite dio, i_mutex locking can be released */
	overwrite = *((int *)iocb->private);
2994

2995 2996 2997 2998 2999
	if (overwrite) {
		atomic_inc(&inode->i_dio_count);
		down_read(&EXT4_I(inode)->i_data_sem);
		mutex_unlock(&inode->i_mutex);
	}
3000

3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026
	/*
	 * We could direct write to holes and fallocate.
	 *
	 * Allocated blocks to fill the hole are marked as
	 * uninitialized to prevent parallel buffered read to expose
	 * the stale data before DIO complete the data IO.
	 *
	 * As to previously fallocated extents, ext4 get_block will
	 * just simply mark the buffer mapped but still keep the
	 * extents uninitialized.
	 *
	 * 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 deferred 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.
	 */
	iocb->private = NULL;
	ext4_inode_aio_set(inode, NULL);
	if (!is_sync_kiocb(iocb)) {
		ext4_io_end_t *io_end = ext4_init_io_end(inode, GFP_NOFS);
		if (!io_end) {
			ret = -ENOMEM;
			goto retake_lock;
3027
		}
3028 3029
		io_end->flag |= EXT4_IO_END_DIRECT;
		iocb->private = io_end;
3030
		/*
3031 3032 3033 3034
		 * we save the io structure for current async direct
		 * IO, so that later ext4_map_blocks() could flag the
		 * io structure whether there is a unwritten extents
		 * needs to be converted when IO is completed.
3035
		 */
3036 3037
		ext4_inode_aio_set(inode, io_end);
	}
3038

3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084
	if (overwrite) {
		get_block_func = ext4_get_block_write_nolock;
	} else {
		get_block_func = ext4_get_block_write;
		dio_flags = DIO_LOCKING;
	}
	ret = __blockdev_direct_IO(rw, iocb, inode,
				   inode->i_sb->s_bdev, iov,
				   offset, nr_segs,
				   get_block_func,
				   ext4_end_io_dio,
				   NULL,
				   dio_flags);

	if (iocb->private)
		ext4_inode_aio_set(inode, 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 destroyed 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;
	} else if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
						EXT4_STATE_DIO_UNWRITTEN)) {
		int err;
		/*
		 * for non AIO case, since the IO is already
		 * completed, we could do the conversion right here
		 */
		err = ext4_convert_unwritten_extents(inode,
						     offset, ret);
		if (err < 0)
			ret = err;
		ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
	}
3085

3086 3087 3088 3089 3090 3091
retake_lock:
	/* take i_mutex locking again if we do a ovewrite dio */
	if (overwrite) {
		inode_dio_done(inode);
		up_read(&EXT4_I(inode)->i_data_sem);
		mutex_lock(&inode->i_mutex);
3092
	}
3093

3094
	return ret;
3095 3096 3097 3098 3099 3100 3101 3102
}

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;
3103
	ssize_t ret;
3104

3105 3106 3107 3108 3109 3110
	/*
	 * If we are doing data journalling we don't support O_DIRECT
	 */
	if (ext4_should_journal_data(inode))
		return 0;

T
Tao Ma 已提交
3111 3112 3113 3114
	/* Let buffer I/O handle the inline data case. */
	if (ext4_has_inline_data(inode))
		return 0;

3115
	trace_ext4_direct_IO_enter(inode, offset, iov_length(iov, nr_segs), rw);
3116
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3117 3118 3119 3120 3121 3122
		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;
3123 3124
}

3125
/*
3126
 * Pages can be marked dirty completely asynchronously from ext4's journalling
3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137
 * 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.
 */
3138
static int ext4_journalled_set_page_dirty(struct page *page)
3139 3140 3141 3142 3143
{
	SetPageChecked(page);
	return __set_page_dirty_nobuffers(page);
}

3144
static const struct address_space_operations ext4_ordered_aops = {
3145 3146
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3147
	.writepage		= ext4_writepage,
3148 3149 3150 3151 3152 3153 3154 3155
	.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,
3156
	.error_remove_page	= generic_error_remove_page,
3157 3158
};

3159
static const struct address_space_operations ext4_writeback_aops = {
3160 3161
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3162
	.writepage		= ext4_writepage,
3163 3164 3165 3166 3167 3168 3169 3170
	.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,
3171
	.error_remove_page	= generic_error_remove_page,
3172 3173
};

3174
static const struct address_space_operations ext4_journalled_aops = {
3175 3176
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3177
	.writepage		= ext4_writepage,
3178 3179 3180 3181
	.write_begin		= ext4_write_begin,
	.write_end		= ext4_journalled_write_end,
	.set_page_dirty		= ext4_journalled_set_page_dirty,
	.bmap			= ext4_bmap,
3182
	.invalidatepage		= ext4_journalled_invalidatepage,
3183
	.releasepage		= ext4_releasepage,
3184
	.direct_IO		= ext4_direct_IO,
3185
	.is_partially_uptodate  = block_is_partially_uptodate,
3186
	.error_remove_page	= generic_error_remove_page,
3187 3188
};

3189
static const struct address_space_operations ext4_da_aops = {
3190 3191
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3192
	.writepage		= ext4_writepage,
3193 3194 3195 3196 3197 3198 3199 3200 3201
	.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,
3202
	.error_remove_page	= generic_error_remove_page,
3203 3204
};

3205
void ext4_set_aops(struct inode *inode)
3206
{
3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220
	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:
3221
		inode->i_mapping->a_ops = &ext4_journalled_aops;
3222 3223 3224 3225
		break;
	default:
		BUG();
	}
3226 3227
}

3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247

/*
 * 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)
3248
		return -ENOMEM;
3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276

	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"
3277
 * from:   The starting byte offset (from the beginning of the file)
3278 3279 3280 3281 3282 3283 3284
 *         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
3285
 *         for updating the contents of a page whose blocks may
3286 3287 3288
 *         have already been released, and we only want to zero
 *         out the regions that correspond to those released blocks.
 *
3289
 * Returns zero on success or negative on failure.
3290
 */
E
Eric Sandeen 已提交
3291
static int ext4_discard_partial_page_buffers_no_lock(handle_t *handle,
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
		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);

3317 3318
	if (!page_has_buffers(page))
		create_empty_buffers(page, blocksize, 0);
3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330

	/* 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) {
3331 3332
		unsigned int end_of_block, range_to_discard;

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 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417
		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);
3418
		} else
3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430
			mark_buffer_dirty(bh);

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

	return err;
}

3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441
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;
}

3442 3443 3444 3445 3446 3447 3448 3449
/*
 * 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
 *
3450
 * Returns: 0 on success or negative on failure
3451 3452 3453 3454 3455 3456
 */

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))
3457
		return -EOPNOTSUPP;
3458

3459 3460
	if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
		return ext4_ind_punch_hole(file, offset, length);
3461

3462 3463
	if (EXT4_SB(inode->i_sb)->s_cluster_ratio > 1) {
		/* TODO: Add support for bigalloc file systems */
3464
		return -EOPNOTSUPP;
3465 3466
	}

3467 3468
	trace_ext4_punch_hole(inode, offset, length);

3469 3470 3471
	return ext4_ext_punch_hole(file, offset, length);
}

3472
/*
3473
 * ext4_truncate()
3474
 *
3475 3476
 * We block out ext4_get_block() block instantiations across the entire
 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3477 3478
 * simultaneously on behalf of the same inode.
 *
3479
 * As we work through the truncate and commit bits of it to the journal there
3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492
 * 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
3493
 * i_disksize in this case).  After a crash, ext4_orphan_cleanup() will see
3494
 * that this inode's truncate did not complete and it will again call
3495 3496
 * 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
3497
 * that's fine - as long as they are linked from the inode, the post-crash
3498
 * ext4_truncate() run will find them and release them.
3499
 */
3500
void ext4_truncate(struct inode *inode)
3501
{
3502 3503
	trace_ext4_truncate_enter(inode);

3504
	if (!ext4_can_truncate(inode))
3505 3506
		return;

3507
	ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
3508

3509
	if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
3510
		ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
3511

3512 3513 3514 3515 3516 3517 3518 3519
	if (ext4_has_inline_data(inode)) {
		int has_inline = 1;

		ext4_inline_data_truncate(inode, &has_inline);
		if (has_inline)
			return;
	}

3520
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3521
		ext4_ext_truncate(inode);
3522 3523
	else
		ext4_ind_truncate(inode);
3524

3525
	trace_ext4_truncate_exit(inode);
3526 3527 3528
}

/*
3529
 * ext4_get_inode_loc returns with an extra refcount against the inode's
3530 3531 3532 3533
 * 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.
 */
3534 3535
static int __ext4_get_inode_loc(struct inode *inode,
				struct ext4_iloc *iloc, int in_mem)
3536
{
3537 3538 3539 3540 3541 3542
	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 已提交
3543
	iloc->bh = NULL;
3544 3545
	if (!ext4_valid_inum(sb, inode->i_ino))
		return -EIO;
3546

3547 3548 3549
	iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
	gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
	if (!gdp)
3550 3551
		return -EIO;

3552 3553 3554
	/*
	 * Figure out the offset within the block group inode table
	 */
3555
	inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
3556 3557 3558 3559 3560 3561
	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);
3562
	if (unlikely(!bh))
3563
		return -ENOMEM;
3564 3565
	if (!buffer_uptodate(bh)) {
		lock_buffer(bh);
3566 3567 3568 3569 3570 3571 3572 3573 3574 3575

		/*
		 * 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);

3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588
		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;
3589
			int i, start;
3590

3591
			start = inode_offset & ~(inodes_per_block - 1);
3592

3593 3594
			/* Is the inode bitmap in cache? */
			bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
3595
			if (unlikely(!bitmap_bh))
3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606
				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;
			}
3607
			for (i = start; i < start + inodes_per_block; i++) {
3608 3609
				if (i == inode_offset)
					continue;
3610
				if (ext4_test_bit(i, bitmap_bh->b_data))
3611 3612 3613
					break;
			}
			brelse(bitmap_bh);
3614
			if (i == start + inodes_per_block) {
3615 3616 3617 3618 3619 3620 3621 3622 3623
				/* 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:
3624 3625 3626 3627 3628 3629 3630 3631 3632
		/*
		 * 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 已提交
3633
			/* s_inode_readahead_blks is always a power of 2 */
3634 3635 3636 3637 3638
			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);
3639
			if (ext4_has_group_desc_csum(sb))
3640
				num -= ext4_itable_unused_count(sb, gdp);
3641 3642 3643 3644 3645 3646 3647
			table += num / inodes_per_block;
			if (end > table)
				end = table;
			while (b <= end)
				sb_breadahead(sb, b++);
		}

3648 3649 3650 3651 3652
		/*
		 * 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.
		 */
3653
		trace_ext4_load_inode(inode);
3654 3655
		get_bh(bh);
		bh->b_end_io = end_buffer_read_sync;
3656
		submit_bh(READ | REQ_META | REQ_PRIO, bh);
3657 3658
		wait_on_buffer(bh);
		if (!buffer_uptodate(bh)) {
3659 3660
			EXT4_ERROR_INODE_BLOCK(inode, block,
					       "unable to read itable block");
3661 3662 3663 3664 3665 3666 3667 3668 3669
			brelse(bh);
			return -EIO;
		}
	}
has_buffer:
	iloc->bh = bh;
	return 0;
}

3670
int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
3671 3672
{
	/* We have all inode data except xattrs in memory here. */
3673
	return __ext4_get_inode_loc(inode, iloc,
3674
		!ext4_test_inode_state(inode, EXT4_STATE_XATTR));
3675 3676
}

3677
void ext4_set_inode_flags(struct inode *inode)
3678
{
3679
	unsigned int flags = EXT4_I(inode)->i_flags;
3680 3681

	inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
3682
	if (flags & EXT4_SYNC_FL)
3683
		inode->i_flags |= S_SYNC;
3684
	if (flags & EXT4_APPEND_FL)
3685
		inode->i_flags |= S_APPEND;
3686
	if (flags & EXT4_IMMUTABLE_FL)
3687
		inode->i_flags |= S_IMMUTABLE;
3688
	if (flags & EXT4_NOATIME_FL)
3689
		inode->i_flags |= S_NOATIME;
3690
	if (flags & EXT4_DIRSYNC_FL)
3691 3692 3693
		inode->i_flags |= S_DIRSYNC;
}

3694 3695 3696
/* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
void ext4_get_inode_flags(struct ext4_inode_info *ei)
{
3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716
	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);
3717
}
3718

3719
static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
3720
				  struct ext4_inode_info *ei)
3721 3722
{
	blkcnt_t i_blocks ;
A
Aneesh Kumar K.V 已提交
3723 3724
	struct inode *inode = &(ei->vfs_inode);
	struct super_block *sb = inode->i_sb;
3725 3726 3727 3728 3729 3730

	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);
3731
		if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) {
A
Aneesh Kumar K.V 已提交
3732 3733 3734 3735 3736
			/* i_blocks represent file system block size */
			return i_blocks  << (inode->i_blkbits - 9);
		} else {
			return i_blocks;
		}
3737 3738 3739 3740
	} else {
		return le32_to_cpu(raw_inode->i_blocks_lo);
	}
}
3741

3742 3743 3744 3745 3746 3747
static inline void ext4_iget_extra_inode(struct inode *inode,
					 struct ext4_inode *raw_inode,
					 struct ext4_inode_info *ei)
{
	__le32 *magic = (void *)raw_inode +
			EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize;
3748
	if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC)) {
3749
		ext4_set_inode_state(inode, EXT4_STATE_XATTR);
3750
		ext4_find_inline_data_nolock(inode);
3751 3752
	} else
		EXT4_I(inode)->i_inline_off = 0;
3753 3754
}

3755
struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
3756
{
3757 3758
	struct ext4_iloc iloc;
	struct ext4_inode *raw_inode;
3759 3760
	struct ext4_inode_info *ei;
	struct inode *inode;
3761
	journal_t *journal = EXT4_SB(sb)->s_journal;
3762
	long ret;
3763
	int block;
3764 3765
	uid_t i_uid;
	gid_t i_gid;
3766

3767 3768 3769 3770 3771 3772 3773
	inode = iget_locked(sb, ino);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;

	ei = EXT4_I(inode);
3774
	iloc.bh = NULL;
3775

3776 3777
	ret = __ext4_get_inode_loc(inode, &iloc, 0);
	if (ret < 0)
3778
		goto bad_inode;
3779
	raw_inode = ext4_raw_inode(&iloc);
3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812

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

3813
	inode->i_mode = le16_to_cpu(raw_inode->i_mode);
3814 3815
	i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
	i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
3816
	if (!(test_opt(inode->i_sb, NO_UID32))) {
3817 3818
		i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
		i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
3819
	}
3820 3821
	i_uid_write(inode, i_uid);
	i_gid_write(inode, i_gid);
M
Miklos Szeredi 已提交
3822
	set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
3823

3824
	ext4_clear_state_flags(ei);	/* Only relevant on 32-bit archs */
3825
	ei->i_inline_off = 0;
3826 3827 3828 3829 3830 3831 3832 3833 3834
	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 ||
3835
		    !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
3836
			/* this inode is deleted */
3837
			ret = -ESTALE;
3838 3839 3840 3841 3842 3843 3844 3845
			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);
3846
	inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
3847
	ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
3848
	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT))
B
Badari Pulavarty 已提交
3849 3850
		ei->i_file_acl |=
			((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
3851
	inode->i_size = ext4_isize(raw_inode);
3852
	ei->i_disksize = inode->i_size;
3853 3854 3855
#ifdef CONFIG_QUOTA
	ei->i_reserved_quota = 0;
#endif
3856 3857
	inode->i_generation = le32_to_cpu(raw_inode->i_generation);
	ei->i_block_group = iloc.block_group;
3858
	ei->i_last_alloc_group = ~0;
3859 3860 3861 3862
	/*
	 * 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!
	 */
3863
	for (block = 0; block < EXT4_N_BLOCKS; block++)
3864 3865 3866
		ei->i_data[block] = raw_inode->i_block[block];
	INIT_LIST_HEAD(&ei->i_orphan);

3867 3868 3869 3870 3871 3872 3873 3874 3875 3876 3877
	/*
	 * 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;

3878
		read_lock(&journal->j_state_lock);
3879 3880 3881 3882 3883 3884 3885 3886
		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;
3887
		read_unlock(&journal->j_state_lock);
3888 3889 3890 3891
		ei->i_sync_tid = tid;
		ei->i_datasync_tid = tid;
	}

3892
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
3893 3894
		if (ei->i_extra_isize == 0) {
			/* The extra space is currently unused. Use it. */
3895 3896
			ei->i_extra_isize = sizeof(struct ext4_inode) -
					    EXT4_GOOD_OLD_INODE_SIZE;
3897
		} else {
3898
			ext4_iget_extra_inode(inode, raw_inode, ei);
3899
		}
3900
	}
3901

K
Kalpak Shah 已提交
3902 3903 3904 3905 3906
	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);

3907 3908 3909 3910 3911 3912 3913
	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;
	}

3914
	ret = 0;
3915
	if (ei->i_file_acl &&
3916
	    !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
3917 3918
		EXT4_ERROR_INODE(inode, "bad extended attribute block %llu",
				 ei->i_file_acl);
3919 3920
		ret = -EIO;
		goto bad_inode;
3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933
	} else if (!ext4_has_inline_data(inode)) {
		if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
			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);
		} else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
			   (S_ISLNK(inode->i_mode) &&
			    !ext4_inode_is_fast_symlink(inode))) {
			/* Validate block references which are part of inode */
			ret = ext4_ind_check_inode(inode);
		}
3934
	}
3935
	if (ret)
3936
		goto bad_inode;
3937

3938
	if (S_ISREG(inode->i_mode)) {
3939 3940 3941
		inode->i_op = &ext4_file_inode_operations;
		inode->i_fop = &ext4_file_operations;
		ext4_set_aops(inode);
3942
	} else if (S_ISDIR(inode->i_mode)) {
3943 3944
		inode->i_op = &ext4_dir_inode_operations;
		inode->i_fop = &ext4_dir_operations;
3945
	} else if (S_ISLNK(inode->i_mode)) {
3946
		if (ext4_inode_is_fast_symlink(inode)) {
3947
			inode->i_op = &ext4_fast_symlink_inode_operations;
3948 3949 3950
			nd_terminate_link(ei->i_data, inode->i_size,
				sizeof(ei->i_data) - 1);
		} else {
3951 3952
			inode->i_op = &ext4_symlink_inode_operations;
			ext4_set_aops(inode);
3953
		}
3954 3955
	} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
	      S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
3956
		inode->i_op = &ext4_special_inode_operations;
3957 3958 3959 3960 3961 3962
		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])));
3963 3964
	} else {
		ret = -EIO;
3965
		EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode);
3966
		goto bad_inode;
3967
	}
3968
	brelse(iloc.bh);
3969
	ext4_set_inode_flags(inode);
3970 3971
	unlock_new_inode(inode);
	return inode;
3972 3973

bad_inode:
3974
	brelse(iloc.bh);
3975 3976
	iget_failed(inode);
	return ERR_PTR(ret);
3977 3978
}

3979 3980 3981 3982 3983 3984 3985 3986 3987 3988
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) {
		/*
3989
		 * i_blocks can be represented in a 32 bit variable
3990 3991
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
3992
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
3993
		raw_inode->i_blocks_high = 0;
3994
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
3995 3996 3997 3998 3999 4000
		return 0;
	}
	if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE))
		return -EFBIG;

	if (i_blocks <= 0xffffffffffffULL) {
4001 4002 4003 4004
		/*
		 * i_blocks can be represented in a 48 bit variable
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
4005
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
4006
		raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
4007
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4008
	} else {
4009
		ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE);
A
Aneesh Kumar K.V 已提交
4010 4011 4012 4013
		/* 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);
4014
	}
4015
	return 0;
4016 4017
}

4018 4019 4020 4021 4022 4023 4024
/*
 * 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.
 */
4025
static int ext4_do_update_inode(handle_t *handle,
4026
				struct inode *inode,
4027
				struct ext4_iloc *iloc)
4028
{
4029 4030
	struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
	struct ext4_inode_info *ei = EXT4_I(inode);
4031 4032
	struct buffer_head *bh = iloc->bh;
	int err = 0, rc, block;
4033
	int need_datasync = 0;
4034 4035
	uid_t i_uid;
	gid_t i_gid;
4036 4037 4038

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

4042
	ext4_get_inode_flags(ei);
4043
	raw_inode->i_mode = cpu_to_le16(inode->i_mode);
4044 4045
	i_uid = i_uid_read(inode);
	i_gid = i_gid_read(inode);
4046
	if (!(test_opt(inode->i_sb, NO_UID32))) {
4047 4048
		raw_inode->i_uid_low = cpu_to_le16(low_16_bits(i_uid));
		raw_inode->i_gid_low = cpu_to_le16(low_16_bits(i_gid));
4049 4050 4051 4052
/*
 * Fix up interoperability with old kernels. Otherwise, old inodes get
 * re-used with the upper 16 bits of the uid/gid intact
 */
4053
		if (!ei->i_dtime) {
4054
			raw_inode->i_uid_high =
4055
				cpu_to_le16(high_16_bits(i_uid));
4056
			raw_inode->i_gid_high =
4057
				cpu_to_le16(high_16_bits(i_gid));
4058 4059 4060 4061 4062
		} else {
			raw_inode->i_uid_high = 0;
			raw_inode->i_gid_high = 0;
		}
	} else {
4063 4064
		raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid));
		raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(i_gid));
4065 4066 4067 4068
		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 已提交
4069 4070 4071 4072 4073 4074

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

4075 4076
	if (ext4_inode_blocks_set(handle, raw_inode, ei))
		goto out_brelse;
4077
	raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
4078
	raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF);
4079 4080
	if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
	    cpu_to_le32(EXT4_OS_HURD))
B
Badari Pulavarty 已提交
4081 4082
		raw_inode->i_file_acl_high =
			cpu_to_le16(ei->i_file_acl >> 32);
4083
	raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
4084 4085 4086 4087
	if (ei->i_disksize != ext4_isize(raw_inode)) {
		ext4_isize_set(raw_inode, ei->i_disksize);
		need_datasync = 1;
	}
4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102
	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,
4103
					EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4104
			ext4_handle_sync(handle);
4105
			err = ext4_handle_dirty_super(handle, sb);
4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119
		}
	}
	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;
		}
4120
	} else if (!ext4_has_inline_data(inode)) {
4121 4122
		for (block = 0; block < EXT4_N_BLOCKS; block++)
			raw_inode->i_block[block] = ei->i_data[block];
4123
	}
4124

4125 4126 4127 4128 4129
	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);
4130
		raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
4131 4132
	}

4133 4134
	ext4_inode_csum_set(inode, raw_inode, ei);

4135
	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
4136
	rc = ext4_handle_dirty_metadata(handle, NULL, bh);
4137 4138
	if (!err)
		err = rc;
4139
	ext4_clear_inode_state(inode, EXT4_STATE_NEW);
4140

4141
	ext4_update_inode_fsync_trans(handle, inode, need_datasync);
4142
out_brelse:
4143
	brelse(bh);
4144
	ext4_std_error(inode->i_sb, err);
4145 4146 4147 4148
	return err;
}

/*
4149
 * ext4_write_inode()
4150 4151 4152 4153 4154
 *
 * 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
4155
 *   transaction to commit.
4156 4157 4158 4159 4160 4161 4162 4163 4164 4165
 *
 * - 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
4166
 * ext4_mark_inode_dirty().  This is a correctness thing for O_SYNC and for
4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182
 * 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.
 */
4183
int ext4_write_inode(struct inode *inode, struct writeback_control *wbc)
4184
{
4185 4186
	int err;

4187 4188 4189
	if (current->flags & PF_MEMALLOC)
		return 0;

4190 4191 4192 4193 4194 4195
	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;
		}
4196

4197
		if (wbc->sync_mode != WB_SYNC_ALL)
4198 4199 4200 4201 4202
			return 0;

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

4204
		err = __ext4_get_inode_loc(inode, &iloc, 0);
4205 4206
		if (err)
			return err;
4207
		if (wbc->sync_mode == WB_SYNC_ALL)
4208 4209
			sync_dirty_buffer(iloc.bh);
		if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
4210 4211
			EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr,
					 "IO error syncing inode");
4212 4213
			err = -EIO;
		}
4214
		brelse(iloc.bh);
4215 4216
	}
	return err;
4217 4218
}

4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252 4253 4254 4255 4256 4257 4258 4259
/*
 * In data=journal mode ext4_journalled_invalidatepage() may fail to invalidate
 * buffers that are attached to a page stradding i_size and are undergoing
 * commit. In that case we have to wait for commit to finish and try again.
 */
static void ext4_wait_for_tail_page_commit(struct inode *inode)
{
	struct page *page;
	unsigned offset;
	journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
	tid_t commit_tid = 0;
	int ret;

	offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
	/*
	 * All buffers in the last page remain valid? Then there's nothing to
	 * do. We do the check mainly to optimize the common PAGE_CACHE_SIZE ==
	 * blocksize case
	 */
	if (offset > PAGE_CACHE_SIZE - (1 << inode->i_blkbits))
		return;
	while (1) {
		page = find_lock_page(inode->i_mapping,
				      inode->i_size >> PAGE_CACHE_SHIFT);
		if (!page)
			return;
		ret = __ext4_journalled_invalidatepage(page, offset);
		unlock_page(page);
		page_cache_release(page);
		if (ret != -EBUSY)
			return;
		commit_tid = 0;
		read_lock(&journal->j_state_lock);
		if (journal->j_committing_transaction)
			commit_tid = journal->j_committing_transaction->t_tid;
		read_unlock(&journal->j_state_lock);
		if (commit_tid)
			jbd2_log_wait_commit(journal, commit_tid);
	}
}

4260
/*
4261
 * ext4_setattr()
4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274
 *
 * 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.)
 *
4275 4276 4277 4278 4279 4280 4281 4282
 * 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.
4283
 */
4284
int ext4_setattr(struct dentry *dentry, struct iattr *attr)
4285 4286 4287
{
	struct inode *inode = dentry->d_inode;
	int error, rc = 0;
4288
	int orphan = 0;
4289 4290 4291 4292 4293 4294
	const unsigned int ia_valid = attr->ia_valid;

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

4295
	if (is_quota_modification(inode, attr))
4296
		dquot_initialize(inode);
4297 4298
	if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||
	    (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid))) {
4299 4300 4301 4302
		handle_t *handle;

		/* (user+group)*(old+new) structure, inode write (sb,
		 * inode block, ? - but truncate inode update has it) */
D
Dmitry Monakhov 已提交
4303
		handle = ext4_journal_start(inode, (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
4304
					EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb))+3);
4305 4306 4307 4308
		if (IS_ERR(handle)) {
			error = PTR_ERR(handle);
			goto err_out;
		}
4309
		error = dquot_transfer(inode, attr);
4310
		if (error) {
4311
			ext4_journal_stop(handle);
4312 4313 4314 4315 4316 4317 4318 4319
			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;
4320 4321
		error = ext4_mark_inode_dirty(handle, inode);
		ext4_journal_stop(handle);
4322 4323
	}

4324
	if (attr->ia_valid & ATTR_SIZE) {
4325

4326
		if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4327 4328
			struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

4329 4330
			if (attr->ia_size > sbi->s_bitmap_maxbytes)
				return -EFBIG;
4331 4332 4333
		}
	}

4334
	if (S_ISREG(inode->i_mode) &&
4335
	    attr->ia_valid & ATTR_SIZE &&
4336
	    (attr->ia_size < inode->i_size)) {
4337 4338
		handle_t *handle;

4339
		handle = ext4_journal_start(inode, 3);
4340 4341 4342 4343
		if (IS_ERR(handle)) {
			error = PTR_ERR(handle);
			goto err_out;
		}
4344 4345 4346 4347
		if (ext4_handle_valid(handle)) {
			error = ext4_orphan_add(handle, inode);
			orphan = 1;
		}
4348 4349
		EXT4_I(inode)->i_disksize = attr->ia_size;
		rc = ext4_mark_inode_dirty(handle, inode);
4350 4351
		if (!error)
			error = rc;
4352
		ext4_journal_stop(handle);
4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364

		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);
4365
				orphan = 0;
4366 4367 4368 4369
				ext4_journal_stop(handle);
				goto err_out;
			}
		}
4370 4371
	}

4372
	if (attr->ia_valid & ATTR_SIZE) {
4373 4374 4375 4376 4377 4378 4379 4380 4381
		if (attr->ia_size != inode->i_size) {
			loff_t oldsize = inode->i_size;

			i_size_write(inode, attr->ia_size);
			/*
			 * Blocks are going to be removed from the inode. Wait
			 * for dio in flight.  Temporarily disable
			 * dioread_nolock to prevent livelock.
			 */
4382
			if (orphan) {
4383 4384 4385 4386 4387 4388
				if (!ext4_should_journal_data(inode)) {
					ext4_inode_block_unlocked_dio(inode);
					inode_dio_wait(inode);
					ext4_inode_resume_unlocked_dio(inode);
				} else
					ext4_wait_for_tail_page_commit(inode);
4389
			}
4390 4391 4392 4393 4394
			/*
			 * Truncate pagecache after we've waited for commit
			 * in data=journal mode to make pages freeable.
			 */
			truncate_pagecache(inode, oldsize, inode->i_size);
4395
		}
4396
		ext4_truncate(inode);
4397
	}
4398

C
Christoph Hellwig 已提交
4399 4400 4401 4402 4403 4404 4405 4406 4407
	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.
	 */
4408
	if (orphan && inode->i_nlink)
4409
		ext4_orphan_del(NULL, inode);
4410 4411

	if (!rc && (ia_valid & ATTR_MODE))
4412
		rc = ext4_acl_chmod(inode);
4413 4414

err_out:
4415
	ext4_std_error(inode->i_sb, error);
4416 4417 4418 4419 4420
	if (!error)
		error = rc;
	return error;
}

4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439
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.
	 */
4440 4441
	delalloc_blocks = EXT4_C2B(EXT4_SB(inode->i_sb),
				EXT4_I(inode)->i_reserved_data_blocks);
4442 4443 4444 4445

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

4447 4448
static int ext4_index_trans_blocks(struct inode *inode, int nrblocks, int chunk)
{
4449
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
4450
		return ext4_ind_trans_blocks(inode, nrblocks, chunk);
4451
	return ext4_ext_index_trans_blocks(inode, nrblocks, chunk);
4452
}
4453

4454
/*
4455 4456 4457
 * 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
4458
 *
4459
 * If datablocks are discontiguous, they are possible to spread over
4460
 * different block groups too. If they are contiguous, with flexbg,
4461
 * they could still across block group boundary.
4462
 *
4463 4464
 * Also account for superblock, inode, quota and xattr blocks
 */
4465
static int ext4_meta_trans_blocks(struct inode *inode, int nrblocks, int chunk)
4466
{
4467 4468
	ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
	int gdpblocks;
4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494
	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;
4495 4496
	if (groups > ngroups)
		groups = ngroups;
4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509
	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 已提交
4510
 * Calculate the total number of credits to reserve to fit
4511 4512
 * the modification of a single pages into a single transaction,
 * which may include multiple chunks of block allocations.
4513
 *
4514
 * This could be called via ext4_write_begin()
4515
 *
4516
 * We need to consider the worse case, when
4517
 * one new block per extent.
4518
 */
A
Alex Tomas 已提交
4519
int ext4_writepage_trans_blocks(struct inode *inode)
4520
{
4521
	int bpp = ext4_journal_blocks_per_page(inode);
4522 4523
	int ret;

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

4526
	/* Account for data blocks for journalled mode */
4527
	if (ext4_should_journal_data(inode))
4528
		ret += bpp;
4529 4530
	return ret;
}
4531 4532 4533 4534 4535

/*
 * Calculate the journal credits for a chunk of data modification.
 *
 * This is called from DIO, fallocate or whoever calling
4536
 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
4537 4538 4539 4540 4541 4542 4543 4544 4545
 *
 * 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);
}

4546
/*
4547
 * The caller must have previously called ext4_reserve_inode_write().
4548 4549
 * Give this, we know that the caller already has write access to iloc->bh.
 */
4550
int ext4_mark_iloc_dirty(handle_t *handle,
4551
			 struct inode *inode, struct ext4_iloc *iloc)
4552 4553 4554
{
	int err = 0;

4555
	if (IS_I_VERSION(inode))
4556 4557
		inode_inc_iversion(inode);

4558 4559 4560
	/* the do_update_inode consumes one bh->b_count */
	get_bh(iloc->bh);

4561
	/* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
4562
	err = ext4_do_update_inode(handle, inode, iloc);
4563 4564 4565 4566 4567 4568 4569 4570 4571 4572
	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
4573 4574
ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
			 struct ext4_iloc *iloc)
4575
{
4576 4577 4578 4579 4580 4581 4582 4583 4584
	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;
4585 4586
		}
	}
4587
	ext4_std_error(inode->i_sb, err);
4588 4589 4590
	return err;
}

4591 4592 4593 4594
/*
 * Expand an inode by new_extra_isize bytes.
 * Returns 0 on success or negative error number on failure.
 */
A
Aneesh Kumar K.V 已提交
4595 4596 4597 4598
static int ext4_expand_extra_isize(struct inode *inode,
				   unsigned int new_extra_isize,
				   struct ext4_iloc iloc,
				   handle_t *handle)
4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610
{
	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 */
4611 4612
	if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
	    header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623
		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);
}

4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636
/*
 * 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.
 */
4637
int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
4638
{
4639
	struct ext4_iloc iloc;
4640 4641 4642
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	static unsigned int mnt_count;
	int err, ret;
4643 4644

	might_sleep();
4645
	trace_ext4_mark_inode_dirty(inode, _RET_IP_);
4646
	err = ext4_reserve_inode_write(handle, inode, &iloc);
4647 4648
	if (ext4_handle_valid(handle) &&
	    EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize &&
4649
	    !ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND)) {
4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662
		/*
		 * 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) {
4663 4664
				ext4_set_inode_state(inode,
						     EXT4_STATE_NO_EXPAND);
A
Aneesh Kumar K.V 已提交
4665 4666
				if (mnt_count !=
					le16_to_cpu(sbi->s_es->s_mnt_count)) {
4667
					ext4_warning(inode->i_sb,
4668 4669 4670
					"Unable to expand inode %lu. Delete"
					" some EAs or run e2fsck.",
					inode->i_ino);
A
Aneesh Kumar K.V 已提交
4671 4672
					mnt_count =
					  le16_to_cpu(sbi->s_es->s_mnt_count);
4673 4674 4675 4676
				}
			}
		}
	}
4677
	if (!err)
4678
		err = ext4_mark_iloc_dirty(handle, inode, &iloc);
4679 4680 4681 4682
	return err;
}

/*
4683
 * ext4_dirty_inode() is called from __mark_inode_dirty()
4684 4685 4686 4687 4688
 *
 * 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.
 *
4689
 * Also, dquot_alloc_block() will always dirty the inode when blocks
4690 4691 4692 4693 4694 4695
 * 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.
 */
4696
void ext4_dirty_inode(struct inode *inode, int flags)
4697 4698 4699
{
	handle_t *handle;

4700
	handle = ext4_journal_start(inode, 2);
4701 4702
	if (IS_ERR(handle))
		goto out;
4703 4704 4705

	ext4_mark_inode_dirty(handle, inode);

4706
	ext4_journal_stop(handle);
4707 4708 4709 4710 4711 4712 4713 4714
out:
	return;
}

#if 0
/*
 * Bind an inode's backing buffer_head into this transaction, to prevent
 * it from being flushed to disk early.  Unlike
4715
 * ext4_reserve_inode_write, this leaves behind no bh reference and
4716 4717 4718
 * returns no iloc structure, so the caller needs to repeat the iloc
 * lookup to mark the inode dirty later.
 */
4719
static int ext4_pin_inode(handle_t *handle, struct inode *inode)
4720
{
4721
	struct ext4_iloc iloc;
4722 4723 4724

	int err = 0;
	if (handle) {
4725
		err = ext4_get_inode_loc(inode, &iloc);
4726 4727
		if (!err) {
			BUFFER_TRACE(iloc.bh, "get_write_access");
4728
			err = jbd2_journal_get_write_access(handle, iloc.bh);
4729
			if (!err)
4730
				err = ext4_handle_dirty_metadata(handle,
4731
								 NULL,
4732
								 iloc.bh);
4733 4734 4735
			brelse(iloc.bh);
		}
	}
4736
	ext4_std_error(inode->i_sb, err);
4737 4738 4739 4740
	return err;
}
#endif

4741
int ext4_change_inode_journal_flag(struct inode *inode, int val)
4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756
{
	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.
	 */

4757
	journal = EXT4_JOURNAL(inode);
4758 4759
	if (!journal)
		return 0;
4760
	if (is_journal_aborted(journal))
4761
		return -EROFS;
4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772
	/* 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;
	}
4773

4774 4775 4776 4777
	/* Wait for all existing dio workers */
	ext4_inode_block_unlocked_dio(inode);
	inode_dio_wait(inode);

4778
	jbd2_journal_lock_updates(journal);
4779 4780 4781 4782 4783 4784 4785 4786 4787 4788

	/*
	 * 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)
4789
		ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
4790 4791
	else {
		jbd2_journal_flush(journal);
4792
		ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
4793
	}
4794
	ext4_set_aops(inode);
4795

4796
	jbd2_journal_unlock_updates(journal);
4797
	ext4_inode_resume_unlocked_dio(inode);
4798 4799 4800

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

4801
	handle = ext4_journal_start(inode, 1);
4802 4803 4804
	if (IS_ERR(handle))
		return PTR_ERR(handle);

4805
	err = ext4_mark_inode_dirty(handle, inode);
4806
	ext4_handle_sync(handle);
4807 4808
	ext4_journal_stop(handle);
	ext4_std_error(inode->i_sb, err);
4809 4810 4811

	return err;
}
4812 4813 4814 4815 4816 4817

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

4818
int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
4819
{
4820
	struct page *page = vmf->page;
4821 4822
	loff_t size;
	unsigned long len;
4823
	int ret;
4824 4825 4826
	struct file *file = vma->vm_file;
	struct inode *inode = file->f_path.dentry->d_inode;
	struct address_space *mapping = inode->i_mapping;
4827 4828 4829
	handle_t *handle;
	get_block_t *get_block;
	int retries = 0;
4830

4831
	sb_start_pagefault(inode->i_sb);
4832
	file_update_time(vma->vm_file);
4833 4834 4835 4836 4837 4838 4839 4840 4841 4842
	/* 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;
4843
	}
4844 4845

	lock_page(page);
4846 4847 4848 4849 4850 4851
	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;
4852
	}
4853 4854 4855 4856 4857

	if (page->index == size >> PAGE_CACHE_SHIFT)
		len = size & ~PAGE_CACHE_MASK;
	else
		len = PAGE_CACHE_SIZE;
4858
	/*
4859 4860
	 * 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
4861
	 */
4862
	if (page_has_buffers(page)) {
4863 4864 4865
		if (!ext4_walk_page_buffers(NULL, page_buffers(page),
					    0, len, NULL,
					    ext4_bh_unmapped)) {
4866 4867 4868 4869
			/* Wait so that we don't change page under IO */
			wait_on_page_writeback(page);
			ret = VM_FAULT_LOCKED;
			goto out;
4870
		}
4871
	}
4872
	unlock_page(page);
4873 4874 4875 4876 4877 4878 4879 4880
	/* 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)) {
4881
		ret = VM_FAULT_SIGBUS;
4882 4883 4884 4885
		goto out;
	}
	ret = __block_page_mkwrite(vma, vmf, get_block);
	if (!ret && ext4_should_journal_data(inode)) {
4886
		if (ext4_walk_page_buffers(handle, page_buffers(page), 0,
4887 4888 4889
			  PAGE_CACHE_SIZE, NULL, do_journal_get_write_access)) {
			unlock_page(page);
			ret = VM_FAULT_SIGBUS;
4890
			ext4_journal_stop(handle);
4891 4892 4893 4894 4895 4896 4897 4898 4899 4900
			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:
4901
	sb_end_pagefault(inode->i_sb);
4902 4903
	return ret;
}