block: remove q->sysfs_dir_lock and fix race updating nr_hw_queue
v3 cover block: remove q->sysfs_dir_lock and fix race updating nr_hw_queue
Hi,
There're two patches in this patchest.
The first patch removes redundant q->sysfs_dir_lock.
The second patch fixes nr_hw_queue update racing with disk addition/ removal.
In the current implementation we use q->sysfs_dir_lock for protecting kobject addition/deletion while we register/unregister blk-mq with sysfs. However the sysfs/kernfs internal implementation already protects against the simultaneous addtion/deletion of kobjects. So in that sense use of q->sysfs_dir_lock appears redundant.
Furthermore, there're few other callsites in the current code where we use q->sysfs_dir_lock along with q->sysfs_lock while addition/deletion of independent access ranges for a disk under sysfs. Please refer, disk_ register_independent_access_ranges() and disk_unregister_independent_ access_ranges(). Here as well we could easily remove use of q->sysfs_dir_ lock.
The only thing which q->syfs_dir_lock appears to protect is the use of variable q->mq_sysfs_init_done. However this could be solved by converting q->mq_sysfs_init_done to an atomic variable.
In past few days, we have seen many lockdep splat in block layer and getting rid of this one might help reduce some contention as well we need to worry less about lock ordering wrt to q->sysfs_dir_lock. The first patch helps fix this.
The second patch addresses a potential race between nr_hw_queue update and disk addition/removal. The __blk_mq_update_nr_hw_queues function removes and then adds hctx sysfs files. Similarly the disk addition/ removal code also adds or remove the hctx sysfs files. So it's quite possible that disk addition/removal code could race with __blk_mq_update_ nr_hw_queues() while it adds/deletes hctx sysfs files. Apparently, __blk_mq_update_nr_hw_queues() holds q->tag_list_lock while it runs, and so to avoid race between __blk_mq_update_nr_hw_queues() and disk addition/removal code, we should hold the same q->tag_list_lock while we add/delete hctx sysfs files while registering/uregistering disk queue. So the second patch in the series helps fix this race condition which may manifests while we add/remove hctx sysfs files.
I ran blktests and xfstests with lockdep configured to ensure that above changes don't generate lockdep spalt.
Nilay Shroff (2):
block: get rid of request queue ->sysfs_dir_lock
block: fix nr_hw_queue update racing with disk addition/removal
Changes from v2:
- few nitpicking fixes in the second patch (hch)
- Link to v2: https://lore.kernel.org/all/[email protected]/
Changes from v1:
- remove q->sysfs_init_done and replace it with registered queue
flag (hch)
- fix nr_hw_queue update racing with disk addition/removal (hch)
- Link to v1: https://lore.kernel.org/all/[email protected]/
Nilay Shroff (2):
block: get rid of request queue ->sysfs_dir_lock
block: fix nr_hw_queue update racing with disk addition/removal
block/blk-core.c | 1 - block/blk-ia-ranges.c | 4 ---- block/blk-mq-sysfs.c | 40 ++++++++++++++-------------------------- block/blk-sysfs.c | 5 ----- include/linux/blkdev.h | 3 --- 5 files changed, 14 insertions(+), 39 deletions(-)
Signature · 1 line
2.47.1
RFC PATCH v3 1/2 block: get rid of request queue ->sysfs_dir_lock
The request queue uses ->sysfs_dir_lock for protecting the addition/ deletion of kobject entries under sysfs while we register/unregister blk-mq. However kobject addition/deletion is already protected with kernfs/sysfs internal synchronization primitives. So use of q->sysfs_ dir_lock seems redundant.
Moreover, q->sysfs_dir_lock is also used at few other callsites along with q->sysfs_lock for protecting the addition/deletion of kojects. One such example is when we register with sysfs a set of independent access ranges for a disk. Here as well we could get rid off q->sysfs_ dir_lock and only use q->sysfs_lock.
The only variable which q->sysfs_dir_lock appears to protect is q-> mq_sysfs_init_done which is set/unset while registering/unregistering blk-mq with sysfs. But use of q->mq_sysfs_init_done could be easily replaced using queue registered bit QUEUE_FLAG_REGISTERED.
So with this patch we remove q->sysfs_dir_lock from each callsite and replace q->mq_sysfs_init_done using QUEUE_FLAG_REGISTERED.
--- block/blk-core.c | 1 - block/blk-ia-ranges.c | 4 ---- block/blk-mq-sysfs.c | 23 +++++------------------ block/blk-sysfs.c | 5 ----- include/linux/blkdev.h | 3 --- 5 files changed, 5 insertions(+), 31 deletions(-)
block/blk-core.c +0 -1
@@ -430,7 +430,6 @@ struct request_queue *blk_alloc_queue(struct queue_limits *lim, int node_id)refcount_set (&q->refs,1 );mutex_init (&q->debugfs_mutex);mutex_init (&q->sysfs_lock); -mutex_init (&q->sysfs_dir_lock);mutex_init (&q->limits_lock);mutex_init (&q->rq_qos_mutex);spin_lock_init (&q->queue_lock);
block/blk-ia-ranges.c +0 -4
@@ -111,7 +111,6 @@ int disk_register_independent_access_ranges(struct gendisk *disk)struct request_queue *q = disk->queue;int i, ret; -lockdep_assert_held (&q->sysfs_dir_lock);lockdep_assert_held (&q->sysfs_lock);if (!iars)
@@ -155,7 +154,6 @@ void disk_unregister_independent_access_ranges(struct gendisk *disk)struct blk_independent_access_ranges *iars = disk->ia_ranges;int i; -lockdep_assert_held (&q->sysfs_dir_lock);lockdep_assert_held (&q->sysfs_lock);if (!iars)
@@ -289,7 +287,6 @@ void disk_set_independent_access_ranges(struct gendisk *disk, {struct request_queue *q = disk->queue; -mutex_lock (&q->sysfs_dir_lock);mutex_lock (&q->sysfs_lock);if (iars && !disk_check_ia_ranges (disk, iars)) {kfree (iars);
@@ -313,6 +310,5 @@ void disk_set_independent_access_ranges(struct gendisk *disk,disk_register_independent_access_ranges (disk); unlock:mutex_unlock (&q->sysfs_lock); -mutex_unlock (&q->sysfs_dir_lock); }EXPORT_SYMBOL_GPL (disk_set_independent_access_ranges);
block/blk-mq-sysfs.c +5 -18
@@ -223,8 +223,6 @@ int blk_mq_sysfs_register(struct gendisk *disk)unsigned long i, j;int ret; -lockdep_assert_held (&q->sysfs_dir_lock); - ret =kobject_add (q->mq_kobj, &disk_to_dev (disk)->kobj,"mq" );if (ret <0 ) goto out;
@@ -237,7 +235,6 @@ int blk_mq_sysfs_register(struct gendisk *disk) goto unreg; } - q->mq_sysfs_init_done = true; out:return ret;
@@ -259,15 +256,12 @@ void blk_mq_sysfs_unregister(struct gendisk *disk)struct blk_mq_hw_ctx *hctx;unsigned long i; -lockdep_assert_held (&q->sysfs_dir_lock);queue_for_each_hw_ctx (q, hctx, i)blk_mq_unregister_hctx (hctx);kobject_uevent (q->mq_kobj,KOBJ_REMOVE );kobject_del (q->mq_kobj); - - q->mq_sysfs_init_done = false; }void blk_mq_sysfs_unregister_hctxs (struct request_queue *q)
@@ -275,15 +269,11 @@ void blk_mq_sysfs_unregister_hctxs(struct request_queue *q)struct blk_mq_hw_ctx *hctx;unsigned long i; -mutex_lock (&q->sysfs_dir_lock); -if (!q->mq_sysfs_init_done) - goto unlock; +if (!blk_queue_registered (q)) +return ;queue_for_each_hw_ctx (q, hctx, i)blk_mq_unregister_hctx (hctx); - -unlock: -mutex_unlock (&q->sysfs_dir_lock); }int blk_mq_sysfs_register_hctxs (struct request_queue *q)
@@ -292,9 +282,8 @@ int blk_mq_sysfs_register_hctxs(struct request_queue *q)unsigned long i;int ret =0 ; -mutex_lock (&q->sysfs_dir_lock); -if (!q->mq_sysfs_init_done) - goto unlock; +if (!blk_queue_registered (q)) + goto out;queue_for_each_hw_ctx (q, hctx, i) { ret =blk_mq_register_hctx (hctx);
@@ -302,8 +291,6 @@ int blk_mq_sysfs_register_hctxs(struct request_queue *q)break ; } -unlock: -mutex_unlock (&q->sysfs_dir_lock); - +out:return ret; }
block/blk-sysfs.c +0 -5
@@ -764,7 +764,6 @@ int blk_register_queue(struct gendisk *disk)struct request_queue *q = disk->queue;int ret; -mutex_lock (&q->sysfs_dir_lock);kobject_init (&disk->queue_kobj, &blk_queue_ktype); ret =kobject_add (&disk->queue_kobj, &disk_to_dev (disk)->kobj,"queue" );if (ret <0 )
@@ -805,7 +804,6 @@ int blk_register_queue(struct gendisk *disk)if (q->elevator)kobject_uevent (&q->elevator->kobj,KOBJ_ADD );mutex_unlock (&q->sysfs_lock); -mutex_unlock (&q->sysfs_dir_lock);/* * SCSI probing may synchronously create and destroy a lot of
@@ -830,7 +828,6 @@ int blk_register_queue(struct gendisk *disk)mutex_unlock (&q->sysfs_lock); out_put_queue_kobj:kobject_put (&disk->queue_kobj); -mutex_unlock (&q->sysfs_dir_lock);return ret; }
@@ -861,7 +858,6 @@ void blk_unregister_queue(struct gendisk *disk)blk_queue_flag_clear (QUEUE_FLAG_REGISTERED , q);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.
@@ -878,7 +874,6 @@ void blk_unregister_queue(struct gendisk *disk)/* Now that we've deleted all child objects, we can delete the queue. */ kobject_uevent (&disk->queue_kobj,KOBJ_REMOVE );kobject_del (&disk->queue_kobj); -mutex_unlock (&q->sysfs_dir_lock);blk_debugfs_remove (disk); }
include/linux/blkdev.h +0 -3
@@ -561,7 +561,6 @@ struct request_queue {struct list_head flush_list;struct mutex sysfs_lock; -struct mutex sysfs_dir_lock;struct mutex limits_lock;/*
@@ -605,8 +604,6 @@ struct request_queue {* Serializes all debugfs metadata operations using the above dentries. */ struct mutex debugfs_mutex; - -bool mq_sysfs_init_done; };/* Keep blk_queue_flag_name[] in sync with the definitions below */
Signature · 1 line
2.47.1
Re: [RFC PATCHv3 1/2] block: get rid of request queue ->sysfs_dir_lock
Quoted 22 lines · Nilay Shroff
The request queue uses ->sysfs_dir_lock for protecting the addition/ deletion of kobject entries under sysfs while we register/unregister blk-mq. However kobject addition/deletion is already protected with kernfs/sysfs internal synchronization primitives. So use of
q->sysfs_dir_lockseems redundant.Moreover,
q->sysfs_dir_lockis also used at few other callsites along withq->sysfs_lockfor protecting the addition/deletion of kojects. One such example is when we register with sysfs a set of independent access ranges for a disk. Here as well we could get rid offq->sysfs_dir_lockand only useq->sysfs_lock.The only variable which
q->sysfs_dir_lockappears to protect is q->mq_sysfs_init_donewhich is set/unset while registering/unregistering blk-mq with sysfs. But use ofq->mq_sysfs_init_donecould be easily replaced using queue registered bitQUEUE_FLAG_REGISTERED.So with this patch we remove
q->sysfs_dir_lockfrom each callsite and replaceq->mq_sysfs_init_doneusingQUEUE_FLAG_REGISTERED.Reviewed-by Christoph Hellwig <[email protected]>Signed-off-by Nilay Shroff <[email protected]>
Quoted 8 lines
--- block/blk-core.c | 1 - block/blk-ia-ranges.c | 4 ---- block/blk-mq-sysfs.c | 23 +++++------------------ block/blk-sysfs.c | 5 ----- include/linux/blkdev.h | 3 --- 5 files changed, 5 insertions(+), 31 deletions(-)
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Frankenstr. 146, 90461 Nürnberg HRB 36809 (AG Nürnberg), GF: I. Totev, A. McDonald, W. Knoblich
RFC PATCH v3 2/2 block: fix nr_hw_queue update racing with disk addition/removal
In reply to Nilay ShroffThe nr_hw_queue update could potentially race with disk addtion/removal while registering/unregistering hctx sysfs files. The __blk_mq_update_ nr_hw_queues() runs with q->tag_list_lock held and so to avoid it racing with disk addition/removal we should acquire q->tag_list_lock while registering/unregistering hctx sysfs files.
With this patch, blk_mq_sysfs_register() (called during disk addition) and blk_mq_sysfs_unregister() (called during disk removal) now runs with q->tag_list_lock held so that it avoids racing with __blk_mq_update _nr_hw_queues().
--- block/blk-mq-sysfs.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-)
block/blk-mq-sysfs.c +9 -8
@@ -225,25 +225,25 @@ int blk_mq_sysfs_register(struct gendisk *disk) ret =kobject_add (q->mq_kobj, &disk_to_dev (disk)->kobj,"mq" );if (ret <0 ) - goto out; +return ret;kobject_uevent (q->mq_kobj,KOBJ_ADD ); +mutex_lock (&q->tag_set->tag_list_lock);queue_for_each_hw_ctx (q, hctx, i) { ret =blk_mq_register_hctx (hctx);if (ret) - goto unreg; + goto out_unreg; } +mutex_unlock (&q->tag_set->tag_list_lock); +return 0 ; - -out: -return ret; - -unreg: +out_unreg:queue_for_each_hw_ctx (q, hctx, j) {if (j < i)blk_mq_unregister_hctx (hctx); } +mutex_unlock (&q->tag_set->tag_list_lock);kobject_uevent (q->mq_kobj,KOBJ_REMOVE );kobject_del (q->mq_kobj);
@@ -256,9 +256,10 @@ void blk_mq_sysfs_unregister(struct gendisk *disk)struct blk_mq_hw_ctx *hctx;unsigned long i; - +mutex_lock (&q->tag_set->tag_list_lock);queue_for_each_hw_ctx (q, hctx, i)blk_mq_unregister_hctx (hctx); +mutex_unlock (&q->tag_set->tag_list_lock);kobject_uevent (q->mq_kobj,KOBJ_REMOVE );kobject_del (q->mq_kobj);
Signature · 1 line
2.47.1
Re: [RFC PATCHv3 2/2] block: fix nr_hw_queue update racing with disk addition/removal
Looks good:
Re: [RFC PATCHv3 2/2] block: fix nr_hw_queue update racing with disk addition/removal
In reply to Nilay ShroffQuoted 21 lines · Nilay Shroff
The
nr_hw_queueupdate could potentially race with disk addtion/removal while registering/unregistering hctx sysfs files. The__blk_mq_update_nr_hw_queues()runs withq->tag_list_lockheld and so to avoid it racing with disk addition/removal we should acquireq->tag_list_lockwhile registering/unregistering hctx sysfs files.With this patch,
blk_mq_sysfs_register()(called during disk addition) andblk_mq_sysfs_unregister()(called during disk removal) now runs withq->tag_list_lockheld so that it avoids racing with__blk_mq_update_nr_hw_queues().Signed-off-by Nilay Shroff <[email protected]>--- block/blk-mq-sysfs.c | 17 +++++++++-------- 1 file changed, 9 insertions(+), 8 deletions(-)block/blk-mq-sysfs.c +0
-0
block/blk-mq-sysfs.c int blk_mq_sysfs_register(struct gendisk *disk) · line 232
Quoted 9 lines
block/blk-mq-sysfs.c +2
-1@@ -225,25 +225,25 @@ int blk_mq_sysfs_register(struct gendisk *disk) ret =kobject_add (q->mq_kobj, &disk_to_dev (disk)->kobj,"mq" );if (ret <0 ) - goto out; +return ret;kobject_uevent (q->mq_kobj,KOBJ_ADD ); +mutex_lock (&q->tag_set->tag_list_lock);
Maybe a comment here to indicate that it prevents a race?
Quoted 24 lines
block/blk-mq-sysfs.c +5
-6queue_for_each_hw_ctx (q, hctx, i) { ret =blk_mq_register_hctx (hctx);if (ret) - goto unreg; + goto out_unreg; } +mutex_unlock (&q->tag_set->tag_list_lock); +return 0 ; - -out: -return ret; - -unreg: +out_unreg:queue_for_each_hw_ctx (q, hctx, j) {if (j < i)blk_mq_unregister_hctx (hctx); } +mutex_unlock (&q->tag_set->tag_list_lock);kobject_uevent (q->mq_kobj,KOBJ_REMOVE );kobject_del (q->mq_kobj);
block/blk-mq-sysfs.c void blk_mq_sysfs_unregister(struct gendisk *disk) · line 259
Quoted 5 lines
block/blk-mq-sysfs.c +1
-1@@ -256,9 +256,10 @@ void blk_mq_sysfs_unregister(struct gendisk *disk)struct blk_mq_hw_ctx *hctx;unsigned long i; - +mutex_lock (&q->tag_set->tag_list_lock);
Similar here.
block/blk-mq-sysfs.c void blk_mq_sysfs_unregister(struct gendisk *disk) · line 265
Quoted 6 lines
block/blk-mq-sysfs.c +1
-0queue_for_each_hw_ctx (q, hctx, i)blk_mq_unregister_hctx (hctx); +mutex_unlock (&q->tag_set->tag_list_lock);kobject_uevent (q->mq_kobj,KOBJ_REMOVE );kobject_del (q->mq_kobj);
Otherwise looks good.
Cheers,
Hannes
Signature · 4 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Frankenstr. 146, 90461 Nürnberg HRB 36809 (AG Nürnberg), GF: I. Totev, A. McDonald, W. Knoblich
Quoted 5 lines · Nilay Shroff
There're two patches in this patchest.
The first patch removes redundantq->sysfs_dir_lock.
The second patch fixesnr_hw_queueupdate racing with disk addition/ removal.
Quoted 7 lines
In the current implementation we use
q->sysfs_dir_lockfor protecting kobject addition/deletion while we register/unregister blk-mq with sysfs. However the sysfs/kernfs internal implementation already protects against the simultaneous addtion/deletion of kobjects. So in that sense use ofq->sysfs_dir_lockappears redundant.[...]
Applied, thanks!
[1/2] block: get rid of request queue ->sysfs_dir_lock
commit: fe6628608627424fb4a6d4c8d2235822457c5d9c
[2/2] block: fix nr_hw_queue update racing with disk addition/removal
commit: 14ef49657ff3b7156952b2eadcf2e5bafd735795Best regards,
Signature · 1 line
Jens Axboe