Merge branch 'for-3.20/bdi' of git://git.kernel.dk/linux-block

[linux-drm-fsl-dcu.git] / mm / vmscan.c

diff --git a/mm/vmscan.c b/mm/vmscan.c
index e00a16393f21e18c3ce156dbdd2777e15ba7e7f8..224dd298fdcd342b3b26d8046bc6bcf89b60475c 100644 (file)
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -91,6 +91,9 @@ struct scan_control {
        /* Can pages be swapped as part of reclaim? */
        unsigned int may_swap:1;
 
+       /* Can cgroups be reclaimed below their normal consumption range? */
+       unsigned int may_thrash:1;
+
        unsigned int hibernation_mode:1;
 
        /* One of the zones is ready for compaction */
@@ -1903,8 +1906,12 @@ static void get_scan_count(struct lruvec *lruvec, int swappiness,
         * latencies, so it's better to scan a minimum amount there as
         * well.
         */
-       if (current_is_kswapd() && !zone_reclaimable(zone))
-               force_scan = true;
+       if (current_is_kswapd()) {
+               if (!zone_reclaimable(zone))
+                       force_scan = true;
+               if (!mem_cgroup_lruvec_online(lruvec))
+                       force_scan = true;
+       }
        if (!global_reclaim(sc))
                force_scan = true;
 
@@ -2290,6 +2297,12 @@ static bool shrink_zone(struct zone *zone, struct scan_control *sc,
                        struct lruvec *lruvec;
                        int swappiness;
 
+                       if (mem_cgroup_low(root, memcg)) {
+                               if (!sc->may_thrash)
+                                       continue;
+                               mem_cgroup_events(memcg, MEMCG_LOW, 1);
+                       }
+
                        lruvec = mem_cgroup_zone_lruvec(zone, memcg);
                        swappiness = mem_cgroup_swappiness(memcg);
 
@@ -2311,8 +2324,7 @@ static bool shrink_zone(struct zone *zone, struct scan_control *sc,
                                mem_cgroup_iter_break(root, memcg);
                                break;
                        }
-                       memcg = mem_cgroup_iter(root, memcg, &reclaim);
-               } while (memcg);
+               } while ((memcg = mem_cgroup_iter(root, memcg, &reclaim)));
 
                /*
                 * Shrink the slab caches in the same proportion that
@@ -2515,10 +2527,11 @@ static bool shrink_zones(struct zonelist *zonelist, struct scan_control *sc)
 static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
                                          struct scan_control *sc)
 {
+       int initial_priority = sc->priority;
        unsigned long total_scanned = 0;
        unsigned long writeback_threshold;
        bool zones_reclaimable;
-
+retry:
        delayacct_freepages_start();
 
        if (global_reclaim(sc))
@@ -2568,6 +2581,13 @@ static unsigned long do_try_to_free_pages(struct zonelist *zonelist,
        if (sc->compaction_ready)
                return 1;
 
+       /* Untapped cgroup reserves?  Don't OOM, retry. */
+       if (!sc->may_thrash) {
+               sc->priority = initial_priority;
+               sc->may_thrash = 1;
+               goto retry;
+       }
+
        /* Any of the zones still reclaimable?  Don't OOM. */
        if (zones_reclaimable)
                return 1;
@@ -2656,7 +2676,7 @@ static bool throttle_direct_reclaim(gfp_t gfp_mask, struct zonelist *zonelist,
         * should make reasonable progress.
         */
        for_each_zone_zonelist_nodemask(zone, z, zonelist,
-                                       gfp_mask, nodemask) {
+                                       gfp_zone(gfp_mask), nodemask) {
                if (zone_idx(zone) > ZONE_NORMAL)
                        continue;
 
@@ -3175,7 +3195,7 @@ static unsigned long balance_pgdat(pg_data_t *pgdat, int order,
                 */
                if (waitqueue_active(&pgdat->pfmemalloc_wait) &&
                                pfmemalloc_watermark_ok(pgdat))
-                       wake_up(&pgdat->pfmemalloc_wait);
+                       wake_up_all(&pgdat->pfmemalloc_wait);
 
                /*
                 * Fragmentation may mean that the system cannot be rebalanced