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: Zhang Yi <yi.zhang@huawei.com>
Reviewed-by: Jan Kara <jack@suse.cz>
Reviewed-by: Ojaswin Mujoo <ojaswin@linux.ibm.com>
Link: https://patch.msgid.link/20241220011637.1157197-5-yi.zhang@huaweicloud.com
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index 902b7c00c240b9429faf8aa3a4258ccc5b1794a8..2b7d781bfcad14c4403290e6e339d95747d6accc 100644 (file)
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -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)

diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 0d8b2e073a50303ed22ab06cc6c6cb09ede5fc3c..4fdb6526439f90ed174f44cc0e34664fa90f60b6 100644 (file)
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -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;
+               goto out;
 
        /*
-        * If the hole extends beyond i_size, set the hole
-        * to end after the page that contains i_size
+        * 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.
         */
-       if (offset + length > inode->i_size) {
-               length = inode->i_size +
-                  PAGE_SIZE - (inode->i_size & (PAGE_SIZE - 1)) -
-                  offset;
-       }
+       if (end > inode->i_size)
+               end = round_up(inode->i_size, PAGE_SIZE);
+       if (end > max_end)
+               end = max_end;
+       length = end - offset;
 
        /*
-        * For punch hole the length + offset needs to be within one block
-        * before last range. Adjust the length if it goes beyond that limit.
+        * Attach jinode to inode for jbd2 if we do any zeroing of partial
+        * block.
         */
-       max_length = sbi->s_bitmap_maxbytes - inode->i_sb->s_blocksize;
-       if (offset + length > max_length)
-               length = max_length - 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
-                */
+       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;
+               goto out_invalidate_lock;
 
-       first_block_offset = round_up(offset, sb->s_blocksize);
-       last_block_offset = round_down((offset + length), sb->s_blocksize) - 1;
+       ret = ext4_update_disksize_before_punch(inode, offset, length);
+       if (ret)
+               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;
-
-               ret = ext4_truncate_page_cache_block_range(inode,
-                               first_block_offset, last_block_offset + 1);
-               if (ret)
-                       goto out_dio;
-       }
+       ret = ext4_truncate_page_cache_block_range(inode, offset, end);
+       if (ret)
+               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);
+       ext4_fc_track_range(handle, inode, start_lblk, end_lblk);
+
+       ret = ext4_mark_inode_dirty(handle, inode);
+       if (unlikely(ret))
+               goto out_handle;
+
+       ext4_update_inode_fsync_trans(handle, inode, 1);
        if (IS_SYNC(inode))
                ext4_handle_sync(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:
+out_handle:
        ext4_journal_stop(handle);
-out_dio:
+out_invalidate_lock:
        filemap_invalidate_unlock(mapping);
-out_mutex:
+out:
        inode_unlock(inode);
        return ret;
 }