3 files changed, 32 insertions, 0 deletions

diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index a378c295851..05eaf5e3aad 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -7,6 +7,8 @@
 #include <linux/sched.h>
 #include <linux/fs.h>
 
+DECLARE_PER_CPU(int, dirty_throttle_leaks);
+
 /*
  * The 1/4 region under the global dirty thresh is for smooth dirty throttling:
  *
diff --git a/kernel/exit.c b/kernel/exit.c
index d0b7d988f87..d4aac24cc46 100644
--- a/kernel/exit.c
+++ b/kernel/exit.c
@@ -51,6 +51,7 @@
 #include <trace/events/sched.h>
 #include <linux/hw_breakpoint.h>
 #include <linux/oom.h>
+#include <linux/writeback.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -1037,6 +1038,8 @@ NORET_TYPE void do_exit(long code)
         validate_creds_for_do_exit(tsk);
 
         preempt_disable();
+        if (tsk->nr_dirtied)
+                __this_cpu_add(dirty_throttle_leaks, tsk->nr_dirtied);
         exit_rcu();
         /* causes final put_task_struct in finish_task_switch(). */
         tsk->state = TASK_DEAD;
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 50f08241f98..619c445fc03 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -1214,6 +1214,22 @@ void set_page_dirty_balance(struct page *page, int page_mkwrite)
 
 static DEFINE_PER_CPU(int, bdp_ratelimits);
 
+/*
+ * Normal tasks are throttled by
+ *      loop {
+ *              dirty tsk->nr_dirtied_pause pages;
+ *              take a snap in balance_dirty_pages();
+ *      }
+ * However there is a worst case. If every task exit immediately when dirtied
+ * (tsk->nr_dirtied_pause - 1) pages, balance_dirty_pages() will never be
+ * called to throttle the page dirties. The solution is to save the not yet
+ * throttled page dirties in dirty_throttle_leaks on task exit and charge them
+ * randomly into the running tasks. This works well for the above worst case,
+ * as the new task will pick up and accumulate the old task's leaked dirty
+ * count and eventually get throttled.
+ */
+DEFINE_PER_CPU(int, dirty_throttle_leaks) = 0;
+
 /**
  * balance_dirty_pages_ratelimited_nr - balance dirty memory state
  * @mapping: address_space which was dirtied
@@ -1261,6 +1277,17 @@ void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
                         ratelimit = 0;
                 }
         }
+        /*
+         * Pick up the dirtied pages by the exited tasks. This avoids lots of
+         * short-lived tasks (eg. gcc invocations in a kernel build) escaping
+         * the dirty throttling and livelock other long-run dirtiers.
+         */
+        p = &__get_cpu_var(dirty_throttle_leaks);
+        if (*p > 0 && current->nr_dirtied < ratelimit) {
+                nr_pages_dirtied = min(*p, ratelimit - current->nr_dirtied);
+                *p -= nr_pages_dirtied;
+                current->nr_dirtied += nr_pages_dirtied;
+        }
         preempt_enable();
 
         if (unlikely(current->nr_dirtied >= ratelimit))