writeback: move bdi threads exiting logic to the forker thread

Currently, bdi threads can decide to exit if there were no useful activities
for 5 minutes. However, this causes nasty races: we can easily oops in the
'bdi_queue_work()' if the bdi thread decides to exit while we are waking it up.

And even if we do not oops, but the bdi tread exits immediately after we wake
it up, we'd lose the wake-up event and have an unnecessary delay (up to 5 secs)
in the bdi work processing.

This patch makes the forker thread to be the central place which not only
creates bdi threads, but also kills them if they were inactive long enough.
This better design-wise.

Another reason why this change was done is to prepare for the further changes
which will prevent the bdi threads from waking up every 5 sec and wasting
power. Indeed, when the task does not wake up periodically anymore, it won't be
able to exit either.

This patch also moves the the 'wake_up_bit()' call from the bdi thread to the
forker thread as well. So now the forker thread sets the BDI_pending bit, then
forks the task or kills it, then clears the bit and wakes up the waiting
process.

The only process which may wain on the bit is 'bdi_wb_shutdown()'. This
function was changed as well - now it first removes the bdi from the
'bdi_list', then waits on the 'BDI_pending' bit. Once it wakes up, it is
guaranteed that the forker thread won't race with it, because the bdi is not
visible. Note, the forker thread sets the 'BDI_pending' bit under the
'bdi->wb_lock' which is essential for proper serialization.

And additionally, when we change 'bdi->wb.task', we now take the
'bdi->work_lock', to make sure that we do not lose wake-ups which we otherwise
would when raced with, say, 'bdi_queue_work()'.

Signed-off-by: Artem Bityutskiy <Artem.Bityutskiy@nokia.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <jaxboe@fusionio.com>

1 files changed, 12 insertions, 42 deletions

diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index 9f5cab75c15..905f3ea3848 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -78,21 +78,17 @@ static void bdi_queue_work(struct backing_dev_info *bdi,
 
         spin_lock(&bdi->wb_lock);
         list_add_tail(&work->list, &bdi->work_list);
-        spin_unlock(&bdi->wb_lock);
-
-        /*
-         * If the default thread isn't there, make sure we add it. When
-         * it gets created and wakes up, we'll run this work.
-         */
-        if (unlikely(!bdi->wb.task)) {
+        if (bdi->wb.task) {
+                wake_up_process(bdi->wb.task);
+        } else {
+                /*
+                 * The bdi thread isn't there, wake up the forker thread which
+                 * will create and run it.
+                 */
                 trace_writeback_nothread(bdi, work);
                 wake_up_process(default_backing_dev_info.wb.task);
-        } else {
-                struct bdi_writeback *wb = &bdi->wb;
-
-                if (wb->task)
-                        wake_up_process(wb->task);
         }
+        spin_unlock(&bdi->wb_lock);
 }
 
 static void
@@ -800,7 +796,6 @@ int bdi_writeback_thread(void *data)
 {
         struct bdi_writeback *wb = data;
         struct backing_dev_info *bdi = wb->bdi;
-        unsigned long wait_jiffies = -1UL;
         long pages_written;
 
         current->flags |= PF_FLUSHER | PF_SWAPWRITE;
@@ -812,13 +807,6 @@ int bdi_writeback_thread(void *data)
          */
         set_user_nice(current, 0);
 
-        /*
-         * Clear pending bit and wakeup anybody waiting to tear us down
-         */
-        clear_bit(BDI_pending, &bdi->state);
-        smp_mb__after_clear_bit();
-        wake_up_bit(&bdi->state, BDI_pending);
-
         trace_writeback_thread_start(bdi);
 
         while (!kthread_should_stop()) {
@@ -828,18 +816,6 @@ int bdi_writeback_thread(void *data)
 
                 if (pages_written)
                         wb->last_active = jiffies;
-                else if (wait_jiffies != -1UL) {
-                        unsigned long max_idle;
-
-                        /*
-                         * Longest period of inactivity that we tolerate. If we
-                         * see dirty data again later, the thread will get
-                         * recreated automatically.
-                         */
-                        max_idle = max(5UL * 60 * HZ, wait_jiffies);
-                        if (time_after(jiffies, max_idle + wb->last_active))
-                                break;
-                }
 
                 set_current_state(TASK_INTERRUPTIBLE);
                 if (!list_empty(&bdi->work_list)) {
@@ -847,21 +823,15 @@ int bdi_writeback_thread(void *data)
                         continue;
                 }
 
-                if (dirty_writeback_interval) {
-                        wait_jiffies = msecs_to_jiffies(dirty_writeback_interval * 10);
-                        schedule_timeout(wait_jiffies);
-                } else
+                if (dirty_writeback_interval)
+                        schedule_timeout(msecs_to_jiffies(dirty_writeback_interval * 10));
+                else
                         schedule();
 
                 try_to_freeze();
         }
 
-        wb->task = NULL;
-
-        /*
-         * Flush any work that raced with us exiting. No new work
-         * will be added, since this bdi isn't discoverable anymore.
-         */
+        /* Flush any work that raced with us exiting */
         if (!list_empty(&bdi->work_list))
                 wb_do_writeback(wb, 1);