ext4: clean up len and offset checks in ext4_fallocate()

- Fix some comments.

- Consistently access i_size directly rather than using i_size_read(),
  since in all relevant cases we're under inode_lock().

- Simplify the alignment checks by using the IS_ALIGNED() macro.

- In ext4_insert_range(), do the check against s_maxbytes in a way
  that is safe against signed overflow.  (This doesn't currently matter
  for ext4 due to ext4's limited max file size, but this is something
  other filesystems have gotten wrong.  We might as well do it safely.)

Signed-off-by: Eric Biggers <ebiggers@google.com>
Link: https://lore.kernel.org/r/20191231180444.46586-3-ebiggers@kernel.org
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Reviewed-by: Ritesh Harjani <riteshh@linux.ibm.com>
Reviewed-by: Jan Kara <jack@suse.cz>

diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index e005d9821c0e34a99971b23b97baaffae3ecae3d..9ff19cfc4ecbcd902bb5d56a4b057d7ac09dd526 100644 (file)
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -4716,7 +4716,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,
        }
 
        if (!(mode & FALLOC_FL_KEEP_SIZE) &&
-           (offset + len > i_size_read(inode) ||
+           (offset + len > inode->i_size ||
             offset + len > EXT4_I(inode)->i_disksize)) {
                new_size = offset + len;
                ret = inode_newsize_ok(inode, new_size);
@@ -4800,7 +4800,7 @@ static long ext4_zero_range(struct file *file, loff_t offset,
                * Mark that we allocate beyond EOF so the subsequent truncate
                * can proceed even if the new size is the same as i_size.
                */
-               if ((offset + len) > i_size_read(inode))
+               if (offset + len > inode->i_size)
                        ext4_set_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
        }
        ext4_mark_inode_dirty(handle, inode);
@@ -4887,7 +4887,7 @@ long ext4_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
        }
 
        if (!(mode & FALLOC_FL_KEEP_SIZE) &&
-           (offset + len > i_size_read(inode) ||
+           (offset + len > inode->i_size ||
             offset + len > EXT4_I(inode)->i_disksize)) {
                new_size = offset + len;
                ret = inode_newsize_ok(inode, new_size);
@@ -5435,9 +5435,8 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len)
        if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
                return -EOPNOTSUPP;
 
-       /* Collapse range works only on fs block size aligned offsets. */
-       if (offset & (EXT4_CLUSTER_SIZE(sb) - 1) ||
-           len & (EXT4_CLUSTER_SIZE(sb) - 1))
+       /* Collapse range works only on fs cluster size aligned regions. */
+       if (!IS_ALIGNED(offset | len, EXT4_CLUSTER_SIZE(sb)))
                return -EINVAL;
 
        if (!S_ISREG(inode->i_mode))
@@ -5460,7 +5459,7 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len)
         * There is no need to overlap collapse range with EOF, in which case
         * it is effectively a truncate operation
         */
-       if (offset + len >= i_size_read(inode)) {
+       if (offset + len >= inode->i_size) {
                ret = -EINVAL;
                goto out_mutex;
        }
@@ -5538,7 +5537,7 @@ int ext4_collapse_range(struct inode *inode, loff_t offset, loff_t len)
                goto out_stop;
        }
 
-       new_size = i_size_read(inode) - len;
+       new_size = inode->i_size - len;
        i_size_write(inode, new_size);
        EXT4_I(inode)->i_disksize = new_size;
 
@@ -5585,9 +5584,8 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len)
        if (!ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
                return -EOPNOTSUPP;
 
-       /* Insert range works only on fs block size aligned offsets. */
-       if (offset & (EXT4_CLUSTER_SIZE(sb) - 1) ||
-                       len & (EXT4_CLUSTER_SIZE(sb) - 1))
+       /* Insert range works only on fs cluster size aligned regions. */
+       if (!IS_ALIGNED(offset | len, EXT4_CLUSTER_SIZE(sb)))
                return -EINVAL;
 
        if (!S_ISREG(inode->i_mode))
@@ -5612,14 +5610,14 @@ int ext4_insert_range(struct inode *inode, loff_t offset, loff_t len)
                goto out_mutex;
        }
 
-       /* Check for wrap through zero */
-       if (inode->i_size + len > inode->i_sb->s_maxbytes) {
+       /* Check whether the maximum file size would be exceeded */
+       if (len > inode->i_sb->s_maxbytes - inode->i_size) {
                ret = -EFBIG;
                goto out_mutex;
        }
 
-       /* Offset should be less than i_size */
-       if (offset >= i_size_read(inode)) {
+       /* Offset must be less than i_size */
+       if (offset >= inode->i_size) {
                ret = -EINVAL;
                goto out_mutex;
        }