RFC: fix queue freeze and limit locking order (alt take)
Subsystems (9)
Christoph Hellwig
maintainerHi all,
this is my version of Damien's "Fix queue freeze and limit locking order". A lot looks very similar, but it was done independently based on the previous discussion.
The changelogs are very sparse as the moment as I started it before the holidays and just finished it enough to send it out as a RFC today.
Diffstat:
block/blk-core.c | 14 +++- block/blk-integrity.c | 4 - block/blk-mq.c | 19 ------ block/blk-mq.h | 6 + block/blk-settings.c | 27 ++++++++ block/blk-sysfs.c | 128 +++++++++++++++++++---------------------- block/blk-zoned.c | 7 -- drivers/block/loop.c | 7 ++ drivers/block/nbd.c | 17 ----- drivers/block/virtio_blk.c | 4 - drivers/nvme/host/core.c | 9 +- drivers/scsi/sd.c | 17 +---- drivers/scsi/sr.c | 5 - drivers/usb/storage/scsiglue.c | 5 - include/linux/blkdev.h | 5 - 15 files changed, 133 insertions(+), 141 deletions(-)
Christoph Hellwig
maintainerPATCH 1/10 block: fix docs for freezing of queue limits updates
queue_limits_commit_update is the function that needs to operate on a frozen queue, not queue_limits_start_update. Update the kerneldoc comments to reflect that.
--- block/blk-settings.c | 3 ++- include/linux/blkdev.h | 3 +-- 2 files changed, 3 insertions(+), 3 deletions(-)
block/blk-settings.c +2 -1
@@ -413,7 +413,8 @@ int blk_set_default_limits(struct queue_limits *lim)* @lim: limits to apply * * Apply the limits in @lim that were obtained from queue_limits_start_update() -* and updated by the caller to @q. +* and updated by the caller to @q. The caller must have frozen the queue or +* ensured that there is outstanding I/O by other means. * * Returns 0 if successful, else a negative error code. */
include/linux/blkdev.h +1 -2
@@ -944,8 +944,7 @@ static inline unsigned int blk_boundary_sectors_left(sector_t offset,* the caller can modify. The caller must call queue_limits_commit_update() * to finish the update. * -* Context: process context. The caller must have frozen the queue or ensured -* that there is outstanding I/O by other means. +* Context: process context. */ static inline struct queue_limits queue_limits_start_update (struct request_queue *q)
Signature · 1 line
2.45.2
Damien Le Moal
maintainerRe: [PATCH 01/10] block: fix docs for freezing of queue limits updates
Quoted 15 lines · Christoph Hellwig
queue_limits_commit_updateis the function that needs to operate on a frozen queue, notqueue_limits_start_update. Update the kerneldoc comments to reflect that.Signed-off-by Christoph Hellwig <[email protected]>--- block/blk-settings.c | 3 ++- include/linux/blkdev.h | 3 +-- 2 files changed, 3 insertions(+), 3 deletions(-)block/blk-settings.c +0
-0
block/blk-settings.c int blk_set_default_limits(struct queue_limits *lim) · line 417
Quoted 6 lines
block/blk-settings.c +2
-1@@ -413,7 +413,8 @@ int blk_set_default_limits(struct queue_limits *lim)* @lim: limits to apply * * Apply the limits in @lim that were obtained from queue_limits_start_update() -* and updated by the caller to @q. +* and updated by the caller to @q. The caller must have frozen the queue or +* ensured that there is outstanding I/O by other means.
...ensure that there are no outstanding I/Os by other means.
Quoted 17 lines
block/blk-settings.c +0
-0* * Returns 0 if successful, else a negative error code. */ include/linux/blkdev.h +1
-2@@ -944,8 +944,7 @@ static inline unsigned int blk_boundary_sectors_left(sector_t offset,* the caller can modify. The caller must call queue_limits_commit_update() * to finish the update. * -* Context: process context. The caller must have frozen the queue or ensured -* that there is outstanding I/O by other means. +* Context: process context. */ static inline struct queue_limits queue_limits_start_update (struct request_queue *q)
Signature · 2 lines
Damien Le Moal Western Digital Research
Christoph Hellwig
maintainerPATCH 2/10 block: add a queue_limits_commit_update_frozen helper
In reply to Christoph HellwigAdd a helper that freezes the queue, updates the queue limits and unfreezes the queue and convert all open coded versions of that to the new helper.
--- block/blk-integrity.c | 4 +--- block/blk-settings.c | 24 ++++++++++++++++++++++++ block/blk-zoned.c | 7 +------ drivers/block/virtio_blk.c | 2 -- drivers/scsi/sd.c | 17 +++++------------ drivers/scsi/sr.c | 5 +---- include/linux/blkdev.h | 2 ++ 7 files changed, 34 insertions(+), 27 deletions(-)
block/blk-integrity.c +1 -3
@@ -218,9 +218,7 @@ static ssize_t flag_store(struct device *dev, const char *page, size_t count,else lim.integrity.flags |= flag; -blk_mq_freeze_queue (q); - err =queue_limits_commit_update (q, &lim); -blk_mq_unfreeze_queue (q); + err =queue_limits_commit_update_frozen (q, &lim);if (err)return err;return count;
block/blk-settings.c +24 -0
@@ -444,6 +444,30 @@ int queue_limits_commit_update(struct request_queue *q, }EXPORT_SYMBOL_GPL (queue_limits_commit_update); +/** +* queue_limits_commit_update_frozen - commit an atomic update of queue limits +* @q: queue to update +* @lim: limits to apply +* +* Apply the limits in @lim that were obtained from queue_limits_start_update() +* and updated by the caller to @q. Freezes the queue before the updated and +* unfreezes it after. +* +* Returns 0 if successful, else a negative error code. +*/ +int queue_limits_commit_update_frozen (struct request_queue *q, +struct queue_limits *lim) +{ +int ret; + +blk_mq_freeze_queue (q); + ret =queue_limits_commit_update (q, lim); +blk_mq_unfreeze_queue (q); + +return ret; +} +EXPORT_SYMBOL_GPL (queue_limits_commit_update_frozen); +/** * queue_limits_set - apply queue limits to queue * @q: queue to update
block/blk-zoned.c +1 -6
@@ -1444,7 +1444,6 @@ static int disk_update_zone_resources(struct gendisk *disk,unsigned int nr_seq_zones, nr_conv_zones;unsigned int pool_size;struct queue_limits lim; -int ret; disk->nr_zones = args->nr_zones; disk->zone_capacity = args->zone_capacity;
@@ -1495,11 +1494,7 @@ static int disk_update_zone_resources(struct gendisk *disk, } commit: -blk_mq_freeze_queue (q); - ret =queue_limits_commit_update (q, &lim); -blk_mq_unfreeze_queue (q); - -return ret; +return queue_limits_commit_update_frozen (q, &lim); } static int blk_revalidate_conv_zone(struct blk_zone *zone, unsigned int idx,
drivers/block/virtio_blk.c +0 -2
@@ -1105,9 +1105,7 @@ cache_type_store(struct device *dev, struct device_attribute *attr, lim.features |=BLK_FEAT_WRITE_CACHE ; else lim.features &= ~BLK_FEAT_WRITE_CACHE; -blk_mq_freeze_queue (disk->queue); i =queue_limits_commit_update (disk->queue, &lim); -blk_mq_unfreeze_queue (disk->queue);if (i)return i;return count;
drivers/scsi/sd.c +5 -12
@@ -177,9 +177,8 @@ cache_type_store(struct device *dev, struct device_attribute *attr, lim =queue_limits_start_update (sdkp->disk->queue);sd_set_flush_flag (sdkp, &lim); -blk_mq_freeze_queue (sdkp->disk->queue); - ret =queue_limits_commit_update (sdkp->disk->queue, &lim); -blk_mq_unfreeze_queue (sdkp->disk->queue); + ret =queue_limits_commit_update_frozen (sdkp->disk->queue, + &lim);if (ret)return ret;return count;
@@ -483,9 +482,7 @@ provisioning_mode_store(struct device *dev, struct device_attribute *attr, lim =queue_limits_start_update (sdkp->disk->queue);sd_config_discard (sdkp, &lim, mode); -blk_mq_freeze_queue (sdkp->disk->queue); - err =queue_limits_commit_update (sdkp->disk->queue, &lim); -blk_mq_unfreeze_queue (sdkp->disk->queue); + err =queue_limits_commit_update_frozen (sdkp->disk->queue, &lim);if (err)return err;return count;
@@ -594,9 +591,7 @@ max_write_same_blocks_store(struct device *dev, struct device_attribute *attr, lim =queue_limits_start_update (sdkp->disk->queue);sd_config_write_same (sdkp, &lim); -blk_mq_freeze_queue (sdkp->disk->queue); - err =queue_limits_commit_update (sdkp->disk->queue, &lim); -blk_mq_unfreeze_queue (sdkp->disk->queue); + err =queue_limits_commit_update_frozen (sdkp->disk->queue, &lim);if (err)return err;return count;
@@ -3803,9 +3798,7 @@ static int sd_revalidate_disk(struct gendisk *disk)sd_config_write_same (sdkp, &lim);kfree (buffer); -blk_mq_freeze_queue (sdkp->disk->queue); - err =queue_limits_commit_update (sdkp->disk->queue, &lim); -blk_mq_unfreeze_queue (sdkp->disk->queue); + err =queue_limits_commit_update_frozen (sdkp->disk->queue, &lim);if (err)return err;
drivers/scsi/sr.c +1 -4
@@ -797,10 +797,7 @@ static int get_sectorsize(struct scsi_cd *cd) lim =queue_limits_start_update (q); lim.logical_block_size = sector_size; -blk_mq_freeze_queue (q); - err =queue_limits_commit_update (q, &lim); -blk_mq_unfreeze_queue (q); -return err; +return queue_limits_commit_update_frozen (q, &lim); }static int get_capabilities (struct scsi_cd *cd)
include/linux/blkdev.h +2 -0
@@ -952,6 +952,8 @@ queue_limits_start_update(struct request_queue *q)mutex_lock (&q->limits_lock);return q->limits; } +int queue_limits_commit_update_frozen (struct request_queue *q, +struct queue_limits *lim);int queue_limits_commit_update (struct request_queue *q,struct queue_limits *lim);int queue_limits_set (struct request_queue *q,struct queue_limits *lim);
Signature · 1 line
2.45.2
Damien Le Moal
maintainerRe: [PATCH 02/10] block: add a queue_limits_commit_update_frozen helper
Quoted 5 lines · Christoph Hellwig
Add a helper that freezes the queue, updates the queue limits and unfreezes the queue and convert all open coded versions of that to the new helper.
Signed-off-by Christoph Hellwig <[email protected]>
[...]
drivers/block/virtio_blk.c cache_type_store(struct device *dev, struct device_attribute *attr, · line 1108
Quoted 10 lines
drivers/block/virtio_blk.c +0
-1@@ -1105,9 +1105,7 @@ cache_type_store(struct device *dev, struct device_attribute *attr, lim.features |=BLK_FEAT_WRITE_CACHE ; else lim.features &= ~BLK_FEAT_WRITE_CACHE; -blk_mq_freeze_queue (disk->queue); i =queue_limits_commit_update (disk->queue, &lim);
You need to change this line to use queue_limits_commit_update_frozen().
Other than that, looks good !
Signature · 2 lines
Damien Le Moal Western Digital Research
Christoph Hellwig
maintainerPATCH 3/10 block: add a store_limit operations for sysfs entries
In reply to Christoph HellwigDe-duplicate the code for updating queue limits by adding a store_limit method that allows having common code handle the actual queue limits update.
--- block/blk-sysfs.c | 128 ++++++++++++++++++++++------------------------ 1 file changed, 61 insertions(+), 67 deletions(-)
block/blk-sysfs.c +61 -67
@@ -24,6 +24,8 @@ struct queue_sysfs_entry {struct attribute attr;ssize_t (*show)(struct gendisk *disk,char *page);ssize_t (*store)(struct gendisk *disk,const char *page,size_t count); +int (*store_limit)(struct gendisk *disk,const char *page, +size_t count,struct queue_limits *lim);void (*load_module)(struct gendisk *disk,const char *page,size_t count); };
@@ -153,13 +155,11 @@ QUEUE_SYSFS_SHOW_CONST(discard_zeroes_data, 0) QUEUE_SYSFS_SHOW_CONST(write_same_max, 0) QUEUE_SYSFS_SHOW_CONST(poll_delay, -1) -static ssize_t queue_max_discard_sectors_store (struct gendisk *disk, -const char *page,size_t count) +static int queue_max_discard_sectors_store (struct gendisk *disk, +const char *page,size_t count,struct queue_limits *lim) {unsigned long max_discard_bytes; -struct queue_limits lim;ssize_t ret; -int err; ret =queue_var_store (&max_discard_bytes, page, count);if (ret <0 )
@@ -171,38 +171,28 @@ static ssize_t queue_max_discard_sectors_store(struct gendisk *disk,if ((max_discard_bytes >>SECTOR_SHIFT ) >UINT_MAX )return -EINVAL ; - lim =queue_limits_start_update (disk->queue); - lim.max_user_discard_sectors = max_discard_bytes >>SECTOR_SHIFT ; - err =queue_limits_commit_update (disk->queue, &lim); -if (err) -return err; -return ret; + lim->max_user_discard_sectors = max_discard_bytes >>SECTOR_SHIFT ; +return 0 ; } -static ssize_t -queue_max_sectors_store (struct gendisk *disk,const char *page,size_t count) +static int +queue_max_sectors_store (struct gendisk *disk,const char *page,size_t count, +struct queue_limits *lim) {unsigned long max_sectors_kb; -struct queue_limits lim;ssize_t ret; -int err; ret =queue_var_store (&max_sectors_kb, page, count);if (ret <0 )return ret; - lim =queue_limits_start_update (disk->queue); - lim.max_user_sectors = max_sectors_kb <<1 ; - err =queue_limits_commit_update (disk->queue, &lim); -if (err) -return err; -return ret; + lim->max_user_sectors = max_sectors_kb <<1 ; +return 0 ; }static ssize_t queue_feature_store (struct gendisk *disk,const char *page, -size_t count,blk_features_t feature) +size_t count,struct queue_limits *lim,blk_features_t feature) { -struct queue_limits lim;unsigned long val;ssize_t ret;
@@ -210,15 +200,11 @@ static ssize_t queue_feature_store(struct gendisk *disk, const char *page,if (ret <0 )return ret; - lim =queue_limits_start_update (disk->queue);if (val) - lim.features |= feature; + lim->features |= feature;else - lim.features &= ~feature; - ret =queue_limits_commit_update (disk->queue, &lim); -if (ret) -return ret; -return count; + lim->features &= ~feature; +return 0 ; }#define QUEUE_SYSFS_FEATURE (_name, _feature) \
@@ -227,10 +213,10 @@ static ssize_t queue_##_name##_show(struct gendisk *disk, char *page) \return sysfs_emit (page,"%u\n" , \ !!(disk->queue->limits.features & _feature)); \ } \ -static ssize_t queue_##_name##_store(struct gendisk *disk, \ -const char *page,size_t count) \ +static int queue_##_name##_store(struct gendisk *disk, \ +const char *page,size_t count,struct queue_limits *lim) \ { \ -return queue_feature_store (disk, page, count, _feature); \ +return queue_feature_store (disk, page, count, lim, _feature); \ }QUEUE_SYSFS_FEATURE (rotational,BLK_FEAT_ROTATIONAL )
@@ -266,10 +252,9 @@ static ssize_t queue_iostats_passthrough_show(struct gendisk *disk, char *page)return queue_var_show (!!blk_queue_passthrough_stat (disk->queue), page); } -static ssize_t queue_iostats_passthrough_store (struct gendisk *disk, -const char *page,size_t count) +static int queue_iostats_passthrough_store (struct gendisk *disk, +const char *page,size_t count,struct queue_limits *lim) { -struct queue_limits lim;unsigned long ios;ssize_t ret;
@@ -277,18 +262,13 @@ static ssize_t queue_iostats_passthrough_store(struct gendisk *disk,if (ret <0 )return ret; - lim =queue_limits_start_update (disk->queue);if (ios) - lim.flags |=BLK_FLAG_IOSTATS_PASSTHROUGH ; + lim->flags |=BLK_FLAG_IOSTATS_PASSTHROUGH ;else - lim.flags &= ~BLK_FLAG_IOSTATS_PASSTHROUGH ; - - ret =queue_limits_commit_update (disk->queue, &lim); -if (ret) -return ret; - -return count; + lim->flags &= ~BLK_FLAG_IOSTATS_PASSTHROUGH ; +return 0 ; } +static ssize_t queue_nomerges_show (struct gendisk *disk,char *page) { return queue_var_show((blk_queue_nomerges(disk->queue) << 1) |
@@ -391,12 +371,10 @@ static ssize_t queue_wc_show(struct gendisk *disk, char *page)return sysfs_emit (page,"write through\n" ); } -static ssize_t queue_wc_store (struct gendisk *disk,const char *page, -size_t count) +static int queue_wc_store (struct gendisk *disk,const char *page, +size_t count,struct queue_limits *lim) { -struct queue_limits lim;bool disable; -int err;if (!strncmp (page,"write back" ,10 )) { disable = false;
@@ -407,15 +385,11 @@ static ssize_t queue_wc_store(struct gendisk *disk, const char *page,return -EINVAL ; } - lim =queue_limits_start_update (disk->queue);if (disable) - lim.flags |=BLK_FLAG_WRITE_CACHE_DISABLED ; + lim->flags |=BLK_FLAG_WRITE_CACHE_DISABLED ;else - lim.flags &= ~BLK_FLAG_WRITE_CACHE_DISABLED ; - err =queue_limits_commit_update (disk->queue, &lim); -if (err) -return err; -return count; + lim->flags &= ~BLK_FLAG_WRITE_CACHE_DISABLED ; +return 0 ; }#define QUEUE_RO_ENTRY (_prefix, _name) \
@@ -431,6 +405,13 @@ static struct queue_sysfs_entry _prefix##_entry = { \ .store = _prefix##_store, \ }; +#define QUEUE_LIM_RW_ENTRY (_prefix, _name) \ +static struct queue_sysfs_entry _prefix##_entry = { \ + .attr = { .name = _name, .mode = 0644 }, \ + .show = _prefix##_show, \ + .store_limit = _prefix##_store, \ +} +#define QUEUE_RW_LOAD_MODULE_ENTRY (_prefix, _name) \ static struct queue_sysfs_entry _prefix##_entry = { \ .attr = { .name = _name, .mode = 0644 }, \
@@ -441,7 +422,7 @@ static struct queue_sysfs_entry _prefix##_entry = { \QUEUE_RW_ENTRY (queue_requests,"nr_requests" );QUEUE_RW_ENTRY (queue_ra,"read_ahead_kb" ); -QUEUE_RW_ENTRY (queue_max_sectors,"max_sectors_kb" ); +QUEUE_LIM_RW_ENTRY (queue_max_sectors,"max_sectors_kb" );QUEUE_RO_ENTRY (queue_max_hw_sectors,"max_hw_sectors_kb" );QUEUE_RO_ENTRY (queue_max_segments,"max_segments" );QUEUE_RO_ENTRY (queue_max_integrity_segments,"max_integrity_segments" );
@@ -457,7 +438,7 @@ QUEUE_RO_ENTRY(queue_io_opt, "optimal_io_size");QUEUE_RO_ENTRY (queue_max_discard_segments,"max_discard_segments" );QUEUE_RO_ENTRY (queue_discard_granularity,"discard_granularity" );QUEUE_RO_ENTRY (queue_max_hw_discard_sectors,"discard_max_hw_bytes" ); -QUEUE_RW_ENTRY (queue_max_discard_sectors,"discard_max_bytes" ); +QUEUE_LIM_RW_ENTRY (queue_max_discard_sectors,"discard_max_bytes" );QUEUE_RO_ENTRY (queue_discard_zeroes_data,"discard_zeroes_data" );QUEUE_RO_ENTRY (queue_atomic_write_max_sectors,"atomic_write_max_bytes" );
@@ -477,11 +458,11 @@ QUEUE_RO_ENTRY(queue_max_open_zones, "max_open_zones");QUEUE_RO_ENTRY (queue_max_active_zones,"max_active_zones" );QUEUE_RW_ENTRY (queue_nomerges,"nomerges" ); -QUEUE_RW_ENTRY (queue_iostats_passthrough,"iostats_passthrough" ); +QUEUE_LIM_RW_ENTRY (queue_iostats_passthrough,"iostats_passthrough" );QUEUE_RW_ENTRY (queue_rq_affinity,"rq_affinity" );QUEUE_RW_ENTRY (queue_poll,"io_poll" );QUEUE_RW_ENTRY (queue_poll_delay,"io_poll_delay" ); -QUEUE_RW_ENTRY (queue_wc,"write_cache" ); +QUEUE_LIM_RW_ENTRY (queue_wc,"write_cache" );QUEUE_RO_ENTRY (queue_fua,"fua" );QUEUE_RO_ENTRY (queue_dax,"dax" );QUEUE_RW_ENTRY (queue_io_timeout,"io_timeout" );
@@ -494,10 +475,10 @@ static struct queue_sysfs_entry queue_hw_sector_size_entry = { .show = queue_logical_block_size_show, }; -QUEUE_RW_ENTRY (queue_rotational,"rotational" ); -QUEUE_RW_ENTRY (queue_iostats,"iostats" ); -QUEUE_RW_ENTRY (queue_add_random,"add_random" ); -QUEUE_RW_ENTRY (queue_stable_writes,"stable_writes" ); +QUEUE_LIM_RW_ENTRY (queue_rotational,"rotational" ); +QUEUE_LIM_RW_ENTRY (queue_iostats,"iostats" ); +QUEUE_LIM_RW_ENTRY (queue_add_random,"add_random" ); +QUEUE_LIM_RW_ENTRY (queue_stable_writes,"stable_writes" );#ifdef CONFIG_BLK_WBT static ssize_t queue_var_store64 (s64 *var,const char *page)
@@ -695,7 +676,7 @@ queue_attr_store(struct kobject *kobj, struct attribute *attr,struct request_queue *q = disk->queue;ssize_t res; -if (!entry->store) +if (!entry->store_limit && !entry->store)return -EIO ;/*
@@ -706,11 +687,24 @@ queue_attr_store(struct kobject *kobj, struct attribute *attr,if (entry->load_module) entry->load_module (disk, page, length); -blk_mq_freeze_queue (q);mutex_lock (&q->sysfs_lock); - res = entry->store (disk, page, length); -mutex_unlock (&q->sysfs_lock); +blk_mq_freeze_queue (q); +if (entry->store_limit) { +struct queue_limits lim =queue_limits_start_update (q); + + res = entry->store_limit (disk, page, length, &lim); +if (res <0 ) { +queue_limits_cancel_update (q); + }else { + res =queue_limits_commit_update (q, &lim); +if (!res) + res = length; + } + }else { + res = entry->store (disk, page, length); + }blk_mq_unfreeze_queue (q); +mutex_unlock (&q->sysfs_lock);return res; }
Signature · 1 line
2.45.2
Damien Le Moal
maintainerRe: [PATCH 03/10] block: add a store_limit operations for sysfs entries
Quoted 5 lines · Christoph Hellwig
De-duplicate the code for updating queue limits by adding a
store_limitmethod that allows having common code handle the actual queue limits update.Signed-off-by Christoph Hellwig <[email protected]>
[...]
block/blk-sysfs.c queue_attr_store(struct kobject *kobj, struct attribute *attr, · line 691
Quoted 9 lines
block/blk-sysfs.c +1
-3@@ -706,11 +687,24 @@ queue_attr_store(struct kobject *kobj, struct attribute *attr,if (entry->load_module) entry->load_module (disk, page, length); -blk_mq_freeze_queue (q);mutex_lock (&q->sysfs_lock); - res = entry->store (disk, page, length); -mutex_unlock (&q->sysfs_lock); +blk_mq_freeze_queue (q);
The freeze must NOT be done for the "if (entry->store_limit)" case. So this needs to go int the "else". Otherwise, you still have freeze the take limit lock order which can cause the ABBA deadlocks in SCSI sd.
block/blk-sysfs.c queue_attr_store(struct kobject *kobj, struct attribute *attr, · line 699
Quoted 8 lines
block/blk-sysfs.c +8
-0+if (entry->store_limit) { +struct queue_limits lim =queue_limits_start_update (q); + + res = entry->store_limit (disk, page, length, &lim); +if (res <0 ) { +queue_limits_cancel_update (q); + }else { + res =queue_limits_commit_update (q, &lim);
Here you must use queue_limits_commit_update_frozen().
block/blk-sysfs.c queue_attr_store(struct kobject *kobj, struct attribute *attr, · line 706
Quoted 7 lines
block/blk-sysfs.c +6
-0+if (!res) + res = length; + } + }else { + res = entry->store (disk, page, length); + }blk_mq_unfreeze_queue (q);
And this one needs to go in the else after the call to entry->store().
Quoted 4 lines
block/blk-sysfs.c +1
-0+mutex_unlock (&q->sysfs_lock);return res; }
Signature · 2 lines
Damien Le Moal Western Digital Research
Christoph Hellwig
maintainerRe: [PATCH 03/10] block: add a store_limit operations for sysfs entries
Quoted 3 lines · Damien Le Moal
The freeze must NOT be done for the "if (
entry->store_limit)" case. So this needs to go int the "else". Otherwise, you still have freeze the take limit lock order which can cause the ABBA deadlocks in SCSI sd.
That is fixed in the next patch. This one is pure refactoring without behavior change.
Christoph Hellwig
maintainerPATCH 4/10 block: use queue_limits_commit_update in queue_attr_store
In reply to Christoph HellwigUse queue_limits_commit_update to apply a consistent freeze vs limits lock order in queue_attr_store. Also remove taking the sysfs lock as it doesn't protect anything here.
--- block/blk-sysfs.c | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-)
block/blk-sysfs.c +10 -8
@@ -687,22 +687,24 @@ queue_attr_store(struct kobject *kobj, struct attribute *attr,if (entry->load_module) entry->load_module (disk, page, length); -mutex_lock (&q->sysfs_lock); -blk_mq_freeze_queue (q);if (entry->store_limit) {struct queue_limits lim =queue_limits_start_update (q); res = entry->store_limit (disk, page, length, &lim);if (res <0 ) {queue_limits_cancel_update (q); - }else { - res =queue_limits_commit_update (q, &lim); -if (!res) - res = length; +return res; } - }else { - res = entry->store (disk, page, length); + + res =queue_limits_commit_update_frozen (q, &lim); +if (res) +return res; +return length; } + +mutex_lock (&q->sysfs_lock); +blk_mq_freeze_queue (q); + res = entry->store (disk, page, length);blk_mq_unfreeze_queue (q);mutex_unlock (&q->sysfs_lock);return res;
Signature · 1 line
2.45.2
Damien Le Moal
maintainerRe: [PATCH 04/10] block: use queue_limits_commit_update in queue_attr_store
Quoted 5 lines · Christoph Hellwig
Use
queue_limits_commit_updateto apply a consistent freeze vs limits lock order inqueue_attr_store. Also remove taking the sysfs lock as it doesn't protect anything here.Signed-off-by Christoph Hellwig <[email protected]>
Oops. OK. so please disregard my comments on patch 3. This is all fixed here. May be sqash this patch with patch 3 ?
Quoted 41 lines
--- block/blk-sysfs.c | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-)block/blk-sysfs.c +10
-8@@ -687,22 +687,24 @@ queue_attr_store(struct kobject *kobj, struct attribute *attr,if (entry->load_module) entry->load_module (disk, page, length); -mutex_lock (&q->sysfs_lock); -blk_mq_freeze_queue (q);if (entry->store_limit) {struct queue_limits lim =queue_limits_start_update (q); res = entry->store_limit (disk, page, length, &lim);if (res <0 ) {queue_limits_cancel_update (q); - }else { - res =queue_limits_commit_update (q, &lim); -if (!res) - res = length; +return res; } - }else { - res = entry->store (disk, page, length); + + res =queue_limits_commit_update_frozen (q, &lim); +if (res) +return res; +return length; } + +mutex_lock (&q->sysfs_lock); +blk_mq_freeze_queue (q); + res = entry->store (disk, page, length);blk_mq_unfreeze_queue (q);mutex_unlock (&q->sysfs_lock);return res;
Signature · 2 lines
Damien Le Moal Western Digital Research
Christoph Hellwig
maintainerPATCH 5/10 block: don't update BLK_FEAT_POLL in __blk_mq_update_nr_hw_queues
In reply to Christoph HellwigWhen __blk_mq_update_nr_hw_queues changes the number of tag sets, it might have to disable poll queues. Currently it does so by adjusting the BLK_FEAT_POLL, which is a bit against the intent of features that describe hardware / driver capabilities, but more importantly causes nasty lock order problems with the broadly held freeze when updating the number of hardware queues and the limits lock. Fix this by leaving BLK_FEAT_POLL alone, and instead check for the number of sets and poll queues in the bio submission and poll handler. While this adds extra work to the fast path, the variables are in cache lines used by these operations anyway, so it should be cheap enough.
--- block/blk-core.c | 14 +++++++++++--- block/blk-mq.c | 19 +------------------ block/blk-mq.h | 6 ++++++ 3 files changed, 18 insertions(+), 21 deletions(-)
block/blk-core.c +11 -3
@@ -753,6 +753,15 @@ static blk_status_t blk_validate_atomic_write_op_size(struct request_queue *q,return BLK_STS_OK ; } +static bool bdev_can_poll (struct block_device *bdev) +{ +struct request_queue *q =bdev_get_queue (bdev); + +if (queue_is_mq (q)) +return blk_mq_can_poll (q->tag_set); +return q->limits.features &BLK_FEAT_POLL ; +} +/** * submit_bio_noacct - re-submit a bio to the block device layer for I/O * @bio: The bio describing the location in memory and on the device.
@@ -805,8 +814,7 @@ void submit_bio_noacct(struct bio *bio) } } -if (!(q->limits.features &BLK_FEAT_POLL ) && - (bio->bi_opf &REQ_POLLED )) { +if ((bio->bi_opf &REQ_POLLED ) && !bdev_can_poll (bdev)) {bio_clear_polled (bio); goto not_supported; }
@@ -935,7 +943,7 @@ int bio_poll(struct bio *bio, struct io_comp_batch *iob, unsigned int flags)return 0 ; q =bdev_get_queue (bdev); -if (cookie ==BLK_QC_T_NONE || !(q->limits.features &BLK_FEAT_POLL )) +if (cookie ==BLK_QC_T_NONE || !bdev_can_poll (bdev))return 0 ;blk_flush_plug (current->plug, false);
block/blk-mq.c +1 -18
@@ -4321,12 +4321,6 @@ void blk_mq_release(struct request_queue *q)blk_mq_sysfs_deinit (q); } -static bool blk_mq_can_poll (struct blk_mq_tag_set *set) -{ -return set->nr_maps >HCTX_TYPE_POLL && - set->map[HCTX_TYPE_POLL ].nr_queues; -} -struct request_queue *blk_mq_alloc_queue (struct blk_mq_tag_set *set,struct queue_limits *lim,void *queuedata) {
@@ -4336,9 +4330,7 @@ struct request_queue *blk_mq_alloc_queue(struct blk_mq_tag_set *set,if (!lim) lim = &default_lim; - lim->features |=BLK_FEAT_IO_STAT |BLK_FEAT_NOWAIT ; -if (blk_mq_can_poll (set)) - lim->features |=BLK_FEAT_POLL ; + lim->features |=BLK_FEAT_IO_STAT |BLK_FEAT_NOWAIT |BLK_FEAT_POLL ; q =blk_alloc_queue (lim, set->numa_node);if (IS_ERR (q))
@@ -5025,8 +5017,6 @@ static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set, fallback:blk_mq_update_queue_map (set);list_for_each_entry (q, &set->tag_list, tag_set_list) { -struct queue_limits lim; -blk_mq_realloc_hw_ctxs (set, q);if (q->nr_hw_queues != set->nr_hw_queues) {
@@ -5040,13 +5030,6 @@ static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set, set->nr_hw_queues = prev_nr_hw_queues; goto fallback; } - lim =queue_limits_start_update (q); -if (blk_mq_can_poll (set)) - lim.features |=BLK_FEAT_POLL ; -else - lim.features &= ~BLK_FEAT_POLL ; -if (queue_limits_commit_update (q, &lim) <0 ) -pr_warn ("updating the poll flag failed\n" );blk_mq_map_swqueue (q); }
block/blk-mq.h +6 -0
@@ -111,6 +111,12 @@ static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q,return ctx->hctxs[blk_mq_get_hctx_type (opf)]; } +static inline bool blk_mq_can_poll (struct blk_mq_tag_set *set) +{ +return set->nr_maps >HCTX_TYPE_POLL && + set->map[HCTX_TYPE_POLL ].nr_queues; +} +/* * sysfs helpers */
Signature · 1 line
2.45.2
Damien Le Moal
maintainerRe: [PATCH 05/10] block: don't update BLK_FEAT_POLL in __blk_mq_update_nr_hw_queues
Quoted 75 lines · Christoph Hellwig
When
__blk_mq_update_nr_hw_queueschanges the number of tag sets, it might have to disable poll queues. Currently it does so by adjusting theBLK_FEAT_POLL, which is a bit against the intent of features that describe hardware / driver capabilities, but more importantly causes nasty lock order problems with the broadly held freeze when updating the number of hardware queues and the limits lock. Fix this by leavingBLK_FEAT_POLLalone, and instead check for the number of sets and poll queues in the bio submission and poll handler. While this adds extra work to the fast path, the variables are in cache lines used by these operations anyway, so it should be cheap enough.Signed-off-by Christoph Hellwig <[email protected]>--- block/blk-core.c | 14 +++++++++++--- block/blk-mq.c | 19 +------------------ block/blk-mq.h | 6 ++++++ 3 files changed, 18 insertions(+), 21 deletions(-)block/blk-core.c +11
-3@@ -753,6 +753,15 @@ static blk_status_t blk_validate_atomic_write_op_size(struct request_queue *q,return BLK_STS_OK ; } +static bool bdev_can_poll (struct block_device *bdev) +{ +struct request_queue *q =bdev_get_queue (bdev); + +if (queue_is_mq (q)) +return blk_mq_can_poll (q->tag_set); +return q->limits.features &BLK_FEAT_POLL ; +} +/** * submit_bio_noacct - re-submit a bio to the block device layer for I/O * @bio: The bio describing the location in memory and on the device. @@ -805,8 +814,7 @@ void submit_bio_noacct(struct bio *bio) } } -if (!(q->limits.features &BLK_FEAT_POLL ) && - (bio->bi_opf &REQ_POLLED )) { +if ((bio->bi_opf &REQ_POLLED ) && !bdev_can_poll (bdev)) {bio_clear_polled (bio); goto not_supported; }@@ -935,7 +943,7 @@ int bio_poll(struct bio *bio, struct io_comp_batch *iob, unsigned int flags)return 0 ; q =bdev_get_queue (bdev); -if (cookie ==BLK_QC_T_NONE || !(q->limits.features &BLK_FEAT_POLL )) +if (cookie ==BLK_QC_T_NONE || !bdev_can_poll (bdev))return 0 ;blk_flush_plug (current->plug, false);block/blk-mq.c +0
-6@@ -4321,12 +4321,6 @@ void blk_mq_release(struct request_queue *q)blk_mq_sysfs_deinit (q); } -static bool blk_mq_can_poll (struct blk_mq_tag_set *set) -{ -return set->nr_maps >HCTX_TYPE_POLL && - set->map[HCTX_TYPE_POLL ].nr_queues; -} -struct request_queue *blk_mq_alloc_queue (struct blk_mq_tag_set *set,struct queue_limits *lim,void *queuedata) {
block/blk-mq.c struct request_queue *blk_mq_alloc_queue(struct blk_mq_tag_set *set, · line 4333
Quoted 7 lines
block/blk-mq.c +1
-3@@ -4336,9 +4330,7 @@ struct request_queue *blk_mq_alloc_queue(struct blk_mq_tag_set *set,if (!lim) lim = &default_lim; - lim->features |=BLK_FEAT_IO_STAT |BLK_FEAT_NOWAIT ; -if (blk_mq_can_poll (set)) - lim->features |=BLK_FEAT_POLL ; + lim->features |=BLK_FEAT_IO_STAT |BLK_FEAT_NOWAIT |BLK_FEAT_POLL ;
Why set BLK_FEAT_POLL unconditionally ? This is changing the current default for many devices, no ?
Quoted 43 lines
block/blk-mq.c +0
-9q =blk_alloc_queue (lim, set->numa_node);if (IS_ERR (q))@@ -5025,8 +5017,6 @@ static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set, fallback:blk_mq_update_queue_map (set);list_for_each_entry (q, &set->tag_list, tag_set_list) { -struct queue_limits lim; -blk_mq_realloc_hw_ctxs (set, q);if (q->nr_hw_queues != set->nr_hw_queues) {@@ -5040,13 +5030,6 @@ static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set, set->nr_hw_queues = prev_nr_hw_queues; goto fallback; } - lim =queue_limits_start_update (q); -if (blk_mq_can_poll (set)) - lim.features |=BLK_FEAT_POLL ; -else - lim.features &= ~BLK_FEAT_POLL ; -if (queue_limits_commit_update (q, &lim) <0 ) -pr_warn ("updating the poll flag failed\n" );blk_mq_map_swqueue (q); }block/blk-mq.h +6
-0@@ -111,6 +111,12 @@ static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q,return ctx->hctxs[blk_mq_get_hctx_type (opf)]; } +static inline bool blk_mq_can_poll (struct blk_mq_tag_set *set) +{ +return set->nr_maps >HCTX_TYPE_POLL && + set->map[HCTX_TYPE_POLL ].nr_queues; +} +/* * sysfs helpers */
Signature · 2 lines
Damien Le Moal Western Digital Research
Christoph Hellwig
maintainerRe: [PATCH 05/10] block: don't update BLK_FEAT_POLL in __blk_mq_update_nr_hw_queues
Quoted 4 lines · Damien Le Moal
block/blk-mq.c struct request_queue *blk_mq_alloc_queue(struct blk_mq_tag_set *set, · line 4333
Quoted 1 line
block/blk-mq.c +1
-0+ lim->features |=BLK_FEAT_IO_STAT |BLK_FEAT_NOWAIT |BLK_FEAT_POLL ;Why set
BLK_FEAT_POLLunconditionally ? This is changing the current default for many devices, no ?
Due to the runtime check it doesn't actually change behavior. But it does change the value read from sysfs, which also need extra check for poll queues. But the entire point is that we don't have to update this field when updating the queues, so yes it should be set unconditonally.
Re: [PATCH 05/10] block: don't update BLK_FEAT_POLL in __blk_mq_update_nr_hw_queues
In reply to Christoph HellwigQuoted 25 lines · Christoph Hellwig
When
__blk_mq_update_nr_hw_queueschanges the number of tag sets, it might have to disable poll queues. Currently it does so by adjusting theBLK_FEAT_POLL, which is a bit against the intent of features that describe hardware / driver capabilities, but more importantly causes nasty lock order problems with the broadly held freeze when updating the number of hardware queues and the limits lock. Fix this by leavingBLK_FEAT_POLLalone, and instead check for the number of sets and poll queues in the bio submission and poll handler. While this adds extra work to the fast path, the variables are in cache lines used by these operations anyway, so it should be cheap enough.Signed-off-by Christoph Hellwig <[email protected]>--- block/blk-core.c | 14 +++++++++++--- block/blk-mq.c | 19 +------------------ block/blk-mq.h | 6 ++++++ 3 files changed, 18 insertions(+), 21 deletions(-)block/blk-core.c +0
-0@@ -753,6 +753,15 @@ static blk_status_t blk_validate_atomic_write_op_size(struct request_queue *q,return BLK_STS_OK ; }
block/blk-core.c static blk_status_t blk_validate_atomic_write_op_size(struct request_queue *q, · line 764
Quoted 10 lines
block/blk-core.c +9
-0+static bool bdev_can_poll (struct block_device *bdev) +{ +struct request_queue *q =bdev_get_queue (bdev); + +if (queue_is_mq (q)) +return blk_mq_can_poll (q->tag_set); +return q->limits.features &BLK_FEAT_POLL ; +} +
Should we make bdev_can_poll() inline ?
Quoted 90 lines
block/blk-core.c +2
-3/** * submit_bio_noacct - re-submit a bio to the block device layer for I/O * @bio: The bio describing the location in memory and on the device. @@ -805,8 +814,7 @@ void submit_bio_noacct(struct bio *bio) } } -if (!(q->limits.features &BLK_FEAT_POLL ) && - (bio->bi_opf &REQ_POLLED )) { +if ((bio->bi_opf &REQ_POLLED ) && !bdev_can_poll (bdev)) {bio_clear_polled (bio); goto not_supported; }@@ -935,7 +943,7 @@ int bio_poll(struct bio *bio, struct io_comp_batch *iob, unsigned int flags)return 0 ; q =bdev_get_queue (bdev); -if (cookie ==BLK_QC_T_NONE || !(q->limits.features &BLK_FEAT_POLL )) +if (cookie ==BLK_QC_T_NONE || !bdev_can_poll (bdev))return 0 ;blk_flush_plug (current->plug, false);block/blk-mq.c +1
-18@@ -4321,12 +4321,6 @@ void blk_mq_release(struct request_queue *q)blk_mq_sysfs_deinit (q); } -static bool blk_mq_can_poll (struct blk_mq_tag_set *set) -{ -return set->nr_maps >HCTX_TYPE_POLL && - set->map[HCTX_TYPE_POLL ].nr_queues; -} -struct request_queue *blk_mq_alloc_queue (struct blk_mq_tag_set *set,struct queue_limits *lim,void *queuedata) {@@ -4336,9 +4330,7 @@ struct request_queue *blk_mq_alloc_queue(struct blk_mq_tag_set *set,if (!lim) lim = &default_lim; - lim->features |=BLK_FEAT_IO_STAT |BLK_FEAT_NOWAIT ; -if (blk_mq_can_poll (set)) - lim->features |=BLK_FEAT_POLL ; + lim->features |=BLK_FEAT_IO_STAT |BLK_FEAT_NOWAIT |BLK_FEAT_POLL ; q =blk_alloc_queue (lim, set->numa_node);if (IS_ERR (q))@@ -5025,8 +5017,6 @@ static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set, fallback:blk_mq_update_queue_map (set);list_for_each_entry (q, &set->tag_list, tag_set_list) { -struct queue_limits lim; -blk_mq_realloc_hw_ctxs (set, q);if (q->nr_hw_queues != set->nr_hw_queues) {@@ -5040,13 +5030,6 @@ static void __blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set, set->nr_hw_queues = prev_nr_hw_queues; goto fallback; } - lim =queue_limits_start_update (q); -if (blk_mq_can_poll (set)) - lim.features |=BLK_FEAT_POLL ; -else - lim.features &= ~BLK_FEAT_POLL ; -if (queue_limits_commit_update (q, &lim) <0 ) -pr_warn ("updating the poll flag failed\n" );blk_mq_map_swqueue (q); }block/blk-mq.h +6
-0@@ -111,6 +111,12 @@ static inline struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *q,return ctx->hctxs[blk_mq_get_hctx_type (opf)]; } +static inline bool blk_mq_can_poll (struct blk_mq_tag_set *set) +{ +return set->nr_maps >HCTX_TYPE_POLL && + set->map[HCTX_TYPE_POLL ].nr_queues; +} +/* * sysfs helpers */
Christoph Hellwig
maintainerRe: [PATCH 05/10] block: don't update BLK_FEAT_POLL in __blk_mq_update_nr_hw_queues
Quoted 11 lines · Nilay Shroff
block/blk-core.c static blk_status_t blk_validate_atomic_write_op_size(struct request_queue *q, · line 764
Quoted 9 lines
block/blk-core.c +9
-0+static bool bdev_can_poll (struct block_device *bdev) +{ +struct request_queue *q =bdev_get_queue (bdev); + +if (queue_is_mq (q)) +return blk_mq_can_poll (q->tag_set); +return q->limits.features &BLK_FEAT_POLL ; +} +Should we make
bdev_can_poll()inline ?
I don't really see the point. It's file local and doesn't have any magic that could confuse the code generator, so we might as well leave it to the compiler. Although that might be about to change per the discussion with Damien, which could require it in blk-sysfs, in which case it should become an inline in a header.
Re: [PATCH 05/10] block: don't update BLK_FEAT_POLL in __blk_mq_update_nr_hw_queues
Quoted 13 lines · Christoph Hellwig
Quoted 11 lines · Nilay Shroff
block/blk-core.c static blk_status_t blk_validate_atomic_write_op_size(struct request_queue *q, · line 764
Quoted 9 lines
block/blk-core.c +9
-0+static bool bdev_can_poll (struct block_device *bdev) +{ +struct request_queue *q =bdev_get_queue (bdev); + +if (queue_is_mq (q)) +return blk_mq_can_poll (q->tag_set); +return q->limits.features &BLK_FEAT_POLL ; +} +Should we make
bdev_can_poll()inline ?
Quoted 6 lines
I don't really see the point. It's file local and doesn't have any magic that could confuse the code generator, so we might as well leave it to the compiler. Although that might be about to change per the discussion with Damien, which could require it in blk-sysfs, in which case it should become an inline in a header.
Oh yes, I saw that you moved blk_mq_can_poll() to blk-mq.h and made it inline so thought why bdev_can_poll() can't be made inline? BTW, bdev_can_poll() is called from IO fastpath and so making it inline may slightly improve performance.
On another note, I do see that blk_mq_can_poll() is now only called from bdev_can_poll(). So you may want to merge these two functions in a single call and make that inline.
Thanks,
--Nilay
Christoph Hellwig
maintainerRe: [PATCH 05/10] block: don't update BLK_FEAT_POLL in __blk_mq_update_nr_hw_queues
Quoted 2 lines · Nilay Shroff
Oh yes, I saw that you moved
blk_mq_can_poll()toblk-mq.hand made it inline so thought whybdev_can_poll()can't be made inline?
It can be, but why would you want it to? What do you gain from forcing the compiler to inline it, when sane compilers with a sane inlining threshold will do that anyway.
Quoted 5 lines
BTW,
bdev_can_poll()is called from IO fastpath and so making it inline may slightly improve performance.
On another note, I do see thatblk_mq_can_poll()is now only called frombdev_can_poll(). So you may want to merge these two functions in a single call and make that inline.
I'd rather keep generic block layer logic separate from blk-mq logic. We tend to do a few direct calls into blk-mq from the core code to avoid the indirect call overhead, but we should still keep the code as separate as possible to keep it somewhat modular.
Re: [PATCH 05/10] block: don't update BLK_FEAT_POLL in __blk_mq_update_nr_hw_queues
Quoted 7 lines · Christoph Hellwig
Quoted 2 lines · Nilay Shroff
Oh yes, I saw that you moved
blk_mq_can_poll()toblk-mq.hand made it inline so thought whybdev_can_poll()can't be made inline?It can be, but why would you want it to? What do you gain from forcing the compiler to inline it, when sane compilers with a sane inlining threshold will do that anyway.
Hmm, ok, I was thinking just in case we want to force compiler. What if in case compiler doesn't inline it? However, if we're moving this function to a header then it would be made inline, anyways.
Quoted 7 lines
Quoted 6 lines
BTW,
bdev_can_poll()is called from IO fastpath and so making it inline may slightly improve performance.
On another note, I do see thatblk_mq_can_poll()is now only called frombdev_can_poll(). So you may want to merge these two functions in a single call and make that inline.
Quoted 5 lines
I'd rather keep generic block layer logic separate from blk-mq logic. We tend to do a few direct calls into blk-mq from the core code to avoid the indirect call overhead, but we should still keep the code as separate as possible to keep it somewhat modular.
Okay, make sense.
Thanks,
--Nilay
Christoph Hellwig
maintainerPATCH 6/10 virtio_blk: use queue_limits_commit_update_frozen in cache_type_store
In reply to Christoph HellwigSo far cache_type_store didn't freeze the queue, fix that by using the queue_limits_commit_update_frozen helper.
--- drivers/block/virtio_blk.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/block/virtio_blk.c +1 -1
@@ -1105,7 +1105,7 @@ cache_type_store(struct device *dev, struct device_attribute *attr, lim.features |=BLK_FEAT_WRITE_CACHE ; else lim.features &= ~BLK_FEAT_WRITE_CACHE; - i =queue_limits_commit_update (disk->queue, &lim); + i =queue_limits_commit_update_frozen (disk->queue, &lim);if (i)return i;return count;
Signature · 1 line
2.45.2
Damien Le Moal
maintainerRe: [PATCH 06/10] virtio_blk: use queue_limits_commit_update_frozen in cache_type_store
Quoted 4 lines · Christoph Hellwig
So far
cache_type_storedidn't freeze the queue, fix that by using thequeue_limits_commit_update_frozenhelper.Signed-off-by Christoph Hellwig <[email protected]>
This should be squashed in patch 2, no ?
Quoted 17 lines
--- drivers/block/virtio_blk.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)drivers/block/virtio_blk.c +1
-1@@ -1105,7 +1105,7 @@ cache_type_store(struct device *dev, struct device_attribute *attr, lim.features |=BLK_FEAT_WRITE_CACHE ; else lim.features &= ~BLK_FEAT_WRITE_CACHE; - i =queue_limits_commit_update (disk->queue, &lim); + i =queue_limits_commit_update_frozen (disk->queue, &lim);if (i)return i;return count;
Signature · 2 lines
Damien Le Moal Western Digital Research
Christoph Hellwig
maintainerRe: [PATCH 06/10] virtio_blk: use queue_limits_commit_update_frozen in cache_type_store
Quoted 7 lines · Damien Le Moal
Quoted 4 lines · Christoph Hellwig
So far
cache_type_storedidn't freeze the queue, fix that by using thequeue_limits_commit_update_frozenhelper.Signed-off-by Christoph Hellwig <[email protected]>This should be squashed in patch 2, no ?
patch 2 is supposed to just be a mechanical conversion, and each behavior change should be in it's own patch.
Damien Le Moal
maintainerRe: [PATCH 06/10] virtio_blk: use queue_limits_commit_update_frozen in cache_type_store
Quoted 11 lines · Christoph Hellwig
Quoted 7 lines · Damien Le Moal
Quoted 4 lines · Christoph Hellwig
So far
cache_type_storedidn't freeze the queue, fix that by using thequeue_limits_commit_update_frozenhelper.Signed-off-by Christoph Hellwig <[email protected]>This should be squashed in patch 2, no ?
patch 2 is supposed to just be a mechanical conversion, and each behavior change should be in it's own patch.
Sounds good to me, but let's be consistent then: do not remove the freeze/unfreeze from virtio_blk in patch 2 and do it here in this patch. Otherwise, patch 2 *does* change the behavior of virtio_blk, introducing a bug (missing freeze around commit update).
Signature · 2 lines
Damien Le Moal Western Digital Research
Christoph Hellwig
maintainerRe: [PATCH 06/10] virtio_blk: use queue_limits_commit_update_frozen in cache_type_store
Quoted 4 lines · Damien Le Moal
Sounds good to me, but let's be consistent then: do not remove the freeze/unfreeze from
virtio_blkin patch 2 and do it here in this patch. Otherwise, patch 2 *does* change the behavior ofvirtio_blk, introducing a bug (missing freeze around commit update).
Yeah, I'll fix it up. As mentioned in the cover letter I just brushed this up just enough to be presentable for now.
Christoph Hellwig
maintainerPATCH 7/10 usb-storage: use queue_limits_commit_update_frozen in max_sectors_store
In reply to Christoph HellwigUse queue_limits_commit_update_frozen so that limits lock is taken with the queue frozen.
--- drivers/usb/storage/scsiglue.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-)
drivers/usb/storage/scsiglue.c +1 -4
@@ -592,12 +592,9 @@ static ssize_t max_sectors_store(struct device *dev, struct device_attribute *atif (sscanf (buf,"%hu" , &ms) <=0 )return -EINVAL ; -blk_mq_freeze_queue (sdev->request_queue); lim =queue_limits_start_update (sdev->request_queue); lim.max_hw_sectors = ms; - ret =queue_limits_commit_update (sdev->request_queue, &lim); -blk_mq_unfreeze_queue (sdev->request_queue); - + ret =queue_limits_commit_update_frozen (sdev->request_queue, &lim);if (ret)return ret;return count;
Signature · 1 line
2.45.2
Christoph Hellwig
maintainerPATCH 8/10 nvme: freeze queue after taking limits lock
In reply to Christoph HellwigWork towards a consistent locking order by always freezing the queue inside the limits lock.
--- drivers/nvme/host/core.c | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-)
drivers/nvme/host/core.c +5 -4
@@ -2128,9 +2128,10 @@ static int nvme_update_ns_info_generic(struct nvme_ns *ns,struct queue_limits lim;int ret; -blk_mq_freeze_queue (ns->disk->queue); lim =queue_limits_start_update (ns->disk->queue);nvme_set_ctrl_limits (ns->ctrl, &lim); + +blk_mq_freeze_queue (ns->disk->queue); ret =queue_limits_commit_update (ns->disk->queue, &lim);set_disk_ro (ns->disk,nvme_ns_is_readonly (ns, info));blk_mq_unfreeze_queue (ns->disk->queue);
@@ -2177,12 +2178,12 @@ static int nvme_update_ns_info_block(struct nvme_ns *ns, goto out; } + lim =queue_limits_start_update (ns->disk->queue); +blk_mq_freeze_queue (ns->disk->queue); ns->head->lba_shift = id->lbaf[lbaf].ds; ns->head->nuse =le64_to_cpu (id->nuse); capacity =nvme_lba_to_sect (ns->head,le64_to_cpu (id->nsze)); - - lim =queue_limits_start_update (ns->disk->queue);nvme_set_ctrl_limits (ns->ctrl, &lim);nvme_configure_metadata (ns->ctrl, ns->head, id, nvm, info);nvme_set_chunk_sectors (ns, id, &lim);
@@ -2285,6 +2286,7 @@ static int nvme_update_ns_info(struct nvme_ns *ns, struct nvme_ns_info *info)struct queue_limits *ns_lim = &ns->disk->queue->limits;struct queue_limits lim; + lim =queue_limits_start_update (ns->head->disk->queue);blk_mq_freeze_queue (ns->head->disk->queue);/* * queue_limits mixes values that are the hardware limitations
@@ -2301,7 +2303,6 @@ static int nvme_update_ns_info(struct nvme_ns *ns, struct nvme_ns_info *info)* the splitting limits in to make sure we still obey possibly * lower limitations of other controllers. */ - lim =queue_limits_start_update (ns->head->disk->queue); lim.logical_block_size = ns_lim->logical_block_size; lim.physical_block_size = ns_lim->physical_block_size; lim.io_min = ns_lim->io_min;
Signature · 1 line
2.45.2
Christoph Hellwig
maintainerPATCH 9/10 loop: document why loop_clear_limits updates queue limits without freezing
In reply to Christoph Hellwig--- drivers/block/loop.c | 7 +++++++ 1 file changed, 7 insertions(+)
drivers/block/loop.c +7 -0
@@ -311,6 +311,13 @@ static void loop_clear_limits(struct loop_device *lo, int mode) lim.discard_granularity =0 ; } +/* +* XXX: this updates the queue limits without freezing the queue, which +* is against the locking protocol and dangerous. But we can't just +* freeze the queue as we're inside the ->queue_rq method here. So this +* should move out into a workqueue unless we get the file operations to +* advertise if they support specific fallocate operations. +*/ queue_limits_commit_update (lo->lo_queue, &lim); }
Signature · 1 line
2.45.2
Christoph Hellwig
maintainerPATCH 10/10 nbd: use queue_limits_commit_update_frozen in nbd_set_size
In reply to Christoph HellwigApply the consistent freeze vs limit lock order in nbd_set_size by using queue_limits_commit_update_frozen. This also allows to get rid of the lower level __nbd_set_size helper.
--- drivers/block/nbd.c | 17 ++--------------- 1 file changed, 2 insertions(+), 15 deletions(-)
drivers/block/nbd.c +2 -15
@@ -327,8 +327,7 @@ static void nbd_mark_nsock_dead(struct nbd_device *nbd, struct nbd_sock *nsock, nsock->sent =0 ; } -static int __nbd_set_size (struct nbd_device *nbd,loff_t bytesize, -loff_t blksize) +static int nbd_set_size (struct nbd_device *nbd,loff_t bytesize,loff_t blksize) {struct queue_limits lim;int error;
@@ -368,7 +367,7 @@ static int __nbd_set_size(struct nbd_device *nbd, loff_t bytesize, lim.logical_block_size = blksize; lim.physical_block_size = blksize; - error =queue_limits_commit_update (nbd->disk->queue, &lim); + error =queue_limits_commit_update_frozen (nbd->disk->queue, &lim);if (error)return error;
@@ -379,18 +378,6 @@ static int __nbd_set_size(struct nbd_device *nbd, loff_t bytesize,return 0 ; } -static int nbd_set_size (struct nbd_device *nbd,loff_t bytesize, -loff_t blksize) -{ -int error; - -blk_mq_freeze_queue (nbd->disk->queue); - error =__nbd_set_size (nbd, bytesize, blksize); -blk_mq_unfreeze_queue (nbd->disk->queue); - -return error; -} -static void nbd_complete_rq (struct request *req) {struct nbd_cmd *cmd =blk_mq_rq_to_pdu (req);
Signature · 1 line
2.45.2