lkml.org 
[lkml]   [2010]   [Aug]   [5]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[PATCH 04/13] writeback: dont redirty tail an inode with dirty pages
    This extends commit b3af9468ae (writeback: don't delay inodes redirtied
    by a fast dirtier) to the !kupdate case.

    It also simplifies logic. Note that the I_DIRTY_PAGES test/handling is
    merged into the PAGECACHE_TAG_DIRTY case. I_DIRTY_PAGES (at the line
    removed by this patch) means there are _new_ pages get dirtied during
    writeback, while PAGECACHE_TAG_DIRTY means there are dirty pages. In
    this sense, the PAGECACHE_TAG_DIRTY test covers the I_DIRTY_PAGES case.

    In *_set_page_dirty*(), PAGECACHE_TAG_DIRTY is set racelessly, while
    I_DIRTY_PAGES might be set on the inode for a page just truncated. It
    has no real impact on this patch -- it's actually slightly better now.

    afs_fsync() always set I_DIRTY_PAGES after calling afs_writepages(),
    maybe to keep the inode in the dirty list. That's a different code path,
    so won't impact the requeue-vs-redirty timing here permenantly.

    CC: David Howells <dhowells@redhat.com>
    CC: Dave Chinner <david@fromorbit.com>
    CC: Christoph Hellwig <hch@infradead.org>
    Acked-by: Jan Kara <jack@suse.cz>
    Signed-off-by: Wu Fengguang <fengguang.wu@intel.com>
    ---
    fs/fs-writeback.c | 22 +++++++++-------------
    1 file changed, 9 insertions(+), 13 deletions(-)

    --- linux-next.orig/fs/fs-writeback.c 2010-07-11 09:13:30.000000000 +0800
    +++ linux-next/fs/fs-writeback.c 2010-07-12 23:26:06.000000000 +0800
    @@ -367,18 +367,7 @@ writeback_single_inode(struct inode *ino
    spin_lock(&inode_lock);
    inode->i_state &= ~I_SYNC;
    if (!(inode->i_state & I_FREEING)) {
    - if ((inode->i_state & I_DIRTY_PAGES) && wbc->for_kupdate) {
    - /*
    - * More pages get dirtied by a fast dirtier.
    - */
    - goto select_queue;
    - } else if (inode->i_state & I_DIRTY) {
    - /*
    - * At least XFS will redirty the inode during the
    - * writeback (delalloc) and on io completion (isize).
    - */
    - redirty_tail(inode);
    - } else if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
    + if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
    /*
    * We didn't write back all the pages. nfs_writepages()
    * sometimes bales out without doing anything. Redirty
    @@ -400,7 +389,6 @@ writeback_single_inode(struct inode *ino
    * soon as the queue becomes uncongested.
    */
    inode->i_state |= I_DIRTY_PAGES;
    -select_queue:
    if (wbc->nr_to_write <= 0) {
    /*
    * slice used up: queue for next turn
    @@ -423,6 +411,14 @@ select_queue:
    inode->i_state |= I_DIRTY_PAGES;
    redirty_tail(inode);
    }
    + } else if (inode->i_state & I_DIRTY) {
    + /*
    + * Filesystems can dirty the inode during writeback
    + * operations, such as delayed allocation during
    + * submission or metadata updates after data IO
    + * completion.
    + */
    + redirty_tail(inode);
    } else if (atomic_read(&inode->i_count)) {
    /*
    * The inode is clean, inuse



    \
     
     \ /
      Last update: 2010-08-05 18:33    [W:0.025 / U:31.692 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site