[XFS] endianess annotations and cleanup for the quota code

SGI-PV: 943272 SGI-Modid: xfs-linux:xfs-kern:199767a Signed-off-by: Christoph Hellwig <hch@sgi.com> Signed-off-by: Nathan Scott <nathans@sgi.com>
author: Christoph Hellwig <hch@sgi.com> 2005-11-01 23:01:12 -0500
committer: Nathan Scott <nathans@sgi.com> 2005-11-01 23:01:12 -0500
commit: 1149d96ae825a1e1e9d66774175372c003f29caf (patch)
tree: bfc8b5c03a39283228922e711fd2675bd281db50 /fs/xfs/quota/xfs_dquot.c
parent: fa7e7d71e05f12921fefdc23386183578d3ed8c7 (diff)
1 files changed, 89 insertions, 95 deletions
diff --git a/fs/xfs/quota/xfs_dquot.c b/fs/xfs/quota/xfs_dquot.c
index d3c23accfa19..00b5043dfa5a 100644
--- a/fs/xfs/quota/xfs_dquot.c
+++ b/fs/xfs/quota/xfs_dquot.c
@@ -96,7 +96,7 @@ xfs_qm_dqinit(
        brandnewdquot = xfs_qm_dqalloc_incore(&dqp);
        dqp->dq_flags = type;
-        INT_SET(dqp->q_core.d_id, ARCH_CONVERT, id);
+        dqp->q_core.d_id = cpu_to_be32(id);
        dqp->q_mount = mp;
        /*
@@ -178,10 +178,10 @@ xfs_qm_dqinit_core(
        /*
         * Caller has zero'd the entire dquot 'chunk' already.
         */
-        INT_SET(d->dd_diskdq.d_magic, ARCH_CONVERT, XFS_DQUOT_MAGIC);
+        d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
-        INT_SET(d->dd_diskdq.d_version, ARCH_CONVERT, XFS_DQUOT_VERSION);
+        d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
-        INT_SET(d->dd_diskdq.d_id, ARCH_CONVERT, id);
+        d->dd_diskdq.d_id = cpu_to_be32(id);
-        INT_SET(d->dd_diskdq.d_flags, ARCH_CONVERT, type);
+        d->dd_diskdq.d_flags = type;
 }
@@ -211,19 +211,13 @@ __xfs_dqtrace_entry(
                     (void *)(__psint_t)dqp->q_nrefs,
                     (void *)(__psint_t)dqp->dq_flags,
                     (void *)(__psint_t)dqp->q_res_bcount,
-                     (void *)(__psint_t)INT_GET(dqp->q_core.d_bcount,
+                     (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_bcount),
-                                                ARCH_CONVERT),
+                     (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_icount),
-                     (void *)(__psint_t)INT_GET(dqp->q_core.d_icount,
+                     (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_blk_hardlimit),
-                                                ARCH_CONVERT),
+                     (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_blk_softlimit),
-                     (void *)(__psint_t)INT_GET(dqp->q_core.d_blk_hardlimit,
+                     (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_ino_hardlimit),
-                                                ARCH_CONVERT),
+                     (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_ino_softlimit),
-                     (void *)(__psint_t)INT_GET(dqp->q_core.d_blk_softlimit,
+                     (void *)(__psint_t)be32_to_cpu(dqp->q_core.d_id),
-                                                ARCH_CONVERT),
-                     (void *)(__psint_t)INT_GET(dqp->q_core.d_ino_hardlimit,
-                                                ARCH_CONVERT),
-                     (void *)(__psint_t)INT_GET(dqp->q_core.d_ino_softlimit,
-                                                ARCH_CONVERT),
-                     (void *)(__psint_t)INT_GET(dqp->q_core.d_id, ARCH_CONVERT),
                     (void *)(__psint_t)current_pid(),
                     (void *)(__psint_t)ino,
                     (void *)(__psint_t)retaddr,
@@ -248,17 +242,17 @@ xfs_qm_adjust_dqlimits(
        ASSERT(d->d_id);
        if (q->qi_bsoftlimit && !d->d_blk_softlimit)
-                INT_SET(d->d_blk_softlimit, ARCH_CONVERT, q->qi_bsoftlimit);
+                d->d_blk_softlimit = cpu_to_be64(q->qi_bsoftlimit);
        if (q->qi_bhardlimit && !d->d_blk_hardlimit)
-                INT_SET(d->d_blk_hardlimit, ARCH_CONVERT, q->qi_bhardlimit);
+                d->d_blk_hardlimit = cpu_to_be64(q->qi_bhardlimit);
        if (q->qi_isoftlimit && !d->d_ino_softlimit)
-                INT_SET(d->d_ino_softlimit, ARCH_CONVERT, q->qi_isoftlimit);
+                d->d_ino_softlimit = cpu_to_be64(q->qi_isoftlimit);
        if (q->qi_ihardlimit && !d->d_ino_hardlimit)
-                INT_SET(d->d_ino_hardlimit, ARCH_CONVERT, q->qi_ihardlimit);
+                d->d_ino_hardlimit = cpu_to_be64(q->qi_ihardlimit);
        if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit)
-                INT_SET(d->d_rtb_softlimit, ARCH_CONVERT, q->qi_rtbsoftlimit);
+                d->d_rtb_softlimit = cpu_to_be64(q->qi_rtbsoftlimit);
        if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit)
-                INT_SET(d->d_rtb_hardlimit, ARCH_CONVERT, q->qi_rtbhardlimit);
+                d->d_rtb_hardlimit = cpu_to_be64(q->qi_rtbhardlimit);
 }
 /*
@@ -282,81 +276,81 @@ xfs_qm_adjust_dqtimers(
        ASSERT(d->d_id);
 #ifdef QUOTADEBUG
-        if (INT_GET(d->d_blk_hardlimit, ARCH_CONVERT))
+        if (d->d_blk_hardlimit)
-                ASSERT(INT_GET(d->d_blk_softlimit, ARCH_CONVERT) <=
+                ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
-                        INT_GET(d->d_blk_hardlimit, ARCH_CONVERT));
+                       be64_to_cpu(d->d_blk_hardlimit));
-        if (INT_GET(d->d_ino_hardlimit, ARCH_CONVERT))
+        if (d->d_ino_hardlimit)
-                ASSERT(INT_GET(d->d_ino_softlimit, ARCH_CONVERT) <=
+                ASSERT(be64_to_cpu(d->d_ino_softlimit) <=
-                        INT_GET(d->d_ino_hardlimit, ARCH_CONVERT));
+                       be64_to_cpu(d->d_ino_hardlimit));
-        if (INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT))
+        if (d->d_rtb_hardlimit)
-                ASSERT(INT_GET(d->d_rtb_softlimit, ARCH_CONVERT) <=
+                ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
-                        INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT));
+                       be64_to_cpu(d->d_rtb_hardlimit));
 #endif
        if (!d->d_btimer) {
-                if ((INT_GET(d->d_blk_softlimit, ARCH_CONVERT) &&
+                if ((d->d_blk_softlimit &&
-                    (INT_GET(d->d_bcount, ARCH_CONVERT) >=
+                     (be64_to_cpu(d->d_bcount) >=
-                                INT_GET(d->d_blk_softlimit, ARCH_CONVERT))) ||
+                      be64_to_cpu(d->d_blk_softlimit))) ||
-                    (INT_GET(d->d_blk_hardlimit, ARCH_CONVERT) &&
+                    (d->d_blk_hardlimit &&
-                    (INT_GET(d->d_bcount, ARCH_CONVERT) >=
+                     (be64_to_cpu(d->d_bcount) >=
-                                INT_GET(d->d_blk_hardlimit, ARCH_CONVERT)))) {
+                      be64_to_cpu(d->d_blk_hardlimit)))) {
-                        INT_SET(d->d_btimer, ARCH_CONVERT,
+                        d->d_btimer = cpu_to_be32(get_seconds() +
-                                get_seconds() + XFS_QI_BTIMELIMIT(mp));
+                                        XFS_QI_BTIMELIMIT(mp));
                } else {
                        d->d_bwarns = 0;
                }
        } else {
                if ((!d->d_blk_softlimit ||
-                    (INT_GET(d->d_bcount, ARCH_CONVERT) <
+                     (be64_to_cpu(d->d_bcount) <
-                                INT_GET(d->d_blk_softlimit, ARCH_CONVERT))) &&
+                      be64_to_cpu(d->d_blk_softlimit))) &&
                    (!d->d_blk_hardlimit ||
-                    (INT_GET(d->d_bcount, ARCH_CONVERT) <
+                    (be64_to_cpu(d->d_bcount) <
-                                INT_GET(d->d_blk_hardlimit, ARCH_CONVERT)))) {
+                     be64_to_cpu(d->d_blk_hardlimit)))) {
                        d->d_btimer = 0;
                }
        }
        if (!d->d_itimer) {
-                if ((INT_GET(d->d_ino_softlimit, ARCH_CONVERT) &&
+                if ((d->d_ino_softlimit &&
-                    (INT_GET(d->d_icount, ARCH_CONVERT) >=
+                     (be64_to_cpu(d->d_icount) >=
-                                INT_GET(d->d_ino_softlimit, ARCH_CONVERT))) ||
+                      be64_to_cpu(d->d_ino_softlimit))) ||
-                    (INT_GET(d->d_ino_hardlimit, ARCH_CONVERT) &&
+                    (d->d_ino_hardlimit &&
-                    (INT_GET(d->d_icount, ARCH_CONVERT) >=
+                     (be64_to_cpu(d->d_icount) >=
-                                INT_GET(d->d_ino_hardlimit, ARCH_CONVERT)))) {
+                      be64_to_cpu(d->d_ino_hardlimit)))) {
-                        INT_SET(d->d_itimer, ARCH_CONVERT,
+                        d->d_itimer = cpu_to_be32(get_seconds() +
-                                get_seconds() + XFS_QI_ITIMELIMIT(mp));
+                                        XFS_QI_ITIMELIMIT(mp));
                } else {
                        d->d_iwarns = 0;
                }
        } else {
                if ((!d->d_ino_softlimit ||
-                    (INT_GET(d->d_icount, ARCH_CONVERT) <
+                     (be64_to_cpu(d->d_icount) <
-                                INT_GET(d->d_ino_softlimit, ARCH_CONVERT)))  &&
+                      be64_to_cpu(d->d_ino_softlimit)))  &&
                    (!d->d_ino_hardlimit ||
-                    (INT_GET(d->d_icount, ARCH_CONVERT) <
+                     (be64_to_cpu(d->d_icount) <
-                                INT_GET(d->d_ino_hardlimit, ARCH_CONVERT)))) {
+                      be64_to_cpu(d->d_ino_hardlimit)))) {
                        d->d_itimer = 0;
                }
        }
        if (!d->d_rtbtimer) {
-                if ((INT_GET(d->d_rtb_softlimit, ARCH_CONVERT) &&
+                if ((d->d_rtb_softlimit &&
-                    (INT_GET(d->d_rtbcount, ARCH_CONVERT) >=
+                     (be64_to_cpu(d->d_rtbcount) >=
-                                INT_GET(d->d_rtb_softlimit, ARCH_CONVERT))) ||
+                      be64_to_cpu(d->d_rtb_softlimit))) ||
-                    (INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT) &&
+                    (d->d_rtb_hardlimit &&
-                    (INT_GET(d->d_rtbcount, ARCH_CONVERT) >=
+                     (be64_to_cpu(d->d_rtbcount) >=
-                                INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT)))) {
+                      be64_to_cpu(d->d_rtb_hardlimit)))) {
-                        INT_SET(d->d_rtbtimer, ARCH_CONVERT,
+                        d->d_rtbtimer = cpu_to_be32(get_seconds() +
-                                get_seconds() + XFS_QI_RTBTIMELIMIT(mp));
+                                        XFS_QI_RTBTIMELIMIT(mp));
                } else {
                        d->d_rtbwarns = 0;
                }
        } else {
                if ((!d->d_rtb_softlimit ||
-                    (INT_GET(d->d_rtbcount, ARCH_CONVERT) <
+                     (be64_to_cpu(d->d_rtbcount) <
-                                INT_GET(d->d_rtb_softlimit, ARCH_CONVERT))) &&
+                      be64_to_cpu(d->d_rtb_softlimit))) &&
                    (!d->d_rtb_hardlimit ||
-                    (INT_GET(d->d_rtbcount, ARCH_CONVERT) <
+                     (be64_to_cpu(d->d_rtbcount) <
-                                INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT)))) {
+                      be64_to_cpu(d->d_rtb_hardlimit)))) {
                        d->d_rtbtimer = 0;
                }
        }
@@ -474,7 +468,7 @@ xfs_qm_dqalloc(
         * Make a chunk of dquots out of this buffer and log
         * the entire thing.
         */
-        xfs_qm_init_dquot_blk(tp, mp, INT_GET(dqp->q_core.d_id, ARCH_CONVERT),
+        xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
                              dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
        /*
@@ -538,7 +532,7 @@ xfs_qm_dqtobp(
        xfs_trans_t     *tp = (tpp ? *tpp : NULL);
        mp = dqp->q_mount;
-        id = INT_GET(dqp->q_core.d_id, ARCH_CONVERT);
+        id = be32_to_cpu(dqp->q_core.d_id);
        nmaps = 1;
        newdquot = B_FALSE;
@@ -677,16 +671,16 @@ xfs_qm_dqread(
        /* copy everything from disk dquot to the incore dquot */
        memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t));
-        ASSERT(INT_GET(dqp->q_core.d_id, ARCH_CONVERT) == id);
+        ASSERT(be32_to_cpu(dqp->q_core.d_id) == id);
        xfs_qm_dquot_logitem_init(dqp);
        /*
         * Reservation counters are defined as reservation plus current usage
         * to avoid having to add everytime.
         */
-        dqp->q_res_bcount = INT_GET(ddqp->d_bcount, ARCH_CONVERT);
+        dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount);
-        dqp->q_res_icount = INT_GET(ddqp->d_icount, ARCH_CONVERT);
+        dqp->q_res_icount = be64_to_cpu(ddqp->d_icount);
-        dqp->q_res_rtbcount = INT_GET(ddqp->d_rtbcount, ARCH_CONVERT);
+        dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount);
        /* Mark the buf so that this will stay incore a little longer */
        XFS_BUF_SET_VTYPE_REF(bp, B_FS_DQUOT, XFS_DQUOT_REF);
@@ -812,7 +806,7 @@ xfs_qm_dqlookup(
                 * dqlock to look at the id field of the dquot, since the
                 * id can't be modified without the hashlock anyway.
                 */
-                if (INT_GET(dqp->q_core.d_id, ARCH_CONVERT) == id && dqp->q_mount == mp) {
+                if (be32_to_cpu(dqp->q_core.d_id) == id && dqp->q_mount == mp) {
                        xfs_dqtrace_entry(dqp, "DQFOUND BY LOOKUP");
                        /*
                         * All in core dquots must be on the dqlist of mp
@@ -843,7 +837,7 @@ xfs_qm_dqlookup(
                         * id couldn't have changed; we had the hashlock all
                         * along
                         */
-                        ASSERT(INT_GET(dqp->q_core.d_id, ARCH_CONVERT) == id);
+                        ASSERT(be32_to_cpu(dqp->q_core.d_id) == id);
                        if (flist_locked) {
                                if (dqp->q_nrefs != 0) {
@@ -1265,7 +1259,7 @@ xfs_qm_dqflush(
                return (error);
        }
-        if (xfs_qm_dqcheck(&dqp->q_core, INT_GET(ddqp->d_id, ARCH_CONVERT),
+        if (xfs_qm_dqcheck(&dqp->q_core, be32_to_cpu(ddqp->d_id),
                           0, XFS_QMOPT_DOWARN, "dqflush (incore copy)")) {
                xfs_force_shutdown(dqp->q_mount, XFS_CORRUPT_INCORE);
                return XFS_ERROR(EIO);
@@ -1418,8 +1412,8 @@ xfs_dqlock2(
 {
        if (d1 && d2) {
                ASSERT(d1 != d2);
-                if (INT_GET(d1->q_core.d_id, ARCH_CONVERT) >
+                if (be32_to_cpu(d1->q_core.d_id) >
-                    INT_GET(d2->q_core.d_id, ARCH_CONVERT)) {
+                    be32_to_cpu(d2->q_core.d_id)) {
                        xfs_dqlock(d2);
                        xfs_dqlock(d1);
                } else {
@@ -1541,33 +1535,33 @@ xfs_qm_dqprint(xfs_dquot_t *dqp)
 {
        cmn_err(CE_DEBUG, "-----------KERNEL DQUOT----------------");
        cmn_err(CE_DEBUG, "---- dquotID =  %d",
-                (int)INT_GET(dqp->q_core.d_id, ARCH_CONVERT));
+                (int)be32_to_cpu(dqp->q_core.d_id));
        cmn_err(CE_DEBUG, "---- type    =  %s", DQFLAGTO_TYPESTR(dqp));
        cmn_err(CE_DEBUG, "---- fs      =  0x%p", dqp->q_mount);
        cmn_err(CE_DEBUG, "---- blkno   =  0x%x", (int) dqp->q_blkno);
        cmn_err(CE_DEBUG, "---- boffset =  0x%x", (int) dqp->q_bufoffset);
        cmn_err(CE_DEBUG, "---- blkhlimit =  %Lu (0x%x)",
-                INT_GET(dqp->q_core.d_blk_hardlimit, ARCH_CONVERT),
+                be64_to_cpu(dqp->q_core.d_blk_hardlimit),
-                (int) INT_GET(dqp->q_core.d_blk_hardlimit, ARCH_CONVERT));
+                (int)be64_to_cpu(dqp->q_core.d_blk_hardlimit));
        cmn_err(CE_DEBUG, "---- blkslimit =  %Lu (0x%x)",
-                INT_GET(dqp->q_core.d_blk_softlimit, ARCH_CONVERT),
+                be64_to_cpu(dqp->q_core.d_blk_softlimit),
-                (int)INT_GET(dqp->q_core.d_blk_softlimit, ARCH_CONVERT));
+                (int)be64_to_cpu(dqp->q_core.d_blk_softlimit));
        cmn_err(CE_DEBUG, "---- inohlimit =  %Lu (0x%x)",
-                INT_GET(dqp->q_core.d_ino_hardlimit, ARCH_CONVERT),
+                be64_to_cpu(dqp->q_core.d_ino_hardlimit),
-                (int)INT_GET(dqp->q_core.d_ino_hardlimit, ARCH_CONVERT));
+                (int)be64_to_cpu(dqp->q_core.d_ino_hardlimit));
        cmn_err(CE_DEBUG, "---- inoslimit =  %Lu (0x%x)",
-                INT_GET(dqp->q_core.d_ino_softlimit, ARCH_CONVERT),
+                be64_to_cpu(dqp->q_core.d_ino_softlimit),
-                (int)INT_GET(dqp->q_core.d_ino_softlimit, ARCH_CONVERT));
+                (int)be64_to_cpu(dqp->q_core.d_ino_softlimit));
        cmn_err(CE_DEBUG, "---- bcount  =  %Lu (0x%x)",
-                INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT),
+                be64_to_cpu(dqp->q_core.d_bcount),
-                (int)INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT));
+                (int)be64_to_cpu(dqp->q_core.d_bcount));
        cmn_err(CE_DEBUG, "---- icount  =  %Lu (0x%x)",
-                INT_GET(dqp->q_core.d_icount, ARCH_CONVERT),
+                be64_to_cpu(dqp->q_core.d_icount),
-                (int)INT_GET(dqp->q_core.d_icount, ARCH_CONVERT));
+                (int)be64_to_cpu(dqp->q_core.d_icount));
        cmn_err(CE_DEBUG, "---- btimer  =  %d",
-                (int)INT_GET(dqp->q_core.d_btimer, ARCH_CONVERT));
+                (int)be32_to_cpu(dqp->q_core.d_btimer));
        cmn_err(CE_DEBUG, "---- itimer  =  %d",
-                (int)INT_GET(dqp->q_core.d_itimer, ARCH_CONVERT));
+                (int)be32_to_cpu(dqp->q_core.d_itimer));
        cmn_err(CE_DEBUG, "---------------------------");
 }
 #endif
author	Christoph Hellwig <hch@sgi.com>	2005-11-01 23:01:12 -0500
committer	Nathan Scott <nathans@sgi.com>	2005-11-01 23:01:12 -0500
commit	1149d96ae825a1e1e9d66774175372c003f29caf (patch)
tree	bfc8b5c03a39283228922e711fd2675bd281db50 /fs/xfs/quota/xfs_dquot.c
parent	fa7e7d71e05f12921fefdc23386183578d3ed8c7 (diff)

diff --git a/fs/xfs/quota/xfs_dquot.c b/fs/xfs/quota/xfs_dquot.c index d3c23accfa19..00b5043dfa5a 100644 --- a/fs/xfs/quota/xfs_dquot.c +++ b/fs/xfs/quota/xfs_dquot.c
@@ -96,7 +96,7 @@ xfs_qm_dqinit(
96		96
97	brandnewdquot = xfs_qm_dqalloc_incore(&dqp);	97	brandnewdquot = xfs_qm_dqalloc_incore(&dqp);
98	dqp->dq_flags = type;	98	dqp->dq_flags = type;
99	INT_SET(dqp->q_core.d_id, ARCH_CONVERT, id);	99	dqp->q_core.d_id = cpu_to_be32(id);
100	dqp->q_mount = mp;	100	dqp->q_mount = mp;
101		101
102	/*	102	/*
@@ -178,10 +178,10 @@ xfs_qm_dqinit_core(
178	/*	178	/*
179	* Caller has zero'd the entire dquot 'chunk' already.	179	* Caller has zero'd the entire dquot 'chunk' already.
180	*/	180	*/
181	INT_SET(d->dd_diskdq.d_magic, ARCH_CONVERT, XFS_DQUOT_MAGIC);	181	d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
182	INT_SET(d->dd_diskdq.d_version, ARCH_CONVERT, XFS_DQUOT_VERSION);	182	d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
183	INT_SET(d->dd_diskdq.d_id, ARCH_CONVERT, id);	183	d->dd_diskdq.d_id = cpu_to_be32(id);
184	INT_SET(d->dd_diskdq.d_flags, ARCH_CONVERT, type);	184	d->dd_diskdq.d_flags = type;
185	}	185	}
186		186
187		187
@@ -211,19 +211,13 @@ __xfs_dqtrace_entry(
211	(void *)(__psint_t)dqp->q_nrefs,	211	(void *)(__psint_t)dqp->q_nrefs,
212	(void *)(__psint_t)dqp->dq_flags,	212	(void *)(__psint_t)dqp->dq_flags,
213	(void *)(__psint_t)dqp->q_res_bcount,	213	(void *)(__psint_t)dqp->q_res_bcount,
214	(void *)(__psint_t)INT_GET(dqp->q_core.d_bcount,	214	(void *)(__psint_t)be64_to_cpu(dqp->q_core.d_bcount),
215	ARCH_CONVERT),	215	(void *)(__psint_t)be64_to_cpu(dqp->q_core.d_icount),
216	(void *)(__psint_t)INT_GET(dqp->q_core.d_icount,	216	(void *)(__psint_t)be64_to_cpu(dqp->q_core.d_blk_hardlimit),
217	ARCH_CONVERT),	217	(void *)(__psint_t)be64_to_cpu(dqp->q_core.d_blk_softlimit),
218	(void *)(__psint_t)INT_GET(dqp->q_core.d_blk_hardlimit,	218	(void *)(__psint_t)be64_to_cpu(dqp->q_core.d_ino_hardlimit),
219	ARCH_CONVERT),	219	(void *)(__psint_t)be64_to_cpu(dqp->q_core.d_ino_softlimit),
220	(void *)(__psint_t)INT_GET(dqp->q_core.d_blk_softlimit,	220	(void *)(__psint_t)be32_to_cpu(dqp->q_core.d_id),
221	ARCH_CONVERT),
222	(void *)(__psint_t)INT_GET(dqp->q_core.d_ino_hardlimit,
223	ARCH_CONVERT),
224	(void *)(__psint_t)INT_GET(dqp->q_core.d_ino_softlimit,
225	ARCH_CONVERT),
226	(void *)(__psint_t)INT_GET(dqp->q_core.d_id, ARCH_CONVERT),
227	(void *)(__psint_t)current_pid(),	221	(void *)(__psint_t)current_pid(),
228	(void *)(__psint_t)ino,	222	(void *)(__psint_t)ino,
229	(void *)(__psint_t)retaddr,	223	(void *)(__psint_t)retaddr,
@@ -248,17 +242,17 @@ xfs_qm_adjust_dqlimits(
248	ASSERT(d->d_id);	242	ASSERT(d->d_id);
249		243
250	if (q->qi_bsoftlimit && !d->d_blk_softlimit)	244	if (q->qi_bsoftlimit && !d->d_blk_softlimit)
251	INT_SET(d->d_blk_softlimit, ARCH_CONVERT, q->qi_bsoftlimit);	245	d->d_blk_softlimit = cpu_to_be64(q->qi_bsoftlimit);
252	if (q->qi_bhardlimit && !d->d_blk_hardlimit)	246	if (q->qi_bhardlimit && !d->d_blk_hardlimit)
253	INT_SET(d->d_blk_hardlimit, ARCH_CONVERT, q->qi_bhardlimit);	247	d->d_blk_hardlimit = cpu_to_be64(q->qi_bhardlimit);
254	if (q->qi_isoftlimit && !d->d_ino_softlimit)	248	if (q->qi_isoftlimit && !d->d_ino_softlimit)
255	INT_SET(d->d_ino_softlimit, ARCH_CONVERT, q->qi_isoftlimit);	249	d->d_ino_softlimit = cpu_to_be64(q->qi_isoftlimit);
256	if (q->qi_ihardlimit && !d->d_ino_hardlimit)	250	if (q->qi_ihardlimit && !d->d_ino_hardlimit)
257	INT_SET(d->d_ino_hardlimit, ARCH_CONVERT, q->qi_ihardlimit);	251	d->d_ino_hardlimit = cpu_to_be64(q->qi_ihardlimit);
258	if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit)	252	if (q->qi_rtbsoftlimit && !d->d_rtb_softlimit)
259	INT_SET(d->d_rtb_softlimit, ARCH_CONVERT, q->qi_rtbsoftlimit);	253	d->d_rtb_softlimit = cpu_to_be64(q->qi_rtbsoftlimit);
260	if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit)	254	if (q->qi_rtbhardlimit && !d->d_rtb_hardlimit)
261	INT_SET(d->d_rtb_hardlimit, ARCH_CONVERT, q->qi_rtbhardlimit);	255	d->d_rtb_hardlimit = cpu_to_be64(q->qi_rtbhardlimit);
262	}	256	}
263		257
264	/*	258	/*
@@ -282,81 +276,81 @@ xfs_qm_adjust_dqtimers(
282	ASSERT(d->d_id);	276	ASSERT(d->d_id);
283		277
284	#ifdef QUOTADEBUG	278	#ifdef QUOTADEBUG
285	if (INT_GET(d->d_blk_hardlimit, ARCH_CONVERT))	279	if (d->d_blk_hardlimit)
286	ASSERT(INT_GET(d->d_blk_softlimit, ARCH_CONVERT) <=	280	ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
287	INT_GET(d->d_blk_hardlimit, ARCH_CONVERT));	281	be64_to_cpu(d->d_blk_hardlimit));
288	if (INT_GET(d->d_ino_hardlimit, ARCH_CONVERT))	282	if (d->d_ino_hardlimit)
289	ASSERT(INT_GET(d->d_ino_softlimit, ARCH_CONVERT) <=	283	ASSERT(be64_to_cpu(d->d_ino_softlimit) <=
290	INT_GET(d->d_ino_hardlimit, ARCH_CONVERT));	284	be64_to_cpu(d->d_ino_hardlimit));
291	if (INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT))	285	if (d->d_rtb_hardlimit)
292	ASSERT(INT_GET(d->d_rtb_softlimit, ARCH_CONVERT) <=	286	ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
293	INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT));	287	be64_to_cpu(d->d_rtb_hardlimit));
294	#endif	288	#endif
295	if (!d->d_btimer) {	289	if (!d->d_btimer) {
296	if ((INT_GET(d->d_blk_softlimit, ARCH_CONVERT) &&	290	if ((d->d_blk_softlimit &&
297	(INT_GET(d->d_bcount, ARCH_CONVERT) >=	291	(be64_to_cpu(d->d_bcount) >=
298	INT_GET(d->d_blk_softlimit, ARCH_CONVERT))) \|\|	292	be64_to_cpu(d->d_blk_softlimit))) \|\|
299	(INT_GET(d->d_blk_hardlimit, ARCH_CONVERT) &&	293	(d->d_blk_hardlimit &&
300	(INT_GET(d->d_bcount, ARCH_CONVERT) >=	294	(be64_to_cpu(d->d_bcount) >=
301	INT_GET(d->d_blk_hardlimit, ARCH_CONVERT)))) {	295	be64_to_cpu(d->d_blk_hardlimit)))) {
302	INT_SET(d->d_btimer, ARCH_CONVERT,	296	d->d_btimer = cpu_to_be32(get_seconds() +
303	get_seconds() + XFS_QI_BTIMELIMIT(mp));	297	XFS_QI_BTIMELIMIT(mp));
304	} else {	298	} else {
305	d->d_bwarns = 0;	299	d->d_bwarns = 0;
306	}	300	}
307	} else {	301	} else {
308	if ((!d->d_blk_softlimit \|\|	302	if ((!d->d_blk_softlimit \|\|
309	(INT_GET(d->d_bcount, ARCH_CONVERT) <	303	(be64_to_cpu(d->d_bcount) <
310	INT_GET(d->d_blk_softlimit, ARCH_CONVERT))) &&	304	be64_to_cpu(d->d_blk_softlimit))) &&
311	(!d->d_blk_hardlimit \|\|	305	(!d->d_blk_hardlimit \|\|
312	(INT_GET(d->d_bcount, ARCH_CONVERT) <	306	(be64_to_cpu(d->d_bcount) <
313	INT_GET(d->d_blk_hardlimit, ARCH_CONVERT)))) {	307	be64_to_cpu(d->d_blk_hardlimit)))) {
314	d->d_btimer = 0;	308	d->d_btimer = 0;
315	}	309	}
316	}	310	}
317		311
318	if (!d->d_itimer) {	312	if (!d->d_itimer) {
319	if ((INT_GET(d->d_ino_softlimit, ARCH_CONVERT) &&	313	if ((d->d_ino_softlimit &&
320	(INT_GET(d->d_icount, ARCH_CONVERT) >=	314	(be64_to_cpu(d->d_icount) >=
321	INT_GET(d->d_ino_softlimit, ARCH_CONVERT))) \|\|	315	be64_to_cpu(d->d_ino_softlimit))) \|\|
322	(INT_GET(d->d_ino_hardlimit, ARCH_CONVERT) &&	316	(d->d_ino_hardlimit &&
323	(INT_GET(d->d_icount, ARCH_CONVERT) >=	317	(be64_to_cpu(d->d_icount) >=
324	INT_GET(d->d_ino_hardlimit, ARCH_CONVERT)))) {	318	be64_to_cpu(d->d_ino_hardlimit)))) {
325	INT_SET(d->d_itimer, ARCH_CONVERT,	319	d->d_itimer = cpu_to_be32(get_seconds() +
326	get_seconds() + XFS_QI_ITIMELIMIT(mp));	320	XFS_QI_ITIMELIMIT(mp));
327	} else {	321	} else {
328	d->d_iwarns = 0;	322	d->d_iwarns = 0;
329	}	323	}
330	} else {	324	} else {
331	if ((!d->d_ino_softlimit \|\|	325	if ((!d->d_ino_softlimit \|\|
332	(INT_GET(d->d_icount, ARCH_CONVERT) <	326	(be64_to_cpu(d->d_icount) <
333	INT_GET(d->d_ino_softlimit, ARCH_CONVERT))) &&	327	be64_to_cpu(d->d_ino_softlimit))) &&
334	(!d->d_ino_hardlimit \|\|	328	(!d->d_ino_hardlimit \|\|
335	(INT_GET(d->d_icount, ARCH_CONVERT) <	329	(be64_to_cpu(d->d_icount) <
336	INT_GET(d->d_ino_hardlimit, ARCH_CONVERT)))) {	330	be64_to_cpu(d->d_ino_hardlimit)))) {
337	d->d_itimer = 0;	331	d->d_itimer = 0;
338	}	332	}
339	}	333	}
340		334
341	if (!d->d_rtbtimer) {	335	if (!d->d_rtbtimer) {
342	if ((INT_GET(d->d_rtb_softlimit, ARCH_CONVERT) &&	336	if ((d->d_rtb_softlimit &&
343	(INT_GET(d->d_rtbcount, ARCH_CONVERT) >=	337	(be64_to_cpu(d->d_rtbcount) >=
344	INT_GET(d->d_rtb_softlimit, ARCH_CONVERT))) \|\|	338	be64_to_cpu(d->d_rtb_softlimit))) \|\|
345	(INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT) &&	339	(d->d_rtb_hardlimit &&
346	(INT_GET(d->d_rtbcount, ARCH_CONVERT) >=	340	(be64_to_cpu(d->d_rtbcount) >=
347	INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT)))) {	341	be64_to_cpu(d->d_rtb_hardlimit)))) {
348	INT_SET(d->d_rtbtimer, ARCH_CONVERT,	342	d->d_rtbtimer = cpu_to_be32(get_seconds() +
349	get_seconds() + XFS_QI_RTBTIMELIMIT(mp));	343	XFS_QI_RTBTIMELIMIT(mp));
350	} else {	344	} else {
351	d->d_rtbwarns = 0;	345	d->d_rtbwarns = 0;
352	}	346	}
353	} else {	347	} else {
354	if ((!d->d_rtb_softlimit \|\|	348	if ((!d->d_rtb_softlimit \|\|
355	(INT_GET(d->d_rtbcount, ARCH_CONVERT) <	349	(be64_to_cpu(d->d_rtbcount) <
356	INT_GET(d->d_rtb_softlimit, ARCH_CONVERT))) &&	350	be64_to_cpu(d->d_rtb_softlimit))) &&
357	(!d->d_rtb_hardlimit \|\|	351	(!d->d_rtb_hardlimit \|\|
358	(INT_GET(d->d_rtbcount, ARCH_CONVERT) <	352	(be64_to_cpu(d->d_rtbcount) <
359	INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT)))) {	353	be64_to_cpu(d->d_rtb_hardlimit)))) {
360	d->d_rtbtimer = 0;	354	d->d_rtbtimer = 0;
361	}	355	}
362	}	356	}
@@ -474,7 +468,7 @@ xfs_qm_dqalloc(
474	* Make a chunk of dquots out of this buffer and log	468	* Make a chunk of dquots out of this buffer and log
475	* the entire thing.	469	* the entire thing.
476	*/	470	*/
477	xfs_qm_init_dquot_blk(tp, mp, INT_GET(dqp->q_core.d_id, ARCH_CONVERT),	471	xfs_qm_init_dquot_blk(tp, mp, be32_to_cpu(dqp->q_core.d_id),
478	dqp->dq_flags & XFS_DQ_ALLTYPES, bp);	472	dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
479		473
480	/*	474	/*
@@ -538,7 +532,7 @@ xfs_qm_dqtobp(
538	xfs_trans_t tp = (tpp ? tpp : NULL);	532	xfs_trans_t tp = (tpp ? tpp : NULL);
539		533
540	mp = dqp->q_mount;	534	mp = dqp->q_mount;
541	id = INT_GET(dqp->q_core.d_id, ARCH_CONVERT);	535	id = be32_to_cpu(dqp->q_core.d_id);
542	nmaps = 1;	536	nmaps = 1;
543	newdquot = B_FALSE;	537	newdquot = B_FALSE;
544		538
@@ -677,16 +671,16 @@ xfs_qm_dqread(
677		671
678	/* copy everything from disk dquot to the incore dquot */	672	/* copy everything from disk dquot to the incore dquot */
679	memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t));	673	memcpy(&dqp->q_core, ddqp, sizeof(xfs_disk_dquot_t));
680	ASSERT(INT_GET(dqp->q_core.d_id, ARCH_CONVERT) == id);	674	ASSERT(be32_to_cpu(dqp->q_core.d_id) == id);
681	xfs_qm_dquot_logitem_init(dqp);	675	xfs_qm_dquot_logitem_init(dqp);
682		676
683	/*	677	/*
684	* Reservation counters are defined as reservation plus current usage	678	* Reservation counters are defined as reservation plus current usage
685	* to avoid having to add everytime.	679	* to avoid having to add everytime.
686	*/	680	*/
687	dqp->q_res_bcount = INT_GET(ddqp->d_bcount, ARCH_CONVERT);	681	dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount);
688	dqp->q_res_icount = INT_GET(ddqp->d_icount, ARCH_CONVERT);	682	dqp->q_res_icount = be64_to_cpu(ddqp->d_icount);
689	dqp->q_res_rtbcount = INT_GET(ddqp->d_rtbcount, ARCH_CONVERT);	683	dqp->q_res_rtbcount = be64_to_cpu(ddqp->d_rtbcount);
690		684
691	/* Mark the buf so that this will stay incore a little longer */	685	/* Mark the buf so that this will stay incore a little longer */
692	XFS_BUF_SET_VTYPE_REF(bp, B_FS_DQUOT, XFS_DQUOT_REF);	686	XFS_BUF_SET_VTYPE_REF(bp, B_FS_DQUOT, XFS_DQUOT_REF);
@@ -812,7 +806,7 @@ xfs_qm_dqlookup(
812	* dqlock to look at the id field of the dquot, since the	806	* dqlock to look at the id field of the dquot, since the
813	* id can't be modified without the hashlock anyway.	807	* id can't be modified without the hashlock anyway.
814	*/	808	*/
815	if (INT_GET(dqp->q_core.d_id, ARCH_CONVERT) == id && dqp->q_mount == mp) {	809	if (be32_to_cpu(dqp->q_core.d_id) == id && dqp->q_mount == mp) {
816	xfs_dqtrace_entry(dqp, "DQFOUND BY LOOKUP");	810	xfs_dqtrace_entry(dqp, "DQFOUND BY LOOKUP");
817	/*	811	/*
818	* All in core dquots must be on the dqlist of mp	812	* All in core dquots must be on the dqlist of mp
@@ -843,7 +837,7 @@ xfs_qm_dqlookup(
843	* id couldn't have changed; we had the hashlock all	837	* id couldn't have changed; we had the hashlock all
844	* along	838	* along
845	*/	839	*/
846	ASSERT(INT_GET(dqp->q_core.d_id, ARCH_CONVERT) == id);	840	ASSERT(be32_to_cpu(dqp->q_core.d_id) == id);
847		841
848	if (flist_locked) {	842	if (flist_locked) {
849	if (dqp->q_nrefs != 0) {	843	if (dqp->q_nrefs != 0) {
@@ -1265,7 +1259,7 @@ xfs_qm_dqflush(
1265	return (error);	1259	return (error);
1266	}	1260	}
1267		1261
1268	if (xfs_qm_dqcheck(&dqp->q_core, INT_GET(ddqp->d_id, ARCH_CONVERT),	1262	if (xfs_qm_dqcheck(&dqp->q_core, be32_to_cpu(ddqp->d_id),
1269	0, XFS_QMOPT_DOWARN, "dqflush (incore copy)")) {	1263	0, XFS_QMOPT_DOWARN, "dqflush (incore copy)")) {
1270	xfs_force_shutdown(dqp->q_mount, XFS_CORRUPT_INCORE);	1264	xfs_force_shutdown(dqp->q_mount, XFS_CORRUPT_INCORE);
1271	return XFS_ERROR(EIO);	1265	return XFS_ERROR(EIO);
@@ -1418,8 +1412,8 @@ xfs_dqlock2(
1418	{	1412	{
1419	if (d1 && d2) {	1413	if (d1 && d2) {
1420	ASSERT(d1 != d2);	1414	ASSERT(d1 != d2);
1421	if (INT_GET(d1->q_core.d_id, ARCH_CONVERT) >	1415	if (be32_to_cpu(d1->q_core.d_id) >
1422	INT_GET(d2->q_core.d_id, ARCH_CONVERT)) {	1416	be32_to_cpu(d2->q_core.d_id)) {
1423	xfs_dqlock(d2);	1417	xfs_dqlock(d2);
1424	xfs_dqlock(d1);	1418	xfs_dqlock(d1);
1425	} else {	1419	} else {
@@ -1541,33 +1535,33 @@ xfs_qm_dqprint(xfs_dquot_t *dqp)
1541	{	1535	{
1542	cmn_err(CE_DEBUG, "-----------KERNEL DQUOT----------------");	1536	cmn_err(CE_DEBUG, "-----------KERNEL DQUOT----------------");
1543	cmn_err(CE_DEBUG, "---- dquotID = %d",	1537	cmn_err(CE_DEBUG, "---- dquotID = %d",
1544	(int)INT_GET(dqp->q_core.d_id, ARCH_CONVERT));	1538	(int)be32_to_cpu(dqp->q_core.d_id));
1545	cmn_err(CE_DEBUG, "---- type = %s", DQFLAGTO_TYPESTR(dqp));	1539	cmn_err(CE_DEBUG, "---- type = %s", DQFLAGTO_TYPESTR(dqp));
1546	cmn_err(CE_DEBUG, "---- fs = 0x%p", dqp->q_mount);	1540	cmn_err(CE_DEBUG, "---- fs = 0x%p", dqp->q_mount);
1547	cmn_err(CE_DEBUG, "---- blkno = 0x%x", (int) dqp->q_blkno);	1541	cmn_err(CE_DEBUG, "---- blkno = 0x%x", (int) dqp->q_blkno);
1548	cmn_err(CE_DEBUG, "---- boffset = 0x%x", (int) dqp->q_bufoffset);	1542	cmn_err(CE_DEBUG, "---- boffset = 0x%x", (int) dqp->q_bufoffset);
1549	cmn_err(CE_DEBUG, "---- blkhlimit = %Lu (0x%x)",	1543	cmn_err(CE_DEBUG, "---- blkhlimit = %Lu (0x%x)",
1550	INT_GET(dqp->q_core.d_blk_hardlimit, ARCH_CONVERT),	1544	be64_to_cpu(dqp->q_core.d_blk_hardlimit),
1551	(int) INT_GET(dqp->q_core.d_blk_hardlimit, ARCH_CONVERT));	1545	(int)be64_to_cpu(dqp->q_core.d_blk_hardlimit));
1552	cmn_err(CE_DEBUG, "---- blkslimit = %Lu (0x%x)",	1546	cmn_err(CE_DEBUG, "---- blkslimit = %Lu (0x%x)",
1553	INT_GET(dqp->q_core.d_blk_softlimit, ARCH_CONVERT),	1547	be64_to_cpu(dqp->q_core.d_blk_softlimit),
1554	(int)INT_GET(dqp->q_core.d_blk_softlimit, ARCH_CONVERT));	1548	(int)be64_to_cpu(dqp->q_core.d_blk_softlimit));
1555	cmn_err(CE_DEBUG, "---- inohlimit = %Lu (0x%x)",	1549	cmn_err(CE_DEBUG, "---- inohlimit = %Lu (0x%x)",
1556	INT_GET(dqp->q_core.d_ino_hardlimit, ARCH_CONVERT),	1550	be64_to_cpu(dqp->q_core.d_ino_hardlimit),
1557	(int)INT_GET(dqp->q_core.d_ino_hardlimit, ARCH_CONVERT));	1551	(int)be64_to_cpu(dqp->q_core.d_ino_hardlimit));
1558	cmn_err(CE_DEBUG, "---- inoslimit = %Lu (0x%x)",	1552	cmn_err(CE_DEBUG, "---- inoslimit = %Lu (0x%x)",
1559	INT_GET(dqp->q_core.d_ino_softlimit, ARCH_CONVERT),	1553	be64_to_cpu(dqp->q_core.d_ino_softlimit),
1560	(int)INT_GET(dqp->q_core.d_ino_softlimit, ARCH_CONVERT));	1554	(int)be64_to_cpu(dqp->q_core.d_ino_softlimit));
1561	cmn_err(CE_DEBUG, "---- bcount = %Lu (0x%x)",	1555	cmn_err(CE_DEBUG, "---- bcount = %Lu (0x%x)",
1562	INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT),	1556	be64_to_cpu(dqp->q_core.d_bcount),
1563	(int)INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT));	1557	(int)be64_to_cpu(dqp->q_core.d_bcount));
1564	cmn_err(CE_DEBUG, "---- icount = %Lu (0x%x)",	1558	cmn_err(CE_DEBUG, "---- icount = %Lu (0x%x)",
1565	INT_GET(dqp->q_core.d_icount, ARCH_CONVERT),	1559	be64_to_cpu(dqp->q_core.d_icount),
1566	(int)INT_GET(dqp->q_core.d_icount, ARCH_CONVERT));	1560	(int)be64_to_cpu(dqp->q_core.d_icount));
1567	cmn_err(CE_DEBUG, "---- btimer = %d",	1561	cmn_err(CE_DEBUG, "---- btimer = %d",
1568	(int)INT_GET(dqp->q_core.d_btimer, ARCH_CONVERT));	1562	(int)be32_to_cpu(dqp->q_core.d_btimer));
1569	cmn_err(CE_DEBUG, "---- itimer = %d",	1563	cmn_err(CE_DEBUG, "---- itimer = %d",
1570	(int)INT_GET(dqp->q_core.d_itimer, ARCH_CONVERT));	1564	(int)be32_to_cpu(dqp->q_core.d_itimer));
1571	cmn_err(CE_DEBUG, "---------------------------");	1565	cmn_err(CE_DEBUG, "---------------------------");
1572	}	1566	}
1573	#endif	1567	#endif