/* * Copyright (c) 2000-2002 Silicon Graphics, Inc.  All Rights Reserved. * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License as * published by the Free Software Foundation. * * This program is distributed in the hope that it would be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * * Further, this software is distributed without any warranty that it is * free of the rightful claim of any third person regarding infringement * or the like.	 Any license provided herein, whether implied or * otherwise, applies only to this software file.  Patent licenses, if * any, provided herein do not apply to combinations of this program with * other software, or any other product whatsoever. * * You should have received a copy of the GNU General Public License along * with this program; if not, write the Free Software Foundation, Inc., 59 * Temple Place - Suite 330, Boston MA 02111-1307, USA. * * Contact information: Silicon Graphics, Inc., 1600 Amphitheatre Pkwy, * Mountain View, CA  94043, or: * * http://www.sgi.com * * For further information regarding this notice, see: * * http://oss.sgi.com/projects/GenInfo/SGIGPLNoticeExplan/ */#include "xfs.h"#include "xfs_fs.h"#include "xfs_inum.h"#include "xfs_log.h"#include "xfs_trans.h"#include "xfs_sb.h"#include "xfs_ag.h"#include "xfs_dir.h"#include "xfs_dir2.h"#include "xfs_alloc.h"#include "xfs_dmapi.h"#include "xfs_quota.h"#include "xfs_mount.h"#include "xfs_alloc_btree.h"#include "xfs_bmap_btree.h"#include "xfs_ialloc_btree.h"#include "xfs_btree.h"#include "xfs_ialloc.h"#include "xfs_attr_sf.h"#include "xfs_dir_sf.h"#include "xfs_dir2_sf.h"#include "xfs_dinode.h"#include "xfs_inode.h"#include "xfs_bmap.h"#include "xfs_bit.h"#include "xfs_rtalloc.h"#include "xfs_error.h"#include "xfs_itable.h"#include "xfs_rw.h"#include "xfs_acl.h"#include "xfs_cap.h"#include "xfs_mac.h"#include "xfs_attr.h"#include "xfs_buf_item.h"#include "xfs_trans_priv.h"#include "xfs_qm.h"STATIC void	xfs_trans_alloc_dqinfo(xfs_trans_t *);/* * Add the locked dquot to the transaction. * The dquot must be locked, and it cannot be associated with any * transaction. */voidxfs_trans_dqjoin(	xfs_trans_t	*tp,	xfs_dquot_t	*dqp){	xfs_dq_logitem_t    *lp;	ASSERT(! XFS_DQ_IS_ADDEDTO_TRX(tp, dqp));	ASSERT(XFS_DQ_IS_LOCKED(dqp));	ASSERT(XFS_DQ_IS_LOGITEM_INITD(dqp));	lp = &dqp->q_logitem;	/*	 * Get a log_item_desc to point at the new item.	 */	(void) xfs_trans_add_item(tp, (xfs_log_item_t*)(lp));	/*	 * Initialize i_transp so we can later determine if this dquot is	 * associated with this transaction.	 */	dqp->q_transp = tp;}/* * This is called to mark the dquot as needing * to be logged when the transaction is committed.  The dquot must * already be associated with the given transaction. * Note that it marks the entire transaction as dirty. In the ordinary * case, this gets called via xfs_trans_commit, after the transaction * is already dirty. However, there's nothing stop this from getting * called directly, as done by xfs_qm_scall_setqlim. Hence, the TRANS_DIRTY * flag. */voidxfs_trans_log_dquot(	xfs_trans_t	*tp,	xfs_dquot_t	*dqp){	xfs_log_item_desc_t	*lidp;	ASSERT(XFS_DQ_IS_ADDEDTO_TRX(tp, dqp));	ASSERT(XFS_DQ_IS_LOCKED(dqp));	lidp = xfs_trans_find_item(tp, (xfs_log_item_t*)(&dqp->q_logitem));	ASSERT(lidp != NULL);	tp->t_flags |= XFS_TRANS_DIRTY;	lidp->lid_flags |= XFS_LID_DIRTY;}/* * Carry forward whatever is left of the quota blk reservation to * the spanky new transaction */STATIC voidxfs_trans_dup_dqinfo(	xfs_trans_t	*otp,	xfs_trans_t	*ntp){	xfs_dqtrx_t	*oq, *nq;	int		i,j;	xfs_dqtrx_t	*oqa, *nqa;	if (!otp->t_dqinfo)		return;	xfs_trans_alloc_dqinfo(ntp);	oqa = otp->t_dqinfo->dqa_usrdquots;	nqa = ntp->t_dqinfo->dqa_usrdquots;	/*	 * Because the quota blk reservation is carried forward,	 * it is also necessary to carry forward the DQ_DIRTY flag.	 */	if(otp->t_flags & XFS_TRANS_DQ_DIRTY)		ntp->t_flags |= XFS_TRANS_DQ_DIRTY;	for (j = 0; j < 2; j++) {		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {			if (oqa[i].qt_dquot == NULL)				break;			oq = &oqa[i];			nq = &nqa[i];			nq->qt_dquot = oq->qt_dquot;			nq->qt_bcount_delta = nq->qt_icount_delta = 0;			nq->qt_rtbcount_delta = 0;			/*			 * Transfer whatever is left of the reservations.			 */			nq->qt_blk_res = oq->qt_blk_res - oq->qt_blk_res_used;			oq->qt_blk_res = oq->qt_blk_res_used;			nq->qt_rtblk_res = oq->qt_rtblk_res -				oq->qt_rtblk_res_used;			oq->qt_rtblk_res = oq->qt_rtblk_res_used;			nq->qt_ino_res = oq->qt_ino_res - oq->qt_ino_res_used;			oq->qt_ino_res = oq->qt_ino_res_used;		}		oqa = otp->t_dqinfo->dqa_grpdquots;		nqa = ntp->t_dqinfo->dqa_grpdquots;	}}/* * Wrap around mod_dquot to account for both user and group quotas. */voidxfs_trans_mod_dquot_byino(	xfs_trans_t	*tp,	xfs_inode_t	*ip,	uint		field,	long		delta){	xfs_mount_t	*mp;	ASSERT(tp);	mp = tp->t_mountp;	if (!XFS_IS_QUOTA_ON(mp) ||	    ip->i_ino == mp->m_sb.sb_uquotino ||	    ip->i_ino == mp->m_sb.sb_gquotino)		return;	if (tp->t_dqinfo == NULL)		xfs_trans_alloc_dqinfo(tp);	if (XFS_IS_UQUOTA_ON(mp) && ip->i_udquot) {		(void) xfs_trans_mod_dquot(tp, ip->i_udquot, field, delta);	}	if (XFS_IS_GQUOTA_ON(mp) && ip->i_gdquot) {		(void) xfs_trans_mod_dquot(tp, ip->i_gdquot, field, delta);	}}STATIC xfs_dqtrx_t *xfs_trans_get_dqtrx(	xfs_trans_t	*tp,	xfs_dquot_t	*dqp){	int		i;	xfs_dqtrx_t	*qa;	for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {		qa = XFS_QM_DQP_TO_DQACCT(tp, dqp);		if (qa[i].qt_dquot == NULL ||		    qa[i].qt_dquot == dqp) {			return (&qa[i]);		}	}	return (NULL);}/* * Make the changes in the transaction structure. * The moral equivalent to xfs_trans_mod_sb(). * We don't touch any fields in the dquot, so we don't care * if it's locked or not (most of the time it won't be). */voidxfs_trans_mod_dquot(	xfs_trans_t	*tp,	xfs_dquot_t	*dqp,	uint		field,	long		delta){	xfs_dqtrx_t	*qtrx;	ASSERT(tp);	qtrx = NULL;	if (tp->t_dqinfo == NULL)		xfs_trans_alloc_dqinfo(tp);	/*	 * Find either the first free slot or the slot that belongs	 * to this dquot.	 */	qtrx = xfs_trans_get_dqtrx(tp, dqp);	ASSERT(qtrx);	if (qtrx->qt_dquot == NULL)		qtrx->qt_dquot = dqp;	switch (field) {		/*		 * regular disk blk reservation		 */	      case XFS_TRANS_DQ_RES_BLKS:		qtrx->qt_blk_res += (ulong)delta;		break;		/*		 * inode reservation		 */	      case XFS_TRANS_DQ_RES_INOS:		qtrx->qt_ino_res += (ulong)delta;		break;		/*		 * disk blocks used.		 */	      case XFS_TRANS_DQ_BCOUNT:		if (qtrx->qt_blk_res && delta > 0) {			qtrx->qt_blk_res_used += (ulong)delta;			ASSERT(qtrx->qt_blk_res >= qtrx->qt_blk_res_used);		}		qtrx->qt_bcount_delta += delta;		break;	      case XFS_TRANS_DQ_DELBCOUNT:		qtrx->qt_delbcnt_delta += delta;		break;		/*		 * Inode Count		 */	      case XFS_TRANS_DQ_ICOUNT:		if (qtrx->qt_ino_res && delta > 0) {			qtrx->qt_ino_res_used += (ulong)delta;			ASSERT(qtrx->qt_ino_res >= qtrx->qt_ino_res_used);		}		qtrx->qt_icount_delta += delta;		break;		/*		 * rtblk reservation		 */	      case XFS_TRANS_DQ_RES_RTBLKS:		qtrx->qt_rtblk_res += (ulong)delta;		break;		/*		 * rtblk count		 */	      case XFS_TRANS_DQ_RTBCOUNT:		if (qtrx->qt_rtblk_res && delta > 0) {			qtrx->qt_rtblk_res_used += (ulong)delta;			ASSERT(qtrx->qt_rtblk_res >= qtrx->qt_rtblk_res_used);		}		qtrx->qt_rtbcount_delta += delta;		break;	      case XFS_TRANS_DQ_DELRTBCOUNT:		qtrx->qt_delrtb_delta += delta;		break;	      default:		ASSERT(0);	}	tp->t_flags |= XFS_TRANS_DQ_DIRTY;}/* * Given an array of dqtrx structures, lock all the dquots associated * and join them to the transaction, provided they have been modified. * We know that the highest number of dquots (of one type - usr OR grp), * involved in a transaction is 2 and that both usr and grp combined - 3. * So, we don't attempt to make this very generic. */STATIC voidxfs_trans_dqlockedjoin(	xfs_trans_t	*tp,	xfs_dqtrx_t	*q){	ASSERT(q[0].qt_dquot != NULL);	if (q[1].qt_dquot == NULL) {		xfs_dqlock(q[0].qt_dquot);		xfs_trans_dqjoin(tp, q[0].qt_dquot);	} else {		ASSERT(XFS_QM_TRANS_MAXDQS == 2);		xfs_dqlock2(q[0].qt_dquot, q[1].qt_dquot);		xfs_trans_dqjoin(tp, q[0].qt_dquot);		xfs_trans_dqjoin(tp, q[1].qt_dquot);	}}/* * Called by xfs_trans_commit() and similar in spirit to * xfs_trans_apply_sb_deltas(). * Go thru all the dquots belonging to this transaction and modify the * INCORE dquot to reflect the actual usages. * Unreserve just the reservations done by this transaction. * dquot is still left locked at exit. */voidxfs_trans_apply_dquot_deltas(	xfs_trans_t		*tp){	int			i, j;	xfs_dquot_t		*dqp;	xfs_dqtrx_t		*qtrx, *qa;	xfs_disk_dquot_t	*d;	long			totalbdelta;	long			totalrtbdelta;	if (! (tp->t_flags & XFS_TRANS_DQ_DIRTY))		return;	ASSERT(tp->t_dqinfo);	qa = tp->t_dqinfo->dqa_usrdquots;	for (j = 0; j < 2; j++) {		if (qa[0].qt_dquot == NULL) {			qa = tp->t_dqinfo->dqa_grpdquots;			continue;		}		/*		 * Lock all of the dquots and join them to the transaction.		 */		xfs_trans_dqlockedjoin(tp, qa);		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {			qtrx = &qa[i];			/*			 * The array of dquots is filled			 * sequentially, not sparsely.			 */			if ((dqp = qtrx->qt_dquot) == NULL)				break;			ASSERT(XFS_DQ_IS_LOCKED(dqp));			ASSERT(XFS_DQ_IS_ADDEDTO_TRX(tp, dqp));			/*			 * adjust the actual number of blocks used			 */			d = &dqp->q_core;			/*			 * The issue here is - sometimes we don't make a blkquota			 * reservation intentionally to be fair to users			 * (when the amount is small). On the other hand,			 * delayed allocs do make reservations, but that's			 * outside of a transaction, so we have no			 * idea how much was really reserved.			 * So, here we've accumulated delayed allocation blks and			 * non-delay blks. The assumption is that the			 * delayed ones are always reserved (outside of a			 * transaction), and the others may or may not have			 * quota reservations.			 */			totalbdelta = qtrx->qt_bcount_delta +				qtrx->qt_delbcnt_delta;			totalrtbdelta = qtrx->qt_rtbcount_delta +				qtrx->qt_delrtb_delta;#ifdef QUOTADEBUG			if (totalbdelta < 0)				ASSERT(INT_GET(d->d_bcount, ARCH_CONVERT) >=				       (xfs_qcnt_t) -totalbdelta);			if (totalrtbdelta < 0)				ASSERT(INT_GET(d->d_rtbcount, ARCH_CONVERT) >=				       (xfs_qcnt_t) -totalrtbdelta);			if (qtrx->qt_icount_delta < 0)				ASSERT(INT_GET(d->d_icount, ARCH_CONVERT) >=				       (xfs_qcnt_t) -qtrx->qt_icount_delta);#endif			if (totalbdelta)				INT_MOD(d->d_bcount, ARCH_CONVERT, (xfs_qcnt_t)totalbdelta);			if (qtrx->qt_icount_delta)				INT_MOD(d->d_icount, ARCH_CONVERT, (xfs_qcnt_t)qtrx->qt_icount_delta);			if (totalrtbdelta)				INT_MOD(d->d_rtbcount, ARCH_CONVERT, (xfs_qcnt_t)totalrtbdelta);			/*			 * Start/reset the timer(s) if needed.			 */			xfs_qm_adjust_dqtimers(tp->t_mountp, d);			dqp->dq_flags |= XFS_DQ_DIRTY;			/*			 * add this to the list of items to get logged			 */