From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-8.4 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,MAILING_LIST_MULTI,SPF_PASS, T_DKIMWL_WL_MED,USER_IN_DEF_DKIM_WL autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 47378C468C6 for ; Fri, 13 Jul 2018 23:07:35 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id E84AF208A1 for ; Fri, 13 Jul 2018 23:07:34 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="oiUvHQwB" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E84AF208A1 Authentication-Results: mail.kernel.org; dmarc=fail (p=reject dis=none) header.from=google.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1731898AbeGMXYO (ORCPT ); Fri, 13 Jul 2018 19:24:14 -0400 Received: from mail-pf0-f196.google.com ([209.85.192.196]:39300 "EHLO mail-pf0-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1731592AbeGMXYN (ORCPT ); Fri, 13 Jul 2018 19:24:13 -0400 Received: by mail-pf0-f196.google.com with SMTP id s21-v6so23428495pfm.6 for ; Fri, 13 Jul 2018 16:07:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=date:from:to:cc:subject:in-reply-to:message-id:references :user-agent:mime-version; bh=WOnO5EeeqUhQ5cYMpWpsvlm4YZxVLKH4lNKgsOqxjMI=; b=oiUvHQwB93DH7UDGssZox15UAv2dIHlzDGCc+yLX6JL1ZaB6OYSzG+VehngDE2j7// zU4jlNmSr1DFS8/NArPUezLM7g2ceWtsaMl4IvavUad1souwmH/wSSk+vOUPE4TmsyBw c+2IvNZP1JeTch4NUwbW/MTDpk2XgnOBZUmz62n12QyGje0y/6fL39WIzEhoZJXa9OEy TG14MWjm3R2yNdFFoA02XjweSDQMGnwg1OnNZlhVMoIrGSdv1dMfbq47e3dRCnJxIyf0 VC2nD/rUdGoCEroGnpaqScPsaxKGA/hpjQrPRCznHDuZjI+e4TISccXR8LgALfhAXHIt CewQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:in-reply-to:message-id :references:user-agent:mime-version; bh=WOnO5EeeqUhQ5cYMpWpsvlm4YZxVLKH4lNKgsOqxjMI=; b=T7BUf/eLB1QDj4xh+d6V4pK9pNSIGeb7JZy+OzsxrDi4H5e4iKLbXpAUHqFMiUBG2v 0suBmmKVb1RxBDcQ5zJjwS0klTlGA9hY40R5bRTULIyQxWdOi8MuIa8rBM2Tcly/zQvY kbRxP7sgUPbfor7x5wujU+PyzSdbuvdfsXjuvjOeb8LltDLUma39vvyyMh7B7ZEnidg1 m7/+ZVjLaKe52LRbspBO4fXXW4smvkm33yo6x4k2uw9Xy798oOKkyW9iw6ccPNzFmZfc W5uRA8Hhc/NEKYdrsiLq7U4yQhTzqFJQZnsxxwKgIQqgkS/70ddjT+V1P4/JUm5jNqk4 VRiQ== X-Gm-Message-State: AOUpUlG2mcqKDgoZJUQHOZOd+oRqxemQ1waxNX7+xCJ3YC+XNOJW2eRk E2Wtve+5/5uxE9FUZE+MxycRjA== X-Google-Smtp-Source: AAOMgpfIkqG9uxewubJJZphPa6Cm8hLcikZ5vGmuZcFkK2562P40XZ9jF2h10fbdmXF5P/ZESE4u2w== X-Received: by 2002:a63:5350:: with SMTP id t16-v6mr7599006pgl.196.1531523250254; Fri, 13 Jul 2018 16:07:30 -0700 (PDT) Received: from [2620:15c:17:3:3a5:23a7:5e32:4598] ([2620:15c:17:3:3a5:23a7:5e32:4598]) by smtp.gmail.com with ESMTPSA id v4-v6sm175043pgr.36.2018.07.13.16.07.29 (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Fri, 13 Jul 2018 16:07:29 -0700 (PDT) Date: Fri, 13 Jul 2018 16:07:29 -0700 (PDT) From: David Rientjes X-X-Sender: rientjes@chino.kir.corp.google.com To: Andrew Morton , Roman Gushchin cc: Michal Hocko , Vladimir Davydov , Johannes Weiner , Tejun Heo , cgroups@vger.kernel.org, linux-kernel@vger.kernel.org, linux-mm@kvack.org Subject: [patch v3 -mm 3/6] mm, memcg: add hierarchical usage oom policy In-Reply-To: Message-ID: References: User-Agent: Alpine 2.21 (DEB 202 2017-01-01) MIME-Version: 1.0 Content-Type: text/plain; charset=US-ASCII Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org One of the three significant concerns brought up about the cgroup aware oom killer is that its decisionmaking is completely evaded by creating subcontainers and attaching processes such that the ancestor's usage does not exceed another cgroup on the system. Consider the example from the previous patch where "memory" is set in each mem cgroup's cgroup.controllers: mem cgroup cgroup.procs ========== ============ /cg1 1 process consuming 250MB /cg2 3 processes consuming 100MB each /cg3/cg31 2 processes consuming 100MB each /cg3/cg32 2 processes consuming 100MB each If memory.oom_policy is "cgroup", a process from /cg2 is chosen because it is in the single indivisible memory consumer with the greatest usage. The true usage of /cg3 is actually 400MB, but a process from /cg2 is chosen because cgroups are compared individually rather than hierarchically. If a system is divided into two users, for example: mem cgroup memory.max ========== ========== /userA 250MB /userB 250MB If /userA runs all processes attached to the local mem cgroup, whereas /userB distributes their processes over a set of subcontainers under /userB, /userA will be unfairly penalized. There is incentive with cgroup v2 to distribute processes over a set of subcontainers if those processes shall be constrained by other cgroup controllers; this is a direct result of mandating a single, unified hierarchy for cgroups. A user may also reasonably do this for mem cgroup control or statistics. And, a user may do this to evade the cgroup-aware oom killer selection logic. This patch adds an oom policy, "tree", that accounts for hierarchical usage when comparing cgroups and the cgroup aware oom killer is enabled by an ancestor. This allows administrators, for example, to require users in their own top-level mem cgroup subtree to be accounted for with hierarchical usage. In other words, they can longer evade the oom killer by using other controllers or subcontainers. If an oom policy of "tree" is in place for a subtree, such as /cg3 above, the hierarchical usage is used for comparisons with other cgroups if either "cgroup" or "tree" is the oom policy of the oom mem cgroup. Thus, if /cg3/memory.oom_policy is "tree", one of the processes from /cg3's subcontainers is chosen for oom kill. Signed-off-by: David Rientjes --- Documentation/admin-guide/cgroup-v2.rst | 17 ++++++++++++++--- include/linux/memcontrol.h | 5 +++++ mm/memcontrol.c | 18 ++++++++++++------ 3 files changed, 31 insertions(+), 9 deletions(-) diff --git a/Documentation/admin-guide/cgroup-v2.rst b/Documentation/admin-guide/cgroup-v2.rst --- a/Documentation/admin-guide/cgroup-v2.rst +++ b/Documentation/admin-guide/cgroup-v2.rst @@ -1113,6 +1113,10 @@ PAGE_SIZE multiple when read back. memory consumers; that is, they will compare mem cgroup usage rather than process memory footprint. See the "OOM Killer" section below. + If "tree", the OOM killer will compare mem cgroups and its subtree + as a single indivisible memory consumer. This policy cannot be set + on the root mem cgroup. See the "OOM Killer" section below. + When an OOM condition occurs, the policy is dictated by the mem cgroup that is OOM (the root mem cgroup for a system-wide OOM condition). If a descendant mem cgroup has a policy of "none", for @@ -1120,6 +1124,10 @@ PAGE_SIZE multiple when read back. the heuristic will still compare mem cgroups as indivisible memory consumers. + When an OOM condition occurs in a mem cgroup with an OOM policy of + "cgroup" or "tree", the OOM killer will compare mem cgroups with + "cgroup" policy individually with "tree" policy subtrees. + memory.events A read-only flat-keyed file which exists on non-root cgroups. The following entries are defined. Unless specified @@ -1355,7 +1363,7 @@ out of memory, its memory.oom_policy will dictate how the OOM killer will select a process, or cgroup, to kill. Likewise, when the system is OOM, the policy is dictated by the root mem cgroup. -There are currently two available oom policies: +There are currently three available oom policies: - "none": default, choose the largest single memory hogging process to oom kill, as traditionally the OOM killer has always done. @@ -1364,6 +1372,9 @@ There are currently two available oom policies: subtree as an OOM victim and kill at least one process, depending on memory.oom_group, from it. + - "tree": choose the cgroup with the largest memory footprint considering + itself and its subtree and kill at least one process. + When selecting a cgroup as a victim, the OOM killer will kill the process with the largest memory footprint. A user can control this behavior by enabling the per-cgroup memory.oom_group option. If set, it causes the @@ -1382,8 +1393,8 @@ Please, note that memory charges are not migrating if tasks are moved between different memory cgroups. Moving tasks with significant memory footprint may affect OOM victim selection logic. If it's a case, please, consider creating a common ancestor for -the source and destination memory cgroups and enabling oom_group -on ancestor layer. +the source and destination memory cgroups and setting a policy of "tree" +and enabling oom_group on an ancestor layer. IO diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h --- a/include/linux/memcontrol.h +++ b/include/linux/memcontrol.h @@ -77,6 +77,11 @@ enum memcg_oom_policy { * mem cgroup as an indivisible consumer */ MEMCG_OOM_POLICY_CGROUP, + /* + * Tree cgroup usage for all descendant memcg groups, treating each mem + * cgroup and its subtree as an indivisible consumer + */ + MEMCG_OOM_POLICY_TREE, }; struct mem_cgroup_reclaim_cookie { diff --git a/mm/memcontrol.c b/mm/memcontrol.c --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -2952,7 +2952,7 @@ static void select_victim_memcg(struct mem_cgroup *root, struct oom_control *oc) /* * The oom_score is calculated for leaf memory cgroups (including * the root memcg). - * Non-leaf oom_group cgroups accumulating score of descendant + * Cgroups with oom policy of "tree" accumulate the score of descendant * leaf memory cgroups. */ rcu_read_lock(); @@ -2961,10 +2961,11 @@ static void select_victim_memcg(struct mem_cgroup *root, struct oom_control *oc) /* * We don't consider non-leaf non-oom_group memory cgroups - * as OOM victims. + * without the oom policy of "tree" as OOM victims. */ if (memcg_has_children(iter) && iter != root_mem_cgroup && - !mem_cgroup_oom_group(iter)) + !mem_cgroup_oom_group(iter) && + iter->oom_policy != MEMCG_OOM_POLICY_TREE) continue; /* @@ -3027,7 +3028,7 @@ bool mem_cgroup_select_oom_victim(struct oom_control *oc) else root = root_mem_cgroup; - if (root->oom_policy != MEMCG_OOM_POLICY_CGROUP) + if (root->oom_policy == MEMCG_OOM_POLICY_NONE) return false; select_victim_memcg(root, oc); @@ -5812,11 +5813,14 @@ static int memory_oom_policy_show(struct seq_file *m, void *v) switch (policy) { case MEMCG_OOM_POLICY_CGROUP: - seq_puts(m, "none [cgroup]\n"); + seq_puts(m, "none [cgroup] tree\n"); + break; + case MEMCG_OOM_POLICY_TREE: + seq_puts(m, "none cgroup [tree]\n"); break; case MEMCG_OOM_POLICY_NONE: default: - seq_puts(m, "[none] cgroup\n"); + seq_puts(m, "[none] cgroup tree\n"); }; return 0; } @@ -5832,6 +5836,8 @@ static ssize_t memory_oom_policy_write(struct kernfs_open_file *of, memcg->oom_policy = MEMCG_OOM_POLICY_NONE; else if (!memcmp("cgroup", buf, min(sizeof("cgroup")-1, nbytes))) memcg->oom_policy = MEMCG_OOM_POLICY_CGROUP; + else if (!memcmp("tree", buf, min(sizeof("tree")-1, nbytes))) + memcg->oom_policy = MEMCG_OOM_POLICY_TREE; else ret = -EINVAL;