From patchwork Mon Jul 13 11:06:01 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chris Down X-Patchwork-Id: 11659483 Return-Path: Received: from mail.kernel.org (pdx-korg-mail-1.web.codeaurora.org [172.30.200.123]) by pdx-korg-patchwork-2.web.codeaurora.org (Postfix) with ESMTP id F375113B6 for ; Mon, 13 Jul 2020 11:06:05 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id B2F8C2083B for ; Mon, 13 Jul 2020 11:06:05 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chrisdown.name header.i=@chrisdown.name header.b="LFQgUlJ+" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org B2F8C2083B Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=chrisdown.name Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id E7BB28D0006; Mon, 13 Jul 2020 07:06:04 -0400 (EDT) Delivered-To: linux-mm-outgoing@kvack.org Received: by kanga.kvack.org (Postfix, from userid 40) id E2C2F8D0001; Mon, 13 Jul 2020 07:06:04 -0400 (EDT) X-Original-To: int-list-linux-mm@kvack.org X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id CF4A58D0006; Mon, 13 Jul 2020 07:06:04 -0400 (EDT) X-Original-To: linux-mm@kvack.org X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0221.hostedemail.com [216.40.44.221]) by kanga.kvack.org (Postfix) with ESMTP id BA5178D0001 for ; Mon, 13 Jul 2020 07:06:04 -0400 (EDT) Received: from smtpin05.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay04.hostedemail.com (Postfix) with ESMTP id 76D291F0A for ; Mon, 13 Jul 2020 11:06:04 +0000 (UTC) X-FDA: 77032773048.05.fruit96_1b08b7826ee7 Received: from filter.hostedemail.com (10.5.16.251.rfc1918.com [10.5.16.251]) by smtpin05.hostedemail.com (Postfix) with ESMTP id 4C65418017AD5 for ; Mon, 13 Jul 2020 11:06:04 +0000 (UTC) X-Spam-Summary: 1,0,0,857297f06c7edeea,d41d8cd98f00b204,chris@chrisdown.name,,RULES_HIT:2:41:69:355:379:800:960:973:988:989:1260:1277:1312:1313:1314:1345:1359:1437:1516:1518:1519:1535:1593:1594:1595:1596:1605:1730:1747:1777:1792:2198:2199:2393:2553:2559:2562:2731:2890:2897:2898:3138:3139:3140:3141:3142:3865:3866:3867:3868:3870:3871:3872:3874:4042:4049:4120:4321:4605:5007:6261:6653:7903:9040:9592:10004:11026:11232:11473:11658:11914:12043:12291:12295:12296:12297:12438:12517:12519:12555:12683:12895:12986:13255:13439:13895:14096:14097:14394:21063:21080:21444:21450:21451:21627:21795:21966:21990:30001:30041:30045:30051:30054:30064:30070:30090,0,RBL:209.85.218.67:@chrisdown.name:.lbl8.mailshell.net-62.2.0.100 66.100.201.201;04y8sbhemnowakdngg7mmjg6enyu9yc879im85ooagzjypgwp1bx9qrbi9ir99p.my619rfa4me673553y9r5uimfd96adkmt54wawmfcw911ni98dn831jczx4ydxj.g-lbl8.mailshell.net-223.238.255.100,CacheIP:none,Bayesian:0.5,0.5,0.5,Netcheck:none,DomainCache:0,MSF:not bulk,SPF:fp,MSBL:0,DNSBL:non e,Custom X-HE-Tag: fruit96_1b08b7826ee7 X-Filterd-Recvd-Size: 9708 Received: from mail-ej1-f67.google.com (mail-ej1-f67.google.com [209.85.218.67]) by imf02.hostedemail.com (Postfix) with ESMTP for ; Mon, 13 Jul 2020 11:06:03 +0000 (UTC) Received: by mail-ej1-f67.google.com with SMTP id br7so2649541ejb.5 for ; Mon, 13 Jul 2020 04:06:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=chrisdown.name; s=google; h=date:from:to:cc:subject:message-id:references:mime-version :content-disposition:in-reply-to:user-agent; bh=ZoFkzkrQ309RFK+OEsYyChcl3CTS19ns9lFUyyEZu6I=; b=LFQgUlJ+p3zW2HOohTZcQq0P9OZqCn0CZRV0HGSvImtjSzSUtVppG/KQiK1YkTZHTp 6TWBAPc17Yp4sU9vBHDYzg44bvvA9m2lQNSI6McRsXDS1EX+I76sdFvmMwKfKqB3HB2y wkBxcblZOEGjILE15qynikXnOrpBBMbCnWIO4= 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:message-id:references :mime-version:content-disposition:in-reply-to:user-agent; bh=ZoFkzkrQ309RFK+OEsYyChcl3CTS19ns9lFUyyEZu6I=; b=s7r6MFdglF23bjOdfR6QxKa3mQNPaiIaqF98avknDUgD2XY6aeFXDMGxUWDIh7bqUP DMeX8soMDhvWxbD17AUcNXgunOb+SkiCOQDnH67ZeGfhzryUF+FUJiE/DntjEYHOfeLD OukNiIaWYgSt8clbq0U9FrK6WRqSnJhbvYEXbZ9gkhLk5HkL+DPDGDjmdOVGZDP7FhNs ijhZeqMUUqouW5fMQZKXkQCUcbTDMZIydqNxAFAnZdUvCrPJzQd75IaqNIP4fMo+xNIX v4QqAUlV/RYrNl/DncCrx4VxHMzKxbWY4E2oFuxIkQJnxT7FxzeriEjKKUGEQK4a0y0H D9fw== X-Gm-Message-State: AOAM532jORShPcBQpzXEYKvSfdehZZumSqyhaP8LT4OPNKUpARrNxBgw zgivE1zeEScvcGsi8AXkgVSuVw== X-Google-Smtp-Source: ABdhPJx8VC1E7arfSO0GtUNoH/+MOB0zhtWuPG7aUY/otYk3jFdjhA+LKvkFN4VSahhnVp2L/73NfQ== X-Received: by 2002:a17:906:aac9:: with SMTP id kt9mr68370630ejb.488.1594638362470; Mon, 13 Jul 2020 04:06:02 -0700 (PDT) Received: from localhost ([2620:10d:c093:400::5:ef88]) by smtp.gmail.com with ESMTPSA id d16sm9318965ejo.31.2020.07.13.04.06.01 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 13 Jul 2020 04:06:01 -0700 (PDT) Date: Mon, 13 Jul 2020 12:06:01 +0100 From: Chris Down To: Andrew Morton Cc: Johannes Weiner , Michal Hocko , Roman Gushchin , Yafang Shao , linux-mm@kvack.org, cgroups@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [PATCH v4 2/2] mm, memcg: Decouple e{low,min} state mutations from protection checks Message-ID: References: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: User-Agent: Mutt/1.14.5 (2020-06-23) X-Rspamd-Queue-Id: 4C65418017AD5 X-Spamd-Result: default: False [0.00 / 100.00] X-Rspamd-Server: rspam05 X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: mem_cgroup_protected currently is both used to set effective low and min and return a mem_cgroup_protection based on the result. As a user, this can be a little unexpected: it appears to be a simple predicate function, if not for the big warning in the comment above about the order in which it must be executed. This change makes it so that we separate the state mutations from the actual protection checks, which makes it more obvious where we need to be careful mutating internal state, and where we are simply checking and don't need to worry about that. [mhocko@suse.com - don't check protection on root memcgs] Signed-off-by: Chris Down Suggested-by: Johannes Weiner Acked-by: Johannes Weiner Acked-by: Michal Hocko Cc: Roman Gushchin --- include/linux/memcontrol.h | 53 ++++++++++++++++++++++++++++++-------- mm/memcontrol.c | 28 +++++--------------- mm/vmscan.c | 17 +++--------- 3 files changed, 53 insertions(+), 45 deletions(-) diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h index 33d834a187e5..d7887888ce99 100644 --- a/include/linux/memcontrol.h +++ b/include/linux/memcontrol.h @@ -55,12 +55,6 @@ enum memcg_memory_event { MEMCG_NR_MEMORY_EVENTS, }; -enum mem_cgroup_protection { - MEMCG_PROT_NONE, - MEMCG_PROT_LOW, - MEMCG_PROT_MIN, -}; - struct mem_cgroup_reclaim_cookie { pg_data_t *pgdat; unsigned int generation; @@ -413,8 +407,36 @@ static inline unsigned long mem_cgroup_protection(struct mem_cgroup *root, READ_ONCE(memcg->memory.elow)); } -enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root, - struct mem_cgroup *memcg); +void mem_cgroup_calculate_protection(struct mem_cgroup *root, + struct mem_cgroup *memcg); + +static inline bool mem_cgroup_supports_protection(struct mem_cgroup *memcg) +{ + /* + * The root memcg doesn't account charges, and doesn't support + * protection. + */ + return !mem_cgroup_disabled() && !mem_cgroup_is_root(memcg); + +} + +static inline bool mem_cgroup_below_low(struct mem_cgroup *memcg) +{ + if (!mem_cgroup_supports_protection(memcg)) + return false; + + return READ_ONCE(memcg->memory.elow) >= + page_counter_read(&memcg->memory); +} + +static inline bool mem_cgroup_below_min(struct mem_cgroup *memcg) +{ + if (!mem_cgroup_supports_protection(memcg)) + return false; + + return READ_ONCE(memcg->memory.emin) >= + page_counter_read(&memcg->memory); +} int mem_cgroup_charge(struct page *page, struct mm_struct *mm, gfp_t gfp_mask); @@ -943,10 +965,19 @@ static inline unsigned long mem_cgroup_protection(struct mem_cgroup *root, return 0; } -static inline enum mem_cgroup_protection mem_cgroup_protected( - struct mem_cgroup *root, struct mem_cgroup *memcg) +static inline void mem_cgroup_calculate_protection(struct mem_cgroup *root, + struct mem_cgroup *memcg) { - return MEMCG_PROT_NONE; +} + +static inline bool mem_cgroup_below_low(struct mem_cgroup *memcg) +{ + return false; +} + +static inline bool mem_cgroup_below_min(struct mem_cgroup *memcg) +{ + return false; } static inline int mem_cgroup_charge(struct page *page, struct mm_struct *mm, diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 21b620e36aa0..1f101078b217 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -6548,21 +6548,15 @@ static unsigned long effective_protection(unsigned long usage, * * WARNING: This function is not stateless! It can only be used as part * of a top-down tree iteration, not for isolated queries. - * - * Returns one of the following: - * MEMCG_PROT_NONE: cgroup memory is not protected - * MEMCG_PROT_LOW: cgroup memory is protected as long there is - * an unprotected supply of reclaimable memory from other cgroups. - * MEMCG_PROT_MIN: cgroup memory is protected */ -enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root, - struct mem_cgroup *memcg) +void mem_cgroup_calculate_protection(struct mem_cgroup *root, + struct mem_cgroup *memcg) { unsigned long usage, parent_usage; struct mem_cgroup *parent; if (mem_cgroup_disabled()) - return MEMCG_PROT_NONE; + return; if (!root) root = root_mem_cgroup; @@ -6575,21 +6569,21 @@ enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root, * that special casing. */ if (memcg == root) - return MEMCG_PROT_NONE; + return; usage = page_counter_read(&memcg->memory); if (!usage) - return MEMCG_PROT_NONE; + return; parent = parent_mem_cgroup(memcg); /* No parent means a non-hierarchical mode on v1 memcg */ if (!parent) - return MEMCG_PROT_NONE; + return; if (parent == root) { memcg->memory.emin = READ_ONCE(memcg->memory.min); memcg->memory.elow = READ_ONCE(memcg->memory.low); - goto out; + return; } parent_usage = page_counter_read(&parent->memory); @@ -6603,14 +6597,6 @@ enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root, READ_ONCE(memcg->memory.low), READ_ONCE(parent->memory.elow), atomic_long_read(&parent->memory.children_low_usage))); - -out: - if (usage <= memcg->memory.emin) - return MEMCG_PROT_MIN; - else if (usage <= memcg->memory.elow) - return MEMCG_PROT_LOW; - else - return MEMCG_PROT_NONE; } /** diff --git a/mm/vmscan.c b/mm/vmscan.c index 89921a12acae..626bdde485b3 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -2615,14 +2615,15 @@ static void shrink_node_memcgs(pg_data_t *pgdat, struct scan_control *sc) unsigned long reclaimed; unsigned long scanned; - switch (mem_cgroup_protected(target_memcg, memcg)) { - case MEMCG_PROT_MIN: + mem_cgroup_calculate_protection(target_memcg, memcg); + + if (mem_cgroup_below_min(memcg)) { /* * Hard protection. * If there is no reclaimable memory, OOM. */ continue; - case MEMCG_PROT_LOW: + } else if (mem_cgroup_below_low(memcg)) { /* * Soft protection. * Respect the protection only as long as @@ -2634,16 +2635,6 @@ static void shrink_node_memcgs(pg_data_t *pgdat, struct scan_control *sc) continue; } memcg_memory_event(memcg, MEMCG_LOW); - break; - case MEMCG_PROT_NONE: - /* - * All protection thresholds breached. We may - * still choose to vary the scan pressure - * applied based on by how much the cgroup in - * question has exceeded its protection - * thresholds (see get_scan_count). - */ - break; } reclaimed = sc->nr_reclaimed;