xfs
[Top] [All Lists]

[PATCH 30/45] xfs: remove XFS_QMOPT_DQSUSER

To: xfs@xxxxxxxxxxx
Subject: [PATCH 30/45] xfs: remove XFS_QMOPT_DQSUSER
From: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date: Fri, 28 Oct 2011 05:54:53 -0400
References: <20111028095423.796574703@xxxxxxxxxxxxxxxxxxxxxx>
User-agent: quilt/0.48-1
Just read the id 0 dquot from disk directly in xfs_qm_init_quotainfo, instead
of going through dqget and having a special flag to not add the dquot to any
lists.

Signed-off-by: Christoph Hellwig <hch@xxxxxx>

---
 fs/xfs/xfs_dquot.c |   27 ++++++---------------------
 fs/xfs/xfs_dquot.h |    2 ++
 fs/xfs/xfs_qm.c    |   22 ++++++++++------------
 fs/xfs/xfs_quota.h |    1 -
 4 files changed, 18 insertions(+), 34 deletions(-)

Index: xfs/fs/xfs/xfs_dquot.c
===================================================================
--- xfs.orig/fs/xfs/xfs_dquot.c 2011-10-27 22:40:06.948673259 +0200
+++ xfs/fs/xfs/xfs_dquot.c      2011-10-27 22:40:07.534173092 +0200
@@ -553,7 +553,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,
@@ -802,32 +802,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.
Index: xfs/fs/xfs/xfs_dquot.h
===================================================================
--- xfs.orig/fs/xfs/xfs_dquot.h 2011-10-27 22:40:05.876670670 +0200
+++ xfs/fs/xfs/xfs_dquot.h      2011-10-27 22:40:07.534173092 +0200
@@ -129,6 +129,8 @@ static inline void xfs_dqunlock_nonotify
                                     (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 *);
Index: xfs/fs/xfs/xfs_qm.c
===================================================================
--- xfs.orig/fs/xfs/xfs_qm.c    2011-10-27 22:40:05.868674047 +0200
+++ xfs/fs/xfs/xfs_qm.c 2011-10-27 22:40:07.538179215 +0200
@@ -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;
Index: xfs/fs/xfs/xfs_quota.h
===================================================================
--- xfs.orig/fs/xfs/xfs_quota.h 2011-10-27 22:40:04.376671215 +0200
+++ xfs/fs/xfs/xfs_quota.h      2011-10-27 22:40:07.542229613 +0200
@@ -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 */

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