Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-22 04:02:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

mm: shrinker: convert shrinker_rwsem to mutex

Browse Source 
Now there are no readers of shrinker_rwsem, so we can simply replace it
with mutex lock.

[akpm@linux-foundation.org: update the fix to alloc_shrinker_info()]
Link: https://lkml.kernel.org/r/20230911094444.68966-46-zhengqi.arch@bytedance.com
Signed-off-by: Qi Zheng <zhengqi.arch@bytedance.com>
Reviewed-by: Muchun Song <songmuchun@bytedance.com>
Cc: Abhinav Kumar <quic_abhinavk@quicinc.com>
Cc: Alasdair Kergon <agk@redhat.com>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
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: Chris Mason <clm@fb.com>
Cc: Christian Brauner <brauner@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: David Sterba <dsterba@suse.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: Josef Bacik <josef@toxicpanda.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: 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>
This commit is contained in:
Qi Zheng 2023-09-11 17:44:44 +08:00 committed by Andrew Morton
parent 604b8b6550
commit 8a0e8bb112
4 changed files with 24 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/md/dm-cache-metadata.c
View File

@ -1828,7 +1828,7 @@ int dm_cache_metadata_abort(struct dm_cache_metadata *cmd)
* Replacement block manager (new_bm) is created and old_bm destroyed outside of * Replacement block manager (new_bm) is created and old_bm destroyed outside of
* cmd root_lock to avoid ABBA deadlock that would result (due to life-cycle of * cmd root_lock to avoid ABBA deadlock that would result (due to life-cycle of
* shrinker associated with the block manager's bufio client vs cmd root_lock). * shrinker associated with the block manager's bufio client vs cmd root_lock).
* - must take shrinker_rwsem without holding cmd->root_lock * - must take shrinker_mutex without holding cmd->root_lock
*/ */
new_bm = dm_block_manager_create(cmd->bdev, DM_CACHE_METADATA_BLOCK_SIZE << SECTOR_SHIFT, new_bm = dm_block_manager_create(cmd->bdev, DM_CACHE_METADATA_BLOCK_SIZE << SECTOR_SHIFT,
CACHE_MAX_CONCURRENT_LOCKS); CACHE_MAX_CONCURRENT_LOCKS);

2
fs/super.c
View File

@ -178,7 +178,7 @@ static void super_wake(struct super_block *sb, unsigned int flag)
* One thing we have to be careful of with a per-sb shrinker is that we don't * One thing we have to be careful of with a per-sb shrinker is that we don't
* drop the last active reference to the superblock from within the shrinker. * drop the last active reference to the superblock from within the shrinker.
* If that happens we could trigger unregistering the shrinker from within the * If that happens we could trigger unregistering the shrinker from within the
* shrinker path and that leads to deadlock on the shrinker_rwsem. Hence we * shrinker path and that leads to deadlock on the shrinker_mutex. Hence we
* take a passive reference to the superblock to avoid this from occurring. * take a passive reference to the superblock to avoid this from occurring.
*/ */
static unsigned long super_cache_scan(struct shrinker *shrink, static unsigned long super_cache_scan(struct shrinker *shrink,

30
mm/shrinker.c
View File

@ -8,7 +8,7 @@
#include "internal.h" #include "internal.h"
LIST_HEAD(shrinker_list); LIST_HEAD(shrinker_list);
DECLARE_RWSEM(shrinker_rwsem); DEFINE_MUTEX(shrinker_mutex);
#ifdef CONFIG_MEMCG #ifdef CONFIG_MEMCG
static int shrinker_nr_max; static int shrinker_nr_max;
@ -80,7 +80,7 @@ int alloc_shrinker_info(struct mem_cgroup *memcg)
int nid, ret = 0; int nid, ret = 0;
int array_size = 0; int array_size = 0;
down_write(&shrinker_rwsem); mutex_lock(&shrinker_mutex);
array_size = shrinker_unit_size(shrinker_nr_max); array_size = shrinker_unit_size(shrinker_nr_max);
for_each_node(nid) { for_each_node(nid) {
info = kvzalloc_node(sizeof(*info) + array_size, GFP_KERNEL, nid); info = kvzalloc_node(sizeof(*info) + array_size, GFP_KERNEL, nid);
@ -91,12 +91,12 @@ int alloc_shrinker_info(struct mem_cgroup *memcg)
goto err; goto err;
rcu_assign_pointer(memcg->nodeinfo[nid]->shrinker_info, info); rcu_assign_pointer(memcg->nodeinfo[nid]->shrinker_info, info);
} }
up_write(&shrinker_rwsem); mutex_unlock(&shrinker_mutex);
return ret; return ret;
err: err:
up_write(&shrinker_rwsem); mutex_unlock(&shrinker_mutex);
free_shrinker_info(memcg); free_shrinker_info(memcg);
return -ENOMEM; return -ENOMEM;
} }
@ -105,7 +105,7 @@ static struct shrinker_info *shrinker_info_protected(struct mem_cgroup *memcg,
int nid) int nid)
{ {
return rcu_dereference_protected(memcg->nodeinfo[nid]->shrinker_info, return rcu_dereference_protected(memcg->nodeinfo[nid]->shrinker_info,
lockdep_is_held(&shrinker_rwsem)); lockdep_is_held(&shrinker_mutex));
} }
static int expand_one_shrinker_info(struct mem_cgroup *memcg, int new_size, static int expand_one_shrinker_info(struct mem_cgroup *memcg, int new_size,
@ -155,7 +155,7 @@ static int expand_shrinker_info(int new_id)
if (!root_mem_cgroup) if (!root_mem_cgroup)
goto out; goto out;
lockdep_assert_held(&shrinker_rwsem); lockdep_assert_held(&shrinker_mutex);
new_size = shrinker_unit_size(new_nr_max); new_size = shrinker_unit_size(new_nr_max);
old_size = shrinker_unit_size(shrinker_nr_max); old_size = shrinker_unit_size(shrinker_nr_max);
@ -218,7 +218,7 @@ static int shrinker_memcg_alloc(struct shrinker *shrinker)
if (mem_cgroup_disabled()) if (mem_cgroup_disabled())
return -ENOSYS; return -ENOSYS;
down_write(&shrinker_rwsem); mutex_lock(&shrinker_mutex);
id = idr_alloc(&shrinker_idr, shrinker, 0, 0, GFP_KERNEL); id = idr_alloc(&shrinker_idr, shrinker, 0, 0, GFP_KERNEL);
if (id < 0) if (id < 0)
goto unlock; goto unlock;
@ -232,7 +232,7 @@ static int shrinker_memcg_alloc(struct shrinker *shrinker)
shrinker->id = id; shrinker->id = id;
ret = 0; ret = 0;
unlock: unlock:
up_write(&shrinker_rwsem); mutex_unlock(&shrinker_mutex);
return ret; return ret;
} }
@ -242,7 +242,7 @@ static void shrinker_memcg_remove(struct shrinker *shrinker)
BUG_ON(id < 0); BUG_ON(id < 0);
lockdep_assert_held(&shrinker_rwsem); lockdep_assert_held(&shrinker_mutex);
idr_remove(&shrinker_idr, id); idr_remove(&shrinker_idr, id);
} }
@ -293,7 +293,7 @@ void reparent_shrinker_deferred(struct mem_cgroup *memcg)
parent = root_mem_cgroup; parent = root_mem_cgroup;
/* Prevent from concurrent shrinker_info expand */ /* Prevent from concurrent shrinker_info expand */
down_write(&shrinker_rwsem); mutex_lock(&shrinker_mutex);
for_each_node(nid) { for_each_node(nid) {
child_info = shrinker_info_protected(memcg, nid); child_info = shrinker_info_protected(memcg, nid);
parent_info = shrinker_info_protected(parent, nid); parent_info = shrinker_info_protected(parent, nid);
@ -306,7 +306,7 @@ void reparent_shrinker_deferred(struct mem_cgroup *memcg)
} }
} }
} }
up_write(&shrinker_rwsem); mutex_unlock(&shrinker_mutex);
} }
#else #else
static int shrinker_memcg_alloc(struct shrinker *shrinker) static int shrinker_memcg_alloc(struct shrinker *shrinker)
@ -740,11 +740,11 @@ void shrinker_register(struct shrinker *shrinker)
return; return;
} }
down_write(&shrinker_rwsem); mutex_lock(&shrinker_mutex);
list_add_tail_rcu(&shrinker->list, &shrinker_list); list_add_tail_rcu(&shrinker->list, &shrinker_list);
shrinker->flags |= SHRINKER_REGISTERED; shrinker->flags |= SHRINKER_REGISTERED;
shrinker_debugfs_add(shrinker); shrinker_debugfs_add(shrinker);
up_write(&shrinker_rwsem); mutex_unlock(&shrinker_mutex);
init_completion(&shrinker->done); init_completion(&shrinker->done);
/* /*
@ -784,7 +784,7 @@ void shrinker_free(struct shrinker *shrinker)
wait_for_completion(&shrinker->done); wait_for_completion(&shrinker->done);
} }
down_write(&shrinker_rwsem); mutex_lock(&shrinker_mutex);
if (shrinker->flags & SHRINKER_REGISTERED) { if (shrinker->flags & SHRINKER_REGISTERED) {
/* /*
* Now we can safely remove it from the shrinker_list and then * Now we can safely remove it from the shrinker_list and then
@ -799,7 +799,7 @@ void shrinker_free(struct shrinker *shrinker)
if (shrinker->flags & SHRINKER_MEMCG_AWARE) if (shrinker->flags & SHRINKER_MEMCG_AWARE)
shrinker_memcg_remove(shrinker); shrinker_memcg_remove(shrinker);
up_write(&shrinker_rwsem); mutex_unlock(&shrinker_mutex);
if (debugfs_entry) if (debugfs_entry)
shrinker_debugfs_remove(debugfs_entry, debugfs_id); shrinker_debugfs_remove(debugfs_entry, debugfs_id);

14
mm/shrinker_debug.c
View File

@ -9,7 +9,7 @@
#include "internal.h" #include "internal.h"
/* defined in vmscan.c */ /* defined in vmscan.c */
extern struct rw_semaphore shrinker_rwsem; extern struct mutex shrinker_mutex;
extern struct list_head shrinker_list; extern struct list_head shrinker_list;
static DEFINE_IDA(shrinker_debugfs_ida); static DEFINE_IDA(shrinker_debugfs_ida);
@ -165,7 +165,7 @@ int shrinker_debugfs_add(struct shrinker *shrinker)
char buf[128]; char buf[128];
int id; int id;
lockdep_assert_held(&shrinker_rwsem); lockdep_assert_held(&shrinker_mutex);
/* debugfs isn't initialized yet, add debugfs entries later. */ /* debugfs isn't initialized yet, add debugfs entries later. */
if (!shrinker_debugfs_root) if (!shrinker_debugfs_root)
@ -208,7 +208,7 @@ int shrinker_debugfs_rename(struct shrinker *shrinker, const char *fmt, ...)
if (!new) if (!new)
return -ENOMEM; return -ENOMEM;
down_write(&shrinker_rwsem); mutex_lock(&shrinker_mutex);
old = shrinker->name; old = shrinker->name;
shrinker->name = new; shrinker->name = new;
@ -226,7 +226,7 @@ int shrinker_debugfs_rename(struct shrinker *shrinker, const char *fmt, ...)
shrinker->debugfs_entry = entry; shrinker->debugfs_entry = entry;
} }
up_write(&shrinker_rwsem); mutex_unlock(&shrinker_mutex);
kfree_const(old); kfree_const(old);
@ -239,7 +239,7 @@ struct dentry *shrinker_debugfs_detach(struct shrinker *shrinker,
{ {
struct dentry *entry = shrinker->debugfs_entry; struct dentry *entry = shrinker->debugfs_entry;
lockdep_assert_held(&shrinker_rwsem); lockdep_assert_held(&shrinker_mutex);
*debugfs_id = entry ? shrinker->debugfs_id : -1; *debugfs_id = entry ? shrinker->debugfs_id : -1;
shrinker->debugfs_entry = NULL; shrinker->debugfs_entry = NULL;
@ -265,14 +265,14 @@ static int __init shrinker_debugfs_init(void)
shrinker_debugfs_root = dentry; shrinker_debugfs_root = dentry;
/* Create debugfs entries for shrinkers registered at boot */ /* Create debugfs entries for shrinkers registered at boot */
down_write(&shrinker_rwsem); mutex_lock(&shrinker_mutex);
list_for_each_entry(shrinker, &shrinker_list, list) list_for_each_entry(shrinker, &shrinker_list, list)
if (!shrinker->debugfs_entry) { if (!shrinker->debugfs_entry) {
ret = shrinker_debugfs_add(shrinker); ret = shrinker_debugfs_add(shrinker);
if (ret) if (ret)
break; break;
} }
up_write(&shrinker_rwsem); mutex_unlock(&shrinker_mutex);
return ret; return ret;
} }