mm, memcg: move memcg limit enforcement from zones to nodes

Memcg needs adjustment after moving LRUs to the node.  Limits are
tracked per memcg but the soft-limit excess is tracked per zone.  As
global page reclaim is based on the node, it is easy to imagine a
situation where a zone soft limit is exceeded even though the memcg
limit is fine.

This patch moves the soft limit tree the node.  Technically, all the
variable names should also change but people are already familiar by the
meaning of "mz" even if "mn" would be a more appropriate name now.

Link: http://lkml.kernel.org/r/1467970510-21195-15-git-send-email-mgorman@techsingularity.net
Signed-off-by: Mel Gorman <mgorman@techsingularity.net>
Acked-by: Michal Hocko <mhocko@suse.com>
Cc: Hillf Danton <hillf.zj@alibaba-inc.com>
Acked-by: Johannes Weiner <hannes@cmpxchg.org>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Rik van Riel <riel@surriel.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 9 insertions, 10 deletions

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 46f7a71ed13b..9f6e673efba7 100644
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -2229,8 +2229,7 @@ static inline void init_tlb_ubc(void)
 static void shrink_node_memcg(struct pglist_data *pgdat, struct mem_cgroup *memcg,
                               struct scan_control *sc, unsigned long *lru_pages)
 {
-        struct zone *zone = &pgdat->node_zones[sc->reclaim_idx];
-        struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, zone, memcg);
+        struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
         unsigned long nr[NR_LRU_LISTS];
         unsigned long targets[NR_LRU_LISTS];
         unsigned long nr_to_scan;
@@ -2439,7 +2438,7 @@ static bool shrink_node(pg_data_t *pgdat, struct scan_control *sc,
         do {
                 struct mem_cgroup *root = sc->target_mem_cgroup;
                 struct mem_cgroup_reclaim_cookie reclaim = {
-                        .zone = &pgdat->node_zones[classzone_idx],
+                        .pgdat = pgdat,
                         .priority = sc->priority,
                 };
                 unsigned long node_lru_pages = 0;
@@ -2647,7 +2646,7 @@ static void shrink_zones(struct zonelist *zonelist, struct scan_control *sc)
                          * and balancing, not for a memcg's limit.
                          */
                         nr_soft_scanned = 0;
-                        nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone,
+                        nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone->zone_pgdat,
                                                 sc->order, sc->gfp_mask,
                                                 &nr_soft_scanned);
                         sc->nr_reclaimed += nr_soft_reclaimed;
@@ -2917,7 +2916,7 @@ unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
 
 unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg,
                                                 gfp_t gfp_mask, bool noswap,
-                                                struct zone *zone,
+                                                pg_data_t *pgdat,
                                                 unsigned long *nr_scanned)
 {
         struct scan_control sc = {
@@ -2944,7 +2943,7 @@ unsigned long mem_cgroup_shrink_node(struct mem_cgroup *memcg,
          * will pick up pages from other mem cgroup's as well. We hack
          * the priority and make it zero.
          */
-        shrink_node_memcg(zone->zone_pgdat, memcg, &sc, &lru_pages);
+        shrink_node_memcg(pgdat, memcg, &sc, &lru_pages);
 
         trace_mm_vmscan_memcg_softlimit_reclaim_end(sc.nr_reclaimed);
 
@@ -2994,7 +2993,7 @@ unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
 #endif
 
 static void age_active_anon(struct pglist_data *pgdat,
-                                struct zone *zone, struct scan_control *sc)
+                                struct scan_control *sc)
 {
         struct mem_cgroup *memcg;
 
@@ -3003,7 +3002,7 @@ static void age_active_anon(struct pglist_data *pgdat,
 
         memcg = mem_cgroup_iter(NULL, NULL, NULL);
         do {
-                struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, zone, memcg);
+                struct lruvec *lruvec = mem_cgroup_lruvec(pgdat, memcg);
 
                 if (inactive_list_is_low(lruvec, false))
                         shrink_active_list(SWAP_CLUSTER_MAX, lruvec,
@@ -3193,7 +3192,7 @@ static int balance_pgdat(pg_data_t *pgdat, int order, int classzone_idx)
                  * pages are rotated regardless of classzone as this is
                  * about consistent aging.
                  */
-                age_active_anon(pgdat, &pgdat->node_zones[MAX_NR_ZONES - 1], &sc);
+                age_active_anon(pgdat, &sc);
 
                 /*
                  * If we're getting trouble reclaiming, start doing writepage
@@ -3205,7 +3204,7 @@ static int balance_pgdat(pg_data_t *pgdat, int order, int classzone_idx)
                 /* Call soft limit reclaim before calling shrink_node. */
                 sc.nr_scanned = 0;
                 nr_soft_scanned = 0;
-                nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(zone, sc.order,
+                nr_soft_reclaimed = mem_cgroup_soft_limit_reclaim(pgdat, sc.order,
                                                 sc.gfp_mask, &nr_soft_scanned);
                 sc.nr_reclaimed += nr_soft_reclaimed;