From patchwork Tue Apr 28 18:26:47 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chris Down X-Patchwork-Id: 11515359 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 72D1081 for ; Tue, 28 Apr 2020 18:26:52 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 40B9E21D80 for ; Tue, 28 Apr 2020 18:26:52 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chrisdown.name header.i=@chrisdown.name header.b="FIUW+caX" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 40B9E21D80 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 6A36E8E0006; Tue, 28 Apr 2020 14:26:51 -0400 (EDT) Delivered-To: linux-mm-outgoing@kvack.org Received: by kanga.kvack.org (Postfix, from userid 40) id 653978E0001; Tue, 28 Apr 2020 14:26:51 -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 56A2B8E0006; Tue, 28 Apr 2020 14:26:51 -0400 (EDT) X-Original-To: linux-mm@kvack.org X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0091.hostedemail.com [216.40.44.91]) by kanga.kvack.org (Postfix) with ESMTP id 41F988E0001 for ; Tue, 28 Apr 2020 14:26:51 -0400 (EDT) Received: from smtpin02.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay02.hostedemail.com (Postfix) with ESMTP id 09CF44DD6 for ; Tue, 28 Apr 2020 18:26:51 +0000 (UTC) X-FDA: 76758095022.02.ghost09_3bc15ce349428 X-Spam-Summary: 2,0,0,ced9d4edb3b9a1e1,d41d8cd98f00b204,chris@chrisdown.name,,RULES_HIT:41:355:379:800:960:973:988:989:1260:1277:1312:1313:1314:1345:1359:1437:1516:1518:1519:1535:1542:1593:1594:1595:1596:1711:1730:1747:1777:1792:2393:2553:2559:2562:2897:3138:3139:3140:3141:3142:3354:3865:3866:3867:3868:3870:3871:3872:3874:4250:5007:6261:6653:7514:7576:7903:9163:10004:10400:10450:10455:11026:11473:11658:11914:12043:12295:12296:12297:12438:12517:12519:12555:12664:12679:12895:13161:13229:13255:13439:13895:14096:14097:14181:14394:14721:19904:19999:21080:21444:21451:21627:21740:21939:21990:30012:30054:30056:30064:30070:30090,0,RBL:209.85.221.65:@chrisdown.name:.lbl8.mailshell.net-62.2.0.100 66.100.201.201,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:68,LUA_SUMMARY:none X-HE-Tag: ghost09_3bc15ce349428 X-Filterd-Recvd-Size: 5629 Received: from mail-wr1-f65.google.com (mail-wr1-f65.google.com [209.85.221.65]) by imf29.hostedemail.com (Postfix) with ESMTP for ; Tue, 28 Apr 2020 18:26:50 +0000 (UTC) Received: by mail-wr1-f65.google.com with SMTP id g13so25848314wrb.8 for ; Tue, 28 Apr 2020 11:26:50 -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; bh=8ZdOelXqdALp+t5GpXOOCmyCgx7RbdhWdYql4OpbI1c=; b=FIUW+caXr+iJxtL6SRGRKizlkX7XhzWQuOY05F0+5+5/65k+s+9ywMQwaLpbod1SvJ FfDh3SAdEhODgckqhW2bHwjVwebnbxOH1HsAcAe4T3Fd/1U0rACWccleZh2AdKLIkD+h o/RxBNRzbhY/2DUlNUpR3LbBF56ufvPXeDgfo= 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; bh=8ZdOelXqdALp+t5GpXOOCmyCgx7RbdhWdYql4OpbI1c=; b=QQQHvMJcrac9NPfP6A/AvCyNeH+SCjKJCyDgTDs5eQUg1mggOZbbQec9ZqA2SHRkyP 2cboZpJ6VL52HZzGNfhJqLFo1oiM6M3ZIMr5XsGvRqaruYWuE2OOFaqzVGbWsieku69X B+My9sGeXdjrtMV4bM8AxZ+uEg7fPCO3BWlxInC0CQLvvk5jwS5tCwfZTFMTac5xTdj2 ppOhYT6KaS7VbwC8YW2vp9pa/wGo7aS3MvYyI2gUDTeWnxH6YTCtEJIDX7tvKrC3cRd7 48jU8ZOU/4U+8FpG1D63yhswyZsolI0fvfK6BtR4+CuPXY8iRXeqGUmhpMxPoOjLRKWB qkQQ== X-Gm-Message-State: AGi0PublfaxxkIJtRLHBgx3SEIcTBDHVjjT069TPAx7HrSjcEhe2yeKa sUN13SeVbUn8N41zPa4BwTOcuw== X-Google-Smtp-Source: APiQypJ2+N7o09gAo7QjMQFnU2CwELzmpsGz8p6QbSTx74nuWdjD7zRh7ERIHa4tuyomWgoTtmqg7Q== X-Received: by 2002:a5d:490f:: with SMTP id x15mr33086688wrq.37.1588098408915; Tue, 28 Apr 2020 11:26:48 -0700 (PDT) Received: from localhost ([2a01:4b00:8432:8a00:56e1:adff:fe3f:49ed]) by smtp.gmail.com with ESMTPSA id r17sm25942192wrn.43.2020.04.28.11.26.47 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 28 Apr 2020 11:26:48 -0700 (PDT) Date: Tue, 28 Apr 2020 19:26:47 +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 1/2] mm, memcg: Avoid stale protection values when cgroup is above protection Message-ID: References: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: 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: Yafang Shao 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. Fixes: 9783aa9917f8 ("mm, memcg: proportional memory.{low,min} reclaim") Signed-off-by: Yafang Shao Signed-off-by: Chris Down Cc: Johannes Weiner Cc: Michal Hocko Cc: Roman Gushchin [hannes@cmpxchg.org: rework code comment] [hannes@cmpxchg.org: changelog] [chris@chrisdown.name: fix store tear] [chris@chrisdown.name: retitle] Acked-by: Johannes Weiner Acked-by: Roman Gushchin Signed-off-by: Yafang Shao Signed-off-by: Michal Hocko Acked-by: Roman Gushchin --- mm/memcontrol.c | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/mm/memcontrol.c b/mm/memcontrol.c index 0be00826b832..b0374be44e9e 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -6392,8 +6392,19 @@ enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root, if (!root) root = root_mem_cgroup; - if (memcg == root) + if (memcg == root) { + /* + * The cgroup is the reclaim root in this reclaim + * cycle, and therefore not protected. But it may have + * stale effective protection values from previous + * cycles in which it was not the reclaim root - for + * example, global reclaim followed by limit reclaim. + * Reset these values for mem_cgroup_protection(). + */ + WRITE_ONCE(memcg->memory.emin, 0); + WRITE_ONCE(memcg->memory.elow, 0); return MEMCG_PROT_NONE; + } usage = page_counter_read(&memcg->memory); if (!usage) From patchwork Tue Apr 28 18:27:00 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chris Down X-Patchwork-Id: 11515361 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 489A781 for ; Tue, 28 Apr 2020 18:27:04 +0000 (UTC) Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by mail.kernel.org (Postfix) with ESMTP id 099BE214AF for ; Tue, 28 Apr 2020 18:27:04 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=chrisdown.name header.i=@chrisdown.name header.b="OuNXAGxv" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 099BE214AF 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 2ABD98E0007; Tue, 28 Apr 2020 14:27:03 -0400 (EDT) Delivered-To: linux-mm-outgoing@kvack.org Received: by kanga.kvack.org (Postfix, from userid 40) id 25C408E0001; Tue, 28 Apr 2020 14:27:03 -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 124CB8E0007; Tue, 28 Apr 2020 14:27:03 -0400 (EDT) X-Original-To: linux-mm@kvack.org X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0207.hostedemail.com [216.40.44.207]) by kanga.kvack.org (Postfix) with ESMTP id F04B88E0001 for ; Tue, 28 Apr 2020 14:27:02 -0400 (EDT) Received: from smtpin21.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay01.hostedemail.com (Postfix) with ESMTP id B4825180AD806 for ; Tue, 28 Apr 2020 18:27:02 +0000 (UTC) X-FDA: 76758095484.21.thing02_3d7626c552838 X-Spam-Summary: 2,0,0,33eebc6e56d1181f,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:2897:2898:3138:3139:3140:3141:3142:3865:3866:3867:3868:3870:3871:3872:3874:4050:4120:4321:4605:5007:6261:6653:7514:7875:7903:9040:9592:10004:11026:11232:11473:11658:11914:12043:12291:12295:12296:12297:12438:12517:12519:12555:12683:12895:12986:13215:13229:13255:13439:13895:14096:14097:14394:21063:21080:21444:21451:21627:21795:21966:21990:30041:30045:30051:30054:30064:30070:30090,0,RBL:209.85.128.67:@chrisdown.name:.lbl8.mailshell.net-66.100.201.201 62.2.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: thing02_3d7626c552838 X-Filterd-Recvd-Size: 9904 Received: from mail-wm1-f67.google.com (mail-wm1-f67.google.com [209.85.128.67]) by imf40.hostedemail.com (Postfix) with ESMTP for ; Tue, 28 Apr 2020 18:27:02 +0000 (UTC) Received: by mail-wm1-f67.google.com with SMTP id h4so3948480wmb.4 for ; Tue, 28 Apr 2020 11:27:02 -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; bh=RbhBW/kVDmKBpgBPPDRywC4JTwBWDdk0LU6fqNqndyM=; b=OuNXAGxvdUOUc9ZBfgB767lk50030ejNZaRDkEYB6KuqorrlYWG7cJxPf4RkcJWkbV Rb5HrQ+gTll9Y+l5xv5kK3PWiwLB2qNBQTpDztW5AuUSMfVYEKH8jHOJQHQPMsSXbjSK fa1BiGUCbJIK9mdCAFVMw9EgkTzhHxxjmy7lM= 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; bh=RbhBW/kVDmKBpgBPPDRywC4JTwBWDdk0LU6fqNqndyM=; b=AXjHyV+KUZ0BkVOUePB9q2isEVCmHJ2k6FWTslIZ6hBOZ7emWMG3B+7YcNqsPbxlDy OmfflK4hFpKGOQmKJenFYSZZnKKqs/rAjQp9QLRCidmWYQFZGn8YcwJfxocZ2jiRhiaY Gqq5oGApo304GIGGFofA1GJORimmWsadrCqyeHf8ApxSFXHqSAtqcr1O7TVcW8upQz+0 iDY73JccM49bmipRZ15y6ljtRnEAm55Vu0upGEPRQhwzcXr2TKgfTWypNu56TBowLAY5 AbA+dlk8oU9RVT6b+fKYf3HJI5F5d08RaLuUWYhYvXLlIqdmAj/9kco80Q4ssrPQn7+a EB1Q== X-Gm-Message-State: AGi0PubwlMdy5ki2SAj8KKH1zMAQi22UzcBX3f9PQ606bh1mLSeySZZs qPKGR+M9IFPssn0zx7CgIQ8/RQ== X-Google-Smtp-Source: APiQypItaAgbrMyavidZT6lgynKH9R7FHzJu+K99KFV9jUtxw7W/Ss6N3fBp/UNDfbIk0XzuT3fBvw== X-Received: by 2002:a7b:c772:: with SMTP id x18mr6261512wmk.39.1588098421110; Tue, 28 Apr 2020 11:27:01 -0700 (PDT) Received: from localhost ([2a01:4b00:8432:8a00:56e1:adff:fe3f:49ed]) by smtp.gmail.com with ESMTPSA id h2sm4475049wmf.34.2020.04.28.11.27.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 28 Apr 2020 11:27:00 -0700 (PDT) Date: Tue, 28 Apr 2020 19:27:00 +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 2/2] mm, memcg: Decouple e{low,min} state mutations from protection checks Message-ID: <51ffacb736bb02ecc09c828ebe8f4ec7fda68c48.1588092152.git.chris@chrisdown.name> References: MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: 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. Signed-off-by: Chris Down Suggested-by: Johannes Weiner Cc: Michal Hocko Cc: Roman Gushchin Cc: Yafang Shao Acked-by: Johannes Weiner Acked-by: Michal Hocko --- include/linux/memcontrol.h | 48 +++++++++++++++++++++++++++++--------- mm/memcontrol.c | 30 +++++++----------------- mm/vmscan.c | 17 ++++---------- 3 files changed, 49 insertions(+), 46 deletions(-) diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h index d630af1a4e17..88576b1235b0 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; @@ -357,8 +351,26 @@ static inline unsigned long mem_cgroup_protection(struct mem_cgroup *memcg, 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, @@ -838,13 +850,27 @@ static inline void memcg_memory_event_mm(struct mm_struct *mm, static inline unsigned long mem_cgroup_protection(struct mem_cgroup *memcg, bool in_low_reclaim) { + + +static inline void mem_cgroup_calculate_protection(struct mem_cgroup *root, + struct mem_cgroup *memcg); +{ +} + +static inline void mem_cgroup_protection(struct mem_cgroup *memcg, + bool in_low_reclaim) +{ return 0; } -static inline enum mem_cgroup_protection mem_cgroup_protected( - struct mem_cgroup *root, struct mem_cgroup *memcg) +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 MEMCG_PROT_NONE; + 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 b0374be44e9e..317dbbaac603 100644 --- a/mm/memcontrol.c +++ b/mm/memcontrol.c @@ -6368,27 +6368,21 @@ static unsigned long effective_protection(unsigned long usage, } /** - * mem_cgroup_protected - check if memory consumption is in the normal range + * mem_cgroup_calculate_protection - calculate and cache effective low and min * @root: the top ancestor of the sub-tree being checked * @memcg: the memory cgroup to check * * 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; @@ -6403,22 +6397,22 @@ enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root, */ WRITE_ONCE(memcg->memory.emin, 0); WRITE_ONCE(memcg->memory.elow, 0); - 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); @@ -6431,14 +6425,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 72ac38eb8c29..e913c4652341 100644 --- a/mm/vmscan.c +++ b/mm/vmscan.c @@ -2645,14 +2645,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 @@ -2664,16 +2665,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;