xfs: remove qcore from incore dquots

Now that we've stopped using qcore entirely, drop it from the incore
dquot.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Chandan Babu R <chandanrlinux@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>

diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index 4f66564..a534ebe 100644 (file)
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -1150,10 +1150,9 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
 #define XFS_DQUOT_VERSION      (uint8_t)0x01   /* latest version number */
 
 /*
- * This is the main portion of the on-disk representation of quota
- * information for a user. This is the q_core of the struct xfs_dquot that
- * is kept in kernel memory. We pad this with some more expansion room
- * to construct the on disk structure.
+ * This is the main portion of the on-disk representation of quota information
+ * for a user.  We pad this with some more expansion room to construct the on
+ * disk structure.
  */
 struct xfs_disk_dquot {
        __be16          d_magic;        /* dquot magic = XFS_DQUOT_MAGIC */

diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index 20bc763..f4aad5b 100644 (file)
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -79,7 +79,6 @@ xchk_quota_item(
        struct xchk_quota_info  *sqi = priv;
        struct xfs_scrub        *sc = sqi->sc;
        struct xfs_mount        *mp = sc->mp;
-       struct xfs_disk_dquot   *d = &dq->q_core;
        struct xfs_quotainfo    *qi = mp->m_quotainfo;
        xfs_fileoff_t           offset;
        xfs_ino_t               fs_icount;
@@ -98,13 +97,6 @@ xchk_quota_item(
 
        sqi->last_id = dq->q_id;
 
-       /* Did we get the dquot type we wanted? */
-       if (dqtype != (d->d_flags & XFS_DQ_ALLTYPES))
-               xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
-
-       if (d->d_pad0 != cpu_to_be32(0) || d->d_pad != cpu_to_be16(0))
-               xchk_fblock_set_corrupt(sc, XFS_DATA_FORK, offset);
-
        /*
         * Warn if the hard limits are larger than the fs.
         * Administrators can do this, though in production this seems

diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index b094fc4..6ed3cde 100644 (file)
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -529,7 +529,6 @@ xfs_dquot_from_disk(
        }
 
        /* copy everything from disk dquot to the incore dquot */
-       memcpy(&dqp->q_core, ddqp, sizeof(struct xfs_disk_dquot));
        dqp->q_blk.hardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
        dqp->q_blk.softlimit = be64_to_cpu(ddqp->d_blk_softlimit);
        dqp->q_ino.hardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
@@ -568,7 +567,13 @@ xfs_dquot_to_disk(
        struct xfs_disk_dquot   *ddqp,
        struct xfs_dquot        *dqp)
 {
-       memcpy(ddqp, &dqp->q_core, sizeof(struct xfs_disk_dquot));
+       ddqp->d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
+       ddqp->d_version = XFS_DQUOT_VERSION;
+       ddqp->d_flags = dqp->dq_flags & XFS_DQ_ALLTYPES;
+       ddqp->d_id = cpu_to_be32(dqp->q_id);
+       ddqp->d_pad0 = 0;
+       ddqp->d_pad = 0;
+
        ddqp->d_blk_hardlimit = cpu_to_be64(dqp->q_blk.hardlimit);
        ddqp->d_blk_softlimit = cpu_to_be64(dqp->q_blk.softlimit);
        ddqp->d_ino_hardlimit = cpu_to_be64(dqp->q_ino.hardlimit);
@@ -1189,8 +1194,7 @@ xfs_qm_dqflush(
        struct xfs_mount        *mp = dqp->q_mount;
        struct xfs_log_item     *lip = &dqp->q_logitem.qli_item;
        struct xfs_buf          *bp;
-       struct xfs_dqblk        *dqb;
-       struct xfs_disk_dquot   *ddqp;
+       struct xfs_dqblk        *dqblk;
        xfs_failaddr_t          fa;
        int                     error;
 
@@ -1214,22 +1218,6 @@ xfs_qm_dqflush(
        if (error)
                goto out_abort;
 
-       /*
-        * Calculate the location of the dquot inside the buffer.
-        */
-       dqb = bp->b_addr + dqp->q_bufoffset;
-       ddqp = &dqb->dd_diskdq;
-
-       /* sanity check the in-core structure before we flush */
-       fa = xfs_dquot_verify(mp, &dqp->q_core, dqp->q_id, 0);
-       if (fa) {
-               xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS",
-                               dqp->q_id, fa);
-               xfs_buf_relse(bp);
-               error = -EFSCORRUPTED;
-               goto out_abort;
-       }
-
        fa = xfs_qm_dqflush_check(dqp);
        if (fa) {
                xfs_alert(mp, "corrupt dquot ID 0x%x in memory at %pS",
@@ -1239,7 +1227,9 @@ xfs_qm_dqflush(
                goto out_abort;
        }
 
-       xfs_dquot_to_disk(ddqp, dqp);
+       /* Flush the incore dquot to the ondisk buffer. */
+       dqblk = bp->b_addr + dqp->q_bufoffset;
+       xfs_dquot_to_disk(&dqblk->dd_diskdq, dqp);
 
        /*
         * Clear the dirty field and remember the flush lsn for later use.
@@ -1259,8 +1249,8 @@ xfs_qm_dqflush(
         * of a dquot without an up-to-date CRC getting to disk.
         */
        if (xfs_sb_version_hascrc(&mp->m_sb)) {
-               dqb->dd_lsn = cpu_to_be64(dqp->q_logitem.qli_item.li_lsn);
-               xfs_update_cksum((char *)dqb, sizeof(struct xfs_dqblk),
+               dqblk->dd_lsn = cpu_to_be64(dqp->q_logitem.qli_item.li_lsn);
+               xfs_update_cksum((char *)dqblk, sizeof(struct xfs_dqblk),
                                 XFS_DQUOT_CRC_OFF);
        }
 

diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 69dbf3d..48fb0f2 100644 (file)
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -72,7 +72,6 @@ struct xfs_dquot {
        struct xfs_dquot_res    q_ino;  /* inodes */
        struct xfs_dquot_res    q_rtb;  /* realtime blocks */
 
-       struct xfs_disk_dquot   q_core;
        struct xfs_dq_logitem   q_logitem;
 
        xfs_qcnt_t              q_prealloc_lo_wmark;

diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 73fa0b5..1ef6663 100644 (file)
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -161,7 +161,7 @@ xfs_qm_dqpurge(
        xfs_dqfunlock(dqp);
        xfs_dqunlock(dqp);
 
-       radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags), dqp->q_id);
+       radix_tree_delete(xfs_dquot_tree(qi, xfs_dquot_type(dqp)), dqp->q_id);
        qi->qi_dquots--;
 
        /*
@@ -1588,7 +1588,7 @@ xfs_qm_dqfree_one(
        struct xfs_quotainfo    *qi = mp->m_quotainfo;
 
        mutex_lock(&qi->qi_tree_lock);
-       radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags), dqp->q_id);
+       radix_tree_delete(xfs_dquot_tree(qi, xfs_dquot_type(dqp)), dqp->q_id);
 
        qi->qi_dquots--;
        mutex_unlock(&qi->qi_tree_lock);

diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 9e3507b..d05b16e 100644 (file)
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -638,12 +638,9 @@ xfs_qm_scall_getquota_fill_qc(
         * 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_GQUOTA_ENFORCED(mp) &&
-            dqp->q_core.d_flags == XFS_DQ_GROUP) ||
-           (!XFS_IS_PQUOTA_ENFORCED(mp) &&
-            dqp->q_core.d_flags == XFS_DQ_PROJ)) {
+       if ((!XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQ_USER) ||
+           (!XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQ_GROUP) ||
+           (!XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQ_PROJ)) {
                dst->d_spc_timer = 0;
                dst->d_ino_timer = 0;
                dst->d_rt_spc_timer = 0;