xfs: persist quota flags with metadir

It's annoying that one has to keep reminding XFS about what quota
options it should mount with, since the quota flags recording the
previous state are sitting right there in the primary superblock.  Even
more strangely, there exists a noquota option to disable quotas
completely, so it's odder still that providing no options is the same as
noquota.

Starting with metadir, let's change the behavior so that if the user
does not specify any quota-related mount options at all, the ondisk
quota flags will be used to bring up quota.  In other words, the
filesystem will mount in the same state and with the same functionality
as it had during the last mount.

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

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 5b6d4373d5bf51c3d3273ddfaa19c919cf7943dc..3d20774fdd565a0af470b4f726a4f82b01b2236a 100644 (file)
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -850,6 +850,13 @@ xfs_mountfs(
        if (error)
                goto out_fail_wait;
 
+       /*
+        * If we're resuming quota status, pick up the preliminary qflags from
+        * the ondisk superblock so that we know if we should recover dquots.
+        */
+       if (xfs_is_resuming_quotaon(mp))
+               xfs_qm_resume_quotaon(mp);
+
        /*
         * Log's mount-time initialization. The first part of recovery can place
         * some items on the AIL, to be handled when recovery is finished or
@@ -863,6 +870,14 @@ xfs_mountfs(
                goto out_inodegc_shrinker;
        }
 
+       /*
+        * If we're resuming quota status and recovered the log, re-sample the
+        * qflags from the ondisk superblock now that we've recovered it, just
+        * in case someone shut down enforcement just before a crash.
+        */
+       if (xfs_clear_resuming_quotaon(mp) && xlog_recovery_needed(mp->m_log))
+               xfs_qm_resume_quotaon(mp);
+
        /*
         * If logged xattrs are still enabled after log recovery finishes, then
         * they'll be available until unmount.  Otherwise, turn them off.

diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 7aaa42fff8b92b1c29d4fda89ec0411c34ea8a39..38f501692373d426f7d27eeafab87411e3750cac 100644 (file)
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -461,6 +461,8 @@ __XFS_HAS_FEAT(nouuid, NOUUID)
 #define XFS_OPSTATE_UNSET_LOG_INCOMPAT 11
 /* Filesystem can use logged extended attributes */
 #define XFS_OPSTATE_USE_LARP           12
+/* Filesystem should use qflags to determine quotaon status */
+#define XFS_OPSTATE_RESUMING_QUOTAON   13
 
 #define __XFS_IS_OPSTATE(name, NAME) \
 static inline bool xfs_is_ ## name (struct xfs_mount *mp) \
@@ -485,8 +487,12 @@ __XFS_IS_OPSTATE(inodegc_enabled, INODEGC_ENABLED)
 __XFS_IS_OPSTATE(blockgc_enabled, BLOCKGC_ENABLED)
 #ifdef CONFIG_XFS_QUOTA
 __XFS_IS_OPSTATE(quotacheck_running, QUOTACHECK_RUNNING)
+__XFS_IS_OPSTATE(resuming_quotaon, RESUMING_QUOTAON)
 #else
 # define xfs_is_quotacheck_running(mp) (false)
+# define xfs_is_resuming_quotaon(mp)   (false)
+# define xfs_set_resuming_quotaon(mp)  (false)
+# define xfs_clear_resuming_quotaon(mp)        (false)
 #endif
 __XFS_IS_OPSTATE(done_with_log_incompat, UNSET_LOG_INCOMPAT)
 __XFS_IS_OPSTATE(using_logged_xattrs, USE_LARP)

diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
index a11436579877d580f4fbb0a66c0d307a9f7b79f0..79a96558f739e3b5c48a1a2828603b39b7788f64 100644 (file)
--- a/fs/xfs/xfs_qm_bhv.c
+++ b/fs/xfs/xfs_qm_bhv.c
@@ -135,3 +135,21 @@ xfs_qm_newmount(
 
        return 0;
 }
+
+/*
+ * If the sysadmin didn't provide any quota mount options, restore the quota
+ * accounting and enforcement state from the ondisk superblock.  Only do this
+ * for metadir filesystems because this is a behavior change.
+ */
+void
+xfs_qm_resume_quotaon(
+       struct xfs_mount        *mp)
+{
+       if (!xfs_has_metadir(mp))
+               return;
+       if (xfs_has_norecovery(mp))
+               return;
+
+       mp->m_qflags = mp->m_sb.sb_qflags & (XFS_ALL_QUOTA_ACCT |
+                                            XFS_ALL_QUOTA_ENFD);
+}

diff --git a/fs/xfs/xfs_quota.h b/fs/xfs/xfs_quota.h
index 645761997bf2d9548bf841c84efacd83d23b8703..2d36d967380e7c5c8089f4d137eff67db861dc1d 100644 (file)
--- a/fs/xfs/xfs_quota.h
+++ b/fs/xfs/xfs_quota.h
@@ -125,6 +125,7 @@ extern void xfs_qm_dqdetach(struct xfs_inode *);
 extern void xfs_qm_dqrele(struct xfs_dquot *);
 extern void xfs_qm_statvfs(struct xfs_inode *, struct kstatfs *);
 extern int xfs_qm_newmount(struct xfs_mount *, uint *, uint *);
+void xfs_qm_resume_quotaon(struct xfs_mount *mp);
 extern void xfs_qm_mount_quotas(struct xfs_mount *);
 extern void xfs_qm_unmount(struct xfs_mount *);
 extern void xfs_qm_unmount_quotas(struct xfs_mount *);
@@ -202,6 +203,7 @@ xfs_trans_reserve_quota_icreate(struct xfs_trans *tp, struct xfs_dquot *udqp,
 #define xfs_qm_dqrele(d)                       do { (d) = (d); } while(0)
 #define xfs_qm_statvfs(ip, s)                  do { } while(0)
 #define xfs_qm_newmount(mp, a, b)                                      (0)
+#define xfs_qm_resume_quotaon(mp)              ((void)0)
 #define xfs_qm_mount_quotas(mp)
 #define xfs_qm_unmount(mp)
 #define xfs_qm_unmount_quotas(mp)

diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index d3e2c8cfc537fc4e815bd7a86c6309a06d808306..1e0399f56e59eaf416448f5d187aed10c5d577e5 100644 (file)
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -67,6 +67,9 @@ enum xfs_dax_mode {
        XFS_DAX_NEVER = 2,
 };
 
+/* Were quota mount options provided?  Must use the upper 16 bits of qflags. */
+#define XFS_QFLAGS_MNTOPTS     (1U << 31)
+
 static void
 xfs_mount_set_dax_mode(
        struct xfs_mount        *mp,
@@ -1264,6 +1267,8 @@ xfs_fs_parse_param(
        int                     size = 0;
        int                     opt;
 
+       BUILD_BUG_ON(XFS_QFLAGS_MNTOPTS & XFS_MOUNT_QUOTA_ALL);
+
        opt = fs_parse(fc, xfs_fs_parameters, param, &result);
        if (opt < 0)
                return opt;
@@ -1341,32 +1346,39 @@ xfs_fs_parse_param(
        case Opt_noquota:
                parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT;
                parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD;
+               parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS;
                return 0;
        case Opt_quota:
        case Opt_uquota:
        case Opt_usrquota:
                parsing_mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ENFD);
+               parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS;
                return 0;
        case Opt_qnoenforce:
        case Opt_uqnoenforce:
                parsing_mp->m_qflags |= XFS_UQUOTA_ACCT;
                parsing_mp->m_qflags &= ~XFS_UQUOTA_ENFD;
+               parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS;
                return 0;
        case Opt_pquota:
        case Opt_prjquota:
                parsing_mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ENFD);
+               parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS;
                return 0;
        case Opt_pqnoenforce:
                parsing_mp->m_qflags |= XFS_PQUOTA_ACCT;
                parsing_mp->m_qflags &= ~XFS_PQUOTA_ENFD;
+               parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS;
                return 0;
        case Opt_gquota:
        case Opt_grpquota:
                parsing_mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ENFD);
+               parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS;
                return 0;
        case Opt_gqnoenforce:
                parsing_mp->m_qflags |= XFS_GQUOTA_ACCT;
                parsing_mp->m_qflags &= ~XFS_GQUOTA_ENFD;
+               parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS;
                return 0;
        case Opt_discard:
                parsing_mp->m_features |= XFS_FEAT_DISCARD;
@@ -1761,6 +1773,14 @@ xfs_fs_fill_super(
                xfs_warn(mp,
        "EXPERIMENTAL parent pointer feature enabled. Use at your own risk!");
 
+       /*
+        * If no quota mount options were provided, maybe we'll try to pick
+        * up the quota accounting and enforcement flags from the ondisk sb.
+        */
+       if (!(mp->m_qflags & XFS_QFLAGS_MNTOPTS))
+               xfs_set_resuming_quotaon(mp);
+       mp->m_qflags &= ~XFS_QFLAGS_MNTOPTS;
+
        error = xfs_mountfs(mp);
        if (error)
                goto out_filestream_unmount;
@@ -1947,6 +1967,8 @@ xfs_fs_reconfigure(
        int                     flags = fc->sb_flags;
        int                     error;
 
+       new_mp->m_qflags &= ~XFS_QFLAGS_MNTOPTS;
+
        /* version 5 superblocks always support version counters. */
        if (xfs_has_crc(mp))
                fc->sb_flags |= SB_I_VERSION;