Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1149d96a authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Nathan Scott
Browse files

[XFS] endianess annotations and cleanup for the quota code 



SGI-PV: 943272
SGI-Modid: xfs-linux:xfs-kern:199767a

Signed-off-by: default avatarChristoph Hellwig <hch@sgi.com>
Signed-off-by: default avatarNathan Scott <nathans@sgi.com>
parent fa7e7d71

fs/xfs/quota/xfs_dquot.c

+89 −95
Original line number Diff line number Diff line
@@ -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

fs/xfs/quota/xfs_dquot_item.c

+1 −1
Original line number Diff line number Diff line
@@ -450,7 +450,7 @@ xfs_qm_dquot_logitem_init( 
	lp->qli_item.li_mountp = dqp->q_mount;

	lp->qli_dquot = dqp;

	lp->qli_format.qlf_type = XFS_LI_DQUOT;

	lp->qli_format.qlf_id = INT_GET(dqp->q_core.d_id, ARCH_CONVERT);

	lp->qli_format.qlf_id = be32_to_cpu(dqp->q_core.d_id);

	lp->qli_format.qlf_blkno = dqp->q_blkno;

	lp->qli_format.qlf_len = 1;

	/*

fs/xfs/quota/xfs_qm.c

+42 −60
Original line number Diff line number Diff line
@@ -91,10 +91,10 @@ extern mutex_t qcheck_lock; 
	for (dqp = (l)->qh_next; dqp != NULL; dqp = dqp->NXT) { \

		cmn_err(CE_DEBUG, "   %d.  \"%d (%s)\"   " \

				  "bcnt = %d, icnt = %d, refs = %d", \

			++i, (int) INT_GET(dqp->q_core.d_id, ARCH_CONVERT), \

			++i, (int) be32_to_cpu(dqp->q_core.d_id), \

			DQFLAGTO_TYPESTR(dqp),	     \

			(int) INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT), \

			(int) INT_GET(dqp->q_core.d_icount, ARCH_CONVERT), \

			(int) be64_to_cpu(dqp->q_core.d_bcount), \

			(int) be64_to_cpu(dqp->q_core.d_icount), \

			(int) dqp->q_nrefs);  } \

}

#else
@@ -727,7 +727,7 @@ xfs_qm_dqattach_one( 
	 */

	if (udqhint &&

	    (dqp = udqhint->q_gdquot) &&

	    (INT_GET(dqp->q_core.d_id, ARCH_CONVERT) == id)) {

	    (be32_to_cpu(dqp->q_core.d_id) == id)) {

		ASSERT(XFS_DQ_IS_LOCKED(udqhint));

		xfs_dqlock(dqp);

		XFS_DQHOLD(dqp);
@@ -1197,42 +1197,24 @@ xfs_qm_init_quotainfo( 
		 * a user or group before he or she can not perform any

		 * more writing. If it is zero, a default is used.

		 */

		qinf->qi_btimelimit =

				INT_GET(ddqp->d_btimer, ARCH_CONVERT) ?

				INT_GET(ddqp->d_btimer, ARCH_CONVERT) :

				XFS_QM_BTIMELIMIT;

		qinf->qi_itimelimit =

				INT_GET(ddqp->d_itimer, ARCH_CONVERT) ?

				INT_GET(ddqp->d_itimer, ARCH_CONVERT) :

				XFS_QM_ITIMELIMIT;

		qinf->qi_rtbtimelimit =

				INT_GET(ddqp->d_rtbtimer, ARCH_CONVERT) ?

				INT_GET(ddqp->d_rtbtimer, ARCH_CONVERT) :

				XFS_QM_RTBTIMELIMIT;

		qinf->qi_bwarnlimit =

				INT_GET(ddqp->d_bwarns, ARCH_CONVERT) ?

				INT_GET(ddqp->d_bwarns, ARCH_CONVERT) :

				XFS_QM_BWARNLIMIT;

		qinf->qi_iwarnlimit =

				INT_GET(ddqp->d_iwarns, ARCH_CONVERT) ?

				INT_GET(ddqp->d_iwarns, ARCH_CONVERT) :

				XFS_QM_IWARNLIMIT;

		qinf->qi_rtbwarnlimit =

				INT_GET(ddqp->d_rtbwarns, ARCH_CONVERT) ?

				INT_GET(ddqp->d_rtbwarns, ARCH_CONVERT) :

				XFS_QM_RTBWARNLIMIT;

		qinf->qi_bhardlimit =

				INT_GET(ddqp->d_blk_hardlimit, ARCH_CONVERT);

		qinf->qi_bsoftlimit =

				INT_GET(ddqp->d_blk_softlimit, ARCH_CONVERT);

		qinf->qi_ihardlimit =

				INT_GET(ddqp->d_ino_hardlimit, ARCH_CONVERT);

		qinf->qi_isoftlimit =

				INT_GET(ddqp->d_ino_softlimit, ARCH_CONVERT);

		qinf->qi_rtbhardlimit =

				INT_GET(ddqp->d_rtb_hardlimit, ARCH_CONVERT);

		qinf->qi_rtbsoftlimit =

				INT_GET(ddqp->d_rtb_softlimit, ARCH_CONVERT);

		qinf->qi_btimelimit = ddqp->d_btimer ?

			be32_to_cpu(ddqp->d_btimer) : XFS_QM_BTIMELIMIT;

		qinf->qi_itimelimit = ddqp->d_itimer ?

			be32_to_cpu(ddqp->d_itimer) : XFS_QM_ITIMELIMIT;

		qinf->qi_rtbtimelimit = ddqp->d_rtbtimer ?

			be32_to_cpu(ddqp->d_rtbtimer) : XFS_QM_RTBTIMELIMIT;

		qinf->qi_bwarnlimit = ddqp->d_bwarns ?

			be16_to_cpu(ddqp->d_bwarns) : XFS_QM_BWARNLIMIT;

		qinf->qi_iwarnlimit = ddqp->d_iwarns ?

			be16_to_cpu(ddqp->d_iwarns) : XFS_QM_IWARNLIMIT;

		qinf->qi_rtbwarnlimit = ddqp->d_rtbwarns ?

			be16_to_cpu(ddqp->d_rtbwarns) : XFS_QM_RTBWARNLIMIT;

		qinf->qi_bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);

		qinf->qi_bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);

		qinf->qi_ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);

		qinf->qi_isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);

		qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);

		qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);

 

		/*

		 * We sent the XFS_QMOPT_DQSUSER flag to dqget because
@@ -1511,15 +1493,15 @@ xfs_qm_reset_dqcounts( 
		 */

		(void) xfs_qm_dqcheck(ddq, id+j, type, XFS_QMOPT_DQREPAIR,

				      "xfs_quotacheck");

		INT_SET(ddq->d_bcount, ARCH_CONVERT, 0ULL);

		INT_SET(ddq->d_icount, ARCH_CONVERT, 0ULL);

		INT_SET(ddq->d_rtbcount, ARCH_CONVERT, 0ULL);

		INT_SET(ddq->d_btimer, ARCH_CONVERT, (time_t)0);

		INT_SET(ddq->d_itimer, ARCH_CONVERT, (time_t)0);

		INT_SET(ddq->d_rtbtimer, ARCH_CONVERT, (time_t)0);

		INT_SET(ddq->d_bwarns, ARCH_CONVERT, 0UL);

		INT_SET(ddq->d_iwarns, ARCH_CONVERT, 0UL);

		INT_SET(ddq->d_rtbwarns, ARCH_CONVERT, 0UL);

		ddq->d_bcount = 0;

		ddq->d_icount = 0;

		ddq->d_rtbcount = 0;

		ddq->d_btimer = 0;

		ddq->d_itimer = 0;

		ddq->d_rtbtimer = 0;

		ddq->d_bwarns = 0;

		ddq->d_iwarns = 0;

		ddq->d_rtbwarns = 0;

		ddq = (xfs_disk_dquot_t *) ((xfs_dqblk_t *)ddq + 1);

	}
@@ -1692,14 +1674,14 @@ xfs_qm_quotacheck_dqadjust( 
	 * Adjust the inode count and the block count to reflect this inode's

	 * resource usage.

	 */

	INT_MOD(dqp->q_core.d_icount, ARCH_CONVERT, +1);

	be64_add(&dqp->q_core.d_icount, 1);

	dqp->q_res_icount++;

	if (nblks) {

		INT_MOD(dqp->q_core.d_bcount, ARCH_CONVERT, nblks);

		be64_add(&dqp->q_core.d_bcount, nblks);

		dqp->q_res_bcount += nblks;

	}

	if (rtblks) {

		INT_MOD(dqp->q_core.d_rtbcount, ARCH_CONVERT, rtblks);

		be64_add(&dqp->q_core.d_rtbcount, rtblks);

		dqp->q_res_rtbcount += rtblks;

	}
@@ -2186,7 +2168,7 @@ xfs_qm_shake_freelist( 
		xfs_dqtrace_entry(dqp, "DQSHAKE: UNLINKING");

#ifdef QUOTADEBUG

		cmn_err(CE_DEBUG, "Shake 0x%p, ID 0x%x\n",

			dqp, INT_GET(dqp->q_core.d_id, ARCH_CONVERT));

			dqp, be32_to_cpu(dqp->q_core.d_id));

#endif

		ASSERT(dqp->q_nrefs == 0);

		nextdqp = dqp->dq_flnext;
@@ -2654,7 +2636,7 @@ xfs_qm_vop_chown_reserve( 
			XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;



	if (XFS_IS_UQUOTA_ON(mp) && udqp &&

	    ip->i_d.di_uid != (uid_t)INT_GET(udqp->q_core.d_id, ARCH_CONVERT)) {

	    ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {

		delblksudq = udqp;

		/*

		 * If there are delayed allocation blocks, then we have to
@@ -2667,10 +2649,10 @@ xfs_qm_vop_chown_reserve( 
		}

	}

	if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {

		if ((XFS_IS_GQUOTA_ON(ip->i_mount) && ip->i_d.di_gid !=

				INT_GET(gdqp->q_core.d_id, ARCH_CONVERT)) ||

		    (XFS_IS_PQUOTA_ON(ip->i_mount) && ip->i_d.di_projid !=

				INT_GET(gdqp->q_core.d_id, ARCH_CONVERT))) {

		if ((XFS_IS_GQUOTA_ON(ip->i_mount) &&

		     ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id)) ||

		    (XFS_IS_PQUOTA_ON(ip->i_mount) &&

		     ip->i_d.di_projid != be32_to_cpu(gdqp->q_core.d_id))) {

			delblksgdq = gdqp;

			if (delblks) {

				ASSERT(ip->i_gdquot);
@@ -2760,7 +2742,7 @@ xfs_qm_vop_dqattach_and_dqmod_newinode( 
		xfs_dqunlock(udqp);

		ASSERT(ip->i_udquot == NULL);

		ip->i_udquot = udqp;

		ASSERT(ip->i_d.di_uid == INT_GET(udqp->q_core.d_id, ARCH_CONVERT));

		ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));

		xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);

	}

	if (gdqp) {
@@ -2769,7 +2751,7 @@ xfs_qm_vop_dqattach_and_dqmod_newinode( 
		xfs_dqunlock(gdqp);

		ASSERT(ip->i_gdquot == NULL);

		ip->i_gdquot = gdqp;

		ASSERT(ip->i_d.di_gid == INT_GET(gdqp->q_core.d_id, ARCH_CONVERT));

		ASSERT(ip->i_d.di_gid == be32_to_cpu(gdqp->q_core.d_id));

		xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);

	}

}

fs/xfs/quota/xfs_qm_syscalls.c

+51 −57

File changed.

Preview size limit exceeded, changes collapsed.

fs/xfs/quota/xfs_trans_dquot.c

+25 −27
Original line number Diff line number Diff line
@@ -413,25 +413,25 @@ xfs_trans_apply_dquot_deltas( 
				qtrx->qt_delrtb_delta;

#ifdef QUOTADEBUG

			if (totalbdelta < 0)

				ASSERT(INT_GET(d->d_bcount, ARCH_CONVERT) >=

				ASSERT(be64_to_cpu(d->d_bcount) >=

				       (xfs_qcnt_t) -totalbdelta);



			if (totalrtbdelta < 0)

				ASSERT(INT_GET(d->d_rtbcount, ARCH_CONVERT) >=

				ASSERT(be64_to_cpu(d->d_rtbcount) >=

				       (xfs_qcnt_t) -totalrtbdelta);



			if (qtrx->qt_icount_delta < 0)

				ASSERT(INT_GET(d->d_icount, ARCH_CONVERT) >=

				ASSERT(be64_to_cpu(d->d_icount) >=

				       (xfs_qcnt_t) -qtrx->qt_icount_delta);

#endif

			if (totalbdelta)

				INT_MOD(d->d_bcount, ARCH_CONVERT, (xfs_qcnt_t)totalbdelta);

				be64_add(&d->d_bcount, (xfs_qcnt_t)totalbdelta);



			if (qtrx->qt_icount_delta)

				INT_MOD(d->d_icount, ARCH_CONVERT, (xfs_qcnt_t)qtrx->qt_icount_delta);

				be64_add(&d->d_icount, (xfs_qcnt_t)qtrx->qt_icount_delta);



			if (totalrtbdelta)

				INT_MOD(d->d_rtbcount, ARCH_CONVERT, (xfs_qcnt_t)totalrtbdelta);

				be64_add(&d->d_rtbcount, (xfs_qcnt_t)totalrtbdelta);



			/*

			 * Get any default limits in use.
@@ -515,11 +515,11 @@ xfs_trans_apply_dquot_deltas( 
			}



			ASSERT(dqp->q_res_bcount >=

				INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT));

				be64_to_cpu(dqp->q_core.d_bcount));

			ASSERT(dqp->q_res_icount >=

				INT_GET(dqp->q_core.d_icount, ARCH_CONVERT));

				be64_to_cpu(dqp->q_core.d_icount));

			ASSERT(dqp->q_res_rtbcount >=

				INT_GET(dqp->q_core.d_rtbcount, ARCH_CONVERT));

				be64_to_cpu(dqp->q_core.d_rtbcount));

		}

		/*

		 * Do the group quotas next
@@ -626,26 +626,26 @@ xfs_trans_dqresv( 
	}

	ASSERT(XFS_DQ_IS_LOCKED(dqp));

	if (flags & XFS_TRANS_DQ_RES_BLKS) {

		hardlimit = INT_GET(dqp->q_core.d_blk_hardlimit, ARCH_CONVERT);

		hardlimit = be64_to_cpu(dqp->q_core.d_blk_hardlimit);

		if (!hardlimit)

			hardlimit = q->qi_bhardlimit;

		softlimit = INT_GET(dqp->q_core.d_blk_softlimit, ARCH_CONVERT);

		softlimit = be64_to_cpu(dqp->q_core.d_blk_softlimit);

		if (!softlimit)

			softlimit = q->qi_bsoftlimit;

		timer = INT_GET(dqp->q_core.d_btimer, ARCH_CONVERT);

		warns = INT_GET(dqp->q_core.d_bwarns, ARCH_CONVERT);

		timer = be32_to_cpu(dqp->q_core.d_btimer);

		warns = be16_to_cpu(dqp->q_core.d_bwarns);

		warnlimit = XFS_QI_BWARNLIMIT(dqp->q_mount);

		resbcountp = &dqp->q_res_bcount;

	} else {

		ASSERT(flags & XFS_TRANS_DQ_RES_RTBLKS);

		hardlimit = INT_GET(dqp->q_core.d_rtb_hardlimit, ARCH_CONVERT);

		hardlimit = be64_to_cpu(dqp->q_core.d_rtb_hardlimit);

		if (!hardlimit)

			hardlimit = q->qi_rtbhardlimit;

		softlimit = INT_GET(dqp->q_core.d_rtb_softlimit, ARCH_CONVERT);

		softlimit = be64_to_cpu(dqp->q_core.d_rtb_softlimit);

		if (!softlimit)

			softlimit = q->qi_rtbsoftlimit;

		timer = INT_GET(dqp->q_core.d_rtbtimer, ARCH_CONVERT);

		warns = INT_GET(dqp->q_core.d_rtbwarns, ARCH_CONVERT);

		timer = be32_to_cpu(dqp->q_core.d_rtbtimer);

		warns = be16_to_cpu(dqp->q_core.d_rtbwarns);

		warnlimit = XFS_QI_RTBWARNLIMIT(dqp->q_mount);

		resbcountp = &dqp->q_res_rtbcount;

	}
@@ -684,16 +684,14 @@ xfs_trans_dqresv( 
			}

		}

		if (ninos > 0) {

			count = INT_GET(dqp->q_core.d_icount, ARCH_CONVERT);

			timer = INT_GET(dqp->q_core.d_itimer, ARCH_CONVERT);

			warns = INT_GET(dqp->q_core.d_iwarns, ARCH_CONVERT);

			count = be64_to_cpu(dqp->q_core.d_icount);

			timer = be32_to_cpu(dqp->q_core.d_itimer);

			warns = be16_to_cpu(dqp->q_core.d_iwarns);

			warnlimit = XFS_QI_IWARNLIMIT(dqp->q_mount);

			hardlimit = INT_GET(dqp->q_core.d_ino_hardlimit,

						ARCH_CONVERT);

			hardlimit = be64_to_cpu(dqp->q_core.d_ino_hardlimit);

			if (!hardlimit)

				hardlimit = q->qi_ihardlimit;

			softlimit = INT_GET(dqp->q_core.d_ino_softlimit,

						ARCH_CONVERT);

			softlimit = be64_to_cpu(dqp->q_core.d_ino_softlimit);

			if (!softlimit)

				softlimit = q->qi_isoftlimit;

			if (hardlimit > 0ULL && count >= hardlimit) {
@@ -740,9 +738,9 @@ xfs_trans_dqresv( 
					    XFS_TRANS_DQ_RES_INOS,

					    ninos);

	}

	ASSERT(dqp->q_res_bcount >= INT_GET(dqp->q_core.d_bcount, ARCH_CONVERT));

	ASSERT(dqp->q_res_rtbcount >= INT_GET(dqp->q_core.d_rtbcount, ARCH_CONVERT));

	ASSERT(dqp->q_res_icount >= INT_GET(dqp->q_core.d_icount, ARCH_CONVERT));

	ASSERT(dqp->q_res_bcount >= be64_to_cpu(dqp->q_core.d_bcount));

	ASSERT(dqp->q_res_rtbcount >= be64_to_cpu(dqp->q_core.d_rtbcount));

	ASSERT(dqp->q_res_icount >= be64_to_cpu(dqp->q_core.d_icount));



error_return:

	if (! (flags & XFS_QMOPT_DQLOCK)) {