diff mbox series

[14/26] block: move the nonrot flag to queue_limits

Message ID 20240617060532.127975-15-hch@lst.de (mailing list archive)
State New
Headers show
Series [01/26] xen-blkfront: don't disable cache flushes when they fail | expand

Commit Message

Christoph Hellwig June 17, 2024, 6:04 a.m. UTC 
Move the nonrot flag into the queue_limits feature field so that it can
be set atomically with the queue frozen.

Use the chance to switch to defaulting to non-rotational and require
the driver to opt into rotational, which matches the polarity of the
sysfs interface.

For the z2ram, ps3vram, 2x memstick, ubiblock and dcssblk the new
rotational flag is not set as they clearly are not rotational despite
this being a behavior change.  There are some other drivers that
unconditionally set the rotational flag to keep the existing behavior
as they arguably can be used on rotational devices even if that is
probably not their main use today (e.g. virtio_blk and drbd).

The flag is automatically inherited in blk_stack_limits matching the
existing behavior in dm and md.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
---
 arch/m68k/emu/nfblock.c             |  1 +
 arch/um/drivers/ubd_kern.c          |  1 -
 arch/xtensa/platforms/iss/simdisk.c |  5 +++-
 block/blk-mq-debugfs.c              |  1 -
 block/blk-sysfs.c                   | 39 ++++++++++++++++++++++++++---
 drivers/block/amiflop.c             |  5 +++-
 drivers/block/aoe/aoeblk.c          |  1 +
 drivers/block/ataflop.c             |  5 +++-
 drivers/block/brd.c                 |  2 --
 drivers/block/drbd/drbd_main.c      |  3 ++-
 drivers/block/floppy.c              |  3 ++-
 drivers/block/loop.c                |  8 +++---
 drivers/block/mtip32xx/mtip32xx.c   |  1 -
 drivers/block/n64cart.c             |  2 --
 drivers/block/nbd.c                 |  5 ----
 drivers/block/null_blk/main.c       |  1 -
 drivers/block/pktcdvd.c             |  1 +
 drivers/block/ps3disk.c             |  3 ++-
 drivers/block/rbd.c                 |  3 ---
 drivers/block/rnbd/rnbd-clt.c       |  4 ---
 drivers/block/sunvdc.c              |  1 +
 drivers/block/swim.c                |  5 +++-
 drivers/block/swim3.c               |  5 +++-
 drivers/block/ublk_drv.c            |  9 +++----
 drivers/block/virtio_blk.c          |  4 ++-
 drivers/block/xen-blkfront.c        |  1 -
 drivers/block/zram/zram_drv.c       |  2 --
 drivers/cdrom/gdrom.c               |  1 +
 drivers/md/bcache/super.c           |  2 --
 drivers/md/dm-table.c               | 12 ---------
 drivers/md/md.c                     | 13 ----------
 drivers/mmc/core/queue.c            |  1 -
 drivers/mtd/mtd_blkdevs.c           |  1 -
 drivers/nvdimm/btt.c                |  1 -
 drivers/nvdimm/pmem.c               |  1 -
 drivers/nvme/host/core.c            |  1 -
 drivers/nvme/host/multipath.c       |  1 -
 drivers/s390/block/dasd_genhd.c     |  1 -
 drivers/s390/block/scm_blk.c        |  1 -
 drivers/scsi/sd.c                   |  4 +--
 include/linux/blkdev.h              | 10 ++++----
 41 files changed, 83 insertions(+), 88 deletions(-)

Comments

Hannes Reinecke June 17, 2024, 10:36 a.m. UTC | #1 
On 6/17/24 08:04, Christoph Hellwig wrote:
> Move the nonrot flag into the queue_limits feature field so that it can
> be set atomically with the queue frozen.
> 
> Use the chance to switch to defaulting to non-rotational and require
> the driver to opt into rotational, which matches the polarity of the
> sysfs interface.
> 
> For the z2ram, ps3vram, 2x memstick, ubiblock and dcssblk the new
> rotational flag is not set as they clearly are not rotational despite
> this being a behavior change.  There are some other drivers that
> unconditionally set the rotational flag to keep the existing behavior
> as they arguably can be used on rotational devices even if that is
> probably not their main use today (e.g. virtio_blk and drbd).
> 
> The flag is automatically inherited in blk_stack_limits matching the
> existing behavior in dm and md.
> 
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
> ---

Reviewed-by: Hannes Reinecke <hare@suse.de>

Cheers,

Hannes
Simon Fernandez June 19, 2024, 3:23 p.m. UTC | #2 
Hi folks, how can I unsubscribe from this group.?
Thanks in advance.
S

> On 17 Jun 2024, at 07:04, Christoph Hellwig <hch@lst.de> wrote:
> 
> Move the nonrot flag into the queue_limits feature field so that it can
> be set atomically with the queue frozen.
> 
> Use the chance to switch to defaulting to non-rotational and require
> the driver to opt into rotational, which matches the polarity of the
> sysfs interface.
> 
> For the z2ram, ps3vram, 2x memstick, ubiblock and dcssblk the new
> rotational flag is not set as they clearly are not rotational despite
> this being a behavior change.  There are some other drivers that
> unconditionally set the rotational flag to keep the existing behavior
> as they arguably can be used on rotational devices even if that is
> probably not their main use today (e.g. virtio_blk and drbd).
> 
> The flag is automatically inherited in blk_stack_limits matching the
> existing behavior in dm and md.
> 
> Signed-off-by: Christoph Hellwig <hch@lst.de>
> Reviewed-by: Damien Le Moal <dlemoal@kernel.org>
> ---
> arch/m68k/emu/nfblock.c             |  1 +
> arch/um/drivers/ubd_kern.c          |  1 -
> arch/xtensa/platforms/iss/simdisk.c |  5 +++-
> block/blk-mq-debugfs.c              |  1 -
> block/blk-sysfs.c                   | 39 ++++++++++++++++++++++++++---
> drivers/block/amiflop.c             |  5 +++-
> drivers/block/aoe/aoeblk.c          |  1 +
> drivers/block/ataflop.c             |  5 +++-
> drivers/block/brd.c                 |  2 --
> drivers/block/drbd/drbd_main.c      |  3 ++-
> drivers/block/floppy.c              |  3 ++-
> drivers/block/loop.c                |  8 +++---
> drivers/block/mtip32xx/mtip32xx.c   |  1 -
> drivers/block/n64cart.c             |  2 --
> drivers/block/nbd.c                 |  5 ----
> drivers/block/null_blk/main.c       |  1 -
> drivers/block/pktcdvd.c             |  1 +
> drivers/block/ps3disk.c             |  3 ++-
> drivers/block/rbd.c                 |  3 ---
> drivers/block/rnbd/rnbd-clt.c       |  4 ---
> drivers/block/sunvdc.c              |  1 +
> drivers/block/swim.c                |  5 +++-
> drivers/block/swim3.c               |  5 +++-
> drivers/block/ublk_drv.c            |  9 +++----
> drivers/block/virtio_blk.c          |  4 ++-
> drivers/block/xen-blkfront.c        |  1 -
> drivers/block/zram/zram_drv.c       |  2 --
> drivers/cdrom/gdrom.c               |  1 +
> drivers/md/bcache/super.c           |  2 --
> drivers/md/dm-table.c               | 12 ---------
> drivers/md/md.c                     | 13 ----------
> drivers/mmc/core/queue.c            |  1 -
> drivers/mtd/mtd_blkdevs.c           |  1 -
> drivers/nvdimm/btt.c                |  1 -
> drivers/nvdimm/pmem.c               |  1 -
> drivers/nvme/host/core.c            |  1 -
> drivers/nvme/host/multipath.c       |  1 -
> drivers/s390/block/dasd_genhd.c     |  1 -
> drivers/s390/block/scm_blk.c        |  1 -
> drivers/scsi/sd.c                   |  4 +--
> include/linux/blkdev.h              | 10 ++++----
> 41 files changed, 83 insertions(+), 88 deletions(-)
> 
> diff --git a/arch/m68k/emu/nfblock.c b/arch/m68k/emu/nfblock.c
> index 642fb80c5c4e31..8eea7ef9115146 100644
> --- a/arch/m68k/emu/nfblock.c
> +++ b/arch/m68k/emu/nfblock.c
> @@ -98,6 +98,7 @@ static int __init nfhd_init_one(int id, u32 blocks, u32 bsize)
> {
> 	struct queue_limits lim = {
> 		.logical_block_size	= bsize,
> +		.features		= BLK_FEAT_ROTATIONAL,
> 	};
> 	struct nfhd_device *dev;
> 	int dev_id = id - NFHD_DEV_OFFSET;
> diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
> index 19e01691ea0ea7..9f1e76ddda5a26 100644
> --- a/arch/um/drivers/ubd_kern.c
> +++ b/arch/um/drivers/ubd_kern.c
> @@ -882,7 +882,6 @@ static int ubd_add(int n, char **error_out)
> 		goto out_cleanup_tags;
> 	}
> 
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, disk->queue);
> 	disk->major = UBD_MAJOR;
> 	disk->first_minor = n << UBD_SHIFT;
> 	disk->minors = 1 << UBD_SHIFT;
> diff --git a/arch/xtensa/platforms/iss/simdisk.c b/arch/xtensa/platforms/iss/simdisk.c
> index defc67909a9c74..d6d2b533a5744d 100644
> --- a/arch/xtensa/platforms/iss/simdisk.c
> +++ b/arch/xtensa/platforms/iss/simdisk.c
> @@ -263,6 +263,9 @@ static const struct proc_ops simdisk_proc_ops = {
> static int __init simdisk_setup(struct simdisk *dev, int which,
> 		struct proc_dir_entry *procdir)
> {
> +	struct queue_limits lim = {
> +		.features		= BLK_FEAT_ROTATIONAL,
> +	};
> 	char tmp[2] = { '0' + which, 0 };
> 	int err;
> 
> @@ -271,7 +274,7 @@ static int __init simdisk_setup(struct simdisk *dev, int which,
> 	spin_lock_init(&dev->lock);
> 	dev->users = 0;
> 
> -	dev->gd = blk_alloc_disk(NULL, NUMA_NO_NODE);
> +	dev->gd = blk_alloc_disk(&lim, NUMA_NO_NODE);
> 	if (IS_ERR(dev->gd)) {
> 		err = PTR_ERR(dev->gd);
> 		goto out;
> diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c
> index e8b9db7c30c455..4d0e62ec88f033 100644
> --- a/block/blk-mq-debugfs.c
> +++ b/block/blk-mq-debugfs.c
> @@ -84,7 +84,6 @@ static const char *const blk_queue_flag_name[] = {
> 	QUEUE_FLAG_NAME(NOMERGES),
> 	QUEUE_FLAG_NAME(SAME_COMP),
> 	QUEUE_FLAG_NAME(FAIL_IO),
> -	QUEUE_FLAG_NAME(NONROT),
> 	QUEUE_FLAG_NAME(IO_STAT),
> 	QUEUE_FLAG_NAME(NOXMERGES),
> 	QUEUE_FLAG_NAME(ADD_RANDOM),
> diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
> index 4f524c1d5e08bd..637ed3bbbfb46f 100644
> --- a/block/blk-sysfs.c
> +++ b/block/blk-sysfs.c
> @@ -263,6 +263,39 @@ static ssize_t queue_dma_alignment_show(struct request_queue *q, char *page)
> 	return queue_var_show(queue_dma_alignment(q), page);
> }
> 
> +static ssize_t queue_feature_store(struct request_queue *q, const char *page,
> +		size_t count, unsigned int feature)
> +{
> +	struct queue_limits lim;
> +	unsigned long val;
> +	ssize_t ret;
> +
> +	ret = queue_var_store(&val, page, count);
> +	if (ret < 0)
> +		return ret;
> +
> +	lim = queue_limits_start_update(q);
> +	if (val)
> +		lim.features |= feature;
> +	else
> +		lim.features &= ~feature;
> +	ret = queue_limits_commit_update(q, &lim);
> +	if (ret)
> +		return ret;
> +	return count;
> +}
> +
> +#define QUEUE_SYSFS_FEATURE(_name, _feature)				 \
> +static ssize_t queue_##_name##_show(struct request_queue *q, char *page) \
> +{									 \
> +	return sprintf(page, "%u\n", !!(q->limits.features & _feature)); \
> +}									 \
> +static ssize_t queue_##_name##_store(struct request_queue *q,		 \
> +		const char *page, size_t count)				 \
> +{									 \
> +	return queue_feature_store(q, page, count, _feature);		 \
> +}
> +
> #define QUEUE_SYSFS_BIT_FNS(name, flag, neg)				\
> static ssize_t								\
> queue_##name##_show(struct request_queue *q, char *page)		\
> @@ -289,7 +322,7 @@ queue_##name##_store(struct request_queue *q, const char *page, size_t count) \
> 	return ret;							\
> }
> 
> -QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
> +QUEUE_SYSFS_FEATURE(rotational, BLK_FEAT_ROTATIONAL)
> QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
> QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
> QUEUE_SYSFS_BIT_FNS(stable_writes, STABLE_WRITES, 0);
> @@ -526,7 +559,7 @@ static struct queue_sysfs_entry queue_hw_sector_size_entry = {
> 	.show = queue_logical_block_size_show,
> };
> 
> -QUEUE_RW_ENTRY(queue_nonrot, "rotational");
> +QUEUE_RW_ENTRY(queue_rotational, "rotational");
> QUEUE_RW_ENTRY(queue_iostats, "iostats");
> QUEUE_RW_ENTRY(queue_random, "add_random");
> QUEUE_RW_ENTRY(queue_stable_writes, "stable_writes");
> @@ -624,7 +657,7 @@ static struct attribute *queue_attrs[] = {
> 	&queue_write_zeroes_max_entry.attr,
> 	&queue_zone_append_max_entry.attr,
> 	&queue_zone_write_granularity_entry.attr,
> -	&queue_nonrot_entry.attr,
> +	&queue_rotational_entry.attr,
> 	&queue_zoned_entry.attr,
> 	&queue_nr_zones_entry.attr,
> 	&queue_max_open_zones_entry.attr,
> diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
> index a25414228e4741..ff45701f7a5e31 100644
> --- a/drivers/block/amiflop.c
> +++ b/drivers/block/amiflop.c
> @@ -1776,10 +1776,13 @@ static const struct blk_mq_ops amiflop_mq_ops = {
> 
> static int fd_alloc_disk(int drive, int system)
> {
> +	struct queue_limits lim = {
> +		.features		= BLK_FEAT_ROTATIONAL,
> +	};
> 	struct gendisk *disk;
> 	int err;
> 
> -	disk = blk_mq_alloc_disk(&unit[drive].tag_set, NULL, NULL);
> +	disk = blk_mq_alloc_disk(&unit[drive].tag_set, &lim, NULL);
> 	if (IS_ERR(disk))
> 		return PTR_ERR(disk);
> 
> diff --git a/drivers/block/aoe/aoeblk.c b/drivers/block/aoe/aoeblk.c
> index b6dac8cee70fe1..2028795ec61cbb 100644
> --- a/drivers/block/aoe/aoeblk.c
> +++ b/drivers/block/aoe/aoeblk.c
> @@ -337,6 +337,7 @@ aoeblk_gdalloc(void *vp)
> 	struct queue_limits lim = {
> 		.max_hw_sectors		= aoe_maxsectors,
> 		.io_opt			= SZ_2M,
> +		.features		= BLK_FEAT_ROTATIONAL,
> 	};
> 	ulong flags;
> 	int late = 0;
> diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
> index cacc4ba942a814..4ee10a742bdb93 100644
> --- a/drivers/block/ataflop.c
> +++ b/drivers/block/ataflop.c
> @@ -1992,9 +1992,12 @@ static const struct blk_mq_ops ataflop_mq_ops = {
> 
> static int ataflop_alloc_disk(unsigned int drive, unsigned int type)
> {
> +	struct queue_limits lim = {
> +		.features		= BLK_FEAT_ROTATIONAL,
> +	};
> 	struct gendisk *disk;
> 
> -	disk = blk_mq_alloc_disk(&unit[drive].tag_set, NULL, NULL);
> +	disk = blk_mq_alloc_disk(&unit[drive].tag_set, &lim, NULL);
> 	if (IS_ERR(disk))
> 		return PTR_ERR(disk);
> 
> diff --git a/drivers/block/brd.c b/drivers/block/brd.c
> index 558d8e67056608..b25dc463b5e3a6 100644
> --- a/drivers/block/brd.c
> +++ b/drivers/block/brd.c
> @@ -366,8 +366,6 @@ static int brd_alloc(int i)
> 	strscpy(disk->disk_name, buf, DISK_NAME_LEN);
> 	set_capacity(disk, rd_size * 2);
> 	
> -	/* Tell the block layer that this is not a rotational device */
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, disk->queue);
> 	blk_queue_flag_set(QUEUE_FLAG_SYNCHRONOUS, disk->queue);
> 	blk_queue_flag_set(QUEUE_FLAG_NOWAIT, disk->queue);
> 	err = add_disk(disk);
> diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c
> index bf42a46781fa21..2ef29a47807550 100644
> --- a/drivers/block/drbd/drbd_main.c
> +++ b/drivers/block/drbd/drbd_main.c
> @@ -2697,7 +2697,8 @@ enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsig
> 		 * connect.
> 		 */
> 		.max_hw_sectors		= DRBD_MAX_BIO_SIZE_SAFE >> 8,
> -		.features		= BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA,
> +		.features		= BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA |
> +					  BLK_FEAT_ROTATIONAL,
> 	};
> 
> 	device = minor_to_device(minor);
> diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
> index 25c9d85667f1a2..6d7f7df97c3a6c 100644
> --- a/drivers/block/floppy.c
> +++ b/drivers/block/floppy.c
> @@ -4516,7 +4516,8 @@ static bool floppy_available(int drive)
> static int floppy_alloc_disk(unsigned int drive, unsigned int type)
> {
> 	struct queue_limits lim = {
> -		.max_hw_sectors = 64,
> +		.max_hw_sectors		= 64,
> +		.features		= BLK_FEAT_ROTATIONAL,
> 	};
> 	struct gendisk *disk;
> 
> diff --git a/drivers/block/loop.c b/drivers/block/loop.c
> index 08d0fc7f17b701..86b5d956dc4e02 100644
> --- a/drivers/block/loop.c
> +++ b/drivers/block/loop.c
> @@ -985,13 +985,11 @@ static int loop_reconfigure_limits(struct loop_device *lo, unsigned short bsize)
> 	lim.logical_block_size = bsize;
> 	lim.physical_block_size = bsize;
> 	lim.io_min = bsize;
> -	lim.features &= ~BLK_FEAT_WRITE_CACHE;
> +	lim.features &= ~(BLK_FEAT_WRITE_CACHE | BLK_FEAT_ROTATIONAL);
> 	if (file->f_op->fsync && !(lo->lo_flags & LO_FLAGS_READ_ONLY))
> 		lim.features |= BLK_FEAT_WRITE_CACHE;
> -	if (!backing_bdev || bdev_nonrot(backing_bdev))
> -		blk_queue_flag_set(QUEUE_FLAG_NONROT, lo->lo_queue);
> -	else
> -		blk_queue_flag_clear(QUEUE_FLAG_NONROT, lo->lo_queue);
> +	if (backing_bdev && !bdev_nonrot(backing_bdev))
> +		lim.features |= BLK_FEAT_ROTATIONAL;
> 	loop_config_discard(lo, &lim);
> 	return queue_limits_commit_update(lo->lo_queue, &lim);
> }
> diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
> index 43a187609ef794..1dbbf72659d549 100644
> --- a/drivers/block/mtip32xx/mtip32xx.c
> +++ b/drivers/block/mtip32xx/mtip32xx.c
> @@ -3485,7 +3485,6 @@ static int mtip_block_initialize(struct driver_data *dd)
> 		goto start_service_thread;
> 
> 	/* Set device limits. */
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, dd->queue);
> 	blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, dd->queue);
> 	dma_set_max_seg_size(&dd->pdev->dev, 0x400000);
> 
> diff --git a/drivers/block/n64cart.c b/drivers/block/n64cart.c
> index 27b2187e7a6d55..b9fdeff31cafdf 100644
> --- a/drivers/block/n64cart.c
> +++ b/drivers/block/n64cart.c
> @@ -150,8 +150,6 @@ static int __init n64cart_probe(struct platform_device *pdev)
> 	set_capacity(disk, size >> SECTOR_SHIFT);
> 	set_disk_ro(disk, 1);
> 
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, disk->queue);
> -
> 	err = add_disk(disk);
> 	if (err)
> 		goto out_cleanup_disk;
> diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
> index cb1c86a6a3fb9d..6cddf5baffe02a 100644
> --- a/drivers/block/nbd.c
> +++ b/drivers/block/nbd.c
> @@ -1867,11 +1867,6 @@ static struct nbd_device *nbd_dev_add(int index, unsigned int refs)
> 		goto out_err_disk;
> 	}
> 
> -	/*
> -	 * Tell the block layer that we are not a rotational device
> -	 */
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, disk->queue);
> -
> 	mutex_init(&nbd->config_lock);
> 	refcount_set(&nbd->config_refs, 0);
> 	/*
> diff --git a/drivers/block/null_blk/main.c b/drivers/block/null_blk/main.c
> index 21f9d256e88402..83a4ebe4763ae5 100644
> --- a/drivers/block/null_blk/main.c
> +++ b/drivers/block/null_blk/main.c
> @@ -1948,7 +1948,6 @@ static int null_add_dev(struct nullb_device *dev)
> 	}
> 
> 	nullb->q->queuedata = nullb;
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, nullb->q);
> 
> 	rv = ida_alloc(&nullb_indexes, GFP_KERNEL);
> 	if (rv < 0)
> diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
> index 8a2ce80700109d..7cece5884b9c67 100644
> --- a/drivers/block/pktcdvd.c
> +++ b/drivers/block/pktcdvd.c
> @@ -2622,6 +2622,7 @@ static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev)
> 	struct queue_limits lim = {
> 		.max_hw_sectors		= PACKET_MAX_SECTORS,
> 		.logical_block_size	= CD_FRAMESIZE,
> +		.features		= BLK_FEAT_ROTATIONAL,
> 	};
> 	int idx;
> 	int ret = -ENOMEM;
> diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
> index 8b73cf459b5937..ff45ed76646957 100644
> --- a/drivers/block/ps3disk.c
> +++ b/drivers/block/ps3disk.c
> @@ -388,7 +388,8 @@ static int ps3disk_probe(struct ps3_system_bus_device *_dev)
> 		.max_segments		= -1,
> 		.max_segment_size	= dev->bounce_size,
> 		.dma_alignment		= dev->blk_size - 1,
> -		.features		= BLK_FEAT_WRITE_CACHE,
> +		.features		= BLK_FEAT_WRITE_CACHE |
> +					  BLK_FEAT_ROTATIONAL,
> 	};
> 	struct gendisk *gendisk;
> 
> diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
> index 22ad704f81d8b9..ec1f1c7d4275cd 100644
> --- a/drivers/block/rbd.c
> +++ b/drivers/block/rbd.c
> @@ -4997,9 +4997,6 @@ static int rbd_init_disk(struct rbd_device *rbd_dev)
> 	disk->fops = &rbd_bd_ops;
> 	disk->private_data = rbd_dev;
> 
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
> -	/* QUEUE_FLAG_ADD_RANDOM is off by default for blk-mq */
> -
> 	if (!ceph_test_opt(rbd_dev->rbd_client->client, NOCRC))
> 		blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, q);
> 
> diff --git a/drivers/block/rnbd/rnbd-clt.c b/drivers/block/rnbd/rnbd-clt.c
> index 02c4b173182719..4918b0f68b46cd 100644
> --- a/drivers/block/rnbd/rnbd-clt.c
> +++ b/drivers/block/rnbd/rnbd-clt.c
> @@ -1352,10 +1352,6 @@ static int rnbd_clt_setup_gen_disk(struct rnbd_clt_dev *dev,
> 	if (dev->access_mode == RNBD_ACCESS_RO)
> 		set_disk_ro(dev->gd, true);
> 
> -	/*
> -	 * Network device does not need rotational
> -	 */
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, dev->queue);
> 	err = add_disk(dev->gd);
> 	if (err)
> 		put_disk(dev->gd);
> diff --git a/drivers/block/sunvdc.c b/drivers/block/sunvdc.c
> index 5286cb8e0824d1..2d38331ee66793 100644
> --- a/drivers/block/sunvdc.c
> +++ b/drivers/block/sunvdc.c
> @@ -791,6 +791,7 @@ static int probe_disk(struct vdc_port *port)
> 		.seg_boundary_mask		= PAGE_SIZE - 1,
> 		.max_segment_size		= PAGE_SIZE,
> 		.max_segments			= port->ring_cookies,
> +		.features			= BLK_FEAT_ROTATIONAL,
> 	};
> 	struct request_queue *q;
> 	struct gendisk *g;
> diff --git a/drivers/block/swim.c b/drivers/block/swim.c
> index 6731678f3a41db..126f151c4f2cf0 100644
> --- a/drivers/block/swim.c
> +++ b/drivers/block/swim.c
> @@ -787,6 +787,9 @@ static void swim_cleanup_floppy_disk(struct floppy_state *fs)
> 
> static int swim_floppy_init(struct swim_priv *swd)
> {
> +	struct queue_limits lim = {
> +		.features		= BLK_FEAT_ROTATIONAL,
> +	};
> 	int err;
> 	int drive;
> 	struct swim __iomem *base = swd->base;
> @@ -820,7 +823,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, NULL,
> +			blk_mq_alloc_disk(&swd->unit[drive].tag_set, &lim,
> 					  &swd->unit[drive]);
> 		if (IS_ERR(swd->unit[drive].disk)) {
> 			blk_mq_free_tag_set(&swd->unit[drive].tag_set);
> diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
> index a04756ac778ee8..90be1017f7bfcd 100644
> --- a/drivers/block/swim3.c
> +++ b/drivers/block/swim3.c
> @@ -1189,6 +1189,9 @@ static int swim3_add_device(struct macio_dev *mdev, int index)
> static int swim3_attach(struct macio_dev *mdev,
> 			const struct of_device_id *match)
> {
> +	struct queue_limits lim = {
> +		.features		= BLK_FEAT_ROTATIONAL,
> +	};
> 	struct floppy_state *fs;
> 	struct gendisk *disk;
> 	int rc;
> @@ -1210,7 +1213,7 @@ static int swim3_attach(struct macio_dev *mdev,
> 	if (rc)
> 		goto out_unregister;
> 
> -	disk = blk_mq_alloc_disk(&fs->tag_set, NULL, fs);
> +	disk = blk_mq_alloc_disk(&fs->tag_set, &lim, fs);
> 	if (IS_ERR(disk)) {
> 		rc = PTR_ERR(disk);
> 		goto out_free_tag_set;
> diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c
> index e45c65c1848d31..4fcde099935868 100644
> --- a/drivers/block/ublk_drv.c
> +++ b/drivers/block/ublk_drv.c
> @@ -484,14 +484,8 @@ static inline unsigned ublk_pos_to_tag(loff_t pos)
> 
> static void ublk_dev_param_basic_apply(struct ublk_device *ub)
> {
> -	struct request_queue *q = ub->ub_disk->queue;
> 	const struct ublk_param_basic *p = &ub->params.basic;
> 
> -	if (p->attrs & UBLK_ATTR_ROTATIONAL)
> -		blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
> -	else
> -		blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
> -
> 	if (p->attrs & UBLK_ATTR_READ_ONLY)
> 		set_disk_ro(ub->ub_disk, true);
> 
> @@ -2214,6 +2208,9 @@ static int ublk_ctrl_start_dev(struct ublk_device *ub, struct io_uring_cmd *cmd)
> 			lim.features |= BLK_FEAT_FUA;
> 	}
> 
> +	if (ub->params.basic.attrs & UBLK_ATTR_ROTATIONAL)
> +		lim.features |= BLK_FEAT_ROTATIONAL;
> +
> 	if (wait_for_completion_interruptible(&ub->completion) != 0)
> 		return -EINTR;
> 
> diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
> index b1a3c293528519..13a2f24f176628 100644
> --- a/drivers/block/virtio_blk.c
> +++ b/drivers/block/virtio_blk.c
> @@ -1451,7 +1451,9 @@ static int virtblk_read_limits(struct virtio_blk *vblk,
> static int virtblk_probe(struct virtio_device *vdev)
> {
> 	struct virtio_blk *vblk;
> -	struct queue_limits lim = { };
> +	struct queue_limits lim = {
> +		.features		= BLK_FEAT_ROTATIONAL,
> +	};
> 	int err, index;
> 	unsigned int queue_depth;
> 
> diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
> index 9aafce3e5987bf..fa3a2ba525458b 100644
> --- a/drivers/block/xen-blkfront.c
> +++ b/drivers/block/xen-blkfront.c
> @@ -1146,7 +1146,6 @@ static int xlvbd_alloc_gendisk(blkif_sector_t capacity,
> 		err = PTR_ERR(gd);
> 		goto out_free_tag_set;
> 	}
> -	blk_queue_flag_set(QUEUE_FLAG_VIRT, gd->queue);
> 
> 	strcpy(gd->disk_name, DEV_NAME);
> 	ptr = encode_disk_name(gd->disk_name + sizeof(DEV_NAME) - 1, offset);
> diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
> index 3acd7006ad2ccd..aad840fc7e18e3 100644
> --- a/drivers/block/zram/zram_drv.c
> +++ b/drivers/block/zram/zram_drv.c
> @@ -2245,8 +2245,6 @@ static int zram_add(void)
> 
> 	/* Actual capacity set using sysfs (/sys/block/zram<id>/disksize */
> 	set_capacity(zram->disk, 0);
> -	/* zram devices sort of resembles non-rotational disks */
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, zram->disk->queue);
> 	blk_queue_flag_set(QUEUE_FLAG_SYNCHRONOUS, zram->disk->queue);
> 	blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, zram->disk->queue);
> 	ret = device_add_disk(NULL, zram->disk, zram_disk_groups);
> diff --git a/drivers/cdrom/gdrom.c b/drivers/cdrom/gdrom.c
> index eefdd422ad8e9f..71cfe7a85913c4 100644
> --- a/drivers/cdrom/gdrom.c
> +++ b/drivers/cdrom/gdrom.c
> @@ -744,6 +744,7 @@ static int probe_gdrom(struct platform_device *devptr)
> 		.max_segments			= 1,
> 		/* set a large max size to get most from DMA */
> 		.max_segment_size		= 0x40000,
> +		.features			= BLK_FEAT_ROTATIONAL,
> 	};
> 	int err;
> 
> diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c
> index cb6595c8b5514e..baa364eedd0051 100644
> --- a/drivers/md/bcache/super.c
> +++ b/drivers/md/bcache/super.c
> @@ -974,8 +974,6 @@ static int bcache_device_init(struct bcache_device *d, unsigned int block_size,
> 	d->disk->minors		= BCACHE_MINORS;
> 	d->disk->fops		= ops;
> 	d->disk->private_data	= d;
> -
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, d->disk->queue);
> 	return 0;
> 
> out_bioset_exit:
> diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
> index 03abdae646829c..c062af32970934 100644
> --- a/drivers/md/dm-table.c
> +++ b/drivers/md/dm-table.c
> @@ -1716,12 +1716,6 @@ static int device_dax_write_cache_enabled(struct dm_target *ti,
> 	return false;
> }
> 
> -static int device_is_rotational(struct dm_target *ti, struct dm_dev *dev,
> -				sector_t start, sector_t len, void *data)
> -{
> -	return !bdev_nonrot(dev->bdev);
> -}
> -
> static int device_is_not_random(struct dm_target *ti, struct dm_dev *dev,
> 			     sector_t start, sector_t len, void *data)
> {
> @@ -1870,12 +1864,6 @@ int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
> 	if (dm_table_any_dev_attr(t, device_dax_write_cache_enabled, NULL))
> 		dax_write_cache(t->md->dax_dev, true);
> 
> -	/* Ensure that all underlying devices are non-rotational. */
> -	if (dm_table_any_dev_attr(t, device_is_rotational, NULL))
> -		blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
> -	else
> -		blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
> -
> 	/*
> 	 * Some devices don't use blk_integrity but still want stable pages
> 	 * because they do their own checksumming.
> diff --git a/drivers/md/md.c b/drivers/md/md.c
> index 2f4c5d1755d857..c23423c51fb7c2 100644
> --- a/drivers/md/md.c
> +++ b/drivers/md/md.c
> @@ -6151,20 +6151,7 @@ int md_run(struct mddev *mddev)
> 
> 	if (!mddev_is_dm(mddev)) {
> 		struct request_queue *q = mddev->gendisk->queue;
> -		bool nonrot = true;
> 
> -		rdev_for_each(rdev, mddev) {
> -			if (rdev->raid_disk >= 0 && !bdev_nonrot(rdev->bdev)) {
> -				nonrot = false;
> -				break;
> -			}
> -		}
> -		if (mddev->degraded)
> -			nonrot = false;
> -		if (nonrot)
> -			blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
> -		else
> -			blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
> 		blk_queue_flag_set(QUEUE_FLAG_IO_STAT, q);
> 
> 		/* Set the NOWAIT flags if all underlying devices support it */
> diff --git a/drivers/mmc/core/queue.c b/drivers/mmc/core/queue.c
> index 97ff993d31570c..b4f62fa845864c 100644
> --- a/drivers/mmc/core/queue.c
> +++ b/drivers/mmc/core/queue.c
> @@ -387,7 +387,6 @@ static struct gendisk *mmc_alloc_disk(struct mmc_queue *mq,
> 		blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, mq->queue);
> 	blk_queue_rq_timeout(mq->queue, 60 * HZ);
> 
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, mq->queue);
> 	blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, mq->queue);
> 
> 	dma_set_max_seg_size(mmc_dev(host), queue_max_segment_size(mq->queue));
> diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
> index 1b9f57f231e8be..bf8369ce7ddf1d 100644
> --- a/drivers/mtd/mtd_blkdevs.c
> +++ b/drivers/mtd/mtd_blkdevs.c
> @@ -375,7 +375,6 @@ int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
> 	spin_lock_init(&new->queue_lock);
> 	INIT_LIST_HEAD(&new->rq_list);
> 
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, new->rq);
> 	blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, new->rq);
> 
> 	gd->queue = new->rq;
> diff --git a/drivers/nvdimm/btt.c b/drivers/nvdimm/btt.c
> index c5f8451b494d6c..e474afa8e9f68d 100644
> --- a/drivers/nvdimm/btt.c
> +++ b/drivers/nvdimm/btt.c
> @@ -1518,7 +1518,6 @@ static int btt_blk_init(struct btt *btt)
> 	btt->btt_disk->fops = &btt_fops;
> 	btt->btt_disk->private_data = btt;
> 
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, btt->btt_disk->queue);
> 	blk_queue_flag_set(QUEUE_FLAG_SYNCHRONOUS, btt->btt_disk->queue);
> 
> 	set_capacity(btt->btt_disk, btt->nlba * btt->sector_size >> 9);
> diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
> index aff818469c114c..501cf226df0187 100644
> --- a/drivers/nvdimm/pmem.c
> +++ b/drivers/nvdimm/pmem.c
> @@ -546,7 +546,6 @@ static int pmem_attach_disk(struct device *dev,
> 	}
> 	pmem->virt_addr = addr;
> 
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
> 	blk_queue_flag_set(QUEUE_FLAG_SYNCHRONOUS, q);
> 	if (pmem->pfn_flags & PFN_MAP)
> 		blk_queue_flag_set(QUEUE_FLAG_DAX, q);
> diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
> index 9fc5e36fe2e55e..0d753fe71f35b0 100644
> --- a/drivers/nvme/host/core.c
> +++ b/drivers/nvme/host/core.c
> @@ -3744,7 +3744,6 @@ static void nvme_alloc_ns(struct nvme_ctrl *ctrl, struct nvme_ns_info *info)
> 	if (ctrl->opts && ctrl->opts->data_digest)
> 		blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, ns->queue);
> 
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, ns->queue);
> 	if (ctrl->ops->supports_pci_p2pdma &&
> 	    ctrl->ops->supports_pci_p2pdma(ctrl))
> 		blk_queue_flag_set(QUEUE_FLAG_PCI_P2PDMA, ns->queue);
> diff --git a/drivers/nvme/host/multipath.c b/drivers/nvme/host/multipath.c
> index 3d0e23a0a4ddd8..58c13304e558e0 100644
> --- a/drivers/nvme/host/multipath.c
> +++ b/drivers/nvme/host/multipath.c
> @@ -549,7 +549,6 @@ int nvme_mpath_alloc_disk(struct nvme_ctrl *ctrl, struct nvme_ns_head *head)
> 	sprintf(head->disk->disk_name, "nvme%dn%d",
> 			ctrl->subsys->instance, head->instance);
> 
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, head->disk->queue);
> 	blk_queue_flag_set(QUEUE_FLAG_NOWAIT, head->disk->queue);
> 	blk_queue_flag_set(QUEUE_FLAG_IO_STAT, head->disk->queue);
> 	/*
> diff --git a/drivers/s390/block/dasd_genhd.c b/drivers/s390/block/dasd_genhd.c
> index 4533dd055ca8e3..1aa426b1deddc7 100644
> --- a/drivers/s390/block/dasd_genhd.c
> +++ b/drivers/s390/block/dasd_genhd.c
> @@ -68,7 +68,6 @@ int dasd_gendisk_alloc(struct dasd_block *block)
> 		blk_mq_free_tag_set(&block->tag_set);
> 		return PTR_ERR(gdp);
> 	}
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, gdp->queue);
> 
> 	/* Initialize gendisk structure. */
> 	gdp->major = DASD_MAJOR;
> diff --git a/drivers/s390/block/scm_blk.c b/drivers/s390/block/scm_blk.c
> index 1d456a5a3bfb8e..2e2309fa9a0b34 100644
> --- a/drivers/s390/block/scm_blk.c
> +++ b/drivers/s390/block/scm_blk.c
> @@ -475,7 +475,6 @@ int scm_blk_dev_setup(struct scm_blk_dev *bdev, struct scm_device *scmdev)
> 		goto out_tag;
> 	}
> 	rq = bdev->rq = bdev->gendisk->queue;
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, rq);
> 	blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, rq);
> 
> 	bdev->gendisk->private_data = scmdev;
> diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
> index d8ee4a4d4a6283..a42c3c45e86830 100644
> --- a/drivers/scsi/sd.c
> +++ b/drivers/scsi/sd.c
> @@ -3318,7 +3318,7 @@ static void sd_read_block_characteristics(struct scsi_disk *sdkp,
> 	rcu_read_unlock();
> 
> 	if (rot == 1) {
> -		blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
> +		lim->features &= ~BLK_FEAT_ROTATIONAL;
> 		blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, q);
> 	}
> 
> @@ -3646,7 +3646,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
> 		 * cause this to be updated correctly and any device which
> 		 * doesn't support it should be treated as rotational.
> 		 */
> -		blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
> +		lim.features |= BLK_FEAT_ROTATIONAL;
> 		blk_queue_flag_set(QUEUE_FLAG_ADD_RANDOM, q);
> 
> 		if (scsi_device_supports_vpd(sdp)) {
> diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
> index acdfe5122faa44..988e3248cffeb7 100644
> --- a/include/linux/blkdev.h
> +++ b/include/linux/blkdev.h
> @@ -289,14 +289,16 @@ enum {
> 
> 	/* supports passing on the FUA bit */
> 	BLK_FEAT_FUA				= (1u << 1),
> +
> +	/* rotational device (hard drive or floppy) */
> +	BLK_FEAT_ROTATIONAL			= (1u << 2),
> };
> 
> /*
>  * Flags automatically inherited when stacking limits.
>  */
> #define BLK_FEAT_INHERIT_MASK \
> -	(BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA)
> -
> +	(BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA | BLK_FEAT_ROTATIONAL)
> 
> /* internal flags in queue_limits.flags */
> enum {
> @@ -553,8 +555,6 @@ struct request_queue {
> #define QUEUE_FLAG_NOMERGES     3	/* disable merge attempts */
> #define QUEUE_FLAG_SAME_COMP	4	/* complete on same CPU-group */
> #define QUEUE_FLAG_FAIL_IO	5	/* fake timeout */
> -#define QUEUE_FLAG_NONROT	6	/* non-rotational device (SSD) */
> -#define QUEUE_FLAG_VIRT		QUEUE_FLAG_NONROT /* paravirt device */
> #define QUEUE_FLAG_IO_STAT	7	/* do disk/partitions IO accounting */
> #define QUEUE_FLAG_NOXMERGES	9	/* No extended merges */
> #define QUEUE_FLAG_ADD_RANDOM	10	/* Contributes to random pool */
> @@ -589,7 +589,7 @@ bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q);
> #define blk_queue_nomerges(q)	test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
> #define blk_queue_noxmerges(q)	\
> 	test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags)
> -#define blk_queue_nonrot(q)	test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
> +#define blk_queue_nonrot(q)	((q)->limits.features & BLK_FEAT_ROTATIONAL)
> #define blk_queue_io_stat(q)	test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
> #define blk_queue_add_random(q)	test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
> #define blk_queue_zone_resetall(q)	\
> -- 
> 2.43.0
>
Keith Busch June 24, 2024, 5:08 p.m. UTC | #3 
On Mon, Jun 17, 2024 at 08:04:41AM +0200, Christoph Hellwig wrote:
> -#define blk_queue_nonrot(q)	test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
> +#define blk_queue_nonrot(q)	((q)->limits.features & BLK_FEAT_ROTATIONAL)

This is inverted. Should be:

 #define blk_queue_nonrot(q)	(!((q)->limits.features & BLK_FEAT_ROTATIONAL))
Christoph Hellwig June 24, 2024, 5:24 p.m. UTC | #4 
On Mon, Jun 24, 2024 at 11:08:16AM -0600, Keith Busch wrote:
> On Mon, Jun 17, 2024 at 08:04:41AM +0200, Christoph Hellwig wrote:
> > -#define blk_queue_nonrot(q)	test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
> > +#define blk_queue_nonrot(q)	((q)->limits.features & BLK_FEAT_ROTATIONAL)
> 
> This is inverted. Should be:
> 
>  #define blk_queue_nonrot(q)	(!((q)->limits.features & BLK_FEAT_ROTATIONAL))

Ah yes.  And the sysfs attribute doesn't go through the macro and
won't show the effect.  I'll send a fixup.
Simon Fernandez July 4, 2024, 11:11 a.m. UTC | #5 
Hi folks, how can I unsubscribe from this group.?
Thanks in advance.
S

> On 24 Jun 2024, at 18:08, Keith Busch <kbusch@kernel.org> wrote:
> 
> On Mon, Jun 17, 2024 at 08:04:41AM +0200, Christoph Hellwig wrote:
>> -#define blk_queue_nonrot(q)	test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
>> +#define blk_queue_nonrot(q)	((q)->limits.features & BLK_FEAT_ROTATIONAL)
> 
> This is inverted. Should be:
> 
> #define blk_queue_nonrot(q)	(!((q)->limits.features & BLK_FEAT_ROTATIONAL))
>
Wouter Verhelst July 25, 2024, 11:35 a.m. UTC | #6 
On Mon, Jun 17, 2024 at 08:04:41AM +0200, Christoph Hellwig wrote:
> Use the chance to switch to defaulting to non-rotational and require
> the driver to opt into rotational, which matches the polarity of the
> sysfs interface.
[...]
> diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
> index cb1c86a6a3fb9d..6cddf5baffe02a 100644
> --- a/drivers/block/nbd.c
> +++ b/drivers/block/nbd.c
> @@ -1867,11 +1867,6 @@ static struct nbd_device *nbd_dev_add(int index, unsigned int refs)
>  		goto out_err_disk;
>  	}
>  
> -	/*
> -	 * Tell the block layer that we are not a rotational device
> -	 */
> -	blk_queue_flag_set(QUEUE_FLAG_NONROT, disk->queue);
> -
>  	mutex_init(&nbd->config_lock);
>  	refcount_set(&nbd->config_refs, 0);
>  	/*

NBD actually exports a flag for rotational devices; it's defined in
nbd.h in the NBD userland source as

#define NBD_FLAG_ROTATIONAL     (1 << 4)        /* Use elevator algorithm - rotational media */

which is passed in the same flags field which also contains the
NBD_FLAG_SEND_FLUSH and NBD_FLAG_SEND_FUA flags.

Perhaps we might want to look at that flag and set the device to
rotational if it is specified?
Christoph Hellwig July 25, 2024, 1 p.m. UTC | #7 
On Thu, Jul 25, 2024 at 01:35:46PM +0200, Wouter Verhelst wrote:
> NBD actually exports a flag for rotational devices; it's defined in
> nbd.h in the NBD userland source as
> 
> #define NBD_FLAG_ROTATIONAL     (1 << 4)        /* Use elevator algorithm - rotational media */
> 
> which is passed in the same flags field which also contains the
> NBD_FLAG_SEND_FLUSH and NBD_FLAG_SEND_FUA flags.
> 
> Perhaps we might want to look at that flag and set the device to
> rotational if it is specified?

Yes, that sounds good.  Can you send a patch?
diff mbox series

Patch

diff --git a/arch/m68k/emu/nfblock.c b/arch/m68k/emu/nfblock.c
index 642fb80c5c4e31..8eea7ef9115146 100644
--- a/arch/m68k/emu/nfblock.c
+++ b/arch/m68k/emu/nfblock.c
@@ -98,6 +98,7 @@  static int __init nfhd_init_one(int id, u32 blocks, u32 bsize)
 {
 	struct queue_limits lim = {
 		.logical_block_size	= bsize,
+		.features		= BLK_FEAT_ROTATIONAL,
 	};
 	struct nfhd_device *dev;
 	int dev_id = id - NFHD_DEV_OFFSET;
diff --git a/arch/um/drivers/ubd_kern.c b/arch/um/drivers/ubd_kern.c
index 19e01691ea0ea7..9f1e76ddda5a26 100644
--- a/arch/um/drivers/ubd_kern.c
+++ b/arch/um/drivers/ubd_kern.c
@@ -882,7 +882,6 @@  static int ubd_add(int n, char **error_out)
 		goto out_cleanup_tags;
 	}
 
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, disk->queue);
 	disk->major = UBD_MAJOR;
 	disk->first_minor = n << UBD_SHIFT;
 	disk->minors = 1 << UBD_SHIFT;
diff --git a/arch/xtensa/platforms/iss/simdisk.c b/arch/xtensa/platforms/iss/simdisk.c
index defc67909a9c74..d6d2b533a5744d 100644
--- a/arch/xtensa/platforms/iss/simdisk.c
+++ b/arch/xtensa/platforms/iss/simdisk.c
@@ -263,6 +263,9 @@  static const struct proc_ops simdisk_proc_ops = {
 static int __init simdisk_setup(struct simdisk *dev, int which,
 		struct proc_dir_entry *procdir)
 {
+	struct queue_limits lim = {
+		.features		= BLK_FEAT_ROTATIONAL,
+	};
 	char tmp[2] = { '0' + which, 0 };
 	int err;
 
@@ -271,7 +274,7 @@  static int __init simdisk_setup(struct simdisk *dev, int which,
 	spin_lock_init(&dev->lock);
 	dev->users = 0;
 
-	dev->gd = blk_alloc_disk(NULL, NUMA_NO_NODE);
+	dev->gd = blk_alloc_disk(&lim, NUMA_NO_NODE);
 	if (IS_ERR(dev->gd)) {
 		err = PTR_ERR(dev->gd);
 		goto out;
diff --git a/block/blk-mq-debugfs.c b/block/blk-mq-debugfs.c
index e8b9db7c30c455..4d0e62ec88f033 100644
--- a/block/blk-mq-debugfs.c
+++ b/block/blk-mq-debugfs.c
@@ -84,7 +84,6 @@  static const char *const blk_queue_flag_name[] = {
 	QUEUE_FLAG_NAME(NOMERGES),
 	QUEUE_FLAG_NAME(SAME_COMP),
 	QUEUE_FLAG_NAME(FAIL_IO),
-	QUEUE_FLAG_NAME(NONROT),
 	QUEUE_FLAG_NAME(IO_STAT),
 	QUEUE_FLAG_NAME(NOXMERGES),
 	QUEUE_FLAG_NAME(ADD_RANDOM),
diff --git a/block/blk-sysfs.c b/block/blk-sysfs.c
index 4f524c1d5e08bd..637ed3bbbfb46f 100644
--- a/block/blk-sysfs.c
+++ b/block/blk-sysfs.c
@@ -263,6 +263,39 @@  static ssize_t queue_dma_alignment_show(struct request_queue *q, char *page)
 	return queue_var_show(queue_dma_alignment(q), page);
 }
 
+static ssize_t queue_feature_store(struct request_queue *q, const char *page,
+		size_t count, unsigned int feature)
+{
+	struct queue_limits lim;
+	unsigned long val;
+	ssize_t ret;
+
+	ret = queue_var_store(&val, page, count);
+	if (ret < 0)
+		return ret;
+
+	lim = queue_limits_start_update(q);
+	if (val)
+		lim.features |= feature;
+	else
+		lim.features &= ~feature;
+	ret = queue_limits_commit_update(q, &lim);
+	if (ret)
+		return ret;
+	return count;
+}
+
+#define QUEUE_SYSFS_FEATURE(_name, _feature)				 \
+static ssize_t queue_##_name##_show(struct request_queue *q, char *page) \
+{									 \
+	return sprintf(page, "%u\n", !!(q->limits.features & _feature)); \
+}									 \
+static ssize_t queue_##_name##_store(struct request_queue *q,		 \
+		const char *page, size_t count)				 \
+{									 \
+	return queue_feature_store(q, page, count, _feature);		 \
+}
+
 #define QUEUE_SYSFS_BIT_FNS(name, flag, neg)				\
 static ssize_t								\
 queue_##name##_show(struct request_queue *q, char *page)		\
@@ -289,7 +322,7 @@  queue_##name##_store(struct request_queue *q, const char *page, size_t count) \
 	return ret;							\
 }
 
-QUEUE_SYSFS_BIT_FNS(nonrot, NONROT, 1);
+QUEUE_SYSFS_FEATURE(rotational, BLK_FEAT_ROTATIONAL)
 QUEUE_SYSFS_BIT_FNS(random, ADD_RANDOM, 0);
 QUEUE_SYSFS_BIT_FNS(iostats, IO_STAT, 0);
 QUEUE_SYSFS_BIT_FNS(stable_writes, STABLE_WRITES, 0);
@@ -526,7 +559,7 @@  static struct queue_sysfs_entry queue_hw_sector_size_entry = {
 	.show = queue_logical_block_size_show,
 };
 
-QUEUE_RW_ENTRY(queue_nonrot, "rotational");
+QUEUE_RW_ENTRY(queue_rotational, "rotational");
 QUEUE_RW_ENTRY(queue_iostats, "iostats");
 QUEUE_RW_ENTRY(queue_random, "add_random");
 QUEUE_RW_ENTRY(queue_stable_writes, "stable_writes");
@@ -624,7 +657,7 @@  static struct attribute *queue_attrs[] = {
 	&queue_write_zeroes_max_entry.attr,
 	&queue_zone_append_max_entry.attr,
 	&queue_zone_write_granularity_entry.attr,
-	&queue_nonrot_entry.attr,
+	&queue_rotational_entry.attr,
 	&queue_zoned_entry.attr,
 	&queue_nr_zones_entry.attr,
 	&queue_max_open_zones_entry.attr,
diff --git a/drivers/block/amiflop.c b/drivers/block/amiflop.c
index a25414228e4741..ff45701f7a5e31 100644
--- a/drivers/block/amiflop.c
+++ b/drivers/block/amiflop.c
@@ -1776,10 +1776,13 @@  static const struct blk_mq_ops amiflop_mq_ops = {
 
 static int fd_alloc_disk(int drive, int system)
 {
+	struct queue_limits lim = {
+		.features		= BLK_FEAT_ROTATIONAL,
+	};
 	struct gendisk *disk;
 	int err;
 
-	disk = blk_mq_alloc_disk(&unit[drive].tag_set, NULL, NULL);
+	disk = blk_mq_alloc_disk(&unit[drive].tag_set, &lim, NULL);
 	if (IS_ERR(disk))
 		return PTR_ERR(disk);
 
diff --git a/drivers/block/aoe/aoeblk.c b/drivers/block/aoe/aoeblk.c
index b6dac8cee70fe1..2028795ec61cbb 100644
--- a/drivers/block/aoe/aoeblk.c
+++ b/drivers/block/aoe/aoeblk.c
@@ -337,6 +337,7 @@  aoeblk_gdalloc(void *vp)
 	struct queue_limits lim = {
 		.max_hw_sectors		= aoe_maxsectors,
 		.io_opt			= SZ_2M,
+		.features		= BLK_FEAT_ROTATIONAL,
 	};
 	ulong flags;
 	int late = 0;
diff --git a/drivers/block/ataflop.c b/drivers/block/ataflop.c
index cacc4ba942a814..4ee10a742bdb93 100644
--- a/drivers/block/ataflop.c
+++ b/drivers/block/ataflop.c
@@ -1992,9 +1992,12 @@  static const struct blk_mq_ops ataflop_mq_ops = {
 
 static int ataflop_alloc_disk(unsigned int drive, unsigned int type)
 {
+	struct queue_limits lim = {
+		.features		= BLK_FEAT_ROTATIONAL,
+	};
 	struct gendisk *disk;
 
-	disk = blk_mq_alloc_disk(&unit[drive].tag_set, NULL, NULL);
+	disk = blk_mq_alloc_disk(&unit[drive].tag_set, &lim, NULL);
 	if (IS_ERR(disk))
 		return PTR_ERR(disk);
 
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index 558d8e67056608..b25dc463b5e3a6 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -366,8 +366,6 @@  static int brd_alloc(int i)
 	strscpy(disk->disk_name, buf, DISK_NAME_LEN);
 	set_capacity(disk, rd_size * 2);
 	
-	/* Tell the block layer that this is not a rotational device */
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, disk->queue);
 	blk_queue_flag_set(QUEUE_FLAG_SYNCHRONOUS, disk->queue);
 	blk_queue_flag_set(QUEUE_FLAG_NOWAIT, disk->queue);
 	err = add_disk(disk);
diff --git a/drivers/block/drbd/drbd_main.c b/drivers/block/drbd/drbd_main.c
index bf42a46781fa21..2ef29a47807550 100644
--- a/drivers/block/drbd/drbd_main.c
+++ b/drivers/block/drbd/drbd_main.c
@@ -2697,7 +2697,8 @@  enum drbd_ret_code drbd_create_device(struct drbd_config_context *adm_ctx, unsig
 		 * connect.
 		 */
 		.max_hw_sectors		= DRBD_MAX_BIO_SIZE_SAFE >> 8,
-		.features		= BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA,
+		.features		= BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA |
+					  BLK_FEAT_ROTATIONAL,
 	};
 
 	device = minor_to_device(minor);
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index 25c9d85667f1a2..6d7f7df97c3a6c 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -4516,7 +4516,8 @@  static bool floppy_available(int drive)
 static int floppy_alloc_disk(unsigned int drive, unsigned int type)
 {
 	struct queue_limits lim = {
-		.max_hw_sectors = 64,
+		.max_hw_sectors		= 64,
+		.features		= BLK_FEAT_ROTATIONAL,
 	};
 	struct gendisk *disk;
 
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 08d0fc7f17b701..86b5d956dc4e02 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -985,13 +985,11 @@  static int loop_reconfigure_limits(struct loop_device *lo, unsigned short bsize)
 	lim.logical_block_size = bsize;
 	lim.physical_block_size = bsize;
 	lim.io_min = bsize;
-	lim.features &= ~BLK_FEAT_WRITE_CACHE;
+	lim.features &= ~(BLK_FEAT_WRITE_CACHE | BLK_FEAT_ROTATIONAL);
 	if (file->f_op->fsync && !(lo->lo_flags & LO_FLAGS_READ_ONLY))
 		lim.features |= BLK_FEAT_WRITE_CACHE;
-	if (!backing_bdev || bdev_nonrot(backing_bdev))
-		blk_queue_flag_set(QUEUE_FLAG_NONROT, lo->lo_queue);
-	else
-		blk_queue_flag_clear(QUEUE_FLAG_NONROT, lo->lo_queue);
+	if (backing_bdev && !bdev_nonrot(backing_bdev))
+		lim.features |= BLK_FEAT_ROTATIONAL;
 	loop_config_discard(lo, &lim);
 	return queue_limits_commit_update(lo->lo_queue, &lim);
 }
diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index 43a187609ef794..1dbbf72659d549 100644
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -3485,7 +3485,6 @@  static int mtip_block_initialize(struct driver_data *dd)
 		goto start_service_thread;
 
 	/* Set device limits. */
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, dd->queue);
 	blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, dd->queue);
 	dma_set_max_seg_size(&dd->pdev->dev, 0x400000);
 
diff --git a/drivers/block/n64cart.c b/drivers/block/n64cart.c
index 27b2187e7a6d55..b9fdeff31cafdf 100644
--- a/drivers/block/n64cart.c
+++ b/drivers/block/n64cart.c
@@ -150,8 +150,6 @@  static int __init n64cart_probe(struct platform_device *pdev)
 	set_capacity(disk, size >> SECTOR_SHIFT);
 	set_disk_ro(disk, 1);
 
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, disk->queue);
-
 	err = add_disk(disk);
 	if (err)
 		goto out_cleanup_disk;
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index cb1c86a6a3fb9d..6cddf5baffe02a 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -1867,11 +1867,6 @@  static struct nbd_device *nbd_dev_add(int index, unsigned int refs)
 		goto out_err_disk;
 	}
 
-	/*
-	 * Tell the block layer that we are not a rotational device
-	 */
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, disk->queue);
-
 	mutex_init(&nbd->config_lock);
 	refcount_set(&nbd->config_refs, 0);
 	/*
diff --git a/drivers/block/null_blk/main.c b/drivers/block/null_blk/main.c
index 21f9d256e88402..83a4ebe4763ae5 100644
--- a/drivers/block/null_blk/main.c
+++ b/drivers/block/null_blk/main.c
@@ -1948,7 +1948,6 @@  static int null_add_dev(struct nullb_device *dev)
 	}
 
 	nullb->q->queuedata = nullb;
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, nullb->q);
 
 	rv = ida_alloc(&nullb_indexes, GFP_KERNEL);
 	if (rv < 0)
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 8a2ce80700109d..7cece5884b9c67 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -2622,6 +2622,7 @@  static int pkt_setup_dev(dev_t dev, dev_t* pkt_dev)
 	struct queue_limits lim = {
 		.max_hw_sectors		= PACKET_MAX_SECTORS,
 		.logical_block_size	= CD_FRAMESIZE,
+		.features		= BLK_FEAT_ROTATIONAL,
 	};
 	int idx;
 	int ret = -ENOMEM;
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index 8b73cf459b5937..ff45ed76646957 100644
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -388,7 +388,8 @@  static int ps3disk_probe(struct ps3_system_bus_device *_dev)
 		.max_segments		= -1,
 		.max_segment_size	= dev->bounce_size,
 		.dma_alignment		= dev->blk_size - 1,
-		.features		= BLK_FEAT_WRITE_CACHE,
+		.features		= BLK_FEAT_WRITE_CACHE |
+					  BLK_FEAT_ROTATIONAL,
 	};
 	struct gendisk *gendisk;
 
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index 22ad704f81d8b9..ec1f1c7d4275cd 100644
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -4997,9 +4997,6 @@  static int rbd_init_disk(struct rbd_device *rbd_dev)
 	disk->fops = &rbd_bd_ops;
 	disk->private_data = rbd_dev;
 
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
-	/* QUEUE_FLAG_ADD_RANDOM is off by default for blk-mq */
-
 	if (!ceph_test_opt(rbd_dev->rbd_client->client, NOCRC))
 		blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, q);
 
diff --git a/drivers/block/rnbd/rnbd-clt.c b/drivers/block/rnbd/rnbd-clt.c
index 02c4b173182719..4918b0f68b46cd 100644
--- a/drivers/block/rnbd/rnbd-clt.c
+++ b/drivers/block/rnbd/rnbd-clt.c
@@ -1352,10 +1352,6 @@  static int rnbd_clt_setup_gen_disk(struct rnbd_clt_dev *dev,
 	if (dev->access_mode == RNBD_ACCESS_RO)
 		set_disk_ro(dev->gd, true);
 
-	/*
-	 * Network device does not need rotational
-	 */
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, dev->queue);
 	err = add_disk(dev->gd);
 	if (err)
 		put_disk(dev->gd);
diff --git a/drivers/block/sunvdc.c b/drivers/block/sunvdc.c
index 5286cb8e0824d1..2d38331ee66793 100644
--- a/drivers/block/sunvdc.c
+++ b/drivers/block/sunvdc.c
@@ -791,6 +791,7 @@  static int probe_disk(struct vdc_port *port)
 		.seg_boundary_mask		= PAGE_SIZE - 1,
 		.max_segment_size		= PAGE_SIZE,
 		.max_segments			= port->ring_cookies,
+		.features			= BLK_FEAT_ROTATIONAL,
 	};
 	struct request_queue *q;
 	struct gendisk *g;
diff --git a/drivers/block/swim.c b/drivers/block/swim.c
index 6731678f3a41db..126f151c4f2cf0 100644
--- a/drivers/block/swim.c
+++ b/drivers/block/swim.c
@@ -787,6 +787,9 @@  static void swim_cleanup_floppy_disk(struct floppy_state *fs)
 
 static int swim_floppy_init(struct swim_priv *swd)
 {
+	struct queue_limits lim = {
+		.features		= BLK_FEAT_ROTATIONAL,
+	};
 	int err;
 	int drive;
 	struct swim __iomem *base = swd->base;
@@ -820,7 +823,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, NULL,
+			blk_mq_alloc_disk(&swd->unit[drive].tag_set, &lim,
 					  &swd->unit[drive]);
 		if (IS_ERR(swd->unit[drive].disk)) {
 			blk_mq_free_tag_set(&swd->unit[drive].tag_set);
diff --git a/drivers/block/swim3.c b/drivers/block/swim3.c
index a04756ac778ee8..90be1017f7bfcd 100644
--- a/drivers/block/swim3.c
+++ b/drivers/block/swim3.c
@@ -1189,6 +1189,9 @@  static int swim3_add_device(struct macio_dev *mdev, int index)
 static int swim3_attach(struct macio_dev *mdev,
 			const struct of_device_id *match)
 {
+	struct queue_limits lim = {
+		.features		= BLK_FEAT_ROTATIONAL,
+	};
 	struct floppy_state *fs;
 	struct gendisk *disk;
 	int rc;
@@ -1210,7 +1213,7 @@  static int swim3_attach(struct macio_dev *mdev,
 	if (rc)
 		goto out_unregister;
 
-	disk = blk_mq_alloc_disk(&fs->tag_set, NULL, fs);
+	disk = blk_mq_alloc_disk(&fs->tag_set, &lim, fs);
 	if (IS_ERR(disk)) {
 		rc = PTR_ERR(disk);
 		goto out_free_tag_set;
diff --git a/drivers/block/ublk_drv.c b/drivers/block/ublk_drv.c
index e45c65c1848d31..4fcde099935868 100644
--- a/drivers/block/ublk_drv.c
+++ b/drivers/block/ublk_drv.c
@@ -484,14 +484,8 @@  static inline unsigned ublk_pos_to_tag(loff_t pos)
 
 static void ublk_dev_param_basic_apply(struct ublk_device *ub)
 {
-	struct request_queue *q = ub->ub_disk->queue;
 	const struct ublk_param_basic *p = &ub->params.basic;
 
-	if (p->attrs & UBLK_ATTR_ROTATIONAL)
-		blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
-	else
-		blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
-
 	if (p->attrs & UBLK_ATTR_READ_ONLY)
 		set_disk_ro(ub->ub_disk, true);
 
@@ -2214,6 +2208,9 @@  static int ublk_ctrl_start_dev(struct ublk_device *ub, struct io_uring_cmd *cmd)
 			lim.features |= BLK_FEAT_FUA;
 	}
 
+	if (ub->params.basic.attrs & UBLK_ATTR_ROTATIONAL)
+		lim.features |= BLK_FEAT_ROTATIONAL;
+
 	if (wait_for_completion_interruptible(&ub->completion) != 0)
 		return -EINTR;
 
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index b1a3c293528519..13a2f24f176628 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -1451,7 +1451,9 @@  static int virtblk_read_limits(struct virtio_blk *vblk,
 static int virtblk_probe(struct virtio_device *vdev)
 {
 	struct virtio_blk *vblk;
-	struct queue_limits lim = { };
+	struct queue_limits lim = {
+		.features		= BLK_FEAT_ROTATIONAL,
+	};
 	int err, index;
 	unsigned int queue_depth;
 
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 9aafce3e5987bf..fa3a2ba525458b 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -1146,7 +1146,6 @@  static int xlvbd_alloc_gendisk(blkif_sector_t capacity,
 		err = PTR_ERR(gd);
 		goto out_free_tag_set;
 	}
-	blk_queue_flag_set(QUEUE_FLAG_VIRT, gd->queue);
 
 	strcpy(gd->disk_name, DEV_NAME);
 	ptr = encode_disk_name(gd->disk_name + sizeof(DEV_NAME) - 1, offset);
diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
index 3acd7006ad2ccd..aad840fc7e18e3 100644
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -2245,8 +2245,6 @@  static int zram_add(void)
 
 	/* Actual capacity set using sysfs (/sys/block/zram<id>/disksize */
 	set_capacity(zram->disk, 0);
-	/* zram devices sort of resembles non-rotational disks */
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, zram->disk->queue);
 	blk_queue_flag_set(QUEUE_FLAG_SYNCHRONOUS, zram->disk->queue);
 	blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, zram->disk->queue);
 	ret = device_add_disk(NULL, zram->disk, zram_disk_groups);
diff --git a/drivers/cdrom/gdrom.c b/drivers/cdrom/gdrom.c
index eefdd422ad8e9f..71cfe7a85913c4 100644
--- a/drivers/cdrom/gdrom.c
+++ b/drivers/cdrom/gdrom.c
@@ -744,6 +744,7 @@  static int probe_gdrom(struct platform_device *devptr)
 		.max_segments			= 1,
 		/* set a large max size to get most from DMA */
 		.max_segment_size		= 0x40000,
+		.features			= BLK_FEAT_ROTATIONAL,
 	};
 	int err;
 
diff --git a/drivers/md/bcache/super.c b/drivers/md/bcache/super.c
index cb6595c8b5514e..baa364eedd0051 100644
--- a/drivers/md/bcache/super.c
+++ b/drivers/md/bcache/super.c
@@ -974,8 +974,6 @@  static int bcache_device_init(struct bcache_device *d, unsigned int block_size,
 	d->disk->minors		= BCACHE_MINORS;
 	d->disk->fops		= ops;
 	d->disk->private_data	= d;
-
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, d->disk->queue);
 	return 0;
 
 out_bioset_exit:
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 03abdae646829c..c062af32970934 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -1716,12 +1716,6 @@  static int device_dax_write_cache_enabled(struct dm_target *ti,
 	return false;
 }
 
-static int device_is_rotational(struct dm_target *ti, struct dm_dev *dev,
-				sector_t start, sector_t len, void *data)
-{
-	return !bdev_nonrot(dev->bdev);
-}
-
 static int device_is_not_random(struct dm_target *ti, struct dm_dev *dev,
 			     sector_t start, sector_t len, void *data)
 {
@@ -1870,12 +1864,6 @@  int dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
 	if (dm_table_any_dev_attr(t, device_dax_write_cache_enabled, NULL))
 		dax_write_cache(t->md->dax_dev, true);
 
-	/* Ensure that all underlying devices are non-rotational. */
-	if (dm_table_any_dev_attr(t, device_is_rotational, NULL))
-		blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
-	else
-		blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
-
 	/*
 	 * Some devices don't use blk_integrity but still want stable pages
 	 * because they do their own checksumming.
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 2f4c5d1755d857..c23423c51fb7c2 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -6151,20 +6151,7 @@  int md_run(struct mddev *mddev)
 
 	if (!mddev_is_dm(mddev)) {
 		struct request_queue *q = mddev->gendisk->queue;
-		bool nonrot = true;
 
-		rdev_for_each(rdev, mddev) {
-			if (rdev->raid_disk >= 0 && !bdev_nonrot(rdev->bdev)) {
-				nonrot = false;
-				break;
-			}
-		}
-		if (mddev->degraded)
-			nonrot = false;
-		if (nonrot)
-			blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
-		else
-			blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
 		blk_queue_flag_set(QUEUE_FLAG_IO_STAT, q);
 
 		/* Set the NOWAIT flags if all underlying devices support it */
diff --git a/drivers/mmc/core/queue.c b/drivers/mmc/core/queue.c
index 97ff993d31570c..b4f62fa845864c 100644
--- a/drivers/mmc/core/queue.c
+++ b/drivers/mmc/core/queue.c
@@ -387,7 +387,6 @@  static struct gendisk *mmc_alloc_disk(struct mmc_queue *mq,
 		blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, mq->queue);
 	blk_queue_rq_timeout(mq->queue, 60 * HZ);
 
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, mq->queue);
 	blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, mq->queue);
 
 	dma_set_max_seg_size(mmc_dev(host), queue_max_segment_size(mq->queue));
diff --git a/drivers/mtd/mtd_blkdevs.c b/drivers/mtd/mtd_blkdevs.c
index 1b9f57f231e8be..bf8369ce7ddf1d 100644
--- a/drivers/mtd/mtd_blkdevs.c
+++ b/drivers/mtd/mtd_blkdevs.c
@@ -375,7 +375,6 @@  int add_mtd_blktrans_dev(struct mtd_blktrans_dev *new)
 	spin_lock_init(&new->queue_lock);
 	INIT_LIST_HEAD(&new->rq_list);
 
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, new->rq);
 	blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, new->rq);
 
 	gd->queue = new->rq;
diff --git a/drivers/nvdimm/btt.c b/drivers/nvdimm/btt.c
index c5f8451b494d6c..e474afa8e9f68d 100644
--- a/drivers/nvdimm/btt.c
+++ b/drivers/nvdimm/btt.c
@@ -1518,7 +1518,6 @@  static int btt_blk_init(struct btt *btt)
 	btt->btt_disk->fops = &btt_fops;
 	btt->btt_disk->private_data = btt;
 
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, btt->btt_disk->queue);
 	blk_queue_flag_set(QUEUE_FLAG_SYNCHRONOUS, btt->btt_disk->queue);
 
 	set_capacity(btt->btt_disk, btt->nlba * btt->sector_size >> 9);
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index aff818469c114c..501cf226df0187 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -546,7 +546,6 @@  static int pmem_attach_disk(struct device *dev,
 	}
 	pmem->virt_addr = addr;
 
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
 	blk_queue_flag_set(QUEUE_FLAG_SYNCHRONOUS, q);
 	if (pmem->pfn_flags & PFN_MAP)
 		blk_queue_flag_set(QUEUE_FLAG_DAX, q);
diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
index 9fc5e36fe2e55e..0d753fe71f35b0 100644
--- a/drivers/nvme/host/core.c
+++ b/drivers/nvme/host/core.c
@@ -3744,7 +3744,6 @@  static void nvme_alloc_ns(struct nvme_ctrl *ctrl, struct nvme_ns_info *info)
 	if (ctrl->opts && ctrl->opts->data_digest)
 		blk_queue_flag_set(QUEUE_FLAG_STABLE_WRITES, ns->queue);
 
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, ns->queue);
 	if (ctrl->ops->supports_pci_p2pdma &&
 	    ctrl->ops->supports_pci_p2pdma(ctrl))
 		blk_queue_flag_set(QUEUE_FLAG_PCI_P2PDMA, ns->queue);
diff --git a/drivers/nvme/host/multipath.c b/drivers/nvme/host/multipath.c
index 3d0e23a0a4ddd8..58c13304e558e0 100644
--- a/drivers/nvme/host/multipath.c
+++ b/drivers/nvme/host/multipath.c
@@ -549,7 +549,6 @@  int nvme_mpath_alloc_disk(struct nvme_ctrl *ctrl, struct nvme_ns_head *head)
 	sprintf(head->disk->disk_name, "nvme%dn%d",
 			ctrl->subsys->instance, head->instance);
 
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, head->disk->queue);
 	blk_queue_flag_set(QUEUE_FLAG_NOWAIT, head->disk->queue);
 	blk_queue_flag_set(QUEUE_FLAG_IO_STAT, head->disk->queue);
 	/*
diff --git a/drivers/s390/block/dasd_genhd.c b/drivers/s390/block/dasd_genhd.c
index 4533dd055ca8e3..1aa426b1deddc7 100644
--- a/drivers/s390/block/dasd_genhd.c
+++ b/drivers/s390/block/dasd_genhd.c
@@ -68,7 +68,6 @@  int dasd_gendisk_alloc(struct dasd_block *block)
 		blk_mq_free_tag_set(&block->tag_set);
 		return PTR_ERR(gdp);
 	}
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, gdp->queue);
 
 	/* Initialize gendisk structure. */
 	gdp->major = DASD_MAJOR;
diff --git a/drivers/s390/block/scm_blk.c b/drivers/s390/block/scm_blk.c
index 1d456a5a3bfb8e..2e2309fa9a0b34 100644
--- a/drivers/s390/block/scm_blk.c
+++ b/drivers/s390/block/scm_blk.c
@@ -475,7 +475,6 @@  int scm_blk_dev_setup(struct scm_blk_dev *bdev, struct scm_device *scmdev)
 		goto out_tag;
 	}
 	rq = bdev->rq = bdev->gendisk->queue;
-	blk_queue_flag_set(QUEUE_FLAG_NONROT, rq);
 	blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, rq);
 
 	bdev->gendisk->private_data = scmdev;
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index d8ee4a4d4a6283..a42c3c45e86830 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -3318,7 +3318,7 @@  static void sd_read_block_characteristics(struct scsi_disk *sdkp,
 	rcu_read_unlock();
 
 	if (rot == 1) {
-		blk_queue_flag_set(QUEUE_FLAG_NONROT, q);
+		lim->features &= ~BLK_FEAT_ROTATIONAL;
 		blk_queue_flag_clear(QUEUE_FLAG_ADD_RANDOM, q);
 	}
 
@@ -3646,7 +3646,7 @@  static int sd_revalidate_disk(struct gendisk *disk)
 		 * cause this to be updated correctly and any device which
 		 * doesn't support it should be treated as rotational.
 		 */
-		blk_queue_flag_clear(QUEUE_FLAG_NONROT, q);
+		lim.features |= BLK_FEAT_ROTATIONAL;
 		blk_queue_flag_set(QUEUE_FLAG_ADD_RANDOM, q);
 
 		if (scsi_device_supports_vpd(sdp)) {
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index acdfe5122faa44..988e3248cffeb7 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -289,14 +289,16 @@  enum {
 
 	/* supports passing on the FUA bit */
 	BLK_FEAT_FUA				= (1u << 1),
+
+	/* rotational device (hard drive or floppy) */
+	BLK_FEAT_ROTATIONAL			= (1u << 2),
 };
 
 /*
  * Flags automatically inherited when stacking limits.
  */
 #define BLK_FEAT_INHERIT_MASK \
-	(BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA)
-
+	(BLK_FEAT_WRITE_CACHE | BLK_FEAT_FUA | BLK_FEAT_ROTATIONAL)
 
 /* internal flags in queue_limits.flags */
 enum {
@@ -553,8 +555,6 @@  struct request_queue {
 #define QUEUE_FLAG_NOMERGES     3	/* disable merge attempts */
 #define QUEUE_FLAG_SAME_COMP	4	/* complete on same CPU-group */
 #define QUEUE_FLAG_FAIL_IO	5	/* fake timeout */
-#define QUEUE_FLAG_NONROT	6	/* non-rotational device (SSD) */
-#define QUEUE_FLAG_VIRT		QUEUE_FLAG_NONROT /* paravirt device */
 #define QUEUE_FLAG_IO_STAT	7	/* do disk/partitions IO accounting */
 #define QUEUE_FLAG_NOXMERGES	9	/* No extended merges */
 #define QUEUE_FLAG_ADD_RANDOM	10	/* Contributes to random pool */
@@ -589,7 +589,7 @@  bool blk_queue_flag_test_and_set(unsigned int flag, struct request_queue *q);
 #define blk_queue_nomerges(q)	test_bit(QUEUE_FLAG_NOMERGES, &(q)->queue_flags)
 #define blk_queue_noxmerges(q)	\
 	test_bit(QUEUE_FLAG_NOXMERGES, &(q)->queue_flags)
-#define blk_queue_nonrot(q)	test_bit(QUEUE_FLAG_NONROT, &(q)->queue_flags)
+#define blk_queue_nonrot(q)	((q)->limits.features & BLK_FEAT_ROTATIONAL)
 #define blk_queue_io_stat(q)	test_bit(QUEUE_FLAG_IO_STAT, &(q)->queue_flags)
 #define blk_queue_add_random(q)	test_bit(QUEUE_FLAG_ADD_RANDOM, &(q)->queue_flags)
 #define blk_queue_zone_resetall(q)	\