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: 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-7-yi.zhang@huaweicloud.com
Signed-off-by: Theodore Ts'o <tytso@mit.edu>

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 97ad6fea58d33964d3e0f663bfac268f3af2f49c..8a0a720803a8086a52945f92fad70fcd50b716be 100644 (file)
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -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;
 }