block: don't acquire .sysfs_lock before removing mq & iosched kobjects
v2 cover block: don't acquire .sysfs_lock before removing mq & iosched kobjects
Hi,
The 1st 4 patches cleans up current uses on q->sysfs_lock.
The 5th patch adds one helper for checking if queue is registered.
The last patch splits .sysfs_lock into two locks: one is only for sync .store/.show from sysfs, the other one is for pretecting kobjects registering/unregistering. Meantime avoid to acquire .sysfs_lock when removing mq & iosched kobjects, so that the reported deadlock can be fixed.
V2:
- remove several uses on .sysfs_lock
- Remove blk_mq_register_dev()
- add one helper for checking queue registered
- split .sysfs_lock into two locks
Bart Van Assche (1):
block: Remove blk_mq_register_dev()
Ming Lei (5):
block: don't hold q->sysfs_lock in elevator_init_mq
blk-mq: don't hold q->sysfs_lock in blk_mq_map_swqueue
blk-mq: don't hold q->sysfs_lock in blk_mq_realloc_hw_ctxs()
block: add helper for checking if queue is registered
block: split .sysfs_lock into two locks
block/blk-core.c | 1 + block/blk-mq-sysfs.c | 23 ++++------------ block/blk-mq.c | 10 ------- block/blk-sysfs.c | 50 +++++++++++++++++++++------------- block/blk-wbt.c | 2 +- block/blk.h | 2 +- block/elevator.c | 62 +++++++++++++++++++++++++++++++----------- include/linux/blk-mq.h | 1 - include/linux/blkdev.h | 2 ++ 9 files changed, 88 insertions(+), 65 deletions(-)
Signature · 1 line
2.20.1
PATCH v2 1/6 block: Remove blk_mq_register_dev()
From: Bart Van Assche <[email protected]>
This function has no callers. Hence remove it.
--- block/blk-mq-sysfs.c | 11 ----------- include/linux/blk-mq.h | 1 - 2 files changed, 12 deletions(-)
block/blk-mq-sysfs.c +0 -11
@@ -326,17 +326,6 @@ int __blk_mq_register_dev(struct device *dev, struct request_queue *q)return ret; } -int blk_mq_register_dev (struct device *dev,struct request_queue *q) -{ -int ret; - -mutex_lock (&q->sysfs_lock); - ret =__blk_mq_register_dev (dev, q); -mutex_unlock (&q->sysfs_lock); - -return ret; -} -void blk_mq_sysfs_unregister (struct request_queue *q) {struct blk_mq_hw_ctx *hctx;
include/linux/blk-mq.h +0 -1
@@ -253,7 +253,6 @@ struct request_queue *blk_mq_init_sq_queue(struct blk_mq_tag_set *set,const struct blk_mq_ops *ops, unsigned int queue_depth, unsigned int set_flags); -int blk_mq_register_dev (struct device *,struct request_queue *);void blk_mq_unregister_dev (struct device *,struct request_queue *);int blk_mq_alloc_tag_set (struct blk_mq_tag_set *set);
Signature · 1 line
2.20.1
PATCH v2 2/6 block: don't hold q->sysfs_lock in elevator_init_mq
In reply to Ming LeiThe original comment says:
q->sysfs_lock must be held to provide mutual exclusion between elevator_switch() and here.
Which is simply wrong. elevator_init_mq() is only called from blk_mq_init_allocated_queue, which is always called before the request queue is registered via blk_register_queue(), for dm-rq or normal rq based driver. However, queue's kobject is just exposed added to sysfs in blk_register_queue(). So there isn't such race between elevator_switch() and elevator_init_mq().
So avoid to hold q->sysfs_lock in elevator_init_mq().
--- block/elevator.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
block/elevator.c +7 -7
@@ -608,22 +608,22 @@ int elevator_init_mq(struct request_queue *q)return 0 ;/* -* q->sysfs_lock must be held to provide mutual exclusion between -* elevator_switch() and here. +* We are called from blk_mq_init_allocated_queue() only, at that +* time the request queue isn't registered yet, so the queue +* kobject isn't exposed to userspace. No need to worry about race +* with elevator_switch(), and no need to hold q->sysfs_lock. */ -mutex_lock (&q->sysfs_lock);if (unlikely (q->elevator)) - goto out_unlock; + goto out; e =elevator_get (q,"mq-deadline" , false);if (!e) - goto out_unlock; + goto out; err =blk_mq_init_sched (q, e);if (err)elevator_put (e); -out_unlock: -mutex_unlock (&q->sysfs_lock); +out:return err; }
Signature · 1 line
2.20.1
Re: [PATCH V2 2/6] block: don't hold q->sysfs_lock in elevator_init_mq
Quoted 9 lines · Ming Lei
The original comment says:
q->sysfs_lock must be held to provide mutual exclusion between elevator_switch() and here.Which is simply wrong.
elevator_init_mq()is only called fromblk_mq_init_allocated_queue, which is always called before the request queue is registered viablk_register_queue(), for dm-rq or normal rq based driver. However, queue's kobject is just exposed added to sysfs
^^^^^^^^^^^^
only?Quoted 4 lines
in
blk_register_queue(). So there isn't such race betweenelevator_switch()andelevator_init_mq().So avoid to hold
q->sysfs_lockinelevator_init_mq().
[ ... ]
block/elevator.c int elevator_init_mq(struct request_queue *q) · line 615
Quoted 8 lines
/*
block/elevator.c +4
-2-* q->sysfs_lock must be held to provide mutual exclusion between -* elevator_switch() and here. +* We are called from blk_mq_init_allocated_queue() only, at that +* time the request queue isn't registered yet, so the queue +* kobject isn't exposed to userspace. No need to worry about race +* with elevator_switch(), and no need to hold q->sysfs_lock. */
How about replacing this comment with the following:
WARN_ON_ONCE(test_bit(QUEUE_FLAG_REGISTERED, &q->queue_flags));
Anyway:
PATCH v2 3/6 blk-mq: don't hold q->sysfs_lock in blk_mq_map_swqueue
In reply to Ming Leiblk_mq_map_swqueue() is called from blk_mq_init_allocated_queue() and blk_mq_update_nr_hw_queues(). For the former caller, the kobject isn't exposed to userspace yet. For the latter caller, sysfs/debugfs is un-registered before updating nr_hw_queues.
On the other hand, commit 2f8f1336a48b ("blk-mq: always free hctx after request queue is freed") moves freeing hctx into queue's release handler, so there won't be race with queue release path too.
So don't hold q->sysfs_lock in blk_mq_map_swqueue().
--- block/blk-mq.c | 7 ------- 1 file changed, 7 deletions(-)
block/blk-mq.c +0 -7
@@ -2456,11 +2456,6 @@ static void blk_mq_map_swqueue(struct request_queue *q)struct blk_mq_ctx *ctx;struct blk_mq_tag_set *set = q->tag_set; -/* -* Avoid others reading imcomplete hctx->cpumask through sysfs -*/ -mutex_lock (&q->sysfs_lock); -queue_for_each_hw_ctx (q, hctx, i) {cpumask_clear (hctx->cpumask); hctx->nr_ctx =0 ;
@@ -2521,8 +2516,6 @@ static void blk_mq_map_swqueue(struct request_queue *q) HCTX_TYPE_DEFAULT, i); } -mutex_unlock (&q->sysfs_lock); -queue_for_each_hw_ctx (q, hctx, i) {/* * If no software queues are mapped to this hardware queue,
Signature · 1 line
2.20.1
Re: [PATCH V2 3/6] blk-mq: don't hold q->sysfs_lock in blk_mq_map_swqueue
Quoted 39 lines · Ming Lei
blk_mq_map_swqueue()is called fromblk_mq_init_allocated_queue()andblk_mq_update_nr_hw_queues(). For the former caller, the kobject isn't exposed to userspace yet. For the latter caller, sysfs/debugfs is un-registered before updatingnr_hw_queues.On the other hand, commit
2f8f1336a48b("blk-mq: always free hctx after request queue is freed") moves freeing hctx into queue's release handler, so there won't be race with queue release path too.So don't hold
q->sysfs_lockinblk_mq_map_swqueue().Cc Christoph Hellwig <[email protected]>Cc Hannes Reinecke <[email protected]>Cc Greg KH <[email protected]>Cc Mike Snitzer <[email protected]>Cc Bart Van Assche <[email protected]>Signed-off-by Ming Lei <[email protected]>--- block/blk-mq.c | 7 ------- 1 file changed, 7 deletions(-)block/blk-mq.c +0
-5@@ -2456,11 +2456,6 @@ static void blk_mq_map_swqueue(struct request_queue *q)struct blk_mq_ctx *ctx;struct blk_mq_tag_set *set = q->tag_set; -/* -* Avoid others reading imcomplete hctx->cpumask through sysfs -*/ -mutex_lock (&q->sysfs_lock); -queue_for_each_hw_ctx (q, hctx, i) {cpumask_clear (hctx->cpumask); hctx->nr_ctx =0 ;
block/blk-mq.c static void blk_mq_map_swqueue(struct request_queue *q) · line 2521
Quoted 8 lines
block/blk-mq.c +0
-2@@ -2521,8 +2516,6 @@ static void blk_mq_map_swqueue(struct request_queue *q) HCTX_TYPE_DEFAULT, i); } -mutex_unlock (&q->sysfs_lock); -queue_for_each_hw_ctx (q, hctx, i) {/* * If no software queues are mapped to this hardware queue,
How about adding WARN_ON_ONCE(test_bit(QUEUE_FLAG_REGISTERED, &q->queue_flags)) ?
Anyway:
Re: [PATCH V2 3/6] blk-mq: don't hold q->sysfs_lock in blk_mq_map_swqueue
Quoted 41 lines · Bart Van Assche
Quoted 40 lines · Ming Lei
blk_mq_map_swqueue()is called fromblk_mq_init_allocated_queue()andblk_mq_update_nr_hw_queues(). For the former caller, the kobject isn't exposed to userspace yet. For the latter caller, sysfs/debugfs is un-registered before updatingnr_hw_queues.On the other hand, commit
2f8f1336a48b("blk-mq: always free hctx after request queue is freed") moves freeing hctx into queue's release handler, so there won't be race with queue release path too.So don't hold
q->sysfs_lockinblk_mq_map_swqueue().Cc Christoph Hellwig <[email protected]>Cc Hannes Reinecke <[email protected]>Cc Greg KH <[email protected]>Cc Mike Snitzer <[email protected]>Cc Bart Van Assche <[email protected]>Signed-off-by Ming Lei <[email protected]>--- block/blk-mq.c | 7 ------- 1 file changed, 7 deletions(-)block/blk-mq.c +0
-6@@ -2456,11 +2456,6 @@ static void blk_mq_map_swqueue(struct request_queue *q)struct blk_mq_ctx *ctx;struct blk_mq_tag_set *set = q->tag_set; -/* -* Avoid others reading imcomplete hctx->cpumask through sysfs -*/ -mutex_lock (&q->sysfs_lock); -queue_for_each_hw_ctx (q, hctx, i) {cpumask_clear (hctx->cpumask); hctx->nr_ctx =0 ;@@ -2521,8 +2516,6 @@ static void blk_mq_map_swqueue(struct request_queue *q) HCTX_TYPE_DEFAULT, i); } -mutex_unlock (&q->sysfs_lock);
Quoted 8 lines
block/blk-mq.c static void blk_mq_map_swqueue(struct request_queue *q)
Quoted 5 lines
block/blk-mq.c +0
-1-queue_for_each_hw_ctx (q, hctx, i) {/* * If no software queues are mapped to this hardware queue, How about adding
WARN_ON_ONCE(test_bit(QUEUE_FLAG_REGISTERED, &q->queue_flags))?
q->kobject isn't un-registered before updating nr_hw_queues, and only hctx->kobj is un-registered, so we can't add the warn here.
Thanks,
Ming
PATCH v2 4/6 blk-mq: don't hold q->sysfs_lock in blk_mq_realloc_hw_ctxs()
In reply to Ming Leiblk_mq_realloc_hw_ctxs() is called from blk_mq_init_allocated_queue() and blk_mq_update_nr_hw_queues(). For the former caller, the kobject isn't exposed to userspace yet. For the latter caller, sysfs/debugfs is un-registered before updating nr_hw_queues.
On the other hand, commit 2f8f1336a48b ("blk-mq: always free hctx after request queue is freed") moves freeing hctx into queue's release handler, so there won't be race with queue release path too.
So don't hold q->sysfs_lock in blk_mq_realloc_hw_ctxs().
--- block/blk-mq.c | 3 --- 1 file changed, 3 deletions(-)
block/blk-mq.c +0 -3
@@ -2768,8 +2768,6 @@ static void blk_mq_realloc_hw_ctxs(struct blk_mq_tag_set *set,int i, j, end;struct blk_mq_hw_ctx **hctxs = q->queue_hw_ctx; -/* protect against switching io scheduler */ -mutex_lock (&q->sysfs_lock);for (i =0 ; i < set->nr_hw_queues; i++) {int node;struct blk_mq_hw_ctx *hctx;
@@ -2820,7 +2818,6 @@ static void blk_mq_realloc_hw_ctxs(struct blk_mq_tag_set *set, hctxs[j] =NULL ; } } -mutex_unlock (&q->sysfs_lock); }/*
Signature · 1 line
2.20.1
Re: [PATCH V2 4/6] blk-mq: don't hold q->sysfs_lock in blk_mq_realloc_hw_ctxs()
Quoted 10 lines · Ming Lei
blk_mq_realloc_hw_ctxs()is called fromblk_mq_init_allocated_queue()andblk_mq_update_nr_hw_queues(). For the former caller, the kobject isn't exposed to userspace yet. For the latter caller, sysfs/debugfs is un-registered before updatingnr_hw_queues.On the other hand, commit
2f8f1336a48b("blk-mq: always free hctx after request queue is freed") moves freeing hctx into queue's release handler, so there won't be race with queue release path too.So don't hold
q->sysfs_lockinblk_mq_realloc_hw_ctxs().
How about mentioning that the locking at the start of blk_mq_update_nr_hw_queues() serializes all blk_mq_realloc_hw_ctxs() calls that happen after a queue has been registered in sysfs?
Anyway:
Re: [PATCH V2 4/6] blk-mq: don't hold q->sysfs_lock in blk_mq_realloc_hw_ctxs()
Quoted 10 lines · Bart Van Assche
Quoted 9 lines · Ming Lei
blk_mq_realloc_hw_ctxs()is called fromblk_mq_init_allocated_queue()andblk_mq_update_nr_hw_queues(). For the former caller, the kobject isn't exposed to userspace yet. For the latter caller, sysfs/debugfs is un-registered before updatingnr_hw_queues.On the other hand, commit
2f8f1336a48b("blk-mq: always free hctx after request queue is freed") moves freeing hctx into queue's release handler, so there won't be race with queue release path too.
Quoted 5 lines
Quoted 1 line
So don't hold
q->sysfs_lockinblk_mq_realloc_hw_ctxs().How about mentioning that the locking at the start of
blk_mq_update_nr_hw_queues()serializes allblk_mq_realloc_hw_ctxs()calls that happen after a queue has been registered in sysfs?
This patch is actually wrong because elevator switch still may happen during updating nr_hw_queues, since only hctx sysfs entries are un-registered, and "queue/scheduler" is still visible to userspace.
So I will drop this patch in V3.
Thanks,
Ming
PATCH v2 5/6 block: add helper for checking if queue is registered
In reply to Ming LeiThere are 4 users which check if queue is registered, so add one helper to check it.
--- block/blk-sysfs.c | 4 ++-- block/blk-wbt.c | 2 +- block/elevator.c | 2 +- include/linux/blkdev.h | 1 + 4 files changed, 5 insertions(+), 4 deletions(-)
block/blk-sysfs.c +2 -2
@@ -942,7 +942,7 @@ int blk_register_queue(struct gendisk *disk)if (WARN_ON (!q))return -ENXIO ; -WARN_ONCE (test_bit (QUEUE_FLAG_REGISTERED , &q->queue_flags), +WARN_ONCE (blk_queue_registered (q),"%s is registering an already registered queue\n" ,kobject_name (&dev->kobj));blk_queue_flag_set (QUEUE_FLAG_REGISTERED , q);
@@ -1026,7 +1026,7 @@ void blk_unregister_queue(struct gendisk *disk)return ;/* Return early if disk->queue was never registered. */ -if (!test_bit (QUEUE_FLAG_REGISTERED , &q->queue_flags)) +if (!blk_queue_registered (q))return ;/*
block/blk-wbt.c +1 -1
@@ -656,7 +656,7 @@ void wbt_enable_default(struct request_queue *q)return ;/* Queue not registered? Maybe shutting down... */ -if (!test_bit (QUEUE_FLAG_REGISTERED , &q->queue_flags)) +if (!blk_queue_registered (q))return ;if (queue_is_mq (q) &&IS_ENABLED (CONFIG_BLK_WBT_MQ ))
block/elevator.c +1 -1
@@ -660,7 +660,7 @@ static int __elevator_change(struct request_queue *q, const char *name)struct elevator_type *e;/* Make sure queue is not in the middle of being removed */ -if (!test_bit (QUEUE_FLAG_REGISTERED , &q->queue_flags)) +if (!blk_queue_registered (q))return -ENOENT ;/*
include/linux/blkdev.h +1 -0
@@ -647,6 +647,7 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q);#define blk_queue_quiesced (q) test_bit(QUEUE_FLAG_QUIESCED, &(q)->queue_flags)#define blk_queue_pm_only (q) atomic_read(&(q)->pm_only)#define blk_queue_fua (q) test_bit(QUEUE_FLAG_FUA, &(q)->queue_flags) +#define blk_queue_registered (q) test_bit(QUEUE_FLAG_REGISTERED, &(q)->queue_flags)extern void blk_set_pm_only (struct request_queue *q);extern void blk_clear_pm_only (struct request_queue *q);
Signature · 1 line
2.20.1
Re: [PATCH V2 5/6] block: add helper for checking if queue is registered
Quoted 2 lines · Ming Lei
There are 4 users which check if queue is registered, so add one helper to check it.
PATCH v2 6/6 block: split .sysfs_lock into two locks
In reply to Ming LeiSplit .sysfs_lock into two: one is still named as .sysfs_lock for covering sync .store, the other one is named as .sysfs_dir_lock for covering kobjects and related status change.
sysfs itself can handle the race between add/remove kobjects and showing/storing attributes under kobjects. For switching scheduler via storing to 'queue/scheduler', we use the queue flag of QUEUE_FLAG_REGISTERED with .sysfs_lock for avoiding the race, then we can avoid to hold .sysfs_lock during removing/adding kobjects.
The kernfs built-in lock of 'kn->count' is held in sysfs .show/.store path. Meantime, inside block's .show/.store callback, q->sysfs_lock is required.
However, when mq & iosched kobjects are removed via blk_mq_unregister_dev() & elv_unregister_queue(), q->sysfs_lock is held too. This way causes AB-BA lock because the kernfs built-in lock of 'kn-count' is required inside kobject_del() too, see the lockdep warning[1].
On the other hand, it isn't necessary to acquire q->sysfs_lock for both blk_mq_unregister_dev() & elv_unregister_queue() because clearing REGISTERED flag prevents storing to 'queue/scheduler' from being happened. Also sysfs write(store) is exclusive, so no necessary to hold the lock for elv_unregister_queue() when it is called in switching elevator path.
[1] lockdep warning
======================================================
WARNING: possible circular locking dependency detected
5.3.0-rc3-00044-g73277fc75ea0 #1380 Not tainted
------------------------------------------------------
rmmod/777 is trying to acquire lock:
00000000ac50e981 (kn->count#202){++++}, at: kernfs_remove_by_name_ns+0x59/0x72
but task is already holding lock:
00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
which lock already depends on the new lock.
the existing dependency chain (in reverse order) is:
-> #1 (&q->sysfs_lock){+.+.}:
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__mutex_lock+0x14a/0xa9b
blk_mq_hw_sysfs_show+0x63/0xb6
sysfs_kf_seq_show+0x11f/0x196
seq_read+0x2cd/0x5f2
vfs_read+0xc7/0x18c
ksys_read+0xc4/0x13e
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
-> #0 (kn->count#202){++++}:
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
__kernfs_remove+0x237/0x40b
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
other info that might help us debug this:
Possible unsafe locking scenario:
CPU0 CPU1
---- ----
lock(&q->sysfs_lock);
lock(kn->count#202);
lock(&q->sysfs_lock);
lock(kn->count#202);
*** DEADLOCK ***
2 locks held by rmmod/777:
#0: 00000000e69bd9de (&lock){+.+.}, at: null_exit+0x2e/0x95 [null_blk]
#1: 00000000fb16ae21 (&q->sysfs_lock){+.+.}, at: blk_unregister_queue+0x78/0x10b
stack backtrace:
CPU: 0 PID: 777 Comm: rmmod Not tainted 5.3.0-rc3-00044-g73277fc75ea0 #1380
Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS ?-20180724_192412-buildhw-07.phx4
Call Trace:
dump_stack+0x9a/0xe6
check_noncircular+0x207/0x251
? print_circular_bug+0x32a/0x32a
? find_usage_backwards+0x84/0xb0
check_prev_add+0x5d2/0xc45
validate_chain+0xed3/0xf94
? check_prev_add+0xc45/0xc45
? mark_lock+0x11b/0x804
? check_usage_forwards+0x1ca/0x1ca
__lock_acquire+0x95f/0xa2f
lock_acquire+0x1b4/0x1e8
? kernfs_remove_by_name_ns+0x59/0x72
__kernfs_remove+0x237/0x40b
? kernfs_remove_by_name_ns+0x59/0x72
? kernfs_next_descendant_post+0x7d/0x7d
? strlen+0x10/0x23
? strcmp+0x22/0x44
kernfs_remove_by_name_ns+0x59/0x72
remove_files+0x61/0x96
sysfs_remove_group+0x81/0xa4
sysfs_remove_groups+0x3b/0x44
kobject_del+0x44/0x94
blk_mq_unregister_dev+0x83/0xdd
blk_unregister_queue+0xa0/0x10b
del_gendisk+0x259/0x3fa
? disk_events_poll_msecs_store+0x12b/0x12b
? check_flags+0x1ea/0x204
? mark_held_locks+0x1f/0x7a
null_del_dev+0x8b/0x1c3 [null_blk]
null_exit+0x5c/0x95 [null_blk]
__se_sys_delete_module+0x204/0x337
? free_module+0x39f/0x39f
? blkcg_maybe_throttle_current+0x8a/0x718
? rwlock_bug+0x62/0x62
? __blkcg_punt_bio_submit+0xd0/0xd0
? trace_hardirqs_on_thunk+0x1a/0x20
? mark_held_locks+0x1f/0x7a
? do_syscall_64+0x4c/0x295
do_syscall_64+0xa7/0x295
entry_SYSCALL_64_after_hwframe+0x49/0xbe
RIP: 0033:0x7fb696cdbe6b
Code: 73 01 c3 48 8b 0d 1d 20 0c 00 f7 d8 64 89 01 48 83 c8 ff c3 66 2e 0f 1f 84 00 00 008
RSP: 002b:00007ffec9588788 EFLAGS: 00000206 ORIG_RAX: 00000000000000b0
RAX: ffffffffffffffda RBX: 0000559e589137c0 RCX: 00007fb696cdbe6b
RDX: 000000000000000a RSI: 0000000000000800 RDI: 0000559e58913828
RBP: 0000000000000000 R08: 00007ffec9587701 R09: 0000000000000000
R10: 00007fb696d4eae0 R11: 0000000000000206 R12: 00007ffec95889b0
R13: 00007ffec95896b3 R14: 0000559e58913260 R15: 0000559e589137c0--- block/blk-core.c | 1 + block/blk-mq-sysfs.c | 12 +++++------ block/blk-sysfs.c | 46 ++++++++++++++++++++++++++---------------- block/blk.h | 2 +- block/elevator.c | 46 ++++++++++++++++++++++++++++++++++-------- include/linux/blkdev.h | 1 + 6 files changed, 76 insertions(+), 32 deletions(-)
block/blk-core.c +1 -0
@@ -520,6 +520,7 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)mutex_init (&q->blk_trace_mutex);#endif mutex_init (&q->sysfs_lock); +mutex_init (&q->sysfs_dir_lock);spin_lock_init (&q->queue_lock);init_waitqueue_head (&q->mq_freeze_wq);
block/blk-mq-sysfs.c +6 -6
@@ -247,7 +247,7 @@ void blk_mq_unregister_dev(struct device *dev, struct request_queue *q)struct blk_mq_hw_ctx *hctx;int i; -lockdep_assert_held (&q->sysfs_lock); +lockdep_assert_held (&q->sysfs_dir_lock);queue_for_each_hw_ctx (q, hctx, i)blk_mq_unregister_hctx (hctx);
@@ -297,7 +297,7 @@ int __blk_mq_register_dev(struct device *dev, struct request_queue *q)int ret, i;WARN_ON_ONCE (!q->kobj.parent); -lockdep_assert_held (&q->sysfs_lock); +lockdep_assert_held (&q->sysfs_dir_lock); ret =kobject_add (q->mq_kobj,kobject_get (&dev->kobj),"%s" ,"mq" );if (ret <0 )
@@ -331,7 +331,7 @@ void blk_mq_sysfs_unregister(struct request_queue *q)struct blk_mq_hw_ctx *hctx;int i; -mutex_lock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock);if (!q->mq_sysfs_init_done) goto unlock;
@@ -339,7 +339,7 @@ void blk_mq_sysfs_unregister(struct request_queue *q)blk_mq_unregister_hctx (hctx); unlock: -mutex_unlock (&q->sysfs_lock); +mutex_unlock (&q->sysfs_dir_lock); }int blk_mq_sysfs_register (struct request_queue *q)
@@ -347,7 +347,7 @@ int blk_mq_sysfs_register(struct request_queue *q)struct blk_mq_hw_ctx *hctx;int i, ret =0 ; -mutex_lock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock);if (!q->mq_sysfs_init_done) goto unlock;
@@ -358,7 +358,7 @@ int blk_mq_sysfs_register(struct request_queue *q) } unlock: -mutex_unlock (&q->sysfs_lock); +mutex_unlock (&q->sysfs_dir_lock);return ret; }
block/blk-sysfs.c +29 -17
106 lines not on this page · raw message
block/blk.h +1 -1
@@ -188,7 +188,7 @@ int elevator_init_mq(struct request_queue *q);int elevator_switch_mq (struct request_queue *q,struct elevator_type *new_e);void __elevator_exit (struct request_queue *,struct elevator_queue *); -int elv_register_queue (struct request_queue *q); +int elv_register_queue (struct request_queue *q,bool uevent);void elv_unregister_queue (struct request_queue *q); static inline void elevator_exit(struct request_queue *q,
block/elevator.c +38 -8
92 lines not on this page · raw message
include/linux/blkdev.h +1 -0
@@ -539,6 +539,7 @@ struct request_queue {struct delayed_work requeue_work;struct mutex sysfs_lock; +struct mutex sysfs_dir_lock;/* * for reusing dead hctx instance in case of updating
Signature · 1 line
2.20.1
Re: [PATCH V2 6/6] block: split .sysfs_lock into two locks
Quoted 14 lines · Ming Lei
block/blk-mq-sysfs.c +1
-1@@ -247,7 +247,7 @@ void blk_mq_unregister_dev(struct device *dev, struct request_queue *q)struct blk_mq_hw_ctx *hctx;int i; -lockdep_assert_held (&q->sysfs_lock); +lockdep_assert_held (&q->sysfs_dir_lock);queue_for_each_hw_ctx (q, hctx, i)blk_mq_unregister_hctx (hctx);
block/blk-mq-sysfs.c int __blk_mq_register_dev(struct device *dev, struct request_queue *q) · line 303
Quoted 8 lines
block/blk-mq-sysfs.c +1
-1@@ -297,7 +297,7 @@ int __blk_mq_register_dev(struct device *dev, struct request_queue *q)int ret, i;WARN_ON_ONCE (!q->kobj.parent); -lockdep_assert_held (&q->sysfs_lock); +lockdep_assert_held (&q->sysfs_dir_lock); ret =kobject_add (q->mq_kobj,kobject_get (&dev->kobj),"%s" ,"mq" );if (ret <0 )
blk_mq_unregister_dev and __blk_mq_register_dev() are only used by blk_register_queue() and blk_unregister_queue(). It is the responsibility of the callers of these function to serialize request queue registration and unregistration. Is it really necessary to hold a mutex around the blk_mq_unregister_dev and __blk_mq_register_dev() calls? Or in other words, can it ever happen that multiple threads invoke one or both functions concurrently?
Quoted 28 lines
block/blk-mq-sysfs.c +3
-3@@ -331,7 +331,7 @@ void blk_mq_sysfs_unregister(struct request_queue *q)struct blk_mq_hw_ctx *hctx;int i; -mutex_lock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock);if (!q->mq_sysfs_init_done) goto unlock;@@ -339,7 +339,7 @@ void blk_mq_sysfs_unregister(struct request_queue *q)blk_mq_unregister_hctx (hctx); unlock: -mutex_unlock (&q->sysfs_lock); +mutex_unlock (&q->sysfs_dir_lock); }int blk_mq_sysfs_register (struct request_queue *q)@@ -347,7 +347,7 @@ int blk_mq_sysfs_register(struct request_queue *q)struct blk_mq_hw_ctx *hctx;int i, ret =0 ; -mutex_lock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock);if (!q->mq_sysfs_init_done) goto unlock;
block/blk-mq-sysfs.c int blk_mq_sysfs_register(struct request_queue *q) · line 364
Quoted 8 lines
block/blk-mq-sysfs.c +1
-1@@ -358,7 +358,7 @@ int blk_mq_sysfs_register(struct request_queue *q) } unlock: -mutex_unlock (&q->sysfs_lock); +mutex_unlock (&q->sysfs_dir_lock);return ret; }
blk_mq_sysfs_unregister() and blk_mq_sysfs_register() are only used by __blk_mq_update_nr_hw_queues(). Calls to that function are serialized by the tag_list_lock mutex. Is it really necessary to use any locking inside these functions?
Quoted 66 lines
block/blk-sysfs.c +18
-11@@ -938,6 +938,7 @@ int blk_register_queue(struct gendisk *disk)int ret;struct device *dev =disk_to_dev (disk);struct request_queue *q = disk->queue; +bool has_elevator = false;if (WARN_ON (!q))return -ENXIO ;@@ -945,7 +946,6 @@ int blk_register_queue(struct gendisk *disk)WARN_ONCE (blk_queue_registered (q),"%s is registering an already registered queue\n" ,kobject_name (&dev->kobj)); -blk_queue_flag_set (QUEUE_FLAG_REGISTERED , q);/* * SCSI probing may synchronously create and destroy a lot of @@ -966,7 +966,7 @@ int blk_register_queue(struct gendisk *disk)return ret;/* Prevent changes through sysfs until registration is completed. */ -mutex_lock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock); ret =kobject_add (&q->kobj,kobject_get (&dev->kobj),"%s" ,"queue" );if (ret <0 ) {@@ -987,26 +987,37 @@ int blk_register_queue(struct gendisk *disk)blk_mq_debugfs_register (q); } -kobject_uevent (&q->kobj,KOBJ_ADD ); - -wbt_enable_default (q); - -blk_throtl_register_queue (q); - +/* +* The queue's kobject ADD uevent isn't sent out, also the +* flag of QUEUE_FLAG_REGISTERED isn't set yet, so elevator +* switch won't happen at all. +*/ if (q->elevator) { - ret =elv_register_queue (q); + ret =elv_register_queue (q, false);if (ret) { -mutex_unlock (&q->sysfs_lock); -kobject_uevent (&q->kobj,KOBJ_REMOVE ); +mutex_unlock (&q->sysfs_dir_lock);kobject_del (&q->kobj);blk_trace_remove_sysfs (dev);kobject_put (&dev->kobj);return ret; } + has_elevator = true; } + +mutex_lock (&q->sysfs_lock); +blk_queue_flag_set (QUEUE_FLAG_REGISTERED , q); +wbt_enable_default (q); +blk_throtl_register_queue (q); +mutex_unlock (&q->sysfs_lock); + +/* Now everything is ready and send out KOBJ_ADD uevent */
block/blk-sysfs.c int blk_register_queue(struct gendisk *disk) · line 1022
Quoted 10 lines
block/blk-sysfs.c +5
-1+kobject_uevent (&q->kobj,KOBJ_ADD ); +if (has_elevator) +kobject_uevent (&q->elevator->kobj,KOBJ_ADD ); + ret =0 ; unlock: -mutex_unlock (&q->sysfs_lock); +mutex_unlock (&q->sysfs_dir_lock);return ret; }
My understanding is that the mutex_lock() / mutex_unlock() calls in this function are necessary today to prevent concurrent changes of the scheduler from this function and from sysfs. If the kobject_uevent(KOBJ_ADD) call is moved, does that mean that all mutex_lock() / mutex_unlock() calls can be left out from this function?
Quoted 30 lines
block/blk-sysfs.c +4
-2EXPORT_SYMBOL_GPL (blk_register_queue);@@ -1021,6 +1032,7 @@ EXPORT_SYMBOL_GPL(blk_register_queue);void blk_unregister_queue (struct gendisk *disk) {struct request_queue *q = disk->queue; +bool has_elevator;if (WARN_ON (!q))return ;@@ -1035,25 +1047,25 @@ void blk_unregister_queue(struct gendisk *disk)* concurrent elv_iosched_store() calls. */ mutex_lock (&q->sysfs_lock); -blk_queue_flag_clear (QUEUE_FLAG_REGISTERED , q); + has_elevator = !!q->elevator; +mutex_unlock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock);/* * Remove the sysfs attributes before unregistering the queue data * structures that can be modified through sysfs. */ if (queue_is_mq (q))blk_mq_unregister_dev (disk_to_dev (disk), q); -mutex_unlock (&q->sysfs_lock);kobject_uevent (&q->kobj,KOBJ_REMOVE );kobject_del (&q->kobj);blk_trace_remove_sysfs (disk_to_dev (disk));
block/blk-sysfs.c void blk_unregister_queue(struct gendisk *disk) · line 1071
Quoted 10 lines
block/blk-sysfs.c +2
-3-mutex_lock (&q->sysfs_lock); -if (q->elevator) +if (has_elevator)elv_unregister_queue (q); -mutex_unlock (&q->sysfs_lock); +mutex_unlock (&q->sysfs_dir_lock);kobject_put (&disk_to_dev (disk)->kobj); }
If this function would call kobject_del(&q->kobj) before doing anything else, does that mean that all mutex_lock() / mutex_unlock() calls can be left out from this function?
Thanks,
Bart.
Re: [PATCH V2 6/6] block: split .sysfs_lock into two locks
Quoted 20 lines · Bart Van Assche
Quoted 12 lines · Ming Lei
block/blk-mq-sysfs.c +1
-1@@ -247,7 +247,7 @@ void blk_mq_unregister_dev(struct device *dev, struct request_queue *q)struct blk_mq_hw_ctx *hctx;int i; -lockdep_assert_held (&q->sysfs_lock); +lockdep_assert_held (&q->sysfs_dir_lock);queue_for_each_hw_ctx (q, hctx, i)blk_mq_unregister_hctx (hctx);block/blk-mq-sysfs.c int __blk_mq_register_dev(struct device *dev, struct request_queue *q) · line 301
Quoted 6 lines
block/blk-mq-sysfs.c +1
-1@@ -297,7 +297,7 @@ int __blk_mq_register_dev(struct device *dev, struct request_queue *q)int ret, i;WARN_ON_ONCE (!q->kobj.parent); -lockdep_assert_held (&q->sysfs_lock); +lockdep_assert_held (&q->sysfs_dir_lock); ret =kobject_add (q->mq_kobj,kobject_get (&dev->kobj),"%s" ,"mq" );if (ret <0 )
Quoted 7 lines
blk_mq_unregister_devand__blk_mq_register_dev()are only used byblk_register_queue()andblk_unregister_queue(). It is the responsibility of the callers of these function to serialize request queue registration and unregistration. Is it really necessary to hold a mutex around theblk_mq_unregister_devand__blk_mq_register_dev()calls? Or in other words, can it ever happen that multiple threads invoke one or both functions concurrently?
hctx kobjects can be removed and re-added via blk_mq_update_nr_hw_queues() which may be called at the same time when queue is registering or un-registering.
Also the change can be simpler to use a new lock to replace the old one.
Quoted 26 lines
Quoted 26 lines
block/blk-mq-sysfs.c +3
-4@@ -331,7 +331,7 @@ void blk_mq_sysfs_unregister(struct request_queue *q)struct blk_mq_hw_ctx *hctx;int i; -mutex_lock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock);if (!q->mq_sysfs_init_done) goto unlock;@@ -339,7 +339,7 @@ void blk_mq_sysfs_unregister(struct request_queue *q)blk_mq_unregister_hctx (hctx); unlock: -mutex_unlock (&q->sysfs_lock); +mutex_unlock (&q->sysfs_dir_lock); }int blk_mq_sysfs_register (struct request_queue *q)@@ -347,7 +347,7 @@ int blk_mq_sysfs_register(struct request_queue *q)struct blk_mq_hw_ctx *hctx;int i, ret =0 ; -mutex_lock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock);if (!q->mq_sysfs_init_done) goto unlock;@@ -358,7 +358,7 @@ int blk_mq_sysfs_register(struct request_queue *q) } unlock: -mutex_unlock (&q->sysfs_lock);
Quoted 8 lines
block/blk-mq-sysfs.c int blk_mq_sysfs_register(struct request_queue *q) · line 364
Quoted 3 lines
block/blk-mq-sysfs.c +1
-0+mutex_unlock (&q->sysfs_dir_lock);return ret; }
blk_mq_sysfs_unregister()andblk_mq_sysfs_register()are only used by__blk_mq_update_nr_hw_queues(). Calls to that function are serialized by thetag_list_lockmutex. Is it really necessary to use any locking inside these functions?
hctx kobjects can be removed and re-added via blk_mq_update_nr_hw_queues() which may be called at the same time when queue is registering or un-registering.
Also the change can be simpler to use a new lock to replace the old one.
Quoted 70 lines
Quoted 70 lines
block/blk-sysfs.c +23
-12@@ -938,6 +938,7 @@ int blk_register_queue(struct gendisk *disk)int ret;struct device *dev =disk_to_dev (disk);struct request_queue *q = disk->queue; +bool has_elevator = false;if (WARN_ON (!q))return -ENXIO ;@@ -945,7 +946,6 @@ int blk_register_queue(struct gendisk *disk)WARN_ONCE (blk_queue_registered (q),"%s is registering an already registered queue\n" ,kobject_name (&dev->kobj)); -blk_queue_flag_set (QUEUE_FLAG_REGISTERED , q);/* * SCSI probing may synchronously create and destroy a lot of @@ -966,7 +966,7 @@ int blk_register_queue(struct gendisk *disk)return ret;/* Prevent changes through sysfs until registration is completed. */ -mutex_lock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock); ret =kobject_add (&q->kobj,kobject_get (&dev->kobj),"%s" ,"queue" );if (ret <0 ) {@@ -987,26 +987,37 @@ int blk_register_queue(struct gendisk *disk)blk_mq_debugfs_register (q); } -kobject_uevent (&q->kobj,KOBJ_ADD ); - -wbt_enable_default (q); - -blk_throtl_register_queue (q); - +/* +* The queue's kobject ADD uevent isn't sent out, also the +* flag of QUEUE_FLAG_REGISTERED isn't set yet, so elevator +* switch won't happen at all. +*/ if (q->elevator) { - ret =elv_register_queue (q); + ret =elv_register_queue (q, false);if (ret) { -mutex_unlock (&q->sysfs_lock); -kobject_uevent (&q->kobj,KOBJ_REMOVE ); +mutex_unlock (&q->sysfs_dir_lock);kobject_del (&q->kobj);blk_trace_remove_sysfs (dev);kobject_put (&dev->kobj);return ret; } + has_elevator = true; } + +mutex_lock (&q->sysfs_lock); +blk_queue_flag_set (QUEUE_FLAG_REGISTERED , q); +wbt_enable_default (q); +blk_throtl_register_queue (q); +mutex_unlock (&q->sysfs_lock); + +/* Now everything is ready and send out KOBJ_ADD uevent */ +kobject_uevent (&q->kobj,KOBJ_ADD ); +if (has_elevator) +kobject_uevent (&q->elevator->kobj,KOBJ_ADD ); + ret =0 ; unlock: -mutex_unlock (&q->sysfs_lock); +mutex_unlock (&q->sysfs_dir_lock);
Quoted 8 lines
block/blk-sysfs.c int blk_register_queue(struct gendisk *disk) · line 1021
Quoted 2 lines
block/blk-sysfs.c +0
-0return ret; }My understanding is that the
mutex_lock()/mutex_unlock()calls in this function are necessary today to prevent concurrent changes of the scheduler from this function and from sysfs. If thekobject_uevent(KOBJ_ADD)call is moved, does that mean that allmutex_lock()/mutex_unlock()calls can be left out from this function?
hctx kobjects can be removed and re-added via blk_mq_update_nr_hw_queues() which may be called at the same time when queue is registering or un-registering.
Also the change can be simpler to use a new lock to replace the old one.
Quoted 32 lines
Quoted 32 lines
block/blk-sysfs.c +5
-4EXPORT_SYMBOL_GPL (blk_register_queue);@@ -1021,6 +1032,7 @@ EXPORT_SYMBOL_GPL(blk_register_queue);void blk_unregister_queue (struct gendisk *disk) {struct request_queue *q = disk->queue; +bool has_elevator;if (WARN_ON (!q))return ;@@ -1035,25 +1047,25 @@ void blk_unregister_queue(struct gendisk *disk)* concurrent elv_iosched_store() calls. */ mutex_lock (&q->sysfs_lock); -blk_queue_flag_clear (QUEUE_FLAG_REGISTERED , q); + has_elevator = !!q->elevator; +mutex_unlock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock);/* * Remove the sysfs attributes before unregistering the queue data * structures that can be modified through sysfs. */ if (queue_is_mq (q))blk_mq_unregister_dev (disk_to_dev (disk), q); -mutex_unlock (&q->sysfs_lock);kobject_uevent (&q->kobj,KOBJ_REMOVE );kobject_del (&q->kobj);blk_trace_remove_sysfs (disk_to_dev (disk)); -mutex_lock (&q->sysfs_lock); -if (q->elevator) +if (has_elevator)elv_unregister_queue (q);
Quoted 8 lines
block/blk-sysfs.c void blk_unregister_queue(struct gendisk *disk) · line 1071
Quoted 4 lines
block/blk-sysfs.c +1
-1-mutex_unlock (&q->sysfs_lock); +mutex_unlock (&q->sysfs_dir_lock);kobject_put (&disk_to_dev (disk)->kobj); }If this function would call
kobject_del(&q->kobj)before doing anything else, does that mean that allmutex_lock()/mutex_unlock()calls can be left out from this function?
As I mentioned above, we need to sync between registering/un-registering queue and updating nr_hw_queues, so the lock of sysfs_dir_lock is needed.
Thanks,
Ming
Re: [PATCH V2 6/6] block: split .sysfs_lock into two locks
Quoted 29 lines · Ming Lei
Quoted 20 lines · Bart Van Assche
Quoted 12 lines · Ming Lei
block/blk-mq-sysfs.c +1
-1@@ -247,7 +247,7 @@ void blk_mq_unregister_dev(struct device *dev, struct request_queue *q)struct blk_mq_hw_ctx *hctx;int i; -lockdep_assert_held (&q->sysfs_lock); +lockdep_assert_held (&q->sysfs_dir_lock);queue_for_each_hw_ctx (q, hctx, i)blk_mq_unregister_hctx (hctx);block/blk-mq-sysfs.c int __blk_mq_register_dev(struct device *dev, struct request_queue *q) · line 301
Quoted 6 lines
block/blk-mq-sysfs.c +1
-1@@ -297,7 +297,7 @@ int __blk_mq_register_dev(struct device *dev, struct request_queue *q)int ret, i;WARN_ON_ONCE (!q->kobj.parent); -lockdep_assert_held (&q->sysfs_lock); +lockdep_assert_held (&q->sysfs_dir_lock); ret =kobject_add (q->mq_kobj,kobject_get (&dev->kobj),"%s" ,"mq" );if (ret <0 )Quoted 7 lines
blk_mq_unregister_devand__blk_mq_register_dev()are only used byblk_register_queue()andblk_unregister_queue(). It is the responsibility of the callers of these function to serialize request queue registration and unregistration. Is it really necessary to hold a mutex around theblk_mq_unregister_devand__blk_mq_register_dev()calls? Or in other words, can it ever happen that multiple threads invoke one or both functions concurrently?
Quoted 3 lines
hctx kobjects can be removed and re-added via
blk_mq_update_nr_hw_queues()which may be called at the same time when queue is registering or un-registering.
Shouldn't blk_register_queue() and blk_unregister_queue() be serialized against blk_mq_update_nr_hw_queues()? Allowing these calls to proceed concurrently complicates the block layer and makes the block layer code harder to review than necessary. I don't think that it would help any block driver to allow these calls to proceed concurrently.
Thanks,
Bart.
Re: [PATCH V2 6/6] block: split .sysfs_lock into two locks
Quoted 30 lines · Bart Van Assche
Quoted 29 lines · Ming Lei
Quoted 27 lines · Bart Van Assche
Quoted 12 lines · Ming Lei
block/blk-mq-sysfs.c +1
-1@@ -247,7 +247,7 @@ void blk_mq_unregister_dev(struct device *dev, struct request_queue *q)struct blk_mq_hw_ctx *hctx;int i; -lockdep_assert_held (&q->sysfs_lock); +lockdep_assert_held (&q->sysfs_dir_lock);queue_for_each_hw_ctx (q, hctx, i)blk_mq_unregister_hctx (hctx);block/blk-mq-sysfs.c int __blk_mq_register_dev(struct device *dev, struct request_queue *q) · line 301
Quoted 6 lines
block/blk-mq-sysfs.c +1
-1@@ -297,7 +297,7 @@ int __blk_mq_register_dev(struct device *dev, struct request_queue *q)int ret, i;WARN_ON_ONCE (!q->kobj.parent); -lockdep_assert_held (&q->sysfs_lock); +lockdep_assert_held (&q->sysfs_dir_lock); ret =kobject_add (q->mq_kobj,kobject_get (&dev->kobj),"%s" ,"mq" );if (ret <0 )
blk_mq_unregister_devand__blk_mq_register_dev()are only used byblk_register_queue()andblk_unregister_queue(). It is the responsibility of the callers of these function to serialize request queue registration and unregistration. Is it really necessary to hold a mutex around theblk_mq_unregister_devand__blk_mq_register_dev()calls? Or in other words, can it ever happen that multiple threads invoke one or both functions concurrently?
Quoted 6 lines
Quoted 3 lines
hctx kobjects can be removed and re-added via
blk_mq_update_nr_hw_queues()which may be called at the same time when queue is registering or un-registering.Shouldn't
blk_register_queue()andblk_unregister_queue()be serialized againstblk_mq_update_nr_hw_queues()? Allowing these calls to proceed
It can be easy to say than done. We depends on users for sync between blk_register_queue() and blk_unregister_queue(), also there are several locks involved in blk_mq_update_nr_hw_queues().
Now, the sync is done via .sysfs_lock, and so far not see issues in this area. This patch just converts the .sysfs_lock into .sysfs_dir_lock for same purpose.
If you have simple and workable patch to serialize blk_register_queue() and blk_unregister_queue() against blk_mq_update_nr_hw_queues(), I am happy to review. Otherwise please consider to do it in future, and it shouldn't a blocker for fixing this deadlock, should it?
Thanks,
Ming
Re: [PATCH V2 6/6] block: split .sysfs_lock into two locks
Quoted 8 lines · Ming Lei
Quoted 2 lines · Bart Van Assche
Shouldn't
blk_register_queue()andblk_unregister_queue()be serialized againstblk_mq_update_nr_hw_queues()? Allowing these calls to proceedIt can be easy to say than done. We depends on users for sync between
blk_register_queue()andblk_unregister_queue(), also there are several locks involved inblk_mq_update_nr_hw_queues().
Quoted 8 lines
Now, the sync is done via .sysfs_lock, and so far not see issues in this area. This patch just converts the .sysfs_lock into .sysfs_dir_lock for same purpose.
If you have simple and workable patch to serialize
blk_register_queue()andblk_unregister_queue()againstblk_mq_update_nr_hw_queues(), I am happy to review. Otherwise please consider to do it in future, and it shouldn't a blocker for fixing this deadlock, should it?
Since what I requested would result in serialization across request queues of I/O scheduler changes, let's keep this for a later time.
Bart.
Re: [PATCH V2 6/6] block: split .sysfs_lock into two locks
In reply to Ming LeiQuoted 18 lines · Ming Lei
block/blk-sysfs.c +1
-6@@ -966,7 +966,7 @@ int blk_register_queue(struct gendisk *disk)return ret;/* Prevent changes through sysfs until registration is completed. */ -mutex_lock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock); ret =kobject_add (&q->kobj,kobject_get (&dev->kobj),"%s" ,"queue" );if (ret <0 ) {@@ -987,26 +987,37 @@ int blk_register_queue(struct gendisk *disk)blk_mq_debugfs_register (q); } -kobject_uevent (&q->kobj,KOBJ_ADD ); - -wbt_enable_default (q); - -blk_throtl_register_queue (q);
block/blk-sysfs.c int blk_register_queue(struct gendisk *disk) · line 997
Quoted 10 lines
block/blk-sysfs.c +6
-2- +/* +* The queue's kobject ADD uevent isn't sent out, also the +* flag of QUEUE_FLAG_REGISTERED isn't set yet, so elevator +* switch won't happen at all. +*/ if (q->elevator) { - ret =elv_register_queue (q); + ret =elv_register_queue (q, false);if (ret) {
The above changes seems risky to me. In contrast with what the comment suggests, user space code is not required to wait for KOBJ_ADD event to start using sysfs attributes. I think user space code *can* write into the request queue I/O scheduler sysfs attribute after the kobject_add() call has finished and before kobject_uevent(&q->kobj, KOBJ_ADD) is called.
Bart.
Re: [PATCH V2 6/6] block: split .sysfs_lock into two locks
Quoted 24 lines · Bart Van Assche
Quoted 23 lines · Ming Lei
block/blk-sysfs.c +6
-8@@ -966,7 +966,7 @@ int blk_register_queue(struct gendisk *disk)return ret;/* Prevent changes through sysfs until registration is completed. */ -mutex_lock (&q->sysfs_lock); +mutex_lock (&q->sysfs_dir_lock); ret =kobject_add (&q->kobj,kobject_get (&dev->kobj),"%s" ,"queue" );if (ret <0 ) {@@ -987,26 +987,37 @@ int blk_register_queue(struct gendisk *disk)blk_mq_debugfs_register (q); } -kobject_uevent (&q->kobj,KOBJ_ADD ); - -wbt_enable_default (q); - -blk_throtl_register_queue (q); - +/* +* The queue's kobject ADD uevent isn't sent out, also the +* flag of QUEUE_FLAG_REGISTERED isn't set yet, so elevator +* switch won't happen at all. +*/ if (q->elevator) { - ret =elv_register_queue (q);
Quoted 8 lines
block/blk-sysfs.c int blk_register_queue(struct gendisk *disk) · line 997
Quoted 2 lines
block/blk-sysfs.c +1
-0+ ret =elv_register_queue (q, false);if (ret) {The above changes seems risky to me. In contrast with what the comment suggests, user space code is not required to wait for
KOBJ_ADDevent to start using sysfs attributes. I think user space code *can* write into the request queue I/O scheduler sysfs attribute after thekobject_add()call has finished and beforekobject_uevent(&q->kobj, KOBJ_ADD)is called.
Yeah, one crazy userspace may simply poll on sysfs entres and start to READ/WRITE before seeing the KOBJ_ADD event.
However, we have another protection via the queue flag QUEUE_FLAG_REGISTERED, which is set after everything is done. So if userspace's early store comes, elevator switch still can't happen because the flag is checked in __elevator_change().
thanks,
Ming