atomic queue limits updates v3
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 v2:
- fix the physical block size default
- use PAGE_SECTORS_SHIFT more
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
Re: [PATCH 01/14] block: move max_{open,active}_zones to struct queue_limits
Quoted 9 lines · Christoph Hellwig
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.
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Damien Le Moal <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>---
Looks good.
-ck
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_SECTORS_SHIFT ; +} +/** * 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
Re: [PATCH 02/14] block: refactor disk_update_readahead
Quoted 8 lines · Christoph Hellwig
Factor out a
blk_apply_bdi_limitslimits helper that can be used with an explicitqueue_limitsargument, which will be useful later.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Damien Le Moal <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>---
Looks good.
-ck
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 8 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]>Reviewed-by John Garry <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>---
Looks good.
-ck
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 8 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.
Quoted 7 lines
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by John Garry <[email protected]>Reviewed-by Damien Le Moal <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>--- block/blk-sysfs.c | 37 ++++++++++++-------------------------
Looks good.
-ck
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 9 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.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>---
Looks good.
-ck
Re: [PATCH 05/14] block: add a max_user_discard_sectors queue limit
In reply to Christoph HellwigQuoted 19 lines · Christoph Hellwig
static
ssize_tqueue_discard_max_store(structrequest_queue*q,block/blk-sysfs.c +5
-5const 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 )
block/blk-sysfs.c static ssize_t queue_discard_max_show(struct request_queue *q, char *page) · line 193
Quoted 10 lines
block/blk-sysfs.c +4
-4return -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);
s/min_not_zero/min
Otherwise the whole series looks pretty good! And with that:
Christoph Hellwig
maintainerRe: [PATCH 05/14] block: add a max_user_discard_sectors queue limit
Quoted 6 lines · Keith Busch
block/blk-sysfs.c static ssize_t queue_discard_max_show(struct request_queue *q, char *page) · line 193
Quoted 4 lines
block/blk-sysfs.c +4
-0+ 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);s/min_not_zero/min
Yes. Fixed up right after when converting to the limits based update, but this does create a bisection hazard as-is.
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
Re: [PATCH 06/14] block: use queue_limits_commit_update in queue_discard_max_store
Quoted 10 lines · Christoph Hellwig
Convert
queue_discard_max_storeto usequeue_limits_commit_updateto check and update themax_discard_sectorslimit and freeze the queue before doing so to ensure we don't have requests in flight while changing the limits.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Damien Le Moal <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>---
Looks good.
-ck
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 10 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 John Garry <[email protected]>Reviewed-by Damien Le Moal <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>---
Looks good.
-ck
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 8 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.
Quoted 6 lines
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by John Garry <[email protected]>Reviewed-by Damien Le Moal <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>---
For NVMe/SCSI part :-
Looks good.
-ck
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
@@ -371,7 +371,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 9 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 John Garry <[email protected]>Reviewed-by Damien Le Moal <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>---
For loop, nbd, null_blk, rbd, rnbd, virtio-blk, xen-blkfront, and nvme part:-
Looks good.
-ck
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
Re: [PATCH 11/14] virtio_blk: pass queue_limits to blk_mq_alloc_disk
Quoted 7 lines · Christoph Hellwig
Call
virtblk_read_limitsand most ofvirtblk_probe_zoned_devicebefore allocating the gendisk and thusrequest_queueand make them read into aqueue_limitsstructure instead. Pass this initializedqueue_limitstoblk_mq_alloc_diskto 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.
Quoted 6 lines
Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Stefan Hajnoczi <[email protected]>Reviewed-by Damien Le Moal <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>---
Looks good.
-ck
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
Re: [PATCH 13/14] loop: pass queue_limits to blk_mq_alloc_disk
Quoted 9 lines · Christoph Hellwig
Pass the
max_hw_sectorlimit loop sets at initialization time directly toblk_mq_alloc_diskinstead of updating it right after the allocation.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Damien Le Moal <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>--- drivers/block/loop.c | 11 +++++++----
Looks good.
-ck
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
Re: [PATCH 14/14] loop: use the atomic queue limits update API
Quoted 9 lines · Christoph Hellwig
Pass the default limits to
blk_mq_alloc_diskand then use the queue_limits_{start,commit}_update API to change the limits in an atomic way on existing loop gendisks.Signed-off-by Christoph Hellwig <[email protected]>Reviewed-by Damien Le Moal <[email protected]>Reviewed-by Hannes Reinecke <[email protected]>---
Looks good.
-ck
Martin K. Petersen
Reviewed-byChristoph,
Quoted 6 lines
As the series is big enough it only converts two drivers -
virtio_blkas 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.
Looks nice in general and avoids the annoyances I had with my discovery series wrt. discard. I'm in the process of rebasing that series to fit on top of your changes and things get cleaned up nicely. We'll probably have to coordinate the sd changes a bit.
Anyway. Great to finally get this resolved!
Signature · 1 line
Martin K. Petersen Oracle Linux Engineering
Christoph Hellwig
maintainerQuoted 4 lines · Martin K. Petersen
Looks nice in general and avoids the annoyances I had with my discovery series wrt. discard. I'm in the process of rebasing that series to fit on top of your changes and things get cleaned up nicely. We'll probably have to coordinate the sd changes a bit.
FYI, I haven't really started on SCSI for a bit of protoyping, and it will take a while to get to it.
Ming Lei
Reviewed-byQuoted 26 lines · Christoph Hellwig
Hi 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_limitsstructure 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_blkas 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 v2:
- fix the physical block size default
- usePAGE_SECTORS_SHIFTmore
Quoted 9 lines
Chances since v1:
- remove a spurious NULL return inblk_alloc_queue
- keep the existingmax_discard_sectors== 0 behavior
- drop the patch nvme discard limit update hack - it will go into the series updating nvme instead
- drop achunk_sectorcheck
- usePAGE_SECTORSin a few places
- document the checks and defaults inblk_validate_limits
- various spelling fixes
For the whole series:
Thanks,
Ming
Christoph Hellwig
maintainerI don't want to spam the list with a full resend again, but I've updated the branch here:
git://git.infradead.org/users/hch/block.git blk-limits-base
http://git.infradead.org/?p=users/hch/block.git;a=shortlog;h=refs/heads/blk-limits-base
with the bisection hazard found by Keith and the various review tags.
Jens Axboe
maintainerQuoted 8 lines · Christoph Hellwig
I don't want to spam the list with a full resend again, but I've updated the branch here:
git://git.infradead.org/users/hch/block.gitblk-limits-basehttp://git.infradead.org/?p=users/hch/block.git;a=shortlog;h=refs/heads/blk-limits-base
with the bisection hazard found by Keith and the various review tags.
Can you send a v4 so we can get it applied?
Signature · 1 line
Jens Axboe