From: Qi Zheng via Linux-f2fs-devel <linux-f2fs-devel@lists.sourceforge.net>
To: Muchun Song <muchun.song@linux.dev>
Cc: kvm@vger.kernel.org, djwong@kernel.org, roman.gushchin@linux.dev,
david@fromorbit.com, dri-devel@lists.freedesktop.org,
virtualization@lists.linux-foundation.org, linux-mm@kvack.org,
dm-devel@redhat.com, linux-mtd@lists.infradead.org,
cel@kernel.org, x86@kernel.org, steven.price@arm.com,
cluster-devel@redhat.com, xen-devel@lists.xenproject.org,
linux-ext4@vger.kernel.org, paulmck@kernel.org,
linux-arm-msm@vger.kernel.org, brauner@kernel.org,
rcu@vger.kernel.org, linux-bcache@vger.kernel.org,
yujie.liu@intel.com, vbabka@suse.cz, linux-raid@vger.kernel.org,
linux-nfs@vger.kernel.org, tytso@mit.edu, netdev@vger.kernel.org,
linux-kernel@vger.kernel.org,
linux-f2fs-devel@lists.sourceforge.net,
linux-xfs@vger.kernel.org, senozhatsky@chromium.org,
gregkh@linuxfoundation.org, linux-fsdevel@vger.kernel.org,
akpm@linux-foundation.org, linux-erofs@lists.ozlabs.org,
linux-btrfs@vger.kernel.org, tkhai@ya.ru
Subject: Re: [f2fs-dev] [PATCH v2 03/47] mm: shrinker: add infrastructure for dynamically allocating shrinker
Date: Tue, 25 Jul 2023 17:56:29 +0800 [thread overview]
Message-ID: <c1a1952f-0c3e-2fa1-fdf9-8b3b8a592b23@bytedance.com> (raw)
In-Reply-To: <3648ca69-d65e-8431-135a-a5738586bc25@linux.dev>
Hi Muchun,
On 2023/7/25 17:02, Muchun Song wrote:
>
>
> On 2023/7/24 17:43, Qi Zheng wrote:
>> Currently, the shrinker instances can be divided into the following three
>> types:
>>
>> a) global shrinker instance statically defined in the kernel, such as
>> workingset_shadow_shrinker.
>>
>> b) global shrinker instance statically defined in the kernel modules,
>> such
>> as mmu_shrinker in x86.
>>
>> c) shrinker instance embedded in other structures.
>>
>> For case a, the memory of shrinker instance is never freed. For case b,
>> the memory of shrinker instance will be freed after synchronize_rcu()
>> when
>> the module is unloaded. For case c, the memory of shrinker instance will
>> be freed along with the structure it is embedded in.
>>
>> In preparation for implementing lockless slab shrink, we need to
>> dynamically allocate those shrinker instances in case c, then the memory
>> can be dynamically freed alone by calling kfree_rcu().
>>
>> So this commit adds the following new APIs for dynamically allocating
>> shrinker, and add a private_data field to struct shrinker to record and
>> get the original embedded structure.
>>
>> 1. shrinker_alloc()
>>
>> Used to allocate shrinker instance itself and related memory, it will
>> return a pointer to the shrinker instance on success and NULL on failure.
>>
>> 2. shrinker_free_non_registered()
>>
>> Used to destroy the non-registered shrinker instance.
>
> At least I don't like this name. I know you want to tell others
> this function only should be called when shrinker has not been
> registed but allocated. Maybe shrinker_free() is more simple.
> And and a comment to tell the users when to use it.
OK, if no one else objects, I will change it to shrinker_free() in
the next version.
>
>>
>> 3. shrinker_register()
>>
>> Used to register the shrinker instance, which is same as the current
>> register_shrinker_prepared().
>>
>> 4. shrinker_unregister()
>>
>> Used to unregister and free the shrinker instance.
>>
>> In order to simplify shrinker-related APIs and make shrinker more
>> independent of other kernel mechanisms, subsequent submissions will use
>> the above API to convert all shrinkers (including case a and b) to
>> dynamically allocated, and then remove all existing APIs.
>>
>> This will also have another advantage mentioned by Dave Chinner:
>>
>> ```
>> The other advantage of this is that it will break all the existing
>> out of tree code and third party modules using the old API and will
>> no longer work with a kernel using lockless slab shrinkers. They
>> need to break (both at the source and binary levels) to stop bad
>> things from happening due to using uncoverted shrinkers in the new
>> setup.
>> ```
>>
>> Signed-off-by: Qi Zheng <zhengqi.arch@bytedance.com>
>> ---
>> include/linux/shrinker.h | 6 +++
>> mm/shrinker.c | 113 +++++++++++++++++++++++++++++++++++++++
>> 2 files changed, 119 insertions(+)
>>
>> diff --git a/include/linux/shrinker.h b/include/linux/shrinker.h
>> index 961cb84e51f5..296f5e163861 100644
>> --- a/include/linux/shrinker.h
>> +++ b/include/linux/shrinker.h
>> @@ -70,6 +70,8 @@ struct shrinker {
>> int seeks; /* seeks to recreate an obj */
>> unsigned flags;
>> + void *private_data;
>> +
>> /* These are for internal use */
>> struct list_head list;
>> #ifdef CONFIG_MEMCG
>> @@ -98,6 +100,10 @@ struct shrinker {
>> unsigned long shrink_slab(gfp_t gfp_mask, int nid, struct mem_cgroup
>> *memcg,
>> int priority);
>> +struct shrinker *shrinker_alloc(unsigned int flags, const char *fmt,
>> ...);
>> +void shrinker_free_non_registered(struct shrinker *shrinker);
>> +void shrinker_register(struct shrinker *shrinker);
>> +void shrinker_unregister(struct shrinker *shrinker);
>> extern int __printf(2, 3) prealloc_shrinker(struct shrinker *shrinker,
>> const char *fmt, ...);
>> diff --git a/mm/shrinker.c b/mm/shrinker.c
>> index 0a32ef42f2a7..d820e4cc5806 100644
>> --- a/mm/shrinker.c
>> +++ b/mm/shrinker.c
>> @@ -548,6 +548,119 @@ unsigned long shrink_slab(gfp_t gfp_mask, int
>> nid, struct mem_cgroup *memcg,
>> return freed;
>> }
>> +struct shrinker *shrinker_alloc(unsigned int flags, const char *fmt,
>> ...)
>> +{
>> + struct shrinker *shrinker;
>> + unsigned int size;
>> + va_list __maybe_unused ap;
>> + int err;
>> +
>> + shrinker = kzalloc(sizeof(struct shrinker), GFP_KERNEL);
>> + if (!shrinker)
>> + return NULL;
>> +
>> +#ifdef CONFIG_SHRINKER_DEBUG
>> + va_start(ap, fmt);
>> + shrinker->name = kvasprintf_const(GFP_KERNEL, fmt, ap);
>> + va_end(ap);
>> + if (!shrinker->name)
>> + goto err_name;
>> +#endif
>
> So why not introduce another helper to handle this and declare it
> as a void function when !CONFIG_SHRINKER_DEBUG? Something like the
> following:
>
> #ifdef CONFIG_SHRINKER_DEBUG
> static int shrinker_debugfs_name_alloc(struct shrinker *shrinker, const
> char *fmt,
> va_list vargs)
>
> {
> shrinker->name = kvasprintf_const(GFP_KERNEL, fmt, vargs);
> return shrinker->name ? 0 : -ENOMEM;
> }
> #else
> static int shrinker_debugfs_name_alloc(struct shrinker *shrinker, const
> char *fmt,
> va_list vargs)
> {
> return 0;
> }
> #endif
Will do in the next version.
>
>> + shrinker->flags = flags;
>> +
>> + if (flags & SHRINKER_MEMCG_AWARE) {
>> + err = prealloc_memcg_shrinker(shrinker);
>> + if (err == -ENOSYS)
>> + shrinker->flags &= ~SHRINKER_MEMCG_AWARE;
>> + else if (err == 0)
>> + goto done;
>> + else
>> + goto err_flags;
>> + }
>> +
>> + /*
>> + * The nr_deferred is available on per memcg level for memcg aware
>> + * shrinkers, so only allocate nr_deferred in the following cases:
>> + * - non memcg aware shrinkers
>> + * - !CONFIG_MEMCG
>> + * - memcg is disabled by kernel command line
>> + */
>> + size = sizeof(*shrinker->nr_deferred);
>> + if (flags & SHRINKER_NUMA_AWARE)
>> + size *= nr_node_ids;
>> +
>> + shrinker->nr_deferred = kzalloc(size, GFP_KERNEL);
>> + if (!shrinker->nr_deferred)
>> + goto err_flags;
>> +
>> +done:
>> + return shrinker;
>> +
>> +err_flags:
>> +#ifdef CONFIG_SHRINKER_DEBUG
>> + kfree_const(shrinker->name);
>> + shrinker->name = NULL;
>
> This could be shrinker_debugfs_name_free()
Will do.
>
>> +err_name:
>> +#endif
>> + kfree(shrinker);
>> + return NULL;
>> +}
>> +EXPORT_SYMBOL(shrinker_alloc);
>> +
>> +void shrinker_free_non_registered(struct shrinker *shrinker)
>> +{
>> +#ifdef CONFIG_SHRINKER_DEBUG
>> + kfree_const(shrinker->name);
>> + shrinker->name = NULL;
>
> This could be shrinker_debugfs_name_free()
>
>> +#endif
>> + if (shrinker->flags & SHRINKER_MEMCG_AWARE) {
>> + down_write(&shrinker_rwsem);
>> + unregister_memcg_shrinker(shrinker);
>> + up_write(&shrinker_rwsem);
>> + }
>> +
>> + kfree(shrinker->nr_deferred);
>> + shrinker->nr_deferred = NULL;
>> +
>> + kfree(shrinker);
>> +}
>> +EXPORT_SYMBOL(shrinker_free_non_registered);
>> +
>> +void shrinker_register(struct shrinker *shrinker)
>> +{
>> + down_write(&shrinker_rwsem);
>> + list_add_tail(&shrinker->list, &shrinker_list);
>> + shrinker->flags |= SHRINKER_REGISTERED;
>> + shrinker_debugfs_add(shrinker);
>> + up_write(&shrinker_rwsem);
>> +}
>> +EXPORT_SYMBOL(shrinker_register);
>> +
>> +void shrinker_unregister(struct shrinker *shrinker)
>
> You have made all shrinkers to be dynamically allocated, so
> we should prevent users from allocating shrinkers statically and
> use this function to unregister it. It is better to add a
> flag like SHRINKER_ALLOCATED which is set in shrinker_alloc(),
> and check whether it is set in shrinker_unregister(), if not
> maybe a warning should be added to tell the users what happened.
Make sense, will do.
>
>> +{
>> + struct dentry *debugfs_entry;
>> + int debugfs_id;
>> +
>> + if (!shrinker || !(shrinker->flags & SHRINKER_REGISTERED))
>> + return;
>> +
>> + down_write(&shrinker_rwsem);
>> + list_del(&shrinker->list);
>> + shrinker->flags &= ~SHRINKER_REGISTERED;
>> + if (shrinker->flags & SHRINKER_MEMCG_AWARE)
>> + unregister_memcg_shrinker(shrinker);
>> + debugfs_entry = shrinker_debugfs_detach(shrinker, &debugfs_id);
>
> In the internal of this function, you also could use
> shrinker_debugfs_name_free().
Yeah, will do.
Thanks,
Qi
>
> Thanks.
>
>> + up_write(&shrinker_rwsem);
>> +
>> + shrinker_debugfs_remove(debugfs_entry, debugfs_id);
>> +
>> + kfree(shrinker->nr_deferred);
>> + shrinker->nr_deferred = NULL;
>> +
>> + kfree(shrinker);
>> +}
>> +EXPORT_SYMBOL(shrinker_unregister);
>> +
>> /*
>> * Add a shrinker callback to be called from the vm.
>> */
>
_______________________________________________
Linux-f2fs-devel mailing list
Linux-f2fs-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
next prev parent reply other threads:[~2023-07-25 9:56 UTC|newest]
Thread overview: 110+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-07-24 9:43 [f2fs-dev] [PATCH v2 00/47] use refcount+RCU method to implement lockless slab shrink Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 01/47] mm: vmscan: move shrinker-related code into a separate file Qi Zheng via Linux-f2fs-devel
2023-07-25 2:35 ` Muchun Song
2023-07-25 3:09 ` Qi Zheng via Linux-f2fs-devel
2023-07-25 3:23 ` Muchun Song
2023-07-25 3:27 ` Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 02/47] mm: shrinker: remove redundant shrinker_rwsem in debugfs operations Qi Zheng via Linux-f2fs-devel
2023-07-25 3:17 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 03/47] mm: shrinker: add infrastructure for dynamically allocating shrinker Qi Zheng via Linux-f2fs-devel
2023-07-24 12:25 ` Peter Zijlstra
2023-07-25 3:01 ` Qi Zheng via Linux-f2fs-devel
2023-07-25 9:02 ` Muchun Song
2023-07-25 9:56 ` Qi Zheng via Linux-f2fs-devel [this message]
2023-07-26 7:26 ` Dave Chinner via Linux-f2fs-devel
2023-07-26 9:20 ` Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 04/47] kvm: mmu: dynamically allocate the x86-mmu shrinker Qi Zheng via Linux-f2fs-devel
2023-07-25 9:16 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 05/47] binder: dynamically allocate the android-binder shrinker Qi Zheng via Linux-f2fs-devel
2023-07-24 9:56 ` Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 06/47] drm/ttm: dynamically allocate the drm-ttm_pool shrinker Qi Zheng via Linux-f2fs-devel
2023-07-25 9:19 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 07/47] xenbus/backend: dynamically allocate the xen-backend shrinker Qi Zheng via Linux-f2fs-devel
2023-07-25 9:22 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 08/47] erofs: dynamically allocate the erofs-shrinker Qi Zheng via Linux-f2fs-devel
2023-07-25 9:24 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 09/47] f2fs: dynamically allocate the f2fs-shrinker Qi Zheng via Linux-f2fs-devel
2023-07-25 9:25 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 10/47] gfs2: dynamically allocate the gfs2-glock shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 6:43 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 11/47] gfs2: dynamically allocate the gfs2-qd shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 6:49 ` Muchun Song
2023-07-26 9:22 ` Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 12/47] NFSv4.2: dynamically allocate the nfs-xattr shrinkers Qi Zheng via Linux-f2fs-devel
2023-07-26 6:55 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 13/47] nfs: dynamically allocate the nfs-acl shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 6:57 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 14/47] nfsd: dynamically allocate the nfsd-filecache shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 6:59 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 15/47] quota: dynamically allocate the dquota-cache shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 6:59 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 16/47] ubifs: dynamically allocate the ubifs-slab shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:00 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 17/47] rcu: dynamically allocate the rcu-lazy shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:04 ` Muchun Song
2023-07-26 9:24 ` Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 18/47] rcu: dynamically allocate the rcu-kfree shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:05 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 19/47] mm: thp: dynamically allocate the thp-related shrinkers Qi Zheng via Linux-f2fs-devel
2023-07-26 7:10 ` Muchun Song
2023-07-26 9:27 ` Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 20/47] sunrpc: dynamically allocate the sunrpc_cred shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:11 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 21/47] mm: workingset: dynamically allocate the mm-shadow shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:13 ` Muchun Song
2023-07-26 9:28 ` Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 22/47] drm/i915: dynamically allocate the i915_gem_mm shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:15 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 23/47] drm/msm: dynamically allocate the drm-msm_gem shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:24 ` Muchun Song
2023-07-26 9:31 ` Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 24/47] drm/panfrost: dynamically allocate the drm-panfrost shrinker Qi Zheng via Linux-f2fs-devel
2023-07-24 11:17 ` Steven Price
2023-07-25 3:05 ` Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 25/47] dm: dynamically allocate the dm-bufio shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:24 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 26/47] dm zoned: dynamically allocate the dm-zoned-meta shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:25 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 27/47] md/raid5: dynamically allocate the md-raid5 shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:27 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 28/47] bcache: dynamically allocate the md-bcache shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:32 ` Muchun Song
2023-07-26 9:33 ` Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 29/47] vmw_balloon: dynamically allocate the vmw-balloon shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:35 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 30/47] virtio_balloon: dynamically allocate the virtio-balloon shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:36 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 31/47] mbcache: dynamically allocate the mbcache shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:39 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 32/47] ext4: dynamically allocate the ext4-es shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:40 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 33/47] jbd2, ext4: dynamically allocate the jbd2-journal shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:41 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 34/47] nfsd: dynamically allocate the nfsd-client shrinker Qi Zheng via Linux-f2fs-devel
2023-07-24 12:17 ` Jeff Layton
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 35/47] nfsd: dynamically allocate the nfsd-reply shrinker Qi Zheng via Linux-f2fs-devel
2023-07-24 12:17 ` Jeff Layton
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 36/47] xfs: dynamically allocate the xfs-buf shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:42 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 37/47] xfs: dynamically allocate the xfs-inodegc shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:42 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 38/47] xfs: dynamically allocate the xfs-qm shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:43 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 39/47] zsmalloc: dynamically allocate the mm-zspool shrinker Qi Zheng via Linux-f2fs-devel
2023-07-26 7:43 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 40/47] fs: super: dynamically allocate the s_shrink Qi Zheng via Linux-f2fs-devel
2023-07-26 7:45 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 41/47] mm: shrinker: remove old APIs Qi Zheng via Linux-f2fs-devel
2023-07-26 7:46 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 42/47] drm/ttm: introduce pool_shrink_rwsem Qi Zheng via Linux-f2fs-devel
2023-07-26 7:56 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 43/47] mm: shrinker: add a secondary array for shrinker_info::{map, nr_deferred} Qi Zheng via Linux-f2fs-devel
2023-07-26 9:30 ` Muchun Song
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 44/47] mm: shrinker: make global slab shrink lockless Qi Zheng via Linux-f2fs-devel
2023-07-26 8:08 ` Dave Chinner via Linux-f2fs-devel
2023-07-26 9:14 ` Qi Zheng via Linux-f2fs-devel
2023-07-26 23:09 ` Dave Chinner via Linux-f2fs-devel
2023-07-27 3:34 ` Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 45/47] mm: shrinker: make memcg " Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 46/47] mm: shrinker: hold write lock to reparent shrinker nr_deferred Qi Zheng via Linux-f2fs-devel
2023-07-24 9:43 ` [f2fs-dev] [PATCH v2 47/47] mm: shrinker: convert shrinker_rwsem to mutex Qi Zheng via Linux-f2fs-devel
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=c1a1952f-0c3e-2fa1-fdf9-8b3b8a592b23@bytedance.com \
--to=linux-f2fs-devel@lists.sourceforge.net \
--cc=akpm@linux-foundation.org \
--cc=brauner@kernel.org \
--cc=cel@kernel.org \
--cc=cluster-devel@redhat.com \
--cc=david@fromorbit.com \
--cc=djwong@kernel.org \
--cc=dm-devel@redhat.com \
--cc=dri-devel@lists.freedesktop.org \
--cc=gregkh@linuxfoundation.org \
--cc=kvm@vger.kernel.org \
--cc=linux-arm-msm@vger.kernel.org \
--cc=linux-bcache@vger.kernel.org \
--cc=linux-btrfs@vger.kernel.org \
--cc=linux-erofs@lists.ozlabs.org \
--cc=linux-ext4@vger.kernel.org \
--cc=linux-fsdevel@vger.kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-mm@kvack.org \
--cc=linux-mtd@lists.infradead.org \
--cc=linux-nfs@vger.kernel.org \
--cc=linux-raid@vger.kernel.org \
--cc=linux-xfs@vger.kernel.org \
--cc=muchun.song@linux.dev \
--cc=netdev@vger.kernel.org \
--cc=paulmck@kernel.org \
--cc=rcu@vger.kernel.org \
--cc=roman.gushchin@linux.dev \
--cc=senozhatsky@chromium.org \
--cc=steven.price@arm.com \
--cc=tkhai@ya.ru \
--cc=tytso@mit.edu \
--cc=vbabka@suse.cz \
--cc=virtualization@lists.linux-foundation.org \
--cc=x86@kernel.org \
--cc=xen-devel@lists.xenproject.org \
--cc=yujie.liu@intel.com \
--cc=zhengqi.arch@bytedance.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).