xfs: Code cleanup and removal of some typedef usage

In preparation for combined pquota/gquota support, for the sake
of readability, do some code cleanup surrounding the affected
code.

Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

1 files changed, 80 insertions, 72 deletions

diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 8e707d33e106..cf09aa845d8c 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -1260,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.");
@@ -1282,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);
@@ -1291,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,
@@ -1393,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
@@ -1410,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;
@@ -1437,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;
         }
@@ -1449,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
@@ -1657,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;
 
@@ -1682,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) {
                         /*
@@ -1695,11 +1695,12 @@ 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))) {
+                                                 &uq);
+                        if (error) {
                                 ASSERT(error != ENOENT);
                                 return error;
                         }
@@ -1721,15 +1722,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);
+                                                 &gq);
+                        if (error) {
                                 ASSERT(error != ENOENT);
-                                return error;
+                                goto error_rele;
                         }
                         xfs_dqunlock(gq);
                         lockflags = XFS_ILOCK_SHARED;
@@ -1741,15 +1741,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);
+                                                 &gq);
+                        if (error) {
                                 ASSERT(error != ENOENT);
-                                return (error);
+                                goto error_rele;
                         }
                         xfs_dqunlock(gq);
                         lockflags = XFS_ILOCK_SHARED;
@@ -1772,6 +1771,11 @@ xfs_qm_vop_dqalloc(
         else if (gq)
                 xfs_qm_dqrele(gq);
         return 0;
+
+error_rele:
+        if (uq)
+                xfs_qm_dqrele(uq);
+        return error;
 }
 
 /*
@@ -1819,29 +1823,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
@@ -1849,7 +1855,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) {
@@ -1860,18 +1866,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
@@ -1883,14 +1890,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);
         }