xfs
[Top] [All Lists]

[XFS updates] XFS development tree branch, master, updated. v3.2-rc1-930

To: xfs@xxxxxxxxxxx
Subject: [XFS updates] XFS development tree branch, master, updated. v3.2-rc1-9302-gd060646
From: xfs@xxxxxxxxxxx
Date: Tue, 17 Jan 2012 15:06:59 -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
  d060646 xfs: cleanup xfs_file_aio_write
  5bf1f26 xfs: always return with the iolock held from xfs_file_aio_write_checks
  2813d68 xfs: remove the i_new_size field in struct xfs_inode
  ce7ae15 xfs: remove the i_size field in struct xfs_inode
  f392e63 xfs: replace i_pin_wait with a bit waitqueue
  474fce0 xfs: replace i_flock with a sleeping bitlock
  49e4c70 xfs: make i_flags an unsigned long
  8096b1e xfs: remove the if_ext_max field in struct xfs_ifork
  3d2b312 xfs: remove the unused dm_attrs structure
  bf322d9 xfs: cleanup xfs_iomap_eof_align_last_fsb
  673e8e5 xfs: remove xfs_itruncate_data
      from  099469502f62fbe0d7e4f0b83a2f22538367f734 (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 d060646436233912178e6b9e3a7f30a41214220f
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Dec 18 20:00:14 2011 +0000

    xfs: cleanup xfs_file_aio_write
    
    With all the size field updates out of the way xfs_file_aio_write can
    be further simplified by pushing all iolock handling into
    xfs_file_dio_aio_write and xfs_file_buffered_aio_write and using
    the generic generic_write_sync helper for synchronous writes.
    
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 5bf1f26227a59b9634e95eb3c7c012b766e5e6a0
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Dec 18 20:00:13 2011 +0000

    xfs: always return with the iolock held from xfs_file_aio_write_checks
    
    While xfs_iunlock is fine with 0 lockflags the calling conventions are much
    cleaner if xfs_file_aio_write_checks never returns without the iolock held.
    
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 2813d682e8e6a278f94817429afd46b30875bb6e
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Dec 18 20:00:12 2011 +0000

    xfs: remove the i_new_size field in struct xfs_inode
    
    Now that we use the VFS i_size field throughout XFS there is no need for the
    i_new_size field any more given that the VFS i_size field gets updated
    in ->write_end before unlocking the page, and thus is always uptodate when
    writeback could see a page.  Removing i_new_size also has the advantage that
    we will never have to trim back di_size during a failed buffered write,
    given that it never gets updated past i_size.
    
    Note that currently the generic direct I/O code only updates i_size after
    calling our end_io handler, which requires a small workaround to make
    sure di_size actually makes it to disk.  I hope to fix this properly in
    the generic code.
    
    A downside is that we lose the support for parallel non-overlapping O_DIRECT
    appending writes that recently was added.  I don't think keeping the complex
    and fragile i_new_size infrastructure for this is a good tradeoff - if we
    really care about parallel appending writers we should investigate turning
    the iolock into a range lock, which would also allow for parallel
    non-overlapping buffered writers.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit ce7ae151ddada3dbf67301464343c154903166b3
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Dec 18 20:00:11 2011 +0000

    xfs: remove the i_size field in struct xfs_inode
    
    There is no fundamental need to keep an in-memory inode size copy in the XFS
    inode.  We already have the on-disk value in the dinode, and the separate
    in-memory copy that we need for regular files only in the XFS inode.
    
    Remove the xfs_inode i_size field and change the XFS_ISIZE macro to use the
    VFS inode i_size field for regular files.  Switch code that was directly
    accessing the i_size field in the xfs_inode to XFS_ISIZE, or in cases where
    we are limited to regular files direct access of the VFS inode i_size field.
    
    This also allows dropping some fairly complicated code in the write path
    which dealt with keeping the xfs_inode i_size uptodate with the VFS i_size
    that is getting updated inside ->write_end.
    
    Note that we do not bother resetting the VFS i_size when truncating a file
    that gets freed to zero as there is no point in doing so because the VFS 
inode
    is no longer in use at this point.  Just relax the assert in xfs_ifree to
    only check the on-disk size instead.
    
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit f392e6319a4e9a028b0c8b48f000bb01d660ad53
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Dec 18 20:00:10 2011 +0000

    xfs: replace i_pin_wait with a bit waitqueue
    
    Replace i_pin_wait, which is only used during synchronous inode flushing
    with a bit waitqueue.  This trades off a much smaller inode against
    slightly slower wakeup performance, and saves 12 (32-bit) or 20 (64-bit)
    bytes in the XFS inode.
    
    Reviewed-by: Alex Elder <aelder@xxxxxxx>
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 474fce067521a40dbacc722e8ba119e81c2d31bf
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Dec 18 20:00:09 2011 +0000

    xfs: replace i_flock with a sleeping bitlock
    
    We almost never block on i_flock, the exception is synchronous inode
    flushing.  Instead of bloating the inode with a 16/24-byte completion
    that we abuse as a semaphore just implement it as a bitlock that uses
    a bit waitqueue for the rare sleeping path.  This primarily is a
    tradeoff between a much smaller inode and a faster non-blocking
    path vs faster wakeups, and we are much better off with the former.
    
    A small downside is that we will lose lockdep checking for i_flock, but
    given that it's always taken inside the ilock that should be acceptable.
    
    Note that for example the inode writeback locking is implemented in a
    very similar way.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Alex Elder <aelder@xxxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 49e4c70e52a2bc2090e5a4e003e2888af21d6a2b
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Dec 18 20:00:08 2011 +0000

    xfs: make i_flags an unsigned long
    
    To be used for bit wakeup i_flags needs to be an unsigned long or we'll
    run into trouble on big endian systems.  Because of the 1-byte i_update
    field right after it this actually causes a fairly large size increase
    on its own (4 or 8 bytes), but that increase will be more than offset
    by the next two patches.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Alex Elder <aelder@xxxxxxx>
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 8096b1ebb59b94b3bc6abb6b7d121419e83447ba
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Dec 18 20:00:07 2011 +0000

    xfs: remove the if_ext_max field in struct xfs_ifork
    
    We spent a lot of effort to maintain this field, but it always equals to the
    fork size divided by the constant size of an extent.  The prime use of it is
    to assert that the two stay in sync.  Just divide the fork size by the 
extent
    size in the few places that we actually use it and remove the overhead
    of maintaining it.  Also introduce a few helpers to consolidate the places
    where we actually care about the value.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 3d2b3129c2c48cf0153e0f2058cf87e4b45ca3ac
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Dec 18 20:00:06 2011 +0000

    xfs: remove the unused dm_attrs structure
    
    .. and the just as dead bhv_desc forward declaration while we're at it.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Alex Elder <aelder@xxxxxxx>
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit bf322d983e540f66517db85b6870017613bb1e8d
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Dec 18 20:00:05 2011 +0000

    xfs: cleanup xfs_iomap_eof_align_last_fsb
    
    Replace the nasty if, else if, elseif condition with more natural C flow
    that expressed the logic we want here better.
    
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

commit 673e8e597c06eb81954bf21a10f5cce74a1de8f1
Author: Christoph Hellwig <hch@xxxxxxxxxxxxx>
Date:   Sun Dec 18 20:00:04 2011 +0000

    xfs: remove xfs_itruncate_data
    
    This wrapper isn't overly useful, not to say rather confusing.
    
    Around the call to xfs_itruncate_extents it does:
    
     - add tracing
     - add a few asserts in debug builds
     - conditionally update the inode size in two places
     - log the inode
    
    Both the tracing and the inode logging can be moved to xfs_itruncate_extents
    as they are useful for the attribute fork as well - in fact the attr code
    already does an equivalent xfs_trans_log_inode call just after calling
    xfs_itruncate_extents.  The conditional size updates are a mess, and there
    was no reason to do them in two places anyway, as the first one was
    conditional on the inode having extents - but without extents we
    xfs_itruncate_extents would be a no-op and the placement wouldn't matter
    anyway.  Instead move the size assignments and the asserts that make sense
    to the callers that want it.
    
    As a side effect of this clean up xfs_setattr_size by introducing variables
    for the old and new inode size, and moving the size updates into a common
    place.
    
    Reviewed-by: Dave Chinner <dchinner@xxxxxxxxxx>
    Signed-off-by: Christoph Hellwig <hch@xxxxxx>
    Signed-off-by: Ben Myers <bpm@xxxxxxx>

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

Summary of changes:
 fs/xfs/xfs_aops.c        |   29 ++++---
 fs/xfs/xfs_attr.c        |    4 -
 fs/xfs/xfs_attr_leaf.c   |    9 --
 fs/xfs/xfs_bmap.c        |  116 +++++++++++++---------------
 fs/xfs/xfs_dfrag.c       |   43 +++++-----
 fs/xfs/xfs_file.c        |  184 ++++++++++++-------------------------------
 fs/xfs/xfs_fs_subr.c     |    2 +-
 fs/xfs/xfs_iget.c        |   24 ++++--
 fs/xfs/xfs_inode.c       |  193 +++++++++++-----------------------------------
 fs/xfs/xfs_inode.h       |  114 ++++++++++++++++-----------
 fs/xfs/xfs_inode_item.c  |    8 +-
 fs/xfs/xfs_iomap.c       |   46 ++++++------
 fs/xfs/xfs_iops.c        |   46 +++++++----
 fs/xfs/xfs_qm_syscalls.c |    8 ++-
 fs/xfs/xfs_super.c       |    8 --
 fs/xfs/xfs_sync.c        |    9 +-
 fs/xfs/xfs_trace.h       |   29 ++-----
 fs/xfs/xfs_vnodeops.c    |   44 +++++++----
 18 files changed, 374 insertions(+), 542 deletions(-)


hooks/post-receive
-- 
XFS development tree

<Prev in Thread] Current Thread [Next in Thread>
  • [XFS updates] XFS development tree branch, master, updated. v3.2-rc1-9302-gd060646, xfs <=