fs: super: dynamically allocate the s_shrink

In preparation for implementing lockless slab shrink, use new APIs to
dynamically allocate the s_shrink, so that it can be freed asynchronously
via RCU. Then it doesn't need to wait for RCU read-side critical section
when releasing the struct super_block.

Link: https://lkml.kernel.org/r/20230911094444.68966-39-zhengqi.arch@bytedance.com
Signed-off-by: Qi Zheng <zhengqi.arch@bytedance.com>
Reviewed-by: Muchun Song <songmuchun@bytedance.com>
Acked-by: David Sterba <dsterba@suse.com>
Cc: Chris Mason <clm@fb.com>
Cc: Josef Bacik <josef@toxicpanda.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Christian Brauner <brauner@kernel.org>
Cc: Abhinav Kumar <quic_abhinavk@quicinc.com>
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Alyssa Rosenzweig <alyssa.rosenzweig@collabora.com>
Cc: Andreas Dilger <adilger.kernel@dilger.ca>
Cc: Andreas Gruenbacher <agruenba@redhat.com>
Cc: Anna Schumaker <anna@kernel.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Bob Peterson <rpeterso@redhat.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Carlos Llamas <cmllamas@google.com>
Cc: Chandan Babu R <chandan.babu@oracle.com>
Cc: Chao Yu <chao@kernel.org>
Cc: Christian Koenig <christian.koenig@amd.com>
Cc: Chuck Lever <cel@kernel.org>
Cc: Coly Li <colyli@suse.de>
Cc: Dai Ngo <Dai.Ngo@oracle.com>
Cc: Daniel Vetter <daniel@ffwll.ch>
Cc: Daniel Vetter <daniel.vetter@ffwll.ch>
Cc: "Darrick J. Wong" <djwong@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: David Airlie <airlied@gmail.com>
Cc: David Hildenbrand <david@redhat.com>
Cc: Dmitry Baryshkov <dmitry.baryshkov@linaro.org>
Cc: Gao Xiang <hsiangkao@linux.alibaba.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: Huang Rui <ray.huang@amd.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jaegeuk Kim <jaegeuk@kernel.org>
Cc: Jani Nikula <jani.nikula@linux.intel.com>
Cc: Jan Kara <jack@suse.cz>
Cc: Jason Wang <jasowang@redhat.com>
Cc: Jeff Layton <jlayton@kernel.org>
Cc: Jeffle Xu <jefflexu@linux.alibaba.com>
Cc: Joel Fernandes (Google) <joel@joelfernandes.org>
Cc: Joonas Lahtinen <joonas.lahtinen@linux.intel.com>
Cc: Juergen Gross <jgross@suse.com>
Cc: Kent Overstreet <kent.overstreet@gmail.com>
Cc: Kirill Tkhai <tkhai@ya.ru>
Cc: Marijn Suijten <marijn.suijten@somainline.org>
Cc: "Michael S. Tsirkin" <mst@redhat.com>
Cc: Mike Snitzer <snitzer@kernel.org>
Cc: Minchan Kim <minchan@kernel.org>
Cc: Muchun Song <muchun.song@linux.dev>
Cc: Nadav Amit <namit@vmware.com>
Cc: Neil Brown <neilb@suse.de>
Cc: Oleksandr Tyshchenko <oleksandr_tyshchenko@epam.com>
Cc: Olga Kornievskaia <kolga@netapp.com>
Cc: Paul E. McKenney <paulmck@kernel.org>
Cc: Richard Weinberger <richard@nod.at>
Cc: Rob Clark <robdclark@gmail.com>
Cc: Rob Herring <robh@kernel.org>
Cc: Rodrigo Vivi <rodrigo.vivi@intel.com>
Cc: Roman Gushchin <roman.gushchin@linux.dev>
Cc: Sean Paul <sean@poorly.run>
Cc: Sergey Senozhatsky <senozhatsky@chromium.org>
Cc: Song Liu <song@kernel.org>
Cc: Stefano Stabellini <sstabellini@kernel.org>
Cc: Steven Price <steven.price@arm.com>
Cc: "Theodore Ts'o" <tytso@mit.edu>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Tomeu Vizoso <tomeu.vizoso@collabora.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Trond Myklebust <trond.myklebust@hammerspace.com>
Cc: Tvrtko Ursulin <tvrtko.ursulin@linux.intel.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Xuan Zhuo <xuanzhuo@linux.alibaba.com>
Cc: Yue Hu <huyue2@coolpad.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/fs/btrfs/super.c b/fs/btrfs/super.c
index 1a093ec0f7e3626cd7468575a1697746f9034dd9..b1798bed68f2d682ffc2bf8061881c257c356ff0 100644 (file)
--- a/fs/btrfs/super.c
+++ b/fs/btrfs/super.c
@@ -1519,7 +1519,7 @@ static struct dentry *btrfs_mount_root(struct file_system_type *fs_type,
                        error = -EBUSY;
        } else {
                snprintf(s->s_id, sizeof(s->s_id), "%pg", bdev);
-               shrinker_debugfs_rename(&s->s_shrink, "sb-%s:%s", fs_type->name,
+               shrinker_debugfs_rename(s->s_shrink, "sb-%s:%s", fs_type->name,
                                        s->s_id);
                btrfs_sb(s)->bdev_holder = fs_type;
                error = btrfs_fill_super(s, fs_devices, data);

diff --git a/fs/kernfs/mount.c b/fs/kernfs/mount.c
index c4bf26142eec9baf2d955166ccb892705a1834a8..79b96e74a8a09d3ce3e73e326ca897d309ae00d4 100644 (file)
--- a/fs/kernfs/mount.c
+++ b/fs/kernfs/mount.c
@@ -265,7 +265,7 @@ static int kernfs_fill_super(struct super_block *sb, struct kernfs_fs_context *k
        sb->s_time_gran = 1;
 
        /* sysfs dentries and inodes don't require IO to create */
-       sb->s_shrink.seeks = 0;
+       sb->s_shrink->seeks = 0;
 
        /* get root inode, initialize and unlock it */
        down_read(&kf_root->kernfs_rwsem);

diff --git a/fs/proc/root.c b/fs/proc/root.c
index 9191248f2dacb4a4144c2482c0d43aca4a3c8c43..b55dbc70287b492ae2e4ed43e2a3c04ee0818798 100644 (file)
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -188,7 +188,7 @@ static int proc_fill_super(struct super_block *s, struct fs_context *fc)
        s->s_stack_depth = FILESYSTEM_MAX_STACK_DEPTH;
 
        /* procfs dentries and inodes don't require IO to create */
-       s->s_shrink.seeks = 0;
+       s->s_shrink->seeks = 0;
 
        pde_get(&proc_root);
        root_inode = proc_get_inode(s, &proc_root);

diff --git a/fs/super.c b/fs/super.c
index 2d762ce67f6e6cbc2d16398b8dee93715b0cfb0d..adadf6689611e91fb25c84ba69676a7b9916ee65 100644 (file)
--- a/fs/super.c
+++ b/fs/super.c
@@ -191,7 +191,7 @@ static unsigned long super_cache_scan(struct shrinker *shrink,
        long    dentries;
        long    inodes;
 
-       sb = container_of(shrink, struct super_block, s_shrink);
+       sb = shrink->private_data;
 
        /*
         * Deadlock avoidance.  We may hold various FS locks, and we don't want
@@ -244,7 +244,7 @@ static unsigned long super_cache_count(struct shrinker *shrink,
        struct super_block *sb;
        long    total_objects = 0;
 
-       sb = container_of(shrink, struct super_block, s_shrink);
+       sb = shrink->private_data;
 
        /*
         * We don't call super_trylock_shared() here as it is a scalability
@@ -306,7 +306,7 @@ static void destroy_unused_super(struct super_block *s)
        security_sb_free(s);
        put_user_ns(s->s_user_ns);
        kfree(s->s_subtype);
-       free_prealloced_shrinker(&s->s_shrink);
+       shrinker_free(s->s_shrink);
        /* no delays needed */
        destroy_super_work(&s->destroy_work);
 }
@@ -383,16 +383,19 @@ static struct super_block *alloc_super(struct file_system_type *type, int flags,
        s->s_time_min = TIME64_MIN;
        s->s_time_max = TIME64_MAX;
 
-       s->s_shrink.seeks = DEFAULT_SEEKS;
-       s->s_shrink.scan_objects = super_cache_scan;
-       s->s_shrink.count_objects = super_cache_count;
-       s->s_shrink.batch = 1024;
-       s->s_shrink.flags = SHRINKER_NUMA_AWARE | SHRINKER_MEMCG_AWARE;
-       if (prealloc_shrinker(&s->s_shrink, "sb-%s", type->name))
+       s->s_shrink = shrinker_alloc(SHRINKER_NUMA_AWARE | SHRINKER_MEMCG_AWARE,
+                                    "sb-%s", type->name);
+       if (!s->s_shrink)
                goto fail;
-       if (list_lru_init_memcg(&s->s_dentry_lru, &s->s_shrink))
+
+       s->s_shrink->scan_objects = super_cache_scan;
+       s->s_shrink->count_objects = super_cache_count;
+       s->s_shrink->batch = 1024;
+       s->s_shrink->private_data = s;
+
+       if (list_lru_init_memcg(&s->s_dentry_lru, s->s_shrink))
                goto fail;
-       if (list_lru_init_memcg(&s->s_inode_lru, &s->s_shrink))
+       if (list_lru_init_memcg(&s->s_inode_lru, s->s_shrink))
                goto fail;
        return s;
 
@@ -477,7 +480,7 @@ void deactivate_locked_super(struct super_block *s)
 {
        struct file_system_type *fs = s->s_type;
        if (atomic_dec_and_test(&s->s_active)) {
-               unregister_shrinker(&s->s_shrink);
+               shrinker_free(s->s_shrink);
                fs->kill_sb(s);
 
                kill_super_notify(s);
@@ -818,7 +821,7 @@ retry:
        hlist_add_head(&s->s_instances, &s->s_type->fs_supers);
        spin_unlock(&sb_lock);
        get_filesystem(s->s_type);
-       register_shrinker_prepared(&s->s_shrink);
+       shrinker_register(s->s_shrink);
        return s;
 
 share_extant_sb:
@@ -901,7 +904,7 @@ retry:
        hlist_add_head(&s->s_instances, &type->fs_supers);
        spin_unlock(&sb_lock);
        get_filesystem(type);
-       register_shrinker_prepared(&s->s_shrink);
+       shrinker_register(s->s_shrink);
        return s;
 }
 EXPORT_SYMBOL(sget);
@@ -1522,7 +1525,7 @@ int setup_bdev_super(struct super_block *sb, int sb_flags,
        mutex_unlock(&bdev->bd_fsfreeze_mutex);
 
        snprintf(sb->s_id, sizeof(sb->s_id), "%pg", bdev);
-       shrinker_debugfs_rename(&sb->s_shrink, "sb-%s:%s", sb->s_type->name,
+       shrinker_debugfs_rename(sb->s_shrink, "sb-%s:%s", sb->s_type->name,
                                sb->s_id);
        sb_set_blocksize(sb, block_size(bdev));
        return 0;

diff --git a/include/linux/fs.h b/include/linux/fs.h
index b528f063e8ffaa32a45e1b14398f448445771aa6..fd539c9fef8ea9021321a7dd3690fcfd0bc5006b 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1265,7 +1265,7 @@ struct super_block {
 
        const struct dentry_operations *s_d_op; /* default d_op for dentries */
 
-       struct shrinker s_shrink;       /* per-sb shrinker handle */
+       struct shrinker *s_shrink;      /* per-sb shrinker handle */
 
        /* Number of inodes with nlink == 0 but still referenced */
        atomic_long_t s_remove_count;