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 Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id 7173FC47071 for ; Thu, 16 Nov 2023 20:53:22 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id D002E6B04A5; Thu, 16 Nov 2023 15:53:21 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id C891B6B04A6; Thu, 16 Nov 2023 15:53:21 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id B50836B04A7; Thu, 16 Nov 2023 15:53:21 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from relay.hostedemail.com (smtprelay0015.hostedemail.com [216.40.44.15]) by kanga.kvack.org (Postfix) with ESMTP id 86B486B04A5 for ; Thu, 16 Nov 2023 15:53:21 -0500 (EST) Received: from smtpin24.hostedemail.com (a10.router.float.18 [10.200.18.1]) by unirelay08.hostedemail.com (Postfix) with ESMTP id 31740140221 for ; Thu, 16 Nov 2023 20:53:21 +0000 (UTC) X-FDA: 81465017802.24.057F364 Received: from ams.source.kernel.org (ams.source.kernel.org [145.40.68.75]) by imf13.hostedemail.com (Postfix) with ESMTP id 1330E20009 for ; Thu, 16 Nov 2023 20:53:18 +0000 (UTC) Authentication-Results: imf13.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=JozgZ+B2; spf=pass (imf13.hostedemail.com: domain of chrisl@kernel.org designates 145.40.68.75 as permitted sender) smtp.mailfrom=chrisl@kernel.org; dmarc=pass (policy=none) header.from=kernel.org ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=hostedemail.com; s=arc-20220608; t=1700167999; h=from:from:sender:reply-to:subject:subject:date:date: message-id:message-id:to:to:cc:cc:mime-version:mime-version: content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references:dkim-signature; bh=LLZrcc4nDHw52JAMXbEbtbV8uRm7GjGzufazEk6Ip/Y=; b=WvYwax8iWaOR6bhtpL3EARUePhXcPbKg1YGRBcEVrw+IGAglxgHDH6P4dwW1s+BQ7IMUOn 7txivr8Pg7l+aloIGeCzRrNg2hpT53XopclbobA9kiiUWOuHvyNRShmTeBd3vaAZJgYPi7 RB8rDq5fqQFnxc3gjN+P/+2eZw5Ht2Y= ARC-Seal: i=1; s=arc-20220608; d=hostedemail.com; t=1700167999; a=rsa-sha256; cv=none; b=kV5gWEdGdwwjGBzAedVA2XaYfS85Nxulm8nFWAcCmaDtVp0o6TwQMsfcFyDK+Rf03pPFD+ 25kCVtTD9CwzHvOMYWQFChKGGLlcozOkKoYnRV0ooKUcLZ1MUHShCS4Wkr3+LbAyOyhGc0 PPntFONABtrJAZhtSp79PS4uWo62Qtg= ARC-Authentication-Results: i=1; imf13.hostedemail.com; dkim=pass header.d=kernel.org header.s=k20201202 header.b=JozgZ+B2; spf=pass (imf13.hostedemail.com: domain of chrisl@kernel.org designates 145.40.68.75 as permitted sender) smtp.mailfrom=chrisl@kernel.org; dmarc=pass (policy=none) header.from=kernel.org Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by ams.source.kernel.org (Postfix) with ESMTP id 162BBB81E71 for ; Thu, 16 Nov 2023 20:53:17 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id CAA35C433B6 for ; Thu, 16 Nov 2023 20:53:15 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1700167995; bh=Jpgi48UYmlc0MwDkO2MKVFwyBbqohG9h3VtM7M1mjLo=; h=References:In-Reply-To:From:Date:Subject:To:Cc:From; b=JozgZ+B2on20Oh26UhIksECB8xx0rxHE5YJnJ7g2T/9NLq0i+RYIUd8U/V5qBy2eH /8YwnYw4+f5/cavUExwR/rripiT10YMF0fE2HfE6JAWv4JFmvKiVAIoHiScrZ5yzB+ gI6Th6FoMr/hCLKjJO87k4CdesRp24N1jjOdsDVefjVVF6+DCchXWD/b4Gk4UMqkqm 18ieNqbglOeawqd70HFn1XzJc5Gqq75Gm2/v7y+lwUg9FQx6krGpKXxTpBMvaGSUN6 sCCuHj7XWES+gulWxIRfKg295wJxYfwRsi7shgCAYJaUORzrouRYabYm/E0D+t12xe 46tsn+UMXzJsA== Received: by mail-pg1-f172.google.com with SMTP id 41be03b00d2f7-5bd099e3d3cso937893a12.1 for ; Thu, 16 Nov 2023 12:53:15 -0800 (PST) X-Gm-Message-State: AOJu0YzWBPngwT0SvAkevdF7tEIweB9iqGu7w/V80pUbIX7VxebKw0Zn GAKUInIEZUhJ+NwTtL0vXMZaa+/eiR3gt+1QvzFKrQ== X-Google-Smtp-Source: AGHT+IHvhW/6/qEQhnBANC6lFWCUfOyPAzN8T1BDmTvCsrelJ1c6figQ40+71KWLsPLZWGTV6H3GL+Aw/3xuG5vs79I= X-Received: by 2002:a05:6a20:e110:b0:187:4118:141 with SMTP id kr16-20020a056a20e11000b0018741180141mr8668622pzb.5.1700167994904; Thu, 16 Nov 2023 12:53:14 -0800 (PST) MIME-Version: 1.0 References: <20231115172344.4155593-1-nphamcs@gmail.com> In-Reply-To: <20231115172344.4155593-1-nphamcs@gmail.com> From: Chris Li Date: Thu, 16 Nov 2023 12:53:03 -0800 X-Gmail-Original-Message-ID: Message-ID: Subject: Re: [PATCH v5] zswap: memcontrol: implement zswap writeback disabling To: Nhat Pham Cc: Andrew Morton , tj@kernel.org, lizefan.x@bytedance.com, Johannes Weiner , Domenico Cerasuolo , Yosry Ahmed , Seth Jennings , Dan Streetman , Vitaly Wool , mhocko@kernel.org, roman.gushchin@linux.dev, Shakeel Butt , muchun.song@linux.dev, Hugh Dickins , corbet@lwn.net, Konrad Rzeszutek Wilk , senozhatsky@chromium.org, rppt@kernel.org, linux-mm , kernel-team@meta.com, LKML , linux-doc@vger.kernel.org, david@ixit.cz Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: quoted-printable X-Rspamd-Queue-Id: 1330E20009 X-Rspam-User: X-Rspamd-Server: rspam11 X-Stat-Signature: fnzdghqrgcyisc5g5yiepxjpb9fn6ho1 X-HE-Tag: 1700167998-704903 X-HE-Meta: U2FsdGVkX1+KF+/4Vr0STzfNJ1mdlyBg6iLpel7JngRh9vy/gzQMQfXIvm2zK7q4z/c+mERJitJCadO3LjXR2johZASU6aMhKMcy1YfcIU+vo1hYSbktbndmGlJr8Zka4ezaqz9qyKIwX2ze2PeGuHUyJkxaKpb7T8dGE/seIgIxu8qFLZGprc4D1pFP67axy8fW9fqYdKIwIW1a1T/Ta1hzjhBjRFzOjBOff7nP2YOfMYxWcTZUHJn/o/ExF/L1CnAZ9dSJMXlxv3ru0V2tWHibhx0S8nmk37Eu0eljwiuJ9ar5NfeyJm7CbzJGEoKlrCjtdB9fqBlC8GLJOCP/8fNq4SCGh0ptAA7bHD0y97KXrEXhIfabvko9xEpuFMuTdkf7pOFUi7fcAw4ZTjg8mC83AqCpMg33Vo2X828GpYAAx5FumQUs3SMn6+zgkG3QAz96Gms/o12/y5q23jSBZqSvEIz21L+Ca58wLJ+qH09fpmCOsgeVA/OQlvox3UBhgBuch5htFm/uWZH2/MXICds9YPY4CDWQOPkaBjIIg3KMAxkthBei+/uGj9A5u8FO6v6xDboESwTa0OHCpHZMwMyaqkY9sS4dgW9iut7YBh0ZetM3LVPu5F0pHh3G+gs671j0AJ2mK2mbMAtWsxqtrJ3HsENUe8hQjFKmqzIXiwRLv1axBPFtTq5Yuf3XA5ZfmuyV34gGsfcv1J44+jn5k5PgW+Dpuzkl9lQX/9BCI35OahucJQf7RDKLS7Reaq7sZARQWSwZS0eVPIQmp+0SJfd62xtb0aeBnzDbT7J4Z1s2XwSxgQezgvl/Zj5gCMhTd1q6aYG+Glh4fU1n6Wh3lEC3TkriyC964GTdDe9a+z/l5MS3xCHGL7xDX1jh8vubiGXIn2QkpJcsgeq63GIy/owKk6Qb2pU9DXsJiCu8Kb/gQwMLfPAxQjG2DfG3RKV4Vs0Sir0JEad8fTJ9gcf x/y5CMA6 z3HGXdrvBK0V7LX9Nqzz2DGIQLr6jP5ic2zpB+x+hLYD9LDjtW3FRU1Z7kSD3OK1AQCGt/Ii05BmxeYAWuE9pYQK/taMvjQEOxGEeVSfP5KvYeOtf34/Lk1Cm8WzhImdN/6UucMOdvMzF1HU4QkSLItkR8fdXxTOpOuL597x6cSTNwX9dKzws+gzWXspY9SvbFJdNfcAyGWO/nJs+2BQb4Ynt8d9InApiGwavejxQaH1IqNSgX6SUvTkszwXdJAo6UYuvPNus/XUDuPbX6M9eTBchz52cak32WhWp20YPFHcivh9yWaG69gwxob0enwQg31OmARZQpW4VELPOSndQzUahcOYSHFBTMImshsez6fAInICPYf2QELH22BPgfnRUCds3Z62dy+mqZBaa5CWZ8BFeeDZeUBRIHiWc3Wcdlvv8AefZYBBhPFHrZQ== 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: List-Subscribe: List-Unsubscribe: Hi Nhat, As we discussed, I just want to bounce some alternative ideas related to this write back disabled feature. Currently, the common usage case is zswap alone or zswap + SSD. We treat zswap and SSD as two different tiers with different swap in performance characteristi= cs. If we make it more generic, we can also have more than two swap tiers. e.g. we can have zswap, SSD, network swap or HDD swap. The disable flag is just one bit of information, it can't describe what is the next tier.if it is not the current swap file implementation . One idea is that we can have a more general swap_tier_list object to describe the order of the swap device, The system can have more than one such list to describe different combinations of the tier selection. Each memcg can have a pointer point to one of such swap_tier_list objects, replacing the disabled write back flag in this patch. When you swap out, it will just go through each tier in the list, try to swap it out. This has some implications for the zswap shrink as well. It becomes a more generic "move swap out data to another tier". Generally need to load into the swap cache then write to another tier. Open question is how we deal with the swap cache index across different tiers. The zswap.writeback_disable will not be needed if we have a more generic swap tier framework. Chris On Wed, Nov 15, 2023 at 9:24=E2=80=AFAM Nhat Pham wrote= : > > During our experiment with zswap, we sometimes observe swap IOs due to > occasional zswap store failures and writebacks-to-swap. These swapping > IOs prevent many users who cannot tolerate swapping from adopting zswap > to save memory and improve performance where possible. > > This patch adds the option to disable this behavior entirely: do not > writeback to backing swapping device when a zswap store attempt fail, > and do not write pages in the zswap pool back to the backing swap > device (both when the pool is full, and when the new zswap shrinker is > called). > > This new behavior can be opted-in/out on a per-cgroup basis via a new > cgroup file. By default, writebacks to swap device is enabled, which is > the previous behavior. Initially, writeback is enabled for the root > cgroup, and a newly created cgroup will inherit the current setting of > its parent. > > Note that this is subtly different from setting memory.swap.max to 0, as > it still allows for pages to be stored in the zswap pool (which itself > consumes swap space in its current form). > > This patch should be applied on top of the zswap shrinker series: > > https://lore.kernel.org/lkml/20231106183159.3562879-1-nphamcs@gmail.com/ > > as it also disables the zswap shrinker, a major source of zswap > writebacks. > > Suggested-by: Johannes Weiner > Signed-off-by: Nhat Pham > --- > Documentation/admin-guide/cgroup-v2.rst | 12 ++++++++ > Documentation/admin-guide/mm/zswap.rst | 6 ++++ > include/linux/memcontrol.h | 12 ++++++++ > include/linux/zswap.h | 6 ++++ > mm/memcontrol.c | 38 +++++++++++++++++++++++++ > mm/page_io.c | 6 ++++ > mm/shmem.c | 3 +- > mm/zswap.c | 14 +++++++++ > 8 files changed, 95 insertions(+), 2 deletions(-) > > diff --git a/Documentation/admin-guide/cgroup-v2.rst b/Documentation/admi= n-guide/cgroup-v2.rst > index 3f85254f3cef..2b4ac43efdc8 100644 > --- a/Documentation/admin-guide/cgroup-v2.rst > +++ b/Documentation/admin-guide/cgroup-v2.rst > @@ -1679,6 +1679,18 @@ PAGE_SIZE multiple when read back. > limit, it will refuse to take any more stores before existing > entries fault back in or are written out to disk. > > + memory.zswap.writeback > + A read-write single value file. The default value is "1". The > + initial value of the root cgroup is 1, and when a new cgroup is > + created, it inherits the current value of its parent. > + > + When this is set to 0, all swapping attempts to swapping devices > + are disabled. This included both zswap writebacks, and swapping d= ue > + to zswap store failure. > + > + Note that this is subtly different from setting memory.swap.max t= o > + 0, as it still allows for pages to be written to the zswap pool. > + > memory.pressure > A read-only nested-keyed file. > > diff --git a/Documentation/admin-guide/mm/zswap.rst b/Documentation/admin= -guide/mm/zswap.rst > index 522ae22ccb84..b987e58edb70 100644 > --- a/Documentation/admin-guide/mm/zswap.rst > +++ b/Documentation/admin-guide/mm/zswap.rst > @@ -153,6 +153,12 @@ attribute, e. g.:: > > Setting this parameter to 100 will disable the hysteresis. > > +Some users cannot tolerate the swapping that comes with zswap store fail= ures > +and zswap writebacks. Swapping can be disabled entirely (without disabli= ng > +zswap itself) on a cgroup-basis as follows: > + > + echo 0 > /sys/fs/cgroup//memory.zswap.writeback > + > When there is a sizable amount of cold memory residing in the zswap pool= , it > can be advantageous to proactively write these cold pages to swap and re= claim > the memory for other use cases. By default, the zswap shrinker is disabl= ed. > diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h > index 83590fd0d6d1..3901ff4dae63 100644 > --- a/include/linux/memcontrol.h > +++ b/include/linux/memcontrol.h > @@ -219,6 +219,12 @@ struct mem_cgroup { > > #if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_ZSWAP) > unsigned long zswap_max; > + > + /* > + * Prevent pages from this memcg from being written back from zsw= ap to > + * swap, and from being swapped out on zswap store failures. > + */ > + bool zswap_writeback; > #endif > > unsigned long soft_limit; > @@ -1931,6 +1937,7 @@ static inline void count_objcg_event(struct obj_cgr= oup *objcg, > bool obj_cgroup_may_zswap(struct obj_cgroup *objcg); > void obj_cgroup_charge_zswap(struct obj_cgroup *objcg, size_t size); > void obj_cgroup_uncharge_zswap(struct obj_cgroup *objcg, size_t size); > +bool mem_cgroup_zswap_writeback_enabled(struct mem_cgroup *memcg); > #else > static inline bool obj_cgroup_may_zswap(struct obj_cgroup *objcg) > { > @@ -1944,6 +1951,11 @@ static inline void obj_cgroup_uncharge_zswap(struc= t obj_cgroup *objcg, > size_t size) > { > } > +static inline bool mem_cgroup_zswap_writeback_enabled(struct mem_cgroup = *memcg) > +{ > + /* if zswap is disabled, do not block pages going to the swapping= device */ > + return true; > +} > #endif > > #endif /* _LINUX_MEMCONTROL_H */ > diff --git a/include/linux/zswap.h b/include/linux/zswap.h > index cbd373ba88d2..b4997e27a74b 100644 > --- a/include/linux/zswap.h > +++ b/include/linux/zswap.h > @@ -35,6 +35,7 @@ void zswap_swapoff(int type); > void zswap_memcg_offline_cleanup(struct mem_cgroup *memcg); > void zswap_lruvec_state_init(struct lruvec *lruvec); > void zswap_lruvec_swapin(struct page *page); > +bool is_zswap_enabled(void); > #else > > struct zswap_lruvec_state {}; > @@ -55,6 +56,11 @@ static inline void zswap_swapoff(int type) {} > static inline void zswap_memcg_offline_cleanup(struct mem_cgroup *memcg)= {} > static inline void zswap_lruvec_init(struct lruvec *lruvec) {} > static inline void zswap_lruvec_swapin(struct page *page) {} > + > +static inline bool is_zswap_enabled(void) > +{ > + return false; > +} > #endif > > #endif /* _LINUX_ZSWAP_H */ > diff --git a/mm/memcontrol.c b/mm/memcontrol.c > index 786c7edf5836..5ad71ce31c74 100644 > --- a/mm/memcontrol.c > +++ b/mm/memcontrol.c > @@ -5522,6 +5522,8 @@ mem_cgroup_css_alloc(struct cgroup_subsys_state *pa= rent_css) > WRITE_ONCE(memcg->soft_limit, PAGE_COUNTER_MAX); > #if defined(CONFIG_MEMCG_KMEM) && defined(CONFIG_ZSWAP) > memcg->zswap_max =3D PAGE_COUNTER_MAX; > + WRITE_ONCE(memcg->zswap_writeback, > + !parent || READ_ONCE(parent->zswap_writeback)); > #endif > page_counter_set_high(&memcg->swap, PAGE_COUNTER_MAX); > if (parent) { > @@ -8146,6 +8148,12 @@ void obj_cgroup_uncharge_zswap(struct obj_cgroup *= objcg, size_t size) > rcu_read_unlock(); > } > > +bool mem_cgroup_zswap_writeback_enabled(struct mem_cgroup *memcg) > +{ > + /* if zswap is disabled, do not block pages going to the swapping= device */ > + return !is_zswap_enabled() || !memcg || READ_ONCE(memcg->zswap_wr= iteback); > +} > + > static u64 zswap_current_read(struct cgroup_subsys_state *css, > struct cftype *cft) > { > @@ -8176,6 +8184,31 @@ static ssize_t zswap_max_write(struct kernfs_open_= file *of, > return nbytes; > } > > +static int zswap_writeback_show(struct seq_file *m, void *v) > +{ > + struct mem_cgroup *memcg =3D mem_cgroup_from_seq(m); > + > + seq_printf(m, "%d\n", READ_ONCE(memcg->zswap_writeback)); > + return 0; > +} > + > +static ssize_t zswap_writeback_write(struct kernfs_open_file *of, > + char *buf, size_t nbytes, loff_t off) > +{ > + struct mem_cgroup *memcg =3D mem_cgroup_from_css(of_css(of)); > + int zswap_writeback; > + ssize_t parse_ret =3D kstrtoint(strstrip(buf), 0, &zswap_writebac= k); > + > + if (parse_ret) > + return parse_ret; > + > + if (zswap_writeback !=3D 0 && zswap_writeback !=3D 1) > + return -EINVAL; > + > + WRITE_ONCE(memcg->zswap_writeback, zswap_writeback); > + return nbytes; > +} > + > static struct cftype zswap_files[] =3D { > { > .name =3D "zswap.current", > @@ -8188,6 +8221,11 @@ static struct cftype zswap_files[] =3D { > .seq_show =3D zswap_max_show, > .write =3D zswap_max_write, > }, > + { > + .name =3D "zswap.writeback", > + .seq_show =3D zswap_writeback_show, > + .write =3D zswap_writeback_write, > + }, > { } /* terminate */ > }; > #endif /* CONFIG_MEMCG_KMEM && CONFIG_ZSWAP */ > diff --git a/mm/page_io.c b/mm/page_io.c > index cb559ae324c6..5e606f1aa2f6 100644 > --- a/mm/page_io.c > +++ b/mm/page_io.c > @@ -201,6 +201,12 @@ int swap_writepage(struct page *page, struct writeba= ck_control *wbc) > folio_end_writeback(folio); > return 0; > } > + > + if (!mem_cgroup_zswap_writeback_enabled(folio_memcg(folio))) { > + folio_mark_dirty(folio); > + return AOP_WRITEPAGE_ACTIVATE; > + } > + > __swap_writepage(&folio->page, wbc); > return 0; > } > diff --git a/mm/shmem.c b/mm/shmem.c > index 0d1ce70bce38..ccbaaa5f1c16 100644 > --- a/mm/shmem.c > +++ b/mm/shmem.c > @@ -1514,8 +1514,7 @@ static int shmem_writepage(struct page *page, struc= t writeback_control *wbc) > > mutex_unlock(&shmem_swaplist_mutex); > BUG_ON(folio_mapped(folio)); > - swap_writepage(&folio->page, wbc); > - return 0; > + return swap_writepage(&folio->page, wbc); > } > > mutex_unlock(&shmem_swaplist_mutex); > diff --git a/mm/zswap.c b/mm/zswap.c > index 943090dfe793..caa467e40009 100644 > --- a/mm/zswap.c > +++ b/mm/zswap.c > @@ -152,6 +152,11 @@ module_param_named(exclusive_loads, zswap_exclusive_= loads_enabled, bool, 0644); > static bool zswap_shrinker_enabled; > module_param_named(shrinker_enabled, zswap_shrinker_enabled, bool, 0644)= ; > > +bool is_zswap_enabled(void) > +{ > + return zswap_enabled; > +} > + > /********************************* > * data structures > **********************************/ > @@ -589,6 +594,9 @@ static unsigned long zswap_shrinker_scan(struct shrin= ker *shrinker, > struct zswap_pool *pool =3D shrinker->private_data; > bool encountered_page_in_swapcache =3D false; > > + if (!mem_cgroup_zswap_writeback_enabled(sc->memcg)) > + return SHRINK_STOP; > + > nr_protected =3D > atomic_long_read(&lruvec->zswap_lruvec_state.nr_zswap_pro= tected); > lru_size =3D list_lru_shrink_count(&pool->list_lru, sc); > @@ -619,6 +627,9 @@ static unsigned long zswap_shrinker_count(struct shri= nker *shrinker, > struct lruvec *lruvec =3D mem_cgroup_lruvec(memcg, NODE_DATA(sc->= nid)); > unsigned long nr_backing, nr_stored, nr_freeable, nr_protected; > > + if (!mem_cgroup_zswap_writeback_enabled(memcg)) > + return 0; > + > #ifdef CONFIG_MEMCG_KMEM > cgroup_rstat_flush(memcg->css.cgroup); > nr_backing =3D memcg_page_state(memcg, MEMCG_ZSWAP_B) >> PAGE_SHI= FT; > @@ -934,6 +945,9 @@ static int shrink_memcg(struct mem_cgroup *memcg) > struct zswap_pool *pool; > int nid, shrunk =3D 0; > > + if (!mem_cgroup_zswap_writeback_enabled(memcg)) > + return -EINVAL; > + > /* > * Skip zombies because their LRUs are reparented and we would be > * reclaiming from the parent instead of the dead memcg. > -- > 2.34.1