Commit 162e3c5a authored by Zhang Yi's avatar Zhang Yi Committed by Theodore Ts'o
Browse files

ext4: refactor ext4_collapse_range() 



Simplify ext4_collapse_range() and align its code style with that of
ext4_zero_range() and ext4_punch_hole(). Refactor it by: a) renaming
variables, b) removing redundant input parameter checks and moving
the remaining checks under i_rwsem in preparation for future
refactoring, and c) renaming the three stale error tags.

Signed-off-by: default avatarZhang Yi <yi.zhang@huawei.com>
Reviewed-by: default avatarJan Kara <jack@suse.cz>
Reviewed-by: default avatarOjaswin Mujoo <ojaswin@linux.ibm.com>
Link: https://patch.msgid.link/20241220011637.1157197-7-yi.zhang@huaweicloud.com


Signed-off-by: default avatarTheodore Ts'o <tytso@mit.edu>
parent 53471e0b

fs/ext4/extents.c

+48 −55
Original line number Diff line number Diff line
@@ -5292,43 +5292,36 @@ static int ext4_collapse_range(struct file *file, loff_t offset, loff_t len) 
	struct inode *inode = file_inode(file);

	struct super_block *sb = inode->i_sb;

	struct address_space *mapping = inode->i_mapping;

	ext4_lblk_t punch_start, punch_stop;

	loff_t end = offset + len;

	ext4_lblk_t start_lblk, end_lblk;

	handle_t *handle;

	unsigned int credits;

	loff_t new_size, ioffset;

	loff_t start, new_size;

	int ret;



	/*

	 * We need to test this early because xfstests assumes that a

	 * collapse range of (0, 1) will return EOPNOTSUPP if the file

	 * system does not support collapse range.

	 */

	if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))

		return -EOPNOTSUPP;

	trace_ext4_collapse_range(inode, offset, len);



	/* Collapse range works only on fs cluster size aligned regions. */

	if (!IS_ALIGNED(offset | len, EXT4_CLUSTER_SIZE(sb)))

		return -EINVAL;

	inode_lock(inode);



	trace_ext4_collapse_range(inode, offset, len);

	/* Currently just for extent based files */

	if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {

		ret = -EOPNOTSUPP;

		goto out;

	}



	punch_start = offset >> EXT4_BLOCK_SIZE_BITS(sb);

	punch_stop = (offset + len) >> EXT4_BLOCK_SIZE_BITS(sb);

	/* Collapse range works only on fs cluster size aligned regions. */

	if (!IS_ALIGNED(offset | len, EXT4_CLUSTER_SIZE(sb))) {

		ret = -EINVAL;

		goto out;

	}



	inode_lock(inode);

	/*

	 * There is no need to overlap collapse range with EOF, in which case

	 * it is effectively a truncate operation

	 */

	if (offset + len >= inode->i_size) {

	if (end >= inode->i_size) {

		ret = -EINVAL;

		goto out_mutex;

	}



	/* Currently just for extent based files */

	if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {

		ret = -EOPNOTSUPP;

		goto out_mutex;

		goto out;

	}



	/* Wait for existing dio to complete */
@@ -5336,7 +5329,7 @@ static int ext4_collapse_range(struct file *file, loff_t offset, loff_t len) 


	ret = file_modified(file);

	if (ret)

		goto out_mutex;

		goto out;



	/*

	 * Prevent page faults from reinstantiating pages we have released from
@@ -5346,55 +5339,52 @@ static int ext4_collapse_range(struct file *file, loff_t offset, loff_t len) 


	ret = ext4_break_layouts(inode);

	if (ret)

		goto out_mmap;

		goto out_invalidate_lock;



	/*

	 * Write tail of the last page before removed range and data that

	 * will be shifted since they will get removed from the page cache

	 * below. We are also protected from pages becoming dirty by

	 * i_rwsem and invalidate_lock.

	 * Need to round down offset to be aligned with page size boundary

	 * for page size > block size.

	 */

	ioffset = round_down(offset, PAGE_SIZE);

	/*

	 * Write tail of the last page before removed range since it will get

	 * removed from the page cache below.

	 */

	ret = filemap_write_and_wait_range(mapping, ioffset, offset);

	if (ret)

		goto out_mmap;

	/*

	 * Write data that will be shifted to preserve them when discarding

	 * page cache below. We are also protected from pages becoming dirty

	 * by i_rwsem and invalidate_lock.

	 */

	ret = filemap_write_and_wait_range(mapping, offset + len,

					   LLONG_MAX);

	start = round_down(offset, PAGE_SIZE);

	ret = filemap_write_and_wait_range(mapping, start, offset);

	if (!ret)

		ret = filemap_write_and_wait_range(mapping, end, LLONG_MAX);

	if (ret)

		goto out_mmap;

	truncate_pagecache(inode, ioffset);

		goto out_invalidate_lock;



	truncate_pagecache(inode, start);



	credits = ext4_writepage_trans_blocks(inode);

	handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);

	if (IS_ERR(handle)) {

		ret = PTR_ERR(handle);

		goto out_mmap;

		goto out_invalidate_lock;

	}

	ext4_fc_mark_ineligible(sb, EXT4_FC_REASON_FALLOC_RANGE, handle);



	start_lblk = offset >> inode->i_blkbits;

	end_lblk = (offset + len) >> inode->i_blkbits;



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

	ext4_discard_preallocations(inode);

	ext4_es_remove_extent(inode, punch_start, EXT_MAX_BLOCKS - punch_start);

	ext4_es_remove_extent(inode, start_lblk, EXT_MAX_BLOCKS - start_lblk);



	ret = ext4_ext_remove_space(inode, punch_start, punch_stop - 1);

	ret = ext4_ext_remove_space(inode, start_lblk, end_lblk - 1);

	if (ret) {

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

		goto out_stop;

		goto out_handle;

	}

	ext4_discard_preallocations(inode);



	ret = ext4_ext_shift_extents(inode, handle, punch_stop,

				     punch_stop - punch_start, SHIFT_LEFT);

	ret = ext4_ext_shift_extents(inode, handle, end_lblk,

				     end_lblk - start_lblk, SHIFT_LEFT);

	if (ret) {

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

		goto out_stop;

		goto out_handle;

	}



	new_size = inode->i_size - len;
@@ -5402,16 +5392,19 @@ static int ext4_collapse_range(struct file *file, loff_t offset, loff_t len) 
	EXT4_I(inode)->i_disksize = new_size;



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

	if (IS_SYNC(inode))

		ext4_handle_sync(handle);

	ret = ext4_mark_inode_dirty(handle, inode);

	if (ret)

		goto out_handle;



	ext4_update_inode_fsync_trans(handle, inode, 1);

	if (IS_SYNC(inode))

		ext4_handle_sync(handle);



out_stop:

out_handle:

	ext4_journal_stop(handle);

out_mmap:

out_invalidate_lock:

	filemap_invalidate_unlock(mapping);

out_mutex:

out:

	inode_unlock(inode);

	return ret;

}