linux-f2fs-devel.lists.sourceforge.net archive mirror
 help / color / mirror / Atom feed
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

  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).