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
|