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

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

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

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

48 49
#define MPAGE_DA_EXTENT_TAIL 0x01

50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw,
			      struct ext4_inode_info *ei)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	__u16 csum_lo;
	__u16 csum_hi = 0;
	__u32 csum;

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

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

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

	return csum;
}

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

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

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

	return provided == calculated;
}

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

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

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

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

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

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

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

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

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

	return ret;
180 181 182 183 184
}

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

190
	trace_ext4_evict_inode(inode);
191 192 193

	ext4_ioend_wait(inode);

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

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

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

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

	if (is_bad_inode(inode))
		goto no_delete;

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

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

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

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

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

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

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

333
	return ext4_ind_calc_metadata_amount(inode, lblock);
334 335
}

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

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

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

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

373 374 375 376 377 378
	if (ei->i_reserved_data_blocks == 0) {
		/*
		 * We can release all of the reserved metadata blocks
		 * only when we have written all of the delayed
		 * allocation blocks.
		 */
379
		percpu_counter_sub(&sbi->s_dirtyclusters_counter,
380
				   ei->i_reserved_meta_blocks);
381
		ei->i_reserved_meta_blocks = 0;
382
		ei->i_da_metadata_calc_len = 0;
383
	}
384
	spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
385

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

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

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

423
#define check_block_validity(inode, map)	\
424
	__check_block_validity((inode), __func__, __LINE__, (map))
425

426
/*
427 428
 * Return the number of contiguous dirty pages in a given inode
 * starting at page frame idx.
429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461
 */
static pgoff_t ext4_num_dirty_pages(struct inode *inode, pgoff_t idx,
				    unsigned int max_pages)
{
	struct address_space *mapping = inode->i_mapping;
	pgoff_t	index;
	struct pagevec pvec;
	pgoff_t num = 0;
	int i, nr_pages, done = 0;

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

			lock_page(page);
			if (unlikely(page->mapping != mapping) ||
			    !PageDirty(page) ||
			    PageWriteback(page) ||
			    page->index != idx) {
				done = 1;
				unlock_page(page);
				break;
			}
462 463 464 465 466 467 468 469 470
			if (page_has_buffers(page)) {
				bh = head = page_buffers(page);
				do {
					if (!buffer_delay(bh) &&
					    !buffer_unwritten(bh))
						done = 1;
					bh = bh->b_this_page;
				} while (!done && (bh != head));
			}
471 472 473 474 475
			unlock_page(page);
			if (done)
				break;
			idx++;
			num++;
476 477
			if (num >= max_pages) {
				done = 1;
478
				break;
479
			}
480 481 482 483 484 485
		}
		pagevec_release(&pvec);
	}
	return num;
}

486
/*
487
 * The ext4_map_blocks() function tries to look up the requested blocks,
488
 * and returns if the blocks are already mapped.
489 490 491 492 493
 *
 * 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.
 *
494 495
 * If file type is extents based, it will call ext4_ext_map_blocks(),
 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
496 497 498 499 500 501 502 503
 * based files
 *
 * On success, it returns the number of blocks being mapped or allocate.
 * if create==0 and the blocks are pre-allocated and uninitialized block,
 * the result buffer head is unmapped. If the create ==1, it will make sure
 * the buffer head is mapped.
 *
 * It returns 0 if plain look up failed (blocks have not been allocated), in
504
 * that case, buffer head is unmapped
505 506 507
 *
 * It returns the error in case of allocation failure.
 */
508 509
int ext4_map_blocks(handle_t *handle, struct inode *inode,
		    struct ext4_map_blocks *map, int flags)
510 511
{
	int retval;
512

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

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

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

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

562 563 564 565 566 567 568 569 570 571
	/*
	 * When we call get_blocks without the create flag, the
	 * BH_Unwritten flag could have gotten set if the blocks
	 * requested were part of a uninitialized extent.  We need to
	 * clear this flag now that we are committed to convert all or
	 * part of the uninitialized extent to be an initialized
	 * extent.  This is because we need to avoid the combination
	 * of BH_Unwritten and BH_Mapped flags being simultaneously
	 * set on the buffer_head.
	 */
572
	map->m_flags &= ~EXT4_MAP_UNWRITTEN;
573

574
	/*
575 576 577 578
	 * New blocks allocate and/or writing to uninitialized extent
	 * will possibly result in updating i_data, so we take
	 * the write lock of i_data_sem, and call get_blocks()
	 * with create == 1 flag.
579 580
	 */
	down_write((&EXT4_I(inode)->i_data_sem));
581 582 583 584 585 586 587

	/*
	 * if the caller is from delayed allocation writeout path
	 * we have already reserved fs blocks for allocation
	 * let the underlying get_block() function know to
	 * avoid double accounting
	 */
588
	if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE)
589
		ext4_set_inode_state(inode, EXT4_STATE_DELALLOC_RESERVED);
590 591 592 593
	/*
	 * We need to check for EXT4 here because migrate
	 * could have changed the inode type in between
	 */
594
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
595
		retval = ext4_ext_map_blocks(handle, inode, map, flags);
596
	} else {
597
		retval = ext4_ind_map_blocks(handle, inode, map, flags);
598

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

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

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

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

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

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

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

655 656 657
	map.m_lblk = iblock;
	map.m_len = bh->b_size >> inode->i_blkbits;

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

671
	ret = ext4_map_blocks(handle, inode, &map, flags);
J
Jan Kara 已提交
672
	if (ret > 0) {
673 674 675
		map_bh(bh, inode->i_sb, map.m_pblk);
		bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;
		bh->b_size = inode->i_sb->s_blocksize * map.m_len;
J
Jan Kara 已提交
676
		ret = 0;
677
	}
J
Jan Kara 已提交
678 679
	if (started)
		ext4_journal_stop(handle);
680 681 682
	return ret;
}

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

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

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

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

707 708 709
	/* ensure we send some value back into *errp */
	*errp = 0;

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

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

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

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

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

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

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

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

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

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

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

888
retry:
889 890 891 892
	handle = ext4_journal_start(inode, needed_blocks);
	if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
		goto out;
893
	}
894

895 896 897 898
	/* We cannot recurse into the filesystem as the transaction is already
	 * started */
	flags |= AOP_FLAG_NOFS;

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

906 907
	*pagep = page;

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

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

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

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

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

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

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

971 972 973 974 975 976
	if (ext4_has_inline_data(inode))
		copied = ext4_write_inline_data_end(inode, pos, len,
						    copied, page);
	else
		copied = block_write_end(file, mapping, pos,
					 len, copied, page, fsdata);
977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012

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

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

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

	return copied;
}

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

1029
	trace_ext4_ordered_write_end(inode, pos, len, copied);
1030
	ret = ext4_jbd2_file_inode(handle, inode);
1031 1032

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

1049
	ret2 = ext4_journal_stop(handle);
1050 1051
	if (!ret)
		ret = ret2;
N
Nick Piggin 已提交
1052

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

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

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

1088 1089
	if (ret2 < 0)
		ret = ret2;
1090

1091
	ret2 = ext4_journal_stop(handle);
1092 1093
	if (!ret)
		ret = ret2;
N
Nick Piggin 已提交
1094

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

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

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

1125 1126
	BUG_ON(!ext4_handle_valid(handle));

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

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

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

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

	return ret ? ret : copied;
1178
}
1179

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

	/*
	 * We will charge metadata quota at writeout time; this saves
	 * us from metadata over-estimation, though we may go over by
	 * a small amount in the end.  Here we just reserve for data.
	 */
	ret = dquot_reserve_block(inode, EXT4_C2B(sbi, 1));
	if (ret)
		return ret;
1201 1202 1203 1204 1205 1206

	/*
	 * recalculate the amount of metadata blocks to reserve
	 * in order to allocate nrblocks
	 * worse case is one extent per block
	 */
A
Aneesh Kumar K.V 已提交
1207
repeat:
1208
	spin_lock(&ei->i_block_reservation_lock);
1209 1210 1211 1212 1213 1214
	/*
	 * ext4_calc_metadata_amount() has side effects, which we have
	 * to be prepared undo if we fail to claim space.
	 */
	save_len = ei->i_da_metadata_calc_len;
	save_last_lblock = ei->i_da_metadata_calc_last_lblock;
1215 1216
	md_needed = EXT4_NUM_B2C(sbi,
				 ext4_calc_metadata_amount(inode, lblock));
1217
	trace_ext4_da_reserve_space(inode, md_needed);
1218

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

1238 1239 1240
	return 0;       /* success */
}

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

1246 1247 1248
	if (!to_free)
		return;		/* Nothing to release, exit */

1249
	spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
1250

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

1268 1269 1270 1271 1272
	if (ei->i_reserved_data_blocks == 0) {
		/*
		 * We can release all of the reserved metadata blocks
		 * only when we have written all of the delayed
		 * allocation blocks.
1273 1274
		 * Note that in case of bigalloc, i_reserved_meta_blocks,
		 * i_reserved_data_blocks, etc. refer to number of clusters.
1275
		 */
1276
		percpu_counter_sub(&sbi->s_dirtyclusters_counter,
1277
				   ei->i_reserved_meta_blocks);
1278
		ei->i_reserved_meta_blocks = 0;
1279
		ei->i_da_metadata_calc_len = 0;
1280
	}
1281

1282
	/* update fs dirty data blocks counter */
1283
	percpu_counter_sub(&sbi->s_dirtyclusters_counter, to_free);
1284 1285

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

1287
	dquot_release_reservation_block(inode, EXT4_C2B(sbi, to_free));
1288 1289 1290
}

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

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

		if ((offset <= curr_off) && (buffer_delay(bh))) {
			to_release++;
			clear_buffer_delay(bh);
		}
		curr_off = next_off;
	} while ((bh = bh->b_this_page) != head);
1312

1313 1314 1315 1316 1317
	if (to_release) {
		lblk = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
		ext4_es_remove_extent(inode, lblk, to_release);
	}

1318 1319 1320 1321 1322 1323 1324
	/* If we have released all the blocks belonging to a cluster, then we
	 * need to release the reserved space for that cluster. */
	num_clusters = EXT4_NUM_B2C(sbi, to_release);
	while (num_clusters > 0) {
		lblk = (page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits)) +
			((num_clusters - 1) << sbi->s_cluster_bits);
		if (sbi->s_cluster_ratio == 1 ||
1325
		    !ext4_find_delalloc_cluster(inode, lblk))
1326 1327 1328 1329
			ext4_da_release_space(inode, 1);

		num_clusters--;
	}
1330
}
1331

1332 1333 1334 1335 1336 1337
/*
 * Delayed allocation stuff
 */

/*
 * mpage_da_submit_io - walks through extent of pages and try to write
1338
 * them with writepage() call back
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348
 *
 * @mpd->inode: inode
 * @mpd->first_page: first page of the extent
 * @mpd->next_page: page after the last page of the extent
 *
 * By the time mpage_da_submit_io() is called we expect all blocks
 * to be allocated. this may be wrong if allocation failed.
 *
 * As pages are already locked by write_cache_pages(), we can't use it
 */
1349 1350
static int mpage_da_submit_io(struct mpage_da_data *mpd,
			      struct ext4_map_blocks *map)
1351
{
1352 1353 1354 1355 1356
	struct pagevec pvec;
	unsigned long index, end;
	int ret = 0, err, nr_pages, i;
	struct inode *inode = mpd->inode;
	struct address_space *mapping = inode->i_mapping;
1357
	loff_t size = i_size_read(inode);
1358 1359
	unsigned int len, block_start;
	struct buffer_head *bh, *page_bufs = NULL;
1360
	int journal_data = ext4_should_journal_data(inode);
1361
	sector_t pblock = 0, cur_logical = 0;
1362
	struct ext4_io_submit io_submit;
1363 1364

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

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

1384 1385 1386
			index = page->index;
			if (index > end)
				break;
1387 1388 1389 1390 1391

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

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

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

1419 1420
			bh = page_bufs = page_buffers(page);
			block_start = 0;
1421
			do {
1422
				if (!bh)
1423
					goto skip_page;
1424 1425 1426
				if (map && (cur_logical >= map->m_lblk) &&
				    (cur_logical <= (map->m_lblk +
						     (map->m_len - 1)))) {
1427 1428 1429 1430
					if (buffer_delay(bh)) {
						clear_buffer_delay(bh);
						bh->b_blocknr = pblock;
					}
1431 1432 1433 1434 1435 1436 1437
					if (buffer_unwritten(bh) ||
					    buffer_mapped(bh))
						BUG_ON(bh->b_blocknr != pblock);
					if (map->m_flags & EXT4_MAP_UNINIT)
						set_buffer_uninit(bh);
					clear_buffer_unwritten(bh);
				}
1438

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

1451 1452
			if (skip_page)
				goto skip_page;
1453 1454 1455 1456 1457

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

1458
			clear_page_dirty_for_io(page);
1459 1460 1461 1462 1463 1464
			/*
			 * Delalloc doesn't support data journalling,
			 * but eventually maybe we'll lift this
			 * restriction.
			 */
			if (unlikely(journal_data && PageChecked(page)))
1465
				err = __ext4_journalled_writepage(page, len);
1466
			else if (test_opt(inode->i_sb, MBLK_IO_SUBMIT))
1467 1468
				err = ext4_bio_write_page(&io_submit, page,
							  len, mpd->wbc);
1469 1470 1471 1472 1473 1474
			else if (buffer_uninit(page_bufs)) {
				ext4_set_bh_endio(page_bufs, inode);
				err = block_write_full_page_endio(page,
					noalloc_get_block_write,
					mpd->wbc, ext4_end_io_buffer_write);
			} else
1475 1476
				err = block_write_full_page(page,
					noalloc_get_block_write, mpd->wbc);
1477 1478

			if (!err)
1479
				mpd->pages_written++;
1480 1481 1482 1483 1484 1485 1486 1487 1488
			/*
			 * In error case, we have to continue because
			 * remaining pages are still locked
			 */
			if (ret == 0)
				ret = err;
		}
		pagevec_release(&pvec);
	}
1489
	ext4_io_submit(&io_submit);
1490 1491 1492
	return ret;
}

1493
static void ext4_da_block_invalidatepages(struct mpage_da_data *mpd)
1494 1495 1496 1497 1498 1499
{
	int nr_pages, i;
	pgoff_t index, end;
	struct pagevec pvec;
	struct inode *inode = mpd->inode;
	struct address_space *mapping = inode->i_mapping;
1500
	ext4_lblk_t start, last;
1501

1502 1503
	index = mpd->first_page;
	end   = mpd->next_page - 1;
1504 1505 1506 1507 1508

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

1509
	pagevec_init(&pvec, 0);
1510 1511 1512 1513 1514 1515
	while (index <= end) {
		nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
		if (nr_pages == 0)
			break;
		for (i = 0; i < nr_pages; i++) {
			struct page *page = pvec.pages[i];
1516
			if (page->index > end)
1517 1518 1519 1520 1521 1522 1523
				break;
			BUG_ON(!PageLocked(page));
			BUG_ON(PageWriteback(page));
			block_invalidatepage(page, 0);
			ClearPageUptodate(page);
			unlock_page(page);
		}
1524 1525
		index = pvec.pages[nr_pages - 1]->index + 1;
		pagevec_release(&pvec);
1526 1527 1528 1529
	}
	return;
}

1530 1531 1532
static void ext4_print_free_blocks(struct inode *inode)
{
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
1533 1534 1535
	struct super_block *sb = inode->i_sb;

	ext4_msg(sb, KERN_CRIT, "Total free blocks count %lld",
1536 1537
	       EXT4_C2B(EXT4_SB(inode->i_sb),
			ext4_count_free_clusters(inode->i_sb)));
1538 1539
	ext4_msg(sb, KERN_CRIT, "Free/Dirty block details");
	ext4_msg(sb, KERN_CRIT, "free_blocks=%lld",
1540 1541
	       (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
		percpu_counter_sum(&sbi->s_freeclusters_counter)));
1542
	ext4_msg(sb, KERN_CRIT, "dirty_blocks=%lld",
1543 1544
	       (long long) EXT4_C2B(EXT4_SB(inode->i_sb),
		percpu_counter_sum(&sbi->s_dirtyclusters_counter)));
1545 1546 1547 1548
	ext4_msg(sb, KERN_CRIT, "Block reservation details");
	ext4_msg(sb, KERN_CRIT, "i_reserved_data_blocks=%u",
		 EXT4_I(inode)->i_reserved_data_blocks);
	ext4_msg(sb, KERN_CRIT, "i_reserved_meta_blocks=%u",
1549
	       EXT4_I(inode)->i_reserved_meta_blocks);
1550 1551 1552
	return;
}

1553
/*
1554 1555
 * mpage_da_map_and_submit - go through given space, map them
 *       if necessary, and then submit them for I/O
1556
 *
1557
 * @mpd - bh describing space
1558 1559 1560 1561
 *
 * The function skips space we know is already mapped to disk blocks.
 *
 */
1562
static void mpage_da_map_and_submit(struct mpage_da_data *mpd)
1563
{
1564
	int err, blks, get_blocks_flags;
1565
	struct ext4_map_blocks map, *mapp = NULL;
1566 1567 1568 1569
	sector_t next = mpd->b_blocknr;
	unsigned max_blocks = mpd->b_size >> mpd->inode->i_blkbits;
	loff_t disksize = EXT4_I(mpd->inode)->i_disksize;
	handle_t *handle = NULL;
1570 1571

	/*
1572 1573
	 * If the blocks are mapped already, or we couldn't accumulate
	 * any blocks, then proceed immediately to the submission stage.
1574
	 */
1575 1576 1577 1578 1579
	if ((mpd->b_size == 0) ||
	    ((mpd->b_state  & (1 << BH_Mapped)) &&
	     !(mpd->b_state & (1 << BH_Delay)) &&
	     !(mpd->b_state & (1 << BH_Unwritten))))
		goto submit_io;
1580 1581 1582 1583

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

1584
	/*
1585
	 * Call ext4_map_blocks() to allocate any delayed allocation
1586 1587 1588 1589 1590 1591 1592 1593
	 * blocks, or to convert an uninitialized extent to be
	 * initialized (in the case where we have written into
	 * one or more preallocated blocks).
	 *
	 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE to
	 * indicate that we are on the delayed allocation path.  This
	 * affects functions in many different parts of the allocation
	 * call path.  This flag exists primarily because we don't
1594
	 * want to change *many* call functions, so ext4_map_blocks()
1595
	 * will set the EXT4_STATE_DELALLOC_RESERVED flag once the
1596 1597 1598 1599 1600
	 * inode's allocation semaphore is taken.
	 *
	 * If the blocks in questions were delalloc blocks, set
	 * EXT4_GET_BLOCKS_DELALLOC_RESERVE so the delalloc accounting
	 * variables are updated after the blocks have been allocated.
1601
	 */
1602 1603
	map.m_lblk = next;
	map.m_len = max_blocks;
1604
	get_blocks_flags = EXT4_GET_BLOCKS_CREATE;
1605 1606
	if (ext4_should_dioread_nolock(mpd->inode))
		get_blocks_flags |= EXT4_GET_BLOCKS_IO_CREATE_EXT;
1607
	if (mpd->b_state & (1 << BH_Delay))
1608 1609
		get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE;

1610
	blks = ext4_map_blocks(handle, mpd->inode, &map, get_blocks_flags);
1611
	if (blks < 0) {
1612 1613
		struct super_block *sb = mpd->inode->i_sb;

1614
		err = blks;
1615
		/*
1616
		 * If get block returns EAGAIN or ENOSPC and there
1617 1618
		 * appears to be free blocks we will just let
		 * mpage_da_submit_io() unlock all of the pages.
1619 1620
		 */
		if (err == -EAGAIN)
1621
			goto submit_io;
1622

1623
		if (err == -ENOSPC && ext4_count_free_clusters(sb)) {
1624
			mpd->retval = err;
1625
			goto submit_io;
1626 1627
		}

1628
		/*
1629 1630 1631 1632 1633
		 * get block failure will cause us to loop in
		 * writepages, because a_ops->writepage won't be able
		 * to make progress. The page will be redirtied by
		 * writepage and writepages will again try to write
		 * the same.
1634
		 */
1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
		if (!(EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED)) {
			ext4_msg(sb, KERN_CRIT,
				 "delayed block allocation failed for inode %lu "
				 "at logical offset %llu with max blocks %zd "
				 "with error %d", mpd->inode->i_ino,
				 (unsigned long long) next,
				 mpd->b_size >> mpd->inode->i_blkbits, err);
			ext4_msg(sb, KERN_CRIT,
				"This should not happen!! Data will be lost\n");
			if (err == -ENOSPC)
				ext4_print_free_blocks(mpd->inode);
A
Aneesh Kumar K.V 已提交
1646
		}
1647
		/* invalidate all the pages */
1648
		ext4_da_block_invalidatepages(mpd);
1649 1650 1651

		/* Mark this page range as having been completed */
		mpd->io_done = 1;
1652
		return;
1653
	}
1654 1655
	BUG_ON(blks == 0);

1656
	mapp = &map;
1657 1658 1659
	if (map.m_flags & EXT4_MAP_NEW) {
		struct block_device *bdev = mpd->inode->i_sb->s_bdev;
		int i;
1660

1661 1662
		for (i = 0; i < map.m_len; i++)
			unmap_underlying_metadata(bdev, map.m_pblk + i);
1663 1664 1665
	}

	/*
1666
	 * Update on-disk size along with block allocation.
1667 1668 1669 1670 1671 1672
	 */
	disksize = ((loff_t) next + blks) << mpd->inode->i_blkbits;
	if (disksize > i_size_read(mpd->inode))
		disksize = i_size_read(mpd->inode);
	if (disksize > EXT4_I(mpd->inode)->i_disksize) {
		ext4_update_i_disksize(mpd->inode, disksize);
1673 1674 1675 1676 1677
		err = ext4_mark_inode_dirty(handle, mpd->inode);
		if (err)
			ext4_error(mpd->inode->i_sb,
				   "Failed to mark inode %lu dirty",
				   mpd->inode->i_ino);
1678 1679
	}

1680
submit_io:
1681
	mpage_da_submit_io(mpd, mapp);
1682
	mpd->io_done = 1;
1683 1684
}

1685 1686
#define BH_FLAGS ((1 << BH_Uptodate) | (1 << BH_Mapped) | \
		(1 << BH_Delay) | (1 << BH_Unwritten))
1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697

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

1704 1705 1706 1707
	/*
	 * XXX Don't go larger than mballoc is willing to allocate
	 * This is a stopgap solution.  We eventually need to fold
	 * mpage_da_submit_io() into this function and then call
1708
	 * ext4_map_blocks() multiple times in a loop
1709 1710 1711 1712
	 */
	if (nrblocks >= 8*1024*1024/mpd->inode->i_sb->s_blocksize)
		goto flush_it;

1713
	/* check if thereserved journal credits might overflow */
1714
	if (!(ext4_test_inode_flag(mpd->inode, EXT4_INODE_EXTENTS))) {
1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734
		if (nrblocks >= EXT4_MAX_TRANS_DATA) {
			/*
			 * With non-extent format we are limited by the journal
			 * credit available.  Total credit needed to insert
			 * nrblocks contiguous blocks is dependent on the
			 * nrblocks.  So limit nrblocks.
			 */
			goto flush_it;
		} else if ((nrblocks + (b_size >> mpd->inode->i_blkbits)) >
				EXT4_MAX_TRANS_DATA) {
			/*
			 * Adding the new buffer_head would make it cross the
			 * allowed limit for which we have journal credit
			 * reserved. So limit the new bh->b_size
			 */
			b_size = (EXT4_MAX_TRANS_DATA - nrblocks) <<
						mpd->inode->i_blkbits;
			/* we will do mpage_da_submit_io in the next loop */
		}
	}
1735 1736 1737
	/*
	 * First block in the extent
	 */
1738 1739 1740 1741
	if (mpd->b_size == 0) {
		mpd->b_blocknr = logical;
		mpd->b_size = b_size;
		mpd->b_state = b_state & BH_FLAGS;
1742 1743 1744
		return;
	}

1745
	next = mpd->b_blocknr + nrblocks;
1746 1747 1748
	/*
	 * Can we merge the block to our big extent?
	 */
1749 1750
	if (logical == next && (b_state & BH_FLAGS) == mpd->b_state) {
		mpd->b_size += b_size;
1751 1752 1753
		return;
	}

1754
flush_it:
1755 1756 1757 1758
	/*
	 * We couldn't merge the block to our extent, so we
	 * need to flush current  extent and start new one
	 */
1759
	mpage_da_map_and_submit(mpd);
1760
	return;
1761 1762
}

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

1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792
/*
 * This function is grabs code from the very beginning of
 * ext4_map_blocks, but assumes that the caller is from delayed write
 * time. This function looks up the requested blocks and sets the
 * buffer delay bit under the protection of i_data_sem.
 */
static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
			      struct ext4_map_blocks *map,
			      struct buffer_head *bh)
{
	int retval;
	sector_t invalid_block = ~((sector_t) 0xffff);

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

	map->m_flags = 0;
	ext_debug("ext4_da_map_blocks(): inode %lu, max_blocks %u,"
		  "logical block %lu\n", inode->i_ino, map->m_len,
		  (unsigned long) map->m_lblk);
	/*
	 * Try to see if we can get the block without requesting a new
	 * file system block.
	 */
	down_read((&EXT4_I(inode)->i_data_sem));
1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805
	if (ext4_has_inline_data(inode)) {
		/*
		 * We will soon create blocks for this page, and let
		 * us pretend as if the blocks aren't allocated yet.
		 * In case of clusters, we have to handle the work
		 * of mapping from cluster so that the reserved space
		 * is calculated properly.
		 */
		if ((EXT4_SB(inode->i_sb)->s_cluster_ratio > 1) &&
		    ext4_find_delalloc_cluster(inode, map->m_lblk))
			map->m_flags |= EXT4_MAP_FROM_CLUSTER;
		retval = 0;
	} else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823
		retval = ext4_ext_map_blocks(NULL, inode, map, 0);
	else
		retval = ext4_ind_map_blocks(NULL, inode, map, 0);

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

1824 1825 1826 1827
		retval = ext4_es_insert_extent(inode, map->m_lblk, map->m_len);
		if (retval)
			goto out_unlock;

1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843
		/* Clear EXT4_MAP_FROM_CLUSTER flag since its purpose is served
		 * and it should not appear on the bh->b_state.
		 */
		map->m_flags &= ~EXT4_MAP_FROM_CLUSTER;

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

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

	return retval;
}

1844
/*
1845 1846 1847
 * This is a special get_blocks_t callback which is used by
 * ext4_da_write_begin().  It will either return mapped block or
 * reserve space for a single block.
1848 1849 1850 1851 1852 1853 1854
 *
 * 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.
1855
 */
1856 1857
int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
			   struct buffer_head *bh, int create)
1858
{
1859
	struct ext4_map_blocks map;
1860 1861 1862
	int ret = 0;

	BUG_ON(create == 0);
1863 1864 1865 1866
	BUG_ON(bh->b_size != inode->i_sb->s_blocksize);

	map.m_lblk = iblock;
	map.m_len = 1;
1867 1868 1869 1870 1871 1872

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

1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887
	map_bh(bh, inode->i_sb, map.m_pblk);
	bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;

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

1893 1894 1895
/*
 * This function is used as a standard get_block_t calback function
 * when there is no desire to allocate any blocks.  It is used as a
C
Christoph Hellwig 已提交
1896
 * callback function for block_write_begin() and block_write_full_page().
1897
 * These functions should only try to map a single block at a time.
1898 1899 1900 1901 1902
 *
 * Since this function doesn't do block allocations even if the caller
 * requests it by passing in create=1, it is critically important that
 * any caller checks to make sure that any buffer heads are returned
 * by this function are either all already mapped or marked for
1903 1904 1905
 * delayed allocation before calling  block_write_full_page().  Otherwise,
 * b_blocknr could be left unitialized, and the page write functions will
 * be taken by surprise.
1906 1907
 */
static int noalloc_get_block_write(struct inode *inode, sector_t iblock,
1908 1909
				   struct buffer_head *bh_result, int create)
{
1910
	BUG_ON(bh_result->b_size != inode->i_sb->s_blocksize);
1911
	return _ext4_get_block(inode, iblock, bh_result, 0);
1912 1913
}

1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930
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;
1931
	struct buffer_head *page_bufs = NULL;
1932
	handle_t *handle = NULL;
1933 1934 1935
	int ret = 0, err = 0;
	int inline_data = ext4_has_inline_data(inode);
	struct buffer_head *inode_bh = NULL;
1936

1937
	ClearPageChecked(page);
1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953

	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);
	}
1954 1955 1956 1957 1958 1959 1960 1961 1962 1963
	/* As soon as we unlock the page, it can go away, but we have
	 * references to buffers so we are safe */
	unlock_page(page);

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

1964 1965
	BUG_ON(!ext4_handle_valid(handle));

1966 1967
	if (inline_data) {
		ret = ext4_journal_get_write_access(handle, inode_bh);
1968

1969 1970 1971 1972 1973 1974 1975 1976 1977
		err = ext4_handle_dirty_metadata(handle, inode, inode_bh);

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

		err = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL,
					     write_end_fn);
	}
1978 1979
	if (ret == 0)
		ret = err;
1980
	EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
1981 1982 1983 1984
	err = ext4_journal_stop(handle);
	if (!ret)
		ret = err;

1985 1986 1987
	if (!ext4_has_inline_data(inode))
		ext4_walk_page_buffers(handle, page_bufs, 0, len,
				       NULL, bput_one);
1988
	ext4_set_inode_state(inode, EXT4_STATE_JDATA);
1989
out:
1990
	brelse(inode_bh);
1991 1992 1993
	return ret;
}

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

L
Lukas Czerner 已提交
2044
	trace_ext4_writepage(page);
2045 2046 2047 2048 2049
	size = i_size_read(inode);
	if (page->index == size >> PAGE_CACHE_SHIFT)
		len = size & ~PAGE_CACHE_MASK;
	else
		len = PAGE_CACHE_SIZE;
2050

T
Theodore Ts'o 已提交
2051 2052
	/*
	 * If the page does not have buffers (for whatever reason),
2053
	 * try to create them using __block_write_begin.  If this
T
Theodore Ts'o 已提交
2054 2055
	 * fails, redirty the page and move on.
	 */
2056
	if (!page_has_buffers(page)) {
2057
		if (__block_write_begin(page, 0, len,
T
Theodore Ts'o 已提交
2058 2059
					noalloc_get_block_write)) {
		redirty_page:
2060 2061 2062 2063
			redirty_page_for_writepage(wbc, page);
			unlock_page(page);
			return 0;
		}
T
Theodore Ts'o 已提交
2064 2065 2066
		commit_write = 1;
	}
	page_bufs = page_buffers(page);
2067 2068
	if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL,
				   ext4_bh_delay_or_unwritten)) {
2069
		/*
2070 2071 2072
		 * We don't want to do block allocation, so redirty
		 * the page and return.  We may reach here when we do
		 * a journal commit via journal_submit_inode_data_buffers.
2073 2074 2075
		 * We can also reach here via shrink_page_list but it
		 * should never be for direct reclaim so warn if that
		 * happens
2076
		 */
2077 2078
		WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD)) ==
								PF_MEMALLOC);
T
Theodore Ts'o 已提交
2079 2080 2081
		goto redirty_page;
	}
	if (commit_write)
2082
		/* now mark the buffer_heads as dirty and uptodate */
2083
		block_commit_write(page, 0, len);
2084

2085
	if (PageChecked(page) && ext4_should_journal_data(inode))
2086 2087 2088 2089
		/*
		 * It's mmapped pagecache.  Add buffers and journal it.  There
		 * doesn't seem much point in redirtying the page here.
		 */
2090
		return __ext4_journalled_writepage(page, len);
2091

T
Theodore Ts'o 已提交
2092
	if (buffer_uninit(page_bufs)) {
2093 2094 2095 2096
		ext4_set_bh_endio(page_bufs, inode);
		ret = block_write_full_page_endio(page, noalloc_get_block_write,
					    wbc, ext4_end_io_buffer_write);
	} else
2097 2098
		ret = block_write_full_page(page, noalloc_get_block_write,
					    wbc);
2099 2100 2101 2102

	return ret;
}

2103
/*
2104
 * This is called via ext4_da_writepages() to
L
Lucas De Marchi 已提交
2105
 * calculate the total number of credits to reserve to fit
2106 2107 2108
 * a single extent allocation into a single transaction,
 * ext4_da_writpeages() will loop calling this before
 * the block allocation.
2109
 */
2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120

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

	/*
	 * With non-extent format the journal credit needed to
	 * insert nrblocks contiguous block is dependent on
	 * number of contiguous block. So we will limit
	 * number of contiguous block to a sane value
	 */
2121
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) &&
2122 2123 2124 2125 2126
	    (max_blocks > EXT4_MAX_TRANS_DATA))
		max_blocks = EXT4_MAX_TRANS_DATA;

	return ext4_chunk_trans_blocks(inode, max_blocks);
}
2127

2128 2129
/*
 * write_cache_pages_da - walk the list of dirty pages of the given
2130
 * address space and accumulate pages that need writing, and call
2131 2132
 * mpage_da_map_and_submit to map a single contiguous memory region
 * and then write them.
2133
 */
2134 2135
static int write_cache_pages_da(handle_t *handle,
				struct address_space *mapping,
2136
				struct writeback_control *wbc,
2137 2138
				struct mpage_da_data *mpd,
				pgoff_t *done_index)
2139
{
2140
	struct buffer_head	*bh, *head;
2141
	struct inode		*inode = mapping->host;
2142 2143 2144 2145 2146 2147
	struct pagevec		pvec;
	unsigned int		nr_pages;
	sector_t		logical;
	pgoff_t			index, end;
	long			nr_to_write = wbc->nr_to_write;
	int			i, tag, ret = 0;
2148

2149 2150 2151
	memset(mpd, 0, sizeof(struct mpage_da_data));
	mpd->wbc = wbc;
	mpd->inode = inode;
2152 2153 2154 2155
	pagevec_init(&pvec, 0);
	index = wbc->range_start >> PAGE_CACHE_SHIFT;
	end = wbc->range_end >> PAGE_CACHE_SHIFT;

2156
	if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
2157 2158 2159 2160
		tag = PAGECACHE_TAG_TOWRITE;
	else
		tag = PAGECACHE_TAG_DIRTY;

2161
	*done_index = index;
2162
	while (index <= end) {
2163
		nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
2164 2165
			      min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
		if (nr_pages == 0)
2166
			return 0;
2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177

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

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

2181 2182
			*done_index = page->index + 1;

2183 2184 2185 2186 2187 2188 2189 2190 2191 2192
			/*
			 * If we can't merge this page, and we have
			 * accumulated an contiguous region, write it
			 */
			if ((mpd->next_page != page->index) &&
			    (mpd->next_page != mpd->first_page)) {
				mpage_da_map_and_submit(mpd);
				goto ret_extent_tail;
			}

2193 2194 2195
			lock_page(page);

			/*
2196 2197 2198 2199 2200 2201
			 * 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
2202
			 */
2203 2204 2205 2206
			if (!PageDirty(page) ||
			    (PageWriteback(page) &&
			     (wbc->sync_mode == WB_SYNC_NONE)) ||
			    unlikely(page->mapping != mapping)) {
2207 2208 2209 2210
				unlock_page(page);
				continue;
			}

2211
			wait_on_page_writeback(page);
2212 2213
			BUG_ON(PageWriteback(page));

2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224
			/*
			 * If we have inline data and arrive here, it means that
			 * we will soon create the block for the 1st page, so
			 * we'd better clear the inline data here.
			 */
			if (ext4_has_inline_data(inode)) {
				BUG_ON(ext4_test_inode_state(inode,
						EXT4_STATE_MAY_INLINE_DATA));
				ext4_destroy_inline_data(handle, inode);
			}

2225
			if (mpd->next_page != page->index)
2226 2227 2228 2229 2230 2231
				mpd->first_page = page->index;
			mpd->next_page = page->index + 1;
			logical = (sector_t) page->index <<
				(PAGE_CACHE_SHIFT - inode->i_blkbits);

			if (!page_has_buffers(page)) {
2232 2233
				mpage_add_bh_to_extent(mpd, logical,
						       PAGE_CACHE_SIZE,
2234
						       (1 << BH_Dirty) | (1 << BH_Uptodate));
2235 2236
				if (mpd->io_done)
					goto ret_extent_tail;
2237 2238
			} else {
				/*
2239 2240
				 * Page with regular buffer heads,
				 * just add all dirty ones
2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255
				 */
				head = page_buffers(page);
				bh = head;
				do {
					BUG_ON(buffer_locked(bh));
					/*
					 * We need to try to allocate
					 * unmapped blocks in the same page.
					 * Otherwise we won't make progress
					 * with the page in ext4_writepage
					 */
					if (ext4_bh_delay_or_unwritten(NULL, bh)) {
						mpage_add_bh_to_extent(mpd, logical,
								       bh->b_size,
								       bh->b_state);
2256 2257
						if (mpd->io_done)
							goto ret_extent_tail;
2258 2259
					} else if (buffer_dirty(bh) && (buffer_mapped(bh))) {
						/*
2260 2261 2262 2263 2264 2265 2266 2267 2268
						 * mapped dirty buffer. We need
						 * to update the b_state
						 * because we look at b_state
						 * in mpage_da_map_blocks.  We
						 * don't update b_size because
						 * if we find an unmapped
						 * buffer_head later we need to
						 * use the b_state flag of that
						 * buffer_head.
2269 2270 2271 2272 2273 2274
						 */
						if (mpd->b_size == 0)
							mpd->b_state = bh->b_state & BH_FLAGS;
					}
					logical++;
				} while ((bh = bh->b_this_page) != head);
2275 2276 2277 2278 2279
			}

			if (nr_to_write > 0) {
				nr_to_write--;
				if (nr_to_write == 0 &&
2280
				    wbc->sync_mode == WB_SYNC_NONE)
2281 2282 2283 2284 2285 2286 2287 2288 2289 2290
					/*
					 * We stop writing back only if we are
					 * not doing integrity sync. In case of
					 * integrity sync we have to keep going
					 * because someone may be concurrently
					 * dirtying pages, and we might have
					 * synced a lot of newly appeared dirty
					 * pages, but have not synced all of the
					 * old dirty pages.
					 */
2291
					goto out;
2292 2293 2294 2295 2296
			}
		}
		pagevec_release(&pvec);
		cond_resched();
	}
2297 2298 2299
	return 0;
ret_extent_tail:
	ret = MPAGE_DA_EXTENT_TAIL;
2300 2301 2302
out:
	pagevec_release(&pvec);
	cond_resched();
2303 2304 2305 2306
	return ret;
}


2307
static int ext4_da_writepages(struct address_space *mapping,
2308
			      struct writeback_control *wbc)
2309
{
2310 2311
	pgoff_t	index;
	int range_whole = 0;
2312
	handle_t *handle = NULL;
2313
	struct mpage_da_data mpd;
2314
	struct inode *inode = mapping->host;
2315
	int pages_written = 0;
2316
	unsigned int max_pages;
2317
	int range_cyclic, cycled = 1, io_done = 0;
2318 2319
	int needed_blocks, ret = 0;
	long desired_nr_to_write, nr_to_writebump = 0;
2320
	loff_t range_start = wbc->range_start;
2321
	struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
2322
	pgoff_t done_index = 0;
2323
	pgoff_t end;
S
Shaohua Li 已提交
2324
	struct blk_plug plug;
2325

2326
	trace_ext4_da_writepages(inode, wbc);
2327

2328 2329 2330 2331 2332
	/*
	 * 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
	 */
2333
	if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
2334
		return 0;
2335 2336 2337 2338 2339

	/*
	 * 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
2340
	 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
2341 2342 2343 2344 2345
	 * the latter could be true if the filesystem is mounted
	 * read-only, and in that case, ext4_da_writepages should
	 * *never* be called, so if that ever happens, we would want
	 * the stack trace.
	 */
2346
	if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED))
2347 2348
		return -EROFS;

2349 2350
	if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
		range_whole = 1;
2351

2352 2353
	range_cyclic = wbc->range_cyclic;
	if (wbc->range_cyclic) {
2354
		index = mapping->writeback_index;
2355 2356 2357 2358 2359
		if (index)
			cycled = 0;
		wbc->range_start = index << PAGE_CACHE_SHIFT;
		wbc->range_end  = LLONG_MAX;
		wbc->range_cyclic = 0;
2360 2361
		end = -1;
	} else {
2362
		index = wbc->range_start >> PAGE_CACHE_SHIFT;
2363 2364
		end = wbc->range_end >> PAGE_CACHE_SHIFT;
	}
2365

2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382
	/*
	 * This works around two forms of stupidity.  The first is in
	 * the writeback code, which caps the maximum number of pages
	 * written to be 1024 pages.  This is wrong on multiple
	 * levels; different architectues have a different page size,
	 * which changes the maximum amount of data which gets
	 * written.  Secondly, 4 megabytes is way too small.  XFS
	 * forces this value to be 16 megabytes by multiplying
	 * nr_to_write parameter by four, and then relies on its
	 * allocator to allocate larger extents to make them
	 * contiguous.  Unfortunately this brings us to the second
	 * stupidity, which is that ext4's mballoc code only allocates
	 * at most 2048 blocks.  So we force contiguous writes up to
	 * the number of dirty blocks in the inode, or
	 * sbi->max_writeback_mb_bump whichever is smaller.
	 */
	max_pages = sbi->s_max_writeback_mb_bump << (20 - PAGE_CACHE_SHIFT);
2383 2384 2385 2386 2387 2388
	if (!range_cyclic && range_whole) {
		if (wbc->nr_to_write == LONG_MAX)
			desired_nr_to_write = wbc->nr_to_write;
		else
			desired_nr_to_write = wbc->nr_to_write * 8;
	} else
2389 2390 2391 2392 2393 2394 2395 2396 2397 2398
		desired_nr_to_write = ext4_num_dirty_pages(inode, index,
							   max_pages);
	if (desired_nr_to_write > max_pages)
		desired_nr_to_write = max_pages;

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

2399
retry:
2400
	if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
2401 2402
		tag_pages_for_writeback(mapping, index, end);

S
Shaohua Li 已提交
2403
	blk_start_plug(&plug);
2404
	while (!ret && wbc->nr_to_write > 0) {
2405 2406 2407 2408 2409 2410 2411 2412

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

2415 2416 2417 2418
		/* start a new transaction*/
		handle = ext4_journal_start(inode, needed_blocks);
		if (IS_ERR(handle)) {
			ret = PTR_ERR(handle);
2419
			ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
2420
			       "%ld pages, ino %lu; err %d", __func__,
2421
				wbc->nr_to_write, inode->i_ino, ret);
2422
			blk_finish_plug(&plug);
2423 2424
			goto out_writepages;
		}
2425 2426

		/*
2427
		 * Now call write_cache_pages_da() to find the next
2428
		 * contiguous region of logical blocks that need
2429
		 * blocks to be allocated by ext4 and submit them.
2430
		 */
2431 2432
		ret = write_cache_pages_da(handle, mapping,
					   wbc, &mpd, &done_index);
2433
		/*
2434
		 * If we have a contiguous extent of pages and we
2435 2436 2437 2438
		 * haven't done the I/O yet, map the blocks and submit
		 * them for I/O.
		 */
		if (!mpd.io_done && mpd.next_page != mpd.first_page) {
2439
			mpage_da_map_and_submit(&mpd);
2440 2441
			ret = MPAGE_DA_EXTENT_TAIL;
		}
2442
		trace_ext4_da_write_pages(inode, &mpd);
2443
		wbc->nr_to_write -= mpd.pages_written;
2444

2445
		ext4_journal_stop(handle);
2446

2447
		if ((mpd.retval == -ENOSPC) && sbi->s_journal) {
2448 2449 2450 2451
			/* commit the transaction which would
			 * free blocks released in the transaction
			 * and try again
			 */
2452
			jbd2_journal_force_commit_nested(sbi->s_journal);
2453 2454
			ret = 0;
		} else if (ret == MPAGE_DA_EXTENT_TAIL) {
2455
			/*
2456 2457 2458
			 * Got one extent now try with rest of the pages.
			 * If mpd.retval is set -EIO, journal is aborted.
			 * So we don't need to write any more.
2459
			 */
2460
			pages_written += mpd.pages_written;
2461
			ret = mpd.retval;
2462
			io_done = 1;
2463
		} else if (wbc->nr_to_write)
2464 2465 2466 2467 2468 2469
			/*
			 * There is no more writeout needed
			 * or we requested for a noblocking writeout
			 * and we found the device congested
			 */
			break;
2470
	}
S
Shaohua Li 已提交
2471
	blk_finish_plug(&plug);
2472 2473 2474 2475 2476 2477 2478
	if (!io_done && !cycled) {
		cycled = 1;
		index = 0;
		wbc->range_start = index << PAGE_CACHE_SHIFT;
		wbc->range_end  = mapping->writeback_index - 1;
		goto retry;
	}
2479 2480

	/* Update index */
2481
	wbc->range_cyclic = range_cyclic;
2482 2483 2484 2485 2486
	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
		/*
		 * set the writeback_index so that range_cyclic
		 * mode will write it back later
		 */
2487
		mapping->writeback_index = done_index;
2488

2489
out_writepages:
2490
	wbc->nr_to_write -= nr_to_writebump;
2491
	wbc->range_start = range_start;
2492
	trace_ext4_da_writepages_result(inode, wbc, ret, pages_written);
2493
	return ret;
2494 2495
}

2496 2497 2498 2499 2500 2501 2502 2503
static int ext4_nonda_switch(struct super_block *sb)
{
	s64 free_blocks, dirty_blocks;
	struct ext4_sb_info *sbi = EXT4_SB(sb);

	/*
	 * switch to non delalloc mode if we are running low
	 * on free block. The free block accounting via percpu
2504
	 * counters can get slightly wrong with percpu_counter_batch getting
2505 2506 2507 2508
	 * 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.
	 */
2509 2510 2511
	free_blocks  = EXT4_C2B(sbi,
		percpu_counter_read_positive(&sbi->s_freeclusters_counter));
	dirty_blocks = percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);
2512 2513 2514 2515 2516 2517 2518 2519 2520 2521
	/*
	 * Start pushing delalloc when 1/2 of free blocks are dirty.
	 */
	if (dirty_blocks && (free_blocks < 2 * dirty_blocks) &&
	    !writeback_in_progress(sb->s_bdi) &&
	    down_read_trylock(&sb->s_umount)) {
		writeback_inodes_sb(sb, WB_REASON_FS_FREE_SPACE);
		up_read(&sb->s_umount);
	}

2522
	if (2 * free_blocks < 3 * dirty_blocks ||
2523
		free_blocks < (dirty_blocks + EXT4_FREECLUSTERS_WATERMARK)) {
2524
		/*
2525 2526
		 * free block count is less than 150% of dirty blocks
		 * or free blocks is less than watermark
2527 2528 2529 2530 2531 2532
		 */
		return 1;
	}
	return 0;
}

2533
static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
2534 2535
			       loff_t pos, unsigned len, unsigned flags,
			       struct page **pagep, void **fsdata)
2536
{
2537
	int ret, retries = 0;
2538 2539 2540 2541 2542 2543
	struct page *page;
	pgoff_t index;
	struct inode *inode = mapping->host;
	handle_t *handle;

	index = pos >> PAGE_CACHE_SHIFT;
2544 2545 2546 2547 2548 2549 2550

	if (ext4_nonda_switch(inode->i_sb)) {
		*fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
		return ext4_write_begin(file, mapping, pos,
					len, flags, pagep, fsdata);
	}
	*fsdata = (void *)0;
2551
	trace_ext4_da_write_begin(inode, pos, len, flags);
2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564

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

2565
retry:
2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576
	/*
	 * With delayed allocation, we don't log the i_disksize update
	 * if there is delayed block allocation. But we still need
	 * to journalling the i_disksize update if writes to the end
	 * of file which has an already mapped buffer.
	 */
	handle = ext4_journal_start(inode, 1);
	if (IS_ERR(handle)) {
		ret = PTR_ERR(handle);
		goto out;
	}
2577 2578 2579
	/* We cannot recurse into the filesystem as the transaction is already
	 * started */
	flags |= AOP_FLAG_NOFS;
2580

2581
	page = grab_cache_page_write_begin(mapping, index, flags);
2582 2583 2584 2585 2586
	if (!page) {
		ext4_journal_stop(handle);
		ret = -ENOMEM;
		goto out;
	}
2587 2588
	*pagep = page;

2589
	ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep);
2590 2591 2592 2593
	if (ret < 0) {
		unlock_page(page);
		ext4_journal_stop(handle);
		page_cache_release(page);
2594 2595 2596 2597 2598 2599
		/*
		 * 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)
2600
			ext4_truncate_failed_write(inode);
2601 2602
	}

2603 2604
	if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
		goto retry;
2605 2606 2607 2608
out:
	return ret;
}

2609 2610 2611 2612 2613
/*
 * 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,
2614
					    unsigned long offset)
2615 2616 2617 2618 2619 2620 2621 2622 2623
{
	struct buffer_head *bh;
	struct inode *inode = page->mapping->host;
	unsigned int idx;
	int i;

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

2624
	for (i = 0; i < idx; i++)
2625 2626
		bh = bh->b_this_page;

2627
	if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
2628 2629 2630 2631
		return 0;
	return 1;
}

2632
static int ext4_da_write_end(struct file *file,
2633 2634 2635
			     struct address_space *mapping,
			     loff_t pos, unsigned len, unsigned copied,
			     struct page *page, void *fsdata)
2636 2637 2638 2639 2640
{
	struct inode *inode = mapping->host;
	int ret = 0, ret2;
	handle_t *handle = ext4_journal_current_handle();
	loff_t new_i_size;
2641
	unsigned long start, end;
2642 2643 2644
	int write_mode = (int)(unsigned long)fsdata;

	if (write_mode == FALL_BACK_TO_NONDELALLOC) {
2645 2646
		switch (ext4_inode_journal_mode(inode)) {
		case EXT4_INODE_ORDERED_DATA_MODE:
2647 2648
			return ext4_ordered_write_end(file, mapping, pos,
					len, copied, page, fsdata);
2649
		case EXT4_INODE_WRITEBACK_DATA_MODE:
2650 2651
			return ext4_writeback_write_end(file, mapping, pos,
					len, copied, page, fsdata);
2652
		default:
2653 2654 2655
			BUG();
		}
	}
2656

2657
	trace_ext4_da_write_end(inode, pos, len, copied);
2658
	start = pos & (PAGE_CACHE_SIZE - 1);
2659
	end = start + copied - 1;
2660 2661 2662 2663 2664 2665 2666

	/*
	 * 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;
2667
	if (copied && new_i_size > EXT4_I(inode)->i_disksize) {
2668 2669
		if (ext4_has_inline_data(inode) ||
		    ext4_da_should_update_i_disksize(page, end)) {
2670
			down_write(&EXT4_I(inode)->i_data_sem);
2671
			if (new_i_size > EXT4_I(inode)->i_disksize)
2672 2673
				EXT4_I(inode)->i_disksize = new_i_size;
			up_write(&EXT4_I(inode)->i_data_sem);
2674 2675 2676 2677 2678
			/* 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);
2679
		}
2680
	}
2681 2682 2683 2684 2685 2686 2687 2688

	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,
2689
							page, fsdata);
2690

2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709
	copied = ret2;
	if (ret2 < 0)
		ret = ret2;
	ret2 = ext4_journal_stop(handle);
	if (!ret)
		ret = ret2;

	return ret ? ret : copied;
}

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

2710
	ext4_da_page_release_reservation(page, offset);
2711 2712 2713 2714 2715 2716 2717

out:
	ext4_invalidatepage(page, offset);

	return;
}

2718 2719 2720 2721 2722
/*
 * Force all delayed allocation blocks to be allocated for a given inode.
 */
int ext4_alloc_da_blocks(struct inode *inode)
{
2723 2724
	trace_ext4_alloc_da_blocks(inode);

2725 2726 2727 2728 2729 2730 2731 2732 2733 2734
	if (!EXT4_I(inode)->i_reserved_data_blocks &&
	    !EXT4_I(inode)->i_reserved_meta_blocks)
		return 0;

	/*
	 * We do something simple for now.  The filemap_flush() will
	 * also start triggering a write of the data blocks, which is
	 * not strictly speaking necessary (and for users of
	 * laptop_mode, not even desirable).  However, to do otherwise
	 * would require replicating code paths in:
2735
	 *
2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747
	 * ext4_da_writepages() ->
	 *    write_cache_pages() ---> (via passed in callback function)
	 *        __mpage_da_writepage() -->
	 *           mpage_add_bh_to_extent()
	 *           mpage_da_map_blocks()
	 *
	 * The problem is that write_cache_pages(), located in
	 * mm/page-writeback.c, marks pages clean in preparation for
	 * doing I/O, which is not desirable if we're not planning on
	 * doing I/O at all.
	 *
	 * We could call write_cache_pages(), and then redirty all of
2748
	 * the pages by calling redirty_page_for_writepage() but that
2749 2750
	 * 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 已提交
2751
	 * simplifying them because we wouldn't actually intend to
2752 2753 2754
	 * 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.
2755
	 *
2756 2757 2758 2759 2760 2761
	 * 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);
}
2762

2763 2764 2765 2766 2767
/*
 * 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
2768
 * journal.  If somebody makes a swapfile on an ext4 data-journaling
2769 2770 2771 2772 2773 2774 2775 2776
 * 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.
 */
2777
static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
2778 2779 2780 2781 2782
{
	struct inode *inode = mapping->host;
	journal_t *journal;
	int err;

T
Tao Ma 已提交
2783 2784 2785 2786 2787 2788
	/*
	 * We can get here for an inline file via the FIBMAP ioctl
	 */
	if (ext4_has_inline_data(inode))
		return 0;

2789 2790 2791 2792 2793 2794 2795 2796 2797 2798
	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);
	}

2799 2800
	if (EXT4_JOURNAL(inode) &&
	    ext4_test_inode_state(inode, EXT4_STATE_JDATA)) {
2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811
		/*
		 * 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.)
		 *
2812
		 * NB. EXT4_STATE_JDATA is not set on files other than
2813 2814 2815 2816 2817 2818
		 * 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.
		 */

2819
		ext4_clear_inode_state(inode, EXT4_STATE_JDATA);
2820
		journal = EXT4_JOURNAL(inode);
2821 2822 2823
		jbd2_journal_lock_updates(journal);
		err = jbd2_journal_flush(journal);
		jbd2_journal_unlock_updates(journal);
2824 2825 2826 2827 2828

		if (err)
			return 0;
	}

2829
	return generic_block_bmap(mapping, block, ext4_get_block);
2830 2831
}

2832
static int ext4_readpage(struct file *file, struct page *page)
2833
{
T
Tao Ma 已提交
2834 2835 2836
	int ret = -EAGAIN;
	struct inode *inode = page->mapping->host;

2837
	trace_ext4_readpage(page);
T
Tao Ma 已提交
2838 2839 2840 2841 2842 2843 2844 2845

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

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

	return ret;
2846 2847 2848
}

static int
2849
ext4_readpages(struct file *file, struct address_space *mapping,
2850 2851
		struct list_head *pages, unsigned nr_pages)
{
T
Tao Ma 已提交
2852 2853 2854 2855 2856 2857
	struct inode *inode = mapping->host;

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

2858
	return mpage_readpages(mapping, pages, nr_pages, ext4_get_block);
2859 2860
}

2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880
static void ext4_invalidatepage_free_endio(struct page *page, unsigned long offset)
{
	struct buffer_head *head, *bh;
	unsigned int curr_off = 0;

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

2881
static void ext4_invalidatepage(struct page *page, unsigned long offset)
2882
{
2883 2884
	trace_ext4_invalidatepage(page, offset);

2885 2886 2887 2888 2889
	/*
	 * free any io_end structure allocated for buffers to be discarded
	 */
	if (ext4_should_dioread_nolock(page->mapping->host))
		ext4_invalidatepage_free_endio(page, offset);
2890 2891 2892 2893 2894 2895 2896

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

	block_invalidatepage(page, offset);
}

2897 2898
static int __ext4_journalled_invalidatepage(struct page *page,
					    unsigned long offset)
2899 2900 2901 2902 2903
{
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);

	trace_ext4_journalled_invalidatepage(page, offset);

2904 2905 2906 2907 2908 2909
	/*
	 * If it's a full truncate we just forget about the pending dirtying
	 */
	if (offset == 0)
		ClearPageChecked(page);

2910 2911 2912 2913 2914 2915 2916 2917
	return jbd2_journal_invalidatepage(journal, page, offset);
}

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

2920
static int ext4_releasepage(struct page *page, gfp_t wait)
2921
{
2922
	journal_t *journal = EXT4_JOURNAL(page->mapping->host);
2923

2924 2925
	trace_ext4_releasepage(page);

2926 2927 2928
	WARN_ON(PageChecked(page));
	if (!page_has_buffers(page))
		return 0;
2929 2930 2931 2932
	if (journal)
		return jbd2_journal_try_to_free_buffers(journal, page, wait);
	else
		return try_to_free_buffers(page);
2933 2934
}

2935 2936 2937 2938 2939
/*
 * ext4_get_block used when preparing for a DIO write or buffer write.
 * We allocate an uinitialized extent if blocks haven't been allocated.
 * The extent will be converted to initialized after the IO is complete.
 */
2940
int ext4_get_block_write(struct inode *inode, sector_t iblock,
2941 2942
		   struct buffer_head *bh_result, int create)
{
2943
	ext4_debug("ext4_get_block_write: inode %lu, create flag %d\n",
2944
		   inode->i_ino, create);
2945 2946
	return _ext4_get_block(inode, iblock, bh_result,
			       EXT4_GET_BLOCKS_IO_CREATE_EXT);
2947 2948
}

2949
static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
2950
		   struct buffer_head *bh_result, int create)
2951
{
2952 2953 2954 2955
	ext4_debug("ext4_get_block_write_nolock: inode %lu, create flag %d\n",
		   inode->i_ino, create);
	return _ext4_get_block(inode, iblock, bh_result,
			       EXT4_GET_BLOCKS_NO_LOCK);
2956 2957
}

2958
static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
2959 2960
			    ssize_t size, void *private, int ret,
			    bool is_async)
2961
{
2962
	struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
2963 2964
        ext4_io_end_t *io_end = iocb->private;

2965 2966
	/* if not async direct IO or dio with 0 bytes write, just return */
	if (!io_end || !size)
2967
		goto out;
2968

2969
	ext_debug("ext4_end_io_dio(): io_end 0x%p "
2970
		  "for inode %lu, iocb 0x%p, offset %llu, size %zd\n",
2971 2972 2973
 		  iocb->private, io_end->inode->i_ino, iocb, offset,
		  size);

2974 2975
	iocb->private = NULL;

2976
	/* if not aio dio with unwritten extents, just free io and return */
2977
	if (!(io_end->flag & EXT4_IO_END_UNWRITTEN)) {
2978
		ext4_free_io_end(io_end);
2979 2980 2981
out:
		if (is_async)
			aio_complete(iocb, ret, 0);
2982
		inode_dio_done(inode);
2983
		return;
2984 2985
	}

2986 2987
	io_end->offset = offset;
	io_end->size = size;
2988 2989 2990 2991
	if (is_async) {
		io_end->iocb = iocb;
		io_end->result = ret;
	}
2992

2993
	ext4_add_complete_io(io_end);
2994
}
2995

2996 2997 2998 2999 3000 3001 3002 3003 3004
static void ext4_end_io_buffer_write(struct buffer_head *bh, int uptodate)
{
	ext4_io_end_t *io_end = bh->b_private;
	struct inode *inode;

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

	if (!(io_end->inode->i_sb->s_flags & MS_ACTIVE)) {
3005 3006 3007
		ext4_msg(io_end->inode->i_sb, KERN_INFO,
			 "sb umounted, discard end_io request for inode %lu",
			 io_end->inode->i_ino);
3008 3009 3010 3011
		ext4_free_io_end(io_end);
		goto out;
	}

3012 3013 3014 3015
	/*
	 * It may be over-defensive here to check EXT4_IO_END_UNWRITTEN now,
	 * but being more careful is always safe for the future change.
	 */
3016
	inode = io_end->inode;
3017
	ext4_set_io_unwritten_flag(inode, io_end);
3018
	ext4_add_complete_io(io_end);
3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035
out:
	bh->b_private = NULL;
	bh->b_end_io = NULL;
	clear_buffer_uninit(bh);
	end_buffer_async_write(bh, uptodate);
}

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

retry:
	io_end = ext4_init_io_end(inode, GFP_ATOMIC);
	if (!io_end) {
3036
		pr_warn_ratelimited("%s: allocation fail\n", __func__);
3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054
		schedule();
		goto retry;
	}
	io_end->offset = offset;
	io_end->size = size;
	/*
	 * We need to hold a reference to the page to make sure it
	 * doesn't get evicted before ext4_end_io_work() has a chance
	 * to convert the extent from written to unwritten.
	 */
	io_end->page = page;
	get_page(io_end->page);

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

3055 3056 3057 3058 3059
/*
 * For ext4 extent files, ext4 will do direct-io write to holes,
 * preallocated extents, and those write extend the file, no need to
 * fall back to buffered IO.
 *
3060
 * For holes, we fallocate those blocks, mark them as uninitialized
3061
 * If those blocks were preallocated, we mark sure they are split, but
3062
 * still keep the range to write as uninitialized.
3063
 *
3064
 * The unwritten extents will be converted to written when DIO is completed.
3065
 * For async direct IO, since the IO may still pending when return, we
L
Lucas De Marchi 已提交
3066
 * set up an end_io call back function, which will do the conversion
3067
 * when async direct IO completed.
3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081
 *
 * If the O_DIRECT write will extend the file then add this inode to the
 * orphan list.  So recovery will truncate it back to the original size
 * if the machine crashes during the write.
 *
 */
static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
			      const struct iovec *iov, loff_t offset,
			      unsigned long nr_segs)
{
	struct file *file = iocb->ki_filp;
	struct inode *inode = file->f_mapping->host;
	ssize_t ret;
	size_t count = iov_length(iov, nr_segs);
3082 3083 3084
	int overwrite = 0;
	get_block_t *get_block_func = NULL;
	int dio_flags = 0;
3085
	loff_t final_size = offset + count;
3086

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

3091
	BUG_ON(iocb->private == NULL);
3092

3093 3094
	/* If we do a overwrite dio, i_mutex locking can be released */
	overwrite = *((int *)iocb->private);
3095

3096 3097 3098 3099 3100
	if (overwrite) {
		atomic_inc(&inode->i_dio_count);
		down_read(&EXT4_I(inode)->i_data_sem);
		mutex_unlock(&inode->i_mutex);
	}
3101

3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127
	/*
	 * We could direct write to holes and fallocate.
	 *
	 * Allocated blocks to fill the hole are marked as
	 * uninitialized to prevent parallel buffered read to expose
	 * the stale data before DIO complete the data IO.
	 *
	 * As to previously fallocated extents, ext4 get_block will
	 * just simply mark the buffer mapped but still keep the
	 * extents uninitialized.
	 *
	 * For non AIO case, we will convert those unwritten extents
	 * to written after return back from blockdev_direct_IO.
	 *
	 * For async DIO, the conversion needs to be deferred when the
	 * IO is completed. The ext4 end_io callback function will be
	 * called to take care of the conversion work.  Here for async
	 * case, we allocate an io_end structure to hook to the iocb.
	 */
	iocb->private = NULL;
	ext4_inode_aio_set(inode, NULL);
	if (!is_sync_kiocb(iocb)) {
		ext4_io_end_t *io_end = ext4_init_io_end(inode, GFP_NOFS);
		if (!io_end) {
			ret = -ENOMEM;
			goto retake_lock;
3128
		}
3129 3130
		io_end->flag |= EXT4_IO_END_DIRECT;
		iocb->private = io_end;
3131
		/*
3132 3133 3134 3135
		 * we save the io structure for current async direct
		 * IO, so that later ext4_map_blocks() could flag the
		 * io structure whether there is a unwritten extents
		 * needs to be converted when IO is completed.
3136
		 */
3137 3138
		ext4_inode_aio_set(inode, io_end);
	}
3139

3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185
	if (overwrite) {
		get_block_func = ext4_get_block_write_nolock;
	} else {
		get_block_func = ext4_get_block_write;
		dio_flags = DIO_LOCKING;
	}
	ret = __blockdev_direct_IO(rw, iocb, inode,
				   inode->i_sb->s_bdev, iov,
				   offset, nr_segs,
				   get_block_func,
				   ext4_end_io_dio,
				   NULL,
				   dio_flags);

	if (iocb->private)
		ext4_inode_aio_set(inode, NULL);
	/*
	 * The io_end structure takes a reference to the inode, that
	 * structure needs to be destroyed and the reference to the
	 * inode need to be dropped, when IO is complete, even with 0
	 * byte write, or failed.
	 *
	 * In the successful AIO DIO case, the io_end structure will
	 * be destroyed and the reference to the inode will be dropped
	 * after the end_io call back function is called.
	 *
	 * In the case there is 0 byte write, or error case, since VFS
	 * direct IO won't invoke the end_io call back function, we
	 * need to free the end_io structure here.
	 */
	if (ret != -EIOCBQUEUED && ret <= 0 && iocb->private) {
		ext4_free_io_end(iocb->private);
		iocb->private = NULL;
	} else if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
						EXT4_STATE_DIO_UNWRITTEN)) {
		int err;
		/*
		 * for non AIO case, since the IO is already
		 * completed, we could do the conversion right here
		 */
		err = ext4_convert_unwritten_extents(inode,
						     offset, ret);
		if (err < 0)
			ret = err;
		ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
	}
3186

3187 3188 3189 3190 3191 3192
retake_lock:
	/* take i_mutex locking again if we do a ovewrite dio */
	if (overwrite) {
		inode_dio_done(inode);
		up_read(&EXT4_I(inode)->i_data_sem);
		mutex_lock(&inode->i_mutex);
3193
	}
3194

3195
	return ret;
3196 3197 3198 3199 3200 3201 3202 3203
}

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

3206 3207 3208 3209 3210 3211
	/*
	 * If we are doing data journalling we don't support O_DIRECT
	 */
	if (ext4_should_journal_data(inode))
		return 0;

T
Tao Ma 已提交
3212 3213 3214 3215
	/* Let buffer I/O handle the inline data case. */
	if (ext4_has_inline_data(inode))
		return 0;

3216
	trace_ext4_direct_IO_enter(inode, offset, iov_length(iov, nr_segs), rw);
3217
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3218 3219 3220 3221 3222 3223
		ret = ext4_ext_direct_IO(rw, iocb, iov, offset, nr_segs);
	else
		ret = ext4_ind_direct_IO(rw, iocb, iov, offset, nr_segs);
	trace_ext4_direct_IO_exit(inode, offset,
				iov_length(iov, nr_segs), rw, ret);
	return ret;
3224 3225
}

3226
/*
3227
 * Pages can be marked dirty completely asynchronously from ext4's journalling
3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238
 * 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.
 */
3239
static int ext4_journalled_set_page_dirty(struct page *page)
3240 3241 3242 3243 3244
{
	SetPageChecked(page);
	return __set_page_dirty_nobuffers(page);
}

3245
static const struct address_space_operations ext4_ordered_aops = {
3246 3247
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3248
	.writepage		= ext4_writepage,
3249 3250 3251 3252 3253 3254 3255 3256
	.write_begin		= ext4_write_begin,
	.write_end		= ext4_ordered_write_end,
	.bmap			= ext4_bmap,
	.invalidatepage		= ext4_invalidatepage,
	.releasepage		= ext4_releasepage,
	.direct_IO		= ext4_direct_IO,
	.migratepage		= buffer_migrate_page,
	.is_partially_uptodate  = block_is_partially_uptodate,
3257
	.error_remove_page	= generic_error_remove_page,
3258 3259
};

3260
static const struct address_space_operations ext4_writeback_aops = {
3261 3262
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3263
	.writepage		= ext4_writepage,
3264 3265 3266 3267 3268 3269 3270 3271
	.write_begin		= ext4_write_begin,
	.write_end		= ext4_writeback_write_end,
	.bmap			= ext4_bmap,
	.invalidatepage		= ext4_invalidatepage,
	.releasepage		= ext4_releasepage,
	.direct_IO		= ext4_direct_IO,
	.migratepage		= buffer_migrate_page,
	.is_partially_uptodate  = block_is_partially_uptodate,
3272
	.error_remove_page	= generic_error_remove_page,
3273 3274
};

3275
static const struct address_space_operations ext4_journalled_aops = {
3276 3277
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3278
	.writepage		= ext4_writepage,
3279 3280 3281 3282
	.write_begin		= ext4_write_begin,
	.write_end		= ext4_journalled_write_end,
	.set_page_dirty		= ext4_journalled_set_page_dirty,
	.bmap			= ext4_bmap,
3283
	.invalidatepage		= ext4_journalled_invalidatepage,
3284
	.releasepage		= ext4_releasepage,
3285
	.direct_IO		= ext4_direct_IO,
3286
	.is_partially_uptodate  = block_is_partially_uptodate,
3287
	.error_remove_page	= generic_error_remove_page,
3288 3289
};

3290
static const struct address_space_operations ext4_da_aops = {
3291 3292
	.readpage		= ext4_readpage,
	.readpages		= ext4_readpages,
3293
	.writepage		= ext4_writepage,
3294 3295 3296 3297 3298 3299 3300 3301 3302
	.writepages		= ext4_da_writepages,
	.write_begin		= ext4_da_write_begin,
	.write_end		= ext4_da_write_end,
	.bmap			= ext4_bmap,
	.invalidatepage		= ext4_da_invalidatepage,
	.releasepage		= ext4_releasepage,
	.direct_IO		= ext4_direct_IO,
	.migratepage		= buffer_migrate_page,
	.is_partially_uptodate  = block_is_partially_uptodate,
3303
	.error_remove_page	= generic_error_remove_page,
3304 3305
};

3306
void ext4_set_aops(struct inode *inode)
3307
{
3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321
	switch (ext4_inode_journal_mode(inode)) {
	case EXT4_INODE_ORDERED_DATA_MODE:
		if (test_opt(inode->i_sb, DELALLOC))
			inode->i_mapping->a_ops = &ext4_da_aops;
		else
			inode->i_mapping->a_ops = &ext4_ordered_aops;
		break;
	case EXT4_INODE_WRITEBACK_DATA_MODE:
		if (test_opt(inode->i_sb, DELALLOC))
			inode->i_mapping->a_ops = &ext4_da_aops;
		else
			inode->i_mapping->a_ops = &ext4_writeback_aops;
		break;
	case EXT4_INODE_JOURNAL_DATA_MODE:
3322
		inode->i_mapping->a_ops = &ext4_journalled_aops;
3323 3324 3325 3326
		break;
	default:
		BUG();
	}
3327 3328
}

3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348

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

	page = find_or_create_page(mapping, from >> PAGE_CACHE_SHIFT,
				   mapping_gfp_mask(mapping) & ~__GFP_FS);
	if (!page)
3349
		return -ENOMEM;
3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377

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

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

/*
 * ext4_discard_partial_page_buffers_no_lock()
 * Zeros a page range of length 'length' starting from offset 'from'.
 * Buffer heads that correspond to the block aligned regions of the
 * zeroed range will be unmapped.  Unblock aligned regions
 * will have the corresponding buffer head mapped if needed so that
 * that region of the page can be updated with the partial zero out.
 *
 * This function assumes that the page has already been  locked.  The
 * The range to be discarded must be contained with in the given page.
 * If the specified range exceeds the end of the page it will be shortened
 * to the end of the page that corresponds to 'from'.  This function is
 * appropriate for updating a page and it buffer heads to be unmapped and
 * zeroed for blocks that have been either released, or are going to be
 * released.
 *
 * handle: The journal handle
 * inode:  The files inode
 * page:   A locked page that contains the offset "from"
3378
 * from:   The starting byte offset (from the beginning of the file)
3379 3380 3381 3382 3383 3384 3385
 *         to begin discarding
 * len:    The length of bytes to discard
 * flags:  Optional flags that may be used:
 *
 *         EXT4_DISCARD_PARTIAL_PG_ZERO_UNMAPPED
 *         Only zero the regions of the page whose buffer heads
 *         have already been unmapped.  This flag is appropriate
3386
 *         for updating the contents of a page whose blocks may
3387 3388 3389
 *         have already been released, and we only want to zero
 *         out the regions that correspond to those released blocks.
 *
3390
 * Returns zero on success or negative on failure.
3391
 */
E
Eric Sandeen 已提交
3392
static int ext4_discard_partial_page_buffers_no_lock(handle_t *handle,
3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417
		struct inode *inode, struct page *page, loff_t from,
		loff_t length, int flags)
{
	ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT;
	unsigned int offset = from & (PAGE_CACHE_SIZE-1);
	unsigned int blocksize, max, pos;
	ext4_lblk_t iblock;
	struct buffer_head *bh;
	int err = 0;

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

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

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

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

3418 3419
	if (!page_has_buffers(page))
		create_empty_buffers(page, blocksize, 0);
3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431

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

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

3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518
		err = 0;

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

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

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


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

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

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

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

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

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

		zero_user(page, pos, range_to_discard);

		err = 0;
		if (ext4_should_journal_data(inode)) {
			err = ext4_handle_dirty_metadata(handle, inode, bh);
3519
		} else
3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531
			mark_buffer_dirty(bh);

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

	return err;
}

3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542
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;
}

3543 3544 3545 3546 3547 3548 3549 3550
/*
 * ext4_punch_hole: punches a hole in a file by releaseing the blocks
 * associated with the given offset and length
 *
 * @inode:  File inode
 * @offset: The offset where the hole will begin
 * @len:    The length of the hole
 *
3551
 * Returns: 0 on success or negative on failure
3552 3553 3554 3555 3556 3557
 */

int ext4_punch_hole(struct file *file, loff_t offset, loff_t length)
{
	struct inode *inode = file->f_path.dentry->d_inode;
	if (!S_ISREG(inode->i_mode))
3558
		return -EOPNOTSUPP;
3559 3560 3561

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

3565 3566
	if (EXT4_SB(inode->i_sb)->s_cluster_ratio > 1) {
		/* TODO: Add support for bigalloc file systems */
3567
		return -EOPNOTSUPP;
3568 3569
	}

3570 3571 3572
	return ext4_ext_punch_hole(file, offset, length);
}

3573
/*
3574
 * ext4_truncate()
3575
 *
3576 3577
 * We block out ext4_get_block() block instantiations across the entire
 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
3578 3579
 * simultaneously on behalf of the same inode.
 *
3580
 * As we work through the truncate and commit bits of it to the journal there
3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593
 * 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
3594
 * i_disksize in this case).  After a crash, ext4_orphan_cleanup() will see
3595
 * that this inode's truncate did not complete and it will again call
3596 3597
 * 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
3598
 * that's fine - as long as they are linked from the inode, the post-crash
3599
 * ext4_truncate() run will find them and release them.
3600
 */
3601
void ext4_truncate(struct inode *inode)
3602
{
3603 3604
	trace_ext4_truncate_enter(inode);

3605
	if (!ext4_can_truncate(inode))
3606 3607
		return;

3608
	ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
3609

3610
	if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
3611
		ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
3612

3613 3614 3615 3616 3617 3618 3619 3620
	if (ext4_has_inline_data(inode)) {
		int has_inline = 1;

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

3621
	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3622
		ext4_ext_truncate(inode);
3623 3624
	else
		ext4_ind_truncate(inode);
3625

3626
	trace_ext4_truncate_exit(inode);
3627 3628 3629
}

/*
3630
 * ext4_get_inode_loc returns with an extra refcount against the inode's
3631 3632 3633 3634
 * 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.
 */
3635 3636
static int __ext4_get_inode_loc(struct inode *inode,
				struct ext4_iloc *iloc, int in_mem)
3637
{
3638 3639 3640 3641 3642 3643
	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 已提交
3644
	iloc->bh = NULL;
3645 3646
	if (!ext4_valid_inum(sb, inode->i_ino))
		return -EIO;
3647

3648 3649 3650
	iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
	gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
	if (!gdp)
3651 3652
		return -EIO;

3653 3654 3655
	/*
	 * Figure out the offset within the block group inode table
	 */
3656
	inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
3657 3658 3659 3660 3661 3662
	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);
3663
	if (unlikely(!bh))
3664
		return -ENOMEM;
3665 3666
	if (!buffer_uptodate(bh)) {
		lock_buffer(bh);
3667 3668 3669 3670 3671 3672 3673 3674 3675 3676

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

3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689
		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;
3690
			int i, start;
3691

3692
			start = inode_offset & ~(inodes_per_block - 1);
3693

3694 3695
			/* Is the inode bitmap in cache? */
			bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
3696
			if (unlikely(!bitmap_bh))
3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707
				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;
			}
3708
			for (i = start; i < start + inodes_per_block; i++) {
3709 3710
				if (i == inode_offset)
					continue;
3711
				if (ext4_test_bit(i, bitmap_bh->b_data))
3712 3713 3714
					break;
			}
			brelse(bitmap_bh);
3715
			if (i == start + inodes_per_block) {
3716 3717 3718 3719 3720 3721 3722 3723 3724
				/* 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:
3725 3726 3727 3728 3729 3730 3731 3732 3733
		/*
		 * If we need to do any I/O, try to pre-readahead extra
		 * blocks from the inode table.
		 */
		if (EXT4_SB(sb)->s_inode_readahead_blks) {
			ext4_fsblk_t b, end, table;
			unsigned num;

			table = ext4_inode_table(sb, gdp);
T
Theodore Ts'o 已提交
3734
			/* s_inode_readahead_blks is always a power of 2 */
3735 3736 3737 3738 3739
			b = block & ~(EXT4_SB(sb)->s_inode_readahead_blks-1);
			if (table > b)
				b = table;
			end = b + EXT4_SB(sb)->s_inode_readahead_blks;
			num = EXT4_INODES_PER_GROUP(sb);
3740
			if (ext4_has_group_desc_csum(sb))
3741
				num -= ext4_itable_unused_count(sb, gdp);
3742 3743 3744 3745 3746 3747 3748
			table += num / inodes_per_block;
			if (end > table)
				end = table;
			while (b <= end)
				sb_breadahead(sb, b++);
		}

3749 3750 3751 3752 3753
		/*
		 * 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.
		 */
3754
		trace_ext4_load_inode(inode);
3755 3756
		get_bh(bh);
		bh->b_end_io = end_buffer_read_sync;
3757
		submit_bh(READ | REQ_META | REQ_PRIO, bh);
3758 3759
		wait_on_buffer(bh);
		if (!buffer_uptodate(bh)) {
3760 3761
			EXT4_ERROR_INODE_BLOCK(inode, block,
					       "unable to read itable block");
3762 3763 3764 3765 3766 3767 3768 3769 3770
			brelse(bh);
			return -EIO;
		}
	}
has_buffer:
	iloc->bh = bh;
	return 0;
}

3771
int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
3772 3773
{
	/* We have all inode data except xattrs in memory here. */
3774
	return __ext4_get_inode_loc(inode, iloc,
3775
		!ext4_test_inode_state(inode, EXT4_STATE_XATTR));
3776 3777
}

3778
void ext4_set_inode_flags(struct inode *inode)
3779
{
3780
	unsigned int flags = EXT4_I(inode)->i_flags;
3781 3782

	inode->i_flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
3783
	if (flags & EXT4_SYNC_FL)
3784
		inode->i_flags |= S_SYNC;
3785
	if (flags & EXT4_APPEND_FL)
3786
		inode->i_flags |= S_APPEND;
3787
	if (flags & EXT4_IMMUTABLE_FL)
3788
		inode->i_flags |= S_IMMUTABLE;
3789
	if (flags & EXT4_NOATIME_FL)
3790
		inode->i_flags |= S_NOATIME;
3791
	if (flags & EXT4_DIRSYNC_FL)
3792 3793 3794
		inode->i_flags |= S_DIRSYNC;
}

3795 3796 3797
/* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
void ext4_get_inode_flags(struct ext4_inode_info *ei)
{
3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817
	unsigned int vfs_fl;
	unsigned long old_fl, new_fl;

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

3820
static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
3821
				  struct ext4_inode_info *ei)
3822 3823
{
	blkcnt_t i_blocks ;
A
Aneesh Kumar K.V 已提交
3824 3825
	struct inode *inode = &(ei->vfs_inode);
	struct super_block *sb = inode->i_sb;
3826 3827 3828 3829 3830 3831

	if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
				EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
		/* we are using combined 48 bit field */
		i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
					le32_to_cpu(raw_inode->i_blocks_lo);
3832
		if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) {
A
Aneesh Kumar K.V 已提交
3833 3834 3835 3836 3837
			/* i_blocks represent file system block size */
			return i_blocks  << (inode->i_blkbits - 9);
		} else {
			return i_blocks;
		}
3838 3839 3840 3841
	} else {
		return le32_to_cpu(raw_inode->i_blocks_lo);
	}
}
3842

3843 3844 3845 3846 3847 3848
static inline void ext4_iget_extra_inode(struct inode *inode,
					 struct ext4_inode *raw_inode,
					 struct ext4_inode_info *ei)
{
	__le32 *magic = (void *)raw_inode +
			EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize;
3849
	if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC)) {
3850
		ext4_set_inode_state(inode, EXT4_STATE_XATTR);
3851
		ext4_find_inline_data_nolock(inode);
3852 3853
	} else
		EXT4_I(inode)->i_inline_off = 0;
3854 3855
}

3856
struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
3857
{
3858 3859
	struct ext4_iloc iloc;
	struct ext4_inode *raw_inode;
3860 3861
	struct ext4_inode_info *ei;
	struct inode *inode;
3862
	journal_t *journal = EXT4_SB(sb)->s_journal;
3863
	long ret;
3864
	int block;
3865 3866
	uid_t i_uid;
	gid_t i_gid;
3867

3868 3869 3870 3871 3872 3873 3874
	inode = iget_locked(sb, ino);
	if (!inode)
		return ERR_PTR(-ENOMEM);
	if (!(inode->i_state & I_NEW))
		return inode;

	ei = EXT4_I(inode);
3875
	iloc.bh = NULL;
3876

3877 3878
	ret = __ext4_get_inode_loc(inode, &iloc, 0);
	if (ret < 0)
3879
		goto bad_inode;
3880
	raw_inode = ext4_raw_inode(&iloc);
3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913

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

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

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

3914
	inode->i_mode = le16_to_cpu(raw_inode->i_mode);
3915 3916
	i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
	i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
3917
	if (!(test_opt(inode->i_sb, NO_UID32))) {
3918 3919
		i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
		i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
3920
	}
3921 3922
	i_uid_write(inode, i_uid);
	i_gid_write(inode, i_gid);
M
Miklos Szeredi 已提交
3923
	set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
3924

3925
	ext4_clear_state_flags(ei);	/* Only relevant on 32-bit archs */
3926
	ei->i_inline_off = 0;
3927 3928 3929 3930 3931 3932 3933 3934 3935
	ei->i_dir_start_lookup = 0;
	ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
	/* We now have enough fields to check if the inode was active or not.
	 * This is needed because nfsd might try to access dead inodes
	 * the test is that same one that e2fsck uses
	 * NeilBrown 1999oct15
	 */
	if (inode->i_nlink == 0) {
		if (inode->i_mode == 0 ||
3936
		    !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) {
3937
			/* this inode is deleted */
3938
			ret = -ESTALE;
3939 3940 3941 3942 3943 3944 3945 3946
			goto bad_inode;
		}
		/* The only unlinked inodes we let through here have
		 * valid i_mode and are being read by the orphan
		 * recovery code: that's fine, we're about to complete
		 * the process of deleting those. */
	}
	ei->i_flags = le32_to_cpu(raw_inode->i_flags);
3947
	inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
3948
	ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
3949
	if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT))
B
Badari Pulavarty 已提交
3950 3951
		ei->i_file_acl |=
			((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
3952
	inode->i_size = ext4_isize(raw_inode);
3953
	ei->i_disksize = inode->i_size;
3954 3955 3956
#ifdef CONFIG_QUOTA
	ei->i_reserved_quota = 0;
#endif
3957 3958
	inode->i_generation = le32_to_cpu(raw_inode->i_generation);
	ei->i_block_group = iloc.block_group;
3959
	ei->i_last_alloc_group = ~0;
3960 3961 3962 3963
	/*
	 * 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!
	 */
3964
	for (block = 0; block < EXT4_N_BLOCKS; block++)
3965 3966 3967
		ei->i_data[block] = raw_inode->i_block[block];
	INIT_LIST_HEAD(&ei->i_orphan);

3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978
	/*
	 * 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;

3979
		read_lock(&journal->j_state_lock);
3980 3981 3982 3983 3984 3985 3986 3987
		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;
3988
		read_unlock(&journal->j_state_lock);
3989 3990 3991 3992
		ei->i_sync_tid = tid;
		ei->i_datasync_tid = tid;
	}

3993
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
3994 3995
		if (ei->i_extra_isize == 0) {
			/* The extra space is currently unused. Use it. */
3996 3997
			ei->i_extra_isize = sizeof(struct ext4_inode) -
					    EXT4_GOOD_OLD_INODE_SIZE;
3998
		} else {
3999
			ext4_iget_extra_inode(inode, raw_inode, ei);
4000
		}
4001
	}
4002

K
Kalpak Shah 已提交
4003 4004 4005 4006 4007
	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);

4008 4009 4010 4011 4012 4013 4014
	inode->i_version = le32_to_cpu(raw_inode->i_disk_version);
	if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
		if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
			inode->i_version |=
			(__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
	}

4015
	ret = 0;
4016
	if (ei->i_file_acl &&
4017
	    !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
4018 4019
		EXT4_ERROR_INODE(inode, "bad extended attribute block %llu",
				 ei->i_file_acl);
4020 4021
		ret = -EIO;
		goto bad_inode;
4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034
	} else if (!ext4_has_inline_data(inode)) {
		if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
			if ((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
			    (S_ISLNK(inode->i_mode) &&
			     !ext4_inode_is_fast_symlink(inode))))
				/* Validate extent which is part of inode */
				ret = ext4_ext_check_inode(inode);
		} else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
			   (S_ISLNK(inode->i_mode) &&
			    !ext4_inode_is_fast_symlink(inode))) {
			/* Validate block references which are part of inode */
			ret = ext4_ind_check_inode(inode);
		}
4035
	}
4036
	if (ret)
4037
		goto bad_inode;
4038

4039
	if (S_ISREG(inode->i_mode)) {
4040 4041 4042
		inode->i_op = &ext4_file_inode_operations;
		inode->i_fop = &ext4_file_operations;
		ext4_set_aops(inode);
4043
	} else if (S_ISDIR(inode->i_mode)) {
4044 4045
		inode->i_op = &ext4_dir_inode_operations;
		inode->i_fop = &ext4_dir_operations;
4046
	} else if (S_ISLNK(inode->i_mode)) {
4047
		if (ext4_inode_is_fast_symlink(inode)) {
4048
			inode->i_op = &ext4_fast_symlink_inode_operations;
4049 4050 4051
			nd_terminate_link(ei->i_data, inode->i_size,
				sizeof(ei->i_data) - 1);
		} else {
4052 4053
			inode->i_op = &ext4_symlink_inode_operations;
			ext4_set_aops(inode);
4054
		}
4055 4056
	} else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
	      S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
4057
		inode->i_op = &ext4_special_inode_operations;
4058 4059 4060 4061 4062 4063
		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])));
4064 4065
	} else {
		ret = -EIO;
4066
		EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode);
4067
		goto bad_inode;
4068
	}
4069
	brelse(iloc.bh);
4070
	ext4_set_inode_flags(inode);
4071 4072
	unlock_new_inode(inode);
	return inode;
4073 4074

bad_inode:
4075
	brelse(iloc.bh);
4076 4077
	iget_failed(inode);
	return ERR_PTR(ret);
4078 4079
}

4080 4081 4082 4083 4084 4085 4086 4087 4088 4089
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) {
		/*
4090
		 * i_blocks can be represented in a 32 bit variable
4091 4092
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
4093
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
4094
		raw_inode->i_blocks_high = 0;
4095
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4096 4097 4098 4099 4100 4101
		return 0;
	}
	if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE))
		return -EFBIG;

	if (i_blocks <= 0xffffffffffffULL) {
4102 4103 4104 4105
		/*
		 * i_blocks can be represented in a 48 bit variable
		 * as multiple of 512 bytes
		 */
A
Aneesh Kumar K.V 已提交
4106
		raw_inode->i_blocks_lo   = cpu_to_le32(i_blocks);
4107
		raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
4108
		ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
4109
	} else {
4110
		ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE);
A
Aneesh Kumar K.V 已提交
4111 4112 4113 4114
		/* 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);
4115
	}
4116
	return 0;
4117 4118
}

4119 4120 4121 4122 4123 4124 4125
/*
 * 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.
 */
4126
static int ext4_do_update_inode(handle_t *handle,
4127
				struct inode *inode,
4128
				struct ext4_iloc *iloc)
4129
{
4130 4131
	struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
	struct ext4_inode_info *ei = EXT4_I(inode);
4132 4133
	struct buffer_head *bh = iloc->bh;
	int err = 0, rc, block;
4134
	int need_datasync = 0;
4135 4136
	uid_t i_uid;
	gid_t i_gid;
4137 4138 4139

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

4143
	ext4_get_inode_flags(ei);
4144
	raw_inode->i_mode = cpu_to_le16(inode->i_mode);
4145 4146
	i_uid = i_uid_read(inode);
	i_gid = i_gid_read(inode);
4147
	if (!(test_opt(inode->i_sb, NO_UID32))) {
4148 4149
		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));
4150 4151 4152 4153
/*
 * Fix up interoperability with old kernels. Otherwise, old inodes get
 * re-used with the upper 16 bits of the uid/gid intact
 */
4154
		if (!ei->i_dtime) {
4155
			raw_inode->i_uid_high =
4156
				cpu_to_le16(high_16_bits(i_uid));
4157
			raw_inode->i_gid_high =
4158
				cpu_to_le16(high_16_bits(i_gid));
4159 4160 4161 4162 4163
		} else {
			raw_inode->i_uid_high = 0;
			raw_inode->i_gid_high = 0;
		}
	} else {
4164 4165
		raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid));
		raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(i_gid));
4166 4167 4168 4169
		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 已提交
4170 4171 4172 4173 4174 4175

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

4176 4177
	if (ext4_inode_blocks_set(handle, raw_inode, ei))
		goto out_brelse;
4178
	raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
4179
	raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF);
4180 4181
	if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
	    cpu_to_le32(EXT4_OS_HURD))
B
Badari Pulavarty 已提交
4182 4183
		raw_inode->i_file_acl_high =
			cpu_to_le16(ei->i_file_acl >> 32);
4184
	raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
4185 4186 4187 4188
	if (ei->i_disksize != ext4_isize(raw_inode)) {
		ext4_isize_set(raw_inode, ei->i_disksize);
		need_datasync = 1;
	}
4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203
	if (ei->i_disksize > 0x7fffffffULL) {
		struct super_block *sb = inode->i_sb;
		if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
				EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
				EXT4_SB(sb)->s_es->s_rev_level ==
				cpu_to_le32(EXT4_GOOD_OLD_REV)) {
			/* If this is the first large file
			 * created, add a flag to the superblock.
			 */
			err = ext4_journal_get_write_access(handle,
					EXT4_SB(sb)->s_sbh);
			if (err)
				goto out_brelse;
			ext4_update_dynamic_rev(sb);
			EXT4_SET_RO_COMPAT_FEATURE(sb,
4204
					EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4205
			ext4_handle_sync(handle);
4206
			err = ext4_handle_dirty_super(handle, sb);
4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220
		}
	}
	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;
		}
4221
	} else if (!ext4_has_inline_data(inode)) {
4222 4223
		for (block = 0; block < EXT4_N_BLOCKS; block++)
			raw_inode->i_block[block] = ei->i_data[block];
4224
	}
4225

4226 4227 4228 4229 4230
	raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
	if (ei->i_extra_isize) {
		if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
			raw_inode->i_version_hi =
			cpu_to_le32(inode->i_version >> 32);
4231
		raw_inode->i_extra_isize = cpu_to_le16(ei->i_extra_isize);
4232 4233
	}

4234 4235
	ext4_inode_csum_set(inode, raw_inode, ei);

4236
	BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
4237
	rc = ext4_handle_dirty_metadata(handle, NULL, bh);
4238 4239
	if (!err)
		err = rc;
4240
	ext4_clear_inode_state(inode, EXT4_STATE_NEW);
4241

4242
	ext4_update_inode_fsync_trans(handle, inode, need_datasync);
4243
out_brelse:
4244
	brelse(bh);
4245
	ext4_std_error(inode->i_sb, err);
4246 4247 4248 4249
	return err;
}

/*
4250
 * ext4_write_inode()
4251 4252 4253 4254 4255
 *
 * We are called from a few places:
 *
 * - Within generic_file_write() for O_SYNC files.
 *   Here, there will be no transaction running. We wait for any running
4256
 *   transaction to commit.
4257 4258 4259 4260 4261 4262 4263 4264 4265 4266
 *
 * - Within sys_sync(), kupdate and such.
 *   We wait on commit, if tol to.
 *
 * - Within prune_icache() (PF_MEMALLOC == true)
 *   Here we simply return.  We can't afford to block kswapd on the
 *   journal commit.
 *
 * In all cases it is actually safe for us to return without doing anything,
 * because the inode has been copied into a raw inode buffer in
4267
 * ext4_mark_inode_dirty().  This is a correctness thing for O_SYNC and for
4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283
 * knfsd.
 *
 * Note that we are absolutely dependent upon all inode dirtiers doing the
 * right thing: they *must* call mark_inode_dirty() after dirtying info in
 * which we are interested.
 *
 * It would be a bug for them to not do this.  The code:
 *
 *	mark_inode_dirty(inode)
 *	stuff();
 *	inode->i_size = expr;
 *
 * is in error because a kswapd-driven write_inode() could occur while
 * `stuff()' is running, and the new i_size will be lost.  Plus the inode
 * will no longer be on the superblock's dirty inode list.
 */
4284
int ext4_write_inode(struct inode *inode, struct writeback_control *wbc)
4285
{
4286 4287
	int err;

4288 4289 4290
	if (current->flags & PF_MEMALLOC)
		return 0;

4291 4292 4293 4294 4295 4296
	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;
		}
4297

4298
		if (wbc->sync_mode != WB_SYNC_ALL)
4299 4300 4301 4302 4303
			return 0;

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

4305
		err = __ext4_get_inode_loc(inode, &iloc, 0);
4306 4307
		if (err)
			return err;
4308
		if (wbc->sync_mode == WB_SYNC_ALL)
4309 4310
			sync_dirty_buffer(iloc.bh);
		if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
4311 4312
			EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr,
					 "IO error syncing inode");
4313 4314
			err = -EIO;
		}
4315
		brelse(iloc.bh);
4316 4317
	}
	return err;
4318 4319
}

4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360
/*
 * In data=journal mode ext4_journalled_invalidatepage() may fail to invalidate
 * buffers that are attached to a page stradding i_size and are undergoing
 * commit. In that case we have to wait for commit to finish and try again.
 */
static void ext4_wait_for_tail_page_commit(struct inode *inode)
{
	struct page *page;
	unsigned offset;
	journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
	tid_t commit_tid = 0;
	int ret;

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

4361
/*
4362
 * ext4_setattr()
4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375
 *
 * 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.)
 *
4376 4377 4378 4379 4380 4381 4382 4383
 * 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.
4384
 */
4385
int ext4_setattr(struct dentry *dentry, struct iattr *attr)
4386 4387 4388
{
	struct inode *inode = dentry->d_inode;
	int error, rc = 0;
4389
	int orphan = 0;
4390 4391 4392 4393 4394 4395
	const unsigned int ia_valid = attr->ia_valid;

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

4396
	if (is_quota_modification(inode, attr))
4397
		dquot_initialize(inode);
4398 4399
	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))) {
4400 4401 4402 4403
		handle_t *handle;

		/* (user+group)*(old+new) structure, inode write (sb,
		 * inode block, ? - but truncate inode update has it) */
D
Dmitry Monakhov 已提交
4404
		handle = ext4_journal_start(inode, (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb)+
4405
					EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb))+3);
4406 4407 4408 4409
		if (IS_ERR(handle)) {
			error = PTR_ERR(handle);
			goto err_out;
		}
4410
		error = dquot_transfer(inode, attr);
4411
		if (error) {
4412
			ext4_journal_stop(handle);
4413 4414 4415 4416 4417 4418 4419 4420
			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;
4421 4422
		error = ext4_mark_inode_dirty(handle, inode);
		ext4_journal_stop(handle);
4423 4424
	}

4425
	if (attr->ia_valid & ATTR_SIZE) {
4426

4427
		if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
4428 4429
			struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

4430 4431
			if (attr->ia_size > sbi->s_bitmap_maxbytes)
				return -EFBIG;
4432 4433 4434
		}
	}

4435
	if (S_ISREG(inode->i_mode) &&
4436
	    attr->ia_valid & ATTR_SIZE &&
4437
	    (attr->ia_size < inode->i_size)) {
4438 4439
		handle_t *handle;

4440
		handle = ext4_journal_start(inode, 3);
4441 4442 4443 4444
		if (IS_ERR(handle)) {
			error = PTR_ERR(handle);
			goto err_out;
		}
4445 4446 4447 4448
		if (ext4_handle_valid(handle)) {
			error = ext4_orphan_add(handle, inode);
			orphan = 1;
		}
4449 4450
		EXT4_I(inode)->i_disksize = attr->ia_size;
		rc = ext4_mark_inode_dirty(handle, inode);
4451 4452
		if (!error)
			error = rc;
4453
		ext4_journal_stop(handle);
4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465

		if (ext4_should_order_data(inode)) {
			error = ext4_begin_ordered_truncate(inode,
							    attr->ia_size);
			if (error) {
				/* Do as much error cleanup as possible */
				handle = ext4_journal_start(inode, 3);
				if (IS_ERR(handle)) {
					ext4_orphan_del(NULL, inode);
					goto err_out;
				}
				ext4_orphan_del(handle, inode);
4466
				orphan = 0;
4467 4468 4469 4470
				ext4_journal_stop(handle);
				goto err_out;
			}
		}
4471 4472
	}

4473
	if (attr->ia_valid & ATTR_SIZE) {
4474 4475 4476 4477 4478 4479 4480 4481 4482
		if (attr->ia_size != inode->i_size) {
			loff_t oldsize = inode->i_size;

			i_size_write(inode, attr->ia_size);
			/*
			 * Blocks are going to be removed from the inode. Wait
			 * for dio in flight.  Temporarily disable
			 * dioread_nolock to prevent livelock.
			 */
4483
			if (orphan) {
4484 4485 4486 4487 4488 4489
				if (!ext4_should_journal_data(inode)) {
					ext4_inode_block_unlocked_dio(inode);
					inode_dio_wait(inode);
					ext4_inode_resume_unlocked_dio(inode);
				} else
					ext4_wait_for_tail_page_commit(inode);
4490
			}
4491 4492 4493 4494 4495
			/*
			 * Truncate pagecache after we've waited for commit
			 * in data=journal mode to make pages freeable.
			 */
			truncate_pagecache(inode, oldsize, inode->i_size);
4496
		}
4497
		ext4_truncate(inode);
4498
	}
4499

C
Christoph Hellwig 已提交
4500 4501 4502 4503 4504 4505 4506 4507 4508
	if (!rc) {
		setattr_copy(inode, attr);
		mark_inode_dirty(inode);
	}

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

	if (!rc && (ia_valid & ATTR_MODE))
4513
		rc = ext4_acl_chmod(inode);
4514 4515

err_out:
4516
	ext4_std_error(inode->i_sb, error);
4517 4518 4519 4520 4521
	if (!error)
		error = rc;
	return error;
}

4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540
int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
		 struct kstat *stat)
{
	struct inode *inode;
	unsigned long delalloc_blocks;

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

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

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

4548 4549
static int ext4_index_trans_blocks(struct inode *inode, int nrblocks, int chunk)
{
4550
	if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
4551
		return ext4_ind_trans_blocks(inode, nrblocks, chunk);
4552
	return ext4_ext_index_trans_blocks(inode, nrblocks, chunk);
4553
}
4554

4555
/*
4556 4557 4558
 * 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
4559
 *
4560
 * If datablocks are discontiguous, they are possible to spread over
4561
 * different block groups too. If they are contiguous, with flexbg,
4562
 * they could still across block group boundary.
4563
 *
4564 4565
 * Also account for superblock, inode, quota and xattr blocks
 */
4566
static int ext4_meta_trans_blocks(struct inode *inode, int nrblocks, int chunk)
4567
{
4568 4569
	ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
	int gdpblocks;
4570 4571 4572 4573 4574 4575 4576 4577 4578 4579 4580 4581 4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595
	int idxblocks;
	int ret = 0;

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

	ret = idxblocks;

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

	gdpblocks = groups;
4596 4597
	if (groups > ngroups)
		groups = ngroups;
4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610
	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 已提交
4611
 * Calculate the total number of credits to reserve to fit
4612 4613
 * the modification of a single pages into a single transaction,
 * which may include multiple chunks of block allocations.
4614
 *
4615
 * This could be called via ext4_write_begin()
4616
 *
4617
 * We need to consider the worse case, when
4618
 * one new block per extent.
4619
 */
A
Alex Tomas 已提交
4620
int ext4_writepage_trans_blocks(struct inode *inode)
4621
{
4622
	int bpp = ext4_journal_blocks_per_page(inode);
4623 4624
	int ret;

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

4627
	/* Account for data blocks for journalled mode */
4628
	if (ext4_should_journal_data(inode))
4629
		ret += bpp;
4630 4631
	return ret;
}
4632 4633 4634 4635 4636

/*
 * Calculate the journal credits for a chunk of data modification.
 *
 * This is called from DIO, fallocate or whoever calling
4637
 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
4638 4639 4640 4641 4642 4643 4644 4645 4646
 *
 * 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);
}

4647
/*
4648
 * The caller must have previously called ext4_reserve_inode_write().
4649 4650
 * Give this, we know that the caller already has write access to iloc->bh.
 */
4651
int ext4_mark_iloc_dirty(handle_t *handle,
4652
			 struct inode *inode, struct ext4_iloc *iloc)
4653 4654 4655
{
	int err = 0;

4656
	if (IS_I_VERSION(inode))
4657 4658
		inode_inc_iversion(inode);

4659 4660 4661
	/* the do_update_inode consumes one bh->b_count */
	get_bh(iloc->bh);

4662
	/* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
4663
	err = ext4_do_update_inode(handle, inode, iloc);
4664 4665 4666 4667 4668 4669 4670 4671 4672 4673
	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
4674 4675
ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
			 struct ext4_iloc *iloc)
4676
{
4677 4678 4679 4680 4681 4682 4683 4684 4685
	int err;

	err = ext4_get_inode_loc(inode, iloc);
	if (!err) {
		BUFFER_TRACE(iloc->bh, "get_write_access");
		err = ext4_journal_get_write_access(handle, iloc->bh);
		if (err) {
			brelse(iloc->bh);
			iloc->bh = NULL;
4686 4687
		}
	}
4688
	ext4_std_error(inode->i_sb, err);
4689 4690 4691
	return err;
}

4692 4693 4694 4695
/*
 * Expand an inode by new_extra_isize bytes.
 * Returns 0 on success or negative error number on failure.
 */
A
Aneesh Kumar K.V 已提交
4696 4697 4698 4699
static int ext4_expand_extra_isize(struct inode *inode,
				   unsigned int new_extra_isize,
				   struct ext4_iloc iloc,
				   handle_t *handle)
4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711
{
	struct ext4_inode *raw_inode;
	struct ext4_xattr_ibody_header *header;

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

	raw_inode = ext4_raw_inode(&iloc);

	header = IHDR(inode, raw_inode);

	/* No extended attributes present */
4712 4713
	if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
	    header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724
		memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0,
			new_extra_isize);
		EXT4_I(inode)->i_extra_isize = new_extra_isize;
		return 0;
	}

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

4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737
/*
 * 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.
 */
4738
int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
4739
{
4740
	struct ext4_iloc iloc;
4741 4742 4743
	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
	static unsigned int mnt_count;
	int err, ret;
4744 4745

	might_sleep();
4746
	trace_ext4_mark_inode_dirty(inode, _RET_IP_);
4747
	err = ext4_reserve_inode_write(handle, inode, &iloc);
4748 4749
	if (ext4_handle_valid(handle) &&
	    EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize &&
4750
	    !ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND)) {
4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763
		/*
		 * We need extra buffer credits since we may write into EA block
		 * with this same handle. If journal_extend fails, then it will
		 * only result in a minor loss of functionality for that inode.
		 * If this is felt to be critical, then e2fsck should be run to
		 * force a large enough s_min_extra_isize.
		 */
		if ((jbd2_journal_extend(handle,
			     EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) {
			ret = ext4_expand_extra_isize(inode,
						      sbi->s_want_extra_isize,
						      iloc, handle);
			if (ret) {
4764 4765
				ext4_set_inode_state(inode,
						     EXT4_STATE_NO_EXPAND);
A
Aneesh Kumar K.V 已提交
4766 4767
				if (mnt_count !=
					le16_to_cpu(sbi->s_es->s_mnt_count)) {
4768
					ext4_warning(inode->i_sb,
4769 4770 4771
					"Unable to expand inode %lu. Delete"
					" some EAs or run e2fsck.",
					inode->i_ino);
A
Aneesh Kumar K.V 已提交
4772 4773
					mnt_count =
					  le16_to_cpu(sbi->s_es->s_mnt_count);
4774 4775 4776 4777
				}
			}
		}
	}
4778
	if (!err)
4779
		err = ext4_mark_iloc_dirty(handle, inode, &iloc);
4780 4781 4782 4783
	return err;
}

/*
4784
 * ext4_dirty_inode() is called from __mark_inode_dirty()
4785 4786 4787 4788 4789
 *
 * 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.
 *
4790
 * Also, dquot_alloc_block() will always dirty the inode when blocks
4791 4792 4793 4794 4795 4796
 * 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.
 */
4797
void ext4_dirty_inode(struct inode *inode, int flags)
4798 4799 4800
{
	handle_t *handle;

4801
	handle = ext4_journal_start(inode, 2);
4802 4803
	if (IS_ERR(handle))
		goto out;
4804 4805 4806

	ext4_mark_inode_dirty(handle, inode);

4807
	ext4_journal_stop(handle);
4808 4809 4810 4811 4812 4813 4814 4815
out:
	return;
}

#if 0
/*
 * Bind an inode's backing buffer_head into this transaction, to prevent
 * it from being flushed to disk early.  Unlike
4816
 * ext4_reserve_inode_write, this leaves behind no bh reference and
4817 4818 4819
 * returns no iloc structure, so the caller needs to repeat the iloc
 * lookup to mark the inode dirty later.
 */
4820
static int ext4_pin_inode(handle_t *handle, struct inode *inode)
4821
{
4822
	struct ext4_iloc iloc;
4823 4824 4825

	int err = 0;
	if (handle) {
4826
		err = ext4_get_inode_loc(inode, &iloc);
4827 4828
		if (!err) {
			BUFFER_TRACE(iloc.bh, "get_write_access");
4829
			err = jbd2_journal_get_write_access(handle, iloc.bh);
4830
			if (!err)
4831
				err = ext4_handle_dirty_metadata(handle,
4832
								 NULL,
4833
								 iloc.bh);
4834 4835 4836
			brelse(iloc.bh);
		}
	}
4837
	ext4_std_error(inode->i_sb, err);
4838 4839 4840 4841
	return err;
}
#endif

4842
int ext4_change_inode_journal_flag(struct inode *inode, int val)
4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857
{
	journal_t *journal;
	handle_t *handle;
	int err;

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

4858
	journal = EXT4_JOURNAL(inode);
4859 4860
	if (!journal)
		return 0;
4861
	if (is_journal_aborted(journal))
4862
		return -EROFS;
4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873
	/* We have to allocate physical blocks for delalloc blocks
	 * before flushing journal. otherwise delalloc blocks can not
	 * be allocated any more. even more truncate on delalloc blocks
	 * could trigger BUG by flushing delalloc blocks in journal.
	 * There is no delalloc block in non-journal data mode.
	 */
	if (val && test_opt(inode->i_sb, DELALLOC)) {
		err = ext4_alloc_da_blocks(inode);
		if (err < 0)
			return err;
	}
4874

4875 4876 4877 4878
	/* Wait for all existing dio workers */
	ext4_inode_block_unlocked_dio(inode);
	inode_dio_wait(inode);

4879
	jbd2_journal_lock_updates(journal);
4880 4881 4882 4883 4884 4885 4886 4887 4888 4889

	/*
	 * 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)
4890
		ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
4891 4892
	else {
		jbd2_journal_flush(journal);
4893
		ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
4894
	}
4895
	ext4_set_aops(inode);
4896

4897
	jbd2_journal_unlock_updates(journal);
4898
	ext4_inode_resume_unlocked_dio(inode);
4899 4900 4901

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

4902
	handle = ext4_journal_start(inode, 1);
4903 4904 4905
	if (IS_ERR(handle))
		return PTR_ERR(handle);

4906
	err = ext4_mark_inode_dirty(handle, inode);
4907
	ext4_handle_sync(handle);
4908 4909
	ext4_journal_stop(handle);
	ext4_std_error(inode->i_sb, err);
4910 4911 4912

	return err;
}
4913 4914 4915 4916 4917 4918

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

4919
int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
4920
{
4921
	struct page *page = vmf->page;
4922 4923
	loff_t size;
	unsigned long len;
4924
	int ret;
4925 4926 4927
	struct file *file = vma->vm_file;
	struct inode *inode = file->f_path.dentry->d_inode;
	struct address_space *mapping = inode->i_mapping;
4928 4929 4930
	handle_t *handle;
	get_block_t *get_block;
	int retries = 0;
4931

4932
	sb_start_pagefault(inode->i_sb);
4933
	file_update_time(vma->vm_file);
4934 4935 4936 4937 4938 4939 4940 4941 4942 4943
	/* Delalloc case is easy... */
	if (test_opt(inode->i_sb, DELALLOC) &&
	    !ext4_should_journal_data(inode) &&
	    !ext4_nonda_switch(inode->i_sb)) {
		do {
			ret = __block_page_mkwrite(vma, vmf,
						   ext4_da_get_block_prep);
		} while (ret == -ENOSPC &&
		       ext4_should_retry_alloc(inode->i_sb, &retries));
		goto out_ret;
4944
	}
4945 4946

	lock_page(page);
4947 4948 4949 4950 4951 4952
	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;
4953
	}
4954 4955 4956 4957 4958

	if (page->index == size >> PAGE_CACHE_SHIFT)
		len = size & ~PAGE_CACHE_MASK;
	else
		len = PAGE_CACHE_SIZE;
4959
	/*
4960 4961
	 * 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
4962
	 */
4963
	if (page_has_buffers(page)) {
4964 4965 4966
		if (!ext4_walk_page_buffers(NULL, page_buffers(page),
					    0, len, NULL,
					    ext4_bh_unmapped)) {
4967 4968 4969 4970
			/* Wait so that we don't change page under IO */
			wait_on_page_writeback(page);
			ret = VM_FAULT_LOCKED;
			goto out;
4971
		}
4972
	}
4973
	unlock_page(page);
4974 4975 4976 4977 4978 4979 4980 4981
	/* OK, we need to fill the hole... */
	if (ext4_should_dioread_nolock(inode))
		get_block = ext4_get_block_write;
	else
		get_block = ext4_get_block;
retry_alloc:
	handle = ext4_journal_start(inode, ext4_writepage_trans_blocks(inode));
	if (IS_ERR(handle)) {
4982
		ret = VM_FAULT_SIGBUS;
4983 4984 4985 4986
		goto out;
	}
	ret = __block_page_mkwrite(vma, vmf, get_block);
	if (!ret && ext4_should_journal_data(inode)) {
4987
		if (ext4_walk_page_buffers(handle, page_buffers(page), 0,
4988 4989 4990
			  PAGE_CACHE_SIZE, NULL, do_journal_get_write_access)) {
			unlock_page(page);
			ret = VM_FAULT_SIGBUS;
4991
			ext4_journal_stop(handle);
4992 4993 4994 4995 4996 4997 4998 4999 5000 5001
			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:
5002
	sb_end_pagefault(inode->i_sb);
5003 5004
	return ret;
}