3 files changed, 20 insertions, 40 deletions

diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index 930de9437271..ebd1e86bef1c 100644
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -1841,29 +1841,23 @@ static int mem_cgroup_hierarchical_reclaim(struct mem_cgroup *root_mem,
  */
 static bool mem_cgroup_oom_lock(struct mem_cgroup *mem)
 {
-        int lock_count = -1;
         struct mem_cgroup *iter, *failed = NULL;
         bool cond = true;
 
         for_each_mem_cgroup_tree_cond(iter, mem, cond) {
-                bool locked = iter->oom_lock;
-
-                iter->oom_lock = true;
-                if (lock_count == -1)
-                        lock_count = iter->oom_lock;
-                else if (lock_count != locked) {
+                if (iter->oom_lock) {
                         /*
                          * this subtree of our hierarchy is already locked
                          * so we cannot give a lock.
                          */
-                        lock_count = 0;
                         failed = iter;
                         cond = false;
-                }
+                } else
+                        iter->oom_lock = true;
         }
 
         if (!failed)
-                goto done;
+                return true;
 
         /*
          * OK, we failed to lock the whole subtree so we have to clean up
@@ -1877,8 +1871,7 @@ static bool mem_cgroup_oom_lock(struct mem_cgroup *mem)
                 }
                 iter->oom_lock = false;
         }
-done:
-        return lock_count;
+        return false;
 }
 
 /*
@@ -2169,13 +2162,7 @@ static void drain_all_stock(struct mem_cgroup *root_mem, bool sync)
 
         /* Notify other cpus that system-wide "drain" is running */
         get_online_cpus();
-        /*
-         * Get a hint for avoiding draining charges on the current cpu,
-         * which must be exhausted by our charging.  It is not required that
-         * this be a precise check, so we use raw_smp_processor_id() instead of
-         * getcpu()/putcpu().
-         */
-        curcpu = raw_smp_processor_id();
+        curcpu = get_cpu();
         for_each_online_cpu(cpu) {
                 struct memcg_stock_pcp *stock = &per_cpu(memcg_stock, cpu);
                 struct mem_cgroup *mem;
@@ -2192,6 +2179,7 @@ static void drain_all_stock(struct mem_cgroup *root_mem, bool sync)
                                 schedule_work_on(cpu, &stock->work);
                 }
         }
+        put_cpu();
 
         if (!sync)
                 goto out;
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index d1960744f881..0e309cd1b5b9 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -754,21 +754,10 @@ static void balance_dirty_pages(struct address_space *mapping,
                  * 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 &&
+                if (nr_dirty < dirty_thresh &&
+                    bdi_dirty < (task_bdi_thresh + bdi_thresh) / 2 &&
                     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
diff --git a/mm/vmscan.c b/mm/vmscan.c
index 7ef69124fa3e..b7719ec10dc5 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -2283,7 +2283,7 @@ unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
                 .mem_cgroup = mem,
                 .memcg_record = rec,
         };
-        unsigned long start, end;
+        ktime_t start, end;
 
         sc.gfp_mask = (gfp_mask & GFP_RECLAIM_MASK) |
                         (GFP_HIGHUSER_MOVABLE & ~GFP_RECLAIM_MASK);
@@ -2292,7 +2292,7 @@ unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
                                                       sc.may_writepage,
                                                       sc.gfp_mask);
 
-        start = sched_clock();
+        start = ktime_get();
         /*
          * NOTE: Although we can get the priority field, using it
          * here is not a good idea, since it limits the pages we can scan.
@@ -2301,10 +2301,10 @@ unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
          * the priority and make it zero.
          */
         shrink_zone(0, zone, &sc);
-        end = sched_clock();
+        end = ktime_get();
 
         if (rec)
-                rec->elapsed += end - start;
+                rec->elapsed += ktime_to_ns(ktime_sub(end, start));
         *scanned = sc.nr_scanned;
 
         trace_mm_vmscan_memcg_softlimit_reclaim_end(sc.nr_reclaimed);
@@ -2319,7 +2319,7 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem_cont,
 {
         struct zonelist *zonelist;
         unsigned long nr_reclaimed;
-        unsigned long start, end;
+        ktime_t start, end;
         int nid;
         struct scan_control sc = {
                 .may_writepage = !laptop_mode,
@@ -2337,7 +2337,7 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem_cont,
                 .gfp_mask = sc.gfp_mask,
         };
 
-        start = sched_clock();
+        start = ktime_get();
         /*
          * Unlike direct reclaim via alloc_pages(), memcg's reclaim doesn't
          * take care of from where we get pages. So the node where we start the
@@ -2352,9 +2352,9 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem_cont,
                                             sc.gfp_mask);
 
         nr_reclaimed = do_try_to_free_pages(zonelist, &sc, &shrink);
-        end = sched_clock();
+        end = ktime_get();
         if (rec)
-                rec->elapsed += end - start;
+                rec->elapsed += ktime_to_ns(ktime_sub(end, start));
 
         trace_mm_vmscan_memcg_reclaim_end(nr_reclaimed);
 
@@ -2529,6 +2529,9 @@ loop_again:
                                         high_wmark_pages(zone), 0, 0)) {
                                 end_zone = i;
                                 break;
+                        } else {
+                                /* If balanced, clear the congested flag */
+                                zone_clear_flag(zone, ZONE_CONGESTED);
                         }
                 }
                 if (i < 0)