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

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

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

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

49 50
#define MPAGE_DA_EXTENT_TAIL 0x01

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

60 61 62 63 64
	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);
65

66 67 68 69 70 71 72 73 74 75
	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;
		}
76 77
		csum = ext4_chksum(sbi, csum, (__u8 *)raw + offset,
				   EXT4_INODE_SIZE(inode->i_sb) - offset);
78 79 80 81 82 83 84 85 86 87 88 89
	}

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

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

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

145 146
/*
 * Test whether an inode is a fast symlink.
147
 * A fast symlink has its symlink data stored in ext4_inode_info->i_data.
148
 */
149
int ext4_inode_is_fast_symlink(struct inode *inode)
150
{
151 152
	return S_ISLNK(inode->i_mode) && inode->i_size &&
	       (inode->i_size < EXT4_N_BLOCKS * 4);
153 154 155 156 157 158 159
}

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

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

	return ret;
179 180 181 182 183
}

/*
 * Called at the last iput() if i_nlink is zero.
 */
A
Al Viro 已提交
184
void ext4_evict_inode(struct inode *inode)
185 186
{
	handle_t *handle;
187
	int err;
A
Andreas Dilger 已提交
188
	int extra_credits = 3;
189
	struct ext4_xattr_inode_array *ea_inode_array = NULL;
190

191
	trace_ext4_evict_inode(inode);
192

A
Al Viro 已提交
193
	if (inode->i_nlink) {
194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
		/*
		 * 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.
		 */
212 213
		if (inode->i_ino != EXT4_JOURNAL_INO &&
		    ext4_should_journal_data(inode) &&
214 215
		    (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode)) &&
		    inode->i_data.nrpages) {
216 217 218
			journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
			tid_t commit_tid = EXT4_I(inode)->i_datasync_tid;

219
			jbd2_complete_transaction(journal, commit_tid);
220 221
			filemap_write_and_wait(&inode->i_data);
		}
222
		truncate_inode_pages_final(&inode->i_data);
J
Jan Kara 已提交
223

A
Al Viro 已提交
224 225 226
		goto no_delete;
	}

227 228 229
	if (is_bad_inode(inode))
		goto no_delete;
	dquot_initialize(inode);
230

231 232
	if (ext4_should_order_data(inode))
		ext4_begin_ordered_truncate(inode, 0);
233
	truncate_inode_pages_final(&inode->i_data);
234

235 236 237 238 239
	/*
	 * Protect us against freezing - iput() caller didn't have to have any
	 * protection against it
	 */
	sb_start_intwrite(inode->i_sb);
A
Andreas Dilger 已提交
240

241 242 243 244 245
	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);
246
	if (IS_ERR(handle)) {
247
		ext4_std_error(inode->i_sb, PTR_ERR(handle));
248 249 250 251 252
		/*
		 * 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.
		 */
253
		ext4_orphan_del(NULL, inode);
254
		sb_end_intwrite(inode->i_sb);
255 256
		goto no_delete;
	}
257

258
	if (IS_SYNC(inode))
259
		ext4_handle_sync(handle);
260 261 262 263 264 265 266 267 268 269

	/*
	 * 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));
270
	inode->i_size = 0;
271 272
	err = ext4_mark_inode_dirty(handle, inode);
	if (err) {
273
		ext4_warning(inode->i_sb,
274 275 276
			     "couldn't mark inode dirty (err %d)", err);
		goto stop_handle;
	}
277 278 279 280 281 282 283 284 285
	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;
		}
	}
286

287 288 289 290 291 292 293 294 295 296 297
	/* 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;
298 299
	}

300
	/*
301
	 * Kill off the orphan record which ext4_truncate created.
302
	 * AKPM: I think this can be inside the above `if'.
303
	 * Note that ext4_orphan_del() has to be able to cope with the
304
	 * deletion of a non-existent orphan - this is because we don't
305
	 * know if ext4_truncate() actually created an orphan record.
306 307
	 * (Well, we could do this if we need to, but heck - it works)
	 */
308 309
	ext4_orphan_del(handle, inode);
	EXT4_I(inode)->i_dtime	= get_seconds();
310 311 312 313 314 315 316 317

	/*
	 * 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.
	 */
318
	if (ext4_mark_inode_dirty(handle, inode))
319
		/* If that failed, just do the required in-core inode clear. */
A
Al Viro 已提交
320
		ext4_clear_inode(inode);
321
	else
322 323
		ext4_free_inode(handle, inode);
	ext4_journal_stop(handle);
324
	sb_end_intwrite(inode->i_sb);
325
	ext4_xattr_inode_array_free(ea_inode_array);
326 327
	return;
no_delete:
A
Al Viro 已提交
328
	ext4_clear_inode(inode);	/* We must guarantee clearing of inode... */
329 330
}

331 332
#ifdef CONFIG_QUOTA
qsize_t *ext4_get_reserved_space(struct inode *inode)
333
{
334
	return &EXT4_I(inode)->i_reserved_quota;
335
}
336
#endif
337

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

	spin_lock(&ei->i_block_reservation_lock);
349
	trace_ext4_da_update_reserve_space(inode, used, quota_claim);
350
	if (unlikely(used > ei->i_reserved_data_blocks)) {
351
		ext4_warning(inode->i_sb, "%s: ino %lu, used %d "
352
			 "with only %d reserved data blocks",
353 354 355 356 357
			 __func__, inode->i_ino, used,
			 ei->i_reserved_data_blocks);
		WARN_ON(1);
		used = ei->i_reserved_data_blocks;
	}
358

359 360
	/* Update per-inode reservations */
	ei->i_reserved_data_blocks -= used;
361
	percpu_counter_sub(&sbi->s_dirtyclusters_counter, used);
362

363
	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
364

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

	/*
	 * 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.
	 */
382 383
	if ((ei->i_reserved_data_blocks == 0) &&
	    (atomic_read(&inode->i_writecount) == 0))
384
		ext4_discard_preallocations(inode);
385 386
}

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

J
Jan Kara 已提交
402 403 404 405 406 407
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))
408
		return fscrypt_zeroout_range(inode, lblk, pblk, len);
J
Jan Kara 已提交
409 410 411 412 413 414 415 416

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

	return ret;
}

417
#define check_block_validity(inode, map)	\
418
	__check_block_validity((inode), __func__, __LINE__, (map))
419

420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
#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.
	 */
437
	down_read(&EXT4_I(inode)->i_data_sem);
438 439 440 441 442 443 444
	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);
	}
445
	up_read((&EXT4_I(inode)->i_data_sem));
446 447 448 449 450 451 452 453

	/*
	 * 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) {
454
		printk("ES cache assertion failed for inode: %lu "
455 456 457 458 459 460 461 462 463 464
		       "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 */

465
/*
466
 * The ext4_map_blocks() function tries to look up the requested blocks,
467
 * and returns if the blocks are already mapped.
468 469 470 471 472
 *
 * 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.
 *
473 474
 * If file type is extents based, it will call ext4_ext_map_blocks(),
 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
475 476
 * based files
 *
477 478 479
 * 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.
480 481
 *
 * It returns 0 if plain look up failed (blocks have not been allocated), in
482 483
 * 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.
484 485 486
 *
 * It returns the error in case of allocation failure.
 */
487 488
int ext4_map_blocks(handle_t *handle, struct inode *inode,
		    struct ext4_map_blocks *map, int flags)
489
{
490
	struct extent_status es;
491
	int retval;
492
	int ret = 0;
493 494 495 496 497
#ifdef ES_AGGRESSIVE_TEST
	struct ext4_map_blocks orig_map;

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

499 500 501 502
	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);
503

504 505 506 507 508 509
	/*
	 * 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;

510 511
	/* We can handle the block number less than EXT_MAX_BLOCKS */
	if (unlikely(map->m_lblk >= EXT_MAX_BLOCKS))
512
		return -EFSCORRUPTED;
513

514 515 516 517 518 519 520 521 522 523 524 525
	/* 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)) {
526 527 528 529 530
			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;
531 532 533 534
			retval = 0;
		} else {
			BUG_ON(1);
		}
535 536 537 538
#ifdef ES_AGGRESSIVE_TEST
		ext4_map_blocks_es_recheck(handle, inode, map,
					   &orig_map, flags);
#endif
539 540 541
		goto found;
	}

542
	/*
543 544
	 * Try to see if we can get the block without requesting a new
	 * file system block.
545
	 */
546
	down_read(&EXT4_I(inode)->i_data_sem);
547
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
548 549
		retval = ext4_ext_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
550
	} else {
551 552
		retval = ext4_ind_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
553
	}
554
	if (retval > 0) {
555
		unsigned int status;
556

557 558 559 560 561 562
		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);
563 564
		}

565 566 567
		status = map->m_flags & EXT4_MAP_UNWRITTEN ?
				EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
		if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) &&
568
		    !(status & EXTENT_STATUS_WRITTEN) &&
569 570 571 572 573 574 575 576
		    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;
	}
577
	up_read((&EXT4_I(inode)->i_data_sem));
578

579
found:
580
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
581
		ret = check_block_validity(inode, map);
582 583 584 585
		if (ret != 0)
			return ret;
	}

586
	/* If it is only a block(s) look up */
587
	if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)
588 589 590 591 592 593
		return retval;

	/*
	 * Returns if the blocks have already allocated
	 *
	 * Note that if blocks have been preallocated
594
	 * ext4_ext_get_block() returns the create = 0
595 596
	 * with buffer head unmapped.
	 */
597
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
598 599 600 601 602 603 604
		/*
		 * 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;
605

606
	/*
607 608
	 * Here we clear m_flags because after allocating an new extent,
	 * it will be set again.
609
	 */
610
	map->m_flags &= ~EXT4_MAP_FLAGS;
611

612
	/*
613
	 * New blocks allocate and/or writing to unwritten extent
614
	 * will possibly result in updating i_data, so we take
615
	 * the write lock of i_data_sem, and call get_block()
616
	 * with create == 1 flag.
617
	 */
618
	down_write(&EXT4_I(inode)->i_data_sem);
619

620 621 622 623
	/*
	 * We need to check for EXT4 here because migrate
	 * could have changed the inode type in between
	 */
624
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
625
		retval = ext4_ext_map_blocks(handle, inode, map, flags);
626
	} else {
627
		retval = ext4_ind_map_blocks(handle, inode, map, flags);
628

629
		if (retval > 0 && map->m_flags & EXT4_MAP_NEW) {
630 631 632 633 634
			/*
			 * We allocated new blocks which will result in
			 * i_data's format changing.  Force the migrate
			 * to fail by clearing migrate flags
			 */
635
			ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
636
		}
637

638 639 640 641 642 643 644
		/*
		 * 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) &&
645
			(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE))
646 647
			ext4_da_update_reserve_space(inode, retval, 1);
	}
648

649
	if (retval > 0) {
650
		unsigned int status;
651

652 653 654 655 656 657
		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);
658 659
		}

660 661 662
		/*
		 * We have to zeroout blocks before inserting them into extent
		 * status tree. Otherwise someone could look them up there and
663 664 665
		 * 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.
666 667 668 669
		 */
		if (flags & EXT4_GET_BLOCKS_ZERO &&
		    map->m_flags & EXT4_MAP_MAPPED &&
		    map->m_flags & EXT4_MAP_NEW) {
670 671
			clean_bdev_aliases(inode->i_sb->s_bdev, map->m_pblk,
					   map->m_len);
672 673 674 675 676 677 678 679
			ret = ext4_issue_zeroout(inode, map->m_lblk,
						 map->m_pblk, map->m_len);
			if (ret) {
				retval = ret;
				goto out_sem;
			}
		}

680 681 682 683 684 685 686
		/*
		 * 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))
687
				goto out_sem;
688
		}
689 690 691
		status = map->m_flags & EXT4_MAP_UNWRITTEN ?
				EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
		if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) &&
692
		    !(status & EXTENT_STATUS_WRITTEN) &&
693 694 695 696 697
		    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);
698
		if (ret < 0) {
699
			retval = ret;
700 701
			goto out_sem;
		}
702 703
	}

704
out_sem:
705
	up_write((&EXT4_I(inode)->i_data_sem));
706
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
707
		ret = check_block_validity(inode, map);
708 709
		if (ret != 0)
			return ret;
J
Jan Kara 已提交
710 711 712 713 714 715 716 717 718

		/*
		 * 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 已提交
719
		    !ext4_is_quota_file(inode) &&
J
Jan Kara 已提交
720
		    ext4_should_order_data(inode)) {
721 722 723 724
			if (flags & EXT4_GET_BLOCKS_IO_SUBMIT)
				ret = ext4_jbd2_inode_add_wait(handle, inode);
			else
				ret = ext4_jbd2_inode_add_write(handle, inode);
J
Jan Kara 已提交
725 726 727
			if (ret)
				return ret;
		}
728
	}
729 730 731
	return retval;
}

J
Jan Kara 已提交
732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
/*
 * 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));
}

760 761
static int _ext4_get_block(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int flags)
762
{
763
	struct ext4_map_blocks map;
764
	int ret = 0;
765

T
Tao Ma 已提交
766 767 768
	if (ext4_has_inline_data(inode))
		return -ERANGE;

769 770 771
	map.m_lblk = iblock;
	map.m_len = bh->b_size >> inode->i_blkbits;

772 773
	ret = ext4_map_blocks(ext4_journal_current_handle(), inode, &map,
			      flags);
J
Jan Kara 已提交
774
	if (ret > 0) {
775
		map_bh(bh, inode->i_sb, map.m_pblk);
J
Jan Kara 已提交
776
		ext4_update_bh_state(bh, map.m_flags);
777
		bh->b_size = inode->i_sb->s_blocksize * map.m_len;
J
Jan Kara 已提交
778
		ret = 0;
779 780 781
	} else if (ret == 0) {
		/* hole case, need to fill in bh->b_size */
		bh->b_size = inode->i_sb->s_blocksize * map.m_len;
782 783 784 785
	}
	return ret;
}

786 787 788 789 790 791 792
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);
}

793 794 795 796 797 798 799 800 801 802 803 804 805 806
/*
 * 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);
}

807 808 809
/* Maximum number of blocks we map for direct IO at once. */
#define DIO_MAX_BLOCKS 4096

810 811 812 813 814 815 816
/*
 * 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)
817 818
{
	int dio_credits;
819 820 821
	handle_t *handle;
	int retries = 0;
	int ret;
822 823 824 825 826 827

	/* 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);
828 829 830 831 832 833 834 835 836 837 838
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;
839 840
}

841 842 843 844
/* 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)
{
845 846 847
	/* We don't expect handle for direct IO */
	WARN_ON_ONCE(ext4_journal_current_handle());

848 849 850
	if (!create)
		return _ext4_get_block(inode, iblock, bh, 0);
	return ext4_get_block_trans(inode, iblock, bh, EXT4_GET_BLOCKS_CREATE);
851 852 853
}

/*
854
 * Get block function for AIO DIO writes when we create unwritten extent if
855 856 857
 * blocks are not allocated yet. The extent will be converted to written
 * after IO is complete.
 */
858 859
static int ext4_dio_get_block_unwritten_async(struct inode *inode,
		sector_t iblock, struct buffer_head *bh_result,	int create)
860
{
861 862 863 864 865
	int ret;

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

866 867
	ret = ext4_get_block_trans(inode, iblock, bh_result,
				   EXT4_GET_BLOCKS_IO_CREATE_EXT);
868

869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885
	/*
	 * 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);
		}
886 887 888 889
		set_buffer_defer_completion(bh_result);
	}

	return ret;
890 891
}

892 893 894
/*
 * 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
895
 * after IO is complete by ext4_direct_IO_write().
896 897 898 899 900 901 902 903 904
 */
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());

905 906
	ret = ext4_get_block_trans(inode, iblock, bh_result,
				   EXT4_GET_BLOCKS_IO_CREATE_EXT);
907 908 909

	/*
	 * Mark inode as having pending DIO writes to unwritten extents.
910
	 * ext4_direct_IO_write() checks this flag and converts extents to
911 912 913 914 915 916 917 918
	 * written.
	 */
	if (!ret && buffer_unwritten(bh_result))
		ext4_set_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);

	return ret;
}

919 920 921 922 923 924 925
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);
926 927 928
	/* We don't expect handle for direct IO */
	WARN_ON_ONCE(ext4_journal_current_handle());

929 930 931 932 933
	ret = _ext4_get_block(inode, iblock, bh_result, 0);
	/*
	 * Blocks should have been preallocated! ext4_file_write_iter() checks
	 * that.
	 */
934
	WARN_ON_ONCE(!buffer_mapped(bh_result) || buffer_unwritten(bh_result));
935 936 937 938 939

	return ret;
}


940 941 942
/*
 * `handle' can be NULL if create is zero
 */
943
struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
944
				ext4_lblk_t block, int map_flags)
945
{
946 947
	struct ext4_map_blocks map;
	struct buffer_head *bh;
948
	int create = map_flags & EXT4_GET_BLOCKS_CREATE;
949
	int err;
950 951 952

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

953 954
	map.m_lblk = block;
	map.m_len = 1;
955
	err = ext4_map_blocks(handle, inode, &map, map_flags);
956

957 958
	if (err == 0)
		return create ? ERR_PTR(-ENOSPC) : NULL;
959
	if (err < 0)
960
		return ERR_PTR(err);
961 962

	bh = sb_getblk(inode->i_sb, map.m_pblk);
963 964
	if (unlikely(!bh))
		return ERR_PTR(-ENOMEM);
965 966 967
	if (map.m_flags & EXT4_MAP_NEW) {
		J_ASSERT(create != 0);
		J_ASSERT(handle != NULL);
968

969 970 971 972 973 974 975 976 977
		/*
		 * 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");
978 979 980 981 982 983
		err = ext4_journal_get_create_access(handle, bh);
		if (unlikely(err)) {
			unlock_buffer(bh);
			goto errout;
		}
		if (!buffer_uptodate(bh)) {
984 985
			memset(bh->b_data, 0, inode->i_sb->s_blocksize);
			set_buffer_uptodate(bh);
986
		}
987 988 989
		unlock_buffer(bh);
		BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
		err = ext4_handle_dirty_metadata(handle, inode, bh);
990 991 992
		if (unlikely(err))
			goto errout;
	} else
993 994
		BUFFER_TRACE(bh, "not a new buffer");
	return bh;
995 996 997
errout:
	brelse(bh);
	return ERR_PTR(err);
998 999
}

1000
struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
1001
			       ext4_lblk_t block, int map_flags)
1002
{
1003
	struct buffer_head *bh;
1004

1005
	bh = ext4_getblk(handle, inode, block, map_flags);
1006
	if (IS_ERR(bh))
1007
		return bh;
1008
	if (!bh || buffer_uptodate(bh))
1009
		return bh;
1010
	ll_rw_block(REQ_OP_READ, REQ_META | REQ_PRIO, 1, &bh);
1011 1012 1013 1014
	wait_on_buffer(bh);
	if (buffer_uptodate(bh))
		return bh;
	put_bh(bh);
1015
	return ERR_PTR(-EIO);
1016 1017
}

1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 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
/* 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;
}

1062 1063 1064 1065 1066 1067 1068
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))
1069 1070 1071 1072 1073 1074 1075
{
	struct buffer_head *bh;
	unsigned block_start, block_end;
	unsigned blocksize = head->b_size;
	int err, ret = 0;
	struct buffer_head *next;

1076 1077
	for (bh = head, block_start = 0;
	     ret == 0 && (bh != head || !block_start);
1078
	     block_start = block_end, bh = next) {
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095
		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
1096
 * close off a transaction and start a new one between the ext4_get_block()
1097
 * and the commit_write().  So doing the jbd2_journal_start at the start of
1098 1099
 * prepare_write() is the right place.
 *
1100 1101 1102 1103
 * 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.
1104
 *
1105
 * By accident, ext4 can be reentered when a transaction is open via
1106 1107 1108 1109 1110 1111
 * 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.
 *
1112
 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
1113 1114 1115 1116
 * will _not_ run commit under these circumstances because handle->h_ref
 * is elevated.  We'll still have enough credits for the tiny quotafile
 * write.
 */
1117 1118
int do_journal_get_write_access(handle_t *handle,
				struct buffer_head *bh)
1119
{
1120 1121 1122
	int dirty = buffer_dirty(bh);
	int ret;

1123 1124
	if (!buffer_mapped(bh) || buffer_freed(bh))
		return 0;
1125
	/*
C
Christoph Hellwig 已提交
1126
	 * __block_write_begin() could have dirtied some buffers. Clean
1127 1128
	 * the dirty bit as jbd2_journal_get_write_access() could complain
	 * otherwise about fs integrity issues. Setting of the dirty bit
C
Christoph Hellwig 已提交
1129
	 * by __block_write_begin() isn't a real problem here as we clear
1130 1131 1132 1133 1134
	 * the bit before releasing a page lock and thus writeback cannot
	 * ever write the buffer.
	 */
	if (dirty)
		clear_buffer_dirty(bh);
1135
	BUFFER_TRACE(bh, "get write access");
1136 1137 1138 1139
	ret = ext4_journal_get_write_access(handle, bh);
	if (!ret && dirty)
		ret = ext4_handle_dirty_metadata(handle, NULL, bh);
	return ret;
1140 1141
}

1142 1143 1144 1145
#ifdef CONFIG_EXT4_FS_ENCRYPTION
static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
				  get_block_t *get_block)
{
1146
	unsigned from = pos & (PAGE_SIZE - 1);
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
	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));
1158 1159
	BUG_ON(from > PAGE_SIZE);
	BUG_ON(to > PAGE_SIZE);
1160 1161 1162 1163 1164 1165
	BUG_ON(from > to);

	if (!page_has_buffers(page))
		create_empty_buffers(page, blocksize, 0);
	head = page_buffers(page);
	bbits = ilog2(blocksize);
1166
	block = (sector_t)page->index << (PAGE_SHIFT - bbits);
1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185

	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)) {
1186
				clean_bdev_bh_alias(bh);
1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206
				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)) {
1207
			ll_rw_block(REQ_OP_READ, 0, 1, &bh);
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
			*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)
1224
		err = fscrypt_decrypt_page(page->mapping->host, page,
1225
				PAGE_SIZE, 0, page->index);
1226 1227 1228 1229
	return err;
}
#endif

N
Nick Piggin 已提交
1230
static int ext4_write_begin(struct file *file, struct address_space *mapping,
1231 1232
			    loff_t pos, unsigned len, unsigned flags,
			    struct page **pagep, void **fsdata)
1233
{
1234
	struct inode *inode = mapping->host;
1235
	int ret, needed_blocks;
1236 1237
	handle_t *handle;
	int retries = 0;
1238
	struct page *page;
1239
	pgoff_t index;
1240
	unsigned from, to;
N
Nick Piggin 已提交
1241

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

1245
	trace_ext4_write_begin(inode, pos, len, flags);
1246 1247 1248 1249 1250
	/*
	 * 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;
1251 1252
	index = pos >> PAGE_SHIFT;
	from = pos & (PAGE_SIZE - 1);
1253
	to = from + len;
1254

1255 1256 1257 1258
	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)
1259 1260 1261
			return ret;
		if (ret == 1)
			return 0;
1262 1263
	}

1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277
	/*
	 * 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:
1278
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
1279
	if (IS_ERR(handle)) {
1280
		put_page(page);
1281
		return PTR_ERR(handle);
1282
	}
1283

1284 1285 1286 1287
	lock_page(page);
	if (page->mapping != mapping) {
		/* The page got truncated from under us */
		unlock_page(page);
1288
		put_page(page);
1289
		ext4_journal_stop(handle);
1290
		goto retry_grab;
1291
	}
1292 1293
	/* In case writeback began while the page was unlocked */
	wait_for_stable_page(page);
1294

1295 1296 1297
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	if (ext4_should_dioread_nolock(inode))
		ret = ext4_block_write_begin(page, pos, len,
1298
					     ext4_get_block_unwritten);
1299 1300 1301 1302
	else
		ret = ext4_block_write_begin(page, pos, len,
					     ext4_get_block);
#else
1303
	if (ext4_should_dioread_nolock(inode))
1304 1305
		ret = __block_write_begin(page, pos, len,
					  ext4_get_block_unwritten);
1306
	else
1307
		ret = __block_write_begin(page, pos, len, ext4_get_block);
1308
#endif
N
Nick Piggin 已提交
1309
	if (!ret && ext4_should_journal_data(inode)) {
1310 1311 1312
		ret = ext4_walk_page_buffers(handle, page_buffers(page),
					     from, to, NULL,
					     do_journal_get_write_access);
1313
	}
N
Nick Piggin 已提交
1314 1315

	if (ret) {
1316
		unlock_page(page);
1317
		/*
1318
		 * __block_write_begin may have instantiated a few blocks
1319 1320
		 * outside i_size.  Trim these off again. Don't need
		 * i_size_read because we hold i_mutex.
1321 1322 1323
		 *
		 * Add inode to orphan list in case we crash before
		 * truncate finishes
1324
		 */
1325
		if (pos + len > inode->i_size && ext4_can_truncate(inode))
1326 1327 1328 1329
			ext4_orphan_add(handle, inode);

		ext4_journal_stop(handle);
		if (pos + len > inode->i_size) {
1330
			ext4_truncate_failed_write(inode);
1331
			/*
1332
			 * If truncate failed early the inode might
1333 1334 1335 1336 1337 1338 1339
			 * 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 已提交
1340

1341 1342 1343
		if (ret == -ENOSPC &&
		    ext4_should_retry_alloc(inode->i_sb, &retries))
			goto retry_journal;
1344
		put_page(page);
1345 1346 1347
		return ret;
	}
	*pagep = page;
1348 1349 1350
	return ret;
}

N
Nick Piggin 已提交
1351 1352
/* For write_end() in data=journal mode */
static int write_end_fn(handle_t *handle, struct buffer_head *bh)
1353
{
1354
	int ret;
1355 1356 1357
	if (!buffer_mapped(bh) || buffer_freed(bh))
		return 0;
	set_buffer_uptodate(bh);
1358 1359 1360 1361
	ret = ext4_handle_dirty_metadata(handle, NULL, bh);
	clear_buffer_meta(bh);
	clear_buffer_prio(bh);
	return ret;
1362 1363
}

1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374
/*
 * 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)
1375 1376
{
	handle_t *handle = ext4_journal_current_handle();
1377
	struct inode *inode = mapping->host;
1378
	loff_t old_size = inode->i_size;
1379 1380 1381 1382
	int ret = 0, ret2;
	int i_size_changed = 0;

	trace_ext4_write_end(inode, pos, len, copied);
1383 1384 1385
	if (ext4_has_inline_data(inode)) {
		ret = ext4_write_inline_data_end(inode, pos, len,
						 copied, page);
1386 1387 1388
		if (ret < 0) {
			unlock_page(page);
			put_page(page);
1389
			goto errout;
1390
		}
1391 1392
		copied = ret;
	} else
1393 1394
		copied = block_write_end(file, mapping, pos,
					 len, copied, page, fsdata);
1395
	/*
1396
	 * it's important to update i_size while still holding page lock:
1397 1398
	 * page writeout could otherwise come in and zero beyond i_size.
	 */
1399
	i_size_changed = ext4_update_inode_size(inode, pos + copied);
1400
	unlock_page(page);
1401
	put_page(page);
1402

1403 1404
	if (old_size < pos)
		pagecache_isize_extended(inode, old_size, pos);
1405 1406 1407 1408 1409 1410 1411 1412 1413
	/*
	 * Don't mark the inode dirty under page lock. First, it unnecessarily
	 * makes the holding time of page lock longer. Second, it forces lock
	 * ordering of page lock and transaction start for journaling
	 * filesystems.
	 */
	if (i_size_changed)
		ext4_mark_inode_dirty(handle, inode);

1414
	if (pos + len > inode->i_size && ext4_can_truncate(inode))
1415 1416 1417 1418 1419
		/* 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);
1420
errout:
1421
	ret2 = ext4_journal_stop(handle);
1422 1423
	if (!ret)
		ret = ret2;
N
Nick Piggin 已提交
1424

1425
	if (pos + len > inode->i_size) {
1426
		ext4_truncate_failed_write(inode);
1427
		/*
1428
		 * If truncate failed early the inode might still be
1429 1430 1431 1432 1433 1434 1435
		 * 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 已提交
1436
	return ret ? ret : copied;
1437 1438
}

1439 1440 1441 1442 1443
/*
 * 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.
 */
1444 1445 1446
static void ext4_journalled_zero_new_buffers(handle_t *handle,
					    struct page *page,
					    unsigned from, unsigned to)
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462
{
	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);
1463
					write_end_fn(handle, bh);
1464 1465 1466 1467 1468 1469 1470 1471 1472
				}
				clear_buffer_new(bh);
			}
		}
		block_start = block_end;
		bh = bh->b_this_page;
	} while (bh != head);
}

N
Nick Piggin 已提交
1473
static int ext4_journalled_write_end(struct file *file,
1474 1475 1476
				     struct address_space *mapping,
				     loff_t pos, unsigned len, unsigned copied,
				     struct page *page, void *fsdata)
1477
{
1478
	handle_t *handle = ext4_journal_current_handle();
N
Nick Piggin 已提交
1479
	struct inode *inode = mapping->host;
1480
	loff_t old_size = inode->i_size;
1481 1482
	int ret = 0, ret2;
	int partial = 0;
N
Nick Piggin 已提交
1483
	unsigned from, to;
1484
	int size_changed = 0;
1485

1486
	trace_ext4_journalled_write_end(inode, pos, len, copied);
1487
	from = pos & (PAGE_SIZE - 1);
N
Nick Piggin 已提交
1488 1489
	to = from + len;

1490 1491
	BUG_ON(!ext4_handle_valid(handle));

1492 1493 1494 1495 1496 1497 1498 1499 1500 1501
	if (ext4_has_inline_data(inode)) {
		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)) {
1502 1503 1504 1505 1506 1507
		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);
1508
		ret = ext4_walk_page_buffers(handle, page_buffers(page), from,
1509 1510
					     from + copied, &partial,
					     write_end_fn);
1511 1512 1513
		if (!partial)
			SetPageUptodate(page);
	}
1514
	size_changed = ext4_update_inode_size(inode, pos + copied);
1515
	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
1516
	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1517
	unlock_page(page);
1518
	put_page(page);
1519

1520 1521 1522
	if (old_size < pos)
		pagecache_isize_extended(inode, old_size, pos);

1523
	if (size_changed) {
1524
		ret2 = ext4_mark_inode_dirty(handle, inode);
1525 1526 1527
		if (!ret)
			ret = ret2;
	}
N
Nick Piggin 已提交
1528

1529
	if (pos + len > inode->i_size && ext4_can_truncate(inode))
1530 1531 1532 1533 1534 1535
		/* 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);

1536
errout:
1537
	ret2 = ext4_journal_stop(handle);
1538 1539
	if (!ret)
		ret = ret2;
1540
	if (pos + len > inode->i_size) {
1541
		ext4_truncate_failed_write(inode);
1542
		/*
1543
		 * If truncate failed early the inode might still be
1544 1545 1546 1547 1548 1549
		 * 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 已提交
1550 1551

	return ret ? ret : copied;
1552
}
1553

1554
/*
1555
 * Reserve space for a single cluster
1556
 */
1557
static int ext4_da_reserve_space(struct inode *inode)
1558
{
1559
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1560
	struct ext4_inode_info *ei = EXT4_I(inode);
1561
	int ret;
1562 1563 1564 1565 1566 1567 1568 1569 1570

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

1572
	spin_lock(&ei->i_block_reservation_lock);
1573
	if (ext4_claim_free_clusters(sbi, 1, 0)) {
1574 1575
		spin_unlock(&ei->i_block_reservation_lock);
		dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1));
1576 1577
		return -ENOSPC;
	}
1578
	ei->i_reserved_data_blocks++;
1579
	trace_ext4_da_reserve_space(inode);
1580
	spin_unlock(&ei->i_block_reservation_lock);
1581

1582 1583 1584
	return 0;       /* success */
}

1585
static void ext4_da_release_space(struct inode *inode, int to_free)
1586 1587
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1588
	struct ext4_inode_info *ei = EXT4_I(inode);
1589

1590 1591 1592
	if (!to_free)
		return;		/* Nothing to release, exit */

1593
	spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1594

L
Li Zefan 已提交
1595
	trace_ext4_da_release_space(inode, to_free);
1596
	if (unlikely(to_free > ei->i_reserved_data_blocks)) {
1597
		/*
1598 1599 1600 1601
		 * 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.
1602
		 */
1603
		ext4_warning(inode->i_sb, "ext4_da_release_space: "
1604
			 "ino %lu, to_free %d with only %d reserved "
1605
			 "data blocks", inode->i_ino, to_free,
1606 1607 1608
			 ei->i_reserved_data_blocks);
		WARN_ON(1);
		to_free = ei->i_reserved_data_blocks;
1609
	}
1610
	ei->i_reserved_data_blocks -= to_free;
1611

1612
	/* update fs dirty data blocks counter */
1613
	percpu_counter_sub(&sbi->s_dirtyclusters_counter, to_free);
1614 1615

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

1617
	dquot_release_reservation_block(inode, EXT4_C2B(sbi, to_free));
1618 1619 1620
}

static void ext4_da_page_release_reservation(struct page *page,
1621 1622
					     unsigned int offset,
					     unsigned int length)
1623
{
1624
	int to_release = 0, contiguous_blks = 0;
1625 1626
	struct buffer_head *head, *bh;
	unsigned int curr_off = 0;
1627 1628
	struct inode *inode = page->mapping->host;
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1629
	unsigned int stop = offset + length;
1630
	int num_clusters;
1631
	ext4_fsblk_t lblk;
1632

1633
	BUG_ON(stop > PAGE_SIZE || stop < length);
1634

1635 1636 1637 1638 1639
	head = page_buffers(page);
	bh = head;
	do {
		unsigned int next_off = curr_off + bh->b_size;

1640 1641 1642
		if (next_off > stop)
			break;

1643 1644
		if ((offset <= curr_off) && (buffer_delay(bh))) {
			to_release++;
1645
			contiguous_blks++;
1646
			clear_buffer_delay(bh);
1647 1648
		} else if (contiguous_blks) {
			lblk = page->index <<
1649
			       (PAGE_SHIFT - inode->i_blkbits);
1650 1651 1652 1653
			lblk += (curr_off >> inode->i_blkbits) -
				contiguous_blks;
			ext4_es_remove_extent(inode, lblk, contiguous_blks);
			contiguous_blks = 0;
1654 1655 1656
		}
		curr_off = next_off;
	} while ((bh = bh->b_this_page) != head);
1657

1658
	if (contiguous_blks) {
1659
		lblk = page->index << (PAGE_SHIFT - inode->i_blkbits);
1660 1661
		lblk += (curr_off >> inode->i_blkbits) - contiguous_blks;
		ext4_es_remove_extent(inode, lblk, contiguous_blks);
1662 1663
	}

1664 1665 1666 1667
	/* 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) {
1668
		lblk = (page->index << (PAGE_SHIFT - inode->i_blkbits)) +
1669 1670
			((num_clusters - 1) << sbi->s_cluster_bits);
		if (sbi->s_cluster_ratio == 1 ||
1671
		    !ext4_find_delalloc_cluster(inode, lblk))
1672 1673 1674 1675
			ext4_da_release_space(inode, 1);

		num_clusters--;
	}
1676
}
1677

1678 1679 1680 1681
/*
 * Delayed allocation stuff
 */

J
Jan Kara 已提交
1682 1683 1684
struct mpage_da_data {
	struct inode *inode;
	struct writeback_control *wbc;
1685

J
Jan Kara 已提交
1686 1687 1688
	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 */
1689
	/*
J
Jan Kara 已提交
1690 1691 1692
	 * 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.
1693
	 */
J
Jan Kara 已提交
1694 1695
	struct ext4_map_blocks map;
	struct ext4_io_submit io_submit;	/* IO submission data */
1696
	unsigned int do_map:1;
J
Jan Kara 已提交
1697
};
1698

J
Jan Kara 已提交
1699 1700
static void mpage_release_unused_pages(struct mpage_da_data *mpd,
				       bool invalidate)
1701 1702 1703 1704 1705 1706
{
	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 已提交
1707 1708 1709 1710

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

1712 1713
	index = mpd->first_page;
	end   = mpd->next_page - 1;
J
Jan Kara 已提交
1714 1715
	if (invalidate) {
		ext4_lblk_t start, last;
1716 1717
		start = index << (PAGE_SHIFT - inode->i_blkbits);
		last = end << (PAGE_SHIFT - inode->i_blkbits);
J
Jan Kara 已提交
1718 1719
		ext4_es_remove_extent(inode, start, last - start + 1);
	}
1720

1721
	pagevec_init(&pvec, 0);
1722
	while (index <= end) {
1723
		nr_pages = pagevec_lookup_range(&pvec, mapping, &index, end);
1724 1725 1726 1727
		if (nr_pages == 0)
			break;
		for (i = 0; i < nr_pages; i++) {
			struct page *page = pvec.pages[i];
1728

1729 1730
			BUG_ON(!PageLocked(page));
			BUG_ON(PageWriteback(page));
J
Jan Kara 已提交
1731
			if (invalidate) {
1732 1733
				if (page_mapped(page))
					clear_page_dirty_for_io(page);
1734
				block_invalidatepage(page, 0, PAGE_SIZE);
J
Jan Kara 已提交
1735 1736
				ClearPageUptodate(page);
			}
1737 1738
			unlock_page(page);
		}
1739
		pagevec_release(&pvec);
1740 1741 1742
	}
}

1743 1744 1745
static void ext4_print_free_blocks(struct inode *inode)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1746
	struct super_block *sb = inode->i_sb;
1747
	struct ext4_inode_info *ei = EXT4_I(inode);
1748 1749

	ext4_msg(sb, KERN_CRIT, "Total free blocks count %lld",
1750
	       EXT4_C2B(EXT4_SB(inode->i_sb),
1751
			ext4_count_free_clusters(sb)));
1752 1753
	ext4_msg(sb, KERN_CRIT, "Free/Dirty block details");
	ext4_msg(sb, KERN_CRIT, "free_blocks=%lld",
1754
	       (long long) EXT4_C2B(EXT4_SB(sb),
1755
		percpu_counter_sum(&sbi->s_freeclusters_counter)));
1756
	ext4_msg(sb, KERN_CRIT, "dirty_blocks=%lld",
1757
	       (long long) EXT4_C2B(EXT4_SB(sb),
1758
		percpu_counter_sum(&sbi->s_dirtyclusters_counter)));
1759 1760
	ext4_msg(sb, KERN_CRIT, "Block reservation details");
	ext4_msg(sb, KERN_CRIT, "i_reserved_data_blocks=%u",
1761
		 ei->i_reserved_data_blocks);
1762 1763 1764
	return;
}

1765
static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
1766
{
1767
	return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh);
1768 1769
}

1770 1771 1772 1773 1774 1775 1776 1777 1778 1779
/*
 * 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)
{
1780
	struct extent_status es;
1781 1782
	int retval;
	sector_t invalid_block = ~((sector_t) 0xffff);
1783 1784 1785 1786 1787
#ifdef ES_AGGRESSIVE_TEST
	struct ext4_map_blocks orig_map;

	memcpy(&orig_map, map, sizeof(*map));
#endif
1788 1789 1790 1791 1792 1793 1794 1795

	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);
1796 1797 1798 1799 1800

	/* Lookup extent status tree firstly */
	if (ext4_es_lookup_extent(inode, iblock, &es)) {
		if (ext4_es_is_hole(&es)) {
			retval = 0;
1801
			down_read(&EXT4_I(inode)->i_data_sem);
1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827
			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);

1828 1829 1830
#ifdef ES_AGGRESSIVE_TEST
		ext4_map_blocks_es_recheck(NULL, inode, map, &orig_map, 0);
#endif
1831 1832 1833
		return retval;
	}

1834 1835 1836 1837
	/*
	 * Try to see if we can get the block without requesting a new
	 * file system block.
	 */
1838
	down_read(&EXT4_I(inode)->i_data_sem);
1839
	if (ext4_has_inline_data(inode))
1840
		retval = 0;
1841
	else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
1842
		retval = ext4_ext_map_blocks(NULL, inode, map, 0);
1843
	else
1844
		retval = ext4_ind_map_blocks(NULL, inode, map, 0);
1845

1846
add_delayed:
1847
	if (retval == 0) {
1848
		int ret;
1849 1850 1851 1852
		/*
		 * XXX: __block_prepare_write() unmaps passed block,
		 * is it OK?
		 */
1853 1854 1855 1856 1857
		/*
		 * 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.
		 */
1858
		if (EXT4_SB(inode->i_sb)->s_cluster_ratio == 1 ||
1859
		    !ext4_find_delalloc_cluster(inode, map->m_lblk)) {
1860
			ret = ext4_da_reserve_space(inode);
1861
			if (ret) {
1862
				/* not enough space to reserve */
1863
				retval = ret;
1864
				goto out_unlock;
1865
			}
1866 1867
		}

1868 1869 1870 1871
		ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len,
					    ~0, EXTENT_STATUS_DELAYED);
		if (ret) {
			retval = ret;
1872
			goto out_unlock;
1873
		}
1874

1875 1876 1877
		map_bh(bh, inode->i_sb, invalid_block);
		set_buffer_new(bh);
		set_buffer_delay(bh);
1878 1879
	} else if (retval > 0) {
		int ret;
1880
		unsigned int status;
1881

1882 1883 1884 1885 1886 1887
		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);
1888 1889
		}

1890 1891 1892 1893 1894 1895
		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;
1896 1897 1898 1899 1900 1901 1902 1903
	}

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

	return retval;
}

1904
/*
1905
 * This is a special get_block_t callback which is used by
1906 1907
 * ext4_da_write_begin().  It will either return mapped block or
 * reserve space for a single block.
1908 1909 1910 1911 1912 1913 1914
 *
 * 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.
1915
 */
1916 1917
int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int create)
1918
{
1919
	struct ext4_map_blocks map;
1920 1921 1922
	int ret = 0;

	BUG_ON(create == 0);
1923 1924 1925 1926
	BUG_ON(bh->b_size != inode->i_sb->s_blocksize);

	map.m_lblk = iblock;
	map.m_len = 1;
1927 1928 1929 1930 1931 1932

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

1937
	map_bh(bh, inode->i_sb, map.m_pblk);
J
Jan Kara 已提交
1938
	ext4_update_bh_state(bh, map.m_flags);
1939 1940 1941 1942 1943 1944 1945 1946 1947

	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);
1948
		set_buffer_mapped(bh);
1949 1950
	}
	return 0;
1951
}
1952

1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969
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;
1970
	struct buffer_head *page_bufs = NULL;
1971
	handle_t *handle = NULL;
1972 1973 1974
	int ret = 0, err = 0;
	int inline_data = ext4_has_inline_data(inode);
	struct buffer_head *inode_bh = NULL;
1975

1976
	ClearPageChecked(page);
1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992

	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);
	}
1993 1994 1995 1996 1997 1998
	/*
	 * 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);
1999 2000
	unlock_page(page);

2001 2002
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
				    ext4_writepage_trans_blocks(inode));
2003 2004
	if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
2005 2006
		put_page(page);
		goto out_no_pagelock;
2007
	}
2008 2009
	BUG_ON(!ext4_handle_valid(handle));

2010 2011 2012 2013 2014 2015 2016 2017 2018
	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;
	}

2019
	if (inline_data) {
2020
		BUFFER_TRACE(inode_bh, "get write access");
2021
		ret = ext4_journal_get_write_access(handle, inode_bh);
2022

2023 2024 2025 2026 2027 2028 2029 2030 2031
		err = ext4_handle_dirty_metadata(handle, inode, inode_bh);

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

		err = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL,
					     write_end_fn);
	}
2032 2033
	if (ret == 0)
		ret = err;
2034
	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
2035 2036 2037 2038
	err = ext4_journal_stop(handle);
	if (!ret)
		ret = err;

2039
	if (!ext4_has_inline_data(inode))
2040
		ext4_walk_page_buffers(NULL, page_bufs, 0, len,
2041
				       NULL, bput_one);
2042
	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
2043
out:
2044 2045
	unlock_page(page);
out_no_pagelock:
2046
	brelse(inode_bh);
2047 2048 2049
	return ret;
}

2050
/*
2051 2052 2053 2054
 * 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 已提交
2055
 * we are writing back data modified via mmap(), no one guarantees in which
2056 2057 2058 2059
 * 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.
 *
2060
 * This function can get called via...
2061
 *   - ext4_writepages after taking page lock (have journal handle)
2062
 *   - journal_submit_inode_data_buffers (no journal handle)
2063
 *   - shrink_page_list via the kswapd/direct reclaim (no journal handle)
2064
 *   - grab_page_cache when doing write_begin (have journal handle)
2065 2066 2067 2068 2069 2070 2071 2072 2073
 *
 * 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
2074
 * but other buffer_heads would be unmapped but dirty (dirty done via the
2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
 * 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.
2090
 */
2091
static int ext4_writepage(struct page *page,
2092
			  struct writeback_control *wbc)
2093
{
2094
	int ret = 0;
2095
	loff_t size;
2096
	unsigned int len;
2097
	struct buffer_head *page_bufs = NULL;
2098
	struct inode *inode = page->mapping->host;
2099
	struct ext4_io_submit io_submit;
2100
	bool keep_towrite = false;
2101

2102 2103 2104 2105 2106 2107
	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) {
		ext4_invalidatepage(page, 0, PAGE_SIZE);
		unlock_page(page);
		return -EIO;
	}

L
Lukas Czerner 已提交
2108
	trace_ext4_writepage(page);
2109
	size = i_size_read(inode);
2110 2111
	if (page->index == size >> PAGE_SHIFT)
		len = size & ~PAGE_MASK;
2112
	else
2113
		len = PAGE_SIZE;
2114

T
Theodore Ts'o 已提交
2115 2116
	page_bufs = page_buffers(page);
	/*
2117 2118 2119 2120 2121
	 * 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.
2122 2123 2124 2125 2126 2127 2128 2129 2130 2131
	 *
	 * 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 已提交
2132
	 */
2133 2134
	if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL,
				   ext4_bh_delay_or_unwritten)) {
2135
		redirty_page_for_writepage(wbc, page);
2136
		if ((current->flags & PF_MEMALLOC) ||
2137
		    (inode->i_sb->s_blocksize == PAGE_SIZE)) {
2138 2139 2140 2141 2142 2143 2144
			/*
			 * 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);
2145 2146 2147
			unlock_page(page);
			return 0;
		}
2148
		keep_towrite = true;
T
Theodore Ts'o 已提交
2149
	}
2150

2151
	if (PageChecked(page) && ext4_should_journal_data(inode))
2152 2153 2154 2155
		/*
		 * It's mmapped pagecache.  Add buffers and journal it.  There
		 * doesn't seem much point in redirtying the page here.
		 */
2156
		return __ext4_journalled_writepage(page, len);
2157

J
Jan Kara 已提交
2158 2159 2160 2161 2162 2163 2164
	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;
	}
2165
	ret = ext4_bio_write_page(&io_submit, page, len, wbc, keep_towrite);
2166
	ext4_io_submit(&io_submit);
J
Jan Kara 已提交
2167 2168
	/* Drop io_end reference we got from init */
	ext4_put_io_end_defer(io_submit.io_end);
2169 2170 2171
	return ret;
}

2172 2173 2174
static int mpage_submit_page(struct mpage_da_data *mpd, struct page *page)
{
	int len;
2175
	loff_t size;
2176 2177 2178
	int err;

	BUG_ON(page->index != mpd->first_page);
2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193
	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);
2194 2195
	if (page->index == size >> PAGE_SHIFT)
		len = size & ~PAGE_MASK;
2196
	else
2197
		len = PAGE_SIZE;
2198
	err = ext4_bio_write_page(&mpd->io_submit, page, len, mpd->wbc, false);
2199 2200 2201 2202 2203 2204 2205
	if (!err)
		mpd->wbc->nr_to_write--;
	mpd->first_page++;

	return err;
}

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

2208
/*
2209 2210
 * mballoc gives us at most this number of blocks...
 * XXX: That seems to be only a limitation of ext4_mb_normalize_request().
2211
 * The rest of mballoc seems to handle chunks up to full group size.
2212
 */
2213
#define MAX_WRITEPAGES_EXTENT_LEN 2048
2214

J
Jan Kara 已提交
2215 2216 2217 2218 2219
/*
 * 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
2220
 * @bh - buffer head we want to add to the extent
J
Jan Kara 已提交
2221
 *
2222 2223 2224 2225 2226 2227
 * 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 已提交
2228
 */
2229 2230
static bool mpage_add_bh_to_extent(struct mpage_da_data *mpd, ext4_lblk_t lblk,
				   struct buffer_head *bh)
J
Jan Kara 已提交
2231 2232 2233
{
	struct ext4_map_blocks *map = &mpd->map;

2234 2235 2236 2237 2238 2239 2240 2241
	/* 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 已提交
2242 2243 2244

	/* First block in the extent? */
	if (map->m_len == 0) {
2245 2246 2247
		/* We cannot map unless handle is started... */
		if (!mpd->do_map)
			return false;
J
Jan Kara 已提交
2248 2249
		map->m_lblk = lblk;
		map->m_len = 1;
2250 2251
		map->m_flags = bh->b_state & BH_FLAGS;
		return true;
J
Jan Kara 已提交
2252 2253
	}

2254 2255 2256 2257
	/* Don't go larger than mballoc is willing to allocate */
	if (map->m_len >= MAX_WRITEPAGES_EXTENT_LEN)
		return false;

J
Jan Kara 已提交
2258 2259
	/* Can we merge the block to our big extent? */
	if (lblk == map->m_lblk + map->m_len &&
2260
	    (bh->b_state & BH_FLAGS) == map->m_flags) {
J
Jan Kara 已提交
2261
		map->m_len++;
2262
		return true;
J
Jan Kara 已提交
2263
	}
2264
	return false;
J
Jan Kara 已提交
2265 2266
}

2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286
/*
 * 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 已提交
2287 2288
{
	struct inode *inode = mpd->inode;
2289
	int err;
F
Fabian Frederick 已提交
2290
	ext4_lblk_t blocks = (i_size_read(inode) + i_blocksize(inode) - 1)
J
Jan Kara 已提交
2291 2292 2293 2294 2295
							>> inode->i_blkbits;

	do {
		BUG_ON(buffer_locked(bh));

2296
		if (lblk >= blocks || !mpage_add_bh_to_extent(mpd, lblk, bh)) {
J
Jan Kara 已提交
2297 2298
			/* Found extent to map? */
			if (mpd->map.m_len)
2299
				return 0;
2300 2301 2302
			/* Buffer needs mapping and handle is not started? */
			if (!mpd->do_map)
				return 0;
2303
			/* Everything mapped so far and we hit EOF */
2304
			break;
J
Jan Kara 已提交
2305 2306
		}
	} while (lblk++, (bh = bh->b_this_page) != head);
2307 2308 2309 2310 2311 2312 2313
	/* 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 已提交
2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324
}

/*
 * 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,
2325
 * and mark buffers as uninit when we perform writes to unwritten extents
J
Jan Kara 已提交
2326 2327 2328 2329 2330 2331 2332 2333 2334 2335
 * 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;
2336
	int bpp_bits = PAGE_SHIFT - inode->i_blkbits;
J
Jan Kara 已提交
2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348
	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;

	pagevec_init(&pvec, 0);
	while (start <= end) {
2349
		nr_pages = pagevec_lookup_range(&pvec, inode->i_mapping,
2350
						&start, end);
J
Jan Kara 已提交
2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366
		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;
2367 2368 2369 2370 2371 2372 2373 2374 2375
					/*
					 * 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 已提交
2376
					pagevec_release(&pvec);
2377 2378 2379
					if (err > 0)
						err = 0;
					return err;
J
Jan Kara 已提交
2380 2381 2382 2383 2384 2385
				}
				if (buffer_delay(bh)) {
					clear_buffer_delay(bh);
					bh->b_blocknr = pblock++;
				}
				clear_buffer_unwritten(bh);
2386
			} while (lblk++, (bh = bh->b_this_page) != head);
J
Jan Kara 已提交
2387 2388 2389 2390 2391 2392

			/*
			 * FIXME: This is going to break if dioread_nolock
			 * supports blocksize < pagesize as we will try to
			 * convert potentially unmapped parts of inode.
			 */
2393
			mpd->io_submit.io_end->size += PAGE_SIZE;
J
Jan Kara 已提交
2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413
			/* 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;
2414
	int err, dioread_nolock;
J
Jan Kara 已提交
2415 2416 2417 2418

	trace_ext4_da_write_pages_extent(inode, map);
	/*
	 * Call ext4_map_blocks() to allocate any delayed allocation blocks, or
2419
	 * to convert an unwritten extent to be initialized (in the case
J
Jan Kara 已提交
2420 2421 2422 2423 2424 2425 2426
	 * 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.
	 *
2427 2428 2429 2430
	 * 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 已提交
2431 2432
	 */
	get_blocks_flags = EXT4_GET_BLOCKS_CREATE |
2433 2434
			   EXT4_GET_BLOCKS_METADATA_NOFAIL |
			   EXT4_GET_BLOCKS_IO_SUBMIT;
2435 2436
	dioread_nolock = ext4_should_dioread_nolock(inode);
	if (dioread_nolock)
J
Jan Kara 已提交
2437 2438 2439 2440 2441 2442 2443
		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;
2444
	if (dioread_nolock && (map->m_flags & EXT4_MAP_UNWRITTEN)) {
2445 2446 2447 2448 2449
		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 已提交
2450
		ext4_set_io_unwritten_flag(inode, mpd->io_submit.io_end);
2451
	}
J
Jan Kara 已提交
2452 2453 2454

	BUG_ON(map->m_len == 0);
	if (map->m_flags & EXT4_MAP_NEW) {
2455 2456
		clean_bdev_aliases(inode->i_sb->s_bdev, map->m_pblk,
				   map->m_len);
J
Jan Kara 已提交
2457 2458 2459 2460 2461 2462 2463 2464 2465 2466
	}
	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
2467 2468 2469
 * @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 已提交
2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481
 *
 * 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,
2482 2483
				       struct mpage_da_data *mpd,
				       bool *give_up_on_write)
J
Jan Kara 已提交
2484 2485 2486 2487 2488
{
	struct inode *inode = mpd->inode;
	struct ext4_map_blocks *map = &mpd->map;
	int err;
	loff_t disksize;
2489
	int progress = 0;
J
Jan Kara 已提交
2490 2491 2492

	mpd->io_submit.io_end->offset =
				((loff_t)map->m_lblk) << inode->i_blkbits;
2493
	do {
J
Jan Kara 已提交
2494 2495 2496 2497
		err = mpage_map_one_extent(handle, mpd);
		if (err < 0) {
			struct super_block *sb = inode->i_sb;

2498 2499
			if (ext4_forced_shutdown(EXT4_SB(sb)) ||
			    EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED)
2500
				goto invalidate_dirty_pages;
J
Jan Kara 已提交
2501
			/*
2502 2503 2504
			 * 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 已提交
2505
			 */
2506
			if ((err == -ENOMEM) ||
2507 2508 2509
			    (err == -ENOSPC && ext4_count_free_clusters(sb))) {
				if (progress)
					goto update_disksize;
2510
				return err;
2511
			}
2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525
			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 已提交
2526 2527
			return err;
		}
2528
		progress = 1;
J
Jan Kara 已提交
2529 2530 2531 2532 2533 2534
		/*
		 * Update buffer state, submit mapped pages, and get us new
		 * extent to map
		 */
		err = mpage_map_and_submit_buffers(mpd);
		if (err < 0)
2535
			goto update_disksize;
2536
	} while (map->m_len);
J
Jan Kara 已提交
2537

2538
update_disksize:
2539 2540 2541 2542
	/*
	 * Update on-disk size after IO is submitted.  Races with
	 * truncate are avoided by checking i_size under i_data_sem.
	 */
2543
	disksize = ((loff_t)mpd->first_page) << PAGE_SHIFT;
J
Jan Kara 已提交
2544 2545
	if (disksize > EXT4_I(inode)->i_disksize) {
		int err2;
2546 2547 2548 2549 2550 2551 2552 2553 2554
		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);
2555
		err2 = ext4_mark_inode_dirty(handle, inode);
J
Jan Kara 已提交
2556 2557 2558 2559 2560 2561 2562 2563 2564 2565
		if (err2)
			ext4_error(inode->i_sb,
				   "Failed to mark inode %lu dirty",
				   inode->i_ino);
		if (!err)
			err = err2;
	}
	return err;
}

2566 2567
/*
 * Calculate the total number of credits to reserve for one writepages
2568
 * iteration. This is called from ext4_writepages(). We map an extent of
2569
 * up to MAX_WRITEPAGES_EXTENT_LEN blocks and then we go on and finish mapping
2570 2571 2572
 * the last partial page. So in total we can map MAX_WRITEPAGES_EXTENT_LEN +
 * bpp - 1 blocks in bpp different extents.
 */
2573 2574
static int ext4_da_writepages_trans_blocks(struct inode *inode)
{
2575
	int bpp = ext4_journal_blocks_per_page(inode);
2576

2577 2578
	return ext4_meta_trans_blocks(inode,
				MAX_WRITEPAGES_EXTENT_LEN + bpp - 1, bpp);
2579
}
2580

2581
/*
J
Jan Kara 已提交
2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597
 * 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.
2598
 */
J
Jan Kara 已提交
2599
static int mpage_prepare_extent_to_map(struct mpage_da_data *mpd)
2600
{
J
Jan Kara 已提交
2601 2602 2603
	struct address_space *mapping = mpd->inode->i_mapping;
	struct pagevec pvec;
	unsigned int nr_pages;
2604
	long left = mpd->wbc->nr_to_write;
J
Jan Kara 已提交
2605 2606 2607 2608 2609 2610 2611
	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;
2612

J
Jan Kara 已提交
2613
	if (mpd->wbc->sync_mode == WB_SYNC_ALL || mpd->wbc->tagged_writepages)
2614 2615 2616 2617
		tag = PAGECACHE_TAG_TOWRITE;
	else
		tag = PAGECACHE_TAG_DIRTY;

J
Jan Kara 已提交
2618 2619 2620
	pagevec_init(&pvec, 0);
	mpd->map.m_len = 0;
	mpd->next_page = index;
2621
	while (index <= end) {
2622
		nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
2623 2624
			      min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
		if (nr_pages == 0)
J
Jan Kara 已提交
2625
			goto out;
2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636

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

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

2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650
			/*
			 * 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 已提交
2651 2652 2653
			/* If we can't merge this page, we are done. */
			if (mpd->map.m_len > 0 && mpd->next_page != page->index)
				goto out;
2654

2655 2656
			lock_page(page);
			/*
J
Jan Kara 已提交
2657 2658 2659 2660 2661
			 * 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
2662
			 */
2663 2664
			if (!PageDirty(page) ||
			    (PageWriteback(page) &&
J
Jan Kara 已提交
2665
			     (mpd->wbc->sync_mode == WB_SYNC_NONE)) ||
2666
			    unlikely(page->mapping != mapping)) {
2667 2668 2669 2670
				unlock_page(page);
				continue;
			}

2671
			wait_on_page_writeback(page);
2672 2673
			BUG_ON(PageWriteback(page));

J
Jan Kara 已提交
2674
			if (mpd->map.m_len == 0)
2675 2676
				mpd->first_page = page->index;
			mpd->next_page = page->index + 1;
2677
			/* Add all dirty buffers to mpd */
J
Jan Kara 已提交
2678
			lblk = ((ext4_lblk_t)page->index) <<
2679
				(PAGE_SHIFT - blkbits);
2680
			head = page_buffers(page);
2681 2682
			err = mpage_process_page_bufs(mpd, head, head, lblk);
			if (err <= 0)
J
Jan Kara 已提交
2683
				goto out;
2684
			err = 0;
2685
			left--;
2686 2687 2688 2689
		}
		pagevec_release(&pvec);
		cond_resched();
	}
2690
	return 0;
2691 2692
out:
	pagevec_release(&pvec);
J
Jan Kara 已提交
2693
	return err;
2694 2695
}

2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706
static int __writepage(struct page *page, struct writeback_control *wbc,
		       void *data)
{
	struct address_space *mapping = data;
	int ret = ext4_writepage(page, wbc);
	mapping_set_error(mapping, ret);
	return ret;
}

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
	if (dax_mapping(mapping)) {
		ret = dax_writeback_mapping_range(mapping, inode->i_sb->s_bdev,
						  wbc);
		goto out_writepages;
	}
2732

2733 2734 2735 2736 2737
	/*
	 * 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
	 */
2738
	if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2739
		goto out_writepages;
2740

2741 2742 2743 2744 2745 2746
	if (ext4_should_journal_data(inode)) {
		struct blk_plug plug;

		blk_start_plug(&plug);
		ret = write_cache_pages(mapping, wbc, __writepage, mapping);
		blk_finish_plug(&plug);
2747
		goto out_writepages;
2748 2749
	}

2750 2751 2752 2753
	/*
	 * 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
2754
	 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2755
	 * the latter could be true if the filesystem is mounted
2756
	 * read-only, and in that case, ext4_writepages should
2757 2758 2759
	 * *never* be called, so if that ever happens, we would want
	 * the stack trace.
	 */
2760 2761
	if (unlikely(ext4_forced_shutdown(EXT4_SB(mapping->host->i_sb)) ||
		     sbi->s_mount_flags & EXT4_MF_FS_ABORTED)) {
2762 2763 2764
		ret = -EROFS;
		goto out_writepages;
	}
2765

2766 2767
	if (ext4_should_dioread_nolock(inode)) {
		/*
2768
		 * We may need to convert up to one extent per block in
2769 2770
		 * the page and we may dirty the inode.
		 */
2771
		rsv_blocks = 1 + (PAGE_SIZE >> inode->i_blkbits);
2772 2773
	}

J
Jan Kara 已提交
2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791
	/*
	 * 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);
	}

2792 2793
	if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
		range_whole = 1;
2794

2795
	if (wbc->range_cyclic) {
J
Jan Kara 已提交
2796 2797
		writeback_index = mapping->writeback_index;
		if (writeback_index)
2798
			cycled = 0;
J
Jan Kara 已提交
2799 2800
		mpd.first_page = writeback_index;
		mpd.last_page = -1;
2801
	} else {
2802 2803
		mpd.first_page = wbc->range_start >> PAGE_SHIFT;
		mpd.last_page = wbc->range_end >> PAGE_SHIFT;
2804
	}
2805

J
Jan Kara 已提交
2806 2807 2808
	mpd.inode = inode;
	mpd.wbc = wbc;
	ext4_io_submit_init(&mpd.io_submit, wbc);
2809
retry:
2810
	if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
J
Jan Kara 已提交
2811 2812
		tag_pages_for_writeback(mapping, mpd.first_page, mpd.last_page);
	done = false;
S
Shaohua Li 已提交
2813
	blk_start_plug(&plug);
2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836

	/*
	 * 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 已提交
2837 2838 2839 2840 2841 2842 2843
	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;
		}
2844 2845

		/*
J
Jan Kara 已提交
2846 2847 2848 2849 2850
		 * 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.
2851 2852
		 */
		BUG_ON(ext4_should_journal_data(inode));
2853
		needed_blocks = ext4_da_writepages_trans_blocks(inode);
2854

J
Jan Kara 已提交
2855
		/* start a new transaction */
2856 2857
		handle = ext4_journal_start_with_reserve(inode,
				EXT4_HT_WRITE_PAGE, needed_blocks, rsv_blocks);
2858 2859
		if (IS_ERR(handle)) {
			ret = PTR_ERR(handle);
2860
			ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
2861
			       "%ld pages, ino %lu; err %d", __func__,
2862
				wbc->nr_to_write, inode->i_ino, ret);
J
Jan Kara 已提交
2863 2864
			/* Release allocated io_end */
			ext4_put_io_end(mpd.io_submit.io_end);
2865
			mpd.io_submit.io_end = NULL;
J
Jan Kara 已提交
2866
			break;
2867
		}
2868
		mpd.do_map = 1;
2869

J
Jan Kara 已提交
2870 2871 2872 2873
		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)
2874 2875
				ret = mpage_map_and_submit_extent(handle, &mpd,
					&give_up_on_write);
J
Jan Kara 已提交
2876 2877 2878 2879 2880 2881 2882 2883 2884
			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;
			}
2885
		}
2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898
		/*
		 * 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;
2899
			mpd.do_map = 0;
2900
		}
J
Jan Kara 已提交
2901 2902 2903
		/* Submit prepared bio */
		ext4_io_submit(&mpd.io_submit);
		/* Unlock pages we didn't use */
2904
		mpage_release_unused_pages(&mpd, give_up_on_write);
2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916
		/*
		 * 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);
2917
		mpd.io_submit.io_end = NULL;
J
Jan Kara 已提交
2918 2919 2920 2921

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

	/* Update index */
	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
		/*
J
Jan Kara 已提交
2945
		 * Set the writeback_index so that range_cyclic
2946 2947
		 * mode will write it back later
		 */
J
Jan Kara 已提交
2948
		mapping->writeback_index = mpd.first_page;
2949

2950
out_writepages:
2951 2952
	trace_ext4_writepages_result(inode, wbc, ret,
				     nr_to_write - wbc->nr_to_write);
2953
	percpu_up_read(&sbi->s_journal_flag_rwsem);
2954
	return ret;
2955 2956
}

2957 2958
static int ext4_nonda_switch(struct super_block *sb)
{
2959
	s64 free_clusters, dirty_clusters;
2960 2961 2962 2963 2964
	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
2965
	 * counters can get slightly wrong with percpu_counter_batch getting
2966 2967 2968 2969
	 * 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.
	 */
2970 2971 2972 2973
	free_clusters =
		percpu_counter_read_positive(&sbi->s_freeclusters_counter);
	dirty_clusters =
		percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);
2974 2975 2976
	/*
	 * Start pushing delalloc when 1/2 of free blocks are dirty.
	 */
2977
	if (dirty_clusters && (free_clusters < 2 * dirty_clusters))
2978
		try_to_writeback_inodes_sb(sb, WB_REASON_FS_FREE_SPACE);
2979

2980 2981
	if (2 * free_clusters < 3 * dirty_clusters ||
	    free_clusters < (dirty_clusters + EXT4_FREECLUSTERS_WATERMARK)) {
2982
		/*
2983 2984
		 * free block count is less than 150% of dirty blocks
		 * or free blocks is less than watermark
2985 2986 2987 2988 2989 2990
		 */
		return 1;
	}
	return 0;
}

2991 2992 2993
/* 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)
{
2994
	if (likely(ext4_has_feature_large_file(inode->i_sb)))
2995 2996 2997 2998 2999 3000 3001 3002 3003
		return 1;

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

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

3004
static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
3005 3006
			       loff_t pos, unsigned len, unsigned flags,
			       struct page **pagep, void **fsdata)
3007
{
3008
	int ret, retries = 0;
3009 3010 3011 3012 3013
	struct page *page;
	pgoff_t index;
	struct inode *inode = mapping->host;
	handle_t *handle;

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

3017
	index = pos >> PAGE_SHIFT;
3018

3019 3020
	if (ext4_nonda_switch(inode->i_sb) ||
	    S_ISLNK(inode->i_mode)) {
3021 3022 3023 3024 3025
		*fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
		return ext4_write_begin(file, mapping, pos,
					len, flags, pagep, fsdata);
	}
	*fsdata = (void *)0;
3026
	trace_ext4_da_write_begin(inode, pos, len, flags);
3027 3028 3029 3030 3031 3032

	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)
3033 3034 3035
			return ret;
		if (ret == 1)
			return 0;
3036 3037
	}

3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050
	/*
	 * 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);

3051 3052 3053 3054 3055 3056
	/*
	 * 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.
	 */
3057
retry_journal:
3058 3059
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
				ext4_da_write_credits(inode, pos, len));
3060
	if (IS_ERR(handle)) {
3061
		put_page(page);
3062
		return PTR_ERR(handle);
3063 3064
	}

3065 3066 3067 3068
	lock_page(page);
	if (page->mapping != mapping) {
		/* The page got truncated from under us */
		unlock_page(page);
3069
		put_page(page);
3070
		ext4_journal_stop(handle);
3071
		goto retry_grab;
3072
	}
3073
	/* In case writeback began while the page was unlocked */
3074
	wait_for_stable_page(page);
3075

3076 3077 3078 3079
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	ret = ext4_block_write_begin(page, pos, len,
				     ext4_da_get_block_prep);
#else
3080
	ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep);
3081
#endif
3082 3083 3084
	if (ret < 0) {
		unlock_page(page);
		ext4_journal_stop(handle);
3085 3086 3087 3088 3089 3090
		/*
		 * 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)
3091
			ext4_truncate_failed_write(inode);
3092 3093 3094 3095 3096

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

3097
		put_page(page);
3098
		return ret;
3099 3100
	}

3101
	*pagep = page;
3102 3103 3104
	return ret;
}

3105 3106 3107 3108 3109
/*
 * 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,
3110
					    unsigned long offset)
3111 3112 3113 3114 3115 3116 3117 3118 3119
{
	struct buffer_head *bh;
	struct inode *inode = page->mapping->host;
	unsigned int idx;
	int i;

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

3120
	for (i = 0; i < idx; i++)
3121 3122
		bh = bh->b_this_page;

3123
	if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
3124 3125 3126 3127
		return 0;
	return 1;
}

3128
static int ext4_da_write_end(struct file *file,
3129 3130 3131
			     struct address_space *mapping,
			     loff_t pos, unsigned len, unsigned copied,
			     struct page *page, void *fsdata)
3132 3133 3134 3135 3136
{
	struct inode *inode = mapping->host;
	int ret = 0, ret2;
	handle_t *handle = ext4_journal_current_handle();
	loff_t new_i_size;
3137
	unsigned long start, end;
3138 3139
	int write_mode = (int)(unsigned long)fsdata;

3140 3141 3142
	if (write_mode == FALL_BACK_TO_NONDELALLOC)
		return ext4_write_end(file, mapping, pos,
				      len, copied, page, fsdata);
3143

3144
	trace_ext4_da_write_end(inode, pos, len, copied);
3145
	start = pos & (PAGE_SIZE - 1);
3146
	end = start + copied - 1;
3147 3148 3149 3150 3151 3152 3153

	/*
	 * 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;
3154
	if (copied && new_i_size > EXT4_I(inode)->i_disksize) {
3155 3156
		if (ext4_has_inline_data(inode) ||
		    ext4_da_should_update_i_disksize(page, end)) {
3157
			ext4_update_i_disksize(inode, new_i_size);
3158 3159 3160 3161 3162
			/* 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);
3163
		}
3164
	}
3165 3166 3167 3168 3169 3170 3171 3172

	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,
3173
							page, fsdata);
3174

3175 3176 3177 3178 3179 3180 3181 3182 3183 3184
	copied = ret2;
	if (ret2 < 0)
		ret = ret2;
	ret2 = ext4_journal_stop(handle);
	if (!ret)
		ret = ret2;

	return ret ? ret : copied;
}

3185 3186
static void ext4_da_invalidatepage(struct page *page, unsigned int offset,
				   unsigned int length)
3187 3188 3189 3190 3191 3192 3193 3194
{
	/*
	 * Drop reserved blocks
	 */
	BUG_ON(!PageLocked(page));
	if (!page_has_buffers(page))
		goto out;

3195
	ext4_da_page_release_reservation(page, offset, length);
3196 3197

out:
3198
	ext4_invalidatepage(page, offset, length);
3199 3200 3201 3202

	return;
}

3203 3204 3205 3206 3207
/*
 * Force all delayed allocation blocks to be allocated for a given inode.
 */
int ext4_alloc_da_blocks(struct inode *inode)
{
3208 3209
	trace_ext4_alloc_da_blocks(inode);

3210
	if (!EXT4_I(inode)->i_reserved_data_blocks)
3211 3212 3213 3214 3215 3216 3217 3218
		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:
3219
	 *
3220
	 * ext4_writepages() ->
3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231
	 *    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
3232
	 * the pages by calling redirty_page_for_writepage() but that
3233 3234
	 * 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 已提交
3235
	 * simplifying them because we wouldn't actually intend to
3236 3237 3238
	 * 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.
3239
	 *
3240 3241 3242 3243 3244 3245
	 * 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);
}
3246

3247 3248 3249 3250 3251
/*
 * 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
3252
 * journal.  If somebody makes a swapfile on an ext4 data-journaling
3253 3254 3255 3256 3257 3258 3259 3260
 * 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.
 */
3261
static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
3262 3263 3264 3265 3266
{
	struct inode *inode = mapping->host;
	journal_t *journal;
	int err;

T
Tao Ma 已提交
3267 3268 3269 3270 3271 3272
	/*
	 * We can get here for an inline file via the FIBMAP ioctl
	 */
	if (ext4_has_inline_data(inode))
		return 0;

3273 3274 3275 3276 3277 3278 3279 3280 3281 3282
	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);
	}

3283 3284
	if (EXT4_JOURNAL(inode) &&
	    ext4_test_inode_state(inode, EXT4_STATE_JDATA)) {
3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295
		/*
		 * 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.)
		 *
3296
		 * NB. EXT4_STATE_JDATA is not set on files other than
3297 3298 3299 3300 3301 3302
		 * 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.
		 */

3303
		ext4_clear_inode_state(inode, EXT4_STATE_JDATA);
3304
		journal = EXT4_JOURNAL(inode);
3305 3306 3307
		jbd2_journal_lock_updates(journal);
		err = jbd2_journal_flush(journal);
		jbd2_journal_unlock_updates(journal);
3308 3309 3310 3311 3312

		if (err)
			return 0;
	}

3313
	return generic_block_bmap(mapping, block, ext4_get_block);
3314 3315
}

3316
static int ext4_readpage(struct file *file, struct page *page)
3317
{
T
Tao Ma 已提交
3318 3319 3320
	int ret = -EAGAIN;
	struct inode *inode = page->mapping->host;

3321
	trace_ext4_readpage(page);
T
Tao Ma 已提交
3322 3323 3324 3325 3326

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

	if (ret == -EAGAIN)
3327
		return ext4_mpage_readpages(page->mapping, NULL, page, 1);
T
Tao Ma 已提交
3328 3329

	return ret;
3330 3331 3332
}

static int
3333
ext4_readpages(struct file *file, struct address_space *mapping,
3334 3335
		struct list_head *pages, unsigned nr_pages)
{
T
Tao Ma 已提交
3336 3337 3338 3339 3340 3341
	struct inode *inode = mapping->host;

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

3342
	return ext4_mpage_readpages(mapping, pages, NULL, nr_pages);
3343 3344
}

3345 3346
static void ext4_invalidatepage(struct page *page, unsigned int offset,
				unsigned int length)
3347
{
3348
	trace_ext4_invalidatepage(page, offset, length);
3349

3350 3351 3352
	/* No journalling happens on data buffers when this function is used */
	WARN_ON(page_has_buffers(page) && buffer_jbd(page_buffers(page)));

3353
	block_invalidatepage(page, offset, length);
3354 3355
}

3356
static int __ext4_journalled_invalidatepage(struct page *page,
3357 3358
					    unsigned int offset,
					    unsigned int length)
3359 3360 3361
{
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);

3362
	trace_ext4_journalled_invalidatepage(page, offset, length);
3363

3364 3365 3366
	/*
	 * If it's a full truncate we just forget about the pending dirtying
	 */
3367
	if (offset == 0 && length == PAGE_SIZE)
3368 3369
		ClearPageChecked(page);

3370
	return jbd2_journal_invalidatepage(journal, page, offset, length);
3371 3372 3373 3374
}

/* Wrapper for aops... */
static void ext4_journalled_invalidatepage(struct page *page,
3375 3376
					   unsigned int offset,
					   unsigned int length)
3377
{
3378
	WARN_ON(__ext4_journalled_invalidatepage(page, offset, length) < 0);
3379 3380
}

3381
static int ext4_releasepage(struct page *page, gfp_t wait)
3382
{
3383
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);
3384

3385 3386
	trace_ext4_releasepage(page);

3387 3388
	/* Page has dirty journalled data -> cannot release */
	if (PageChecked(page))
3389
		return 0;
3390 3391 3392 3393
	if (journal)
		return jbd2_journal_try_to_free_buffers(journal, page, wait);
	else
		return try_to_free_buffers(page);
3394 3395
}

3396
#ifdef CONFIG_FS_DAX
3397 3398 3399
static int ext4_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
			    unsigned flags, struct iomap *iomap)
{
3400
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412
	unsigned int blkbits = inode->i_blkbits;
	unsigned long first_block = offset >> blkbits;
	unsigned long last_block = (offset + length - 1) >> blkbits;
	struct ext4_map_blocks map;
	int ret;

	if (WARN_ON_ONCE(ext4_has_inline_data(inode)))
		return -ERANGE;

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

J
Jan Kara 已提交
3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446
	if (!(flags & IOMAP_WRITE)) {
		ret = ext4_map_blocks(NULL, inode, &map, 0);
	} else {
		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;
		}

		/*
3447
		 * If we added blocks beyond i_size, we need to make sure they
J
Jan Kara 已提交
3448
		 * will get truncated if we crash before updating i_size in
3449 3450 3451 3452 3453
		 * 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 已提交
3454
		 */
3455 3456
		if (!(flags & IOMAP_FAULT) && first_block + map.m_len >
		    (i_size_read(inode) + (1 << blkbits) - 1) >> blkbits) {
J
Jan Kara 已提交
3457 3458 3459 3460 3461 3462 3463 3464 3465 3466
			int err;

			err = ext4_orphan_add(handle, inode);
			if (err < 0) {
				ext4_journal_stop(handle);
				return err;
			}
		}
		ext4_journal_stop(handle);
	}
3467 3468

	iomap->flags = 0;
3469 3470
	iomap->bdev = inode->i_sb->s_bdev;
	iomap->dax_dev = sbi->s_daxdev;
3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494
	iomap->offset = first_block << blkbits;

	if (ret == 0) {
		iomap->type = IOMAP_HOLE;
		iomap->blkno = IOMAP_NULL_BLOCK;
		iomap->length = (u64)map.m_len << blkbits;
	} 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;
		}
		iomap->blkno = (sector_t)map.m_pblk << (blkbits - 9);
		iomap->length = (u64)map.m_len << blkbits;
	}

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

J
Jan Kara 已提交
3495 3496 3497 3498 3499 3500 3501 3502
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;

3503
	if (!(flags & IOMAP_WRITE) || (flags & IOMAP_FAULT))
J
Jan Kara 已提交
3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546
		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;
}

3547
const struct iomap_ops ext4_iomap_ops = {
3548
	.iomap_begin		= ext4_iomap_begin,
J
Jan Kara 已提交
3549
	.iomap_end		= ext4_iomap_end,
3550 3551
};

3552
#endif
M
Matthew Wilcox 已提交
3553

3554
static int ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
3555
			    ssize_t size, void *private)
3556
{
3557
        ext4_io_end_t *io_end = private;
3558

J
Jan Kara 已提交
3559
	/* if not async direct IO just return */
3560
	if (!io_end)
3561
		return 0;
3562

3563
	ext_debug("ext4_end_io_dio(): io_end 0x%p "
3564
		  "for inode %lu, iocb 0x%p, offset %llu, size %zd\n",
3565
		  io_end, io_end->inode->i_ino, iocb, offset, size);
3566

3567 3568 3569 3570 3571 3572 3573 3574
	/*
	 * 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;
	}
3575 3576
	io_end->offset = offset;
	io_end->size = size;
3577
	ext4_put_io_end(io_end);
3578 3579

	return 0;
3580
}
3581

3582
/*
J
Jan Kara 已提交
3583 3584 3585
 * Handling of direct IO writes.
 *
 * For ext4 extent files, ext4 will do direct-io write even to holes,
3586 3587 3588
 * preallocated extents, and those write extend the file, no need to
 * fall back to buffered IO.
 *
3589
 * For holes, we fallocate those blocks, mark them as unwritten
3590
 * If those blocks were preallocated, we mark sure they are split, but
3591
 * still keep the range to write as unwritten.
3592
 *
3593
 * The unwritten extents will be converted to written when DIO is completed.
3594
 * For async direct IO, since the IO may still pending when return, we
L
Lucas De Marchi 已提交
3595
 * set up an end_io call back function, which will do the conversion
3596
 * when async direct IO completed.
3597 3598 3599 3600 3601 3602
 *
 * 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.
 *
 */
3603
static ssize_t ext4_direct_IO_write(struct kiocb *iocb, struct iov_iter *iter)
3604 3605 3606
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
J
Jan Kara 已提交
3607
	struct ext4_inode_info *ei = EXT4_I(inode);
3608
	ssize_t ret;
3609
	loff_t offset = iocb->ki_pos;
3610
	size_t count = iov_iter_count(iter);
3611 3612 3613
	int overwrite = 0;
	get_block_t *get_block_func = NULL;
	int dio_flags = 0;
3614
	loff_t final_size = offset + count;
J
Jan Kara 已提交
3615 3616
	int orphan = 0;
	handle_t *handle;
3617

J
Jan Kara 已提交
3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633
	if (final_size > inode->i_size) {
		/* 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;
		ei->i_disksize = inode->i_size;
		ext4_journal_stop(handle);
	}
3634

3635
	BUG_ON(iocb->private == NULL);
3636

3637 3638 3639 3640 3641
	/*
	 * 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 已提交
3642
	inode_dio_begin(inode);
3643

3644 3645
	/* If we do a overwrite dio, i_mutex locking can be released */
	overwrite = *((int *)iocb->private);
3646

3647
	if (overwrite)
A
Al Viro 已提交
3648
		inode_unlock(inode);
3649

3650
	/*
J
Jan Kara 已提交
3651
	 * For extent mapped files we could direct write to holes and fallocate.
3652
	 *
3653 3654 3655
	 * 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.
3656
	 *
3657 3658
	 * As to previously fallocated extents, ext4 get_block will just simply
	 * mark the buffer mapped but still keep the extents unwritten.
3659
	 *
3660 3661 3662 3663
	 * 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.
3664 3665 3666 3667 3668 3669 3670
	 *
	 * 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;
3671
	if (overwrite)
3672
		get_block_func = ext4_dio_get_block_overwrite;
3673
	else if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) ||
F
Fabian Frederick 已提交
3674
		   round_down(offset, i_blocksize(inode)) >= inode->i_size) {
J
Jan Kara 已提交
3675 3676 3677
		get_block_func = ext4_dio_get_block;
		dio_flags = DIO_LOCKING | DIO_SKIP_HOLES;
	} else if (is_sync_kiocb(iocb)) {
3678 3679
		get_block_func = ext4_dio_get_block_unwritten_sync;
		dio_flags = DIO_LOCKING;
3680
	} else {
3681
		get_block_func = ext4_dio_get_block_unwritten_async;
3682 3683
		dio_flags = DIO_LOCKING;
	}
3684 3685 3686
	ret = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
				   get_block_func, ext4_end_io_dio, NULL,
				   dio_flags);
3687

J
Jan Kara 已提交
3688
	if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
3689 3690 3691 3692 3693 3694
						EXT4_STATE_DIO_UNWRITTEN)) {
		int err;
		/*
		 * for non AIO case, since the IO is already
		 * completed, we could do the conversion right here
		 */
3695
		err = ext4_convert_unwritten_extents(NULL, inode,
3696 3697 3698 3699 3700
						     offset, ret);
		if (err < 0)
			ret = err;
		ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
	}
3701

J
Jan Kara 已提交
3702
	inode_dio_end(inode);
3703
	/* take i_mutex locking again if we do a ovewrite dio */
3704
	if (overwrite)
A
Al Viro 已提交
3705
		inode_lock(inode);
3706

J
Jan Kara 已提交
3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750
	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)) {
			/* This is really bad luck. We've written the data
			 * but cannot extend i_size. Bail out and pretend
			 * the write failed... */
			ret = PTR_ERR(handle);
			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;
			if (end > inode->i_size) {
				ei->i_disksize = end;
				i_size_write(inode, end);
				/*
				 * 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;
}

3751
static ssize_t ext4_direct_IO_read(struct kiocb *iocb, struct iov_iter *iter)
J
Jan Kara 已提交
3752
{
J
Jan Kara 已提交
3753 3754
	struct address_space *mapping = iocb->ki_filp->f_mapping;
	struct inode *inode = mapping->host;
3755
	size_t count = iov_iter_count(iter);
J
Jan Kara 已提交
3756 3757
	ssize_t ret;

J
Jan Kara 已提交
3758 3759 3760 3761 3762 3763
	/*
	 * 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);
3764
	ret = filemap_write_and_wait_range(mapping, iocb->ki_pos,
3765
					   iocb->ki_pos + count - 1);
3766 3767 3768 3769
	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 已提交
3770 3771
out_unlock:
	inode_unlock_shared(inode);
3772
	return ret;
3773 3774
}

3775
static ssize_t ext4_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
3776 3777 3778
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
3779
	size_t count = iov_iter_count(iter);
3780
	loff_t offset = iocb->ki_pos;
3781
	ssize_t ret;
3782

3783 3784 3785 3786 3787
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	if (ext4_encrypted_inode(inode) && S_ISREG(inode->i_mode))
		return 0;
#endif

3788 3789 3790 3791 3792 3793
	/*
	 * If we are doing data journalling we don't support O_DIRECT
	 */
	if (ext4_should_journal_data(inode))
		return 0;

T
Tao Ma 已提交
3794 3795 3796 3797
	/* Let buffer I/O handle the inline data case. */
	if (ext4_has_inline_data(inode))
		return 0;

3798 3799 3800 3801
	/* DAX uses iomap path now */
	if (WARN_ON_ONCE(IS_DAX(inode)))
		return 0;

3802
	trace_ext4_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
J
Jan Kara 已提交
3803
	if (iov_iter_rw(iter) == READ)
3804
		ret = ext4_direct_IO_read(iocb, iter);
3805
	else
3806
		ret = ext4_direct_IO_write(iocb, iter);
3807
	trace_ext4_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), ret);
3808
	return ret;
3809 3810
}

3811
/*
3812
 * Pages can be marked dirty completely asynchronously from ext4's journalling
3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823
 * 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.
 */
3824
static int ext4_journalled_set_page_dirty(struct page *page)
3825 3826 3827 3828 3829
{
	SetPageChecked(page);
	return __set_page_dirty_nobuffers(page);
}

3830 3831 3832 3833 3834 3835 3836
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);
}

3837
static const struct address_space_operations ext4_aops = {
3838 3839
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3840
	.writepage		= ext4_writepage,
3841
	.writepages		= ext4_writepages,
3842
	.write_begin		= ext4_write_begin,
3843
	.write_end		= ext4_write_end,
3844
	.set_page_dirty		= ext4_set_page_dirty,
3845 3846 3847 3848 3849 3850
	.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,
3851
	.error_remove_page	= generic_error_remove_page,
3852 3853
};

3854
static const struct address_space_operations ext4_journalled_aops = {
3855 3856
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3857
	.writepage		= ext4_writepage,
3858
	.writepages		= ext4_writepages,
3859 3860 3861 3862
	.write_begin		= ext4_write_begin,
	.write_end		= ext4_journalled_write_end,
	.set_page_dirty		= ext4_journalled_set_page_dirty,
	.bmap			= ext4_bmap,
3863
	.invalidatepage		= ext4_journalled_invalidatepage,
3864
	.releasepage		= ext4_releasepage,
3865
	.direct_IO		= ext4_direct_IO,
3866
	.is_partially_uptodate  = block_is_partially_uptodate,
3867
	.error_remove_page	= generic_error_remove_page,
3868 3869
};

3870
static const struct address_space_operations ext4_da_aops = {
3871 3872
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3873
	.writepage		= ext4_writepage,
3874
	.writepages		= ext4_writepages,
3875 3876
	.write_begin		= ext4_da_write_begin,
	.write_end		= ext4_da_write_end,
3877
	.set_page_dirty		= ext4_set_page_dirty,
3878 3879 3880 3881 3882 3883
	.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,
3884
	.error_remove_page	= generic_error_remove_page,
3885 3886
};

3887
void ext4_set_aops(struct inode *inode)
3888
{
3889 3890 3891 3892 3893
	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:
3894
		inode->i_mapping->a_ops = &ext4_journalled_aops;
3895
		return;
3896 3897 3898
	default:
		BUG();
	}
3899 3900 3901 3902
	if (test_opt(inode->i_sb, DELALLOC))
		inode->i_mapping->a_ops = &ext4_da_aops;
	else
		inode->i_mapping->a_ops = &ext4_aops;
3903 3904
}

R
Ross Zwisler 已提交
3905
static int __ext4_block_zero_page_range(handle_t *handle,
3906 3907
		struct address_space *mapping, loff_t from, loff_t length)
{
3908 3909
	ext4_fsblk_t index = from >> PAGE_SHIFT;
	unsigned offset = from & (PAGE_SIZE-1);
R
Ross Zwisler 已提交
3910
	unsigned blocksize, pos;
3911 3912 3913 3914 3915 3916
	ext4_lblk_t iblock;
	struct inode *inode = mapping->host;
	struct buffer_head *bh;
	struct page *page;
	int err = 0;

3917
	page = find_or_create_page(mapping, from >> PAGE_SHIFT,
3918
				   mapping_gfp_constraint(mapping, ~__GFP_FS));
3919 3920 3921 3922 3923
	if (!page)
		return -ENOMEM;

	blocksize = inode->i_sb->s_blocksize;

3924
	iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956

	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;
3957
		ll_rw_block(REQ_OP_READ, 0, 1, &bh);
3958 3959 3960 3961
		wait_on_buffer(bh);
		/* Uhhuh. Read error. Complain and punt. */
		if (!buffer_uptodate(bh))
			goto unlock;
3962 3963 3964
		if (S_ISREG(inode->i_mode) &&
		    ext4_encrypted_inode(inode)) {
			/* We expect the key to be set. */
3965
			BUG_ON(!fscrypt_has_encryption_key(inode));
3966
			BUG_ON(blocksize != PAGE_SIZE);
3967
			WARN_ON_ONCE(fscrypt_decrypt_page(page->mapping->host,
3968
						page, PAGE_SIZE, 0, page->index));
3969
		}
3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981
	}
	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);
3982
	} else {
3983
		err = 0;
3984
		mark_buffer_dirty(bh);
J
Jan Kara 已提交
3985
		if (ext4_should_order_data(inode))
3986
			err = ext4_jbd2_inode_add_write(handle, inode);
3987
	}
3988 3989 3990

unlock:
	unlock_page(page);
3991
	put_page(page);
3992 3993 3994
	return err;
}

R
Ross Zwisler 已提交
3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005
/*
 * 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;
4006
	unsigned offset = from & (PAGE_SIZE-1);
R
Ross Zwisler 已提交
4007 4008 4009 4010 4011 4012 4013 4014 4015 4016
	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;

4017 4018 4019 4020
	if (IS_DAX(inode)) {
		return iomap_zero_range(inode, from, length, NULL,
					&ext4_iomap_ops);
	}
R
Ross Zwisler 已提交
4021 4022 4023
	return __ext4_block_zero_page_range(handle, mapping, from, length);
}

4024 4025 4026 4027 4028 4029
/*
 * 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.
 */
4030
static int ext4_block_truncate_page(handle_t *handle,
4031 4032
		struct address_space *mapping, loff_t from)
{
4033
	unsigned offset = from & (PAGE_SIZE-1);
4034 4035 4036 4037
	unsigned length;
	unsigned blocksize;
	struct inode *inode = mapping->host;

4038 4039 4040 4041
	/* If we are processing an encrypted inode during orphan list handling */
	if (ext4_encrypted_inode(inode) && !fscrypt_has_encryption_key(inode))
		return 0;

4042 4043 4044 4045 4046 4047
	blocksize = inode->i_sb->s_blocksize;
	length = blocksize - (offset & (blocksize - 1));

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

4048 4049 4050 4051 4052
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;
4053
	unsigned partial_start, partial_end;
4054 4055 4056 4057
	ext4_fsblk_t start, end;
	loff_t byte_end = (lstart + length - 1);
	int err = 0;

4058 4059 4060
	partial_start = lstart & (sb->s_blocksize - 1);
	partial_end = byte_end & (sb->s_blocksize - 1);

4061 4062 4063 4064
	start = lstart >> sb->s_blocksize_bits;
	end = byte_end >> sb->s_blocksize_bits;

	/* Handle partial zero within the single block */
4065 4066
	if (start == end &&
	    (partial_start || (partial_end != sb->s_blocksize - 1))) {
4067 4068 4069 4070 4071
		err = ext4_block_zero_page_range(handle, mapping,
						 lstart, length);
		return err;
	}
	/* Handle partial zero out on the start of the range */
4072
	if (partial_start) {
4073 4074 4075 4076 4077 4078
		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 */
4079
	if (partial_end != sb->s_blocksize - 1)
4080
		err = ext4_block_zero_page_range(handle, mapping,
4081 4082
						 byte_end - partial_end,
						 partial_end + 1);
4083 4084 4085
	return err;
}

4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096
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;
}

4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108
/*
 * 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 已提交
4109
	WARN_ON(!inode_is_locked(inode));
4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125
	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;
}

4126
/*
4127
 * ext4_punch_hole: punches a hole in a file by releasing the blocks
4128 4129 4130 4131 4132 4133
 * associated with the given offset and length
 *
 * @inode:  File inode
 * @offset: The offset where the hole will begin
 * @len:    The length of the hole
 *
4134
 * Returns: 0 on success or negative on failure
4135 4136
 */

4137
int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length)
4138
{
T
Theodore Ts'o 已提交
4139 4140 4141
	struct super_block *sb = inode->i_sb;
	ext4_lblk_t first_block, stop_block;
	struct address_space *mapping = inode->i_mapping;
4142
	loff_t first_block_offset, last_block_offset;
T
Theodore Ts'o 已提交
4143 4144 4145 4146
	handle_t *handle;
	unsigned int credits;
	int ret = 0;

4147
	if (!S_ISREG(inode->i_mode))
4148
		return -EOPNOTSUPP;
4149

4150
	trace_ext4_punch_hole(inode, offset, length, 0);
4151

T
Theodore Ts'o 已提交
4152 4153 4154 4155
	/*
	 * Write out all dirty pages to avoid race conditions
	 * Then release them.
	 */
4156
	if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
T
Theodore Ts'o 已提交
4157 4158 4159 4160 4161 4162
		ret = filemap_write_and_wait_range(mapping, offset,
						   offset + length - 1);
		if (ret)
			return ret;
	}

A
Al Viro 已提交
4163
	inode_lock(inode);
4164

T
Theodore Ts'o 已提交
4165 4166 4167 4168 4169 4170 4171 4172 4173 4174
	/* 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 +
4175
		   PAGE_SIZE - (inode->i_size & (PAGE_SIZE - 1)) -
T
Theodore Ts'o 已提交
4176 4177 4178
		   offset;
	}

4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190
	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;

	}

4191 4192 4193 4194 4195 4196 4197 4198 4199
	/* Wait all existing dio workers, newcomers will block on i_mutex */
	ext4_inode_block_unlocked_dio(inode);
	inode_dio_wait(inode);

	/*
	 * Prevent page faults from reinstantiating pages we have released from
	 * page cache.
	 */
	down_write(&EXT4_I(inode)->i_mmap_sem);
4200 4201
	first_block_offset = round_up(offset, sb->s_blocksize);
	last_block_offset = round_down((offset + length), sb->s_blocksize) - 1;
T
Theodore Ts'o 已提交
4202

4203
	/* Now release the pages and zero block aligned part of pages*/
4204 4205 4206 4207
	if (last_block_offset > first_block_offset) {
		ret = ext4_update_disksize_before_punch(inode, offset, length);
		if (ret)
			goto out_dio;
4208 4209
		truncate_pagecache_range(inode, first_block_offset,
					 last_block_offset);
4210
	}
T
Theodore Ts'o 已提交
4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222

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

4223 4224 4225 4226
	ret = ext4_zero_partial_blocks(handle, inode, offset,
				       length);
	if (ret)
		goto out_stop;
T
Theodore Ts'o 已提交
4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249

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

	/* If there are no blocks to remove, return now */
	if (first_block >= stop_block)
		goto out_stop;

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

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

	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
		ret = ext4_ext_remove_space(inode, first_block,
					    stop_block - 1);
	else
4250
		ret = ext4_ind_remove_space(handle, inode, first_block,
T
Theodore Ts'o 已提交
4251 4252
					    stop_block);

T
Theodore Ts'o 已提交
4253
	up_write(&EXT4_I(inode)->i_data_sem);
T
Theodore Ts'o 已提交
4254 4255
	if (IS_SYNC(inode))
		ext4_handle_sync(handle);
4256

4257
	inode->i_mtime = inode->i_ctime = current_time(inode);
T
Theodore Ts'o 已提交
4258
	ext4_mark_inode_dirty(handle, inode);
4259 4260
	if (ret >= 0)
		ext4_update_inode_fsync_trans(handle, inode, 1);
T
Theodore Ts'o 已提交
4261 4262 4263
out_stop:
	ext4_journal_stop(handle);
out_dio:
4264
	up_write(&EXT4_I(inode)->i_mmap_sem);
T
Theodore Ts'o 已提交
4265 4266
	ext4_inode_resume_unlocked_dio(inode);
out_mutex:
A
Al Viro 已提交
4267
	inode_unlock(inode);
T
Theodore Ts'o 已提交
4268
	return ret;
4269 4270
}

4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295
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;
}

4296
/*
4297
 * ext4_truncate()
4298
 *
4299 4300
 * We block out ext4_get_block() block instantiations across the entire
 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
4301 4302
 * simultaneously on behalf of the same inode.
 *
4303
 * As we work through the truncate and commit bits of it to the journal there
4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316
 * 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
4317
 * i_disksize in this case).  After a crash, ext4_orphan_cleanup() will see
4318
 * that this inode's truncate did not complete and it will again call
4319 4320
 * 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
4321
 * that's fine - as long as they are linked from the inode, the post-crash
4322
 * ext4_truncate() run will find them and release them.
4323
 */
4324
int ext4_truncate(struct inode *inode)
4325
{
T
Theodore Ts'o 已提交
4326 4327
	struct ext4_inode_info *ei = EXT4_I(inode);
	unsigned int credits;
4328
	int err = 0;
T
Theodore Ts'o 已提交
4329 4330 4331
	handle_t *handle;
	struct address_space *mapping = inode->i_mapping;

4332 4333
	/*
	 * There is a possibility that we're either freeing the inode
M
Matthew Wilcox 已提交
4334
	 * or it's a completely new inode. In those cases we might not
4335 4336 4337
	 * have i_mutex locked because it's not necessary.
	 */
	if (!(inode->i_state & (I_NEW|I_FREEING)))
A
Al Viro 已提交
4338
		WARN_ON(!inode_is_locked(inode));
4339 4340
	trace_ext4_truncate_enter(inode);

4341
	if (!ext4_can_truncate(inode))
4342
		return 0;
4343

4344
	ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
4345

4346
	if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
4347
		ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
4348

4349 4350 4351
	if (ext4_has_inline_data(inode)) {
		int has_inline = 1;

4352 4353 4354
		err = ext4_inline_data_truncate(inode, &has_inline);
		if (err)
			return err;
4355
		if (has_inline)
4356
			return 0;
4357 4358
	}

4359 4360 4361
	/* 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)
4362
			return 0;
4363 4364
	}

T
Theodore Ts'o 已提交
4365 4366 4367 4368 4369 4370
	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);
4371 4372
	if (IS_ERR(handle))
		return PTR_ERR(handle);
T
Theodore Ts'o 已提交
4373

4374 4375
	if (inode->i_size & (inode->i_sb->s_blocksize - 1))
		ext4_block_truncate_page(handle, mapping, inode->i_size);
T
Theodore Ts'o 已提交
4376 4377 4378 4379 4380 4381 4382 4383 4384 4385

	/*
	 * 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.
	 */
4386 4387
	err = ext4_orphan_add(handle, inode);
	if (err)
T
Theodore Ts'o 已提交
4388 4389 4390 4391 4392 4393
		goto out_stop;

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

	ext4_discard_preallocations(inode);

4394
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
4395
		err = ext4_ext_truncate(handle, inode);
4396
	else
T
Theodore Ts'o 已提交
4397 4398 4399
		ext4_ind_truncate(handle, inode);

	up_write(&ei->i_data_sem);
4400 4401
	if (err)
		goto out_stop;
T
Theodore Ts'o 已提交
4402 4403 4404 4405 4406 4407 4408 4409 4410

	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
4411
	 * ext4_evict_inode(), and we allow that function to clean up the
T
Theodore Ts'o 已提交
4412 4413 4414 4415 4416
	 * orphan info for us.
	 */
	if (inode->i_nlink)
		ext4_orphan_del(handle, inode);

4417
	inode->i_mtime = inode->i_ctime = current_time(inode);
T
Theodore Ts'o 已提交
4418 4419
	ext4_mark_inode_dirty(handle, inode);
	ext4_journal_stop(handle);
4420

4421
	trace_ext4_truncate_exit(inode);
4422
	return err;
4423 4424 4425
}

/*
4426
 * ext4_get_inode_loc returns with an extra refcount against the inode's
4427 4428 4429 4430
 * 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.
 */
4431 4432
static int __ext4_get_inode_loc(struct inode *inode,
				struct ext4_iloc *iloc, int in_mem)
4433
{
4434 4435 4436 4437 4438 4439
	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 已提交
4440
	iloc->bh = NULL;
4441
	if (!ext4_valid_inum(sb, inode->i_ino))
4442
		return -EFSCORRUPTED;
4443

4444 4445 4446
	iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
	gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
	if (!gdp)
4447 4448
		return -EIO;

4449 4450 4451
	/*
	 * Figure out the offset within the block group inode table
	 */
4452
	inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
4453 4454 4455 4456 4457 4458
	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);
4459
	if (unlikely(!bh))
4460
		return -ENOMEM;
4461 4462
	if (!buffer_uptodate(bh)) {
		lock_buffer(bh);
4463 4464 4465 4466 4467 4468 4469 4470 4471 4472

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

4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485
		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;
4486
			int i, start;
4487

4488
			start = inode_offset & ~(inodes_per_block - 1);
4489

4490 4491
			/* Is the inode bitmap in cache? */
			bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
4492
			if (unlikely(!bitmap_bh))
4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503
				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;
			}
4504
			for (i = start; i < start + inodes_per_block; i++) {
4505 4506
				if (i == inode_offset)
					continue;
4507
				if (ext4_test_bit(i, bitmap_bh->b_data))
4508 4509 4510
					break;
			}
			brelse(bitmap_bh);
4511
			if (i == start + inodes_per_block) {
4512 4513 4514 4515 4516 4517 4518 4519 4520
				/* 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:
4521 4522 4523 4524 4525 4526 4527
		/*
		 * 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;
4528
			__u32 ra_blks = EXT4_SB(sb)->s_inode_readahead_blks;
4529 4530

			table = ext4_inode_table(sb, gdp);
T
Theodore Ts'o 已提交
4531
			/* s_inode_readahead_blks is always a power of 2 */
4532
			b = block & ~((ext4_fsblk_t) ra_blks - 1);
4533 4534
			if (table > b)
				b = table;
4535
			end = b + ra_blks;
4536
			num = EXT4_INODES_PER_GROUP(sb);
4537
			if (ext4_has_group_desc_csum(sb))
4538
				num -= ext4_itable_unused_count(sb, gdp);
4539 4540 4541 4542 4543 4544 4545
			table += num / inodes_per_block;
			if (end > table)
				end = table;
			while (b <= end)
				sb_breadahead(sb, b++);
		}

4546 4547 4548 4549 4550
		/*
		 * 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.
		 */
4551
		trace_ext4_load_inode(inode);
4552 4553
		get_bh(bh);
		bh->b_end_io = end_buffer_read_sync;
4554
		submit_bh(REQ_OP_READ, REQ_META | REQ_PRIO, bh);
4555 4556
		wait_on_buffer(bh);
		if (!buffer_uptodate(bh)) {
4557 4558
			EXT4_ERROR_INODE_BLOCK(inode, block,
					       "unable to read itable block");
4559 4560 4561 4562 4563 4564 4565 4566 4567
			brelse(bh);
			return -EIO;
		}
	}
has_buffer:
	iloc->bh = bh;
	return 0;
}

4568
int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
4569 4570
{
	/* We have all inode data except xattrs in memory here. */
4571
	return __ext4_get_inode_loc(inode, iloc,
4572
		!ext4_test_inode_state(inode, EXT4_STATE_XATTR));
4573 4574
}

4575
void ext4_set_inode_flags(struct inode *inode)
4576
{
4577
	unsigned int flags = EXT4_I(inode)->i_flags;
4578
	unsigned int new_fl = 0;
4579

4580
	if (flags & EXT4_SYNC_FL)
4581
		new_fl |= S_SYNC;
4582
	if (flags & EXT4_APPEND_FL)
4583
		new_fl |= S_APPEND;
4584
	if (flags & EXT4_IMMUTABLE_FL)
4585
		new_fl |= S_IMMUTABLE;
4586
	if (flags & EXT4_NOATIME_FL)
4587
		new_fl |= S_NOATIME;
4588
	if (flags & EXT4_DIRSYNC_FL)
4589
		new_fl |= S_DIRSYNC;
4590 4591 4592
	if (test_opt(inode->i_sb, DAX) && S_ISREG(inode->i_mode) &&
	    !ext4_should_journal_data(inode) && !ext4_has_inline_data(inode) &&
	    !ext4_encrypted_inode(inode))
R
Ross Zwisler 已提交
4593
		new_fl |= S_DAX;
4594
	inode_set_flags(inode, new_fl,
R
Ross Zwisler 已提交
4595
			S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_DAX);
4596 4597
}

4598
static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
4599
				  struct ext4_inode_info *ei)
4600 4601
{
	blkcnt_t i_blocks ;
A
Aneesh Kumar K.V 已提交
4602 4603
	struct inode *inode = &(ei->vfs_inode);
	struct super_block *sb = inode->i_sb;
4604

4605
	if (ext4_has_feature_huge_file(sb)) {
4606 4607 4608
		/* 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);
4609
		if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) {
A
Aneesh Kumar K.V 已提交
4610 4611 4612 4613 4614
			/* i_blocks represent file system block size */
			return i_blocks  << (inode->i_blkbits - 9);
		} else {
			return i_blocks;
		}
4615 4616 4617 4618
	} else {
		return le32_to_cpu(raw_inode->i_blocks_lo);
	}
}
4619

4620 4621 4622 4623 4624 4625
static inline void ext4_iget_extra_inode(struct inode *inode,
					 struct ext4_inode *raw_inode,
					 struct ext4_inode_info *ei)
{
	__le32 *magic = (void *)raw_inode +
			EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize;
4626 4627 4628
	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)) {
4629
		ext4_set_inode_state(inode, EXT4_STATE_XATTR);
4630
		ext4_find_inline_data_nolock(inode);
4631 4632
	} else
		EXT4_I(inode)->i_inline_off = 0;
4633 4634
}

L
Li Xi 已提交
4635 4636
int ext4_get_projid(struct inode *inode, kprojid_t *projid)
{
K
Kaho Ng 已提交
4637
	if (!ext4_has_feature_project(inode->i_sb))
L
Li Xi 已提交
4638 4639 4640 4641 4642
		return -EOPNOTSUPP;
	*projid = EXT4_I(inode)->i_projid;
	return 0;
}

4643
struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
4644
{
4645 4646
	struct ext4_iloc iloc;
	struct ext4_inode *raw_inode;
4647 4648
	struct ext4_inode_info *ei;
	struct inode *inode;
4649
	journal_t *journal = EXT4_SB(sb)->s_journal;
4650
	long ret;
4651
	loff_t size;
4652
	int block;
4653 4654
	uid_t i_uid;
	gid_t i_gid;
L
Li Xi 已提交
4655
	projid_t i_projid;
4656

4657 4658 4659 4660 4661 4662 4663
	inode = iget_locked(sb, ino);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;

	ei = EXT4_I(inode);
4664
	iloc.bh = NULL;
4665

4666 4667
	ret = __ext4_get_inode_loc(inode, &iloc, 0);
	if (ret < 0)
4668
		goto bad_inode;
4669
	raw_inode = ext4_raw_inode(&iloc);
4670 4671 4672 4673

	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 >
4674 4675 4676 4677 4678 4679
			EXT4_INODE_SIZE(inode->i_sb) ||
		    (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));
4680
			ret = -EFSCORRUPTED;
4681 4682 4683 4684 4685 4686
			goto bad_inode;
		}
	} else
		ei->i_extra_isize = 0;

	/* Precompute checksum seed for inode metadata */
4687
	if (ext4_has_metadata_csum(sb)) {
4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699
		struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
		__u32 csum;
		__le32 inum = cpu_to_le32(inode->i_ino);
		__le32 gen = raw_inode->i_generation;
		csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum,
				   sizeof(inum));
		ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen,
					      sizeof(gen));
	}

	if (!ext4_inode_csum_verify(inode, raw_inode, ei)) {
		EXT4_ERROR_INODE(inode, "checksum invalid");
4700
		ret = -EFSBADCRC;
4701 4702 4703
		goto bad_inode;
	}

4704
	inode->i_mode = le16_to_cpu(raw_inode->i_mode);
4705 4706
	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 已提交
4707
	if (ext4_has_feature_project(sb) &&
L
Li Xi 已提交
4708 4709 4710 4711 4712 4713
	    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;

4714
	if (!(test_opt(inode->i_sb, NO_UID32))) {
4715 4716
		i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
		i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
4717
	}
4718 4719
	i_uid_write(inode, i_uid);
	i_gid_write(inode, i_gid);
L
Li Xi 已提交
4720
	ei->i_projid = make_kprojid(&init_user_ns, i_projid);
M
Miklos Szeredi 已提交
4721
	set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
4722

4723
	ext4_clear_state_flags(ei);	/* Only relevant on 32-bit archs */
4724
	ei->i_inline_off = 0;
4725 4726 4727 4728 4729 4730 4731 4732
	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) {
4733 4734 4735
		if ((inode->i_mode == 0 ||
		     !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) &&
		    ino != EXT4_BOOT_LOADER_INO) {
4736
			/* this inode is deleted */
4737
			ret = -ESTALE;
4738 4739 4740 4741 4742
			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
4743 4744 4745
		 * the process of deleting those.
		 * OR it is the EXT4_BOOT_LOADER_INO which is
		 * not initialized on a new filesystem. */
4746 4747
	}
	ei->i_flags = le32_to_cpu(raw_inode->i_flags);
4748
	inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
4749
	ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
4750
	if (ext4_has_feature_64bit(sb))
B
Badari Pulavarty 已提交
4751 4752
		ei->i_file_acl |=
			((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
A
Artem Blagodarenko 已提交
4753
	inode->i_size = ext4_isize(sb, raw_inode);
4754 4755 4756 4757 4758
	if ((size = i_size_read(inode)) < 0) {
		EXT4_ERROR_INODE(inode, "bad i_size value: %lld", size);
		ret = -EFSCORRUPTED;
		goto bad_inode;
	}
4759
	ei->i_disksize = inode->i_size;
4760 4761 4762
#ifdef CONFIG_QUOTA
	ei->i_reserved_quota = 0;
#endif
4763 4764
	inode->i_generation = le32_to_cpu(raw_inode->i_generation);
	ei->i_block_group = iloc.block_group;
4765
	ei->i_last_alloc_group = ~0;
4766 4767 4768 4769
	/*
	 * 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!
	 */
4770
	for (block = 0; block < EXT4_N_BLOCKS; block++)
4771 4772 4773
		ei->i_data[block] = raw_inode->i_block[block];
	INIT_LIST_HEAD(&ei->i_orphan);

4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784
	/*
	 * 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;

4785
		read_lock(&journal->j_state_lock);
4786 4787 4788 4789 4790 4791 4792 4793
		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;
4794
		read_unlock(&journal->j_state_lock);
4795 4796 4797 4798
		ei->i_sync_tid = tid;
		ei->i_datasync_tid = tid;
	}

4799
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
4800 4801
		if (ei->i_extra_isize == 0) {
			/* The extra space is currently unused. Use it. */
4802
			BUILD_BUG_ON(sizeof(struct ext4_inode) & 3);
4803 4804
			ei->i_extra_isize = sizeof(struct ext4_inode) -
					    EXT4_GOOD_OLD_INODE_SIZE;
4805
		} else {
4806
			ext4_iget_extra_inode(inode, raw_inode, ei);
4807
		}
4808
	}
4809

K
Kalpak Shah 已提交
4810 4811 4812 4813 4814
	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);

4815
	if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) {
4816 4817 4818 4819 4820 4821
		inode->i_version = le32_to_cpu(raw_inode->i_disk_version);
		if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
			if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
				inode->i_version |=
		    (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
		}
4822 4823
	}

4824
	ret = 0;
4825
	if (ei->i_file_acl &&
4826
	    !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
4827 4828
		EXT4_ERROR_INODE(inode, "bad extended attribute block %llu",
				 ei->i_file_acl);
4829
		ret = -EFSCORRUPTED;
4830
		goto bad_inode;
4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843
	} else if (!ext4_has_inline_data(inode)) {
		if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
			if ((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
			    (S_ISLNK(inode->i_mode) &&
			     !ext4_inode_is_fast_symlink(inode))))
				/* Validate extent which is part of inode */
				ret = ext4_ext_check_inode(inode);
		} else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
			   (S_ISLNK(inode->i_mode) &&
			    !ext4_inode_is_fast_symlink(inode))) {
			/* Validate block references which are part of inode */
			ret = ext4_ind_check_inode(inode);
		}
4844
	}
4845
	if (ret)
4846
		goto bad_inode;
4847

4848
	if (S_ISREG(inode->i_mode)) {
4849
		inode->i_op = &ext4_file_inode_operations;
4850
		inode->i_fop = &ext4_file_operations;
4851
		ext4_set_aops(inode);
4852
	} else if (S_ISDIR(inode->i_mode)) {
4853 4854
		inode->i_op = &ext4_dir_inode_operations;
		inode->i_fop = &ext4_dir_operations;
4855
	} else if (S_ISLNK(inode->i_mode)) {
4856 4857 4858 4859
		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 已提交
4860
			inode->i_link = (char *)ei->i_data;
4861
			inode->i_op = &ext4_fast_symlink_inode_operations;
4862 4863 4864
			nd_terminate_link(ei->i_data, inode->i_size,
				sizeof(ei->i_data) - 1);
		} else {
4865 4866
			inode->i_op = &ext4_symlink_inode_operations;
			ext4_set_aops(inode);
4867
		}
4868
		inode_nohighmem(inode);
4869 4870
	} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
	      S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
4871
		inode->i_op = &ext4_special_inode_operations;
4872 4873 4874 4875 4876 4877
		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])));
4878 4879
	} else if (ino == EXT4_BOOT_LOADER_INO) {
		make_bad_inode(inode);
4880
	} else {
4881
		ret = -EFSCORRUPTED;
4882
		EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode);
4883
		goto bad_inode;
4884
	}
4885
	brelse(iloc.bh);
4886
	ext4_set_inode_flags(inode);
T
Tahsin Erdogan 已提交
4887

4888 4889
	unlock_new_inode(inode);
	return inode;
4890 4891

bad_inode:
4892
	brelse(iloc.bh);
4893 4894
	iget_failed(inode);
	return ERR_PTR(ret);
4895 4896
}

4897 4898 4899
struct inode *ext4_iget_normal(struct super_block *sb, unsigned long ino)
{
	if (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO)
4900
		return ERR_PTR(-EFSCORRUPTED);
4901 4902 4903
	return ext4_iget(sb, ino);
}

4904 4905 4906 4907 4908 4909 4910 4911 4912 4913
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) {
		/*
4914
		 * i_blocks can be represented in a 32 bit variable
4915 4916
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
4917
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
4918
		raw_inode->i_blocks_high = 0;
4919
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4920 4921
		return 0;
	}
4922
	if (!ext4_has_feature_huge_file(sb))
4923 4924 4925
		return -EFBIG;

	if (i_blocks <= 0xffffffffffffULL) {
4926 4927 4928 4929
		/*
		 * i_blocks can be represented in a 48 bit variable
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
4930
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
4931
		raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
4932
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4933
	} else {
4934
		ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE);
A
Aneesh Kumar K.V 已提交
4935 4936 4937 4938
		/* 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);
4939
	}
4940
	return 0;
4941 4942
}

4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992
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 |
			       I_DIRTY_SYNC | I_DIRTY_DATASYNC)) ||
	    ((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 |
				I_DIRTY_SYNC | I_DIRTY_DATASYNC)) == 0) &&
	    (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;
4993 4994 4995 4996 4997 4998
	/*
	 * 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;
4999 5000 5001 5002 5003 5004 5005 5006
	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);
	}
}

5007 5008 5009 5010 5011 5012 5013
/*
 * 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.
 */
5014
static int ext4_do_update_inode(handle_t *handle,
5015
				struct inode *inode,
5016
				struct ext4_iloc *iloc)
5017
{
5018 5019
	struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
	struct ext4_inode_info *ei = EXT4_I(inode);
5020
	struct buffer_head *bh = iloc->bh;
5021
	struct super_block *sb = inode->i_sb;
5022
	int err = 0, rc, block;
5023
	int need_datasync = 0, set_large_file = 0;
5024 5025
	uid_t i_uid;
	gid_t i_gid;
L
Li Xi 已提交
5026
	projid_t i_projid;
5027

5028 5029 5030
	spin_lock(&ei->i_raw_lock);

	/* For fields not tracked in the in-memory inode,
5031
	 * initialise them to zero for new inodes. */
5032
	if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
5033
		memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
5034 5035

	raw_inode->i_mode = cpu_to_le16(inode->i_mode);
5036 5037
	i_uid = i_uid_read(inode);
	i_gid = i_gid_read(inode);
L
Li Xi 已提交
5038
	i_projid = from_kprojid(&init_user_ns, ei->i_projid);
5039
	if (!(test_opt(inode->i_sb, NO_UID32))) {
5040 5041
		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));
5042 5043 5044 5045
/*
 * Fix up interoperability with old kernels. Otherwise, old inodes get
 * re-used with the upper 16 bits of the uid/gid intact
 */
5046 5047 5048 5049
		if (ei->i_dtime && list_empty(&ei->i_orphan)) {
			raw_inode->i_uid_high = 0;
			raw_inode->i_gid_high = 0;
		} else {
5050
			raw_inode->i_uid_high =
5051
				cpu_to_le16(high_16_bits(i_uid));
5052
			raw_inode->i_gid_high =
5053
				cpu_to_le16(high_16_bits(i_gid));
5054 5055
		}
	} else {
5056 5057
		raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid));
		raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(i_gid));
5058 5059 5060 5061
		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 已提交
5062 5063 5064 5065 5066 5067

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

5068 5069
	err = ext4_inode_blocks_set(handle, raw_inode, ei);
	if (err) {
5070
		spin_unlock(&ei->i_raw_lock);
5071
		goto out_brelse;
5072
	}
5073
	raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
5074
	raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF);
5075
	if (likely(!test_opt2(inode->i_sb, HURD_COMPAT)))
B
Badari Pulavarty 已提交
5076 5077
		raw_inode->i_file_acl_high =
			cpu_to_le16(ei->i_file_acl >> 32);
5078
	raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
A
Artem Blagodarenko 已提交
5079
	if (ei->i_disksize != ext4_isize(inode->i_sb, raw_inode)) {
5080 5081 5082
		ext4_isize_set(raw_inode, ei->i_disksize);
		need_datasync = 1;
	}
5083
	if (ei->i_disksize > 0x7fffffffULL) {
5084
		if (!ext4_has_feature_large_file(sb) ||
5085
				EXT4_SB(sb)->s_es->s_rev_level ==
5086 5087
		    cpu_to_le32(EXT4_GOOD_OLD_REV))
			set_large_file = 1;
5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100
	}
	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;
		}
5101
	} else if (!ext4_has_inline_data(inode)) {
5102 5103
		for (block = 0; block < EXT4_N_BLOCKS; block++)
			raw_inode->i_block[block] = ei->i_data[block];
5104
	}
5105

5106
	if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) {
5107 5108 5109 5110 5111 5112 5113 5114
		raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
		if (ei->i_extra_isize) {
			if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
				raw_inode->i_version_hi =
					cpu_to_le32(inode->i_version >> 32);
			raw_inode->i_extra_isize =
				cpu_to_le16(ei->i_extra_isize);
		}
5115
	}
L
Li Xi 已提交
5116

K
Kaho Ng 已提交
5117
	BUG_ON(!ext4_has_feature_project(inode->i_sb) &&
L
Li Xi 已提交
5118 5119 5120 5121 5122 5123
	       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);

5124
	ext4_inode_csum_set(inode, raw_inode, ei);
5125
	spin_unlock(&ei->i_raw_lock);
5126 5127 5128
	if (inode->i_sb->s_flags & MS_LAZYTIME)
		ext4_update_other_inodes_time(inode->i_sb, inode->i_ino,
					      bh->b_data);
5129

5130
	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
5131
	rc = ext4_handle_dirty_metadata(handle, NULL, bh);
5132 5133
	if (!err)
		err = rc;
5134
	ext4_clear_inode_state(inode, EXT4_STATE_NEW);
5135
	if (set_large_file) {
5136
		BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get write access");
5137 5138 5139 5140
		err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
		if (err)
			goto out_brelse;
		ext4_update_dynamic_rev(sb);
5141
		ext4_set_feature_large_file(sb);
5142 5143 5144
		ext4_handle_sync(handle);
		err = ext4_handle_dirty_super(handle, sb);
	}
5145
	ext4_update_inode_fsync_trans(handle, inode, need_datasync);
5146
out_brelse:
5147
	brelse(bh);
5148
	ext4_std_error(inode->i_sb, err);
5149 5150 5151 5152
	return err;
}

/*
5153
 * ext4_write_inode()
5154 5155 5156
 *
 * We are called from a few places:
 *
5157
 * - Within generic_file_aio_write() -> generic_write_sync() for O_SYNC files.
5158
 *   Here, there will be no transaction running. We wait for any running
5159
 *   transaction to commit.
5160
 *
5161 5162
 * - Within flush work (sys_sync(), kupdate and such).
 *   We wait on commit, if told to.
5163
 *
5164 5165
 * - Within iput_final() -> write_inode_now()
 *   We wait on commit, if told to.
5166 5167 5168
 *
 * 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
5169 5170
 * ext4_mark_inode_dirty().  This is a correctness thing for WB_SYNC_ALL
 * writeback.
5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181
 *
 * 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;
 *
5182 5183 5184
 * 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.
5185
 */
5186
int ext4_write_inode(struct inode *inode, struct writeback_control *wbc)
5187
{
5188 5189
	int err;

5190
	if (WARN_ON_ONCE(current->flags & PF_MEMALLOC))
5191 5192
		return 0;

5193 5194 5195 5196 5197 5198
	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;
		}
5199

5200 5201 5202 5203 5204 5205
		/*
		 * 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)
5206 5207 5208 5209 5210
			return 0;

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

5212
		err = __ext4_get_inode_loc(inode, &iloc, 0);
5213 5214
		if (err)
			return err;
5215 5216 5217 5218 5219
		/*
		 * 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)
5220 5221
			sync_dirty_buffer(iloc.bh);
		if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
5222 5223
			EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr,
					 "IO error syncing inode");
5224 5225
			err = -EIO;
		}
5226
		brelse(iloc.bh);
5227 5228
	}
	return err;
5229 5230
}

5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243
/*
 * 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;

5244
	offset = inode->i_size & (PAGE_SIZE - 1);
5245 5246
	/*
	 * All buffers in the last page remain valid? Then there's nothing to
5247
	 * do. We do the check mainly to optimize the common PAGE_SIZE ==
5248 5249
	 * blocksize case
	 */
F
Fabian Frederick 已提交
5250
	if (offset > PAGE_SIZE - i_blocksize(inode))
5251 5252 5253
		return;
	while (1) {
		page = find_lock_page(inode->i_mapping,
5254
				      inode->i_size >> PAGE_SHIFT);
5255 5256
		if (!page)
			return;
5257
		ret = __ext4_journalled_invalidatepage(page, offset,
5258
						PAGE_SIZE - offset);
5259
		unlock_page(page);
5260
		put_page(page);
5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272
		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);
	}
}

5273
/*
5274
 * ext4_setattr()
5275 5276 5277 5278 5279 5280 5281 5282 5283 5284 5285 5286 5287
 *
 * 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.)
 *
5288 5289 5290 5291 5292 5293 5294 5295
 * 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.
5296
 */
5297
int ext4_setattr(struct dentry *dentry, struct iattr *attr)
5298
{
5299
	struct inode *inode = d_inode(dentry);
5300
	int error, rc = 0;
5301
	int orphan = 0;
5302 5303
	const unsigned int ia_valid = attr->ia_valid;

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

5307
	error = setattr_prepare(dentry, attr);
5308 5309 5310
	if (error)
		return error;

5311 5312 5313 5314 5315
	if (is_quota_modification(inode, attr)) {
		error = dquot_initialize(inode);
		if (error)
			return error;
	}
5316 5317
	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))) {
5318 5319 5320 5321
		handle_t *handle;

		/* (user+group)*(old+new) structure, inode write (sb,
		 * inode block, ? - but truncate inode update has it) */
5322 5323 5324
		handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
			(EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb) +
			 EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)) + 3);
5325 5326 5327 5328
		if (IS_ERR(handle)) {
			error = PTR_ERR(handle);
			goto err_out;
		}
5329 5330 5331 5332 5333

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

5337
		if (error) {
5338
			ext4_journal_stop(handle);
5339 5340 5341 5342 5343 5344 5345 5346
			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;
5347 5348
		error = ext4_mark_inode_dirty(handle, inode);
		ext4_journal_stop(handle);
5349 5350
	}

5351
	if (attr->ia_valid & ATTR_SIZE) {
5352
		handle_t *handle;
5353 5354
		loff_t oldsize = inode->i_size;
		int shrink = (attr->ia_size <= inode->i_size);
5355

5356 5357 5358 5359 5360 5361 5362 5363
		if (ext4_encrypted_inode(inode)) {
			error = fscrypt_get_encryption_info(inode);
			if (error)
				return error;
			if (!fscrypt_has_encryption_key(inode))
				return -ENOKEY;
		}

5364
		if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
5365 5366
			struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

5367 5368
			if (attr->ia_size > sbi->s_bitmap_maxbytes)
				return -EFBIG;
5369
		}
5370 5371
		if (!S_ISREG(inode->i_mode))
			return -EINVAL;
C
Christoph Hellwig 已提交
5372 5373 5374 5375

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

5376
		if (ext4_should_order_data(inode) &&
5377
		    (attr->ia_size < inode->i_size)) {
5378
			error = ext4_begin_ordered_truncate(inode,
5379
							    attr->ia_size);
5380 5381 5382 5383
			if (error)
				goto err_out;
		}
		if (attr->ia_size != inode->i_size) {
5384 5385 5386 5387 5388
			handle = ext4_journal_start(inode, EXT4_HT_INODE, 3);
			if (IS_ERR(handle)) {
				error = PTR_ERR(handle);
				goto err_out;
			}
5389
			if (ext4_handle_valid(handle) && shrink) {
5390 5391 5392
				error = ext4_orphan_add(handle, inode);
				orphan = 1;
			}
E
Eryu Guan 已提交
5393 5394 5395 5396 5397
			/*
			 * Update c/mtime on truncate up, ext4_truncate() will
			 * update c/mtime in shrink case below
			 */
			if (!shrink) {
5398
				inode->i_mtime = current_time(inode);
E
Eryu Guan 已提交
5399 5400
				inode->i_ctime = inode->i_mtime;
			}
5401
			down_write(&EXT4_I(inode)->i_data_sem);
5402 5403 5404 5405
			EXT4_I(inode)->i_disksize = attr->ia_size;
			rc = ext4_mark_inode_dirty(handle, inode);
			if (!error)
				error = rc;
5406 5407 5408 5409 5410 5411 5412 5413
			/*
			 * 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);
5414 5415
			ext4_journal_stop(handle);
			if (error) {
5416 5417
				if (orphan)
					ext4_orphan_del(NULL, inode);
5418 5419
				goto err_out;
			}
5420
		}
5421 5422
		if (!shrink)
			pagecache_isize_extended(inode, oldsize, inode->i_size);
5423

5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435
		/*
		 * Blocks are going to be removed from the inode. Wait
		 * for dio in flight.  Temporarily disable
		 * dioread_nolock to prevent livelock.
		 */
		if (orphan) {
			if (!ext4_should_journal_data(inode)) {
				ext4_inode_block_unlocked_dio(inode);
				inode_dio_wait(inode);
				ext4_inode_resume_unlocked_dio(inode);
			} else
				ext4_wait_for_tail_page_commit(inode);
5436
		}
5437
		down_write(&EXT4_I(inode)->i_mmap_sem);
5438 5439 5440 5441
		/*
		 * Truncate pagecache after we've waited for commit
		 * in data=journal mode to make pages freeable.
		 */
R
Ross Zwisler 已提交
5442
		truncate_pagecache(inode, inode->i_size);
5443 5444 5445 5446 5447
		if (shrink) {
			rc = ext4_truncate(inode);
			if (rc)
				error = rc;
		}
5448
		up_write(&EXT4_I(inode)->i_mmap_sem);
5449
	}
5450

5451
	if (!error) {
C
Christoph Hellwig 已提交
5452 5453 5454 5455 5456 5457 5458 5459
		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.
	 */
5460
	if (orphan && inode->i_nlink)
5461
		ext4_orphan_del(NULL, inode);
5462

5463
	if (!error && (ia_valid & ATTR_MODE))
5464
		rc = posix_acl_chmod(inode, inode->i_mode);
5465 5466

err_out:
5467
	ext4_std_error(inode->i_sb, error);
5468 5469 5470 5471 5472
	if (!error)
		error = rc;
	return error;
}

5473 5474
int ext4_getattr(const struct path *path, struct kstat *stat,
		 u32 request_mask, unsigned int query_flags)
5475
{
D
David Howells 已提交
5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497
	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;
5498

5499 5500 5501 5502 5503 5504
	stat->attributes_mask |= (STATX_ATTR_APPEND |
				  STATX_ATTR_COMPRESSED |
				  STATX_ATTR_ENCRYPTED |
				  STATX_ATTR_IMMUTABLE |
				  STATX_ATTR_NODUMP);

5505
	generic_fillattr(inode, stat);
D
David Howells 已提交
5506 5507 5508 5509 5510 5511 5512 5513 5514 5515
	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);
5516

5517 5518 5519 5520
	/*
	 * 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 已提交
5521
	 * others don't incorrectly think the file is completely sparse.
5522 5523 5524 5525
	 */
	if (unlikely(ext4_has_inline_data(inode)))
		stat->blocks += (stat->size + 511) >> 9;

5526 5527 5528 5529 5530 5531 5532 5533 5534 5535
	/*
	 * 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.
	 */
5536
	delalloc_blocks = EXT4_C2B(EXT4_SB(inode->i_sb),
5537 5538
				   EXT4_I(inode)->i_reserved_data_blocks);
	stat->blocks += delalloc_blocks << (inode->i_sb->s_blocksize_bits - 9);
5539 5540
	return 0;
}
5541

5542 5543
static int ext4_index_trans_blocks(struct inode *inode, int lblocks,
				   int pextents)
5544
{
5545
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
5546 5547
		return ext4_ind_trans_blocks(inode, lblocks);
	return ext4_ext_index_trans_blocks(inode, pextents);
5548
}
5549

5550
/*
5551 5552 5553
 * 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
5554
 *
5555
 * If datablocks are discontiguous, they are possible to spread over
5556
 * different block groups too. If they are contiguous, with flexbg,
5557
 * they could still across block group boundary.
5558
 *
5559 5560
 * Also account for superblock, inode, quota and xattr blocks
 */
T
Tahsin Erdogan 已提交
5561
static int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
5562
				  int pextents)
5563
{
5564 5565
	ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
	int gdpblocks;
5566 5567 5568 5569
	int idxblocks;
	int ret = 0;

	/*
5570 5571
	 * How many index blocks need to touch to map @lblocks logical blocks
	 * to @pextents physical extents?
5572
	 */
5573
	idxblocks = ext4_index_trans_blocks(inode, lblocks, pextents);
5574 5575 5576 5577 5578 5579 5580

	ret = idxblocks;

	/*
	 * Now let's see how many group bitmaps and group descriptors need
	 * to account
	 */
5581
	groups = idxblocks + pextents;
5582
	gdpblocks = groups;
5583 5584
	if (groups > ngroups)
		groups = ngroups;
5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597
	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 已提交
5598
 * Calculate the total number of credits to reserve to fit
5599 5600
 * the modification of a single pages into a single transaction,
 * which may include multiple chunks of block allocations.
5601
 *
5602
 * This could be called via ext4_write_begin()
5603
 *
5604
 * We need to consider the worse case, when
5605
 * one new block per extent.
5606
 */
A
Alex Tomas 已提交
5607
int ext4_writepage_trans_blocks(struct inode *inode)
5608
{
5609
	int bpp = ext4_journal_blocks_per_page(inode);
5610 5611
	int ret;

5612
	ret = ext4_meta_trans_blocks(inode, bpp, bpp);
A
Alex Tomas 已提交
5613

5614
	/* Account for data blocks for journalled mode */
5615
	if (ext4_should_journal_data(inode))
5616
		ret += bpp;
5617 5618
	return ret;
}
5619 5620 5621 5622 5623

/*
 * Calculate the journal credits for a chunk of data modification.
 *
 * This is called from DIO, fallocate or whoever calling
5624
 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
5625 5626 5627 5628 5629 5630 5631 5632 5633
 *
 * 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);
}

5634
/*
5635
 * The caller must have previously called ext4_reserve_inode_write().
5636 5637
 * Give this, we know that the caller already has write access to iloc->bh.
 */
5638
int ext4_mark_iloc_dirty(handle_t *handle,
5639
			 struct inode *inode, struct ext4_iloc *iloc)
5640 5641 5642
{
	int err = 0;

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

5646
	if (IS_I_VERSION(inode))
5647 5648
		inode_inc_iversion(inode);

5649 5650 5651
	/* the do_update_inode consumes one bh->b_count */
	get_bh(iloc->bh);

5652
	/* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
5653
	err = ext4_do_update_inode(handle, inode, iloc);
5654 5655 5656 5657 5658 5659 5660 5661 5662 5663
	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
5664 5665
ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
			 struct ext4_iloc *iloc)
5666
{
5667 5668
	int err;

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

5672 5673 5674 5675 5676 5677 5678
	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;
5679 5680
		}
	}
5681
	ext4_std_error(inode->i_sb, err);
5682 5683 5684
	return err;
}

5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720
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;
	int error;

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

5721 5722 5723 5724
/*
 * Expand an inode by new_extra_isize bytes.
 * Returns 0 on success or negative error number on failure.
 */
5725 5726 5727 5728
static int ext4_try_to_expand_extra_isize(struct inode *inode,
					  unsigned int new_extra_isize,
					  struct ext4_iloc iloc,
					  handle_t *handle)
5729
{
5730 5731
	int no_expand;
	int error;
5732

5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747 5748
	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;
5749

5750
	if (ext4_write_trylock_xattr(inode, &no_expand) == 0)
5751
		return -EBUSY;
5752

5753 5754 5755
	error = __ext4_expand_extra_isize(inode, new_extra_isize, &iloc,
					  handle, &no_expand);
	ext4_write_unlock_xattr(inode, &no_expand);
5756

5757 5758
	return error;
}
5759

5760 5761 5762 5763 5764 5765 5766 5767 5768 5769 5770
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;
5771 5772
	}

5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784
	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);

	BUFFER_TRACE(iloc.bh, "get_write_access");
	error = ext4_journal_get_write_access(handle, iloc->bh);
5785
	if (error) {
5786 5787
		brelse(iloc->bh);
		goto out_stop;
5788
	}
5789

5790 5791 5792 5793 5794 5795 5796 5797 5798 5799
	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);
5800
	return error;
5801 5802
}

5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814 5815
/*
 * 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.
 */
5816
int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
5817
{
5818
	struct ext4_iloc iloc;
5819
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
5820
	int err;
5821 5822

	might_sleep();
5823
	trace_ext4_mark_inode_dirty(inode, _RET_IP_);
5824
	err = ext4_reserve_inode_write(handle, inode, &iloc);
5825 5826
	if (err)
		return err;
5827 5828 5829 5830 5831

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

5832
	return ext4_mark_iloc_dirty(handle, inode, &iloc);
5833 5834 5835
}

/*
5836
 * ext4_dirty_inode() is called from __mark_inode_dirty()
5837 5838 5839 5840 5841
 *
 * 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.
 *
5842
 * Also, dquot_alloc_block() will always dirty the inode when blocks
5843 5844 5845 5846 5847
 * 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.
5848 5849 5850 5851
 *
 * 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.
5852
 */
5853
void ext4_dirty_inode(struct inode *inode, int flags)
5854 5855 5856
{
	handle_t *handle;

5857 5858
	if (flags == I_DIRTY_TIME)
		return;
5859
	handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
5860 5861
	if (IS_ERR(handle))
		goto out;
5862 5863 5864

	ext4_mark_inode_dirty(handle, inode);

5865
	ext4_journal_stop(handle);
5866 5867 5868 5869 5870 5871 5872 5873
out:
	return;
}

#if 0
/*
 * Bind an inode's backing buffer_head into this transaction, to prevent
 * it from being flushed to disk early.  Unlike
5874
 * ext4_reserve_inode_write, this leaves behind no bh reference and
5875 5876 5877
 * returns no iloc structure, so the caller needs to repeat the iloc
 * lookup to mark the inode dirty later.
 */
5878
static int ext4_pin_inode(handle_t *handle, struct inode *inode)
5879
{
5880
	struct ext4_iloc iloc;
5881 5882 5883

	int err = 0;
	if (handle) {
5884
		err = ext4_get_inode_loc(inode, &iloc);
5885 5886
		if (!err) {
			BUFFER_TRACE(iloc.bh, "get_write_access");
5887
			err = jbd2_journal_get_write_access(handle, iloc.bh);
5888
			if (!err)
5889
				err = ext4_handle_dirty_metadata(handle,
5890
								 NULL,
5891
								 iloc.bh);
5892 5893 5894
			brelse(iloc.bh);
		}
	}
5895
	ext4_std_error(inode->i_sb, err);
5896 5897 5898 5899
	return err;
}
#endif

5900
int ext4_change_inode_journal_flag(struct inode *inode, int val)
5901 5902 5903 5904
{
	journal_t *journal;
	handle_t *handle;
	int err;
5905
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916

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

5917
	journal = EXT4_JOURNAL(inode);
5918 5919
	if (!journal)
		return 0;
5920
	if (is_journal_aborted(journal))
5921 5922
		return -EROFS;

5923 5924 5925 5926
	/* Wait for all existing dio workers */
	ext4_inode_block_unlocked_dio(inode);
	inode_dio_wait(inode);

5927 5928 5929 5930 5931 5932 5933 5934 5935 5936 5937 5938 5939 5940 5941 5942 5943 5944
	/*
	 * 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);
			ext4_inode_resume_unlocked_dio(inode);
			return err;
		}
	}

5945
	percpu_down_write(&sbi->s_journal_flag_rwsem);
5946
	jbd2_journal_lock_updates(journal);
5947 5948 5949 5950 5951 5952 5953 5954 5955 5956

	/*
	 * 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)
5957
		ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
5958
	else {
5959 5960 5961
		err = jbd2_journal_flush(journal);
		if (err < 0) {
			jbd2_journal_unlock_updates(journal);
5962
			percpu_up_write(&sbi->s_journal_flag_rwsem);
5963 5964 5965
			ext4_inode_resume_unlocked_dio(inode);
			return err;
		}
5966
		ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
5967
	}
5968
	ext4_set_aops(inode);
5969 5970 5971 5972 5973
	/*
	 * Update inode->i_flags after EXT4_INODE_JOURNAL_DATA was updated.
	 * E.g. S_DAX may get cleared / set.
	 */
	ext4_set_inode_flags(inode);
5974

5975
	jbd2_journal_unlock_updates(journal);
5976 5977
	percpu_up_write(&sbi->s_journal_flag_rwsem);

5978 5979
	if (val)
		up_write(&EXT4_I(inode)->i_mmap_sem);
5980
	ext4_inode_resume_unlocked_dio(inode);
5981 5982 5983

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

5984
	handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
5985 5986 5987
	if (IS_ERR(handle))
		return PTR_ERR(handle);

5988
	err = ext4_mark_inode_dirty(handle, inode);
5989
	ext4_handle_sync(handle);
5990 5991
	ext4_journal_stop(handle);
	ext4_std_error(inode->i_sb, err);
5992 5993 5994

	return err;
}
5995 5996 5997 5998 5999 6000

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

6001
int ext4_page_mkwrite(struct vm_fault *vmf)
6002
{
6003
	struct vm_area_struct *vma = vmf->vma;
6004
	struct page *page = vmf->page;
6005 6006
	loff_t size;
	unsigned long len;
6007
	int ret;
6008
	struct file *file = vma->vm_file;
A
Al Viro 已提交
6009
	struct inode *inode = file_inode(file);
6010
	struct address_space *mapping = inode->i_mapping;
6011 6012 6013
	handle_t *handle;
	get_block_t *get_block;
	int retries = 0;
6014

6015
	sb_start_pagefault(inode->i_sb);
6016
	file_update_time(vma->vm_file);
6017 6018

	down_read(&EXT4_I(inode)->i_mmap_sem);
6019 6020 6021 6022 6023

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

6024 6025 6026 6027 6028
	/* Delalloc case is easy... */
	if (test_opt(inode->i_sb, DELALLOC) &&
	    !ext4_should_journal_data(inode) &&
	    !ext4_nonda_switch(inode->i_sb)) {
		do {
6029
			ret = block_page_mkwrite(vma, vmf,
6030 6031 6032 6033
						   ext4_da_get_block_prep);
		} while (ret == -ENOSPC &&
		       ext4_should_retry_alloc(inode->i_sb, &retries));
		goto out_ret;
6034
	}
6035 6036

	lock_page(page);
6037 6038 6039 6040 6041 6042
	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;
6043
	}
6044

6045 6046
	if (page->index == size >> PAGE_SHIFT)
		len = size & ~PAGE_MASK;
6047
	else
6048
		len = PAGE_SIZE;
6049
	/*
6050 6051
	 * 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
6052
	 */
6053
	if (page_has_buffers(page)) {
6054 6055 6056
		if (!ext4_walk_page_buffers(NULL, page_buffers(page),
					    0, len, NULL,
					    ext4_bh_unmapped)) {
6057
			/* Wait so that we don't change page under IO */
6058
			wait_for_stable_page(page);
6059 6060
			ret = VM_FAULT_LOCKED;
			goto out;
6061
		}
6062
	}
6063
	unlock_page(page);
6064 6065
	/* OK, we need to fill the hole... */
	if (ext4_should_dioread_nolock(inode))
6066
		get_block = ext4_get_block_unwritten;
6067 6068 6069
	else
		get_block = ext4_get_block;
retry_alloc:
6070 6071
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
				    ext4_writepage_trans_blocks(inode));
6072
	if (IS_ERR(handle)) {
6073
		ret = VM_FAULT_SIGBUS;
6074 6075
		goto out;
	}
6076
	ret = block_page_mkwrite(vma, vmf, get_block);
6077
	if (!ret && ext4_should_journal_data(inode)) {
6078
		if (ext4_walk_page_buffers(handle, page_buffers(page), 0,
6079
			  PAGE_SIZE, NULL, do_journal_get_write_access)) {
6080 6081
			unlock_page(page);
			ret = VM_FAULT_SIGBUS;
6082
			ext4_journal_stop(handle);
6083 6084 6085 6086 6087 6088 6089 6090 6091 6092
			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:
6093
	up_read(&EXT4_I(inode)->i_mmap_sem);
6094
	sb_end_pagefault(inode->i_sb);
6095 6096
	return ret;
}
6097

6098
int ext4_filemap_fault(struct vm_fault *vmf)
6099
{
6100
	struct inode *inode = file_inode(vmf->vma->vm_file);
6101 6102 6103
	int err;

	down_read(&EXT4_I(inode)->i_mmap_sem);
6104
	err = filemap_fault(vmf);
6105 6106 6107 6108
	up_read(&EXT4_I(inode)->i_mmap_sem);

	return err;
}
6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171 6172 6173 6174 6175

/*
 * Find the first extent at or after @lblk in an inode that is not a hole.
 * Search for @map_len blocks at most. The extent is returned in @result.
 *
 * The function returns 1 if we found an extent. The function returns 0 in
 * case there is no extent at or after @lblk and in that case also sets
 * @result->es_len to 0. In case of error, the error code is returned.
 */
int ext4_get_next_extent(struct inode *inode, ext4_lblk_t lblk,
			 unsigned int map_len, struct extent_status *result)
{
	struct ext4_map_blocks map;
	struct extent_status es = {};
	int ret;

	map.m_lblk = lblk;
	map.m_len = map_len;

	/*
	 * For non-extent based files this loop may iterate several times since
	 * we do not determine full hole size.
	 */
	while (map.m_len > 0) {
		ret = ext4_map_blocks(NULL, inode, &map, 0);
		if (ret < 0)
			return ret;
		/* There's extent covering m_lblk? Just return it. */
		if (ret > 0) {
			int status;

			ext4_es_store_pblock(result, map.m_pblk);
			result->es_lblk = map.m_lblk;
			result->es_len = map.m_len;
			if (map.m_flags & EXT4_MAP_UNWRITTEN)
				status = EXTENT_STATUS_UNWRITTEN;
			else
				status = EXTENT_STATUS_WRITTEN;
			ext4_es_store_status(result, status);
			return 1;
		}
		ext4_es_find_delayed_extent_range(inode, map.m_lblk,
						  map.m_lblk + map.m_len - 1,
						  &es);
		/* Is delalloc data before next block in extent tree? */
		if (es.es_len && es.es_lblk < map.m_lblk + map.m_len) {
			ext4_lblk_t offset = 0;

			if (es.es_lblk < lblk)
				offset = lblk - es.es_lblk;
			result->es_lblk = es.es_lblk + offset;
			ext4_es_store_pblock(result,
					     ext4_es_pblock(&es) + offset);
			result->es_len = es.es_len - offset;
			ext4_es_store_status(result, ext4_es_status(&es));

			return 1;
		}
		/* There's a hole at m_lblk, advance us after it */
		map.m_lblk += map.m_len;
		map_len -= map.m_len;
		map.m_len = map_len;
		cond_resched();
	}
	result->es_len = 0;
	return 0;
}