xfs
[Top] [All Lists]

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

To: Chandra Seetharaman <sekharan@xxxxxxxxxx>
Subject: Re: [PATCH v9 1/6] xfs: Move code around and remove typedefs
From: Ben Myers <bpm@xxxxxxx>
Date: Mon, 24 Jun 2013 16:36:56 -0500
Cc: xfs@xxxxxxxxxxx
Delivered-to: xfs@xxxxxxxxxxx
In-reply-to: <1372042107-27332-2-git-send-email-sekharan@xxxxxxxxxx>
References: <1372042107-27332-1-git-send-email-sekharan@xxxxxxxxxx> <1372042107-27332-2-git-send-email-sekharan@xxxxxxxxxx>
User-agent: Mutt/1.5.20 (2009-06-14)
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@xxxxxxxxxx>

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@xxxxxxx>

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


<Prev in Thread] Current Thread [Next in Thread>