Merge branch 'master' into for-next

Fast-forward merge with Linus to be able to merge patches
based on more recent version of the tree.

1 files changed, 39 insertions, 35 deletions

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 8e32698fab66..9fdfce7ba403 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -95,8 +95,6 @@ struct scan_control {
         /* Can pages be swapped as part of reclaim? */
         int may_swap;
 
-        int swappiness;
-
         int order;
 
         /*
@@ -173,7 +171,8 @@ static unsigned long zone_nr_lru_pages(struct zone *zone,
                                 struct scan_control *sc, enum lru_list lru)
 {
         if (!scanning_global_lru(sc))
-                return mem_cgroup_zone_nr_lru_pages(sc->mem_cgroup, zone, lru);
+                return mem_cgroup_zone_nr_lru_pages(sc->mem_cgroup,
+                                zone_to_nid(zone), zone_idx(zone), BIT(lru));
 
         return zone_page_state(zone, NR_LRU_BASE + lru);
 }
@@ -1770,6 +1769,13 @@ static unsigned long shrink_list(enum lru_list lru, unsigned long nr_to_scan,
         return shrink_inactive_list(nr_to_scan, zone, sc, priority, file);
 }
 
+static int vmscan_swappiness(struct scan_control *sc)
+{
+        if (scanning_global_lru(sc))
+                return vm_swappiness;
+        return mem_cgroup_swappiness(sc->mem_cgroup);
+}
+
 /*
  * Determine how aggressively the anon and file LRU lists should be
  * scanned.  The relative value of each set of LRU lists is determined
@@ -1788,22 +1794,15 @@ static void get_scan_count(struct zone *zone, struct scan_control *sc,
         u64 fraction[2], denominator;
         enum lru_list l;
         int noswap = 0;
-        int force_scan = 0;
-
-
-        anon  = zone_nr_lru_pages(zone, sc, LRU_ACTIVE_ANON) +
-                zone_nr_lru_pages(zone, sc, LRU_INACTIVE_ANON);
-        file  = zone_nr_lru_pages(zone, sc, LRU_ACTIVE_FILE) +
-                zone_nr_lru_pages(zone, sc, LRU_INACTIVE_FILE);
+        bool force_scan = false;
+        unsigned long nr_force_scan[2];
 
-        if (((anon + file) >> priority) < SWAP_CLUSTER_MAX) {
-                /* kswapd does zone balancing and need to scan this zone */
-                if (scanning_global_lru(sc) && current_is_kswapd())
-                        force_scan = 1;
-                /* memcg may have small limit and need to avoid priority drop */
-                if (!scanning_global_lru(sc))
-                        force_scan = 1;
-        }
+        /* kswapd does zone balancing and needs to scan this zone */
+        if (scanning_global_lru(sc) && current_is_kswapd())
+                force_scan = true;
+        /* memcg may have small limit and need to avoid priority drop */
+        if (!scanning_global_lru(sc))
+                force_scan = true;
 
         /* If we have no swap space, do not bother scanning anon pages. */
         if (!sc->may_swap || (nr_swap_pages <= 0)) {
@@ -1811,9 +1810,16 @@ static void get_scan_count(struct zone *zone, struct scan_control *sc,
                 fraction[0] = 0;
                 fraction[1] = 1;
                 denominator = 1;
+                nr_force_scan[0] = 0;
+                nr_force_scan[1] = SWAP_CLUSTER_MAX;
                 goto out;
         }
 
+        anon  = zone_nr_lru_pages(zone, sc, LRU_ACTIVE_ANON) +
+                zone_nr_lru_pages(zone, sc, LRU_INACTIVE_ANON);
+        file  = zone_nr_lru_pages(zone, sc, LRU_ACTIVE_FILE) +
+                zone_nr_lru_pages(zone, sc, LRU_INACTIVE_FILE);
+
         if (scanning_global_lru(sc)) {
                 free  = zone_page_state(zone, NR_FREE_PAGES);
                 /* If we have very few page cache pages,
@@ -1822,6 +1828,8 @@ static void get_scan_count(struct zone *zone, struct scan_control *sc,
                         fraction[0] = 1;
                         fraction[1] = 0;
                         denominator = 1;
+                        nr_force_scan[0] = SWAP_CLUSTER_MAX;
+                        nr_force_scan[1] = 0;
                         goto out;
                 }
         }
@@ -1830,8 +1838,8 @@ static void get_scan_count(struct zone *zone, struct scan_control *sc,
          * With swappiness at 100, anonymous and file have the same priority.
          * This scanning priority is essentially the inverse of IO cost.
          */
-        anon_prio = sc->swappiness;
-        file_prio = 200 - sc->swappiness;
+        anon_prio = vmscan_swappiness(sc);
+        file_prio = 200 - vmscan_swappiness(sc);
 
         /*
          * OK, so we have swap space and a fair amount of page cache
@@ -1870,6 +1878,11 @@ static void get_scan_count(struct zone *zone, struct scan_control *sc,
         fraction[0] = ap;
         fraction[1] = fp;
         denominator = ap + fp + 1;
+        if (force_scan) {
+                unsigned long scan = SWAP_CLUSTER_MAX;
+                nr_force_scan[0] = div64_u64(scan * ap, denominator);
+                nr_force_scan[1] = div64_u64(scan * fp, denominator);
+        }
 out:
         for_each_evictable_lru(l) {
                 int file = is_file_lru(l);
@@ -1890,12 +1903,8 @@ out:
                  * memcg, priority drop can cause big latency. So, it's better
                  * to scan small amount. See may_noscan above.
                  */
-                if (!scan && force_scan) {
-                        if (file)
-                                scan = SWAP_CLUSTER_MAX;
-                        else if (!noswap)
-                                scan = SWAP_CLUSTER_MAX;
-                }
+                if (!scan && force_scan)
+                        scan = nr_force_scan[file];
                 nr[l] = scan;
         }
 }
@@ -2220,7 +2229,6 @@ unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
                 .nr_to_reclaim = SWAP_CLUSTER_MAX,
                 .may_unmap = 1,
                 .may_swap = 1,
-                .swappiness = vm_swappiness,
                 .order = order,
                 .mem_cgroup = NULL,
                 .nodemask = nodemask,
@@ -2244,7 +2252,6 @@ unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
 
 unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
                                                 gfp_t gfp_mask, bool noswap,
-                                                unsigned int swappiness,
                                                 struct zone *zone,
                                                 unsigned long *nr_scanned)
 {
@@ -2254,7 +2261,6 @@ unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
                 .may_writepage = !laptop_mode,
                 .may_unmap = 1,
                 .may_swap = !noswap,
-                .swappiness = swappiness,
                 .order = 0,
                 .mem_cgroup = mem,
         };
@@ -2283,8 +2289,7 @@ unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
 
 unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem_cont,
                                            gfp_t gfp_mask,
-                                           bool noswap,
-                                           unsigned int swappiness)
+                                           bool noswap)
 {
         struct zonelist *zonelist;
         unsigned long nr_reclaimed;
@@ -2294,7 +2299,6 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *mem_cont,
                 .may_unmap = 1,
                 .may_swap = !noswap,
                 .nr_to_reclaim = SWAP_CLUSTER_MAX,
-                .swappiness = swappiness,
                 .order = 0,
                 .mem_cgroup = mem_cont,
                 .nodemask = NULL, /* we don't care the placement */
@@ -2445,7 +2449,6 @@ static unsigned long balance_pgdat(pg_data_t *pgdat, int order,
                  * we want to put equal scanning pressure on each zone.
                  */
                 .nr_to_reclaim = ULONG_MAX,
-                .swappiness = vm_swappiness,
                 .order = order,
                 .mem_cgroup = NULL,
         };
@@ -2494,6 +2497,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)
@@ -2915,7 +2921,6 @@ unsigned long shrink_all_memory(unsigned long nr_to_reclaim)
                 .may_writepage = 1,
                 .nr_to_reclaim = nr_to_reclaim,
                 .hibernation_mode = 1,
-                .swappiness = vm_swappiness,
                 .order = 0,
         };
         struct shrink_control shrink = {
@@ -3102,7 +3107,6 @@ static int __zone_reclaim(struct zone *zone, gfp_t gfp_mask, unsigned int order)
                 .nr_to_reclaim = max_t(unsigned long, nr_pages,
                                        SWAP_CLUSTER_MAX),
                 .gfp_mask = gfp_mask,
-                .swappiness = vm_swappiness,
                 .order = order,
         };
         struct shrink_control shrink = {