xfs
[Top] [All Lists]

[XFS updates] XFS development tree branch, master, updated. v2.6.33-rc4-

To: xfs@xxxxxxxxxxx
Subject: [XFS updates] XFS development tree branch, master, updated. v2.6.33-rc4-58-g180040b
From: xfs@xxxxxxxxxxx
Date: Fri, 12 Feb 2010 17:33:12 -0600
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "XFS development tree".

The branch, master has been updated
  180040b xfs: optimize log flushing in xfs_fsync
  8718551 xfs: only clear the suid bit once in xfs_write
  5322892 xfs: kill xfs_bawrite
  07fec73 xfs: log changed inodes instead of writing them synchronously
  e8b217e xfs: remove invalid barrier optimization from xfs_fsync
  20026d9 xfs: kill the unused XFS_QMOPT_* flush flags V2
  7d6a7bd xfs: Use delay write promotion for dquot flushing
  089716a xfs: Sort delayed write buffers before dispatch
  d808f61 xfs: Don't issue buffer IO direct from AIL push V2
  c854363 xfs: Use delayed write for inodes rather than async V2
  777df5a xfs: Make inode reclaim states explicit
      from  d5db0f97fbbeff11c88dec1aaf1536a975afbaeb (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 180040b89ee2aed88c0a0b1fcf7ada9a512b12e3
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Fri Feb 5 09:57:55 2010 +0000

    xfs: optimize log flushing in xfs_fsync
    
    If we have a pinned inode it must have a log item attached to it.
    Usually that log item will have ili_last_lsn already set, in which
    case we only need to flush the log up to that LSN instead of doing a
    full log force.  This gives speedups of about 5% in some fsync heavy
    workloads.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit 87185517de81101da5afbc82cefdeed6eeaa38fb
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Wed Feb 3 19:43:31 2010 +0000

    xfs: only clear the suid bit once in xfs_write
    
    file_remove_suid already calls into ->setattr to clear the suid and
    sgid bits if needed, no need to start a second transaction to do it
    ourselves.
    
    Note that xfs_write_clear_setuid issues a sync transaction while the
    path through ->setattr doesn't, but that is consistant with the
    other filesystems.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Alex Elder <aelder@xxxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit 5322892d867e186c6b4c5fff5c99ea4863696a60
Author: Dave Chinner <david@xxxxxxxxxxxxx>
Date:   Thu Feb 4 10:09:14 2010 +1100

    xfs: kill xfs_bawrite
    
    There are no more users of this function left in the XFS code
    now that we've switched everything to delayed write flushing.
    Remove it.
    
    Signed-off-by: Dave Chinner <david@xxxxxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>

commit 07fec73625dc0db6f9aed68019918208a2ca53f5
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Tue Feb 9 11:43:49 2010 +1100

    xfs: log changed inodes instead of writing them synchronously
    
    When an inode has already be flushed delayed write,
    xfs_inode_clean() returns true and hence xfs_fs_write_inode() can
    return on a synchronous inode write without having written the
    inode. Currently these sycnhronous writes only come sync(1),
    unmount, a sycnhronous NFS export and cachefiles so should be
    relatively rare and out of common performance paths.
    
    Realistically, a synchronous inode write is not necessary here; we
    can avoid writing the inode by logging any non-transactional changes
    that are pending.  This needs to be done with synchronous
    transactions, but it avoids seeking between the log and inode
    clusters as we do now. We don't force the log if the inode is
    pinned, though, so this differs from the fsync case.  For normal
    sys_sync and unmount behaviour this is fine because we do a
    synchronous log force in xfs_sync_data which is called from the
    ->sync_fs code.
    
    It does however break the NFS synchronous export guarantees for now,
    but work is under way to fix this at a higher level or for the
    higher level to provide an additional flag in the writeback control
    to tell us that a log force is needed.
    
    Portions of this patch are based on work from Dave Chinner.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxxxxxxxxx>
    Reviewed-by: Dave Chinner <david@xxxxxxxxxxxxx>
    Reviewed-by: Alex Elder <aelder@xxxxxxx>

commit e8b217e7530c6a073ac69f1c85b922d93fdf5647
Author: Christoph Hellwig <hch@xxxxxx>
Date:   Tue Feb 2 10:16:26 2010 +1100

    xfs: remove invalid barrier optimization from xfs_fsync
    
    We always need to flush the disk write cache and can't skip it just because
    the no inode attributes have changed.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Dave Chinner <david@xxxxxxxxxxxxx>

commit 20026d92013d7bb3abb295337191def6758fc086
Author: Dave Chinner <david@xxxxxxxxxxxxx>
Date:   Thu Feb 4 09:48:58 2010 +1100

    xfs: kill the unused XFS_QMOPT_* flush flags V2
    
    dquots are never flushed asynchronously. Remove the flag and the
    async write support from the flush function. Make the default flush
    a delwri flush to make the inode flush code, which leaves the
    XFS_QMOPT_SYNC the only flag remaining.  Convert that to use
    SYNC_WAIT instead, just like the inode flush code.
    
    V2:
    - just pass flush flags straight through
    
    Signed-off-by: Dave Chinner <david@xxxxxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>

commit 7d6a7bde52e449f21a0e86a7a4955b4e08a49d69
Author: Dave Chinner <david@xxxxxxxxxxxxx>
Date:   Tue Jan 26 15:13:41 2010 +1100

    xfs: Use delay write promotion for dquot flushing
    
    xfs_qm_dqflock_pushbuf_wait() does a very similar trick to item
    pushing used to do to flush out delayed write dquot buffers. Change
    it to use the new promotion method rather than an async flush.
    
    Also, xfs_qm_dqflock_pushbuf_wait() can return without the flush lock
    held, yet the callers make the assumption that after this call the
    flush lock is held. Always return with the flush lock held.
    
    Signed-off-by: Dave Chinner <david@xxxxxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>

commit 089716aa1480b7197bcd678b8477774c379a2768
Author: Dave Chinner <david@xxxxxxxxxxxxx>
Date:   Tue Jan 26 15:13:25 2010 +1100

    xfs: Sort delayed write buffers before dispatch
    
    Currently when the xfsbufd writes delayed write buffers, it pushes
    them to disk in the order they come off the delayed write list. If
    there are lots of buffers Ñ?pread widely over the disk, this results
    in overwhelming the elevator sort queues in the block layer and we
    end up losing the posibility of merging adjacent buffers to minimise
    the number of IOs.
    
    Use the new generic list_sort function to sort the delwri dispatch
    queue before issue to ensure that the buffers are pushed in the most
    friendly order possible to the lower layers.
    
    Signed-off-by: Dave Chinner <david@xxxxxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>

commit d808f617ad00a413585b806de340feda5ad9a2da
Author: Dave Chinner <david@xxxxxxxxxxxxx>
Date:   Tue Feb 2 10:13:42 2010 +1100

    xfs: Don't issue buffer IO direct from AIL push V2
    
    All buffers logged into the AIL are marked as delayed write.
    When the AIL needs to push the buffer out, it issues an async write of the
    buffer. This means that IO patterns are dependent on the order of
    buffers in the AIL.
    
    Instead of flushing the buffer, promote the buffer in the delayed
    write list so that the next time the xfsbufd is run the buffer will
    be flushed by the xfsbufd. Return the state to the xfsaild that the
    buffer was promoted so that the xfsaild knows that it needs to cause
    the xfsbufd to run to flush the buffers that were promoted.
    
    Using the xfsbufd for issuing the IO allows us to dispatch all
    buffer IO from the one queue. This means that we can make much more
    enlightened decisions on what order to flush buffers to disk as
    we don't have multiple places issuing IO. Optimisations to xfsbufd
    will be in a future patch.
    
    Version 2
    - kill XFS_ITEM_FLUSHING as it is now unused.
    
    Signed-off-by: Dave Chinner <david@xxxxxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>

commit c854363e80b49dd04a4de18ebc379eb8c8806674
Author: Dave Chinner <david@xxxxxxxxxxxxx>
Date:   Sat Feb 6 12:39:36 2010 +1100

    xfs: Use delayed write for inodes rather than async V2
    
    We currently do background inode flush asynchronously, resulting in
    inodes being written in whatever order the background writeback
    issues them. Not only that, there are also blocking and non-blocking
    asynchronous inode flushes, depending on where the flush comes from.
    
    This patch completely removes asynchronous inode writeback. It
    removes all the strange writeback modes and replaces them with
    either a synchronous flush or a non-blocking delayed write flush.
    That is, inode flushes will only issue IO directly if they are
    synchronous, and background flushing may do nothing if the operation
    would block (e.g. on a pinned inode or buffer lock).
    
    Delayed write flushes will now result in the inode buffer sitting in
    the delwri queue of the buffer cache to be flushed by either an AIL
    push or by the xfsbufd timing out the buffer. This will allow
    accumulation of dirty inode buffers in memory and allow optimisation
    of inode cluster writeback at the xfsbufd level where we have much
    greater queue depths than the block layer elevators. We will also
    get adjacent inode cluster buffer IO merging for free when a later
    patch in the series allows sorting of the delayed write buffers
    before dispatch.
    
    This effectively means that any inode that is written back by
    background writeback will be seen as flush locked during AIL
    pushing, and will result in the buffers being pushed from there.
    This writeback path is currently non-optimal, but the next patch
    in the series will fix that problem.
    
    A side effect of this delayed write mechanism is that background
    inode reclaim will no longer directly flush inodes, nor can it wait
    on the flush lock. The result is that inode reclaim must leave the
    inode in the reclaimable state until it is clean. Hence attempts to
    reclaim a dirty inode in the background will simply skip the inode
    until it is clean and this allows other mechanisms (i.e. xfsbufd) to
    do more optimal writeback of the dirty buffers. As a result, the
    inode reclaim code has been rewritten so that it no longer relies on
    the ambiguous return values of xfs_iflush() to determine whether it
    is safe to reclaim an inode.
    
    Portions of this patch are derived from patches by Christoph
    Hellwig.
    
    Version 2:
    - cleanup reclaim code as suggested by Christoph
    - log background reclaim inode flush errors
    - just pass sync flags to xfs_iflush
    
    Signed-off-by: Dave Chinner <david@xxxxxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>

commit 777df5afdb26c71634edd60582be620ff94e87a0
Author: Dave Chinner <david@xxxxxxxxxxxxx>
Date:   Sat Feb 6 12:37:26 2010 +1100

    xfs: Make inode reclaim states explicit
    
    A.K.A.: don't rely on xfs_iflush() return value in reclaim
    
    We have gradually been moving checks out of the reclaim code because
    they are duplicated in xfs_iflush(). We've had a history of problems
    in this area, and many of them stem from the overloading of the
    return values from xfs_iflush() and interaction with inode flush
    locking to determine if the inode is safe to reclaim.
    
    With the desire to move to delayed write flushing of inodes and
    non-blocking inode tree reclaim walks, the overloading of the
    return value of xfs_iflush makes it very difficult to determine
    the correct thing to do next.
    
    This patch explicitly re-adds the checks to the inode reclaim code,
    removing the reliance on the return value of xfs_iflush() to
    determine what to do next. It also means that we can clearly
    document all the inode states that reclaim must handle and hence
    we can easily see that we handled all the necessary cases.
    
    This also removes the need for the xfs_inode_clean() check in
    xfs_iflush() as all callers now check this first (safely).
    
    Signed-off-by: Dave Chinner <david@xxxxxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>

-----------------------------------------------------------------------

Summary of changes:
 fs/xfs/linux-2.6/xfs_buf.c    |  135 ++++++++++++++++++++++++++--------------
 fs/xfs/linux-2.6/xfs_buf.h    |    3 +-
 fs/xfs/linux-2.6/xfs_lrw.c    |   15 +----
 fs/xfs/linux-2.6/xfs_super.c  |  111 ++++++++++++++++++++++++---------
 fs/xfs/linux-2.6/xfs_sync.c   |  138 +++++++++++++++++++++++++++++++++-------
 fs/xfs/linux-2.6/xfs_trace.h  |    1 +
 fs/xfs/quota/xfs_dquot.c      |   38 +++++-------
 fs/xfs/quota/xfs_dquot_item.c |   87 ++++----------------------
 fs/xfs/quota/xfs_dquot_item.h |    4 -
 fs/xfs/quota/xfs_qm.c         |   14 ++---
 fs/xfs/xfs_buf_item.c         |   64 ++++++++++---------
 fs/xfs/xfs_inode.c            |   86 ++------------------------
 fs/xfs/xfs_inode.h            |   11 +---
 fs/xfs/xfs_inode_item.c       |  108 +++++++-------------------------
 fs/xfs/xfs_inode_item.h       |    6 --
 fs/xfs/xfs_mount.c            |   13 ++++-
 fs/xfs/xfs_quota.h            |    8 +--
 fs/xfs/xfs_rw.c               |   42 ------------
 fs/xfs/xfs_rw.h               |    1 -
 fs/xfs/xfs_trans.h            |    3 +-
 fs/xfs/xfs_trans_ail.c        |   13 ++--
 fs/xfs/xfs_vnodeops.c         |   22 +++----
 22 files changed, 421 insertions(+), 502 deletions(-)


hooks/post-receive
-- 
XFS development tree

<Prev in Thread] Current Thread [Next in Thread>
  • [XFS updates] XFS development tree branch, master, updated. v2.6.33-rc4-58-g180040b, xfs <=