inode.c 181.2 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2
/*
3
 *  linux/fs/ext4/inode.c
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
 *
 * 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)
 *
19
 *  Assorted race fixes, rewrite of ext4_get_block() by Al Viro, 2000
20 21 22 23 24 25
 */

#include <linux/fs.h>
#include <linux/time.h>
#include <linux/highuid.h>
#include <linux/pagemap.h>
26
#include <linux/dax.h>
27 28 29 30
#include <linux/quotaops.h>
#include <linux/string.h>
#include <linux/buffer_head.h>
#include <linux/writeback.h>
31
#include <linux/pagevec.h>
32
#include <linux/mpage.h>
33
#include <linux/namei.h>
34 35
#include <linux/uio.h>
#include <linux/bio.h>
36
#include <linux/workqueue.h>
37
#include <linux/kernel.h>
38
#include <linux/printk.h>
39
#include <linux/slab.h>
40
#include <linux/bitops.h>
41
#include <linux/iomap.h>
42
#include <linux/iversion.h>
43

44
#include "ext4_jbd2.h"
45 46
#include "xattr.h"
#include "acl.h"
47
#include "truncate.h"
48

49 50
#include <trace/events/ext4.h>

51 52
#define MPAGE_DA_EXTENT_TAIL 0x01

53 54 55 56 57
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);
	__u32 csum;
58 59 60
	__u16 dummy_csum = 0;
	int offset = offsetof(struct ext4_inode, i_checksum_lo);
	unsigned int csum_size = sizeof(dummy_csum);
61

62 63 64 65 66
	csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)raw, offset);
	csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum, csum_size);
	offset += csum_size;
	csum = ext4_chksum(sbi, csum, (__u8 *)raw + offset,
			   EXT4_GOOD_OLD_INODE_SIZE - offset);
67

68 69 70 71 72 73 74 75 76 77
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
		offset = offsetof(struct ext4_inode, i_checksum_hi);
		csum = ext4_chksum(sbi, csum, (__u8 *)raw +
				   EXT4_GOOD_OLD_INODE_SIZE,
				   offset - EXT4_GOOD_OLD_INODE_SIZE);
		if (EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) {
			csum = ext4_chksum(sbi, csum, (__u8 *)&dummy_csum,
					   csum_size);
			offset += csum_size;
		}
78 79
		csum = ext4_chksum(sbi, csum, (__u8 *)raw + offset,
				   EXT4_INODE_SIZE(inode->i_sb) - offset);
80 81 82 83 84 85 86 87 88 89 90 91
	}

	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) ||
92
	    !ext4_has_metadata_csum(inode->i_sb))
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
		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) ||
113
	    !ext4_has_metadata_csum(inode->i_sb))
114 115 116 117 118 119 120 121 122
		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);
}

123 124 125
static inline int ext4_begin_ordered_truncate(struct inode *inode,
					      loff_t new_size)
{
126
	trace_ext4_begin_ordered_truncate(inode, new_size);
127 128 129 130 131 132 133 134 135 136 137
	/*
	 * 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);
138 139
}

140 141
static void ext4_invalidatepage(struct page *page, unsigned int offset,
				unsigned int length);
142 143
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);
T
Tahsin Erdogan 已提交
144 145
static int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
				  int pextents);
146

147 148
/*
 * Test whether an inode is a fast symlink.
149
 * A fast symlink has its symlink data stored in ext4_inode_info->i_data.
150
 */
151
int ext4_inode_is_fast_symlink(struct inode *inode)
152
{
153 154 155 156 157 158 159 160 161
	if (!(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL)) {
		int ea_blocks = EXT4_I(inode)->i_file_acl ?
				EXT4_CLUSTER_SIZE(inode->i_sb) >> 9 : 0;

		if (ext4_has_inline_data(inode))
			return 0;

		return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
	}
162 163
	return S_ISLNK(inode->i_mode) && inode->i_size &&
	       (inode->i_size < EXT4_N_BLOCKS * 4);
164 165 166 167 168 169 170
}

/*
 * Restart the transaction associated with *handle.  This does a commit,
 * so before we call here everything must be consistently dirtied against
 * this transaction.
 */
171
int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode,
172
				 int nblocks)
173
{
174 175 176
	int ret;

	/*
177
	 * Drop i_data_sem to avoid deadlock with ext4_map_blocks.  At this
178 179 180 181
	 * 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.
	 */
182
	BUG_ON(EXT4_JOURNAL(inode) == NULL);
183
	jbd_debug(2, "restarting handle %p\n", handle);
184
	up_write(&EXT4_I(inode)->i_data_sem);
185
	ret = ext4_journal_restart(handle, nblocks);
186
	down_write(&EXT4_I(inode)->i_data_sem);
187
	ext4_discard_preallocations(inode);
188 189

	return ret;
190 191 192 193 194
}

/*
 * Called at the last iput() if i_nlink is zero.
 */
A
Al Viro 已提交
195
void ext4_evict_inode(struct inode *inode)
196 197
{
	handle_t *handle;
198
	int err;
A
Andreas Dilger 已提交
199
	int extra_credits = 3;
200
	struct ext4_xattr_inode_array *ea_inode_array = NULL;
201

202
	trace_ext4_evict_inode(inode);
203

A
Al Viro 已提交
204
	if (inode->i_nlink) {
205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
		/*
		 * 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.
		 */
223 224
		if (inode->i_ino != EXT4_JOURNAL_INO &&
		    ext4_should_journal_data(inode) &&
225 226
		    (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode)) &&
		    inode->i_data.nrpages) {
227 228 229
			journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
			tid_t commit_tid = EXT4_I(inode)->i_datasync_tid;

230
			jbd2_complete_transaction(journal, commit_tid);
231 232
			filemap_write_and_wait(&inode->i_data);
		}
233
		truncate_inode_pages_final(&inode->i_data);
J
Jan Kara 已提交
234

A
Al Viro 已提交
235 236 237
		goto no_delete;
	}

238 239 240
	if (is_bad_inode(inode))
		goto no_delete;
	dquot_initialize(inode);
241

242 243
	if (ext4_should_order_data(inode))
		ext4_begin_ordered_truncate(inode, 0);
244
	truncate_inode_pages_final(&inode->i_data);
245

246 247 248 249 250
	/*
	 * Protect us against freezing - iput() caller didn't have to have any
	 * protection against it
	 */
	sb_start_intwrite(inode->i_sb);
A
Andreas Dilger 已提交
251

252 253 254 255 256
	if (!IS_NOQUOTA(inode))
		extra_credits += EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb);

	handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE,
				 ext4_blocks_for_truncate(inode)+extra_credits);
257
	if (IS_ERR(handle)) {
258
		ext4_std_error(inode->i_sb, PTR_ERR(handle));
259 260 261 262 263
		/*
		 * 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.
		 */
264
		ext4_orphan_del(NULL, inode);
265
		sb_end_intwrite(inode->i_sb);
266 267
		goto no_delete;
	}
268

269
	if (IS_SYNC(inode))
270
		ext4_handle_sync(handle);
271 272 273 274 275 276 277 278 279 280

	/*
	 * Set inode->i_size to 0 before calling ext4_truncate(). We need
	 * special handling of symlinks here because i_size is used to
	 * determine whether ext4_inode_info->i_data contains symlink data or
	 * block mappings. Setting i_size to 0 will remove its fast symlink
	 * status. Erase i_data so that it becomes a valid empty block map.
	 */
	if (ext4_inode_is_fast_symlink(inode))
		memset(EXT4_I(inode)->i_data, 0, sizeof(EXT4_I(inode)->i_data));
281
	inode->i_size = 0;
282 283
	err = ext4_mark_inode_dirty(handle, inode);
	if (err) {
284
		ext4_warning(inode->i_sb,
285 286 287
			     "couldn't mark inode dirty (err %d)", err);
		goto stop_handle;
	}
288 289 290 291 292 293 294 295 296
	if (inode->i_blocks) {
		err = ext4_truncate(inode);
		if (err) {
			ext4_error(inode->i_sb,
				   "couldn't truncate inode %lu (err %d)",
				   inode->i_ino, err);
			goto stop_handle;
		}
	}
297

298 299 300 301 302 303 304 305 306 307 308
	/* Remove xattr references. */
	err = ext4_xattr_delete_inode(handle, inode, &ea_inode_array,
				      extra_credits);
	if (err) {
		ext4_warning(inode->i_sb, "xattr delete (err %d)", err);
stop_handle:
		ext4_journal_stop(handle);
		ext4_orphan_del(NULL, inode);
		sb_end_intwrite(inode->i_sb);
		ext4_xattr_inode_array_free(ea_inode_array);
		goto no_delete;
309 310
	}

311
	/*
312
	 * Kill off the orphan record which ext4_truncate created.
313
	 * AKPM: I think this can be inside the above `if'.
314
	 * Note that ext4_orphan_del() has to be able to cope with the
315
	 * deletion of a non-existent orphan - this is because we don't
316
	 * know if ext4_truncate() actually created an orphan record.
317 318
	 * (Well, we could do this if we need to, but heck - it works)
	 */
319
	ext4_orphan_del(handle, inode);
320
	EXT4_I(inode)->i_dtime	= (__u32)ktime_get_real_seconds();
321 322 323 324 325 326 327 328

	/*
	 * 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.
	 */
329
	if (ext4_mark_inode_dirty(handle, inode))
330
		/* If that failed, just do the required in-core inode clear. */
A
Al Viro 已提交
331
		ext4_clear_inode(inode);
332
	else
333 334
		ext4_free_inode(handle, inode);
	ext4_journal_stop(handle);
335
	sb_end_intwrite(inode->i_sb);
336
	ext4_xattr_inode_array_free(ea_inode_array);
337 338
	return;
no_delete:
A
Al Viro 已提交
339
	ext4_clear_inode(inode);	/* We must guarantee clearing of inode... */
340 341
}

342 343
#ifdef CONFIG_QUOTA
qsize_t *ext4_get_reserved_space(struct inode *inode)
344
{
345
	return &EXT4_I(inode)->i_reserved_quota;
346
}
347
#endif
348

349 350 351 352
/*
 * Called with i_data_sem down, which is important since we can call
 * ext4_discard_preallocations() from here.
 */
353 354
void ext4_da_update_reserve_space(struct inode *inode,
					int used, int quota_claim)
355 356
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
357 358 359
	struct ext4_inode_info *ei = EXT4_I(inode);

	spin_lock(&ei->i_block_reservation_lock);
360
	trace_ext4_da_update_reserve_space(inode, used, quota_claim);
361
	if (unlikely(used > ei->i_reserved_data_blocks)) {
362
		ext4_warning(inode->i_sb, "%s: ino %lu, used %d "
363
			 "with only %d reserved data blocks",
364 365 366 367 368
			 __func__, inode->i_ino, used,
			 ei->i_reserved_data_blocks);
		WARN_ON(1);
		used = ei->i_reserved_data_blocks;
	}
369

370 371
	/* Update per-inode reservations */
	ei->i_reserved_data_blocks -= used;
372
	percpu_counter_sub(&sbi->s_dirtyclusters_counter, used);
373

374
	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
375

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

	/*
	 * 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.
	 */
393 394
	if ((ei->i_reserved_data_blocks == 0) &&
	    (atomic_read(&inode->i_writecount) == 0))
395
		ext4_discard_preallocations(inode);
396 397
}

398
static int __check_block_validity(struct inode *inode, const char *func,
399 400
				unsigned int line,
				struct ext4_map_blocks *map)
401
{
402 403 404 405
	if (ext4_has_feature_journal(inode->i_sb) &&
	    (inode->i_ino ==
	     le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_journal_inum)))
		return 0;
406 407
	if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk,
				   map->m_len)) {
408
		ext4_error_inode(inode, func, line, map->m_pblk,
409
				 "lblock %lu mapped to illegal pblock %llu "
410
				 "(length %d)", (unsigned long) map->m_lblk,
411
				 map->m_pblk, map->m_len);
412
		return -EFSCORRUPTED;
413 414 415 416
	}
	return 0;
}

J
Jan Kara 已提交
417 418 419 420 421 422
int ext4_issue_zeroout(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
		       ext4_lblk_t len)
{
	int ret;

	if (ext4_encrypted_inode(inode))
423
		return fscrypt_zeroout_range(inode, lblk, pblk, len);
J
Jan Kara 已提交
424 425 426 427 428 429 430 431

	ret = sb_issue_zeroout(inode->i_sb, pblk, len, GFP_NOFS);
	if (ret > 0)
		ret = 0;

	return ret;
}

432
#define check_block_validity(inode, map)	\
433
	__check_block_validity((inode), __func__, __LINE__, (map))
434

435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451
#ifdef ES_AGGRESSIVE_TEST
static void ext4_map_blocks_es_recheck(handle_t *handle,
				       struct inode *inode,
				       struct ext4_map_blocks *es_map,
				       struct ext4_map_blocks *map,
				       int flags)
{
	int retval;

	map->m_flags = 0;
	/*
	 * There is a race window that the result is not the same.
	 * e.g. xfstests #223 when dioread_nolock enables.  The reason
	 * is that we lookup a block mapping in extent status tree with
	 * out taking i_data_sem.  So at the time the unwritten extent
	 * could be converted.
	 */
452
	down_read(&EXT4_I(inode)->i_data_sem);
453 454 455 456 457 458 459
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
		retval = ext4_ext_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
	} else {
		retval = ext4_ind_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
	}
460
	up_read((&EXT4_I(inode)->i_data_sem));
461 462 463 464 465 466 467 468

	/*
	 * We don't check m_len because extent will be collpased in status
	 * tree.  So the m_len might not equal.
	 */
	if (es_map->m_lblk != map->m_lblk ||
	    es_map->m_flags != map->m_flags ||
	    es_map->m_pblk != map->m_pblk) {
469
		printk("ES cache assertion failed for inode: %lu "
470 471 472 473 474 475 476 477 478 479
		       "es_cached ex [%d/%d/%llu/%x] != "
		       "found ex [%d/%d/%llu/%x] retval %d flags %x\n",
		       inode->i_ino, es_map->m_lblk, es_map->m_len,
		       es_map->m_pblk, es_map->m_flags, map->m_lblk,
		       map->m_len, map->m_pblk, map->m_flags,
		       retval, flags);
	}
}
#endif /* ES_AGGRESSIVE_TEST */

480
/*
481
 * The ext4_map_blocks() function tries to look up the requested blocks,
482
 * and returns if the blocks are already mapped.
483 484 485 486 487
 *
 * 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.
 *
488 489
 * If file type is extents based, it will call ext4_ext_map_blocks(),
 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
490 491
 * based files
 *
492 493 494
 * On success, it returns the number of blocks being mapped or allocated.  if
 * create==0 and the blocks are pre-allocated and unwritten, the resulting @map
 * is marked as unwritten. If the create == 1, it will mark @map as mapped.
495 496
 *
 * It returns 0 if plain look up failed (blocks have not been allocated), in
497 498
 * that case, @map is returned as unmapped but we still do fill map->m_len to
 * indicate the length of a hole starting at map->m_lblk.
499 500 501
 *
 * It returns the error in case of allocation failure.
 */
502 503
int ext4_map_blocks(handle_t *handle, struct inode *inode,
		    struct ext4_map_blocks *map, int flags)
504
{
505
	struct extent_status es;
506
	int retval;
507
	int ret = 0;
508 509 510 511 512
#ifdef ES_AGGRESSIVE_TEST
	struct ext4_map_blocks orig_map;

	memcpy(&orig_map, map, sizeof(*map));
#endif
513

514 515 516 517
	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);
518

519 520 521 522 523 524
	/*
	 * ext4_map_blocks returns an int, and m_len is an unsigned int
	 */
	if (unlikely(map->m_len > INT_MAX))
		map->m_len = INT_MAX;

525 526
	/* We can handle the block number less than EXT_MAX_BLOCKS */
	if (unlikely(map->m_lblk >= EXT_MAX_BLOCKS))
527
		return -EFSCORRUPTED;
528

529 530 531 532 533 534 535 536 537 538 539 540
	/* Lookup extent status tree firstly */
	if (ext4_es_lookup_extent(inode, map->m_lblk, &es)) {
		if (ext4_es_is_written(&es) || ext4_es_is_unwritten(&es)) {
			map->m_pblk = ext4_es_pblock(&es) +
					map->m_lblk - es.es_lblk;
			map->m_flags |= ext4_es_is_written(&es) ?
					EXT4_MAP_MAPPED : EXT4_MAP_UNWRITTEN;
			retval = es.es_len - (map->m_lblk - es.es_lblk);
			if (retval > map->m_len)
				retval = map->m_len;
			map->m_len = retval;
		} else if (ext4_es_is_delayed(&es) || ext4_es_is_hole(&es)) {
541 542 543 544 545
			map->m_pblk = 0;
			retval = es.es_len - (map->m_lblk - es.es_lblk);
			if (retval > map->m_len)
				retval = map->m_len;
			map->m_len = retval;
546 547 548 549
			retval = 0;
		} else {
			BUG_ON(1);
		}
550 551 552 553
#ifdef ES_AGGRESSIVE_TEST
		ext4_map_blocks_es_recheck(handle, inode, map,
					   &orig_map, flags);
#endif
554 555 556
		goto found;
	}

557
	/*
558 559
	 * Try to see if we can get the block without requesting a new
	 * file system block.
560
	 */
561
	down_read(&EXT4_I(inode)->i_data_sem);
562
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
563 564
		retval = ext4_ext_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
565
	} else {
566 567
		retval = ext4_ind_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
568
	}
569
	if (retval > 0) {
570
		unsigned int status;
571

572 573 574 575 576 577
		if (unlikely(retval != map->m_len)) {
			ext4_warning(inode->i_sb,
				     "ES len assertion failed for inode "
				     "%lu: retval %d != map->m_len %d",
				     inode->i_ino, retval, map->m_len);
			WARN_ON(1);
578 579
		}

580 581 582
		status = map->m_flags & EXT4_MAP_UNWRITTEN ?
				EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
		if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) &&
583
		    !(status & EXTENT_STATUS_WRITTEN) &&
584 585 586 587 588 589 590 591
		    ext4_find_delalloc_range(inode, map->m_lblk,
					     map->m_lblk + map->m_len - 1))
			status |= EXTENT_STATUS_DELAYED;
		ret = ext4_es_insert_extent(inode, map->m_lblk,
					    map->m_len, map->m_pblk, status);
		if (ret < 0)
			retval = ret;
	}
592
	up_read((&EXT4_I(inode)->i_data_sem));
593

594
found:
595
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
596
		ret = check_block_validity(inode, map);
597 598 599 600
		if (ret != 0)
			return ret;
	}

601
	/* If it is only a block(s) look up */
602
	if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)
603 604 605 606 607 608
		return retval;

	/*
	 * Returns if the blocks have already allocated
	 *
	 * Note that if blocks have been preallocated
609
	 * ext4_ext_get_block() returns the create = 0
610 611
	 * with buffer head unmapped.
	 */
612
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
613 614 615 616 617 618 619
		/*
		 * If we need to convert extent to unwritten
		 * we continue and do the actual work in
		 * ext4_ext_map_blocks()
		 */
		if (!(flags & EXT4_GET_BLOCKS_CONVERT_UNWRITTEN))
			return retval;
620

621
	/*
622 623
	 * Here we clear m_flags because after allocating an new extent,
	 * it will be set again.
624
	 */
625
	map->m_flags &= ~EXT4_MAP_FLAGS;
626

627
	/*
628
	 * New blocks allocate and/or writing to unwritten extent
629
	 * will possibly result in updating i_data, so we take
630
	 * the write lock of i_data_sem, and call get_block()
631
	 * with create == 1 flag.
632
	 */
633
	down_write(&EXT4_I(inode)->i_data_sem);
634

635 636 637 638
	/*
	 * We need to check for EXT4 here because migrate
	 * could have changed the inode type in between
	 */
639
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
640
		retval = ext4_ext_map_blocks(handle, inode, map, flags);
641
	} else {
642
		retval = ext4_ind_map_blocks(handle, inode, map, flags);
643

644
		if (retval > 0 && map->m_flags & EXT4_MAP_NEW) {
645 646 647 648 649
			/*
			 * We allocated new blocks which will result in
			 * i_data's format changing.  Force the migrate
			 * to fail by clearing migrate flags
			 */
650
			ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
651
		}
652

653 654 655 656 657 658 659
		/*
		 * 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) &&
660
			(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE))
661 662
			ext4_da_update_reserve_space(inode, retval, 1);
	}
663

664
	if (retval > 0) {
665
		unsigned int status;
666

667 668 669 670 671 672
		if (unlikely(retval != map->m_len)) {
			ext4_warning(inode->i_sb,
				     "ES len assertion failed for inode "
				     "%lu: retval %d != map->m_len %d",
				     inode->i_ino, retval, map->m_len);
			WARN_ON(1);
673 674
		}

675 676 677
		/*
		 * We have to zeroout blocks before inserting them into extent
		 * status tree. Otherwise someone could look them up there and
678 679 680
		 * use them before they are really zeroed. We also have to
		 * unmap metadata before zeroing as otherwise writeback can
		 * overwrite zeros with stale data from block device.
681 682 683 684
		 */
		if (flags & EXT4_GET_BLOCKS_ZERO &&
		    map->m_flags & EXT4_MAP_MAPPED &&
		    map->m_flags & EXT4_MAP_NEW) {
685 686
			clean_bdev_aliases(inode->i_sb->s_bdev, map->m_pblk,
					   map->m_len);
687 688 689 690 691 692 693 694
			ret = ext4_issue_zeroout(inode, map->m_lblk,
						 map->m_pblk, map->m_len);
			if (ret) {
				retval = ret;
				goto out_sem;
			}
		}

695 696 697 698 699 700 701
		/*
		 * If the extent has been zeroed out, we don't need to update
		 * extent status tree.
		 */
		if ((flags & EXT4_GET_BLOCKS_PRE_IO) &&
		    ext4_es_lookup_extent(inode, map->m_lblk, &es)) {
			if (ext4_es_is_written(&es))
702
				goto out_sem;
703
		}
704 705 706
		status = map->m_flags & EXT4_MAP_UNWRITTEN ?
				EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
		if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) &&
707
		    !(status & EXTENT_STATUS_WRITTEN) &&
708 709 710 711 712
		    ext4_find_delalloc_range(inode, map->m_lblk,
					     map->m_lblk + map->m_len - 1))
			status |= EXTENT_STATUS_DELAYED;
		ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len,
					    map->m_pblk, status);
713
		if (ret < 0) {
714
			retval = ret;
715 716
			goto out_sem;
		}
717 718
	}

719
out_sem:
720
	up_write((&EXT4_I(inode)->i_data_sem));
721
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
722
		ret = check_block_validity(inode, map);
723 724
		if (ret != 0)
			return ret;
J
Jan Kara 已提交
725 726 727 728 729 730 731 732 733

		/*
		 * Inodes with freshly allocated blocks where contents will be
		 * visible after transaction commit must be on transaction's
		 * ordered data list.
		 */
		if (map->m_flags & EXT4_MAP_NEW &&
		    !(map->m_flags & EXT4_MAP_UNWRITTEN) &&
		    !(flags & EXT4_GET_BLOCKS_ZERO) &&
T
Tahsin Erdogan 已提交
734
		    !ext4_is_quota_file(inode) &&
J
Jan Kara 已提交
735
		    ext4_should_order_data(inode)) {
736 737 738 739
			loff_t start_byte =
				(loff_t)map->m_lblk << inode->i_blkbits;
			loff_t length = (loff_t)map->m_len << inode->i_blkbits;

740
			if (flags & EXT4_GET_BLOCKS_IO_SUBMIT)
741 742
				ret = ext4_jbd2_inode_add_wait(handle, inode,
						start_byte, length);
743
			else
744 745
				ret = ext4_jbd2_inode_add_write(handle, inode,
						start_byte, length);
J
Jan Kara 已提交
746 747 748
			if (ret)
				return ret;
		}
749
	}
750 751 752
	return retval;
}

J
Jan Kara 已提交
753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780
/*
 * Update EXT4_MAP_FLAGS in bh->b_state. For buffer heads attached to pages
 * we have to be careful as someone else may be manipulating b_state as well.
 */
static void ext4_update_bh_state(struct buffer_head *bh, unsigned long flags)
{
	unsigned long old_state;
	unsigned long new_state;

	flags &= EXT4_MAP_FLAGS;

	/* Dummy buffer_head? Set non-atomically. */
	if (!bh->b_page) {
		bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | flags;
		return;
	}
	/*
	 * Someone else may be modifying b_state. Be careful! This is ugly but
	 * once we get rid of using bh as a container for mapping information
	 * to pass to / from get_block functions, this can go away.
	 */
	do {
		old_state = READ_ONCE(bh->b_state);
		new_state = (old_state & ~EXT4_MAP_FLAGS) | flags;
	} while (unlikely(
		 cmpxchg(&bh->b_state, old_state, new_state) != old_state));
}

781 782
static int _ext4_get_block(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int flags)
783
{
784
	struct ext4_map_blocks map;
785
	int ret = 0;
786

T
Tao Ma 已提交
787 788 789
	if (ext4_has_inline_data(inode))
		return -ERANGE;

790 791 792
	map.m_lblk = iblock;
	map.m_len = bh->b_size >> inode->i_blkbits;

793 794
	ret = ext4_map_blocks(ext4_journal_current_handle(), inode, &map,
			      flags);
J
Jan Kara 已提交
795
	if (ret > 0) {
796
		map_bh(bh, inode->i_sb, map.m_pblk);
J
Jan Kara 已提交
797
		ext4_update_bh_state(bh, map.m_flags);
798
		bh->b_size = inode->i_sb->s_blocksize * map.m_len;
J
Jan Kara 已提交
799
		ret = 0;
800 801 802
	} else if (ret == 0) {
		/* hole case, need to fill in bh->b_size */
		bh->b_size = inode->i_sb->s_blocksize * map.m_len;
803 804 805 806
	}
	return ret;
}

807 808 809 810 811 812 813
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);
}

814 815 816 817 818 819 820 821 822 823 824 825 826 827
/*
 * Get block function used when preparing for buffered write if we require
 * creating an unwritten extent if blocks haven't been allocated.  The extent
 * will be converted to written after the IO is complete.
 */
int ext4_get_block_unwritten(struct inode *inode, sector_t iblock,
			     struct buffer_head *bh_result, int create)
{
	ext4_debug("ext4_get_block_unwritten: inode %lu, create flag %d\n",
		   inode->i_ino, create);
	return _ext4_get_block(inode, iblock, bh_result,
			       EXT4_GET_BLOCKS_IO_CREATE_EXT);
}

828 829 830
/* Maximum number of blocks we map for direct IO at once. */
#define DIO_MAX_BLOCKS 4096

831 832 833 834 835 836 837
/*
 * Get blocks function for the cases that need to start a transaction -
 * generally difference cases of direct IO and DAX IO. It also handles retries
 * in case of ENOSPC.
 */
static int ext4_get_block_trans(struct inode *inode, sector_t iblock,
				struct buffer_head *bh_result, int flags)
838 839
{
	int dio_credits;
840 841 842
	handle_t *handle;
	int retries = 0;
	int ret;
843 844 845 846 847 848

	/* Trim mapping request to maximum we can map at once for DIO */
	if (bh_result->b_size >> inode->i_blkbits > DIO_MAX_BLOCKS)
		bh_result->b_size = DIO_MAX_BLOCKS << inode->i_blkbits;
	dio_credits = ext4_chunk_trans_blocks(inode,
				      bh_result->b_size >> inode->i_blkbits);
849 850 851 852 853 854 855 856 857 858 859
retry:
	handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS, dio_credits);
	if (IS_ERR(handle))
		return PTR_ERR(handle);

	ret = _ext4_get_block(inode, iblock, bh_result, flags);
	ext4_journal_stop(handle);

	if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
		goto retry;
	return ret;
860 861
}

862 863 864 865
/* Get block function for DIO reads and writes to inodes without extents */
int ext4_dio_get_block(struct inode *inode, sector_t iblock,
		       struct buffer_head *bh, int create)
{
866 867 868
	/* We don't expect handle for direct IO */
	WARN_ON_ONCE(ext4_journal_current_handle());

869 870 871
	if (!create)
		return _ext4_get_block(inode, iblock, bh, 0);
	return ext4_get_block_trans(inode, iblock, bh, EXT4_GET_BLOCKS_CREATE);
872 873 874
}

/*
875
 * Get block function for AIO DIO writes when we create unwritten extent if
876 877 878
 * blocks are not allocated yet. The extent will be converted to written
 * after IO is complete.
 */
879 880
static int ext4_dio_get_block_unwritten_async(struct inode *inode,
		sector_t iblock, struct buffer_head *bh_result,	int create)
881
{
882 883 884 885 886
	int ret;

	/* We don't expect handle for direct IO */
	WARN_ON_ONCE(ext4_journal_current_handle());

887 888
	ret = ext4_get_block_trans(inode, iblock, bh_result,
				   EXT4_GET_BLOCKS_IO_CREATE_EXT);
889

890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906
	/*
	 * When doing DIO using unwritten extents, we need io_end to convert
	 * unwritten extents to written on IO completion. We allocate io_end
	 * once we spot unwritten extent and store it in b_private. Generic
	 * DIO code keeps b_private set and furthermore passes the value to
	 * our completion callback in 'private' argument.
	 */
	if (!ret && buffer_unwritten(bh_result)) {
		if (!bh_result->b_private) {
			ext4_io_end_t *io_end;

			io_end = ext4_init_io_end(inode, GFP_KERNEL);
			if (!io_end)
				return -ENOMEM;
			bh_result->b_private = io_end;
			ext4_set_io_unwritten_flag(inode, io_end);
		}
907 908 909 910
		set_buffer_defer_completion(bh_result);
	}

	return ret;
911 912
}

913 914 915
/*
 * Get block function for non-AIO DIO writes when we create unwritten extent if
 * blocks are not allocated yet. The extent will be converted to written
916
 * after IO is complete by ext4_direct_IO_write().
917 918 919 920 921 922 923 924 925
 */
static int ext4_dio_get_block_unwritten_sync(struct inode *inode,
		sector_t iblock, struct buffer_head *bh_result,	int create)
{
	int ret;

	/* We don't expect handle for direct IO */
	WARN_ON_ONCE(ext4_journal_current_handle());

926 927
	ret = ext4_get_block_trans(inode, iblock, bh_result,
				   EXT4_GET_BLOCKS_IO_CREATE_EXT);
928 929 930

	/*
	 * Mark inode as having pending DIO writes to unwritten extents.
931
	 * ext4_direct_IO_write() checks this flag and converts extents to
932 933 934 935 936 937 938 939
	 * written.
	 */
	if (!ret && buffer_unwritten(bh_result))
		ext4_set_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);

	return ret;
}

940 941 942 943 944 945 946
static int ext4_dio_get_block_overwrite(struct inode *inode, sector_t iblock,
		   struct buffer_head *bh_result, int create)
{
	int ret;

	ext4_debug("ext4_dio_get_block_overwrite: inode %lu, create flag %d\n",
		   inode->i_ino, create);
947 948 949
	/* We don't expect handle for direct IO */
	WARN_ON_ONCE(ext4_journal_current_handle());

950 951 952 953 954
	ret = _ext4_get_block(inode, iblock, bh_result, 0);
	/*
	 * Blocks should have been preallocated! ext4_file_write_iter() checks
	 * that.
	 */
955
	WARN_ON_ONCE(!buffer_mapped(bh_result) || buffer_unwritten(bh_result));
956 957 958 959 960

	return ret;
}


961 962 963
/*
 * `handle' can be NULL if create is zero
 */
964
struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
965
				ext4_lblk_t block, int map_flags)
966
{
967 968
	struct ext4_map_blocks map;
	struct buffer_head *bh;
969
	int create = map_flags & EXT4_GET_BLOCKS_CREATE;
970
	int err;
971 972 973

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

974 975
	map.m_lblk = block;
	map.m_len = 1;
976
	err = ext4_map_blocks(handle, inode, &map, map_flags);
977

978 979
	if (err == 0)
		return create ? ERR_PTR(-ENOSPC) : NULL;
980
	if (err < 0)
981
		return ERR_PTR(err);
982 983

	bh = sb_getblk(inode->i_sb, map.m_pblk);
984 985
	if (unlikely(!bh))
		return ERR_PTR(-ENOMEM);
986 987 988
	if (map.m_flags & EXT4_MAP_NEW) {
		J_ASSERT(create != 0);
		J_ASSERT(handle != NULL);
989

990 991 992 993 994 995 996 997 998
		/*
		 * 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");
999 1000 1001 1002 1003 1004
		err = ext4_journal_get_create_access(handle, bh);
		if (unlikely(err)) {
			unlock_buffer(bh);
			goto errout;
		}
		if (!buffer_uptodate(bh)) {
1005 1006
			memset(bh->b_data, 0, inode->i_sb->s_blocksize);
			set_buffer_uptodate(bh);
1007
		}
1008 1009 1010
		unlock_buffer(bh);
		BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
		err = ext4_handle_dirty_metadata(handle, inode, bh);
1011 1012 1013
		if (unlikely(err))
			goto errout;
	} else
1014 1015
		BUFFER_TRACE(bh, "not a new buffer");
	return bh;
1016 1017 1018
errout:
	brelse(bh);
	return ERR_PTR(err);
1019 1020
}

1021
struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
1022
			       ext4_lblk_t block, int map_flags)
1023
{
1024
	struct buffer_head *bh;
1025

1026
	bh = ext4_getblk(handle, inode, block, map_flags);
1027
	if (IS_ERR(bh))
1028
		return bh;
1029
	if (!bh || buffer_uptodate(bh))
1030
		return bh;
1031
	ll_rw_block(REQ_OP_READ, REQ_META | REQ_PRIO, 1, &bh);
1032 1033 1034 1035
	wait_on_buffer(bh);
	if (buffer_uptodate(bh))
		return bh;
	put_bh(bh);
1036
	return ERR_PTR(-EIO);
1037 1038
}

1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082
/* Read a contiguous batch of blocks. */
int ext4_bread_batch(struct inode *inode, ext4_lblk_t block, int bh_count,
		     bool wait, struct buffer_head **bhs)
{
	int i, err;

	for (i = 0; i < bh_count; i++) {
		bhs[i] = ext4_getblk(NULL, inode, block + i, 0 /* map_flags */);
		if (IS_ERR(bhs[i])) {
			err = PTR_ERR(bhs[i]);
			bh_count = i;
			goto out_brelse;
		}
	}

	for (i = 0; i < bh_count; i++)
		/* Note that NULL bhs[i] is valid because of holes. */
		if (bhs[i] && !buffer_uptodate(bhs[i]))
			ll_rw_block(REQ_OP_READ, REQ_META | REQ_PRIO, 1,
				    &bhs[i]);

	if (!wait)
		return 0;

	for (i = 0; i < bh_count; i++)
		if (bhs[i])
			wait_on_buffer(bhs[i]);

	for (i = 0; i < bh_count; i++) {
		if (bhs[i] && !buffer_uptodate(bhs[i])) {
			err = -EIO;
			goto out_brelse;
		}
	}
	return 0;

out_brelse:
	for (i = 0; i < bh_count; i++) {
		brelse(bhs[i]);
		bhs[i] = NULL;
	}
	return err;
}

1083 1084 1085 1086 1087 1088 1089
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))
1090 1091 1092 1093 1094 1095 1096
{
	struct buffer_head *bh;
	unsigned block_start, block_end;
	unsigned blocksize = head->b_size;
	int err, ret = 0;
	struct buffer_head *next;

1097 1098
	for (bh = head, block_start = 0;
	     ret == 0 && (bh != head || !block_start);
1099
	     block_start = block_end, bh = next) {
1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
		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
1117
 * close off a transaction and start a new one between the ext4_get_block()
1118
 * and the commit_write().  So doing the jbd2_journal_start at the start of
1119 1120
 * prepare_write() is the right place.
 *
1121 1122 1123 1124
 * 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.
1125
 *
1126
 * By accident, ext4 can be reentered when a transaction is open via
1127 1128 1129 1130 1131 1132
 * 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.
 *
1133
 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
1134 1135 1136 1137
 * will _not_ run commit under these circumstances because handle->h_ref
 * is elevated.  We'll still have enough credits for the tiny quotafile
 * write.
 */
1138 1139
int do_journal_get_write_access(handle_t *handle,
				struct buffer_head *bh)
1140
{
1141 1142 1143
	int dirty = buffer_dirty(bh);
	int ret;

1144 1145
	if (!buffer_mapped(bh) || buffer_freed(bh))
		return 0;
1146
	/*
C
Christoph Hellwig 已提交
1147
	 * __block_write_begin() could have dirtied some buffers. Clean
1148 1149
	 * the dirty bit as jbd2_journal_get_write_access() could complain
	 * otherwise about fs integrity issues. Setting of the dirty bit
C
Christoph Hellwig 已提交
1150
	 * by __block_write_begin() isn't a real problem here as we clear
1151 1152 1153 1154 1155
	 * the bit before releasing a page lock and thus writeback cannot
	 * ever write the buffer.
	 */
	if (dirty)
		clear_buffer_dirty(bh);
1156
	BUFFER_TRACE(bh, "get write access");
1157 1158 1159 1160
	ret = ext4_journal_get_write_access(handle, bh);
	if (!ret && dirty)
		ret = ext4_handle_dirty_metadata(handle, NULL, bh);
	return ret;
1161 1162
}

1163 1164 1165 1166
#ifdef CONFIG_EXT4_FS_ENCRYPTION
static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
				  get_block_t *get_block)
{
1167
	unsigned from = pos & (PAGE_SIZE - 1);
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178
	unsigned to = from + len;
	struct inode *inode = page->mapping->host;
	unsigned block_start, block_end;
	sector_t block;
	int err = 0;
	unsigned blocksize = inode->i_sb->s_blocksize;
	unsigned bbits;
	struct buffer_head *bh, *head, *wait[2], **wait_bh = wait;
	bool decrypt = false;

	BUG_ON(!PageLocked(page));
1179 1180
	BUG_ON(from > PAGE_SIZE);
	BUG_ON(to > PAGE_SIZE);
1181 1182 1183 1184 1185 1186
	BUG_ON(from > to);

	if (!page_has_buffers(page))
		create_empty_buffers(page, blocksize, 0);
	head = page_buffers(page);
	bbits = ilog2(blocksize);
1187
	block = (sector_t)page->index << (PAGE_SHIFT - bbits);
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206

	for (bh = head, block_start = 0; bh != head || !block_start;
	    block++, block_start = block_end, bh = bh->b_this_page) {
		block_end = block_start + blocksize;
		if (block_end <= from || block_start >= to) {
			if (PageUptodate(page)) {
				if (!buffer_uptodate(bh))
					set_buffer_uptodate(bh);
			}
			continue;
		}
		if (buffer_new(bh))
			clear_buffer_new(bh);
		if (!buffer_mapped(bh)) {
			WARN_ON(bh->b_size != blocksize);
			err = get_block(inode, block, bh, 1);
			if (err)
				break;
			if (buffer_new(bh)) {
1207
				clean_bdev_bh_alias(bh);
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227
				if (PageUptodate(page)) {
					clear_buffer_new(bh);
					set_buffer_uptodate(bh);
					mark_buffer_dirty(bh);
					continue;
				}
				if (block_end > to || block_start < from)
					zero_user_segments(page, to, block_end,
							   block_start, from);
				continue;
			}
		}
		if (PageUptodate(page)) {
			if (!buffer_uptodate(bh))
				set_buffer_uptodate(bh);
			continue;
		}
		if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
		    !buffer_unwritten(bh) &&
		    (block_start < from || block_end > to)) {
1228
			ll_rw_block(REQ_OP_READ, 0, 1, &bh);
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244
			*wait_bh++ = bh;
			decrypt = ext4_encrypted_inode(inode) &&
				S_ISREG(inode->i_mode);
		}
	}
	/*
	 * If we issued read requests, let them complete.
	 */
	while (wait_bh > wait) {
		wait_on_buffer(*--wait_bh);
		if (!buffer_uptodate(*wait_bh))
			err = -EIO;
	}
	if (unlikely(err))
		page_zero_new_buffers(page, from, to);
	else if (decrypt)
1245
		err = fscrypt_decrypt_page(page->mapping->host, page,
1246
				PAGE_SIZE, 0, page->index);
1247 1248 1249 1250
	return err;
}
#endif

N
Nick Piggin 已提交
1251
static int ext4_write_begin(struct file *file, struct address_space *mapping,
1252 1253
			    loff_t pos, unsigned len, unsigned flags,
			    struct page **pagep, void **fsdata)
1254
{
1255
	struct inode *inode = mapping->host;
1256
	int ret, needed_blocks;
1257 1258
	handle_t *handle;
	int retries = 0;
1259
	struct page *page;
1260
	pgoff_t index;
1261
	unsigned from, to;
N
Nick Piggin 已提交
1262

1263 1264 1265
	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
		return -EIO;

1266
	trace_ext4_write_begin(inode, pos, len, flags);
1267 1268 1269 1270 1271
	/*
	 * 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;
1272 1273
	index = pos >> PAGE_SHIFT;
	from = pos & (PAGE_SIZE - 1);
1274
	to = from + len;
1275

1276 1277 1278 1279
	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)
1280 1281 1282
			return ret;
		if (ret == 1)
			return 0;
1283 1284
	}

1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
	/*
	 * grab_cache_page_write_begin() can take a long time if the
	 * system is thrashing due to memory pressure, or if the page
	 * is being written back.  So grab it first before we start
	 * the transaction handle.  This also allows us to allocate
	 * the page (if needed) without using GFP_NOFS.
	 */
retry_grab:
	page = grab_cache_page_write_begin(mapping, index, flags);
	if (!page)
		return -ENOMEM;
	unlock_page(page);

retry_journal:
1299
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
1300
	if (IS_ERR(handle)) {
1301
		put_page(page);
1302
		return PTR_ERR(handle);
1303
	}
1304

1305 1306 1307 1308
	lock_page(page);
	if (page->mapping != mapping) {
		/* The page got truncated from under us */
		unlock_page(page);
1309
		put_page(page);
1310
		ext4_journal_stop(handle);
1311
		goto retry_grab;
1312
	}
1313 1314
	/* In case writeback began while the page was unlocked */
	wait_for_stable_page(page);
1315

1316 1317 1318
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	if (ext4_should_dioread_nolock(inode))
		ret = ext4_block_write_begin(page, pos, len,
1319
					     ext4_get_block_unwritten);
1320 1321 1322 1323
	else
		ret = ext4_block_write_begin(page, pos, len,
					     ext4_get_block);
#else
1324
	if (ext4_should_dioread_nolock(inode))
1325 1326
		ret = __block_write_begin(page, pos, len,
					  ext4_get_block_unwritten);
1327
	else
1328
		ret = __block_write_begin(page, pos, len, ext4_get_block);
1329
#endif
N
Nick Piggin 已提交
1330
	if (!ret && ext4_should_journal_data(inode)) {
1331 1332 1333
		ret = ext4_walk_page_buffers(handle, page_buffers(page),
					     from, to, NULL,
					     do_journal_get_write_access);
1334
	}
N
Nick Piggin 已提交
1335 1336

	if (ret) {
1337
		unlock_page(page);
1338
		/*
1339
		 * __block_write_begin may have instantiated a few blocks
1340 1341
		 * outside i_size.  Trim these off again. Don't need
		 * i_size_read because we hold i_mutex.
1342 1343 1344
		 *
		 * Add inode to orphan list in case we crash before
		 * truncate finishes
1345
		 */
1346
		if (pos + len > inode->i_size && ext4_can_truncate(inode))
1347 1348 1349 1350
			ext4_orphan_add(handle, inode);

		ext4_journal_stop(handle);
		if (pos + len > inode->i_size) {
1351
			ext4_truncate_failed_write(inode);
1352
			/*
1353
			 * If truncate failed early the inode might
1354 1355 1356 1357 1358 1359 1360
			 * 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 已提交
1361

1362 1363 1364
		if (ret == -ENOSPC &&
		    ext4_should_retry_alloc(inode->i_sb, &retries))
			goto retry_journal;
1365
		put_page(page);
1366 1367 1368
		return ret;
	}
	*pagep = page;
1369 1370 1371
	return ret;
}

N
Nick Piggin 已提交
1372 1373
/* For write_end() in data=journal mode */
static int write_end_fn(handle_t *handle, struct buffer_head *bh)
1374
{
1375
	int ret;
1376 1377 1378
	if (!buffer_mapped(bh) || buffer_freed(bh))
		return 0;
	set_buffer_uptodate(bh);
1379 1380 1381 1382
	ret = ext4_handle_dirty_metadata(handle, NULL, bh);
	clear_buffer_meta(bh);
	clear_buffer_prio(bh);
	return ret;
1383 1384
}

1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395
/*
 * 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().
 *
 * ext4 never places buffers on inode->i_mapping->private_list.  metadata
 * buffers are managed internally.
 */
static int ext4_write_end(struct file *file,
			  struct address_space *mapping,
			  loff_t pos, unsigned len, unsigned copied,
			  struct page *page, void *fsdata)
1396 1397
{
	handle_t *handle = ext4_journal_current_handle();
1398
	struct inode *inode = mapping->host;
1399
	loff_t old_size = inode->i_size;
1400 1401
	int ret = 0, ret2;
	int i_size_changed = 0;
1402
	int inline_data = ext4_has_inline_data(inode);
1403 1404

	trace_ext4_write_end(inode, pos, len, copied);
1405
	if (inline_data) {
1406 1407
		ret = ext4_write_inline_data_end(inode, pos, len,
						 copied, page);
1408 1409 1410
		if (ret < 0) {
			unlock_page(page);
			put_page(page);
1411
			goto errout;
1412
		}
1413 1414
		copied = ret;
	} else
1415 1416
		copied = block_write_end(file, mapping, pos,
					 len, copied, page, fsdata);
1417
	/*
1418
	 * it's important to update i_size while still holding page lock:
1419 1420
	 * page writeout could otherwise come in and zero beyond i_size.
	 */
1421
	i_size_changed = ext4_update_inode_size(inode, pos + copied);
1422
	unlock_page(page);
1423
	put_page(page);
1424

1425 1426
	if (old_size < pos)
		pagecache_isize_extended(inode, old_size, pos);
1427 1428 1429 1430 1431 1432
	/*
	 * 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.
	 */
1433
	if (i_size_changed || inline_data)
1434 1435
		ext4_mark_inode_dirty(handle, inode);

1436
	if (pos + len > inode->i_size && ext4_can_truncate(inode))
1437 1438 1439 1440 1441
		/* 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);
1442
errout:
1443
	ret2 = ext4_journal_stop(handle);
1444 1445
	if (!ret)
		ret = ret2;
N
Nick Piggin 已提交
1446

1447
	if (pos + len > inode->i_size) {
1448
		ext4_truncate_failed_write(inode);
1449
		/*
1450
		 * If truncate failed early the inode might still be
1451 1452 1453 1454 1455 1456 1457
		 * 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 已提交
1458
	return ret ? ret : copied;
1459 1460
}

1461 1462 1463 1464 1465
/*
 * This is a private version of page_zero_new_buffers() which doesn't
 * set the buffer to be dirty, since in data=journalled mode we need
 * to call ext4_handle_dirty_metadata() instead.
 */
1466 1467 1468
static void ext4_journalled_zero_new_buffers(handle_t *handle,
					    struct page *page,
					    unsigned from, unsigned to)
1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
{
	unsigned int block_start = 0, block_end;
	struct buffer_head *head, *bh;

	bh = head = page_buffers(page);
	do {
		block_end = block_start + bh->b_size;
		if (buffer_new(bh)) {
			if (block_end > from && block_start < to) {
				if (!PageUptodate(page)) {
					unsigned start, size;

					start = max(from, block_start);
					size = min(to, block_end) - start;

					zero_user(page, start, size);
1485
					write_end_fn(handle, bh);
1486 1487 1488 1489 1490 1491 1492 1493 1494
				}
				clear_buffer_new(bh);
			}
		}
		block_start = block_end;
		bh = bh->b_this_page;
	} while (bh != head);
}

N
Nick Piggin 已提交
1495
static int ext4_journalled_write_end(struct file *file,
1496 1497 1498
				     struct address_space *mapping,
				     loff_t pos, unsigned len, unsigned copied,
				     struct page *page, void *fsdata)
1499
{
1500
	handle_t *handle = ext4_journal_current_handle();
N
Nick Piggin 已提交
1501
	struct inode *inode = mapping->host;
1502
	loff_t old_size = inode->i_size;
1503 1504
	int ret = 0, ret2;
	int partial = 0;
N
Nick Piggin 已提交
1505
	unsigned from, to;
1506
	int size_changed = 0;
1507
	int inline_data = ext4_has_inline_data(inode);
1508

1509
	trace_ext4_journalled_write_end(inode, pos, len, copied);
1510
	from = pos & (PAGE_SIZE - 1);
N
Nick Piggin 已提交
1511 1512
	to = from + len;

1513 1514
	BUG_ON(!ext4_handle_valid(handle));

1515
	if (inline_data) {
1516 1517 1518 1519 1520 1521 1522 1523 1524
		ret = ext4_write_inline_data_end(inode, pos, len,
						 copied, page);
		if (ret < 0) {
			unlock_page(page);
			put_page(page);
			goto errout;
		}
		copied = ret;
	} else if (unlikely(copied < len) && !PageUptodate(page)) {
1525 1526 1527 1528 1529 1530
		copied = 0;
		ext4_journalled_zero_new_buffers(handle, page, from, to);
	} else {
		if (unlikely(copied < len))
			ext4_journalled_zero_new_buffers(handle, page,
							 from + copied, to);
1531
		ret = ext4_walk_page_buffers(handle, page_buffers(page), from,
1532 1533
					     from + copied, &partial,
					     write_end_fn);
1534 1535 1536
		if (!partial)
			SetPageUptodate(page);
	}
1537
	size_changed = ext4_update_inode_size(inode, pos + copied);
1538
	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
1539
	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1540
	unlock_page(page);
1541
	put_page(page);
1542

1543 1544 1545
	if (old_size < pos)
		pagecache_isize_extended(inode, old_size, pos);

1546
	if (size_changed || inline_data) {
1547
		ret2 = ext4_mark_inode_dirty(handle, inode);
1548 1549 1550
		if (!ret)
			ret = ret2;
	}
N
Nick Piggin 已提交
1551

1552
	if (pos + len > inode->i_size && ext4_can_truncate(inode))
1553 1554 1555 1556 1557 1558
		/* 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);

1559
errout:
1560
	ret2 = ext4_journal_stop(handle);
1561 1562
	if (!ret)
		ret = ret2;
1563
	if (pos + len > inode->i_size) {
1564
		ext4_truncate_failed_write(inode);
1565
		/*
1566
		 * If truncate failed early the inode might still be
1567 1568 1569 1570 1571 1572
		 * 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 已提交
1573 1574

	return ret ? ret : copied;
1575
}
1576

1577
/*
1578
 * Reserve space for a single cluster
1579
 */
1580
static int ext4_da_reserve_space(struct inode *inode)
1581
{
1582
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1583
	struct ext4_inode_info *ei = EXT4_I(inode);
1584
	int ret;
1585 1586 1587 1588 1589 1590 1591 1592 1593

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

1595
	spin_lock(&ei->i_block_reservation_lock);
1596
	if (ext4_claim_free_clusters(sbi, 1, 0)) {
1597 1598
		spin_unlock(&ei->i_block_reservation_lock);
		dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1));
1599 1600
		return -ENOSPC;
	}
1601
	ei->i_reserved_data_blocks++;
1602
	trace_ext4_da_reserve_space(inode);
1603
	spin_unlock(&ei->i_block_reservation_lock);
1604

1605 1606 1607
	return 0;       /* success */
}

1608
static void ext4_da_release_space(struct inode *inode, int to_free)
1609 1610
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1611
	struct ext4_inode_info *ei = EXT4_I(inode);
1612

1613 1614 1615
	if (!to_free)
		return;		/* Nothing to release, exit */

1616
	spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1617

L
Li Zefan 已提交
1618
	trace_ext4_da_release_space(inode, to_free);
1619
	if (unlikely(to_free > ei->i_reserved_data_blocks)) {
1620
		/*
1621 1622 1623 1624
		 * 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.
1625
		 */
1626
		ext4_warning(inode->i_sb, "ext4_da_release_space: "
1627
			 "ino %lu, to_free %d with only %d reserved "
1628
			 "data blocks", inode->i_ino, to_free,
1629 1630 1631
			 ei->i_reserved_data_blocks);
		WARN_ON(1);
		to_free = ei->i_reserved_data_blocks;
1632
	}
1633
	ei->i_reserved_data_blocks -= to_free;
1634

1635
	/* update fs dirty data blocks counter */
1636
	percpu_counter_sub(&sbi->s_dirtyclusters_counter, to_free);
1637 1638

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

1640
	dquot_release_reservation_block(inode, EXT4_C2B(sbi, to_free));
1641 1642 1643
}

static void ext4_da_page_release_reservation(struct page *page,
1644 1645
					     unsigned int offset,
					     unsigned int length)
1646
{
1647
	int to_release = 0, contiguous_blks = 0;
1648 1649
	struct buffer_head *head, *bh;
	unsigned int curr_off = 0;
1650 1651
	struct inode *inode = page->mapping->host;
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1652
	unsigned int stop = offset + length;
1653
	int num_clusters;
1654
	ext4_fsblk_t lblk;
1655

1656
	BUG_ON(stop > PAGE_SIZE || stop < length);
1657

1658 1659 1660 1661 1662
	head = page_buffers(page);
	bh = head;
	do {
		unsigned int next_off = curr_off + bh->b_size;

1663 1664 1665
		if (next_off > stop)
			break;

1666 1667
		if ((offset <= curr_off) && (buffer_delay(bh))) {
			to_release++;
1668
			contiguous_blks++;
1669
			clear_buffer_delay(bh);
1670 1671
		} else if (contiguous_blks) {
			lblk = page->index <<
1672
			       (PAGE_SHIFT - inode->i_blkbits);
1673 1674 1675 1676
			lblk += (curr_off >> inode->i_blkbits) -
				contiguous_blks;
			ext4_es_remove_extent(inode, lblk, contiguous_blks);
			contiguous_blks = 0;
1677 1678 1679
		}
		curr_off = next_off;
	} while ((bh = bh->b_this_page) != head);
1680

1681
	if (contiguous_blks) {
1682
		lblk = page->index << (PAGE_SHIFT - inode->i_blkbits);
1683 1684
		lblk += (curr_off >> inode->i_blkbits) - contiguous_blks;
		ext4_es_remove_extent(inode, lblk, contiguous_blks);
1685 1686
	}

1687 1688 1689 1690
	/* 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) {
1691
		lblk = (page->index << (PAGE_SHIFT - inode->i_blkbits)) +
1692 1693
			((num_clusters - 1) << sbi->s_cluster_bits);
		if (sbi->s_cluster_ratio == 1 ||
1694
		    !ext4_find_delalloc_cluster(inode, lblk))
1695 1696 1697 1698
			ext4_da_release_space(inode, 1);

		num_clusters--;
	}
1699
}
1700

1701 1702 1703 1704
/*
 * Delayed allocation stuff
 */

J
Jan Kara 已提交
1705 1706 1707
struct mpage_da_data {
	struct inode *inode;
	struct writeback_control *wbc;
1708

J
Jan Kara 已提交
1709 1710 1711
	pgoff_t first_page;	/* The first page to write */
	pgoff_t next_page;	/* Current page to examine */
	pgoff_t last_page;	/* Last page to examine */
1712
	/*
J
Jan Kara 已提交
1713 1714 1715
	 * Extent to map - this can be after first_page because that can be
	 * fully mapped. We somewhat abuse m_flags to store whether the extent
	 * is delalloc or unwritten.
1716
	 */
J
Jan Kara 已提交
1717 1718
	struct ext4_map_blocks map;
	struct ext4_io_submit io_submit;	/* IO submission data */
1719
	unsigned int do_map:1;
J
Jan Kara 已提交
1720
};
1721

J
Jan Kara 已提交
1722 1723
static void mpage_release_unused_pages(struct mpage_da_data *mpd,
				       bool invalidate)
1724 1725 1726 1727 1728 1729
{
	int nr_pages, i;
	pgoff_t index, end;
	struct pagevec pvec;
	struct inode *inode = mpd->inode;
	struct address_space *mapping = inode->i_mapping;
J
Jan Kara 已提交
1730 1731 1732 1733

	/* This is necessary when next_page == 0. */
	if (mpd->first_page >= mpd->next_page)
		return;
1734

1735 1736
	index = mpd->first_page;
	end   = mpd->next_page - 1;
J
Jan Kara 已提交
1737 1738
	if (invalidate) {
		ext4_lblk_t start, last;
1739 1740
		start = index << (PAGE_SHIFT - inode->i_blkbits);
		last = end << (PAGE_SHIFT - inode->i_blkbits);
J
Jan Kara 已提交
1741 1742
		ext4_es_remove_extent(inode, start, last - start + 1);
	}
1743

1744
	pagevec_init(&pvec);
1745
	while (index <= end) {
1746
		nr_pages = pagevec_lookup_range(&pvec, mapping, &index, end);
1747 1748 1749 1750
		if (nr_pages == 0)
			break;
		for (i = 0; i < nr_pages; i++) {
			struct page *page = pvec.pages[i];
1751

1752 1753
			BUG_ON(!PageLocked(page));
			BUG_ON(PageWriteback(page));
J
Jan Kara 已提交
1754
			if (invalidate) {
1755 1756
				if (page_mapped(page))
					clear_page_dirty_for_io(page);
1757
				block_invalidatepage(page, 0, PAGE_SIZE);
J
Jan Kara 已提交
1758 1759
				ClearPageUptodate(page);
			}
1760 1761
			unlock_page(page);
		}
1762
		pagevec_release(&pvec);
1763 1764 1765
	}
}

1766 1767 1768
static void ext4_print_free_blocks(struct inode *inode)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1769
	struct super_block *sb = inode->i_sb;
1770
	struct ext4_inode_info *ei = EXT4_I(inode);
1771 1772

	ext4_msg(sb, KERN_CRIT, "Total free blocks count %lld",
1773
	       EXT4_C2B(EXT4_SB(inode->i_sb),
1774
			ext4_count_free_clusters(sb)));
1775 1776
	ext4_msg(sb, KERN_CRIT, "Free/Dirty block details");
	ext4_msg(sb, KERN_CRIT, "free_blocks=%lld",
1777
	       (long long) EXT4_C2B(EXT4_SB(sb),
1778
		percpu_counter_sum(&sbi->s_freeclusters_counter)));
1779
	ext4_msg(sb, KERN_CRIT, "dirty_blocks=%lld",
1780
	       (long long) EXT4_C2B(EXT4_SB(sb),
1781
		percpu_counter_sum(&sbi->s_dirtyclusters_counter)));
1782 1783
	ext4_msg(sb, KERN_CRIT, "Block reservation details");
	ext4_msg(sb, KERN_CRIT, "i_reserved_data_blocks=%u",
1784
		 ei->i_reserved_data_blocks);
1785 1786 1787
	return;
}

1788
static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
1789
{
1790
	return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh);
1791 1792
}

1793 1794 1795 1796 1797 1798 1799 1800 1801 1802
/*
 * 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)
{
1803
	struct extent_status es;
1804 1805
	int retval;
	sector_t invalid_block = ~((sector_t) 0xffff);
1806 1807 1808 1809 1810
#ifdef ES_AGGRESSIVE_TEST
	struct ext4_map_blocks orig_map;

	memcpy(&orig_map, map, sizeof(*map));
#endif
1811 1812 1813 1814 1815 1816 1817 1818

	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);
1819 1820 1821 1822 1823

	/* Lookup extent status tree firstly */
	if (ext4_es_lookup_extent(inode, iblock, &es)) {
		if (ext4_es_is_hole(&es)) {
			retval = 0;
1824
			down_read(&EXT4_I(inode)->i_data_sem);
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850
			goto add_delayed;
		}

		/*
		 * Delayed extent could be allocated by fallocate.
		 * So we need to check it.
		 */
		if (ext4_es_is_delayed(&es) && !ext4_es_is_unwritten(&es)) {
			map_bh(bh, inode->i_sb, invalid_block);
			set_buffer_new(bh);
			set_buffer_delay(bh);
			return 0;
		}

		map->m_pblk = ext4_es_pblock(&es) + iblock - es.es_lblk;
		retval = es.es_len - (iblock - es.es_lblk);
		if (retval > map->m_len)
			retval = map->m_len;
		map->m_len = retval;
		if (ext4_es_is_written(&es))
			map->m_flags |= EXT4_MAP_MAPPED;
		else if (ext4_es_is_unwritten(&es))
			map->m_flags |= EXT4_MAP_UNWRITTEN;
		else
			BUG_ON(1);

1851 1852 1853
#ifdef ES_AGGRESSIVE_TEST
		ext4_map_blocks_es_recheck(NULL, inode, map, &orig_map, 0);
#endif
1854 1855 1856
		return retval;
	}

1857 1858 1859 1860
	/*
	 * Try to see if we can get the block without requesting a new
	 * file system block.
	 */
1861
	down_read(&EXT4_I(inode)->i_data_sem);
1862
	if (ext4_has_inline_data(inode))
1863
		retval = 0;
1864
	else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
1865
		retval = ext4_ext_map_blocks(NULL, inode, map, 0);
1866
	else
1867
		retval = ext4_ind_map_blocks(NULL, inode, map, 0);
1868

1869
add_delayed:
1870
	if (retval == 0) {
1871
		int ret;
1872 1873 1874 1875
		/*
		 * XXX: __block_prepare_write() unmaps passed block,
		 * is it OK?
		 */
1876 1877 1878 1879 1880
		/*
		 * If the block was allocated from previously allocated cluster,
		 * then we don't need to reserve it again. However we still need
		 * to reserve metadata for every block we're going to write.
		 */
1881
		if (EXT4_SB(inode->i_sb)->s_cluster_ratio == 1 ||
1882
		    !ext4_find_delalloc_cluster(inode, map->m_lblk)) {
1883
			ret = ext4_da_reserve_space(inode);
1884
			if (ret) {
1885
				/* not enough space to reserve */
1886
				retval = ret;
1887
				goto out_unlock;
1888
			}
1889 1890
		}

1891 1892 1893 1894
		ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len,
					    ~0, EXTENT_STATUS_DELAYED);
		if (ret) {
			retval = ret;
1895
			goto out_unlock;
1896
		}
1897

1898 1899 1900
		map_bh(bh, inode->i_sb, invalid_block);
		set_buffer_new(bh);
		set_buffer_delay(bh);
1901 1902
	} else if (retval > 0) {
		int ret;
1903
		unsigned int status;
1904

1905 1906 1907 1908 1909 1910
		if (unlikely(retval != map->m_len)) {
			ext4_warning(inode->i_sb,
				     "ES len assertion failed for inode "
				     "%lu: retval %d != map->m_len %d",
				     inode->i_ino, retval, map->m_len);
			WARN_ON(1);
1911 1912
		}

1913 1914 1915 1916 1917 1918
		status = map->m_flags & EXT4_MAP_UNWRITTEN ?
				EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
		ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len,
					    map->m_pblk, status);
		if (ret != 0)
			retval = ret;
1919 1920 1921 1922 1923 1924 1925 1926
	}

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

	return retval;
}

1927
/*
1928
 * This is a special get_block_t callback which is used by
1929 1930
 * ext4_da_write_begin().  It will either return mapped block or
 * reserve space for a single block.
1931 1932 1933 1934 1935 1936 1937
 *
 * 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.
1938
 */
1939 1940
int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int create)
1941
{
1942
	struct ext4_map_blocks map;
1943 1944 1945
	int ret = 0;

	BUG_ON(create == 0);
1946 1947 1948 1949
	BUG_ON(bh->b_size != inode->i_sb->s_blocksize);

	map.m_lblk = iblock;
	map.m_len = 1;
1950 1951 1952 1953 1954 1955

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

1960
	map_bh(bh, inode->i_sb, map.m_pblk);
J
Jan Kara 已提交
1961
	ext4_update_bh_state(bh, map.m_flags);
1962 1963 1964 1965 1966 1967 1968 1969 1970

	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);
1971
		set_buffer_mapped(bh);
1972 1973
	}
	return 0;
1974
}
1975

1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
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;
1993
	struct buffer_head *page_bufs = NULL;
1994
	handle_t *handle = NULL;
1995 1996 1997
	int ret = 0, err = 0;
	int inline_data = ext4_has_inline_data(inode);
	struct buffer_head *inode_bh = NULL;
1998

1999
	ClearPageChecked(page);
2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015

	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);
	}
2016 2017 2018 2019 2020 2021
	/*
	 * We need to release the page lock before we start the
	 * journal, so grab a reference so the page won't disappear
	 * out from under us.
	 */
	get_page(page);
2022 2023
	unlock_page(page);

2024 2025
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
				    ext4_writepage_trans_blocks(inode));
2026 2027
	if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
2028 2029
		put_page(page);
		goto out_no_pagelock;
2030
	}
2031 2032
	BUG_ON(!ext4_handle_valid(handle));

2033 2034 2035 2036 2037 2038 2039 2040 2041
	lock_page(page);
	put_page(page);
	if (page->mapping != mapping) {
		/* The page got truncated from under us */
		ext4_journal_stop(handle);
		ret = 0;
		goto out;
	}

2042
	if (inline_data) {
2043
		ret = ext4_mark_inode_dirty(handle, inode);
2044 2045 2046 2047 2048 2049 2050
	} 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);
	}
2051 2052
	if (ret == 0)
		ret = err;
2053
	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
2054 2055 2056 2057
	err = ext4_journal_stop(handle);
	if (!ret)
		ret = err;

2058
	if (!ext4_has_inline_data(inode))
2059
		ext4_walk_page_buffers(NULL, page_bufs, 0, len,
2060
				       NULL, bput_one);
2061
	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
2062
out:
2063 2064
	unlock_page(page);
out_no_pagelock:
2065
	brelse(inode_bh);
2066 2067 2068
	return ret;
}

2069
/*
2070 2071 2072 2073
 * 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 已提交
2074
 * we are writing back data modified via mmap(), no one guarantees in which
2075 2076 2077 2078
 * 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.
 *
2079
 * This function can get called via...
2080
 *   - ext4_writepages after taking page lock (have journal handle)
2081
 *   - journal_submit_inode_data_buffers (no journal handle)
2082
 *   - shrink_page_list via the kswapd/direct reclaim (no journal handle)
2083
 *   - grab_page_cache when doing write_begin (have journal handle)
2084 2085 2086 2087 2088 2089 2090 2091 2092
 *
 * 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
2093
 * but other buffer_heads would be unmapped but dirty (dirty done via the
2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108
 * 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.
2109
 */
2110
static int ext4_writepage(struct page *page,
2111
			  struct writeback_control *wbc)
2112
{
2113
	int ret = 0;
2114
	loff_t size;
2115
	unsigned int len;
2116
	struct buffer_head *page_bufs = NULL;
2117
	struct inode *inode = page->mapping->host;
2118
	struct ext4_io_submit io_submit;
2119
	bool keep_towrite = false;
2120

2121 2122 2123 2124 2125 2126
	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) {
		ext4_invalidatepage(page, 0, PAGE_SIZE);
		unlock_page(page);
		return -EIO;
	}

L
Lukas Czerner 已提交
2127
	trace_ext4_writepage(page);
2128
	size = i_size_read(inode);
2129 2130
	if (page->index == size >> PAGE_SHIFT)
		len = size & ~PAGE_MASK;
2131
	else
2132
		len = PAGE_SIZE;
2133

T
Theodore Ts'o 已提交
2134 2135
	page_bufs = page_buffers(page);
	/*
2136 2137 2138 2139 2140
	 * We cannot do block allocation or other extent handling in this
	 * function. If there are buffers needing that, we have to redirty
	 * the page. But we may reach here when we do a journal commit via
	 * journal_submit_inode_data_buffers() and in that case we must write
	 * allocated buffers to achieve data=ordered mode guarantees.
2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
	 *
	 * Also, if there is only one buffer per page (the fs block
	 * size == the page size), if one buffer needs block
	 * allocation or needs to modify the extent tree to clear the
	 * unwritten flag, we know that the page can't be written at
	 * all, so we might as well refuse the write immediately.
	 * Unfortunately if the block size != page size, we can't as
	 * easily detect this case using ext4_walk_page_buffers(), but
	 * for the extremely common case, this is an optimization that
	 * skips a useless round trip through ext4_bio_write_page().
T
Theodore Ts'o 已提交
2151
	 */
2152 2153
	if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL,
				   ext4_bh_delay_or_unwritten)) {
2154
		redirty_page_for_writepage(wbc, page);
2155
		if ((current->flags & PF_MEMALLOC) ||
2156
		    (inode->i_sb->s_blocksize == PAGE_SIZE)) {
2157 2158 2159 2160 2161 2162 2163
			/*
			 * For memory cleaning there's no point in writing only
			 * some buffers. So just bail out. Warn if we came here
			 * from direct reclaim.
			 */
			WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD))
							== PF_MEMALLOC);
2164 2165 2166
			unlock_page(page);
			return 0;
		}
2167
		keep_towrite = true;
T
Theodore Ts'o 已提交
2168
	}
2169

2170
	if (PageChecked(page) && ext4_should_journal_data(inode))
2171 2172 2173 2174
		/*
		 * It's mmapped pagecache.  Add buffers and journal it.  There
		 * doesn't seem much point in redirtying the page here.
		 */
2175
		return __ext4_journalled_writepage(page, len);
2176

J
Jan Kara 已提交
2177 2178 2179 2180 2181 2182 2183
	ext4_io_submit_init(&io_submit, wbc);
	io_submit.io_end = ext4_init_io_end(inode, GFP_NOFS);
	if (!io_submit.io_end) {
		redirty_page_for_writepage(wbc, page);
		unlock_page(page);
		return -ENOMEM;
	}
2184
	ret = ext4_bio_write_page(&io_submit, page, len, wbc, keep_towrite);
2185
	ext4_io_submit(&io_submit);
J
Jan Kara 已提交
2186 2187
	/* Drop io_end reference we got from init */
	ext4_put_io_end_defer(io_submit.io_end);
2188 2189 2190
	return ret;
}

2191 2192 2193
static int mpage_submit_page(struct mpage_da_data *mpd, struct page *page)
{
	int len;
2194
	loff_t size;
2195 2196 2197
	int err;

	BUG_ON(page->index != mpd->first_page);
2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212
	clear_page_dirty_for_io(page);
	/*
	 * We have to be very careful here!  Nothing protects writeback path
	 * against i_size changes and the page can be writeably mapped into
	 * page tables. So an application can be growing i_size and writing
	 * data through mmap while writeback runs. clear_page_dirty_for_io()
	 * write-protects our page in page tables and the page cannot get
	 * written to again until we release page lock. So only after
	 * clear_page_dirty_for_io() we are safe to sample i_size for
	 * ext4_bio_write_page() to zero-out tail of the written page. We rely
	 * on the barrier provided by TestClearPageDirty in
	 * clear_page_dirty_for_io() to make sure i_size is really sampled only
	 * after page tables are updated.
	 */
	size = i_size_read(mpd->inode);
2213 2214
	if (page->index == size >> PAGE_SHIFT)
		len = size & ~PAGE_MASK;
2215
	else
2216
		len = PAGE_SIZE;
2217
	err = ext4_bio_write_page(&mpd->io_submit, page, len, mpd->wbc, false);
2218 2219 2220 2221 2222 2223 2224
	if (!err)
		mpd->wbc->nr_to_write--;
	mpd->first_page++;

	return err;
}

J
Jan Kara 已提交
2225 2226
#define BH_FLAGS ((1 << BH_Unwritten) | (1 << BH_Delay))

2227
/*
2228 2229
 * mballoc gives us at most this number of blocks...
 * XXX: That seems to be only a limitation of ext4_mb_normalize_request().
2230
 * The rest of mballoc seems to handle chunks up to full group size.
2231
 */
2232
#define MAX_WRITEPAGES_EXTENT_LEN 2048
2233

J
Jan Kara 已提交
2234 2235 2236 2237 2238
/*
 * mpage_add_bh_to_extent - try to add bh to extent of blocks to map
 *
 * @mpd - extent of blocks
 * @lblk - logical number of the block in the file
2239
 * @bh - buffer head we want to add to the extent
J
Jan Kara 已提交
2240
 *
2241 2242 2243 2244 2245 2246
 * The function is used to collect contig. blocks in the same state. If the
 * buffer doesn't require mapping for writeback and we haven't started the
 * extent of buffers to map yet, the function returns 'true' immediately - the
 * caller can write the buffer right away. Otherwise the function returns true
 * if the block has been added to the extent, false if the block couldn't be
 * added.
J
Jan Kara 已提交
2247
 */
2248 2249
static bool mpage_add_bh_to_extent(struct mpage_da_data *mpd, ext4_lblk_t lblk,
				   struct buffer_head *bh)
J
Jan Kara 已提交
2250 2251 2252
{
	struct ext4_map_blocks *map = &mpd->map;

2253 2254 2255 2256 2257 2258 2259 2260
	/* Buffer that doesn't need mapping for writeback? */
	if (!buffer_dirty(bh) || !buffer_mapped(bh) ||
	    (!buffer_delay(bh) && !buffer_unwritten(bh))) {
		/* So far no extent to map => we write the buffer right away */
		if (map->m_len == 0)
			return true;
		return false;
	}
J
Jan Kara 已提交
2261 2262 2263

	/* First block in the extent? */
	if (map->m_len == 0) {
2264 2265 2266
		/* We cannot map unless handle is started... */
		if (!mpd->do_map)
			return false;
J
Jan Kara 已提交
2267 2268
		map->m_lblk = lblk;
		map->m_len = 1;
2269 2270
		map->m_flags = bh->b_state & BH_FLAGS;
		return true;
J
Jan Kara 已提交
2271 2272
	}

2273 2274 2275 2276
	/* Don't go larger than mballoc is willing to allocate */
	if (map->m_len >= MAX_WRITEPAGES_EXTENT_LEN)
		return false;

J
Jan Kara 已提交
2277 2278
	/* Can we merge the block to our big extent? */
	if (lblk == map->m_lblk + map->m_len &&
2279
	    (bh->b_state & BH_FLAGS) == map->m_flags) {
J
Jan Kara 已提交
2280
		map->m_len++;
2281
		return true;
J
Jan Kara 已提交
2282
	}
2283
	return false;
J
Jan Kara 已提交
2284 2285
}

2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305
/*
 * mpage_process_page_bufs - submit page buffers for IO or add them to extent
 *
 * @mpd - extent of blocks for mapping
 * @head - the first buffer in the page
 * @bh - buffer we should start processing from
 * @lblk - logical number of the block in the file corresponding to @bh
 *
 * Walk through page buffers from @bh upto @head (exclusive) and either submit
 * the page for IO if all buffers in this page were mapped and there's no
 * accumulated extent of buffers to map or add buffers in the page to the
 * extent of buffers to map. The function returns 1 if the caller can continue
 * by processing the next page, 0 if it should stop adding buffers to the
 * extent to map because we cannot extend it anymore. It can also return value
 * < 0 in case of error during IO submission.
 */
static int mpage_process_page_bufs(struct mpage_da_data *mpd,
				   struct buffer_head *head,
				   struct buffer_head *bh,
				   ext4_lblk_t lblk)
J
Jan Kara 已提交
2306 2307
{
	struct inode *inode = mpd->inode;
2308
	int err;
F
Fabian Frederick 已提交
2309
	ext4_lblk_t blocks = (i_size_read(inode) + i_blocksize(inode) - 1)
J
Jan Kara 已提交
2310 2311 2312 2313 2314
							>> inode->i_blkbits;

	do {
		BUG_ON(buffer_locked(bh));

2315
		if (lblk >= blocks || !mpage_add_bh_to_extent(mpd, lblk, bh)) {
J
Jan Kara 已提交
2316 2317
			/* Found extent to map? */
			if (mpd->map.m_len)
2318
				return 0;
2319 2320 2321
			/* Buffer needs mapping and handle is not started? */
			if (!mpd->do_map)
				return 0;
2322
			/* Everything mapped so far and we hit EOF */
2323
			break;
J
Jan Kara 已提交
2324 2325
		}
	} while (lblk++, (bh = bh->b_this_page) != head);
2326 2327 2328 2329 2330 2331 2332
	/* So far everything mapped? Submit the page for IO. */
	if (mpd->map.m_len == 0) {
		err = mpage_submit_page(mpd, head->b_page);
		if (err < 0)
			return err;
	}
	return lblk < blocks;
J
Jan Kara 已提交
2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343
}

/*
 * mpage_map_buffers - update buffers corresponding to changed extent and
 *		       submit fully mapped pages for IO
 *
 * @mpd - description of extent to map, on return next extent to map
 *
 * Scan buffers corresponding to changed extent (we expect corresponding pages
 * to be already locked) and update buffer state according to new extent state.
 * We map delalloc buffers to their physical location, clear unwritten bits,
2344
 * and mark buffers as uninit when we perform writes to unwritten extents
J
Jan Kara 已提交
2345 2346 2347 2348 2349 2350 2351 2352 2353 2354
 * and do extent conversion after IO is finished. If the last page is not fully
 * mapped, we update @map to the next extent in the last page that needs
 * mapping. Otherwise we submit the page for IO.
 */
static int mpage_map_and_submit_buffers(struct mpage_da_data *mpd)
{
	struct pagevec pvec;
	int nr_pages, i;
	struct inode *inode = mpd->inode;
	struct buffer_head *head, *bh;
2355
	int bpp_bits = PAGE_SHIFT - inode->i_blkbits;
J
Jan Kara 已提交
2356 2357 2358 2359 2360 2361 2362 2363 2364 2365
	pgoff_t start, end;
	ext4_lblk_t lblk;
	sector_t pblock;
	int err;

	start = mpd->map.m_lblk >> bpp_bits;
	end = (mpd->map.m_lblk + mpd->map.m_len - 1) >> bpp_bits;
	lblk = start << bpp_bits;
	pblock = mpd->map.m_pblk;

2366
	pagevec_init(&pvec);
J
Jan Kara 已提交
2367
	while (start <= end) {
2368
		nr_pages = pagevec_lookup_range(&pvec, inode->i_mapping,
2369
						&start, end);
J
Jan Kara 已提交
2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385
		if (nr_pages == 0)
			break;
		for (i = 0; i < nr_pages; i++) {
			struct page *page = pvec.pages[i];

			bh = head = page_buffers(page);
			do {
				if (lblk < mpd->map.m_lblk)
					continue;
				if (lblk >= mpd->map.m_lblk + mpd->map.m_len) {
					/*
					 * Buffer after end of mapped extent.
					 * Find next buffer in the page to map.
					 */
					mpd->map.m_len = 0;
					mpd->map.m_flags = 0;
2386 2387 2388 2389 2390 2391 2392 2393 2394
					/*
					 * FIXME: If dioread_nolock supports
					 * blocksize < pagesize, we need to make
					 * sure we add size mapped so far to
					 * io_end->size as the following call
					 * can submit the page for IO.
					 */
					err = mpage_process_page_bufs(mpd, head,
								      bh, lblk);
J
Jan Kara 已提交
2395
					pagevec_release(&pvec);
2396 2397 2398
					if (err > 0)
						err = 0;
					return err;
J
Jan Kara 已提交
2399 2400 2401 2402 2403 2404
				}
				if (buffer_delay(bh)) {
					clear_buffer_delay(bh);
					bh->b_blocknr = pblock++;
				}
				clear_buffer_unwritten(bh);
2405
			} while (lblk++, (bh = bh->b_this_page) != head);
J
Jan Kara 已提交
2406 2407 2408 2409 2410 2411

			/*
			 * FIXME: This is going to break if dioread_nolock
			 * supports blocksize < pagesize as we will try to
			 * convert potentially unmapped parts of inode.
			 */
2412
			mpd->io_submit.io_end->size += PAGE_SIZE;
J
Jan Kara 已提交
2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432
			/* Page fully mapped - let IO run! */
			err = mpage_submit_page(mpd, page);
			if (err < 0) {
				pagevec_release(&pvec);
				return err;
			}
		}
		pagevec_release(&pvec);
	}
	/* Extent fully mapped and matches with page boundary. We are done. */
	mpd->map.m_len = 0;
	mpd->map.m_flags = 0;
	return 0;
}

static int mpage_map_one_extent(handle_t *handle, struct mpage_da_data *mpd)
{
	struct inode *inode = mpd->inode;
	struct ext4_map_blocks *map = &mpd->map;
	int get_blocks_flags;
2433
	int err, dioread_nolock;
J
Jan Kara 已提交
2434 2435 2436 2437

	trace_ext4_da_write_pages_extent(inode, map);
	/*
	 * Call ext4_map_blocks() to allocate any delayed allocation blocks, or
2438
	 * to convert an unwritten extent to be initialized (in the case
J
Jan Kara 已提交
2439 2440 2441 2442 2443 2444 2445
	 * where we have written into one or more preallocated blocks).  It is
	 * possible that we're going to need more metadata blocks than
	 * previously reserved. However we must not fail because we're in
	 * writeback and there is nothing we can do about it so it might result
	 * in data loss.  So use reserved blocks to allocate metadata if
	 * possible.
	 *
2446 2447 2448 2449
	 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE if
	 * the blocks in question are delalloc blocks.  This indicates
	 * that the blocks and quotas has already been checked when
	 * the data was copied into the page cache.
J
Jan Kara 已提交
2450 2451
	 */
	get_blocks_flags = EXT4_GET_BLOCKS_CREATE |
2452 2453
			   EXT4_GET_BLOCKS_METADATA_NOFAIL |
			   EXT4_GET_BLOCKS_IO_SUBMIT;
2454 2455
	dioread_nolock = ext4_should_dioread_nolock(inode);
	if (dioread_nolock)
J
Jan Kara 已提交
2456 2457 2458 2459 2460 2461 2462
		get_blocks_flags |= EXT4_GET_BLOCKS_IO_CREATE_EXT;
	if (map->m_flags & (1 << BH_Delay))
		get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE;

	err = ext4_map_blocks(handle, inode, map, get_blocks_flags);
	if (err < 0)
		return err;
2463
	if (dioread_nolock && (map->m_flags & EXT4_MAP_UNWRITTEN)) {
2464 2465 2466 2467 2468
		if (!mpd->io_submit.io_end->handle &&
		    ext4_handle_valid(handle)) {
			mpd->io_submit.io_end->handle = handle->h_rsv_handle;
			handle->h_rsv_handle = NULL;
		}
J
Jan Kara 已提交
2469
		ext4_set_io_unwritten_flag(inode, mpd->io_submit.io_end);
2470
	}
J
Jan Kara 已提交
2471 2472 2473

	BUG_ON(map->m_len == 0);
	if (map->m_flags & EXT4_MAP_NEW) {
2474 2475
		clean_bdev_aliases(inode->i_sb->s_bdev, map->m_pblk,
				   map->m_len);
J
Jan Kara 已提交
2476 2477 2478 2479 2480 2481 2482 2483 2484 2485
	}
	return 0;
}

/*
 * mpage_map_and_submit_extent - map extent starting at mpd->lblk of length
 *				 mpd->len and submit pages underlying it for IO
 *
 * @handle - handle for journal operations
 * @mpd - extent to map
2486 2487 2488
 * @give_up_on_write - we set this to true iff there is a fatal error and there
 *                     is no hope of writing the data. The caller should discard
 *                     dirty pages to avoid infinite loops.
J
Jan Kara 已提交
2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500
 *
 * The function maps extent starting at mpd->lblk of length mpd->len. If it is
 * delayed, blocks are allocated, if it is unwritten, we may need to convert
 * them to initialized or split the described range from larger unwritten
 * extent. Note that we need not map all the described range since allocation
 * can return less blocks or the range is covered by more unwritten extents. We
 * cannot map more because we are limited by reserved transaction credits. On
 * the other hand we always make sure that the last touched page is fully
 * mapped so that it can be written out (and thus forward progress is
 * guaranteed). After mapping we submit all mapped pages for IO.
 */
static int mpage_map_and_submit_extent(handle_t *handle,
2501 2502
				       struct mpage_da_data *mpd,
				       bool *give_up_on_write)
J
Jan Kara 已提交
2503 2504 2505 2506 2507
{
	struct inode *inode = mpd->inode;
	struct ext4_map_blocks *map = &mpd->map;
	int err;
	loff_t disksize;
2508
	int progress = 0;
J
Jan Kara 已提交
2509 2510 2511

	mpd->io_submit.io_end->offset =
				((loff_t)map->m_lblk) << inode->i_blkbits;
2512
	do {
J
Jan Kara 已提交
2513 2514 2515 2516
		err = mpage_map_one_extent(handle, mpd);
		if (err < 0) {
			struct super_block *sb = inode->i_sb;

2517 2518
			if (ext4_forced_shutdown(EXT4_SB(sb)) ||
			    EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED)
2519
				goto invalidate_dirty_pages;
J
Jan Kara 已提交
2520
			/*
2521 2522 2523
			 * Let the uper layers retry transient errors.
			 * In the case of ENOSPC, if ext4_count_free_blocks()
			 * is non-zero, a commit should free up blocks.
J
Jan Kara 已提交
2524
			 */
2525
			if ((err == -ENOMEM) ||
2526 2527 2528
			    (err == -ENOSPC && ext4_count_free_clusters(sb))) {
				if (progress)
					goto update_disksize;
2529
				return err;
2530
			}
2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544
			ext4_msg(sb, KERN_CRIT,
				 "Delayed block allocation failed for "
				 "inode %lu at logical offset %llu with"
				 " max blocks %u with error %d",
				 inode->i_ino,
				 (unsigned long long)map->m_lblk,
				 (unsigned)map->m_len, -err);
			ext4_msg(sb, KERN_CRIT,
				 "This should not happen!! Data will "
				 "be lost\n");
			if (err == -ENOSPC)
				ext4_print_free_blocks(inode);
		invalidate_dirty_pages:
			*give_up_on_write = true;
J
Jan Kara 已提交
2545 2546
			return err;
		}
2547
		progress = 1;
J
Jan Kara 已提交
2548 2549 2550 2551 2552 2553
		/*
		 * Update buffer state, submit mapped pages, and get us new
		 * extent to map
		 */
		err = mpage_map_and_submit_buffers(mpd);
		if (err < 0)
2554
			goto update_disksize;
2555
	} while (map->m_len);
J
Jan Kara 已提交
2556

2557
update_disksize:
2558 2559 2560 2561
	/*
	 * Update on-disk size after IO is submitted.  Races with
	 * truncate are avoided by checking i_size under i_data_sem.
	 */
2562
	disksize = ((loff_t)mpd->first_page) << PAGE_SHIFT;
J
Jan Kara 已提交
2563 2564
	if (disksize > EXT4_I(inode)->i_disksize) {
		int err2;
2565 2566 2567 2568 2569 2570 2571 2572 2573
		loff_t i_size;

		down_write(&EXT4_I(inode)->i_data_sem);
		i_size = i_size_read(inode);
		if (disksize > i_size)
			disksize = i_size;
		if (disksize > EXT4_I(inode)->i_disksize)
			EXT4_I(inode)->i_disksize = disksize;
		up_write(&EXT4_I(inode)->i_data_sem);
2574
		err2 = ext4_mark_inode_dirty(handle, inode);
J
Jan Kara 已提交
2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
		if (err2)
			ext4_error(inode->i_sb,
				   "Failed to mark inode %lu dirty",
				   inode->i_ino);
		if (!err)
			err = err2;
	}
	return err;
}

2585 2586
/*
 * Calculate the total number of credits to reserve for one writepages
2587
 * iteration. This is called from ext4_writepages(). We map an extent of
2588
 * up to MAX_WRITEPAGES_EXTENT_LEN blocks and then we go on and finish mapping
2589 2590 2591
 * the last partial page. So in total we can map MAX_WRITEPAGES_EXTENT_LEN +
 * bpp - 1 blocks in bpp different extents.
 */
2592 2593
static int ext4_da_writepages_trans_blocks(struct inode *inode)
{
2594
	int bpp = ext4_journal_blocks_per_page(inode);
2595

2596 2597
	return ext4_meta_trans_blocks(inode,
				MAX_WRITEPAGES_EXTENT_LEN + bpp - 1, bpp);
2598
}
2599

2600
/*
J
Jan Kara 已提交
2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616
 * mpage_prepare_extent_to_map - find & lock contiguous range of dirty pages
 * 				 and underlying extent to map
 *
 * @mpd - where to look for pages
 *
 * Walk dirty pages in the mapping. If they are fully mapped, submit them for
 * IO immediately. When we find a page which isn't mapped we start accumulating
 * extent of buffers underlying these pages that needs mapping (formed by
 * either delayed or unwritten buffers). We also lock the pages containing
 * these buffers. The extent found is returned in @mpd structure (starting at
 * mpd->lblk with length mpd->len blocks).
 *
 * Note that this function can attach bios to one io_end structure which are
 * neither logically nor physically contiguous. Although it may seem as an
 * unnecessary complication, it is actually inevitable in blocksize < pagesize
 * case as we need to track IO to all buffers underlying a page in one io_end.
2617
 */
J
Jan Kara 已提交
2618
static int mpage_prepare_extent_to_map(struct mpage_da_data *mpd)
2619
{
J
Jan Kara 已提交
2620 2621 2622
	struct address_space *mapping = mpd->inode->i_mapping;
	struct pagevec pvec;
	unsigned int nr_pages;
2623
	long left = mpd->wbc->nr_to_write;
J
Jan Kara 已提交
2624 2625 2626 2627 2628 2629 2630
	pgoff_t index = mpd->first_page;
	pgoff_t end = mpd->last_page;
	int tag;
	int i, err = 0;
	int blkbits = mpd->inode->i_blkbits;
	ext4_lblk_t lblk;
	struct buffer_head *head;
2631

J
Jan Kara 已提交
2632
	if (mpd->wbc->sync_mode == WB_SYNC_ALL || mpd->wbc->tagged_writepages)
2633 2634 2635 2636
		tag = PAGECACHE_TAG_TOWRITE;
	else
		tag = PAGECACHE_TAG_DIRTY;

2637
	pagevec_init(&pvec);
J
Jan Kara 已提交
2638 2639
	mpd->map.m_len = 0;
	mpd->next_page = index;
2640
	while (index <= end) {
J
Jan Kara 已提交
2641
		nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end,
2642
				tag);
2643
		if (nr_pages == 0)
J
Jan Kara 已提交
2644
			goto out;
2645 2646 2647 2648

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

2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659
			/*
			 * Accumulated enough dirty pages? This doesn't apply
			 * to WB_SYNC_ALL mode. For 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.
			 */
			if (mpd->wbc->sync_mode == WB_SYNC_NONE && left <= 0)
				goto out;

J
Jan Kara 已提交
2660 2661 2662
			/* If we can't merge this page, we are done. */
			if (mpd->map.m_len > 0 && mpd->next_page != page->index)
				goto out;
2663

2664 2665
			lock_page(page);
			/*
J
Jan Kara 已提交
2666 2667 2668 2669 2670
			 * 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
2671
			 */
2672 2673
			if (!PageDirty(page) ||
			    (PageWriteback(page) &&
J
Jan Kara 已提交
2674
			     (mpd->wbc->sync_mode == WB_SYNC_NONE)) ||
2675
			    unlikely(page->mapping != mapping)) {
2676 2677 2678 2679
				unlock_page(page);
				continue;
			}

2680
			wait_on_page_writeback(page);
2681 2682
			BUG_ON(PageWriteback(page));

J
Jan Kara 已提交
2683
			if (mpd->map.m_len == 0)
2684 2685
				mpd->first_page = page->index;
			mpd->next_page = page->index + 1;
2686
			/* Add all dirty buffers to mpd */
J
Jan Kara 已提交
2687
			lblk = ((ext4_lblk_t)page->index) <<
2688
				(PAGE_SHIFT - blkbits);
2689
			head = page_buffers(page);
2690 2691
			err = mpage_process_page_bufs(mpd, head, head, lblk);
			if (err <= 0)
J
Jan Kara 已提交
2692
				goto out;
2693
			err = 0;
2694
			left--;
2695 2696 2697 2698
		}
		pagevec_release(&pvec);
		cond_resched();
	}
2699
	return 0;
2700 2701
out:
	pagevec_release(&pvec);
J
Jan Kara 已提交
2702
	return err;
2703 2704
}

2705 2706
static int ext4_writepages(struct address_space *mapping,
			   struct writeback_control *wbc)
2707
{
J
Jan Kara 已提交
2708 2709
	pgoff_t	writeback_index = 0;
	long nr_to_write = wbc->nr_to_write;
2710
	int range_whole = 0;
J
Jan Kara 已提交
2711
	int cycled = 1;
2712
	handle_t *handle = NULL;
2713
	struct mpage_da_data mpd;
2714
	struct inode *inode = mapping->host;
2715
	int needed_blocks, rsv_blocks = 0, ret = 0;
2716
	struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
J
Jan Kara 已提交
2717
	bool done;
S
Shaohua Li 已提交
2718
	struct blk_plug plug;
2719
	bool give_up_on_write = false;
2720

2721 2722 2723
	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
		return -EIO;

2724
	percpu_down_read(&sbi->s_journal_flag_rwsem);
2725
	trace_ext4_writepages(inode, wbc);
2726

2727 2728 2729 2730 2731
	/*
	 * 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
	 */
2732
	if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2733
		goto out_writepages;
2734

2735
	if (ext4_should_journal_data(inode)) {
2736
		ret = generic_writepages(mapping, wbc);
2737
		goto out_writepages;
2738 2739
	}

2740 2741 2742 2743
	/*
	 * 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
2744
	 * EXT4_MF_FS_ABORTED instead of sb->s_flag's SB_RDONLY because
2745
	 * the latter could be true if the filesystem is mounted
2746
	 * read-only, and in that case, ext4_writepages should
2747 2748 2749
	 * *never* be called, so if that ever happens, we would want
	 * the stack trace.
	 */
2750 2751
	if (unlikely(ext4_forced_shutdown(EXT4_SB(mapping->host->i_sb)) ||
		     sbi->s_mount_flags & EXT4_MF_FS_ABORTED)) {
2752 2753 2754
		ret = -EROFS;
		goto out_writepages;
	}
2755

2756 2757
	if (ext4_should_dioread_nolock(inode)) {
		/*
2758
		 * We may need to convert up to one extent per block in
2759 2760
		 * the page and we may dirty the inode.
		 */
2761 2762
		rsv_blocks = 1 + ext4_chunk_trans_blocks(inode,
						PAGE_SIZE >> inode->i_blkbits);
2763 2764
	}

J
Jan Kara 已提交
2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782
	/*
	 * 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)) {
		/* Just inode will be modified... */
		handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
		if (IS_ERR(handle)) {
			ret = PTR_ERR(handle);
			goto out_writepages;
		}
		BUG_ON(ext4_test_inode_state(inode,
				EXT4_STATE_MAY_INLINE_DATA));
		ext4_destroy_inline_data(handle, inode);
		ext4_journal_stop(handle);
	}

2783 2784
	if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
		range_whole = 1;
2785

2786
	if (wbc->range_cyclic) {
J
Jan Kara 已提交
2787 2788
		writeback_index = mapping->writeback_index;
		if (writeback_index)
2789
			cycled = 0;
J
Jan Kara 已提交
2790 2791
		mpd.first_page = writeback_index;
		mpd.last_page = -1;
2792
	} else {
2793 2794
		mpd.first_page = wbc->range_start >> PAGE_SHIFT;
		mpd.last_page = wbc->range_end >> PAGE_SHIFT;
2795
	}
2796

J
Jan Kara 已提交
2797 2798 2799
	mpd.inode = inode;
	mpd.wbc = wbc;
	ext4_io_submit_init(&mpd.io_submit, wbc);
2800
retry:
2801
	if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
J
Jan Kara 已提交
2802 2803
		tag_pages_for_writeback(mapping, mpd.first_page, mpd.last_page);
	done = false;
S
Shaohua Li 已提交
2804
	blk_start_plug(&plug);
2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827

	/*
	 * First writeback pages that don't need mapping - we can avoid
	 * starting a transaction unnecessarily and also avoid being blocked
	 * in the block layer on device congestion while having transaction
	 * started.
	 */
	mpd.do_map = 0;
	mpd.io_submit.io_end = ext4_init_io_end(inode, GFP_KERNEL);
	if (!mpd.io_submit.io_end) {
		ret = -ENOMEM;
		goto unplug;
	}
	ret = mpage_prepare_extent_to_map(&mpd);
	/* Submit prepared bio */
	ext4_io_submit(&mpd.io_submit);
	ext4_put_io_end_defer(mpd.io_submit.io_end);
	mpd.io_submit.io_end = NULL;
	/* Unlock pages we didn't use */
	mpage_release_unused_pages(&mpd, false);
	if (ret < 0)
		goto unplug;

J
Jan Kara 已提交
2828 2829 2830 2831 2832 2833 2834
	while (!done && mpd.first_page <= mpd.last_page) {
		/* For each extent of pages we use new io_end */
		mpd.io_submit.io_end = ext4_init_io_end(inode, GFP_KERNEL);
		if (!mpd.io_submit.io_end) {
			ret = -ENOMEM;
			break;
		}
2835 2836

		/*
J
Jan Kara 已提交
2837 2838 2839 2840 2841
		 * We have two constraints: We find one extent to map and we
		 * must always write out whole page (makes a difference when
		 * blocksize < pagesize) so that we don't block on IO when we
		 * try to write out the rest of the page. Journalled mode is
		 * not supported by delalloc.
2842 2843
		 */
		BUG_ON(ext4_should_journal_data(inode));
2844
		needed_blocks = ext4_da_writepages_trans_blocks(inode);
2845

J
Jan Kara 已提交
2846
		/* start a new transaction */
2847 2848
		handle = ext4_journal_start_with_reserve(inode,
				EXT4_HT_WRITE_PAGE, needed_blocks, rsv_blocks);
2849 2850
		if (IS_ERR(handle)) {
			ret = PTR_ERR(handle);
2851
			ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
2852
			       "%ld pages, ino %lu; err %d", __func__,
2853
				wbc->nr_to_write, inode->i_ino, ret);
J
Jan Kara 已提交
2854 2855
			/* Release allocated io_end */
			ext4_put_io_end(mpd.io_submit.io_end);
2856
			mpd.io_submit.io_end = NULL;
J
Jan Kara 已提交
2857
			break;
2858
		}
2859
		mpd.do_map = 1;
2860

J
Jan Kara 已提交
2861 2862 2863 2864
		trace_ext4_da_write_pages(inode, mpd.first_page, mpd.wbc);
		ret = mpage_prepare_extent_to_map(&mpd);
		if (!ret) {
			if (mpd.map.m_len)
2865 2866
				ret = mpage_map_and_submit_extent(handle, &mpd,
					&give_up_on_write);
J
Jan Kara 已提交
2867 2868 2869 2870 2871 2872 2873 2874 2875
			else {
				/*
				 * We scanned the whole range (or exhausted
				 * nr_to_write), submitted what was mapped and
				 * didn't find anything needing mapping. We are
				 * done.
				 */
				done = true;
			}
2876
		}
2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889
		/*
		 * Caution: If the handle is synchronous,
		 * ext4_journal_stop() can wait for transaction commit
		 * to finish which may depend on writeback of pages to
		 * complete or on page lock to be released.  In that
		 * case, we have to wait until after after we have
		 * submitted all the IO, released page locks we hold,
		 * and dropped io_end reference (for extent conversion
		 * to be able to complete) before stopping the handle.
		 */
		if (!ext4_handle_valid(handle) || handle->h_sync == 0) {
			ext4_journal_stop(handle);
			handle = NULL;
2890
			mpd.do_map = 0;
2891
		}
J
Jan Kara 已提交
2892 2893 2894
		/* Submit prepared bio */
		ext4_io_submit(&mpd.io_submit);
		/* Unlock pages we didn't use */
2895
		mpage_release_unused_pages(&mpd, give_up_on_write);
2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907
		/*
		 * Drop our io_end reference we got from init. We have
		 * to be careful and use deferred io_end finishing if
		 * we are still holding the transaction as we can
		 * release the last reference to io_end which may end
		 * up doing unwritten extent conversion.
		 */
		if (handle) {
			ext4_put_io_end_defer(mpd.io_submit.io_end);
			ext4_journal_stop(handle);
		} else
			ext4_put_io_end(mpd.io_submit.io_end);
2908
		mpd.io_submit.io_end = NULL;
J
Jan Kara 已提交
2909 2910 2911 2912

		if (ret == -ENOSPC && sbi->s_journal) {
			/*
			 * Commit the transaction which would
2913 2914 2915
			 * free blocks released in the transaction
			 * and try again
			 */
2916
			jbd2_journal_force_commit_nested(sbi->s_journal);
2917
			ret = 0;
J
Jan Kara 已提交
2918 2919 2920 2921
			continue;
		}
		/* Fatal error - ENOMEM, EIO... */
		if (ret)
2922
			break;
2923
	}
2924
unplug:
S
Shaohua Li 已提交
2925
	blk_finish_plug(&plug);
2926
	if (!ret && !cycled && wbc->nr_to_write > 0) {
2927
		cycled = 1;
J
Jan Kara 已提交
2928 2929
		mpd.last_page = writeback_index - 1;
		mpd.first_page = 0;
2930 2931
		goto retry;
	}
2932 2933 2934 2935

	/* Update index */
	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
		/*
J
Jan Kara 已提交
2936
		 * Set the writeback_index so that range_cyclic
2937 2938
		 * mode will write it back later
		 */
J
Jan Kara 已提交
2939
		mapping->writeback_index = mpd.first_page;
2940

2941
out_writepages:
2942 2943
	trace_ext4_writepages_result(inode, wbc, ret,
				     nr_to_write - wbc->nr_to_write);
2944
	percpu_up_read(&sbi->s_journal_flag_rwsem);
2945
	return ret;
2946 2947
}

2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968
static int ext4_dax_writepages(struct address_space *mapping,
			       struct writeback_control *wbc)
{
	int ret;
	long nr_to_write = wbc->nr_to_write;
	struct inode *inode = mapping->host;
	struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);

	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
		return -EIO;

	percpu_down_read(&sbi->s_journal_flag_rwsem);
	trace_ext4_writepages(inode, wbc);

	ret = dax_writeback_mapping_range(mapping, inode->i_sb->s_bdev, wbc);
	trace_ext4_writepages_result(inode, wbc, ret,
				     nr_to_write - wbc->nr_to_write);
	percpu_up_read(&sbi->s_journal_flag_rwsem);
	return ret;
}

2969 2970
static int ext4_nonda_switch(struct super_block *sb)
{
2971
	s64 free_clusters, dirty_clusters;
2972 2973 2974 2975 2976
	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
2977
	 * counters can get slightly wrong with percpu_counter_batch getting
2978 2979 2980 2981
	 * 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.
	 */
2982 2983 2984 2985
	free_clusters =
		percpu_counter_read_positive(&sbi->s_freeclusters_counter);
	dirty_clusters =
		percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);
2986 2987 2988
	/*
	 * Start pushing delalloc when 1/2 of free blocks are dirty.
	 */
2989
	if (dirty_clusters && (free_clusters < 2 * dirty_clusters))
2990
		try_to_writeback_inodes_sb(sb, WB_REASON_FS_FREE_SPACE);
2991

2992 2993
	if (2 * free_clusters < 3 * dirty_clusters ||
	    free_clusters < (dirty_clusters + EXT4_FREECLUSTERS_WATERMARK)) {
2994
		/*
2995 2996
		 * free block count is less than 150% of dirty blocks
		 * or free blocks is less than watermark
2997 2998 2999 3000 3001 3002
		 */
		return 1;
	}
	return 0;
}

3003 3004 3005
/* We always reserve for an inode update; the superblock could be there too */
static int ext4_da_write_credits(struct inode *inode, loff_t pos, unsigned len)
{
3006
	if (likely(ext4_has_feature_large_file(inode->i_sb)))
3007 3008 3009 3010 3011 3012 3013 3014 3015
		return 1;

	if (pos + len <= 0x7fffffffULL)
		return 1;

	/* We might need to update the superblock to set LARGE_FILE */
	return 2;
}

3016
static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
3017 3018
			       loff_t pos, unsigned len, unsigned flags,
			       struct page **pagep, void **fsdata)
3019
{
3020
	int ret, retries = 0;
3021 3022 3023 3024 3025
	struct page *page;
	pgoff_t index;
	struct inode *inode = mapping->host;
	handle_t *handle;

3026 3027 3028
	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
		return -EIO;

3029
	index = pos >> PAGE_SHIFT;
3030

3031 3032
	if (ext4_nonda_switch(inode->i_sb) ||
	    S_ISLNK(inode->i_mode)) {
3033 3034 3035 3036 3037
		*fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
		return ext4_write_begin(file, mapping, pos,
					len, flags, pagep, fsdata);
	}
	*fsdata = (void *)0;
3038
	trace_ext4_da_write_begin(inode, pos, len, flags);
3039 3040 3041 3042 3043 3044

	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)
3045 3046 3047
			return ret;
		if (ret == 1)
			return 0;
3048 3049
	}

3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062
	/*
	 * grab_cache_page_write_begin() can take a long time if the
	 * system is thrashing due to memory pressure, or if the page
	 * is being written back.  So grab it first before we start
	 * the transaction handle.  This also allows us to allocate
	 * the page (if needed) without using GFP_NOFS.
	 */
retry_grab:
	page = grab_cache_page_write_begin(mapping, index, flags);
	if (!page)
		return -ENOMEM;
	unlock_page(page);

3063 3064 3065 3066 3067 3068
	/*
	 * 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.
	 */
3069
retry_journal:
3070 3071
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
				ext4_da_write_credits(inode, pos, len));
3072
	if (IS_ERR(handle)) {
3073
		put_page(page);
3074
		return PTR_ERR(handle);
3075 3076
	}

3077 3078 3079 3080
	lock_page(page);
	if (page->mapping != mapping) {
		/* The page got truncated from under us */
		unlock_page(page);
3081
		put_page(page);
3082
		ext4_journal_stop(handle);
3083
		goto retry_grab;
3084
	}
3085
	/* In case writeback began while the page was unlocked */
3086
	wait_for_stable_page(page);
3087

3088 3089 3090 3091
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	ret = ext4_block_write_begin(page, pos, len,
				     ext4_da_get_block_prep);
#else
3092
	ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep);
3093
#endif
3094 3095 3096
	if (ret < 0) {
		unlock_page(page);
		ext4_journal_stop(handle);
3097 3098 3099 3100 3101 3102
		/*
		 * 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)
3103
			ext4_truncate_failed_write(inode);
3104 3105 3106 3107 3108

		if (ret == -ENOSPC &&
		    ext4_should_retry_alloc(inode->i_sb, &retries))
			goto retry_journal;

3109
		put_page(page);
3110
		return ret;
3111 3112
	}

3113
	*pagep = page;
3114 3115 3116
	return ret;
}

3117 3118 3119 3120 3121
/*
 * 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,
3122
					    unsigned long offset)
3123 3124 3125 3126 3127 3128 3129 3130 3131
{
	struct buffer_head *bh;
	struct inode *inode = page->mapping->host;
	unsigned int idx;
	int i;

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

3132
	for (i = 0; i < idx; i++)
3133 3134
		bh = bh->b_this_page;

3135
	if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
3136 3137 3138 3139
		return 0;
	return 1;
}

3140
static int ext4_da_write_end(struct file *file,
3141 3142 3143
			     struct address_space *mapping,
			     loff_t pos, unsigned len, unsigned copied,
			     struct page *page, void *fsdata)
3144 3145 3146 3147 3148
{
	struct inode *inode = mapping->host;
	int ret = 0, ret2;
	handle_t *handle = ext4_journal_current_handle();
	loff_t new_i_size;
3149
	unsigned long start, end;
3150 3151
	int write_mode = (int)(unsigned long)fsdata;

3152 3153 3154
	if (write_mode == FALL_BACK_TO_NONDELALLOC)
		return ext4_write_end(file, mapping, pos,
				      len, copied, page, fsdata);
3155

3156
	trace_ext4_da_write_end(inode, pos, len, copied);
3157
	start = pos & (PAGE_SIZE - 1);
3158
	end = start + copied - 1;
3159 3160 3161 3162 3163 3164 3165

	/*
	 * 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;
3166
	if (copied && new_i_size > EXT4_I(inode)->i_disksize) {
3167 3168
		if (ext4_has_inline_data(inode) ||
		    ext4_da_should_update_i_disksize(page, end)) {
3169
			ext4_update_i_disksize(inode, new_i_size);
3170 3171 3172 3173 3174
			/* 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);
3175
		}
3176
	}
3177 3178 3179 3180 3181 3182 3183 3184

	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,
3185
							page, fsdata);
3186

3187 3188 3189 3190 3191 3192 3193 3194 3195 3196
	copied = ret2;
	if (ret2 < 0)
		ret = ret2;
	ret2 = ext4_journal_stop(handle);
	if (!ret)
		ret = ret2;

	return ret ? ret : copied;
}

3197 3198
static void ext4_da_invalidatepage(struct page *page, unsigned int offset,
				   unsigned int length)
3199 3200 3201 3202 3203 3204 3205 3206
{
	/*
	 * Drop reserved blocks
	 */
	BUG_ON(!PageLocked(page));
	if (!page_has_buffers(page))
		goto out;

3207
	ext4_da_page_release_reservation(page, offset, length);
3208 3209

out:
3210
	ext4_invalidatepage(page, offset, length);
3211 3212 3213 3214

	return;
}

3215 3216 3217 3218 3219
/*
 * Force all delayed allocation blocks to be allocated for a given inode.
 */
int ext4_alloc_da_blocks(struct inode *inode)
{
3220 3221
	trace_ext4_alloc_da_blocks(inode);

3222
	if (!EXT4_I(inode)->i_reserved_data_blocks)
3223 3224 3225 3226 3227 3228 3229 3230
		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:
3231
	 *
3232
	 * ext4_writepages() ->
3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243
	 *    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
3244
	 * the pages by calling redirty_page_for_writepage() but that
3245 3246
	 * 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 已提交
3247
	 * simplifying them because we wouldn't actually intend to
3248 3249 3250
	 * 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.
3251
	 *
3252 3253 3254 3255 3256 3257
	 * 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);
}
3258

3259 3260 3261 3262 3263
/*
 * 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
3264
 * journal.  If somebody makes a swapfile on an ext4 data-journaling
3265 3266 3267 3268 3269 3270 3271 3272
 * 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.
 */
3273
static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
3274 3275 3276 3277 3278
{
	struct inode *inode = mapping->host;
	journal_t *journal;
	int err;

T
Tao Ma 已提交
3279 3280 3281 3282 3283 3284
	/*
	 * We can get here for an inline file via the FIBMAP ioctl
	 */
	if (ext4_has_inline_data(inode))
		return 0;

3285 3286 3287 3288 3289 3290 3291 3292 3293 3294
	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);
	}

3295 3296
	if (EXT4_JOURNAL(inode) &&
	    ext4_test_inode_state(inode, EXT4_STATE_JDATA)) {
3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307
		/*
		 * 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.)
		 *
3308
		 * NB. EXT4_STATE_JDATA is not set on files other than
3309 3310 3311 3312 3313 3314
		 * 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.
		 */

3315
		ext4_clear_inode_state(inode, EXT4_STATE_JDATA);
3316
		journal = EXT4_JOURNAL(inode);
3317 3318 3319
		jbd2_journal_lock_updates(journal);
		err = jbd2_journal_flush(journal);
		jbd2_journal_unlock_updates(journal);
3320 3321 3322 3323 3324

		if (err)
			return 0;
	}

3325
	return generic_block_bmap(mapping, block, ext4_get_block);
3326 3327
}

3328
static int ext4_readpage(struct file *file, struct page *page)
3329
{
T
Tao Ma 已提交
3330 3331 3332
	int ret = -EAGAIN;
	struct inode *inode = page->mapping->host;

3333
	trace_ext4_readpage(page);
T
Tao Ma 已提交
3334 3335 3336 3337 3338

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

	if (ret == -EAGAIN)
3339 3340
		return ext4_mpage_readpages(page->mapping, NULL, page, 1,
						false);
T
Tao Ma 已提交
3341 3342

	return ret;
3343 3344 3345
}

static int
3346
ext4_readpages(struct file *file, struct address_space *mapping,
3347 3348
		struct list_head *pages, unsigned nr_pages)
{
T
Tao Ma 已提交
3349 3350 3351 3352 3353 3354
	struct inode *inode = mapping->host;

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

3355
	return ext4_mpage_readpages(mapping, pages, NULL, nr_pages, true);
3356 3357
}

3358 3359
static void ext4_invalidatepage(struct page *page, unsigned int offset,
				unsigned int length)
3360
{
3361
	trace_ext4_invalidatepage(page, offset, length);
3362

3363 3364 3365
	/* No journalling happens on data buffers when this function is used */
	WARN_ON(page_has_buffers(page) && buffer_jbd(page_buffers(page)));

3366
	block_invalidatepage(page, offset, length);
3367 3368
}

3369
static int __ext4_journalled_invalidatepage(struct page *page,
3370 3371
					    unsigned int offset,
					    unsigned int length)
3372 3373 3374
{
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);

3375
	trace_ext4_journalled_invalidatepage(page, offset, length);
3376

3377 3378 3379
	/*
	 * If it's a full truncate we just forget about the pending dirtying
	 */
3380
	if (offset == 0 && length == PAGE_SIZE)
3381 3382
		ClearPageChecked(page);

3383
	return jbd2_journal_invalidatepage(journal, page, offset, length);
3384 3385 3386 3387
}

/* Wrapper for aops... */
static void ext4_journalled_invalidatepage(struct page *page,
3388 3389
					   unsigned int offset,
					   unsigned int length)
3390
{
3391
	WARN_ON(__ext4_journalled_invalidatepage(page, offset, length) < 0);
3392 3393
}

3394
static int ext4_releasepage(struct page *page, gfp_t wait)
3395
{
3396
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);
3397

3398 3399
	trace_ext4_releasepage(page);

3400 3401
	/* Page has dirty journalled data -> cannot release */
	if (PageChecked(page))
3402
		return 0;
3403 3404 3405 3406
	if (journal)
		return jbd2_journal_try_to_free_buffers(journal, page, wait);
	else
		return try_to_free_buffers(page);
3407 3408
}

3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421
static bool ext4_inode_datasync_dirty(struct inode *inode)
{
	journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;

	if (journal)
		return !jbd2_transaction_committed(journal,
					EXT4_I(inode)->i_datasync_tid);
	/* Any metadata buffers to write? */
	if (!list_empty(&inode->i_mapping->private_list))
		return true;
	return inode->i_state & I_DIRTY_DATASYNC;
}

3422 3423 3424
static int ext4_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
			    unsigned flags, struct iomap *iomap)
{
3425
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
3426
	unsigned int blkbits = inode->i_blkbits;
3427
	unsigned long first_block, last_block;
3428
	struct ext4_map_blocks map;
3429
	bool delalloc = false;
3430 3431
	int ret;

3432 3433 3434 3435 3436
	if ((offset >> blkbits) > EXT4_MAX_LOGICAL_BLOCK)
		return -EINVAL;
	first_block = offset >> blkbits;
	last_block = min_t(loff_t, (offset + length - 1) >> blkbits,
			   EXT4_MAX_LOGICAL_BLOCK);
3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450

	if (flags & IOMAP_REPORT) {
		if (ext4_has_inline_data(inode)) {
			ret = ext4_inline_data_iomap(inode, iomap);
			if (ret != -EAGAIN) {
				if (ret == 0 && offset >= iomap->length)
					ret = -ENOENT;
				return ret;
			}
		}
	} else {
		if (WARN_ON_ONCE(ext4_has_inline_data(inode)))
			return -ERANGE;
	}
3451 3452 3453 3454

	map.m_lblk = first_block;
	map.m_len = last_block - first_block + 1;

3455
	if (flags & IOMAP_REPORT) {
J
Jan Kara 已提交
3456
		ret = ext4_map_blocks(NULL, inode, &map, 0);
3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481
		if (ret < 0)
			return ret;

		if (ret == 0) {
			ext4_lblk_t end = map.m_lblk + map.m_len - 1;
			struct extent_status es;

			ext4_es_find_delayed_extent_range(inode, map.m_lblk, end, &es);

			if (!es.es_len || es.es_lblk > end) {
				/* entire range is a hole */
			} else if (es.es_lblk > map.m_lblk) {
				/* range starts with a hole */
				map.m_len = es.es_lblk - map.m_lblk;
			} else {
				ext4_lblk_t offs = 0;

				if (es.es_lblk < map.m_lblk)
					offs = map.m_lblk - es.es_lblk;
				map.m_lblk = es.es_lblk + offs;
				map.m_len = es.es_len - offs;
				delalloc = true;
			}
		}
	} else if (flags & IOMAP_WRITE) {
J
Jan Kara 已提交
3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512
		int dio_credits;
		handle_t *handle;
		int retries = 0;

		/* Trim mapping request to maximum we can map at once for DIO */
		if (map.m_len > DIO_MAX_BLOCKS)
			map.m_len = DIO_MAX_BLOCKS;
		dio_credits = ext4_chunk_trans_blocks(inode, map.m_len);
retry:
		/*
		 * Either we allocate blocks and then we don't get unwritten
		 * extent so we have reserved enough credits, or the blocks
		 * are already allocated and unwritten and in that case
		 * extent conversion fits in the credits as well.
		 */
		handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
					    dio_credits);
		if (IS_ERR(handle))
			return PTR_ERR(handle);

		ret = ext4_map_blocks(handle, inode, &map,
				      EXT4_GET_BLOCKS_CREATE_ZERO);
		if (ret < 0) {
			ext4_journal_stop(handle);
			if (ret == -ENOSPC &&
			    ext4_should_retry_alloc(inode->i_sb, &retries))
				goto retry;
			return ret;
		}

		/*
3513
		 * If we added blocks beyond i_size, we need to make sure they
J
Jan Kara 已提交
3514
		 * will get truncated if we crash before updating i_size in
3515 3516 3517 3518 3519
		 * ext4_iomap_end(). For faults we don't need to do that (and
		 * even cannot because for orphan list operations inode_lock is
		 * required) - if we happen to instantiate block beyond i_size,
		 * it is because we race with truncate which has already added
		 * the inode to the orphan list.
J
Jan Kara 已提交
3520
		 */
3521 3522
		if (!(flags & IOMAP_FAULT) && first_block + map.m_len >
		    (i_size_read(inode) + (1 << blkbits) - 1) >> blkbits) {
J
Jan Kara 已提交
3523 3524 3525 3526 3527 3528 3529 3530 3531
			int err;

			err = ext4_orphan_add(handle, inode);
			if (err < 0) {
				ext4_journal_stop(handle);
				return err;
			}
		}
		ext4_journal_stop(handle);
3532 3533 3534 3535
	} else {
		ret = ext4_map_blocks(NULL, inode, &map, 0);
		if (ret < 0)
			return ret;
J
Jan Kara 已提交
3536
	}
3537 3538

	iomap->flags = 0;
3539
	if (ext4_inode_datasync_dirty(inode))
3540
		iomap->flags |= IOMAP_F_DIRTY;
3541 3542
	iomap->bdev = inode->i_sb->s_bdev;
	iomap->dax_dev = sbi->s_daxdev;
3543
	iomap->offset = (u64)first_block << blkbits;
3544
	iomap->length = (u64)map.m_len << blkbits;
3545 3546

	if (ret == 0) {
3547
		iomap->type = delalloc ? IOMAP_DELALLOC : IOMAP_HOLE;
3548
		iomap->addr = IOMAP_NULL_ADDR;
3549 3550 3551 3552 3553 3554 3555 3556 3557
	} else {
		if (map.m_flags & EXT4_MAP_MAPPED) {
			iomap->type = IOMAP_MAPPED;
		} else if (map.m_flags & EXT4_MAP_UNWRITTEN) {
			iomap->type = IOMAP_UNWRITTEN;
		} else {
			WARN_ON_ONCE(1);
			return -EIO;
		}
3558
		iomap->addr = (u64)map.m_pblk << blkbits;
3559 3560 3561 3562
	}

	if (map.m_flags & EXT4_MAP_NEW)
		iomap->flags |= IOMAP_F_NEW;
3563

3564 3565 3566
	return 0;
}

J
Jan Kara 已提交
3567 3568 3569 3570 3571 3572 3573 3574
static int ext4_iomap_end(struct inode *inode, loff_t offset, loff_t length,
			  ssize_t written, unsigned flags, struct iomap *iomap)
{
	int ret = 0;
	handle_t *handle;
	int blkbits = inode->i_blkbits;
	bool truncate = false;

3575
	if (!(flags & IOMAP_WRITE) || (flags & IOMAP_FAULT))
J
Jan Kara 已提交
3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618
		return 0;

	handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
	if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
		goto orphan_del;
	}
	if (ext4_update_inode_size(inode, offset + written))
		ext4_mark_inode_dirty(handle, inode);
	/*
	 * We may need to truncate allocated but not written blocks beyond EOF.
	 */
	if (iomap->offset + iomap->length > 
	    ALIGN(inode->i_size, 1 << blkbits)) {
		ext4_lblk_t written_blk, end_blk;

		written_blk = (offset + written) >> blkbits;
		end_blk = (offset + length) >> blkbits;
		if (written_blk < end_blk && ext4_can_truncate(inode))
			truncate = true;
	}
	/*
	 * Remove inode from orphan list if we were extending a inode and
	 * everything went fine.
	 */
	if (!truncate && inode->i_nlink &&
	    !list_empty(&EXT4_I(inode)->i_orphan))
		ext4_orphan_del(handle, inode);
	ext4_journal_stop(handle);
	if (truncate) {
		ext4_truncate_failed_write(inode);
orphan_del:
		/*
		 * If truncate failed early the inode might 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);
	}
	return ret;
}

3619
const struct iomap_ops ext4_iomap_ops = {
3620
	.iomap_begin		= ext4_iomap_begin,
J
Jan Kara 已提交
3621
	.iomap_end		= ext4_iomap_end,
3622 3623
};

3624
static int ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
3625
			    ssize_t size, void *private)
3626
{
3627
        ext4_io_end_t *io_end = private;
3628

J
Jan Kara 已提交
3629
	/* if not async direct IO just return */
3630
	if (!io_end)
3631
		return 0;
3632

3633
	ext_debug("ext4_end_io_dio(): io_end 0x%p "
3634
		  "for inode %lu, iocb 0x%p, offset %llu, size %zd\n",
3635
		  io_end, io_end->inode->i_ino, iocb, offset, size);
3636

3637 3638 3639 3640 3641 3642 3643 3644
	/*
	 * Error during AIO DIO. We cannot convert unwritten extents as the
	 * data was not written. Just clear the unwritten flag and drop io_end.
	 */
	if (size <= 0) {
		ext4_clear_io_unwritten_flag(io_end);
		size = 0;
	}
3645 3646
	io_end->offset = offset;
	io_end->size = size;
3647
	ext4_put_io_end(io_end);
3648 3649

	return 0;
3650
}
3651

3652
/*
J
Jan Kara 已提交
3653 3654 3655
 * Handling of direct IO writes.
 *
 * For ext4 extent files, ext4 will do direct-io write even to holes,
3656 3657 3658
 * preallocated extents, and those write extend the file, no need to
 * fall back to buffered IO.
 *
3659
 * For holes, we fallocate those blocks, mark them as unwritten
3660
 * If those blocks were preallocated, we mark sure they are split, but
3661
 * still keep the range to write as unwritten.
3662
 *
3663
 * The unwritten extents will be converted to written when DIO is completed.
3664
 * For async direct IO, since the IO may still pending when return, we
L
Lucas De Marchi 已提交
3665
 * set up an end_io call back function, which will do the conversion
3666
 * when async direct IO completed.
3667 3668 3669 3670 3671 3672
 *
 * 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.
 *
 */
3673
static ssize_t ext4_direct_IO_write(struct kiocb *iocb, struct iov_iter *iter)
3674 3675 3676
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
3677
	struct ext4_inode_info *ei = EXT4_I(inode);
3678
	ssize_t ret;
3679
	loff_t offset = iocb->ki_pos;
3680
	size_t count = iov_iter_count(iter);
3681 3682 3683
	int overwrite = 0;
	get_block_t *get_block_func = NULL;
	int dio_flags = 0;
3684
	loff_t final_size = offset + count;
J
Jan Kara 已提交
3685 3686
	int orphan = 0;
	handle_t *handle;
3687

3688
	if (final_size > inode->i_size || final_size > ei->i_disksize) {
J
Jan Kara 已提交
3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700
		/* Credits for sb + inode write */
		handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
		if (IS_ERR(handle)) {
			ret = PTR_ERR(handle);
			goto out;
		}
		ret = ext4_orphan_add(handle, inode);
		if (ret) {
			ext4_journal_stop(handle);
			goto out;
		}
		orphan = 1;
3701
		ext4_update_i_disksize(inode, inode->i_size);
J
Jan Kara 已提交
3702 3703
		ext4_journal_stop(handle);
	}
3704

3705
	BUG_ON(iocb->private == NULL);
3706

3707 3708 3709 3710 3711
	/*
	 * Make all waiters for direct IO properly wait also for extent
	 * conversion. This also disallows race between truncate() and
	 * overwrite DIO as i_dio_count needs to be incremented under i_mutex.
	 */
J
Jan Kara 已提交
3712
	inode_dio_begin(inode);
3713

3714 3715
	/* If we do a overwrite dio, i_mutex locking can be released */
	overwrite = *((int *)iocb->private);
3716

3717
	if (overwrite)
A
Al Viro 已提交
3718
		inode_unlock(inode);
3719

3720
	/*
J
Jan Kara 已提交
3721
	 * For extent mapped files we could direct write to holes and fallocate.
3722
	 *
3723 3724 3725
	 * Allocated blocks to fill the hole are marked as unwritten to prevent
	 * parallel buffered read to expose the stale data before DIO complete
	 * the data IO.
3726
	 *
3727 3728
	 * As to previously fallocated extents, ext4 get_block will just simply
	 * mark the buffer mapped but still keep the extents unwritten.
3729
	 *
3730 3731 3732 3733
	 * For non AIO case, we will convert those unwritten extents to written
	 * after return back from blockdev_direct_IO. That way we save us from
	 * allocating io_end structure and also the overhead of offloading
	 * the extent convertion to a workqueue.
3734 3735 3736 3737 3738 3739 3740
	 *
	 * 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;
3741
	if (overwrite)
3742
		get_block_func = ext4_dio_get_block_overwrite;
3743
	else if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) ||
F
Fabian Frederick 已提交
3744
		   round_down(offset, i_blocksize(inode)) >= inode->i_size) {
J
Jan Kara 已提交
3745 3746 3747
		get_block_func = ext4_dio_get_block;
		dio_flags = DIO_LOCKING | DIO_SKIP_HOLES;
	} else if (is_sync_kiocb(iocb)) {
3748 3749
		get_block_func = ext4_dio_get_block_unwritten_sync;
		dio_flags = DIO_LOCKING;
3750
	} else {
3751
		get_block_func = ext4_dio_get_block_unwritten_async;
3752 3753
		dio_flags = DIO_LOCKING;
	}
3754 3755 3756
	ret = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
				   get_block_func, ext4_end_io_dio, NULL,
				   dio_flags);
3757

J
Jan Kara 已提交
3758
	if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
3759 3760 3761 3762 3763 3764
						EXT4_STATE_DIO_UNWRITTEN)) {
		int err;
		/*
		 * for non AIO case, since the IO is already
		 * completed, we could do the conversion right here
		 */
3765
		err = ext4_convert_unwritten_extents(NULL, inode,
3766 3767 3768 3769 3770
						     offset, ret);
		if (err < 0)
			ret = err;
		ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
	}
3771

J
Jan Kara 已提交
3772
	inode_dio_end(inode);
3773
	/* take i_mutex locking again if we do a ovewrite dio */
3774
	if (overwrite)
A
Al Viro 已提交
3775
		inode_lock(inode);
3776

J
Jan Kara 已提交
3777 3778 3779 3780 3781 3782 3783 3784 3785 3786
	if (ret < 0 && final_size > inode->i_size)
		ext4_truncate_failed_write(inode);

	/* Handle extending of i_size after direct IO write */
	if (orphan) {
		int err;

		/* Credits for sb + inode write */
		handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
		if (IS_ERR(handle)) {
3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798
			/*
			 * We wrote the data but cannot extend
			 * i_size. Bail out. In async io case, we do
			 * not return error here because we have
			 * already submmitted the corresponding
			 * bio. Returning error here makes the caller
			 * think that this IO is done and failed
			 * resulting in race with bio's completion
			 * handler.
			 */
			if (!ret)
				ret = PTR_ERR(handle);
J
Jan Kara 已提交
3799 3800 3801 3802 3803 3804 3805 3806 3807
			if (inode->i_nlink)
				ext4_orphan_del(NULL, inode);

			goto out;
		}
		if (inode->i_nlink)
			ext4_orphan_del(handle, inode);
		if (ret > 0) {
			loff_t end = offset + ret;
3808
			if (end > inode->i_size || end > ei->i_disksize) {
3809
				ext4_update_i_disksize(inode, end);
3810 3811
				if (end > inode->i_size)
					i_size_write(inode, end);
J
Jan Kara 已提交
3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829
				/*
				 * We're going to return a positive `ret'
				 * here due to non-zero-length I/O, so there's
				 * no way of reporting error returns from
				 * ext4_mark_inode_dirty() to userspace.  So
				 * ignore it.
				 */
				ext4_mark_inode_dirty(handle, inode);
			}
		}
		err = ext4_journal_stop(handle);
		if (ret == 0)
			ret = err;
	}
out:
	return ret;
}

3830
static ssize_t ext4_direct_IO_read(struct kiocb *iocb, struct iov_iter *iter)
J
Jan Kara 已提交
3831
{
J
Jan Kara 已提交
3832 3833
	struct address_space *mapping = iocb->ki_filp->f_mapping;
	struct inode *inode = mapping->host;
3834
	size_t count = iov_iter_count(iter);
J
Jan Kara 已提交
3835 3836
	ssize_t ret;

J
Jan Kara 已提交
3837 3838 3839 3840 3841 3842
	/*
	 * Shared inode_lock is enough for us - it protects against concurrent
	 * writes & truncates and since we take care of writing back page cache,
	 * we are protected against page writeback as well.
	 */
	inode_lock_shared(inode);
3843
	ret = filemap_write_and_wait_range(mapping, iocb->ki_pos,
3844
					   iocb->ki_pos + count - 1);
3845 3846 3847 3848
	if (ret)
		goto out_unlock;
	ret = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev,
				   iter, ext4_dio_get_block, NULL, NULL, 0);
J
Jan Kara 已提交
3849 3850
out_unlock:
	inode_unlock_shared(inode);
3851
	return ret;
3852 3853
}

3854
static ssize_t ext4_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
3855 3856 3857
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
3858
	size_t count = iov_iter_count(iter);
3859
	loff_t offset = iocb->ki_pos;
3860
	ssize_t ret;
3861

3862 3863 3864 3865 3866
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	if (ext4_encrypted_inode(inode) && S_ISREG(inode->i_mode))
		return 0;
#endif

3867 3868 3869 3870 3871 3872
	/*
	 * If we are doing data journalling we don't support O_DIRECT
	 */
	if (ext4_should_journal_data(inode))
		return 0;

T
Tao Ma 已提交
3873 3874 3875 3876
	/* Let buffer I/O handle the inline data case. */
	if (ext4_has_inline_data(inode))
		return 0;

3877
	trace_ext4_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
J
Jan Kara 已提交
3878
	if (iov_iter_rw(iter) == READ)
3879
		ret = ext4_direct_IO_read(iocb, iter);
3880
	else
3881
		ret = ext4_direct_IO_write(iocb, iter);
3882
	trace_ext4_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), ret);
3883
	return ret;
3884 3885
}

3886
/*
3887
 * Pages can be marked dirty completely asynchronously from ext4's journalling
3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898
 * 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.
 */
3899
static int ext4_journalled_set_page_dirty(struct page *page)
3900 3901 3902 3903 3904
{
	SetPageChecked(page);
	return __set_page_dirty_nobuffers(page);
}

3905 3906 3907 3908 3909 3910 3911
static int ext4_set_page_dirty(struct page *page)
{
	WARN_ON_ONCE(!PageLocked(page) && !PageDirty(page));
	WARN_ON_ONCE(!page_has_buffers(page));
	return __set_page_dirty_buffers(page);
}

3912
static const struct address_space_operations ext4_aops = {
3913 3914
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3915
	.writepage		= ext4_writepage,
3916
	.writepages		= ext4_writepages,
3917
	.write_begin		= ext4_write_begin,
3918
	.write_end		= ext4_write_end,
3919
	.set_page_dirty		= ext4_set_page_dirty,
3920 3921 3922 3923 3924 3925
	.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,
3926
	.error_remove_page	= generic_error_remove_page,
3927 3928
};

3929
static const struct address_space_operations ext4_journalled_aops = {
3930 3931
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3932
	.writepage		= ext4_writepage,
3933
	.writepages		= ext4_writepages,
3934 3935 3936 3937
	.write_begin		= ext4_write_begin,
	.write_end		= ext4_journalled_write_end,
	.set_page_dirty		= ext4_journalled_set_page_dirty,
	.bmap			= ext4_bmap,
3938
	.invalidatepage		= ext4_journalled_invalidatepage,
3939
	.releasepage		= ext4_releasepage,
3940
	.direct_IO		= ext4_direct_IO,
3941
	.is_partially_uptodate  = block_is_partially_uptodate,
3942
	.error_remove_page	= generic_error_remove_page,
3943 3944
};

3945
static const struct address_space_operations ext4_da_aops = {
3946 3947
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3948
	.writepage		= ext4_writepage,
3949
	.writepages		= ext4_writepages,
3950 3951
	.write_begin		= ext4_da_write_begin,
	.write_end		= ext4_da_write_end,
3952
	.set_page_dirty		= ext4_set_page_dirty,
3953 3954 3955 3956 3957 3958
	.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,
3959
	.error_remove_page	= generic_error_remove_page,
3960 3961
};

3962 3963 3964 3965
static const struct address_space_operations ext4_dax_aops = {
	.writepages		= ext4_dax_writepages,
	.direct_IO		= noop_direct_IO,
	.set_page_dirty		= noop_set_page_dirty,
3966
	.bmap			= ext4_bmap,
3967 3968 3969
	.invalidatepage		= noop_invalidatepage,
};

3970
void ext4_set_aops(struct inode *inode)
3971
{
3972 3973 3974 3975 3976
	switch (ext4_inode_journal_mode(inode)) {
	case EXT4_INODE_ORDERED_DATA_MODE:
	case EXT4_INODE_WRITEBACK_DATA_MODE:
		break;
	case EXT4_INODE_JOURNAL_DATA_MODE:
3977
		inode->i_mapping->a_ops = &ext4_journalled_aops;
3978
		return;
3979 3980 3981
	default:
		BUG();
	}
3982 3983 3984
	if (IS_DAX(inode))
		inode->i_mapping->a_ops = &ext4_dax_aops;
	else if (test_opt(inode->i_sb, DELALLOC))
3985 3986 3987
		inode->i_mapping->a_ops = &ext4_da_aops;
	else
		inode->i_mapping->a_ops = &ext4_aops;
3988 3989
}

R
Ross Zwisler 已提交
3990
static int __ext4_block_zero_page_range(handle_t *handle,
3991 3992
		struct address_space *mapping, loff_t from, loff_t length)
{
3993 3994
	ext4_fsblk_t index = from >> PAGE_SHIFT;
	unsigned offset = from & (PAGE_SIZE-1);
R
Ross Zwisler 已提交
3995
	unsigned blocksize, pos;
3996 3997 3998 3999 4000 4001
	ext4_lblk_t iblock;
	struct inode *inode = mapping->host;
	struct buffer_head *bh;
	struct page *page;
	int err = 0;

4002
	page = find_or_create_page(mapping, from >> PAGE_SHIFT,
4003
				   mapping_gfp_constraint(mapping, ~__GFP_FS));
4004 4005 4006 4007 4008
	if (!page)
		return -ENOMEM;

	blocksize = inode->i_sb->s_blocksize;

4009
	iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041

	if (!page_has_buffers(page))
		create_empty_buffers(page, blocksize, 0);

	/* Find the buffer that contains "offset" */
	bh = page_buffers(page);
	pos = blocksize;
	while (offset >= pos) {
		bh = bh->b_this_page;
		iblock++;
		pos += blocksize;
	}
	if (buffer_freed(bh)) {
		BUFFER_TRACE(bh, "freed: skip");
		goto unlock;
	}
	if (!buffer_mapped(bh)) {
		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 unlock;
		}
	}

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

	if (!buffer_uptodate(bh)) {
		err = -EIO;
4042
		ll_rw_block(REQ_OP_READ, 0, 1, &bh);
4043 4044 4045 4046
		wait_on_buffer(bh);
		/* Uhhuh. Read error. Complain and punt. */
		if (!buffer_uptodate(bh))
			goto unlock;
4047 4048 4049
		if (S_ISREG(inode->i_mode) &&
		    ext4_encrypted_inode(inode)) {
			/* We expect the key to be set. */
4050
			BUG_ON(!fscrypt_has_encryption_key(inode));
4051
			BUG_ON(blocksize != PAGE_SIZE);
4052
			WARN_ON_ONCE(fscrypt_decrypt_page(page->mapping->host,
4053
						page, PAGE_SIZE, 0, page->index));
4054
		}
4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066
	}
	if (ext4_should_journal_data(inode)) {
		BUFFER_TRACE(bh, "get write access");
		err = ext4_journal_get_write_access(handle, bh);
		if (err)
			goto unlock;
	}
	zero_user(page, offset, length);
	BUFFER_TRACE(bh, "zeroed end of block");

	if (ext4_should_journal_data(inode)) {
		err = ext4_handle_dirty_metadata(handle, inode, bh);
4067
	} else {
4068
		err = 0;
4069
		mark_buffer_dirty(bh);
J
Jan Kara 已提交
4070
		if (ext4_should_order_data(inode))
4071 4072
			err = ext4_jbd2_inode_add_write(handle, inode, from,
					length);
4073
	}
4074 4075 4076

unlock:
	unlock_page(page);
4077
	put_page(page);
4078 4079 4080
	return err;
}

R
Ross Zwisler 已提交
4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091
/*
 * ext4_block_zero_page_range() zeros out a mapping of length 'length'
 * starting from file offset 'from'.  The range to be zero'd must
 * be contained with in one block.  If the specified range exceeds
 * the end of the block it will be shortened to end of the block
 * that cooresponds to 'from'
 */
static int ext4_block_zero_page_range(handle_t *handle,
		struct address_space *mapping, loff_t from, loff_t length)
{
	struct inode *inode = mapping->host;
4092
	unsigned offset = from & (PAGE_SIZE-1);
R
Ross Zwisler 已提交
4093 4094 4095 4096 4097 4098 4099 4100 4101 4102
	unsigned blocksize = inode->i_sb->s_blocksize;
	unsigned max = blocksize - (offset & (blocksize - 1));

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

4103 4104 4105 4106
	if (IS_DAX(inode)) {
		return iomap_zero_range(inode, from, length, NULL,
					&ext4_iomap_ops);
	}
R
Ross Zwisler 已提交
4107 4108 4109
	return __ext4_block_zero_page_range(handle, mapping, from, length);
}

4110 4111 4112 4113 4114 4115
/*
 * ext4_block_truncate_page() zeroes out a mapping from file offset `from'
 * up to the end of the block which corresponds to `from'.
 * This required during truncate. We need to physically zero the tail end
 * of that block so it doesn't yield old data if the file is later grown.
 */
4116
static int ext4_block_truncate_page(handle_t *handle,
4117 4118
		struct address_space *mapping, loff_t from)
{
4119
	unsigned offset = from & (PAGE_SIZE-1);
4120 4121 4122 4123
	unsigned length;
	unsigned blocksize;
	struct inode *inode = mapping->host;

4124 4125 4126 4127
	/* If we are processing an encrypted inode during orphan list handling */
	if (ext4_encrypted_inode(inode) && !fscrypt_has_encryption_key(inode))
		return 0;

4128 4129 4130 4131 4132 4133
	blocksize = inode->i_sb->s_blocksize;
	length = blocksize - (offset & (blocksize - 1));

	return ext4_block_zero_page_range(handle, mapping, from, length);
}

4134 4135 4136 4137 4138
int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode,
			     loff_t lstart, loff_t length)
{
	struct super_block *sb = inode->i_sb;
	struct address_space *mapping = inode->i_mapping;
4139
	unsigned partial_start, partial_end;
4140 4141 4142 4143
	ext4_fsblk_t start, end;
	loff_t byte_end = (lstart + length - 1);
	int err = 0;

4144 4145 4146
	partial_start = lstart & (sb->s_blocksize - 1);
	partial_end = byte_end & (sb->s_blocksize - 1);

4147 4148 4149 4150
	start = lstart >> sb->s_blocksize_bits;
	end = byte_end >> sb->s_blocksize_bits;

	/* Handle partial zero within the single block */
4151 4152
	if (start == end &&
	    (partial_start || (partial_end != sb->s_blocksize - 1))) {
4153 4154 4155 4156 4157
		err = ext4_block_zero_page_range(handle, mapping,
						 lstart, length);
		return err;
	}
	/* Handle partial zero out on the start of the range */
4158
	if (partial_start) {
4159 4160 4161 4162 4163 4164
		err = ext4_block_zero_page_range(handle, mapping,
						 lstart, sb->s_blocksize);
		if (err)
			return err;
	}
	/* Handle partial zero out on the end of the range */
4165
	if (partial_end != sb->s_blocksize - 1)
4166
		err = ext4_block_zero_page_range(handle, mapping,
4167 4168
						 byte_end - partial_end,
						 partial_end + 1);
4169 4170 4171
	return err;
}

4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182
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;
}

4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194
/*
 * We have to make sure i_disksize gets properly updated before we truncate
 * page cache due to hole punching or zero range. Otherwise i_disksize update
 * can get lost as it may have been postponed to submission of writeback but
 * that will never happen after we truncate page cache.
 */
int ext4_update_disksize_before_punch(struct inode *inode, loff_t offset,
				      loff_t len)
{
	handle_t *handle;
	loff_t size = i_size_read(inode);

A
Al Viro 已提交
4195
	WARN_ON(!inode_is_locked(inode));
4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211
	if (offset > size || offset + len < size)
		return 0;

	if (EXT4_I(inode)->i_disksize >= size)
		return 0;

	handle = ext4_journal_start(inode, EXT4_HT_MISC, 1);
	if (IS_ERR(handle))
		return PTR_ERR(handle);
	ext4_update_i_disksize(inode, size);
	ext4_mark_inode_dirty(handle, inode);
	ext4_journal_stop(handle);

	return 0;
}

4212
static void ext4_wait_dax_page(struct ext4_inode_info *ei)
4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235
{
	up_write(&ei->i_mmap_sem);
	schedule();
	down_write(&ei->i_mmap_sem);
}

int ext4_break_layouts(struct inode *inode)
{
	struct ext4_inode_info *ei = EXT4_I(inode);
	struct page *page;
	int error;

	if (WARN_ON_ONCE(!rwsem_is_locked(&ei->i_mmap_sem)))
		return -EINVAL;

	do {
		page = dax_layout_busy_page(inode->i_mapping);
		if (!page)
			return 0;

		error = ___wait_var_event(&page->_refcount,
				atomic_read(&page->_refcount) == 1,
				TASK_INTERRUPTIBLE, 0, 0,
4236 4237
				ext4_wait_dax_page(ei));
	} while (error == 0);
4238 4239 4240 4241

	return error;
}

4242
/*
4243
 * ext4_punch_hole: punches a hole in a file by releasing the blocks
4244 4245 4246 4247 4248 4249
 * associated with the given offset and length
 *
 * @inode:  File inode
 * @offset: The offset where the hole will begin
 * @len:    The length of the hole
 *
4250
 * Returns: 0 on success or negative on failure
4251 4252
 */

4253
int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length)
4254
{
T
Theodore Ts'o 已提交
4255 4256 4257
	struct super_block *sb = inode->i_sb;
	ext4_lblk_t first_block, stop_block;
	struct address_space *mapping = inode->i_mapping;
4258
	loff_t first_block_offset, last_block_offset;
T
Theodore Ts'o 已提交
4259 4260 4261 4262
	handle_t *handle;
	unsigned int credits;
	int ret = 0;

4263
	if (!S_ISREG(inode->i_mode))
4264
		return -EOPNOTSUPP;
4265

4266
	trace_ext4_punch_hole(inode, offset, length, 0);
4267

4268 4269 4270 4271 4272 4273 4274 4275 4276
	ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
	if (ext4_has_inline_data(inode)) {
		down_write(&EXT4_I(inode)->i_mmap_sem);
		ret = ext4_convert_inline_data(inode);
		up_write(&EXT4_I(inode)->i_mmap_sem);
		if (ret)
			return ret;
	}

T
Theodore Ts'o 已提交
4277 4278 4279 4280
	/*
	 * Write out all dirty pages to avoid race conditions
	 * Then release them.
	 */
4281
	if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
T
Theodore Ts'o 已提交
4282 4283 4284 4285 4286 4287
		ret = filemap_write_and_wait_range(mapping, offset,
						   offset + length - 1);
		if (ret)
			return ret;
	}

A
Al Viro 已提交
4288
	inode_lock(inode);
4289

T
Theodore Ts'o 已提交
4290 4291 4292 4293 4294 4295 4296 4297 4298 4299
	/* No need to punch hole beyond i_size */
	if (offset >= inode->i_size)
		goto out_mutex;

	/*
	 * If the hole extends beyond i_size, set the hole
	 * to end after the page that contains i_size
	 */
	if (offset + length > inode->i_size) {
		length = inode->i_size +
4300
		   PAGE_SIZE - (inode->i_size & (PAGE_SIZE - 1)) -
T
Theodore Ts'o 已提交
4301 4302 4303
		   offset;
	}

4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315
	if (offset & (sb->s_blocksize - 1) ||
	    (offset + length) & (sb->s_blocksize - 1)) {
		/*
		 * Attach jinode to inode for jbd2 if we do any zeroing of
		 * partial block
		 */
		ret = ext4_inode_attach_jinode(inode);
		if (ret < 0)
			goto out_mutex;

	}

4316 4317 4318 4319 4320 4321 4322 4323
	/* Wait all existing dio workers, newcomers will block on i_mutex */
	inode_dio_wait(inode);

	/*
	 * Prevent page faults from reinstantiating pages we have released from
	 * page cache.
	 */
	down_write(&EXT4_I(inode)->i_mmap_sem);
4324 4325 4326 4327 4328

	ret = ext4_break_layouts(inode);
	if (ret)
		goto out_dio;

4329 4330
	first_block_offset = round_up(offset, sb->s_blocksize);
	last_block_offset = round_down((offset + length), sb->s_blocksize) - 1;
T
Theodore Ts'o 已提交
4331

4332
	/* Now release the pages and zero block aligned part of pages*/
4333 4334 4335 4336
	if (last_block_offset > first_block_offset) {
		ret = ext4_update_disksize_before_punch(inode, offset, length);
		if (ret)
			goto out_dio;
4337 4338
		truncate_pagecache_range(inode, first_block_offset,
					 last_block_offset);
4339
	}
T
Theodore Ts'o 已提交
4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351

	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
		credits = ext4_writepage_trans_blocks(inode);
	else
		credits = ext4_blocks_for_truncate(inode);
	handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
	if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
		ext4_std_error(sb, ret);
		goto out_dio;
	}

4352 4353 4354 4355
	ret = ext4_zero_partial_blocks(handle, inode, offset,
				       length);
	if (ret)
		goto out_stop;
T
Theodore Ts'o 已提交
4356 4357 4358 4359 4360

	first_block = (offset + sb->s_blocksize - 1) >>
		EXT4_BLOCK_SIZE_BITS(sb);
	stop_block = (offset + length) >> EXT4_BLOCK_SIZE_BITS(sb);

4361 4362
	/* If there are blocks to remove, do it */
	if (stop_block > first_block) {
T
Theodore Ts'o 已提交
4363

4364 4365
		down_write(&EXT4_I(inode)->i_data_sem);
		ext4_discard_preallocations(inode);
T
Theodore Ts'o 已提交
4366

4367 4368 4369 4370 4371 4372
		ret = ext4_es_remove_extent(inode, first_block,
					    stop_block - first_block);
		if (ret) {
			up_write(&EXT4_I(inode)->i_data_sem);
			goto out_stop;
		}
T
Theodore Ts'o 已提交
4373

4374 4375 4376 4377 4378 4379
		if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
			ret = ext4_ext_remove_space(inode, first_block,
						    stop_block - 1);
		else
			ret = ext4_ind_remove_space(handle, inode, first_block,
						    stop_block);
T
Theodore Ts'o 已提交
4380

4381 4382
		up_write(&EXT4_I(inode)->i_data_sem);
	}
T
Theodore Ts'o 已提交
4383 4384
	if (IS_SYNC(inode))
		ext4_handle_sync(handle);
4385

4386
	inode->i_mtime = inode->i_ctime = current_time(inode);
T
Theodore Ts'o 已提交
4387
	ext4_mark_inode_dirty(handle, inode);
4388 4389
	if (ret >= 0)
		ext4_update_inode_fsync_trans(handle, inode, 1);
T
Theodore Ts'o 已提交
4390 4391 4392
out_stop:
	ext4_journal_stop(handle);
out_dio:
4393
	up_write(&EXT4_I(inode)->i_mmap_sem);
T
Theodore Ts'o 已提交
4394
out_mutex:
A
Al Viro 已提交
4395
	inode_unlock(inode);
T
Theodore Ts'o 已提交
4396
	return ret;
4397 4398
}

4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423
int ext4_inode_attach_jinode(struct inode *inode)
{
	struct ext4_inode_info *ei = EXT4_I(inode);
	struct jbd2_inode *jinode;

	if (ei->jinode || !EXT4_SB(inode->i_sb)->s_journal)
		return 0;

	jinode = jbd2_alloc_inode(GFP_KERNEL);
	spin_lock(&inode->i_lock);
	if (!ei->jinode) {
		if (!jinode) {
			spin_unlock(&inode->i_lock);
			return -ENOMEM;
		}
		ei->jinode = jinode;
		jbd2_journal_init_jbd_inode(ei->jinode, inode);
		jinode = NULL;
	}
	spin_unlock(&inode->i_lock);
	if (unlikely(jinode != NULL))
		jbd2_free_inode(jinode);
	return 0;
}

4424
/*
4425
 * ext4_truncate()
4426
 *
4427 4428
 * We block out ext4_get_block() block instantiations across the entire
 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
4429 4430
 * simultaneously on behalf of the same inode.
 *
4431
 * As we work through the truncate and commit bits of it to the journal there
4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444
 * 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
4445
 * i_disksize in this case).  After a crash, ext4_orphan_cleanup() will see
4446
 * that this inode's truncate did not complete and it will again call
4447 4448
 * 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
4449
 * that's fine - as long as they are linked from the inode, the post-crash
4450
 * ext4_truncate() run will find them and release them.
4451
 */
4452
int ext4_truncate(struct inode *inode)
4453
{
T
Theodore Ts'o 已提交
4454 4455
	struct ext4_inode_info *ei = EXT4_I(inode);
	unsigned int credits;
4456
	int err = 0;
T
Theodore Ts'o 已提交
4457 4458 4459
	handle_t *handle;
	struct address_space *mapping = inode->i_mapping;

4460 4461
	/*
	 * There is a possibility that we're either freeing the inode
M
Matthew Wilcox 已提交
4462
	 * or it's a completely new inode. In those cases we might not
4463 4464 4465
	 * have i_mutex locked because it's not necessary.
	 */
	if (!(inode->i_state & (I_NEW|I_FREEING)))
A
Al Viro 已提交
4466
		WARN_ON(!inode_is_locked(inode));
4467 4468
	trace_ext4_truncate_enter(inode);

4469
	if (!ext4_can_truncate(inode))
4470
		return 0;
4471

4472
	ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
4473

4474
	if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
4475
		ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
4476

4477 4478 4479
	if (ext4_has_inline_data(inode)) {
		int has_inline = 1;

4480 4481 4482
		err = ext4_inline_data_truncate(inode, &has_inline);
		if (err)
			return err;
4483
		if (has_inline)
4484
			return 0;
4485 4486
	}

4487 4488 4489
	/* If we zero-out tail of the page, we have to create jinode for jbd2 */
	if (inode->i_size & (inode->i_sb->s_blocksize - 1)) {
		if (ext4_inode_attach_jinode(inode) < 0)
4490
			return 0;
4491 4492
	}

T
Theodore Ts'o 已提交
4493 4494 4495 4496 4497 4498
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
		credits = ext4_writepage_trans_blocks(inode);
	else
		credits = ext4_blocks_for_truncate(inode);

	handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
4499 4500
	if (IS_ERR(handle))
		return PTR_ERR(handle);
T
Theodore Ts'o 已提交
4501

4502 4503
	if (inode->i_size & (inode->i_sb->s_blocksize - 1))
		ext4_block_truncate_page(handle, mapping, inode->i_size);
T
Theodore Ts'o 已提交
4504 4505 4506 4507 4508 4509 4510 4511 4512 4513

	/*
	 * We add the inode to the orphan list, so that if this
	 * truncate spans multiple transactions, and we crash, we will
	 * resume the truncate when the filesystem recovers.  It also
	 * marks the inode dirty, to catch the new size.
	 *
	 * Implication: the file must always be in a sane, consistent
	 * truncatable state while each transaction commits.
	 */
4514 4515
	err = ext4_orphan_add(handle, inode);
	if (err)
T
Theodore Ts'o 已提交
4516 4517 4518 4519 4520 4521
		goto out_stop;

	down_write(&EXT4_I(inode)->i_data_sem);

	ext4_discard_preallocations(inode);

4522
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
4523
		err = ext4_ext_truncate(handle, inode);
4524
	else
T
Theodore Ts'o 已提交
4525 4526 4527
		ext4_ind_truncate(handle, inode);

	up_write(&ei->i_data_sem);
4528 4529
	if (err)
		goto out_stop;
T
Theodore Ts'o 已提交
4530 4531 4532 4533 4534 4535 4536 4537 4538

	if (IS_SYNC(inode))
		ext4_handle_sync(handle);

out_stop:
	/*
	 * If this was a simple ftruncate() and the file will remain alive,
	 * then we need to clear up the orphan record which we created above.
	 * However, if this was a real unlink then we were called by
4539
	 * ext4_evict_inode(), and we allow that function to clean up the
T
Theodore Ts'o 已提交
4540 4541 4542 4543 4544
	 * orphan info for us.
	 */
	if (inode->i_nlink)
		ext4_orphan_del(handle, inode);

4545
	inode->i_mtime = inode->i_ctime = current_time(inode);
T
Theodore Ts'o 已提交
4546 4547
	ext4_mark_inode_dirty(handle, inode);
	ext4_journal_stop(handle);
4548

4549
	trace_ext4_truncate_exit(inode);
4550
	return err;
4551 4552 4553
}

/*
4554
 * ext4_get_inode_loc returns with an extra refcount against the inode's
4555 4556 4557 4558
 * 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.
 */
4559 4560
static int __ext4_get_inode_loc(struct inode *inode,
				struct ext4_iloc *iloc, int in_mem)
4561
{
4562 4563 4564 4565 4566 4567
	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 已提交
4568
	iloc->bh = NULL;
4569 4570
	if (inode->i_ino < EXT4_ROOT_INO ||
	    inode->i_ino > le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count))
4571
		return -EFSCORRUPTED;
4572

4573 4574 4575
	iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
	gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
	if (!gdp)
4576 4577
		return -EIO;

4578 4579 4580
	/*
	 * Figure out the offset within the block group inode table
	 */
4581
	inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
4582 4583 4584 4585 4586 4587
	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);
4588
	if (unlikely(!bh))
4589
		return -ENOMEM;
4590 4591
	if (!buffer_uptodate(bh)) {
		lock_buffer(bh);
4592 4593 4594 4595 4596 4597 4598 4599 4600 4601

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

4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614
		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;
4615
			int i, start;
4616

4617
			start = inode_offset & ~(inodes_per_block - 1);
4618

4619 4620
			/* Is the inode bitmap in cache? */
			bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
4621
			if (unlikely(!bitmap_bh))
4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632
				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;
			}
4633
			for (i = start; i < start + inodes_per_block; i++) {
4634 4635
				if (i == inode_offset)
					continue;
4636
				if (ext4_test_bit(i, bitmap_bh->b_data))
4637 4638 4639
					break;
			}
			brelse(bitmap_bh);
4640
			if (i == start + inodes_per_block) {
4641 4642 4643 4644 4645 4646 4647 4648 4649
				/* 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:
4650 4651 4652 4653 4654 4655 4656
		/*
		 * 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;
4657
			__u32 ra_blks = EXT4_SB(sb)->s_inode_readahead_blks;
4658 4659

			table = ext4_inode_table(sb, gdp);
T
Theodore Ts'o 已提交
4660
			/* s_inode_readahead_blks is always a power of 2 */
4661
			b = block & ~((ext4_fsblk_t) ra_blks - 1);
4662 4663
			if (table > b)
				b = table;
4664
			end = b + ra_blks;
4665
			num = EXT4_INODES_PER_GROUP(sb);
4666
			if (ext4_has_group_desc_csum(sb))
4667
				num -= ext4_itable_unused_count(sb, gdp);
4668 4669 4670 4671 4672 4673 4674
			table += num / inodes_per_block;
			if (end > table)
				end = table;
			while (b <= end)
				sb_breadahead(sb, b++);
		}

4675 4676 4677 4678 4679
		/*
		 * 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.
		 */
4680
		trace_ext4_load_inode(inode);
4681 4682
		get_bh(bh);
		bh->b_end_io = end_buffer_read_sync;
4683
		submit_bh(REQ_OP_READ, REQ_META | REQ_PRIO, bh);
4684 4685
		wait_on_buffer(bh);
		if (!buffer_uptodate(bh)) {
4686 4687
			EXT4_ERROR_INODE_BLOCK(inode, block,
					       "unable to read itable block");
4688 4689 4690 4691 4692 4693 4694 4695 4696
			brelse(bh);
			return -EIO;
		}
	}
has_buffer:
	iloc->bh = bh;
	return 0;
}

4697
int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
4698 4699
{
	/* We have all inode data except xattrs in memory here. */
4700
	return __ext4_get_inode_loc(inode, iloc,
4701
		!ext4_test_inode_state(inode, EXT4_STATE_XATTR));
4702 4703
}

R
Ross Zwisler 已提交
4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718
static bool ext4_should_use_dax(struct inode *inode)
{
	if (!test_opt(inode->i_sb, DAX))
		return false;
	if (!S_ISREG(inode->i_mode))
		return false;
	if (ext4_should_journal_data(inode))
		return false;
	if (ext4_has_inline_data(inode))
		return false;
	if (ext4_encrypted_inode(inode))
		return false;
	return true;
}

4719
void ext4_set_inode_flags(struct inode *inode)
4720
{
4721
	unsigned int flags = EXT4_I(inode)->i_flags;
4722
	unsigned int new_fl = 0;
4723

4724
	if (flags & EXT4_SYNC_FL)
4725
		new_fl |= S_SYNC;
4726
	if (flags & EXT4_APPEND_FL)
4727
		new_fl |= S_APPEND;
4728
	if (flags & EXT4_IMMUTABLE_FL)
4729
		new_fl |= S_IMMUTABLE;
4730
	if (flags & EXT4_NOATIME_FL)
4731
		new_fl |= S_NOATIME;
4732
	if (flags & EXT4_DIRSYNC_FL)
4733
		new_fl |= S_DIRSYNC;
R
Ross Zwisler 已提交
4734
	if (ext4_should_use_dax(inode))
R
Ross Zwisler 已提交
4735
		new_fl |= S_DAX;
4736 4737
	if (flags & EXT4_ENCRYPT_FL)
		new_fl |= S_ENCRYPTED;
4738
	inode_set_flags(inode, new_fl,
4739 4740
			S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_DAX|
			S_ENCRYPTED);
4741 4742
}

4743
static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
4744
				  struct ext4_inode_info *ei)
4745 4746
{
	blkcnt_t i_blocks ;
A
Aneesh Kumar K.V 已提交
4747 4748
	struct inode *inode = &(ei->vfs_inode);
	struct super_block *sb = inode->i_sb;
4749

4750
	if (ext4_has_feature_huge_file(sb)) {
4751 4752 4753
		/* 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);
4754
		if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) {
A
Aneesh Kumar K.V 已提交
4755 4756 4757 4758 4759
			/* i_blocks represent file system block size */
			return i_blocks  << (inode->i_blkbits - 9);
		} else {
			return i_blocks;
		}
4760 4761 4762 4763
	} else {
		return le32_to_cpu(raw_inode->i_blocks_lo);
	}
}
4764

4765
static inline int ext4_iget_extra_inode(struct inode *inode,
4766 4767 4768 4769 4770
					 struct ext4_inode *raw_inode,
					 struct ext4_inode_info *ei)
{
	__le32 *magic = (void *)raw_inode +
			EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize;
4771

4772 4773 4774
	if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize + sizeof(__le32) <=
	    EXT4_INODE_SIZE(inode->i_sb) &&
	    *magic == cpu_to_le32(EXT4_XATTR_MAGIC)) {
4775
		ext4_set_inode_state(inode, EXT4_STATE_XATTR);
4776
		return ext4_find_inline_data_nolock(inode);
4777 4778
	} else
		EXT4_I(inode)->i_inline_off = 0;
4779
	return 0;
4780 4781
}

L
Li Xi 已提交
4782 4783
int ext4_get_projid(struct inode *inode, kprojid_t *projid)
{
K
Kaho Ng 已提交
4784
	if (!ext4_has_feature_project(inode->i_sb))
L
Li Xi 已提交
4785 4786 4787 4788 4789
		return -EOPNOTSUPP;
	*projid = EXT4_I(inode)->i_projid;
	return 0;
}

4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809
/*
 * ext4 has self-managed i_version for ea inodes, it stores the lower 32bit of
 * refcount in i_version, so use raw values if inode has EXT4_EA_INODE_FL flag
 * set.
 */
static inline void ext4_inode_set_iversion_queried(struct inode *inode, u64 val)
{
	if (unlikely(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL))
		inode_set_iversion_raw(inode, val);
	else
		inode_set_iversion_queried(inode, val);
}
static inline u64 ext4_inode_peek_iversion(const struct inode *inode)
{
	if (unlikely(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL))
		return inode_peek_iversion_raw(inode);
	else
		return inode_peek_iversion(inode);
}

4810 4811 4812
struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
			  ext4_iget_flags flags, const char *function,
			  unsigned int line)
4813
{
4814 4815
	struct ext4_iloc iloc;
	struct ext4_inode *raw_inode;
4816 4817
	struct ext4_inode_info *ei;
	struct inode *inode;
4818
	journal_t *journal = EXT4_SB(sb)->s_journal;
4819
	long ret;
4820
	loff_t size;
4821
	int block;
4822 4823
	uid_t i_uid;
	gid_t i_gid;
L
Li Xi 已提交
4824
	projid_t i_projid;
4825

4826
	if ((!(flags & EXT4_IGET_SPECIAL) &&
4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837
	     (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO)) ||
	    (ino < EXT4_ROOT_INO) ||
	    (ino > le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count))) {
		if (flags & EXT4_IGET_HANDLE)
			return ERR_PTR(-ESTALE);
		__ext4_error(sb, function, line,
			     "inode #%lu: comm %s: iget: illegal inode #",
			     ino, current->comm);
		return ERR_PTR(-EFSCORRUPTED);
	}

4838 4839 4840 4841 4842 4843 4844
	inode = iget_locked(sb, ino);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;

	ei = EXT4_I(inode);
4845
	iloc.bh = NULL;
4846

4847 4848
	ret = __ext4_get_inode_loc(inode, &iloc, 0);
	if (ret < 0)
4849
		goto bad_inode;
4850
	raw_inode = ext4_raw_inode(&iloc);
4851

4852
	if ((ino == EXT4_ROOT_INO) && (raw_inode->i_links_count == 0)) {
4853 4854
		ext4_error_inode(inode, function, line, 0,
				 "iget: root inode unallocated");
4855 4856 4857 4858
		ret = -EFSCORRUPTED;
		goto bad_inode;
	}

4859 4860 4861 4862 4863 4864
	if ((flags & EXT4_IGET_HANDLE) &&
	    (raw_inode->i_links_count == 0) && (raw_inode->i_mode == 0)) {
		ret = -ESTALE;
		goto bad_inode;
	}

4865 4866 4867
	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 >
4868 4869
			EXT4_INODE_SIZE(inode->i_sb) ||
		    (ei->i_extra_isize & 3)) {
4870 4871 4872
			ext4_error_inode(inode, function, line, 0,
					 "iget: bad extra_isize %u "
					 "(inode size %u)",
4873 4874
					 ei->i_extra_isize,
					 EXT4_INODE_SIZE(inode->i_sb));
4875
			ret = -EFSCORRUPTED;
4876 4877 4878 4879 4880 4881
			goto bad_inode;
		}
	} else
		ei->i_extra_isize = 0;

	/* Precompute checksum seed for inode metadata */
4882
	if (ext4_has_metadata_csum(sb)) {
4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893
		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)) {
4894 4895
		ext4_error_inode(inode, function, line, 0,
				 "iget: checksum invalid");
4896
		ret = -EFSBADCRC;
4897 4898 4899
		goto bad_inode;
	}

4900
	inode->i_mode = le16_to_cpu(raw_inode->i_mode);
4901 4902
	i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
	i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
K
Kaho Ng 已提交
4903
	if (ext4_has_feature_project(sb) &&
L
Li Xi 已提交
4904 4905 4906 4907 4908 4909
	    EXT4_INODE_SIZE(sb) > EXT4_GOOD_OLD_INODE_SIZE &&
	    EXT4_FITS_IN_INODE(raw_inode, ei, i_projid))
		i_projid = (projid_t)le32_to_cpu(raw_inode->i_projid);
	else
		i_projid = EXT4_DEF_PROJID;

4910
	if (!(test_opt(inode->i_sb, NO_UID32))) {
4911 4912
		i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
		i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
4913
	}
4914 4915
	i_uid_write(inode, i_uid);
	i_gid_write(inode, i_gid);
L
Li Xi 已提交
4916
	ei->i_projid = make_kprojid(&init_user_ns, i_projid);
M
Miklos Szeredi 已提交
4917
	set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
4918

4919
	ext4_clear_state_flags(ei);	/* Only relevant on 32-bit archs */
4920
	ei->i_inline_off = 0;
4921 4922 4923 4924 4925 4926 4927 4928
	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) {
4929 4930 4931
		if ((inode->i_mode == 0 ||
		     !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) &&
		    ino != EXT4_BOOT_LOADER_INO) {
4932
			/* this inode is deleted */
4933
			ret = -ESTALE;
4934 4935 4936 4937 4938
			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
4939 4940 4941
		 * the process of deleting those.
		 * OR it is the EXT4_BOOT_LOADER_INO which is
		 * not initialized on a new filesystem. */
4942 4943
	}
	ei->i_flags = le32_to_cpu(raw_inode->i_flags);
4944
	ext4_set_inode_flags(inode);
4945
	inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
4946
	ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
4947
	if (ext4_has_feature_64bit(sb))
B
Badari Pulavarty 已提交
4948 4949
		ei->i_file_acl |=
			((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
A
Artem Blagodarenko 已提交
4950
	inode->i_size = ext4_isize(sb, raw_inode);
4951
	if ((size = i_size_read(inode)) < 0) {
4952 4953
		ext4_error_inode(inode, function, line, 0,
				 "iget: bad i_size value: %lld", size);
4954 4955 4956
		ret = -EFSCORRUPTED;
		goto bad_inode;
	}
4957
	ei->i_disksize = inode->i_size;
4958 4959 4960
#ifdef CONFIG_QUOTA
	ei->i_reserved_quota = 0;
#endif
4961 4962
	inode->i_generation = le32_to_cpu(raw_inode->i_generation);
	ei->i_block_group = iloc.block_group;
4963
	ei->i_last_alloc_group = ~0;
4964 4965 4966 4967
	/*
	 * 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!
	 */
4968
	for (block = 0; block < EXT4_N_BLOCKS; block++)
4969 4970 4971
		ei->i_data[block] = raw_inode->i_block[block];
	INIT_LIST_HEAD(&ei->i_orphan);

4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982
	/*
	 * 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;

4983
		read_lock(&journal->j_state_lock);
4984 4985 4986 4987 4988 4989 4990 4991
		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;
4992
		read_unlock(&journal->j_state_lock);
4993 4994 4995 4996
		ei->i_sync_tid = tid;
		ei->i_datasync_tid = tid;
	}

4997
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
4998 4999
		if (ei->i_extra_isize == 0) {
			/* The extra space is currently unused. Use it. */
5000
			BUILD_BUG_ON(sizeof(struct ext4_inode) & 3);
5001 5002
			ei->i_extra_isize = sizeof(struct ext4_inode) -
					    EXT4_GOOD_OLD_INODE_SIZE;
5003
		} else {
5004 5005 5006
			ret = ext4_iget_extra_inode(inode, raw_inode, ei);
			if (ret)
				goto bad_inode;
5007
		}
5008
	}
5009

K
Kalpak Shah 已提交
5010 5011 5012 5013 5014
	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);

5015
	if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) {
J
Jeff Layton 已提交
5016 5017
		u64 ivers = le32_to_cpu(raw_inode->i_disk_version);

5018 5019
		if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
			if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
J
Jeff Layton 已提交
5020
				ivers |=
5021 5022
		    (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
		}
5023
		ext4_inode_set_iversion_queried(inode, ivers);
5024 5025
	}

5026
	ret = 0;
5027
	if (ei->i_file_acl &&
5028
	    !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
5029 5030
		ext4_error_inode(inode, function, line, 0,
				 "iget: bad extended attribute block %llu",
5031
				 ei->i_file_acl);
5032
		ret = -EFSCORRUPTED;
5033
		goto bad_inode;
5034
	} else if (!ext4_has_inline_data(inode)) {
5035 5036 5037 5038 5039
		/* validate the block references in the inode */
		if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
		   (S_ISLNK(inode->i_mode) &&
		    !ext4_inode_is_fast_symlink(inode))) {
			if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
5040
				ret = ext4_ext_check_inode(inode);
5041 5042
			else
				ret = ext4_ind_check_inode(inode);
5043
		}
5044
	}
5045
	if (ret)
5046
		goto bad_inode;
5047

5048
	if (S_ISREG(inode->i_mode)) {
5049
		inode->i_op = &ext4_file_inode_operations;
5050
		inode->i_fop = &ext4_file_operations;
5051
		ext4_set_aops(inode);
5052
	} else if (S_ISDIR(inode->i_mode)) {
5053 5054
		inode->i_op = &ext4_dir_inode_operations;
		inode->i_fop = &ext4_dir_operations;
5055
	} else if (S_ISLNK(inode->i_mode)) {
5056 5057
		/* VFS does not allow setting these so must be corruption */
		if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) {
5058 5059 5060
			ext4_error_inode(inode, function, line, 0,
					 "iget: immutable or append flags "
					 "not allowed on symlinks");
5061 5062 5063
			ret = -EFSCORRUPTED;
			goto bad_inode;
		}
5064 5065 5066 5067
		if (ext4_encrypted_inode(inode)) {
			inode->i_op = &ext4_encrypted_symlink_inode_operations;
			ext4_set_aops(inode);
		} else if (ext4_inode_is_fast_symlink(inode)) {
A
Al Viro 已提交
5068
			inode->i_link = (char *)ei->i_data;
5069
			inode->i_op = &ext4_fast_symlink_inode_operations;
5070 5071 5072
			nd_terminate_link(ei->i_data, inode->i_size,
				sizeof(ei->i_data) - 1);
		} else {
5073 5074
			inode->i_op = &ext4_symlink_inode_operations;
			ext4_set_aops(inode);
5075
		}
5076
		inode_nohighmem(inode);
5077 5078
	} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
	      S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
5079
		inode->i_op = &ext4_special_inode_operations;
5080 5081 5082 5083 5084 5085
		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])));
5086 5087
	} else if (ino == EXT4_BOOT_LOADER_INO) {
		make_bad_inode(inode);
5088
	} else {
5089
		ret = -EFSCORRUPTED;
5090 5091
		ext4_error_inode(inode, function, line, 0,
				 "iget: bogus i_mode (%o)", inode->i_mode);
5092
		goto bad_inode;
5093
	}
5094
	brelse(iloc.bh);
T
Tahsin Erdogan 已提交
5095

5096 5097
	unlock_new_inode(inode);
	return inode;
5098 5099

bad_inode:
5100
	brelse(iloc.bh);
5101 5102
	iget_failed(inode);
	return ERR_PTR(ret);
5103 5104
}

5105 5106 5107 5108 5109 5110 5111 5112 5113 5114
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) {
		/*
5115
		 * i_blocks can be represented in a 32 bit variable
5116 5117
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
5118
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
5119
		raw_inode->i_blocks_high = 0;
5120
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
5121 5122
		return 0;
	}
5123
	if (!ext4_has_feature_huge_file(sb))
5124 5125 5126
		return -EFBIG;

	if (i_blocks <= 0xffffffffffffULL) {
5127 5128 5129 5130
		/*
		 * i_blocks can be represented in a 48 bit variable
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
5131
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
5132
		raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
5133
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
5134
	} else {
5135
		ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE);
A
Aneesh Kumar K.V 已提交
5136 5137 5138 5139
		/* 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);
5140
	}
5141
	return 0;
5142 5143
}

5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155
struct other_inode {
	unsigned long		orig_ino;
	struct ext4_inode	*raw_inode;
};

static int other_inode_match(struct inode * inode, unsigned long ino,
			     void *data)
{
	struct other_inode *oi = (struct other_inode *) data;

	if ((inode->i_ino != ino) ||
	    (inode->i_state & (I_FREEING | I_WILL_FREE | I_NEW |
5156
			       I_DIRTY_INODE)) ||
5157 5158 5159 5160
	    ((inode->i_state & I_DIRTY_TIME) == 0))
		return 0;
	spin_lock(&inode->i_lock);
	if (((inode->i_state & (I_FREEING | I_WILL_FREE | I_NEW |
5161
				I_DIRTY_INODE)) == 0) &&
5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193
	    (inode->i_state & I_DIRTY_TIME)) {
		struct ext4_inode_info	*ei = EXT4_I(inode);

		inode->i_state &= ~(I_DIRTY_TIME | I_DIRTY_TIME_EXPIRED);
		spin_unlock(&inode->i_lock);

		spin_lock(&ei->i_raw_lock);
		EXT4_INODE_SET_XTIME(i_ctime, inode, oi->raw_inode);
		EXT4_INODE_SET_XTIME(i_mtime, inode, oi->raw_inode);
		EXT4_INODE_SET_XTIME(i_atime, inode, oi->raw_inode);
		ext4_inode_csum_set(inode, oi->raw_inode, ei);
		spin_unlock(&ei->i_raw_lock);
		trace_ext4_other_inode_update_time(inode, oi->orig_ino);
		return -1;
	}
	spin_unlock(&inode->i_lock);
	return -1;
}

/*
 * Opportunistically update the other time fields for other inodes in
 * the same inode table block.
 */
static void ext4_update_other_inodes_time(struct super_block *sb,
					  unsigned long orig_ino, char *buf)
{
	struct other_inode oi;
	unsigned long ino;
	int i, inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
	int inode_size = EXT4_INODE_SIZE(sb);

	oi.orig_ino = orig_ino;
5194 5195 5196 5197 5198 5199
	/*
	 * Calculate the first inode in the inode table block.  Inode
	 * numbers are one-based.  That is, the first inode in a block
	 * (assuming 4k blocks and 256 byte inodes) is (n*16 + 1).
	 */
	ino = ((orig_ino - 1) & ~(inodes_per_block - 1)) + 1;
5200 5201 5202 5203 5204 5205 5206 5207
	for (i = 0; i < inodes_per_block; i++, ino++, buf += inode_size) {
		if (ino == orig_ino)
			continue;
		oi.raw_inode = (struct ext4_inode *) buf;
		(void) find_inode_nowait(sb, ino, other_inode_match, &oi);
	}
}

5208 5209 5210 5211 5212 5213 5214
/*
 * 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.
 */
5215
static int ext4_do_update_inode(handle_t *handle,
5216
				struct inode *inode,
5217
				struct ext4_iloc *iloc)
5218
{
5219 5220
	struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
	struct ext4_inode_info *ei = EXT4_I(inode);
5221
	struct buffer_head *bh = iloc->bh;
5222
	struct super_block *sb = inode->i_sb;
5223
	int err = 0, rc, block;
5224
	int need_datasync = 0, set_large_file = 0;
5225 5226
	uid_t i_uid;
	gid_t i_gid;
L
Li Xi 已提交
5227
	projid_t i_projid;
5228

5229 5230 5231
	spin_lock(&ei->i_raw_lock);

	/* For fields not tracked in the in-memory inode,
5232
	 * initialise them to zero for new inodes. */
5233
	if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
5234
		memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
5235 5236

	raw_inode->i_mode = cpu_to_le16(inode->i_mode);
5237 5238
	i_uid = i_uid_read(inode);
	i_gid = i_gid_read(inode);
L
Li Xi 已提交
5239
	i_projid = from_kprojid(&init_user_ns, ei->i_projid);
5240
	if (!(test_opt(inode->i_sb, NO_UID32))) {
5241 5242
		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));
5243 5244 5245 5246
/*
 * Fix up interoperability with old kernels. Otherwise, old inodes get
 * re-used with the upper 16 bits of the uid/gid intact
 */
5247 5248 5249 5250
		if (ei->i_dtime && list_empty(&ei->i_orphan)) {
			raw_inode->i_uid_high = 0;
			raw_inode->i_gid_high = 0;
		} else {
5251
			raw_inode->i_uid_high =
5252
				cpu_to_le16(high_16_bits(i_uid));
5253
			raw_inode->i_gid_high =
5254
				cpu_to_le16(high_16_bits(i_gid));
5255 5256
		}
	} else {
5257 5258
		raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid));
		raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(i_gid));
5259 5260 5261 5262
		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 已提交
5263 5264 5265 5266 5267 5268

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

5269 5270
	err = ext4_inode_blocks_set(handle, raw_inode, ei);
	if (err) {
5271
		spin_unlock(&ei->i_raw_lock);
5272
		goto out_brelse;
5273
	}
5274
	raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
5275
	raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF);
5276
	if (likely(!test_opt2(inode->i_sb, HURD_COMPAT)))
B
Badari Pulavarty 已提交
5277 5278
		raw_inode->i_file_acl_high =
			cpu_to_le16(ei->i_file_acl >> 32);
5279
	raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
A
Artem Blagodarenko 已提交
5280
	if (ei->i_disksize != ext4_isize(inode->i_sb, raw_inode)) {
5281 5282 5283
		ext4_isize_set(raw_inode, ei->i_disksize);
		need_datasync = 1;
	}
5284
	if (ei->i_disksize > 0x7fffffffULL) {
5285
		if (!ext4_has_feature_large_file(sb) ||
5286
				EXT4_SB(sb)->s_es->s_rev_level ==
5287 5288
		    cpu_to_le32(EXT4_GOOD_OLD_REV))
			set_large_file = 1;
5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301
	}
	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;
		}
5302
	} else if (!ext4_has_inline_data(inode)) {
5303 5304
		for (block = 0; block < EXT4_N_BLOCKS; block++)
			raw_inode->i_block[block] = ei->i_data[block];
5305
	}
5306

5307
	if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) {
5308
		u64 ivers = ext4_inode_peek_iversion(inode);
J
Jeff Layton 已提交
5309 5310

		raw_inode->i_disk_version = cpu_to_le32(ivers);
5311 5312 5313
		if (ei->i_extra_isize) {
			if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
				raw_inode->i_version_hi =
J
Jeff Layton 已提交
5314
					cpu_to_le32(ivers >> 32);
5315 5316 5317
			raw_inode->i_extra_isize =
				cpu_to_le16(ei->i_extra_isize);
		}
5318
	}
L
Li Xi 已提交
5319

K
Kaho Ng 已提交
5320
	BUG_ON(!ext4_has_feature_project(inode->i_sb) &&
L
Li Xi 已提交
5321 5322 5323 5324 5325 5326
	       i_projid != EXT4_DEF_PROJID);

	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
	    EXT4_FITS_IN_INODE(raw_inode, ei, i_projid))
		raw_inode->i_projid = cpu_to_le32(i_projid);

5327
	ext4_inode_csum_set(inode, raw_inode, ei);
5328
	spin_unlock(&ei->i_raw_lock);
5329
	if (inode->i_sb->s_flags & SB_LAZYTIME)
5330 5331
		ext4_update_other_inodes_time(inode->i_sb, inode->i_ino,
					      bh->b_data);
5332

5333
	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
5334
	rc = ext4_handle_dirty_metadata(handle, NULL, bh);
5335 5336
	if (!err)
		err = rc;
5337
	ext4_clear_inode_state(inode, EXT4_STATE_NEW);
5338
	if (set_large_file) {
5339
		BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get write access");
5340 5341 5342
		err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
		if (err)
			goto out_brelse;
5343
		ext4_set_feature_large_file(sb);
5344 5345 5346
		ext4_handle_sync(handle);
		err = ext4_handle_dirty_super(handle, sb);
	}
5347
	ext4_update_inode_fsync_trans(handle, inode, need_datasync);
5348
out_brelse:
5349
	brelse(bh);
5350
	ext4_std_error(inode->i_sb, err);
5351 5352 5353 5354
	return err;
}

/*
5355
 * ext4_write_inode()
5356 5357 5358
 *
 * We are called from a few places:
 *
5359
 * - Within generic_file_aio_write() -> generic_write_sync() for O_SYNC files.
5360
 *   Here, there will be no transaction running. We wait for any running
5361
 *   transaction to commit.
5362
 *
5363 5364
 * - Within flush work (sys_sync(), kupdate and such).
 *   We wait on commit, if told to.
5365
 *
5366 5367
 * - Within iput_final() -> write_inode_now()
 *   We wait on commit, if told to.
5368 5369 5370
 *
 * 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
5371 5372
 * ext4_mark_inode_dirty().  This is a correctness thing for WB_SYNC_ALL
 * writeback.
5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383
 *
 * 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;
 *
5384 5385 5386
 * is in error because 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.
5387
 */
5388
int ext4_write_inode(struct inode *inode, struct writeback_control *wbc)
5389
{
5390 5391
	int err;

5392 5393
	if (WARN_ON_ONCE(current->flags & PF_MEMALLOC) ||
	    sb_rdonly(inode->i_sb))
5394 5395
		return 0;

5396 5397 5398
	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
		return -EIO;

5399 5400 5401 5402 5403 5404
	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;
		}
5405

5406 5407 5408 5409 5410 5411
		/*
		 * No need to force transaction in WB_SYNC_NONE mode. Also
		 * ext4_sync_fs() will force the commit after everything is
		 * written.
		 */
		if (wbc->sync_mode != WB_SYNC_ALL || wbc->for_sync)
5412 5413
			return 0;

5414 5415
		err = jbd2_complete_transaction(EXT4_SB(inode->i_sb)->s_journal,
						EXT4_I(inode)->i_sync_tid);
5416 5417
	} else {
		struct ext4_iloc iloc;
5418

5419
		err = __ext4_get_inode_loc(inode, &iloc, 0);
5420 5421
		if (err)
			return err;
5422 5423 5424 5425 5426
		/*
		 * sync(2) will flush the whole buffer cache. No need to do
		 * it here separately for each inode.
		 */
		if (wbc->sync_mode == WB_SYNC_ALL && !wbc->for_sync)
5427 5428
			sync_dirty_buffer(iloc.bh);
		if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
5429 5430
			EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr,
					 "IO error syncing inode");
5431 5432
			err = -EIO;
		}
5433
		brelse(iloc.bh);
5434 5435
	}
	return err;
5436 5437
}

5438 5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450
/*
 * 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;

5451
	offset = inode->i_size & (PAGE_SIZE - 1);
5452 5453
	/*
	 * All buffers in the last page remain valid? Then there's nothing to
5454
	 * do. We do the check mainly to optimize the common PAGE_SIZE ==
5455 5456
	 * blocksize case
	 */
F
Fabian Frederick 已提交
5457
	if (offset > PAGE_SIZE - i_blocksize(inode))
5458 5459 5460
		return;
	while (1) {
		page = find_lock_page(inode->i_mapping,
5461
				      inode->i_size >> PAGE_SHIFT);
5462 5463
		if (!page)
			return;
5464
		ret = __ext4_journalled_invalidatepage(page, offset,
5465
						PAGE_SIZE - offset);
5466
		unlock_page(page);
5467
		put_page(page);
5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479
		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);
	}
}

5480
/*
5481
 * ext4_setattr()
5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494
 *
 * 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.)
 *
5495 5496 5497 5498 5499 5500 5501 5502
 * 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.
5503
 */
5504
int ext4_setattr(struct dentry *dentry, struct iattr *attr)
5505
{
5506
	struct inode *inode = d_inode(dentry);
5507
	int error, rc = 0;
5508
	int orphan = 0;
5509 5510
	const unsigned int ia_valid = attr->ia_valid;

5511 5512 5513
	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
		return -EIO;

5514 5515 5516 5517 5518 5519 5520 5521
	if (unlikely(IS_IMMUTABLE(inode)))
		return -EPERM;

	if (unlikely(IS_APPEND(inode) &&
		     (ia_valid & (ATTR_MODE | ATTR_UID |
				  ATTR_GID | ATTR_TIMES_SET))))
		return -EPERM;

5522
	error = setattr_prepare(dentry, attr);
5523 5524 5525
	if (error)
		return error;

5526 5527 5528 5529
	error = fscrypt_prepare_setattr(dentry, attr);
	if (error)
		return error;

5530 5531 5532 5533 5534
	if (is_quota_modification(inode, attr)) {
		error = dquot_initialize(inode);
		if (error)
			return error;
	}
5535 5536
	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))) {
5537 5538 5539 5540
		handle_t *handle;

		/* (user+group)*(old+new) structure, inode write (sb,
		 * inode block, ? - but truncate inode update has it) */
5541 5542 5543
		handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
			(EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb) +
			 EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)) + 3);
5544 5545 5546 5547
		if (IS_ERR(handle)) {
			error = PTR_ERR(handle);
			goto err_out;
		}
5548 5549 5550 5551 5552

		/* dquot_transfer() calls back ext4_get_inode_usage() which
		 * counts xattr inode references.
		 */
		down_read(&EXT4_I(inode)->xattr_sem);
5553
		error = dquot_transfer(inode, attr);
5554 5555
		up_read(&EXT4_I(inode)->xattr_sem);

5556
		if (error) {
5557
			ext4_journal_stop(handle);
5558 5559 5560 5561 5562 5563 5564 5565
			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;
5566 5567
		error = ext4_mark_inode_dirty(handle, inode);
		ext4_journal_stop(handle);
5568 5569
	}

5570
	if (attr->ia_valid & ATTR_SIZE) {
5571
		handle_t *handle;
5572 5573
		loff_t oldsize = inode->i_size;
		int shrink = (attr->ia_size <= inode->i_size);
5574

5575
		if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
5576 5577
			struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

5578 5579
			if (attr->ia_size > sbi->s_bitmap_maxbytes)
				return -EFBIG;
5580
		}
5581 5582
		if (!S_ISREG(inode->i_mode))
			return -EINVAL;
C
Christoph Hellwig 已提交
5583 5584 5585 5586

		if (IS_I_VERSION(inode) && attr->ia_size != inode->i_size)
			inode_inc_iversion(inode);

5587
		if (ext4_should_order_data(inode) &&
5588
		    (attr->ia_size < inode->i_size)) {
5589
			error = ext4_begin_ordered_truncate(inode,
5590
							    attr->ia_size);
5591 5592 5593 5594
			if (error)
				goto err_out;
		}
		if (attr->ia_size != inode->i_size) {
5595 5596 5597 5598 5599
			handle = ext4_journal_start(inode, EXT4_HT_INODE, 3);
			if (IS_ERR(handle)) {
				error = PTR_ERR(handle);
				goto err_out;
			}
5600
			if (ext4_handle_valid(handle) && shrink) {
5601 5602 5603
				error = ext4_orphan_add(handle, inode);
				orphan = 1;
			}
E
Eryu Guan 已提交
5604 5605 5606 5607 5608
			/*
			 * Update c/mtime on truncate up, ext4_truncate() will
			 * update c/mtime in shrink case below
			 */
			if (!shrink) {
5609
				inode->i_mtime = current_time(inode);
E
Eryu Guan 已提交
5610 5611
				inode->i_ctime = inode->i_mtime;
			}
5612
			down_write(&EXT4_I(inode)->i_data_sem);
5613 5614 5615 5616
			EXT4_I(inode)->i_disksize = attr->ia_size;
			rc = ext4_mark_inode_dirty(handle, inode);
			if (!error)
				error = rc;
5617 5618 5619 5620 5621 5622 5623 5624
			/*
			 * We have to update i_size under i_data_sem together
			 * with i_disksize to avoid races with writeback code
			 * running ext4_wb_update_i_disksize().
			 */
			if (!error)
				i_size_write(inode, attr->ia_size);
			up_write(&EXT4_I(inode)->i_data_sem);
5625 5626
			ext4_journal_stop(handle);
			if (error) {
5627
				if (orphan && inode->i_nlink)
5628
					ext4_orphan_del(NULL, inode);
5629 5630
				goto err_out;
			}
5631
		}
5632
		if (!shrink) {
5633
			pagecache_isize_extended(inode, oldsize, inode->i_size);
5634 5635 5636 5637 5638 5639
		} else {
			/*
			 * Blocks are going to be removed from the inode. Wait
			 * for dio in flight.
			 */
			inode_dio_wait(inode);
5640
		}
5641 5642
		if (orphan && ext4_should_journal_data(inode))
			ext4_wait_for_tail_page_commit(inode);
5643
		down_write(&EXT4_I(inode)->i_mmap_sem);
5644 5645 5646 5647 5648 5649 5650 5651

		rc = ext4_break_layouts(inode);
		if (rc) {
			up_write(&EXT4_I(inode)->i_mmap_sem);
			error = rc;
			goto err_out;
		}

5652 5653 5654 5655
		/*
		 * Truncate pagecache after we've waited for commit
		 * in data=journal mode to make pages freeable.
		 */
R
Ross Zwisler 已提交
5656
		truncate_pagecache(inode, inode->i_size);
5657 5658 5659 5660 5661
		if (shrink) {
			rc = ext4_truncate(inode);
			if (rc)
				error = rc;
		}
5662
		up_write(&EXT4_I(inode)->i_mmap_sem);
5663
	}
5664

5665
	if (!error) {
C
Christoph Hellwig 已提交
5666 5667 5668 5669 5670 5671 5672 5673
		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.
	 */
5674
	if (orphan && inode->i_nlink)
5675
		ext4_orphan_del(NULL, inode);
5676

5677
	if (!error && (ia_valid & ATTR_MODE))
5678
		rc = posix_acl_chmod(inode, inode->i_mode);
5679 5680

err_out:
5681
	ext4_std_error(inode->i_sb, error);
5682 5683 5684 5685 5686
	if (!error)
		error = rc;
	return error;
}

5687 5688
int ext4_getattr(const struct path *path, struct kstat *stat,
		 u32 request_mask, unsigned int query_flags)
5689
{
D
David Howells 已提交
5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711
	struct inode *inode = d_inode(path->dentry);
	struct ext4_inode *raw_inode;
	struct ext4_inode_info *ei = EXT4_I(inode);
	unsigned int flags;

	if (EXT4_FITS_IN_INODE(raw_inode, ei, i_crtime)) {
		stat->result_mask |= STATX_BTIME;
		stat->btime.tv_sec = ei->i_crtime.tv_sec;
		stat->btime.tv_nsec = ei->i_crtime.tv_nsec;
	}

	flags = ei->i_flags & EXT4_FL_USER_VISIBLE;
	if (flags & EXT4_APPEND_FL)
		stat->attributes |= STATX_ATTR_APPEND;
	if (flags & EXT4_COMPR_FL)
		stat->attributes |= STATX_ATTR_COMPRESSED;
	if (flags & EXT4_ENCRYPT_FL)
		stat->attributes |= STATX_ATTR_ENCRYPTED;
	if (flags & EXT4_IMMUTABLE_FL)
		stat->attributes |= STATX_ATTR_IMMUTABLE;
	if (flags & EXT4_NODUMP_FL)
		stat->attributes |= STATX_ATTR_NODUMP;
5712

5713 5714 5715 5716 5717 5718
	stat->attributes_mask |= (STATX_ATTR_APPEND |
				  STATX_ATTR_COMPRESSED |
				  STATX_ATTR_ENCRYPTED |
				  STATX_ATTR_IMMUTABLE |
				  STATX_ATTR_NODUMP);

5719
	generic_fillattr(inode, stat);
D
David Howells 已提交
5720 5721 5722 5723 5724 5725 5726 5727 5728 5729
	return 0;
}

int ext4_file_getattr(const struct path *path, struct kstat *stat,
		      u32 request_mask, unsigned int query_flags)
{
	struct inode *inode = d_inode(path->dentry);
	u64 delalloc_blocks;

	ext4_getattr(path, stat, request_mask, query_flags);
5730

5731 5732 5733 5734
	/*
	 * If there is inline data in the inode, the inode will normally not
	 * have data blocks allocated (it may have an external xattr block).
	 * Report at least one sector for such files, so tools like tar, rsync,
T
Theodore Ts'o 已提交
5735
	 * others don't incorrectly think the file is completely sparse.
5736 5737 5738 5739
	 */
	if (unlikely(ext4_has_inline_data(inode)))
		stat->blocks += (stat->size + 511) >> 9;

5740 5741 5742 5743 5744 5745 5746 5747 5748 5749
	/*
	 * 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.
	 */
5750
	delalloc_blocks = EXT4_C2B(EXT4_SB(inode->i_sb),
5751 5752
				   EXT4_I(inode)->i_reserved_data_blocks);
	stat->blocks += delalloc_blocks << (inode->i_sb->s_blocksize_bits - 9);
5753 5754
	return 0;
}
5755

5756 5757
static int ext4_index_trans_blocks(struct inode *inode, int lblocks,
				   int pextents)
5758
{
5759
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
5760 5761
		return ext4_ind_trans_blocks(inode, lblocks);
	return ext4_ext_index_trans_blocks(inode, pextents);
5762
}
5763

5764
/*
5765 5766 5767
 * 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
5768
 *
5769
 * If datablocks are discontiguous, they are possible to spread over
5770
 * different block groups too. If they are contiguous, with flexbg,
5771
 * they could still across block group boundary.
5772
 *
5773 5774
 * Also account for superblock, inode, quota and xattr blocks
 */
T
Tahsin Erdogan 已提交
5775
static int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
5776
				  int pextents)
5777
{
5778 5779
	ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
	int gdpblocks;
5780 5781 5782 5783
	int idxblocks;
	int ret = 0;

	/*
5784 5785
	 * How many index blocks need to touch to map @lblocks logical blocks
	 * to @pextents physical extents?
5786
	 */
5787
	idxblocks = ext4_index_trans_blocks(inode, lblocks, pextents);
5788 5789 5790 5791 5792 5793 5794

	ret = idxblocks;

	/*
	 * Now let's see how many group bitmaps and group descriptors need
	 * to account
	 */
5795
	groups = idxblocks + pextents;
5796
	gdpblocks = groups;
5797 5798
	if (groups > ngroups)
		groups = ngroups;
5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811
	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 已提交
5812
 * Calculate the total number of credits to reserve to fit
5813 5814
 * the modification of a single pages into a single transaction,
 * which may include multiple chunks of block allocations.
5815
 *
5816
 * This could be called via ext4_write_begin()
5817
 *
5818
 * We need to consider the worse case, when
5819
 * one new block per extent.
5820
 */
A
Alex Tomas 已提交
5821
int ext4_writepage_trans_blocks(struct inode *inode)
5822
{
5823
	int bpp = ext4_journal_blocks_per_page(inode);
5824 5825
	int ret;

5826
	ret = ext4_meta_trans_blocks(inode, bpp, bpp);
A
Alex Tomas 已提交
5827

5828
	/* Account for data blocks for journalled mode */
5829
	if (ext4_should_journal_data(inode))
5830
		ret += bpp;
5831 5832
	return ret;
}
5833 5834 5835 5836 5837

/*
 * Calculate the journal credits for a chunk of data modification.
 *
 * This is called from DIO, fallocate or whoever calling
5838
 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
5839 5840 5841 5842 5843 5844 5845 5846 5847
 *
 * 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);
}

5848
/*
5849
 * The caller must have previously called ext4_reserve_inode_write().
5850 5851
 * Give this, we know that the caller already has write access to iloc->bh.
 */
5852
int ext4_mark_iloc_dirty(handle_t *handle,
5853
			 struct inode *inode, struct ext4_iloc *iloc)
5854 5855 5856
{
	int err = 0;

5857 5858
	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) {
		put_bh(iloc->bh);
5859
		return -EIO;
5860
	}
5861
	if (IS_I_VERSION(inode))
5862 5863
		inode_inc_iversion(inode);

5864 5865 5866
	/* the do_update_inode consumes one bh->b_count */
	get_bh(iloc->bh);

5867
	/* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
5868
	err = ext4_do_update_inode(handle, inode, iloc);
5869 5870 5871 5872 5873 5874 5875 5876 5877 5878
	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
5879 5880
ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
			 struct ext4_iloc *iloc)
5881
{
5882 5883
	int err;

5884 5885 5886
	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb))))
		return -EIO;

5887 5888 5889 5890 5891 5892 5893
	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;
5894 5895
		}
	}
5896
	ext4_std_error(inode->i_sb, err);
5897 5898 5899
	return err;
}

5900 5901 5902 5903 5904 5905 5906
static int __ext4_expand_extra_isize(struct inode *inode,
				     unsigned int new_extra_isize,
				     struct ext4_iloc *iloc,
				     handle_t *handle, int *no_expand)
{
	struct ext4_inode *raw_inode;
	struct ext4_xattr_ibody_header *header;
5907 5908
	unsigned int inode_size = EXT4_INODE_SIZE(inode->i_sb);
	struct ext4_inode_info *ei = EXT4_I(inode);
5909
	int error;
5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921 5922

	/* this was checked at iget time, but double check for good measure */
	if ((EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize > inode_size) ||
	    (ei->i_extra_isize & 3)) {
		EXT4_ERROR_INODE(inode, "bad extra_isize %u (inode size %u)",
				 ei->i_extra_isize,
				 EXT4_INODE_SIZE(inode->i_sb));
		return -EFSCORRUPTED;
	}
	if ((new_extra_isize < ei->i_extra_isize) ||
	    (new_extra_isize < 4) ||
	    (new_extra_isize > inode_size - EXT4_GOOD_OLD_INODE_SIZE))
		return -EINVAL;	/* Should never happen */
5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947 5948 5949 5950

	raw_inode = ext4_raw_inode(iloc);

	header = IHDR(inode, raw_inode);

	/* No extended attributes present */
	if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
	    header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
		memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE +
		       EXT4_I(inode)->i_extra_isize, 0,
		       new_extra_isize - EXT4_I(inode)->i_extra_isize);
		EXT4_I(inode)->i_extra_isize = new_extra_isize;
		return 0;
	}

	/* try to expand with EAs present */
	error = ext4_expand_extra_isize_ea(inode, new_extra_isize,
					   raw_inode, handle);
	if (error) {
		/*
		 * Inode size expansion failed; don't try again
		 */
		*no_expand = 1;
	}

	return error;
}

5951 5952 5953 5954
/*
 * Expand an inode by new_extra_isize bytes.
 * Returns 0 on success or negative error number on failure.
 */
5955 5956 5957 5958
static int ext4_try_to_expand_extra_isize(struct inode *inode,
					  unsigned int new_extra_isize,
					  struct ext4_iloc iloc,
					  handle_t *handle)
5959
{
5960 5961
	int no_expand;
	int error;
5962

5963 5964 5965 5966 5967 5968 5969 5970 5971 5972 5973 5974 5975 5976 5977 5978
	if (ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND))
		return -EOVERFLOW;

	/*
	 * In nojournal mode, we can immediately attempt to expand
	 * the inode.  When journaled, we first need to obtain extra
	 * buffer credits since we may write into the 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 (ext4_handle_valid(handle) &&
	    jbd2_journal_extend(handle,
				EXT4_DATA_TRANS_BLOCKS(inode->i_sb)) != 0)
		return -ENOSPC;
5979

5980
	if (ext4_write_trylock_xattr(inode, &no_expand) == 0)
5981
		return -EBUSY;
5982

5983 5984 5985
	error = __ext4_expand_extra_isize(inode, new_extra_isize, &iloc,
					  handle, &no_expand);
	ext4_write_unlock_xattr(inode, &no_expand);
5986

5987 5988
	return error;
}
5989

5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000
int ext4_expand_extra_isize(struct inode *inode,
			    unsigned int new_extra_isize,
			    struct ext4_iloc *iloc)
{
	handle_t *handle;
	int no_expand;
	int error, rc;

	if (ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND)) {
		brelse(iloc->bh);
		return -EOVERFLOW;
6001 6002
	}

6003 6004 6005 6006 6007 6008 6009 6010 6011 6012
	handle = ext4_journal_start(inode, EXT4_HT_INODE,
				    EXT4_DATA_TRANS_BLOCKS(inode->i_sb));
	if (IS_ERR(handle)) {
		error = PTR_ERR(handle);
		brelse(iloc->bh);
		return error;
	}

	ext4_write_lock_xattr(inode, &no_expand);

6013
	BUFFER_TRACE(iloc->bh, "get_write_access");
6014
	error = ext4_journal_get_write_access(handle, iloc->bh);
6015
	if (error) {
6016 6017
		brelse(iloc->bh);
		goto out_stop;
6018
	}
6019

6020 6021 6022 6023 6024 6025 6026 6027 6028 6029
	error = __ext4_expand_extra_isize(inode, new_extra_isize, iloc,
					  handle, &no_expand);

	rc = ext4_mark_iloc_dirty(handle, inode, iloc);
	if (!error)
		error = rc;

	ext4_write_unlock_xattr(inode, &no_expand);
out_stop:
	ext4_journal_stop(handle);
6030
	return error;
6031 6032
}

6033 6034 6035 6036 6037 6038 6039 6040 6041 6042 6043 6044 6045
/*
 * 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.
 */
6046
int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
6047
{
6048
	struct ext4_iloc iloc;
6049
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
6050
	int err;
6051 6052

	might_sleep();
6053
	trace_ext4_mark_inode_dirty(inode, _RET_IP_);
6054
	err = ext4_reserve_inode_write(handle, inode, &iloc);
6055 6056
	if (err)
		return err;
6057 6058 6059 6060 6061

	if (EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize)
		ext4_try_to_expand_extra_isize(inode, sbi->s_want_extra_isize,
					       iloc, handle);

6062
	return ext4_mark_iloc_dirty(handle, inode, &iloc);
6063 6064 6065
}

/*
6066
 * ext4_dirty_inode() is called from __mark_inode_dirty()
6067 6068 6069 6070 6071
 *
 * 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.
 *
6072
 * Also, dquot_alloc_block() will always dirty the inode when blocks
6073 6074 6075 6076 6077
 * 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.
6078 6079 6080 6081
 *
 * If only the I_DIRTY_TIME flag is set, we can skip everything.  If
 * I_DIRTY_TIME and I_DIRTY_SYNC is set, the only inode fields we need
 * to copy into the on-disk inode structure are the timestamp files.
6082
 */
6083
void ext4_dirty_inode(struct inode *inode, int flags)
6084 6085 6086
{
	handle_t *handle;

6087 6088
	if (flags == I_DIRTY_TIME)
		return;
6089
	handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
6090 6091
	if (IS_ERR(handle))
		goto out;
6092 6093 6094

	ext4_mark_inode_dirty(handle, inode);

6095
	ext4_journal_stop(handle);
6096 6097 6098 6099 6100 6101 6102 6103
out:
	return;
}

#if 0
/*
 * Bind an inode's backing buffer_head into this transaction, to prevent
 * it from being flushed to disk early.  Unlike
6104
 * ext4_reserve_inode_write, this leaves behind no bh reference and
6105 6106 6107
 * returns no iloc structure, so the caller needs to repeat the iloc
 * lookup to mark the inode dirty later.
 */
6108
static int ext4_pin_inode(handle_t *handle, struct inode *inode)
6109
{
6110
	struct ext4_iloc iloc;
6111 6112 6113

	int err = 0;
	if (handle) {
6114
		err = ext4_get_inode_loc(inode, &iloc);
6115 6116
		if (!err) {
			BUFFER_TRACE(iloc.bh, "get_write_access");
6117
			err = jbd2_journal_get_write_access(handle, iloc.bh);
6118
			if (!err)
6119
				err = ext4_handle_dirty_metadata(handle,
6120
								 NULL,
6121
								 iloc.bh);
6122 6123 6124
			brelse(iloc.bh);
		}
	}
6125
	ext4_std_error(inode->i_sb, err);
6126 6127 6128 6129
	return err;
}
#endif

6130
int ext4_change_inode_journal_flag(struct inode *inode, int val)
6131 6132 6133 6134
{
	journal_t *journal;
	handle_t *handle;
	int err;
6135
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146

	/*
	 * 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.
	 */

6147
	journal = EXT4_JOURNAL(inode);
6148 6149
	if (!journal)
		return 0;
6150
	if (is_journal_aborted(journal))
6151 6152
		return -EROFS;

6153 6154 6155
	/* Wait for all existing dio workers */
	inode_dio_wait(inode);

6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172
	/*
	 * Before flushing the journal and switching inode's aops, we have
	 * to flush all dirty data the inode has. There can be outstanding
	 * delayed allocations, there can be unwritten extents created by
	 * fallocate or buffered writes in dioread_nolock mode covered by
	 * dirty data which can be converted only after flushing the dirty
	 * data (and journalled aops don't know how to handle these cases).
	 */
	if (val) {
		down_write(&EXT4_I(inode)->i_mmap_sem);
		err = filemap_write_and_wait(inode->i_mapping);
		if (err < 0) {
			up_write(&EXT4_I(inode)->i_mmap_sem);
			return err;
		}
	}

6173
	percpu_down_write(&sbi->s_journal_flag_rwsem);
6174
	jbd2_journal_lock_updates(journal);
6175 6176 6177 6178 6179 6180 6181 6182 6183 6184

	/*
	 * 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)
6185
		ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
6186
	else {
6187 6188 6189
		err = jbd2_journal_flush(journal);
		if (err < 0) {
			jbd2_journal_unlock_updates(journal);
6190
			percpu_up_write(&sbi->s_journal_flag_rwsem);
6191 6192
			return err;
		}
6193
		ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
6194
	}
6195
	ext4_set_aops(inode);
6196

6197
	jbd2_journal_unlock_updates(journal);
6198 6199
	percpu_up_write(&sbi->s_journal_flag_rwsem);

6200 6201
	if (val)
		up_write(&EXT4_I(inode)->i_mmap_sem);
6202 6203 6204

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

6205
	handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
6206 6207 6208
	if (IS_ERR(handle))
		return PTR_ERR(handle);

6209
	err = ext4_mark_inode_dirty(handle, inode);
6210
	ext4_handle_sync(handle);
6211 6212
	ext4_journal_stop(handle);
	ext4_std_error(inode->i_sb, err);
6213 6214 6215

	return err;
}
6216 6217 6218 6219 6220 6221

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

6222
int ext4_page_mkwrite(struct vm_fault *vmf)
6223
{
6224
	struct vm_area_struct *vma = vmf->vma;
6225
	struct page *page = vmf->page;
6226 6227
	loff_t size;
	unsigned long len;
6228
	int ret;
6229
	struct file *file = vma->vm_file;
A
Al Viro 已提交
6230
	struct inode *inode = file_inode(file);
6231
	struct address_space *mapping = inode->i_mapping;
6232 6233 6234
	handle_t *handle;
	get_block_t *get_block;
	int retries = 0;
6235

6236 6237 6238
	if (unlikely(IS_IMMUTABLE(inode)))
		return VM_FAULT_SIGBUS;

6239
	sb_start_pagefault(inode->i_sb);
6240
	file_update_time(vma->vm_file);
6241 6242

	down_read(&EXT4_I(inode)->i_mmap_sem);
6243 6244 6245 6246 6247

	ret = ext4_convert_inline_data(inode);
	if (ret)
		goto out_ret;

6248 6249 6250 6251 6252
	/* Delalloc case is easy... */
	if (test_opt(inode->i_sb, DELALLOC) &&
	    !ext4_should_journal_data(inode) &&
	    !ext4_nonda_switch(inode->i_sb)) {
		do {
6253
			ret = block_page_mkwrite(vma, vmf,
6254 6255 6256 6257
						   ext4_da_get_block_prep);
		} while (ret == -ENOSPC &&
		       ext4_should_retry_alloc(inode->i_sb, &retries));
		goto out_ret;
6258
	}
6259 6260

	lock_page(page);
6261 6262 6263 6264 6265 6266
	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;
6267
	}
6268

6269 6270
	if (page->index == size >> PAGE_SHIFT)
		len = size & ~PAGE_MASK;
6271
	else
6272
		len = PAGE_SIZE;
6273
	/*
6274 6275
	 * 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
6276
	 */
6277
	if (page_has_buffers(page)) {
6278 6279 6280
		if (!ext4_walk_page_buffers(NULL, page_buffers(page),
					    0, len, NULL,
					    ext4_bh_unmapped)) {
6281
			/* Wait so that we don't change page under IO */
6282
			wait_for_stable_page(page);
6283 6284
			ret = VM_FAULT_LOCKED;
			goto out;
6285
		}
6286
	}
6287
	unlock_page(page);
6288 6289
	/* OK, we need to fill the hole... */
	if (ext4_should_dioread_nolock(inode))
6290
		get_block = ext4_get_block_unwritten;
6291 6292 6293
	else
		get_block = ext4_get_block;
retry_alloc:
6294 6295
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
				    ext4_writepage_trans_blocks(inode));
6296
	if (IS_ERR(handle)) {
6297
		ret = VM_FAULT_SIGBUS;
6298 6299
		goto out;
	}
6300
	ret = block_page_mkwrite(vma, vmf, get_block);
6301
	if (!ret && ext4_should_journal_data(inode)) {
6302
		if (ext4_walk_page_buffers(handle, page_buffers(page), 0,
6303
			  PAGE_SIZE, NULL, do_journal_get_write_access)) {
6304 6305
			unlock_page(page);
			ret = VM_FAULT_SIGBUS;
6306
			ext4_journal_stop(handle);
6307 6308 6309 6310 6311 6312 6313 6314 6315 6316
			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:
6317
	up_read(&EXT4_I(inode)->i_mmap_sem);
6318
	sb_end_pagefault(inode->i_sb);
6319 6320
	return ret;
}
6321

6322
int ext4_filemap_fault(struct vm_fault *vmf)
6323
{
6324
	struct inode *inode = file_inode(vmf->vma->vm_file);
6325 6326 6327
	int err;

	down_read(&EXT4_I(inode)->i_mmap_sem);
6328
	err = filemap_fault(vmf);
6329 6330 6331 6332
	up_read(&EXT4_I(inode)->i_mmap_sem);

	return err;
}