memcg: allow setting low_limit

Export memory.low_limit_in_bytes knob with the same rules as the hard
limit represented by limit_in_bytes knob (e.g.  no limit to be set for the
root cgroup).  There is no memsw alternative for low_limit_in_bytes
because the primary motivation behind this limit is to protect the working
set of the group and so considering swap doesn't make much sense.  There
is also no kmem variant exported because we do not have any easy way to
protect kernel allocations now.

Please note that the low limit might exceed the hard limit which basically
means that the group is not reclaimable if there is other reclaim target
in the hierarchy under pressure.

Signed-off-by: Michal Hocko <mhocko@suse.cz>
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/res_counter.h b/include/linux/res_counter.h
index 408724eeec7138c9b60facc2c2b07daf15ecc184..b810855024f9b8d84f75178c8a074c507a3d6ffc 100644 (file)
--- a/include/linux/res_counter.h
+++ b/include/linux/res_counter.h
@@ -93,6 +93,7 @@ enum {
        RES_LIMIT,
        RES_FAILCNT,
        RES_SOFT_LIMIT,
+       RES_LOW_LIMIT,
 };
 
 /*
@@ -247,4 +248,16 @@ res_counter_set_soft_limit(struct res_counter *cnt,
        return 0;
 }
 
+static inline int
+res_counter_set_low_limit(struct res_counter *cnt,
+                               unsigned long long low_limit)
+{
+       unsigned long flags;
+
+       spin_lock_irqsave(&cnt->lock, flags);
+       cnt->low_limit = low_limit;
+       spin_unlock_irqrestore(&cnt->lock, flags);
+       return 0;
+}
+
 #endif

diff --git a/kernel/res_counter.c b/kernel/res_counter.c
index 51dbac6a363358b435a14f9e7952b9489eb3bf9d..e851a9ad50bf354416993cc197d6fbee56619553 100644 (file)
--- a/kernel/res_counter.c
+++ b/kernel/res_counter.c
@@ -136,6 +136,8 @@ res_counter_member(struct res_counter *counter, int member)
                return &counter->failcnt;
        case RES_SOFT_LIMIT:
                return &counter->soft_limit;
+       case RES_LOW_LIMIT:
+               return &counter->low_limit;
        };
 
        BUG();

diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index f650f2b30870a1570ff11c040e943d002dde32cd..299bf6a524ab30ef334f50292ad0403213ed1839 100644 (file)
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -1688,8 +1688,9 @@ void mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
 
        rcu_read_unlock();
 
-       pr_info("memory: usage %llukB, limit %llukB, failcnt %llu\n",
+       pr_info("memory: usage %llukB, low_limit %llukB limit %llukB, failcnt %llu\n",
                res_counter_read_u64(&memcg->res, RES_USAGE) >> 10,
+               res_counter_read_u64(&memcg->res, RES_LOW_LIMIT) >> 10,
                res_counter_read_u64(&memcg->res, RES_LIMIT) >> 10,
                res_counter_read_u64(&memcg->res, RES_FAILCNT));
        pr_info("memory+swap: usage %llukB, limit %llukB, failcnt %llu\n",
@@ -5128,6 +5129,24 @@ static int mem_cgroup_write(struct cgroup_subsys_state *css, struct cftype *cft,
                else
                        return -EINVAL;
                break;
+       case RES_LOW_LIMIT:
+               if (mem_cgroup_is_root(memcg)) { /* Can't set limit on root */
+                       ret = -EINVAL;
+                       break;
+               }
+               ret = res_counter_memparse_write_strategy(buffer, &val);
+               if (ret)
+                       break;
+               if (type == _MEM) {
+                       ret = res_counter_set_low_limit(&memcg->res, val);
+                       break;
+               }
+               /*
+                * memsw low limit doesn't make any sense and kmem is not
+                * implemented yet - if ever
+                */
+               return -EINVAL;
+
        case RES_SOFT_LIMIT:
                ret = res_counter_memparse_write_strategy(buffer, &val);
                if (ret)
@@ -6049,6 +6068,12 @@ static struct cftype mem_cgroup_files[] = {
                .write_string = mem_cgroup_write,
                .read_u64 = mem_cgroup_read_u64,
        },
+       {
+               .name = "low_limit_in_bytes",
+               .private = MEMFILE_PRIVATE(_MEM, RES_LOW_LIMIT),
+               .write_string = mem_cgroup_write,
+               .read_u64 = mem_cgroup_read_u64,
+       },
        {
                .name = "soft_limit_in_bytes",
                .private = MEMFILE_PRIVATE(_MEM, RES_SOFT_LIMIT),