xfs: do not write the buffer from xfs_qm_dqflush

Instead of writing the buffer directly from inside xfs_qm_dqflush return it
to the caller and let the caller decide what to do with the buffer.  Also
remove the pincount check in xfs_qm_dqflush that all non-blocking callers
already implement and the now unused flags parameter and the XFS_DQ_IS_DIRTY
check that all callers already perform.

[ Dave Chinner: fixed build error cause by missing '{'. ]

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Mark Tinguely <tinguely@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 786a61e1cccd3a41324a1d189980cc5f92dc0d77..53757d83e4f6e03e10f2d106cd4802db797af1c4 100644 (file)
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -878,8 +878,8 @@ xfs_qm_dqflush_done(
  */
 int
 xfs_qm_dqflush(
-       xfs_dquot_t             *dqp,
-       uint                    flags)
+       struct xfs_dquot        *dqp,
+       struct xfs_buf          **bpp)
 {
        struct xfs_mount        *mp = dqp->q_mount;
        struct xfs_buf          *bp;
@@ -891,14 +891,8 @@ xfs_qm_dqflush(
 
        trace_xfs_dqflush(dqp);
 
-       /*
-        * If not dirty, or it's pinned and we are not supposed to block, nada.
-        */
-       if (!XFS_DQ_IS_DIRTY(dqp) ||
-           ((flags & SYNC_TRYLOCK) && atomic_read(&dqp->q_pincount) > 0)) {
-               xfs_dqfunlock(dqp);
-               return 0;
-       }
+       *bpp = NULL;
+
        xfs_qm_dqunpin_wait(dqp);
 
        /*
@@ -918,9 +912,8 @@ xfs_qm_dqflush(
                        xfs_trans_ail_delete(mp->m_ail, lip);
                else
                        spin_unlock(&mp->m_ail->xa_lock);
-
-               xfs_dqfunlock(dqp);
-               return XFS_ERROR(EIO);
+               error = XFS_ERROR(EIO);
+               goto out_unlock;
        }
 
        /*
@@ -928,11 +921,8 @@ xfs_qm_dqflush(
         */
        error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp, dqp->q_blkno,
                                   mp->m_quotainfo->qi_dqchunklen, 0, &bp);
-       if (error) {
-               ASSERT(error != ENOENT);
-               xfs_dqfunlock(dqp);
-               return error;
-       }
+       if (error)
+               goto out_unlock;
 
        /*
         * Calculate the location of the dquot inside the buffer.
@@ -978,20 +968,13 @@ xfs_qm_dqflush(
                xfs_log_force(mp, 0);
        }
 
-       if (flags & SYNC_WAIT)
-               error = xfs_bwrite(bp);
-       else
-               xfs_buf_delwri_queue(bp);
-
-       xfs_buf_relse(bp);
-
        trace_xfs_dqflush_done(dqp);
+       *bpp = bp;
+       return 0;
 
-       /*
-        * dqp is still locked, but caller is free to unlock it now.
-        */
-       return error;
-
+out_unlock:
+       xfs_dqfunlock(dqp);
+       return XFS_ERROR(EIO);
 }
 
 /*

diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index ef9190bd8b300a061244d1d294a90acf39610b08..5f2a2f2c0c5bcbc33c05dca7f6b00af8517a81b4 100644 (file)
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -141,7 +141,7 @@ static inline xfs_dquot_t *xfs_inode_dquot(struct xfs_inode *ip, int type)
 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 int             xfs_qm_dqflush(struct xfs_dquot *, struct xfs_buf **);
 extern void            xfs_qm_dqunpin_wait(xfs_dquot_t *);
 extern void            xfs_qm_adjust_dqtimers(xfs_mount_t *,
                                        xfs_disk_dquot_t *);

diff --git a/fs/xfs/xfs_dquot_item.c b/fs/xfs/xfs_dquot_item.c
index 34baeae4526580c193ec5741bbaac4a165dadf0c..8d82958142725ea24e8897f00db5b5a476a9226a 100644 (file)
--- a/fs/xfs/xfs_dquot_item.c
+++ b/fs/xfs/xfs_dquot_item.c
@@ -119,10 +119,12 @@ xfs_qm_dquot_logitem_push(
        struct xfs_log_item     *lip)
 {
        struct xfs_dquot        *dqp = DQUOT_ITEM(lip)->qli_dquot;
+       struct xfs_buf          *bp = NULL;
        int                     error;
 
        ASSERT(XFS_DQ_IS_LOCKED(dqp));
        ASSERT(!completion_done(&dqp->q_flush));
+       ASSERT(atomic_read(&dqp->q_pincount) == 0);
 
        /*
         * Since we were able to lock the dquot's flush lock and
@@ -133,10 +135,16 @@ xfs_qm_dquot_logitem_push(
         * lock without sleeping, then there must not have been
         * anyone in the process of flushing the dquot.
         */
-       error = xfs_qm_dqflush(dqp, SYNC_TRYLOCK);
-       if (error)
+       error = xfs_qm_dqflush(dqp, &bp);
+       if (error) {
                xfs_warn(dqp->q_mount, "%s: push error %d on dqp %p",
                        __func__, error, dqp);
+               goto out_unlock;
+       }
+
+       xfs_buf_delwri_queue(bp);
+       xfs_buf_relse(bp);
+out_unlock:
        xfs_dqunlock(dqp);
 }
 
@@ -239,6 +247,15 @@ xfs_qm_dquot_logitem_trylock(
        if (!xfs_dqlock_nowait(dqp))
                return XFS_ITEM_LOCKED;
 
+       /*
+        * Re-check the pincount now that we stabilized the value by
+        * taking the quota lock.
+        */
+       if (atomic_read(&dqp->q_pincount) > 0) {
+               xfs_dqunlock(dqp);
+               return XFS_ITEM_PINNED;
+       }
+
        if (!xfs_dqflock_nowait(dqp)) {
                /*
                 * dquot has already been flushed to the backing buffer,

diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 18ba438386ab17e295ea8d28b9aad61056ff469f..95aecf52475d29a4237d8e200a0ecf9b81f686b1 100644 (file)
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -175,16 +175,21 @@ xfs_qm_dqpurge(
         * we're unmounting, we do care, so we flush it and wait.
         */
        if (XFS_DQ_IS_DIRTY(dqp)) {
-               int     error;
+               struct xfs_buf  *bp = NULL;
+               int             error;
 
                /*
                 * We don't care about getting disk errors here. We need
                 * to purge this dquot anyway, so we go ahead regardless.
                 */
-               error = xfs_qm_dqflush(dqp, SYNC_WAIT);
-               if (error)
+               error = xfs_qm_dqflush(dqp, &bp);
+               if (error) {
                        xfs_warn(mp, "%s: dquot %p flush failed",
                                __func__, dqp);
+               } else {
+                       error = xfs_bwrite(bp);
+                       xfs_buf_relse(bp);
+               }
                xfs_dqflock(dqp);
        }
 
@@ -1200,6 +1205,7 @@ STATIC int
 xfs_qm_flush_one(
        struct xfs_dquot        *dqp)
 {
+       struct xfs_buf          *bp = NULL;
        int                     error = 0;
 
        xfs_dqlock(dqp);
@@ -1211,8 +1217,12 @@ xfs_qm_flush_one(
        if (!xfs_dqflock_nowait(dqp))
                xfs_dqflock_pushbuf_wait(dqp);
 
-       error = xfs_qm_dqflush(dqp, 0);
+       error = xfs_qm_dqflush(dqp, &bp);
+       if (error)
+               goto out_unlock;
 
+       xfs_buf_delwri_queue(bp);
+       xfs_buf_relse(bp);
 out_unlock:
        xfs_dqunlock(dqp);
        return error;
@@ -1479,18 +1489,23 @@ xfs_qm_dqreclaim_one(
         * dirty dquots.
         */
        if (XFS_DQ_IS_DIRTY(dqp)) {
+               struct xfs_buf  *bp = NULL;
+
                trace_xfs_dqreclaim_dirty(dqp);
 
                /*
                 * We flush it delayed write, so don't bother releasing the
                 * freelist lock.
                 */
-               error = xfs_qm_dqflush(dqp, 0);
+               error = xfs_qm_dqflush(dqp, &bp);
                if (error) {
                        xfs_warn(mp, "%s: dquot %p flush failed",
                                 __func__, dqp);
+                       goto out_busy;
                }
 
+               xfs_buf_delwri_queue(bp);
+               xfs_buf_relse(bp);
                /*
                 * Give the dquot another try on the freelist, as the
                 * flushing will take some time.