Commit 982bf37d authored by Zhang Yi's avatar Zhang Yi Committed by Theodore Ts'o
Browse files

ext4: refactor ext4_punch_hole() 



The current implementation of ext4_punch_hole() contains complex
position calculations and stale error tags. To improve the code's
clarity and maintainability, it is essential to clean up the code and
improve its readability, this can be achieved by: a) simplifying and
renaming variables; b) eliminating unnecessary position calculations;
c) writing back all data in data=journal mode, and drop page cache from
the original offset to the end, rather than using aligned blocks,
d) renaming the 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-5-yi.zhang@huaweicloud.com


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

fs/ext4/ext4.h

+2 −0
Original line number Diff line number Diff line
@@ -367,6 +367,8 @@ struct ext4_io_submit { 
#define EXT4_MAX_BLOCKS(size, offset, blkbits) \

	((EXT4_BLOCK_ALIGN(size + offset, blkbits) >> blkbits) - (offset >> \

								  blkbits))

#define EXT4_B_TO_LBLK(inode, offset) \

	(round_up((offset), i_blocksize(inode)) >> (inode)->i_blkbits)



/* Translate a block number to a cluster number */

#define EXT4_B2C(sbi, blk)	((blk) >> (sbi)->s_cluster_bits)

fs/ext4/inode.c

+53 −66
Original line number Diff line number Diff line
@@ -4009,13 +4009,13 @@ int ext4_punch_hole(struct file *file, loff_t offset, loff_t length) 
{

	struct inode *inode = file_inode(file);

	struct super_block *sb = inode->i_sb;

	ext4_lblk_t first_block, stop_block;

	ext4_lblk_t start_lblk, end_lblk;

	struct address_space *mapping = inode->i_mapping;

	loff_t first_block_offset, last_block_offset, max_length;

	struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);

	loff_t max_end = EXT4_SB(sb)->s_bitmap_maxbytes - sb->s_blocksize;

	loff_t end = offset + length;

	handle_t *handle;

	unsigned int credits;

	int ret = 0, ret2 = 0;

	int ret = 0;



	trace_ext4_punch_hole(inode, offset, length, 0);
@@ -4023,36 +4023,27 @@ int ext4_punch_hole(struct file *file, loff_t offset, loff_t length) 


	/* No need to punch hole beyond i_size */

	if (offset >= inode->i_size)

		goto out_mutex;



	/*

	 * If the hole extends beyond i_size, set the hole

	 * to end after the page that contains i_size

	 */

	if (offset + length > inode->i_size) {

		length = inode->i_size +

		   PAGE_SIZE - (inode->i_size & (PAGE_SIZE - 1)) -

		   offset;

	}

		goto out;



	/*

	 * For punch hole the length + offset needs to be within one block

	 * before last range. Adjust the length if it goes beyond that limit.

	 * If the hole extends beyond i_size, set the hole to end after

	 * the page that contains i_size, and also make sure that the hole

	 * within one block before last range.

	 */

	max_length = sbi->s_bitmap_maxbytes - inode->i_sb->s_blocksize;

	if (offset + length > max_length)

		length = max_length - offset;

	if (end > inode->i_size)

		end = round_up(inode->i_size, PAGE_SIZE);

	if (end > max_end)

		end = max_end;

	length = end - offset;



	if (offset & (sb->s_blocksize - 1) ||

	    (offset + length) & (sb->s_blocksize - 1)) {

	/*

		 * Attach jinode to inode for jbd2 if we do any zeroing of

		 * partial block

	 * Attach jinode to inode for jbd2 if we do any zeroing of partial

	 * block.

	 */

	if (!IS_ALIGNED(offset | end, sb->s_blocksize)) {

		ret = ext4_inode_attach_jinode(inode);

		if (ret < 0)

			goto out_mutex;



			goto out;

	}



	/* Wait all existing dio workers, newcomers will block on i_rwsem */
@@ -4060,7 +4051,7 @@ int ext4_punch_hole(struct file *file, loff_t offset, loff_t length) 


	ret = file_modified(file);

	if (ret)

		goto out_mutex;

		goto out;



	/*

	 * Prevent page faults from reinstantiating pages we have released from
@@ -4070,22 +4061,16 @@ int ext4_punch_hole(struct file *file, loff_t offset, loff_t length) 


	ret = ext4_break_layouts(inode);

	if (ret)

		goto out_dio;



	first_block_offset = round_up(offset, sb->s_blocksize);

	last_block_offset = round_down((offset + length), sb->s_blocksize) - 1;

		goto out_invalidate_lock;



	/* Now release the pages and zero block aligned part of pages*/

	if (last_block_offset > first_block_offset) {

	ret = ext4_update_disksize_before_punch(inode, offset, length);

	if (ret)

			goto out_dio;

		goto out_invalidate_lock;



		ret = ext4_truncate_page_cache_block_range(inode,

				first_block_offset, last_block_offset + 1);

	/* Now release the pages and zero block aligned part of pages*/

	ret = ext4_truncate_page_cache_block_range(inode, offset, end);

	if (ret)

			goto out_dio;

	}

		goto out_invalidate_lock;



	if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))

		credits = ext4_writepage_trans_blocks(inode);
@@ -4095,52 +4080,54 @@ int ext4_punch_hole(struct file *file, loff_t offset, loff_t length) 
	if (IS_ERR(handle)) {

		ret = PTR_ERR(handle);

		ext4_std_error(sb, ret);

		goto out_dio;

		goto out_invalidate_lock;

	}



	ret = ext4_zero_partial_blocks(handle, inode, offset,

				       length);

	ret = ext4_zero_partial_blocks(handle, inode, offset, length);

	if (ret)

		goto out_stop;



	first_block = (offset + sb->s_blocksize - 1) >>

		EXT4_BLOCK_SIZE_BITS(sb);

	stop_block = (offset + length) >> EXT4_BLOCK_SIZE_BITS(sb);

		goto out_handle;



	/* If there are blocks to remove, do it */

	if (stop_block > first_block) {

		ext4_lblk_t hole_len = stop_block - first_block;

	start_lblk = EXT4_B_TO_LBLK(inode, offset);

	end_lblk = end >> inode->i_blkbits;



	if (end_lblk > start_lblk) {

		ext4_lblk_t hole_len = end_lblk - start_lblk;



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

		ext4_discard_preallocations(inode);



		ext4_es_remove_extent(inode, first_block, hole_len);

		ext4_es_remove_extent(inode, start_lblk, hole_len);



		if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))

			ret = ext4_ext_remove_space(inode, first_block,

						    stop_block - 1);

			ret = ext4_ext_remove_space(inode, start_lblk,

						    end_lblk - 1);

		else

			ret = ext4_ind_remove_space(handle, inode, first_block,

						    stop_block);

			ret = ext4_ind_remove_space(handle, inode, start_lblk,

						    end_lblk);

		if (ret) {

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

			goto out_handle;

		}



		ext4_es_insert_extent(inode, first_block, hole_len, ~0,

		ext4_es_insert_extent(inode, start_lblk, hole_len, ~0,

				      EXTENT_STATUS_HOLE, 0);

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

	}

	ext4_fc_track_range(handle, inode, first_block, stop_block);

	if (IS_SYNC(inode))

		ext4_handle_sync(handle);

	ext4_fc_track_range(handle, inode, start_lblk, end_lblk);



	ret = ext4_mark_inode_dirty(handle, inode);

	if (unlikely(ret))

		goto out_handle;



	ret2 = ext4_mark_inode_dirty(handle, inode);

	if (unlikely(ret2))

		ret = ret2;

	if (ret >= 0)

	ext4_update_inode_fsync_trans(handle, inode, 1);

out_stop:

	if (IS_SYNC(inode))

		ext4_handle_sync(handle);

out_handle:

	ext4_journal_stop(handle);

out_dio:

out_invalidate_lock:

	filemap_invalidate_unlock(mapping);

out_mutex:

out:

	inode_unlock(inode);

	return ret;

}