xfs
[Top] [All Lists]

[XFS updates] XFS development tree branch, for-next, updated. v3.5-rc1-2

To: xfs@xxxxxxxxxxx
Subject: [XFS updates] XFS development tree branch, for-next, updated. v3.5-rc1-21-g9b73bd7
From: xfs@xxxxxxxxxxx
Date: Sun, 1 Jul 2012 14:57:43 -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-next has been updated
  9b73bd7 xfs: factor buffer reading from xfs_dir2_leaf_getdents
  1d9025e xfs: remove struct xfs_dabuf and infrastructure
  3605431 xfs: use discontiguous xfs_buf support in dabuf wrappers
  372cc85 xfs: support discontiguous buffers in the xfs_buf_log_item
  de2a4f5 xfs: add discontiguous buffer support to transactions
  6dde270 xfs: add discontiguous buffer map interface
  3e85c86 xfs: convert internal buffer functions to pass maps
  cbb7baa xfs: separate buffer indexing from block map
  77c1a08 xfs: struct xfs_buf_log_format isn't variable sized.
      from  9a8d2fdbb47aaa1eaa136b89da5e5e6b60015c78 (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 9b73bd7b61f320ffe7bda0126592ccf836d7ef90
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri Jun 22 18:50:15 2012 +1000

    xfs: factor buffer reading from xfs_dir2_leaf_getdents
    
    The buffer reading code in xfs_dir2_leaf_getdents is complex and difficult 
to
    follow due to the readahead and all the context is carries. it is also badly
    indented and so difficult to read. Factor it out into a separate function to
    make it easier to understand and optimise in future patches.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 1d9025e56143c0c4aebebdb62e46618d3d284218
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri Jun 22 18:50:14 2012 +1000

    xfs: remove struct xfs_dabuf and infrastructure
    
    The struct xfs_dabuf now only tracks a single xfs_buf and all the
    information it holds can be gained directly from the xfs_buf. Hence
    we can remove the struct dabuf and pass the xfs_buf around
    everywhere.
    
    Kill the struct dabuf and the associated infrastructure.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 3605431fb9739a30ccd0c6380ae8e3c6f8e670a5
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri Jun 22 18:50:13 2012 +1000

    xfs: use discontiguous xfs_buf support in dabuf wrappers
    
    First step in converting the directory code to use native
    discontiguous buffers and replacing the dabuf construct.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 372cc85ec6820c91b4eeff303880f25cb5a00ab5
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri Jun 22 18:50:12 2012 +1000

    xfs: support discontiguous buffers in the xfs_buf_log_item
    
    discontigous buffer in separate buffer format structures. This means log
    recovery will recover all the changes on a per segment basis without
    requiring any knowledge of the fact that it was logged from a
    compound buffer.
    
    To do this, we need to be able to determine what buffer segment any
    given offset into the compound buffer sits over. This enables us to
    translate the dirty bitmap in the number of separate buffer format
    structures required.
    
    We also need to be able to determine the number of bitmap elements
    that a given buffer segment has, as this determines the size of the
    buffer format structure. Hence we need to be able to determine the
    both the start offset into the buffer and the length of a given
    segment to be able to calculate this.
    
    With this information, we can preallocate, build and format the
    correct log vector array for each segment in a compound buffer to
    appear exactly the same as individually logged buffers in the log.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit de2a4f59190303ff5b82ead2969968a325e61230
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri Jun 22 18:50:11 2012 +1000

    xfs: add discontiguous buffer support to transactions
    
    Now that the buffer cache supports discontiguous buffers, add
    support to the transaction buffer interface for getting and reading
    buffers.
    
    Note that this patch does not convert the buffer item logging to
    support discontiguous buffers. That will be done as a separate
    commit.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 6dde27077eaf590eac279627f74b7e4e40b864b2
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri Jun 22 18:50:10 2012 +1000

    xfs: add discontiguous buffer map interface
    
    With the internal interfaces supporting discontiguous buffer maps,
    add external lookup, read and get interfaces so they can start to be
    used.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 3e85c868a697805a3d4c7800a6bacdfc81d15cdf
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri Jun 22 18:50:09 2012 +1000

    xfs: convert internal buffer functions to pass maps
    
    While the external interface currently uses separate blockno/length
    variables, we need to move internal interfaces to passing and
    parsing vector maps. This will then allow us to add external
    interfaces to support discontiguous buffer maps as the internal code
    will already support them.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit cbb7baab285a540f173ef1ec3d5bcf9d0ad29d16
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri Jun 22 18:50:08 2012 +1000

    xfs: separate buffer indexing from block map
    
    To support discontiguous buffers in the buffer cache, we need to
    separate the cache index variables from the I/O map. While this is
    currently a 1:1 mapping, discontiguous buffer support will break
    this relationship.
    
    However, for caching purposes, we can still treat them the same as a
    contiguous buffer - the block number of the first block and the
    length of the buffer - as that is still a unique representation.
    Also, the only way we will ever access the discontiguous regions of
    buffers is via bulding the complete buffer in the first place, so
    using the initial block number and entire buffer length is a sane
    way to index the buffers.
    
    Add a block mapping vector construct to the xfs_buf and use it in
    the places where we are doing IO instead of the current
    b_bn/b_length variables.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 77c1a08fc9ece4cb130b9fd279738e799f0c2864
Author: Dave Chinner <dchinner@xxxxxxxxxx>
Date:   Fri Jun 22 18:50:07 2012 +1000

    xfs: struct xfs_buf_log_format isn't variable sized.
    
    The struct xfs_buf_log_format wants to think the dirty bitmap is
    variable sized.  In fact, it is variable size on disk simply due to
    the way we map it from the in-memory structure, but we still just
    use a fixed size memory allocation for the in-memory structure.
    
    Hence it makes no sense to set the function up as a variable sized
    structure when we already know it's maximum size, and we always
    allocate it as such. Simplify the structure by making the dirty
    bitmap a fixed sized array and just using the size of the structure
    for the allocation size.
    
    This will make it much simpler to allocate and manipulate an array
    of format structures for discontiguous buffer support.
    
    The previous struct xfs_buf_log_item size according to
    /proc/slabinfo was 224 bytes. pahole doesn't give the same size
    because of the variable size definition. With this modification,
    pahole reports the same as /proc/slabinfo:
    
        /* size: 224, cachelines: 4, members: 6 */
    
    Because the xfs_buf_log_item size is now determined by the maximum
    supported block size we introduce a dependency on xfs_alloc_btree.h.
    Avoid this dependency by moving the idefines for the maximum block
    sizes supported to xfs_types.h with all the other max/min type
    defines to avoid any new dependencies.
    
    Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Reviewed-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

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

Summary of changes:
 fs/xfs/xfs_alloc_btree.h |   14 -
 fs/xfs/xfs_attr.c        |   78 ++---
 fs/xfs/xfs_attr_leaf.c   |  255 +++++++-------
 fs/xfs/xfs_attr_leaf.h   |   21 +-
 fs/xfs/xfs_buf.c         |  240 ++++++++++----
 fs/xfs/xfs_buf.h         |  116 ++++++-
 fs/xfs/xfs_buf_item.c    |  345 +++++++++++++------
 fs/xfs/xfs_buf_item.h    |   38 ++-
 fs/xfs/xfs_da_btree.c    |  823 +++++++++++++++++++---------------------------
 fs/xfs/xfs_da_btree.h    |   36 +-
 fs/xfs/xfs_dir2.c        |    4 +-
 fs/xfs/xfs_dir2_block.c  |  118 +++----
 fs/xfs/xfs_dir2_data.c   |   50 +--
 fs/xfs/xfs_dir2_leaf.c   |  621 +++++++++++++++++-----------------
 fs/xfs/xfs_dir2_node.c   |  236 ++++++-------
 fs/xfs/xfs_dir2_priv.h   |   46 +--
 fs/xfs/xfs_dir2_sf.c     |    4 +-
 fs/xfs/xfs_super.c       |   14 +-
 fs/xfs/xfs_trans.h       |   50 ++-
 fs/xfs/xfs_trans_buf.c   |   68 ++--
 fs/xfs/xfs_types.h       |   14 +
 21 files changed, 1679 insertions(+), 1512 deletions(-)


hooks/post-receive
-- 
XFS development tree

<Prev in Thread] Current Thread [Next in Thread>
  • [XFS updates] XFS development tree branch, for-next, updated. v3.5-rc1-21-g9b73bd7, xfs <=