xfs: rename XFS_DQ_{USER,GROUP,PROJ} to XFS_DQTYPE_*

We're going to split up the incore dquot state flags from the ondisk
dquot flags (eventually renaming this "type") so start by renaming the
three flags and the bitmask that are going to participate in this.

Signed-off-by: Darrick J. Wong <darrick.wong@oracle.com>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>

diff --git a/fs/xfs/libxfs/xfs_dquot_buf.c b/fs/xfs/libxfs/xfs_dquot_buf.c
index eb2412e13f30b1a562f7fffffb76b2e678994132..450147df30424ab596ee185d74f0ec2dc672108e 100644 (file)
--- a/fs/xfs/libxfs/xfs_dquot_buf.c
+++ b/fs/xfs/libxfs/xfs_dquot_buf.c
@@ -59,9 +59,9 @@ xfs_dquot_verify(
        if (ddq->d_version != XFS_DQUOT_VERSION)
                return __this_address;
 
-       if (ddq->d_flags != XFS_DQ_USER &&
-           ddq->d_flags != XFS_DQ_PROJ &&
-           ddq->d_flags != XFS_DQ_GROUP)
+       if (ddq->d_flags != XFS_DQTYPE_USER &&
+           ddq->d_flags != XFS_DQTYPE_PROJ &&
+           ddq->d_flags != XFS_DQTYPE_GROUP)
                return __this_address;
 
        if (id != -1 && id != be32_to_cpu(ddq->d_id))

diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index a534ebee92b9e13db86ac60968446d8b0aac7b8c..5d5e0f5eda973505358e6dc539a19aa3c7b9fe1f 100644 (file)
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -1157,7 +1157,7 @@ static inline void xfs_dinode_put_rdev(struct xfs_dinode *dip, xfs_dev_t rdev)
 struct xfs_disk_dquot {
        __be16          d_magic;        /* dquot magic = XFS_DQUOT_MAGIC */
        __u8            d_version;      /* dquot version */
-       __u8            d_flags;        /* XFS_DQ_USER/PROJ/GROUP */
+       __u8            d_flags;        /* XFS_DQTYPE_USER/PROJ/GROUP */
        __be32          d_id;           /* user,project,group id */
        __be64          d_blk_hardlimit;/* absolute limit on disk blks */
        __be64          d_blk_softlimit;/* preferred limit on disk blks */

diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
index d2245f375719ab94c68f276d558570bd181c811c..baf6c4ad88afe4861741bcdd4c40d5622117bc02 100644 (file)
--- a/fs/xfs/libxfs/xfs_quota_defs.h
+++ b/fs/xfs/libxfs/xfs_quota_defs.h
@@ -21,18 +21,20 @@ typedef uint16_t    xfs_qwarncnt_t;
 /*
  * flags for q_flags field in the dquot.
  */
-#define XFS_DQ_USER            0x0001          /* a user quota */
-#define XFS_DQ_PROJ            0x0002          /* project quota */
-#define XFS_DQ_GROUP           0x0004          /* a group quota */
+#define XFS_DQTYPE_USER                0x0001          /* a user quota */
+#define XFS_DQTYPE_PROJ                0x0002          /* project quota */
+#define XFS_DQTYPE_GROUP       0x0004          /* a group quota */
 #define XFS_DQFLAG_DIRTY       0x0008          /* dquot is dirty */
 #define XFS_DQFLAG_FREEING     0x0010          /* dquot is being torn down */
 
-#define XFS_DQ_ALLTYPES                (XFS_DQ_USER|XFS_DQ_PROJ|XFS_DQ_GROUP)
+#define XFS_DQTYPE_REC_MASK    (XFS_DQTYPE_USER | \
+                                XFS_DQTYPE_PROJ | \
+                                XFS_DQTYPE_GROUP)
 
 #define XFS_DQFLAG_STRINGS \
-       { XFS_DQ_USER,          "USER" }, \
-       { XFS_DQ_PROJ,          "PROJ" }, \
-       { XFS_DQ_GROUP,         "GROUP" }, \
+       { XFS_DQTYPE_USER,      "USER" }, \
+       { XFS_DQTYPE_PROJ,      "PROJ" }, \
+       { XFS_DQTYPE_GROUP,     "GROUP" }, \
        { XFS_DQFLAG_DIRTY,     "DIRTY" }, \
        { XFS_DQFLAG_FREEING,   "FREEING" }
 

diff --git a/fs/xfs/scrub/quota.c b/fs/xfs/scrub/quota.c
index f4aad5b0018835c9e2db5f057897efffe6857aee..1db07485f14868a3f78a064009ce0134ac348292 100644 (file)
--- a/fs/xfs/scrub/quota.c
+++ b/fs/xfs/scrub/quota.c
@@ -24,11 +24,11 @@ xchk_quota_to_dqtype(
 {
        switch (sc->sm->sm_type) {
        case XFS_SCRUB_TYPE_UQUOTA:
-               return XFS_DQ_USER;
+               return XFS_DQTYPE_USER;
        case XFS_SCRUB_TYPE_GQUOTA:
-               return XFS_DQ_GROUP;
+               return XFS_DQTYPE_GROUP;
        case XFS_SCRUB_TYPE_PQUOTA:
-               return XFS_DQ_PROJ;
+               return XFS_DQTYPE_PROJ;
        default:
                return 0;
        }

diff --git a/fs/xfs/scrub/repair.c b/fs/xfs/scrub/repair.c
index db3cfd12803d473a1a98fc0be284212dac2fddad..0746518965862e6f78b02ba6108dc44781b9cab4 100644 (file)
--- a/fs/xfs/scrub/repair.c
+++ b/fs/xfs/scrub/repair.c
@@ -939,11 +939,11 @@ xrep_ino_dqattach(
 "inode %llu repair encountered quota error %d, quotacheck forced.",
                                (unsigned long long)sc->ip->i_ino, error);
                if (XFS_IS_UQUOTA_ON(sc->mp) && !sc->ip->i_udquot)
-                       xrep_force_quotacheck(sc, XFS_DQ_USER);
+                       xrep_force_quotacheck(sc, XFS_DQTYPE_USER);
                if (XFS_IS_GQUOTA_ON(sc->mp) && !sc->ip->i_gdquot)
-                       xrep_force_quotacheck(sc, XFS_DQ_GROUP);
+                       xrep_force_quotacheck(sc, XFS_DQTYPE_GROUP);
                if (XFS_IS_PQUOTA_ON(sc->mp) && !sc->ip->i_pdquot)
-                       xrep_force_quotacheck(sc, XFS_DQ_PROJ);
+                       xrep_force_quotacheck(sc, XFS_DQTYPE_PROJ);
                /* fall through */
        case -ESRCH:
                error = 0;

diff --git a/fs/xfs/xfs_buf_item_recover.c b/fs/xfs/xfs_buf_item_recover.c
index 8bee582cf66adecef78dadd7a4c7f4cb6159b5d7..d480f11e6b007d3691709659976b5039a285d85f 100644 (file)
--- a/fs/xfs/xfs_buf_item_recover.c
+++ b/fs/xfs/xfs_buf_item_recover.c
@@ -546,11 +546,11 @@ xlog_recover_do_dquot_buffer(
 
        type = 0;
        if (buf_f->blf_flags & XFS_BLF_UDQUOT_BUF)
-               type |= XFS_DQ_USER;
+               type |= XFS_DQTYPE_USER;
        if (buf_f->blf_flags & XFS_BLF_PDQUOT_BUF)
-               type |= XFS_DQ_PROJ;
+               type |= XFS_DQTYPE_PROJ;
        if (buf_f->blf_flags & XFS_BLF_GDQUOT_BUF)
-               type |= XFS_DQ_GROUP;
+               type |= XFS_DQTYPE_GROUP;
        /*
         * This type of quotas was turned off, so ignore this buffer
         */

diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 8e84623cc331709a96dc24fb08e5fb6433c6b79d..4053e7e390f1906310e98be99a03b84bfc707ed7 100644 (file)
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -190,10 +190,10 @@ xfs_qm_init_dquot_blk(
                }
        }
 
-       if (type & XFS_DQ_USER) {
+       if (type & XFS_DQTYPE_USER) {
                qflag = XFS_UQUOTA_CHKD;
                blftype = XFS_BLF_UDQUOT_BUF;
-       } else if (type & XFS_DQ_PROJ) {
+       } else if (type & XFS_DQTYPE_PROJ) {
                qflag = XFS_PQUOTA_CHKD;
                blftype = XFS_BLF_PDQUOT_BUF;
        } else {
@@ -311,7 +311,7 @@ xfs_dquot_disk_alloc(
         * the entire thing.
         */
        xfs_qm_init_dquot_blk(tp, mp, dqp->q_id,
-                             dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
+                             dqp->dq_flags & XFS_DQTYPE_REC_MASK, bp);
        xfs_buf_set_ref(bp, XFS_DQUOT_REF);
 
        /*
@@ -448,13 +448,13 @@ xfs_dquot_alloc(
         * quotas.
         */
        switch (type) {
-       case XFS_DQ_USER:
+       case XFS_DQTYPE_USER:
                /* uses the default lock class */
                break;
-       case XFS_DQ_GROUP:
+       case XFS_DQTYPE_GROUP:
                lockdep_set_class(&dqp->q_qlock, &xfs_dquot_group_class);
                break;
-       case XFS_DQ_PROJ:
+       case XFS_DQTYPE_PROJ:
                lockdep_set_class(&dqp->q_qlock, &xfs_dquot_project_class);
                break;
        default:
@@ -480,7 +480,7 @@ xfs_dquot_from_disk(
         * Ensure that we got the type and ID we were looking for.
         * Everything else was checked by the dquot buffer verifier.
         */
-       if ((ddqp->d_flags & XFS_DQ_ALLTYPES) != dqp->dq_flags ||
+       if ((ddqp->d_flags & XFS_DQTYPE_REC_MASK) != dqp->dq_flags ||
            be32_to_cpu(ddqp->d_id) != dqp->q_id) {
                xfs_alert_tag(bp->b_mount, XFS_PTAG_VERIFIER_ERROR,
                          "Metadata corruption detected at %pS, quota %u",
@@ -530,7 +530,7 @@ xfs_dquot_to_disk(
 {
        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_flags = dqp->dq_flags & XFS_DQTYPE_REC_MASK;
        ddqp->d_id = cpu_to_be32(dqp->q_id);
        ddqp->d_pad0 = 0;
        ddqp->d_pad = 0;
@@ -779,15 +779,15 @@ xfs_qm_dqget_checks(
                return -ESRCH;
 
        switch (type) {
-       case XFS_DQ_USER:
+       case XFS_DQTYPE_USER:
                if (!XFS_IS_UQUOTA_ON(mp))
                        return -ESRCH;
                return 0;
-       case XFS_DQ_GROUP:
+       case XFS_DQTYPE_GROUP:
                if (!XFS_IS_GQUOTA_ON(mp))
                        return -ESRCH;
                return 0;
-       case XFS_DQ_PROJ:
+       case XFS_DQTYPE_PROJ:
                if (!XFS_IS_PQUOTA_ON(mp))
                        return -ESRCH;
                return 0;
@@ -874,11 +874,11 @@ xfs_qm_id_for_quotatype(
        uint                    type)
 {
        switch (type) {
-       case XFS_DQ_USER:
+       case XFS_DQTYPE_USER:
                return i_uid_read(VFS_I(ip));
-       case XFS_DQ_GROUP:
+       case XFS_DQTYPE_GROUP:
                return i_gid_read(VFS_I(ip));
-       case XFS_DQ_PROJ:
+       case XFS_DQTYPE_PROJ:
                return ip->i_d.di_projid;
        }
        ASSERT(0);
@@ -1114,11 +1114,11 @@ static xfs_failaddr_t
 xfs_qm_dqflush_check(
        struct xfs_dquot        *dqp)
 {
-       __u8                    type = dqp->dq_flags & XFS_DQ_ALLTYPES;
+       __u8                    type = dqp->dq_flags & XFS_DQTYPE_REC_MASK;
 
-       if (type != XFS_DQ_USER &&
-           type != XFS_DQ_GROUP &&
-           type != XFS_DQ_PROJ)
+       if (type != XFS_DQTYPE_USER &&
+           type != XFS_DQTYPE_GROUP &&
+           type != XFS_DQTYPE_PROJ)
                return __this_address;
 
        if (dqp->q_id == 0)

diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 9e44da522684e7ff1d349e37e20832268c18a52e..17a21677723f67a149fd3a4a179376abf126dbdb 100644 (file)
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -130,12 +130,12 @@ static inline void xfs_dqunlock(struct xfs_dquot *dqp)
 
 static inline int xfs_this_quota_on(struct xfs_mount *mp, int type)
 {
-       switch (type & XFS_DQ_ALLTYPES) {
-       case XFS_DQ_USER:
+       switch (type & XFS_DQTYPE_REC_MASK) {
+       case XFS_DQTYPE_USER:
                return XFS_IS_UQUOTA_ON(mp);
-       case XFS_DQ_GROUP:
+       case XFS_DQTYPE_GROUP:
                return XFS_IS_GQUOTA_ON(mp);
-       case XFS_DQ_PROJ:
+       case XFS_DQTYPE_PROJ:
                return XFS_IS_PQUOTA_ON(mp);
        default:
                return 0;
@@ -144,12 +144,12 @@ static inline int xfs_this_quota_on(struct xfs_mount *mp, int type)
 
 static inline struct xfs_dquot *xfs_inode_dquot(struct xfs_inode *ip, int type)
 {
-       switch (type & XFS_DQ_ALLTYPES) {
-       case XFS_DQ_USER:
+       switch (type & XFS_DQTYPE_REC_MASK) {
+       case XFS_DQTYPE_USER:
                return ip->i_udquot;
-       case XFS_DQ_GROUP:
+       case XFS_DQTYPE_GROUP:
                return ip->i_gdquot;
-       case XFS_DQ_PROJ:
+       case XFS_DQTYPE_PROJ:
                return ip->i_pdquot;
        default:
                return NULL;
@@ -175,9 +175,9 @@ void xfs_dquot_to_disk(struct xfs_disk_dquot *ddqp, struct xfs_dquot *dqp);
 
 #define XFS_DQ_IS_LOCKED(dqp)  (mutex_is_locked(&((dqp)->q_qlock)))
 #define XFS_DQ_IS_DIRTY(dqp)   ((dqp)->q_flags & XFS_DQFLAG_DIRTY)
-#define XFS_QM_ISUDQ(dqp)      ((dqp)->dq_flags & XFS_DQ_USER)
-#define XFS_QM_ISPDQ(dqp)      ((dqp)->dq_flags & XFS_DQ_PROJ)
-#define XFS_QM_ISGDQ(dqp)      ((dqp)->dq_flags & XFS_DQ_GROUP)
+#define XFS_QM_ISUDQ(dqp)      ((dqp)->dq_flags & XFS_DQTYPE_USER)
+#define XFS_QM_ISPDQ(dqp)      ((dqp)->dq_flags & XFS_DQTYPE_PROJ)
+#define XFS_QM_ISGDQ(dqp)      ((dqp)->dq_flags & XFS_DQTYPE_GROUP)
 
 void           xfs_qm_dqdestroy(struct xfs_dquot *dqp);
 int            xfs_qm_dqflush(struct xfs_dquot *dqp, struct xfs_buf **bpp);

diff --git a/fs/xfs/xfs_dquot_item_recover.c b/fs/xfs/xfs_dquot_item_recover.c
index 9f64162ca300264bca6ad14f597f38d47c3f5774..d7eb85c7d394d47429f8d815ca96693b5bba54f6 100644 (file)
--- a/fs/xfs/xfs_dquot_item_recover.c
+++ b/fs/xfs/xfs_dquot_item_recover.c
@@ -39,7 +39,7 @@ xlog_recover_dquot_ra_pass2(
        if (item->ri_buf[1].i_len < sizeof(struct xfs_disk_dquot))
                return;
 
-       type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
+       type = recddq->d_flags & (XFS_DQTYPE_USER | XFS_DQTYPE_PROJ | XFS_DQTYPE_GROUP);
        ASSERT(type);
        if (log->l_quotaoffs_flag & type)
                return;
@@ -91,7 +91,7 @@ xlog_recover_dquot_commit_pass2(
        /*
         * This type of quotas was turned off, so ignore this record.
         */
-       type = recddq->d_flags & (XFS_DQ_USER | XFS_DQ_PROJ | XFS_DQ_GROUP);
+       type = recddq->d_flags & (XFS_DQTYPE_USER | XFS_DQTYPE_PROJ | XFS_DQTYPE_GROUP);
        ASSERT(type);
        if (log->l_quotaoffs_flag & type)
                return 0;
@@ -185,11 +185,11 @@ xlog_recover_quotaoff_commit_pass1(
         * group/project quotaoff or both.
         */
        if (qoff_f->qf_flags & XFS_UQUOTA_ACCT)
-               log->l_quotaoffs_flag |= XFS_DQ_USER;
+               log->l_quotaoffs_flag |= XFS_DQTYPE_USER;
        if (qoff_f->qf_flags & XFS_PQUOTA_ACCT)
-               log->l_quotaoffs_flag |= XFS_DQ_PROJ;
+               log->l_quotaoffs_flag |= XFS_DQTYPE_PROJ;
        if (qoff_f->qf_flags & XFS_GQUOTA_ACCT)
-               log->l_quotaoffs_flag |= XFS_DQ_GROUP;
+               log->l_quotaoffs_flag |= XFS_DQTYPE_GROUP;
 
        return 0;
 }

diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index 58a750ce689c0d4d2e232f0f3996e874a6bc2d3a..3c6e936d2f9923ea7fa48a60a30e32607aaeba14 100644 (file)
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -1424,7 +1424,7 @@ __xfs_inode_free_quota_eofblocks(
        eofb.eof_flags = XFS_EOF_FLAGS_UNION|XFS_EOF_FLAGS_SYNC;
 
        if (XFS_IS_UQUOTA_ENFORCED(ip->i_mount)) {
-               dq = xfs_inode_dquot(ip, XFS_DQ_USER);
+               dq = xfs_inode_dquot(ip, XFS_DQTYPE_USER);
                if (dq && xfs_dquot_lowsp(dq)) {
                        eofb.eof_uid = VFS_I(ip)->i_uid;
                        eofb.eof_flags |= XFS_EOF_FLAGS_UID;
@@ -1433,7 +1433,7 @@ __xfs_inode_free_quota_eofblocks(
        }
 
        if (XFS_IS_GQUOTA_ENFORCED(ip->i_mount)) {
-               dq = xfs_inode_dquot(ip, XFS_DQ_GROUP);
+               dq = xfs_inode_dquot(ip, XFS_DQTYPE_GROUP);
                if (dq && xfs_dquot_lowsp(dq)) {
                        eofb.eof_gid = VFS_I(ip)->i_gid;
                        eofb.eof_flags |= XFS_EOF_FLAGS_GID;

diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index f60a6e44363b6c484ff631841f3ff0cd0cac2496..d3dc4106a35cd5506706a11d5cdc7048afa7c29c 100644 (file)
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -450,14 +450,14 @@ xfs_iomap_prealloc_size(
         * Check each quota to cap the prealloc size, provide a shift value to
         * throttle with and adjust amount of available space.
         */
-       if (xfs_quota_need_throttle(ip, XFS_DQ_USER, alloc_blocks))
-               xfs_quota_calc_throttle(ip, XFS_DQ_USER, &qblocks, &qshift,
+       if (xfs_quota_need_throttle(ip, XFS_DQTYPE_USER, alloc_blocks))
+               xfs_quota_calc_throttle(ip, XFS_DQTYPE_USER, &qblocks, &qshift,
                                        &freesp);
-       if (xfs_quota_need_throttle(ip, XFS_DQ_GROUP, alloc_blocks))
-               xfs_quota_calc_throttle(ip, XFS_DQ_GROUP, &qblocks, &qshift,
+       if (xfs_quota_need_throttle(ip, XFS_DQTYPE_GROUP, alloc_blocks))
+               xfs_quota_calc_throttle(ip, XFS_DQTYPE_GROUP, &qblocks, &qshift,
                                        &freesp);
-       if (xfs_quota_need_throttle(ip, XFS_DQ_PROJ, alloc_blocks))
-               xfs_quota_calc_throttle(ip, XFS_DQ_PROJ, &qblocks, &qshift,
+       if (xfs_quota_need_throttle(ip, XFS_DQTYPE_PROJ, alloc_blocks))
+               xfs_quota_calc_throttle(ip, XFS_DQTYPE_PROJ, &qblocks, &qshift,
                                        &freesp);
 
        /*

diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index bf94c1bbda16423fc2ea23e404524a6aa79454ef..47d4b6937c84c477cd52ec847bf5558d882d8ac7 100644 (file)
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -189,11 +189,11 @@ xfs_qm_dqpurge_all(
        uint                    flags)
 {
        if (flags & XFS_QMOPT_UQUOTA)
-               xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge, NULL);
+               xfs_qm_dquot_walk(mp, XFS_DQTYPE_USER, xfs_qm_dqpurge, NULL);
        if (flags & XFS_QMOPT_GQUOTA)
-               xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_dqpurge, NULL);
+               xfs_qm_dquot_walk(mp, XFS_DQTYPE_GROUP, xfs_qm_dqpurge, NULL);
        if (flags & XFS_QMOPT_PQUOTA)
-               xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_dqpurge, NULL);
+               xfs_qm_dquot_walk(mp, XFS_DQTYPE_PROJ, xfs_qm_dqpurge, NULL);
 }
 
 /*
@@ -331,7 +331,7 @@ xfs_qm_dqattach_locked(
 
        if (XFS_IS_UQUOTA_ON(mp) && !ip->i_udquot) {
                error = xfs_qm_dqattach_one(ip, i_uid_read(VFS_I(ip)),
-                               XFS_DQ_USER, doalloc, &ip->i_udquot);
+                               XFS_DQTYPE_USER, doalloc, &ip->i_udquot);
                if (error)
                        goto done;
                ASSERT(ip->i_udquot);
@@ -339,14 +339,14 @@ xfs_qm_dqattach_locked(
 
        if (XFS_IS_GQUOTA_ON(mp) && !ip->i_gdquot) {
                error = xfs_qm_dqattach_one(ip, i_gid_read(VFS_I(ip)),
-                               XFS_DQ_GROUP, doalloc, &ip->i_gdquot);
+                               XFS_DQTYPE_GROUP, doalloc, &ip->i_gdquot);
                if (error)
                        goto done;
                ASSERT(ip->i_gdquot);
        }
 
        if (XFS_IS_PQUOTA_ON(mp) && !ip->i_pdquot) {
-               error = xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
+               error = xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQTYPE_PROJ,
                                doalloc, &ip->i_pdquot);
                if (error)
                        goto done;
@@ -664,16 +664,16 @@ xfs_qm_init_quotainfo(
 
        mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
 
-       xfs_qm_init_timelimits(mp, XFS_DQ_USER);
-       xfs_qm_init_timelimits(mp, XFS_DQ_GROUP);
-       xfs_qm_init_timelimits(mp, XFS_DQ_PROJ);
+       xfs_qm_init_timelimits(mp, XFS_DQTYPE_USER);
+       xfs_qm_init_timelimits(mp, XFS_DQTYPE_GROUP);
+       xfs_qm_init_timelimits(mp, XFS_DQTYPE_PROJ);
 
        if (XFS_IS_UQUOTA_RUNNING(mp))
-               xfs_qm_set_defquota(mp, XFS_DQ_USER, qinf);
+               xfs_qm_set_defquota(mp, XFS_DQTYPE_USER, qinf);
        if (XFS_IS_GQUOTA_RUNNING(mp))
-               xfs_qm_set_defquota(mp, XFS_DQ_GROUP, qinf);
+               xfs_qm_set_defquota(mp, XFS_DQTYPE_GROUP, qinf);
        if (XFS_IS_PQUOTA_RUNNING(mp))
-               xfs_qm_set_defquota(mp, XFS_DQ_PROJ, qinf);
+               xfs_qm_set_defquota(mp, XFS_DQTYPE_PROJ, qinf);
 
        qinf->qi_shrinker.count_objects = xfs_qm_shrink_count;
        qinf->qi_shrinker.scan_objects = xfs_qm_shrink_scan;
@@ -855,7 +855,7 @@ xfs_qm_reset_dqcounts(
                 * xfs_dquot_verify.
                 */
                if (xfs_dqblk_verify(mp, &dqb[j], id + j) ||
-                   (dqb[j].dd_diskdq.d_flags & XFS_DQ_ALLTYPES) != type)
+                   (dqb[j].dd_diskdq.d_flags & XFS_DQTYPE_REC_MASK) != type)
                        xfs_dqblk_repair(mp, &dqb[j], id + j, type);
 
                /*
@@ -1176,21 +1176,21 @@ xfs_qm_dqusage_adjust(
         * and quotaoffs don't race. (Quotachecks happen at mount time only).
         */
        if (XFS_IS_UQUOTA_ON(mp)) {
-               error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_USER, nblks,
+               error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_USER, nblks,
                                rtblks);
                if (error)
                        goto error0;
        }
 
        if (XFS_IS_GQUOTA_ON(mp)) {
-               error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_GROUP, nblks,
+               error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_GROUP, nblks,
                                rtblks);
                if (error)
                        goto error0;
        }
 
        if (XFS_IS_PQUOTA_ON(mp)) {
-               error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_PROJ, nblks,
+               error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQTYPE_PROJ, nblks,
                                rtblks);
                if (error)
                        goto error0;
@@ -1281,7 +1281,7 @@ xfs_qm_quotacheck(
         * We don't log our changes till later.
         */
        if (uip) {
-               error = xfs_qm_reset_dqcounts_buf(mp, uip, XFS_DQ_USER,
+               error = xfs_qm_reset_dqcounts_buf(mp, uip, XFS_DQTYPE_USER,
                                         &buffer_list);
                if (error)
                        goto error_return;
@@ -1289,7 +1289,7 @@ xfs_qm_quotacheck(
        }
 
        if (gip) {
-               error = xfs_qm_reset_dqcounts_buf(mp, gip, XFS_DQ_GROUP,
+               error = xfs_qm_reset_dqcounts_buf(mp, gip, XFS_DQTYPE_GROUP,
                                         &buffer_list);
                if (error)
                        goto error_return;
@@ -1297,7 +1297,7 @@ xfs_qm_quotacheck(
        }
 
        if (pip) {
-               error = xfs_qm_reset_dqcounts_buf(mp, pip, XFS_DQ_PROJ,
+               error = xfs_qm_reset_dqcounts_buf(mp, pip, XFS_DQTYPE_PROJ,
                                         &buffer_list);
                if (error)
                        goto error_return;
@@ -1314,17 +1314,17 @@ xfs_qm_quotacheck(
         * down to disk buffers if everything was updated successfully.
         */
        if (XFS_IS_UQUOTA_ON(mp)) {
-               error = xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_flush_one,
+               error = xfs_qm_dquot_walk(mp, XFS_DQTYPE_USER, xfs_qm_flush_one,
                                          &buffer_list);
        }
        if (XFS_IS_GQUOTA_ON(mp)) {
-               error2 = xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_flush_one,
+               error2 = xfs_qm_dquot_walk(mp, XFS_DQTYPE_GROUP, xfs_qm_flush_one,
                                           &buffer_list);
                if (!error)
                        error = error2;
        }
        if (XFS_IS_PQUOTA_ON(mp)) {
-               error2 = xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_flush_one,
+               error2 = xfs_qm_dquot_walk(mp, XFS_DQTYPE_PROJ, xfs_qm_flush_one,
                                           &buffer_list);
                if (!error)
                        error = error2;
@@ -1662,7 +1662,7 @@ xfs_qm_vop_dqalloc(
                         */
                        xfs_iunlock(ip, lockflags);
                        error = xfs_qm_dqget(mp, from_kuid(user_ns, uid),
-                                       XFS_DQ_USER, true, &uq);
+                                       XFS_DQTYPE_USER, true, &uq);
                        if (error) {
                                ASSERT(error != -ENOENT);
                                return error;
@@ -1686,7 +1686,7 @@ xfs_qm_vop_dqalloc(
                if (!gid_eq(inode->i_gid, gid)) {
                        xfs_iunlock(ip, lockflags);
                        error = xfs_qm_dqget(mp, from_kgid(user_ns, gid),
-                                       XFS_DQ_GROUP, true, &gq);
+                                       XFS_DQTYPE_GROUP, true, &gq);
                        if (error) {
                                ASSERT(error != -ENOENT);
                                goto error_rele;
@@ -1702,8 +1702,8 @@ xfs_qm_vop_dqalloc(
        if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
                if (ip->i_d.di_projid != prid) {
                        xfs_iunlock(ip, lockflags);
-                       error = xfs_qm_dqget(mp, (xfs_dqid_t)prid, XFS_DQ_PROJ,
-                                       true, &pq);
+                       error = xfs_qm_dqget(mp, (xfs_dqid_t)prid,
+                                       XFS_DQTYPE_PROJ, true, &pq);
                        if (error) {
                                ASSERT(error != -ENOENT);
                                goto error_rele;

diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
index 11c28ff0298c2dd97540d6f759a84583bd84b106..21bc67d4962c033c1f84d9ad454eac20ab5948e3 100644 (file)
--- a/fs/xfs/xfs_qm.h
+++ b/fs/xfs/xfs_qm.h
@@ -73,11 +73,11 @@ xfs_dquot_tree(
        int                     type)
 {
        switch (type) {
-       case XFS_DQ_USER:
+       case XFS_DQTYPE_USER:
                return &qi->qi_uquota_tree;
-       case XFS_DQ_GROUP:
+       case XFS_DQTYPE_GROUP:
                return &qi->qi_gquota_tree;
-       case XFS_DQ_PROJ:
+       case XFS_DQTYPE_PROJ:
                return &qi->qi_pquota_tree;
        default:
                ASSERT(0);
@@ -88,12 +88,12 @@ xfs_dquot_tree(
 static inline struct xfs_inode *
 xfs_quota_inode(xfs_mount_t *mp, uint dq_flags)
 {
-       switch (dq_flags & XFS_DQ_ALLTYPES) {
-       case XFS_DQ_USER:
+       switch (dq_flags & XFS_DQTYPE_REC_MASK) {
+       case XFS_DQTYPE_USER:
                return mp->m_quotainfo->qi_uquotaip;
-       case XFS_DQ_GROUP:
+       case XFS_DQTYPE_GROUP:
                return mp->m_quotainfo->qi_gquotaip;
-       case XFS_DQ_PROJ:
+       case XFS_DQTYPE_PROJ:
                return mp->m_quotainfo->qi_pquotaip;
        default:
                ASSERT(0);
@@ -105,11 +105,11 @@ static inline int
 xfs_dquot_type(struct xfs_dquot *dqp)
 {
        if (XFS_QM_ISUDQ(dqp))
-               return XFS_DQ_USER;
+               return XFS_DQTYPE_USER;
        if (XFS_QM_ISGDQ(dqp))
-               return XFS_DQ_GROUP;
+               return XFS_DQTYPE_GROUP;
        ASSERT(XFS_QM_ISPDQ(dqp));
-       return XFS_DQ_PROJ;
+       return XFS_DQTYPE_PROJ;
 }
 
 extern void    xfs_trans_mod_dquot(struct xfs_trans *tp, struct xfs_dquot *dqp,
@@ -166,11 +166,11 @@ static inline struct xfs_def_quota *
 xfs_get_defquota(struct xfs_quotainfo *qi, int type)
 {
        switch (type) {
-       case XFS_DQ_USER:
+       case XFS_DQTYPE_USER:
                return &qi->qi_usr_default;
-       case XFS_DQ_GROUP:
+       case XFS_DQTYPE_GROUP:
                return &qi->qi_grp_default;
-       case XFS_DQ_PROJ:
+       case XFS_DQTYPE_PROJ:
                return &qi->qi_prj_default;
        default:
                ASSERT(0);

diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
index 0993217e5ac86883e790719e1ff124f8d8d81fe3..639398091ad6bac4655d3472dd712071d40dd60d 100644 (file)
--- a/fs/xfs/xfs_qm_bhv.c
+++ b/fs/xfs/xfs_qm_bhv.c
@@ -60,7 +60,7 @@ xfs_qm_statvfs(
        struct xfs_mount        *mp = ip->i_mount;
        struct xfs_dquot        *dqp;
 
-       if (!xfs_qm_dqget(mp, ip->i_d.di_projid, XFS_DQ_PROJ, false, &dqp)) {
+       if (!xfs_qm_dqget(mp, ip->i_d.di_projid, XFS_DQTYPE_PROJ, false, &dqp)) {
                xfs_fill_statvfs_from_dquot(statp, dqp);
                xfs_qm_dqput(dqp);
        }

diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index cbe352187d328d59f857d23fed2fd3e60e27ed5f..119c3d7d5f51b3268a9e7f97c8587dd6fef82e39 100644 (file)
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -660,18 +660,18 @@ 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) && type == XFS_DQ_USER) ||
-           (!XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQ_GROUP) ||
-           (!XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQ_PROJ)) {
+       if ((!XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_USER) ||
+           (!XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_GROUP) ||
+           (!XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_PROJ)) {
                dst->d_spc_timer = 0;
                dst->d_ino_timer = 0;
                dst->d_rt_spc_timer = 0;
        }
 
 #ifdef DEBUG
-       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)) &&
+       if (((XFS_IS_UQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_USER) ||
+            (XFS_IS_GQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_GROUP) ||
+            (XFS_IS_PQUOTA_ENFORCED(mp) && type == XFS_DQTYPE_PROJ)) &&
            dqp->q_id != 0) {
                if ((dst->d_space > dst->d_spc_softlimit) &&
                    (dst->d_spc_softlimit > 0)) {

diff --git a/fs/xfs/xfs_quota.h b/fs/xfs/xfs_quota.h
index c92ae5e02ce86a032bf948f70667f29d625c17f5..0ae35fb5cb8927881d336bc6b2e07fc363a43de0 100644 (file)
--- a/fs/xfs/xfs_quota.h
+++ b/fs/xfs/xfs_quota.h
@@ -42,11 +42,11 @@ xfs_quota_chkd_flag(
        uint            dqtype)
 {
        switch (dqtype) {
-       case XFS_DQ_USER:
+       case XFS_DQTYPE_USER:
                return XFS_UQUOTA_CHKD;
-       case XFS_DQ_GROUP:
+       case XFS_DQTYPE_GROUP:
                return XFS_GQUOTA_CHKD;
-       case XFS_DQ_PROJ:
+       case XFS_DQTYPE_PROJ:
                return XFS_PQUOTA_CHKD;
        default:
                return 0;

diff --git a/fs/xfs/xfs_quotaops.c b/fs/xfs/xfs_quotaops.c
index 299695a068f370309bf7c11a5ce68425cb27e82c..ba69906edecf72c54344934a7a95b87958f88dfa 100644 (file)
--- a/fs/xfs/xfs_quotaops.c
+++ b/fs/xfs/xfs_quotaops.c
@@ -90,11 +90,11 @@ xfs_quota_type(int type)
 {
        switch (type) {
        case USRQUOTA:
-               return XFS_DQ_USER;
+               return XFS_DQTYPE_USER;
        case GRPQUOTA:
-               return XFS_DQ_GROUP;
+               return XFS_DQTYPE_GROUP;
        default:
-               return XFS_DQ_PROJ;
+               return XFS_DQTYPE_PROJ;
        }
 }
 

diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index a8f480e5401fce85b9fdaa5fc41c72d9207ba43e..ea61e279f831737ff1e7ae355c0de23f6627155c 100644 (file)
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -553,9 +553,9 @@ xfs_quota_warn(
 {
        enum quota_type qtype;
 
-       if (dqp->dq_flags & XFS_DQ_PROJ)
+       if (dqp->dq_flags & XFS_DQTYPE_PROJ)
                qtype = PRJQUOTA;
-       else if (dqp->dq_flags & XFS_DQ_USER)
+       else if (dqp->dq_flags & XFS_DQTYPE_USER)
                qtype = USRQUOTA;
        else
                qtype = GRPQUOTA;