xfs: Remove incore use of XFS_OQUOTA_ENFD and XFS_OQUOTA_CHKD

Remove all incore use of XFS_OQUOTA_ENFD and XFS_OQUOTA_CHKD. Instead,
start using XFS_GQUOTA_.* XFS_PQUOTA_.* counterparts for GQUOTA and
PQUOTA respectively.

On-disk copy still uses XFS_OQUOTA_ENFD and XFS_OQUOTA_CHKD.

Read and write of the superblock does the conversion from *OQUOTA*
to *[PG]QUOTA*.

Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

7 files changed, 123 insertions, 53 deletions

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 2978bb4cc72a..2b0ba3581656 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -336,6 +336,14 @@ xfs_mount_validate_sb(
                 return XFS_ERROR(EWRONGFS);
         }
 
+        if ((sbp->sb_qflags & (XFS_OQUOTA_ENFD | XFS_OQUOTA_CHKD)) &&
+                        (sbp->sb_qflags & (XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD |
+                                XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD))) {
+                xfs_notice(mp,
+"Super block has XFS_OQUOTA bits along with XFS_PQUOTA and/or XFS_GQUOTA bits.\n");
+                return XFS_ERROR(EFSCORRUPTED);
+        }
+
         /*
          * Version 5 superblock feature mask validation. Reject combinations the
          * kernel cannot support up front before checking anything else. For
@@ -561,6 +569,18 @@ out_unwind:
         return error;
 }
 
+static void
+xfs_sb_quota_from_disk(struct xfs_sb *sbp)
+{
+        if (sbp->sb_qflags & XFS_OQUOTA_ENFD)
+                sbp->sb_qflags |= (sbp->sb_qflags & XFS_PQUOTA_ACCT) ?
+                                        XFS_PQUOTA_ENFD : XFS_GQUOTA_ENFD;
+        if (sbp->sb_qflags & XFS_OQUOTA_CHKD)
+                sbp->sb_qflags |= (sbp->sb_qflags & XFS_PQUOTA_ACCT) ?
+                                        XFS_PQUOTA_CHKD : XFS_GQUOTA_CHKD;
+        sbp->sb_qflags &= ~(XFS_OQUOTA_ENFD | XFS_OQUOTA_CHKD);
+}
+
 void
 xfs_sb_from_disk(
         struct xfs_sb   *to,
@@ -622,6 +642,35 @@ xfs_sb_from_disk(
         to->sb_lsn = be64_to_cpu(from->sb_lsn);
 }
 
+static inline void
+xfs_sb_quota_to_disk(
+        xfs_dsb_t       *to,
+        xfs_sb_t        *from,
+        __int64_t       *fields)
+{
+        __uint16_t      qflags = from->sb_qflags;
+
+        if (*fields & XFS_SB_QFLAGS) {
+                /*
+                 * The in-core version of sb_qflags do not have
+                 * XFS_OQUOTA_* flags, whereas the on-disk version
+                 * does.  So, convert incore XFS_{PG}QUOTA_* flags
+                 * to on-disk XFS_OQUOTA_* flags.
+                 */
+                qflags &= ~(XFS_PQUOTA_ENFD | XFS_PQUOTA_CHKD |
+                                XFS_GQUOTA_ENFD | XFS_GQUOTA_CHKD);
+
+                if (from->sb_qflags &
+                                (XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD))
+                        qflags |= XFS_OQUOTA_ENFD;
+                if (from->sb_qflags &
+                                (XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD))
+                        qflags |= XFS_OQUOTA_CHKD;
+                to->sb_qflags = cpu_to_be16(qflags);
+                *fields &= ~XFS_SB_QFLAGS;
+        }
+}
+
 /*
  * Copy in core superblock to ondisk one.
  *
@@ -643,6 +692,7 @@ xfs_sb_to_disk(
         if (!fields)
                 return;
 
+        xfs_sb_quota_to_disk(to, from, &fields);
         while (fields) {
                 f = (xfs_sb_field_t)xfs_lowbit64((__uint64_t)fields);
                 first = xfs_sb_info[f].offset;
@@ -835,6 +885,7 @@ reread:
          */
         xfs_sb_from_disk(&mp->m_sb, XFS_BUF_TO_SBP(bp));
 
+        xfs_sb_quota_from_disk(&mp->m_sb);
         /*
          * We must be able to do sector-sized and sector-aligned IO.
          */
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index cf09aa845d8c..7a3e007b49f4 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -299,8 +299,10 @@ xfs_qm_mount_quotas(
          */
         if (!XFS_IS_UQUOTA_ON(mp))
                 mp->m_qflags &= ~XFS_UQUOTA_CHKD;
-        if (!(XFS_IS_GQUOTA_ON(mp) || XFS_IS_PQUOTA_ON(mp)))
-                mp->m_qflags &= ~XFS_OQUOTA_CHKD;
+        if (!XFS_IS_GQUOTA_ON(mp))
+                mp->m_qflags &= ~XFS_GQUOTA_CHKD;
+        if (!XFS_IS_PQUOTA_ON(mp))
+                mp->m_qflags &= ~XFS_PQUOTA_CHKD;
 
  write_changes:
         /*
@@ -1297,7 +1299,8 @@ xfs_qm_quotacheck(
                                          &buffer_list);
                 if (error)
                         goto error_return;
-                flags |= XFS_OQUOTA_CHKD;
+                flags |= XFS_IS_GQUOTA_ON(mp) ?
+                                        XFS_GQUOTA_CHKD : XFS_PQUOTA_CHKD;
         }
 
         do {
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index b03b2abd1e13..a08801ae24e2 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -117,11 +117,11 @@ xfs_qm_scall_quotaoff(
         }
         if (flags & XFS_GQUOTA_ACCT) {
                 dqtype |= XFS_QMOPT_GQUOTA;
-                flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);
+                flags |= (XFS_GQUOTA_CHKD | XFS_GQUOTA_ENFD);
                 inactivate_flags |= XFS_GQUOTA_ACTIVE;
         } else if (flags & XFS_PQUOTA_ACCT) {
                 dqtype |= XFS_QMOPT_PQUOTA;
-                flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);
+                flags |= (XFS_PQUOTA_CHKD | XFS_PQUOTA_ENFD);
                 inactivate_flags |= XFS_PQUOTA_ACTIVE;
         }
 
@@ -335,14 +335,14 @@ xfs_qm_scall_quotaon(
          * quota acct on ondisk without m_qflags' knowing.
          */
         if (((flags & XFS_UQUOTA_ACCT) == 0 &&
-            (mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 &&
-            (flags & XFS_UQUOTA_ENFD))
-            ||
+             (mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 &&
+             (flags & XFS_UQUOTA_ENFD)) ||
+            ((flags & XFS_GQUOTA_ACCT) == 0 &&
+             (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&
+             (flags & XFS_GQUOTA_ENFD)) ||
             ((flags & XFS_PQUOTA_ACCT) == 0 &&
-            (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&
-            (flags & XFS_GQUOTA_ACCT) == 0 &&
-            (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&
-            (flags & XFS_OQUOTA_ENFD))) {
+             (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&
+             (flags & XFS_PQUOTA_ENFD))) {
                 xfs_debug(mp,
                         "%s: Can't enforce without acct, flags=%x sbflags=%x\n",
                         __func__, flags, mp->m_sb.sb_qflags);
@@ -776,9 +776,12 @@ xfs_qm_scall_getquota(
          * gets turned off. No need to confuse the user level code,
          * so return zeroes in that case.
          */
-        if ((!XFS_IS_UQUOTA_ENFORCED(mp) && dqp->q_core.d_flags == XFS_DQ_USER) ||
-            (!XFS_IS_OQUOTA_ENFORCED(mp) &&
-                        (dqp->q_core.d_flags & (XFS_DQ_PROJ | XFS_DQ_GROUP)))) {
+        if ((!XFS_IS_UQUOTA_ENFORCED(mp) &&
+             dqp->q_core.d_flags == XFS_DQ_USER) ||
+            (!XFS_IS_GQUOTA_ENFORCED(mp) &&
+             dqp->q_core.d_flags == XFS_DQ_GROUP) ||
+            (!XFS_IS_PQUOTA_ENFORCED(mp) &&
+             dqp->q_core.d_flags == XFS_DQ_PROJ)) {
                 dst->d_btimer = 0;
                 dst->d_itimer = 0;
                 dst->d_rtbtimer = 0;
@@ -786,8 +789,8 @@ xfs_qm_scall_getquota(
 
 #ifdef DEBUG
         if (((XFS_IS_UQUOTA_ENFORCED(mp) && dst->d_flags == FS_USER_QUOTA) ||
-             (XFS_IS_OQUOTA_ENFORCED(mp) &&
-                        (dst->d_flags & (FS_PROJ_QUOTA | FS_GROUP_QUOTA)))) &&
+             (XFS_IS_GQUOTA_ENFORCED(mp) && dst->d_flags == FS_GROUP_QUOTA) ||
+             (XFS_IS_PQUOTA_ENFORCED(mp) && dst->d_flags == FS_PROJ_QUOTA)) &&
             dst->d_id != 0) {
                 if ((dst->d_bcount > dst->d_blk_softlimit) &&
                     (dst->d_blk_softlimit > 0)) {
@@ -833,16 +836,16 @@ xfs_qm_export_flags(
         uflags = 0;
         if (flags & XFS_UQUOTA_ACCT)
                 uflags |= FS_QUOTA_UDQ_ACCT;
-        if (flags & XFS_PQUOTA_ACCT)
-                uflags |= FS_QUOTA_PDQ_ACCT;
         if (flags & XFS_GQUOTA_ACCT)
                 uflags |= FS_QUOTA_GDQ_ACCT;
+        if (flags & XFS_PQUOTA_ACCT)
+                uflags |= FS_QUOTA_PDQ_ACCT;
         if (flags & XFS_UQUOTA_ENFD)
                 uflags |= FS_QUOTA_UDQ_ENFD;
-        if (flags & (XFS_OQUOTA_ENFD)) {
-                uflags |= (flags & XFS_GQUOTA_ACCT) ?
-                        FS_QUOTA_GDQ_ENFD : FS_QUOTA_PDQ_ENFD;
-        }
+        if (flags & XFS_GQUOTA_ENFD)
+                uflags |= FS_QUOTA_GDQ_ENFD;
+        if (flags & XFS_PQUOTA_ENFD)
+                uflags |= FS_QUOTA_PDQ_ENFD;
         return (uflags);
 }
 
diff --git a/fs/xfs/xfs_quota.h b/fs/xfs/xfs_quota.h
index c38068f26c55..c3483bab9cde 100644
--- a/fs/xfs/xfs_quota.h
+++ b/fs/xfs/xfs_quota.h
@@ -161,30 +161,42 @@ typedef struct xfs_qoff_logformat {
 #define XFS_GQUOTA_ACCT 0x0040  /* group quota accounting ON */
 
 /*
+ * Conversion to and from the combined OQUOTA flag (if necessary)
+ * is done only in xfs_sb_qflags_to_disk() and xfs_sb_qflags_from_disk()
+ */
+#define XFS_GQUOTA_ENFD 0x0080  /* group quota limits enforced */
+#define XFS_GQUOTA_CHKD 0x0100  /* quotacheck run on group quotas */
+#define XFS_PQUOTA_ENFD 0x0200  /* project quota limits enforced */
+#define XFS_PQUOTA_CHKD 0x0400  /* quotacheck run on project quotas */
+
+/*
  * Quota Accounting/Enforcement flags
  */
 #define XFS_ALL_QUOTA_ACCT      \
                 (XFS_UQUOTA_ACCT | XFS_GQUOTA_ACCT | XFS_PQUOTA_ACCT)
-#define XFS_ALL_QUOTA_ENFD      (XFS_UQUOTA_ENFD | XFS_OQUOTA_ENFD)
-#define XFS_ALL_QUOTA_CHKD      (XFS_UQUOTA_CHKD | XFS_OQUOTA_CHKD)
+#define XFS_ALL_QUOTA_ENFD      \
+                (XFS_UQUOTA_ENFD | XFS_GQUOTA_ENFD | XFS_PQUOTA_ENFD)
+#define XFS_ALL_QUOTA_CHKD      \
+                (XFS_UQUOTA_CHKD | XFS_GQUOTA_CHKD | XFS_PQUOTA_CHKD)
 
 #define XFS_IS_QUOTA_RUNNING(mp)        ((mp)->m_qflags & XFS_ALL_QUOTA_ACCT)
 #define XFS_IS_UQUOTA_RUNNING(mp)       ((mp)->m_qflags & XFS_UQUOTA_ACCT)
 #define XFS_IS_PQUOTA_RUNNING(mp)       ((mp)->m_qflags & XFS_PQUOTA_ACCT)
 #define XFS_IS_GQUOTA_RUNNING(mp)       ((mp)->m_qflags & XFS_GQUOTA_ACCT)
 #define XFS_IS_UQUOTA_ENFORCED(mp)      ((mp)->m_qflags & XFS_UQUOTA_ENFD)
-#define XFS_IS_OQUOTA_ENFORCED(mp)      ((mp)->m_qflags & XFS_OQUOTA_ENFD)
+#define XFS_IS_GQUOTA_ENFORCED(mp)      ((mp)->m_qflags & XFS_GQUOTA_ENFD)
+#define XFS_IS_PQUOTA_ENFORCED(mp)      ((mp)->m_qflags & XFS_PQUOTA_ENFD)
 
 /*
  * Incore only flags for quotaoff - these bits get cleared when quota(s)
  * are in the process of getting turned off. These flags are in m_qflags but
  * never in sb_qflags.
  */
-#define XFS_UQUOTA_ACTIVE       0x0100  /* uquotas are being turned off */
-#define XFS_PQUOTA_ACTIVE       0x0200  /* pquotas are being turned off */
-#define XFS_GQUOTA_ACTIVE       0x0400  /* gquotas are being turned off */
+#define XFS_UQUOTA_ACTIVE       0x1000  /* uquotas are being turned off */
+#define XFS_GQUOTA_ACTIVE       0x2000  /* gquotas are being turned off */
+#define XFS_PQUOTA_ACTIVE       0x4000  /* pquotas are being turned off */
 #define XFS_ALL_QUOTA_ACTIVE    \
-        (XFS_UQUOTA_ACTIVE | XFS_PQUOTA_ACTIVE | XFS_GQUOTA_ACTIVE)
+        (XFS_UQUOTA_ACTIVE | XFS_GQUOTA_ACTIVE | XFS_PQUOTA_ACTIVE)
 
 /*
  * Checking XFS_IS_*QUOTA_ON() while holding any inode lock guarantees
@@ -268,24 +280,23 @@ typedef struct xfs_qoff_logformat {
         ((XFS_IS_UQUOTA_ON(mp) && \
                 (mp->m_sb.sb_qflags & XFS_UQUOTA_CHKD) == 0) || \
          (XFS_IS_GQUOTA_ON(mp) && \
-                ((mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD) == 0 || \
-                 (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT))) || \
+                (mp->m_sb.sb_qflags & XFS_GQUOTA_CHKD) == 0) || \
          (XFS_IS_PQUOTA_ON(mp) && \
-                ((mp->m_sb.sb_qflags & XFS_OQUOTA_CHKD) == 0 || \
-                 (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT))))
+                (mp->m_sb.sb_qflags & XFS_PQUOTA_CHKD) == 0))
 
 #define XFS_MOUNT_QUOTA_SET1    (XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\
-                                 XFS_UQUOTA_CHKD|XFS_PQUOTA_ACCT|\
-                                 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD)
+                                 XFS_UQUOTA_CHKD|XFS_GQUOTA_ACCT|\
+                                 XFS_GQUOTA_ENFD|XFS_GQUOTA_CHKD)
 
 #define XFS_MOUNT_QUOTA_SET2    (XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\
-                                 XFS_UQUOTA_CHKD|XFS_GQUOTA_ACCT|\
-                                 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD)
+                                 XFS_UQUOTA_CHKD|XFS_PQUOTA_ACCT|\
+                                 XFS_PQUOTA_ENFD|XFS_PQUOTA_CHKD)
 
 #define XFS_MOUNT_QUOTA_ALL     (XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD|\
-                                 XFS_UQUOTA_CHKD|XFS_PQUOTA_ACCT|\
-                                 XFS_OQUOTA_ENFD|XFS_OQUOTA_CHKD|\
-                                 XFS_GQUOTA_ACCT)
+                                 XFS_UQUOTA_CHKD|XFS_GQUOTA_ACCT|\
+                                 XFS_GQUOTA_ENFD|XFS_GQUOTA_CHKD|\
+                                 XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD|\
+                                 XFS_PQUOTA_CHKD)
 
 
 /*
diff --git a/fs/xfs/xfs_quotaops.c b/fs/xfs/xfs_quotaops.c
index 71926d630527..20e30f93b0c7 100644
--- a/fs/xfs/xfs_quotaops.c
+++ b/fs/xfs/xfs_quotaops.c
@@ -75,8 +75,10 @@ xfs_fs_set_xstate(
                 flags |= XFS_GQUOTA_ACCT;
         if (uflags & FS_QUOTA_UDQ_ENFD)
                 flags |= XFS_UQUOTA_ENFD;
-        if (uflags & (FS_QUOTA_PDQ_ENFD|FS_QUOTA_GDQ_ENFD))
-                flags |= XFS_OQUOTA_ENFD;
+        if (uflags & FS_QUOTA_GDQ_ENFD)
+                flags |= XFS_GQUOTA_ENFD;
+        if (uflags & FS_QUOTA_PDQ_ENFD)
+                flags |= XFS_PQUOTA_ENFD;
 
         switch (op) {
         case Q_XQUOTAON:
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index e5e8b5ee8bfa..1d68ffcdeaa7 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -360,17 +360,17 @@ xfs_parseargs(
                 } else if (!strcmp(this_char, MNTOPT_PQUOTA) ||
                            !strcmp(this_char, MNTOPT_PRJQUOTA)) {
                         mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
-                                         XFS_OQUOTA_ENFD);
+                                         XFS_PQUOTA_ENFD);
                 } else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) {
                         mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
-                        mp->m_qflags &= ~XFS_OQUOTA_ENFD;
+                        mp->m_qflags &= ~XFS_PQUOTA_ENFD;
                 } else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
                            !strcmp(this_char, MNTOPT_GRPQUOTA)) {
                         mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
-                                         XFS_OQUOTA_ENFD);
+                                         XFS_GQUOTA_ENFD);
                 } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
                         mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
-                        mp->m_qflags &= ~XFS_OQUOTA_ENFD;
+                        mp->m_qflags &= ~XFS_GQUOTA_ENFD;
                 } else if (!strcmp(this_char, MNTOPT_DELAYLOG)) {
                         xfs_warn(mp,
         "delaylog is the default now, option is deprecated.");
@@ -559,12 +559,12 @@ xfs_showargs(
         /* Either project or group quotas can be active, not both */
 
         if (mp->m_qflags & XFS_PQUOTA_ACCT) {
-                if (mp->m_qflags & XFS_OQUOTA_ENFD)
+                if (mp->m_qflags & XFS_PQUOTA_ENFD)
                         seq_puts(m, "," MNTOPT_PRJQUOTA);
                 else
                         seq_puts(m, "," MNTOPT_PQUOTANOENF);
         } else if (mp->m_qflags & XFS_GQUOTA_ACCT) {
-                if (mp->m_qflags & XFS_OQUOTA_ENFD)
+                if (mp->m_qflags & XFS_GQUOTA_ENFD)
                         seq_puts(m, "," MNTOPT_GRPQUOTA);
                 else
                         seq_puts(m, "," MNTOPT_GQUOTANOENF);
@@ -1132,8 +1132,8 @@ xfs_fs_statfs(
         spin_unlock(&mp->m_sb_lock);
 
         if ((ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
-            ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))) ==
-                              (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))
+            ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) ==
+                              (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))
                 xfs_qm_statvfs(ip, statp);
         return 0;
 }
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 7ea7485f9fb8..3ba64d540168 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -632,8 +632,8 @@ xfs_trans_dqresv(
         if ((flags & XFS_QMOPT_FORCE_RES) == 0 &&
             dqp->q_core.d_id &&
             ((XFS_IS_UQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISUDQ(dqp)) ||
-             (XFS_IS_OQUOTA_ENFORCED(dqp->q_mount) &&
-              (XFS_QM_ISPDQ(dqp) || XFS_QM_ISGDQ(dqp))))) {
+             (XFS_IS_GQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISGDQ(dqp)) ||
+             (XFS_IS_PQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISPDQ(dqp)))) {
                 if (nblks > 0) {
                         /*
                          * dquot is locked already. See if we'd go over the