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

Commit 8a7b8a89 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Alex Elder
Browse files

xfs: access quotainfo structure directly 



Access fields in m_quotainfo directly instead of hiding them behind the
XFS_QI_* macros.  Add local variables for the quotainfo pointer in places
where we have lots of them.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarDave Chinner <david@fromorbit.com>
parent 37bc5743

fs/xfs/quota/xfs_dquot.c

+29 −28
Original line number Diff line number Diff line
@@ -252,7 +252,7 @@ xfs_qm_adjust_dqtimers( 
		     (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));

					mp->m_quotainfo->qi_btimelimit);

		} else {

			d->d_bwarns = 0;

		}
@@ -275,7 +275,7 @@ xfs_qm_adjust_dqtimers( 
		     (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));

					mp->m_quotainfo->qi_itimelimit);

		} else {

			d->d_iwarns = 0;

		}
@@ -298,7 +298,7 @@ xfs_qm_adjust_dqtimers( 
		     (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));

					mp->m_quotainfo->qi_rtbtimelimit);

		} else {

			d->d_rtbwarns = 0;

		}
@@ -325,6 +325,7 @@ xfs_qm_init_dquot_blk( 
	uint		type,

	xfs_buf_t	*bp)

{

	struct xfs_quotainfo	*q = mp->m_quotainfo;

	xfs_dqblk_t	*d;

	int		curid, i;
@@ -337,16 +338,16 @@ xfs_qm_init_dquot_blk( 
	/*

	 * ID of the first dquot in the block - id's are zero based.

	 */

	curid = id - (id % XFS_QM_DQPERBLK(mp));

	curid = id - (id % q->qi_dqperchunk);

	ASSERT(curid >= 0);

	memset(d, 0, BBTOB(XFS_QI_DQCHUNKLEN(mp)));

	for (i = 0; i < XFS_QM_DQPERBLK(mp); i++, d++, curid++)

	memset(d, 0, BBTOB(q->qi_dqchunklen));

	for (i = 0; i < q->qi_dqperchunk; i++, d++, curid++)

		xfs_qm_dqinit_core(curid, type, d);

	xfs_trans_dquot_buf(tp, bp,

			    (type & XFS_DQ_USER ? XFS_BLI_UDQUOT_BUF :

			    ((type & XFS_DQ_PROJ) ? XFS_BLI_PDQUOT_BUF :

			     XFS_BLI_GDQUOT_BUF)));

	xfs_trans_log_buf(tp, bp, 0, BBTOB(XFS_QI_DQCHUNKLEN(mp)) - 1);

	xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);

}
@@ -419,7 +420,7 @@ xfs_qm_dqalloc( 
	/* now we can just get the buffer (there's nothing to read yet) */

	bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,

			       dqp->q_blkno,

			       XFS_QI_DQCHUNKLEN(mp),

			       mp->m_quotainfo->qi_dqchunklen,

			       0);

	if (!bp || (error = XFS_BUF_GETERROR(bp)))

		goto error1;
@@ -500,7 +501,8 @@ xfs_qm_dqtobp( 
	 */

	if (dqp->q_blkno == (xfs_daddr_t) 0) {

		/* We use the id as an index */

		dqp->q_fileoffset = (xfs_fileoff_t)id / XFS_QM_DQPERBLK(mp);

		dqp->q_fileoffset = (xfs_fileoff_t)id /

					mp->m_quotainfo->qi_dqperchunk;

		nmaps = 1;

		quotip = XFS_DQ_TO_QIP(dqp);

		xfs_ilock(quotip, XFS_ILOCK_SHARED);
@@ -529,7 +531,7 @@ xfs_qm_dqtobp( 
		/*

		 * offset of dquot in the (fixed sized) dquot chunk.

		 */

		dqp->q_bufoffset = (id % XFS_QM_DQPERBLK(mp)) *

		dqp->q_bufoffset = (id % mp->m_quotainfo->qi_dqperchunk) *

			sizeof(xfs_dqblk_t);

		if (map.br_startblock == HOLESTARTBLOCK) {

			/*
@@ -562,12 +564,10 @@ xfs_qm_dqtobp( 
	if (!newdquot) {

		trace_xfs_dqtobp_read(dqp);



		if ((error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,

		error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,

					   dqp->q_blkno,

					       XFS_QI_DQCHUNKLEN(mp),

					       0, &bp))) {

			return (error);

		}

					   mp->m_quotainfo->qi_dqchunklen,

					   0, &bp);

		if (error || !bp)

			return XFS_ERROR(error);

	}
@@ -689,14 +689,14 @@ xfs_qm_idtodq( 
	tp = NULL;

	if (flags & XFS_QMOPT_DQALLOC) {

		tp = xfs_trans_alloc(mp, XFS_TRANS_QM_DQALLOC);

		if ((error = xfs_trans_reserve(tp,

				       XFS_QM_DQALLOC_SPACE_RES(mp),

		error = xfs_trans_reserve(tp, XFS_QM_DQALLOC_SPACE_RES(mp),

				XFS_WRITE_LOG_RES(mp) +

					      BBTOB(XFS_QI_DQCHUNKLEN(mp)) - 1 +

				BBTOB(mp->m_quotainfo->qi_dqchunklen) - 1 +

				128,

				0,

				XFS_TRANS_PERM_LOG_RES,

				       XFS_WRITE_LOG_COUNT))) {

				XFS_WRITE_LOG_COUNT);

		if (error) {

			cancelflags = 0;

			goto error0;

		}
@@ -1495,6 +1495,7 @@ void 
xfs_qm_dqflock_pushbuf_wait(

	xfs_dquot_t	*dqp)

{

	xfs_mount_t	*mp = dqp->q_mount;

	xfs_buf_t	*bp;



	/*
@@ -1503,14 +1504,14 @@ xfs_qm_dqflock_pushbuf_wait( 
	 * out immediately.  We'll be able to acquire

	 * the flush lock when the I/O completes.

	 */

	bp = xfs_incore(dqp->q_mount->m_ddev_targp, dqp->q_blkno,

		    XFS_QI_DQCHUNKLEN(dqp->q_mount), XBF_TRYLOCK);

	bp = xfs_incore(mp->m_ddev_targp, dqp->q_blkno,

			mp->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK);

	if (!bp)

		goto out_lock;



	if (XFS_BUF_ISDELAYWRITE(bp)) {

		if (XFS_BUF_ISPINNED(bp))

			xfs_log_force(dqp->q_mount, 0);

			xfs_log_force(mp, 0);

		xfs_buf_delwri_promote(bp);

		wake_up_process(bp->b_target->bt_task);

	}

fs/xfs/quota/xfs_dquot_item.c

+1 −1
Original line number Diff line number Diff line
@@ -227,7 +227,7 @@ xfs_qm_dquot_logitem_pushbuf( 
	}

	mp = dqp->q_mount;

	bp = xfs_incore(mp->m_ddev_targp, qip->qli_format.qlf_blkno,

		    XFS_QI_DQCHUNKLEN(mp), XBF_TRYLOCK);

			mp->m_quotainfo->qi_dqchunklen, XBF_TRYLOCK);

	xfs_dqunlock(dqp);

	if (!bp)

		return;

fs/xfs/quota/xfs_qm.c

+76 −68
Original line number Diff line number Diff line
@@ -465,20 +465,21 @@ xfs_qm_unmount_quotas( 
 */

STATIC int

xfs_qm_dqflush_all(

	xfs_mount_t	*mp,

	struct xfs_mount	*mp,

	int			sync_mode)

{

	struct xfs_quotainfo	*q = mp->m_quotainfo;

	int			recl;

	xfs_dquot_t	*dqp;

	struct xfs_dquot	*dqp;

	int			niters;

	int			error;



	if (mp->m_quotainfo == NULL)

	if (!q)

		return 0;

	niters = 0;

again:

	mutex_lock(&mp->m_quotainfo->qi_dqlist_lock);

	list_for_each_entry(dqp, &mp->m_quotainfo->qi_dqlist, q_mplist) {

	mutex_lock(&q->qi_dqlist_lock);

	list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {

		xfs_dqlock(dqp);

		if (! XFS_DQ_IS_DIRTY(dqp)) {

			xfs_dqunlock(dqp);
@@ -486,7 +487,7 @@ xfs_qm_dqflush_all( 
		}



		/* XXX a sentinel would be better */

		recl = mp->m_quotainfo->qi_dqreclaims;

		recl = q->qi_dqreclaims;

		if (!xfs_dqflock_nowait(dqp)) {

			/*

			 * If we can't grab the flush lock then check
@@ -501,21 +502,21 @@ xfs_qm_dqflush_all( 
		 * Let go of the mplist lock. We don't want to hold it

		 * across a disk write.

		 */

		mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);

		mutex_unlock(&q->qi_dqlist_lock);

		error = xfs_qm_dqflush(dqp, sync_mode);

		xfs_dqunlock(dqp);

		if (error)

			return error;



		mutex_lock(&mp->m_quotainfo->qi_dqlist_lock);

		if (recl != mp->m_quotainfo->qi_dqreclaims) {

			mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);

		mutex_lock(&q->qi_dqlist_lock);

		if (recl != q->qi_dqreclaims) {

			mutex_unlock(&q->qi_dqlist_lock);

			/* XXX restart limit */

			goto again;

		}

	}



	mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);

	mutex_unlock(&q->qi_dqlist_lock);

	/* return ! busy */

	return 0;

}
@@ -525,14 +526,15 @@ xfs_qm_dqflush_all( 
 */

STATIC void

xfs_qm_detach_gdquots(

	xfs_mount_t	*mp)

	struct xfs_mount	*mp)

{

	xfs_dquot_t	*dqp, *gdqp;

	struct xfs_quotainfo	*q = mp->m_quotainfo;

	struct xfs_dquot	*dqp, *gdqp;

	int			nrecl;



 again:

	ASSERT(mutex_is_locked(&mp->m_quotainfo->qi_dqlist_lock));

	list_for_each_entry(dqp, &mp->m_quotainfo->qi_dqlist, q_mplist) {

	ASSERT(mutex_is_locked(&q->qi_dqlist_lock));

	list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {

		xfs_dqlock(dqp);

		if ((gdqp = dqp->q_gdquot)) {

			xfs_dqlock(gdqp);
@@ -545,12 +547,12 @@ xfs_qm_detach_gdquots( 
			 * Can't hold the mplist lock across a dqput.

			 * XXXmust convert to marker based iterations here.

			 */

			nrecl = mp->m_quotainfo->qi_dqreclaims;

			mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);

			nrecl = q->qi_dqreclaims;

			mutex_unlock(&q->qi_dqlist_lock);

			xfs_qm_dqput(gdqp);



			mutex_lock(&mp->m_quotainfo->qi_dqlist_lock);

			if (nrecl != mp->m_quotainfo->qi_dqreclaims)

			mutex_lock(&q->qi_dqlist_lock);

			if (nrecl != q->qi_dqreclaims)

				goto again;

		}

	}
@@ -564,22 +566,23 @@ xfs_qm_detach_gdquots( 
 */

STATIC int

xfs_qm_dqpurge_int(

	xfs_mount_t	*mp,

	uint		flags) /* QUOTAOFF/UMOUNTING/UQUOTA/PQUOTA/GQUOTA */

	struct xfs_mount	*mp,

	uint			flags)

{

	xfs_dquot_t	*dqp, *n;

	struct xfs_quotainfo	*q = mp->m_quotainfo;

	struct xfs_dquot	*dqp, *n;

	uint			dqtype;

	int			nrecl;

	int			nmisses;



	if (mp->m_quotainfo == NULL)

	if (!q)

		return 0;



	dqtype = (flags & XFS_QMOPT_UQUOTA) ? XFS_DQ_USER : 0;

	dqtype |= (flags & XFS_QMOPT_PQUOTA) ? XFS_DQ_PROJ : 0;

	dqtype |= (flags & XFS_QMOPT_GQUOTA) ? XFS_DQ_GROUP : 0;



	mutex_lock(&mp->m_quotainfo->qi_dqlist_lock);

	mutex_lock(&q->qi_dqlist_lock);



	/*

	 * In the first pass through all incore dquots of this filesystem,
@@ -591,12 +594,12 @@ xfs_qm_dqpurge_int( 


      again:

	nmisses = 0;

	ASSERT(mutex_is_locked(&mp->m_quotainfo->qi_dqlist_lock));

	ASSERT(mutex_is_locked(&q->qi_dqlist_lock));

	/*

	 * Try to get rid of all of the unwanted dquots. The idea is to

	 * get them off mplist and hashlist, but leave them on freelist.

	 */

	list_for_each_entry_safe(dqp, n, &mp->m_quotainfo->qi_dqlist, q_mplist) {

	list_for_each_entry_safe(dqp, n, &q->qi_dqlist, q_mplist) {

		/*

		 * It's OK to look at the type without taking dqlock here.

		 * We're holding the mplist lock here, and that's needed for
@@ -606,10 +609,10 @@ xfs_qm_dqpurge_int( 
			continue;



		if (!mutex_trylock(&dqp->q_hash->qh_lock)) {

			nrecl = mp->m_quotainfo->qi_dqreclaims;

			mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);

			nrecl = q->qi_dqreclaims;

			mutex_unlock(&q->qi_dqlist_lock);

			mutex_lock(&dqp->q_hash->qh_lock);

			mutex_lock(&mp->m_quotainfo->qi_dqlist_lock);

			mutex_lock(&q->qi_dqlist_lock);



			/*

			 * XXXTheoretically, we can get into a very long
@@ -617,7 +620,7 @@ xfs_qm_dqpurge_int( 
			 * No one can be adding dquots to the mplist at

			 * this point, but somebody might be taking things off.

			 */

			if (nrecl != mp->m_quotainfo->qi_dqreclaims) {

			if (nrecl != q->qi_dqreclaims) {

				mutex_unlock(&dqp->q_hash->qh_lock);

				goto again;

			}
@@ -629,7 +632,7 @@ xfs_qm_dqpurge_int( 
		 */

		nmisses += xfs_qm_dqpurge(dqp);

	}

	mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);

	mutex_unlock(&q->qi_dqlist_lock);

	return nmisses;

}
@@ -929,11 +932,12 @@ xfs_qm_dqdetach( 


int

xfs_qm_sync(

	xfs_mount_t	*mp,

	struct xfs_mount	*mp,

	int			flags)

{

	struct xfs_quotainfo	*q = mp->m_quotainfo;

	int			recl, restarts;

	xfs_dquot_t	*dqp;

	struct xfs_dquot	*dqp;

	int			error;



	if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
@@ -942,7 +946,7 @@ xfs_qm_sync( 
	restarts = 0;



  again:

	mutex_lock(&mp->m_quotainfo->qi_dqlist_lock);

	mutex_lock(&q->qi_dqlist_lock);

	/*

	 * dqpurge_all() also takes the mplist lock and iterate thru all dquots

	 * in quotaoff. However, if the QUOTA_ACTIVE bits are not cleared
@@ -950,11 +954,11 @@ xfs_qm_sync( 
	 * as long as we have it locked.

	 */

	if (!XFS_IS_QUOTA_ON(mp)) {

		mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);

		mutex_unlock(&q->qi_dqlist_lock);

		return 0;

	}

	ASSERT(mutex_is_locked(&mp->m_quotainfo->qi_dqlist_lock));

	list_for_each_entry(dqp, &mp->m_quotainfo->qi_dqlist, q_mplist) {

	ASSERT(mutex_is_locked(&q->qi_dqlist_lock));

	list_for_each_entry(dqp, &q->qi_dqlist, q_mplist) {

		/*

		 * If this is vfs_sync calling, then skip the dquots that

		 * don't 'seem' to be dirty. ie. don't acquire dqlock.
@@ -978,7 +982,7 @@ xfs_qm_sync( 
		}



		/* XXX a sentinel would be better */

		recl = mp->m_quotainfo->qi_dqreclaims;

		recl = q->qi_dqreclaims;

		if (!xfs_dqflock_nowait(dqp)) {

			if (flags & SYNC_TRYLOCK) {

				xfs_dqunlock(dqp);
@@ -998,7 +1002,7 @@ xfs_qm_sync( 
		 * Let go of the mplist lock. We don't want to hold it

		 * across a disk write

		 */

		mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);

		mutex_unlock(&q->qi_dqlist_lock);

		error = xfs_qm_dqflush(dqp, flags);

		xfs_dqunlock(dqp);

		if (error && XFS_FORCED_SHUTDOWN(mp))
@@ -1006,17 +1010,17 @@ xfs_qm_sync( 
		else if (error)

			return error;



		mutex_lock(&mp->m_quotainfo->qi_dqlist_lock);

		if (recl != mp->m_quotainfo->qi_dqreclaims) {

		mutex_lock(&q->qi_dqlist_lock);

		if (recl != q->qi_dqreclaims) {

			if (++restarts >= XFS_QM_SYNC_MAX_RESTARTS)

				break;



			mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);

			mutex_unlock(&q->qi_dqlist_lock);

			goto again;

		}

	}



	mutex_unlock(&mp->m_quotainfo->qi_dqlist_lock);

	mutex_unlock(&q->qi_dqlist_lock);

	return 0;

}
@@ -1382,10 +1386,10 @@ xfs_qm_reset_dqcounts( 
#ifdef DEBUG

	j = XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);

	do_div(j, sizeof(xfs_dqblk_t));

	ASSERT(XFS_QM_DQPERBLK(mp) == j);

	ASSERT(mp->m_quotainfo->qi_dqperchunk == j);

#endif

	ddq = (xfs_disk_dquot_t *)XFS_BUF_PTR(bp);

	for (j = 0; j < XFS_QM_DQPERBLK(mp); j++) {

	for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) {

		/*

		 * Do a sanity check, and if needed, repair the dqblk. Don't

		 * output any warnings because it's perfectly possible to
@@ -1440,7 +1444,7 @@ xfs_qm_dqiter_bufs( 
	while (blkcnt--) {

		error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,

			      XFS_FSB_TO_DADDR(mp, bno),

			      (int)XFS_QI_DQCHUNKLEN(mp), 0, &bp);

			      mp->m_quotainfo->qi_dqchunklen, 0, &bp);

		if (error)

			break;
@@ -1450,7 +1454,7 @@ xfs_qm_dqiter_bufs( 
		 * goto the next block.

		 */

		bno++;

		firstid += XFS_QM_DQPERBLK(mp);

		firstid += mp->m_quotainfo->qi_dqperchunk;

	}

	return error;

}
@@ -1516,7 +1520,7 @@ xfs_qm_dqiterate( 
				continue;



			firstid = (xfs_dqid_t) map[i].br_startoff *

				XFS_QM_DQPERBLK(mp);

				mp->m_quotainfo->qi_dqperchunk;

			/*

			 * Do a read-ahead on the next extent.

			 */
@@ -1527,7 +1531,7 @@ xfs_qm_dqiterate( 
				while (rablkcnt--) {

					xfs_baread(mp->m_ddev_targp,

					       XFS_FSB_TO_DADDR(mp, rablkno),

					       (int)XFS_QI_DQCHUNKLEN(mp));

					       mp->m_quotainfo->qi_dqchunklen);

					rablkno++;

				}

			}
@@ -1758,7 +1762,7 @@ xfs_qm_quotacheck( 
	lastino = 0;

	flags = 0;



	ASSERT(XFS_QI_UQIP(mp) || XFS_QI_GQIP(mp));

	ASSERT(mp->m_quotainfo->qi_uquotaip || mp->m_quotainfo->qi_gquotaip);

	ASSERT(XFS_IS_QUOTA_RUNNING(mp));



	/*
@@ -1774,15 +1778,19 @@ xfs_qm_quotacheck( 
	 * their counters to zero. We need a clean slate.

	 * We don't log our changes till later.

	 */

	if ((uip = XFS_QI_UQIP(mp))) {

		if ((error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA)))

	uip = mp->m_quotainfo->qi_uquotaip;

	if (uip) {

		error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA);

		if (error)

			goto error_return;

		flags |= XFS_UQUOTA_CHKD;

	}



	if ((gip = XFS_QI_GQIP(mp))) {

		if ((error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?

					XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA)))

	gip = mp->m_quotainfo->qi_gquotaip;

	if (gip) {

		error = xfs_qm_dqiterate(mp, gip, XFS_IS_GQUOTA_ON(mp) ?

					XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);

		if (error)

			goto error_return;

		flags |= XFS_OQUOTA_CHKD;

	}
@@ -1931,8 +1939,8 @@ xfs_qm_init_quotainos( 
		}

	}



	XFS_QI_UQIP(mp) = uip;

	XFS_QI_GQIP(mp) = gip;

	mp->m_quotainfo->qi_uquotaip = uip;

	mp->m_quotainfo->qi_gquotaip = gip;



	return 0;

}

fs/xfs/quota/xfs_qm_syscalls.c

+56 −58
Original line number Diff line number Diff line
@@ -79,6 +79,7 @@ xfs_qm_scall_quotaoff( 
	xfs_mount_t		*mp,

	uint			flags)

{

	struct xfs_quotainfo	*q = mp->m_quotainfo;

	uint			dqtype;

	int			error;

	uint			inactivate_flags;
@@ -102,11 +103,8 @@ xfs_qm_scall_quotaoff( 
	 * critical thing.

	 * If quotaoff, then we must be dealing with the root filesystem.

	 */

	ASSERT(mp->m_quotainfo);

	if (mp->m_quotainfo)

		mutex_lock(&(XFS_QI_QOFFLOCK(mp)));



	ASSERT(mp->m_quotainfo);

	ASSERT(q);

	mutex_lock(&q->qi_quotaofflock);



	/*

	 * If we're just turning off quota enforcement, change mp and go.
@@ -117,7 +115,7 @@ xfs_qm_scall_quotaoff( 
		spin_lock(&mp->m_sb_lock);

		mp->m_sb.sb_qflags = mp->m_qflags;

		spin_unlock(&mp->m_sb_lock);

		mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));

		mutex_unlock(&q->qi_quotaofflock);



		/* XXX what to do if error ? Revert back to old vals incore ? */

		error = xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS);
@@ -150,10 +148,8 @@ xfs_qm_scall_quotaoff( 
	 * Nothing to do?  Don't complain. This happens when we're just

	 * turning off quota enforcement.

	 */

	if ((mp->m_qflags & flags) == 0) {

		mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));

		return (0);

	}

	if ((mp->m_qflags & flags) == 0)

		goto out_unlock;



	/*

	 * Write the LI_QUOTAOFF log record, and do SB changes atomically,
@@ -162,7 +158,7 @@ xfs_qm_scall_quotaoff( 
	 */

	error = xfs_qm_log_quotaoff(mp, &qoffstart, flags);

	if (error)

		goto out_error;

		goto out_unlock;



	/*

	 * Next we clear the XFS_MOUNT_*DQ_ACTIVE bit(s) in the mount struct
@@ -222,7 +218,7 @@ xfs_qm_scall_quotaoff( 
	if (error) {

		/* We're screwed now. Shutdown is the only option. */

		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);

		goto out_error;

		goto out_unlock;

	}



	/*
@@ -230,27 +226,26 @@ xfs_qm_scall_quotaoff( 
	 */

	if (((flags & XFS_MOUNT_QUOTA_ALL) == XFS_MOUNT_QUOTA_SET1) ||

	    ((flags & XFS_MOUNT_QUOTA_ALL) == XFS_MOUNT_QUOTA_SET2)) {

		mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));

		mutex_unlock(&q->qi_quotaofflock);

		xfs_qm_destroy_quotainfo(mp);

		return (0);

	}



	/*

	 * Release our quotainode references, and vn_purge them,

	 * if we don't need them anymore.

	 * Release our quotainode references if we don't need them anymore.

	 */

	if ((dqtype & XFS_QMOPT_UQUOTA) && XFS_QI_UQIP(mp)) {

		IRELE(XFS_QI_UQIP(mp));

		XFS_QI_UQIP(mp) = NULL;

	if ((dqtype & XFS_QMOPT_UQUOTA) && q->qi_uquotaip) {

		IRELE(q->qi_uquotaip);

		q->qi_uquotaip = NULL;

	}

	if ((dqtype & (XFS_QMOPT_GQUOTA|XFS_QMOPT_PQUOTA)) && XFS_QI_GQIP(mp)) {

		IRELE(XFS_QI_GQIP(mp));

		XFS_QI_GQIP(mp) = NULL;

	if ((dqtype & (XFS_QMOPT_GQUOTA|XFS_QMOPT_PQUOTA)) && q->qi_gquotaip) {

		IRELE(q->qi_gquotaip);

		q->qi_gquotaip = NULL;

	}

out_error:

	mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));



	return (error);

out_unlock:

	mutex_unlock(&q->qi_quotaofflock);

	return error;

}



int
@@ -379,9 +374,9 @@ xfs_qm_scall_quotaon( 
	/*

	 * Switch on quota enforcement in core.

	 */

	mutex_lock(&(XFS_QI_QOFFLOCK(mp)));

	mutex_lock(&mp->m_quotainfo->qi_quotaofflock);

	mp->m_qflags |= (flags & XFS_ALL_QUOTA_ENFD);

	mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));

	mutex_unlock(&mp->m_quotainfo->qi_quotaofflock);



	return (0);

}
@@ -392,10 +387,11 @@ xfs_qm_scall_quotaon( 
 */

int

xfs_qm_scall_getqstat(

	xfs_mount_t	*mp,

	fs_quota_stat_t *out)

	struct xfs_mount	*mp,

	struct fs_quota_stat	*out)

{

	xfs_inode_t	*uip, *gip;

	struct xfs_quotainfo	*q = mp->m_quotainfo;

	struct xfs_inode	*uip, *gip;

	boolean_t		tempuqip, tempgqip;



	uip = gip = NULL;
@@ -415,9 +411,9 @@ xfs_qm_scall_getqstat( 
	out->qs_uquota.qfs_ino = mp->m_sb.sb_uquotino;

	out->qs_gquota.qfs_ino = mp->m_sb.sb_gquotino;



	if (mp->m_quotainfo) {

		uip = mp->m_quotainfo->qi_uquotaip;

		gip = mp->m_quotainfo->qi_gquotaip;

	if (q) {

		uip = q->qi_uquotaip;

		gip = q->qi_gquotaip;

	}

	if (!uip && mp->m_sb.sb_uquotino != NULLFSINO) {

		if (xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
@@ -441,15 +437,15 @@ xfs_qm_scall_getqstat( 
		if (tempgqip)

			IRELE(gip);

	}

	if (mp->m_quotainfo) {

		out->qs_incoredqs = mp->m_quotainfo->qi_dquots;

		out->qs_btimelimit = XFS_QI_BTIMELIMIT(mp);

		out->qs_itimelimit = XFS_QI_ITIMELIMIT(mp);

		out->qs_rtbtimelimit = XFS_QI_RTBTIMELIMIT(mp);

		out->qs_bwarnlimit = XFS_QI_BWARNLIMIT(mp);

		out->qs_iwarnlimit = XFS_QI_IWARNLIMIT(mp);

	if (q) {

		out->qs_incoredqs = q->qi_dquots;

		out->qs_btimelimit = q->qi_btimelimit;

		out->qs_itimelimit = q->qi_itimelimit;

		out->qs_rtbtimelimit = q->qi_rtbtimelimit;

		out->qs_bwarnlimit = q->qi_bwarnlimit;

		out->qs_iwarnlimit = q->qi_iwarnlimit;

	}

	return (0);

	return 0;

}



/*
@@ -462,6 +458,7 @@ xfs_qm_scall_setqlim( 
	uint			type,

	fs_disk_quota_t		*newlim)

{

	struct xfs_quotainfo	*q = mp->m_quotainfo;

	xfs_disk_dquot_t	*ddq;

	xfs_dquot_t		*dqp;

	xfs_trans_t		*tp;
@@ -485,7 +482,7 @@ xfs_qm_scall_setqlim( 
	 * a quotaoff from happening). (XXXThis doesn't currently happen

	 * because we take the vfslock before calling xfs_qm_sysent).

	 */

	mutex_lock(&(XFS_QI_QOFFLOCK(mp)));

	mutex_lock(&q->qi_quotaofflock);



	/*

	 * Get the dquot (locked), and join it to the transaction.
@@ -493,9 +490,8 @@ xfs_qm_scall_setqlim( 
	 */

	if ((error = xfs_qm_dqget(mp, NULL, id, type, XFS_QMOPT_DQALLOC, &dqp))) {

		xfs_trans_cancel(tp, XFS_TRANS_ABORT);

		mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));

		ASSERT(error != ENOENT);

		return (error);

		goto out_unlock;

	}

	xfs_trans_dqjoin(tp, dqp);

	ddq = &dqp->q_core;
@@ -513,8 +509,8 @@ xfs_qm_scall_setqlim( 
		ddq->d_blk_hardlimit = cpu_to_be64(hard);

		ddq->d_blk_softlimit = cpu_to_be64(soft);

		if (id == 0) {

			mp->m_quotainfo->qi_bhardlimit = hard;

			mp->m_quotainfo->qi_bsoftlimit = soft;

			q->qi_bhardlimit = hard;

			q->qi_bsoftlimit = soft;

		}

	} else {

		qdprintk("blkhard %Ld < blksoft %Ld\n", hard, soft);
@@ -529,8 +525,8 @@ xfs_qm_scall_setqlim( 
		ddq->d_rtb_hardlimit = cpu_to_be64(hard);

		ddq->d_rtb_softlimit = cpu_to_be64(soft);

		if (id == 0) {

			mp->m_quotainfo->qi_rtbhardlimit = hard;

			mp->m_quotainfo->qi_rtbsoftlimit = soft;

			q->qi_rtbhardlimit = hard;

			q->qi_rtbsoftlimit = soft;

		}

	} else {

		qdprintk("rtbhard %Ld < rtbsoft %Ld\n", hard, soft);
@@ -546,8 +542,8 @@ xfs_qm_scall_setqlim( 
		ddq->d_ino_hardlimit = cpu_to_be64(hard);

		ddq->d_ino_softlimit = cpu_to_be64(soft);

		if (id == 0) {

			mp->m_quotainfo->qi_ihardlimit = hard;

			mp->m_quotainfo->qi_isoftlimit = soft;

			q->qi_ihardlimit = hard;

			q->qi_isoftlimit = soft;

		}

	} else {

		qdprintk("ihard %Ld < isoft %Ld\n", hard, soft);
@@ -572,23 +568,23 @@ xfs_qm_scall_setqlim( 
		 * for warnings.

		 */

		if (newlim->d_fieldmask & FS_DQ_BTIMER) {

			mp->m_quotainfo->qi_btimelimit = newlim->d_btimer;

			q->qi_btimelimit = newlim->d_btimer;

			ddq->d_btimer = cpu_to_be32(newlim->d_btimer);

		}

		if (newlim->d_fieldmask & FS_DQ_ITIMER) {

			mp->m_quotainfo->qi_itimelimit = newlim->d_itimer;

			q->qi_itimelimit = newlim->d_itimer;

			ddq->d_itimer = cpu_to_be32(newlim->d_itimer);

		}

		if (newlim->d_fieldmask & FS_DQ_RTBTIMER) {

			mp->m_quotainfo->qi_rtbtimelimit = newlim->d_rtbtimer;

			q->qi_rtbtimelimit = newlim->d_rtbtimer;

			ddq->d_rtbtimer = cpu_to_be32(newlim->d_rtbtimer);

		}

		if (newlim->d_fieldmask & FS_DQ_BWARNS)

			mp->m_quotainfo->qi_bwarnlimit = newlim->d_bwarns;

			q->qi_bwarnlimit = newlim->d_bwarns;

		if (newlim->d_fieldmask & FS_DQ_IWARNS)

			mp->m_quotainfo->qi_iwarnlimit = newlim->d_iwarns;

			q->qi_iwarnlimit = newlim->d_iwarns;

		if (newlim->d_fieldmask & FS_DQ_RTBWARNS)

			mp->m_quotainfo->qi_rtbwarnlimit = newlim->d_rtbwarns;

			q->qi_rtbwarnlimit = newlim->d_rtbwarns;

	} else {

		/*

		 * If the user is now over quota, start the timelimit.
@@ -605,8 +601,9 @@ xfs_qm_scall_setqlim( 
	error = xfs_trans_commit(tp, 0);

	xfs_qm_dqprint(dqp);

	xfs_qm_dqrele(dqp);

	mutex_unlock(&(XFS_QI_QOFFLOCK(mp)));



 out_unlock:

	mutex_unlock(&q->qi_quotaofflock);

	return error;

}
@@ -853,7 +850,8 @@ xfs_dqrele_inode( 
	int			error;



	/* skip quota inodes */

	if (ip == XFS_QI_UQIP(ip->i_mount) || ip == XFS_QI_GQIP(ip->i_mount)) {

	if (ip == ip->i_mount->m_quotainfo->qi_uquotaip ||

	    ip == ip->i_mount->m_quotainfo->qi_gquotaip) {

		ASSERT(ip->i_udquot == NULL);

		ASSERT(ip->i_gdquot == NULL);

		read_unlock(&pag->pag_ici_lock);

fs/xfs/quota/xfs_quota_priv.h

+0 −14
Original line number Diff line number Diff line
@@ -24,22 +24,8 @@ 
 */

#define XFS_DQITER_MAP_SIZE	10



/* Number of dquots that fit in to a dquot block */

#define XFS_QM_DQPERBLK(mp)	((mp)->m_quotainfo->qi_dqperchunk)



#define XFS_DQ_IS_ADDEDTO_TRX(t, d)	((d)->q_transp == (t))



#define XFS_QI_UQIP(mp)		((mp)->m_quotainfo->qi_uquotaip)

#define XFS_QI_GQIP(mp)		((mp)->m_quotainfo->qi_gquotaip)

#define XFS_QI_DQCHUNKLEN(mp)	((mp)->m_quotainfo->qi_dqchunklen)

#define XFS_QI_BTIMELIMIT(mp)	((mp)->m_quotainfo->qi_btimelimit)

#define XFS_QI_RTBTIMELIMIT(mp) ((mp)->m_quotainfo->qi_rtbtimelimit)

#define XFS_QI_ITIMELIMIT(mp)	((mp)->m_quotainfo->qi_itimelimit)

#define XFS_QI_BWARNLIMIT(mp)	((mp)->m_quotainfo->qi_bwarnlimit)

#define XFS_QI_RTBWARNLIMIT(mp)	((mp)->m_quotainfo->qi_rtbwarnlimit)

#define XFS_QI_IWARNLIMIT(mp)	((mp)->m_quotainfo->qi_iwarnlimit)

#define XFS_QI_QOFFLOCK(mp)	((mp)->m_quotainfo->qi_quotaofflock)



/*

 * Hash into a bucket in the dquot hash table, based on <mp, id>.

 */