2 files changed, 54 insertions, 0 deletions

diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index e9d371b6053b..b625073b80c8 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -7,6 +7,27 @@
 #include <linux/sched.h>
 #include <linux/fs.h>
 
+/*
+ * The 1/16 region above the global dirty limit will be put to maximum pauses:
+ *
+ *      (limit, limit + limit/DIRTY_MAXPAUSE_AREA)
+ *
+ * The 1/16 region above the max-pause region, dirty exceeded bdi's will be put
+ * to loops:
+ *
+ *      (limit + limit/DIRTY_MAXPAUSE_AREA, limit + limit/DIRTY_PASSGOOD_AREA)
+ *
+ * Further beyond, all dirtier tasks will enter a loop waiting (possibly long
+ * time) for the dirty pages to drop, unless written enough pages.
+ *
+ * The global dirty threshold is normally equal to the global dirty limit,
+ * except when the system suddenly allocates a lot of anonymous memory and
+ * knocks down the global dirty threshold quickly, in which case the global
+ * dirty limit will follow down slowly to prevent livelocking all dirtier tasks.
+ */
+#define DIRTY_MAXPAUSE_AREA             16
+#define DIRTY_PASSGOOD_AREA             8
+
 struct backing_dev_info;
 
 /*
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index da959952b9f5..798842a22474 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -37,6 +37,11 @@
 #include <trace/events/writeback.h>
 
 /*
+ * Sleep at most 200ms at a time in balance_dirty_pages().
+ */
+#define MAX_PAUSE               max(HZ/5, 1)
+
+/*
  * Estimate write bandwidth at 200ms intervals.
  */
 #define BANDWIDTH_INTERVAL      max(HZ/5, 1)
@@ -399,6 +404,11 @@ unsigned long determine_dirtyable_memory(void)
         return x + 1;   /* Ensure that we never return 0 */
 }
 
+static unsigned long hard_dirty_limit(unsigned long thresh)
+{
+        return max(thresh, global_dirty_limit);
+}
+
 /*
  * global_dirty_limits - background-writeback and dirty-throttling thresholds
  *
@@ -723,6 +733,29 @@ static void balance_dirty_pages(struct address_space *mapping,
                 io_schedule_timeout(pause);
                 trace_balance_dirty_wait(bdi);
 
+                dirty_thresh = hard_dirty_limit(dirty_thresh);
+                /*
+                 * max-pause area. If dirty exceeded but still within this
+                 * area, no need to sleep for more than 200ms: (a) 8 pages per
+                 * 200ms is typically more than enough to curb heavy dirtiers;
+                 * (b) the pause time limit makes the dirtiers more responsive.
+                 */
+                if (nr_dirty < dirty_thresh +
+                               dirty_thresh / DIRTY_MAXPAUSE_AREA &&
+                    time_after(jiffies, start_time + MAX_PAUSE))
+                        break;
+                /*
+                 * pass-good area. When some bdi gets blocked (eg. NFS server
+                 * not responding), or write bandwidth dropped dramatically due
+                 * to concurrent reads, or dirty threshold suddenly dropped and
+                 * the dirty pages cannot be brought down anytime soon (eg. on
+                 * slow USB stick), at least let go of the good bdi's.
+                 */
+                if (nr_dirty < dirty_thresh +
+                               dirty_thresh / DIRTY_PASSGOOD_AREA &&
+                    bdi_dirty < bdi_thresh)
+                        break;
+
                 /*
                  * Increase the delay for each loop, up to our previous
                  * default of taking a 100ms nap.