block: move zone related fields to struct gendisk

Move the zone related fields that are currently stored in
struct request_queue to struct gendisk as these are part of the highlevel
block layer API and are only used for non-passthrough I/O that requires
the gendisk.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Chaitanya Kulkarni <kch@nvidia.com>
Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Link: https://lore.kernel.org/r/20220706070350.1703384-17-hch@lst.de
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/block/blk-mq-debugfs-zoned.c b/block/blk-mq-debugfs-zoned.c
index 038cb627c86896e11282d1ad9173d9a26c913eb6..a77b099c34b7a6b90bdaa48be24f8c942cace2de 100644 (file)
--- a/block/blk-mq-debugfs-zoned.c
+++ b/block/blk-mq-debugfs-zoned.c
@@ -11,11 +11,11 @@ int queue_zone_wlock_show(void *data, struct seq_file *m)
        struct request_queue *q = data;
        unsigned int i;
 
-       if (!q->seq_zones_wlock)
+       if (!q->disk->seq_zones_wlock)
                return 0;
 
-       for (i = 0; i < q->nr_zones; i++)
-               if (test_bit(i, q->seq_zones_wlock))
+       for (i = 0; i < q->disk->nr_zones; i++)
+               if (test_bit(i, q->disk->seq_zones_wlock))
                        seq_printf(m, "%u\n", i);
 
        return 0;

diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
index 5ce72345ac6660e0fb072f12ce206a204c84a278..c0303026752d590a0d2648c34f8165ecf9c6df27 100644 (file)
--- a/block/blk-sysfs.c
+++ b/block/blk-sysfs.c
@@ -325,7 +325,7 @@ static ssize_t queue_zoned_show(struct request_queue *q, char *page)
 
 static ssize_t queue_nr_zones_show(struct request_queue *q, char *page)
 {
-       return queue_var_show(blk_queue_nr_zones(q), page);
+       return queue_var_show(disk_nr_zones(q->disk), page);
 }
 
 static ssize_t queue_max_open_zones_show(struct request_queue *q, char *page)

diff --git a/block/blk-zoned.c b/block/blk-zoned.c
index c2d8a38f449aab680d23dd80dd2a1a750523ba67..7c017458d5ce5e6907f6612b1a15b3b51adc5c4e 100644 (file)
--- a/block/blk-zoned.c
+++ b/block/blk-zoned.c
@@ -57,10 +57,10 @@ EXPORT_SYMBOL_GPL(blk_zone_cond_str);
  */
 bool blk_req_needs_zone_write_lock(struct request *rq)
 {
-       if (!rq->q->seq_zones_wlock)
+       if (blk_rq_is_passthrough(rq))
                return false;
 
-       if (blk_rq_is_passthrough(rq))
+       if (!rq->q->disk->seq_zones_wlock)
                return false;
 
        switch (req_op(rq)) {
@@ -77,7 +77,7 @@ bool blk_req_zone_write_trylock(struct request *rq)
 {
        unsigned int zno = blk_rq_zone_no(rq);
 
-       if (test_and_set_bit(zno, rq->q->seq_zones_wlock))
+       if (test_and_set_bit(zno, rq->q->disk->seq_zones_wlock))
                return false;
 
        WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
@@ -90,7 +90,7 @@ EXPORT_SYMBOL_GPL(blk_req_zone_write_trylock);
 void __blk_req_zone_write_lock(struct request *rq)
 {
        if (WARN_ON_ONCE(test_and_set_bit(blk_rq_zone_no(rq),
-                                         rq->q->seq_zones_wlock)))
+                                         rq->q->disk->seq_zones_wlock)))
                return;
 
        WARN_ON_ONCE(rq->rq_flags & RQF_ZONE_WRITE_LOCKED);
@@ -101,9 +101,9 @@ EXPORT_SYMBOL_GPL(__blk_req_zone_write_lock);
 void __blk_req_zone_write_unlock(struct request *rq)
 {
        rq->rq_flags &= ~RQF_ZONE_WRITE_LOCKED;
-       if (rq->q->seq_zones_wlock)
+       if (rq->q->disk->seq_zones_wlock)
                WARN_ON_ONCE(!test_and_clear_bit(blk_rq_zone_no(rq),
-                                                rq->q->seq_zones_wlock));
+                                                rq->q->disk->seq_zones_wlock));
 }
 EXPORT_SYMBOL_GPL(__blk_req_zone_write_unlock);
 
@@ -189,7 +189,7 @@ static int blk_zone_need_reset_cb(struct blk_zone *zone, unsigned int idx,
 static int blkdev_zone_reset_all_emulated(struct block_device *bdev,
                                          gfp_t gfp_mask)
 {
-       struct request_queue *q = bdev_get_queue(bdev);
+       struct gendisk *disk = bdev->bd_disk;
        sector_t capacity = bdev_nr_sectors(bdev);
        sector_t zone_sectors = bdev_zone_sectors(bdev);
        unsigned long *need_reset;
@@ -197,19 +197,18 @@ static int blkdev_zone_reset_all_emulated(struct block_device *bdev,
        sector_t sector = 0;
        int ret;
 
-       need_reset = blk_alloc_zone_bitmap(q->node, q->nr_zones);
+       need_reset = blk_alloc_zone_bitmap(disk->queue->node, disk->nr_zones);
        if (!need_reset)
                return -ENOMEM;
 
-       ret = bdev->bd_disk->fops->report_zones(bdev->bd_disk, 0,
-                               q->nr_zones, blk_zone_need_reset_cb,
-                               need_reset);
+       ret = disk->fops->report_zones(disk, 0, disk->nr_zones,
+                                      blk_zone_need_reset_cb, need_reset);
        if (ret < 0)
                goto out_free_need_reset;
 
        ret = 0;
        while (sector < capacity) {
-               if (!test_bit(blk_queue_zone_no(q, sector), need_reset)) {
+               if (!test_bit(disk_zone_no(disk, sector), need_reset)) {
                        sector += zone_sectors;
                        continue;
                }
@@ -452,12 +451,10 @@ fail:
 
 void disk_free_zone_bitmaps(struct gendisk *disk)
 {
-       struct request_queue *q = disk->queue;
-
-       kfree(q->conv_zones_bitmap);
-       q->conv_zones_bitmap = NULL;
-       kfree(q->seq_zones_wlock);
-       q->seq_zones_wlock = NULL;
+       kfree(disk->conv_zones_bitmap);
+       disk->conv_zones_bitmap = NULL;
+       kfree(disk->seq_zones_wlock);
+       disk->seq_zones_wlock = NULL;
 }
 
 struct blk_revalidate_zone_args {
@@ -607,9 +604,9 @@ int blk_revalidate_disk_zones(struct gendisk *disk,
        blk_mq_freeze_queue(q);
        if (ret > 0) {
                blk_queue_chunk_sectors(q, args.zone_sectors);
-               q->nr_zones = args.nr_zones;
-               swap(q->seq_zones_wlock, args.seq_zones_wlock);
-               swap(q->conv_zones_bitmap, args.conv_zones_bitmap);
+               disk->nr_zones = args.nr_zones;
+               swap(disk->seq_zones_wlock, args.seq_zones_wlock);
+               swap(disk->conv_zones_bitmap, args.conv_zones_bitmap);
                if (update_driver_data)
                        update_driver_data(disk);
                ret = 0;
@@ -634,9 +631,9 @@ void disk_clear_zone_settings(struct gendisk *disk)
        disk_free_zone_bitmaps(disk);
        blk_queue_flag_clear(QUEUE_FLAG_ZONE_RESETALL, q);
        q->required_elevator_features &= ~ELEVATOR_F_ZBD_SEQ_WRITE;
-       q->nr_zones = 0;
-       q->max_open_zones = 0;
-       q->max_active_zones = 0;
+       disk->nr_zones = 0;
+       disk->max_open_zones = 0;
+       disk->max_active_zones = 0;
        q->limits.chunk_sectors = 0;
        q->limits.zone_write_granularity = 0;
        q->limits.max_zone_append_sectors = 0;

diff --git a/drivers/block/null_blk/zoned.c b/drivers/block/null_blk/zoned.c
index e62c52e964259b4ff931432be131f81b1fb3a997..64b06caab98434f842ff3f5d2126fc5a65544eac 100644 (file)
--- a/drivers/block/null_blk/zoned.c
+++ b/drivers/block/null_blk/zoned.c
@@ -170,7 +170,7 @@ int null_register_zoned_dev(struct nullb *nullb)
                        return ret;
        } else {
                blk_queue_chunk_sectors(q, dev->zone_size_sects);
-               q->nr_zones = bdev_nr_zones(nullb->disk->part0);
+               nullb->disk->nr_zones = bdev_nr_zones(nullb->disk->part0);
        }
 
        blk_queue_max_zone_append_sectors(q, dev->zone_size_sects);

diff --git a/drivers/md/dm-zone.c b/drivers/md/dm-zone.c
index 842c31019b513041ce6da47db42e492255385aaf..2b89cde30c9e9d5caff06c4b24f6330f6a370a1f 100644 (file)
--- a/drivers/md/dm-zone.c
+++ b/drivers/md/dm-zone.c
@@ -139,13 +139,11 @@ bool dm_is_zone_write(struct mapped_device *md, struct bio *bio)
 
 void dm_cleanup_zoned_dev(struct mapped_device *md)
 {
-       struct request_queue *q = md->queue;
-
-       if (q) {
-               kfree(q->conv_zones_bitmap);
-               q->conv_zones_bitmap = NULL;
-               kfree(q->seq_zones_wlock);
-               q->seq_zones_wlock = NULL;
+       if (md->disk) {
+               kfree(md->disk->conv_zones_bitmap);
+               md->disk->conv_zones_bitmap = NULL;
+               kfree(md->disk->seq_zones_wlock);
+               md->disk->seq_zones_wlock = NULL;
        }
 
        kvfree(md->zwp_offset);
@@ -179,31 +177,31 @@ static int dm_zone_revalidate_cb(struct blk_zone *zone, unsigned int idx,
                                 void *data)
 {
        struct mapped_device *md = data;
-       struct request_queue *q = md->queue;
+       struct gendisk *disk = md->disk;
 
        switch (zone->type) {
        case BLK_ZONE_TYPE_CONVENTIONAL:
-               if (!q->conv_zones_bitmap) {
-                       q->conv_zones_bitmap =
-                               kcalloc(BITS_TO_LONGS(q->nr_zones),
+               if (!disk->conv_zones_bitmap) {
+                       disk->conv_zones_bitmap =
+                               kcalloc(BITS_TO_LONGS(disk->nr_zones),
                                        sizeof(unsigned long), GFP_NOIO);
-                       if (!q->conv_zones_bitmap)
+                       if (!disk->conv_zones_bitmap)
                                return -ENOMEM;
                }
-               set_bit(idx, q->conv_zones_bitmap);
+               set_bit(idx, disk->conv_zones_bitmap);
                break;
        case BLK_ZONE_TYPE_SEQWRITE_REQ:
        case BLK_ZONE_TYPE_SEQWRITE_PREF:
-               if (!q->seq_zones_wlock) {
-                       q->seq_zones_wlock =
-                               kcalloc(BITS_TO_LONGS(q->nr_zones),
+               if (!disk->seq_zones_wlock) {
+                       disk->seq_zones_wlock =
+                               kcalloc(BITS_TO_LONGS(disk->nr_zones),
                                        sizeof(unsigned long), GFP_NOIO);
-                       if (!q->seq_zones_wlock)
+                       if (!disk->seq_zones_wlock)
                                return -ENOMEM;
                }
                if (!md->zwp_offset) {
                        md->zwp_offset =
-                               kvcalloc(q->nr_zones, sizeof(unsigned int),
+                               kvcalloc(disk->nr_zones, sizeof(unsigned int),
                                         GFP_KERNEL);
                        if (!md->zwp_offset)
                                return -ENOMEM;
@@ -228,7 +226,7 @@ static int dm_zone_revalidate_cb(struct blk_zone *zone, unsigned int idx,
  */
 static int dm_revalidate_zones(struct mapped_device *md, struct dm_table *t)
 {
-       struct request_queue *q = md->queue;
+       struct gendisk *disk = md->disk;
        unsigned int noio_flag;
        int ret;
 
@@ -236,7 +234,7 @@ static int dm_revalidate_zones(struct mapped_device *md, struct dm_table *t)
         * Check if something changed. If yes, cleanup the current resources
         * and reallocate everything.
         */
-       if (!q->nr_zones || q->nr_zones != md->nr_zones)
+       if (!disk->nr_zones || disk->nr_zones != md->nr_zones)
                dm_cleanup_zoned_dev(md);
        if (md->nr_zones)
                return 0;
@@ -246,17 +244,17 @@ static int dm_revalidate_zones(struct mapped_device *md, struct dm_table *t)
         * operations in this context are done as if GFP_NOIO was specified.
         */
        noio_flag = memalloc_noio_save();
-       ret = dm_blk_do_report_zones(md, t, 0, q->nr_zones,
+       ret = dm_blk_do_report_zones(md, t, 0, disk->nr_zones,
                                     dm_zone_revalidate_cb, md);
        memalloc_noio_restore(noio_flag);
        if (ret < 0)
                goto err;
-       if (ret != q->nr_zones) {
+       if (ret != disk->nr_zones) {
                ret = -EIO;
                goto err;
        }
 
-       md->nr_zones = q->nr_zones;
+       md->nr_zones = disk->nr_zones;
 
        return 0;
 
@@ -301,7 +299,7 @@ int dm_set_zones_restrictions(struct dm_table *t, struct request_queue *q)
         * correct value to be exposed in sysfs queue/nr_zones.
         */
        WARN_ON_ONCE(queue_is_mq(q));
-       q->nr_zones = bdev_nr_zones(md->disk->part0);
+       md->disk->nr_zones = bdev_nr_zones(md->disk->part0);
 
        /* Check if zone append is natively supported */
        if (dm_table_supports_zone_append(t)) {
@@ -466,26 +464,26 @@ static blk_status_t dm_zone_map_bio_end(struct mapped_device *md, unsigned int z
        }
 }
 
-static inline void dm_zone_lock(struct request_queue *q,
-                               unsigned int zno, struct bio *clone)
+static inline void dm_zone_lock(struct gendisk *disk, unsigned int zno,
+                               struct bio *clone)
 {
        if (WARN_ON_ONCE(bio_flagged(clone, BIO_ZONE_WRITE_LOCKED)))
                return;
 
-       wait_on_bit_lock_io(q->seq_zones_wlock, zno, TASK_UNINTERRUPTIBLE);
+       wait_on_bit_lock_io(disk->seq_zones_wlock, zno, TASK_UNINTERRUPTIBLE);
        bio_set_flag(clone, BIO_ZONE_WRITE_LOCKED);
 }
 
-static inline void dm_zone_unlock(struct request_queue *q,
-                                 unsigned int zno, struct bio *clone)
+static inline void dm_zone_unlock(struct gendisk *disk, unsigned int zno,
+                                 struct bio *clone)
 {
        if (!bio_flagged(clone, BIO_ZONE_WRITE_LOCKED))
                return;
 
-       WARN_ON_ONCE(!test_bit(zno, q->seq_zones_wlock));
-       clear_bit_unlock(zno, q->seq_zones_wlock);
+       WARN_ON_ONCE(!test_bit(zno, disk->seq_zones_wlock));
+       clear_bit_unlock(zno, disk->seq_zones_wlock);
        smp_mb__after_atomic();
-       wake_up_bit(q->seq_zones_wlock, zno);
+       wake_up_bit(disk->seq_zones_wlock, zno);
 
        bio_clear_flag(clone, BIO_ZONE_WRITE_LOCKED);
 }
@@ -520,7 +518,6 @@ int dm_zone_map_bio(struct dm_target_io *tio)
        struct dm_io *io = tio->io;
        struct dm_target *ti = tio->ti;
        struct mapped_device *md = io->md;
-       struct request_queue *q = md->queue;
        struct bio *clone = &tio->clone;
        struct orig_bio_details orig_bio_details;
        unsigned int zno;
@@ -536,7 +533,7 @@ int dm_zone_map_bio(struct dm_target_io *tio)
 
        /* Lock the target zone */
        zno = bio_zone_no(clone);
-       dm_zone_lock(q, zno, clone);
+       dm_zone_lock(md->disk, zno, clone);
 
        orig_bio_details.nr_sectors = bio_sectors(clone);
        orig_bio_details.op = bio_op(clone);
@@ -546,7 +543,7 @@ int dm_zone_map_bio(struct dm_target_io *tio)
         * both valid, and if the bio is a zone append, remap it to a write.
         */
        if (!dm_zone_map_bio_begin(md, zno, clone)) {
-               dm_zone_unlock(q, zno, clone);
+               dm_zone_unlock(md->disk, zno, clone);
                return DM_MAPIO_KILL;
        }
 
@@ -570,12 +567,12 @@ int dm_zone_map_bio(struct dm_target_io *tio)
                sts = dm_zone_map_bio_end(md, zno, &orig_bio_details,
                                          *tio->len_ptr);
                if (sts != BLK_STS_OK)
-                       dm_zone_unlock(q, zno, clone);
+                       dm_zone_unlock(md->disk, zno, clone);
                break;
        case DM_MAPIO_REQUEUE:
        case DM_MAPIO_KILL:
        default:
-               dm_zone_unlock(q, zno, clone);
+               dm_zone_unlock(md->disk, zno, clone);
                sts = BLK_STS_IOERR;
                break;
        }
@@ -592,7 +589,6 @@ int dm_zone_map_bio(struct dm_target_io *tio)
 void dm_zone_endio(struct dm_io *io, struct bio *clone)
 {
        struct mapped_device *md = io->md;
-       struct request_queue *q = md->queue;
        struct gendisk *disk = md->disk;
        struct bio *orig_bio = io->orig_bio;
        unsigned int zwp_offset;
@@ -651,5 +647,5 @@ void dm_zone_endio(struct dm_io *io, struct bio *clone)
                                zwp_offset - bio_sectors(orig_bio);
        }
 
-       dm_zone_unlock(q, zno, clone);
+       dm_zone_unlock(disk, zno, clone);
 }

diff --git a/drivers/nvme/host/multipath.c b/drivers/nvme/host/multipath.c
index ccf9a6da8f6e1dff6db3bc534f9d18e2a4e3e565..f26640ccb95552ffae8986d4261e0d9ad5ba1844 100644 (file)
--- a/drivers/nvme/host/multipath.c
+++ b/drivers/nvme/host/multipath.c
@@ -830,7 +830,7 @@ void nvme_mpath_add_disk(struct nvme_ns *ns, struct nvme_id_ns *id)
                                   ns->head->disk->queue);
 #ifdef CONFIG_BLK_DEV_ZONED
        if (blk_queue_is_zoned(ns->queue) && ns->head->disk)
-               ns->head->disk->queue->nr_zones = ns->queue->nr_zones;
+               ns->head->disk->nr_zones = ns->disk->nr_zones;
 #endif
 }
 

diff --git a/drivers/nvme/target/zns.c b/drivers/nvme/target/zns.c
index 9d8717126ab3100287208adddf9956fbb2d5857f..c0ee21fcab8169604baed74a58fb9f7e7fbfff57 100644 (file)
--- a/drivers/nvme/target/zns.c
+++ b/drivers/nvme/target/zns.c
@@ -57,7 +57,7 @@ bool nvmet_bdev_zns_enable(struct nvmet_ns *ns)
         * zones, reject the device. Otherwise, use report zones to detect if
         * the device has conventional zones.
         */
-       if (ns->bdev->bd_disk->queue->conv_zones_bitmap)
+       if (ns->bdev->bd_disk->conv_zones_bitmap)
                return false;
 
        ret = blkdev_report_zones(ns->bdev, 0, bdev_nr_zones(ns->bdev),
@@ -414,7 +414,7 @@ static u16 nvmet_bdev_zone_mgmt_emulate_all(struct nvmet_req *req)
        }
 
        while (sector < bdev_nr_sectors(bdev)) {
-               if (test_bit(blk_queue_zone_no(q, sector), d.zbitmap)) {
+               if (test_bit(disk_zone_no(bdev->bd_disk, sector), d.zbitmap)) {
                        bio = blk_next_bio(bio, bdev, 0,
                                zsa_req_op(req->cmd->zms.zsa) | REQ_SYNC,
                                GFP_KERNEL);

diff --git a/drivers/scsi/sd_zbc.c b/drivers/scsi/sd_zbc.c
index b4106f8997342909598ba785ad5e8cf23c00a90b..b8c97456506acc3debe3ca36a9253265f6860a4e 100644 (file)
--- a/drivers/scsi/sd_zbc.c
+++ b/drivers/scsi/sd_zbc.c
@@ -855,7 +855,7 @@ int sd_zbc_revalidate_zones(struct scsi_disk *sdkp)
 
        if (sdkp->zone_info.zone_blocks == zone_blocks &&
            sdkp->zone_info.nr_zones == nr_zones &&
-           disk->queue->nr_zones == nr_zones)
+           disk->nr_zones == nr_zones)
                goto unlock;
 
        flags = memalloc_noio_save();

diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index 810a24884f7ebbd1b54d09cee1b0eefb56d34ea5..d74f6a6b7e69b7e3b672378faed7f0259106a403 100644 (file)
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -1129,12 +1129,12 @@ void blk_dump_rq_flags(struct request *, char *);
 #ifdef CONFIG_BLK_DEV_ZONED
 static inline unsigned int blk_rq_zone_no(struct request *rq)
 {
-       return blk_queue_zone_no(rq->q, blk_rq_pos(rq));
+       return disk_zone_no(rq->q->disk, blk_rq_pos(rq));
 }
 
 static inline unsigned int blk_rq_zone_is_seq(struct request *rq)
 {
-       return blk_queue_zone_is_seq(rq->q, blk_rq_pos(rq));
+       return disk_zone_is_seq(rq->q->disk, blk_rq_pos(rq));
 }
 
 bool blk_req_needs_zone_write_lock(struct request *rq);
@@ -1156,8 +1156,8 @@ static inline void blk_req_zone_write_unlock(struct request *rq)
 
 static inline bool blk_req_zone_is_write_locked(struct request *rq)
 {
-       return rq->q->seq_zones_wlock &&
-               test_bit(blk_rq_zone_no(rq), rq->q->seq_zones_wlock);
+       return rq->q->disk->seq_zones_wlock &&
+               test_bit(blk_rq_zone_no(rq), rq->q->disk->seq_zones_wlock);
 }
 
 static inline bool blk_req_can_dispatch_to_zone(struct request *rq)

diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 21b97f7115dcb64093ee4dda98c90a089551c7d2..22c477fadc0f3830416f01a10b765f1529f99d75 100644 (file)
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -164,6 +164,29 @@ struct gendisk {
 #ifdef  CONFIG_BLK_DEV_INTEGRITY
        struct kobject integrity_kobj;
 #endif /* CONFIG_BLK_DEV_INTEGRITY */
+
+#ifdef CONFIG_BLK_DEV_ZONED
+       /*
+        * Zoned block device information for request dispatch control.
+        * nr_zones is the total number of zones of the device. This is always
+        * 0 for regular block devices. conv_zones_bitmap is a bitmap of nr_zones
+        * bits which indicates if a zone is conventional (bit set) or
+        * sequential (bit clear). seq_zones_wlock is a bitmap of nr_zones
+        * bits which indicates if a zone is write locked, that is, if a write
+        * request targeting the zone was dispatched.
+        *
+        * Reads of this information must be protected with blk_queue_enter() /
+        * blk_queue_exit(). Modifying this information is only allowed while
+        * no requests are being processed. See also blk_mq_freeze_queue() and
+        * 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 */
+
 #if IS_ENABLED(CONFIG_CDROM)
        struct cdrom_device_info *cdi;
 #endif
@@ -467,31 +490,6 @@ struct request_queue {
 
        unsigned int            required_elevator_features;
 
-#ifdef CONFIG_BLK_DEV_ZONED
-       /*
-        * Zoned block device information for request dispatch control.
-        * nr_zones is the total number of zones of the device. This is always
-        * 0 for regular block devices. conv_zones_bitmap is a bitmap of nr_zones
-        * bits which indicates if a zone is conventional (bit set) or
-        * sequential (bit clear). seq_zones_wlock is a bitmap of nr_zones
-        * bits which indicates if a zone is write locked, that is, if a write
-        * request targeting the zone was dispatched. All three fields are
-        * initialized by the low level device driver (e.g. scsi/sd.c).
-        * Stacking drivers (device mappers) may or may not initialize
-        * these fields.
-        *
-        * Reads of this information must be protected with blk_queue_enter() /
-        * blk_queue_exit(). Modifying this information is only allowed while
-        * no requests are being processed. See also blk_mq_freeze_queue() and
-        * blk_mq_unfreeze_queue().
-        */
-       unsigned int            nr_zones;
-       unsigned long           *conv_zones_bitmap;
-       unsigned long           *seq_zones_wlock;
-       unsigned int            max_open_zones;
-       unsigned int            max_active_zones;
-#endif /* CONFIG_BLK_DEV_ZONED */
-
        int                     node;
 #ifdef CONFIG_BLK_DEV_IO_TRACE
        struct blk_trace __rcu  *blk_trace;
@@ -668,63 +666,59 @@ static inline bool blk_queue_is_zoned(struct request_queue *q)
 }
 
 #ifdef CONFIG_BLK_DEV_ZONED
-static inline unsigned int blk_queue_nr_zones(struct request_queue *q)
+static inline unsigned int disk_nr_zones(struct gendisk *disk)
 {
-       return blk_queue_is_zoned(q) ? q->nr_zones : 0;
+       return blk_queue_is_zoned(disk->queue) ? disk->nr_zones : 0;
 }
 
-static inline unsigned int blk_queue_zone_no(struct request_queue *q,
-                                            sector_t sector)
+static inline unsigned int disk_zone_no(struct gendisk *disk, sector_t sector)
 {
-       if (!blk_queue_is_zoned(q))
+       if (!blk_queue_is_zoned(disk->queue))
                return 0;
-       return sector >> ilog2(q->limits.chunk_sectors);
+       return sector >> ilog2(disk->queue->limits.chunk_sectors);
 }
 
-static inline bool blk_queue_zone_is_seq(struct request_queue *q,
-                                        sector_t sector)
+static inline bool disk_zone_is_seq(struct gendisk *disk, sector_t sector)
 {
-       if (!blk_queue_is_zoned(q))
+       if (!blk_queue_is_zoned(disk->queue))
                return false;
-       if (!q->conv_zones_bitmap)
+       if (!disk->conv_zones_bitmap)
                return true;
-       return !test_bit(blk_queue_zone_no(q, sector), q->conv_zones_bitmap);
+       return !test_bit(disk_zone_no(disk, sector), disk->conv_zones_bitmap);
 }
 
 static inline void disk_set_max_open_zones(struct gendisk *disk,
                unsigned int max_open_zones)
 {
-       disk->queue->max_open_zones = max_open_zones;
+       disk->max_open_zones = max_open_zones;
 }
 
 static inline void disk_set_max_active_zones(struct gendisk *disk,
                unsigned int max_active_zones)
 {
-       disk->queue->max_active_zones = max_active_zones;
+       disk->max_active_zones = max_active_zones;
 }
 
 static inline unsigned int bdev_max_open_zones(struct block_device *bdev)
 {
-       return bdev->bd_disk->queue->max_open_zones;
+       return bdev->bd_disk->max_open_zones;
 }
 
 static inline unsigned int bdev_max_active_zones(struct block_device *bdev)
 {
-       return bdev->bd_disk->queue->max_active_zones;
+       return bdev->bd_disk->max_active_zones;
 }
 
 #else /* CONFIG_BLK_DEV_ZONED */
-static inline unsigned int blk_queue_nr_zones(struct request_queue *q)
+static inline unsigned int disk_nr_zones(struct gendisk *disk)
 {
        return 0;
 }
-static inline bool blk_queue_zone_is_seq(struct request_queue *q,
-                                        sector_t sector)
+static inline bool disk_zone_is_seq(struct gendisk *disk, sector_t sector)
 {
        return false;
 }
-static inline unsigned int blk_queue_zone_no(struct request_queue *q,
-                                            sector_t sector)
+static inline unsigned int disk_zone_no(struct gendisk *disk, sector_t sector)
 {
        return 0;
 }
@@ -732,6 +726,7 @@ static inline unsigned int bdev_max_open_zones(struct block_device *bdev)
 {
        return 0;
 }
+
 static inline unsigned int bdev_max_active_zones(struct block_device *bdev)
 {
        return 0;
@@ -900,14 +895,12 @@ const char *blk_zone_cond_str(enum blk_zone_cond zone_cond);
 
 static inline unsigned int bio_zone_no(struct bio *bio)
 {
-       return blk_queue_zone_no(bdev_get_queue(bio->bi_bdev),
-                                bio->bi_iter.bi_sector);
+       return disk_zone_no(bio->bi_bdev->bd_disk, bio->bi_iter.bi_sector);
 }
 
 static inline unsigned int bio_zone_is_seq(struct bio *bio)
 {
-       return blk_queue_zone_is_seq(bdev_get_queue(bio->bi_bdev),
-                                    bio->bi_iter.bi_sector);
+       return disk_zone_is_seq(bio->bi_bdev->bd_disk, bio->bi_iter.bi_sector);
 }
 
 /*