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

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

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

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

51 52
#define MPAGE_DA_EXTENT_TAIL 0x01

53 54 55 56 57
static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw,
			      struct ext4_inode_info *ei)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	__u32 csum;
58 59 60
	__u16 dummy_csum = 0;
	int offset = offsetof(struct ext4_inode, i_checksum_lo);
	unsigned int csum_size = sizeof(dummy_csum);
61

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

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

	return csum;
}

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

	if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
	    cpu_to_le32(EXT4_OS_LINUX) ||
92
	    !ext4_has_metadata_csum(inode->i_sb))
93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
		return 1;

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

	return provided == calculated;
}

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

	if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
	    cpu_to_le32(EXT4_OS_LINUX) ||
113
	    !ext4_has_metadata_csum(inode->i_sb))
114 115 116 117 118 119 120 121 122
		return;

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

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

140 141
static void ext4_invalidatepage(struct page *page, unsigned int offset,
				unsigned int length);
142 143
static int __ext4_journalled_writepage(struct page *page, unsigned int len);
static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh);
T
Tahsin Erdogan 已提交
144 145
static int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
				  int pextents);
146

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

		if (ext4_has_inline_data(inode))
			return 0;

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

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

	/*
177
	 * Drop i_data_sem to avoid deadlock with ext4_map_blocks.  At this
178 179 180 181
	 * moment, get_block can be called only for blocks inside i_size since
	 * page cache has been already dropped and writes are blocked by
	 * i_mutex. So we can safely drop the i_data_sem here.
	 */
182
	BUG_ON(EXT4_JOURNAL(inode) == NULL);
183
	jbd_debug(2, "restarting handle %p\n", handle);
184
	up_write(&EXT4_I(inode)->i_data_sem);
185
	ret = ext4_journal_restart(handle, nblocks);
186
	down_write(&EXT4_I(inode)->i_data_sem);
187
	ext4_discard_preallocations(inode);
188 189

	return ret;
190 191 192 193 194
}

/*
 * Called at the last iput() if i_nlink is zero.
 */
A
Al Viro 已提交
195
void ext4_evict_inode(struct inode *inode)
196 197
{
	handle_t *handle;
198
	int err;
199 200 201 202 203 204
	/*
	 * Credits for final inode cleanup and freeing:
	 * sb + inode (ext4_orphan_del()), block bitmap, group descriptor
	 * (xattr block freeing), bitmap, group descriptor (inode freeing)
	 */
	int extra_credits = 6;
205
	struct ext4_xattr_inode_array *ea_inode_array = NULL;
206

207
	trace_ext4_evict_inode(inode);
208

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

235
			jbd2_complete_transaction(journal, commit_tid);
236 237
			filemap_write_and_wait(&inode->i_data);
		}
238
		truncate_inode_pages_final(&inode->i_data);
J
Jan Kara 已提交
239

A
Al Viro 已提交
240 241 242
		goto no_delete;
	}

243 244 245
	if (is_bad_inode(inode))
		goto no_delete;
	dquot_initialize(inode);
246

247 248
	if (ext4_should_order_data(inode))
		ext4_begin_ordered_truncate(inode, 0);
249
	truncate_inode_pages_final(&inode->i_data);
250

251 252 253 254 255
	/*
	 * Protect us against freezing - iput() caller didn't have to have any
	 * protection against it
	 */
	sb_start_intwrite(inode->i_sb);
A
Andreas Dilger 已提交
256

257 258 259
	if (!IS_NOQUOTA(inode))
		extra_credits += EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb);

260 261 262 263
	/*
	 * Block bitmap, group descriptor, and inode are accounted in both
	 * ext4_blocks_for_truncate() and extra_credits. So subtract 3.
	 */
264
	handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE,
265
			 ext4_blocks_for_truncate(inode) + extra_credits - 3);
266
	if (IS_ERR(handle)) {
267
		ext4_std_error(inode->i_sb, PTR_ERR(handle));
268 269 270 271 272
		/*
		 * 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.
		 */
273
		ext4_orphan_del(NULL, inode);
274
		sb_end_intwrite(inode->i_sb);
275 276
		goto no_delete;
	}
277

278
	if (IS_SYNC(inode))
279
		ext4_handle_sync(handle);
280 281 282 283 284 285 286 287 288 289

	/*
	 * 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));
290
	inode->i_size = 0;
291 292
	err = ext4_mark_inode_dirty(handle, inode);
	if (err) {
293
		ext4_warning(inode->i_sb,
294 295 296
			     "couldn't mark inode dirty (err %d)", err);
		goto stop_handle;
	}
297 298 299 300 301 302 303 304 305
	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;
		}
	}
306

307 308 309 310 311 312 313 314 315 316 317
	/* 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;
318 319
	}

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

	/*
	 * 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.
	 */
338
	if (ext4_mark_inode_dirty(handle, inode))
339
		/* If that failed, just do the required in-core inode clear. */
A
Al Viro 已提交
340
		ext4_clear_inode(inode);
341
	else
342 343
		ext4_free_inode(handle, inode);
	ext4_journal_stop(handle);
344
	sb_end_intwrite(inode->i_sb);
345
	ext4_xattr_inode_array_free(ea_inode_array);
346 347
	return;
no_delete:
A
Al Viro 已提交
348
	ext4_clear_inode(inode);	/* We must guarantee clearing of inode... */
349 350
}

351 352
#ifdef CONFIG_QUOTA
qsize_t *ext4_get_reserved_space(struct inode *inode)
353
{
354
	return &EXT4_I(inode)->i_reserved_quota;
355
}
356
#endif
357

358 359 360 361
/*
 * Called with i_data_sem down, which is important since we can call
 * ext4_discard_preallocations() from here.
 */
362 363
void ext4_da_update_reserve_space(struct inode *inode,
					int used, int quota_claim)
364 365
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
366 367 368
	struct ext4_inode_info *ei = EXT4_I(inode);

	spin_lock(&ei->i_block_reservation_lock);
369
	trace_ext4_da_update_reserve_space(inode, used, quota_claim);
370
	if (unlikely(used > ei->i_reserved_data_blocks)) {
371
		ext4_warning(inode->i_sb, "%s: ino %lu, used %d "
372
			 "with only %d reserved data blocks",
373 374 375 376 377
			 __func__, inode->i_ino, used,
			 ei->i_reserved_data_blocks);
		WARN_ON(1);
		used = ei->i_reserved_data_blocks;
	}
378

379 380
	/* Update per-inode reservations */
	ei->i_reserved_data_blocks -= used;
381
	percpu_counter_sub(&sbi->s_dirtyclusters_counter, used);
382

383
	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
384

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

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

407
static int __check_block_validity(struct inode *inode, const char *func,
408 409
				unsigned int line,
				struct ext4_map_blocks *map)
410
{
411 412 413 414
	if (ext4_has_feature_journal(inode->i_sb) &&
	    (inode->i_ino ==
	     le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_journal_inum)))
		return 0;
415 416
	if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk,
				   map->m_len)) {
417
		ext4_error_inode(inode, func, line, map->m_pblk,
418
				 "lblock %lu mapped to illegal pblock %llu "
419
				 "(length %d)", (unsigned long) map->m_lblk,
420
				 map->m_pblk, map->m_len);
421
		return -EFSCORRUPTED;
422 423 424 425
	}
	return 0;
}

J
Jan Kara 已提交
426 427 428 429 430 431
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))
432
		return fscrypt_zeroout_range(inode, lblk, pblk, len);
J
Jan Kara 已提交
433 434 435 436 437 438 439 440

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

	return ret;
}

441
#define check_block_validity(inode, map)	\
442
	__check_block_validity((inode), __func__, __LINE__, (map))
443

444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
#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.
	 */
461
	down_read(&EXT4_I(inode)->i_data_sem);
462 463 464 465 466 467 468
	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);
	}
469
	up_read((&EXT4_I(inode)->i_data_sem));
470 471 472 473 474 475 476 477

	/*
	 * 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) {
478
		printk("ES cache assertion failed for inode: %lu "
479 480 481 482 483 484 485 486 487 488
		       "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 */

489
/*
490
 * The ext4_map_blocks() function tries to look up the requested blocks,
491
 * and returns if the blocks are already mapped.
492 493 494 495 496
 *
 * 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.
 *
497 498
 * If file type is extents based, it will call ext4_ext_map_blocks(),
 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
499 500
 * based files
 *
501 502 503
 * 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.
504 505
 *
 * It returns 0 if plain look up failed (blocks have not been allocated), in
506 507
 * 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.
508 509 510
 *
 * It returns the error in case of allocation failure.
 */
511 512
int ext4_map_blocks(handle_t *handle, struct inode *inode,
		    struct ext4_map_blocks *map, int flags)
513
{
514
	struct extent_status es;
515
	int retval;
516
	int ret = 0;
517 518 519 520 521
#ifdef ES_AGGRESSIVE_TEST
	struct ext4_map_blocks orig_map;

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

523 524 525 526
	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);
527

528 529 530 531 532 533
	/*
	 * 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;

534 535
	/* We can handle the block number less than EXT_MAX_BLOCKS */
	if (unlikely(map->m_lblk >= EXT_MAX_BLOCKS))
536
		return -EFSCORRUPTED;
537

538 539 540 541 542 543 544 545 546 547 548 549
	/* 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)) {
550 551 552 553 554
			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;
555 556 557 558
			retval = 0;
		} else {
			BUG_ON(1);
		}
559 560 561 562
#ifdef ES_AGGRESSIVE_TEST
		ext4_map_blocks_es_recheck(handle, inode, map,
					   &orig_map, flags);
#endif
563 564 565
		goto found;
	}

566
	/*
567 568
	 * Try to see if we can get the block without requesting a new
	 * file system block.
569
	 */
570
	down_read(&EXT4_I(inode)->i_data_sem);
571
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
572 573
		retval = ext4_ext_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
574
	} else {
575 576
		retval = ext4_ind_map_blocks(handle, inode, map, flags &
					     EXT4_GET_BLOCKS_KEEP_SIZE);
577
	}
578
	if (retval > 0) {
579
		unsigned int status;
580

581 582 583 584 585 586
		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);
587 588
		}

589 590 591
		status = map->m_flags & EXT4_MAP_UNWRITTEN ?
				EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
		if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) &&
592
		    !(status & EXTENT_STATUS_WRITTEN) &&
593 594
		    ext4_es_scan_range(inode, &ext4_es_is_delayed, map->m_lblk,
				       map->m_lblk + map->m_len - 1))
595 596 597 598 599 600
			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;
	}
601
	up_read((&EXT4_I(inode)->i_data_sem));
602

603
found:
604
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
605
		ret = check_block_validity(inode, map);
606 607 608 609
		if (ret != 0)
			return ret;
	}

610
	/* If it is only a block(s) look up */
611
	if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)
612 613 614 615 616 617
		return retval;

	/*
	 * Returns if the blocks have already allocated
	 *
	 * Note that if blocks have been preallocated
618
	 * ext4_ext_get_block() returns the create = 0
619 620
	 * with buffer head unmapped.
	 */
621
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
622 623 624 625 626 627 628
		/*
		 * 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;
629

630
	/*
631 632
	 * Here we clear m_flags because after allocating an new extent,
	 * it will be set again.
633
	 */
634
	map->m_flags &= ~EXT4_MAP_FLAGS;
635

636
	/*
637
	 * New blocks allocate and/or writing to unwritten extent
638
	 * will possibly result in updating i_data, so we take
639
	 * the write lock of i_data_sem, and call get_block()
640
	 * with create == 1 flag.
641
	 */
642
	down_write(&EXT4_I(inode)->i_data_sem);
643

644 645 646 647
	/*
	 * We need to check for EXT4 here because migrate
	 * could have changed the inode type in between
	 */
648
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
649
		retval = ext4_ext_map_blocks(handle, inode, map, flags);
650
	} else {
651
		retval = ext4_ind_map_blocks(handle, inode, map, flags);
652

653
		if (retval > 0 && map->m_flags & EXT4_MAP_NEW) {
654 655 656 657 658
			/*
			 * We allocated new blocks which will result in
			 * i_data's format changing.  Force the migrate
			 * to fail by clearing migrate flags
			 */
659
			ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
660
		}
661

662 663 664 665 666 667 668
		/*
		 * 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) &&
669
			(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE))
670 671
			ext4_da_update_reserve_space(inode, retval, 1);
	}
672

673
	if (retval > 0) {
674
		unsigned int status;
675

676 677 678 679 680 681
		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);
682 683
		}

684 685 686
		/*
		 * We have to zeroout blocks before inserting them into extent
		 * status tree. Otherwise someone could look them up there and
687 688 689
		 * 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.
690 691 692 693
		 */
		if (flags & EXT4_GET_BLOCKS_ZERO &&
		    map->m_flags & EXT4_MAP_MAPPED &&
		    map->m_flags & EXT4_MAP_NEW) {
694 695
			clean_bdev_aliases(inode->i_sb->s_bdev, map->m_pblk,
					   map->m_len);
696 697 698 699 700 701 702 703
			ret = ext4_issue_zeroout(inode, map->m_lblk,
						 map->m_pblk, map->m_len);
			if (ret) {
				retval = ret;
				goto out_sem;
			}
		}

704 705 706 707 708 709 710
		/*
		 * 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))
711
				goto out_sem;
712
		}
713 714 715
		status = map->m_flags & EXT4_MAP_UNWRITTEN ?
				EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
		if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) &&
716
		    !(status & EXTENT_STATUS_WRITTEN) &&
717 718
		    ext4_es_scan_range(inode, &ext4_es_is_delayed, map->m_lblk,
				       map->m_lblk + map->m_len - 1))
719 720 721
			status |= EXTENT_STATUS_DELAYED;
		ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len,
					    map->m_pblk, status);
722
		if (ret < 0) {
723
			retval = ret;
724 725
			goto out_sem;
		}
726 727
	}

728
out_sem:
729
	up_write((&EXT4_I(inode)->i_data_sem));
730
	if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
731
		ret = check_block_validity(inode, map);
732 733
		if (ret != 0)
			return ret;
J
Jan Kara 已提交
734 735 736 737 738 739 740 741 742

		/*
		 * 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 已提交
743
		    !ext4_is_quota_file(inode) &&
J
Jan Kara 已提交
744
		    ext4_should_order_data(inode)) {
745 746 747 748
			loff_t start_byte =
				(loff_t)map->m_lblk << inode->i_blkbits;
			loff_t length = (loff_t)map->m_len << inode->i_blkbits;

749
			if (flags & EXT4_GET_BLOCKS_IO_SUBMIT)
750 751
				ret = ext4_jbd2_inode_add_wait(handle, inode,
						start_byte, length);
752
			else
753 754
				ret = ext4_jbd2_inode_add_write(handle, inode,
						start_byte, length);
J
Jan Kara 已提交
755 756 757
			if (ret)
				return ret;
		}
758
	}
759 760 761
	return retval;
}

J
Jan Kara 已提交
762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789
/*
 * 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));
}

790 791
static int _ext4_get_block(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int flags)
792
{
793
	struct ext4_map_blocks map;
794
	int ret = 0;
795

T
Tao Ma 已提交
796 797 798
	if (ext4_has_inline_data(inode))
		return -ERANGE;

799 800 801
	map.m_lblk = iblock;
	map.m_len = bh->b_size >> inode->i_blkbits;

802 803
	ret = ext4_map_blocks(ext4_journal_current_handle(), inode, &map,
			      flags);
J
Jan Kara 已提交
804
	if (ret > 0) {
805
		map_bh(bh, inode->i_sb, map.m_pblk);
J
Jan Kara 已提交
806
		ext4_update_bh_state(bh, map.m_flags);
807
		bh->b_size = inode->i_sb->s_blocksize * map.m_len;
J
Jan Kara 已提交
808
		ret = 0;
809 810 811
	} else if (ret == 0) {
		/* hole case, need to fill in bh->b_size */
		bh->b_size = inode->i_sb->s_blocksize * map.m_len;
812 813 814 815
	}
	return ret;
}

816 817 818 819 820 821 822
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);
}

823 824 825 826 827 828 829 830 831 832 833 834 835 836
/*
 * 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);
}

837 838 839
/* Maximum number of blocks we map for direct IO at once. */
#define DIO_MAX_BLOCKS 4096

840 841 842 843 844 845 846
/*
 * 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)
847 848
{
	int dio_credits;
849 850 851
	handle_t *handle;
	int retries = 0;
	int ret;
852 853 854 855 856 857

	/* 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);
858 859 860 861 862 863 864 865 866 867 868
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;
869 870
}

871 872 873 874
/* 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)
{
875 876 877
	/* We don't expect handle for direct IO */
	WARN_ON_ONCE(ext4_journal_current_handle());

878 879 880
	if (!create)
		return _ext4_get_block(inode, iblock, bh, 0);
	return ext4_get_block_trans(inode, iblock, bh, EXT4_GET_BLOCKS_CREATE);
881 882 883
}

/*
884
 * Get block function for AIO DIO writes when we create unwritten extent if
885 886 887
 * blocks are not allocated yet. The extent will be converted to written
 * after IO is complete.
 */
888 889
static int ext4_dio_get_block_unwritten_async(struct inode *inode,
		sector_t iblock, struct buffer_head *bh_result,	int create)
890
{
891 892 893 894 895
	int ret;

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

896 897
	ret = ext4_get_block_trans(inode, iblock, bh_result,
				   EXT4_GET_BLOCKS_IO_CREATE_EXT);
898

899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915
	/*
	 * 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);
		}
916 917 918 919
		set_buffer_defer_completion(bh_result);
	}

	return ret;
920 921
}

922 923 924
/*
 * 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
925
 * after IO is complete by ext4_direct_IO_write().
926 927 928 929 930 931 932 933 934
 */
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());

935 936
	ret = ext4_get_block_trans(inode, iblock, bh_result,
				   EXT4_GET_BLOCKS_IO_CREATE_EXT);
937 938 939

	/*
	 * Mark inode as having pending DIO writes to unwritten extents.
940
	 * ext4_direct_IO_write() checks this flag and converts extents to
941 942 943 944 945 946 947 948
	 * written.
	 */
	if (!ret && buffer_unwritten(bh_result))
		ext4_set_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);

	return ret;
}

949 950 951 952 953 954 955
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);
956 957 958
	/* We don't expect handle for direct IO */
	WARN_ON_ONCE(ext4_journal_current_handle());

959 960 961 962 963
	ret = _ext4_get_block(inode, iblock, bh_result, 0);
	/*
	 * Blocks should have been preallocated! ext4_file_write_iter() checks
	 * that.
	 */
964
	WARN_ON_ONCE(!buffer_mapped(bh_result) || buffer_unwritten(bh_result));
965 966 967 968 969

	return ret;
}


970 971 972
/*
 * `handle' can be NULL if create is zero
 */
973
struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
974
				ext4_lblk_t block, int map_flags)
975
{
976 977
	struct ext4_map_blocks map;
	struct buffer_head *bh;
978
	int create = map_flags & EXT4_GET_BLOCKS_CREATE;
979
	int err;
980 981 982

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

983 984
	map.m_lblk = block;
	map.m_len = 1;
985
	err = ext4_map_blocks(handle, inode, &map, map_flags);
986

987 988
	if (err == 0)
		return create ? ERR_PTR(-ENOSPC) : NULL;
989
	if (err < 0)
990
		return ERR_PTR(err);
991 992

	bh = sb_getblk(inode->i_sb, map.m_pblk);
993 994
	if (unlikely(!bh))
		return ERR_PTR(-ENOMEM);
995 996 997
	if (map.m_flags & EXT4_MAP_NEW) {
		J_ASSERT(create != 0);
		J_ASSERT(handle != NULL);
998

999 1000 1001 1002 1003 1004 1005 1006 1007
		/*
		 * 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");
1008 1009 1010 1011 1012 1013
		err = ext4_journal_get_create_access(handle, bh);
		if (unlikely(err)) {
			unlock_buffer(bh);
			goto errout;
		}
		if (!buffer_uptodate(bh)) {
1014 1015
			memset(bh->b_data, 0, inode->i_sb->s_blocksize);
			set_buffer_uptodate(bh);
1016
		}
1017 1018 1019
		unlock_buffer(bh);
		BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
		err = ext4_handle_dirty_metadata(handle, inode, bh);
1020 1021 1022
		if (unlikely(err))
			goto errout;
	} else
1023 1024
		BUFFER_TRACE(bh, "not a new buffer");
	return bh;
1025 1026 1027
errout:
	brelse(bh);
	return ERR_PTR(err);
1028 1029
}

1030
struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
1031
			       ext4_lblk_t block, int map_flags)
1032
{
1033
	struct buffer_head *bh;
1034

1035
	bh = ext4_getblk(handle, inode, block, map_flags);
1036
	if (IS_ERR(bh))
1037
		return bh;
1038
	if (!bh || buffer_uptodate(bh))
1039
		return bh;
1040
	ll_rw_block(REQ_OP_READ, REQ_META | REQ_PRIO, 1, &bh);
1041 1042 1043 1044
	wait_on_buffer(bh);
	if (buffer_uptodate(bh))
		return bh;
	put_bh(bh);
1045
	return ERR_PTR(-EIO);
1046 1047
}

1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
/* 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;
}

1092 1093 1094 1095 1096 1097 1098
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))
1099 1100 1101 1102 1103 1104 1105
{
	struct buffer_head *bh;
	unsigned block_start, block_end;
	unsigned blocksize = head->b_size;
	int err, ret = 0;
	struct buffer_head *next;

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

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

1172 1173 1174 1175
#ifdef CONFIG_EXT4_FS_ENCRYPTION
static int ext4_block_write_begin(struct page *page, loff_t pos, unsigned len,
				  get_block_t *get_block)
{
1176
	unsigned from = pos & (PAGE_SIZE - 1);
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187
	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));
1188 1189
	BUG_ON(from > PAGE_SIZE);
	BUG_ON(to > PAGE_SIZE);
1190 1191 1192 1193 1194 1195
	BUG_ON(from > to);

	if (!page_has_buffers(page))
		create_empty_buffers(page, blocksize, 0);
	head = page_buffers(page);
	bbits = ilog2(blocksize);
1196
	block = (sector_t)page->index << (PAGE_SHIFT - bbits);
1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215

	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)) {
1216
				clean_bdev_bh_alias(bh);
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236
				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)) {
1237
			ll_rw_block(REQ_OP_READ, 0, 1, &bh);
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253
			*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)
1254
		err = fscrypt_decrypt_page(page->mapping->host, page,
1255
				PAGE_SIZE, 0, page->index);
1256 1257 1258 1259
	return err;
}
#endif

N
Nick Piggin 已提交
1260
static int ext4_write_begin(struct file *file, struct address_space *mapping,
1261 1262
			    loff_t pos, unsigned len, unsigned flags,
			    struct page **pagep, void **fsdata)
1263
{
1264
	struct inode *inode = mapping->host;
1265
	int ret, needed_blocks;
1266 1267
	handle_t *handle;
	int retries = 0;
1268
	struct page *page;
1269
	pgoff_t index;
1270
	unsigned from, to;
N
Nick Piggin 已提交
1271

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

1275
	trace_ext4_write_begin(inode, pos, len, flags);
1276 1277 1278 1279 1280
	/*
	 * 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;
1281 1282
	index = pos >> PAGE_SHIFT;
	from = pos & (PAGE_SIZE - 1);
1283
	to = from + len;
1284

1285 1286 1287 1288
	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)
1289 1290 1291
			return ret;
		if (ret == 1)
			return 0;
1292 1293
	}

1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307
	/*
	 * 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:
1308
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
1309
	if (IS_ERR(handle)) {
1310
		put_page(page);
1311
		return PTR_ERR(handle);
1312
	}
1313

1314 1315 1316 1317
	lock_page(page);
	if (page->mapping != mapping) {
		/* The page got truncated from under us */
		unlock_page(page);
1318
		put_page(page);
1319
		ext4_journal_stop(handle);
1320
		goto retry_grab;
1321
	}
1322 1323
	/* In case writeback began while the page was unlocked */
	wait_for_stable_page(page);
1324

1325 1326 1327
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	if (ext4_should_dioread_nolock(inode))
		ret = ext4_block_write_begin(page, pos, len,
1328
					     ext4_get_block_unwritten);
1329 1330 1331 1332
	else
		ret = ext4_block_write_begin(page, pos, len,
					     ext4_get_block);
#else
1333
	if (ext4_should_dioread_nolock(inode))
1334 1335
		ret = __block_write_begin(page, pos, len,
					  ext4_get_block_unwritten);
1336
	else
1337
		ret = __block_write_begin(page, pos, len, ext4_get_block);
1338
#endif
N
Nick Piggin 已提交
1339
	if (!ret && ext4_should_journal_data(inode)) {
1340 1341 1342
		ret = ext4_walk_page_buffers(handle, page_buffers(page),
					     from, to, NULL,
					     do_journal_get_write_access);
1343
	}
N
Nick Piggin 已提交
1344 1345

	if (ret) {
1346
		unlock_page(page);
1347
		/*
1348
		 * __block_write_begin may have instantiated a few blocks
1349 1350
		 * outside i_size.  Trim these off again. Don't need
		 * i_size_read because we hold i_mutex.
1351 1352 1353
		 *
		 * Add inode to orphan list in case we crash before
		 * truncate finishes
1354
		 */
1355
		if (pos + len > inode->i_size && ext4_can_truncate(inode))
1356 1357 1358 1359
			ext4_orphan_add(handle, inode);

		ext4_journal_stop(handle);
		if (pos + len > inode->i_size) {
1360
			ext4_truncate_failed_write(inode);
1361
			/*
1362
			 * If truncate failed early the inode might
1363 1364 1365 1366 1367 1368 1369
			 * 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 已提交
1370

1371 1372 1373
		if (ret == -ENOSPC &&
		    ext4_should_retry_alloc(inode->i_sb, &retries))
			goto retry_journal;
1374
		put_page(page);
1375 1376 1377
		return ret;
	}
	*pagep = page;
1378 1379 1380
	return ret;
}

N
Nick Piggin 已提交
1381 1382
/* For write_end() in data=journal mode */
static int write_end_fn(handle_t *handle, struct buffer_head *bh)
1383
{
1384
	int ret;
1385 1386 1387
	if (!buffer_mapped(bh) || buffer_freed(bh))
		return 0;
	set_buffer_uptodate(bh);
1388 1389 1390 1391
	ret = ext4_handle_dirty_metadata(handle, NULL, bh);
	clear_buffer_meta(bh);
	clear_buffer_prio(bh);
	return ret;
1392 1393
}

1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
/*
 * 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)
1405 1406
{
	handle_t *handle = ext4_journal_current_handle();
1407
	struct inode *inode = mapping->host;
1408
	loff_t old_size = inode->i_size;
1409 1410
	int ret = 0, ret2;
	int i_size_changed = 0;
1411
	int inline_data = ext4_has_inline_data(inode);
1412 1413

	trace_ext4_write_end(inode, pos, len, copied);
1414
	if (inline_data) {
1415 1416
		ret = ext4_write_inline_data_end(inode, pos, len,
						 copied, page);
1417 1418 1419
		if (ret < 0) {
			unlock_page(page);
			put_page(page);
1420
			goto errout;
1421
		}
1422 1423
		copied = ret;
	} else
1424 1425
		copied = block_write_end(file, mapping, pos,
					 len, copied, page, fsdata);
1426
	/*
1427
	 * it's important to update i_size while still holding page lock:
1428 1429
	 * page writeout could otherwise come in and zero beyond i_size.
	 */
1430
	i_size_changed = ext4_update_inode_size(inode, pos + copied);
1431
	unlock_page(page);
1432
	put_page(page);
1433

1434 1435
	if (old_size < pos)
		pagecache_isize_extended(inode, old_size, pos);
1436 1437 1438 1439 1440 1441
	/*
	 * 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.
	 */
1442
	if (i_size_changed || inline_data)
1443 1444
		ext4_mark_inode_dirty(handle, inode);

1445
	if (pos + len > inode->i_size && ext4_can_truncate(inode))
1446 1447 1448 1449 1450
		/* 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);
1451
errout:
1452
	ret2 = ext4_journal_stop(handle);
1453 1454
	if (!ret)
		ret = ret2;
N
Nick Piggin 已提交
1455

1456
	if (pos + len > inode->i_size) {
1457
		ext4_truncate_failed_write(inode);
1458
		/*
1459
		 * If truncate failed early the inode might still be
1460 1461 1462 1463 1464 1465 1466
		 * 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 已提交
1467
	return ret ? ret : copied;
1468 1469
}

1470 1471 1472 1473 1474
/*
 * 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.
 */
1475 1476 1477
static void ext4_journalled_zero_new_buffers(handle_t *handle,
					    struct page *page,
					    unsigned from, unsigned to)
1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493
{
	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);
1494
					write_end_fn(handle, bh);
1495 1496 1497 1498 1499 1500 1501 1502 1503
				}
				clear_buffer_new(bh);
			}
		}
		block_start = block_end;
		bh = bh->b_this_page;
	} while (bh != head);
}

N
Nick Piggin 已提交
1504
static int ext4_journalled_write_end(struct file *file,
1505 1506 1507
				     struct address_space *mapping,
				     loff_t pos, unsigned len, unsigned copied,
				     struct page *page, void *fsdata)
1508
{
1509
	handle_t *handle = ext4_journal_current_handle();
N
Nick Piggin 已提交
1510
	struct inode *inode = mapping->host;
1511
	loff_t old_size = inode->i_size;
1512 1513
	int ret = 0, ret2;
	int partial = 0;
N
Nick Piggin 已提交
1514
	unsigned from, to;
1515
	int size_changed = 0;
1516
	int inline_data = ext4_has_inline_data(inode);
1517

1518
	trace_ext4_journalled_write_end(inode, pos, len, copied);
1519
	from = pos & (PAGE_SIZE - 1);
N
Nick Piggin 已提交
1520 1521
	to = from + len;

1522 1523
	BUG_ON(!ext4_handle_valid(handle));

1524
	if (inline_data) {
1525 1526 1527 1528 1529 1530 1531 1532 1533
		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)) {
1534 1535 1536 1537 1538 1539
		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);
1540
		ret = ext4_walk_page_buffers(handle, page_buffers(page), from,
1541 1542
					     from + copied, &partial,
					     write_end_fn);
1543 1544 1545
		if (!partial)
			SetPageUptodate(page);
	}
1546
	size_changed = ext4_update_inode_size(inode, pos + copied);
1547
	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
1548
	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1549
	unlock_page(page);
1550
	put_page(page);
1551

1552 1553 1554
	if (old_size < pos)
		pagecache_isize_extended(inode, old_size, pos);

1555
	if (size_changed || inline_data) {
1556
		ret2 = ext4_mark_inode_dirty(handle, inode);
1557 1558 1559
		if (!ret)
			ret = ret2;
	}
N
Nick Piggin 已提交
1560

1561
	if (pos + len > inode->i_size && ext4_can_truncate(inode))
1562 1563 1564 1565 1566 1567
		/* 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);

1568
errout:
1569
	ret2 = ext4_journal_stop(handle);
1570 1571
	if (!ret)
		ret = ret2;
1572
	if (pos + len > inode->i_size) {
1573
		ext4_truncate_failed_write(inode);
1574
		/*
1575
		 * If truncate failed early the inode might still be
1576 1577 1578 1579 1580 1581
		 * 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 已提交
1582 1583

	return ret ? ret : copied;
1584
}
1585

1586
/*
1587
 * Reserve space for a single cluster
1588
 */
1589
static int ext4_da_reserve_space(struct inode *inode)
1590
{
1591
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1592
	struct ext4_inode_info *ei = EXT4_I(inode);
1593
	int ret;
1594 1595 1596 1597 1598 1599 1600 1601 1602

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

1604
	spin_lock(&ei->i_block_reservation_lock);
1605
	if (ext4_claim_free_clusters(sbi, 1, 0)) {
1606 1607
		spin_unlock(&ei->i_block_reservation_lock);
		dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1));
1608 1609
		return -ENOSPC;
	}
1610
	ei->i_reserved_data_blocks++;
1611
	trace_ext4_da_reserve_space(inode);
1612
	spin_unlock(&ei->i_block_reservation_lock);
1613

1614 1615 1616
	return 0;       /* success */
}

1617
void ext4_da_release_space(struct inode *inode, int to_free)
1618 1619
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1620
	struct ext4_inode_info *ei = EXT4_I(inode);
1621

1622 1623 1624
	if (!to_free)
		return;		/* Nothing to release, exit */

1625
	spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1626

L
Li Zefan 已提交
1627
	trace_ext4_da_release_space(inode, to_free);
1628
	if (unlikely(to_free > ei->i_reserved_data_blocks)) {
1629
		/*
1630 1631 1632 1633
		 * 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.
1634
		 */
1635
		ext4_warning(inode->i_sb, "ext4_da_release_space: "
1636
			 "ino %lu, to_free %d with only %d reserved "
1637
			 "data blocks", inode->i_ino, to_free,
1638 1639 1640
			 ei->i_reserved_data_blocks);
		WARN_ON(1);
		to_free = ei->i_reserved_data_blocks;
1641
	}
1642
	ei->i_reserved_data_blocks -= to_free;
1643

1644
	/* update fs dirty data blocks counter */
1645
	percpu_counter_sub(&sbi->s_dirtyclusters_counter, to_free);
1646 1647

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

1649
	dquot_release_reservation_block(inode, EXT4_C2B(sbi, to_free));
1650 1651 1652
}

static void ext4_da_page_release_reservation(struct page *page,
1653 1654
					     unsigned int offset,
					     unsigned int length)
1655
{
1656
	int contiguous_blks = 0;
1657 1658
	struct buffer_head *head, *bh;
	unsigned int curr_off = 0;
1659
	struct inode *inode = page->mapping->host;
1660
	unsigned int stop = offset + length;
1661
	ext4_fsblk_t lblk;
1662

1663
	BUG_ON(stop > PAGE_SIZE || stop < length);
1664

1665 1666 1667 1668 1669
	head = page_buffers(page);
	bh = head;
	do {
		unsigned int next_off = curr_off + bh->b_size;

1670 1671 1672
		if (next_off > stop)
			break;

1673
		if ((offset <= curr_off) && (buffer_delay(bh))) {
1674
			contiguous_blks++;
1675
			clear_buffer_delay(bh);
1676 1677
		} else if (contiguous_blks) {
			lblk = page->index <<
1678
			       (PAGE_SHIFT - inode->i_blkbits);
1679 1680
			lblk += (curr_off >> inode->i_blkbits) -
				contiguous_blks;
1681
			ext4_es_remove_blks(inode, lblk, contiguous_blks);
1682
			contiguous_blks = 0;
1683 1684 1685
		}
		curr_off = next_off;
	} while ((bh = bh->b_this_page) != head);
1686

1687
	if (contiguous_blks) {
1688
		lblk = page->index << (PAGE_SHIFT - inode->i_blkbits);
1689
		lblk += (curr_off >> inode->i_blkbits) - contiguous_blks;
1690
		ext4_es_remove_blks(inode, lblk, contiguous_blks);
1691 1692
	}

1693
}
1694

1695 1696 1697 1698
/*
 * Delayed allocation stuff
 */

J
Jan Kara 已提交
1699 1700 1701
struct mpage_da_data {
	struct inode *inode;
	struct writeback_control *wbc;
1702

J
Jan Kara 已提交
1703 1704 1705
	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 */
1706
	/*
J
Jan Kara 已提交
1707 1708 1709
	 * 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.
1710
	 */
J
Jan Kara 已提交
1711 1712
	struct ext4_map_blocks map;
	struct ext4_io_submit io_submit;	/* IO submission data */
1713
	unsigned int do_map:1;
J
Jan Kara 已提交
1714
};
1715

J
Jan Kara 已提交
1716 1717
static void mpage_release_unused_pages(struct mpage_da_data *mpd,
				       bool invalidate)
1718 1719 1720 1721 1722 1723
{
	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 已提交
1724 1725 1726 1727

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

1729 1730
	index = mpd->first_page;
	end   = mpd->next_page - 1;
J
Jan Kara 已提交
1731 1732
	if (invalidate) {
		ext4_lblk_t start, last;
1733 1734
		start = index << (PAGE_SHIFT - inode->i_blkbits);
		last = end << (PAGE_SHIFT - inode->i_blkbits);
J
Jan Kara 已提交
1735 1736
		ext4_es_remove_extent(inode, start, last - start + 1);
	}
1737

1738
	pagevec_init(&pvec);
1739
	while (index <= end) {
1740
		nr_pages = pagevec_lookup_range(&pvec, mapping, &index, end);
1741 1742 1743 1744
		if (nr_pages == 0)
			break;
		for (i = 0; i < nr_pages; i++) {
			struct page *page = pvec.pages[i];
1745

1746 1747
			BUG_ON(!PageLocked(page));
			BUG_ON(PageWriteback(page));
J
Jan Kara 已提交
1748
			if (invalidate) {
1749 1750
				if (page_mapped(page))
					clear_page_dirty_for_io(page);
1751
				block_invalidatepage(page, 0, PAGE_SIZE);
J
Jan Kara 已提交
1752 1753
				ClearPageUptodate(page);
			}
1754 1755
			unlock_page(page);
		}
1756
		pagevec_release(&pvec);
1757 1758 1759
	}
}

1760 1761 1762
static void ext4_print_free_blocks(struct inode *inode)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1763
	struct super_block *sb = inode->i_sb;
1764
	struct ext4_inode_info *ei = EXT4_I(inode);
1765 1766

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

1782
static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
1783
{
1784
	return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh);
1785 1786
}

1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 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 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
/*
 * ext4_insert_delayed_block - adds a delayed block to the extents status
 *                             tree, incrementing the reserved cluster/block
 *                             count or making a pending reservation
 *                             where needed
 *
 * @inode - file containing the newly added block
 * @lblk - logical block to be added
 *
 * Returns 0 on success, negative error code on failure.
 */
static int ext4_insert_delayed_block(struct inode *inode, ext4_lblk_t lblk)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	int ret;
	bool allocated = false;

	/*
	 * If the cluster containing lblk is shared with a delayed,
	 * written, or unwritten extent in a bigalloc file system, it's
	 * already been accounted for and does not need to be reserved.
	 * A pending reservation must be made for the cluster if it's
	 * shared with a written or unwritten extent and doesn't already
	 * have one.  Written and unwritten extents can be purged from the
	 * extents status tree if the system is under memory pressure, so
	 * it's necessary to examine the extent tree if a search of the
	 * extents status tree doesn't get a match.
	 */
	if (sbi->s_cluster_ratio == 1) {
		ret = ext4_da_reserve_space(inode);
		if (ret != 0)   /* ENOSPC */
			goto errout;
	} else {   /* bigalloc */
		if (!ext4_es_scan_clu(inode, &ext4_es_is_delonly, lblk)) {
			if (!ext4_es_scan_clu(inode,
					      &ext4_es_is_mapped, lblk)) {
				ret = ext4_clu_mapped(inode,
						      EXT4_B2C(sbi, lblk));
				if (ret < 0)
					goto errout;
				if (ret == 0) {
					ret = ext4_da_reserve_space(inode);
					if (ret != 0)   /* ENOSPC */
						goto errout;
				} else {
					allocated = true;
				}
			} else {
				allocated = true;
			}
		}
	}

	ret = ext4_es_insert_delayed_block(inode, lblk, allocated);

errout:
	return ret;
}

1846 1847 1848 1849 1850 1851 1852 1853 1854 1855
/*
 * 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)
{
1856
	struct extent_status es;
1857 1858
	int retval;
	sector_t invalid_block = ~((sector_t) 0xffff);
1859 1860 1861 1862 1863
#ifdef ES_AGGRESSIVE_TEST
	struct ext4_map_blocks orig_map;

	memcpy(&orig_map, map, sizeof(*map));
#endif
1864 1865 1866 1867 1868 1869 1870 1871

	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);
1872 1873 1874 1875 1876

	/* Lookup extent status tree firstly */
	if (ext4_es_lookup_extent(inode, iblock, &es)) {
		if (ext4_es_is_hole(&es)) {
			retval = 0;
1877
			down_read(&EXT4_I(inode)->i_data_sem);
1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903
			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);

1904 1905 1906
#ifdef ES_AGGRESSIVE_TEST
		ext4_map_blocks_es_recheck(NULL, inode, map, &orig_map, 0);
#endif
1907 1908 1909
		return retval;
	}

1910 1911 1912 1913
	/*
	 * Try to see if we can get the block without requesting a new
	 * file system block.
	 */
1914
	down_read(&EXT4_I(inode)->i_data_sem);
1915
	if (ext4_has_inline_data(inode))
1916
		retval = 0;
1917
	else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
1918
		retval = ext4_ext_map_blocks(NULL, inode, map, 0);
1919
	else
1920
		retval = ext4_ind_map_blocks(NULL, inode, map, 0);
1921

1922
add_delayed:
1923
	if (retval == 0) {
1924
		int ret;
1925

1926 1927 1928 1929 1930
		/*
		 * XXX: __block_prepare_write() unmaps passed block,
		 * is it OK?
		 */

1931 1932
		ret = ext4_insert_delayed_block(inode, map->m_lblk);
		if (ret != 0) {
1933
			retval = ret;
1934
			goto out_unlock;
1935
		}
1936

1937 1938 1939
		map_bh(bh, inode->i_sb, invalid_block);
		set_buffer_new(bh);
		set_buffer_delay(bh);
1940 1941
	} else if (retval > 0) {
		int ret;
1942
		unsigned int status;
1943

1944 1945 1946 1947 1948 1949
		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);
1950 1951
		}

1952 1953 1954 1955 1956 1957
		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;
1958 1959 1960 1961 1962 1963 1964 1965
	}

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

	return retval;
}

1966
/*
1967
 * This is a special get_block_t callback which is used by
1968 1969
 * ext4_da_write_begin().  It will either return mapped block or
 * reserve space for a single block.
1970 1971 1972 1973 1974 1975 1976
 *
 * 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.
1977
 */
1978 1979
int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int create)
1980
{
1981
	struct ext4_map_blocks map;
1982 1983 1984
	int ret = 0;

	BUG_ON(create == 0);
1985 1986 1987 1988
	BUG_ON(bh->b_size != inode->i_sb->s_blocksize);

	map.m_lblk = iblock;
	map.m_len = 1;
1989 1990 1991 1992 1993 1994

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

1999
	map_bh(bh, inode->i_sb, map.m_pblk);
J
Jan Kara 已提交
2000
	ext4_update_bh_state(bh, map.m_flags);
2001 2002 2003 2004 2005 2006 2007 2008 2009

	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);
2010
		set_buffer_mapped(bh);
2011 2012
	}
	return 0;
2013
}
2014

2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031
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;
2032
	struct buffer_head *page_bufs = NULL;
2033
	handle_t *handle = NULL;
2034 2035 2036
	int ret = 0, err = 0;
	int inline_data = ext4_has_inline_data(inode);
	struct buffer_head *inode_bh = NULL;
2037

2038
	ClearPageChecked(page);
2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054

	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);
	}
2055 2056 2057 2058 2059 2060
	/*
	 * 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);
2061 2062
	unlock_page(page);

2063 2064
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
				    ext4_writepage_trans_blocks(inode));
2065 2066
	if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
2067 2068
		put_page(page);
		goto out_no_pagelock;
2069
	}
2070 2071
	BUG_ON(!ext4_handle_valid(handle));

2072 2073 2074 2075 2076 2077 2078 2079 2080
	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;
	}

2081
	if (inline_data) {
2082
		ret = ext4_mark_inode_dirty(handle, inode);
2083 2084 2085 2086 2087 2088 2089
	} 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);
	}
2090 2091
	if (ret == 0)
		ret = err;
2092
	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
2093 2094 2095 2096
	err = ext4_journal_stop(handle);
	if (!ret)
		ret = err;

2097
	if (!ext4_has_inline_data(inode))
2098
		ext4_walk_page_buffers(NULL, page_bufs, 0, len,
2099
				       NULL, bput_one);
2100
	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
2101
out:
2102 2103
	unlock_page(page);
out_no_pagelock:
2104
	brelse(inode_bh);
2105 2106 2107
	return ret;
}

2108
/*
2109 2110 2111 2112
 * 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 已提交
2113
 * we are writing back data modified via mmap(), no one guarantees in which
2114 2115 2116 2117
 * 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.
 *
2118
 * This function can get called via...
2119
 *   - ext4_writepages after taking page lock (have journal handle)
2120
 *   - journal_submit_inode_data_buffers (no journal handle)
2121
 *   - shrink_page_list via the kswapd/direct reclaim (no journal handle)
2122
 *   - grab_page_cache when doing write_begin (have journal handle)
2123 2124 2125 2126 2127 2128 2129 2130 2131
 *
 * 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
2132
 * but other buffer_heads would be unmapped but dirty (dirty done via the
2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147
 * 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.
2148
 */
2149
static int ext4_writepage(struct page *page,
2150
			  struct writeback_control *wbc)
2151
{
2152
	int ret = 0;
2153
	loff_t size;
2154
	unsigned int len;
2155
	struct buffer_head *page_bufs = NULL;
2156
	struct inode *inode = page->mapping->host;
2157
	struct ext4_io_submit io_submit;
2158
	bool keep_towrite = false;
2159

2160 2161 2162 2163 2164 2165
	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) {
		ext4_invalidatepage(page, 0, PAGE_SIZE);
		unlock_page(page);
		return -EIO;
	}

L
Lukas Czerner 已提交
2166
	trace_ext4_writepage(page);
2167
	size = i_size_read(inode);
2168 2169
	if (page->index == size >> PAGE_SHIFT)
		len = size & ~PAGE_MASK;
2170
	else
2171
		len = PAGE_SIZE;
2172

T
Theodore Ts'o 已提交
2173 2174
	page_bufs = page_buffers(page);
	/*
2175 2176 2177 2178 2179
	 * 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.
2180 2181 2182 2183 2184 2185 2186 2187 2188 2189
	 *
	 * 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 已提交
2190
	 */
2191 2192
	if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL,
				   ext4_bh_delay_or_unwritten)) {
2193
		redirty_page_for_writepage(wbc, page);
2194
		if ((current->flags & PF_MEMALLOC) ||
2195
		    (inode->i_sb->s_blocksize == PAGE_SIZE)) {
2196 2197 2198 2199 2200 2201 2202
			/*
			 * 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);
2203 2204 2205
			unlock_page(page);
			return 0;
		}
2206
		keep_towrite = true;
T
Theodore Ts'o 已提交
2207
	}
2208

2209
	if (PageChecked(page) && ext4_should_journal_data(inode))
2210 2211 2212 2213
		/*
		 * It's mmapped pagecache.  Add buffers and journal it.  There
		 * doesn't seem much point in redirtying the page here.
		 */
2214
		return __ext4_journalled_writepage(page, len);
2215

J
Jan Kara 已提交
2216 2217 2218 2219 2220 2221 2222
	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;
	}
2223
	ret = ext4_bio_write_page(&io_submit, page, len, wbc, keep_towrite);
2224
	ext4_io_submit(&io_submit);
J
Jan Kara 已提交
2225 2226
	/* Drop io_end reference we got from init */
	ext4_put_io_end_defer(io_submit.io_end);
2227 2228 2229
	return ret;
}

2230 2231 2232
static int mpage_submit_page(struct mpage_da_data *mpd, struct page *page)
{
	int len;
2233
	loff_t size;
2234 2235 2236
	int err;

	BUG_ON(page->index != mpd->first_page);
2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251
	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);
2252 2253
	if (page->index == size >> PAGE_SHIFT)
		len = size & ~PAGE_MASK;
2254
	else
2255
		len = PAGE_SIZE;
2256
	err = ext4_bio_write_page(&mpd->io_submit, page, len, mpd->wbc, false);
2257 2258 2259 2260 2261 2262 2263
	if (!err)
		mpd->wbc->nr_to_write--;
	mpd->first_page++;

	return err;
}

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

2266
/*
2267 2268
 * mballoc gives us at most this number of blocks...
 * XXX: That seems to be only a limitation of ext4_mb_normalize_request().
2269
 * The rest of mballoc seems to handle chunks up to full group size.
2270
 */
2271
#define MAX_WRITEPAGES_EXTENT_LEN 2048
2272

J
Jan Kara 已提交
2273 2274 2275 2276 2277
/*
 * 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
2278
 * @bh - buffer head we want to add to the extent
J
Jan Kara 已提交
2279
 *
2280 2281 2282 2283 2284 2285
 * 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 已提交
2286
 */
2287 2288
static bool mpage_add_bh_to_extent(struct mpage_da_data *mpd, ext4_lblk_t lblk,
				   struct buffer_head *bh)
J
Jan Kara 已提交
2289 2290 2291
{
	struct ext4_map_blocks *map = &mpd->map;

2292 2293 2294 2295 2296 2297 2298 2299
	/* 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 已提交
2300 2301 2302

	/* First block in the extent? */
	if (map->m_len == 0) {
2303 2304 2305
		/* We cannot map unless handle is started... */
		if (!mpd->do_map)
			return false;
J
Jan Kara 已提交
2306 2307
		map->m_lblk = lblk;
		map->m_len = 1;
2308 2309
		map->m_flags = bh->b_state & BH_FLAGS;
		return true;
J
Jan Kara 已提交
2310 2311
	}

2312 2313 2314 2315
	/* Don't go larger than mballoc is willing to allocate */
	if (map->m_len >= MAX_WRITEPAGES_EXTENT_LEN)
		return false;

J
Jan Kara 已提交
2316 2317
	/* Can we merge the block to our big extent? */
	if (lblk == map->m_lblk + map->m_len &&
2318
	    (bh->b_state & BH_FLAGS) == map->m_flags) {
J
Jan Kara 已提交
2319
		map->m_len++;
2320
		return true;
J
Jan Kara 已提交
2321
	}
2322
	return false;
J
Jan Kara 已提交
2323 2324
}

2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344
/*
 * 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 已提交
2345 2346
{
	struct inode *inode = mpd->inode;
2347
	int err;
F
Fabian Frederick 已提交
2348
	ext4_lblk_t blocks = (i_size_read(inode) + i_blocksize(inode) - 1)
J
Jan Kara 已提交
2349 2350 2351 2352 2353
							>> inode->i_blkbits;

	do {
		BUG_ON(buffer_locked(bh));

2354
		if (lblk >= blocks || !mpage_add_bh_to_extent(mpd, lblk, bh)) {
J
Jan Kara 已提交
2355 2356
			/* Found extent to map? */
			if (mpd->map.m_len)
2357
				return 0;
2358 2359 2360
			/* Buffer needs mapping and handle is not started? */
			if (!mpd->do_map)
				return 0;
2361
			/* Everything mapped so far and we hit EOF */
2362
			break;
J
Jan Kara 已提交
2363 2364
		}
	} while (lblk++, (bh = bh->b_this_page) != head);
2365 2366 2367 2368 2369 2370 2371
	/* 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 已提交
2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
}

/*
 * 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,
2383
 * and mark buffers as uninit when we perform writes to unwritten extents
J
Jan Kara 已提交
2384 2385 2386 2387 2388 2389 2390 2391 2392 2393
 * 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;
2394
	int bpp_bits = PAGE_SHIFT - inode->i_blkbits;
J
Jan Kara 已提交
2395 2396 2397 2398 2399 2400 2401 2402 2403 2404
	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;

2405
	pagevec_init(&pvec);
J
Jan Kara 已提交
2406
	while (start <= end) {
2407
		nr_pages = pagevec_lookup_range(&pvec, inode->i_mapping,
2408
						&start, end);
J
Jan Kara 已提交
2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424
		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;
2425 2426 2427 2428 2429 2430 2431 2432 2433
					/*
					 * 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 已提交
2434
					pagevec_release(&pvec);
2435 2436 2437
					if (err > 0)
						err = 0;
					return err;
J
Jan Kara 已提交
2438 2439 2440 2441 2442 2443
				}
				if (buffer_delay(bh)) {
					clear_buffer_delay(bh);
					bh->b_blocknr = pblock++;
				}
				clear_buffer_unwritten(bh);
2444
			} while (lblk++, (bh = bh->b_this_page) != head);
J
Jan Kara 已提交
2445 2446 2447 2448 2449 2450

			/*
			 * FIXME: This is going to break if dioread_nolock
			 * supports blocksize < pagesize as we will try to
			 * convert potentially unmapped parts of inode.
			 */
2451
			mpd->io_submit.io_end->size += PAGE_SIZE;
J
Jan Kara 已提交
2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
			/* 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;
2472
	int err, dioread_nolock;
J
Jan Kara 已提交
2473 2474 2475 2476

	trace_ext4_da_write_pages_extent(inode, map);
	/*
	 * Call ext4_map_blocks() to allocate any delayed allocation blocks, or
2477
	 * to convert an unwritten extent to be initialized (in the case
J
Jan Kara 已提交
2478 2479 2480 2481 2482 2483 2484
	 * 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.
	 *
2485 2486 2487 2488
	 * 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 已提交
2489 2490
	 */
	get_blocks_flags = EXT4_GET_BLOCKS_CREATE |
2491 2492
			   EXT4_GET_BLOCKS_METADATA_NOFAIL |
			   EXT4_GET_BLOCKS_IO_SUBMIT;
2493 2494
	dioread_nolock = ext4_should_dioread_nolock(inode);
	if (dioread_nolock)
J
Jan Kara 已提交
2495 2496 2497 2498 2499 2500 2501
		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;
2502
	if (dioread_nolock && (map->m_flags & EXT4_MAP_UNWRITTEN)) {
2503 2504 2505 2506 2507
		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;
		}
2508
		mpd->io_submit.can_submit = 0;
J
Jan Kara 已提交
2509
		ext4_set_io_unwritten_flag(inode, mpd->io_submit.io_end);
2510
	}
J
Jan Kara 已提交
2511 2512 2513

	BUG_ON(map->m_len == 0);
	if (map->m_flags & EXT4_MAP_NEW) {
2514 2515
		clean_bdev_aliases(inode->i_sb->s_bdev, map->m_pblk,
				   map->m_len);
J
Jan Kara 已提交
2516 2517 2518 2519 2520 2521 2522 2523 2524 2525
	}
	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
2526 2527 2528
 * @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 已提交
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540
 *
 * 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,
2541 2542
				       struct mpage_da_data *mpd,
				       bool *give_up_on_write)
J
Jan Kara 已提交
2543 2544 2545 2546 2547
{
	struct inode *inode = mpd->inode;
	struct ext4_map_blocks *map = &mpd->map;
	int err;
	loff_t disksize;
2548
	int progress = 0;
J
Jan Kara 已提交
2549 2550 2551

	mpd->io_submit.io_end->offset =
				((loff_t)map->m_lblk) << inode->i_blkbits;
2552
	do {
J
Jan Kara 已提交
2553 2554 2555 2556
		err = mpage_map_one_extent(handle, mpd);
		if (err < 0) {
			struct super_block *sb = inode->i_sb;

2557 2558
			if (ext4_forced_shutdown(EXT4_SB(sb)) ||
			    EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED)
2559
				goto invalidate_dirty_pages;
J
Jan Kara 已提交
2560
			/*
2561 2562 2563
			 * 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 已提交
2564
			 */
2565
			if ((err == -ENOMEM) ||
2566 2567 2568
			    (err == -ENOSPC && ext4_count_free_clusters(sb))) {
				if (progress)
					goto update_disksize;
2569
				return err;
2570
			}
2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584
			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 已提交
2585 2586
			return err;
		}
2587
		progress = 1;
J
Jan Kara 已提交
2588 2589 2590 2591 2592 2593
		/*
		 * Update buffer state, submit mapped pages, and get us new
		 * extent to map
		 */
		err = mpage_map_and_submit_buffers(mpd);
		if (err < 0)
2594
			goto update_disksize;
2595
	} while (map->m_len);
J
Jan Kara 已提交
2596

2597
update_disksize:
2598 2599 2600 2601
	/*
	 * Update on-disk size after IO is submitted.  Races with
	 * truncate are avoided by checking i_size under i_data_sem.
	 */
2602
	disksize = ((loff_t)mpd->first_page) << PAGE_SHIFT;
J
Jan Kara 已提交
2603 2604
	if (disksize > EXT4_I(inode)->i_disksize) {
		int err2;
2605 2606 2607 2608 2609 2610 2611 2612 2613
		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);
2614
		err2 = ext4_mark_inode_dirty(handle, inode);
J
Jan Kara 已提交
2615 2616 2617 2618 2619 2620 2621 2622 2623 2624
		if (err2)
			ext4_error(inode->i_sb,
				   "Failed to mark inode %lu dirty",
				   inode->i_ino);
		if (!err)
			err = err2;
	}
	return err;
}

2625 2626
/*
 * Calculate the total number of credits to reserve for one writepages
2627
 * iteration. This is called from ext4_writepages(). We map an extent of
2628
 * up to MAX_WRITEPAGES_EXTENT_LEN blocks and then we go on and finish mapping
2629 2630 2631
 * the last partial page. So in total we can map MAX_WRITEPAGES_EXTENT_LEN +
 * bpp - 1 blocks in bpp different extents.
 */
2632 2633
static int ext4_da_writepages_trans_blocks(struct inode *inode)
{
2634
	int bpp = ext4_journal_blocks_per_page(inode);
2635

2636 2637
	return ext4_meta_trans_blocks(inode,
				MAX_WRITEPAGES_EXTENT_LEN + bpp - 1, bpp);
2638
}
2639

2640
/*
J
Jan Kara 已提交
2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656
 * 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.
2657
 */
J
Jan Kara 已提交
2658
static int mpage_prepare_extent_to_map(struct mpage_da_data *mpd)
2659
{
J
Jan Kara 已提交
2660 2661 2662
	struct address_space *mapping = mpd->inode->i_mapping;
	struct pagevec pvec;
	unsigned int nr_pages;
2663
	long left = mpd->wbc->nr_to_write;
J
Jan Kara 已提交
2664 2665 2666 2667 2668 2669 2670
	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;
2671

J
Jan Kara 已提交
2672
	if (mpd->wbc->sync_mode == WB_SYNC_ALL || mpd->wbc->tagged_writepages)
2673 2674 2675 2676
		tag = PAGECACHE_TAG_TOWRITE;
	else
		tag = PAGECACHE_TAG_DIRTY;

2677
	pagevec_init(&pvec);
J
Jan Kara 已提交
2678 2679
	mpd->map.m_len = 0;
	mpd->next_page = index;
2680
	while (index <= end) {
J
Jan Kara 已提交
2681
		nr_pages = pagevec_lookup_range_tag(&pvec, mapping, &index, end,
2682
				tag);
2683
		if (nr_pages == 0)
J
Jan Kara 已提交
2684
			goto out;
2685 2686 2687 2688

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

2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699
			/*
			 * 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 已提交
2700 2701 2702
			/* If we can't merge this page, we are done. */
			if (mpd->map.m_len > 0 && mpd->next_page != page->index)
				goto out;
2703

2704 2705
			lock_page(page);
			/*
J
Jan Kara 已提交
2706 2707 2708 2709 2710
			 * 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
2711
			 */
2712 2713
			if (!PageDirty(page) ||
			    (PageWriteback(page) &&
J
Jan Kara 已提交
2714
			     (mpd->wbc->sync_mode == WB_SYNC_NONE)) ||
2715
			    unlikely(page->mapping != mapping)) {
2716 2717 2718 2719
				unlock_page(page);
				continue;
			}

2720
			wait_on_page_writeback(page);
2721 2722
			BUG_ON(PageWriteback(page));

J
Jan Kara 已提交
2723
			if (mpd->map.m_len == 0)
2724 2725
				mpd->first_page = page->index;
			mpd->next_page = page->index + 1;
2726
			/* Add all dirty buffers to mpd */
J
Jan Kara 已提交
2727
			lblk = ((ext4_lblk_t)page->index) <<
2728
				(PAGE_SHIFT - blkbits);
2729
			head = page_buffers(page);
2730 2731
			err = mpage_process_page_bufs(mpd, head, head, lblk);
			if (err <= 0)
J
Jan Kara 已提交
2732
				goto out;
2733
			err = 0;
2734
			left--;
2735 2736 2737 2738
		}
		pagevec_release(&pvec);
		cond_resched();
	}
2739
	return 0;
2740 2741
out:
	pagevec_release(&pvec);
J
Jan Kara 已提交
2742
	return err;
2743 2744
}

2745 2746
static int ext4_writepages(struct address_space *mapping,
			   struct writeback_control *wbc)
2747
{
J
Jan Kara 已提交
2748 2749
	pgoff_t	writeback_index = 0;
	long nr_to_write = wbc->nr_to_write;
2750
	int range_whole = 0;
J
Jan Kara 已提交
2751
	int cycled = 1;
2752
	handle_t *handle = NULL;
2753
	struct mpage_da_data mpd;
2754
	struct inode *inode = mapping->host;
2755
	int needed_blocks, rsv_blocks = 0, ret = 0;
2756
	struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
J
Jan Kara 已提交
2757
	bool done;
S
Shaohua Li 已提交
2758
	struct blk_plug plug;
2759
	bool give_up_on_write = false;
2760

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

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

2767 2768 2769 2770 2771
	/*
	 * 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
	 */
2772
	if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2773
		goto out_writepages;
2774

2775
	if (ext4_should_journal_data(inode)) {
2776
		ret = generic_writepages(mapping, wbc);
2777
		goto out_writepages;
2778 2779
	}

2780 2781 2782 2783
	/*
	 * 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
2784
	 * EXT4_MF_FS_ABORTED instead of sb->s_flag's SB_RDONLY because
2785
	 * the latter could be true if the filesystem is mounted
2786
	 * read-only, and in that case, ext4_writepages should
2787 2788 2789
	 * *never* be called, so if that ever happens, we would want
	 * the stack trace.
	 */
2790 2791
	if (unlikely(ext4_forced_shutdown(EXT4_SB(mapping->host->i_sb)) ||
		     sbi->s_mount_flags & EXT4_MF_FS_ABORTED)) {
2792 2793 2794
		ret = -EROFS;
		goto out_writepages;
	}
2795

2796 2797
	if (ext4_should_dioread_nolock(inode)) {
		/*
2798
		 * We may need to convert up to one extent per block in
2799 2800
		 * the page and we may dirty the inode.
		 */
2801 2802
		rsv_blocks = 1 + ext4_chunk_trans_blocks(inode,
						PAGE_SIZE >> inode->i_blkbits);
2803 2804
	}

J
Jan Kara 已提交
2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822
	/*
	 * 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);
	}

2823 2824
	if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
		range_whole = 1;
2825

2826
	if (wbc->range_cyclic) {
J
Jan Kara 已提交
2827 2828
		writeback_index = mapping->writeback_index;
		if (writeback_index)
2829
			cycled = 0;
J
Jan Kara 已提交
2830 2831
		mpd.first_page = writeback_index;
		mpd.last_page = -1;
2832
	} else {
2833 2834
		mpd.first_page = wbc->range_start >> PAGE_SHIFT;
		mpd.last_page = wbc->range_end >> PAGE_SHIFT;
2835
	}
2836

J
Jan Kara 已提交
2837 2838 2839
	mpd.inode = inode;
	mpd.wbc = wbc;
	ext4_io_submit_init(&mpd.io_submit, wbc);
2840
retry:
2841
	if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
J
Jan Kara 已提交
2842 2843
		tag_pages_for_writeback(mapping, mpd.first_page, mpd.last_page);
	done = false;
S
Shaohua Li 已提交
2844
	blk_start_plug(&plug);
2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858

	/*
	 * 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);
2859 2860
	/* Unlock pages we didn't use */
	mpage_release_unused_pages(&mpd, false);
2861 2862 2863 2864 2865 2866 2867
	/* 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;
	if (ret < 0)
		goto unplug;

J
Jan Kara 已提交
2868 2869 2870 2871 2872 2873 2874
	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;
		}
2875 2876

		/*
J
Jan Kara 已提交
2877 2878 2879 2880 2881
		 * 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.
2882 2883
		 */
		BUG_ON(ext4_should_journal_data(inode));
2884
		needed_blocks = ext4_da_writepages_trans_blocks(inode);
2885

J
Jan Kara 已提交
2886
		/* start a new transaction */
2887 2888
		handle = ext4_journal_start_with_reserve(inode,
				EXT4_HT_WRITE_PAGE, needed_blocks, rsv_blocks);
2889 2890
		if (IS_ERR(handle)) {
			ret = PTR_ERR(handle);
2891
			ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
2892
			       "%ld pages, ino %lu; err %d", __func__,
2893
				wbc->nr_to_write, inode->i_ino, ret);
J
Jan Kara 已提交
2894 2895
			/* Release allocated io_end */
			ext4_put_io_end(mpd.io_submit.io_end);
2896
			mpd.io_submit.io_end = NULL;
J
Jan Kara 已提交
2897
			break;
2898
		}
2899
		mpd.do_map = 1;
2900

J
Jan Kara 已提交
2901 2902 2903 2904
		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)
2905 2906
				ret = mpage_map_and_submit_extent(handle, &mpd,
					&give_up_on_write);
J
Jan Kara 已提交
2907 2908 2909 2910 2911 2912 2913 2914 2915
			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;
			}
2916
		}
2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929
		/*
		 * 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;
2930
			mpd.do_map = 0;
2931
		}
J
Jan Kara 已提交
2932
		/* Unlock pages we didn't use */
2933
		mpage_release_unused_pages(&mpd, give_up_on_write);
2934 2935 2936
		/* Submit all prepared bio */
		if (!mpd.io_submit.can_submit)
			mpd.io_submit.can_submit = 1;
2937 2938
		ext4_io_submit(&mpd.io_submit);

2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950
		/*
		 * 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);
2951
		mpd.io_submit.io_end = NULL;
J
Jan Kara 已提交
2952 2953 2954 2955

		if (ret == -ENOSPC && sbi->s_journal) {
			/*
			 * Commit the transaction which would
2956 2957 2958
			 * free blocks released in the transaction
			 * and try again
			 */
2959
			jbd2_journal_force_commit_nested(sbi->s_journal);
2960
			ret = 0;
J
Jan Kara 已提交
2961 2962 2963 2964
			continue;
		}
		/* Fatal error - ENOMEM, EIO... */
		if (ret)
2965
			break;
2966
	}
2967
unplug:
S
Shaohua Li 已提交
2968
	blk_finish_plug(&plug);
2969
	if (!ret && !cycled && wbc->nr_to_write > 0) {
2970
		cycled = 1;
J
Jan Kara 已提交
2971 2972
		mpd.last_page = writeback_index - 1;
		mpd.first_page = 0;
2973 2974
		goto retry;
	}
2975 2976 2977 2978

	/* Update index */
	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
		/*
J
Jan Kara 已提交
2979
		 * Set the writeback_index so that range_cyclic
2980 2981
		 * mode will write it back later
		 */
J
Jan Kara 已提交
2982
		mapping->writeback_index = mpd.first_page;
2983

2984
out_writepages:
2985 2986
	trace_ext4_writepages_result(inode, wbc, ret,
				     nr_to_write - wbc->nr_to_write);
2987
	percpu_up_read(&sbi->s_journal_flag_rwsem);
2988
	return ret;
2989 2990
}

2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011
static int ext4_dax_writepages(struct address_space *mapping,
			       struct writeback_control *wbc)
{
	int ret;
	long nr_to_write = wbc->nr_to_write;
	struct inode *inode = mapping->host;
	struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);

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

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

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

3012 3013
static int ext4_nonda_switch(struct super_block *sb)
{
3014
	s64 free_clusters, dirty_clusters;
3015 3016 3017 3018 3019
	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
3020
	 * counters can get slightly wrong with percpu_counter_batch getting
3021 3022 3023 3024
	 * 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.
	 */
3025 3026 3027 3028
	free_clusters =
		percpu_counter_read_positive(&sbi->s_freeclusters_counter);
	dirty_clusters =
		percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);
3029 3030 3031
	/*
	 * Start pushing delalloc when 1/2 of free blocks are dirty.
	 */
3032
	if (dirty_clusters && (free_clusters < 2 * dirty_clusters))
3033
		try_to_writeback_inodes_sb(sb, WB_REASON_FS_FREE_SPACE);
3034

3035 3036
	if (2 * free_clusters < 3 * dirty_clusters ||
	    free_clusters < (dirty_clusters + EXT4_FREECLUSTERS_WATERMARK)) {
3037
		/*
3038 3039
		 * free block count is less than 150% of dirty blocks
		 * or free blocks is less than watermark
3040 3041 3042 3043 3044 3045
		 */
		return 1;
	}
	return 0;
}

3046 3047 3048
/* 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)
{
3049
	if (likely(ext4_has_feature_large_file(inode->i_sb)))
3050 3051 3052 3053 3054 3055 3056 3057 3058
		return 1;

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

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

3059
static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
3060 3061
			       loff_t pos, unsigned len, unsigned flags,
			       struct page **pagep, void **fsdata)
3062
{
3063
	int ret, retries = 0;
3064 3065 3066 3067 3068
	struct page *page;
	pgoff_t index;
	struct inode *inode = mapping->host;
	handle_t *handle;

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

3072
	index = pos >> PAGE_SHIFT;
3073

3074 3075
	if (ext4_nonda_switch(inode->i_sb) ||
	    S_ISLNK(inode->i_mode)) {
3076 3077 3078 3079 3080
		*fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
		return ext4_write_begin(file, mapping, pos,
					len, flags, pagep, fsdata);
	}
	*fsdata = (void *)0;
3081
	trace_ext4_da_write_begin(inode, pos, len, flags);
3082 3083 3084 3085 3086 3087

	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)
3088 3089 3090
			return ret;
		if (ret == 1)
			return 0;
3091 3092
	}

3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105
	/*
	 * 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);

3106 3107 3108 3109 3110 3111
	/*
	 * 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.
	 */
3112
retry_journal:
3113 3114
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
				ext4_da_write_credits(inode, pos, len));
3115
	if (IS_ERR(handle)) {
3116
		put_page(page);
3117
		return PTR_ERR(handle);
3118 3119
	}

3120 3121 3122 3123
	lock_page(page);
	if (page->mapping != mapping) {
		/* The page got truncated from under us */
		unlock_page(page);
3124
		put_page(page);
3125
		ext4_journal_stop(handle);
3126
		goto retry_grab;
3127
	}
3128
	/* In case writeback began while the page was unlocked */
3129
	wait_for_stable_page(page);
3130

3131 3132 3133 3134
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	ret = ext4_block_write_begin(page, pos, len,
				     ext4_da_get_block_prep);
#else
3135
	ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep);
3136
#endif
3137 3138 3139
	if (ret < 0) {
		unlock_page(page);
		ext4_journal_stop(handle);
3140 3141 3142 3143 3144 3145
		/*
		 * 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)
3146
			ext4_truncate_failed_write(inode);
3147 3148 3149 3150 3151

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

3152
		put_page(page);
3153
		return ret;
3154 3155
	}

3156
	*pagep = page;
3157 3158 3159
	return ret;
}

3160 3161 3162 3163 3164
/*
 * 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,
3165
					    unsigned long offset)
3166 3167 3168 3169 3170 3171 3172 3173 3174
{
	struct buffer_head *bh;
	struct inode *inode = page->mapping->host;
	unsigned int idx;
	int i;

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

3175
	for (i = 0; i < idx; i++)
3176 3177
		bh = bh->b_this_page;

3178
	if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
3179 3180 3181 3182
		return 0;
	return 1;
}

3183
static int ext4_da_write_end(struct file *file,
3184 3185 3186
			     struct address_space *mapping,
			     loff_t pos, unsigned len, unsigned copied,
			     struct page *page, void *fsdata)
3187 3188 3189 3190 3191
{
	struct inode *inode = mapping->host;
	int ret = 0, ret2;
	handle_t *handle = ext4_journal_current_handle();
	loff_t new_i_size;
3192
	unsigned long start, end;
3193 3194
	int write_mode = (int)(unsigned long)fsdata;

3195 3196 3197
	if (write_mode == FALL_BACK_TO_NONDELALLOC)
		return ext4_write_end(file, mapping, pos,
				      len, copied, page, fsdata);
3198

3199
	trace_ext4_da_write_end(inode, pos, len, copied);
3200
	start = pos & (PAGE_SIZE - 1);
3201
	end = start + copied - 1;
3202 3203 3204 3205 3206 3207 3208

	/*
	 * 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;
3209
	if (copied && new_i_size > EXT4_I(inode)->i_disksize) {
3210 3211
		if (ext4_has_inline_data(inode) ||
		    ext4_da_should_update_i_disksize(page, end)) {
3212
			ext4_update_i_disksize(inode, new_i_size);
3213 3214 3215 3216 3217
			/* 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);
3218
		}
3219
	}
3220 3221 3222 3223 3224 3225 3226 3227

	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,
3228
							page, fsdata);
3229

3230 3231 3232 3233 3234 3235 3236 3237 3238 3239
	copied = ret2;
	if (ret2 < 0)
		ret = ret2;
	ret2 = ext4_journal_stop(handle);
	if (!ret)
		ret = ret2;

	return ret ? ret : copied;
}

3240 3241
static void ext4_da_invalidatepage(struct page *page, unsigned int offset,
				   unsigned int length)
3242 3243 3244 3245 3246 3247 3248 3249
{
	/*
	 * Drop reserved blocks
	 */
	BUG_ON(!PageLocked(page));
	if (!page_has_buffers(page))
		goto out;

3250
	ext4_da_page_release_reservation(page, offset, length);
3251 3252

out:
3253
	ext4_invalidatepage(page, offset, length);
3254 3255 3256 3257

	return;
}

3258 3259 3260 3261 3262
/*
 * Force all delayed allocation blocks to be allocated for a given inode.
 */
int ext4_alloc_da_blocks(struct inode *inode)
{
3263 3264
	trace_ext4_alloc_da_blocks(inode);

3265
	if (!EXT4_I(inode)->i_reserved_data_blocks)
3266 3267 3268 3269 3270 3271 3272 3273
		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:
3274
	 *
3275
	 * ext4_writepages() ->
3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286
	 *    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
3287
	 * the pages by calling redirty_page_for_writepage() but that
3288 3289
	 * 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 已提交
3290
	 * simplifying them because we wouldn't actually intend to
3291 3292 3293
	 * 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.
3294
	 *
3295 3296 3297 3298 3299 3300
	 * 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);
}
3301

3302 3303 3304 3305 3306
/*
 * 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
3307
 * journal.  If somebody makes a swapfile on an ext4 data-journaling
3308 3309 3310 3311 3312 3313 3314 3315
 * 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.
 */
3316
static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
3317 3318 3319 3320 3321
{
	struct inode *inode = mapping->host;
	journal_t *journal;
	int err;

T
Tao Ma 已提交
3322 3323 3324 3325 3326 3327
	/*
	 * We can get here for an inline file via the FIBMAP ioctl
	 */
	if (ext4_has_inline_data(inode))
		return 0;

3328 3329 3330 3331 3332 3333 3334 3335 3336 3337
	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);
	}

3338 3339
	if (EXT4_JOURNAL(inode) &&
	    ext4_test_inode_state(inode, EXT4_STATE_JDATA)) {
3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350
		/*
		 * 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.)
		 *
3351
		 * NB. EXT4_STATE_JDATA is not set on files other than
3352 3353 3354 3355 3356 3357
		 * 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.
		 */

3358
		ext4_clear_inode_state(inode, EXT4_STATE_JDATA);
3359
		journal = EXT4_JOURNAL(inode);
3360 3361 3362
		jbd2_journal_lock_updates(journal);
		err = jbd2_journal_flush(journal);
		jbd2_journal_unlock_updates(journal);
3363 3364 3365 3366 3367

		if (err)
			return 0;
	}

3368
	return generic_block_bmap(mapping, block, ext4_get_block);
3369 3370
}

3371
static int ext4_readpage(struct file *file, struct page *page)
3372
{
T
Tao Ma 已提交
3373 3374 3375
	int ret = -EAGAIN;
	struct inode *inode = page->mapping->host;

3376
	trace_ext4_readpage(page);
T
Tao Ma 已提交
3377 3378 3379 3380 3381

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

	if (ret == -EAGAIN)
3382 3383
		return ext4_mpage_readpages(page->mapping, NULL, page, 1,
						false);
T
Tao Ma 已提交
3384 3385

	return ret;
3386 3387 3388
}

static int
3389
ext4_readpages(struct file *file, struct address_space *mapping,
3390 3391
		struct list_head *pages, unsigned nr_pages)
{
T
Tao Ma 已提交
3392 3393 3394 3395 3396 3397
	struct inode *inode = mapping->host;

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

3398
	return ext4_mpage_readpages(mapping, pages, NULL, nr_pages, true);
3399 3400
}

3401 3402
static void ext4_invalidatepage(struct page *page, unsigned int offset,
				unsigned int length)
3403
{
3404
	trace_ext4_invalidatepage(page, offset, length);
3405

3406 3407 3408
	/* No journalling happens on data buffers when this function is used */
	WARN_ON(page_has_buffers(page) && buffer_jbd(page_buffers(page)));

3409
	block_invalidatepage(page, offset, length);
3410 3411
}

3412
static int __ext4_journalled_invalidatepage(struct page *page,
3413 3414
					    unsigned int offset,
					    unsigned int length)
3415 3416 3417
{
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);

3418
	trace_ext4_journalled_invalidatepage(page, offset, length);
3419

3420 3421 3422
	/*
	 * If it's a full truncate we just forget about the pending dirtying
	 */
3423
	if (offset == 0 && length == PAGE_SIZE)
3424 3425
		ClearPageChecked(page);

3426
	return jbd2_journal_invalidatepage(journal, page, offset, length);
3427 3428 3429 3430
}

/* Wrapper for aops... */
static void ext4_journalled_invalidatepage(struct page *page,
3431 3432
					   unsigned int offset,
					   unsigned int length)
3433
{
3434
	WARN_ON(__ext4_journalled_invalidatepage(page, offset, length) < 0);
3435 3436
}

3437
static int ext4_releasepage(struct page *page, gfp_t wait)
3438
{
3439
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);
3440

3441 3442
	trace_ext4_releasepage(page);

3443 3444
	/* Page has dirty journalled data -> cannot release */
	if (PageChecked(page))
3445
		return 0;
3446 3447 3448 3449
	if (journal)
		return jbd2_journal_try_to_free_buffers(journal, page, wait);
	else
		return try_to_free_buffers(page);
3450 3451
}

3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464
static bool ext4_inode_datasync_dirty(struct inode *inode)
{
	journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;

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

3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509
static void ext4_set_iomap(struct inode *inode, struct iomap *iomap,
			   struct ext4_map_blocks *map, loff_t offset,
			   loff_t length)
{
	u8 blkbits = inode->i_blkbits;

	/*
	 * Writes that span EOF might trigger an I/O size update on completion,
	 * so consider them to be dirty for the purpose of O_DSYNC, even if
	 * there is no other metadata changes being made or are pending.
	 */
	iomap->flags = 0;
	if (ext4_inode_datasync_dirty(inode) ||
	    offset + length > i_size_read(inode))
		iomap->flags |= IOMAP_F_DIRTY;

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

	iomap->bdev = inode->i_sb->s_bdev;
	iomap->dax_dev = EXT4_SB(inode->i_sb)->s_daxdev;
	iomap->offset = (u64) map->m_lblk << blkbits;
	iomap->length = (u64) map->m_len << blkbits;

	/*
	 * Flags passed to ext4_map_blocks() for direct I/O writes can result
	 * in m_flags having both EXT4_MAP_MAPPED and EXT4_MAP_UNWRITTEN bits
	 * set. In order for any allocated unwritten extents to be converted
	 * into written extents correctly within the ->end_io() handler, we
	 * need to ensure that the iomap->type is set appropriately. Hence, the
	 * reason why we need to check whether the EXT4_MAP_UNWRITTEN bit has
	 * been set first.
	 */
	if (map->m_flags & EXT4_MAP_UNWRITTEN) {
		iomap->type = IOMAP_UNWRITTEN;
		iomap->addr = (u64) map->m_pblk << blkbits;
	} else if (map->m_flags & EXT4_MAP_MAPPED) {
		iomap->type = IOMAP_MAPPED;
		iomap->addr = (u64) map->m_pblk << blkbits;
	} else {
		iomap->type = IOMAP_HOLE;
		iomap->addr = IOMAP_NULL_ADDR;
	}
}

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 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566
static int ext4_iomap_alloc(struct inode *inode, struct ext4_map_blocks *map,
			    unsigned int flags)
{
	handle_t *handle;
	u8 blkbits = inode->i_blkbits;
	int ret, dio_credits, retries = 0;

	/*
	 * Trim the mapping request to the maximum value that we can map at
	 * once for direct I/O.
	 */
	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 don't get an unwritten extent, so
	 * in that case we have reserved enough credits. Or, the blocks are
	 * already allocated and unwritten. In that case, the extent conversion
	 * fits into 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)
		goto journal_stop;

	/*
	 * If we've allocated blocks beyond EOF, we need to ensure that they're
	 * truncated if we crash before updating the inode size metadata within
	 * ext4_iomap_end(). For faults, we don't need to do that (and cannot
	 * due to orphan list operations needing an inode_lock()). If we happen
	 * to instantiate blocks beyond EOF, it is because we race with a
	 * truncate operation, which already has added the inode onto the
	 * orphan list.
	 */
	if (!(flags & IOMAP_FAULT) && map->m_lblk + map->m_len >
	    (i_size_read(inode) + (1 << blkbits) - 1) >> blkbits) {
		int err;

		err = ext4_orphan_add(handle, inode);
		if (err < 0)
			ret = err;
	}

journal_stop:
	ext4_journal_stop(handle);
	if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
		goto retry;

	return ret;
}


3567 3568 3569 3570
static int ext4_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
			    unsigned flags, struct iomap *iomap)
{
	unsigned int blkbits = inode->i_blkbits;
3571
	unsigned long first_block, last_block;
3572
	struct ext4_map_blocks map;
3573
	bool delalloc = false;
3574 3575
	int ret;

3576 3577 3578 3579 3580
	if ((offset >> blkbits) > EXT4_MAX_LOGICAL_BLOCK)
		return -EINVAL;
	first_block = offset >> blkbits;
	last_block = min_t(loff_t, (offset + length - 1) >> blkbits,
			   EXT4_MAX_LOGICAL_BLOCK);
3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594

	if (flags & IOMAP_REPORT) {
		if (ext4_has_inline_data(inode)) {
			ret = ext4_inline_data_iomap(inode, iomap);
			if (ret != -EAGAIN) {
				if (ret == 0 && offset >= iomap->length)
					ret = -ENOENT;
				return ret;
			}
		}
	} else {
		if (WARN_ON_ONCE(ext4_has_inline_data(inode)))
			return -ERANGE;
	}
3595 3596 3597 3598

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

3599
	if (flags & IOMAP_REPORT) {
J
Jan Kara 已提交
3600
		ret = ext4_map_blocks(NULL, inode, &map, 0);
3601 3602 3603 3604 3605 3606 3607
		if (ret < 0)
			return ret;

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

3608 3609
			ext4_es_find_extent_range(inode, &ext4_es_is_delayed,
						  map.m_lblk, end, &es);
3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626

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

				if (es.es_lblk < map.m_lblk)
					offs = map.m_lblk - es.es_lblk;
				map.m_lblk = es.es_lblk + offs;
				map.m_len = es.es_len - offs;
				delalloc = true;
			}
		}
	} else if (flags & IOMAP_WRITE) {
3627
		ret = ext4_iomap_alloc(inode, &map, flags);
3628 3629
	} else {
		ret = ext4_map_blocks(NULL, inode, &map, 0);
J
Jan Kara 已提交
3630
	}
3631

3632 3633 3634
	if (ret < 0)
		return ret;

3635 3636 3637
	ext4_set_iomap(inode, iomap, &map, offset, length);
	if (delalloc && iomap->type == IOMAP_HOLE)
		iomap->type = IOMAP_DELALLOC;
3638

3639 3640 3641
	return 0;
}

J
Jan Kara 已提交
3642 3643 3644 3645 3646 3647 3648 3649
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;

3650
	if (!(flags & IOMAP_WRITE) || (flags & IOMAP_FAULT))
J
Jan Kara 已提交
3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693
		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;
}

3694
const struct iomap_ops ext4_iomap_ops = {
3695
	.iomap_begin		= ext4_iomap_begin,
J
Jan Kara 已提交
3696
	.iomap_end		= ext4_iomap_end,
3697 3698
};

3699
static int ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
3700
			    ssize_t size, void *private)
3701
{
3702
        ext4_io_end_t *io_end = private;
3703

J
Jan Kara 已提交
3704
	/* if not async direct IO just return */
3705
	if (!io_end)
3706
		return 0;
3707

3708
	ext_debug("ext4_end_io_dio(): io_end 0x%p "
3709
		  "for inode %lu, iocb 0x%p, offset %llu, size %zd\n",
3710
		  io_end, io_end->inode->i_ino, iocb, offset, size);
3711

3712 3713 3714 3715 3716 3717 3718 3719
	/*
	 * 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;
	}
3720 3721
	io_end->offset = offset;
	io_end->size = size;
3722
	ext4_put_io_end(io_end);
3723 3724

	return 0;
3725
}
3726

3727
/*
J
Jan Kara 已提交
3728 3729 3730
 * Handling of direct IO writes.
 *
 * For ext4 extent files, ext4 will do direct-io write even to holes,
3731 3732 3733
 * preallocated extents, and those write extend the file, no need to
 * fall back to buffered IO.
 *
3734
 * For holes, we fallocate those blocks, mark them as unwritten
3735
 * If those blocks were preallocated, we mark sure they are split, but
3736
 * still keep the range to write as unwritten.
3737
 *
3738
 * The unwritten extents will be converted to written when DIO is completed.
3739
 * For async direct IO, since the IO may still pending when return, we
L
Lucas De Marchi 已提交
3740
 * set up an end_io call back function, which will do the conversion
3741
 * when async direct IO completed.
3742 3743 3744 3745 3746 3747
 *
 * 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.
 *
 */
3748
static ssize_t ext4_direct_IO_write(struct kiocb *iocb, struct iov_iter *iter)
3749 3750 3751
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
3752
	struct ext4_inode_info *ei = EXT4_I(inode);
3753
	ssize_t ret;
3754
	loff_t offset = iocb->ki_pos;
3755
	size_t count = iov_iter_count(iter);
3756 3757 3758
	int overwrite = 0;
	get_block_t *get_block_func = NULL;
	int dio_flags = 0;
3759
	loff_t final_size = offset + count;
J
Jan Kara 已提交
3760 3761
	int orphan = 0;
	handle_t *handle;
3762

3763
	if (final_size > inode->i_size || final_size > ei->i_disksize) {
J
Jan Kara 已提交
3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775
		/* 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;
3776
		ext4_update_i_disksize(inode, inode->i_size);
J
Jan Kara 已提交
3777 3778
		ext4_journal_stop(handle);
	}
3779

3780
	BUG_ON(iocb->private == NULL);
3781

3782 3783 3784 3785 3786
	/*
	 * 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 已提交
3787
	inode_dio_begin(inode);
3788

3789 3790
	/* If we do a overwrite dio, i_mutex locking can be released */
	overwrite = *((int *)iocb->private);
3791

3792
	if (overwrite)
A
Al Viro 已提交
3793
		inode_unlock(inode);
3794

3795
	/*
J
Jan Kara 已提交
3796
	 * For extent mapped files we could direct write to holes and fallocate.
3797
	 *
3798 3799 3800
	 * 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.
3801
	 *
3802 3803
	 * As to previously fallocated extents, ext4 get_block will just simply
	 * mark the buffer mapped but still keep the extents unwritten.
3804
	 *
3805 3806 3807 3808
	 * 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.
3809 3810 3811 3812 3813 3814 3815
	 *
	 * 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;
3816
	if (overwrite)
3817
		get_block_func = ext4_dio_get_block_overwrite;
3818
	else if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) ||
F
Fabian Frederick 已提交
3819
		   round_down(offset, i_blocksize(inode)) >= inode->i_size) {
J
Jan Kara 已提交
3820 3821 3822
		get_block_func = ext4_dio_get_block;
		dio_flags = DIO_LOCKING | DIO_SKIP_HOLES;
	} else if (is_sync_kiocb(iocb)) {
3823 3824
		get_block_func = ext4_dio_get_block_unwritten_sync;
		dio_flags = DIO_LOCKING;
3825
	} else {
3826
		get_block_func = ext4_dio_get_block_unwritten_async;
3827 3828
		dio_flags = DIO_LOCKING;
	}
3829 3830 3831
	ret = __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
				   get_block_func, ext4_end_io_dio, NULL,
				   dio_flags);
3832

J
Jan Kara 已提交
3833
	if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
3834 3835 3836 3837 3838 3839
						EXT4_STATE_DIO_UNWRITTEN)) {
		int err;
		/*
		 * for non AIO case, since the IO is already
		 * completed, we could do the conversion right here
		 */
3840
		err = ext4_convert_unwritten_extents(NULL, inode,
3841 3842 3843 3844 3845
						     offset, ret);
		if (err < 0)
			ret = err;
		ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
	}
3846

J
Jan Kara 已提交
3847
	inode_dio_end(inode);
3848
	/* take i_mutex locking again if we do a ovewrite dio */
3849
	if (overwrite)
A
Al Viro 已提交
3850
		inode_lock(inode);
3851

J
Jan Kara 已提交
3852 3853 3854 3855 3856 3857 3858 3859 3860 3861
	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)) {
3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 3873
			/*
			 * We wrote the data but cannot extend
			 * i_size. Bail out. In async io case, we do
			 * not return error here because we have
			 * already submmitted the corresponding
			 * bio. Returning error here makes the caller
			 * think that this IO is done and failed
			 * resulting in race with bio's completion
			 * handler.
			 */
			if (!ret)
				ret = PTR_ERR(handle);
J
Jan Kara 已提交
3874 3875 3876 3877 3878 3879 3880 3881 3882
			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;
3883
			if (end > inode->i_size || end > ei->i_disksize) {
3884
				ext4_update_i_disksize(inode, end);
3885 3886
				if (end > inode->i_size)
					i_size_write(inode, end);
J
Jan Kara 已提交
3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904
				/*
				 * 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;
}

3905
static ssize_t ext4_direct_IO_read(struct kiocb *iocb, struct iov_iter *iter)
J
Jan Kara 已提交
3906
{
J
Jan Kara 已提交
3907 3908
	struct address_space *mapping = iocb->ki_filp->f_mapping;
	struct inode *inode = mapping->host;
3909
	size_t count = iov_iter_count(iter);
J
Jan Kara 已提交
3910 3911
	ssize_t ret;

J
Jan Kara 已提交
3912 3913 3914 3915 3916
	/*
	 * 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.
	 */
3917 3918 3919 3920 3921 3922 3923
	if (iocb->ki_flags & IOCB_NOWAIT) {
		if (!inode_trylock_shared(inode))
			return -EAGAIN;
	} else {
		inode_lock_shared(inode);
	}

3924
	ret = filemap_write_and_wait_range(mapping, iocb->ki_pos,
3925
					   iocb->ki_pos + count - 1);
3926 3927 3928 3929
	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 已提交
3930 3931
out_unlock:
	inode_unlock_shared(inode);
3932
	return ret;
3933 3934
}

3935
static ssize_t ext4_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
3936 3937 3938
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
3939
	size_t count = iov_iter_count(iter);
3940
	loff_t offset = iocb->ki_pos;
3941
	ssize_t ret;
3942

3943 3944 3945 3946 3947
#ifdef CONFIG_EXT4_FS_ENCRYPTION
	if (ext4_encrypted_inode(inode) && S_ISREG(inode->i_mode))
		return 0;
#endif

3948 3949 3950 3951 3952 3953
	/*
	 * If we are doing data journalling we don't support O_DIRECT
	 */
	if (ext4_should_journal_data(inode))
		return 0;

T
Tao Ma 已提交
3954 3955 3956 3957
	/* Let buffer I/O handle the inline data case. */
	if (ext4_has_inline_data(inode))
		return 0;

3958
	trace_ext4_direct_IO_enter(inode, offset, count, iov_iter_rw(iter));
J
Jan Kara 已提交
3959
	if (iov_iter_rw(iter) == READ)
3960
		ret = ext4_direct_IO_read(iocb, iter);
3961
	else
3962
		ret = ext4_direct_IO_write(iocb, iter);
3963
	trace_ext4_direct_IO_exit(inode, offset, count, iov_iter_rw(iter), ret);
3964
	return ret;
3965 3966
}

3967
/*
3968
 * Pages can be marked dirty completely asynchronously from ext4's journalling
3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979
 * 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.
 */
3980
static int ext4_journalled_set_page_dirty(struct page *page)
3981 3982 3983 3984 3985
{
	SetPageChecked(page);
	return __set_page_dirty_nobuffers(page);
}

3986 3987 3988 3989 3990 3991 3992
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);
}

3993
static const struct address_space_operations ext4_aops = {
3994 3995
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3996
	.writepage		= ext4_writepage,
3997
	.writepages		= ext4_writepages,
3998
	.write_begin		= ext4_write_begin,
3999
	.write_end		= ext4_write_end,
4000
	.set_page_dirty		= ext4_set_page_dirty,
4001 4002 4003 4004 4005 4006
	.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,
4007
	.error_remove_page	= generic_error_remove_page,
4008 4009
};

4010
static const struct address_space_operations ext4_journalled_aops = {
4011 4012
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
4013
	.writepage		= ext4_writepage,
4014
	.writepages		= ext4_writepages,
4015 4016 4017 4018
	.write_begin		= ext4_write_begin,
	.write_end		= ext4_journalled_write_end,
	.set_page_dirty		= ext4_journalled_set_page_dirty,
	.bmap			= ext4_bmap,
4019
	.invalidatepage		= ext4_journalled_invalidatepage,
4020
	.releasepage		= ext4_releasepage,
4021
	.direct_IO		= ext4_direct_IO,
4022
	.is_partially_uptodate  = block_is_partially_uptodate,
4023
	.error_remove_page	= generic_error_remove_page,
4024 4025
};

4026
static const struct address_space_operations ext4_da_aops = {
4027 4028
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
4029
	.writepage		= ext4_writepage,
4030
	.writepages		= ext4_writepages,
4031 4032
	.write_begin		= ext4_da_write_begin,
	.write_end		= ext4_da_write_end,
4033
	.set_page_dirty		= ext4_set_page_dirty,
4034 4035 4036 4037 4038 4039
	.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,
4040
	.error_remove_page	= generic_error_remove_page,
4041 4042
};

4043 4044 4045 4046
static const struct address_space_operations ext4_dax_aops = {
	.writepages		= ext4_dax_writepages,
	.direct_IO		= noop_direct_IO,
	.set_page_dirty		= noop_set_page_dirty,
4047
	.bmap			= ext4_bmap,
4048 4049 4050
	.invalidatepage		= noop_invalidatepage,
};

4051
void ext4_set_aops(struct inode *inode)
4052
{
4053 4054 4055 4056 4057
	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:
4058
		inode->i_mapping->a_ops = &ext4_journalled_aops;
4059
		return;
4060 4061 4062
	default:
		BUG();
	}
4063 4064 4065
	if (IS_DAX(inode))
		inode->i_mapping->a_ops = &ext4_dax_aops;
	else if (test_opt(inode->i_sb, DELALLOC))
4066 4067 4068
		inode->i_mapping->a_ops = &ext4_da_aops;
	else
		inode->i_mapping->a_ops = &ext4_aops;
4069 4070
}

R
Ross Zwisler 已提交
4071
static int __ext4_block_zero_page_range(handle_t *handle,
4072 4073
		struct address_space *mapping, loff_t from, loff_t length)
{
4074 4075
	ext4_fsblk_t index = from >> PAGE_SHIFT;
	unsigned offset = from & (PAGE_SIZE-1);
R
Ross Zwisler 已提交
4076
	unsigned blocksize, pos;
4077 4078 4079 4080 4081 4082
	ext4_lblk_t iblock;
	struct inode *inode = mapping->host;
	struct buffer_head *bh;
	struct page *page;
	int err = 0;

4083
	page = find_or_create_page(mapping, from >> PAGE_SHIFT,
4084
				   mapping_gfp_constraint(mapping, ~__GFP_FS));
4085 4086 4087 4088 4089
	if (!page)
		return -ENOMEM;

	blocksize = inode->i_sb->s_blocksize;

4090
	iblock = index << (PAGE_SHIFT - inode->i_sb->s_blocksize_bits);
4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122

	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;
4123
		ll_rw_block(REQ_OP_READ, 0, 1, &bh);
4124 4125 4126 4127
		wait_on_buffer(bh);
		/* Uhhuh. Read error. Complain and punt. */
		if (!buffer_uptodate(bh))
			goto unlock;
4128 4129 4130
		if (S_ISREG(inode->i_mode) &&
		    ext4_encrypted_inode(inode)) {
			/* We expect the key to be set. */
4131
			BUG_ON(!fscrypt_has_encryption_key(inode));
4132
			BUG_ON(blocksize != PAGE_SIZE);
4133
			WARN_ON_ONCE(fscrypt_decrypt_page(page->mapping->host,
4134
						page, PAGE_SIZE, 0, page->index));
4135
		}
4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147
	}
	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);
4148
	} else {
4149
		err = 0;
4150
		mark_buffer_dirty(bh);
J
Jan Kara 已提交
4151
		if (ext4_should_order_data(inode))
4152 4153
			err = ext4_jbd2_inode_add_write(handle, inode, from,
					length);
4154
	}
4155 4156 4157

unlock:
	unlock_page(page);
4158
	put_page(page);
4159 4160 4161
	return err;
}

R
Ross Zwisler 已提交
4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172
/*
 * 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;
4173
	unsigned offset = from & (PAGE_SIZE-1);
R
Ross Zwisler 已提交
4174 4175 4176 4177 4178 4179 4180 4181 4182 4183
	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;

4184 4185 4186 4187
	if (IS_DAX(inode)) {
		return iomap_zero_range(inode, from, length, NULL,
					&ext4_iomap_ops);
	}
R
Ross Zwisler 已提交
4188 4189 4190
	return __ext4_block_zero_page_range(handle, mapping, from, length);
}

4191 4192 4193 4194 4195 4196
/*
 * 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.
 */
4197
static int ext4_block_truncate_page(handle_t *handle,
4198 4199
		struct address_space *mapping, loff_t from)
{
4200
	unsigned offset = from & (PAGE_SIZE-1);
4201 4202 4203 4204
	unsigned length;
	unsigned blocksize;
	struct inode *inode = mapping->host;

4205 4206 4207 4208
	/* If we are processing an encrypted inode during orphan list handling */
	if (ext4_encrypted_inode(inode) && !fscrypt_has_encryption_key(inode))
		return 0;

4209 4210 4211 4212 4213 4214
	blocksize = inode->i_sb->s_blocksize;
	length = blocksize - (offset & (blocksize - 1));

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

4215 4216 4217 4218 4219
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;
4220
	unsigned partial_start, partial_end;
4221 4222 4223 4224
	ext4_fsblk_t start, end;
	loff_t byte_end = (lstart + length - 1);
	int err = 0;

4225 4226 4227
	partial_start = lstart & (sb->s_blocksize - 1);
	partial_end = byte_end & (sb->s_blocksize - 1);

4228 4229 4230 4231
	start = lstart >> sb->s_blocksize_bits;
	end = byte_end >> sb->s_blocksize_bits;

	/* Handle partial zero within the single block */
4232 4233
	if (start == end &&
	    (partial_start || (partial_end != sb->s_blocksize - 1))) {
4234 4235 4236 4237 4238
		err = ext4_block_zero_page_range(handle, mapping,
						 lstart, length);
		return err;
	}
	/* Handle partial zero out on the start of the range */
4239
	if (partial_start) {
4240 4241 4242 4243 4244 4245
		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 */
4246
	if (partial_end != sb->s_blocksize - 1)
4247
		err = ext4_block_zero_page_range(handle, mapping,
4248 4249
						 byte_end - partial_end,
						 partial_end + 1);
4250 4251 4252
	return err;
}

4253 4254 4255 4256 4257 4258 4259 4260 4261 4262 4263
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;
}

4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275
/*
 * 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 已提交
4276
	WARN_ON(!inode_is_locked(inode));
4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292
	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;
}

4293
static void ext4_wait_dax_page(struct ext4_inode_info *ei)
4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316
{
	up_write(&ei->i_mmap_sem);
	schedule();
	down_write(&ei->i_mmap_sem);
}

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

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

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

		error = ___wait_var_event(&page->_refcount,
				atomic_read(&page->_refcount) == 1,
				TASK_INTERRUPTIBLE, 0, 0,
4317 4318
				ext4_wait_dax_page(ei));
	} while (error == 0);
4319 4320 4321 4322

	return error;
}

4323
/*
4324
 * ext4_punch_hole: punches a hole in a file by releasing the blocks
4325 4326 4327 4328 4329 4330
 * associated with the given offset and length
 *
 * @inode:  File inode
 * @offset: The offset where the hole will begin
 * @len:    The length of the hole
 *
4331
 * Returns: 0 on success or negative on failure
4332 4333
 */

4334
int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length)
4335
{
T
Theodore Ts'o 已提交
4336 4337 4338
	struct super_block *sb = inode->i_sb;
	ext4_lblk_t first_block, stop_block;
	struct address_space *mapping = inode->i_mapping;
4339
	loff_t first_block_offset, last_block_offset;
T
Theodore Ts'o 已提交
4340 4341 4342 4343
	handle_t *handle;
	unsigned int credits;
	int ret = 0;

4344
	if (!S_ISREG(inode->i_mode))
4345
		return -EOPNOTSUPP;
4346

4347
	trace_ext4_punch_hole(inode, offset, length, 0);
4348

4349 4350 4351 4352 4353 4354 4355 4356 4357
	ext4_clear_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA);
	if (ext4_has_inline_data(inode)) {
		down_write(&EXT4_I(inode)->i_mmap_sem);
		ret = ext4_convert_inline_data(inode);
		up_write(&EXT4_I(inode)->i_mmap_sem);
		if (ret)
			return ret;
	}

T
Theodore Ts'o 已提交
4358 4359 4360 4361
	/*
	 * Write out all dirty pages to avoid race conditions
	 * Then release them.
	 */
4362
	if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
T
Theodore Ts'o 已提交
4363 4364 4365 4366 4367 4368
		ret = filemap_write_and_wait_range(mapping, offset,
						   offset + length - 1);
		if (ret)
			return ret;
	}

A
Al Viro 已提交
4369
	inode_lock(inode);
4370

T
Theodore Ts'o 已提交
4371 4372 4373 4374 4375 4376 4377 4378 4379 4380
	/* 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 +
4381
		   PAGE_SIZE - (inode->i_size & (PAGE_SIZE - 1)) -
T
Theodore Ts'o 已提交
4382 4383 4384
		   offset;
	}

4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396
	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;

	}

4397 4398 4399 4400 4401 4402 4403 4404
	/* Wait all existing dio workers, newcomers will block on i_mutex */
	inode_dio_wait(inode);

	/*
	 * Prevent page faults from reinstantiating pages we have released from
	 * page cache.
	 */
	down_write(&EXT4_I(inode)->i_mmap_sem);
4405 4406 4407 4408 4409

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

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

4413
	/* Now release the pages and zero block aligned part of pages*/
4414 4415 4416 4417
	if (last_block_offset > first_block_offset) {
		ret = ext4_update_disksize_before_punch(inode, offset, length);
		if (ret)
			goto out_dio;
4418 4419
		truncate_pagecache_range(inode, first_block_offset,
					 last_block_offset);
4420
	}
T
Theodore Ts'o 已提交
4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432

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

4433 4434 4435 4436
	ret = ext4_zero_partial_blocks(handle, inode, offset,
				       length);
	if (ret)
		goto out_stop;
T
Theodore Ts'o 已提交
4437 4438 4439 4440 4441

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

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

4445 4446
		down_write(&EXT4_I(inode)->i_data_sem);
		ext4_discard_preallocations(inode);
T
Theodore Ts'o 已提交
4447

4448 4449 4450 4451 4452 4453
		ret = ext4_es_remove_extent(inode, first_block,
					    stop_block - first_block);
		if (ret) {
			up_write(&EXT4_I(inode)->i_data_sem);
			goto out_stop;
		}
T
Theodore Ts'o 已提交
4454

4455 4456 4457 4458 4459 4460
		if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
			ret = ext4_ext_remove_space(inode, first_block,
						    stop_block - 1);
		else
			ret = ext4_ind_remove_space(handle, inode, first_block,
						    stop_block);
T
Theodore Ts'o 已提交
4461

4462 4463
		up_write(&EXT4_I(inode)->i_data_sem);
	}
T
Theodore Ts'o 已提交
4464 4465
	if (IS_SYNC(inode))
		ext4_handle_sync(handle);
4466

4467
	inode->i_mtime = inode->i_ctime = current_time(inode);
T
Theodore Ts'o 已提交
4468
	ext4_mark_inode_dirty(handle, inode);
4469 4470
	if (ret >= 0)
		ext4_update_inode_fsync_trans(handle, inode, 1);
T
Theodore Ts'o 已提交
4471 4472 4473
out_stop:
	ext4_journal_stop(handle);
out_dio:
4474
	up_write(&EXT4_I(inode)->i_mmap_sem);
T
Theodore Ts'o 已提交
4475
out_mutex:
A
Al Viro 已提交
4476
	inode_unlock(inode);
T
Theodore Ts'o 已提交
4477
	return ret;
4478 4479
}

4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504
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;
}

4505
/*
4506
 * ext4_truncate()
4507
 *
4508 4509
 * We block out ext4_get_block() block instantiations across the entire
 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
4510 4511
 * simultaneously on behalf of the same inode.
 *
4512
 * As we work through the truncate and commit bits of it to the journal there
4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525
 * 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
4526
 * i_disksize in this case).  After a crash, ext4_orphan_cleanup() will see
4527
 * that this inode's truncate did not complete and it will again call
4528 4529
 * 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
4530
 * that's fine - as long as they are linked from the inode, the post-crash
4531
 * ext4_truncate() run will find them and release them.
4532
 */
4533
int ext4_truncate(struct inode *inode)
4534
{
T
Theodore Ts'o 已提交
4535 4536
	struct ext4_inode_info *ei = EXT4_I(inode);
	unsigned int credits;
4537
	int err = 0;
T
Theodore Ts'o 已提交
4538 4539 4540
	handle_t *handle;
	struct address_space *mapping = inode->i_mapping;

4541 4542
	/*
	 * There is a possibility that we're either freeing the inode
M
Matthew Wilcox 已提交
4543
	 * or it's a completely new inode. In those cases we might not
4544 4545 4546
	 * have i_mutex locked because it's not necessary.
	 */
	if (!(inode->i_state & (I_NEW|I_FREEING)))
A
Al Viro 已提交
4547
		WARN_ON(!inode_is_locked(inode));
4548 4549
	trace_ext4_truncate_enter(inode);

4550
	if (!ext4_can_truncate(inode))
4551
		return 0;
4552

4553
	ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
4554

4555
	if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
4556
		ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
4557

4558 4559 4560
	if (ext4_has_inline_data(inode)) {
		int has_inline = 1;

4561 4562 4563
		err = ext4_inline_data_truncate(inode, &has_inline);
		if (err)
			return err;
4564
		if (has_inline)
4565
			return 0;
4566 4567
	}

4568 4569 4570
	/* 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)
4571
			return 0;
4572 4573
	}

T
Theodore Ts'o 已提交
4574 4575 4576 4577 4578 4579
	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);
4580 4581
	if (IS_ERR(handle))
		return PTR_ERR(handle);
T
Theodore Ts'o 已提交
4582

4583 4584
	if (inode->i_size & (inode->i_sb->s_blocksize - 1))
		ext4_block_truncate_page(handle, mapping, inode->i_size);
T
Theodore Ts'o 已提交
4585 4586 4587 4588 4589 4590 4591 4592 4593 4594

	/*
	 * 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.
	 */
4595 4596
	err = ext4_orphan_add(handle, inode);
	if (err)
T
Theodore Ts'o 已提交
4597 4598 4599 4600 4601 4602
		goto out_stop;

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

	ext4_discard_preallocations(inode);

4603
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
4604
		err = ext4_ext_truncate(handle, inode);
4605
	else
T
Theodore Ts'o 已提交
4606 4607 4608
		ext4_ind_truncate(handle, inode);

	up_write(&ei->i_data_sem);
4609 4610
	if (err)
		goto out_stop;
T
Theodore Ts'o 已提交
4611 4612 4613 4614 4615 4616 4617 4618 4619

	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
4620
	 * ext4_evict_inode(), and we allow that function to clean up the
T
Theodore Ts'o 已提交
4621 4622 4623 4624 4625
	 * orphan info for us.
	 */
	if (inode->i_nlink)
		ext4_orphan_del(handle, inode);

4626
	inode->i_mtime = inode->i_ctime = current_time(inode);
T
Theodore Ts'o 已提交
4627 4628
	ext4_mark_inode_dirty(handle, inode);
	ext4_journal_stop(handle);
4629

4630
	trace_ext4_truncate_exit(inode);
4631
	return err;
4632 4633 4634
}

/*
4635
 * ext4_get_inode_loc returns with an extra refcount against the inode's
4636 4637 4638 4639
 * 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.
 */
4640 4641
static int __ext4_get_inode_loc(struct inode *inode,
				struct ext4_iloc *iloc, int in_mem)
4642
{
4643 4644 4645 4646 4647 4648
	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 已提交
4649
	iloc->bh = NULL;
4650 4651
	if (inode->i_ino < EXT4_ROOT_INO ||
	    inode->i_ino > le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count))
4652
		return -EFSCORRUPTED;
4653

4654 4655 4656
	iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
	gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
	if (!gdp)
4657 4658
		return -EIO;

4659 4660 4661
	/*
	 * Figure out the offset within the block group inode table
	 */
4662
	inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
4663 4664 4665 4666 4667 4668
	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);
4669
	if (unlikely(!bh))
4670
		return -ENOMEM;
4671 4672
	if (!buffer_uptodate(bh)) {
		lock_buffer(bh);
4673 4674 4675 4676 4677 4678 4679 4680 4681 4682

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

4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695
		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;
4696
			int i, start;
4697

4698
			start = inode_offset & ~(inodes_per_block - 1);
4699

4700 4701
			/* Is the inode bitmap in cache? */
			bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
4702
			if (unlikely(!bitmap_bh))
4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713
				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;
			}
4714
			for (i = start; i < start + inodes_per_block; i++) {
4715 4716
				if (i == inode_offset)
					continue;
4717
				if (ext4_test_bit(i, bitmap_bh->b_data))
4718 4719 4720
					break;
			}
			brelse(bitmap_bh);
4721
			if (i == start + inodes_per_block) {
4722 4723 4724 4725 4726 4727 4728 4729 4730
				/* 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:
4731 4732 4733 4734 4735 4736 4737
		/*
		 * 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;
4738
			__u32 ra_blks = EXT4_SB(sb)->s_inode_readahead_blks;
4739 4740

			table = ext4_inode_table(sb, gdp);
T
Theodore Ts'o 已提交
4741
			/* s_inode_readahead_blks is always a power of 2 */
4742
			b = block & ~((ext4_fsblk_t) ra_blks - 1);
4743 4744
			if (table > b)
				b = table;
4745
			end = b + ra_blks;
4746
			num = EXT4_INODES_PER_GROUP(sb);
4747
			if (ext4_has_group_desc_csum(sb))
4748
				num -= ext4_itable_unused_count(sb, gdp);
4749 4750 4751 4752 4753 4754 4755
			table += num / inodes_per_block;
			if (end > table)
				end = table;
			while (b <= end)
				sb_breadahead(sb, b++);
		}

4756 4757 4758 4759 4760
		/*
		 * 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.
		 */
4761
		trace_ext4_load_inode(inode);
4762 4763
		get_bh(bh);
		bh->b_end_io = end_buffer_read_sync;
4764
		submit_bh(REQ_OP_READ, REQ_META | REQ_PRIO, bh);
4765 4766
		wait_on_buffer(bh);
		if (!buffer_uptodate(bh)) {
4767 4768
			EXT4_ERROR_INODE_BLOCK(inode, block,
					       "unable to read itable block");
4769 4770 4771 4772 4773 4774 4775 4776 4777
			brelse(bh);
			return -EIO;
		}
	}
has_buffer:
	iloc->bh = bh;
	return 0;
}

4778
int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
4779 4780
{
	/* We have all inode data except xattrs in memory here. */
4781
	return __ext4_get_inode_loc(inode, iloc,
4782
		!ext4_test_inode_state(inode, EXT4_STATE_XATTR));
4783 4784
}

R
Ross Zwisler 已提交
4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799
static bool ext4_should_use_dax(struct inode *inode)
{
	if (!test_opt(inode->i_sb, DAX))
		return false;
	if (!S_ISREG(inode->i_mode))
		return false;
	if (ext4_should_journal_data(inode))
		return false;
	if (ext4_has_inline_data(inode))
		return false;
	if (ext4_encrypted_inode(inode))
		return false;
	return true;
}

4800
void ext4_set_inode_flags(struct inode *inode)
4801
{
4802
	unsigned int flags = EXT4_I(inode)->i_flags;
4803
	unsigned int new_fl = 0;
4804

4805
	if (flags & EXT4_SYNC_FL)
4806
		new_fl |= S_SYNC;
4807
	if (flags & EXT4_APPEND_FL)
4808
		new_fl |= S_APPEND;
4809
	if (flags & EXT4_IMMUTABLE_FL)
4810
		new_fl |= S_IMMUTABLE;
4811
	if (flags & EXT4_NOATIME_FL)
4812
		new_fl |= S_NOATIME;
4813
	if (flags & EXT4_DIRSYNC_FL)
4814
		new_fl |= S_DIRSYNC;
R
Ross Zwisler 已提交
4815
	if (ext4_should_use_dax(inode))
R
Ross Zwisler 已提交
4816
		new_fl |= S_DAX;
4817 4818
	if (flags & EXT4_ENCRYPT_FL)
		new_fl |= S_ENCRYPTED;
4819
	inode_set_flags(inode, new_fl,
4820 4821
			S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC|S_DAX|
			S_ENCRYPTED);
4822 4823
}

4824
static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
4825
				  struct ext4_inode_info *ei)
4826 4827
{
	blkcnt_t i_blocks ;
A
Aneesh Kumar K.V 已提交
4828 4829
	struct inode *inode = &(ei->vfs_inode);
	struct super_block *sb = inode->i_sb;
4830

4831
	if (ext4_has_feature_huge_file(sb)) {
4832 4833 4834
		/* 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);
4835
		if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) {
A
Aneesh Kumar K.V 已提交
4836 4837 4838 4839 4840
			/* i_blocks represent file system block size */
			return i_blocks  << (inode->i_blkbits - 9);
		} else {
			return i_blocks;
		}
4841 4842 4843 4844
	} else {
		return le32_to_cpu(raw_inode->i_blocks_lo);
	}
}
4845

4846
static inline int ext4_iget_extra_inode(struct inode *inode,
4847 4848 4849 4850 4851
					 struct ext4_inode *raw_inode,
					 struct ext4_inode_info *ei)
{
	__le32 *magic = (void *)raw_inode +
			EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize;
4852

4853 4854 4855
	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)) {
4856
		ext4_set_inode_state(inode, EXT4_STATE_XATTR);
4857
		return ext4_find_inline_data_nolock(inode);
4858 4859
	} else
		EXT4_I(inode)->i_inline_off = 0;
4860
	return 0;
4861 4862
}

L
Li Xi 已提交
4863 4864
int ext4_get_projid(struct inode *inode, kprojid_t *projid)
{
K
Kaho Ng 已提交
4865
	if (!ext4_has_feature_project(inode->i_sb))
L
Li Xi 已提交
4866 4867 4868 4869 4870
		return -EOPNOTSUPP;
	*projid = EXT4_I(inode)->i_projid;
	return 0;
}

4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890
/*
 * ext4 has self-managed i_version for ea inodes, it stores the lower 32bit of
 * refcount in i_version, so use raw values if inode has EXT4_EA_INODE_FL flag
 * set.
 */
static inline void ext4_inode_set_iversion_queried(struct inode *inode, u64 val)
{
	if (unlikely(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL))
		inode_set_iversion_raw(inode, val);
	else
		inode_set_iversion_queried(inode, val);
}
static inline u64 ext4_inode_peek_iversion(const struct inode *inode)
{
	if (unlikely(EXT4_I(inode)->i_flags & EXT4_EA_INODE_FL))
		return inode_peek_iversion_raw(inode);
	else
		return inode_peek_iversion(inode);
}

4891 4892 4893
struct inode *__ext4_iget(struct super_block *sb, unsigned long ino,
			  ext4_iget_flags flags, const char *function,
			  unsigned int line)
4894
{
4895 4896
	struct ext4_iloc iloc;
	struct ext4_inode *raw_inode;
4897 4898
	struct ext4_inode_info *ei;
	struct inode *inode;
4899
	journal_t *journal = EXT4_SB(sb)->s_journal;
4900
	long ret;
4901
	loff_t size;
4902
	int block;
4903 4904
	uid_t i_uid;
	gid_t i_gid;
L
Li Xi 已提交
4905
	projid_t i_projid;
4906

4907
	if ((!(flags & EXT4_IGET_SPECIAL) &&
4908 4909 4910 4911 4912 4913 4914 4915 4916 4917 4918
	     (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO)) ||
	    (ino < EXT4_ROOT_INO) ||
	    (ino > le32_to_cpu(EXT4_SB(sb)->s_es->s_inodes_count))) {
		if (flags & EXT4_IGET_HANDLE)
			return ERR_PTR(-ESTALE);
		__ext4_error(sb, function, line,
			     "inode #%lu: comm %s: iget: illegal inode #",
			     ino, current->comm);
		return ERR_PTR(-EFSCORRUPTED);
	}

4919 4920 4921 4922 4923 4924 4925
	inode = iget_locked(sb, ino);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;

	ei = EXT4_I(inode);
4926
	iloc.bh = NULL;
4927

4928 4929
	ret = __ext4_get_inode_loc(inode, &iloc, 0);
	if (ret < 0)
4930
		goto bad_inode;
4931
	raw_inode = ext4_raw_inode(&iloc);
4932

4933
	if ((ino == EXT4_ROOT_INO) && (raw_inode->i_links_count == 0)) {
4934 4935
		ext4_error_inode(inode, function, line, 0,
				 "iget: root inode unallocated");
4936 4937 4938 4939
		ret = -EFSCORRUPTED;
		goto bad_inode;
	}

4940 4941 4942 4943 4944 4945
	if ((flags & EXT4_IGET_HANDLE) &&
	    (raw_inode->i_links_count == 0) && (raw_inode->i_mode == 0)) {
		ret = -ESTALE;
		goto bad_inode;
	}

4946 4947 4948
	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 >
4949 4950
			EXT4_INODE_SIZE(inode->i_sb) ||
		    (ei->i_extra_isize & 3)) {
4951 4952 4953
			ext4_error_inode(inode, function, line, 0,
					 "iget: bad extra_isize %u "
					 "(inode size %u)",
4954 4955
					 ei->i_extra_isize,
					 EXT4_INODE_SIZE(inode->i_sb));
4956
			ret = -EFSCORRUPTED;
4957 4958 4959 4960 4961 4962
			goto bad_inode;
		}
	} else
		ei->i_extra_isize = 0;

	/* Precompute checksum seed for inode metadata */
4963
	if (ext4_has_metadata_csum(sb)) {
4964 4965 4966 4967 4968 4969 4970 4971 4972 4973 4974
		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)) {
4975 4976
		ext4_error_inode(inode, function, line, 0,
				 "iget: checksum invalid");
4977
		ret = -EFSBADCRC;
4978 4979 4980
		goto bad_inode;
	}

4981
	inode->i_mode = le16_to_cpu(raw_inode->i_mode);
4982 4983
	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 已提交
4984
	if (ext4_has_feature_project(sb) &&
L
Li Xi 已提交
4985 4986 4987 4988 4989 4990
	    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;

4991
	if (!(test_opt(inode->i_sb, NO_UID32))) {
4992 4993
		i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
		i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
4994
	}
4995 4996
	i_uid_write(inode, i_uid);
	i_gid_write(inode, i_gid);
L
Li Xi 已提交
4997
	ei->i_projid = make_kprojid(&init_user_ns, i_projid);
M
Miklos Szeredi 已提交
4998
	set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
4999

5000
	ext4_clear_state_flags(ei);	/* Only relevant on 32-bit archs */
5001
	ei->i_inline_off = 0;
5002 5003 5004 5005 5006 5007 5008 5009
	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) {
5010 5011 5012
		if ((inode->i_mode == 0 ||
		     !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) &&
		    ino != EXT4_BOOT_LOADER_INO) {
5013
			/* this inode is deleted */
5014
			ret = -ESTALE;
5015 5016 5017 5018 5019
			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
5020 5021 5022
		 * the process of deleting those.
		 * OR it is the EXT4_BOOT_LOADER_INO which is
		 * not initialized on a new filesystem. */
5023 5024
	}
	ei->i_flags = le32_to_cpu(raw_inode->i_flags);
5025
	ext4_set_inode_flags(inode);
5026
	inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
5027
	ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
5028
	if (ext4_has_feature_64bit(sb))
B
Badari Pulavarty 已提交
5029 5030
		ei->i_file_acl |=
			((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
A
Artem Blagodarenko 已提交
5031
	inode->i_size = ext4_isize(sb, raw_inode);
5032
	if ((size = i_size_read(inode)) < 0) {
5033 5034
		ext4_error_inode(inode, function, line, 0,
				 "iget: bad i_size value: %lld", size);
5035 5036 5037
		ret = -EFSCORRUPTED;
		goto bad_inode;
	}
5038
	ei->i_disksize = inode->i_size;
5039 5040 5041
#ifdef CONFIG_QUOTA
	ei->i_reserved_quota = 0;
#endif
5042 5043
	inode->i_generation = le32_to_cpu(raw_inode->i_generation);
	ei->i_block_group = iloc.block_group;
5044
	ei->i_last_alloc_group = ~0;
5045 5046 5047 5048
	/*
	 * 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!
	 */
5049
	for (block = 0; block < EXT4_N_BLOCKS; block++)
5050 5051 5052
		ei->i_data[block] = raw_inode->i_block[block];
	INIT_LIST_HEAD(&ei->i_orphan);

5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063
	/*
	 * 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;

5064
		read_lock(&journal->j_state_lock);
5065 5066 5067 5068 5069 5070 5071 5072
		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;
5073
		read_unlock(&journal->j_state_lock);
5074 5075 5076 5077
		ei->i_sync_tid = tid;
		ei->i_datasync_tid = tid;
	}

5078
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
5079 5080
		if (ei->i_extra_isize == 0) {
			/* The extra space is currently unused. Use it. */
5081
			BUILD_BUG_ON(sizeof(struct ext4_inode) & 3);
5082 5083
			ei->i_extra_isize = sizeof(struct ext4_inode) -
					    EXT4_GOOD_OLD_INODE_SIZE;
5084
		} else {
5085 5086 5087
			ret = ext4_iget_extra_inode(inode, raw_inode, ei);
			if (ret)
				goto bad_inode;
5088
		}
5089
	}
5090

K
Kalpak Shah 已提交
5091 5092 5093 5094 5095
	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);

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

5099 5100
		if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
			if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
J
Jeff Layton 已提交
5101
				ivers |=
5102 5103
		    (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
		}
5104
		ext4_inode_set_iversion_queried(inode, ivers);
5105 5106
	}

5107
	ret = 0;
5108
	if (ei->i_file_acl &&
5109
	    !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
5110 5111
		ext4_error_inode(inode, function, line, 0,
				 "iget: bad extended attribute block %llu",
5112
				 ei->i_file_acl);
5113
		ret = -EFSCORRUPTED;
5114
		goto bad_inode;
5115
	} else if (!ext4_has_inline_data(inode)) {
5116 5117 5118 5119 5120
		/* validate the block references in the inode */
		if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
		   (S_ISLNK(inode->i_mode) &&
		    !ext4_inode_is_fast_symlink(inode))) {
			if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
5121
				ret = ext4_ext_check_inode(inode);
5122 5123
			else
				ret = ext4_ind_check_inode(inode);
5124
		}
5125
	}
5126
	if (ret)
5127
		goto bad_inode;
5128

5129
	if (S_ISREG(inode->i_mode)) {
5130
		inode->i_op = &ext4_file_inode_operations;
5131
		inode->i_fop = &ext4_file_operations;
5132
		ext4_set_aops(inode);
5133
	} else if (S_ISDIR(inode->i_mode)) {
5134 5135
		inode->i_op = &ext4_dir_inode_operations;
		inode->i_fop = &ext4_dir_operations;
5136
	} else if (S_ISLNK(inode->i_mode)) {
5137 5138
		/* VFS does not allow setting these so must be corruption */
		if (IS_APPEND(inode) || IS_IMMUTABLE(inode)) {
5139 5140 5141
			ext4_error_inode(inode, function, line, 0,
					 "iget: immutable or append flags "
					 "not allowed on symlinks");
5142 5143 5144
			ret = -EFSCORRUPTED;
			goto bad_inode;
		}
5145 5146 5147 5148
		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 已提交
5149
			inode->i_link = (char *)ei->i_data;
5150
			inode->i_op = &ext4_fast_symlink_inode_operations;
5151 5152 5153
			nd_terminate_link(ei->i_data, inode->i_size,
				sizeof(ei->i_data) - 1);
		} else {
5154 5155
			inode->i_op = &ext4_symlink_inode_operations;
			ext4_set_aops(inode);
5156
		}
5157
		inode_nohighmem(inode);
5158 5159
	} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
	      S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
5160
		inode->i_op = &ext4_special_inode_operations;
5161 5162 5163 5164 5165 5166
		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])));
5167 5168
	} else if (ino == EXT4_BOOT_LOADER_INO) {
		make_bad_inode(inode);
5169
	} else {
5170
		ret = -EFSCORRUPTED;
5171 5172
		ext4_error_inode(inode, function, line, 0,
				 "iget: bogus i_mode (%o)", inode->i_mode);
5173
		goto bad_inode;
5174
	}
5175
	brelse(iloc.bh);
T
Tahsin Erdogan 已提交
5176

5177 5178
	unlock_new_inode(inode);
	return inode;
5179 5180

bad_inode:
5181
	brelse(iloc.bh);
5182 5183
	iget_failed(inode);
	return ERR_PTR(ret);
5184 5185
}

5186 5187 5188 5189 5190 5191 5192 5193 5194 5195
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) {
		/*
5196
		 * i_blocks can be represented in a 32 bit variable
5197 5198
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
5199
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
5200
		raw_inode->i_blocks_high = 0;
5201
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
5202 5203
		return 0;
	}
5204
	if (!ext4_has_feature_huge_file(sb))
5205 5206 5207
		return -EFBIG;

	if (i_blocks <= 0xffffffffffffULL) {
5208 5209 5210 5211
		/*
		 * i_blocks can be represented in a 48 bit variable
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
5212
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
5213
		raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
5214
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
5215
	} else {
5216
		ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE);
A
Aneesh Kumar K.V 已提交
5217 5218 5219 5220
		/* 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);
5221
	}
5222
	return 0;
5223 5224
}

5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236
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 |
5237
			       I_DIRTY_INODE)) ||
5238 5239 5240 5241
	    ((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 |
5242
				I_DIRTY_INODE)) == 0) &&
5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273 5274
	    (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;
5275 5276 5277 5278 5279 5280
	/*
	 * 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;
5281 5282 5283 5284 5285 5286 5287 5288
	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);
	}
}

5289 5290 5291 5292 5293 5294 5295
/*
 * 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.
 */
5296
static int ext4_do_update_inode(handle_t *handle,
5297
				struct inode *inode,
5298
				struct ext4_iloc *iloc)
5299
{
5300 5301
	struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
	struct ext4_inode_info *ei = EXT4_I(inode);
5302
	struct buffer_head *bh = iloc->bh;
5303
	struct super_block *sb = inode->i_sb;
5304
	int err = 0, rc, block;
5305
	int need_datasync = 0, set_large_file = 0;
5306 5307
	uid_t i_uid;
	gid_t i_gid;
L
Li Xi 已提交
5308
	projid_t i_projid;
5309

5310 5311 5312
	spin_lock(&ei->i_raw_lock);

	/* For fields not tracked in the in-memory inode,
5313
	 * initialise them to zero for new inodes. */
5314
	if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
5315
		memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
5316 5317

	raw_inode->i_mode = cpu_to_le16(inode->i_mode);
5318 5319
	i_uid = i_uid_read(inode);
	i_gid = i_gid_read(inode);
L
Li Xi 已提交
5320
	i_projid = from_kprojid(&init_user_ns, ei->i_projid);
5321
	if (!(test_opt(inode->i_sb, NO_UID32))) {
5322 5323
		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));
5324 5325 5326 5327
/*
 * Fix up interoperability with old kernels. Otherwise, old inodes get
 * re-used with the upper 16 bits of the uid/gid intact
 */
5328 5329 5330 5331
		if (ei->i_dtime && list_empty(&ei->i_orphan)) {
			raw_inode->i_uid_high = 0;
			raw_inode->i_gid_high = 0;
		} else {
5332
			raw_inode->i_uid_high =
5333
				cpu_to_le16(high_16_bits(i_uid));
5334
			raw_inode->i_gid_high =
5335
				cpu_to_le16(high_16_bits(i_gid));
5336 5337
		}
	} else {
5338 5339
		raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid));
		raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(i_gid));
5340 5341 5342 5343
		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 已提交
5344 5345 5346 5347 5348 5349

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

5350 5351
	err = ext4_inode_blocks_set(handle, raw_inode, ei);
	if (err) {
5352
		spin_unlock(&ei->i_raw_lock);
5353
		goto out_brelse;
5354
	}
5355
	raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
5356
	raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF);
5357
	if (likely(!test_opt2(inode->i_sb, HURD_COMPAT)))
B
Badari Pulavarty 已提交
5358 5359
		raw_inode->i_file_acl_high =
			cpu_to_le16(ei->i_file_acl >> 32);
5360
	raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
A
Artem Blagodarenko 已提交
5361
	if (ei->i_disksize != ext4_isize(inode->i_sb, raw_inode)) {
5362 5363 5364
		ext4_isize_set(raw_inode, ei->i_disksize);
		need_datasync = 1;
	}
5365
	if (ei->i_disksize > 0x7fffffffULL) {
5366
		if (!ext4_has_feature_large_file(sb) ||
5367
				EXT4_SB(sb)->s_es->s_rev_level ==
5368 5369
		    cpu_to_le32(EXT4_GOOD_OLD_REV))
			set_large_file = 1;
5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382
	}
	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;
		}
5383
	} else if (!ext4_has_inline_data(inode)) {
5384 5385
		for (block = 0; block < EXT4_N_BLOCKS; block++)
			raw_inode->i_block[block] = ei->i_data[block];
5386
	}
5387

5388
	if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) {
5389
		u64 ivers = ext4_inode_peek_iversion(inode);
J
Jeff Layton 已提交
5390 5391

		raw_inode->i_disk_version = cpu_to_le32(ivers);
5392 5393 5394
		if (ei->i_extra_isize) {
			if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
				raw_inode->i_version_hi =
J
Jeff Layton 已提交
5395
					cpu_to_le32(ivers >> 32);
5396 5397 5398
			raw_inode->i_extra_isize =
				cpu_to_le16(ei->i_extra_isize);
		}
5399
	}
L
Li Xi 已提交
5400

K
Kaho Ng 已提交
5401
	BUG_ON(!ext4_has_feature_project(inode->i_sb) &&
L
Li Xi 已提交
5402 5403 5404 5405 5406 5407
	       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);

5408
	ext4_inode_csum_set(inode, raw_inode, ei);
5409
	spin_unlock(&ei->i_raw_lock);
5410
	if (inode->i_sb->s_flags & SB_LAZYTIME)
5411 5412
		ext4_update_other_inodes_time(inode->i_sb, inode->i_ino,
					      bh->b_data);
5413

5414
	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
5415
	rc = ext4_handle_dirty_metadata(handle, NULL, bh);
5416 5417
	if (!err)
		err = rc;
5418
	ext4_clear_inode_state(inode, EXT4_STATE_NEW);
5419
	if (set_large_file) {
5420
		BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get write access");
5421 5422 5423
		err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
		if (err)
			goto out_brelse;
5424
		ext4_set_feature_large_file(sb);
5425 5426 5427
		ext4_handle_sync(handle);
		err = ext4_handle_dirty_super(handle, sb);
	}
5428
	ext4_update_inode_fsync_trans(handle, inode, need_datasync);
5429
out_brelse:
5430
	brelse(bh);
5431
	ext4_std_error(inode->i_sb, err);
5432 5433 5434 5435
	return err;
}

/*
5436
 * ext4_write_inode()
5437 5438 5439
 *
 * We are called from a few places:
 *
5440
 * - Within generic_file_aio_write() -> generic_write_sync() for O_SYNC files.
5441
 *   Here, there will be no transaction running. We wait for any running
5442
 *   transaction to commit.
5443
 *
5444 5445
 * - Within flush work (sys_sync(), kupdate and such).
 *   We wait on commit, if told to.
5446
 *
5447 5448
 * - Within iput_final() -> write_inode_now()
 *   We wait on commit, if told to.
5449 5450 5451
 *
 * 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
5452 5453
 * ext4_mark_inode_dirty().  This is a correctness thing for WB_SYNC_ALL
 * writeback.
5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464
 *
 * 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;
 *
5465 5466 5467
 * 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.
5468
 */
5469
int ext4_write_inode(struct inode *inode, struct writeback_control *wbc)
5470
{
5471 5472
	int err;

5473 5474
	if (WARN_ON_ONCE(current->flags & PF_MEMALLOC) ||
	    sb_rdonly(inode->i_sb))
5475 5476
		return 0;

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

5480 5481 5482 5483 5484 5485
	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;
		}
5486

5487 5488 5489 5490 5491 5492
		/*
		 * 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)
5493 5494
			return 0;

5495 5496
		err = jbd2_complete_transaction(EXT4_SB(inode->i_sb)->s_journal,
						EXT4_I(inode)->i_sync_tid);
5497 5498
	} else {
		struct ext4_iloc iloc;
5499

5500
		err = __ext4_get_inode_loc(inode, &iloc, 0);
5501 5502
		if (err)
			return err;
5503 5504 5505 5506 5507
		/*
		 * 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)
5508 5509
			sync_dirty_buffer(iloc.bh);
		if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
5510 5511
			EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr,
					 "IO error syncing inode");
5512 5513
			err = -EIO;
		}
5514
		brelse(iloc.bh);
5515 5516
	}
	return err;
5517 5518
}

5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531
/*
 * 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;

5532
	offset = inode->i_size & (PAGE_SIZE - 1);
5533
	/*
5534 5535 5536 5537 5538 5539 5540
	 * If the page is fully truncated, we don't need to wait for any commit
	 * (and we even should not as __ext4_journalled_invalidatepage() may
	 * strip all buffers from the page but keep the page dirty which can then
	 * confuse e.g. concurrent ext4_writepage() seeing dirty page without
	 * buffers). Also we don't need to wait for any commit if all buffers in
	 * the page remain valid. This is most beneficial for the common case of
	 * blocksize == PAGESIZE.
5541
	 */
5542
	if (!offset || offset > (PAGE_SIZE - i_blocksize(inode)))
5543 5544 5545
		return;
	while (1) {
		page = find_lock_page(inode->i_mapping,
5546
				      inode->i_size >> PAGE_SHIFT);
5547 5548
		if (!page)
			return;
5549
		ret = __ext4_journalled_invalidatepage(page, offset,
5550
						PAGE_SIZE - offset);
5551
		unlock_page(page);
5552
		put_page(page);
5553 5554 5555 5556 5557 5558 5559 5560 5561 5562 5563 5564
		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);
	}
}

5565
/*
5566
 * ext4_setattr()
5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579
 *
 * 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.)
 *
5580 5581 5582 5583 5584 5585 5586 5587
 * 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.
5588
 */
5589
int ext4_setattr(struct dentry *dentry, struct iattr *attr)
5590
{
5591
	struct inode *inode = d_inode(dentry);
5592
	int error, rc = 0;
5593
	int orphan = 0;
5594 5595
	const unsigned int ia_valid = attr->ia_valid;

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

5599 5600 5601 5602 5603 5604 5605 5606
	if (unlikely(IS_IMMUTABLE(inode)))
		return -EPERM;

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

5607
	error = setattr_prepare(dentry, attr);
5608 5609 5610
	if (error)
		return error;

5611 5612 5613 5614
	error = fscrypt_prepare_setattr(dentry, attr);
	if (error)
		return error;

5615 5616 5617 5618 5619
	if (is_quota_modification(inode, attr)) {
		error = dquot_initialize(inode);
		if (error)
			return error;
	}
5620 5621
	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))) {
5622 5623 5624 5625
		handle_t *handle;

		/* (user+group)*(old+new) structure, inode write (sb,
		 * inode block, ? - but truncate inode update has it) */
5626 5627 5628
		handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
			(EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb) +
			 EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)) + 3);
5629 5630 5631 5632
		if (IS_ERR(handle)) {
			error = PTR_ERR(handle);
			goto err_out;
		}
5633 5634 5635 5636 5637

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

5641
		if (error) {
5642
			ext4_journal_stop(handle);
5643 5644 5645 5646 5647 5648 5649 5650
			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;
5651 5652
		error = ext4_mark_inode_dirty(handle, inode);
		ext4_journal_stop(handle);
5653 5654
	}

5655
	if (attr->ia_valid & ATTR_SIZE) {
5656
		handle_t *handle;
5657 5658
		loff_t oldsize = inode->i_size;
		int shrink = (attr->ia_size <= inode->i_size);
5659

5660
		if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
5661 5662
			struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

5663 5664
			if (attr->ia_size > sbi->s_bitmap_maxbytes)
				return -EFBIG;
5665
		}
5666 5667
		if (!S_ISREG(inode->i_mode))
			return -EINVAL;
C
Christoph Hellwig 已提交
5668 5669 5670 5671

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

5672
		if (ext4_should_order_data(inode) &&
5673
		    (attr->ia_size < inode->i_size)) {
5674
			error = ext4_begin_ordered_truncate(inode,
5675
							    attr->ia_size);
5676 5677 5678 5679
			if (error)
				goto err_out;
		}
		if (attr->ia_size != inode->i_size) {
5680 5681 5682 5683 5684
			handle = ext4_journal_start(inode, EXT4_HT_INODE, 3);
			if (IS_ERR(handle)) {
				error = PTR_ERR(handle);
				goto err_out;
			}
5685
			if (ext4_handle_valid(handle) && shrink) {
5686 5687 5688
				error = ext4_orphan_add(handle, inode);
				orphan = 1;
			}
E
Eryu Guan 已提交
5689 5690 5691 5692 5693
			/*
			 * Update c/mtime on truncate up, ext4_truncate() will
			 * update c/mtime in shrink case below
			 */
			if (!shrink) {
5694
				inode->i_mtime = current_time(inode);
E
Eryu Guan 已提交
5695 5696
				inode->i_ctime = inode->i_mtime;
			}
5697
			down_write(&EXT4_I(inode)->i_data_sem);
5698 5699 5700 5701
			EXT4_I(inode)->i_disksize = attr->ia_size;
			rc = ext4_mark_inode_dirty(handle, inode);
			if (!error)
				error = rc;
5702 5703 5704 5705 5706 5707 5708 5709
			/*
			 * 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);
5710 5711
			ext4_journal_stop(handle);
			if (error) {
5712
				if (orphan && inode->i_nlink)
5713
					ext4_orphan_del(NULL, inode);
5714 5715
				goto err_out;
			}
5716
		}
5717
		if (!shrink) {
5718
			pagecache_isize_extended(inode, oldsize, inode->i_size);
5719 5720 5721 5722 5723 5724
		} else {
			/*
			 * Blocks are going to be removed from the inode. Wait
			 * for dio in flight.
			 */
			inode_dio_wait(inode);
5725
		}
5726 5727
		if (orphan && ext4_should_journal_data(inode))
			ext4_wait_for_tail_page_commit(inode);
5728
		down_write(&EXT4_I(inode)->i_mmap_sem);
5729 5730 5731 5732 5733 5734 5735 5736

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

5737 5738 5739 5740
		/*
		 * Truncate pagecache after we've waited for commit
		 * in data=journal mode to make pages freeable.
		 */
R
Ross Zwisler 已提交
5741
		truncate_pagecache(inode, inode->i_size);
5742 5743 5744 5745 5746
		if (shrink) {
			rc = ext4_truncate(inode);
			if (rc)
				error = rc;
		}
5747
		up_write(&EXT4_I(inode)->i_mmap_sem);
5748
	}
5749

5750
	if (!error) {
C
Christoph Hellwig 已提交
5751 5752 5753 5754 5755 5756 5757 5758
		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.
	 */
5759
	if (orphan && inode->i_nlink)
5760
		ext4_orphan_del(NULL, inode);
5761

5762
	if (!error && (ia_valid & ATTR_MODE))
5763
		rc = posix_acl_chmod(inode, inode->i_mode);
5764 5765

err_out:
5766
	ext4_std_error(inode->i_sb, error);
5767 5768 5769 5770 5771
	if (!error)
		error = rc;
	return error;
}

5772 5773
int ext4_getattr(const struct path *path, struct kstat *stat,
		 u32 request_mask, unsigned int query_flags)
5774
{
D
David Howells 已提交
5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796
	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;
5797

5798 5799 5800 5801 5802 5803
	stat->attributes_mask |= (STATX_ATTR_APPEND |
				  STATX_ATTR_COMPRESSED |
				  STATX_ATTR_ENCRYPTED |
				  STATX_ATTR_IMMUTABLE |
				  STATX_ATTR_NODUMP);

5804
	generic_fillattr(inode, stat);
D
David Howells 已提交
5805 5806 5807 5808 5809 5810 5811 5812 5813 5814
	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);
5815

5816 5817 5818 5819
	/*
	 * 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 已提交
5820
	 * others don't incorrectly think the file is completely sparse.
5821 5822 5823 5824
	 */
	if (unlikely(ext4_has_inline_data(inode)))
		stat->blocks += (stat->size + 511) >> 9;

5825 5826 5827 5828 5829 5830 5831 5832 5833 5834
	/*
	 * 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.
	 */
5835
	delalloc_blocks = EXT4_C2B(EXT4_SB(inode->i_sb),
5836 5837
				   EXT4_I(inode)->i_reserved_data_blocks);
	stat->blocks += delalloc_blocks << (inode->i_sb->s_blocksize_bits - 9);
5838 5839
	return 0;
}
5840

5841 5842
static int ext4_index_trans_blocks(struct inode *inode, int lblocks,
				   int pextents)
5843
{
5844
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
5845 5846
		return ext4_ind_trans_blocks(inode, lblocks);
	return ext4_ext_index_trans_blocks(inode, pextents);
5847
}
5848

5849
/*
5850 5851 5852
 * 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
5853
 *
5854
 * If datablocks are discontiguous, they are possible to spread over
5855
 * different block groups too. If they are contiguous, with flexbg,
5856
 * they could still across block group boundary.
5857
 *
5858 5859
 * Also account for superblock, inode, quota and xattr blocks
 */
T
Tahsin Erdogan 已提交
5860
static int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
5861
				  int pextents)
5862
{
5863 5864
	ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
	int gdpblocks;
5865 5866 5867 5868
	int idxblocks;
	int ret = 0;

	/*
5869 5870
	 * How many index blocks need to touch to map @lblocks logical blocks
	 * to @pextents physical extents?
5871
	 */
5872
	idxblocks = ext4_index_trans_blocks(inode, lblocks, pextents);
5873 5874 5875 5876 5877 5878 5879

	ret = idxblocks;

	/*
	 * Now let's see how many group bitmaps and group descriptors need
	 * to account
	 */
5880
	groups = idxblocks + pextents;
5881
	gdpblocks = groups;
5882 5883
	if (groups > ngroups)
		groups = ngroups;
5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896
	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 已提交
5897
 * Calculate the total number of credits to reserve to fit
5898 5899
 * the modification of a single pages into a single transaction,
 * which may include multiple chunks of block allocations.
5900
 *
5901
 * This could be called via ext4_write_begin()
5902
 *
5903
 * We need to consider the worse case, when
5904
 * one new block per extent.
5905
 */
A
Alex Tomas 已提交
5906
int ext4_writepage_trans_blocks(struct inode *inode)
5907
{
5908
	int bpp = ext4_journal_blocks_per_page(inode);
5909 5910
	int ret;

5911
	ret = ext4_meta_trans_blocks(inode, bpp, bpp);
A
Alex Tomas 已提交
5912

5913
	/* Account for data blocks for journalled mode */
5914
	if (ext4_should_journal_data(inode))
5915
		ret += bpp;
5916 5917
	return ret;
}
5918 5919 5920 5921 5922

/*
 * Calculate the journal credits for a chunk of data modification.
 *
 * This is called from DIO, fallocate or whoever calling
5923
 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
5924 5925 5926 5927 5928 5929 5930 5931 5932
 *
 * 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);
}

5933
/*
5934
 * The caller must have previously called ext4_reserve_inode_write().
5935 5936
 * Give this, we know that the caller already has write access to iloc->bh.
 */
5937
int ext4_mark_iloc_dirty(handle_t *handle,
5938
			 struct inode *inode, struct ext4_iloc *iloc)
5939 5940 5941
{
	int err = 0;

5942 5943
	if (unlikely(ext4_forced_shutdown(EXT4_SB(inode->i_sb)))) {
		put_bh(iloc->bh);
5944
		return -EIO;
5945
	}
5946
	if (IS_I_VERSION(inode))
5947 5948
		inode_inc_iversion(inode);

5949 5950 5951
	/* the do_update_inode consumes one bh->b_count */
	get_bh(iloc->bh);

5952
	/* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
5953
	err = ext4_do_update_inode(handle, inode, iloc);
5954 5955 5956 5957 5958 5959 5960 5961 5962 5963
	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
5964 5965
ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
			 struct ext4_iloc *iloc)
5966
{
5967 5968
	int err;

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

5972 5973 5974 5975 5976 5977 5978
	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;
5979 5980
		}
	}
5981
	ext4_std_error(inode->i_sb, err);
5982 5983 5984
	return err;
}

5985 5986 5987 5988 5989 5990 5991
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;
5992 5993
	unsigned int inode_size = EXT4_INODE_SIZE(inode->i_sb);
	struct ext4_inode_info *ei = EXT4_I(inode);
5994
	int error;
5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007

	/* this was checked at iget time, but double check for good measure */
	if ((EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize > inode_size) ||
	    (ei->i_extra_isize & 3)) {
		EXT4_ERROR_INODE(inode, "bad extra_isize %u (inode size %u)",
				 ei->i_extra_isize,
				 EXT4_INODE_SIZE(inode->i_sb));
		return -EFSCORRUPTED;
	}
	if ((new_extra_isize < ei->i_extra_isize) ||
	    (new_extra_isize < 4) ||
	    (new_extra_isize > inode_size - EXT4_GOOD_OLD_INODE_SIZE))
		return -EINVAL;	/* Should never happen */
6008 6009 6010 6011 6012 6013 6014 6015 6016 6017 6018 6019 6020 6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031 6032 6033 6034 6035

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

6036 6037 6038 6039
/*
 * Expand an inode by new_extra_isize bytes.
 * Returns 0 on success or negative error number on failure.
 */
6040 6041 6042 6043
static int ext4_try_to_expand_extra_isize(struct inode *inode,
					  unsigned int new_extra_isize,
					  struct ext4_iloc iloc,
					  handle_t *handle)
6044
{
6045 6046
	int no_expand;
	int error;
6047

6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060 6061 6062 6063
	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;
6064

6065
	if (ext4_write_trylock_xattr(inode, &no_expand) == 0)
6066
		return -EBUSY;
6067

6068 6069 6070
	error = __ext4_expand_extra_isize(inode, new_extra_isize, &iloc,
					  handle, &no_expand);
	ext4_write_unlock_xattr(inode, &no_expand);
6071

6072 6073
	return error;
}
6074

6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085
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;
6086 6087
	}

6088 6089 6090 6091 6092 6093 6094 6095 6096 6097
	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);

6098
	BUFFER_TRACE(iloc->bh, "get_write_access");
6099
	error = ext4_journal_get_write_access(handle, iloc->bh);
6100
	if (error) {
6101 6102
		brelse(iloc->bh);
		goto out_stop;
6103
	}
6104

6105 6106 6107 6108 6109 6110 6111 6112 6113 6114
	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);
6115
	return error;
6116 6117
}

6118 6119 6120 6121 6122 6123 6124 6125 6126 6127 6128 6129 6130
/*
 * 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.
 */
6131
int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
6132
{
6133
	struct ext4_iloc iloc;
6134
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
6135
	int err;
6136 6137

	might_sleep();
6138
	trace_ext4_mark_inode_dirty(inode, _RET_IP_);
6139
	err = ext4_reserve_inode_write(handle, inode, &iloc);
6140 6141
	if (err)
		return err;
6142 6143 6144 6145 6146

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

6147
	return ext4_mark_iloc_dirty(handle, inode, &iloc);
6148 6149 6150
}

/*
6151
 * ext4_dirty_inode() is called from __mark_inode_dirty()
6152 6153 6154 6155 6156
 *
 * 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.
 *
6157
 * Also, dquot_alloc_block() will always dirty the inode when blocks
6158 6159 6160 6161 6162
 * 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.
6163 6164 6165 6166
 *
 * 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.
6167
 */
6168
void ext4_dirty_inode(struct inode *inode, int flags)
6169 6170 6171
{
	handle_t *handle;

6172 6173
	if (flags == I_DIRTY_TIME)
		return;
6174
	handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
6175 6176
	if (IS_ERR(handle))
		goto out;
6177 6178 6179

	ext4_mark_inode_dirty(handle, inode);

6180
	ext4_journal_stop(handle);
6181 6182 6183 6184 6185 6186 6187 6188
out:
	return;
}

#if 0
/*
 * Bind an inode's backing buffer_head into this transaction, to prevent
 * it from being flushed to disk early.  Unlike
6189
 * ext4_reserve_inode_write, this leaves behind no bh reference and
6190 6191 6192
 * returns no iloc structure, so the caller needs to repeat the iloc
 * lookup to mark the inode dirty later.
 */
6193
static int ext4_pin_inode(handle_t *handle, struct inode *inode)
6194
{
6195
	struct ext4_iloc iloc;
6196 6197 6198

	int err = 0;
	if (handle) {
6199
		err = ext4_get_inode_loc(inode, &iloc);
6200 6201
		if (!err) {
			BUFFER_TRACE(iloc.bh, "get_write_access");
6202
			err = jbd2_journal_get_write_access(handle, iloc.bh);
6203
			if (!err)
6204
				err = ext4_handle_dirty_metadata(handle,
6205
								 NULL,
6206
								 iloc.bh);
6207 6208 6209
			brelse(iloc.bh);
		}
	}
6210
	ext4_std_error(inode->i_sb, err);
6211 6212 6213 6214
	return err;
}
#endif

6215
int ext4_change_inode_journal_flag(struct inode *inode, int val)
6216 6217 6218 6219
{
	journal_t *journal;
	handle_t *handle;
	int err;
6220
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
6221 6222 6223 6224 6225 6226 6227 6228 6229 6230 6231

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

6232
	journal = EXT4_JOURNAL(inode);
6233 6234
	if (!journal)
		return 0;
6235
	if (is_journal_aborted(journal))
6236 6237
		return -EROFS;

6238 6239 6240
	/* Wait for all existing dio workers */
	inode_dio_wait(inode);

6241 6242 6243 6244 6245 6246 6247 6248 6249 6250 6251 6252 6253 6254 6255 6256 6257
	/*
	 * Before flushing the journal and switching inode's aops, we have
	 * to flush all dirty data the inode has. There can be outstanding
	 * delayed allocations, there can be unwritten extents created by
	 * fallocate or buffered writes in dioread_nolock mode covered by
	 * dirty data which can be converted only after flushing the dirty
	 * data (and journalled aops don't know how to handle these cases).
	 */
	if (val) {
		down_write(&EXT4_I(inode)->i_mmap_sem);
		err = filemap_write_and_wait(inode->i_mapping);
		if (err < 0) {
			up_write(&EXT4_I(inode)->i_mmap_sem);
			return err;
		}
	}

6258
	percpu_down_write(&sbi->s_journal_flag_rwsem);
6259
	jbd2_journal_lock_updates(journal);
6260 6261 6262 6263 6264 6265 6266 6267 6268 6269

	/*
	 * 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)
6270
		ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
6271
	else {
6272 6273 6274
		err = jbd2_journal_flush(journal);
		if (err < 0) {
			jbd2_journal_unlock_updates(journal);
6275
			percpu_up_write(&sbi->s_journal_flag_rwsem);
6276 6277
			return err;
		}
6278
		ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
6279
	}
6280
	ext4_set_aops(inode);
6281

6282
	jbd2_journal_unlock_updates(journal);
6283 6284
	percpu_up_write(&sbi->s_journal_flag_rwsem);

6285 6286
	if (val)
		up_write(&EXT4_I(inode)->i_mmap_sem);
6287 6288 6289

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

6290
	handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
6291 6292 6293
	if (IS_ERR(handle))
		return PTR_ERR(handle);

6294
	err = ext4_mark_inode_dirty(handle, inode);
6295
	ext4_handle_sync(handle);
6296 6297
	ext4_journal_stop(handle);
	ext4_std_error(inode->i_sb, err);
6298 6299 6300

	return err;
}
6301 6302 6303 6304 6305 6306

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

6307
int ext4_page_mkwrite(struct vm_fault *vmf)
6308
{
6309
	struct vm_area_struct *vma = vmf->vma;
6310
	struct page *page = vmf->page;
6311 6312
	loff_t size;
	unsigned long len;
6313
	int ret;
6314
	struct file *file = vma->vm_file;
A
Al Viro 已提交
6315
	struct inode *inode = file_inode(file);
6316
	struct address_space *mapping = inode->i_mapping;
6317 6318 6319
	handle_t *handle;
	get_block_t *get_block;
	int retries = 0;
6320

6321 6322 6323
	if (unlikely(IS_IMMUTABLE(inode)))
		return VM_FAULT_SIGBUS;

6324
	sb_start_pagefault(inode->i_sb);
6325
	file_update_time(vma->vm_file);
6326 6327

	down_read(&EXT4_I(inode)->i_mmap_sem);
6328 6329 6330 6331 6332

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

6333 6334 6335 6336 6337
	/* Delalloc case is easy... */
	if (test_opt(inode->i_sb, DELALLOC) &&
	    !ext4_should_journal_data(inode) &&
	    !ext4_nonda_switch(inode->i_sb)) {
		do {
6338
			ret = block_page_mkwrite(vma, vmf,
6339 6340 6341 6342
						   ext4_da_get_block_prep);
		} while (ret == -ENOSPC &&
		       ext4_should_retry_alloc(inode->i_sb, &retries));
		goto out_ret;
6343
	}
6344 6345

	lock_page(page);
6346 6347 6348 6349 6350 6351
	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;
6352
	}
6353

6354 6355
	if (page->index == size >> PAGE_SHIFT)
		len = size & ~PAGE_MASK;
6356
	else
6357
		len = PAGE_SIZE;
6358
	/*
6359 6360
	 * 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
6361
	 */
6362
	if (page_has_buffers(page)) {
6363 6364 6365
		if (!ext4_walk_page_buffers(NULL, page_buffers(page),
					    0, len, NULL,
					    ext4_bh_unmapped)) {
6366
			/* Wait so that we don't change page under IO */
6367
			wait_for_stable_page(page);
6368 6369
			ret = VM_FAULT_LOCKED;
			goto out;
6370
		}
6371
	}
6372
	unlock_page(page);
6373 6374
	/* OK, we need to fill the hole... */
	if (ext4_should_dioread_nolock(inode))
6375
		get_block = ext4_get_block_unwritten;
6376 6377 6378
	else
		get_block = ext4_get_block;
retry_alloc:
6379 6380
	handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
				    ext4_writepage_trans_blocks(inode));
6381
	if (IS_ERR(handle)) {
6382
		ret = VM_FAULT_SIGBUS;
6383 6384
		goto out;
	}
6385
	ret = block_page_mkwrite(vma, vmf, get_block);
6386
	if (!ret && ext4_should_journal_data(inode)) {
6387
		if (ext4_walk_page_buffers(handle, page_buffers(page), 0,
6388
			  PAGE_SIZE, NULL, do_journal_get_write_access)) {
6389 6390
			unlock_page(page);
			ret = VM_FAULT_SIGBUS;
6391
			ext4_journal_stop(handle);
6392 6393 6394 6395 6396 6397 6398 6399 6400 6401
			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:
6402
	up_read(&EXT4_I(inode)->i_mmap_sem);
6403
	sb_end_pagefault(inode->i_sb);
6404 6405
	return ret;
}
6406

6407
int ext4_filemap_fault(struct vm_fault *vmf)
6408
{
6409
	struct inode *inode = file_inode(vmf->vma->vm_file);
6410 6411 6412
	int err;

	down_read(&EXT4_I(inode)->i_mmap_sem);
6413
	err = filemap_fault(vmf);
6414 6415 6416 6417
	up_read(&EXT4_I(inode)->i_mmap_sem);

	return err;
}