From patchwork Sat May 2 13:59:09 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yafang Shao X-Patchwork-Id: 11523917 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 B9CD41575 for ; Sat, 2 May 2020 13:59:48 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 7974824953 for ; Sat, 2 May 2020 13:59:48 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="PJwvYDyW" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 7974824953 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id A13318E0006; Sat, 2 May 2020 09:59:47 -0400 (EDT) Delivered-To: linux-mm-outgoing@kvack.org Received: by kanga.kvack.org (Postfix, from userid 40) id 9EA208E0001; Sat, 2 May 2020 09:59:47 -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 8D9E38E0006; Sat, 2 May 2020 09:59:47 -0400 (EDT) X-Original-To: linux-mm@kvack.org X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0070.hostedemail.com [216.40.44.70]) by kanga.kvack.org (Postfix) with ESMTP id 77DF68E0001 for ; Sat, 2 May 2020 09:59:47 -0400 (EDT) Received: from smtpin06.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay04.hostedemail.com (Postfix) with ESMTP id 3591140E1 for ; Sat, 2 May 2020 13:59:47 +0000 (UTC) X-FDA: 76771937214.06.hook44_8f9ca836e425a X-Spam-Summary: 2,0,0,8a74aea36f7f71be,d41d8cd98f00b204,laoar.shao@gmail.com,,RULES_HIT:2:41:355:379:541:800:960:973:988:989:1260:1345:1359:1437:1535:1605:1606:1730:1747:1777:1792:2393:2553:2559:2562:2897:3138:3139:3140:3141:3142:3865:3866:3867:3868:3870:3871:3872:3874:4119:4250:4321:4605:5007:6261:6653:7514:7903:7904:9163:9413:10004:11026:11473:11658:11914:12043:12219:12291:12295:12296:12297:12438:12517:12519:12555:12664:12679:12683:12895:13161:13229:13255:14096:14394:14687:21080:21444:21451:21627:21666:21740:21939:21966:21990:30012:30054:30056:30064:30074:30090,0,RBL:209.85.216.68:@gmail.com:.lbl8.mailshell.net-66.100.201.100 62.18.0.100,CacheIP:none,Bayesian:0.5,0.5,0.5,Netcheck:none,DomainCache:0,MSF:not bulk,SPF:fp,MSBL:0,DNSBL:none,Custom_rules:0:0:0,LFtime:24,LUA_SUMMARY:none X-HE-Tag: hook44_8f9ca836e425a X-Filterd-Recvd-Size: 8092 Received: from mail-pj1-f68.google.com (mail-pj1-f68.google.com [209.85.216.68]) by imf41.hostedemail.com (Postfix) with ESMTP for ; Sat, 2 May 2020 13:59:46 +0000 (UTC) Received: by mail-pj1-f68.google.com with SMTP id fu13so1267856pjb.5 for ; Sat, 02 May 2020 06:59:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=caKjrX3mTcTL/HDQZh9r3jby6eePBgvigX1m8H2FqMM=; b=PJwvYDyWmjLiD+opA/iBX4wubGJhRitB58y81nezrrNMsgjVGaRf0J9qJaW2M9+gFO 0+rOGTfncF4XnZJRUYD0ghz+Vcb9/cPNlzfh8bmmmsjOXxkKMWsZA0ViwqBSODbudPFR 350kx4N28wPyr4GvSLkJsnsMU9H2qEEURjYoucYThEaUD/Far0+ZBh6HRZjDs9nBmMKg psCARF95htu373na2YZP9lhh/E2KY2lMXRc/eI3I/HyTonETRtc2iLOSZxS+PWg565AB J+6KByaisPncFT82ZrAhWg7X+X0Dz0QbL+Myv78b/FQXIwHMBzS1y/8mA2r0PdzD7z5P a9MA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=caKjrX3mTcTL/HDQZh9r3jby6eePBgvigX1m8H2FqMM=; b=o16RKivgBzThfNPKUByI4dVl0bUbVWsuLy+TBkMzDcdNNv6XZ8XF3bjbJwTzmCVhiA ePzs0s4Bn1h990MTn+rkjK0TpkwpKmjarU3NGTGI/FKUJ7B/w1Y9NIzpXPD9Yel7DCJo 0IQ0iu/RYvtlPHZqOGT9/UUVmgOSEvyT+73+zLcTJkcULsrt9RxSGryDvW5VSRH/5E37 Yug85w+aRtcXKZcOax+nMu2tSx6+lLPGnafP8TT0K+drVrOvXS2MMjQ7+g2J6lB5GX6u WOBWUVeXFmsg0+NKTL9LitddJBQeHkbga1wKofn12MLvQhztAL7F5OgJqKYQkmcv3vPu tZOg== X-Gm-Message-State: AGi0PubW6rQ2biQsFe3zZ2o4YPSAq+uDq7zU5U/qpmVATkMSMkduBUbl kWsSal4Q2LTLssyA+CgPxPM= X-Google-Smtp-Source: APiQypLcvy71ZPYf/vQvh6nnnTSNaj1XveXfT4i+EVrOXHkd69BF3phI+Vum5pDRX5D92EbZ0wemrA== X-Received: by 2002:a17:902:a405:: with SMTP id p5mr9667988plq.36.1588427985783; Sat, 02 May 2020 06:59:45 -0700 (PDT) Received: from localhost.localdomain ([203.100.54.194]) by smtp.gmail.com with ESMTPSA id i11sm4145708pgi.1.2020.05.02.06.59.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 02 May 2020 06:59:45 -0700 (PDT) From: Yafang Shao To: akpm@linux-foundation.org Cc: mhocko@kernel.org, hannes@cmpxchg.org, chris@chrisdown.name, guro@fb.com, linux-mm@kvack.org, Yafang Shao Subject: [PATCH v2 1/2] mm, memcg: Avoid stale protection values when cgroup is above protection Date: Sat, 2 May 2020 09:59:09 -0400 Message-Id: <20200502135910.7255-2-laoar.shao@gmail.com> X-Mailer: git-send-email 2.18.1 In-Reply-To: <20200502135910.7255-1-laoar.shao@gmail.com> References: <20200502135910.7255-1-laoar.shao@gmail.com> 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: A cgroup can have both memory protection and a memory limit to isolate it from its siblings in both directions - for example, to prevent it from being shrunk below 2G under high pressure from outside, but also from growing beyond 4G under low pressure. Commit 9783aa9917f8 ("mm, memcg: proportional memory.{low,min} reclaim") implemented proportional scan pressure so that multiple siblings in excess of their protection settings don't get reclaimed equally but instead in accordance to their unprotected portion. During limit reclaim, this proportionality shouldn't apply of course: there is no competition, all pressure is from within the cgroup and should be applied as such. Reclaim should operate at full efficiency. However, mem_cgroup_protected() never expected anybody to look at the effective protection values when it indicated that the cgroup is above its protection. As a result, a query during limit reclaim may return stale protection values that were calculated by a previous reclaim cycle in which the cgroup did have siblings. When this happens, reclaim is unnecessarily hesitant and potentially slow to meet the desired limit. In theory this could lead to premature OOM kills, although it's not obvious this has occurred in practice. [hannes@cmpxchg.org: changelog] [mhocko@kernel.org: rework code comment] [chris@chrisdown.name: retitle] Fixes: 9783aa9917f8 ("mm, memcg: proportional memory.{low,min} reclaim") Signed-off-by: Yafang Shao Acked-by: Roman Gushchin Cc: Michal Hocko Cc: Johannes Weiner Cc: Chris Down Acked-by: Chris Down Acked-by: Johannes Weiner Acked-by: Michal Hocko --- include/linux/memcontrol.h | 42 ++++++++++++++++++++++++++++++++++++-- mm/memcontrol.c | 8 ++++++++ mm/vmscan.c | 3 ++- 3 files changed, 50 insertions(+), 3 deletions(-) diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h index d275c72c4f8e..c07548ce26cb 100644 --- a/include/linux/memcontrol.h +++ b/include/linux/memcontrol.h @@ -344,12 +344,49 @@ static inline bool mem_cgroup_disabled(void) return !cgroup_subsys_enabled(memory_cgrp_subsys); } -static inline unsigned long mem_cgroup_protection(struct mem_cgroup *memcg, +static inline unsigned long mem_cgroup_protection(struct mem_cgroup *root, + struct mem_cgroup *memcg, bool in_low_reclaim) { if (mem_cgroup_disabled()) return 0; + /* + * There is no reclaim protection applied to a targeted reclaim. + * We are special casing this specific case here because + * mem_cgroup_protected calculation is not robust enough to keep + * the protection invariant for calculated effective values for + * parallel reclaimers with different reclaim target. This is + * especially a problem for tail memcgs (as they have pages on LRU) + * which would want to have effective values 0 for targeted reclaim + * but a different value for external reclaim. + * + * Example + * Let's have global and A's reclaim in parallel: + * | + * A (low=2G, usage = 3G, max = 3G, children_low_usage = 1.5G) + * |\ + * | C (low = 1G, usage = 2.5G) + * B (low = 1G, usage = 0.5G) + * + * For the global reclaim + * A.elow = A.low + * B.elow = min(B.usage, B.low) because children_low_usage <= A.elow + * C.elow = min(C.usage, C.low) + * + * With the effective values resetting we have A reclaim + * A.elow = 0 + * B.elow = B.low + * C.elow = C.low + * + * If the global reclaim races with A's reclaim then + * B.elow = C.elow = 0 because children_low_usage > A.elow) + * is possible and reclaiming B would be violating the protection. + * + */ + if (root == memcg) + return 0; + if (in_low_reclaim) return READ_ONCE(memcg->memory.emin); @@ -835,7 +872,8 @@ static inline void memcg_memory_event_mm(struct mm_struct *mm, { } -static inline unsigned long mem_cgroup_protection(struct mem_cgroup *memcg, +static inline unsigned long mem_cgroup_protection(struct mem_cgroup *root, + struct mem_cgroup *memcg, bool in_low_reclaim) { return 0; diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 5beea03dd58a..1206682edc1a 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -6388,6 +6388,14 @@ enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root, if (!root) root = root_mem_cgroup; + + /* + * Effective values of the reclaim targets are ignored so they + * can be stale. Have a look at mem_cgroup_protection for more + * details. + * TODO: calculation should be more robust so that we do not need + * that special casing. + */ if (memcg == root) return MEMCG_PROT_NONE; diff --git a/mm/vmscan.c b/mm/vmscan.c index b06868fc4926..4d3027ac131c 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -2346,7 +2346,8 @@ static void get_scan_count(struct lruvec *lruvec, struct scan_control *sc, unsigned long protection; lruvec_size = lruvec_lru_size(lruvec, lru, sc->reclaim_idx); - protection = mem_cgroup_protection(memcg, + protection = mem_cgroup_protection(sc->target_mem_cgroup, + memcg, sc->memcg_low_reclaim); if (protection) { From patchwork Sat May 2 13:59:10 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Yafang Shao X-Patchwork-Id: 11523919 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 66E781864 for ; Sat, 2 May 2020 13:59:54 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 2501D2173E for ; Sat, 2 May 2020 13:59:54 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="hja7iStb" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 2501D2173E Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=owner-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix) id 3F7B08E0007; Sat, 2 May 2020 09:59:53 -0400 (EDT) Delivered-To: linux-mm-outgoing@kvack.org Received: by kanga.kvack.org (Postfix, from userid 40) id 3AA108E0001; Sat, 2 May 2020 09:59:53 -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 24A428E0007; Sat, 2 May 2020 09:59:53 -0400 (EDT) X-Original-To: linux-mm@kvack.org X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0170.hostedemail.com [216.40.44.170]) by kanga.kvack.org (Postfix) with ESMTP id 0DB078E0001 for ; Sat, 2 May 2020 09:59:53 -0400 (EDT) Received: from smtpin11.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay01.hostedemail.com (Postfix) with ESMTP id BAD56180AD806 for ; Sat, 2 May 2020 13:59:52 +0000 (UTC) X-FDA: 76771937424.11.stage52_906a3cf5b5506 X-Spam-Summary: 2,0,0,f2a9e928c630e32f,d41d8cd98f00b204,laoar.shao@gmail.com,,RULES_HIT:2:41:69:355:379:541:800:960:973:988:989:1260:1345:1359:1437:1535:1605:1730:1747:1777:1792:2198:2199:2393:2553:2559:2562:2731:2897:2898:3138:3139:3140:3141:3142:3865:3866:3867:3868:3870:3871:3872:3874:4049:4120:4321:4605:5007:6261:6653:7514:7576:7903:9040:9413:9592:10004:11026:11232:11473:11658:11914:12043:12291:12295:12296:12297:12438:12517:12519:12555:12679:12683:12895:12986:13255:14096:14394:14687:21063:21080:21444:21451:21627:21666:21795:21966:21990:30041:30045:30051:30054:30064:30070:30090,0,RBL:209.85.215.195:@gmail.com:.lbl8.mailshell.net-66.100.201.100 62.18.0.100,CacheIP:none,Bayesian:0.5,0.5,0.5,Netcheck:none,DomainCache:0,MSF:not bulk,SPF:fp,MSBL:0,DNSBL:none,Custom_rules:0:0:0,LFtime:24,LUA_SUMMARY:none X-HE-Tag: stage52_906a3cf5b5506 X-Filterd-Recvd-Size: 9469 Received: from mail-pg1-f195.google.com (mail-pg1-f195.google.com [209.85.215.195]) by imf46.hostedemail.com (Postfix) with ESMTP for ; Sat, 2 May 2020 13:59:52 +0000 (UTC) Received: by mail-pg1-f195.google.com with SMTP id t11so6000339pgg.2 for ; Sat, 02 May 2020 06:59:52 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=LCKJNoB/rGVMGmC+SzniM4qEJsOIw7HOm82kp06/+hc=; b=hja7iStbKXi49+l11DsfZvaq4zg2UwBGOpNePYOzfKIz82Bsc+XyPnk3oljStpYRGd 5iRDik1j08BNsaCtc/6kR/8CQ1zHEshR3Jth8i4hOsS18p94S6iund4MQAbjw2q5pV3h jkg0bWwPPZDSpQbBKO9XotARsIc55t2mcjpcZ8HyHu6n5E6N8Wk08bep4Z7EvHzLcUgk qI15Z/7jQDwFse1PG2iSe75znaAd3HUaNcaba4FuVjRQG0WrYq8HO5jCrvdVOYH7ybtf JK7k4D69qI4c9skDc8M7vEDh2BKm/wRCJnqBmYKc/lr045l68B9Almsu6FKjT/TYjXmU aG7A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=LCKJNoB/rGVMGmC+SzniM4qEJsOIw7HOm82kp06/+hc=; b=hWB0qWRQVZoNZa0dt9JYNOlfS7Y7j4SfgvJrSQhse70EDKMERt3TW+HXmqMCElMoBU l8rDB9JvVFqLqb6uG5rRAhH0gC2hiepUniprbtscVfkyVKQFLw3GXGAtWkrRKAuVl2Ru OcaYhwII7Vk4tW27WgVGyQFDC6yMK9yWunXQXN7zvZeMi/oanwZ2ok8MRiwSY37NNxZ0 dI9DTlUyMX4MS9CRvDITA/mUVKaYKFXhymlgI4oCddp1BApUjOyPK3zgqoewz1H5p202 lmU73gglwQwIMCU+5CJS8WZj6yLuwgQKSPxgSx44Af+mWBLXK9GuWhlEKNyhRLtjtBu3 JXLA== X-Gm-Message-State: AGi0PubFlftwaMTKjeQ/3dtJx+QpCdvE4MmEMSisp3J0+NhY9LX3GJkL SKf97CWrFIy7ETNIXrdXXM4= X-Google-Smtp-Source: APiQypKjk2KKcxFL37txfpfDi1dz/Q8KOqDoZh1/ES7e/Dt2xMPh9ebmEPQb9bK0LykkHjKhEm4aqg== X-Received: by 2002:a62:7d8c:: with SMTP id y134mr9449946pfc.231.1588427991404; Sat, 02 May 2020 06:59:51 -0700 (PDT) Received: from localhost.localdomain ([203.100.54.194]) by smtp.gmail.com with ESMTPSA id i11sm4145708pgi.1.2020.05.02.06.59.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 02 May 2020 06:59:50 -0700 (PDT) From: Yafang Shao To: akpm@linux-foundation.org Cc: mhocko@kernel.org, hannes@cmpxchg.org, chris@chrisdown.name, guro@fb.com, linux-mm@kvack.org, Yafang Shao Subject: [PATCH v2 2/2] mm, memcg: Decouple e{low,min} state mutations from protection checks Date: Sat, 2 May 2020 09:59:10 -0400 Message-Id: <20200502135910.7255-3-laoar.shao@gmail.com> X-Mailer: git-send-email 2.18.1 In-Reply-To: <20200502135910.7255-1-laoar.shao@gmail.com> References: <20200502135910.7255-1-laoar.shao@gmail.com> 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: From: Chris Down From: Chris Down 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. Signed-off-by: Chris Down Suggested-by: Johannes Weiner Acked-by: Johannes Weiner Acked-by: Michal Hocko Cc: Roman Gushchin Signed-off-by: Yafang Shao --- include/linux/memcontrol.h | 43 ++++++++++++++++++++++++++++---------- mm/memcontrol.c | 28 +++++++------------------ mm/vmscan.c | 17 ++++----------- 3 files changed, 43 insertions(+), 45 deletions(-) diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h index c07548ce26cb..7a2c56fc220c 100644 --- a/include/linux/memcontrol.h +++ b/include/linux/memcontrol.h @@ -50,12 +50,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; @@ -394,8 +388,26 @@ 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_below_low(struct mem_cgroup *memcg) +{ + if (mem_cgroup_disabled()) + 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_disabled()) + return false; + + return READ_ONCE(memcg->memory.emin) >= + page_counter_read(&memcg->memory); +} int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm, gfp_t gfp_mask, struct mem_cgroup **memcgp, @@ -879,10 +891,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) +{ +} + +static inline bool mem_cgroup_below_low(struct mem_cgroup *memcg) { - return MEMCG_PROT_NONE; + return false; +} + +static inline bool mem_cgroup_below_min(struct mem_cgroup *memcg) +{ + return false; } static inline int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm, diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 1206682edc1a..474815acaf93 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -6370,21 +6370,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; @@ -6397,21 +6391,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 = memcg->memory.low; - goto out; + return; } parent_usage = page_counter_read(&parent->memory); @@ -6424,14 +6418,6 @@ enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root, WRITE_ONCE(memcg->memory.elow, effective_protection(usage, parent_usage, 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 4d3027ac131c..c71660e2c304 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -2635,14 +2635,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 @@ -2654,16 +2655,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;