xfs: move repair temporary files to the metadata directory tree

Due to resource acquisition rules, we have to create the ondisk
temporary files used to stage a filesystem repair before we can acquire
a reference to the inode that we actually want to repair.  Therefore,
we do not know at tempfile creation time whether the tempfile will
belong to the regular directory tree or the metadata directory tree.

This distinction becomes important when the swapext code tries to figure
out the quota accounting of the two files whose mappings are being
swapped.  The swapext code assumes that accounting updates are required
for a file if dqattach attaches dquots.  Metadir files are never
accounted in quota, which means that swapext must not update the quota
accounting when swapping in a repaired directory/xattr/rtbitmap structure.

Prior to the swapext call, therefore, both files must be marked as
METADIR for dqattach so that dqattach will ignore them.  Add support for
a repair tempfile to be switched to the metadir tree and switched back
before being released so that ifree will just free the file.

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

diff --git a/fs/xfs/scrub/common.c b/fs/xfs/scrub/common.c
index 6d955580f608a48d065edbc4e02e527be8665331..c26a3314237a6905dfa6dd4a47ddfb36203cc97c 100644 (file)
--- a/fs/xfs/scrub/common.c
+++ b/fs/xfs/scrub/common.c
@@ -39,6 +39,7 @@
 #include "scrub/trace.h"
 #include "scrub/repair.h"
 #include "scrub/health.h"
+#include "scrub/tempfile.h"
 
 /* Common code for the metadata scrubbers. */
 
@@ -1090,6 +1091,10 @@ xchk_setup_inode_contents(
        if (error)
                return error;
 
+       error = xrep_tempfile_adjust_directory_tree(sc);
+       if (error)
+               return error;
+
        /* Lock the inode so the VFS cannot touch this file. */
        xchk_ilock(sc, XFS_IOLOCK_EXCL);
 

diff --git a/fs/xfs/scrub/tempfile.c b/fs/xfs/scrub/tempfile.c
index 3c5a1d77fefae916b7f5be59cdaa81afff5531ea..4b7f7860e37ece1eaad8f59dd183e65a6d183ed0 100644 (file)
--- a/fs/xfs/scrub/tempfile.c
+++ b/fs/xfs/scrub/tempfile.c
@@ -22,6 +22,7 @@
 #include "xfs_exchmaps.h"
 #include "xfs_defer.h"
 #include "xfs_symlink_remote.h"
+#include "xfs_metafile.h"
 #include "scrub/scrub.h"
 #include "scrub/common.h"
 #include "scrub/repair.h"
@@ -182,6 +183,101 @@ out_release_dquots:
        return error;
 }
 
+/*
+ * Temporary files have to be created before we even know which inode we're
+ * going to scrub, so we assume that they will be part of the regular directory
+ * tree.  If it turns out that we're actually scrubbing a file from the
+ * metadata directory tree, we have to subtract the temp file from the root
+ * dquots and detach the dquots.
+ */
+int
+xrep_tempfile_adjust_directory_tree(
+       struct xfs_scrub        *sc)
+{
+       int                     error;
+
+       if (!sc->tempip)
+               return 0;
+
+       ASSERT(sc->tp == NULL);
+       ASSERT(!xfs_is_metadir_inode(sc->tempip));
+
+       if (!sc->ip || !xfs_is_metadir_inode(sc->ip))
+               return 0;
+
+       xfs_ilock(sc->tempip, XFS_IOLOCK_EXCL);
+       sc->temp_ilock_flags |= XFS_IOLOCK_EXCL;
+
+       error = xchk_trans_alloc(sc, 0);
+       if (error)
+               goto out_iolock;
+
+       xrep_tempfile_ilock(sc);
+       xfs_trans_ijoin(sc->tp, sc->tempip, 0);
+
+       /* Metadir files are not accounted in quota, so drop icount */
+       xfs_trans_mod_dquot_byino(sc->tp, sc->tempip, XFS_TRANS_DQ_ICOUNT, -1L);
+       xfs_metafile_set_iflag(sc->tp, sc->tempip, XFS_METAFILE_UNKNOWN);
+
+       error = xrep_trans_commit(sc);
+       if (error)
+               goto out_ilock;
+
+       xfs_qm_dqdetach(sc->tempip);
+out_ilock:
+       xrep_tempfile_iunlock(sc);
+out_iolock:
+       xrep_tempfile_iounlock(sc);
+       return error;
+}
+
+/*
+ * Remove this temporary file from the metadata directory tree so that it can
+ * be inactivated the normal way.
+ */
+STATIC int
+xrep_tempfile_remove_metadir(
+       struct xfs_scrub        *sc)
+{
+       int                     error;
+
+       if (!sc->tempip || !xfs_is_metadir_inode(sc->tempip))
+               return 0;
+
+       ASSERT(sc->tp == NULL);
+
+       xfs_ilock(sc->tempip, XFS_IOLOCK_EXCL);
+       sc->temp_ilock_flags |= XFS_IOLOCK_EXCL;
+
+       error = xchk_trans_alloc(sc, 0);
+       if (error)
+               goto out_iolock;
+
+       xrep_tempfile_ilock(sc);
+       xfs_trans_ijoin(sc->tp, sc->tempip, 0);
+
+       xfs_metafile_clear_iflag(sc->tp, sc->tempip);
+
+       /* Non-metadir files are accounted in quota, so bump bcount/icount */
+       error = xfs_qm_dqattach_locked(sc->tempip, false);
+       if (error)
+               goto out_cancel;
+
+       xfs_trans_mod_dquot_byino(sc->tp, sc->tempip, XFS_TRANS_DQ_ICOUNT, 1L);
+       xfs_trans_mod_dquot_byino(sc->tp, sc->tempip, XFS_TRANS_DQ_BCOUNT,
+                       sc->tempip->i_nblocks);
+       error = xrep_trans_commit(sc);
+       goto out_ilock;
+
+out_cancel:
+       xchk_trans_cancel(sc);
+out_ilock:
+       xrep_tempfile_iunlock(sc);
+out_iolock:
+       xrep_tempfile_iounlock(sc);
+       return error;
+}
+
 /* Take IOLOCK_EXCL on the temporary file, maybe. */
 bool
 xrep_tempfile_iolock_nowait(
@@ -290,6 +386,7 @@ xrep_tempfile_rele(
                sc->temp_ilock_flags = 0;
        }
 
+       xrep_tempfile_remove_metadir(sc);
        xchk_irele(sc, sc->tempip);
        sc->tempip = NULL;
 }

diff --git a/fs/xfs/scrub/tempfile.h b/fs/xfs/scrub/tempfile.h
index e51399f595fe9aa46508e171832e7c16d842285b..71c1b54599c306491ecc7b66d741558b213e4813 100644 (file)
--- a/fs/xfs/scrub/tempfile.h
+++ b/fs/xfs/scrub/tempfile.h
@@ -10,6 +10,8 @@
 int xrep_tempfile_create(struct xfs_scrub *sc, uint16_t mode);
 void xrep_tempfile_rele(struct xfs_scrub *sc);
 
+int xrep_tempfile_adjust_directory_tree(struct xfs_scrub *sc);
+
 bool xrep_tempfile_iolock_nowait(struct xfs_scrub *sc);
 int xrep_tempfile_iolock_polled(struct xfs_scrub *sc);
 void xrep_tempfile_iounlock(struct xfs_scrub *sc);
@@ -42,6 +44,7 @@ static inline void xrep_tempfile_iolock_both(struct xfs_scrub *sc)
        xchk_ilock(sc, XFS_IOLOCK_EXCL);
 }
 # define xrep_is_tempfile(ip)          (false)
+# define xrep_tempfile_adjust_directory_tree(sc)       (0)
 # define xrep_tempfile_rele(sc)
 #endif /* CONFIG_XFS_ONLINE_REPAIR */