Commit d86e716a authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Jens Axboe
Browse files

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: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarChaitanya Kulkarni <kch@nvidia.com>
Reviewed-by: default avatarDamien Le Moal <damien.lemoal@opensource.wdc.com>
Reviewed-by: default avatarJohannes Thumshirn <johannes.thumshirn@wdc.com>
Link: https://lore.kernel.org/r/20220706070350.1703384-17-hch@lst.de


Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent de71973c

block/blk-mq-debugfs-zoned.c

+3 −3
Original line number Diff line number Diff line
@@ -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;

block/blk-sysfs.c

+1 −1
Original line number Diff line number Diff line
@@ -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)

block/blk-zoned.c

+21 −24
Original line number Diff line number Diff line
@@ -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 @@ int blkdev_zone_mgmt_ioctl(struct block_device *bdev, fmode_t mode, 


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;

drivers/block/null_blk/zoned.c

+1 −1
Original line number Diff line number Diff line
@@ -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);

drivers/md/dm-zone.c

+35 −39
Original line number Diff line number Diff line
@@ -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);

}