@@ -1098,6 +1098,17 @@ PAGE_SIZE multiple when read back.
If cgroup-aware OOM killer is not enabled, ENOTSUPP error
is returned on attempt to access the file.
+ memory.oom_policy
+
+ A read-write single string file which exists on all cgroups. The
+ default value is "none".
+
+ If "none", the OOM killer will use the default policy to choose a
+ victim; that is, it will choose the single process with the largest
+ memory footprint adjusted by /proc/pid/oom_score_adj (see
+ Documentation/filesystems/proc.txt). This is the same policy as if
+ memory cgroups were not even mounted.
+
memory.events
A read-only flat-keyed file which exists on non-root cgroups.
The following entries are defined. Unless specified
@@ -66,6 +66,14 @@ enum mem_cgroup_protection {
MEMCG_PROT_MIN,
};
+enum memcg_oom_policy {
+ /*
+ * No special oom policy, process selection is determined by
+ * oom_badness()
+ */
+ MEMCG_OOM_POLICY_NONE,
+};
+
struct mem_cgroup_reclaim_cookie {
pg_data_t *pgdat;
int priority;
@@ -234,6 +242,9 @@ struct mem_cgroup {
/* OOM-Killer disable */
int oom_kill_disable;
+ /* OOM policy for this subtree */
+ enum memcg_oom_policy oom_policy;
+
/*
* Treat the sub-tree as an indivisible memory consumer,
* kill all belonging tasks if the memory cgroup selected
@@ -4649,6 +4649,7 @@ mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
if (parent) {
memcg->swappiness = mem_cgroup_swappiness(parent);
memcg->oom_kill_disable = parent->oom_kill_disable;
+ memcg->oom_policy = parent->oom_policy;
}
if (parent && parent->use_hierarchy) {
memcg->use_hierarchy = true;
@@ -5810,6 +5811,34 @@ static int memory_stat_show(struct seq_file *m, void *v)
return 0;
}
+static int memory_oom_policy_show(struct seq_file *m, void *v)
+{
+ struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
+ enum memcg_oom_policy policy = READ_ONCE(memcg->oom_policy);
+
+ switch (policy) {
+ case MEMCG_OOM_POLICY_NONE:
+ default:
+ seq_puts(m, "[none]\n");
+ };
+ return 0;
+}
+
+static ssize_t memory_oom_policy_write(struct kernfs_open_file *of,
+ char *buf, size_t nbytes, loff_t off)
+{
+ struct mem_cgroup *memcg = mem_cgroup_from_css(of_css(of));
+ ssize_t ret = nbytes;
+
+ buf = strstrip(buf);
+ if (!memcmp("none", buf, min(sizeof("none")-1, nbytes)))
+ memcg->oom_policy = MEMCG_OOM_POLICY_NONE;
+ else
+ ret = -EINVAL;
+
+ return ret;
+}
+
static struct cftype memory_files[] = {
{
.name = "current",
@@ -5857,6 +5886,12 @@ static struct cftype memory_files[] = {
.flags = CFTYPE_NOT_ON_ROOT,
.seq_show = memory_stat_show,
},
+ {
+ .name = "oom_policy",
+ .flags = CFTYPE_NS_DELEGATABLE,
+ .seq_show = memory_oom_policy_show,
+ .write = memory_oom_policy_write,
+ },
{ } /* terminate */
};
The cgroup aware oom killer is needlessly enforced for the entire system by a mount option. It's unnecessary to force the system into a single oom policy: either cgroup aware, or the traditional process aware. This patch introduces a memory.oom_policy tunable for all mem cgroups. It is currently a no-op: it can only be set to "none", which is its default policy. It will be expanded in the next patch to define cgroup aware oom killer behavior for its subtree. This is an extensible interface that can be used to define cgroup aware assessment of mem cgroup subtrees or the traditional process aware assessment. Reading memory.oom_policy will specify the list of available policies. Another benefit of such an approach is that an admin can lock in a certain policy for the system or for a mem cgroup subtree and can delegate the policy decision to the user to determine if the kill should originate from a subcontainer, as indivisible memory consumers themselves, or selection should be done per process. Signed-off-by: David Rientjes <rientjes@google.com> --- Documentation/admin-guide/cgroup-v2.rst | 11 ++++++++ include/linux/memcontrol.h | 11 ++++++++ mm/memcontrol.c | 35 +++++++++++++++++++++++++ 3 files changed, 57 insertions(+)