Re: [PATCH v9 1/6] xfs: Move code around and remove typedefs

[Ben Myers <bpm@sgi.com>]

Hi Chandra,

On Sun, Jun 23, 2013 at 09:48:22PM -0500, Chandra Seetharaman wrote:
> Removed some typedefs, defined new functions, made some code clean up all in
> preparation of the series.
> 
> No functional changes.
> 
> Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>

As Dave mentioned, there are a few categories of changes that would probably be
better as separate patches.  I count 6:

1) the addition of xfs_is_quota_inode

2) conversion of XFS_DQUOT_TREE macro to xfs_dquot_tree inlined function

3) addition of xfs_dq_to_quota_inode

4) cleanups in xfs_dquot.c (xfs_qm_quotacheck,xfs_qm_init_quotainos,
   xfs_qm_vop_dqalloc,xfs_qm_vop_chown_reserve) and xfs_trans_dquot.c
   (xfs_trans_reserve_quota_bydquots)

5) changes to struct xfs_quotainfo.  I don't have an aversion to the comments
   in the structure.  I'm guessing that you updated from xfs_inode_t to
   struct xfs_inode and then ran into an 80 column issue later in the
   structure.  It'd be nice to have the entries all line up, but I think
   your compromise is fine.  Might have been better off touching only
   the quota inodes and leaving the rest, but... style.

6) add dqtypes enum, make an array in xfs_dquot_acct, update
   xfs_trans_dup_dqinfo.  Now we have a two dimensional array in there, and 
   I wonder if it would be better if it were more strongly typed.  e.g.

   tp->t_dqinfo->dq_type[j]->dqt_ents[i]

   (or something)


A couple more style notes below.  If have the time and see fit to split this
up, great.  Otherwise I will happily take it as is.

Reviewed-by: Ben Myers <bpm@sgi.com>

> ---
>  fs/xfs/xfs_dquot.c       |   16 ++--
>  fs/xfs/xfs_dquot.h       |    4 -
>  fs/xfs/xfs_icache.c      |    3 +-
>  fs/xfs/xfs_itable.c      |    2 +-
>  fs/xfs/xfs_qm.c          |  175 +++++++++++++++++++++++----------------------
>  fs/xfs/xfs_qm.h          |  133 ++++++++++++++++++++++-------------
>  fs/xfs/xfs_qm_syscalls.c |    8 +-
>  fs/xfs/xfs_sb.h          |    6 ++
>  fs/xfs/xfs_symlink.c     |    3 +-
>  fs/xfs/xfs_trans_dquot.c |   83 +++++++++-------------
>  10 files changed, 230 insertions(+), 203 deletions(-)
> 
> diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
> index 044e97a..f01012d 100644
> --- a/fs/xfs/xfs_dquot.c
> +++ b/fs/xfs/xfs_dquot.c
> @@ -570,13 +570,13 @@ xfs_qm_dqtobp(
>  	xfs_buf_t		**O_bpp,
>  	uint			flags)
>  {
> -	xfs_bmbt_irec_t map;
> -	int		nmaps = 1, error;
> -	xfs_buf_t	*bp;
> -	xfs_inode_t	*quotip = XFS_DQ_TO_QIP(dqp);
> -	xfs_mount_t	*mp = dqp->q_mount;
> -	xfs_dqid_t	id = be32_to_cpu(dqp->q_core.d_id);
> -	xfs_trans_t	*tp = (tpp ? *tpp : NULL);
> +	struct xfs_bmbt_irec	map;
> +	int			nmaps = 1, error;
> +	struct xfs_buf		*bp;
> +	struct xfs_inode	*quotip = xfs_dq_to_quota_inode(dqp);
> +	struct xfs_mount	*mp = dqp->q_mount;
> +	xfs_dqid_t		id = be32_to_cpu(dqp->q_core.d_id);
> +	struct xfs_trans	*tp = (tpp ? *tpp : NULL);
>  
>  	dqp->q_fileoffset = (xfs_fileoff_t)id / mp->m_quotainfo->qi_dqperchunk;
>  
> @@ -804,7 +804,7 @@ xfs_qm_dqget(
>  	xfs_dquot_t	**O_dqpp) /* OUT : locked incore dquot */
>  {
>  	struct xfs_quotainfo	*qi = mp->m_quotainfo;
> -	struct radix_tree_root *tree = XFS_DQUOT_TREE(qi, type);
> +	struct radix_tree_root *tree = xfs_dquot_tree(qi, type);
>  	struct xfs_dquot	*dqp;
>  	int			error;
>  
> diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
> index 4f0ebfc..b596626 100644
> --- a/fs/xfs/xfs_dquot.h
> +++ b/fs/xfs/xfs_dquot.h
> @@ -143,10 +143,6 @@ static inline xfs_dquot_t *xfs_inode_dquot(struct xfs_inode *ip, int type)
>  #define XFS_QM_ISUDQ(dqp)	((dqp)->dq_flags & XFS_DQ_USER)
>  #define XFS_QM_ISPDQ(dqp)	((dqp)->dq_flags & XFS_DQ_PROJ)
>  #define XFS_QM_ISGDQ(dqp)	((dqp)->dq_flags & XFS_DQ_GROUP)
> -#define XFS_DQ_TO_QINF(dqp)	((dqp)->q_mount->m_quotainfo)
> -#define XFS_DQ_TO_QIP(dqp)	(XFS_QM_ISUDQ(dqp) ? \
> -				 XFS_DQ_TO_QINF(dqp)->qi_uquotaip : \
> -				 XFS_DQ_TO_QINF(dqp)->qi_gquotaip)
>  
>  extern int		xfs_qm_dqread(struct xfs_mount *, xfs_dqid_t, uint,
>  					uint, struct xfs_dquot	**);
> diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
> index 96e344e..9560dc1 100644
> --- a/fs/xfs/xfs_icache.c
> +++ b/fs/xfs/xfs_icache.c
> @@ -335,7 +335,8 @@ xfs_iget_cache_miss(
>  	iflags = XFS_INEW;
>  	if (flags & XFS_IGET_DONTCACHE)
>  		iflags |= XFS_IDONTCACHE;
> -	ip->i_udquot = ip->i_gdquot = NULL;
> +	ip->i_udquot = NULL;
> +	ip->i_gdquot = NULL;
>  	xfs_iflags_set(ip, iflags);
>  
>  	/* insert the new inode */
> diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
> index 2ea7d40..9cbf9e0 100644
> --- a/fs/xfs/xfs_itable.c
> +++ b/fs/xfs/xfs_itable.c
> @@ -43,7 +43,7 @@ xfs_internal_inum(
>  {
>  	return (ino == mp->m_sb.sb_rbmino || ino == mp->m_sb.sb_rsumino ||
>  		(xfs_sb_version_hasquota(&mp->m_sb) &&
> -		 (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino)));
> +		 xfs_is_quota_inode(&mp->m_sb, ino)));
>  }
>  
>  /*
> diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
> index b75c9bb..f5f9925 100644
> --- a/fs/xfs/xfs_qm.c
> +++ b/fs/xfs/xfs_qm.c
> @@ -70,7 +70,7 @@ xfs_qm_dquot_walk(
>  	void			*data)
>  {
>  	struct xfs_quotainfo	*qi = mp->m_quotainfo;
> -	struct radix_tree_root	*tree = XFS_DQUOT_TREE(qi, type);
> +	struct radix_tree_root	*tree = xfs_dquot_tree(qi, type);
>  	uint32_t		next_index;
>  	int			last_error = 0;
>  	int			skipped;
> @@ -189,7 +189,7 @@ xfs_qm_dqpurge(
>  	xfs_dqfunlock(dqp);
>  	xfs_dqunlock(dqp);
>  
> -	radix_tree_delete(XFS_DQUOT_TREE(qi, dqp->q_core.d_flags),
> +	radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
>  			  be32_to_cpu(dqp->q_core.d_id));
>  	qi->qi_dquots--;
>  
> @@ -489,8 +489,7 @@ xfs_qm_need_dqattach(
>  		return false;
>  	if (!XFS_NOT_DQATTACHED(mp, ip))
>  		return false;
> -	if (ip->i_ino == mp->m_sb.sb_uquotino ||
> -	    ip->i_ino == mp->m_sb.sb_gquotino)
> +	if (xfs_is_quota_inode(&mp->m_sb, ip->i_ino))
>  		return false;
>  	return true;
>  }
> @@ -606,8 +605,7 @@ xfs_qm_dqdetach(
>  
>  	trace_xfs_dquot_dqdetach(ip);
>  
> -	ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_uquotino);
> -	ASSERT(ip->i_ino != ip->i_mount->m_sb.sb_gquotino);
> +	ASSERT(!xfs_is_quota_inode(&ip->i_mount->m_sb, ip->i_ino));
>  	if (ip->i_udquot) {
>  		xfs_qm_dqrele(ip->i_udquot);
>  		ip->i_udquot = NULL;
> @@ -1152,7 +1150,7 @@ xfs_qm_dqusage_adjust(
>  	 * rootino must have its resources accounted for, not so with the quota
>  	 * inodes.
>  	 */
> -	if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
> +	if (xfs_is_quota_inode(&mp->m_sb, ino)) {
>  		*res = BULKSTAT_RV_NOTHING;
>  		return XFS_ERROR(EINVAL);
>  	}
> @@ -1262,19 +1260,20 @@ int
>  xfs_qm_quotacheck(
>  	xfs_mount_t	*mp)
>  {
> -	int		done, count, error, error2;
> -	xfs_ino_t	lastino;
> -	size_t		structsz;
> -	xfs_inode_t	*uip, *gip;
> -	uint		flags;
> -	LIST_HEAD	(buffer_list);
> +	int			done, count, error, error2;
> +	xfs_ino_t		lastino;
> +	size_t			structsz;
> +	uint			flags;
> +	LIST_HEAD		(buffer_list);
> +	struct xfs_inode	*uip = mp->m_quotainfo->qi_uquotaip;
> +	struct xfs_inode	*gip = mp->m_quotainfo->qi_gquotaip;
>  
>  	count = INT_MAX;
>  	structsz = 1;
>  	lastino = 0;
>  	flags = 0;
>  
> -	ASSERT(mp->m_quotainfo->qi_uquotaip || mp->m_quotainfo->qi_gquotaip);
> +	ASSERT(uip || gip);
>  	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
>  
>  	xfs_notice(mp, "Quotacheck needed: Please wait.");
> @@ -1284,7 +1283,6 @@ xfs_qm_quotacheck(
>  	 * their counters to zero. We need a clean slate.
>  	 * We don't log our changes till later.
>  	 */
> -	uip = mp->m_quotainfo->qi_uquotaip;
>  	if (uip) {
>  		error = xfs_qm_dqiterate(mp, uip, XFS_QMOPT_UQUOTA,
>  					 &buffer_list);
> @@ -1293,7 +1291,6 @@ xfs_qm_quotacheck(
>  		flags |= XFS_UQUOTA_CHKD;
>  	}
>  
> -	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,
> @@ -1395,15 +1392,13 @@ STATIC int
>  xfs_qm_init_quotainos(
>  	xfs_mount_t	*mp)
>  {
> -	xfs_inode_t	*uip, *gip;
> -	int		error;
> -	__int64_t	sbflags;
> -	uint		flags;
> +	struct xfs_inode	*uip = NULL;
> +	struct xfs_inode	*gip = NULL;
> +	int			error;
> +	__int64_t		sbflags = 0;
> +	uint			flags = 0;
>  
>  	ASSERT(mp->m_quotainfo);
> -	uip = gip = NULL;
> -	sbflags = 0;
> -	flags = 0;
>  
>  	/*
>  	 * Get the uquota and gquota inodes
> @@ -1412,19 +1407,18 @@ xfs_qm_init_quotainos(
>  		if (XFS_IS_UQUOTA_ON(mp) &&
>  		    mp->m_sb.sb_uquotino != NULLFSINO) {
>  			ASSERT(mp->m_sb.sb_uquotino > 0);
> -			if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
> -					     0, 0, &uip)))
> +			error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
> +					     0, 0, &uip);
> +			if (error)
>  				return XFS_ERROR(error);
>  		}
>  		if (XFS_IS_OQUOTA_ON(mp) &&
>  		    mp->m_sb.sb_gquotino != NULLFSINO) {
>  			ASSERT(mp->m_sb.sb_gquotino > 0);
> -			if ((error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
> -					     0, 0, &gip))) {
> -				if (uip)
> -					IRELE(uip);
> -				return XFS_ERROR(error);
> -			}
> +			error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
> +					     0, 0, &gip);
> +			if (error)
> +				goto error_rele;
>  		}
>  	} else {
>  		flags |= XFS_QMOPT_SBVERSION;
> @@ -1439,10 +1433,11 @@ xfs_qm_init_quotainos(
>  	 * temporarily switch to read-write to do this.
>  	 */
>  	if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
> -		if ((error = xfs_qm_qino_alloc(mp, &uip,
> +		error = xfs_qm_qino_alloc(mp, &uip,
>  					      sbflags | XFS_SB_UQUOTINO,
> -					      flags | XFS_QMOPT_UQUOTA)))
> -			return XFS_ERROR(error);
> +					      flags | XFS_QMOPT_UQUOTA);
> +		if (error)
> +			goto error_rele;
>  
>  		flags &= ~XFS_QMOPT_SBVERSION;
>  	}
> @@ -1451,18 +1446,21 @@ xfs_qm_init_quotainos(
>  				XFS_QMOPT_GQUOTA : XFS_QMOPT_PQUOTA);
>  		error = xfs_qm_qino_alloc(mp, &gip,
>  					  sbflags | XFS_SB_GQUOTINO, flags);
> -		if (error) {
> -			if (uip)
> -				IRELE(uip);
> -
> -			return XFS_ERROR(error);
> -		}
> +		if (error)
> +			goto error_rele;
>  	}
>  
>  	mp->m_quotainfo->qi_uquotaip = uip;
>  	mp->m_quotainfo->qi_gquotaip = gip;
>  
>  	return 0;
> +
> +error_rele:
> +	if (uip)
> +		IRELE(uip);
> +	if (gip)
> +		IRELE(gip);
> +	return XFS_ERROR(error);
>  }
>  
>  STATIC void
> @@ -1473,7 +1471,7 @@ xfs_qm_dqfree_one(
>  	struct xfs_quotainfo	*qi = mp->m_quotainfo;
>  
>  	mutex_lock(&qi->qi_tree_lock);
> -	radix_tree_delete(XFS_DQUOT_TREE(qi, dqp->q_core.d_flags),
> +	radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
>  			  be32_to_cpu(dqp->q_core.d_id));
>  
>  	qi->qi_dquots--;
> @@ -1659,7 +1657,8 @@ xfs_qm_vop_dqalloc(
>  	struct xfs_dquot	**O_gdqpp)
>  {
>  	struct xfs_mount	*mp = ip->i_mount;
> -	struct xfs_dquot	*uq, *gq;
> +	struct xfs_dquot	*uq = NULL;
> +	struct xfs_dquot	*gq = NULL;
>  	int			error;
>  	uint			lockflags;
>  
> @@ -1684,7 +1683,6 @@ xfs_qm_vop_dqalloc(
>  		}
>  	}
>  
> -	uq = gq = NULL;
>  	if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
>  		if (ip->i_d.di_uid != uid) {
>  			/*
> @@ -1697,14 +1695,14 @@ xfs_qm_vop_dqalloc(
>  			 * holding ilock.
>  			 */
>  			xfs_iunlock(ip, lockflags);
> -			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
> +			error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t) uid,
>  						 XFS_DQ_USER,
>  						 XFS_QMOPT_DQALLOC |
>  						 XFS_QMOPT_DOWARN,
> -						 &uq))) {
> -				ASSERT(error != ENOENT);
> +						 &uq);
> +			ASSERT(error != ENOENT);

You have a series of these asserts which used to be in the error case taken out
of the error case.  Clearly the assertion is still true when error == 0... but
I tend to prefer that it still be in the error curlies.  A silly style thing
which I welcome you to reject with prejudice.

> +			if (error)
>  				return error;
> -			}
>  			/*
>  			 * Get the ilock in the right order.
>  			 */
> @@ -1723,16 +1721,14 @@ xfs_qm_vop_dqalloc(
>  	if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
>  		if (ip->i_d.di_gid != gid) {
>  			xfs_iunlock(ip, lockflags);
> -			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
> +			error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)gid,
>  						 XFS_DQ_GROUP,
>  						 XFS_QMOPT_DQALLOC |
>  						 XFS_QMOPT_DOWARN,
> -						 &gq))) {
> -				if (uq)
> -					xfs_qm_dqrele(uq);
> -				ASSERT(error != ENOENT);
> -				return error;
> -			}
> +						 &gq);
> +			ASSERT(error != ENOENT);
> +			if (error)
> +				goto error_rele;
>  			xfs_dqunlock(gq);
>  			lockflags = XFS_ILOC_SHARED;
>  			xfs_ilock(ip, lockflags);
> @@ -1743,16 +1739,14 @@ xfs_qm_vop_dqalloc(
>  	} else if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
>  		if (xfs_get_projid(ip) != prid) {
>  			xfs_iunlock(ip, lockflags);
> -			if ((error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
> +			error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)prid,
>  						 XFS_DQ_PROJ,
>  						 XFS_QMOPT_DQALLOC |
>  						 XFS_QMOPT_DOWARN,
> -						 &gq))) {
> -				if (uq)
> -					xfs_qm_dqrele(uq);
> -				ASSERT(error != ENOENT);
> -				return (error);
> -			}
> +						 &gq);
> +			ASSERT(error != ENOENT);
> +			if (error)
> +				goto error_rele;
>  			xfs_dqunlock(gq);
>  			lockflags = XFS_ILOCK_SHARED;
>  			xfs_ilock(ip, lockflags);
> @@ -1774,6 +1768,11 @@ xfs_qm_vop_dqalloc(
>  	else if (gq)
>  		xfs_qm_dqrele(gq);
>  	return 0;
> +
> +error_rele:
> +	if (uq)
> +		xfs_qm_dqrele(uq);
> +	return error;
>  }
>  
>  /*
> @@ -1821,29 +1820,31 @@ xfs_qm_vop_chown(
>   */
>  int
>  xfs_qm_vop_chown_reserve(
> -	xfs_trans_t	*tp,
> -	xfs_inode_t	*ip,
> -	xfs_dquot_t	*udqp,
> -	xfs_dquot_t	*gdqp,
> -	uint		flags)
> +	struct xfs_trans	*tp,
> +	struct xfs_inode	*ip,
> +	struct xfs_dquot	*udqp,
> +	struct xfs_dquot	*gdqp,
> +	uint			flags)
>  {
> -	xfs_mount_t	*mp = ip->i_mount;
> -	uint		delblks, blkflags, prjflags = 0;
> -	xfs_dquot_t	*unresudq, *unresgdq, *delblksudq, *delblksgdq;
> -	int		error;
> +	struct xfs_mount	*mp = ip->i_mount;
> +	uint			delblks, blkflags, prjflags = 0;
> +	struct xfs_dquot	*udq_unres = NULL;
> +	struct xfs_dquot	*gdq_unres = NULL;
> +	struct xfs_dquot	*udq_delblks = NULL;
> +	struct xfs_dquot	*gdq_delblks = NULL;
> +	int			error;
>  
>  
>  	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
>  	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
>  
>  	delblks = ip->i_delayed_blks;
> -	delblksudq = delblksgdq = unresudq = unresgdq = NULL;
>  	blkflags = XFS_IS_REALTIME_INODE(ip) ?
>  			XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
>  
>  	if (XFS_IS_UQUOTA_ON(mp) && udqp &&
>  	    ip->i_d.di_uid != (uid_t)be32_to_cpu(udqp->q_core.d_id)) {
> -		delblksudq = udqp;
> +		udq_delblks = udqp;
>  		/*
>  		 * If there are delayed allocation blocks, then we have to
>  		 * unreserve those from the old dquot, and add them to the
> @@ -1851,7 +1852,7 @@ xfs_qm_vop_chown_reserve(
>  		 */
>  		if (delblks) {
>  			ASSERT(ip->i_udquot);
> -			unresudq = ip->i_udquot;
> +			udq_unres = ip->i_udquot;
>  		}
>  	}
>  	if (XFS_IS_OQUOTA_ON(ip->i_mount) && gdqp) {
> @@ -1862,18 +1863,19 @@ xfs_qm_vop_chown_reserve(
>  		if (prjflags ||
>  		    (XFS_IS_GQUOTA_ON(ip->i_mount) &&
>  		     ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id))) {
> -			delblksgdq = gdqp;
> +			gdq_delblks = gdqp;
>  			if (delblks) {
>  				ASSERT(ip->i_gdquot);
> -				unresgdq = ip->i_gdquot;
> +				gdq_unres = ip->i_gdquot;
>  			}
>  		}
>  	}
>  
> -	if ((error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
> -				delblksudq, delblksgdq, ip->i_d.di_nblocks, 1,
> -				flags | blkflags | prjflags)))
> -		return (error);
> +	error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
> +				udq_delblks, gdq_delblks, ip->i_d.di_nblocks, 1,
> +				flags | blkflags | prjflags);
> +	if (error)
> +		return error;
>  
>  	/*
>  	 * Do the delayed blks reservations/unreservations now. Since, these
> @@ -1885,14 +1887,15 @@ xfs_qm_vop_chown_reserve(
>  		/*
>  		 * Do the reservations first. Unreservation can't fail.
>  		 */
> -		ASSERT(delblksudq || delblksgdq);
> -		ASSERT(unresudq || unresgdq);
> -		if ((error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
> -				delblksudq, delblksgdq, (xfs_qcnt_t)delblks, 0,
> -				flags | blkflags | prjflags)))
> -			return (error);
> +		ASSERT(udq_delblks || gdq_delblks);
> +		ASSERT(udq_unres || gdq_unres);
> +		error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
> +			    udq_delblks, gdq_delblks, (xfs_qcnt_t)delblks, 0,
> +			    flags | blkflags | prjflags);
> +		if (error)
> +			return error;
>  		xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
> -				unresudq, unresgdq, -((xfs_qcnt_t)delblks), 0,
> +				udq_unres, gdq_unres, -((xfs_qcnt_t)delblks), 0,
>  				blkflags);
>  	}
>  
> diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
> index 5d16a6e..4b330f2 100644
> --- a/fs/xfs/xfs_qm.h
> +++ b/fs/xfs/xfs_qm.h
> @@ -42,57 +42,89 @@ extern struct kmem_zone	*xfs_qm_dqtrxzone;
>   * The mount structure keeps a pointer to this.
>   */
>  typedef struct xfs_quotainfo {
> -	struct radix_tree_root qi_uquota_tree;
> -	struct radix_tree_root qi_gquota_tree;
> -	struct mutex qi_tree_lock;
> -	xfs_inode_t	*qi_uquotaip;	 /* user quota inode */
> -	xfs_inode_t	*qi_gquotaip;	 /* group quota inode */
> -	struct list_head qi_lru_list;
> -	struct mutex	 qi_lru_lock;
> -	int		 qi_lru_count;
> -	int		 qi_dquots;
> -	time_t		 qi_btimelimit;	 /* limit for blks timer */
> -	time_t		 qi_itimelimit;	 /* limit for inodes timer */
> -	time_t		 qi_rtbtimelimit;/* limit for rt blks timer */
> -	xfs_qwarncnt_t	 qi_bwarnlimit;	 /* limit for blks warnings */
> -	xfs_qwarncnt_t	 qi_iwarnlimit;	 /* limit for inodes warnings */
> -	xfs_qwarncnt_t	 qi_rtbwarnlimit;/* limit for rt blks warnings */
> -	struct mutex	 qi_quotaofflock;/* to serialize quotaoff */
> -	xfs_filblks_t	 qi_dqchunklen;	 /* # BBs in a chunk of dqs */
> -	uint		 qi_dqperchunk;	 /* # ondisk dqs in above chunk */
> -	xfs_qcnt_t	 qi_bhardlimit;	 /* default data blk hard limit */
> -	xfs_qcnt_t	 qi_bsoftlimit;	 /* default data blk soft limit */
> -	xfs_qcnt_t	 qi_ihardlimit;	 /* default inode count hard limit */
> -	xfs_qcnt_t	 qi_isoftlimit;	 /* default inode count soft limit */
> -	xfs_qcnt_t	 qi_rtbhardlimit;/* default realtime blk hard limit */
> -	xfs_qcnt_t	 qi_rtbsoftlimit;/* default realtime blk soft limit */
> -	struct shrinker  qi_shrinker;
> +	struct radix_tree_root	qi_uquota_tree;
> +	struct radix_tree_root	qi_gquota_tree;
> +	struct mutex		qi_tree_lock;
> +	struct xfs_inode	*qi_uquotaip;	 /* user quota inode */
> +	struct xfs_inode	*qi_gquotaip;	 /* group quota inode */
> +	struct list_head	qi_lru_list;
> +	struct mutex		qi_lru_lock;
> +	int		qi_lru_count;
> +	int		qi_dquots;
> +	time_t		qi_btimelimit;	 /* limit for blks timer */
> +	time_t		qi_itimelimit;	 /* limit for inodes timer */
> +	time_t		qi_rtbtimelimit;/* limit for rt blks timer */
> +	xfs_qwarncnt_t	qi_bwarnlimit;	 /* limit for blks warnings */
> +	xfs_qwarncnt_t	qi_iwarnlimit;	 /* limit for inodes warnings */
> +	xfs_qwarncnt_t	qi_rtbwarnlimit;/* limit for rt blks warnings */
> +	struct mutex	qi_quotaofflock;/* to serialize quotaoff */
> +	xfs_filblks_t	qi_dqchunklen;	 /* # BBs in a chunk of dqs */
> +	uint		qi_dqperchunk;	 /* # ondisk dqs in above chunk */
> +	xfs_qcnt_t	qi_bhardlimit;	 /* default data blk hard limit */
> +	xfs_qcnt_t	qi_bsoftlimit;	 /* default data blk soft limit */
> +	xfs_qcnt_t	qi_ihardlimit;	 /* default inode count hard limit */
> +	xfs_qcnt_t	qi_isoftlimit;	 /* default inode count soft limit */
> +	xfs_qcnt_t	qi_rtbhardlimit;/* default realtime blk hard limit */
> +	xfs_qcnt_t	qi_rtbsoftlimit;/* default realtime blk soft limit */
> +	struct shrinker	qi_shrinker;
>  } xfs_quotainfo_t;
>  
> -#define XFS_DQUOT_TREE(qi, type) \
> -	((type & XFS_DQ_USER) ? \
> -	 &((qi)->qi_uquota_tree) : \
> -	 &((qi)->qi_gquota_tree))
> +static inline struct radix_tree_root *
> +xfs_dquot_tree(
> +	struct xfs_quotainfo	*qi,
> +	int			type)
> +{
> +	switch (type) {
> +	case XFS_DQ_USER:
> +		return &qi->qi_uquota_tree;
> +	case XFS_DQ_GROUP:
> +	case XFS_DQ_PROJ:
> +		return &qi->qi_gquota_tree;
> +	default:
> +		ASSERT(0);
> +	}
> +	return NULL;
> +}
>  
> +static inline struct xfs_inode *
> +xfs_dq_to_quota_inode(struct xfs_dquot *dqp)
> +{
> +	switch (dqp->dq_flags & XFS_DQ_ALLTYPES) {
> +	case XFS_DQ_USER:
> +		return dqp->q_mount->m_quotainfo->qi_uquotaip;
> +	case XFS_DQ_GROUP:
> +	case XFS_DQ_PROJ:
> +		return dqp->q_mount->m_quotainfo->qi_gquotaip;
> +	default:
> +		ASSERT(0);
> +	}
> +	return NULL;
> +}
>  
>  extern int	xfs_qm_calc_dquots_per_chunk(struct xfs_mount *mp,
>  					     unsigned int nbblks);
> -extern void	xfs_trans_mod_dquot(xfs_trans_t *, xfs_dquot_t *, uint, long);
> -extern int	xfs_trans_reserve_quota_bydquots(xfs_trans_t *, xfs_mount_t *,
> -			xfs_dquot_t *, xfs_dquot_t *, long, long, uint);
> -extern void	xfs_trans_dqjoin(xfs_trans_t *, xfs_dquot_t *);
> -extern void	xfs_trans_log_dquot(xfs_trans_t *, xfs_dquot_t *);
> +extern void	xfs_trans_mod_dquot(struct xfs_trans *,
> +					struct xfs_dquot *, uint, long);
> +extern int	xfs_trans_reserve_quota_bydquots(struct xfs_trans *,
> +			struct xfs_mount *, struct xfs_dquot *,
> +			struct xfs_dquot *, long, long, uint);
> +extern void	xfs_trans_dqjoin(struct xfs_trans *, struct xfs_dquot *);
> +extern void	xfs_trans_log_dquot(struct xfs_trans *, struct xfs_dquot *);
>  
>  /*
>   * We keep the usr and grp dquots separately so that locking will be easier
>   * to do at commit time. All transactions that we know of at this point
>   * affect no more than two dquots of one type. Hence, the TRANS_MAXDQS value.
>   */
> +enum {
> +	XFS_QM_TRANS_USR = 0,
> +	XFS_QM_TRANS_GRP,
> +	XFS_QM_TRANS_DQTYPES
> +};
>  #define XFS_QM_TRANS_MAXDQS		2
> -typedef struct xfs_dquot_acct {
> -	xfs_dqtrx_t	dqa_usrdquots[XFS_QM_TRANS_MAXDQS];
> -	xfs_dqtrx_t	dqa_grpdquots[XFS_QM_TRANS_MAXDQS];
> -} xfs_dquot_acct_t;
> +struct xfs_dquot_acct {
> +	struct xfs_dqtrx	dqs[XFS_QM_TRANS_DQTYPES][XFS_QM_TRANS_MAXDQS];
> +};
>  
>  /*
>   * Users are allowed to have a usage exceeding their softlimit for
> @@ -106,22 +138,23 @@ typedef struct xfs_dquot_acct {
>  #define XFS_QM_IWARNLIMIT	5
>  #define XFS_QM_RTBWARNLIMIT	5
>  
> -extern void		xfs_qm_destroy_quotainfo(xfs_mount_t *);
> -extern int		xfs_qm_quotacheck(xfs_mount_t *);
> -extern int		xfs_qm_write_sb_changes(xfs_mount_t *, __int64_t);
> +extern void		xfs_qm_destroy_quotainfo(struct xfs_mount *);
> +extern int		xfs_qm_quotacheck(struct xfs_mount *);
> +extern int		xfs_qm_write_sb_changes(struct xfs_mount *, __int64_t);
>  
>  /* dquot stuff */
> -extern void		xfs_qm_dqpurge_all(xfs_mount_t *, uint);
> -extern void		xfs_qm_dqrele_all_inodes(xfs_mount_t *, uint);
> +extern void		xfs_qm_dqpurge_all(struct xfs_mount *, uint);
> +extern void		xfs_qm_dqrele_all_inodes(struct xfs_mount *, uint);
>  
>  /* quota ops */
> -extern int		xfs_qm_scall_trunc_qfiles(xfs_mount_t *, uint);
> -extern int		xfs_qm_scall_getquota(xfs_mount_t *, xfs_dqid_t, uint,
> -					fs_disk_quota_t *);
> +extern int		xfs_qm_scall_trunc_qfiles(struct xfs_mount *, uint);
> +extern int		xfs_qm_scall_getquota(struct xfs_mount *, xfs_dqid_t,
> +					uint, struct fs_disk_quota *);
>  extern int		xfs_qm_scall_setqlim(struct xfs_mount *, xfs_dqid_t, uint,
> -					fs_disk_quota_t *);
> -extern int		xfs_qm_scall_getqstat(xfs_mount_t *, fs_quota_stat_t *);
> -extern int		xfs_qm_scall_quotaon(xfs_mount_t *, uint);
> -extern int		xfs_qm_scall_quotaoff(xfs_mount_t *, uint);
> +					struct fs_disk_quota *);
> +extern int		xfs_qm_scall_getqstat(struct xfs_mount *,
> +					struct fs_quota_stat *);
> +extern int		xfs_qm_scall_quotaon(struct xfs_mount *, uint);
> +extern int		xfs_qm_scall_quotaoff(struct xfs_mount *, uint);
>  
>  #endif /* __XFS_QM_H__ */
> diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
> index 6cdf6ff..b03b2ab 100644
> --- a/fs/xfs/xfs_qm_syscalls.c
> +++ b/fs/xfs/xfs_qm_syscalls.c
> @@ -407,11 +407,11 @@ xfs_qm_scall_getqstat(
>  	struct fs_quota_stat	*out)
>  {
>  	struct xfs_quotainfo	*q = mp->m_quotainfo;
> -	struct xfs_inode	*uip, *gip;
> -	bool                    tempuqip, tempgqip;
> +	struct xfs_inode	*uip = NULL;
> +	struct xfs_inode	*gip = NULL;
> +	bool                    tempuqip = false;
> +	bool                    tempgqip = false;
>  
> -	uip = gip = NULL;
> -	tempuqip = tempgqip = false;
>  	memset(out, 0, sizeof(fs_quota_stat_t));
>  
>  	out->qs_version = FS_QSTAT_VERSION;
> diff --git a/fs/xfs/xfs_sb.h b/fs/xfs/xfs_sb.h
> index 2de58a8..78f9e70 100644
> --- a/fs/xfs/xfs_sb.h
> +++ b/fs/xfs/xfs_sb.h
> @@ -618,6 +618,12 @@ xfs_sb_has_incompat_log_feature(
>  	return (sbp->sb_features_log_incompat & feature) != 0;
>  }
>  
> +static inline bool
> +xfs_is_quota_inode(struct xfs_sb *sbp, xfs_ino_t ino)
> +{
> +	return (ino == sbp->sb_uquotino || ino == sbp->sb_gquotino);
> +}
> +
>  /*
>   * end of superblock version macros
>   */
> diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
> index 738c04b..e830fb5 100644
> --- a/fs/xfs/xfs_symlink.c
> +++ b/fs/xfs/xfs_symlink.c
> @@ -358,7 +358,8 @@ xfs_symlink(
>  	int			n;
>  	xfs_buf_t		*bp;
>  	prid_t			prid;
> -	struct xfs_dquot	*udqp, *gdqp;
> +	struct xfs_dquot	*udqp = NULL;
> +	struct xfs_dquot	*gdqp = NULL;
>  	uint			resblks;
>  
>  	*ipp = NULL;
> diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
> index fec75d0..7ea7485 100644
> --- a/fs/xfs/xfs_trans_dquot.c
> +++ b/fs/xfs/xfs_trans_dquot.c
> @@ -103,8 +103,6 @@ xfs_trans_dup_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,
> @@ -113,7 +111,9 @@ xfs_trans_dup_dqinfo(
>  	if(otp->t_flags & XFS_TRANS_DQ_DIRTY)
>  		ntp->t_flags |= XFS_TRANS_DQ_DIRTY;
>  
> -	for (j = 0; j < 2; j++) {
> +	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
> +		oqa = otp->t_dqinfo->dqs[j];
> +		nqa = ntp->t_dqinfo->dqs[j];
>  		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
>  			if (oqa[i].qt_dquot == NULL)
>  				break;
> @@ -138,8 +138,6 @@ xfs_trans_dup_dqinfo(
>  			oq->qt_ino_res = oq->qt_ino_res_used;
>  

Could clean up this extra line...


_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs