xfs: fix fallocate functions when rtextsize is larger than 1

In commit fe341eb151ec, I forgot that xfs_free_file_space isn't strictly
a "remove mapped blocks" function.  It is actually a function to zero
file space by punching out the middle and writing zeroes to the
unaligned ends of the specified range.  Therefore, putting a rtextsize
alignment check in that function is wrong because that breaks unaligned
ZERO_RANGE on the realtime volume.

Furthermore, xfs_file_fallocate already has alignment checks for the
functions require the file range to be aligned to the size of a
fundamental allocation unit (which is 1 FSB on the data volume and 1 rt
extent on the realtime volume).  Create a new helper to check fallocate
arguments against the realtiem allocation unit size, fix the fallocate
frontend to use it, fix free_file_space to delete the correct range, and
remove a now redundant check from insert_file_space.

NOTE: The realtime extent size is not required to be a power of two!

Fixes: fe341eb151ec ("xfs: ensure that fpunch, fcollapse, and finsert operations are aligned to rt extent size")
Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>

diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index f2a8a0e75e1ff46b8e9dd12d0a8af2d170aa6cea..7371a7f7c652943ea4b06baef0dea79de1ace5db 100644 (file)
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -947,11 +947,11 @@ xfs_free_file_space(
        endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
 
        /* We can only free complete realtime extents. */
-       if (XFS_IS_REALTIME_INODE(ip)) {
-               xfs_extlen_t    extsz = xfs_get_extsz_hint(ip);
-
-               if ((startoffset_fsb | endoffset_fsb) & (extsz - 1))
-                       return -EINVAL;
+       if (XFS_IS_REALTIME_INODE(ip) && mp->m_sb.sb_rextsize > 1) {
+               startoffset_fsb = roundup_64(startoffset_fsb,
+                                            mp->m_sb.sb_rextsize);
+               endoffset_fsb = rounddown_64(endoffset_fsb,
+                                            mp->m_sb.sb_rextsize);
        }
 
        /*
@@ -1147,14 +1147,6 @@ xfs_insert_file_space(
 
        trace_xfs_insert_file_space(ip);
 
-       /* We can only insert complete realtime extents. */
-       if (XFS_IS_REALTIME_INODE(ip)) {
-               xfs_extlen_t    extsz = xfs_get_extsz_hint(ip);
-
-               if ((stop_fsb | shift_fsb) & (extsz - 1))
-                       return -EINVAL;
-       }
-
        error = xfs_bmap_can_insert_extents(ip, stop_fsb, shift_fsb);
        if (error)
                return error;

diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 3d1b951247440d002830d30a88fe316ada0daa11..5b0f93f738372dfde612437cb9fe38f78aaadbf0 100644 (file)
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -32,6 +32,39 @@
 
 static const struct vm_operations_struct xfs_file_vm_ops;
 
+/*
+ * Decide if the given file range is aligned to the size of the fundamental
+ * allocation unit for the file.
+ */
+static bool
+xfs_is_falloc_aligned(
+       struct xfs_inode        *ip,
+       loff_t                  pos,
+       long long int           len)
+{
+       struct xfs_mount        *mp = ip->i_mount;
+       uint64_t                mask;
+
+       if (XFS_IS_REALTIME_INODE(ip)) {
+               if (!is_power_of_2(mp->m_sb.sb_rextsize)) {
+                       u64     rextbytes;
+                       u32     mod;
+
+                       rextbytes = XFS_FSB_TO_B(mp, mp->m_sb.sb_rextsize);
+                       div_u64_rem(pos, rextbytes, &mod);
+                       if (mod)
+                               return false;
+                       div_u64_rem(len, rextbytes, &mod);
+                       return mod == 0;
+               }
+               mask = XFS_FSB_TO_B(mp, mp->m_sb.sb_rextsize) - 1;
+       } else {
+               mask = mp->m_sb.sb_blocksize - 1;
+       }
+
+       return !((pos | len) & mask);
+}
+
 int
 xfs_update_prealloc_flags(
        struct xfs_inode        *ip,
@@ -850,9 +883,7 @@ xfs_file_fallocate(
                if (error)
                        goto out_unlock;
        } else if (mode & FALLOC_FL_COLLAPSE_RANGE) {
-               unsigned int blksize_mask = i_blocksize(inode) - 1;
-
-               if (offset & blksize_mask || len & blksize_mask) {
+               if (!xfs_is_falloc_aligned(ip, offset, len)) {
                        error = -EINVAL;
                        goto out_unlock;
                }
@@ -872,10 +903,9 @@ xfs_file_fallocate(
                if (error)
                        goto out_unlock;
        } else if (mode & FALLOC_FL_INSERT_RANGE) {
-               unsigned int    blksize_mask = i_blocksize(inode) - 1;
                loff_t          isize = i_size_read(inode);
 
-               if (offset & blksize_mask || len & blksize_mask) {
+               if (!xfs_is_falloc_aligned(ip, offset, len)) {
                        error = -EINVAL;
                        goto out_unlock;
                }

diff --git a/fs/xfs/xfs_linux.h b/fs/xfs/xfs_linux.h
index ad1009778d33fdbe22610d6b269111270834343b..5b7a1e2015595f1bb0692bcb72ae80aaf96b5dc1 100644 (file)
--- a/fs/xfs/xfs_linux.h
+++ b/fs/xfs/xfs_linux.h
@@ -175,6 +175,12 @@ static inline xfs_dev_t linux_to_xfs_dev_t(dev_t dev)
 #define xfs_sort(a,n,s,fn)     sort(a,n,s,fn,NULL)
 #define xfs_stack_trace()      dump_stack()
 
+static inline uint64_t rounddown_64(uint64_t x, uint32_t y)
+{
+       do_div(x, y);
+       return x * y;
+}
+
 static inline uint64_t roundup_64(uint64_t x, uint32_t y)
 {
        x += y - 1;