xfs
[Top] [All Lists]

Re: crash with latest code drop.

To: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Subject: Re: crash with latest code drop.
From: Dave Chinner <david@xxxxxxxxxxxxx>
Date: Wed, 15 Oct 2008 14:16:46 +1100
Cc: Peter Leckie <pleckie@xxxxxxx>, xfs@xxxxxxxxxxx
In-reply-to: <20081015022948.GA20966@xxxxxxxxxxxxx>
Mail-followup-to: Christoph Hellwig <hch@xxxxxxxxxxxxx>, Peter Leckie <pleckie@xxxxxxx>, xfs@xxxxxxxxxxx
References: <48F54C20.8060704@xxxxxxx> <20081015011857.GS10716@disturbed> <20081015022948.GA20966@xxxxxxxxxxxxx>
User-agent: Mutt/1.5.18 (2008-05-17)
On Tue, Oct 14, 2008 at 10:29:49PM -0400, Christoph Hellwig wrote:
> > +            * in reclaim. Leave it for the reclaim code to flush.
> >              */
> >             if (igrab(inode)) {
> >                     read_unlock(&pag->pag_ici_lock);
> >                     xfs_ilock(ip, lock_flags);
> >             } else {
> > +                   /* leave it to reclaim */
> >                     read_unlock(&pag->pag_ici_lock);
> > +                   continue;
> >             }
> 
> Might be betters as
> 
>               if (!igrab(inode)) {
>                       /* leave it to reclaim */
>                       read_unlock(&pag->pag_ici_lock);
>                       continue;
>               }
> 
>               read_unlock(&pag->pag_ici_lock);
>               xfs_ilock(ip, lock_flags);

Yes, saner and more consistent with other code to do it that way.

> which then also shows that we could stop doing the ilock at all for
> the DELWRI case, thas is after fixing the last caller doing
> SYNC_ATTR|SYNC_DELWRI.  Well yeah, lots of things still to sort out in
> this area.

Here's an updated patch that takes into account all this. it removes
a fair chunk of code now....

Cheers,

Dave.
-- 
Dave Chinner
david@xxxxxxxxxxxxx


XFS: avoid all reclaimable inodes in xfs_sync_inodes_ag

If we are syncing data in xfs_sync_inodes_ag(), the VFS
inode must still be referencable as the dirty data state
is carried on the VFS inode. hence if we can't get a
reference via igrab(), the inode must be in reclaim which
implies that it has no dirty data attached.

Leave such inodes to the reclaim code to flush the dirty
inode state to disk and so avoid attempting to access the
VFS inode when it may not exist in xfs_sync_inodes_ag().

Version 2:
o change igrab logic to be more linear
o remove initial reclaimable inode check now that we are using
  igrab() failure to detect inodes in reclaim
o assert that igrab failure occurs only on reclaimable inodes
o clean up inode locking - only grab the iolock if we are doing
  a SYNC_DELWRI call and we have a dirty inode.

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

diff --git a/fs/xfs/linux-2.6/xfs_sync.c b/fs/xfs/linux-2.6/xfs_sync.c
index 08b2acf..d371423 100644
--- a/fs/xfs/linux-2.6/xfs_sync.c
+++ b/fs/xfs/linux-2.6/xfs_sync.c
@@ -63,25 +63,16 @@ xfs_sync_inodes_ag(
        int             error = 0;
        int             last_error = 0;
        int             fflag = XFS_B_ASYNC;
-       int             lock_flags = XFS_ILOCK_SHARED;
 
        if (flags & SYNC_DELWRI)
                fflag = XFS_B_DELWRI;
        if (flags & SYNC_WAIT)
                fflag = 0;              /* synchronous overrides all */
 
-       if (flags & SYNC_DELWRI) {
-               /*
-                * We need the I/O lock if we're going to call any of
-                * the flush/inval routines.
-                */
-               lock_flags |= XFS_IOLOCK_SHARED;
-       }
-
        do {
                struct inode    *inode;
-               boolean_t       inode_refed;
                xfs_inode_t     *ip = NULL;
+               int             lock_flags = XFS_ILOCK_SHARED;
 
                /*
                 * use a gang lookup to find the next inode in the tree
@@ -109,15 +100,6 @@ xfs_sync_inodes_ag(
                        break;
                }
 
-               /*
-                * skip inodes in reclaim. Let xfs_syncsub do that for
-                * us so we don't need to worry.
-                */
-               if (xfs_iflags_test(ip, (XFS_IRECLAIM|XFS_IRECLAIMABLE))) {
-                       read_unlock(&pag->pag_ici_lock);
-                       continue;
-               }
-
                /* bad inodes are dealt with elsewhere */
                inode = VFS_I(ip);
                if (is_bad_inode(inode)) {
@@ -132,42 +114,29 @@ xfs_sync_inodes_ag(
                }
 
                /*
-                * If we can't get a reference on the VFS_I, the inode must be
-                * in reclaim. If we can get the inode lock without blocking,
-                * it is safe to flush the inode because we hold the tree lock
-                * and xfs_iextract will block right now. Hence if we lock the
-                * inode while holding the tree lock, xfs_ireclaim() is
-                * guaranteed to block on the inode lock we now hold and hence
-                * it is safe to reference the inode until we drop the inode
-                * locks completely.
+                * If we can't get a reference on the inode, it must be
+                * in reclaim. Leave it for the reclaim code to flush.
                 */
-               inode_refed = B_FALSE;
-               if (igrab(inode)) {
-                       read_unlock(&pag->pag_ici_lock);
-                       xfs_ilock(ip, lock_flags);
-                       inode_refed = B_TRUE;
-               } else {
-                       if (!xfs_ilock_nowait(ip, lock_flags)) {
-                               /* leave it to reclaim */
-                               read_unlock(&pag->pag_ici_lock);
-                               continue;
-                       }
+               if (!igrab(inode)) {
+                       ASSERT(xfs_iflags_test(ip,
+                                       (XFS_IRECLAIM|XFS_IRECLAIMABLE)));
                        read_unlock(&pag->pag_ici_lock);
+                       continue;
                }
+               read_unlock(&pag->pag_ici_lock);
 
                /*
                 * If we have to flush data or wait for I/O completion
-                * we need to drop the ilock that we currently hold.
-                * If we need to drop the lock, insert a marker if we
-                * have not already done so.
+                * we need to hold the iolock.
                 */
                if ((flags & SYNC_DELWRI) && VN_DIRTY(inode)) {
-                       xfs_iunlock(ip, XFS_ILOCK_SHARED);
+                       xfs_ilock(ip, XFS_IOLOCK_SHARED);
+                       lock_flags |= XFS_IOLOCK_SHARED;
                        error = xfs_flush_pages(ip, 0, -1, fflag, FI_NONE);
                        if (flags & SYNC_IOWAIT)
                                vn_iowait(ip);
-                       xfs_ilock(ip, XFS_ILOCK_SHARED);
                }
+               xfs_ilock(ip, XFS_ILOCK_SHARED);
 
                if ((flags & SYNC_ATTR) && !xfs_inode_clean(ip)) {
                        if (flags & SYNC_WAIT) {
@@ -184,12 +153,8 @@ xfs_sync_inodes_ag(
                        }
                }
 
-               if (lock_flags)
-                       xfs_iunlock(ip, lock_flags);
-
-               if (inode_refed) {
-                       IRELE(ip);
-               }
+               xfs_iunlock(ip, lock_flags);
+               IRELE(ip);
 
                if (error)
                        last_error = error;

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