7 files changed, 61 insertions, 292 deletions

diff --git a/fs/xfs/quota/xfs_dquot.c b/fs/xfs/quota/xfs_dquot.c
index 6543c0b29753..e4babcc63423 100644
--- a/fs/xfs/quota/xfs_dquot.c
+++ b/fs/xfs/quota/xfs_dquot.c
@@ -804,7 +804,7 @@ xfs_qm_dqlookup(
         uint                    flist_locked;
         xfs_dquot_t             *d;
 
-        ASSERT(XFS_DQ_IS_HASH_LOCKED(qh));
+        ASSERT(mutex_is_locked(&qh->qh_lock));
 
         flist_locked = B_FALSE;
 
@@ -877,7 +877,7 @@ xfs_qm_dqlookup(
                         /*
                          * move the dquot to the front of the hashchain
                          */
-                        ASSERT(XFS_DQ_IS_HASH_LOCKED(qh));
+                        ASSERT(mutex_is_locked(&qh->qh_lock));
                         if (dqp->HL_PREVP != &qh->qh_next) {
                                 xfs_dqtrace_entry(dqp,
                                                   "DQLOOKUP: HASH MOVETOFRONT");
@@ -892,13 +892,13 @@ xfs_qm_dqlookup(
                         }
                         xfs_dqtrace_entry(dqp, "LOOKUP END");
                         *O_dqpp = dqp;
-                        ASSERT(XFS_DQ_IS_HASH_LOCKED(qh));
+                        ASSERT(mutex_is_locked(&qh->qh_lock));
                         return (0);
                 }
         }
 
         *O_dqpp = NULL;
-        ASSERT(XFS_DQ_IS_HASH_LOCKED(qh));
+        ASSERT(mutex_is_locked(&qh->qh_lock));
         return (1);
 }
 
@@ -956,7 +956,7 @@ xfs_qm_dqget(
                         ASSERT(ip->i_gdquot == NULL);
         }
 #endif
-        XFS_DQ_HASH_LOCK(h);
+        mutex_lock(&h->qh_lock);
 
         /*
          * Look in the cache (hashtable).
@@ -971,7 +971,7 @@ xfs_qm_dqget(
                  */
                 ASSERT(*O_dqpp);
                 ASSERT(XFS_DQ_IS_LOCKED(*O_dqpp));
-                XFS_DQ_HASH_UNLOCK(h);
+                mutex_unlock(&h->qh_lock);
                 xfs_dqtrace_entry(*O_dqpp, "DQGET DONE (FROM CACHE)");
                 return (0);     /* success */
         }
@@ -991,7 +991,7 @@ xfs_qm_dqget(
          * we don't keep the lock across a disk read
          */
         version = h->qh_version;
-        XFS_DQ_HASH_UNLOCK(h);
+        mutex_unlock(&h->qh_lock);
 
         /*
          * Allocate the dquot on the kernel heap, and read the ondisk
@@ -1056,7 +1056,7 @@ xfs_qm_dqget(
         /*
          * Hashlock comes after ilock in lock order
          */
-        XFS_DQ_HASH_LOCK(h);
+        mutex_lock(&h->qh_lock);
         if (version != h->qh_version) {
                 xfs_dquot_t *tmpdqp;
                 /*
@@ -1072,7 +1072,7 @@ xfs_qm_dqget(
                          * and start over.
                          */
                         xfs_qm_dqput(tmpdqp);
-                        XFS_DQ_HASH_UNLOCK(h);
+                        mutex_unlock(&h->qh_lock);
                         xfs_qm_dqdestroy(dqp);
                         XQM_STATS_INC(xqmstats.xs_qm_dquot_dups);
                         goto again;
@@ -1083,7 +1083,7 @@ xfs_qm_dqget(
          * Put the dquot at the beginning of the hash-chain and mp's list
          * LOCK ORDER: hashlock, freelistlock, mplistlock, udqlock, gdqlock ..
          */
-        ASSERT(XFS_DQ_IS_HASH_LOCKED(h));
+        ASSERT(mutex_is_locked(&h->qh_lock));
         dqp->q_hash = h;
         XQM_HASHLIST_INSERT(h, dqp);
 
@@ -1102,7 +1102,7 @@ xfs_qm_dqget(
         XQM_MPLIST_INSERT(&(XFS_QI_MPL_LIST(mp)), dqp);
 
         xfs_qm_mplist_unlock(mp);
-        XFS_DQ_HASH_UNLOCK(h);
+        mutex_unlock(&h->qh_lock);
  dqret:
         ASSERT((ip == NULL) || xfs_isilocked(ip, XFS_ILOCK_EXCL));
         xfs_dqtrace_entry(dqp, "DQGET DONE");
@@ -1440,7 +1440,7 @@ xfs_qm_dqpurge(
         xfs_mount_t     *mp = dqp->q_mount;
 
         ASSERT(XFS_QM_IS_MPLIST_LOCKED(mp));
-        ASSERT(XFS_DQ_IS_HASH_LOCKED(dqp->q_hash));
+        ASSERT(mutex_is_locked(&dqp->q_hash->qh_lock));
 
         xfs_dqlock(dqp);
         /*
@@ -1453,7 +1453,7 @@ xfs_qm_dqpurge(
          */
         if (dqp->q_nrefs != 0) {
                 xfs_dqunlock(dqp);
-                XFS_DQ_HASH_UNLOCK(dqp->q_hash);
+                mutex_unlock(&dqp->q_hash->qh_lock);
                 return (1);
         }
 
@@ -1517,7 +1517,7 @@ xfs_qm_dqpurge(
         memset(&dqp->q_core, 0, sizeof(dqp->q_core));
         xfs_dqfunlock(dqp);
         xfs_dqunlock(dqp);
-        XFS_DQ_HASH_UNLOCK(thishash);
+        mutex_unlock(&thishash->qh_lock);
         return (0);
 }
 
diff --git a/fs/xfs/quota/xfs_dquot.h b/fs/xfs/quota/xfs_dquot.h
index d443e93b4331..d1f726e0e5a4 100644
--- a/fs/xfs/quota/xfs_dquot.h
+++ b/fs/xfs/quota/xfs_dquot.h
@@ -109,19 +109,6 @@ enum {
 
 #define XFS_DQHOLD(dqp)         ((dqp)->q_nrefs++)
 
-#ifdef DEBUG
-static inline int
-XFS_DQ_IS_LOCKED(xfs_dquot_t *dqp)
-{
-        if (mutex_trylock(&dqp->q_qlock)) {
-                mutex_unlock(&dqp->q_qlock);
-                return 0;
-        }
-        return 1;
-}
-#endif
-
-
 /*
  * Manage the q_flush completion queue embedded in the dquot.  This completion
  * queue synchronizes processes attempting to flush the in-core dquot back to
@@ -142,6 +129,7 @@ static inline void xfs_dqfunlock(xfs_dquot_t *dqp)
         complete(&dqp->q_flush);
 }
 
+#define XFS_DQ_IS_LOCKED(dqp)   (mutex_is_locked(&((dqp)->q_qlock)))
 #define XFS_DQ_IS_ON_FREELIST(dqp)  ((dqp)->dq_flnext != (dqp))
 #define XFS_DQ_IS_DIRTY(dqp)    ((dqp)->dq_flags & XFS_DQ_DIRTY)
 #define XFS_QM_ISUDQ(dqp)       ((dqp)->dq_flags & XFS_DQ_USER)
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index fd0b383d72a5..11d0a4f89a0e 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -69,8 +69,6 @@ STATIC void	xfs_qm_list_destroy(xfs_dqlist_t *);
 
 STATIC void     xfs_qm_freelist_init(xfs_frlist_t *);
 STATIC void     xfs_qm_freelist_destroy(xfs_frlist_t *);
-STATIC int      xfs_qm_mplist_nowait(xfs_mount_t *);
-STATIC int      xfs_qm_dqhashlock_nowait(xfs_dquot_t *);
 
 STATIC int      xfs_qm_init_quotainos(xfs_mount_t *);
 STATIC int      xfs_qm_init_quotainfo(xfs_mount_t *);
@@ -219,7 +217,7 @@ xfs_qm_hold_quotafs_ref(
          * the structure could disappear between the entry to this routine and
          * a HOLD operation if not locked.
          */
-        XFS_QM_LOCK(xfs_Gqm);
+        mutex_lock(&xfs_Gqm_lock);
 
         if (xfs_Gqm == NULL)
                 xfs_Gqm = xfs_Gqm_init();
@@ -228,8 +226,8 @@ xfs_qm_hold_quotafs_ref(
          * debugging and statistical purposes, but ...
          * Just take a reference and get out.
          */
-        XFS_QM_HOLD(xfs_Gqm);
-        XFS_QM_UNLOCK(xfs_Gqm);
+        xfs_Gqm->qm_nrefs++;
+        mutex_unlock(&xfs_Gqm_lock);
 
         return 0;
 }
@@ -277,13 +275,12 @@ xfs_qm_rele_quotafs_ref(
          * Destroy the entire XQM. If somebody mounts with quotaon, this'll
          * be restarted.
          */
-        XFS_QM_LOCK(xfs_Gqm);
-        XFS_QM_RELE(xfs_Gqm);
-        if (xfs_Gqm->qm_nrefs == 0) {
+        mutex_lock(&xfs_Gqm_lock);
+        if (--xfs_Gqm->qm_nrefs == 0) {
                 xfs_qm_destroy(xfs_Gqm);
                 xfs_Gqm = NULL;
         }
-        XFS_QM_UNLOCK(xfs_Gqm);
+        mutex_unlock(&xfs_Gqm_lock);
 }
 
 /*
@@ -577,10 +574,10 @@ xfs_qm_dqpurge_int(
                         continue;
                 }
 
-                if (! xfs_qm_dqhashlock_nowait(dqp)) {
+                if (!mutex_trylock(&dqp->q_hash->qh_lock)) {
                         nrecl = XFS_QI_MPLRECLAIMS(mp);
                         xfs_qm_mplist_unlock(mp);
-                        XFS_DQ_HASH_LOCK(dqp->q_hash);
+                        mutex_lock(&dqp->q_hash->qh_lock);
                         xfs_qm_mplist_lock(mp);
 
                         /*
@@ -590,7 +587,7 @@ xfs_qm_dqpurge_int(
                          * this point, but somebody might be taking things off.
                          */
                         if (nrecl != XFS_QI_MPLRECLAIMS(mp)) {
-                                XFS_DQ_HASH_UNLOCK(dqp->q_hash);
+                                mutex_unlock(&dqp->q_hash->qh_lock);
                                 goto again;
                         }
                 }
@@ -2028,7 +2025,7 @@ xfs_qm_shake_freelist(
                  * a dqlookup process that holds the hashlock that is
                  * waiting for the freelist lock.
                  */
-                if (! xfs_qm_dqhashlock_nowait(dqp)) {
+                if (!mutex_trylock(&dqp->q_hash->qh_lock)) {
                         xfs_dqfunlock(dqp);
                         xfs_dqunlock(dqp);
                         dqp = dqp->dq_flnext;
@@ -2045,7 +2042,7 @@ xfs_qm_shake_freelist(
                         /* XXX put a sentinel so that we can come back here */
                         xfs_dqfunlock(dqp);
                         xfs_dqunlock(dqp);
-                        XFS_DQ_HASH_UNLOCK(hash);
+                        mutex_unlock(&hash->qh_lock);
                         xfs_qm_freelist_unlock(xfs_Gqm);
                         if (++restarts >= XFS_QM_RECLAIM_MAX_RESTARTS)
                                 return nreclaimed;
@@ -2062,7 +2059,7 @@ xfs_qm_shake_freelist(
                 XQM_HASHLIST_REMOVE(hash, dqp);
                 xfs_dqfunlock(dqp);
                 xfs_qm_mplist_unlock(dqp->q_mount);
-                XFS_DQ_HASH_UNLOCK(hash);
+                mutex_unlock(&hash->qh_lock);
 
  off_freelist:
                 XQM_FREELIST_REMOVE(dqp);
@@ -2204,7 +2201,7 @@ xfs_qm_dqreclaim_one(void)
                         continue;
                 }
 
-                if (! xfs_qm_dqhashlock_nowait(dqp))
+                if (!mutex_trylock(&dqp->q_hash->qh_lock))
                         goto mplistunlock;
 
                 ASSERT(dqp->q_nrefs == 0);
@@ -2213,7 +2210,7 @@ xfs_qm_dqreclaim_one(void)
                 XQM_HASHLIST_REMOVE(dqp->q_hash, dqp);
                 XQM_FREELIST_REMOVE(dqp);
                 dqpout = dqp;
-                XFS_DQ_HASH_UNLOCK(dqp->q_hash);
+                mutex_unlock(&dqp->q_hash->qh_lock);
  mplistunlock:
                 xfs_qm_mplist_unlock(dqp->q_mount);
                 xfs_dqfunlock(dqp);
@@ -2716,34 +2713,3 @@ xfs_qm_freelist_append(xfs_frlist_t *ql, xfs_dquot_t *dq)
 {
         xfs_qm_freelist_insert((xfs_frlist_t *)ql->qh_prev, dq);
 }
-
-STATIC int
-xfs_qm_dqhashlock_nowait(
-        xfs_dquot_t *dqp)
-{
-        int locked;
-
-        locked = mutex_trylock(&((dqp)->q_hash->qh_lock));
-        return locked;
-}
-
-int
-xfs_qm_freelist_lock_nowait(
-        xfs_qm_t *xqm)
-{
-        int locked;
-
-        locked = mutex_trylock(&(xqm->qm_dqfreelist.qh_lock));
-        return locked;
-}
-
-STATIC int
-xfs_qm_mplist_nowait(
-        xfs_mount_t     *mp)
-{
-        int locked;
-
-        ASSERT(mp->m_quotainfo);
-        locked = mutex_trylock(&(XFS_QI_MPLLOCK(mp)));
-        return locked;
-}
diff --git a/fs/xfs/quota/xfs_qm.h b/fs/xfs/quota/xfs_qm.h
index ddf09166387c..933df4204fc7 100644
--- a/fs/xfs/quota/xfs_qm.h
+++ b/fs/xfs/quota/xfs_qm.h
@@ -158,11 +158,6 @@ typedef struct xfs_dquot_acct {
 #define XFS_QM_IWARNLIMIT       5
 #define XFS_QM_RTBWARNLIMIT     5
 
-#define XFS_QM_LOCK(xqm)        (mutex_lock(&xqm##_lock))
-#define XFS_QM_UNLOCK(xqm)      (mutex_unlock(&xqm##_lock))
-#define XFS_QM_HOLD(xqm)        ((xqm)->qm_nrefs++)
-#define XFS_QM_RELE(xqm)        ((xqm)->qm_nrefs--)
-
 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 *);
@@ -178,6 +173,16 @@ 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);
 
+/* 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_setqlim(xfs_mount_t *, 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);
+
 /* vop stuff */
 extern int              xfs_qm_vop_dqalloc(xfs_mount_t *, xfs_inode_t *,
                                         uid_t, gid_t, prid_t, uint,
@@ -194,11 +199,6 @@ extern int		xfs_qm_vop_chown_reserve(xfs_trans_t *, xfs_inode_t *,
 /* list stuff */
 extern void             xfs_qm_freelist_append(xfs_frlist_t *, xfs_dquot_t *);
 extern void             xfs_qm_freelist_unlink(xfs_dquot_t *);
-extern int              xfs_qm_freelist_lock_nowait(xfs_qm_t *);
-
-/* system call interface */
-extern int              xfs_qm_quotactl(struct xfs_mount *, int, int,
-                                xfs_caddr_t);
 
 #ifdef DEBUG
 extern int              xfs_qm_internalqcheck(xfs_mount_t *);
diff --git a/fs/xfs/quota/xfs_qm_bhv.c b/fs/xfs/quota/xfs_qm_bhv.c
index bc6c5cca3e12..63037c689a4b 100644
--- a/fs/xfs/quota/xfs_qm_bhv.c
+++ b/fs/xfs/quota/xfs_qm_bhv.c
@@ -235,7 +235,6 @@ struct xfs_qmops xfs_qmcore_xfs = {
         .xfs_dqvopchownresv     = xfs_qm_vop_chown_reserve,
         .xfs_dqstatvfs          = xfs_qm_statvfs,
         .xfs_dqsync             = xfs_qm_sync,
-        .xfs_quotactl           = xfs_qm_quotactl,
         .xfs_dqtrxops           = &xfs_trans_dquot_ops,
 };
 EXPORT_SYMBOL(xfs_qmcore_xfs);
diff --git a/fs/xfs/quota/xfs_qm_syscalls.c b/fs/xfs/quota/xfs_qm_syscalls.c
index 68139b38aede..b00c8d484aa9 100644
--- a/fs/xfs/quota/xfs_qm_syscalls.c
+++ b/fs/xfs/quota/xfs_qm_syscalls.c
@@ -57,135 +57,16 @@
 # define qdprintk(s, args...)   do { } while (0)
 #endif
 
-STATIC int      xfs_qm_scall_trunc_qfiles(xfs_mount_t *, uint);
-STATIC int      xfs_qm_scall_getquota(xfs_mount_t *, xfs_dqid_t, uint,
-                                        fs_disk_quota_t *);
-STATIC int      xfs_qm_scall_getqstat(xfs_mount_t *, fs_quota_stat_t *);
-STATIC int      xfs_qm_scall_setqlim(xfs_mount_t *, xfs_dqid_t, uint,
-                                        fs_disk_quota_t *);
-STATIC int      xfs_qm_scall_quotaon(xfs_mount_t *, uint);
-STATIC int      xfs_qm_scall_quotaoff(xfs_mount_t *, uint, boolean_t);
 STATIC int      xfs_qm_log_quotaoff(xfs_mount_t *, xfs_qoff_logitem_t **, uint);
 STATIC int      xfs_qm_log_quotaoff_end(xfs_mount_t *, xfs_qoff_logitem_t *,
                                         uint);
-STATIC uint     xfs_qm_import_flags(uint);
 STATIC uint     xfs_qm_export_flags(uint);
-STATIC uint     xfs_qm_import_qtype_flags(uint);
 STATIC uint     xfs_qm_export_qtype_flags(uint);
 STATIC void     xfs_qm_export_dquot(xfs_mount_t *, xfs_disk_dquot_t *,
                                         fs_disk_quota_t *);
 
 
 /*
- * The main distribution switch of all XFS quotactl system calls.
- */
-int
-xfs_qm_quotactl(
-        xfs_mount_t     *mp,
-        int             cmd,
-        int             id,
-        xfs_caddr_t     addr)
-{
-        int             error;
-
-        ASSERT(addr != NULL || cmd == Q_XQUOTASYNC);
-
-        /*
-         * The following commands are valid even when quotaoff.
-         */
-        switch (cmd) {
-        case Q_XQUOTARM:
-                /*
-                 * Truncate quota files. quota must be off.
-                 */
-                if (XFS_IS_QUOTA_ON(mp))
-                        return XFS_ERROR(EINVAL);
-                if (mp->m_flags & XFS_MOUNT_RDONLY)
-                        return XFS_ERROR(EROFS);
-                return (xfs_qm_scall_trunc_qfiles(mp,
-                               xfs_qm_import_qtype_flags(*(uint *)addr)));
-
-        case Q_XGETQSTAT:
-                /*
-                 * Get quota status information.
-                 */
-                return (xfs_qm_scall_getqstat(mp, (fs_quota_stat_t *)addr));
-
-        case Q_XQUOTAON:
-                /*
-                 * QUOTAON - enabling quota enforcement.
-                 * Quota accounting must be turned on at mount time.
-                 */
-                if (mp->m_flags & XFS_MOUNT_RDONLY)
-                        return XFS_ERROR(EROFS);
-                return (xfs_qm_scall_quotaon(mp,
-                                          xfs_qm_import_flags(*(uint *)addr)));
-
-        case Q_XQUOTAOFF:
-                if (mp->m_flags & XFS_MOUNT_RDONLY)
-                        return XFS_ERROR(EROFS);
-                break;
-
-        case Q_XQUOTASYNC:
-                return xfs_sync_inodes(mp, SYNC_DELWRI);
-
-        default:
-                break;
-        }
-
-        if (! XFS_IS_QUOTA_ON(mp))
-                return XFS_ERROR(ESRCH);
-
-        switch (cmd) {
-        case Q_XQUOTAOFF:
-                if (mp->m_flags & XFS_MOUNT_RDONLY)
-                        return XFS_ERROR(EROFS);
-                error = xfs_qm_scall_quotaoff(mp,
-                                            xfs_qm_import_flags(*(uint *)addr),
-                                            B_FALSE);
-                break;
-
-        case Q_XGETQUOTA:
-                error = xfs_qm_scall_getquota(mp, (xfs_dqid_t)id, XFS_DQ_USER,
-                                        (fs_disk_quota_t *)addr);
-                break;
-        case Q_XGETGQUOTA:
-                error = xfs_qm_scall_getquota(mp, (xfs_dqid_t)id, XFS_DQ_GROUP,
-                                        (fs_disk_quota_t *)addr);
-                break;
-        case Q_XGETPQUOTA:
-                error = xfs_qm_scall_getquota(mp, (xfs_dqid_t)id, XFS_DQ_PROJ,
-                                        (fs_disk_quota_t *)addr);
-                break;
-
-        case Q_XSETQLIM:
-                if (mp->m_flags & XFS_MOUNT_RDONLY)
-                        return XFS_ERROR(EROFS);
-                error = xfs_qm_scall_setqlim(mp, (xfs_dqid_t)id, XFS_DQ_USER,
-                                             (fs_disk_quota_t *)addr);
-                break;
-        case Q_XSETGQLIM:
-                if (mp->m_flags & XFS_MOUNT_RDONLY)
-                        return XFS_ERROR(EROFS);
-                error = xfs_qm_scall_setqlim(mp, (xfs_dqid_t)id, XFS_DQ_GROUP,
-                                             (fs_disk_quota_t *)addr);
-                break;
-        case Q_XSETPQLIM:
-                if (mp->m_flags & XFS_MOUNT_RDONLY)
-                        return XFS_ERROR(EROFS);
-                error = xfs_qm_scall_setqlim(mp, (xfs_dqid_t)id, XFS_DQ_PROJ,
-                                             (fs_disk_quota_t *)addr);
-                break;
-
-        default:
-                error = XFS_ERROR(EINVAL);
-                break;
-        }
-
-        return (error);
-}
-
-/*
  * Turn off quota accounting and/or enforcement for all udquots and/or
  * gdquots. Called only at unmount time.
  *
@@ -193,11 +74,10 @@ xfs_qm_quotactl(
  * incore, and modifies the ondisk dquot directly. Therefore, for example,
  * it is an error to call this twice, without purging the cache.
  */
-STATIC int
+int
 xfs_qm_scall_quotaoff(
         xfs_mount_t             *mp,
-        uint                    flags,
-        boolean_t               force)
+        uint                    flags)
 {
         uint                    dqtype;
         int                     error;
@@ -205,8 +85,6 @@ xfs_qm_scall_quotaoff(
         xfs_qoff_logitem_t      *qoffstart;
         int                     nculprits;
 
-        if (!force && !capable(CAP_SYS_ADMIN))
-                return XFS_ERROR(EPERM);
         /*
          * No file system can have quotas enabled on disk but not in core.
          * Note that quota utilities (like quotaoff) _expect_
@@ -375,7 +253,7 @@ out_error:
         return (error);
 }
 
-STATIC int
+int
 xfs_qm_scall_trunc_qfiles(
         xfs_mount_t     *mp,
         uint            flags)
@@ -383,8 +261,6 @@ xfs_qm_scall_trunc_qfiles(
         int             error = 0, error2 = 0;
         xfs_inode_t     *qip;
 
-        if (!capable(CAP_SYS_ADMIN))
-                return XFS_ERROR(EPERM);
         if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0) {
                 qdprintk("qtrunc flags=%x m_qflags=%x\n", flags, mp->m_qflags);
                 return XFS_ERROR(EINVAL);
@@ -416,7 +292,7 @@ xfs_qm_scall_trunc_qfiles(
  * effect immediately.
  * (Switching on quota accounting must be done at mount time.)
  */
-STATIC int
+int
 xfs_qm_scall_quotaon(
         xfs_mount_t     *mp,
         uint            flags)
@@ -426,9 +302,6 @@ xfs_qm_scall_quotaon(
         uint            accflags;
         __int64_t       sbflags;
 
-        if (!capable(CAP_SYS_ADMIN))
-                return XFS_ERROR(EPERM);
-
         flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);
         /*
          * Switching on quota accounting must be done at mount time.
@@ -517,7 +390,7 @@ xfs_qm_scall_quotaon(
 /*
  * Return quota status information, such as uquota-off, enforcements, etc.
  */
-STATIC int
+int
 xfs_qm_scall_getqstat(
         xfs_mount_t     *mp,
         fs_quota_stat_t *out)
@@ -582,7 +455,7 @@ xfs_qm_scall_getqstat(
 /*
  * Adjust quota limits, and start/stop timers accordingly.
  */
-STATIC int
+int
 xfs_qm_scall_setqlim(
         xfs_mount_t             *mp,
         xfs_dqid_t              id,
@@ -595,9 +468,6 @@ xfs_qm_scall_setqlim(
         int                     error;
         xfs_qcnt_t              hard, soft;
 
-        if (!capable(CAP_SYS_ADMIN))
-                return XFS_ERROR(EPERM);
-
         if ((newlim->d_fieldmask &
             (FS_DQ_LIMIT_MASK|FS_DQ_TIMER_MASK|FS_DQ_WARNS_MASK)) == 0)
                 return (0);
@@ -742,7 +612,7 @@ xfs_qm_scall_setqlim(
         return error;
 }
 
-STATIC int
+int
 xfs_qm_scall_getquota(
         xfs_mount_t     *mp,
         xfs_dqid_t      id,
@@ -935,30 +805,6 @@ xfs_qm_export_dquot(
 }
 
 STATIC uint
-xfs_qm_import_qtype_flags(
-        uint            uflags)
-{
-        uint            oflags = 0;
-
-        /*
-         * Can't be more than one, or none.
-         */
-        if (((uflags & (XFS_GROUP_QUOTA | XFS_USER_QUOTA)) ==
-                        (XFS_GROUP_QUOTA | XFS_USER_QUOTA)) ||
-            ((uflags & (XFS_GROUP_QUOTA | XFS_PROJ_QUOTA)) ==
-                        (XFS_GROUP_QUOTA | XFS_PROJ_QUOTA)) ||
-            ((uflags & (XFS_USER_QUOTA | XFS_PROJ_QUOTA)) ==
-                        (XFS_USER_QUOTA | XFS_PROJ_QUOTA)) ||
-            ((uflags & (XFS_GROUP_QUOTA|XFS_USER_QUOTA|XFS_PROJ_QUOTA)) == 0))
-                return (0);
-
-        oflags |= (uflags & XFS_USER_QUOTA) ? XFS_DQ_USER : 0;
-        oflags |= (uflags & XFS_PROJ_QUOTA) ? XFS_DQ_PROJ : 0;
-        oflags |= (uflags & XFS_GROUP_QUOTA) ? XFS_DQ_GROUP: 0;
-        return oflags;
-}
-
-STATIC uint
 xfs_qm_export_qtype_flags(
         uint flags)
 {
@@ -979,26 +825,6 @@ xfs_qm_export_qtype_flags(
 }
 
 STATIC uint
-xfs_qm_import_flags(
-        uint uflags)
-{
-        uint flags = 0;
-
-        if (uflags & XFS_QUOTA_UDQ_ACCT)
-                flags |= XFS_UQUOTA_ACCT;
-        if (uflags & XFS_QUOTA_PDQ_ACCT)
-                flags |= XFS_PQUOTA_ACCT;
-        if (uflags & XFS_QUOTA_GDQ_ACCT)
-                flags |= XFS_GQUOTA_ACCT;
-        if (uflags & XFS_QUOTA_UDQ_ENFD)
-                flags |= XFS_UQUOTA_ENFD;
-        if (uflags & (XFS_QUOTA_PDQ_ENFD|XFS_QUOTA_GDQ_ENFD))
-                flags |= XFS_OQUOTA_ENFD;
-        return (flags);
-}
-
-
-STATIC uint
 xfs_qm_export_flags(
         uint flags)
 {
diff --git a/fs/xfs/quota/xfs_quota_priv.h b/fs/xfs/quota/xfs_quota_priv.h
index c4fcea600bc2..8286b2842b6b 100644
--- a/fs/xfs/quota/xfs_quota_priv.h
+++ b/fs/xfs/quota/xfs_quota_priv.h
@@ -42,34 +42,24 @@
 #define XFS_QI_QOFFLOCK(mp)     ((mp)->m_quotainfo->qi_quotaofflock)
 
 #define XFS_QI_MPL_LIST(mp)     ((mp)->m_quotainfo->qi_dqlist)
-#define XFS_QI_MPLLOCK(mp)      ((mp)->m_quotainfo->qi_dqlist.qh_lock)
 #define XFS_QI_MPLNEXT(mp)      ((mp)->m_quotainfo->qi_dqlist.qh_next)
 #define XFS_QI_MPLNDQUOTS(mp)   ((mp)->m_quotainfo->qi_dqlist.qh_nelems)
 
-#define XQMLCK(h)                       (mutex_lock(&((h)->qh_lock)))
-#define XQMUNLCK(h)                     (mutex_unlock(&((h)->qh_lock)))
-#ifdef DEBUG
-struct xfs_dqhash;
-static inline int XQMISLCKD(struct xfs_dqhash *h)
-{
-        if (mutex_trylock(&h->qh_lock)) {
-                mutex_unlock(&h->qh_lock);
-                return 0;
-        }
-        return 1;
-}
-#endif
-
-#define XFS_DQ_HASH_LOCK(h)             XQMLCK(h)
-#define XFS_DQ_HASH_UNLOCK(h)           XQMUNLCK(h)
-#define XFS_DQ_IS_HASH_LOCKED(h)        XQMISLCKD(h)
-
-#define xfs_qm_mplist_lock(mp)          XQMLCK(&(XFS_QI_MPL_LIST(mp)))
-#define xfs_qm_mplist_unlock(mp)        XQMUNLCK(&(XFS_QI_MPL_LIST(mp)))
-#define XFS_QM_IS_MPLIST_LOCKED(mp)     XQMISLCKD(&(XFS_QI_MPL_LIST(mp)))
-
-#define xfs_qm_freelist_lock(qm)        XQMLCK(&((qm)->qm_dqfreelist))
-#define xfs_qm_freelist_unlock(qm)      XQMUNLCK(&((qm)->qm_dqfreelist))
+#define xfs_qm_mplist_lock(mp) \
+        mutex_lock(&(XFS_QI_MPL_LIST(mp).qh_lock))
+#define xfs_qm_mplist_nowait(mp) \
+        mutex_trylock(&(XFS_QI_MPL_LIST(mp).qh_lock))
+#define xfs_qm_mplist_unlock(mp) \
+        mutex_unlock(&(XFS_QI_MPL_LIST(mp).qh_lock))
+#define XFS_QM_IS_MPLIST_LOCKED(mp) \
+        mutex_is_locked(&(XFS_QI_MPL_LIST(mp).qh_lock))
+
+#define xfs_qm_freelist_lock(qm) \
+        mutex_lock(&((qm)->qm_dqfreelist.qh_lock))
+#define xfs_qm_freelist_lock_nowait(qm) \
+        mutex_trylock(&((qm)->qm_dqfreelist.qh_lock))
+#define xfs_qm_freelist_unlock(qm) \
+        mutex_unlock(&((qm)->qm_dqfreelist.qh_lock))
 
 /*
  * Hash into a bucket in the dquot hash table, based on <mp, id>.