[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>

1 files changed, 89 insertions, 95 deletions

diff --git a/fs/xfs/quota/xfs_dquot.c b/fs/xfs/quota/xfs_dquot.c
index d3c23accfa1..00b5043dfa5 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);
-	INT_SET(d->dd_diskdq.d_version, ARCH_CONVERT, XFS_DQUOT_VERSION);
-	INT_SET(d->dd_diskdq.d_id, ARCH_CONVERT, id);
-	INT_SET(d->dd_diskdq.d_flags, ARCH_CONVERT, type);
+	d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
+	d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
+	d->dd_diskdq.d_id = cpu_to_be32(id);
+	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,
-						ARCH_CONVERT),
-		     (void *)(__psint_t)INT_GET(dqp->q_core.d_icount,
-						ARCH_CONVERT),
-		     (void *)(__psint_t)INT_GET(dqp->q_core.d_blk_hardlimit,
-						ARCH_CONVERT),
-		     (void *)(__psint_t)INT_GET(dqp->q_core.d_blk_softlimit,
-						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)be64_to_cpu(dqp->q_core.d_bcount),
+		     (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_icount),
+		     (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_blk_hardlimit),
+		     (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_blk_softlimit),
+		     (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_ino_hardlimit),
+		     (void *)(__psint_t)be64_to_cpu(dqp->q_core.d_ino_softlimit),
+		     (void *)(__psint_t)be32_to_cpu(dqp->q_core.d_id),
 		     (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))
-		ASSERT(INT_GET(d->d_blk_softlimit, ARCH_CONVERT) <=
-			INT_GET(d->d_blk_hardlimit, ARCH_CONVERT));
-	if (INT_GET(d->d_ino_hardlimit, ARCH_CONVERT))
-		ASSERT(INT_GET(d->d_ino_softlimit, ARCH_CONVERT) <=
-			INT_GET(d->d_ino_hardlimit, ARCH_CONVERT));
-	if (INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT))
-		ASSERT(INT_GET(d->d_rtb_softlimit, ARCH_CONVERT) <=
-			INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT));
+	if (d->d_blk_hardlimit)
+		ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
+		       be64_to_cpu(d->d_blk_hardlimit));
+	if (d->d_ino_hardlimit)
+		ASSERT(be64_to_cpu(d->d_ino_softlimit) <=
+		       be64_to_cpu(d->d_ino_hardlimit));
+	if (d->d_rtb_hardlimit)
+		ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
+		       be64_to_cpu(d->d_rtb_hardlimit));
 #endif
 	if (!d->d_btimer) {
-		if ((INT_GET(d->d_blk_softlimit, ARCH_CONVERT) &&
-		    (INT_GET(d->d_bcount, ARCH_CONVERT) >=
-				INT_GET(d->d_blk_softlimit, ARCH_CONVERT))) ||
-		    (INT_GET(d->d_blk_hardlimit, ARCH_CONVERT) &&
-		    (INT_GET(d->d_bcount, ARCH_CONVERT) >=
-				INT_GET(d->d_blk_hardlimit, ARCH_CONVERT)))) {
-			INT_SET(d->d_btimer, ARCH_CONVERT,
-				get_seconds() + XFS_QI_BTIMELIMIT(mp));
+		if ((d->d_blk_softlimit &&
+		     (be64_to_cpu(d->d_bcount) >=
+		      be64_to_cpu(d->d_blk_softlimit))) ||
+		    (d->d_blk_hardlimit &&
+		     (be64_to_cpu(d->d_bcount) >=
+		      be64_to_cpu(d->d_blk_hardlimit)))) {
+			d->d_btimer = cpu_to_be32(get_seconds() +
+					XFS_QI_BTIMELIMIT(mp));
 		} else {
 			d->d_bwarns = 0;
 		}
 	} else {
 		if ((!d->d_blk_softlimit ||
-		    (INT_GET(d->d_bcount, ARCH_CONVERT) <
-				INT_GET(d->d_blk_softlimit, ARCH_CONVERT))) &&
+		     (be64_to_cpu(d->d_bcount) <
+		      be64_to_cpu(d->d_blk_softlimit))) &&
 		    (!d->d_blk_hardlimit ||
-		    (INT_GET(d->d_bcount, ARCH_CONVERT) <
-				INT_GET(d->d_blk_hardlimit, ARCH_CONVERT)))) {
+		    (be64_to_cpu(d->d_bcount) <
+		     be64_to_cpu(d->d_blk_hardlimit)))) {
 			d->d_btimer = 0;
 		}
 	}
 
 	if (!d->d_itimer) {
-		if ((INT_GET(d->d_ino_softlimit, ARCH_CONVERT) &&
-		    (INT_GET(d->d_icount, ARCH_CONVERT) >=
-				INT_GET(d->d_ino_softlimit, ARCH_CONVERT))) ||
-		    (INT_GET(d->d_ino_hardlimit, ARCH_CONVERT) &&
-		    (INT_GET(d->d_icount, ARCH_CONVERT) >=
-				INT_GET(d->d_ino_hardlimit, ARCH_CONVERT)))) {
-			INT_SET(d->d_itimer, ARCH_CONVERT,
-				get_seconds() + XFS_QI_ITIMELIMIT(mp));
+		if ((d->d_ino_softlimit &&
+		     (be64_to_cpu(d->d_icount) >=
+		      be64_to_cpu(d->d_ino_softlimit))) ||
+		    (d->d_ino_hardlimit &&
+		     (be64_to_cpu(d->d_icount) >=
+		      be64_to_cpu(d->d_ino_hardlimit)))) {
+			d->d_itimer = cpu_to_be32(get_seconds() +
+					XFS_QI_ITIMELIMIT(mp));
 		} else {
 			d->d_iwarns = 0;
 		}
 	} else {
 		if ((!d->d_ino_softlimit ||
-		    (INT_GET(d->d_icount, ARCH_CONVERT) <
-				INT_GET(d->d_ino_softlimit, ARCH_CONVERT)))  &&
+		     (be64_to_cpu(d->d_icount) <
+		      be64_to_cpu(d->d_ino_softlimit)))  &&
 		    (!d->d_ino_hardlimit ||
-		    (INT_GET(d->d_icount, ARCH_CONVERT) <
-				INT_GET(d->d_ino_hardlimit, ARCH_CONVERT)))) {
+		     (be64_to_cpu(d->d_icount) <
+		      be64_to_cpu(d->d_ino_hardlimit)))) {
 			d->d_itimer = 0;
 		}
 	}
 
 	if (!d->d_rtbtimer) {
-		if ((INT_GET(d->d_rtb_softlimit, ARCH_CONVERT) &&
-		    (INT_GET(d->d_rtbcount, ARCH_CONVERT) >=
-				INT_GET(d->d_rtb_softlimit, ARCH_CONVERT))) ||
-		    (INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT) &&
-		    (INT_GET(d->d_rtbcount, ARCH_CONVERT) >=
-				INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT)))) {
-			INT_SET(d->d_rtbtimer, ARCH_CONVERT,
-				get_seconds() + XFS_QI_RTBTIMELIMIT(mp));
+		if ((d->d_rtb_softlimit &&
+		     (be64_to_cpu(d->d_rtbcount) >=
+		      be64_to_cpu(d->d_rtb_softlimit))) ||
+		    (d->d_rtb_hardlimit &&
+		     (be64_to_cpu(d->d_rtbcount) >=
+		      be64_to_cpu(d->d_rtb_hardlimit)))) {
+			d->d_rtbtimer = cpu_to_be32(get_seconds() +
+					XFS_QI_RTBTIMELIMIT(mp));
 		} else {
 			d->d_rtbwarns = 0;
 		}
 	} else {
 		if ((!d->d_rtb_softlimit ||
-		    (INT_GET(d->d_rtbcount, ARCH_CONVERT) <
-				INT_GET(d->d_rtb_softlimit, ARCH_CONVERT))) &&
+		     (be64_to_cpu(d->d_rtbcount) <
+		      be64_to_cpu(d->d_rtb_softlimit))) &&
 		    (!d->d_rtb_hardlimit ||
-		    (INT_GET(d->d_rtbcount, ARCH_CONVERT) <
-				INT_GET(d->d_rtb_hardlimit, ARCH_CONVERT)))) {
+		     (be64_to_cpu(d->d_rtbcount) <
+		      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_icount = INT_GET(ddqp->d_icount, ARCH_CONVERT);
-	dqp->q_res_rtbcount = INT_GET(ddqp->d_rtbcount, ARCH_CONVERT);
+	dqp->q_res_bcount = be64_to_cpu(ddqp->d_bcount);
+	dqp->q_res_icount = be64_to_cpu(ddqp->d_icount);
+	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) >
-		    INT_GET(d2->q_core.d_id, ARCH_CONVERT)) {
+		if (be32_to_cpu(d1->q_core.d_id) >
+		    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),
-		(int) INT_GET(dqp->q_core.d_blk_hardlimit, ARCH_CONVERT));
+		be64_to_cpu(dqp->q_core.d_blk_hardlimit),
+		(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),
-		(int)INT_GET(dqp->q_core.d_blk_softlimit, ARCH_CONVERT));
+		be64_to_cpu(dqp->q_core.d_blk_softlimit),
+		(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),
-		(int)INT_GET(dqp->q_core.d_ino_hardlimit, ARCH_CONVERT));
+		be64_to_cpu(dqp->q_core.d_ino_hardlimit),
+		(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),
-		(int)INT_GET(dqp->q_core.d_ino_softlimit, ARCH_CONVERT));
+		be64_to_cpu(dqp->q_core.d_ino_softlimit),
+		(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),
-		(int)INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT));
+		be64_to_cpu(dqp->q_core.d_bcount),
+		(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),
-		(int)INT_GET(dqp->q_core.d_icount, ARCH_CONVERT));
+		be64_to_cpu(dqp->q_core.d_icount),
+		(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