From nobody Fri Apr 10 12:40:08 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 86EE4ECAAA1 for ; Fri, 16 Sep 2022 17:06:50 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229913AbiIPRGr (ORCPT ); Fri, 16 Sep 2022 13:06:47 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34942 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229614AbiIPRGm (ORCPT ); Fri, 16 Sep 2022 13:06:42 -0400 Received: from mail-pl1-x62f.google.com (mail-pl1-x62f.google.com [IPv6:2607:f8b0:4864:20::62f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3E9AFB657D; Fri, 16 Sep 2022 10:06:37 -0700 (PDT) Received: by mail-pl1-x62f.google.com with SMTP id t3so22019742ply.2; Fri, 16 Sep 2022 10:06:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=references:in-reply-to:message-id:date:subject:cc:to:from:from:to :cc:subject:date; bh=NHX0v7JDxtUMM333DJPPrllexhVOYL7Nj+UJXW7k7Y8=; b=pa/sJLJcN+B/Gm25t+BGj5bgblNIz7/PAmxl6hiXx1smZzr03fp4MqJ/q/wlShntIw BcXbPjsBHGmXGrE0s2Sv2om6ZYgRIGDe3KIDNILW73JyMXR68sT7uhKIw3iRr/p7MwxR 1FWxvUH5LeudO/mP+KZS3neYWq/v8ZRj7BzdnW48emGzopX4Sh7z33C+1E5eq4iIkeRr 1GoWDaFGgVN2o0T/On9Rla8LAIZAUwzjFpc/Eytfqz5Q+sXAcRnzkPi7TR1v01WVWHlS TaDTCkgQXQ4ewRC92j3wEH3bMvPyGukKbsK1R3Yojr1yn1scu/e/FbsHKMQdZV6ohBp2 eh2g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=references:in-reply-to:message-id:date:subject:cc:to:from :x-gm-message-state:from:to:cc:subject:date; bh=NHX0v7JDxtUMM333DJPPrllexhVOYL7Nj+UJXW7k7Y8=; b=akIsvl4zMQNjiwU3afO8iVDgfguG7q7lACAGU/eqGQ94ATszS8lntWubvPVvRvnqA5 AY4cOYUlpFIk392Y9IqRuf8rI3cGSq3gQJ2upYsgrSIXxvlt6cUbkd/DOekaek6Gzlru xjc4GgEOWj2VhQj7YZUkwBd3jjhevxNMz0qAbIwiBMBKs+oBOya+DndsD1HuBHMNenXy y+A9nwpXSnUKhfkv7tdwo7ISI7F2EaQIOfceC7SPSkIuhWhV7eGD30qn3K3QgDTdJD3J cXqyGGnTRLL2dW7WRJGGfACZnNeRLvcZB2nqpxsJ7zDBt8a/oIGHt8M/3qmY+Q0RRieY rX1A== X-Gm-Message-State: ACrzQf1eM7lUSGCUQ46jZ2l3AohD48ukFvOn3TRInC4SijruVpU5HitR Wj2Y8bhiVRUf5W1h52Om1VY= X-Google-Smtp-Source: AMsMyM63V0YKfwJrz1k6xxEeD01J5ColjWgNUnV4EN+5k+EjrshLwF197ITwrydBRmUahAUoJEKVwQ== X-Received: by 2002:a17:90b:1d01:b0:203:2bda:abb1 with SMTP id on1-20020a17090b1d0100b002032bdaabb1mr11969428pjb.204.1663347996703; Fri, 16 Sep 2022 10:06:36 -0700 (PDT) Received: from localhost.localdomain ([117.176.186.9]) by smtp.gmail.com with ESMTPSA id z12-20020a170903018c00b00176d4b093e1sm15386677plg.16.2022.09.16.10.06.30 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 16 Sep 2022 10:06:36 -0700 (PDT) From: wangyong X-Google-Original-From: wangyong To: gregkh@linuxfoundation.org Cc: jaewon31.kim@samsung.com, linux-kernel@vger.kernel.org, mhocko@kernel.org, stable@vger.kernel.org, wang.yong12@zte.com.cn, yongw.pur@gmail.com, Joonsoo Kim , Andrew Morton , Johannes Weiner , Minchan Kim , Mel Gorman , Linus Torvalds Subject: [PATCH 1/3] mm/page_alloc: use ac->high_zoneidx for classzone_idx Date: Fri, 16 Sep 2022 10:05:47 -0700 Message-Id: <1663347949-20389-2-git-send-email-wang.yong12@zte.com.cn> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1663347949-20389-1-git-send-email-wang.yong12@zte.com.cn> References: <1663347949-20389-1-git-send-email-wang.yong12@zte.com.cn> Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" From: Joonsoo Kim Patch series "integrate classzone_idx and high_zoneidx", v5. This patchset is followup of the problem reported and discussed two years ago [1, 2]. The problem this patchset solves is related to the classzone_idx on the NUMA system. It causes a problem when the lowmem reserve protection exists for some zones on a node that do not exist on other nodes. This problem was reported two years ago, and, at that time, the solution got general agreements [2]. But it was not upstreamed. [1]: http://lkml.kernel.org/r/20180102063528.GG30397@yexl-desktop [2]: http://lkml.kernel.org/r/1525408246-14768-1-git-send-email-iamjoonsoo.= kim@lge.com This patch (of 2): Currently, we use classzone_idx to calculate lowmem reserve proetection for an allocation request. This classzone_idx causes a problem on NUMA systems when the lowmem reserve protection exists for some zones on a node that do not exist on other nodes. Before further explanation, I should first clarify how to compute the classzone_idx and the high_zoneidx. - ac->high_zoneidx is computed via the arcane gfp_zone(gfp_mask) and represents the index of the highest zone the allocation can use - classzone_idx was supposed to be the index of the highest zone on the local node that the allocation can use, that is actually available in the system Think about following example. Node 0 has 4 populated zone, DMA/DMA32/NORMAL/MOVABLE. Node 1 has 1 populated zone, NORMAL. Some zones, such as MOVABLE, doesn't exist on node 1 and this makes following difference. Assume that there is an allocation request whose gfp_zone(gfp_mask) is the zone, MOVABLE. Then, it's high_zoneidx is 3. If this allocation is initiated on node 0, it's classzone_idx is 3 since actually available/usable zone on local (node 0) is MOVABLE. If this allocation is initiated on node 1, it's classzone_idx is 2 since actually available/usable zone on local (node 1) is NORMAL. You can see that classzone_idx of the allocation request are different according to their starting node, even if their high_zoneidx is the same. Think more about these two allocation requests. If they are processed on local, there is no problem. However, if allocation is initiated on node 1 are processed on remote, in this example, at the NORMAL zone on node 0, due to memory shortage, problem occurs. Their different classzone_idx leads to different lowmem reserve and then different min watermark. See the following example. root@ubuntu:/sys/devices/system/memory# cat /proc/zoneinfo Node 0, zone DMA per-node stats ... pages free 3965 min 5 low 8 high 11 spanned 4095 present 3998 managed 3977 protection: (0, 2961, 4928, 5440) ... Node 0, zone DMA32 pages free 757955 min 1129 low 1887 high 2645 spanned 1044480 present 782303 managed 758116 protection: (0, 0, 1967, 2479) ... Node 0, zone Normal pages free 459806 min 750 low 1253 high 1756 spanned 524288 present 524288 managed 503620 protection: (0, 0, 0, 4096) ... Node 0, zone Movable pages free 130759 min 195 low 326 high 457 spanned 1966079 present 131072 managed 131072 protection: (0, 0, 0, 0) ... Node 1, zone DMA pages free 0 min 0 low 0 high 0 spanned 0 present 0 managed 0 protection: (0, 0, 1006, 1006) Node 1, zone DMA32 pages free 0 min 0 low 0 high 0 spanned 0 present 0 managed 0 protection: (0, 0, 1006, 1006) Node 1, zone Normal per-node stats ... pages free 233277 min 383 low 640 high 897 spanned 262144 present 262144 managed 257744 protection: (0, 0, 0, 0) ... Node 1, zone Movable pages free 0 min 0 low 0 high 0 spanned 262144 present 0 managed 0 protection: (0, 0, 0, 0) - static min watermark for the NORMAL zone on node 0 is 750. - lowmem reserve for the request with classzone idx 3 at the NORMAL on node 0 is 4096. - lowmem reserve for the request with classzone idx 2 at the NORMAL on node 0 is 0. So, overall min watermark is: allocation initiated on node 0 (classzone_idx 3): 750 + 4096 =3D 4846 allocation initiated on node 1 (classzone_idx 2): 750 + 0 =3D 750 Allocation initiated on node 1 will have some precedence than allocation initiated on node 0 because min watermark of the former allocation is lower than the other. So, allocation initiated on node 1 could succeed on node 0 when allocation initiated on node 0 could not, and, this could cause too many numa_miss allocation. Then, performance could be downgraded. Recently, there was a regression report about this problem on CMA patches since CMA memory are placed in ZONE_MOVABLE by those patches. I checked that problem is disappeared with this fix that uses high_zoneidx for classzone_idx. http://lkml.kernel.org/r/20180102063528.GG30397@yexl-desktop Using high_zoneidx for classzone_idx is more consistent way than previous approach because system's memory layout doesn't affect anything to it. With this patch, both classzone_idx on above example will be 3 so will have the same min watermark. allocation initiated on node 0: 750 + 4096 =3D 4846 allocation initiated on node 1: 750 + 4096 =3D 4846 One could wonder if there is a side effect that allocation initiated on node 1 will use higher bar when allocation is handled on local since classzone_idx could be higher than before. It will not happen because the zone without managed page doesn't contributes lowmem_reserve at all. Reported-by: Ye Xiaolong Signed-off-by: Joonsoo Kim Signed-off-by: Andrew Morton Tested-by: Ye Xiaolong Reviewed-by: Baoquan He Acked-by: Vlastimil Babka Acked-by: David Rientjes Cc: Johannes Weiner Cc: Michal Hocko Cc: Minchan Kim Cc: Mel Gorman Link: http://lkml.kernel.org/r/1587095923-7515-1-git-send-email-iamjoonsoo.= kim@lge.com Link: http://lkml.kernel.org/r/1587095923-7515-2-git-send-email-iamjoonsoo.= kim@lge.com Signed-off-by: Linus Torvalds --- mm/internal.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mm/internal.h b/mm/internal.h index 3a2e973..922a173 100644 --- a/mm/internal.h +++ b/mm/internal.h @@ -123,7 +123,7 @@ struct alloc_context { bool spread_dirty_pages; }; =20 -#define ac_classzone_idx(ac) zonelist_zone_idx(ac->preferred_zoneref) +#define ac_classzone_idx(ac) (ac->high_zoneidx) =20 /* * Locate the struct page for both the matching buddy in our --=20 2.7.4 From nobody Fri Apr 10 12:40:08 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2A989ECAAA1 for ; Fri, 16 Sep 2022 17:07:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229585AbiIPRHC (ORCPT ); Fri, 16 Sep 2022 13:07:02 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35074 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229932AbiIPRGv (ORCPT ); Fri, 16 Sep 2022 13:06:51 -0400 Received: from mail-pf1-x433.google.com (mail-pf1-x433.google.com [IPv6:2607:f8b0:4864:20::433]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 8A01EB656F; Fri, 16 Sep 2022 10:06:49 -0700 (PDT) Received: by mail-pf1-x433.google.com with SMTP id y127so21819530pfy.5; Fri, 16 Sep 2022 10:06:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=references:in-reply-to:message-id:date:subject:cc:to:from:from:to :cc:subject:date; bh=oo7u2RMqtvn+f9vVLWk7c1hXsiGPEPQ41u+tdbZ00WY=; b=ULCZgzOwAj5gEn5gZ0ov+KXlyCAF97hCMJKwf+iQnVJNMEx7Z1pnH/LGftzOJ9YSYu MzdagE91DdRPH/GDSQmAUUUJb80L6CRCED2gg6Ph1RBZ76fuhrBBd8/AgolmAiqqPFN5 r1Api3OAPOi8gpDdAp87d9f7H6SijcFNDkDA1nkUsauml6TKrRutctjWYAU7YNB/7WQT jWRWXo3WL47u2Bk9B8CEEZ0ngHT/0Q23PDK7KxTr6hLg5WB9VQeqWogxloJmpvjykaVW D5HPjcIMHzLN7GghhYp37cYty8gVg/NKb1v0+9OYNnrlc5tKxoud99sLv2IMP3eWqrWo JaaA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=references:in-reply-to:message-id:date:subject:cc:to:from :x-gm-message-state:from:to:cc:subject:date; bh=oo7u2RMqtvn+f9vVLWk7c1hXsiGPEPQ41u+tdbZ00WY=; b=KLTu5DJ3SF2ZrtxE271IQ/6BnPbtnef/fS4tDhWWSwKZAVl+5OoHcyqvRfVJc82FxY Xdfttd3H//bxATTc/mNyYWEvZNynflVbhfzR2nnRgWZG+MwS2Gf40kivwedthUk4sspS s7lQzuRbWS2LqCTYyRnPLXwapp/1ajJWteQ2IaKI4uIxUJyfVUrQg4BjGGsiz9DUWW82 ai0JjjMAamLeXyJ3tTFUD2z82VAWThf0jlhWEL3sHhWIMUNGrgCdxj7Ftd7Q2nwQRZXp 51bMTmcsiy2omRl7Ii8P6H5jWEJ4plbmzBBEP4A2/hmQAHyacyG9FdV4IvibP/dcHwM6 URrA== X-Gm-Message-State: ACrzQf3GCiRmBc11ULgxf2AQGaYb46YlNglF5whpn5FZPGa9VuLxy7ki q23rtm/LMn4LgqKowT2SfNM= X-Google-Smtp-Source: AMsMyM7ypvJ6LyfAu+SvbIIyWL09Js8gh62kTKwJ6Y1fzhGTmHDN2ERwhTpd39GlGP0rt079XHFDhA== X-Received: by 2002:a05:6a00:4287:b0:543:7bae:55f7 with SMTP id bx7-20020a056a00428700b005437bae55f7mr6451197pfb.58.1663348008910; Fri, 16 Sep 2022 10:06:48 -0700 (PDT) Received: from localhost.localdomain ([117.176.186.9]) by smtp.gmail.com with ESMTPSA id z12-20020a170903018c00b00176d4b093e1sm15386677plg.16.2022.09.16.10.06.43 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 16 Sep 2022 10:06:48 -0700 (PDT) From: wangyong X-Google-Original-From: wangyong To: gregkh@linuxfoundation.org Cc: jaewon31.kim@samsung.com, linux-kernel@vger.kernel.org, mhocko@kernel.org, stable@vger.kernel.org, wang.yong12@zte.com.cn, yongw.pur@gmail.com, Andrew Morton , Johannes Weiner , Yong-Taek Lee , Linus Torvalds Subject: [PATCH 2/3] page_alloc: consider highatomic reserve in watermark fast Date: Fri, 16 Sep 2022 10:05:48 -0700 Message-Id: <1663347949-20389-3-git-send-email-wang.yong12@zte.com.cn> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1663347949-20389-1-git-send-email-wang.yong12@zte.com.cn> References: <1663347949-20389-1-git-send-email-wang.yong12@zte.com.cn> Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" From: Jaewon Kim zone_watermark_fast was introduced by commit 48ee5f3696f6 ("mm, page_alloc: shortcut watermark checks for order-0 pages"). The commit simply checks if free pages is bigger than watermark without additional calculation such like reducing watermark. It considered free cma pages but it did not consider highatomic reserved. This may incur exhaustion of free pages except high order atomic free pages. Assume that reserved_highatomic pageblock is bigger than watermark min, and there are only few free pages except high order atomic free. Because zone_watermark_fast passes the allocation without considering high order atomic free, normal reclaimable allocation like GFP_HIGHUSER will consume all the free pages. Then finally order-0 atomic allocation may fail on allocation. This means watermark min is not protected against non-atomic allocation. The order-0 atomic allocation with ALLOC_HARDER unwantedly can be failed. Additionally the __GFP_MEMALLOC allocation with ALLOC_NO_WATERMARKS also can be failed. To avoid the problem, zone_watermark_fast should consider highatomic reserve. If the actual size of high atomic free is counted accurately like cma free, we may use it. On this patch just use nr_reserved_highatomic. Additionally introduce __zone_watermark_unusable_free to factor out common parts between zone_watermark_fast and __zone_watermark_ok. This is an example of ALLOC_HARDER allocation failure using v4.19 based kernel. Binder:9343_3: page allocation failure: order:0, mode:0x480020(GFP_ATOMIC)= , nodemask=3D(null) Call trace: [] dump_stack+0xb8/0xf0 [] warn_alloc+0xd8/0x12c [] __alloc_pages_nodemask+0x120c/0x1250 [] new_slab+0x128/0x604 [] ___slab_alloc+0x508/0x670 [] __kmalloc+0x2f8/0x310 [] context_struct_to_string+0x104/0x1cc [] security_sid_to_context_core+0x74/0x144 [] security_sid_to_context+0x10/0x18 [] selinux_secid_to_secctx+0x20/0x28 [] security_secid_to_secctx+0x3c/0x70 [] binder_transaction+0xe68/0x454c Mem-Info: active_anon:102061 inactive_anon:81551 isolated_anon:0 active_file:59102 inactive_file:68924 isolated_file:64 unevictable:611 dirty:63 writeback:0 unstable:0 slab_reclaimable:13324 slab_unreclaimable:44354 mapped:83015 shmem:4858 pagetables:26316 bounce:0 free:2727 free_pcp:1035 free_cma:178 Node 0 active_anon:408244kB inactive_anon:326204kB active_file:236408kB in= active_file:275696kB unevictable:2444kB isolated(anon):0kB isolated(file):2= 56kB mapped:332060kB dirty:252kB writeback:0kB shmem:19432kB writeback_tmp:= 0kB unstable:0kB all_unreclaimable? no Normal free:10908kB min:6192kB low:44388kB high:47060kB active_anon:409160= kB inactive_anon:325924kB active_file:235820kB inactive_file:276628kB unevi= ctable:2444kB writepending:252kB present:3076096kB managed:2673676kB mlocke= d:2444kB kernel_stack:62512kB pagetables:105264kB bounce:0kB free_pcp:4140k= B local_pcp:40kB free_cma:712kB lowmem_reserve[]: 0 0 Normal: 505*4kB (H) 357*8kB (H) 201*16kB (H) 65*32kB (H) 1*64kB (H) 0*128k= B 0*256kB 0*512kB 0*1024kB 0*2048kB 0*4096kB =3D 10236kB 138826 total pagecache pages 5460 pages in swap cache Swap cache stats: add 8273090, delete 8267506, find 1004381/4060142 This is an example of ALLOC_NO_WATERMARKS allocation failure using v4.14 based kernel. kswapd0: page allocation failure: order:0, mode:0x140000a(GFP_NOIO|__GFP_H= IGHMEM|__GFP_MOVABLE), nodemask=3D(null) kswapd0 cpuset=3D/ mems_allowed=3D0 CPU: 4 PID: 1221 Comm: kswapd0 Not tainted 4.14.113-18770262-userdebug #1 Call trace: [<0000000000000000>] dump_backtrace+0x0/0x248 [<0000000000000000>] show_stack+0x18/0x20 [<0000000000000000>] __dump_stack+0x20/0x28 [<0000000000000000>] dump_stack+0x68/0x90 [<0000000000000000>] warn_alloc+0x104/0x198 [<0000000000000000>] __alloc_pages_nodemask+0xdc0/0xdf0 [<0000000000000000>] zs_malloc+0x148/0x3d0 [<0000000000000000>] zram_bvec_rw+0x410/0x798 [<0000000000000000>] zram_rw_page+0x88/0xdc [<0000000000000000>] bdev_write_page+0x70/0xbc [<0000000000000000>] __swap_writepage+0x58/0x37c [<0000000000000000>] swap_writepage+0x40/0x4c [<0000000000000000>] shrink_page_list+0xc30/0xf48 [<0000000000000000>] shrink_inactive_list+0x2b0/0x61c [<0000000000000000>] shrink_node_memcg+0x23c/0x618 [<0000000000000000>] shrink_node+0x1c8/0x304 [<0000000000000000>] kswapd+0x680/0x7c4 [<0000000000000000>] kthread+0x110/0x120 [<0000000000000000>] ret_from_fork+0x10/0x18 Mem-Info: active_anon:111826 inactive_anon:65557 isolated_anon:0\x0a active_file:442= 60 inactive_file:83422 isolated_file:0\x0a unevictable:4158 dirty:117 write= back:0 unstable:0\x0a slab_reclaimable:13943 slab_unreclaimable:= 43315\x0a mapped:102511 shmem:3299 pagetables:19566 bounce:0\x0a free:3510 = free_pcp:553 free_cma:0 Node 0 active_anon:447304kB inactive_anon:262228kB active_file:177040kB in= active_file:333688kB unevictable:16632kB isolated(anon):0kB isolated(file):= 0kB mapped:410044kB d irty:468kB writeback:0kB shmem:13196kB writeback_tmp:= 0kB unstable:0kB all_unreclaimable? no Normal free:14040kB min:7440kB low:94500kB high:98136kB reserved_highatomi= c:32768KB active_anon:447336kB inactive_anon:261668kB active_file:177572kB = inactive_file:333768k B unevictable:16632kB writepending:480kB pr= esent:4081664kB managed:3637088kB mlocked:16632kB kernel_stack:47072kB page= tables:78264kB bounce:0kB free_pcp:2280kB local_pcp:720kB free_cma:0kB = [ 4738.329607] lowmem_reserve[]: 0 0 Normal: 860*4kB (H) 453*8kB (H) 180*16kB (H) 26*32kB (H) 34*64kB (H) 6*128= kB (H) 2*256kB (H) 0*512kB 0*1024kB 0*2048kB 0*4096kB =3D 14232kB This is trace log which shows GFP_HIGHUSER consumes free pages right before ALLOC_NO_WATERMARKS. <...>-22275 [006] .... 889.213383: mm_page_alloc: page=3D00000000d2be56= 65 pfn=3D970744 order=3D0 migratetype=3D0 nr_free=3D3650 gfp_flags=3DGFP_HI= GHUSER|__GFP_ZERO <...>-22275 [006] .... 889.213385: mm_page_alloc: page=3D000000004b2335= c2 pfn=3D970745 order=3D0 migratetype=3D0 nr_free=3D3650 gfp_flags=3DGFP_HI= GHUSER|__GFP_ZERO <...>-22275 [006] .... 889.213387: mm_page_alloc: page=3D00000000017272= e1 pfn=3D970278 order=3D0 migratetype=3D0 nr_free=3D3650 gfp_flags=3DGFP_HI= GHUSER|__GFP_ZERO <...>-22275 [006] .... 889.213389: mm_page_alloc: page=3D00000000c4be79= fb pfn=3D970279 order=3D0 migratetype=3D0 nr_free=3D3650 gfp_flags=3DGFP_HI= GHUSER|__GFP_ZERO <...>-22275 [006] .... 889.213391: mm_page_alloc: page=3D00000000f8a51d= 4f pfn=3D970260 order=3D0 migratetype=3D0 nr_free=3D3650 gfp_flags=3DGFP_HI= GHUSER|__GFP_ZERO <...>-22275 [006] .... 889.213393: mm_page_alloc: page=3D000000006ba8f5= ac pfn=3D970261 order=3D0 migratetype=3D0 nr_free=3D3650 gfp_flags=3DGFP_HI= GHUSER|__GFP_ZERO <...>-22275 [006] .... 889.213395: mm_page_alloc: page=3D00000000819f1c= d3 pfn=3D970196 order=3D0 migratetype=3D0 nr_free=3D3650 gfp_flags=3DGFP_HI= GHUSER|__GFP_ZERO <...>-22275 [006] .... 889.213396: mm_page_alloc: page=3D00000000f6b72a= 64 pfn=3D970197 order=3D0 migratetype=3D0 nr_free=3D3650 gfp_flags=3DGFP_HI= GHUSER|__GFP_ZERO kswapd0-1207 [005] ...1 889.213398: mm_page_alloc: page=3D (null) pfn=3D= 0 order=3D0 migratetype=3D1 nr_free=3D3650 gfp_flags=3DGFP_NOWAIT|__GFP_HIG= HMEM|__GFP_NOWARN|__GFP_MOVABLE [jaewon31.kim@samsung.com: remove redundant code for high-order] Link: http://lkml.kernel.org/r/20200623035242.27232-1-jaewon31.kim@samsun= g.com Reported-by: Yong-Taek Lee Suggested-by: Minchan Kim Signed-off-by: Jaewon Kim Signed-off-by: Andrew Morton Reviewed-by: Baoquan He Acked-by: Vlastimil Babka Acked-by: Mel Gorman Cc: Johannes Weiner Cc: Yong-Taek Lee Cc: Michal Hocko Link: http://lkml.kernel.org/r/20200619235958.11283-1-jaewon31.kim@samsung.= com Signed-off-by: Linus Torvalds --- mm/page_alloc.c | 65 ++++++++++++++++++++++++++++++++---------------------= ---- 1 file changed, 36 insertions(+), 29 deletions(-) diff --git a/mm/page_alloc.c b/mm/page_alloc.c index 9c35403..237463d 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -3130,6 +3130,29 @@ static inline bool should_fail_alloc_page(gfp_t gfp_= mask, unsigned int order) =20 #endif /* CONFIG_FAIL_PAGE_ALLOC */ =20 +static inline long __zone_watermark_unusable_free(struct zone *z, + unsigned int order, unsigned int alloc_flags) +{ + const bool alloc_harder =3D (alloc_flags & (ALLOC_HARDER|ALLOC_OOM)); + long unusable_free =3D (1 << order) - 1; + + /* + * If the caller does not have rights to ALLOC_HARDER then subtract + * the high-atomic reserves. This will over-estimate the size of the + * atomic reserve but it avoids a search. + */ + if (likely(!alloc_harder)) + unusable_free +=3D z->nr_reserved_highatomic; + +#ifdef CONFIG_CMA + /* If allocation can't use CMA areas don't use free CMA pages */ + if (!(alloc_flags & ALLOC_CMA)) + unusable_free +=3D zone_page_state(z, NR_FREE_CMA_PAGES); +#endif + + return unusable_free; +} + /* * Return true if free base pages are above 'mark'. For high-order checks = it * will return true of the order-0 watermark is reached and there is at le= ast @@ -3145,19 +3168,12 @@ bool __zone_watermark_ok(struct zone *z, unsigned i= nt order, unsigned long mark, const bool alloc_harder =3D (alloc_flags & (ALLOC_HARDER|ALLOC_OOM)); =20 /* free_pages may go negative - that's OK */ - free_pages -=3D (1 << order) - 1; + free_pages -=3D __zone_watermark_unusable_free(z, order, alloc_flags); =20 if (alloc_flags & ALLOC_HIGH) min -=3D min / 2; =20 - /* - * If the caller does not have rights to ALLOC_HARDER then subtract - * the high-atomic reserves. This will over-estimate the size of the - * atomic reserve but it avoids a search. - */ - if (likely(!alloc_harder)) { - free_pages -=3D z->nr_reserved_highatomic; - } else { + if (unlikely(alloc_harder)) { /* * OOM victims can try even harder than normal ALLOC_HARDER * users on the grounds that it's definitely going to be in @@ -3170,13 +3186,6 @@ bool __zone_watermark_ok(struct zone *z, unsigned in= t order, unsigned long mark, min -=3D min / 4; } =20 - -#ifdef CONFIG_CMA - /* If allocation can't use CMA areas don't use free CMA pages */ - if (!(alloc_flags & ALLOC_CMA)) - free_pages -=3D zone_page_state(z, NR_FREE_CMA_PAGES); -#endif - /* * Check watermarks for an order-0 allocation request. If these * are not met, then a high-order request also cannot go ahead @@ -3225,24 +3234,22 @@ bool zone_watermark_ok(struct zone *z, unsigned int= order, unsigned long mark, static inline bool zone_watermark_fast(struct zone *z, unsigned int order, unsigned long mark, int classzone_idx, unsigned int alloc_flags) { - long free_pages =3D zone_page_state(z, NR_FREE_PAGES); - long cma_pages =3D 0; + long free_pages; =20 -#ifdef CONFIG_CMA - /* If allocation can't use CMA areas don't use free CMA pages */ - if (!(alloc_flags & ALLOC_CMA)) - cma_pages =3D zone_page_state(z, NR_FREE_CMA_PAGES); -#endif + free_pages =3D zone_page_state(z, NR_FREE_PAGES); =20 /* * Fast check for order-0 only. If this fails then the reserves - * need to be calculated. There is a corner case where the check - * passes but only the high-order atomic reserve are free. If - * the caller is !atomic then it'll uselessly search the free - * list. That corner case is then slower but it is harmless. + * need to be calculated. */ - if (!order && (free_pages - cma_pages) > mark + z->lowmem_reserve[classzo= ne_idx]) - return true; + if (!order) { + long fast_free; + + fast_free =3D free_pages; + fast_free -=3D __zone_watermark_unusable_free(z, 0, alloc_flags); + if (fast_free > mark + z->lowmem_reserve[classzone_idx]) + return true; + } =20 return __zone_watermark_ok(z, order, mark, classzone_idx, alloc_flags, free_pages); --=20 2.7.4 From nobody Fri Apr 10 12:40:08 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5C513ECAAA1 for ; Fri, 16 Sep 2022 17:07:23 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229976AbiIPRHW (ORCPT ); Fri, 16 Sep 2022 13:07:22 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:35254 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S229731AbiIPRHM (ORCPT ); Fri, 16 Sep 2022 13:07:12 -0400 Received: from mail-pl1-x629.google.com (mail-pl1-x629.google.com [IPv6:2607:f8b0:4864:20::629]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3F451B69D7; Fri, 16 Sep 2022 10:07:03 -0700 (PDT) Received: by mail-pl1-x629.google.com with SMTP id s18so16059981plr.4; Fri, 16 Sep 2022 10:07:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=references:in-reply-to:message-id:date:subject:cc:to:from:from:to :cc:subject:date; bh=ZQ4epJy4kuC71aqt6/p49SxHHX9PRTr4w8eT6UANlFc=; b=UrXbed1sCIkZkoXBLB070iyqZTAzOAN2KFDdu45xcMpXshpGd3wMlebzLUat9IFHMt Y5kJ17jTnRaD8bsyStt0bfoTJv80SeaWYfcs0pTOtcHdsV9DmKouMLlcvsfuE4LPuOF7 QAD1TAlbgowEDf0XOGYzNIcB/mNl9+CIr7sAdOBwFOaeyDg/45C7TEdvUxkcNvFhgAWA LjBxZ29QPC94uvnEM3upZDPSZBC9RQtIXM3vpLBqc6eo7TBHgRANzdWNnU8EXSDmzFTr qQZys+qqptAtEqvzt17ZSOLFRv5JCCWqhcJJ6Ky2Ypq2wXQDCTdsdOtSSLNtvsCeRk1V XdGw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=references:in-reply-to:message-id:date:subject:cc:to:from :x-gm-message-state:from:to:cc:subject:date; bh=ZQ4epJy4kuC71aqt6/p49SxHHX9PRTr4w8eT6UANlFc=; b=TW9eLMnD9+4i5p96vlHrDJDTMus13dWF+VyIqrocyNE7dodPccmNVHVvdY1DmnS4PZ g4GuPFhY+xtnGXjQN7AWx4DTifAUFR8EeKUni+dH6+e1eaTlR0nQ0bUmbryqlNrOWQ9o TWXsfehtmdhsX4t3dD+piaPhvoOdiFLGbfgmmY1lwT2yiZ3bHbFgc6au4lr/Qi/V/pxR /fH2iebfBPAznFzP+dho1gVXcqQ5VxTOSUoYcXYlfHTF3YLDxFz64lE7uyAKsQ/1Wbli neX0we0BmjIehTjxnBMeGPwvxLtYV/ESN9nwwPPHp1QPOVEZe4eRav4dcm0j0nuuG7xN XMjg== X-Gm-Message-State: ACrzQf2CYzAHwSIQCl4c1dlFQf856IYq469y7yLgIv5EVFO8ChmyW0J3 liOvGo6nFMO4GmRmoqAVwoc= X-Google-Smtp-Source: AMsMyM7jbIDEJhuPlPlo7kKEFpNNyEEHgQV6Vx9+PE4XLaM6YEfj447Jz2V9H2h1kUCkdvWeAdoSbA== X-Received: by 2002:a17:903:2290:b0:178:272b:e414 with SMTP id b16-20020a170903229000b00178272be414mr805886plh.120.1663348022490; Fri, 16 Sep 2022 10:07:02 -0700 (PDT) Received: from localhost.localdomain ([117.176.186.9]) by smtp.gmail.com with ESMTPSA id z12-20020a170903018c00b00176d4b093e1sm15386677plg.16.2022.09.16.10.06.56 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Fri, 16 Sep 2022 10:07:02 -0700 (PDT) From: wangyong X-Google-Original-From: wangyong To: gregkh@linuxfoundation.org Cc: jaewon31.kim@samsung.com, linux-kernel@vger.kernel.org, mhocko@kernel.org, stable@vger.kernel.org, wang.yong12@zte.com.cn, yongw.pur@gmail.com, Minchan Kim , Baoquan He , Vlastimil Babka , Johannes Weiner , Yong-Taek Lee , stable@vger.kerenl.org, Andrew Morton Subject: [PATCH 3/3] page_alloc: fix invalid watermark check on a negative value Date: Fri, 16 Sep 2022 10:05:49 -0700 Message-Id: <1663347949-20389-4-git-send-email-wang.yong12@zte.com.cn> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1663347949-20389-1-git-send-email-wang.yong12@zte.com.cn> References: <1663347949-20389-1-git-send-email-wang.yong12@zte.com.cn> Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" From: Jaewon Kim There was a report that a task is waiting at the throttle_direct_reclaim. The pgscan_direct_throttle in vmstat was increasing. This is a bug where zone_watermark_fast returns true even when the free is very low. The commit f27ce0e14088 ("page_alloc: consider highatomic reserve in watermark fast") changed the watermark fast to consider highatomic reserve. But it did not handle a negative value case which can be happened when reserved_highatomic pageblock is bigger than the actual free. If watermark is considered as ok for the negative value, allocating contexts for order-0 will consume all free pages without direct reclaim, and finally free page may become depleted except highatomic free. Then allocating contexts may fall into throttle_direct_reclaim. This symptom may easily happen in a system where wmark min is low and other reclaimers like kswapd does not make free pages quickly. Handle the negative case by using MIN. Link: https://lkml.kernel.org/r/20220725095212.25388-1-jaewon31.kim@samsung= .com Fixes: f27ce0e14088 ("page_alloc: consider highatomic reserve in watermark = fast") Signed-off-by: Jaewon Kim Reported-by: GyeongHwan Hong Acked-by: Mel Gorman Cc: Minchan Kim Cc: Baoquan He Cc: Vlastimil Babka Cc: Johannes Weiner Cc: Michal Hocko Cc: Yong-Taek Lee Cc: Signed-off-by: Andrew Morton --- mm/page_alloc.c | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) diff --git a/mm/page_alloc.c b/mm/page_alloc.c index 237463d..d6d8a37 100644 --- a/mm/page_alloc.c +++ b/mm/page_alloc.c @@ -3243,11 +3243,15 @@ static inline bool zone_watermark_fast(struct zone = *z, unsigned int order, * need to be calculated. */ if (!order) { - long fast_free; + long usable_free; + long reserved; =20 - fast_free =3D free_pages; - fast_free -=3D __zone_watermark_unusable_free(z, 0, alloc_flags); - if (fast_free > mark + z->lowmem_reserve[classzone_idx]) + usable_free =3D free_pages; + reserved =3D __zone_watermark_unusable_free(z, 0, alloc_flags); + + /* reserved may over estimate high-atomic reserves. */ + usable_free -=3D min(usable_free, reserved); + if (usable_free > mark + z->lowmem_reserve[classzone_idx]) return true; } =20 --=20 2.7.4