xfs
[Top] [All Lists]

[XFS updates] XFS development tree branch, for-linus, updated. v2.6.38-1

To: xfs@xxxxxxxxxxx
Subject: [XFS updates] XFS development tree branch, for-linus, updated. v2.6.38-10134-gbf59170
From: xfs@xxxxxxxxxxx
Date: Mon, 23 May 2011 16:44:39 -0500
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, for-linus has been updated
  discards  7ac956576d0ce8f97450a39c2f304db8eea01647 (commit)
  discards  fe0da767311933d1c1907cb8d326beea7a3cbd9c (commit)
  discards  50e86686dfb287d720af8b0f977202d205c04215 (commit)
  discards  9e7004e741de0b2daabbbadafbaf11ff1a94e00c (commit)
  discards  228d62dd3f74734b9801c789b5addc57fdfc208f (commit)
  bf59170 xfs: obey minleft values during extent allocation correctly
  4439647 xfs: reset buffer pointers before freeing them
  ee58abd xfs: avoid getting stuck during async inode flushes
  e573751 xfs: fix xfs_itruncate_start tracing
  1beb65a xfs: fix duplicate workqueue initialisation
  e69522a xfs: kill off xfs_printk()
  e4d3c4a xfs: fix race condition in AIL push trigger
  fd5670f xfs: make AIL target updates and compares 32bit safe.
  cb64026 xfs: always push the AIL to the target
  ea35a20 xfs: exit AIL push work correctly when AIL is empty
  b223221 xfs: ensure reclaim cursor is reset correctly at end of AG
  8c1fdd0 xfs: add an x86 compat handler for XFS_IOC_ZERO_RANGE
  1a18a29 xfs: fix compiler warning in xfs_trace.h
  45c51b9 xfs: cleanup duplicate initializations
  8a072a4 xfs: reduce the number of pagb_lock roundtrips in xfs_alloc_clear_busy
  97d3ac7 xfs: exact busy extent tracking
  e26f050 xfs: do not immediately reuse busy extent ranges
  a870acd xfs: optimize AGFL refills
      from  7ac956576d0ce8f97450a39c2f304db8eea01647 (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 bf59170a66bc3eaf3ee513aa6ce9774aa2ab5188
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Thu Apr 21 09:34:28 2011 +0000

    xfs: obey minleft values during extent allocation correctly
    
    When allocating an extent that is long enough to consume the
    remaining free space in an AG, we need to ensure that the allocation
    leaves enough space in the AG for any subsequent bmap btree blocks
    that are needed to track the new extent. These have to be allocated
    in the same AG as we only reserve enough blocks in an allocation
    transaction for modification of the freespace trees in a single AG.
    
    xfs_alloc_fix_minleft() has been considering blocks on the AGFL as
    free blocks available for extent and bmbt block allocation, which is
    not correct - blocks on the AGFL are there exclusively for the use
    of the free space btrees. As a result, when minleft is less than the
    number of blocks on the AGFL, xfs_alloc_fix_minleft() does not trim
    the given extent to leave minleft blocks available for bmbt
    allocation, and hence we can fail allocation during bmbt record
    insertion.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit 44396476a0f24e5174768d3732f1958857c26d22
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Thu Apr 21 09:34:27 2011 +0000

    xfs: reset buffer pointers before freeing them
    
    When we free a vmapped buffer, we need to ensure the vmap address
    and length we free is the same as when it was allocated. In various
    places in the log code we change the memory the buffer is pointing
    to before issuing IO, but we never reset the buffer to point back to
    it's original memory (or no memory, if that is the case for the
    buffer).
    
    As a result, when we free the buffer it points to memory that is
    owned by something else and attempts to unmap and free it. Because
    the range does not match any known mapped range, it can trigger
    BUG_ON() traps in the vmap code, and potentially corrupt the vmap
    area tracking.
    
    Fix this by always resetting these buffers to their original state
    before freeing them.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit ee58abdfcc8201f500107c7ba03f738af8b49b85
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Thu Apr 21 09:34:26 2011 +0000

    xfs: avoid getting stuck during async inode flushes
    
    When the underlying inode buffer is locked and xfs_sync_inode_attr()
    is doing a non-blocking flush, xfs_iflush() can return EAGAIN.  When
    this happens, clear the error rather than returning it to
    xfs_inode_ag_walk(), as returning EAGAIN will result in the AG walk
    delaying for a short while and trying again. This can result in
    background walks getting stuck on the one AG until inode buffer is
    unlocked by some other means.
    
    This behaviour was noticed when analysing event traces followed by
    code inspection and verification of the fix via further traces.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit e57375153d7376f2a923d98c388c1e20227b5731
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Thu Apr 21 09:34:25 2011 +0000

    xfs: fix xfs_itruncate_start tracing
    
    Variables are ordered incorrectly in trace call.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit 1beb65ad45f29fa1d53c13c6a20056a190ac9060
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Tue May 10 02:05:50 2011 +0000

    xfs: fix duplicate workqueue initialisation
    
    The workqueue initialisation function is called twice when
    initialising the XFS subsystem. Remove the second initialisation
    call.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit e69522a8cc51fbefbfe9d178ad177f7b6ca00ebd
Author: Joe Perches <joe@xxxxxxxxxxx>
Date:   Tue May 3 20:14:44 2011 +0000

    xfs: kill off xfs_printk()
    
    xfs_alert_tag() can be defined using xfs_alert(), and thereby avoid
    using xfs_printk() altogether.  This is the only remaining use of
    xfs_printk(), so changing it this way means xfs_printk() can simply
    be eliminated.can simply be eliminated.can simply be eliminated.can
    simply be eliminated.can simply be eliminated.can simply be
    eliminated.can simply be eliminated.can simply be eliminated.can
    simply be eliminated.
    
    Also add format checking to the non-debug inline function xfs_debug.
    Miscellaneous function prototype argument alignment.
    
    (Updated to delete the definition of xfs_printk(), which is
    no longer used or needed.)
    
    Signed-off-by: Joe Perches <joe@xxxxxxxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit e4d3c4a43b595d5124ae824d300626e6489ae857
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri May 6 02:54:08 2011 +0000

    xfs: fix race condition in AIL push trigger
    
    The recent conversion of the xfsaild functionality to a work queue
    introduced a hard-to-hit log space grant hang. One is caused by a
    race condition in determining whether there is a psh in progress or
    not.
    
    The XFS_AIL_PUSHING_BIT is used to determine whether a push is
    currently in progress.  When the AIL push work completes, it checked
    whether the target changed and cleared the PUSHING bit to allow a
    new push to be requeued. The race condition is as follows:
    
        Thread 1                push work
    
        smp_wmb()
                                smp_rmb()
                                check ailp->xa_target unchanged
        update ailp->xa_target
        test/set PUSHING bit
        does not queue
                                clear PUSHING bit
                                does not requeue
    
    Now that the push target is updated, new attempts to push the AIL
    will not trigger as the push target will be the same, and hence
    despite trying to push the AIL we won't ever wake it again.
    
    The fix is to ensure that the AIL push work clears the PUSHING bit
    before it checks if the target is unchanged.
    
    As a result, both push triggers operate on the same test/set bit
    criteria, so even if we race in the push work and miss the target
    update, the thread requesting the push will still set the PUSHING
    bit and queue the push work to occur. For safety sake, the same
    queue check is done if the push work detects the target change,
    though only one of the two will will queue new work due to the use
    of test_and_set_bit() checks.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Alex Elder <aelder@xxxxxxx>

commit fd5670f22fce247754243cf2ed41941e5762d990
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri May 6 02:54:07 2011 +0000

    xfs: make AIL target updates and compares 32bit safe.
    
    The recent conversion of the xfsaild functionality to a work queue
    introduced a hard-to-hit log space grant hang. One of the problems
    noticed was that updates of the push target are not 32 bit safe as
    the target is a 64 bit value.
    
    We cannot copy a 64 bit LSN without the possibility of corrupting
    the result when racing with another updating thread. We have
    function to do this update safely without needing to care about
    32/64 bit issues - xfs_trans_ail_copy_lsn() - so use that when
    updating the AIL push target.
    
    Also move the reading of the target in the push work inside the AIL
    lock, and use XFS_LSN_CMP() for the unlocked comparison during work
    termination to close read holes as well.
    
    Signed-off-by: Dave Chinner <david@xxxxxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Alex Elder <aelder@xxxxxxx>

commit cb64026b6e8af50db598ec7c3f59d504259b00bb
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri May 6 02:54:06 2011 +0000

    xfs: always push the AIL to the target
    
    The recent conversion of the xfsaild functionality to a work queue
    introduced a hard-to-hit log space grant hang. One of the problems
    discovered is a target mismatch between the item pushing loop and
    the target itself.
    
    The push trigger checks for the target increasing (i.e. new target >
    current) while the push loop only pushes items that have a LSN <
    current. As a result, we can get the situation where the push target
    is X, the items at the tail of the AIL have LSN X and they don't get
    pushed. The push work then completes thinking it is done, and cannot
    be restarted until the push target increases to >= X + 1. If the
    push target then never increases (because the tail is not moving),
    then we never run the push work again and we stall.
    
    Fix it by making sure log items with a LSN that matches the target
    exactly are pushed during the loop.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Alex Elder <aelder@xxxxxxx>

commit ea35a20021f8497390d05b93271b4d675516c654
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri May 6 02:54:05 2011 +0000

    xfs: exit AIL push work correctly when AIL is empty
    
    The recent conversion of the xfsaild functionality to a work queue
    introduced a hard-to-hit log space grant hang. The main cause is a
    regression where a work exit path fails to clear the PUSHING state
    and recheck the target correctly.
    
    Make both exit paths do the same PUSHING bit clearing and target
    checking when the "no more work to be done" condition is hit.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Alex Elder <aelder@xxxxxxx>

commit b223221956675ce8a7b436d198ced974bb388571
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri May 6 02:54:04 2011 +0000

    xfs: ensure reclaim cursor is reset correctly at end of AG
    
    On a 32 bit highmem PowerPC machine, the XFS inode cache was growing
    without bound and exhausting low memory causing the OOM killer to be
    triggered. After some effort, the problem was reproduced on a 32 bit
    x86 highmem machine.
    
    The problem is that the per-ag inode reclaim index cursor was not
    getting reset to the start of the AG if the radix tree tag lookup
    found no more reclaimable inodes. Hence every further reclaim
    attempt started at the same index beyond where any reclaimable
    inodes lay, and no further background reclaim ever occurred from the
    AG.
    
    Without background inode reclaim the VM driven cache shrinker
    simply cannot keep up with cache growth, and OOM is the result.
    
    While the change that exposed the problem was the conversion of the
    inode reclaim to use work queues for background reclaim, it was not
    the cause of the bug. The bug was introduced when the cursor code
    was added, just waiting for some weird configuration to strike....
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Tested-By: Christian Kujau <lists@xxxxxxxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Alex Elder <aelder@xxxxxxx>

commit 8c1fdd0be5498f852e00c5fbd9cb0c3969e46cc6
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Thu Apr 21 13:21:03 2011 +0000

    xfs: add an x86 compat handler for XFS_IOC_ZERO_RANGE
    
    XFS_IOC_ZERO_RANGE uses struct xfs_flock64, and thus requires argument
    translation for 32-bit binaries on x86.  Add the required
    XFS_IOC_ZERO_RANGE_32 defined and add it to the list of commands that
    require xfs_flock64 translation.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit 1a18a29478a38e5df382cd299f636187fde773ab
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Apr 24 19:02:58 2011 +0000

    xfs: fix compiler warning in xfs_trace.h
    
    xfs_fsblock_t may be a 32-bit type on if XFS_BIG_BLKNOS is not set,
    make sure to cast a value of this type to an unsigned long long
    before using the ll printk qualifier.
    
    Reported-by: Randy Dunlap <randy.dunlap@xxxxxxxxxx>
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit 45c51b99943c4c74165b19dc2f96e8ba93bdecb9
Author: David Sterba <dsterba@xxxxxxx>
Date:   Wed Apr 13 22:03:28 2011 +0000

    xfs: cleanup duplicate initializations
    
    follow these guidelines:
    - leave initialization in the declaration block if it fits the line
    - move to the code where it's more suitable ('for' init block)
    
    The last chunk was modified from David's original to be a correct
    fix for what appeared to be a duplicate initialization.
    
    Signed-off-by: David Sterba <dsterba@xxxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>

commit 8a072a4d4c6a5b6ec32836c467d2996393c76c6f
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Apr 24 19:06:17 2011 +0000

    xfs: reduce the number of pagb_lock roundtrips in xfs_alloc_clear_busy
    
    Instead of finding the per-ag and then taking and releasing the pagb_lock
    for every single busy extent completed sort the list of busy extents and
    only switch betweens AGs where nessecary.  This becomes especially important
    with the online discard support which will hit this lock more often.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit 97d3ac75e5e0ebf7ca38ae74cebd201c09b97ab2
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Apr 24 19:06:16 2011 +0000

    xfs: exact busy extent tracking
    
    Update the extent tree in case we have to reuse a busy extent, so that it
    always is kept uptodate.  This is done by replacing the busy list searches
    with a new xfs_alloc_busy_reuse helper, which updates the busy extent tree
    in case of a reuse.  This allows us to allow reusing metadata extents
    unconditionally, and thus avoid log forces especially for allocation btree
    blocks.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit e26f0501cf743a4289603501413f97ffcb4612f2
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Apr 24 19:06:15 2011 +0000

    xfs: do not immediately reuse busy extent ranges
    
    Every time we reallocate a busy extent, we cause a synchronous log force
    to occur to ensure the freeing transaction is on disk before we continue
    and use the newly allocated extent.  This is extremely sub-optimal as we
    have to mark every transaction with blocks that get reused as synchronous.
    
    Instead of searching the busy extent list after deciding on the extent to
    allocate, check each candidate extent during the allocation decisions as
    to whether they are in the busy list.  If they are in the busy list, we
    trim the busy range out of the extent we have found and determine if that
    trimmed range is still OK for allocation. In many cases, this check can
    be incorporated into the allocation extent alignment code which already
    does trimming of the found extent before determining if it is a valid
    candidate for allocation.
    
    Based on earlier patches from Dave Chinner.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

commit a870acd9b2671de56514a430edfa7867823c31c9
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Apr 24 19:06:14 2011 +0000

    xfs: optimize AGFL refills
    
    While we need to make sure we do not reuse busy extents, there is no need
    to force out busy extents when moving them between the AGFL and the
    freespace btree as we still take care of that when doing the real 
allocation.
    
    To avoid the log force when just moving extents from the different free
    space tracking structures, move the busy search out of
    xfs_alloc_get_freelist into the callers that need it, and move the busy
    list insert from xfs_free_ag_extent which is used both by AGFL refills
    and real allocation to xfs_free_extent, which is only used by the latter.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Alex Elder <aelder@xxxxxxx>

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

Summary of changes:
 fs/xfs/linux-2.6/xfs_buf.c     |   22 +-
 fs/xfs/linux-2.6/xfs_buf.h     |    1 +
 fs/xfs/linux-2.6/xfs_ioctl32.c |    3 +-
 fs/xfs/linux-2.6/xfs_ioctl32.h |    1 +
 fs/xfs/linux-2.6/xfs_linux.h   |    1 +
 fs/xfs/linux-2.6/xfs_message.c |   20 +-
 fs/xfs/linux-2.6/xfs_message.h |    7 +-
 fs/xfs/linux-2.6/xfs_super.c   |    4 -
 fs/xfs/linux-2.6/xfs_sync.c    |   10 +
 fs/xfs/linux-2.6/xfs_trace.h   |   76 ++---
 fs/xfs/xfs_ag.h                |    1 -
 fs/xfs/xfs_alloc.c             |  844 +++++++++++++++++++++++++++------------
 fs/xfs/xfs_alloc.h             |   15 +-
 fs/xfs/xfs_alloc_btree.c       |   13 +-
 fs/xfs/xfs_dfrag.c             |    6 +-
 fs/xfs/xfs_inode.c             |    2 +-
 fs/xfs/xfs_inode_item.c        |    1 -
 fs/xfs/xfs_log.c               |   15 +-
 fs/xfs/xfs_log.h               |    2 -
 fs/xfs/xfs_log_cil.c           |    5 +-
 fs/xfs/xfs_log_priv.h          |    2 +
 fs/xfs/xfs_log_recover.c       |   75 ++--
 fs/xfs/xfs_mount.c             |    4 +-
 fs/xfs/xfs_trans.c             |    6 +-
 fs/xfs/xfs_types.h             |    2 -
 25 files changed, 721 insertions(+), 417 deletions(-)


hooks/post-receive
-- 
XFS development tree

<Prev in Thread] Current Thread [Next in Thread>
  • [XFS updates] XFS development tree branch, for-linus, updated. v2.6.38-10134-gbf59170, xfs <=