atomic queue limits updates v2
Subsystems (25)
Christoph Hellwig
maintainerHi Jens,
currently queue limits updates are a mess in that they are updated one limit at a time, which makes both cross-checking them against other limits hard, and also makes it hard to provide atomicy.
This series tries to change this by updating the whole set of queue
limits atomically. This in done in two ways:
- for the initial setup the queue_limits structure is simply passed to the queue/disk allocation helpers and applies there after validation.
- for the (relatively few) cases that update limits at runtime a pair of helpers to take a snapshot of the current limits and to commit it after picking up the callers changes are provided.
As the series is big enough it only converts two drivers - virtio_blk as a heavily used driver in virtualized setups, and loop as one that actually does runtime updates while being fairly simple. I plan to update most drivers for this merge window, although SCSI will probably have to wait for the next one given that it will need extensive API changes in the LLDD and ULD interfaces.
Chances since v1:
- remove a spurious NULL return in blk_alloc_queue
- keep the existing max_discard_sectors == 0 behavior
- drop the patch nvme discard limit update hack - it will go into the series updating nvme instead
- drop a chunk_sector check
- use PAGE_SECTORS in a few places
- document the checks and defaults in blk_validate_limits
- various spelling fixes
Diffstat:
arch/um/drivers/ubd_kern.c | 2 block/blk-core.c | 31 ++- block/blk-mq.c | 26 +-- block/blk-settings.c | 213 ++++++++++++++++++++++++- block/blk-sysfs.c | 59 +++---- block/blk.h | 3 block/bsg-lib.c | 2 block/genhd.c | 4 drivers/block/amiflop.c | 2 drivers/block/aoe/aoeblk.c | 2 drivers/block/ataflop.c | 2 drivers/block/floppy.c | 2 drivers/block/loop.c | 75 ++++----- drivers/block/mtip32xx/mtip32xx.c | 2 drivers/block/nbd.c | 2 drivers/block/null_blk/main.c | 2 drivers/block/ps3disk.c | 2 drivers/block/rbd.c | 2 drivers/block/rnbd/rnbd-clt.c | 2 drivers/block/sunvdc.c | 2 drivers/block/swim.c | 2 drivers/block/swim3.c | 2 drivers/block/ublk_drv.c | 2 drivers/block/virtio_blk.c | 299 ++++++++++++++++++------------------ drivers/block/xen-blkfront.c | 2 drivers/block/z2ram.c | 2 drivers/cdrom/gdrom.c | 2 drivers/memstick/core/ms_block.c | 2 drivers/memstick/core/mspro_block.c | 2 drivers/mmc/core/queue.c | 2 drivers/mtd/mtd_blkdevs.c | 2 drivers/mtd/ubi/block.c | 2 drivers/nvme/host/apple.c | 2 drivers/nvme/host/core.c | 8 drivers/s390/block/dasd_genhd.c | 2 drivers/s390/block/scm_blk.c | 2 drivers/scsi/scsi_scan.c | 2 drivers/ufs/core/ufshcd.c | 2 include/linux/blk-mq.h | 10 - include/linux/blkdev.h | 36 +++- 40 files changed, 526 insertions(+), 296 deletions(-)
Christoph Hellwig
maintainerPATCH 1/14 block: move max_{open,active}_zones to struct queue_limits
The maximum number of open and active zones is a limit on the queue and should be places there so that we can including it in the upcoming queue limits batch update API.
--- include/linux/blkdev.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
include/linux/blkdev.h +6 -6
@@ -189,8 +189,6 @@ struct gendisk {* blk_mq_unfreeze_queue(). */ unsigned int nr_zones; -unsigned int max_open_zones; -unsigned int max_active_zones;unsigned long *conv_zones_bitmap;unsigned long *seq_zones_wlock;#endif /* CONFIG_BLK_DEV_ZONED */
@@ -307,6 +305,8 @@ struct queue_limits {unsigned char discard_misaligned;unsigned char raid_partial_stripes_expensive;bool zoned; +unsigned int max_open_zones; +unsigned int max_active_zones;/* * Drivers that set dma_alignment to less than 511 must be prepared to
@@ -639,23 +639,23 @@ static inline bool disk_zone_is_seq(struct gendisk *disk, sector_t sector)static inline void disk_set_max_open_zones (struct gendisk *disk,unsigned int max_open_zones) { - disk->max_open_zones = max_open_zones; + disk->queue->limits.max_open_zones = max_open_zones; }static inline void disk_set_max_active_zones (struct gendisk *disk,unsigned int max_active_zones) { - disk->max_active_zones = max_active_zones; + disk->queue->limits.max_active_zones = max_active_zones; }static inline unsigned int bdev_max_open_zones (struct block_device *bdev) { -return bdev->bd_disk->max_open_zones; +return bdev->bd_disk->queue->limits.max_open_zones; }static inline unsigned int bdev_max_active_zones (struct block_device *bdev) { -return bdev->bd_disk->max_active_zones; +return bdev->bd_disk->queue->limits.max_active_zones; }#else /* CONFIG_BLK_DEV_ZONED */
Signature · 1 line
2.39.2
Bart Van Assche
reviewerRe: [PATCH 01/14] block: move max_{open,active}_zones to struct queue_limits
Quoted 14 lines · Christoph Hellwig
include/linux/blkdev.h +0
-2@@ -189,8 +189,6 @@ struct gendisk {* blk_mq_unfreeze_queue(). */ unsigned int nr_zones; -unsigned int max_open_zones; -unsigned int max_active_zones;unsigned long *conv_zones_bitmap;unsigned long *seq_zones_wlock;#endif /* CONFIG_BLK_DEV_ZONED */
include/linux/blkdev.h struct queue_limits { · line 309
Quoted 5 lines
include/linux/blkdev.h +2
-0@@ -307,6 +305,8 @@ struct queue_limits {unsigned char discard_misaligned;unsigned char raid_partial_stripes_expensive;bool zoned; +unsigned int max_open_zones; +unsigned int max_active_zones;
Not all struct queue_limits instances are associated with a gendisk. Do we need a way to separate the limits that apply to all request queues from the limits that only apply to disks in struct queue_limits, e.g. a comment that separates the two?
Thanks,
Bart.
Christoph Hellwig
maintainerRe: [PATCH 01/14] block: move max_{open,active}_zones to struct queue_limits
Quoted 11 lines · Bart Van Assche
include/linux/blkdev.h struct queue_limits { · line 309
Quoted 6 lines
include/linux/blkdev.h +2
-0@@ -307,6 +305,8 @@ struct queue_limits {unsigned char discard_misaligned;unsigned char raid_partial_stripes_expensive;bool zoned; +unsigned int max_open_zones; +unsigned int max_active_zones;Not all struct
queue_limitsinstances are associated with a gendisk. Do we need a way to separate the limits that apply to all request queues from the limits that only apply to disks in structqueue_limits, e.g. a comment that separates the two?
I've actually been thinking about that for a while. It does sound like a good idea but I wonder how practical it is. But that is on the table for after we've sorted out the basic API problems, as that makes splitting it much easier if we do that eventually.
Christoph Hellwig
maintainerPATCH 2/14 block: refactor disk_update_readahead
In reply to Christoph HellwigFactor out a blk_apply_bdi_limits limits helper that can be used with an explicit queue_limits argument, which will be useful later.
--- block/blk-settings.c | 21 ++++++++++++--------- 1 file changed, 12 insertions(+), 9 deletions(-)
block/blk-settings.c +12 -9
@@ -85,6 +85,17 @@ void blk_set_stacking_limits(struct queue_limits *lim) }EXPORT_SYMBOL (blk_set_stacking_limits); +static void blk_apply_bdi_limits (struct backing_dev_info *bdi, +struct queue_limits *lim) +{ +/* +* For read-ahead of large files to be effective, we need to read ahead +* at least twice the optimal I/O size. +*/ + bdi->ra_pages =max (lim->io_opt *2 /PAGE_SIZE ,VM_READAHEAD_PAGES ); + bdi->io_pages = lim->max_sectors >> (PAGE_SHIFT -9 ); +} +/** * blk_queue_bounce_limit - set bounce buffer limit for queue * @q: the request queue for the device
@@ -393,15 +404,7 @@ EXPORT_SYMBOL(blk_queue_alignment_offset);void disk_update_readahead (struct gendisk *disk) { -struct request_queue *q = disk->queue; - -/* -* For read-ahead of large files to be effective, we need to read ahead -* at least twice the optimal I/O size. -*/ - disk->bdi->ra_pages = -max (queue_io_opt (q) *2 /PAGE_SIZE ,VM_READAHEAD_PAGES ); - disk->bdi->io_pages =queue_max_sectors (q) >> (PAGE_SHIFT -9 ); +blk_apply_bdi_limits (disk->bdi, &disk->queue->limits); }EXPORT_SYMBOL_GPL (disk_update_readahead);
Signature · 1 line
2.39.2
Bart Van Assche
reviewerRe: [PATCH 02/14] block: refactor disk_update_readahead
block/blk-settings.c void blk_set_stacking_limits(struct queue_limits *lim) · line 97
Quoted 10 lines · Christoph Hellwig
block/blk-settings.c +10
-0+static void blk_apply_bdi_limits (struct backing_dev_info *bdi, +struct queue_limits *lim) +{ +/* +* For read-ahead of large files to be effective, we need to read ahead +* at least twice the optimal I/O size. +*/ + bdi->ra_pages =max (lim->io_opt *2 /PAGE_SIZE ,VM_READAHEAD_PAGES ); + bdi->io_pages = lim->max_sectors >> (PAGE_SHIFT -9 ); +}
Would this be a good opportunity to change (PAGE_SHIFT - 9) into PAGE_SECTORS_SHIFT?
Thanks,
Bart.
Christoph Hellwig
maintainerRe: [PATCH 02/14] block: refactor disk_update_readahead
Quoted 10 lines · Bart Van Assche
block/blk-settings.c void blk_set_stacking_limits(struct queue_limits *lim) · line 97
Quoted 7 lines
block/blk-settings.c +7
-0+/* +* For read-ahead of large files to be effective, we need to read ahead +* at least twice the optimal I/O size. +*/ + bdi->ra_pages =max (lim->io_opt *2 /PAGE_SIZE ,VM_READAHEAD_PAGES ); + bdi->io_pages = lim->max_sectors >> (PAGE_SHIFT -9 ); +}Would this be a good opportunity to change (
PAGE_SHIFT- 9) intoPAGE_SECTORS_SHIFT?
If I have to respin for some reason I'll include it. Otherwise feel free to send a trivial follow on patch.
Christoph Hellwig
maintainerPATCH 3/14 block: add an API to atomically update queue limits
In reply to Christoph HellwigAdd a new queue_limits_{start,commit}_update pair of functions that allows taking an atomic snapshot of queue limits, update it, and commit it if it passes validity checking.
--- block/blk-core.c | 1 + block/blk-settings.c | 182 +++++++++++++++++++++++++++++++++++++++++ block/blk.h | 1 + include/linux/blkdev.h | 23 ++++++ 4 files changed, 207 insertions(+)
block/blk-core.c +1 -0
@@ -424,6 +424,7 @@ struct request_queue *blk_alloc_queue(int node_id)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-settings.c +182 -0
188 lines not on this page · raw message
block/blk.h +1 -0
@@ -447,6 +447,7 @@ static inline void bio_release_page(struct bio *bio, struct page *page)unpin_user_page (page); } +int blk_validate_limits (struct queue_limits *lim);struct request_queue *blk_alloc_queue (int node_id);int disk_scan_partitions (struct gendisk *disk,blk_mode_t mode);
include/linux/blkdev.h +23 -0
@@ -473,6 +473,7 @@ struct request_queue {struct mutex sysfs_lock;struct mutex sysfs_dir_lock; +struct mutex limits_lock;/* * for reusing dead hctx instance in case of updating
@@ -861,6 +862,28 @@ static inline unsigned int blk_chunk_sectors_left(sector_t offset,return chunk_sectors - (offset & (chunk_sectors -1 )); } +/** +* queue_limits_start_update - start an atomic update of queue limits +* @q: queue to update +* +* This functions starts an atomic update of the queue limits. It takes a lock +* to prevent other updates and returns a snapshot of the current limits that +* 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. +*/ +static inline struct queue_limits +queue_limits_start_update (struct request_queue *q) + __acquires(q->limits_lock) +{ +mutex_lock (&q->limits_lock); +return q->limits; +} +int queue_limits_commit_update (struct request_queue *q, +struct queue_limits *lim); +/* * Access functions for manipulating queue properties */
Signature · 1 line
2.39.2
Re: [PATCH 03/14] block: add an API to atomically update queue limits
Quoted 4 lines · Christoph Hellwig
Add a new queue_limits_{start,commit}_update pair of functions that allows taking an atomic snapshot of queue limits, update it, and commit it if it passes validity checking.
Quoted 8 lines
Signed-off-by Christoph Hellwig <[email protected]>--- block/blk-core.c | 1 + block/blk-settings.c | 182 +++++++++++++++++++++++++++++++++++++++++ block/blk.h | 1 + include/linux/blkdev.h | 23 ++++++ 4 files changed, 207 insertions(+)
Cheers,
Hannes
Signature · 5 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Ivo Totev, Andrew McDonald, Werner Knoblich
Re: [PATCH 03/14] block: add an API to atomically update queue limits
In reply to Christoph HellwigQuoted 5 lines · Christoph Hellwig
Add a new queue_limits_{start,commit}_update pair of functions that allows taking an atomic snapshot of queue limits, update it, and commit it if it passes validity checking.
Signed-off-by Christoph Hellwig <[email protected]>
Feel free to add:
However there's still some nitpicking and maybe a real issue, below.
Quoted 24 lines
--- block/blk-core.c | 1 + block/blk-settings.c | 182 +++++++++++++++++++++++++++++++++++++++++ block/blk.h | 1 + include/linux/blkdev.h | 23 ++++++ 4 files changed, 207 insertions(+)block/blk-core.c +1
-0@@ -424,6 +424,7 @@ struct request_queue *blk_alloc_queue(int node_id)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-settings.c +0
-0
block/blk-settings.c static void blk_apply_bdi_limits(struct backing_dev_info *bdi, · line 105
Quoted 10 lines
block/blk-settings.c +7
-0@@ -96,6 +96,188 @@ static void blk_apply_bdi_limits(struct backing_dev_info *bdi, bdi->io_pages = lim->max_sectors >> (PAGE_SHIFT -9 ); } +static int blk_validate_zoned_limits (struct queue_limits *lim) +{ +if (!lim->zoned) { +if (WARN_ON_ONCE (lim->max_open_zones) || +WARN_ON_ONCE (lim->max_active_zones) || +WARN_ON_ONCE (lim->zone_write_granularity) || +WARN_ON_ONCE (lim->max_zone_append_sectors))
nit: some - like me - prefer {} for multi-line if statements, but that's personal taste
Quoted 30 lines
block/blk-settings.c +30
-0+return -EINVAL ; +return 0 ; + } + +if (WARN_ON_ONCE (!IS_ENABLED (CONFIG_BLK_DEV_ZONED ))) +return -EINVAL ; + +if (lim->zone_write_granularity < lim->logical_block_size) + lim->zone_write_granularity = lim->logical_block_size; + +if (lim->max_zone_append_sectors) { +/* +* The Zone Append size is limited by the maximum I/O size +* and the zone size given that it can't span zones. +*/ + lim->max_zone_append_sectors = +min3 (lim->max_hw_sectors, + lim->max_zone_append_sectors, + lim->chunk_sectors); + } + +return 0 ; +} + +/* +* Check that the limits in lim are valid, initialize defaults for unset +* values, and cap values based on others where needed. +*/ +int blk_validate_limits (struct queue_limits *lim) +{
block/blk-settings.c static void blk_apply_bdi_limits(struct backing_dev_info *bdi, · line 145
Quoted 10 lines
block/blk-settings.c +10
-0+unsigned int max_hw_sectors; + +/* +* Unless otherwise specified, default to 512 byte logical blocks and a +* physical block size equal to the logical block size. +*/ +if (!lim->logical_block_size) + lim->logical_block_size =SECTOR_SIZE ; +if (lim->physical_block_size < lim->logical_block_size) + lim->physical_block_size = lim->physical_block_size;
I guess that should really be:lim->physical_block_size = lim->logical_block_size;
Quoted 22 lines
block/blk-settings.c +22
-0+ +/* +* The minimum I/O size defaults to the physical block size unless +* explicitly overridden. +*/ +if (lim->io_min < lim->physical_block_size) + lim->io_min = lim->physical_block_size; + +/* +* max_hw_sectors has a somewhat weird default for historical reason, +* but driver really should set their own instead of relying on this +* value. +* +* The block layer relies on the fact that every driver can +* handle at lest a page worth of data per I/O, and needs the value +* aligned to the logical block size. +*/ +if (!lim->max_hw_sectors) + lim->max_hw_sectors =BLK_SAFE_MAX_SECTORS ; +if (WARN_ON_ONCE (lim->max_hw_sectors <PAGE_SECTORS )) +return -EINVAL ; + lim->max_hw_sectors = round_down(lim->max_hw_sectors,
block/blk-settings.c static void blk_apply_bdi_limits(struct backing_dev_info *bdi, · line 177
Quoted 10 lines
block/blk-settings.c +10
-0+ lim->logical_block_size >> SECTOR_SHIFT); + +/* +* The actual max_sectors value is a complex beast and also takes the +* max_dev_sectors value (set by SCSI ULPs) and a user configurable +* value into account. The ->max_sectors value is always calculated +* from these, so directly setting it won't have any effect. +*/ + max_hw_sectors =min_not_zero (lim->max_hw_sectors, + lim->max_dev_sectors);
nit: maybe we should use a different variable for this for sake of clarity
Quoted 56 lines
block/blk-settings.c +56
-0+if (lim->max_user_sectors) { +if (lim->max_user_sectors > max_hw_sectors || + lim->max_user_sectors <PAGE_SIZE /SECTOR_SIZE ) +return -EINVAL ; + lim->max_sectors =min (max_hw_sectors, lim->max_user_sectors); + }else { + lim->max_sectors =min (max_hw_sectors,BLK_DEF_MAX_SECTORS_CAP ); + } + lim->max_sectors =round_down (lim->max_sectors, + lim->logical_block_size >>SECTOR_SHIFT ); + +/* +* Random default for the maximum number of sectors. Driver should not +* rely on this and set their own. +*/ +if (!lim->max_segments) + lim->max_segments =BLK_MAX_SEGMENTS ; + + lim->max_discard_sectors = lim->max_hw_discard_sectors; +if (!lim->max_discard_segments) + lim->max_discard_segments =1 ; + +if (lim->discard_granularity < lim->physical_block_size) + lim->discard_granularity = lim->physical_block_size; + +/* +* By default there is no limit on the segment boundary alignment, +* but if there is one it can't be smaller than the page size as +* that would break all the normal I/O patterns. +*/ +if (!lim->seg_boundary_mask) + lim->seg_boundary_mask =BLK_SEG_BOUNDARY_MASK ; +if (WARN_ON_ONCE (lim->seg_boundary_mask <PAGE_SIZE -1 )) +return -EINVAL ; + +/* +* The maximum segment size has an odd historic 64k default that +* drivers probably should override. Just like the I/O size we +* require drivers to at least handle a full page per segment. +*/ +if (!lim->max_segment_size) + lim->max_segment_size =BLK_MAX_SEGMENT_SIZE ; +if (WARN_ON_ONCE (lim->max_segment_size <PAGE_SIZE )) +return -EINVAL ; + +/* +* Devices that require a virtual boundary do not support scatter/gather +* I/O natively, but instead require a descriptor list entry for each +* page (which might not be identical to the Linux PAGE_SIZE). Because +* of that they are not limited by our notion of "segment size". +*/ +if (lim->virt_boundary_mask) { +if (WARN_ON_ONCE (lim->max_segment_size && + lim->max_segment_size !=UINT_MAX )) +return -EINVAL ; + lim->max_segment_size =UINT_MAX ;
block/blk-settings.c static void blk_apply_bdi_limits(struct backing_dev_info *bdi, · line 243
Quoted 10 lines
block/blk-settings.c +10
-0+ } + +/* +* We require drivers to at least do logical block aligned I/O, but +* historically could not check for that due to the separate calls +* to set the limits. Once the transition is finished the check +* below should be narrowed down to check the logical block size. +*/ +if (!lim->dma_alignment) + lim->dma_alignment =SECTOR_SIZE -1 ;
It would be also nice to update blk_set_default_limits to use this (and not '511') or also any other instances of hard-coding SECTOR_SIZE for 512
Quoted 11 lines
block/blk-settings.c +11
-0+if (WARN_ON_ONCE (lim->dma_alignment >PAGE_SIZE )) +return -EINVAL ; + +if (lim->alignment_offset) { + lim->alignment_offset &= (lim->physical_block_size -1 ); + lim->misaligned =0 ; + } + +return blk_validate_zoned_limits (lim); +} +
Christoph Hellwig
maintainerRe: [PATCH 03/14] block: add an API to atomically update queue limits
Quoted 11 lines · John Garry
block/blk-settings.c static void blk_apply_bdi_limits(struct backing_dev_info *bdi, · line 105
Quoted 6 lines
block/blk-settings.c +6
-0+{ +if (!lim->zoned) { +if (WARN_ON_ONCE (lim->max_open_zones) || +WARN_ON_ONCE (lim->max_active_zones) || +WARN_ON_ONCE (lim->zone_write_granularity) || +WARN_ON_ONCE (lim->max_zone_append_sectors))nit: some - like me - prefer {} for multi-line if statements, but that's personal taste
Review
Quoted 1 line
(quoted diff) +1
-0+ return -EINVAL;
That would be really weird and contrary to the normal Linux style.
Quoted 7 lines
block/blk-settings.c static void blk_apply_bdi_limits(struct backing_dev_info *bdi, · line 145
Quoted 4 lines
block/blk-settings.c +4
-0+if (!lim->logical_block_size) + lim->logical_block_size =SECTOR_SIZE ; +if (lim->physical_block_size < lim->logical_block_size) + lim->physical_block_size = lim->physical_block_size;I guess that should really be:
lim->physical_block_size=lim->logical_block_size;
Thanks, that does need fixing.
Quoted 5 lines
Quoted 5 lines
block/blk-settings.c +5
-0+ lim->max_hw_sectors =round_down (lim->max_hw_sectors, + lim->logical_block_size >>SECTOR_SHIFT ); + +/* +* The actual max_sectors value is a complex beast and also takes the
Quoted 8 lines
block/blk-settings.c static void blk_apply_bdi_limits(struct backing_dev_info *bdi, · line 177
Quoted 6 lines
block/blk-settings.c +6
-0+* max_dev_sectors value (set by SCSI ULPs) and a user configurable +* value into account. The ->max_sectors value is always calculated +* from these, so directly setting it won't have any effect. +*/ + max_hw_sectors =min_not_zero (lim->max_hw_sectors, + lim->max_dev_sectors);nit: maybe we should use a different variable for this for sake of clarity
What variable name would work better for you?
Quoted 11 lines
block/blk-settings.c static void blk_apply_bdi_limits(struct backing_dev_info *bdi, · line 243
Quoted 8 lines
block/blk-settings.c +8
-0+/* +* We require drivers to at least do logical block aligned I/O, but +* historically could not check for that due to the separate calls +* to set the limits. Once the transition is finished the check +* below should be narrowed down to check the logical block size. +*/ +if (!lim->dma_alignment) + lim->dma_alignment =SECTOR_SIZE -1 ;It would be also nice to update
blk_set_default_limitsto use this (and not '511') or also any other instances of hard-codingSECTOR_SIZEfor 512
That would be nice, but defintively not in scope for this patch.
Re: [PATCH 03/14] block: add an API to atomically update queue limits
Quoted 10 lines · Christoph Hellwig
Quoted 9 lines
block/blk-settings.c static void blk_apply_bdi_limits(struct backing_dev_info *bdi, · line 177
Quoted 8 lines
block/blk-settings.c +8
-0+/* +* The actual max_sectors value is a complex beast and also takes the +* max_dev_sectors value (set by SCSI ULPs) and a user configurable +* value into account. The ->max_sectors value is always calculated +* from these, so directly setting it won't have any effect. +*/ + max_hw_sectors =min_not_zero (lim->max_hw_sectors, + lim->max_dev_sectors);nit: maybe we should use a different variable for this for sake of clarity
What variable name would work better for you?
Maybe max_dev_sectors. No big deal to keep as is.
Quoted 2 lines
Quoted 2 lines
Quoted 2 lines
(quoted diff) +1
-0+ /*
Christoph Hellwig
maintainerPATCH 4/14 block: use queue_limits_commit_update in queue_max_sectors_store
In reply to Christoph HellwigConvert queue_max_sectors_store to use queue_limits_commit_update to check and update the max_sectors limit and freeze the queue before doing so to ensure we don't have requests in flight while changing the limits.
Note that this removes the previously held queue_lock that doesn't protect against any other reader or writer.
--- block/blk-sysfs.c | 37 ++++++++++++------------------------- 1 file changed, 12 insertions(+), 25 deletions(-)
block/blk-sysfs.c +12 -25
@@ -226,35 +226,22 @@ static ssize_t queue_zone_append_max_show(struct request_queue *q, char *page)static ssize_t queue_max_sectors_store (struct request_queue *q,const char *page,size_t count) { -unsigned long var; -unsigned int max_sectors_kb, - max_hw_sectors_kb =queue_max_hw_sectors (q) >>1 , - page_kb =1 << (PAGE_SHIFT -10 ); -ssize_t ret =queue_var_store (&var, page, count); +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; - max_sectors_kb = (unsigned int )var; - max_hw_sectors_kb =min_not_zero (max_hw_sectors_kb, - q->limits.max_dev_sectors >>1 ); -if (max_sectors_kb ==0 ) { - q->limits.max_user_sectors =0 ; - max_sectors_kb =min (max_hw_sectors_kb, -BLK_DEF_MAX_SECTORS_CAP >>1 ); - }else { -if (max_sectors_kb > max_hw_sectors_kb || - max_sectors_kb < page_kb) -return -EINVAL ; - q->limits.max_user_sectors = max_sectors_kb <<1 ; - } - -spin_lock_irq (&q->queue_lock); - q->limits.max_sectors = max_sectors_kb <<1 ; -if (q->disk) - q->disk->bdi->io_pages = max_sectors_kb >> (PAGE_SHIFT -10 ); -spin_unlock_irq (&q->queue_lock); - +blk_mq_freeze_queue (q); + lim =queue_limits_start_update (q); + lim.max_user_sectors = max_sectors_kb <<1 ; + err =queue_limits_commit_update (q, &lim); +blk_mq_unfreeze_queue (q); +if (err) +return err;return ret; }
Signature · 1 line
2.39.2
Re: [PATCH 04/14] block: use queue_limits_commit_update in queue_max_sectors_store
Quoted 7 lines · Christoph Hellwig
Convert
queue_max_sectors_storeto usequeue_limits_commit_updateto check and update themax_sectorslimit and freeze the queue before doing so to ensure we don't have requests in flight while changing the limits.Note that this removes the previously held
queue_lockthat doesn't protect against any other reader or writer.
I don't really get why we specifically locked that code segment in queue_max_sectors_store() previously. Was it to ensure max_sectors and q->disk->bdi->io_pages are always atomically updated?
Quoted 4 lines
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Damien Le Moal <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>
Feel free to add:
Christoph Hellwig
maintainerRe: [PATCH 04/14] block: use queue_limits_commit_update in queue_max_sectors_store
Quoted 6 lines · John Garry
Quoted 5 lines · Christoph Hellwig
Convert
queue_max_sectors_storeto usequeue_limits_commit_updateto check and update themax_sectorslimit and freeze the queue before doing so to ensure we don't have requests in flight while changing the limits.
Quoted 6 lines
Quoted 2 lines
Note that this removes the previously held
queue_lockthat doesn't protect against any other reader or writer.I don't really get why we specifically locked that code segment in
queue_max_sectors_store()previously. Was it to ensuremax_sectorsandq->disk->bdi->io_pagesare always atomically updated?
It's been there basically forever. Back in the day before blk-mq and lock splitting it might actually have protected something.
Christoph Hellwig
maintainerPATCH 5/14 block: add a max_user_discard_sectors queue limit
In reply to Christoph HellwigAdd a new max_user_discard_sectors limit that mirrors max_user_sectors and stores the value that the user manually set. This now allows updates of the max_hw_discard_sectors to not worry about the user limit.
--- block/blk-settings.c | 12 +++++++++--- block/blk-sysfs.c | 18 +++++++++--------- include/linux/blkdev.h | 1 + 3 files changed, 19 insertions(+), 12 deletions(-)
block/blk-settings.c +9 -3
@@ -47,6 +47,7 @@ void blk_set_default_limits(struct queue_limits *lim) lim->max_zone_append_sectors =0 ; lim->max_discard_sectors =0 ; lim->max_hw_discard_sectors =0 ; + lim->max_user_discard_sectors =UINT_MAX ; lim->max_secure_erase_sectors =0 ; lim->discard_granularity =512 ; lim->discard_alignment =0 ;
@@ -193,7 +194,9 @@ int blk_validate_limits(struct queue_limits *lim)if (!lim->max_segments) lim->max_segments =BLK_MAX_SEGMENTS ; - lim->max_discard_sectors = lim->max_hw_discard_sectors; + lim->max_discard_sectors = +min (lim->max_hw_discard_sectors, lim->max_user_discard_sectors); +if (!lim->max_discard_segments) lim->max_discard_segments =1 ;
@@ -370,8 +373,11 @@ EXPORT_SYMBOL(blk_queue_chunk_sectors);void blk_queue_max_discard_sectors (struct request_queue *q,unsigned int max_discard_sectors) { - q->limits.max_hw_discard_sectors = max_discard_sectors; - q->limits.max_discard_sectors = max_discard_sectors; +struct queue_limits *lim = &q->limits; + + lim->max_hw_discard_sectors = max_discard_sectors; + lim->max_discard_sectors = +min (max_discard_sectors, lim->max_user_discard_sectors); }EXPORT_SYMBOL (blk_queue_max_discard_sectors);
block/blk-sysfs.c +9 -9
@@ -174,23 +174,23 @@ static ssize_t queue_discard_max_show(struct request_queue *q, char *page)static ssize_t queue_discard_max_store (struct request_queue *q,const char *page,size_t count) { -unsigned long max_discard; -ssize_t ret =queue_var_store (&max_discard, page, count); +unsigned long max_discard_bytes; +ssize_t ret; + ret =queue_var_store (&max_discard_bytes, page, count);if (ret <0 )return ret; -if (max_discard & (q->limits.discard_granularity -1 )) +if (max_discard_bytes & (q->limits.discard_granularity -1 ))return -EINVAL ; - max_discard >>=9 ; -if (max_discard >UINT_MAX ) +if ((max_discard_bytes >>SECTOR_SHIFT ) >UINT_MAX )return -EINVAL ; -if (max_discard > q->limits.max_hw_discard_sectors) - max_discard = q->limits.max_hw_discard_sectors; - - q->limits.max_discard_sectors = max_discard; + q->limits.max_user_discard_sectors = max_discard_bytes >>SECTOR_SHIFT ; + q->limits.max_discard_sectors = +min_not_zero (q->limits.max_hw_discard_sectors, + q->limits.max_user_discard_sectors);return ret; }
include/linux/blkdev.h +1 -0
@@ -290,6 +290,7 @@ struct queue_limits {unsigned int io_opt;unsigned int max_discard_sectors;unsigned int max_hw_discard_sectors; +unsigned int max_user_discard_sectors;unsigned int max_secure_erase_sectors;unsigned int max_write_zeroes_sectors;unsigned int max_zone_append_sectors;
Signature · 1 line
2.39.2
Re: [PATCH 05/14] block: add a max_user_discard_sectors queue limit
Quoted 5 lines · Christoph Hellwig
Add a new
max_user_discard_sectorslimit that mirrorsmax_user_sectorsand stores the value that the user manually set. This now allows updates of themax_hw_discard_sectorsto not worry about the user limit.
Quoted 7 lines
Signed-off-by Christoph Hellwig <[email protected]>--- block/blk-settings.c | 12 +++++++++--- block/blk-sysfs.c | 18 +++++++++--------- include/linux/blkdev.h | 1 + 3 files changed, 19 insertions(+), 12 deletions(-)
Cheers,
Hannes
Signature · 5 lines
Dr. Hannes Reinecke Kernel Storage Architect [email protected] +49 911 74053 688 SUSE Software Solutions GmbH, Maxfeldstr. 5, 90409 Nürnberg HRB 36809 (AG Nürnberg), GF: Ivo Totev, Andrew McDonald, Werner Knoblich
Christoph Hellwig
maintainerPATCH 6/14 block: use queue_limits_commit_update in queue_discard_max_store
In reply to Christoph HellwigConvert queue_discard_max_store to use queue_limits_commit_update to check and update the max_discard_sectors limit and freeze the queue before doing so to ensure we don't have requests in flight while changing the limits.
--- block/blk-sysfs.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-)
block/blk-sysfs.c +10 -4
@@ -175,7 +175,9 @@ static ssize_t queue_discard_max_store(struct request_queue *q, const char *page, size_t count) { 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 )
@@ -187,10 +189,14 @@ static ssize_t queue_discard_max_store(struct request_queue *q,if ((max_discard_bytes >>SECTOR_SHIFT ) >UINT_MAX )return -EINVAL ; - q->limits.max_user_discard_sectors = max_discard_bytes >>SECTOR_SHIFT ; - q->limits.max_discard_sectors = -min_not_zero (q->limits.max_hw_discard_sectors, - q->limits.max_user_discard_sectors); +blk_mq_freeze_queue (q); + lim =queue_limits_start_update (q); + lim.max_user_discard_sectors = max_discard_bytes >>SECTOR_SHIFT ; + err =queue_limits_commit_update (q, &lim); +blk_mq_unfreeze_queue (q); + +if (err) +return err;return ret; }
Signature · 1 line
2.39.2
Christoph Hellwig
maintainerPATCH 7/14 block: pass a queue_limits argument to blk_alloc_queue
In reply to Christoph HellwigPass a queue_limits to blk_alloc_queue and apply it if non-NULL. This will allow allocating queues with valid queue limits instead of setting the values one at a time later.
--- block/blk-core.c | 30 ++++++++++++++++++++++-------- block/blk-mq.c | 6 +++--- block/blk.h | 2 +- block/genhd.c | 4 ++-- 4 files changed, 28 insertions(+), 14 deletions(-)
block/blk-core.c +22 -8
@@ -393,24 +393,38 @@ static void blk_timeout_work(struct work_struct *work) { } -struct request_queue *blk_alloc_queue (int node_id) +struct request_queue *blk_alloc_queue (struct queue_limits *lim,int node_id) {struct request_queue *q; +int error; q =kmem_cache_alloc_node (blk_requestq_cachep,GFP_KERNEL | __GFP_ZERO, node_id);if (!q) -return NULL ; +return ERR_PTR (-ENOMEM ); q->last_merge =NULL ; +if (lim) { + error =blk_validate_limits (lim); +if (error) + goto fail_q; + q->limits = *lim; + }else { +blk_set_default_limits (&q->limits); + } + q->id =ida_alloc (&blk_queue_ida,GFP_KERNEL ); -if (q->id <0 ) +if (q->id <0 ) { + error = q->id; goto fail_q; + } q->stats =blk_alloc_queue_stats (); -if (!q->stats) +if (!q->stats) { + error = -ENOMEM ; goto fail_id; + } q->node = node_id;
@@ -435,12 +449,12 @@ struct request_queue *blk_alloc_queue(int node_id)* Init percpu_ref in atomic mode so that it's faster to shutdown. * See blk_register_queue() for details. */ -if (percpu_ref_init (&q->q_usage_counter, + error =percpu_ref_init (&q->q_usage_counter, blk_queue_usage_counter_release, -PERCPU_REF_INIT_ATOMIC ,GFP_KERNEL )) +PERCPU_REF_INIT_ATOMIC ,GFP_KERNEL ); +if (error) goto fail_stats; -blk_set_default_limits (&q->limits); q->nr_requests =BLKDEV_DEFAULT_RQ ;return q;
@@ -451,7 +465,7 @@ struct request_queue *blk_alloc_queue(int node_id)ida_free (&blk_queue_ida, q->id); fail_q:kmem_cache_free (blk_requestq_cachep, q); -return NULL ; +return ERR_PTR (error); }/**
block/blk-mq.c +3 -3
@@ -4092,9 +4092,9 @@ static struct request_queue *blk_mq_init_queue_data(struct blk_mq_tag_set *set,struct request_queue *q;int ret; - q =blk_alloc_queue (set->numa_node); -if (!q) -return ERR_PTR (-ENOMEM ); + q =blk_alloc_queue (NULL , set->numa_node); +if (IS_ERR (q)) +return q; q->queuedata = queuedata; ret =blk_mq_init_allocated_queue (set, q);if (ret) {
block/blk.h +1 -1
@@ -448,7 +448,7 @@ static inline void bio_release_page(struct bio *bio, struct page *page) }int blk_validate_limits (struct queue_limits *lim); -struct request_queue *blk_alloc_queue (int node_id); +struct request_queue *blk_alloc_queue (struct queue_limits *lim,int node_id);int disk_scan_partitions (struct gendisk *disk,blk_mode_t mode);
block/genhd.c +2 -2
@@ -1396,8 +1396,8 @@ struct gendisk *__blk_alloc_disk(int node, struct lock_class_key *lkclass)struct request_queue *q;struct gendisk *disk; - q =blk_alloc_queue (node); -if (!q) + q =blk_alloc_queue (NULL , node); +if (IS_ERR (q))return NULL ; disk =__alloc_disk_node (q, node, lkclass);
Signature · 1 line
2.39.2
Re: [PATCH 07/14] block: pass a queue_limits argument to blk_alloc_queue
Quoted 7 lines · Christoph Hellwig
Pass a
queue_limitstoblk_alloc_queueand apply it if non-NULL. This will allow allocating queues with valid queue limits instead of setting the values one at a time later.Signed-off-by Christoph Hellwig<[email protected]>Reviewed-by Damien Le Moal<[email protected]>Reviewed-by Hannes Reinecke<[email protected]>
FWIW,
Christoph Hellwig
maintainerPATCH 8/14 block: pass a queue_limits argument to blk_mq_init_queue
In reply to Christoph HellwigPass a queue_limits to blk_mq_init_queue and apply it if non-NULL. This will allow allocating queues with valid queue limits instead of setting the values one at a time later.
Also rename the function to blk_mq_alloc_queue as that is a much better name for a function that allocates a queue and always pass the queuedata argument instead of having a separate version for the extra argument.
--- block/blk-mq.c | 19 +++++++------------ block/bsg-lib.c | 2 +- drivers/nvme/host/apple.c | 2 +- drivers/nvme/host/core.c | 6 +++--- drivers/scsi/scsi_scan.c | 2 +- drivers/ufs/core/ufshcd.c | 2 +- include/linux/blk-mq.h | 3 ++- 7 files changed, 16 insertions(+), 20 deletions(-)
block/blk-mq.c +7 -12
@@ -4086,13 +4086,13 @@ void blk_mq_release(struct request_queue *q)blk_mq_sysfs_deinit (q); } -static struct request_queue *blk_mq_init_queue_data (struct blk_mq_tag_set *set, -void *queuedata) +struct request_queue *blk_mq_alloc_queue (struct blk_mq_tag_set *set, +struct queue_limits *lim,void *queuedata) {struct request_queue *q;int ret; - q =blk_alloc_queue (NULL , set->numa_node); + q =blk_alloc_queue (lim, set->numa_node);if (IS_ERR (q))return q; q->queuedata = queuedata;
@@ -4103,20 +4103,15 @@ static struct request_queue *blk_mq_init_queue_data(struct blk_mq_tag_set *set, }return q; } - -struct request_queue *blk_mq_init_queue (struct blk_mq_tag_set *set) -{ -return blk_mq_init_queue_data (set,NULL ); -} -EXPORT_SYMBOL (blk_mq_init_queue); +EXPORT_SYMBOL (blk_mq_alloc_queue);/** * blk_mq_destroy_queue - shutdown a request queue * @q: request queue to shutdown * -* This shuts down a request queue allocated by blk_mq_init_queue(). All future +* This shuts down a request queue allocated by blk_mq_alloc_queue(). All future * requests will be failed with -ENODEV. The caller is responsible for dropping -* the reference from blk_mq_init_queue() by calling blk_put_queue(). +* the reference from blk_mq_alloc_queue() by calling blk_put_queue(). * * Context: can sleep */
@@ -4143,7 +4138,7 @@ struct gendisk *__blk_mq_alloc_disk(struct blk_mq_tag_set *set, void *queuedata,struct request_queue *q;struct gendisk *disk; - q =blk_mq_init_queue_data (set, queuedata); + q =blk_mq_alloc_queue (set,NULL , queuedata);if (IS_ERR (q))return ERR_CAST (q);
block/bsg-lib.c +1 -1
@@ -383,7 +383,7 @@ struct request_queue *bsg_setup_queue(struct device *dev, const char *name,if (blk_mq_alloc_tag_set (set)) goto out_tag_set; - q =blk_mq_init_queue (set); + q =blk_mq_alloc_queue (set,NULL ,NULL );if (IS_ERR (q)) { ret =PTR_ERR (q); goto out_queue;
drivers/nvme/host/apple.c +1 -1
@@ -1515,7 +1515,7 @@ static int apple_nvme_probe(struct platform_device *pdev) goto put_dev; } - anv->ctrl.admin_q =blk_mq_init_queue (&anv->admin_tagset); + anv->ctrl.admin_q =blk_mq_alloc_queue (&anv->admin_tagset,NULL ,NULL );if (IS_ERR (anv->ctrl.admin_q)) { ret = -ENOMEM ; goto put_dev;
drivers/nvme/host/core.c +3 -3
@@ -4313,14 +4313,14 @@ int nvme_alloc_admin_tag_set(struct nvme_ctrl *ctrl, struct blk_mq_tag_set *set,if (ret)return ret; - ctrl->admin_q =blk_mq_init_queue (set); + ctrl->admin_q =blk_mq_alloc_queue (set,NULL ,NULL );if (IS_ERR (ctrl->admin_q)) { ret =PTR_ERR (ctrl->admin_q); goto out_free_tagset; }if (ctrl->ops->flags &NVME_F_FABRICS ) { - ctrl->fabrics_q =blk_mq_init_queue (set); + ctrl->fabrics_q =blk_mq_alloc_queue (set,NULL ,NULL );if (IS_ERR (ctrl->fabrics_q)) { ret =PTR_ERR (ctrl->fabrics_q); goto out_cleanup_admin_q;
@@ -4384,7 +4384,7 @@ int nvme_alloc_io_tag_set(struct nvme_ctrl *ctrl, struct blk_mq_tag_set *set,return ret;if (ctrl->ops->flags &NVME_F_FABRICS ) { - ctrl->connect_q =blk_mq_init_queue (set); + ctrl->connect_q =blk_mq_alloc_queue (set,NULL ,NULL );if (IS_ERR (ctrl->connect_q)) { ret =PTR_ERR (ctrl->connect_q); goto out_free_tag_set;
drivers/scsi/scsi_scan.c +1 -1
@@ -332,7 +332,7 @@ static struct scsi_device *scsi_alloc_sdev(struct scsi_target *starget, sdev->sg_reserved_size =INT_MAX ; - q =blk_mq_init_queue (&sdev->host->tag_set); + q =blk_mq_alloc_queue (&sdev->host->tag_set,NULL ,NULL );if (IS_ERR (q)) {/* release fn is set up in scsi_sysfs_device_initialise, so * have to free and put manually here */
drivers/ufs/core/ufshcd.c +1 -1
@@ -10592,7 +10592,7 @@ int ufshcd_init(struct ufs_hba *hba, void __iomem *mmio_base, unsigned int irq) err =blk_mq_alloc_tag_set (&hba->tmf_tag_set);if (err <0 ) goto out_remove_scsi_host; - hba->tmf_queue =blk_mq_init_queue (&hba->tmf_tag_set); + hba->tmf_queue =blk_mq_alloc_queue (&hba->tmf_tag_set,NULL ,NULL );if (IS_ERR (hba->tmf_queue)) { err =PTR_ERR (hba->tmf_queue); goto free_tmf_tag_set;
include/linux/blk-mq.h +2 -1
@@ -692,7 +692,8 @@ struct gendisk *__blk_mq_alloc_disk(struct blk_mq_tag_set *set, void *queuedata, })struct gendisk *blk_mq_alloc_disk_for_queue (struct request_queue *q,struct lock_class_key *lkclass); -struct request_queue *blk_mq_init_queue (struct blk_mq_tag_set *); +struct request_queue *blk_mq_alloc_queue (struct blk_mq_tag_set *set, +struct queue_limits *lim,void *queuedata);int blk_mq_init_allocated_queue (struct blk_mq_tag_set *set,struct request_queue *q);void blk_mq_destroy_queue (struct request_queue *);
Signature · 1 line
2.39.2
Re: [PATCH 08/14] block: pass a queue_limits argument to blk_mq_init_queue
Quoted 11 lines · Christoph Hellwig
Pass a
queue_limitstoblk_mq_init_queueand apply it if non-NULL. This will allow allocating queues with valid queue limits instead of setting the values one at a time later.Also rename the function to
blk_mq_alloc_queueas that is a much better name for a function that allocates a queue and always pass the queuedata argument instead of having a separate version for the extra argument.Signed-off-by Christoph Hellwig<[email protected]>Reviewed-by Damien Le Moal<[email protected]>Reviewed-by Hannes Reinecke<[email protected]>
FWIW,
Christoph Hellwig
maintainerPATCH 9/14 block: pass a queue_limits argument to blk_mq_alloc_disk
In reply to Christoph HellwigPass a queue_limits to blk_mq_alloc_disk and apply it if non-NULL. This will allow allocating queues with valid queue limits instead of setting the values one at a time later.
--- arch/um/drivers/ubd_kern.c | 2 +- block/blk-mq.c | 5 +++-- drivers/block/amiflop.c | 2 +- drivers/block/aoe/aoeblk.c | 2 +- drivers/block/ataflop.c | 2 +- drivers/block/floppy.c | 2 +- drivers/block/loop.c | 2 +- drivers/block/mtip32xx/mtip32xx.c | 2 +- drivers/block/nbd.c | 2 +- drivers/block/null_blk/main.c | 2 +- drivers/block/ps3disk.c | 2 +- drivers/block/rbd.c | 2 +- drivers/block/rnbd/rnbd-clt.c | 2 +- drivers/block/sunvdc.c | 2 +- drivers/block/swim.c | 2 +- drivers/block/swim3.c | 2 +- drivers/block/ublk_drv.c | 2 +- drivers/block/virtio_blk.c | 2 +- drivers/block/xen-blkfront.c | 2 +- drivers/block/z2ram.c | 2 +- drivers/cdrom/gdrom.c | 2 +- drivers/memstick/core/ms_block.c | 2 +- drivers/memstick/core/mspro_block.c | 2 +- drivers/mmc/core/queue.c | 2 +- drivers/mtd/mtd_blkdevs.c | 2 +- drivers/mtd/ubi/block.c | 2 +- drivers/nvme/host/core.c | 2 +- drivers/s390/block/dasd_genhd.c | 2 +- drivers/s390/block/scm_blk.c | 2 +- include/linux/blk-mq.h | 7 ++++--- 30 files changed, 35 insertions(+), 33 deletions(-)
arch/um/drivers/ubd_kern.c +1 -1
@@ -906,7 +906,7 @@ static int ubd_add(int n, char **error_out)if (err) goto out; - disk =blk_mq_alloc_disk (&ubd_dev->tag_set, ubd_dev); + disk =blk_mq_alloc_disk (&ubd_dev->tag_set,NULL , ubd_dev);if (IS_ERR (disk)) { err =PTR_ERR (disk); goto out_cleanup_tags;
block/blk-mq.c +3 -2
@@ -4132,13 +4132,14 @@ void blk_mq_destroy_queue(struct request_queue *q) }EXPORT_SYMBOL (blk_mq_destroy_queue); -struct gendisk *__blk_mq_alloc_disk (struct blk_mq_tag_set *set,void *queuedata, +struct gendisk *__blk_mq_alloc_disk (struct blk_mq_tag_set *set, +struct queue_limits *lim,void *queuedata,struct lock_class_key *lkclass) {struct request_queue *q;struct gendisk *disk; - q =blk_mq_alloc_queue (set,NULL , queuedata); + q =blk_mq_alloc_queue (set, lim, queuedata);if (IS_ERR (q))return ERR_CAST (q);
drivers/block/amiflop.c +1 -1
@@ -1779,7 +1779,7 @@ static int fd_alloc_disk(int drive, int system)struct gendisk *disk;int err; - disk =blk_mq_alloc_disk (&unit[drive].tag_set,NULL ); + disk =blk_mq_alloc_disk (&unit[drive].tag_set,NULL ,NULL );if (IS_ERR (disk))return PTR_ERR (disk);
drivers/block/aoe/aoeblk.c +1 -1
@@ -370,7 +370,7 @@ aoeblk_gdalloc(void *vp) goto err_mempool; } - gd =blk_mq_alloc_disk (set, d); + gd =blk_mq_alloc_disk (set,NULL , d);if (IS_ERR (gd)) {pr_err ("aoe: cannot allocate block queue for %ld.%d\n" , d->aoemajor, d->aoeminor);
drivers/block/ataflop.c +1 -1
@@ -1994,7 +1994,7 @@ static int ataflop_alloc_disk(unsigned int drive, unsigned int type) {struct gendisk *disk; - disk =blk_mq_alloc_disk (&unit[drive].tag_set,NULL ); + disk =blk_mq_alloc_disk (&unit[drive].tag_set,NULL ,NULL );if (IS_ERR (disk))return PTR_ERR (disk);
drivers/block/floppy.c +1 -1
@@ -4515,7 +4515,7 @@ static int floppy_alloc_disk(unsigned int drive, unsigned int type) {struct gendisk *disk; - disk =blk_mq_alloc_disk (&tag_sets[drive],NULL ); + disk =blk_mq_alloc_disk (&tag_sets[drive],NULL ,NULL );if (IS_ERR (disk))return PTR_ERR (disk);
drivers/block/loop.c +1 -1
@@ -2025,7 +2025,7 @@ static int loop_add(int i)if (err) goto out_free_idr; - disk = lo->lo_disk =blk_mq_alloc_disk (&lo->tag_set, lo); + disk = lo->lo_disk =blk_mq_alloc_disk (&lo->tag_set,NULL , lo);if (IS_ERR (disk)) { err =PTR_ERR (disk); goto out_cleanup_tags;
drivers/block/mtip32xx/mtip32xx.c +1 -1
@@ -3431,7 +3431,7 @@ static int mtip_block_initialize(struct driver_data *dd) goto block_queue_alloc_tag_error; } - dd->disk =blk_mq_alloc_disk (&dd->tags, dd); + dd->disk =blk_mq_alloc_disk (&dd->tags,NULL , dd);if (IS_ERR (dd->disk)) {dev_err (&dd->pdev->dev,"Unable to allocate request queue\n" );
drivers/block/nbd.c +1 -1
@@ -1823,7 +1823,7 @@ static struct nbd_device *nbd_dev_add(int index, unsigned int refs)if (err <0 ) goto out_free_tags; - disk =blk_mq_alloc_disk (&nbd->tag_set,NULL ); + disk =blk_mq_alloc_disk (&nbd->tag_set,NULL ,NULL );if (IS_ERR (disk)) { err =PTR_ERR (disk); goto out_free_idr;
drivers/block/null_blk/main.c +1 -1
@@ -2136,7 +2136,7 @@ static int null_add_dev(struct nullb_device *dev) goto out_cleanup_queues; nullb->tag_set->timeout =5 *HZ ; - nullb->disk =blk_mq_alloc_disk (nullb->tag_set, nullb); + nullb->disk =blk_mq_alloc_disk (nullb->tag_set,NULL , nullb);if (IS_ERR (nullb->disk)) { rv =PTR_ERR (nullb->disk); goto out_cleanup_tags;
drivers/block/ps3disk.c +1 -1
@@ -431,7 +431,7 @@ static int ps3disk_probe(struct ps3_system_bus_device *_dev)if (error) goto fail_teardown; - gendisk =blk_mq_alloc_disk (&priv->tag_set, dev); + gendisk =blk_mq_alloc_disk (&priv->tag_set,NULL , dev);if (IS_ERR (gendisk)) {dev_err (&dev->sbd.core,"%s:%u: blk_mq_alloc_disk failed\n" , __func__, __LINE__);
drivers/block/rbd.c +1 -1
@@ -4966,7 +4966,7 @@ static int rbd_init_disk(struct rbd_device *rbd_dev)if (err)return err; - disk =blk_mq_alloc_disk (&rbd_dev->tag_set, rbd_dev); + disk =blk_mq_alloc_disk (&rbd_dev->tag_set,NULL , rbd_dev);if (IS_ERR (disk)) { err =PTR_ERR (disk); goto out_tag_set;
drivers/block/rnbd/rnbd-clt.c +1 -1
@@ -1408,7 +1408,7 @@ static int rnbd_client_setup_device(struct rnbd_clt_dev *dev, dev->size =le64_to_cpu (rsp->nsectors) *le16_to_cpu (rsp->logical_block_size); - dev->gd =blk_mq_alloc_disk (&dev->sess->tag_set, dev); + dev->gd =blk_mq_alloc_disk (&dev->sess->tag_set,NULL , dev);if (IS_ERR (dev->gd))return PTR_ERR (dev->gd); dev->queue = dev->gd->queue;
drivers/block/sunvdc.c +1 -1
@@ -824,7 +824,7 @@ static int probe_disk(struct vdc_port *port)if (err)return err; - g =blk_mq_alloc_disk (&port->tag_set, port); + g =blk_mq_alloc_disk (&port->tag_set,NULL , port);if (IS_ERR (g)) { printk(KERN_ERR PFX "%s: Could not allocate gendisk.\n", port->vio.name);
drivers/block/swim.c +1 -1
@@ -820,7 +820,7 @@ static int swim_floppy_init(struct swim_priv *swd) goto exit_put_disks; swd->unit[drive].disk = -blk_mq_alloc_disk (&swd->unit[drive].tag_set, +blk_mq_alloc_disk (&swd->unit[drive].tag_set,NULL , &swd->unit[drive]);if (IS_ERR (swd->unit[drive].disk)) {blk_mq_free_tag_set (&swd->unit[drive].tag_set);
drivers/block/swim3.c +1 -1
@@ -1210,7 +1210,7 @@ static int swim3_attach(struct macio_dev *mdev,if (rc) goto out_unregister; - disk =blk_mq_alloc_disk (&fs->tag_set, fs); + disk =blk_mq_alloc_disk (&fs->tag_set,NULL , fs);if (IS_ERR (disk)) { rc =PTR_ERR (disk); goto out_free_tag_set;
drivers/block/ublk_drv.c +1 -1
@@ -2222,7 +2222,7 @@ static int ublk_ctrl_start_dev(struct ublk_device *ub, struct io_uring_cmd *cmd) goto out_unlock; } - disk =blk_mq_alloc_disk (&ub->tag_set,NULL ); + disk =blk_mq_alloc_disk (&ub->tag_set,NULL ,NULL );if (IS_ERR (disk)) { ret =PTR_ERR (disk); goto out_unlock;
drivers/block/virtio_blk.c +1 -1
@@ -1330,7 +1330,7 @@ static int virtblk_probe(struct virtio_device *vdev)if (err) goto out_free_vq; - vblk->disk =blk_mq_alloc_disk (&vblk->tag_set, vblk); + vblk->disk =blk_mq_alloc_disk (&vblk->tag_set,NULL , vblk);if (IS_ERR (vblk->disk)) { err =PTR_ERR (vblk->disk); goto out_free_tags;
drivers/block/xen-blkfront.c +1 -1
@@ -1136,7 +1136,7 @@ static int xlvbd_alloc_gendisk(blkif_sector_t capacity,if (err) goto out_release_minors; - gd =blk_mq_alloc_disk (&info->tag_set, info); + gd =blk_mq_alloc_disk (&info->tag_set,NULL , info);if (IS_ERR (gd)) { err =PTR_ERR (gd); goto out_free_tag_set;
drivers/block/z2ram.c +1 -1
@@ -318,7 +318,7 @@ static int z2ram_register_disk(int minor)struct gendisk *disk;int err; - disk =blk_mq_alloc_disk (&tag_set,NULL ); + disk =blk_mq_alloc_disk (&tag_set,NULL ,NULL );if (IS_ERR (disk))return PTR_ERR (disk);
drivers/cdrom/gdrom.c +1 -1
@@ -778,7 +778,7 @@ static int probe_gdrom(struct platform_device *devptr)if (err) goto probe_fail_free_cd_info; - gd.disk =blk_mq_alloc_disk (&gd.tag_set,NULL ); + gd.disk =blk_mq_alloc_disk (&gd.tag_set,NULL ,NULL );if (IS_ERR (gd.disk)) { err =PTR_ERR (gd.disk); goto probe_fail_free_tag_set;
drivers/memstick/core/ms_block.c +1 -1
@@ -2093,7 +2093,7 @@ static int msb_init_disk(struct memstick_dev *card)if (rc) goto out_release_id; - msb->disk =blk_mq_alloc_disk (&msb->tag_set, card); + msb->disk =blk_mq_alloc_disk (&msb->tag_set,NULL , card);if (IS_ERR (msb->disk)) { rc =PTR_ERR (msb->disk); goto out_free_tag_set;
drivers/memstick/core/mspro_block.c +1 -1
@@ -1138,7 +1138,7 @@ static int mspro_block_init_disk(struct memstick_dev *card)if (rc) goto out_release_id; - msb->disk =blk_mq_alloc_disk (&msb->tag_set, card); + msb->disk =blk_mq_alloc_disk (&msb->tag_set,NULL , card);if (IS_ERR (msb->disk)) { rc =PTR_ERR (msb->disk); goto out_free_tag_set;
drivers/mmc/core/queue.c +1 -1
@@ -447,7 +447,7 @@ struct gendisk *mmc_init_queue(struct mmc_queue *mq, struct mmc_card *card)return ERR_PTR (ret); - disk =blk_mq_alloc_disk (&mq->tag_set, mq); + disk =blk_mq_alloc_disk (&mq->tag_set,NULL , mq);if (IS_ERR (disk)) {blk_mq_free_tag_set (&mq->tag_set);return disk;
drivers/mtd/mtd_blkdevs.c +1 -1
@@ -333,7 +333,7 @@ int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new) goto out_kfree_tag_set;/* Create gendisk */ - gd =blk_mq_alloc_disk (new->tag_set, new); + gd =blk_mq_alloc_disk (new->tag_set,NULL , new);if (IS_ERR (gd)) { ret =PTR_ERR (gd); goto out_free_tag_set;
drivers/mtd/ubi/block.c +1 -1
@@ -393,7 +393,7 @@ int ubiblock_create(struct ubi_volume_info *vi)/* Initialize the gendisk of this ubiblock device */ - gd =blk_mq_alloc_disk (&dev->tag_set, dev); + gd =blk_mq_alloc_disk (&dev->tag_set,NULL , dev);if (IS_ERR (gd)) { ret =PTR_ERR (gd); goto out_free_tags;
drivers/nvme/host/core.c +1 -1
@@ -3643,7 +3643,7 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, struct nvme_ns_info *info)if (!ns)return ; - disk =blk_mq_alloc_disk (ctrl->tagset, ns); + disk =blk_mq_alloc_disk (ctrl->tagset,NULL , ns);if (IS_ERR (disk)) goto out_free_ns; disk->fops = &nvme_bdev_ops;
drivers/s390/block/dasd_genhd.c +1 -1
@@ -58,7 +58,7 @@ int dasd_gendisk_alloc(struct dasd_block *block)if (rc)return rc; - gdp =blk_mq_alloc_disk (&block->tag_set, block); + gdp =blk_mq_alloc_disk (&block->tag_set,NULL , block);if (IS_ERR (gdp)) {blk_mq_free_tag_set (&block->tag_set);return PTR_ERR (gdp);
drivers/s390/block/scm_blk.c +1 -1
@@ -462,7 +462,7 @@ int scm_blk_dev_setup(struct scm_blk_dev *bdev, struct scm_device *scmdev)if (ret) goto out; - bdev->gendisk =blk_mq_alloc_disk (&bdev->tag_set, scmdev); + bdev->gendisk =blk_mq_alloc_disk (&bdev->tag_set,NULL , scmdev);if (IS_ERR (bdev->gendisk)) { ret =PTR_ERR (bdev->gendisk); goto out_tag;
include/linux/blk-mq.h +4 -3
@@ -682,13 +682,14 @@ enum {#define BLK_MQ_NO_HCTX_IDX (-1U) -struct gendisk *__blk_mq_alloc_disk (struct blk_mq_tag_set *set,void *queuedata, +struct gendisk *__blk_mq_alloc_disk (struct blk_mq_tag_set *set, +struct queue_limits *lim,void *queuedata,struct lock_class_key *lkclass); -#define blk_mq_alloc_disk (set, queuedata) \ +#define blk_mq_alloc_disk (set, lim, queuedata) \ ({ \ static struct lock_class_key __key; \ \ - __blk_mq_alloc_disk(set, queuedata, &__key); \ + __blk_mq_alloc_disk(set, lim, queuedata, &__key); \ })struct gendisk *blk_mq_alloc_disk_for_queue (struct request_queue *q,struct lock_class_key *lkclass);
Signature · 1 line
2.39.2
Re: [PATCH 09/14] block: pass a queue_limits argument to blk_mq_alloc_disk
Quoted 8 lines · Christoph Hellwig
Pass a
queue_limitstoblk_mq_alloc_diskand apply it if non-NULL. This will allow allocating queues with valid queue limits instead of setting the values one at a time later.Signed-off-by Christoph Hellwig<[email protected]>Reviewed-by Damien Le Moal<[email protected]>Reviewed-by Hannes Reinecke<[email protected]>---
FWIW,
Christoph Hellwig
maintainerPATCH 10/14 virtio_blk: split virtblk_probe
In reply to Christoph HellwigSplit out a virtblk_read_limits helper that just reads the various queue limits to separate it from the higher level probing logic.
--- drivers/block/virtio_blk.c | 193 +++++++++++++++++++------------------ 1 file changed, 101 insertions(+), 92 deletions(-)
drivers/block/virtio_blk.c +101 -92
@@ -1248,31 +1248,17 @@ static const struct blk_mq_ops virtio_mq_ops = {static unsigned int virtblk_queue_depth;module_param_named (queue_depth, virtblk_queue_depth, uint,0444 ); -static int virtblk_probe (struct virtio_device *vdev) +static int virtblk_read_limits (struct virtio_blk *vblk) { -struct virtio_blk *vblk; -struct request_queue *q; -int err, index; - +struct request_queue *q = vblk->disk->queue; +struct virtio_device *vdev = vblk->vdev;u32 v, blk_size, max_size, sg_elems, opt_io_size;u32 max_discard_segs =0 ;u32 discard_granularity =0 ;u16 min_io_size;u8 physical_block_exp, alignment_offset; -unsigned int queue_depth;size_t max_dma_size; - -if (!vdev->config->get) { -dev_err (&vdev->dev,"%s failure: config access disabled\n" , - __func__); -return -EINVAL ; - } - - err =ida_alloc_range (&vd_index_ida,0 , -minor_to_index (1 <<MINORBITS ) -1 ,GFP_KERNEL ); -if (err <0 ) - goto out; - index = err; +int err;/* We need to know how many segments before we allocate. */ err = virtio_cread_feature(vdev, VIRTIO_BLK_F_SEG_MAX,
@@ -1286,73 +1272,6 @@ static int virtblk_probe(struct virtio_device *vdev)/* Prevent integer overflows and honor max vq size */ sg_elems =min_t (u32, sg_elems,VIRTIO_BLK_MAX_SG_ELEMS -2 ); - vdev->priv = vblk =kmalloc (sizeof (*vblk),GFP_KERNEL ); -if (!vblk) { - err = -ENOMEM ; - goto out_free_index; - } - -mutex_init (&vblk->vdev_mutex); - - vblk->vdev = vdev; - -INIT_WORK (&vblk->config_work, virtblk_config_changed_work); - - err =init_vq (vblk); -if (err) - goto out_free_vblk; - -/* Default queue sizing is to fill the ring. */ -if (!virtblk_queue_depth) { - queue_depth = vblk->vqs[0 ].vq->num_free; -/* ... but without indirect descs, we use 2 descs per req */ -if (!virtio_has_feature (vdev,VIRTIO_RING_F_INDIRECT_DESC )) - queue_depth /=2 ; - }else { - queue_depth = virtblk_queue_depth; - } - -memset (&vblk->tag_set,0 ,sizeof (vblk->tag_set)); - vblk->tag_set.ops = &virtio_mq_ops; - vblk->tag_set.queue_depth = queue_depth; - vblk->tag_set.numa_node =NUMA_NO_NODE ; - vblk->tag_set.flags =BLK_MQ_F_SHOULD_MERGE ; - vblk->tag_set.cmd_size = -sizeof (struct virtblk_req ) + -sizeof (struct scatterlist ) *VIRTIO_BLK_INLINE_SG_CNT ; - vblk->tag_set.driver_data = vblk; - vblk->tag_set.nr_hw_queues = vblk->num_vqs; - vblk->tag_set.nr_maps =1 ; -if (vblk->io_queues[HCTX_TYPE_POLL ]) - vblk->tag_set.nr_maps =3 ; - - err =blk_mq_alloc_tag_set (&vblk->tag_set); -if (err) - goto out_free_vq; - - vblk->disk =blk_mq_alloc_disk (&vblk->tag_set,NULL , vblk); -if (IS_ERR (vblk->disk)) { - err =PTR_ERR (vblk->disk); - goto out_free_tags; - } - q = vblk->disk->queue; - -virtblk_name_format ("vd" , index, vblk->disk->disk_name,DISK_NAME_LEN ); - - vblk->disk->major = major; - vblk->disk->first_minor =index_to_minor (index); - vblk->disk->minors =1 <<PART_BITS ; - vblk->disk->private_data = vblk; - vblk->disk->fops = &virtblk_fops; - vblk->index = index; - -/* configure queue flush support */ -virtblk_update_cache_mode (vdev); - -/* If disk is read-only in the host, the guest should obey */ -if (virtio_has_feature (vdev,VIRTIO_BLK_F_RO )) -set_disk_ro (vblk->disk,1 ); -/* We can handle whatever the host told us to handle. */ blk_queue_max_segments (q, sg_elems);
@@ -1381,7 +1300,7 @@ static int virtblk_probe(struct virtio_device *vdev)dev_err (&vdev->dev,"virtio_blk: invalid block size: 0x%x\n" , blk_size); - goto out_cleanup_disk; +return err; }blk_queue_logical_block_size (q, blk_size);
@@ -1455,8 +1374,7 @@ static int virtblk_probe(struct virtio_device *vdev)if (!v) {dev_err (&vdev->dev,"virtio_blk: secure_erase_sector_alignment can't be 0\n" ); - err = -EINVAL ; - goto out_cleanup_disk; +return -EINVAL ; } discard_granularity =min_not_zero (discard_granularity, v);
@@ -1470,8 +1388,7 @@ static int virtblk_probe(struct virtio_device *vdev)if (!v) {dev_err (&vdev->dev,"virtio_blk: max_secure_erase_sectors can't be 0\n" ); - err = -EINVAL ; - goto out_cleanup_disk; +return -EINVAL ; }blk_queue_max_secure_erase_sectors (q, v);
@@ -1485,8 +1402,7 @@ static int virtblk_probe(struct virtio_device *vdev)if (!v) {dev_err (&vdev->dev,"virtio_blk: max_secure_erase_seg can't be 0\n" ); - err = -EINVAL ; - goto out_cleanup_disk; +return -EINVAL ; } max_discard_segs =min_not_zero (max_discard_segs, v);
@@ -1511,6 +1427,99 @@ static int virtblk_probe(struct virtio_device *vdev) q->limits.discard_granularity = blk_size; } +return 0 ; +} + +static int virtblk_probe (struct virtio_device *vdev) +{ +struct virtio_blk *vblk; +struct request_queue *q; +int err, index; +unsigned int queue_depth; + +if (!vdev->config->get) { +dev_err (&vdev->dev,"%s failure: config access disabled\n" , + __func__); +return -EINVAL ; + } + + err =ida_alloc_range (&vd_index_ida,0 , +minor_to_index (1 <<MINORBITS ) -1 ,GFP_KERNEL ); +if (err <0 ) + goto out; + index = err; + + vdev->priv = vblk =kmalloc (sizeof (*vblk),GFP_KERNEL ); +if (!vblk) { + err = -ENOMEM ; + goto out_free_index; + } + +mutex_init (&vblk->vdev_mutex); + + vblk->vdev = vdev; + +INIT_WORK (&vblk->config_work, virtblk_config_changed_work); + + err =init_vq (vblk); +if (err) + goto out_free_vblk; + +/* Default queue sizing is to fill the ring. */ +if (!virtblk_queue_depth) { + queue_depth = vblk->vqs[0 ].vq->num_free; +/* ... but without indirect descs, we use 2 descs per req */ +if (!virtio_has_feature (vdev,VIRTIO_RING_F_INDIRECT_DESC )) + queue_depth /=2 ; + }else { + queue_depth = virtblk_queue_depth; + } + +memset (&vblk->tag_set,0 ,sizeof (vblk->tag_set)); + vblk->tag_set.ops = &virtio_mq_ops; + vblk->tag_set.queue_depth = queue_depth; + vblk->tag_set.numa_node =NUMA_NO_NODE ; + vblk->tag_set.flags =BLK_MQ_F_SHOULD_MERGE ; + vblk->tag_set.cmd_size = +sizeof (struct virtblk_req ) + +sizeof (struct scatterlist ) *VIRTIO_BLK_INLINE_SG_CNT ; + vblk->tag_set.driver_data = vblk; + vblk->tag_set.nr_hw_queues = vblk->num_vqs; + vblk->tag_set.nr_maps =1 ; +if (vblk->io_queues[HCTX_TYPE_POLL ]) + vblk->tag_set.nr_maps =3 ; + + err =blk_mq_alloc_tag_set (&vblk->tag_set); +if (err) + goto out_free_vq; + + vblk->disk =blk_mq_alloc_disk (&vblk->tag_set,NULL , vblk); +if (IS_ERR (vblk->disk)) { + err =PTR_ERR (vblk->disk); + goto out_free_tags; + } + q = vblk->disk->queue; + +virtblk_name_format ("vd" , index, vblk->disk->disk_name,DISK_NAME_LEN ); + + vblk->disk->major = major; + vblk->disk->first_minor =index_to_minor (index); + vblk->disk->minors =1 <<PART_BITS ; + vblk->disk->private_data = vblk; + vblk->disk->fops = &virtblk_fops; + vblk->index = index; + +/* configure queue flush support */ +virtblk_update_cache_mode (vdev); + +/* If disk is read-only in the host, the guest should obey */ +if (virtio_has_feature (vdev,VIRTIO_BLK_F_RO )) +set_disk_ro (vblk->disk,1 ); + + err =virtblk_read_limits (vblk); +if (err) + goto out_cleanup_disk; +virtblk_update_capacity (vblk, false);virtio_device_ready (vdev);
Signature · 1 line
2.39.2
Christoph Hellwig
maintainerPATCH 11/14 virtio_blk: pass queue_limits to blk_mq_alloc_disk
In reply to Christoph HellwigCall virtblk_read_limits and most of virtblk_probe_zoned_device before allocating the gendisk and thus request_queue and make them read into a queue_limits structure instead. Pass this initialized queue_limits to blk_mq_alloc_disk to set the queue up with the right parameters from the start and only leave a few final touches for zoned devices to be done just before adding the disk.
--- drivers/block/virtio_blk.c | 130 ++++++++++++++++++------------------- 1 file changed, 64 insertions(+), 66 deletions(-)
drivers/block/virtio_blk.c +64 -66
@@ -720,16 +720,15 @@ static int virtblk_report_zones(struct gendisk *disk, sector_t sector,return ret; } -static int virtblk_probe_zoned_device (struct virtio_device *vdev, -struct virtio_blk *vblk, -struct request_queue *q) +static int virtblk_read_zoned_limits (struct virtio_blk *vblk, +struct queue_limits *lim) { +struct virtio_device *vdev = vblk->vdev;u32 v, wg;dev_dbg (&vdev->dev,"probing host-managed zoned device\n" ); -disk_set_zoned (vblk->disk); -blk_queue_flag_set (QUEUE_FLAG_ZONE_RESETALL , q); + lim->zoned = true; virtio_cread(vdev, struct virtio_blk_config, zoned.max_open_zones, &v);
@@ -747,8 +746,8 @@ static int virtblk_probe_zoned_device(struct virtio_device *vdev,dev_warn (&vdev->dev,"zero write granularity reported\n" );return -ENODEV ; } -blk_queue_physical_block_size (q, wg); -blk_queue_io_min (q, wg); + lim->physical_block_size = wg; + lim->io_min = wg;dev_dbg (&vdev->dev,"write granularity = %u\n" , wg);
@@ -764,13 +763,13 @@ static int virtblk_probe_zoned_device(struct virtio_device *vdev, vblk->zone_sectors);return -ENODEV ; } -blk_queue_chunk_sectors (q, vblk->zone_sectors); + lim->chunk_sectors = vblk->zone_sectors;dev_dbg (&vdev->dev,"zone sectors = %u\n" , vblk->zone_sectors);if (virtio_has_feature (vdev,VIRTIO_BLK_F_DISCARD )) {dev_warn (&vblk->vdev->dev,"ignoring negotiated F_DISCARD for zoned device\n" ); -blk_queue_max_discard_sectors (q,0 ); + lim->max_hw_discard_sectors =0 ; } virtio_cread(vdev, struct virtio_blk_config,
@@ -785,25 +784,21 @@ static int virtblk_probe_zoned_device(struct virtio_device *vdev, wg, v); return -ENODEV; } -blk_queue_max_zone_append_sectors (q, v); + lim->max_zone_append_sectors = v;dev_dbg (&vdev->dev,"max append sectors = %u\n" , v); -return blk_revalidate_disk_zones (vblk->disk,NULL ); +return 0 ; } -#else -/* -* Zoned block device support is not configured in this kernel. -* Host-managed zoned devices can't be supported, but others are -* good to go as regular block devices. +* Zoned block device support is not configured in this kernel, host-managed +* zoned devices can't be supported. */ #define virtblk_report_zones NULL - -static inline int virtblk_probe_zoned_device (struct virtio_device *vdev, -struct virtio_blk *vblk,struct request_queue *q) +static inline int virtblk_read_zoned_limits (struct virtio_blk *vblk, +struct queue_limits *lim) { -dev_err (&vdev->dev, +dev_err (&vblk->vdev->dev,"virtio_blk: zoned devices are not supported" );return -EOPNOTSUPP ; }
@@ -1248,9 +1243,9 @@ static const struct blk_mq_ops virtio_mq_ops = {static unsigned int virtblk_queue_depth;module_param_named (queue_depth, virtblk_queue_depth, uint,0444 ); -static int virtblk_read_limits (struct virtio_blk *vblk) +static int virtblk_read_limits (struct virtio_blk *vblk, +struct queue_limits *lim) { -struct request_queue *q = vblk->disk->queue;struct virtio_device *vdev = vblk->vdev;u32 v, blk_size, max_size, sg_elems, opt_io_size;u32 max_discard_segs =0 ;
@@ -1273,10 +1268,10 @@ static int virtblk_read_limits(struct virtio_blk *vblk) sg_elems =min_t (u32, sg_elems,VIRTIO_BLK_MAX_SG_ELEMS -2 );/* We can handle whatever the host told us to handle. */ -blk_queue_max_segments (q, sg_elems); + lim->max_segments = sg_elems;/* No real sector limit. */ -blk_queue_max_hw_sectors (q,UINT_MAX ); + lim->max_hw_sectors =UINT_MAX ; max_dma_size =virtio_max_dma_size (vdev); max_size = max_dma_size >U32_MAX ?U32_MAX : max_dma_size;
@@ -1288,7 +1283,7 @@ static int virtblk_read_limits(struct virtio_blk *vblk)if (!err) max_size =min (max_size, v); -blk_queue_max_segment_size (q, max_size); + lim->max_segment_size = max_size;/* Host can optionally specify the block size of the device */ err = virtio_cread_feature(vdev, VIRTIO_BLK_F_BLK_SIZE,
@@ -1303,35 +1298,34 @@ static int virtblk_read_limits(struct virtio_blk *vblk)return err; } -blk_queue_logical_block_size (q, blk_size); + lim->logical_block_size = blk_size; }else - blk_size =queue_logical_block_size (q); + blk_size = lim->logical_block_size;/* Use topology information if available */ err =virtio_cread_feature (vdev,VIRTIO_BLK_F_TOPOLOGY , struct virtio_blk_config, physical_block_exp, &physical_block_exp);if (!err && physical_block_exp) -blk_queue_physical_block_size (q, - blk_size * (1 << physical_block_exp)); + lim->physical_block_size = blk_size * (1 << physical_block_exp); err =virtio_cread_feature (vdev,VIRTIO_BLK_F_TOPOLOGY , struct virtio_blk_config, alignment_offset, &alignment_offset);if (!err && alignment_offset) -blk_queue_alignment_offset (q, blk_size * alignment_offset); + lim->alignment_offset = blk_size * alignment_offset; err =virtio_cread_feature (vdev,VIRTIO_BLK_F_TOPOLOGY , struct virtio_blk_config, min_io_size, &min_io_size);if (!err && min_io_size) -blk_queue_io_min (q, blk_size * min_io_size); + lim->io_min = blk_size * min_io_size; err =virtio_cread_feature (vdev,VIRTIO_BLK_F_TOPOLOGY , struct virtio_blk_config, opt_io_size, &opt_io_size);if (!err && opt_io_size) -blk_queue_io_opt (q, blk_size * opt_io_size); + lim->io_opt = blk_size * opt_io_size;if (virtio_has_feature (vdev,VIRTIO_BLK_F_DISCARD )) { virtio_cread(vdev, struct virtio_blk_config,
@@ -1339,7 +1333,7 @@ static int virtblk_read_limits(struct virtio_blk *vblk) virtio_cread(vdev, struct virtio_blk_config, max_discard_sectors, &v); -blk_queue_max_discard_sectors (q, v ? v :UINT_MAX ); + lim->max_hw_discard_sectors = v ? v :UINT_MAX ; virtio_cread(vdev, struct virtio_blk_config, max_discard_seg, &max_discard_segs);
@@ -1348,7 +1342,7 @@ static int virtblk_read_limits(struct virtio_blk *vblk)if (virtio_has_feature (vdev,VIRTIO_BLK_F_WRITE_ZEROES )) { virtio_cread(vdev, struct virtio_blk_config, max_write_zeroes_sectors, &v); -blk_queue_max_write_zeroes_sectors (q, v ? v :UINT_MAX ); + lim->max_write_zeroes_sectors = v ? v :UINT_MAX ; }/* The discard and secure erase limits are combined since the Linux
@@ -1391,7 +1385,7 @@ static int virtblk_read_limits(struct virtio_blk *vblk)return -EINVAL ; } -blk_queue_max_secure_erase_sectors (q, v); + lim->max_secure_erase_sectors = v; virtio_cread(vdev, struct virtio_blk_config, max_secure_erase_seg, &v);
@@ -1418,13 +1412,34 @@ static int virtblk_read_limits(struct virtio_blk *vblk)if (!max_discard_segs) max_discard_segs = sg_elems; -blk_queue_max_discard_segments (q, -min (max_discard_segs,MAX_DISCARD_SEGMENTS )); + lim->max_discard_segments = +min (max_discard_segs,MAX_DISCARD_SEGMENTS );if (discard_granularity) - q->limits.discard_granularity = discard_granularity <<SECTOR_SHIFT ; + lim->discard_granularity = + discard_granularity <<SECTOR_SHIFT ;else - q->limits.discard_granularity = blk_size; + lim->discard_granularity = blk_size; + } + +if (virtio_has_feature (vdev,VIRTIO_BLK_F_ZONED )) { +u8 model; + + virtio_cread(vdev, struct virtio_blk_config, zoned.model, &model); +switch (model) { +case VIRTIO_BLK_Z_NONE : +case VIRTIO_BLK_Z_HA : +/* treat host-aware devices as non-zoned */ +return 0 ; +case VIRTIO_BLK_Z_HM : + err =virtblk_read_zoned_limits (vblk, lim); +if (err) +return err; +break ; +default : +dev_err (&vdev->dev,"unsupported zone model %d\n" , model); +return -EINVAL ; + } }return 0 ;
@@ -1433,7 +1448,7 @@ static int virtblk_read_limits(struct virtio_blk *vblk)static int virtblk_probe (struct virtio_device *vdev) {struct virtio_blk *vblk; -struct request_queue *q; +struct queue_limits lim = { };int err, index;unsigned int queue_depth;
@@ -1493,12 +1508,15 @@ static int virtblk_probe(struct virtio_device *vdev)if (err) goto out_free_vq; - vblk->disk =blk_mq_alloc_disk (&vblk->tag_set,NULL , vblk); + err =virtblk_read_limits (vblk, &lim); +if (err) + goto out_free_tags; + + vblk->disk =blk_mq_alloc_disk (&vblk->tag_set, &lim, vblk);if (IS_ERR (vblk->disk)) { err =PTR_ERR (vblk->disk); goto out_free_tags; } - q = vblk->disk->queue;virtblk_name_format ("vd" , index, vblk->disk->disk_name,DISK_NAME_LEN );
@@ -1516,10 +1534,6 @@ static int virtblk_probe(struct virtio_device *vdev)if (virtio_has_feature (vdev,VIRTIO_BLK_F_RO ))set_disk_ro (vblk->disk,1 ); - err =virtblk_read_limits (vblk); -if (err) - goto out_cleanup_disk; -virtblk_update_capacity (vblk, false);virtio_device_ready (vdev);
@@ -1527,27 +1541,11 @@ static int virtblk_probe(struct virtio_device *vdev)* All steps that follow use the VQs therefore they need to be * placed after the virtio_device_ready() call above. */ -if (virtio_has_feature (vdev,VIRTIO_BLK_F_ZONED )) { -u8 model; - - virtio_cread(vdev, struct virtio_blk_config, zoned.model, - &model); -switch (model) { -case VIRTIO_BLK_Z_NONE : -case VIRTIO_BLK_Z_HA : -/* Present the host-aware device as non-zoned */ -break ; -case VIRTIO_BLK_Z_HM : - err =virtblk_probe_zoned_device (vdev, vblk, q); -if (err) - goto out_cleanup_disk; -break ; -default : -dev_err (&vdev->dev,"unsupported zone model %d\n" , - model); - err = -EINVAL ; +if (IS_ENABLED (CONFIG_BLK_DEV_ZONED ) && lim.zoned) { +blk_queue_flag_set (QUEUE_FLAG_ZONE_RESETALL , vblk->disk->queue); + err =blk_revalidate_disk_zones (vblk->disk,NULL ); +if (err) goto out_cleanup_disk; - } } err =device_add_disk (&vdev->dev, vblk->disk, virtblk_attr_groups);
Signature · 1 line
2.39.2
Christoph Hellwig
maintainerPATCH 12/14 loop: cleanup loop_config_discard
In reply to Christoph HellwigInitialize the local variables for the discard max sectors and granularity to zero as a sensible default, and then merge the calls assigning them to the queue limits.
--- drivers/block/loop.c | 27 ++++++++------------------- 1 file changed, 8 insertions(+), 19 deletions(-)
drivers/block/loop.c +8 -19
@@ -755,7 +755,8 @@ static void loop_config_discard(struct loop_device *lo)struct file *file = lo->lo_backing_file;struct inode *inode = file->f_mapping->host;struct request_queue *q = lo->lo_queue; -u32 granularity, max_discard_sectors; +u32 granularity =0 , max_discard_sectors =0 ; +struct kstatfs sbuf;/* * If the backing device is a block device, mirror its zeroing
@@ -775,29 +776,17 @@ static void loop_config_discard(struct loop_device *lo)* We use punch hole to reclaim the free space used by the * image a.k.a. discard. */ - }else if (!file->f_op->fallocate) { - max_discard_sectors =0 ; - granularity =0 ; - - }else { -struct kstatfs sbuf; - + }else if (file->f_op->fallocate && !vfs_statfs (&file->f_path, &sbuf)) { max_discard_sectors =UINT_MAX >>9 ; -if (!vfs_statfs (&file->f_path, &sbuf)) - granularity = sbuf.f_bsize; -else - max_discard_sectors =0 ; + granularity = sbuf.f_bsize; } -if (max_discard_sectors) { +blk_queue_max_discard_sectors (q, max_discard_sectors); +blk_queue_max_write_zeroes_sectors (q, max_discard_sectors); +if (max_discard_sectors) q->limits.discard_granularity = granularity; -blk_queue_max_discard_sectors (q, max_discard_sectors); -blk_queue_max_write_zeroes_sectors (q, max_discard_sectors); - }else { +else q->limits.discard_granularity =0 ; -blk_queue_max_discard_sectors (q,0 ); -blk_queue_max_write_zeroes_sectors (q,0 ); - } } struct loop_worker {
Signature · 1 line
2.39.2
Christoph Hellwig
maintainerPATCH 13/14 loop: pass queue_limits to blk_mq_alloc_disk
In reply to Christoph HellwigPass the max_hw_sector limit loop sets at initialization time directly to blk_mq_alloc_disk instead of updating it right after the allocation.
--- drivers/block/loop.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
drivers/block/loop.c +7 -4
@@ -1971,6 +1971,12 @@ static const struct blk_mq_ops loop_mq_ops = {static int loop_add (int i) { +struct queue_limits lim = { +/* +* Random number picked from the historic block max_sectors cap. +*/ + .max_hw_sectors =2560u , + };struct loop_device *lo;struct gendisk *disk;int err;
@@ -2014,16 +2020,13 @@ static int loop_add(int i)if (err) goto out_free_idr; - disk = lo->lo_disk =blk_mq_alloc_disk (&lo->tag_set,NULL , lo); + disk = lo->lo_disk =blk_mq_alloc_disk (&lo->tag_set, &lim, lo);if (IS_ERR (disk)) { err =PTR_ERR (disk); goto out_cleanup_tags; } lo->lo_queue = lo->lo_disk->queue; -/* random number picked from the history block max_sectors cap */ -blk_queue_max_hw_sectors (lo->lo_queue,2560u ); -/* * By default, we do buffer IO, so it doesn't make sense to enable * merge because the I/O submitted to backing file is handled page by
Signature · 1 line
2.39.2
Christoph Hellwig
maintainerPATCH 14/14 loop: use the atomic queue limits update API
In reply to Christoph HellwigPass the default limits to blk_mq_alloc_disk and then use the queue_limits_{start,commit}_update API to change the limits in an atomic way on existing loop gendisks.
--- drivers/block/loop.c | 41 +++++++++++++++++++++++++---------------- 1 file changed, 25 insertions(+), 16 deletions(-)
drivers/block/loop.c +25 -16
@@ -750,11 +750,11 @@ static void loop_sysfs_exit(struct loop_device *lo) &loop_attribute_group); } -static void loop_config_discard (struct loop_device *lo) +static void loop_config_discard (struct loop_device *lo, +struct queue_limits *lim) {struct file *file = lo->lo_backing_file;struct inode *inode = file->f_mapping->host; -struct request_queue *q = lo->lo_queue;u32 granularity =0 , max_discard_sectors =0 ;struct kstatfs sbuf;
@@ -781,12 +781,12 @@ static void loop_config_discard(struct loop_device *lo) granularity = sbuf.f_bsize; } -blk_queue_max_discard_sectors (q, max_discard_sectors); -blk_queue_max_write_zeroes_sectors (q, max_discard_sectors); + lim->max_hw_discard_sectors = max_discard_sectors; + lim->max_write_zeroes_sectors = max_discard_sectors;if (max_discard_sectors) - q->limits.discard_granularity = granularity; + lim->discard_granularity = granularity;else - q->limits.discard_granularity =0 ; + lim->discard_granularity =0 ; }struct loop_worker {
@@ -975,6 +975,20 @@ loop_set_status_from_info(struct loop_device *lo,return 0 ; } +static int loop_reconfigure_limits (struct loop_device *lo,unsigned short bsize, +bool update_discard_settings) +{ +struct queue_limits lim; + + lim =queue_limits_start_update (lo->lo_queue); + lim.logical_block_size = bsize; + lim.physical_block_size = bsize; + lim.io_min = bsize; +if (update_discard_settings) +loop_config_discard (lo, &lim); +return queue_limits_commit_update (lo->lo_queue, &lim); +} +static int loop_configure (struct loop_device *lo,blk_mode_t mode,struct block_device *bdev,const struct loop_config *config)
@@ -1072,11 +1086,10 @@ static int loop_configure(struct loop_device *lo, blk_mode_t mode,else bsize =512 ; -blk_queue_logical_block_size (lo->lo_queue, bsize); -blk_queue_physical_block_size (lo->lo_queue, bsize); -blk_queue_io_min (lo->lo_queue, bsize); + error =loop_reconfigure_limits (lo, bsize, true); +if (WARN_ON_ONCE (error)) + goto out_unlock; -loop_config_discard (lo);loop_update_rotational (lo);loop_update_dio (lo);loop_sysfs_init (lo);
@@ -1143,9 +1156,7 @@ static void __loop_clr_fd(struct loop_device *lo, bool release) lo->lo_offset =0 ; lo->lo_sizelimit =0 ;memset (lo->lo_file_name,0 ,LO_NAME_SIZE ); -blk_queue_logical_block_size (lo->lo_queue,512 ); -blk_queue_physical_block_size (lo->lo_queue,512 ); -blk_queue_io_min (lo->lo_queue,512 ); +loop_reconfigure_limits (lo,512 , false);invalidate_disk (lo->lo_disk);loop_sysfs_exit (lo);/* let user-space know about this change */
@@ -1477,9 +1488,7 @@ static int loop_set_block_size(struct loop_device *lo, unsigned long arg)invalidate_bdev (lo->lo_device);blk_mq_freeze_queue (lo->lo_queue); -blk_queue_logical_block_size (lo->lo_queue, arg); -blk_queue_physical_block_size (lo->lo_queue, arg); -blk_queue_io_min (lo->lo_queue, arg); + err =loop_reconfigure_limits (lo, arg, false);loop_update_dio (lo);blk_mq_unfreeze_queue (lo->lo_queue);
Signature · 1 line
2.39.2