xfs
[Top] [All Lists]

[PATCH 2/6] [XFS] Use xfs_inode_flush() in xfs_sync_inodes_ag()

To: xfs@xxxxxxxxxxx
Subject: [PATCH 2/6] [XFS] Use xfs_inode_flush() in xfs_sync_inodes_ag()
From: Dave Chinner <david@xxxxxxxxxxxxx>
Date: Sun, 15 Mar 2009 22:46:39 +1100
In-reply-to: <1237117603-26071-1-git-send-email-david@xxxxxxxxxxxxx>
References: <1237117603-26071-1-git-send-email-david@xxxxxxxxxxxxx>
xfs_sync_inodes_ag() effectively open-codes xfs_inode_flush()
to do blocking vs non-blocking inode flushing. It doesn't have
all the optimisations that xfs_inode_flush() has but does
the same thing. Call xfs_inode_flush() instead.

Signed-off-by: Dave Chinner <david@xxxxxxxxxxxxx>
---
 fs/xfs/linux-2.6/xfs_sync.c |   63 +++++++++++++++++++++++++++++++-----------
 1 files changed, 46 insertions(+), 17 deletions(-)

diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c
index fd024e2..b3d4f7a 100644
--- a/fs/xfs/linux-2.6/xfs_sync.c
+++ b/fs/xfs/linux-2.6/xfs_sync.c
@@ -43,6 +43,7 @@
 #include "xfs_buf_item.h"
 #include "xfs_inode_item.h"
 #include "xfs_rw.h"
+#include "linux-2.6/xfs_vnode.h"
 
 #include <linux/kthread.h>
 #include <linux/freezer.h>
@@ -78,6 +79,47 @@ xfs_sync_inode_data(
        return error;
 }
 
+static int
+xfs_sync_inode_flush(
+       struct xfs_inode        *ip,
+       int                     flags)
+{
+       int             error = 0;
+
+       /*
+        * Bypass inodes which have already been cleaned by
+        * the inode flush clustering code inside xfs_iflush
+        */
+       if (xfs_inode_clean(ip))
+               return 0;
+
+       /*
+        * We make this non-blocking if the inode is contended,
+        * return EAGAIN to indicate to the caller that they
+        * did not succeed. This prevents the flush path from
+        * blocking on inodes inside another operation right
+        * now, they get caught later by xfs_sync.
+        */
+       if (flags & SYNC_WAIT) {
+               xfs_ilock(ip, XFS_ILOCK_SHARED);
+               xfs_iflock(ip);
+
+               error = xfs_iflush(ip, XFS_IFLUSH_SYNC);
+       } else {
+               if (!xfs_ilock_nowait(ip, XFS_ILOCK_SHARED))
+                       goto out;
+               if (xfs_ipincount(ip) || !xfs_iflock_nowait(ip))
+                       goto out_unlock;
+
+               error = xfs_iflush(ip, XFS_IFLUSH_ASYNC_NOBLOCK);
+       }
+
+out_unlock:
+       xfs_iunlock(ip, XFS_ILOCK_SHARED);
+out:
+       return error;
+}
+
 /*
  * Sync all the inodes in the given AG according to the
  * direction given by the flags.
@@ -97,7 +139,6 @@ xfs_sync_inodes_ag(
        do {
                struct inode    *inode;
                xfs_inode_t     *ip = NULL;
-               int             lock_flags = XFS_ILOCK_SHARED;
 
                /*
                 * use a gang lookup to find the next inode in the tree
@@ -156,22 +197,10 @@ xfs_sync_inodes_ag(
                if (flags & SYNC_DELWRI)
                        error = xfs_sync_inode_data(ip, flags);
 
-               xfs_ilock(ip, XFS_ILOCK_SHARED);
-               if ((flags & SYNC_ATTR) && !xfs_inode_clean(ip)) {
-                       if (flags & SYNC_WAIT) {
-                               xfs_iflock(ip);
-                               if (!xfs_inode_clean(ip))
-                                       error = xfs_iflush(ip, XFS_IFLUSH_SYNC);
-                               else
-                                       xfs_ifunlock(ip);
-                       } else if (xfs_iflock_nowait(ip)) {
-                               if (!xfs_inode_clean(ip))
-                                       error = xfs_iflush(ip, 
XFS_IFLUSH_DELWRI);
-                               else
-                                       xfs_ifunlock(ip);
-                       }
-               }
-               xfs_iput(ip, lock_flags);
+               if (flags & SYNC_ATTR)
+                       error = xfs_sync_inode_flush(ip, flags);
+
+               IRELE(ip);
 
                if (error)
                        last_error = error;
-- 
1.6.2

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