4 files changed, 18 insertions, 34 deletions

diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 1a2aa173ef21..b4ff40b5f918 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -552,7 +552,7 @@ xfs_qm_dqtobp(
  *
  * If XFS_QMOPT_DQALLOC is set, allocate a dquot on disk if it needed.
  */
-STATIC int
+int
 xfs_qm_dqread(
         struct xfs_mount        *mp,
         xfs_dqid_t              id,
@@ -804,32 +804,17 @@ restart:
         mutex_unlock(&h->qh_lock);
 
         error = xfs_qm_dqread(mp, id, type, flags, &dqp);
-        if (error) {
-                if (ip)
-                        xfs_ilock(ip, XFS_ILOCK_EXCL);
-                return error;
-        }
 
-        /*
-         * See if this is mount code calling to look at the overall quota limits
-         * which are stored in the id == 0 user or group's dquot.
-         * Since we may not have done a quotacheck by this point, just return
-         * the dquot without attaching it to any hashtables, lists, etc, or even
-         * taking a reference.
-         * The caller must dqdestroy this once done.
-         */
-        if (flags & XFS_QMOPT_DQSUSER) {
-                ASSERT(id == 0);
-                ASSERT(! ip);
-                goto dqret;
-        }
+        if (ip)
+                xfs_ilock(ip, XFS_ILOCK_EXCL);
+
+        if (error)
+                return error;
 
         /*
          * Dquot lock comes after hashlock in the lock ordering
          */
         if (ip) {
-                xfs_ilock(ip, XFS_ILOCK_EXCL);
-
                 /*
                  * A dquot could be attached to this inode by now, since
                  * we had dropped the ilock.
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index cc0149d217ba..a1d91d8f1802 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -129,6 +129,8 @@ static inline void xfs_dqunlock_nonotify(struct xfs_dquot *dqp)
                                      (XFS_IS_UQUOTA_ON((d)->q_mount)) : \
                                      (XFS_IS_OQUOTA_ON((d)->q_mount))))
 
+extern int              xfs_qm_dqread(struct xfs_mount *, xfs_dqid_t, uint,
+                                        uint, struct xfs_dquot  **);
 extern void             xfs_qm_dqdestroy(xfs_dquot_t *);
 extern int              xfs_qm_dqflush(xfs_dquot_t *, uint);
 extern void             xfs_qm_dqpurge(xfs_dquot_t *);
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index cd7460ba4e69..b8df0bda5a54 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -858,18 +858,21 @@ xfs_qm_init_quotainfo(
         /*
          * We try to get the limits from the superuser's limits fields.
          * This is quite hacky, but it is standard quota practice.
+         *
          * We look at the USR dquot with id == 0 first, but if user quotas
          * are not enabled we goto the GRP dquot with id == 0.
          * We don't really care to keep separate default limits for user
          * and group quotas, at least not at this point.
+         *
+         * Since we may not have done a quotacheck by this point, just read
+         * the dquot without attaching it to any hashtables or lists.
          */
-        error = xfs_qm_dqget(mp, NULL, (xfs_dqid_t)0,
-                             XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER : 
-                             (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
-                                XFS_DQ_PROJ),
-                             XFS_QMOPT_DQSUSER|XFS_QMOPT_DOWARN,
-                             &dqp);
-        if (! error) {
+        error = xfs_qm_dqread(mp, 0,
+                        XFS_IS_UQUOTA_RUNNING(mp) ? XFS_DQ_USER :
+                         (XFS_IS_GQUOTA_RUNNING(mp) ? XFS_DQ_GROUP :
+                          XFS_DQ_PROJ),
+                        XFS_QMOPT_DOWARN, &dqp);
+        if (!error) {
                 xfs_disk_dquot_t        *ddqp = &dqp->q_core;
 
                 /*
@@ -896,11 +899,6 @@ xfs_qm_init_quotainfo(
                 qinf->qi_rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
                 qinf->qi_rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
  
-                /*
-                 * We sent the XFS_QMOPT_DQSUSER flag to dqget because
-                 * we don't want this dquot cached. We haven't done a
-                 * quotacheck yet, and quotacheck doesn't like incore dquots.
-                 */
                 xfs_qm_dqdestroy(dqp);
         } else {
                 qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
diff --git a/fs/xfs/xfs_quota.h b/fs/xfs/xfs_quota.h
index b86c62f5eeba..8a0807e0f979 100644
--- a/fs/xfs/xfs_quota.h
+++ b/fs/xfs/xfs_quota.h
@@ -197,7 +197,6 @@ typedef struct xfs_qoff_logformat {
 #define XFS_QMOPT_UQUOTA        0x0000004 /* user dquot requested */
 #define XFS_QMOPT_PQUOTA        0x0000008 /* project dquot requested */
 #define XFS_QMOPT_FORCE_RES     0x0000010 /* ignore quota limits */
-#define XFS_QMOPT_DQSUSER       0x0000020 /* don't cache super users dquot */
 #define XFS_QMOPT_SBVERSION     0x0000040 /* change superblock version num */
 #define XFS_QMOPT_DOWARN        0x0000400 /* increase warning cnt if needed */
 #define XFS_QMOPT_DQREPAIR      0x0001000 /* repair dquot if damaged */