* [PATCH 0/2] XFS: Run kernel threads on demand @ 2010-01-02 2:43 Dave Chinner 2010-01-02 2:43 ` [PATCH 1/2] XFS: Don't wake the aild once per second Dave Chinner 2010-01-02 2:43 ` [PATCH 2/2] XFS: Don't wake xfsbufd when idle Dave Chinner 0 siblings, 2 replies; 7+ messages in thread From: Dave Chinner @ 2010-01-02 2:43 UTC (permalink / raw) To: xfs We run the xfsbufd and the xfsaild once a second even when there is no work to do. Make them demand driven so that we don't needlessly wake idle CPUs to do nothing. This should make power misers with XFS filesystems happy. _______________________________________________ xfs mailing list xfs@oss.sgi.com http://oss.sgi.com/mailman/listinfo/xfs ^ permalink raw reply [flat|nested] 7+ messages in thread
* [PATCH 1/2] XFS: Don't wake the aild once per second 2010-01-02 2:43 [PATCH 0/2] XFS: Run kernel threads on demand Dave Chinner @ 2010-01-02 2:43 ` Dave Chinner 2010-01-04 15:16 ` Christoph Hellwig 2010-01-02 2:43 ` [PATCH 2/2] XFS: Don't wake xfsbufd when idle Dave Chinner 1 sibling, 1 reply; 7+ messages in thread From: Dave Chinner @ 2010-01-02 2:43 UTC (permalink / raw) To: xfs Now that the AIL push algorithm is traversal safe, we don't need a watchdog function in the xfsaild to catch pushes that fail to make progress. Remove the watchdog timeout and make pushes purely driven by demand. This will remove the once-per-second wakeup that is seen when the filesystem is idle and make laptop power misers happy. Signed-off-by: Dave Chinner <david@fromorbit.com> --- fs/xfs/linux-2.6/xfs_super.c | 7 +++---- fs/xfs/xfs_trans_ail.c | 17 ++++++++++------- 2 files changed, 13 insertions(+), 11 deletions(-) diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c index 09783cc..84ce77a 100644 --- a/fs/xfs/linux-2.6/xfs_super.c +++ b/fs/xfs/linux-2.6/xfs_super.c @@ -877,12 +877,11 @@ xfsaild( { struct xfs_ail *ailp = data; xfs_lsn_t last_pushed_lsn = 0; - long tout = 0; + long tout = 1000; /* milliseconds */ while (!kthread_should_stop()) { - if (tout) - schedule_timeout_interruptible(msecs_to_jiffies(tout)); - tout = 1000; + tout = !tout ? MAX_SCHEDULE_TIMEOUT : msecs_to_jiffies(tout); + schedule_timeout_interruptible(tout); /* swsusp */ try_to_freeze(); diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c index 2ffc570..8ca123e 100644 --- a/fs/xfs/xfs_trans_ail.c +++ b/fs/xfs/xfs_trans_ail.c @@ -237,14 +237,15 @@ out: } /* - * Function that does the work of pushing on the AIL + * xfsaild_push does the work of pushing on the AIL. Returning a timeout of + * zero indicates that the caller should sleep until woken. */ long xfsaild_push( struct xfs_ail *ailp, xfs_lsn_t *last_lsn) { - long tout = 1000; /* milliseconds */ + long tout = 0; xfs_lsn_t last_pushed_lsn = *last_lsn; xfs_lsn_t target = ailp->xa_target; xfs_lsn_t lsn; @@ -279,7 +280,6 @@ xfsaild_push( * prevents use from spinning when we can't do anything or there is * lots of contention on the AIL lists. */ - tout = 10; lsn = lip->li_lsn; flush_log = stuck = count = 0; while ((XFS_LSN_CMP(lip->li_lsn, target) < 0)) { @@ -376,14 +376,14 @@ xfsaild_push( if (!count) { /* We're past our target or empty, so idle */ - tout = 1000; + tout = 0; } else if (XFS_LSN_CMP(lsn, target) >= 0) { /* * We reached the target so wait a bit longer for I/O to * complete and remove pushed items from the AIL before we * start the next scan from the start of the AIL. */ - tout += 20; + tout = 50; last_pushed_lsn = 0; } else if ((stuck * 100) / count > 90) { /* @@ -395,11 +395,14 @@ xfsaild_push( * Backoff a bit more to allow some I/O to complete before * continuing from where we were. */ - tout += 10; + tout = 20; + } else { + /* more to do, but wait a short while before continuing */ + tout = 10; } *last_lsn = last_pushed_lsn; return tout; -} /* xfsaild_push */ +} /* -- 1.6.5 _______________________________________________ xfs mailing list xfs@oss.sgi.com http://oss.sgi.com/mailman/listinfo/xfs ^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [PATCH 1/2] XFS: Don't wake the aild once per second 2010-01-02 2:43 ` [PATCH 1/2] XFS: Don't wake the aild once per second Dave Chinner @ 2010-01-04 15:16 ` Christoph Hellwig 2010-01-04 23:28 ` Dave Chinner 0 siblings, 1 reply; 7+ messages in thread From: Christoph Hellwig @ 2010-01-04 15:16 UTC (permalink / raw) To: Dave Chinner; +Cc: xfs On Sat, Jan 02, 2010 at 01:43:34PM +1100, Dave Chinner wrote: > Now that the AIL push algorithm is traversal safe, we don't need a > watchdog function in the xfsaild to catch pushes that fail to make > progress. Remove the watchdog timeout and make pushes purely driven > by demand. This will remove the once-per-second wakeup that is seen > when the filesystem is idle and make laptop power misers happy. Looks good, but a few nitpicks below: > - long tout = 0; > + long tout = 1000; /* milliseconds */ Why do we use a timeout when starting up now? If there's a good reason for it the reason at least should be explained in a comment here. > while (!kthread_should_stop()) { > - if (tout) > - schedule_timeout_interruptible(msecs_to_jiffies(tout)); > - tout = 1000; > + tout = !tout ? MAX_SCHEDULE_TIMEOUT : msecs_to_jiffies(tout); Why not just: schedule_timeout_interruptible(tout ? msecs_to_jiffies(tout) : MAX_SCHEDULE_TIMEOUT); that avoids the assignment of different units to the same variable, and also the negation. > + long tout = 0; > xfs_lsn_t last_pushed_lsn = *last_lsn; > xfs_lsn_t target = ailp->xa_target; > xfs_lsn_t lsn; > @@ -279,7 +280,6 @@ xfsaild_push( > * prevents use from spinning when we can't do anything or there is > * lots of contention on the AIL lists. > */ > - tout = 10; > lsn = lip->li_lsn; > flush_log = stuck = count = 0; > while ((XFS_LSN_CMP(lip->li_lsn, target) < 0)) { > @@ -376,14 +376,14 @@ xfsaild_push( > > if (!count) { > /* We're past our target or empty, so idle */ > - tout = 1000; > + tout = 0; tout always is 0 here already. > } else if (XFS_LSN_CMP(lsn, target) >= 0) { > /* > * We reached the target so wait a bit longer for I/O to > * complete and remove pushed items from the AIL before we > * start the next scan from the start of the AIL. > */ > - tout += 20; > + tout = 50; > last_pushed_lsn = 0; > } else if ((stuck * 100) / count > 90) { > /* > @@ -395,11 +395,14 @@ xfsaild_push( > * Backoff a bit more to allow some I/O to complete before > * continuing from where we were. > */ > - tout += 10; > + tout = 20; > + } else { > + /* more to do, but wait a short while before continuing */ > + tout = 10; > } > *last_lsn = last_pushed_lsn; > return tout; > -} /* xfsaild_push */ > +} All the += and co here is a bit confusing. We always return 0 now except for those last two cases that return 20 or 10. So I'd just change them to a tout = 10/20; _______________________________________________ xfs mailing list xfs@oss.sgi.com http://oss.sgi.com/mailman/listinfo/xfs ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH 1/2] XFS: Don't wake the aild once per second 2010-01-04 15:16 ` Christoph Hellwig @ 2010-01-04 23:28 ` Dave Chinner 0 siblings, 0 replies; 7+ messages in thread From: Dave Chinner @ 2010-01-04 23:28 UTC (permalink / raw) To: Christoph Hellwig; +Cc: xfs On Mon, Jan 04, 2010 at 10:16:16AM -0500, Christoph Hellwig wrote: > On Sat, Jan 02, 2010 at 01:43:34PM +1100, Dave Chinner wrote: > > Now that the AIL push algorithm is traversal safe, we don't need a > > watchdog function in the xfsaild to catch pushes that fail to make > > progress. Remove the watchdog timeout and make pushes purely driven > > by demand. This will remove the once-per-second wakeup that is seen > > when the filesystem is idle and make laptop power misers happy. > > Looks good, but a few nitpicks below: > > > - long tout = 0; > > + long tout = 1000; /* milliseconds */ > > Why do we use a timeout when starting up now? If there's a good reason > for it the reason at least should be explained in a comment here. No good reason. > > while (!kthread_should_stop()) { > > - if (tout) > > - schedule_timeout_interruptible(msecs_to_jiffies(tout)); > > - tout = 1000; > > + tout = !tout ? MAX_SCHEDULE_TIMEOUT : msecs_to_jiffies(tout); > > Why not just: > > schedule_timeout_interruptible(tout ? > msecs_to_jiffies(tout) : MAX_SCHEDULE_TIMEOUT); > > that avoids the assignment of different units to the same variable, and > also the negation. Much cleaner. Fixed. > > + long tout = 0; > > xfs_lsn_t last_pushed_lsn = *last_lsn; > > xfs_lsn_t target = ailp->xa_target; > > xfs_lsn_t lsn; > > @@ -279,7 +280,6 @@ xfsaild_push( > > * prevents use from spinning when we can't do anything or there is > > * lots of contention on the AIL lists. > > */ > > - tout = 10; > > lsn = lip->li_lsn; > > flush_log = stuck = count = 0; > > while ((XFS_LSN_CMP(lip->li_lsn, target) < 0)) { > > @@ -376,14 +376,14 @@ xfsaild_push( > > > > if (!count) { > > /* We're past our target or empty, so idle */ > > - tout = 1000; > > + tout = 0; > > tout always is 0 here already. Good catch. Hmm - I just noticed that we should be resetting the last_lsn when we idle. I've fixed that now. > > } else if (XFS_LSN_CMP(lsn, target) >= 0) { > > /* > > * We reached the target so wait a bit longer for I/O to > > * complete and remove pushed items from the AIL before we > > * start the next scan from the start of the AIL. > > */ > > - tout += 20; > > + tout = 50; > > last_pushed_lsn = 0; > > } else if ((stuck * 100) / count > 90) { > > /* > > @@ -395,11 +395,14 @@ xfsaild_push( > > * Backoff a bit more to allow some I/O to complete before > > * continuing from where we were. > > */ > > - tout += 10; > > + tout = 20; > > + } else { > > + /* more to do, but wait a short while before continuing */ > > + tout = 10; > > } > > *last_lsn = last_pushed_lsn; > > return tout; > > -} /* xfsaild_push */ > > +} > > All the += and co here is a bit confusing. We always return 0 now > except for those last two cases that return 20 or 10. So I'd just > change them to a tout = 10/20; I'm not sure what you mean - isn't that what this patch does? i.e. now looks like: if idle tout = 0 else if we reach the target tout = 50 else if stuck tout = 20 else tout = 10 Updated patch below. Cheers, Dave. -- Dave Chinner david@fromorbit.com XFS: Don't wake the aild once per second Now that the AIL push algorithm is traversal safe, we don't need a watchdog function in the xfsaild to catch pushes that fail to make progress. Remove the watchdog timeout and make pushes purely driven by demand. This will remove the once-per-second wakeup that is seen when the filesystem is idle and make laptop power misers happy. Signed-off-by: Dave Chinner <david@fromorbit.com> --- fs/xfs/linux-2.6/xfs_super.c | 7 +++---- fs/xfs/xfs_trans_ail.c | 19 +++++++++++-------- 2 files changed, 14 insertions(+), 12 deletions(-) diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c index 09783cc..0a4fd0e 100644 --- a/fs/xfs/linux-2.6/xfs_super.c +++ b/fs/xfs/linux-2.6/xfs_super.c @@ -877,12 +877,11 @@ xfsaild( { struct xfs_ail *ailp = data; xfs_lsn_t last_pushed_lsn = 0; - long tout = 0; + long tout = 0; /* milliseconds */ while (!kthread_should_stop()) { - if (tout) - schedule_timeout_interruptible(msecs_to_jiffies(tout)); - tout = 1000; + schedule_timeout_interruptible(tout ? + msecs_to_jiffies(tout) : MAX_SCHEDULE_TIMEOUT); /* swsusp */ try_to_freeze(); diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c index 2ffc570..063dfbd 100644 --- a/fs/xfs/xfs_trans_ail.c +++ b/fs/xfs/xfs_trans_ail.c @@ -237,14 +237,15 @@ out: } /* - * Function that does the work of pushing on the AIL + * xfsaild_push does the work of pushing on the AIL. Returning a timeout of + * zero indicates that the caller should sleep until woken. */ long xfsaild_push( struct xfs_ail *ailp, xfs_lsn_t *last_lsn) { - long tout = 1000; /* milliseconds */ + long tout = 0; xfs_lsn_t last_pushed_lsn = *last_lsn; xfs_lsn_t target = ailp->xa_target; xfs_lsn_t lsn; @@ -262,7 +263,7 @@ xfsaild_push( */ xfs_trans_ail_cursor_done(ailp, cur); spin_unlock(&ailp->xa_lock); - last_pushed_lsn = 0; + *last_lsn = 0; return tout; } @@ -279,7 +280,6 @@ xfsaild_push( * prevents use from spinning when we can't do anything or there is * lots of contention on the AIL lists. */ - tout = 10; lsn = lip->li_lsn; flush_log = stuck = count = 0; while ((XFS_LSN_CMP(lip->li_lsn, target) < 0)) { @@ -376,14 +376,14 @@ xfsaild_push( if (!count) { /* We're past our target or empty, so idle */ - tout = 1000; + last_pushed_lsn = 0; } else if (XFS_LSN_CMP(lsn, target) >= 0) { /* * We reached the target so wait a bit longer for I/O to * complete and remove pushed items from the AIL before we * start the next scan from the start of the AIL. */ - tout += 20; + tout = 50; last_pushed_lsn = 0; } else if ((stuck * 100) / count > 90) { /* @@ -395,11 +395,14 @@ xfsaild_push( * Backoff a bit more to allow some I/O to complete before * continuing from where we were. */ - tout += 10; + tout = 20; + } else { + /* more to do, but wait a short while before continuing */ + tout = 10; } *last_lsn = last_pushed_lsn; return tout; -} /* xfsaild_push */ +} /* _______________________________________________ xfs mailing list xfs@oss.sgi.com http://oss.sgi.com/mailman/listinfo/xfs ^ permalink raw reply related [flat|nested] 7+ messages in thread
* [PATCH 2/2] XFS: Don't wake xfsbufd when idle 2010-01-02 2:43 [PATCH 0/2] XFS: Run kernel threads on demand Dave Chinner 2010-01-02 2:43 ` [PATCH 1/2] XFS: Don't wake the aild once per second Dave Chinner @ 2010-01-02 2:43 ` Dave Chinner 2010-01-04 15:20 ` Christoph Hellwig 1 sibling, 1 reply; 7+ messages in thread From: Dave Chinner @ 2010-01-02 2:43 UTC (permalink / raw) To: xfs The xfsbufd wakes every xfsbufd_centisecs (once per second by default) for each filesystem even when the filesystem is idle. If the xfsbufd has nothing to do, put it into a long term sleep and only wake it up when there is work pending (i.e. dirty buffers to flush soon). This will make laptop power misers happy. Signed-off-by: Dave Chinner <david@fromorbit.com> --- fs/xfs/linux-2.6/xfs_buf.c | 28 +++++++++++++++++++--------- 1 files changed, 19 insertions(+), 9 deletions(-) diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c index 77b8be8..759cbaf 100644 --- a/fs/xfs/linux-2.6/xfs_buf.c +++ b/fs/xfs/linux-2.6/xfs_buf.c @@ -43,10 +43,10 @@ static kmem_zone_t *xfs_buf_zone; STATIC int xfsbufd(void *); -STATIC int xfsbufd_wakeup(int, gfp_t); +STATIC int xfsbufd_wakeup_all(int, gfp_t); STATIC void xfs_buf_delwri_queue(xfs_buf_t *, int); static struct shrinker xfs_buf_shake = { - .shrink = xfsbufd_wakeup, + .shrink = xfsbufd_wakeup_all, .seeks = DEFAULT_SEEKS, }; @@ -385,7 +385,7 @@ _xfs_buf_lookup_pages( __func__, gfp_mask); XFS_STATS_INC(xb_page_retries); - xfsbufd_wakeup(0, gfp_mask); + xfsbufd_wakeup_all(0, gfp_mask); congestion_wait(BLK_RW_ASYNC, HZ/50); goto retry; } @@ -1595,6 +1595,11 @@ xfs_buf_delwri_queue( list_del(&bp->b_list); } + if (list_empty(dwq)) { + /* start xfsbufd as it has something to do now */ + wake_up_process(bp->b_target->bt_task); + } + bp->b_flags |= _XBF_DELWRI_Q; list_add_tail(&bp->b_list, dwq); bp->b_queuetime = jiffies; @@ -1634,7 +1639,7 @@ xfs_buf_runall_queues( } STATIC int -xfsbufd_wakeup( +xfsbufd_wakeup_all( int priority, gfp_t mask) { @@ -1644,6 +1649,8 @@ xfsbufd_wakeup( list_for_each_entry(btp, &xfs_buftarg_list, bt_list) { if (test_bit(XBT_FORCE_SLEEP, &btp->bt_flags)) continue; + if (list_empty(&btp->bt_delwrite_queue)) + continue; set_bit(XBT_FORCE_FLUSH, &btp->bt_flags); wake_up_process(btp->bt_task); } @@ -1708,6 +1715,9 @@ xfsbufd( set_freezable(); do { + long age = xfs_buf_age_centisecs * msecs_to_jiffies(10); + long tout = age; + if (unlikely(freezing(current))) { set_bit(XBT_FORCE_SLEEP, &target->bt_flags); refrigerator(); @@ -1715,12 +1725,12 @@ xfsbufd( clear_bit(XBT_FORCE_SLEEP, &target->bt_flags); } - schedule_timeout_interruptible( - xfs_buf_timer_centisecs * msecs_to_jiffies(10)); - - xfs_buf_delwri_split(target, &tmp, - xfs_buf_age_centisecs * msecs_to_jiffies(10)); + /* sleep for a long time if there is nothing to do. */ + if (list_empty(&target->bt_delwrite_queue)) + tout = MAX_SCHEDULE_TIMEOUT; + schedule_timeout_interruptible(tout); + xfs_buf_delwri_split(target, &tmp, age); count = 0; while (!list_empty(&tmp)) { bp = list_entry(tmp.next, xfs_buf_t, b_list); -- 1.6.5 _______________________________________________ xfs mailing list xfs@oss.sgi.com http://oss.sgi.com/mailman/listinfo/xfs ^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [PATCH 2/2] XFS: Don't wake xfsbufd when idle 2010-01-02 2:43 ` [PATCH 2/2] XFS: Don't wake xfsbufd when idle Dave Chinner @ 2010-01-04 15:20 ` Christoph Hellwig 2010-01-04 23:52 ` Dave Chinner 0 siblings, 1 reply; 7+ messages in thread From: Christoph Hellwig @ 2010-01-04 15:20 UTC (permalink / raw) To: Dave Chinner; +Cc: xfs On Sat, Jan 02, 2010 at 01:43:35PM +1100, Dave Chinner wrote: > The xfsbufd wakes every xfsbufd_centisecs (once per second by > default) for each filesystem even when the filesystem is idle. > If the xfsbufd has nothing to do, put it into a long term sleep > and only wake it up when there is work pending (i.e. dirty > buffers to flush soon). This will make laptop power misers happy. > > Signed-off-by: Dave Chinner <david@fromorbit.com> > --- > fs/xfs/linux-2.6/xfs_buf.c | 28 +++++++++++++++++++--------- > 1 files changed, 19 insertions(+), 9 deletions(-) > > STATIC int xfsbufd(void *); > -STATIC int xfsbufd_wakeup(int, gfp_t); > +STATIC int xfsbufd_wakeup_all(int, gfp_t); this rename seems unrelated to the rest of the patch. > @@ -1595,6 +1595,11 @@ xfs_buf_delwri_queue( > list_del(&bp->b_list); > } > > + if (list_empty(dwq)) { > + /* start xfsbufd as it has something to do now */ > + wake_up_process(bp->b_target->bt_task); > + } Does it make sense to wake xfsbufd before actually adding the item and unlocking the queue lock? Shouldn't this be defered until after the addition? _______________________________________________ xfs mailing list xfs@oss.sgi.com http://oss.sgi.com/mailman/listinfo/xfs ^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [PATCH 2/2] XFS: Don't wake xfsbufd when idle 2010-01-04 15:20 ` Christoph Hellwig @ 2010-01-04 23:52 ` Dave Chinner 0 siblings, 0 replies; 7+ messages in thread From: Dave Chinner @ 2010-01-04 23:52 UTC (permalink / raw) To: Christoph Hellwig; +Cc: xfs On Mon, Jan 04, 2010 at 10:20:48AM -0500, Christoph Hellwig wrote: > On Sat, Jan 02, 2010 at 01:43:35PM +1100, Dave Chinner wrote: > > The xfsbufd wakes every xfsbufd_centisecs (once per second by > > default) for each filesystem even when the filesystem is idle. > > If the xfsbufd has nothing to do, put it into a long term sleep > > and only wake it up when there is work pending (i.e. dirty > > buffers to flush soon). This will make laptop power misers happy. > > > > Signed-off-by: Dave Chinner <david@fromorbit.com> > > --- > > fs/xfs/linux-2.6/xfs_buf.c | 28 +++++++++++++++++++--------- > > 1 files changed, 19 insertions(+), 9 deletions(-) > > > > > STATIC int xfsbufd(void *); > > -STATIC int xfsbufd_wakeup(int, gfp_t); > > +STATIC int xfsbufd_wakeup_all(int, gfp_t); > > this rename seems unrelated to the rest of the patch. For memory reclaim we want to wake up the xfsbufd threads on every single filesystem to free up as much memory as possible. Hence with the addition of demand flushing we have a situation now where we can wakeup either a single xfsbufd or we need to wake up all of them. It seemed right to make the distinction clear by renaming the function. I can drop it if this doesn't make sense.... > > @@ -1595,6 +1595,11 @@ xfs_buf_delwri_queue( > > list_del(&bp->b_list); > > } > > > > + if (list_empty(dwq)) { > > + /* start xfsbufd as it has something to do now */ > > + wake_up_process(bp->b_target->bt_task); > > + } > > Does it make sense to wake xfsbufd before actually adding the item and > unlocking the queue lock? Shouldn't this be defered until after the > addition? I did it to avoid a temp var - if the xfsbufd runs before we finish here then is will spin on the lock until we have added the buffer to the list and dropped the lock. wake_up_process() is safe to call under a spinlock, so that is not an issue here. Also, the xfsbufd checks for an empty list before it sleeps, so on wakeup it will always see the newly added buffer because it tries unconditionally to dequeue buffers on wakeup. Hence I think this is safe and race free. Cheers, Dave. -- Dave Chinner david@fromorbit.com _______________________________________________ xfs mailing list xfs@oss.sgi.com http://oss.sgi.com/mailman/listinfo/xfs ^ permalink raw reply [flat|nested] 7+ messages in thread
end of thread, other threads:[~2010-01-04 23:51 UTC | newest] Thread overview: 7+ messages (download: mbox.gz follow: Atom feed -- links below jump to the message on this page -- 2010-01-02 2:43 [PATCH 0/2] XFS: Run kernel threads on demand Dave Chinner 2010-01-02 2:43 ` [PATCH 1/2] XFS: Don't wake the aild once per second Dave Chinner 2010-01-04 15:16 ` Christoph Hellwig 2010-01-04 23:28 ` Dave Chinner 2010-01-02 2:43 ` [PATCH 2/2] XFS: Don't wake xfsbufd when idle Dave Chinner 2010-01-04 15:20 ` Christoph Hellwig 2010-01-04 23:52 ` Dave Chinner
This is a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox