memcg-mm-introduce-lowlimit-reclaim-fix

mem_cgroup_reclaim_eligible -> mem_cgroup_within_guarantee
follow_low_limit -> honor_memcg_guarantee
and as suggested by Johannes.

Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: KAMEZAWA Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Greg Thelen <gthelen@google.com>
Cc: Michel Lespinasse <walken@google.com>
Cc: Tejun Heo <tj@kernel.org>
Cc: Hugh Dickins <hughd@google.com>
Cc: Roman Gushchin <klamm@yandex-team.ru>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index bfd54264e73a0012cf7b982ea7ca4f4c71ddefd7..c3a53cbb88ebd5b2958fb05b9ae8e44cc78652be 100644 (file)
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -92,7 +92,7 @@ bool __mem_cgroup_same_or_subtree(const struct mem_cgroup *root_memcg,
 bool task_in_mem_cgroup(struct task_struct *task,
                        const struct mem_cgroup *memcg);
 
-extern bool mem_cgroup_reclaim_eligible(struct mem_cgroup *memcg,
+extern bool mem_cgroup_within_guarantee(struct mem_cgroup *memcg,
                struct mem_cgroup *root);
 
 extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page);
@@ -291,10 +291,10 @@ static inline struct lruvec *mem_cgroup_page_lruvec(struct page *page,
        return &zone->lruvec;
 }
 
-static inline bool mem_cgroup_reclaim_eligible(struct mem_cgroup *memcg,
+static inline bool mem_cgroup_within_guarantee(struct mem_cgroup *memcg,
                struct mem_cgroup *root)
 {
-       return true;
+       return false;
 }
 
 static inline struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)

diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index c65addf4929ae73d686022626ddc52c28cc87cc5..92c35f8a44a02896e9135404798eccdfd44c217b 100644 (file)
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -2797,26 +2797,27 @@ static struct mem_cgroup *mem_cgroup_lookup(unsigned short id)
 }
 
 /**
- * mem_cgroup_reclaim_eligible - checks whether given memcg is eligible for the
- * reclaim
+ * mem_cgroup_within_guarantee - checks whether given memcg is within its
+ * memory guarantee
  * @memcg: target memcg for the reclaim
  * @root: root of the reclaim hierarchy (null for the global reclaim)
  *
- * The given group is reclaimable if it is above its low limit and the same
- * applies for all parents up the hierarchy until root (including).
+ * The given group is within its reclaim gurantee if it is below its low limit
+ * or the same applies for any parent up the hierarchy until root (including).
+ * Such a group might be excluded from the reclaim.
  */
-bool mem_cgroup_reclaim_eligible(struct mem_cgroup *memcg,
+bool mem_cgroup_within_guarantee(struct mem_cgroup *memcg,
                struct mem_cgroup *root)
 {
        do {
                if (!res_counter_low_limit_excess(&memcg->res))
-                       return false;
+                       return true;
                if (memcg == root)
                        break;
 
        } while ((memcg = parent_mem_cgroup(memcg)));
 
-       return true;
+       return false;
 }
 
 struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page)

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 19b6a04df810e07052b543ff3a34b14459c2e823..ff8da5e759b68f29787490fee1e7f7d6162d920b 100644 (file)
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -2230,8 +2230,18 @@ static inline bool should_continue_reclaim(struct zone *zone,
        }
 }
 
+/**
+ * __shrink_zone - shrinks a given zone
+ *
+ * @zone: zone to shrink
+ * @sc: scan control with additional reclaim parameters
+ * @honor_memcg_guarantee: do not reclaim memcgs which are within their memory
+ * guarantee
+ *
+ * Returns the number of reclaimed memcgs.
+ */
 static unsigned __shrink_zone(struct zone *zone, struct scan_control *sc,
-               bool follow_low_limit)
+               bool honor_memcg_guarantee)
 {
        unsigned long nr_reclaimed, nr_scanned;
        unsigned nr_scanned_groups = 0;
@@ -2251,12 +2261,9 @@ static unsigned __shrink_zone(struct zone *zone, struct scan_control *sc,
                do {
                        struct lruvec *lruvec;
 
-                       /*
-                        * Memcg might be under its low limit so we have to
-                        * skip it during the first reclaim round
-                        */
-                       if (follow_low_limit &&
-                                       !mem_cgroup_reclaim_eligible(memcg, root)) {
+                       /* Memcg might be protected from the reclaim */
+                       if (honor_memcg_guarantee &&
+                                       mem_cgroup_within_guarantee(memcg, root)) {
                                /*
                                 * It would be more optimal to skip the memcg
                                 * subtree now but we do not have a memcg iter
@@ -2304,8 +2311,8 @@ static void shrink_zone(struct zone *zone, struct scan_control *sc)
        if (!__shrink_zone(zone, sc, true)) {
                /*
                 * First round of reclaim didn't find anything to reclaim
-                * because of low limit protection so try again and ignore
-                * the low limit this time.
+                * because of the memory guantees for all memcgs in the
+                * reclaim target so try again and ignore guarantees this time.
                 */
                __shrink_zone(zone, sc, false);
        }