xfs: make file range exchange support realtime files

Source kernel commit: e62941103faa2eedba6a155316e059a490c743a6

Now that bmap items support the realtime device, we can add the
necessary pieces to the file range exchange code to support exchanging
mappings.  All we really need to do here is adjust the blockcount
upwards to the end of the rt extent and remove the inode checks.

Signed-off-by: Darrick J. Wong <djwong@kernel.org>
Reviewed-by: Christoph Hellwig <hch@lst.de>

diff --git a/include/xfs_inode.h b/include/xfs_inode.h
index a351bb0d9040f155591faf163156cdd1efc4f593..825708383641ee0f36bd92a1980914cfd1440b7b 100644 (file)
--- a/include/xfs_inode.h
+++ b/include/xfs_inode.h
@@ -325,6 +325,16 @@ static inline bool xfs_inode_has_large_extent_counts(struct xfs_inode *ip)
        return ip->i_diflags2 & XFS_DIFLAG2_NREXT64;
 }
 
+
+/*
+ * Decide if this file is a realtime file whose data allocation unit is larger
+ * than a single filesystem block.
+ */
+static inline bool xfs_inode_has_bigrtalloc(struct xfs_inode *ip)
+{
+       return XFS_IS_REALTIME_INODE(ip) && ip->i_mount->m_sb.sb_rextsize > 1;
+}
+
 /* Always set the child's GID to this value, even if the parent is setgid. */
 #define CRED_FORCE_GID (1U << 0)
 struct cred {

diff --git a/libxfs/xfs_exchmaps.c b/libxfs/xfs_exchmaps.c
index 34ac9d5f26e01e38cb41d7f16b93d8ce2a0e45bb..37e58d0885da4ea01f93534484d7233e1c79a11f 100644 (file)
--- a/libxfs/xfs_exchmaps.c
+++ b/libxfs/xfs_exchmaps.c
@@ -149,12 +149,7 @@ xfs_exchmaps_check_forks(
            ifp2->if_format == XFS_DINODE_FMT_LOCAL)
                return -EINVAL;
 
-       /* We don't support realtime data forks yet. */
-       if (!XFS_IS_REALTIME_INODE(req->ip1))
-               return 0;
-       if (whichfork == XFS_ATTR_FORK)
-               return 0;
-       return -EINVAL;
+       return 0;
 }
 
 #ifdef CONFIG_XFS_QUOTA
@@ -195,6 +190,8 @@ xfs_exchmaps_can_skip_mapping(
        struct xfs_exchmaps_intent      *xmi,
        struct xfs_bmbt_irec            *irec)
 {
+       struct xfs_mount                *mp = xmi->xmi_ip1->i_mount;
+
        /* Do not skip this mapping if the caller did not tell us to. */
        if (!(xmi->xmi_flags & XFS_EXCHMAPS_INO1_WRITTEN))
                return false;
@@ -206,11 +203,64 @@ xfs_exchmaps_can_skip_mapping(
        /*
         * The mapping is unwritten or a hole.  It cannot be a delalloc
         * reservation because we already excluded those.  It cannot be an
-        * unwritten mapping with dirty page cache because we flushed the page
-        * cache.  We don't support realtime files yet, so we needn't (yet)
-        * deal with them.
+        * unwritten extent with dirty page cache because we flushed the page
+        * cache.  For files where the allocation unit is 1FSB (files on the
+        * data dev, rt files if the extent size is 1FSB), we can safely
+        * skip this mapping.
         */
-       return true;
+       if (!xfs_inode_has_bigrtalloc(xmi->xmi_ip1))
+               return true;
+
+       /*
+        * For a realtime file with a multi-fsb allocation unit, the decision
+        * is trickier because we can only swap full allocation units.
+        * Unwritten mappings can appear in the middle of an rtx if the rtx is
+        * partially written, but they can also appear for preallocations.
+        *
+        * If the mapping is a hole, skip it entirely.  Holes should align with
+        * rtx boundaries.
+        */
+       if (!xfs_bmap_is_real_extent(irec))
+               return true;
+
+       /*
+        * All mappings below this point are unwritten.
+        *
+        * - If the beginning is not aligned to an rtx, trim the end of the
+        *   mapping so that it does not cross an rtx boundary, and swap it.
+        *
+        * - If both ends are aligned to an rtx, skip the entire mapping.
+        */
+       if (!isaligned_64(irec->br_startoff, mp->m_sb.sb_rextsize)) {
+               xfs_fileoff_t   new_end;
+
+               new_end = roundup_64(irec->br_startoff, mp->m_sb.sb_rextsize);
+               irec->br_blockcount = min(irec->br_blockcount,
+                                         new_end - irec->br_startoff);
+               return false;
+       }
+       if (isaligned_64(irec->br_blockcount, mp->m_sb.sb_rextsize))
+               return true;
+
+       /*
+        * All mappings below this point are unwritten, start on an rtx
+        * boundary, and do not end on an rtx boundary.
+        *
+        * - If the mapping is longer than one rtx, trim the end of the mapping
+        *   down to an rtx boundary and skip it.
+        *
+        * - The mapping is shorter than one rtx.  Swap it.
+        */
+       if (irec->br_blockcount > mp->m_sb.sb_rextsize) {
+               xfs_fileoff_t   new_end;
+
+               new_end = rounddown_64(irec->br_startoff + irec->br_blockcount,
+                               mp->m_sb.sb_rextsize);
+               irec->br_blockcount = new_end - irec->br_startoff;
+               return true;
+       }
+
+       return false;
 }
 
 /*