Merge branch 'master' of git://git.kernel.org/pub/scm/fs/xfs/xfs

9 files changed, 140 insertions, 313 deletions

diff --git a/fs/xfs/quota/xfs_dquot.c b/fs/xfs/quota/xfs_dquot.c
index e4babcc63423..2f3f2229eaaf 100644
--- a/fs/xfs/quota/xfs_dquot.c
+++ b/fs/xfs/quota/xfs_dquot.c
@@ -42,7 +42,6 @@
 #include "xfs_error.h"
 #include "xfs_itable.h"
 #include "xfs_rw.h"
-#include "xfs_acl.h"
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_trans_space.h"
@@ -1194,7 +1193,9 @@ void
 xfs_qm_dqrele(
         xfs_dquot_t     *dqp)
 {
-        ASSERT(dqp);
+        if (!dqp)
+                return;
+
         xfs_dqtrace_entry(dqp, "DQRELE");
 
         xfs_dqlock(dqp);
diff --git a/fs/xfs/quota/xfs_dquot.h b/fs/xfs/quota/xfs_dquot.h
index de0f402ddb4c..6533ead9b889 100644
--- a/fs/xfs/quota/xfs_dquot.h
+++ b/fs/xfs/quota/xfs_dquot.h
@@ -181,7 +181,6 @@ extern void		xfs_qm_adjust_dqlimits(xfs_mount_t *,
 extern int              xfs_qm_dqget(xfs_mount_t *, xfs_inode_t *,
                                         xfs_dqid_t, uint, uint, xfs_dquot_t **);
 extern void             xfs_qm_dqput(xfs_dquot_t *);
-extern void             xfs_qm_dqrele(xfs_dquot_t *);
 extern void             xfs_dqlock(xfs_dquot_t *);
 extern void             xfs_dqlock2(xfs_dquot_t *, xfs_dquot_t *);
 extern void             xfs_dqunlock(xfs_dquot_t *);
diff --git a/fs/xfs/quota/xfs_dquot_item.c b/fs/xfs/quota/xfs_dquot_item.c
index 1728f6a7c4f5..d0d4a9a0bbd7 100644
--- a/fs/xfs/quota/xfs_dquot_item.c
+++ b/fs/xfs/quota/xfs_dquot_item.c
@@ -42,7 +42,6 @@
 #include "xfs_error.h"
 #include "xfs_itable.h"
 #include "xfs_rw.h"
-#include "xfs_acl.h"
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_trans_priv.h"
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index 5b6695049e00..45b1bfef7388 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -42,7 +42,6 @@
 #include "xfs_error.h"
 #include "xfs_bmap.h"
 #include "xfs_rw.h"
-#include "xfs_acl.h"
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_trans_space.h"
@@ -287,11 +286,13 @@ xfs_qm_rele_quotafs_ref(
  * Just destroy the quotainfo structure.
  */
 void
-xfs_qm_unmount_quotadestroy(
-        xfs_mount_t     *mp)
+xfs_qm_unmount(
+        struct xfs_mount        *mp)
 {
-        if (mp->m_quotainfo)
+        if (mp->m_quotainfo) {
+                xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL | XFS_QMOPT_UMOUNTING);
                 xfs_qm_destroy_quotainfo(mp);
+        }
 }
 
 
@@ -385,8 +386,13 @@ xfs_qm_mount_quotas(
         if (error) {
                 xfs_fs_cmn_err(CE_WARN, mp,
                         "Failed to initialize disk quotas.");
+                return;
         }
-        return;
+
+#ifdef QUOTADEBUG
+        if (XFS_IS_QUOTA_ON(mp))
+                xfs_qm_internalqcheck(mp);
+#endif
 }
 
 /*
@@ -774,12 +780,11 @@ xfs_qm_dqattach_grouphint(
  * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
  * into account.
  * If XFS_QMOPT_DQALLOC, the dquot(s) will be allocated if needed.
- * If XFS_QMOPT_ILOCKED, then inode sent is already locked EXCL.
  * Inode may get unlocked and relocked in here, and the caller must deal with
  * the consequences.
  */
 int
-xfs_qm_dqattach(
+xfs_qm_dqattach_locked(
         xfs_inode_t     *ip,
         uint            flags)
 {
@@ -787,17 +792,14 @@ xfs_qm_dqattach(
         uint            nquotas = 0;
         int             error = 0;
 
-        if ((! XFS_IS_QUOTA_ON(mp)) ||
-            (! XFS_NOT_DQATTACHED(mp, ip)) ||
-            (ip->i_ino == mp->m_sb.sb_uquotino) ||
-            (ip->i_ino == mp->m_sb.sb_gquotino))
+        if (!XFS_IS_QUOTA_RUNNING(mp) ||
+            !XFS_IS_QUOTA_ON(mp) ||
+            !XFS_NOT_DQATTACHED(mp, ip) ||
+            ip->i_ino == mp->m_sb.sb_uquotino ||
+            ip->i_ino == mp->m_sb.sb_gquotino)
                 return 0;
 
-        ASSERT((flags & XFS_QMOPT_ILOCKED) == 0 ||
-               xfs_isilocked(ip, XFS_ILOCK_EXCL));
-
-        if (! (flags & XFS_QMOPT_ILOCKED))
-                xfs_ilock(ip, XFS_ILOCK_EXCL);
+        ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 
         if (XFS_IS_UQUOTA_ON(mp)) {
                 error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
@@ -849,8 +851,7 @@ xfs_qm_dqattach(
                 xfs_qm_dqattach_grouphint(ip->i_udquot, ip->i_gdquot);
         }
 
-      done:
-
+ done:
 #ifdef QUOTADEBUG
         if (! error) {
                 if (XFS_IS_UQUOTA_ON(mp))
@@ -858,15 +859,22 @@ xfs_qm_dqattach(
                 if (XFS_IS_OQUOTA_ON(mp))
                         ASSERT(ip->i_gdquot);
         }
+        ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
 #endif
+        return error;
+}
 
-        if (! (flags & XFS_QMOPT_ILOCKED))
-                xfs_iunlock(ip, XFS_ILOCK_EXCL);
+int
+xfs_qm_dqattach(
+        struct xfs_inode        *ip,
+        uint                    flags)
+{
+        int                     error;
+
+        xfs_ilock(ip, XFS_ILOCK_EXCL);
+        error = xfs_qm_dqattach_locked(ip, flags);
+        xfs_iunlock(ip, XFS_ILOCK_EXCL);
 
-#ifdef QUOTADEBUG
-        else
-                ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
-#endif
         return error;
 }
 
@@ -896,11 +904,6 @@ xfs_qm_dqdetach(
         }
 }
 
-/*
- * This is called to sync quotas. We can be told to use non-blocking
- * semantics by either the SYNC_BDFLUSH flag or the absence of the
- * SYNC_WAIT flag.
- */
 int
 xfs_qm_sync(
         xfs_mount_t     *mp,
@@ -909,17 +912,13 @@ xfs_qm_sync(
         int             recl, restarts;
         xfs_dquot_t     *dqp;
         uint            flush_flags;
-        boolean_t       nowait;
         int             error;
 
-        if (! XFS_IS_QUOTA_ON(mp))
+        if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
                 return 0;
 
+        flush_flags = (flags & SYNC_WAIT) ? XFS_QMOPT_SYNC : XFS_QMOPT_DELWRI;
         restarts = 0;
-        /*
-         * We won't block unless we are asked to.
-         */
-        nowait = (boolean_t)(flags & SYNC_BDFLUSH || (flags & SYNC_WAIT) == 0);
 
   again:
         xfs_qm_mplist_lock(mp);
@@ -939,18 +938,10 @@ xfs_qm_sync(
                  * don't 'seem' to be dirty. ie. don't acquire dqlock.
                  * This is very similar to what xfs_sync does with inodes.
                  */
-                if (flags & SYNC_BDFLUSH) {
-                        if (! XFS_DQ_IS_DIRTY(dqp))
+                if (flags & SYNC_TRYLOCK) {
+                        if (!XFS_DQ_IS_DIRTY(dqp))
                                 continue;
-                }
-
-                if (nowait) {
-                        /*
-                         * Try to acquire the dquot lock. We are NOT out of
-                         * lock order, but we just don't want to wait for this
-                         * lock, unless somebody wanted us to.
-                         */
-                        if (! xfs_qm_dqlock_nowait(dqp))
+                        if (!xfs_qm_dqlock_nowait(dqp))
                                 continue;
                 } else {
                         xfs_dqlock(dqp);
@@ -967,7 +958,7 @@ xfs_qm_sync(
                 /* XXX a sentinel would be better */
                 recl = XFS_QI_MPLRECLAIMS(mp);
                 if (!xfs_dqflock_nowait(dqp)) {
-                        if (nowait) {
+                        if (flags & SYNC_TRYLOCK) {
                                 xfs_dqunlock(dqp);
                                 continue;
                         }
@@ -985,7 +976,6 @@ xfs_qm_sync(
                  * Let go of the mplist lock. We don't want to hold it
                  * across a disk write
                  */
-                flush_flags = (nowait) ? XFS_QMOPT_DELWRI : XFS_QMOPT_SYNC;
                 xfs_qm_mplist_unlock(mp);
                 xfs_dqtrace_entry(dqp, "XQM_SYNC: DQFLUSH");
                 error = xfs_qm_dqflush(dqp, flush_flags);
@@ -2319,20 +2309,20 @@ xfs_qm_write_sb_changes(
  */
 int
 xfs_qm_vop_dqalloc(
-        xfs_mount_t     *mp,
-        xfs_inode_t     *ip,
-        uid_t           uid,
-        gid_t           gid,
-        prid_t          prid,
-        uint            flags,
-        xfs_dquot_t     **O_udqpp,
-        xfs_dquot_t     **O_gdqpp)
+        struct xfs_inode        *ip,
+        uid_t                   uid,
+        gid_t                   gid,
+        prid_t                  prid,
+        uint                    flags,
+        struct xfs_dquot        **O_udqpp,
+        struct xfs_dquot        **O_gdqpp)
 {
-        int             error;
-        xfs_dquot_t     *uq, *gq;
-        uint            lockflags;
+        struct xfs_mount        *mp = ip->i_mount;
+        struct xfs_dquot        *uq, *gq;
+        int                     error;
+        uint                    lockflags;
 
-        if (!XFS_IS_QUOTA_ON(mp))
+        if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
                 return 0;
 
         lockflags = XFS_ILOCK_EXCL;
@@ -2346,8 +2336,8 @@ xfs_qm_vop_dqalloc(
          * if necessary. The dquot(s) will not be locked.
          */
         if (XFS_NOT_DQATTACHED(mp, ip)) {
-                if ((error = xfs_qm_dqattach(ip, XFS_QMOPT_DQALLOC |
-                                            XFS_QMOPT_ILOCKED))) {
+                error = xfs_qm_dqattach_locked(ip, XFS_QMOPT_DQALLOC);
+                if (error) {
                         xfs_iunlock(ip, lockflags);
                         return error;
                 }
@@ -2469,6 +2459,7 @@ xfs_qm_vop_chown(
         uint            bfield = XFS_IS_REALTIME_INODE(ip) ?
                                  XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;
 
+
         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
         ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
 
@@ -2508,13 +2499,13 @@ xfs_qm_vop_chown_reserve(
         xfs_dquot_t     *gdqp,
         uint            flags)
 {
-        int             error;
-        xfs_mount_t     *mp;
+        xfs_mount_t     *mp = ip->i_mount;
         uint            delblks, blkflags, prjflags = 0;
         xfs_dquot_t     *unresudq, *unresgdq, *delblksudq, *delblksgdq;
+        int             error;
+
 
         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
-        mp = ip->i_mount;
         ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 
         delblks = ip->i_delayed_blks;
@@ -2582,28 +2573,23 @@ xfs_qm_vop_chown_reserve(
 
 int
 xfs_qm_vop_rename_dqattach(
-        xfs_inode_t     **i_tab)
+        struct xfs_inode        **i_tab)
 {
-        xfs_inode_t     *ip;
-        int             i;
-        int             error;
+        struct xfs_mount        *mp = i_tab[0]->i_mount;
+        int                     i;
 
-        ip = i_tab[0];
-
-        if (! XFS_IS_QUOTA_ON(ip->i_mount))
+        if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
                 return 0;
 
-        if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
-                error = xfs_qm_dqattach(ip, 0);
-                if (error)
-                        return error;
-        }
-        for (i = 1; (i < 4 && i_tab[i]); i++) {
+        for (i = 0; (i < 4 && i_tab[i]); i++) {
+                struct xfs_inode        *ip = i_tab[i];
+                int                     error;
+
                 /*
                  * Watch out for duplicate entries in the table.
                  */
-                if ((ip = i_tab[i]) != i_tab[i-1]) {
-                        if (XFS_NOT_DQATTACHED(ip->i_mount, ip)) {
+                if (i == 0 || ip != i_tab[i-1]) {
+                        if (XFS_NOT_DQATTACHED(mp, ip)) {
                                 error = xfs_qm_dqattach(ip, 0);
                                 if (error)
                                         return error;
@@ -2614,17 +2600,19 @@ xfs_qm_vop_rename_dqattach(
 }
 
 void
-xfs_qm_vop_dqattach_and_dqmod_newinode(
-        xfs_trans_t     *tp,
-        xfs_inode_t     *ip,
-        xfs_dquot_t     *udqp,
-        xfs_dquot_t     *gdqp)
+xfs_qm_vop_create_dqattach(
+        struct xfs_trans        *tp,
+        struct xfs_inode        *ip,
+        struct xfs_dquot        *udqp,
+        struct xfs_dquot        *gdqp)
 {
-        if (!XFS_IS_QUOTA_ON(tp->t_mountp))
+        struct xfs_mount        *mp = tp->t_mountp;
+
+        if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
                 return;
 
         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
-        ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp));
+        ASSERT(XFS_IS_QUOTA_RUNNING(mp));
 
         if (udqp) {
                 xfs_dqlock(udqp);
@@ -2632,7 +2620,7 @@ xfs_qm_vop_dqattach_and_dqmod_newinode(
                 xfs_dqunlock(udqp);
                 ASSERT(ip->i_udquot == NULL);
                 ip->i_udquot = udqp;
-                ASSERT(XFS_IS_UQUOTA_ON(tp->t_mountp));
+                ASSERT(XFS_IS_UQUOTA_ON(mp));
                 ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
                 xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
         }
@@ -2642,8 +2630,8 @@ xfs_qm_vop_dqattach_and_dqmod_newinode(
                 xfs_dqunlock(gdqp);
                 ASSERT(ip->i_gdquot == NULL);
                 ip->i_gdquot = gdqp;
-                ASSERT(XFS_IS_OQUOTA_ON(tp->t_mountp));
-                ASSERT((XFS_IS_GQUOTA_ON(tp->t_mountp) ?
+                ASSERT(XFS_IS_OQUOTA_ON(mp));
+                ASSERT((XFS_IS_GQUOTA_ON(mp) ?
                         ip->i_d.di_gid : ip->i_d.di_projid) ==
                                 be32_to_cpu(gdqp->q_core.d_id));
                 xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
diff --git a/fs/xfs/quota/xfs_qm.h b/fs/xfs/quota/xfs_qm.h
index a371954cae1b..495564b8af38 100644
--- a/fs/xfs/quota/xfs_qm.h
+++ b/fs/xfs/quota/xfs_qm.h
@@ -127,8 +127,6 @@ typedef struct xfs_quotainfo {
 } xfs_quotainfo_t;
 
 
-extern xfs_dqtrxops_t   xfs_trans_dquot_ops;
-
 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);
@@ -159,17 +157,11 @@ typedef struct xfs_dquot_acct {
 #define XFS_QM_RTBWARNLIMIT     5
 
 extern void             xfs_qm_destroy_quotainfo(xfs_mount_t *);
-extern void             xfs_qm_mount_quotas(xfs_mount_t *);
 extern int              xfs_qm_quotacheck(xfs_mount_t *);
-extern void             xfs_qm_unmount_quotadestroy(xfs_mount_t *);
-extern void             xfs_qm_unmount_quotas(xfs_mount_t *);
 extern int              xfs_qm_write_sb_changes(xfs_mount_t *, __int64_t);
-extern int              xfs_qm_sync(xfs_mount_t *, int);
 
 /* dquot stuff */
 extern boolean_t        xfs_qm_dqalloc_incore(xfs_dquot_t **);
-extern int              xfs_qm_dqattach(xfs_inode_t *, uint);
-extern void             xfs_qm_dqdetach(xfs_inode_t *);
 extern int              xfs_qm_dqpurge_all(xfs_mount_t *, uint);
 extern void             xfs_qm_dqrele_all_inodes(xfs_mount_t *, uint);
 
@@ -183,19 +175,6 @@ 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);
 
-/* vop stuff */
-extern int              xfs_qm_vop_dqalloc(xfs_mount_t *, xfs_inode_t *,
-                                        uid_t, gid_t, prid_t, uint,
-                                        xfs_dquot_t **, xfs_dquot_t **);
-extern void             xfs_qm_vop_dqattach_and_dqmod_newinode(
-                                        xfs_trans_t *, xfs_inode_t *,
-                                        xfs_dquot_t *, xfs_dquot_t *);
-extern int              xfs_qm_vop_rename_dqattach(xfs_inode_t **);
-extern xfs_dquot_t *    xfs_qm_vop_chown(xfs_trans_t *, xfs_inode_t *,
-                                        xfs_dquot_t **, xfs_dquot_t *);
-extern int              xfs_qm_vop_chown_reserve(xfs_trans_t *, xfs_inode_t *,
-                                        xfs_dquot_t *, xfs_dquot_t *, uint);
-
 /* list stuff */
 extern void             xfs_qm_freelist_append(xfs_frlist_t *, xfs_dquot_t *);
 extern void             xfs_qm_freelist_unlink(xfs_dquot_t *);
diff --git a/fs/xfs/quota/xfs_qm_bhv.c b/fs/xfs/quota/xfs_qm_bhv.c
index 63037c689a4b..a5346630dfae 100644
--- a/fs/xfs/quota/xfs_qm_bhv.c
+++ b/fs/xfs/quota/xfs_qm_bhv.c
@@ -42,7 +42,6 @@
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_rw.h"
-#include "xfs_acl.h"
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_qm.h"
@@ -84,7 +83,7 @@ xfs_fill_statvfs_from_dquot(
  * return a statvfs of the project, not the entire filesystem.
  * This makes such trees appear as if they are filesystems in themselves.
  */
-STATIC void
+void
 xfs_qm_statvfs(
         xfs_inode_t             *ip,
         struct kstatfs          *statp)
@@ -92,20 +91,13 @@ xfs_qm_statvfs(
         xfs_mount_t             *mp = ip->i_mount;
         xfs_dquot_t             *dqp;
 
-        if (!(ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) ||
-            !((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))) ==
-                              (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))
-                return;
-
         if (!xfs_qm_dqget(mp, NULL, ip->i_d.di_projid, XFS_DQ_PROJ, 0, &dqp)) {
-                xfs_disk_dquot_t        *dp = &dqp->q_core;
-
-                xfs_fill_statvfs_from_dquot(statp, dp);
+                xfs_fill_statvfs_from_dquot(statp, &dqp->q_core);
                 xfs_qm_dqput(dqp);
         }
 }
 
-STATIC int
+int
 xfs_qm_newmount(
         xfs_mount_t     *mp,
         uint            *needquotamount,
@@ -114,9 +106,6 @@ xfs_qm_newmount(
         uint            quotaondisk;
         uint            uquotaondisk = 0, gquotaondisk = 0, pquotaondisk = 0;
 
-        *quotaflags = 0;
-        *needquotamount = B_FALSE;
-
         quotaondisk = xfs_sb_version_hasquota(&mp->m_sb) &&
                                 (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT);
 
@@ -179,66 +168,6 @@ xfs_qm_newmount(
         return 0;
 }
 
-STATIC int
-xfs_qm_endmount(
-        xfs_mount_t     *mp,
-        uint            needquotamount,
-        uint            quotaflags)
-{
-        if (needquotamount) {
-                ASSERT(mp->m_qflags == 0);
-                mp->m_qflags = quotaflags;
-                xfs_qm_mount_quotas(mp);
-        }
-
-#if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
-        if (! (XFS_IS_QUOTA_ON(mp)))
-                xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas not turned on");
-        else
-                xfs_fs_cmn_err(CE_NOTE, mp, "Disk quotas turned on");
-#endif
-
-#ifdef QUOTADEBUG
-        if (XFS_IS_QUOTA_ON(mp) && xfs_qm_internalqcheck(mp))
-                cmn_err(CE_WARN, "XFS: mount internalqcheck failed");
-#endif
-
-        return 0;
-}
-
-STATIC void
-xfs_qm_dqrele_null(
-        xfs_dquot_t     *dq)
-{
-        /*
-         * Called from XFS, where we always check first for a NULL dquot.
-         */
-        if (!dq)
-                return;
-        xfs_qm_dqrele(dq);
-}
-
-
-struct xfs_qmops xfs_qmcore_xfs = {
-        .xfs_qminit             = xfs_qm_newmount,
-        .xfs_qmdone             = xfs_qm_unmount_quotadestroy,
-        .xfs_qmmount            = xfs_qm_endmount,
-        .xfs_qmunmount          = xfs_qm_unmount_quotas,
-        .xfs_dqrele             = xfs_qm_dqrele_null,
-        .xfs_dqattach           = xfs_qm_dqattach,
-        .xfs_dqdetach           = xfs_qm_dqdetach,
-        .xfs_dqpurgeall         = xfs_qm_dqpurge_all,
-        .xfs_dqvopalloc         = xfs_qm_vop_dqalloc,
-        .xfs_dqvopcreate        = xfs_qm_vop_dqattach_and_dqmod_newinode,
-        .xfs_dqvoprename        = xfs_qm_vop_rename_dqattach,
-        .xfs_dqvopchown         = xfs_qm_vop_chown,
-        .xfs_dqvopchownresv     = xfs_qm_vop_chown_reserve,
-        .xfs_dqstatvfs          = xfs_qm_statvfs,
-        .xfs_dqsync             = xfs_qm_sync,
-        .xfs_dqtrxops           = &xfs_trans_dquot_ops,
-};
-EXPORT_SYMBOL(xfs_qmcore_xfs);
-
 void __init
 xfs_qm_init(void)
 {
diff --git a/fs/xfs/quota/xfs_qm_stats.c b/fs/xfs/quota/xfs_qm_stats.c
index 709f5f545cf5..21b08c0396a1 100644
--- a/fs/xfs/quota/xfs_qm_stats.c
+++ b/fs/xfs/quota/xfs_qm_stats.c
@@ -42,7 +42,6 @@
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_rw.h"
-#include "xfs_acl.h"
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_qm.h"
diff --git a/fs/xfs/quota/xfs_qm_syscalls.c b/fs/xfs/quota/xfs_qm_syscalls.c
index c7b66f6506ce..4e4276b956e8 100644
--- a/fs/xfs/quota/xfs_qm_syscalls.c
+++ b/fs/xfs/quota/xfs_qm_syscalls.c
@@ -45,7 +45,6 @@
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_rw.h"
-#include "xfs_acl.h"
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_utils.h"
@@ -847,105 +846,55 @@ xfs_qm_export_flags(
 }
 
 
-/*
- * Release all the dquots on the inodes in an AG.
- */
-STATIC void
-xfs_qm_dqrele_inodes_ag(
-        xfs_mount_t     *mp,
-        int             ag,
-        uint            flags)
+STATIC int
+xfs_dqrele_inode(
+        struct xfs_inode        *ip,
+        struct xfs_perag        *pag,
+        int                     flags)
 {
-        xfs_inode_t     *ip = NULL;
-        xfs_perag_t     *pag = &mp->m_perag[ag];
-        int             first_index = 0;
-        int             nr_found;
-
-        do {
-                /*
-                 * use a gang lookup to find the next inode in the tree
-                 * as the tree is sparse and a gang lookup walks to find
-                 * the number of objects requested.
-                 */
-                read_lock(&pag->pag_ici_lock);
-                nr_found = radix_tree_gang_lookup(&pag->pag_ici_root,
-                                (void**)&ip, first_index, 1);
-
-                if (!nr_found) {
-                        read_unlock(&pag->pag_ici_lock);
-                        break;
-                }
-
-                /*
-                 * Update the index for the next lookup. Catch overflows
-                 * into the next AG range which can occur if we have inodes
-                 * in the last block of the AG and we are currently
-                 * pointing to the last inode.
-                 */
-                first_index = XFS_INO_TO_AGINO(mp, ip->i_ino + 1);
-                if (first_index < XFS_INO_TO_AGINO(mp, ip->i_ino)) {
-                        read_unlock(&pag->pag_ici_lock);
-                        break;
-                }
-
-                /* skip quota inodes */
-                if (ip == XFS_QI_UQIP(mp) || ip == XFS_QI_GQIP(mp)) {
-                        ASSERT(ip->i_udquot == NULL);
-                        ASSERT(ip->i_gdquot == NULL);
-                        read_unlock(&pag->pag_ici_lock);
-                        continue;
-                }
+        int                     error;
 
-                /*
-                 * If we can't get a reference on the inode, it must be
-                 * in reclaim. Leave it for the reclaim code to flush.
-                 */
-                if (!igrab(VFS_I(ip))) {
-                        read_unlock(&pag->pag_ici_lock);
-                        continue;
-                }
+        /* skip quota inodes */
+        if (ip == XFS_QI_UQIP(ip->i_mount) || ip == XFS_QI_GQIP(ip->i_mount)) {
+                ASSERT(ip->i_udquot == NULL);
+                ASSERT(ip->i_gdquot == NULL);
                 read_unlock(&pag->pag_ici_lock);
+                return 0;
+        }
 
-                /* avoid new inodes though we shouldn't find any here */
-                if (xfs_iflags_test(ip, XFS_INEW)) {
-                        IRELE(ip);
-                        continue;
-                }
+        error = xfs_sync_inode_valid(ip, pag);
+        if (error)
+                return error;
 
-                xfs_ilock(ip, XFS_ILOCK_EXCL);
-                if ((flags & XFS_UQUOTA_ACCT) && ip->i_udquot) {
-                        xfs_qm_dqrele(ip->i_udquot);
-                        ip->i_udquot = NULL;
-                }
-                if (flags & (XFS_PQUOTA_ACCT|XFS_GQUOTA_ACCT) &&
-                    ip->i_gdquot) {
-                        xfs_qm_dqrele(ip->i_gdquot);
-                        ip->i_gdquot = NULL;
-                }
-                xfs_iput(ip, XFS_ILOCK_EXCL);
+        xfs_ilock(ip, XFS_ILOCK_EXCL);
+        if ((flags & XFS_UQUOTA_ACCT) && ip->i_udquot) {
+                xfs_qm_dqrele(ip->i_udquot);
+                ip->i_udquot = NULL;
+        }
+        if (flags & (XFS_PQUOTA_ACCT|XFS_GQUOTA_ACCT) && ip->i_gdquot) {
+                xfs_qm_dqrele(ip->i_gdquot);
+                ip->i_gdquot = NULL;
+        }
+        xfs_iput(ip, XFS_ILOCK_EXCL);
+        IRELE(ip);
 
-        } while (nr_found);
+        return 0;
 }
 
+
 /*
  * Go thru all the inodes in the file system, releasing their dquots.
+ *
  * Note that the mount structure gets modified to indicate that quotas are off
- * AFTER this, in the case of quotaoff. This also gets called from
- * xfs_rootumount.
+ * AFTER this, in the case of quotaoff.
  */
 void
 xfs_qm_dqrele_all_inodes(
         struct xfs_mount *mp,
         uint             flags)
 {
-        int             i;
-
         ASSERT(mp->m_quotainfo);
-        for (i = 0; i < mp->m_sb.sb_agcount; i++) {
-                if (!mp->m_perag[i].pag_ici_init)
-                        continue;
-                xfs_qm_dqrele_inodes_ag(mp, i, flags);
-        }
+        xfs_inode_ag_iterator(mp, xfs_dqrele_inode, flags, XFS_ICI_NO_TAG);
 }
 
 /*------------------------------------------------------------------------*/
diff --git a/fs/xfs/quota/xfs_trans_dquot.c b/fs/xfs/quota/xfs_trans_dquot.c
index 447173bcf96d..97ac9640be98 100644
--- a/fs/xfs/quota/xfs_trans_dquot.c
+++ b/fs/xfs/quota/xfs_trans_dquot.c
@@ -42,7 +42,6 @@
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_rw.h"
-#include "xfs_acl.h"
 #include "xfs_attr.h"
 #include "xfs_buf_item.h"
 #include "xfs_trans_priv.h"
@@ -111,7 +110,7 @@ xfs_trans_log_dquot(
  * Carry forward whatever is left of the quota blk reservation to
  * the spanky new transaction
  */
-STATIC void
+void
 xfs_trans_dup_dqinfo(
         xfs_trans_t     *otp,
         xfs_trans_t     *ntp)
@@ -167,19 +166,17 @@ xfs_trans_dup_dqinfo(
 /*
  * Wrap around mod_dquot to account for both user and group quotas.
  */
-STATIC void
+void
 xfs_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;
+        xfs_mount_t     *mp = tp->t_mountp;
 
-        if (!XFS_IS_QUOTA_ON(mp) ||
+        if (!XFS_IS_QUOTA_RUNNING(mp) ||
+            !XFS_IS_QUOTA_ON(mp) ||
             ip->i_ino == mp->m_sb.sb_uquotino ||
             ip->i_ino == mp->m_sb.sb_gquotino)
                 return;
@@ -229,6 +226,7 @@ xfs_trans_mod_dquot(
         xfs_dqtrx_t     *qtrx;
 
         ASSERT(tp);
+        ASSERT(XFS_IS_QUOTA_RUNNING(tp->t_mountp));
         qtrx = NULL;
 
         if (tp->t_dqinfo == NULL)
@@ -346,7 +344,7 @@ xfs_trans_dqlockedjoin(
  * Unreserve just the reservations done by this transaction.
  * dquot is still left locked at exit.
  */
-STATIC void
+void
 xfs_trans_apply_dquot_deltas(
         xfs_trans_t             *tp)
 {
@@ -357,7 +355,7 @@ xfs_trans_apply_dquot_deltas(
         long                    totalbdelta;
         long                    totalrtbdelta;
 
-        if (! (tp->t_flags & XFS_TRANS_DQ_DIRTY))
+        if (!(tp->t_flags & XFS_TRANS_DQ_DIRTY))
                 return;
 
         ASSERT(tp->t_dqinfo);
@@ -531,7 +529,7 @@ xfs_trans_apply_dquot_deltas(
  * we simply throw those away, since that's the expected behavior
  * when a transaction is curtailed without a commit.
  */
-STATIC void
+void
 xfs_trans_unreserve_and_mod_dquots(
         xfs_trans_t             *tp)
 {
@@ -768,7 +766,7 @@ xfs_trans_reserve_quota_bydquots(
 {
         int             resvd = 0, error;
 
-        if (!XFS_IS_QUOTA_ON(mp))
+        if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
                 return 0;
 
         if (tp && tp->t_dqinfo == NULL)
@@ -811,18 +809,17 @@ xfs_trans_reserve_quota_bydquots(
  * This doesn't change the actual usage, just the reservation.
  * The inode sent in is locked.
  */
-STATIC int
+int
 xfs_trans_reserve_quota_nblks(
-        xfs_trans_t     *tp,
-        xfs_mount_t     *mp,
-        xfs_inode_t     *ip,
-        long            nblks,
-        long            ninos,
-        uint            flags)
+        struct xfs_trans        *tp,
+        struct xfs_inode        *ip,
+        long                    nblks,
+        long                    ninos,
+        uint                    flags)
 {
-        int             error;
+        struct xfs_mount        *mp = ip->i_mount;
 
-        if (!XFS_IS_QUOTA_ON(mp))
+        if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
                 return 0;
         if (XFS_IS_PQUOTA_ON(mp))
                 flags |= XFS_QMOPT_ENOSPC;
@@ -831,7 +828,6 @@ xfs_trans_reserve_quota_nblks(
         ASSERT(ip->i_ino != mp->m_sb.sb_gquotino);
 
         ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
-        ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));
         ASSERT((flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
                                 XFS_TRANS_DQ_RES_RTBLKS ||
                (flags & ~(XFS_QMOPT_FORCE_RES | XFS_QMOPT_ENOSPC)) ==
@@ -840,11 +836,9 @@ xfs_trans_reserve_quota_nblks(
         /*
          * Reserve nblks against these dquots, with trans as the mediator.
          */
-        error = xfs_trans_reserve_quota_bydquots(tp, mp,
-                                                 ip->i_udquot, ip->i_gdquot,
-                                                 nblks, ninos,
-                                                 flags);
-        return error;
+        return xfs_trans_reserve_quota_bydquots(tp, mp,
+                                                ip->i_udquot, ip->i_gdquot,
+                                                nblks, ninos, flags);
 }
 
 /*
@@ -895,25 +889,15 @@ STATIC void
 xfs_trans_alloc_dqinfo(
         xfs_trans_t     *tp)
 {
-        (tp)->t_dqinfo = kmem_zone_zalloc(xfs_Gqm->qm_dqtrxzone, KM_SLEEP);
+        tp->t_dqinfo = kmem_zone_zalloc(xfs_Gqm->qm_dqtrxzone, KM_SLEEP);
 }
 
-STATIC void
+void
 xfs_trans_free_dqinfo(
         xfs_trans_t     *tp)
 {
         if (!tp->t_dqinfo)
                 return;
-        kmem_zone_free(xfs_Gqm->qm_dqtrxzone, (tp)->t_dqinfo);
-        (tp)->t_dqinfo = NULL;
+        kmem_zone_free(xfs_Gqm->qm_dqtrxzone, tp->t_dqinfo);
+        tp->t_dqinfo = NULL;
 }
-
-xfs_dqtrxops_t  xfs_trans_dquot_ops = {
-        .qo_dup_dqinfo                  = xfs_trans_dup_dqinfo,
-        .qo_free_dqinfo                 = xfs_trans_free_dqinfo,
-        .qo_mod_dquot_byino             = xfs_trans_mod_dquot_byino,
-        .qo_apply_dquot_deltas          = xfs_trans_apply_dquot_deltas,
-        .qo_reserve_quota_nblks         = xfs_trans_reserve_quota_nblks,
-        .qo_reserve_quota_bydquots      = xfs_trans_reserve_quota_bydquots,
-        .qo_unreserve_and_mod_dquots    = xfs_trans_unreserve_and_mod_dquots,
-};