More graceful flusher thread memory reclaim wakeup

Everybody is passing in 0 now, let's get rid of the argument.

Signed-off-by Jens Axboe <[email protected]>

---
 fs/buffer.c               | 2 +-
 fs/fs-writeback.c         | 9 ++++-----
 fs/sync.c                 | 2 +-
 include/linux/writeback.h | 2 +-
 mm/vmscan.c               | 2 +-
 5 files changed, 8 insertions(+), 9 deletions(-)

fs/buffer.c +1 -1

index 9471a445e370..cf71926797d3 100644
@@ -260,7 +260,7 @@ static void free_more_memory(void)
 	struct zoneref *z;
 	int nid;
 
-	wakeup_flusher_threads(0, WB_REASON_FREE_MORE_MEM);
+	wakeup_flusher_threads(WB_REASON_FREE_MORE_MEM);
 	yield();
 
 	for_each_online_node(nid) {

fs/fs-writeback.c +4 -5

index 245c430a2e41..bb6148dc6d24 100644
@@ -1947,12 +1947,12 @@ void wb_workfn(struct work_struct *work)
 }
 
 /*
- * Start writeback of `nr_pages' pages.  If `nr_pages' is zero, write back
- * the whole world.
+ * Wakeup the flusher threads to start writeback of all currently dirty pages
  */
-void wakeup_flusher_threads(long nr_pages, enum wb_reason reason)
+void wakeup_flusher_threads(enum wb_reason reason)
 {
 	struct backing_dev_info *bdi;
+	long nr_pages;
 
 	/*
 	 * If we are expecting writeback progress we must submit plugged IO.

@@ -1960,8 +1960,7 @@ void wakeup_flusher_threads(long nr_pages, enum wb_reason reason)
 	if (blk_needs_flush_plug(current))
 		blk_schedule_flush_plug(current);
 
-	if (!nr_pages)
-		nr_pages = get_nr_dirty_pages();
+	nr_pages = get_nr_dirty_pages();
 
 	rcu_read_lock();
 	list_for_each_entry_rcu(bdi, &bdi_list, bdi_list) {

fs/sync.c +1 -1

index a576aa2e6b09..09f96a18dd93 100644
@@ -108,7 +108,7 @@ SYSCALL_DEFINE0(sync)
 {
 	int nowait = 0, wait = 1;
 
-	wakeup_flusher_threads(0, WB_REASON_SYNC);
+	wakeup_flusher_threads(WB_REASON_SYNC);
 	iterate_supers(sync_inodes_one_sb, NULL);
 	iterate_supers(sync_fs_one_sb, &nowait);
 	iterate_supers(sync_fs_one_sb, &wait);

include/linux/writeback.h +1 -1

index d5815794416c..1f9c6db5e29a 100644
@@ -189,7 +189,7 @@ bool try_to_writeback_inodes_sb(struct super_block *, enum wb_reason reason);
 bool try_to_writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
 				   enum wb_reason reason);
 void sync_inodes_sb(struct super_block *);
-void wakeup_flusher_threads(long nr_pages, enum wb_reason reason);
+void wakeup_flusher_threads(enum wb_reason reason);
 void inode_wait_for_writeback(struct inode *inode);
 
 /* writeback.h requires fs.h; it, too, is not included from here. */

mm/vmscan.c +1 -1

index 13d711dd8776..42a7fdd52d87 100644
@@ -1867,7 +1867,7 @@ shrink_inactive_list(unsigned long nr_to_scan, struct lruvec *lruvec,
 		 * also allow kswapd to start writing pages during reclaim.
 		 */
 		if (stat.nr_unqueued_dirty == nr_taken) {
-			wakeup_flusher_threads(0, WB_REASON_VMSCAN);
+			wakeup_flusher_threads(WB_REASON_VMSCAN);
 			set_bit(PGDAT_DIRTY, &pgdat->flags);
 		}
 

Signature · 1 line

2.7.4

Laptop mode really wants to writeback the number of dirty pages and inodes. Instead of calculating this in the caller, just pass in 0 and let wakeup_flusher_threads() handle it.

Use the new wakeup_flusher_threads_bdi() instead of rolling our own. This changes the writeback to not be range cyclic, but that should not matter for laptop mode flush-all semantics.

Quoted 8 lines · Jens Axboe

Laptop mode really wants to writeback the number of dirty pages and inodes. Instead of calculating this in the caller, just pass in 0 and let wakeup_flusher_threads() handle it.

Use the new wakeup_flusher_threads_bdi() instead of rolling our own. This changes the writeback to not be range cyclic, but that should not matter for laptop mode flush-all semantics.

Looks good,

Reviewed-by Christoph Hellwig <[email protected]>

While we're at sorting out the laptop_mode_wb_timer mess:
can we move initializing and deleting it from the block code to the backing-dev code given that it now doesn't assume anything about block devices any more?

Use the new wakeup_flusher_threads_bdi() instead of rolling our own. This changes the writeback to not be range cyclic, but that should not matter for laptop mode flush-all semantics.

Laptop mode really wants to writeback the number of dirty pages and inodes. Instead of calculating this in the caller, just pass in 0 and let wakeup_flusher_threads() handle it.

Use the new wakeup_flusher_threads_bdi() instead of rolling our own. This changes the writeback to not be range cyclic, but that should not matter for laptop mode flush-all semantics.

Acked-by Johannes Weiner <[email protected]>

Tested-by Chris Mason <[email protected]>

Signed-off-by Jens Axboe <[email protected]>

Reviewed-by Jan Kara <[email protected]>

Signed-off-by Jens Axboe <[email protected]>

Now that we have no external callers of wb_start_writeback(), we can shuffle the passing in of 'nr_pages'. Everybody passes in 0 at this point, so just kill the argument and move the dirty count retrieval to that function.

Acked-by Johannes Weiner <[email protected]>

Tested-by Chris Mason <[email protected]>

Signed-off-by Jens Axboe <[email protected]>

---
 fs/fs-writeback.c | 42 ++++++++++++++++++------------------------
 1 file changed, 18 insertions(+), 24 deletions(-)

fs/fs-writeback.c +18 -24

index ecbd26d1121d..3916ea2484ae 100644
@@ -933,8 +933,19 @@ static void bdi_split_work_to_wbs(struct backing_dev_info *bdi,
 
 #endif	/* CONFIG_CGROUP_WRITEBACK */
 
-static void wb_start_writeback(struct bdi_writeback *wb, long nr_pages,
-			       bool range_cyclic, enum wb_reason reason)
+/*
+ * Add in the number of potentially dirty inodes, because each inode
+ * write can dirty pagecache in the underlying blockdev.
+ */
+static unsigned long get_nr_dirty_pages(void)
+{
+	return global_node_page_state(NR_FILE_DIRTY) +
+		global_node_page_state(NR_UNSTABLE_NFS) +
+		get_nr_dirty_inodes();
+}
+
+static void wb_start_writeback(struct bdi_writeback *wb, bool range_cyclic,
+			       enum wb_reason reason)
 {
 	struct wb_writeback_work *work;
 

@@ -954,7 +965,7 @@ static void wb_start_writeback(struct bdi_writeback *wb, long nr_pages,
 	}
 
 	work->sync_mode	= WB_SYNC_NONE;
-	work->nr_pages	= nr_pages;
+	work->nr_pages	= wb_split_bdi_pages(wb, get_nr_dirty_pages());
 	work->range_cyclic = range_cyclic;
 	work->reason	= reason;
 	work->auto_free	= 1;

@@ -1814,17 +1825,6 @@ static struct wb_writeback_work *get_next_work_item(struct bdi_writeback *wb)
 	return work;
 }
 
-/*
- * Add in the number of potentially dirty inodes, because each inode
- * write can dirty pagecache in the underlying blockdev.
- */
-static unsigned long get_nr_dirty_pages(void)
-{
-	return global_node_page_state(NR_FILE_DIRTY) +
-		global_node_page_state(NR_UNSTABLE_NFS) +
-		get_nr_dirty_inodes();
-}
-
 static long wb_check_background_flush(struct bdi_writeback *wb)
 {
 	if (wb_over_bg_thresh(wb)) {

@@ -1951,7 +1951,7 @@ void wb_workfn(struct work_struct *work)
  * write back the whole world.
  */
 static void __wakeup_flusher_threads_bdi(struct backing_dev_info *bdi,
-					 long nr_pages, enum wb_reason reason)
+					 enum wb_reason reason)
 {
 	struct bdi_writeback *wb;
 

@@ -1959,17 +1959,14 @@ static void __wakeup_flusher_threads_bdi(struct backing_dev_info *bdi,
 		return;
 
 	list_for_each_entry_rcu(wb, &bdi->wb_list, bdi_node)
-		wb_start_writeback(wb, wb_split_bdi_pages(wb, nr_pages),
-					   false, reason);
+		wb_start_writeback(wb, false, reason);
 }
 
 void wakeup_flusher_threads_bdi(struct backing_dev_info *bdi,
 				enum wb_reason reason)
 {
-	long nr_pages = get_nr_dirty_pages();
-
 	rcu_read_lock();
-	__wakeup_flusher_threads_bdi(bdi, nr_pages, reason);
+	__wakeup_flusher_threads_bdi(bdi, reason);
 	rcu_read_unlock();
 }
 

@@ -1979,7 +1976,6 @@ void wakeup_flusher_threads_bdi(struct backing_dev_info *bdi,
 void wakeup_flusher_threads(enum wb_reason reason)
 {
 	struct backing_dev_info *bdi;
-	long nr_pages;
 
 	/*
 	 * If we are expecting writeback progress we must submit plugged IO.

@@ -1987,11 +1983,9 @@ void wakeup_flusher_threads(enum wb_reason reason)
 	if (blk_needs_flush_plug(current))
 		blk_schedule_flush_plug(current);
 
-	nr_pages = get_nr_dirty_pages();
-
 	rcu_read_lock();
 	list_for_each_entry_rcu(bdi, &bdi_list, bdi_list)
-		__wakeup_flusher_threads_bdi(bdi, nr_pages, reason);
+		__wakeup_flusher_threads_bdi(bdi, reason);
 	rcu_read_unlock();
 }
 

Signature · 1 line

2.7.4

When someone calls wakeup_flusher_threads() or wakeup_flusher_threads_bdi(), they schedule writeback of all dirty pages in the system (or on that bdi). If we are tight on memory, we can get tons of these queued from kswapd/vmscan. This causes (at least) two problems:

1) We consume a ton of memory just allocating writeback work items.
2) We spend so much time processing these work items, that we introduce a softlockup in writeback processing.

Fix this by adding a 'start_all' bit to the writeback structure, and set that when someone attempts to flush all dirty page. The bit is cleared when we start writeback on that work item. If the bit is already set when we attempt to queue !nr_pages writeback, then we simply ignore it.

This provides us one full flush in flight, with one pending as well, and makes for more efficient handling of this type of writeback.

Acked-by Johannes Weiner <[email protected]>

Tested-by Chris Mason <[email protected]>

Reviewed-by Jan Kara <[email protected]>

Signed-off-by Jens Axboe <[email protected]>

---
 fs/fs-writeback.c                | 24 ++++++++++++++++++++++++
 include/linux/backing-dev-defs.h |  1 +
 2 files changed, 25 insertions(+)

fs/fs-writeback.c +2 -0

index 3916ea2484ae..6205319d0c24 100644
@@ -53,6 +53,7 @@ struct wb_writeback_work {
 	unsigned int for_background:1;
 	unsigned int for_sync:1;	/* sync(2) WB_SYNC_ALL writeback */
 	unsigned int auto_free:1;	/* free on completion */
+	unsigned int start_all:1;	/* nr_pages == 0 (all) writeback */
 	enum wb_reason reason;		/* why was writeback initiated? */
 
 	struct list_head list;		/* pending work list */

@@ -953,12 +954,26 @@ static void wb_start_writeback(struct bdi_writeback *wb, bool range_cyclic,
 		return;
 
 	/*
+	 * All callers of this function want to start writeback of all

Quoted 43 lines · Jens Axboe

When someone calls wakeup_flusher_threads() or wakeup_flusher_threads_bdi(), they schedule writeback of all dirty pages in the system (or on that bdi). If we are tight on memory, we can get tons of these queued from kswapd/vmscan. This causes (at least) two problems:

1) We consume a ton of memory just allocating writeback work items.
2) We spend so much time processing these work items, that we introduce a softlockup in writeback processing.

Fix this by adding a 'start_all' bit to the writeback structure, and set that when someone attempts to flush all dirty page. The bit is cleared when we start writeback on that work item. If the bit is already set when we attempt to queue !nr_pages writeback, then we simply ignore it.

This provides us one full flush in flight, with one pending as well, and makes for more efficient handling of this type of writeback.

Acked-by Johannes Weiner <[email protected]>

Tested-by Chris Mason <[email protected]>

Reviewed-by Jan Kara <[email protected]>

Signed-off-by Jens Axboe <[email protected]>

---
 fs/fs-writeback.c                | 24 ++++++++++++++++++++++++
 include/linux/backing-dev-defs.h |  1 +
 2 files changed, 25 insertions(+)

fs/fs-writeback.c +1 -0

index 3916ea2484ae..6205319d0c24 100644
@@ -53,6 +53,7 @@ struct wb_writeback_work {
 	unsigned int for_background:1;
 	unsigned int for_sync:1;	/* sync(2) WB_SYNC_ALL writeback */
 	unsigned int auto_free:1;	/* free on completion */
+	unsigned int start_all:1;	/* nr_pages == 0 (all) writeback */
 	enum wb_reason reason;		/* why was writeback initiated? */
 
 	struct list_head list;		/* pending work list */

@@ -953,12 +954,26 @@ static void wb_start_writeback(struct bdi_writeback *wb, bool range_cyclic,
 		return;
 

fs/fs-writeback.c static void wb_start_writeback(struct bdi_writeback *wb, bool range_cyclic, · line 967

Quoted 12 lines

fs/fs-writeback.c +11 -0

 	/*
+	 * All callers of this function want to start writeback of all
+	 * dirty pages. Places like vmscan can call this at a very
+	 * high frequency, causing pointless allocations of tons of
+	 * work items and keeping the flusher threads busy retrieving
+	 * that work. Ensure that we only allow one of them pending and
+	 * inflight at the time
+	 */
+	if (test_bit(WB_start_all, &wb->state))
+		return;
+
+	set_bit(WB_start_all, &wb->state);

This should be test_and_set_bit here..

But more importantly once we are not guaranteed that we only have a single global wb_writeback_work per bdi_writeback we should just embedd that into struct bdi_writeback instead of dynamically allocating it.

Quoted 4 lines

But more importantly once we are not guaranteed that we only have a single global wb_writeback_work per bdi_writeback we should just embedd that into struct bdi_writeback instead of dynamically allocating it.

We could do this as a followup. But right now the logic is that we can have on started (inflight), and still have one new queued.

Something like the below would fit on top to do that. Gets rid of the allocation and embeds the work item for global start-all in the bdi_writeback structure.

Quoted 5 lines · Jens Axboe

Quoted 4 lines

But more importantly once we are not guaranteed that we only have a single global wb_writeback_work per bdi_writeback we should just embedd that into struct bdi_writeback instead of dynamically allocating it.

Quoted 2 lines

We could do this as a followup. But right now the logic is that we can have on started (inflight), and still have one new queued.

Something like the below would fit on top to do that. Gets rid of the allocation and embeds the work item for global start-all in the bdi_writeback structure.

Quoted 6 lines · Jens Axboe

Quoted 5 lines · Jens Axboe

Quoted 4 lines

But more importantly once we are not guaranteed that we only have a single global wb_writeback_work per bdi_writeback we should just embedd that into struct bdi_writeback instead of dynamically allocating it.

Quoted 6 lines

Quoted 2 lines

We could do this as a followup. But right now the logic is that we can have on started (inflight), and still have one new queued.

Something like the below would fit on top to do that. Gets rid of the allocation and embeds the work item for global start-all in the bdi_writeback structure.

Hum, so when we consider stuff like embedded work item, I would somewhat prefer to handle this like we do for for_background and for_kupdate style writeback so that we don't have another special case. For these don't queue any item, we just queue writeback work into the workqueue (via wb_wakeup()). When flusher work gets processed wb_do_writeback() checks (after processing all normal writeback requests) whether conditions for these special writeback styles are met and if yes, it creates on-stack work item and processes it (see wb_check_old_data_flush() and wb_check_background_flush()).

So in this case we would just set some flag in bdi_writeback when memory reclaim needs help and wb_do_writeback() would check for this flag and create and process writeback-all style writeback work. Granted this does not preserve ordering of requests (basically any specific request gets priority over writeback-whole-world request) but memory gets cleaned in either case so flusher should be doing what is needed.

Quoted 6 lines · Jens Axboe

Quoted 5 lines · Jens Axboe

Quoted 4 lines

But more importantly once we are not guaranteed that we only have a single global wb_writeback_work per bdi_writeback we should just embedd that into struct bdi_writeback instead of dynamically allocating it.

Quoted 6 lines

Quoted 2 lines

We could do this as a followup. But right now the logic is that we can have on started (inflight), and still have one new queued.

Something like the below would fit on top to do that. Gets rid of the allocation and embeds the work item for global start-all in the bdi_writeback structure.

Hum, so when we consider stuff like embedded work item, I would somewhat prefer to handle this like we do for for_background and for_kupdate style writeback so that we don't have another special case. For these don't queue any item, we just queue writeback work into the workqueue (via wb_wakeup()). When flusher work gets processed wb_do_writeback() checks (after processing all normal writeback requests) whether conditions for these special writeback styles are met and if yes, it creates on-stack work item and processes it (see wb_check_old_data_flush() and wb_check_background_flush()).

So in this case we would just set some flag in bdi_writeback when memory reclaim needs help and wb_do_writeback() would check for this flag and create and process writeback-all style writeback work. Granted this does not preserve ordering of requests (basically any specific request gets priority over writeback-whole-world request) but memory gets cleaned in either case so flusher should be doing what is needed.

Quoted 24 lines · Jan Kara

Quoted 6 lines · Jens Axboe

Quoted 5 lines · Jens Axboe

Quoted 4 lines

But more importantly once we are not guaranteed that we only have a single global wb_writeback_work per bdi_writeback we should just embedd that into struct bdi_writeback instead of dynamically allocating it.

Quoted 6 lines

Quoted 2 lines

We could do this as a followup. But right now the logic is that we can have on started (inflight), and still have one new queued.

Something like the below would fit on top to do that. Gets rid of the allocation and embeds the work item for global start-all in the bdi_writeback structure.

Hum, so when we consider stuff like embedded work item, I would somewhat prefer to handle this like we do for for_background and for_kupdate style writeback so that we don't have another special case. For these don't queue any item, we just queue writeback work into the workqueue (via wb_wakeup()). When flusher work gets processed wb_do_writeback() checks (after processing all normal writeback requests) whether conditions for these special writeback styles are met and if yes, it creates on-stack work item and processes it (see wb_check_old_data_flush() and wb_check_background_flush()).

Quoted 6 lines

So in this case we would just set some flag in bdi_writeback when memory reclaim needs help and wb_do_writeback() would check for this flag and create and process writeback-all style writeback work. Granted this does not preserve ordering of requests (basically any specific request gets priority over writeback-whole-world request) but memory gets cleaned in either case so flusher should be doing what is needed.

How about something like the below? It's on top of the latest series, which is in my wb-start-all branch. It handles start_all like the background/kupdate style writeback, reusing the WB_start_all bit for that.

On a plane, so untested, but it seems pretty straight forward. It changes the logic a little bit, as the WB_start_all bit isn't cleared until after we're done with a flush-all request. At this point it's truly on inflight at any point in time, not one inflight and one potentially queued.

Quoted 24 lines · Jan Kara

Quoted 6 lines · Jens Axboe

Quoted 5 lines · Jens Axboe

Quoted 4 lines

But more importantly once we are not guaranteed that we only have a single global wb_writeback_work per bdi_writeback we should just embedd that into struct bdi_writeback instead of dynamically allocating it.

Quoted 6 lines

Quoted 2 lines

We could do this as a followup. But right now the logic is that we can have on started (inflight), and still have one new queued.

Something like the below would fit on top to do that. Gets rid of the allocation and embeds the work item for global start-all in the bdi_writeback structure.

Hum, so when we consider stuff like embedded work item, I would somewhat prefer to handle this like we do for for_background and for_kupdate style writeback so that we don't have another special case. For these don't queue any item, we just queue writeback work into the workqueue (via wb_wakeup()). When flusher work gets processed wb_do_writeback() checks (after processing all normal writeback requests) whether conditions for these special writeback styles are met and if yes, it creates on-stack work item and processes it (see wb_check_old_data_flush() and wb_check_background_flush()).

Quoted 6 lines

So in this case we would just set some flag in bdi_writeback when memory reclaim needs help and wb_do_writeback() would check for this flag and create and process writeback-all style writeback work. Granted this does not preserve ordering of requests (basically any specific request gets priority over writeback-whole-world request) but memory gets cleaned in either case so flusher should be doing what is needed.

How about something like the below? It's on top of the latest series, which is in my wb-start-all branch. It handles start_all like the background/kupdate style writeback, reusing the WB_start_all bit for that.

On a plane, so untested, but it seems pretty straight forward. It changes the logic a little bit, as the WB_start_all bit isn't cleared until after we're done with a flush-all request. At this point it's truly on inflight at any point in time, not one inflight and one potentially queued.

fs/fs-writeback.c +34 -37

index 399619c97567..9e24d604c59c 100644
@@ -53,7 +53,6 @@ struct wb_writeback_work {
 	unsigned int for_background:1;
 	unsigned int for_sync:1;	/* sync(2) WB_SYNC_ALL writeback */
 	unsigned int auto_free:1;	/* free on completion */
-	unsigned int start_all:1;	/* nr_pages == 0 (all) writeback */
 	enum wb_reason reason;		/* why was writeback initiated? */
 
 	struct list_head list;		/* pending work list */

@@ -947,8 +946,6 @@ static unsigned long get_nr_dirty_pages(void)
 
 static void wb_start_writeback(struct bdi_writeback *wb, enum wb_reason reason)
 {
-	struct wb_writeback_work *work;
-
 	if (!wb_has_dirty_io(wb))
 		return;
 

@@ -958,35 +955,14 @@ static void wb_start_writeback(struct bdi_writeback *wb, enum wb_reason reason)
 	 * high frequency, causing pointless allocations of tons of
 	 * work items and keeping the flusher threads busy retrieving
 	 * that work. Ensure that we only allow one of them pending and
-	 * inflight at the time. It doesn't matter if we race a little
-	 * bit on this, so use the faster separate test/set bit variants.
+	 * inflight at the time.
 	 */
-	if (test_bit(WB_start_all, &wb->state))
+	if (test_bit(WB_start_all, &wb->state) ||
+	    test_and_set_bit(WB_start_all, &wb->state))
 		return;
 
-	set_bit(WB_start_all, &wb->state);
-
-	/*
-	 * This is WB_SYNC_NONE writeback, so if allocation fails just
-	 * wakeup the thread for old dirty data writeback
-	 */
-	work = kzalloc(sizeof(*work),
-		       GFP_NOWAIT | __GFP_NOMEMALLOC | __GFP_NOWARN);
-	if (!work) {
-		clear_bit(WB_start_all, &wb->state);
-		trace_writeback_nowork(wb);
-		wb_wakeup(wb);
-		return;
-	}
-
-	work->sync_mode	= WB_SYNC_NONE;
-	work->nr_pages	= wb_split_bdi_pages(wb, get_nr_dirty_pages());
-	work->range_cyclic = 1;
-	work->reason	= reason;
-	work->auto_free	= 1;
-	work->start_all = 1;
-
-	wb_queue_work(wb, work);
+	wb->start_all_reason = reason;
+	wb_wakeup(wb);
 }
 
 /**

@@ -1838,14 +1814,6 @@ static struct wb_writeback_work *get_next_work_item(struct bdi_writeback *wb)
 		list_del_init(&work->list);
 	}
 	spin_unlock_bh(&wb->work_lock);
-
-	/*
-	 * Once we start processing a work item that had !nr_pages,
-	 * clear the wb state bit for that so we can allow more.
-	 */
-	if (work && work->start_all)
-		clear_bit(WB_start_all, &wb->state);
-
 	return work;
 }
 

@@ -1901,6 +1869,30 @@ static long wb_check_old_data_flush(struct bdi_writeback *wb)
 	return 0;
 }
 
+static long wb_check_start_all(struct bdi_writeback *wb)
+{
+	long nr_pages;
+
+	if (!test_bit(WB_start_all, &wb->state))
+		return 0;
+
+	nr_pages = get_nr_dirty_pages();
+	if (nr_pages) {
+		struct wb_writeback_work work = {
+			.nr_pages	= wb_split_bdi_pages(wb, nr_pages),
+			.sync_mode	= WB_SYNC_NONE,
+			.range_cyclic	= 1,
+			.reason		= wb->start_all_reason,
+		};
+
+		nr_pages = wb_writeback(wb, &work);
+	}
+
+	clear_bit(WB_start_all, &wb->state);
+	return nr_pages;
+}
+
+
 /*
  * Retrieve work items and do the writeback they describe
  */

@@ -1917,6 +1909,11 @@ static long wb_do_writeback(struct bdi_writeback *wb)
 	}
 
 	/*
+	 * Check for a flush-everything request
+	 */
+	wrote += wb_check_start_all(wb);
+
+	/*
 	 * Check for periodic writeback, kupdated() style
 	 */
 	wrote += wb_check_old_data_flush(wb);

include/linux/backing-dev-defs.h +1 -0

index 420de5c7c7f9..f0f1df29d6b8 100644
@@ -116,6 +116,7 @@ struct bdi_writeback {
 
 	struct fprop_local_percpu completions;
 	int dirty_exceeded;
+	int start_all_reason;
 
 	spinlock_t work_lock;		/* protects work_list & dwork scheduling */
 	struct list_head work_list;

include/trace/events/writeback.h +0 -1

index 9b57f014d79d..19a0ea08e098 100644
@@ -286,7 +286,6 @@ DEFINE_EVENT(writeback_class, name, \
 	TP_PROTO(struct bdi_writeback *wb), \
 	TP_ARGS(wb))
 
-DEFINE_WRITEBACK_EVENT(writeback_nowork);
 DEFINE_WRITEBACK_EVENT(writeback_wake_background);
 
 TRACE_EVENT(writeback_bdi_register,

Signature · 2 lines

-- 
Jens Axboe