* [PATCH v10 01/13] block: make bdev_nr_zones and disk_zone_no generic for npo2 zone size
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 02/13] block:rearrange bdev_{is_zoned,zone_sectors,get_queue} helpers in blkdev.h Pankaj Raghav
` (11 subsequent siblings)
12 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav, Luis Chamberlain, Adam Manzanares
Adapt bdev_nr_zones and disk_zone_no functions so that they can
also work for non-power-of-2 zone sizes.
As the existing deployments assume that a device zone size is a power of
2 number of sectors, power-of-2 optimized calculation is used for those
devices.
There are no direct hot paths modified and the changes just
introduce one new branch per call.
Reviewed-by: Luis Chamberlain <mcgrof@kernel.org>
Reviewed-by: Adam Manzanares <a.manzanares@samsung.com>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
---
block/blk-zoned.c | 13 +++++++++----
include/linux/blkdev.h | 8 +++++++-
2 files changed, 16 insertions(+), 5 deletions(-)
diff --git a/block/blk-zoned.c b/block/blk-zoned.c
index a264621d4905..dce9c95b4bcd 100644
--- a/block/blk-zoned.c
+++ b/block/blk-zoned.c
@@ -111,17 +111,22 @@ EXPORT_SYMBOL_GPL(__blk_req_zone_write_unlock);
* bdev_nr_zones - Get number of zones
* @bdev: Target device
*
- * Return the total number of zones of a zoned block device. For a block
- * device without zone capabilities, the number of zones is always 0.
+ * Return the total number of zones of a zoned block device, including the
+ * eventual small last zone if present. For a block device without zone
+ * capabilities, the number of zones is always 0.
*/
unsigned int bdev_nr_zones(struct block_device *bdev)
{
sector_t zone_sectors = bdev_zone_sectors(bdev);
+ sector_t capacity = bdev_nr_sectors(bdev);
if (!bdev_is_zoned(bdev))
return 0;
- return (bdev_nr_sectors(bdev) + zone_sectors - 1) >>
- ilog2(zone_sectors);
+
+ if (is_power_of_2(zone_sectors))
+ return (capacity + zone_sectors - 1) >> ilog2(zone_sectors);
+
+ return DIV_ROUND_UP_SECTOR_T(capacity, zone_sectors);
}
EXPORT_SYMBOL_GPL(bdev_nr_zones);
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 84b13fdd34a7..ab82d1ff0cce 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -674,9 +674,15 @@ static inline unsigned int disk_nr_zones(struct gendisk *disk)
static inline unsigned int disk_zone_no(struct gendisk *disk, sector_t sector)
{
+ sector_t zone_sectors = disk->queue->limits.chunk_sectors;
+
if (!blk_queue_is_zoned(disk->queue))
return 0;
- return sector >> ilog2(disk->queue->limits.chunk_sectors);
+
+ if (is_power_of_2(zone_sectors))
+ return sector >> ilog2(zone_sectors);
+
+ return div64_u64(sector, zone_sectors);
}
static inline bool disk_zone_is_seq(struct gendisk *disk, sector_t sector)
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH v10 02/13] block:rearrange bdev_{is_zoned,zone_sectors,get_queue} helpers in blkdev.h
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 01/13] block: make bdev_nr_zones and disk_zone_no generic for npo2 zone size Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 20:21 ` Damien Le Moal
2022-08-11 14:30 ` [PATCH v10 03/13] block: allow blk-zoned devices to have non-power-of-2 zone size Pankaj Raghav
` (10 subsequent siblings)
12 siblings, 1 reply; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav
Define bdev_is_zoned(), bdev_zone_sectors() and bdev_get_queue() earlier
in the blkdev.h include file. Simplify bdev_is_zoned() by removing the
superfluous NULL check for request queue while we are at it.
This commit has no functional change, and it is a prep patch for allowing
zoned devices with non-power-of-2 zone sizes in the block layer.
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
---
include/linux/blkdev.h | 43 +++++++++++++++++++-----------------------
1 file changed, 19 insertions(+), 24 deletions(-)
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index ab82d1ff0cce..84e7881262e3 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -635,6 +635,11 @@ static inline bool queue_is_mq(struct request_queue *q)
return q->mq_ops;
}
+static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
+{
+ return bdev->bd_queue; /* this is never NULL */
+}
+
#ifdef CONFIG_PM
static inline enum rpm_status queue_rpm_status(struct request_queue *q)
{
@@ -666,6 +671,20 @@ static inline bool blk_queue_is_zoned(struct request_queue *q)
}
}
+static inline bool bdev_is_zoned(struct block_device *bdev)
+{
+ return blk_queue_is_zoned(bdev_get_queue(bdev));
+}
+
+static inline sector_t bdev_zone_sectors(struct block_device *bdev)
+{
+ struct request_queue *q = bdev_get_queue(bdev);
+
+ if (!blk_queue_is_zoned(q))
+ return 0;
+ return q->limits.chunk_sectors;
+}
+
#ifdef CONFIG_BLK_DEV_ZONED
static inline unsigned int disk_nr_zones(struct gendisk *disk)
{
@@ -892,11 +911,6 @@ int bio_poll(struct bio *bio, struct io_comp_batch *iob, unsigned int flags);
int iocb_bio_iopoll(struct kiocb *kiocb, struct io_comp_batch *iob,
unsigned int flags);
-static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
-{
- return bdev->bd_queue; /* this is never NULL */
-}
-
/* Helper to convert BLK_ZONE_ZONE_XXX to its string format XXX */
const char *blk_zone_cond_str(enum blk_zone_cond zone_cond);
@@ -1296,25 +1310,6 @@ static inline enum blk_zoned_model bdev_zoned_model(struct block_device *bdev)
return BLK_ZONED_NONE;
}
-static inline bool bdev_is_zoned(struct block_device *bdev)
-{
- struct request_queue *q = bdev_get_queue(bdev);
-
- if (q)
- return blk_queue_is_zoned(q);
-
- return false;
-}
-
-static inline sector_t bdev_zone_sectors(struct block_device *bdev)
-{
- struct request_queue *q = bdev_get_queue(bdev);
-
- if (!blk_queue_is_zoned(q))
- return 0;
- return q->limits.chunk_sectors;
-}
-
static inline int queue_dma_alignment(const struct request_queue *q)
{
return q ? q->dma_alignment : 511;
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* Re: [PATCH v10 02/13] block:rearrange bdev_{is_zoned,zone_sectors,get_queue} helpers in blkdev.h
2022-08-11 14:30 ` [PATCH v10 02/13] block:rearrange bdev_{is_zoned,zone_sectors,get_queue} helpers in blkdev.h Pankaj Raghav
@ 2022-08-11 20:21 ` Damien Le Moal
0 siblings, 0 replies; 24+ messages in thread
From: Damien Le Moal @ 2022-08-11 20:21 UTC (permalink / raw)
To: Pankaj Raghav, snitzer, axboe, hch, agk
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel
On 2022/08/11 7:30, Pankaj Raghav wrote:
> Define bdev_is_zoned(), bdev_zone_sectors() and bdev_get_queue() earlier
> in the blkdev.h include file. Simplify bdev_is_zoned() by removing the
> superfluous NULL check for request queue while we are at it.
>
> This commit has no functional change, and it is a prep patch for allowing
> zoned devices with non-power-of-2 zone sizes in the block layer.
>
> Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
> Reviewed-by: Bart Van Assche <bvanassche@acm.org>
> ---
> include/linux/blkdev.h | 43 +++++++++++++++++++-----------------------
> 1 file changed, 19 insertions(+), 24 deletions(-)
>
> diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
> index ab82d1ff0cce..84e7881262e3 100644
> --- a/include/linux/blkdev.h
> +++ b/include/linux/blkdev.h
> @@ -635,6 +635,11 @@ static inline bool queue_is_mq(struct request_queue *q)
> return q->mq_ops;
> }
>
> +static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
> +{
> + return bdev->bd_queue; /* this is never NULL */
> +}
> +
> #ifdef CONFIG_PM
> static inline enum rpm_status queue_rpm_status(struct request_queue *q)
> {
> @@ -666,6 +671,20 @@ static inline bool blk_queue_is_zoned(struct request_queue *q)
> }
> }
>
> +static inline bool bdev_is_zoned(struct block_device *bdev)
> +{
> + return blk_queue_is_zoned(bdev_get_queue(bdev));
> +}
You changed this too, so drop the current reviewed-by tag please.
For the next round, feel free to add:
Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
> +
> +static inline sector_t bdev_zone_sectors(struct block_device *bdev)
> +{
> + struct request_queue *q = bdev_get_queue(bdev);
> +
> + if (!blk_queue_is_zoned(q))
> + return 0;
> + return q->limits.chunk_sectors;
> +}
> +
> #ifdef CONFIG_BLK_DEV_ZONED
> static inline unsigned int disk_nr_zones(struct gendisk *disk)
> {
> @@ -892,11 +911,6 @@ int bio_poll(struct bio *bio, struct io_comp_batch *iob, unsigned int flags);
> int iocb_bio_iopoll(struct kiocb *kiocb, struct io_comp_batch *iob,
> unsigned int flags);
>
> -static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
> -{
> - return bdev->bd_queue; /* this is never NULL */
> -}
> -
> /* Helper to convert BLK_ZONE_ZONE_XXX to its string format XXX */
> const char *blk_zone_cond_str(enum blk_zone_cond zone_cond);
>
> @@ -1296,25 +1310,6 @@ static inline enum blk_zoned_model bdev_zoned_model(struct block_device *bdev)
> return BLK_ZONED_NONE;
> }
>
> -static inline bool bdev_is_zoned(struct block_device *bdev)
> -{
> - struct request_queue *q = bdev_get_queue(bdev);
> -
> - if (q)
> - return blk_queue_is_zoned(q);
> -
> - return false;
> -}
> -
> -static inline sector_t bdev_zone_sectors(struct block_device *bdev)
> -{
> - struct request_queue *q = bdev_get_queue(bdev);
> -
> - if (!blk_queue_is_zoned(q))
> - return 0;
> - return q->limits.chunk_sectors;
> -}
> -
> static inline int queue_dma_alignment(const struct request_queue *q)
> {
> return q ? q->dma_alignment : 511;
--
Damien Le Moal
Western Digital Research
^ permalink raw reply [flat|nested] 24+ messages in thread
* [PATCH v10 03/13] block: allow blk-zoned devices to have non-power-of-2 zone size
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 01/13] block: make bdev_nr_zones and disk_zone_no generic for npo2 zone size Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 02/13] block:rearrange bdev_{is_zoned,zone_sectors,get_queue} helpers in blkdev.h Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 04/13] nvmet: Allow ZNS target to support non-power_of_2 zone sizes Pankaj Raghav
` (9 subsequent siblings)
12 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav, Luis Chamberlain
Checking if a given sector is aligned to a zone is a common
operation that is performed for zoned devices. Add
bdev_is_zone_start helper to check for this instead of opencoding it
everywhere.
Convert the calculations on zone size to be generic instead of relying on
power-of-2(po2) based arithmetic in the block layer using the helpers
wherever possible.
The only hot path affected by this change for zoned devices with po2
zone size is in blk_check_zone_append() but bdev_is_zone_start() helper is
used to optimize the calculation for po2 zone sizes.
Finally, allow zoned devices with non po2 zone sizes provided that their
zone capacity and zone size are equal. The main motivation to allow zoned
devices with non po2 zone size is to remove the unmapped LBA between
zone capcity and zone size for devices that cannot have a po2 zone
capacity.
Reviewed-by: Luis Chamberlain <mcgrof@kernel.org>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
---
block/blk-core.c | 2 +-
block/blk-zoned.c | 24 ++++++++++++++++++------
include/linux/blkdev.h | 30 ++++++++++++++++++++++++++++++
3 files changed, 49 insertions(+), 7 deletions(-)
diff --git a/block/blk-core.c b/block/blk-core.c
index a0d1104c5590..1cb519220ffb 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -563,7 +563,7 @@ static inline blk_status_t blk_check_zone_append(struct request_queue *q,
return BLK_STS_NOTSUPP;
/* The bio sector must point to the start of a sequential zone */
- if (bio->bi_iter.bi_sector & (bdev_zone_sectors(bio->bi_bdev) - 1) ||
+ if (!bdev_is_zone_start(bio->bi_bdev, bio->bi_iter.bi_sector) ||
!bio_zone_is_seq(bio))
return BLK_STS_IOERR;
diff --git a/block/blk-zoned.c b/block/blk-zoned.c
index dce9c95b4bcd..6806c69c81dc 100644
--- a/block/blk-zoned.c
+++ b/block/blk-zoned.c
@@ -285,10 +285,10 @@ int blkdev_zone_mgmt(struct block_device *bdev, enum req_op op,
return -EINVAL;
/* Check alignment (handle eventual smaller last zone) */
- if (sector & (zone_sectors - 1))
+ if (!bdev_is_zone_start(bdev, sector))
return -EINVAL;
- if ((nr_sectors & (zone_sectors - 1)) && end_sector != capacity)
+ if (!bdev_is_zone_start(bdev, nr_sectors) && end_sector != capacity)
return -EINVAL;
/*
@@ -486,14 +486,26 @@ static int blk_revalidate_zone_cb(struct blk_zone *zone, unsigned int idx,
* smaller last zone.
*/
if (zone->start == 0) {
- if (zone->len == 0 || !is_power_of_2(zone->len)) {
- pr_warn("%s: Invalid zoned device with non power of two zone size (%llu)\n",
- disk->disk_name, zone->len);
+ if (zone->len == 0) {
+ pr_warn("%s: Invalid zero zone size", disk->disk_name);
+ return -ENODEV;
+ }
+
+ /*
+ * Non power-of-2 zone size support was added to remove the
+ * gap between zone capacity and zone size. Though it is technically
+ * possible to have gaps in a non power-of-2 device, Linux requires
+ * the zone size to be equal to zone capacity for non power-of-2
+ * zoned devices.
+ */
+ if (!is_power_of_2(zone->len) && zone->capacity < zone->len) {
+ pr_err("%s: Invalid zone capacity %lld with non power-of-2 zone size %lld",
+ disk->disk_name, zone->capacity, zone->len);
return -ENODEV;
}
args->zone_sectors = zone->len;
- args->nr_zones = (capacity + zone->len - 1) >> ilog2(zone->len);
+ args->nr_zones = div64_u64(capacity + zone->len - 1, zone->len);
} else if (zone->start + args->zone_sectors < capacity) {
if (zone->len != args->zone_sectors) {
pr_warn("%s: Invalid zoned device with non constant zone size\n",
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 84e7881262e3..d0d66a0db224 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -704,6 +704,30 @@ static inline unsigned int disk_zone_no(struct gendisk *disk, sector_t sector)
return div64_u64(sector, zone_sectors);
}
+static inline sector_t bdev_offset_from_zone_start(struct block_device *bdev,
+ sector_t sec)
+{
+ sector_t zone_sectors = bdev_zone_sectors(bdev);
+ u64 remainder = 0;
+
+ if (!bdev_is_zoned(bdev))
+ return 0;
+
+ if (is_power_of_2(zone_sectors))
+ return sec & (zone_sectors - 1);
+
+ div64_u64_rem(sec, zone_sectors, &remainder);
+ return remainder;
+}
+
+static inline bool bdev_is_zone_start(struct block_device *bdev, sector_t sec)
+{
+ if (!bdev_is_zoned(bdev))
+ return false;
+
+ return bdev_offset_from_zone_start(bdev, sec) == 0;
+}
+
static inline bool disk_zone_is_seq(struct gendisk *disk, sector_t sector)
{
if (!blk_queue_is_zoned(disk->queue))
@@ -748,6 +772,12 @@ static inline unsigned int disk_zone_no(struct gendisk *disk, sector_t sector)
{
return 0;
}
+
+static inline bool bdev_is_zone_start(struct block_device *bdev, sector_t sec)
+{
+ return false;
+}
+
static inline unsigned int bdev_max_open_zones(struct block_device *bdev)
{
return 0;
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH v10 04/13] nvmet: Allow ZNS target to support non-power_of_2 zone sizes
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
` (2 preceding siblings ...)
2022-08-11 14:30 ` [PATCH v10 03/13] block: allow blk-zoned devices to have non-power-of-2 zone size Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 05/13] nvme: zns: Allow ZNS drives that have non-power_of_2 zone size Pankaj Raghav
` (8 subsequent siblings)
12 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav, Johannes Thumshirn, Luis Chamberlain
A generic bdev_zone_no() helper is added to calculate zone number for a
given sector in a block device. This helper internally uses disk_zone_no()
to find the zone number.
Use the helper bdev_zone_no() to calculate nr of zones. This let's us
make modifications to the math if needed in one place and adds now
support for zoned devices with non po2 zone size.
Reviewed by: Adam Manzanares <a.manzanares@samsung.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Signed-off-by: Luis Chamberlain <mcgrof@kernel.org>
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
---
drivers/nvme/target/zns.c | 3 +--
include/linux/blkdev.h | 5 +++++
2 files changed, 6 insertions(+), 2 deletions(-)
diff --git a/drivers/nvme/target/zns.c b/drivers/nvme/target/zns.c
index c7ef69f29fe4..662f1a92f39b 100644
--- a/drivers/nvme/target/zns.c
+++ b/drivers/nvme/target/zns.c
@@ -241,8 +241,7 @@ static unsigned long nvmet_req_nr_zones_from_slba(struct nvmet_req *req)
{
unsigned int sect = nvmet_lba_to_sect(req->ns, req->cmd->zmr.slba);
- return bdev_nr_zones(req->ns->bdev) -
- (sect >> ilog2(bdev_zone_sectors(req->ns->bdev)));
+ return bdev_nr_zones(req->ns->bdev) - bdev_zone_no(req->ns->bdev, sect);
}
static unsigned long get_nr_zones_from_buf(struct nvmet_req *req, u32 bufsize)
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index d0d66a0db224..b2636dcca105 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -1340,6 +1340,11 @@ static inline enum blk_zoned_model bdev_zoned_model(struct block_device *bdev)
return BLK_ZONED_NONE;
}
+static inline unsigned int bdev_zone_no(struct block_device *bdev, sector_t sec)
+{
+ return disk_zone_no(bdev->bd_disk, sec);
+}
+
static inline int queue_dma_alignment(const struct request_queue *q)
{
return q ? q->dma_alignment : 511;
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH v10 05/13] nvme: zns: Allow ZNS drives that have non-power_of_2 zone size
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
` (3 preceding siblings ...)
2022-08-11 14:30 ` [PATCH v10 04/13] nvmet: Allow ZNS target to support non-power_of_2 zone sizes Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-16 21:14 ` Keith Busch
2022-08-11 14:30 ` [PATCH v10 06/13] null_blk: allow zoned devices with non power-of-2 zone sizes Pankaj Raghav
` (7 subsequent siblings)
12 siblings, 1 reply; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav, Luis Chamberlain
Remove the condition which disallows non-power_of_2 zone size ZNS drive
to be updated and use generic method to calculate number of zones
instead of relying on log and shift based calculation on zone size.
The power_of_2 calculation has been replaced directly with generic
calculation without special handling. Both modified functions are not
used in hot paths, they are only used during initialization &
revalidation of the ZNS device.
As rounddown macro from math.h does not work for 32 bit architectures,
round down operation is open coded.
Reviewed-by: Luis Chamberlain <mcgrof@kernel.org>
Reviewed by: Adam Manzanares <a.manzanares@samsung.com>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
---
drivers/nvme/host/zns.c | 16 +++++++---------
1 file changed, 7 insertions(+), 9 deletions(-)
diff --git a/drivers/nvme/host/zns.c b/drivers/nvme/host/zns.c
index 12316ab51bda..73e4ad495ae8 100644
--- a/drivers/nvme/host/zns.c
+++ b/drivers/nvme/host/zns.c
@@ -101,13 +101,6 @@ int nvme_update_zone_info(struct nvme_ns *ns, unsigned lbaf)
}
ns->zsze = nvme_lba_to_sect(ns, le64_to_cpu(id->lbafe[lbaf].zsze));
- if (!is_power_of_2(ns->zsze)) {
- dev_warn(ns->ctrl->device,
- "invalid zone size:%llu for namespace:%u\n",
- ns->zsze, ns->head->ns_id);
- status = -ENODEV;
- goto free_data;
- }
disk_set_zoned(ns->disk, BLK_ZONED_HM);
blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q);
@@ -129,7 +122,7 @@ static void *nvme_zns_alloc_report_buffer(struct nvme_ns *ns,
sizeof(struct nvme_zone_descriptor);
nr_zones = min_t(unsigned int, nr_zones,
- get_capacity(ns->disk) >> ilog2(ns->zsze));
+ div64_u64(get_capacity(ns->disk), ns->zsze));
bufsize = sizeof(struct nvme_zone_report) +
nr_zones * sizeof(struct nvme_zone_descriptor);
@@ -182,6 +175,7 @@ int nvme_ns_report_zones(struct nvme_ns *ns, sector_t sector,
int ret, zone_idx = 0;
unsigned int nz, i;
size_t buflen;
+ u64 remainder = 0;
if (ns->head->ids.csi != NVME_CSI_ZNS)
return -EINVAL;
@@ -197,7 +191,11 @@ int nvme_ns_report_zones(struct nvme_ns *ns, sector_t sector,
c.zmr.zrasf = NVME_ZRASF_ZONE_REPORT_ALL;
c.zmr.pr = NVME_REPORT_ZONE_PARTIAL;
- sector &= ~(ns->zsze - 1);
+ /*
+ * Round down the sector value to the nearest zone start
+ */
+ div64_u64_rem(sector, ns->zsze, &remainder);
+ sector -= remainder;
while (zone_idx < nr_zones && sector < get_capacity(ns->disk)) {
memset(report, 0, buflen);
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* Re: [PATCH v10 05/13] nvme: zns: Allow ZNS drives that have non-power_of_2 zone size
2022-08-11 14:30 ` [PATCH v10 05/13] nvme: zns: Allow ZNS drives that have non-power_of_2 zone size Pankaj Raghav
@ 2022-08-16 21:14 ` Keith Busch
2022-08-17 7:28 ` Pankaj Raghav
0 siblings, 1 reply; 24+ messages in thread
From: Keith Busch @ 2022-08-16 21:14 UTC (permalink / raw)
To: Pankaj Raghav
Cc: snitzer, axboe, hch, agk, damien.lemoal, linux-block,
Johannes.Thumshirn, bvanassche, matias.bjorling, hare, gost.dev,
linux-nvme, jaegeuk, pankydev8, linux-kernel, dm-devel,
Luis Chamberlain
On Thu, Aug 11, 2022 at 04:30:35PM +0200, Pankaj Raghav wrote:
> @@ -101,13 +101,6 @@ int nvme_update_zone_info(struct nvme_ns *ns, unsigned lbaf)
> }
>
> ns->zsze = nvme_lba_to_sect(ns, le64_to_cpu(id->lbafe[lbaf].zsze));
> - if (!is_power_of_2(ns->zsze)) {
> - dev_warn(ns->ctrl->device,
> - "invalid zone size:%llu for namespace:%u\n",
> - ns->zsze, ns->head->ns_id);
> - status = -ENODEV;
> - goto free_data;
> - }
We used to bail out early if the format wasn't supported, which wouldn't create
the namespace.
Now you are relying on blk_revalidate_disk_zones() to report an error for
invalid format, but the handling for an error there is different: the namespace
still gets created. I'm not sure if that's a problem, but it's different.
^ permalink raw reply [flat|nested] 24+ messages in thread* Re: [PATCH v10 05/13] nvme: zns: Allow ZNS drives that have non-power_of_2 zone size
2022-08-16 21:14 ` Keith Busch
@ 2022-08-17 7:28 ` Pankaj Raghav
0 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-17 7:28 UTC (permalink / raw)
To: Keith Busch
Cc: snitzer, axboe, hch, agk, damien.lemoal, linux-block,
Johannes.Thumshirn, bvanassche, matias.bjorling, hare, gost.dev,
linux-nvme, jaegeuk, pankydev8, linux-kernel, dm-devel,
Luis Chamberlain
Hi Keith,
On 2022-08-16 23:14, Keith Busch wrote:
> On Thu, Aug 11, 2022 at 04:30:35PM +0200, Pankaj Raghav wrote:
>> @@ -101,13 +101,6 @@ int nvme_update_zone_info(struct nvme_ns *ns, unsigned lbaf)
>> }
>>
>> ns->zsze = nvme_lba_to_sect(ns, le64_to_cpu(id->lbafe[lbaf].zsze));
>> - if (!is_power_of_2(ns->zsze)) {
>> - dev_warn(ns->ctrl->device,
>> - "invalid zone size:%llu for namespace:%u\n",
>> - ns->zsze, ns->head->ns_id);
>> - status = -ENODEV;
>> - goto free_data;
>> - }
>
> We used to bail out early if the format wasn't supported, which wouldn't create
> the namespace.
>
> Now you are relying on blk_revalidate_disk_zones() to report an error for
> invalid format, but the handling for an error there is different: the namespace
> still gets created. I'm not sure if that's a problem, but it's different.
That is right but it is not a problem. Once the block layer supports the
non-po2 zone sizes, we don't need to bail out here because it will be
compatible. If unequal zone sizes are found, block layer will report an
error during blk_revalidate_disk_zones() which is the current behavior anyway.
Other checks such as zone operation support are still in
nvme_update_zone_info() resulting in an early bail out if violated.
^ permalink raw reply [flat|nested] 24+ messages in thread
* [PATCH v10 06/13] null_blk: allow zoned devices with non power-of-2 zone sizes
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
` (4 preceding siblings ...)
2022-08-11 14:30 ` [PATCH v10 05/13] nvme: zns: Allow ZNS drives that have non-power_of_2 zone size Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 07/13] zonefs: allow non power of 2 zoned devices Pankaj Raghav
` (6 subsequent siblings)
12 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav, Luis Chamberlain
Convert the power-of-2(po2) based calculation with zone size to be generic
in null_zone_no with optimization for po2 zone sizes.
The nr_zones calculation in null_init_zoned_dev has been replaced with a
division without special handling for po2 zone sizes as this function is
called only during the initialization and will not be invoked in the hot
path.
Reviewed-by: Luis Chamberlain <mcgrof@kernel.org>
Reviewed by: Adam Manzanares <a.manzanares@samsung.com>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
---
drivers/block/null_blk/main.c | 5 ++---
drivers/block/null_blk/null_blk.h | 1 +
drivers/block/null_blk/zoned.c | 18 +++++++++++-------
3 files changed, 14 insertions(+), 10 deletions(-)
diff --git a/drivers/block/null_blk/main.c b/drivers/block/null_blk/main.c
index c451c477978f..f1e0605dee94 100644
--- a/drivers/block/null_blk/main.c
+++ b/drivers/block/null_blk/main.c
@@ -1976,9 +1976,8 @@ static int null_validate_conf(struct nullb_device *dev)
if (dev->queue_mode == NULL_Q_BIO)
dev->mbps = 0;
- if (dev->zoned &&
- (!dev->zone_size || !is_power_of_2(dev->zone_size))) {
- pr_err("zone_size must be power-of-two\n");
+ if (dev->zoned && !dev->zone_size) {
+ pr_err("Invalid zero zone size\n");
return -EINVAL;
}
diff --git a/drivers/block/null_blk/null_blk.h b/drivers/block/null_blk/null_blk.h
index 94ff68052b1e..f63b6bed1bb3 100644
--- a/drivers/block/null_blk/null_blk.h
+++ b/drivers/block/null_blk/null_blk.h
@@ -83,6 +83,7 @@ struct nullb_device {
unsigned int imp_close_zone_no;
struct nullb_zone *zones;
sector_t zone_size_sects;
+ unsigned int zone_size_sects_shift;
bool need_zone_res_mgmt;
spinlock_t zone_res_lock;
diff --git a/drivers/block/null_blk/zoned.c b/drivers/block/null_blk/zoned.c
index 55a69e48ef8b..015f6823706c 100644
--- a/drivers/block/null_blk/zoned.c
+++ b/drivers/block/null_blk/zoned.c
@@ -16,7 +16,10 @@ static inline sector_t mb_to_sects(unsigned long mb)
static inline unsigned int null_zone_no(struct nullb_device *dev, sector_t sect)
{
- return sect >> ilog2(dev->zone_size_sects);
+ if (dev->zone_size_sects_shift)
+ return sect >> dev->zone_size_sects_shift;
+
+ return div64_u64(sect, dev->zone_size_sects);
}
static inline void null_lock_zone_res(struct nullb_device *dev)
@@ -65,10 +68,6 @@ int null_init_zoned_dev(struct nullb_device *dev, struct request_queue *q)
sector_t sector = 0;
unsigned int i;
- if (!is_power_of_2(dev->zone_size)) {
- pr_err("zone_size must be power-of-two\n");
- return -EINVAL;
- }
if (dev->zone_size > dev->size) {
pr_err("Zone size larger than device capacity\n");
return -EINVAL;
@@ -86,9 +85,14 @@ int null_init_zoned_dev(struct nullb_device *dev, struct request_queue *q)
zone_capacity_sects = mb_to_sects(dev->zone_capacity);
dev_capacity_sects = mb_to_sects(dev->size);
dev->zone_size_sects = mb_to_sects(dev->zone_size);
- dev->nr_zones = round_up(dev_capacity_sects, dev->zone_size_sects)
- >> ilog2(dev->zone_size_sects);
+ if (is_power_of_2(dev->zone_size_sects))
+ dev->zone_size_sects_shift = ilog2(dev->zone_size_sects);
+ else
+ dev->zone_size_sects_shift = 0;
+
+ dev->nr_zones = DIV_ROUND_UP_SECTOR_T(dev_capacity_sects,
+ dev->zone_size_sects);
dev->zones = kvmalloc_array(dev->nr_zones, sizeof(struct nullb_zone),
GFP_KERNEL | __GFP_ZERO);
if (!dev->zones)
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH v10 07/13] zonefs: allow non power of 2 zoned devices
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
` (5 preceding siblings ...)
2022-08-11 14:30 ` [PATCH v10 06/13] null_blk: allow zoned devices with non power-of-2 zone sizes Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 08/13] dm-zoned: ensure only power of 2 zone sizes are allowed Pankaj Raghav
` (5 subsequent siblings)
12 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav, Luis Chamberlain
The zone size shift variable is useful only if the zone sizes are known
to be power of 2. Remove that variable and use generic helpers from
block layer to calculate zone index in zonefs.
Acked-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Reviewed-by: Luis Chamberlain <mcgrof@kernel.org>
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
---
fs/zonefs/super.c | 6 ++----
fs/zonefs/zonefs.h | 1 -
2 files changed, 2 insertions(+), 5 deletions(-)
diff --git a/fs/zonefs/super.c b/fs/zonefs/super.c
index 860f0b1032c6..e549ef16738c 100644
--- a/fs/zonefs/super.c
+++ b/fs/zonefs/super.c
@@ -476,10 +476,9 @@ static void __zonefs_io_error(struct inode *inode, bool write)
{
struct zonefs_inode_info *zi = ZONEFS_I(inode);
struct super_block *sb = inode->i_sb;
- struct zonefs_sb_info *sbi = ZONEFS_SB(sb);
unsigned int noio_flag;
unsigned int nr_zones =
- zi->i_zone_size >> (sbi->s_zone_sectors_shift + SECTOR_SHIFT);
+ bdev_zone_no(sb->s_bdev, zi->i_zone_size >> SECTOR_SHIFT);
struct zonefs_ioerr_data err = {
.inode = inode,
.write = write,
@@ -1401,7 +1400,7 @@ static int zonefs_init_file_inode(struct inode *inode, struct blk_zone *zone,
struct zonefs_inode_info *zi = ZONEFS_I(inode);
int ret = 0;
- inode->i_ino = zone->start >> sbi->s_zone_sectors_shift;
+ inode->i_ino = bdev_zone_no(sb->s_bdev, zone->start);
inode->i_mode = S_IFREG | sbi->s_perm;
zi->i_ztype = type;
@@ -1776,7 +1775,6 @@ static int zonefs_fill_super(struct super_block *sb, void *data, int silent)
* interface constraints.
*/
sb_set_blocksize(sb, bdev_zone_write_granularity(sb->s_bdev));
- sbi->s_zone_sectors_shift = ilog2(bdev_zone_sectors(sb->s_bdev));
sbi->s_uid = GLOBAL_ROOT_UID;
sbi->s_gid = GLOBAL_ROOT_GID;
sbi->s_perm = 0640;
diff --git a/fs/zonefs/zonefs.h b/fs/zonefs/zonefs.h
index 4b3de66c3233..39895195cda6 100644
--- a/fs/zonefs/zonefs.h
+++ b/fs/zonefs/zonefs.h
@@ -177,7 +177,6 @@ struct zonefs_sb_info {
kgid_t s_gid;
umode_t s_perm;
uuid_t s_uuid;
- unsigned int s_zone_sectors_shift;
unsigned int s_nr_files[ZONEFS_ZTYPE_MAX];
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH v10 08/13] dm-zoned: ensure only power of 2 zone sizes are allowed
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
` (6 preceding siblings ...)
2022-08-11 14:30 ` [PATCH v10 07/13] zonefs: allow non power of 2 zoned devices Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 09/13] dm-zone: use generic helpers to calculate offset from zone start Pankaj Raghav
` (4 subsequent siblings)
12 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Luis Chamberlain, Pankaj Raghav
From: Luis Chamberlain <mcgrof@kernel.org>
dm-zoned relies on the assumption that the zone size is a
power-of-2(po2) and the zone capacity is same as the zone size.
Ensure only po2 devices can be used as dm-zoned target until a native
support for zoned devices with non-po2 zone size is added.
Reviewed-by: Hannes Reinecke <hare@suse.de>
Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Signed-off-by: Luis Chamberlain <mcgrof@kernel.org>
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
---
drivers/md/dm-zoned-target.c | 8 ++++++++
1 file changed, 8 insertions(+)
diff --git a/drivers/md/dm-zoned-target.c b/drivers/md/dm-zoned-target.c
index 95b132b52f33..9325bf5dee81 100644
--- a/drivers/md/dm-zoned-target.c
+++ b/drivers/md/dm-zoned-target.c
@@ -792,6 +792,10 @@ static int dmz_fixup_devices(struct dm_target *ti)
return -EINVAL;
}
zone_nr_sectors = bdev_zone_sectors(bdev);
+ if (!is_power_of_2(zone_nr_sectors)) {
+ ti->error = "Zone size is not a power-of-2 number of sectors";
+ return -EINVAL;
+ }
zoned_dev->zone_nr_sectors = zone_nr_sectors;
zoned_dev->nr_zones = bdev_nr_zones(bdev);
}
@@ -804,6 +808,10 @@ static int dmz_fixup_devices(struct dm_target *ti)
return -EINVAL;
}
zoned_dev->zone_nr_sectors = bdev_zone_sectors(bdev);
+ if (!is_power_of_2(zoned_dev->zone_nr_sectors)) {
+ ti->error = "Zone size is not a power-of-2 number of sectors";
+ return -EINVAL;
+ }
zoned_dev->nr_zones = bdev_nr_zones(bdev);
}
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH v10 09/13] dm-zone: use generic helpers to calculate offset from zone start
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
` (7 preceding siblings ...)
2022-08-11 14:30 ` [PATCH v10 08/13] dm-zoned: ensure only power of 2 zone sizes are allowed Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 10/13] dm-table: allow zoned devices with non power-of-2 zone sizes Pankaj Raghav
` (3 subsequent siblings)
12 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav, Luis Chamberlain
Use the bdev_offset_from_zone_start() helper function to calculate
the offset from zone start instead of using power of 2 based
calculation.
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
Reviewed-by: Luis Chamberlain <mcgrof@kernel.org>
Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
---
drivers/md/dm-zone.c | 8 +++-----
1 file changed, 3 insertions(+), 5 deletions(-)
diff --git a/drivers/md/dm-zone.c b/drivers/md/dm-zone.c
index 3dafc0e8b7a9..ac6fc1293d41 100644
--- a/drivers/md/dm-zone.c
+++ b/drivers/md/dm-zone.c
@@ -390,7 +390,8 @@ static bool dm_zone_map_bio_begin(struct mapped_device *md,
case REQ_OP_WRITE_ZEROES:
case REQ_OP_WRITE:
/* Writes must be aligned to the zone write pointer */
- if ((clone->bi_iter.bi_sector & (zsectors - 1)) != zwp_offset)
+ if (bdev_offset_from_zone_start(md->disk->part0,
+ clone->bi_iter.bi_sector) != zwp_offset)
return false;
break;
case REQ_OP_ZONE_APPEND:
@@ -602,11 +603,8 @@ void dm_zone_endio(struct dm_io *io, struct bio *clone)
*/
if (clone->bi_status == BLK_STS_OK &&
bio_op(clone) == REQ_OP_ZONE_APPEND) {
- sector_t mask =
- (sector_t)bdev_zone_sectors(disk->part0) - 1;
-
orig_bio->bi_iter.bi_sector +=
- clone->bi_iter.bi_sector & mask;
+ bdev_offset_from_zone_start(disk->part0, clone->bi_iter.bi_sector);
}
return;
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH v10 10/13] dm-table: allow zoned devices with non power-of-2 zone sizes
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
` (8 preceding siblings ...)
2022-08-11 14:30 ` [PATCH v10 09/13] dm-zone: use generic helpers to calculate offset from zone start Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 11/13] dm: call dm_zone_endio after the target endio callback for zoned devices Pankaj Raghav
` (2 subsequent siblings)
12 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav
Allow dm to support zoned devices with non power-of-2(po2) zone sizes as
the block layer now supports it.
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
Reviewed-by: Bart Van Assche <bvanassche@acm.org>
Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
---
drivers/md/dm-table.c | 7 +++----
1 file changed, 3 insertions(+), 4 deletions(-)
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 332f96b58252..31eb1d29d136 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -250,7 +250,7 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
if (bdev_is_zoned(bdev)) {
unsigned int zone_sectors = bdev_zone_sectors(bdev);
- if (start & (zone_sectors - 1)) {
+ if (!bdev_is_zone_start(bdev, start)) {
DMWARN("%s: start=%llu not aligned to h/w zone size %u of %pg",
dm_device_name(ti->table->md),
(unsigned long long)start,
@@ -267,7 +267,7 @@ static int device_area_is_invalid(struct dm_target *ti, struct dm_dev *dev,
* devices do not end up with a smaller zone in the middle of
* the sector range.
*/
- if (len & (zone_sectors - 1)) {
+ if (!bdev_is_zone_start(bdev, len)) {
DMWARN("%s: len=%llu not aligned to h/w zone size %u of %pg",
dm_device_name(ti->table->md),
(unsigned long long)len,
@@ -1642,8 +1642,7 @@ static int validate_hardware_zoned_model(struct dm_table *t,
return -EINVAL;
}
- /* Check zone size validity and compatibility */
- if (!zone_sectors || !is_power_of_2(zone_sectors))
+ if (!zone_sectors)
return -EINVAL;
if (dm_table_any_dev_attr(t, device_not_matches_zone_sectors, &zone_sectors)) {
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH v10 11/13] dm: call dm_zone_endio after the target endio callback for zoned devices
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
` (9 preceding siblings ...)
2022-08-11 14:30 ` [PATCH v10 10/13] dm-table: allow zoned devices with non power-of-2 zone sizes Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 12/13] dm: introduce DM_EMULATED_ZONES target type Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes Pankaj Raghav
12 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav
dm_zone_endio() updates the bi_sector of orig bio for zoned devices that
uses either native append or append emulation, and it is called before the
endio of the target. But target endio can still update the clone bio
after dm_zone_endio is called, thereby, the orig bio does not contain
the updated information anymore.
Currently, this is not a problem as the targets that support zoned devices
such as dm-zoned, dm-linear, and dm-crypt do not have an endio function,
and even if they do (such as dm-flakey), they don't modify the
bio->bi_iter.bi_sector of the cloned bio that is used to update the
orig_bio's bi_sector in dm_zone_endio function.
This is a prep patch for the new dm-po2zone target as it modifies
bi_sector in the endio callback.
Call dm_zone_endio for zoned devices after calling the target's endio
function.
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
---
drivers/md/dm.c | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index 60549b65c799..58b392c51d04 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1122,10 +1122,6 @@ static void clone_endio(struct bio *bio)
disable_write_zeroes(md);
}
- if (static_branch_unlikely(&zoned_enabled) &&
- unlikely(bdev_is_zoned(bio->bi_bdev)))
- dm_zone_endio(io, bio);
-
if (endio) {
int r = endio(ti, bio, &error);
switch (r) {
@@ -1154,6 +1150,10 @@ static void clone_endio(struct bio *bio)
}
}
+ if (static_branch_unlikely(&zoned_enabled) &&
+ unlikely(bdev_is_zoned(bio->bi_bdev)))
+ dm_zone_endio(io, bio);
+
if (static_branch_unlikely(&swap_bios_enabled) &&
unlikely(swap_bios_limit(ti, bio)))
up(&md->swap_bios_semaphore);
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH v10 12/13] dm: introduce DM_EMULATED_ZONES target type
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
` (10 preceding siblings ...)
2022-08-11 14:30 ` [PATCH v10 11/13] dm: call dm_zone_endio after the target endio callback for zoned devices Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 14:30 ` [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes Pankaj Raghav
12 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav
Introduce a new target type DM_EMULATED_ZONES for targets with
a different number of sectors per zone (aka zone size) than the underlying
device zone size.
This target type is introduced as the existing zoned targets assume
that the target and the underlying device have the same zone size.
The new target: dm-po2zone will use this new target
type as it emulates the zone boundary that is different from the
underlying zoned device.
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
---
drivers/md/dm-table.c | 13 ++++++++++---
include/linux/device-mapper.h | 9 +++++++++
2 files changed, 19 insertions(+), 3 deletions(-)
diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index 31eb1d29d136..b37991ea3ffb 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -1614,13 +1614,20 @@ static bool dm_table_supports_zoned_model(struct dm_table *t,
return true;
}
-static int device_not_matches_zone_sectors(struct dm_target *ti, struct dm_dev *dev,
+/*
+ * Callback function to check for device zone sector across devices. If the
+ * DM_TARGET_EMULATED_ZONES target feature flag is not set, then the target
+ * should have the same zone sector as the underlying devices.
+ */
+static int check_valid_device_zone_sectors(struct dm_target *ti, struct dm_dev *dev,
sector_t start, sector_t len, void *data)
{
unsigned int *zone_sectors = data;
- if (!bdev_is_zoned(dev->bdev))
+ if (!bdev_is_zoned(dev->bdev) ||
+ dm_target_supports_emulated_zones(ti->type))
return 0;
+
return bdev_zone_sectors(dev->bdev) != *zone_sectors;
}
@@ -1645,7 +1652,7 @@ static int validate_hardware_zoned_model(struct dm_table *t,
if (!zone_sectors)
return -EINVAL;
- if (dm_table_any_dev_attr(t, device_not_matches_zone_sectors, &zone_sectors)) {
+ if (dm_table_any_dev_attr(t, check_valid_device_zone_sectors, &zone_sectors)) {
DMERR("%s: zone sectors is not consistent across all zoned devices",
dm_device_name(t->md));
return -EINVAL;
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index 04c6acf7faaa..83e20de264c9 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -294,6 +294,15 @@ struct target_type {
#define dm_target_supports_mixed_zoned_model(type) (false)
#endif
+#ifdef CONFIG_BLK_DEV_ZONED
+#define DM_TARGET_EMULATED_ZONES 0x00000400
+#define dm_target_supports_emulated_zones(type) \
+ ((type)->features & DM_TARGET_EMULATED_ZONES)
+#else
+#define DM_TARGET_EMULATED_ZONES 0x00000000
+#define dm_target_supports_emulated_zones(type) (false)
+#endif
+
struct dm_target {
struct dm_table *table;
struct target_type *type;
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes
2022-08-11 14:30 ` [PATCH v10 00/13] support zoned block devices with non-power-of-2 zone sizes Pankaj Raghav
` (11 preceding siblings ...)
2022-08-11 14:30 ` [PATCH v10 12/13] dm: introduce DM_EMULATED_ZONES target type Pankaj Raghav
@ 2022-08-11 14:30 ` Pankaj Raghav
2022-08-11 16:15 ` Damien Le Moal
` (2 more replies)
12 siblings, 3 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-11 14:30 UTC (permalink / raw)
To: snitzer, axboe, hch, agk, damien.lemoal
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Pankaj Raghav, Johannes Thumshirn, Damien Le Moal,
Joel Granados
Only zoned devices with power-of-2(po2) number of sectors per zone(zone
size) were supported in linux but now non power-of-2(npo2) zone sizes
support has been added to the block layer.
Filesystems such as F2FS and btrfs have support for zoned devices with
po2 zone size assumption. Before adding native support for npo2 zone
sizes, it was suggested to create a dm target for npo2 zone size device to
appear as a po2 size zoned target so that file systems can initially work
without any explicit changes by using this target.
The design of this target is very simple: remap the device zone size to
the zone capacity and change the zone size to be the nearest power of 2
number of sectors.
For e.g., a device with a zone size/capacity of 3M will have an equivalent
target layout as follows:
Device layout :-
zone capacity = 3M
zone size = 3M
|--------------|-------------|
0 3M 6M
Target layout :-
zone capacity=3M
zone size = 4M
|--------------|---|--------------|---|
0 3M 4M 7M 8M
The area between target's zone capacity and zone size will be emulated
in the target.
The read IOs that fall in the emulated gap area will return 0 filled
bio and all the other IOs in that area will result in an error.
If a read IO span across the emulated area boundary, then the IOs are
split across them. All other IO operations that span across the emulated
area boundary will result in an error.
The target can be easily created as follows:
dmsetup create <label> --table '0 <size_sects> po2zone /dev/nvme<id>'
Note that the target does not support partial mapping of the underlying
device.
Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
Suggested-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
Suggested-by: Damien Le Moal <damien.lemoal@wdc.com>
Suggested-by: Hannes Reinecke <hare@suse.de>
Reviewed-by: Joel Granados <j.granados@samsung.com>
---
.../admin-guide/device-mapper/dm-po2zone.rst | 71 +++++
.../admin-guide/device-mapper/index.rst | 1 +
drivers/md/Kconfig | 10 +
drivers/md/Makefile | 2 +
drivers/md/dm-po2zone-target.c | 245 ++++++++++++++++++
5 files changed, 329 insertions(+)
create mode 100644 Documentation/admin-guide/device-mapper/dm-po2zone.rst
create mode 100644 drivers/md/dm-po2zone-target.c
diff --git a/Documentation/admin-guide/device-mapper/dm-po2zone.rst b/Documentation/admin-guide/device-mapper/dm-po2zone.rst
new file mode 100644
index 000000000000..19dc215fbcca
--- /dev/null
+++ b/Documentation/admin-guide/device-mapper/dm-po2zone.rst
@@ -0,0 +1,71 @@
+==========
+dm-po2zone
+==========
+The dm-po2zone device mapper target exposes a zoned block device with a
+non-power-of-2(npo2) number of sectors per zone as a power-of-2(po2)
+number of sectors per zone(zone size).
+The filesystems that support zoned block devices such as F2FS and BTRFS
+assume po2 zone size as the kernel has traditionally only supported
+those devices. However, as the kernel now supports zoned block devices with
+npo2 zone sizes, the filesystems can run on top of the dm-po2zone target before
+adding native support.
+
+Partial mapping of the underlying device is not supported by this target.
+
+Algorithm
+=========
+The device mapper target maps the underlying device's zone size to the
+zone capacity and changes the zone size to the nearest po2 zone size.
+The gap between the zone capacity and the zone size is emulated in the target.
+E.g., a zoned block device with a zone size (and capacity) of 3M will have an
+equivalent target layout with mapping as follows:
+
+::
+
+ 0M 3M 4M 6M 8M
+ | | | | |
+ +x------------+--+x---------+--+x------- Target
+ |x | |x | |x
+ x x x
+ x x x
+ x x x
+ x x x
+ |x |x |x
+ +x------------+x------------+x---------- Device
+ | | |
+ 0M 3M 6M
+
+A simple remap is performed for all the BIOs that do not cross the
+emulation gap area, i.e., the area between the zone capacity and size.
+
+If a BIO crosses the emulation gap area, the following operations are performed:
+
+ Read:
+ - If the BIO lies entirely in the emulation gap area, then zero out the BIO and complete it.
+ - If the BIO spans the emulation gap area, split the BIO across the zone capacity boundary
+ and remap only the BIO within the zone capacity boundary. The other part of the split BIO
+ will be zeroed out.
+
+ Other operations:
+ - Return an error
+
+Table parameters
+================
+
+::
+
+ <dev path>
+
+Mandatory parameters:
+
+ <dev path>:
+ Full pathname to the underlying block-device, or a
+ "major:minor" device-number.
+
+Examples
+========
+
+::
+
+ #!/bin/sh
+ echo "0 `blockdev --getsz $1` po2zone $1" | dmsetup create po2z
diff --git a/Documentation/admin-guide/device-mapper/index.rst b/Documentation/admin-guide/device-mapper/index.rst
index cde52cc09645..1fd04b5b0565 100644
--- a/Documentation/admin-guide/device-mapper/index.rst
+++ b/Documentation/admin-guide/device-mapper/index.rst
@@ -23,6 +23,7 @@ Device Mapper
dm-service-time
dm-uevent
dm-zoned
+ dm-po2zone
era
kcopyd
linear
diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
index 998a5cfdbc4e..638801b2449a 100644
--- a/drivers/md/Kconfig
+++ b/drivers/md/Kconfig
@@ -518,6 +518,16 @@ config DM_FLAKEY
help
A target that intermittently fails I/O for debugging purposes.
+config DM_PO2ZONE
+ tristate "Zoned block devices target emulating a power-of-2 number of sectors per zone"
+ depends on BLK_DEV_DM
+ depends on BLK_DEV_ZONED
+ help
+ A target that converts a zoned block device with non-power-of-2(npo2)
+ number of sectors per zone to be power-of-2(po2). Use this target for
+ zoned block devices with npo2 number of sectors per zone until native
+ support is added to the filesystems and applications.
+
config DM_VERITY
tristate "Verity target support"
depends on BLK_DEV_DM
diff --git a/drivers/md/Makefile b/drivers/md/Makefile
index 84291e38dca8..c23f81cc8789 100644
--- a/drivers/md/Makefile
+++ b/drivers/md/Makefile
@@ -26,6 +26,7 @@ dm-era-y += dm-era-target.o
dm-clone-y += dm-clone-target.o dm-clone-metadata.o
dm-verity-y += dm-verity-target.o
dm-zoned-y += dm-zoned-target.o dm-zoned-metadata.o dm-zoned-reclaim.o
+dm-po2zone-y += dm-po2zone-target.o
md-mod-y += md.o md-bitmap.o
raid456-y += raid5.o raid5-cache.o raid5-ppl.o
@@ -60,6 +61,7 @@ obj-$(CONFIG_DM_CRYPT) += dm-crypt.o
obj-$(CONFIG_DM_DELAY) += dm-delay.o
obj-$(CONFIG_DM_DUST) += dm-dust.o
obj-$(CONFIG_DM_FLAKEY) += dm-flakey.o
+obj-$(CONFIG_DM_PO2ZONE) += dm-po2zone.o
obj-$(CONFIG_DM_MULTIPATH) += dm-multipath.o dm-round-robin.o
obj-$(CONFIG_DM_MULTIPATH_QL) += dm-queue-length.o
obj-$(CONFIG_DM_MULTIPATH_ST) += dm-service-time.o
diff --git a/drivers/md/dm-po2zone-target.c b/drivers/md/dm-po2zone-target.c
new file mode 100644
index 000000000000..d7610463245d
--- /dev/null
+++ b/drivers/md/dm-po2zone-target.c
@@ -0,0 +1,245 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2022 Samsung Electronics Co., Ltd.
+ */
+
+#include <linux/device-mapper.h>
+
+#define DM_MSG_PREFIX "po2zone"
+
+struct dm_po2z_target {
+ struct dm_dev *dev;
+ sector_t zone_size; /* Actual zone size of the underlying dev*/
+ sector_t zone_size_po2; /* zone_size rounded to the nearest po2 value */
+ unsigned int zone_size_po2_shift;
+ sector_t zone_size_diff; /* diff between zone_size_po2 and zone_size */
+ unsigned int nr_zones;
+};
+
+static inline unsigned int npo2_zone_no(struct dm_po2z_target *dmh,
+ sector_t sect)
+{
+ return div64_u64(sect, dmh->zone_size);
+}
+
+static inline unsigned int po2_zone_no(struct dm_po2z_target *dmh,
+ sector_t sect)
+{
+ return sect >> dmh->zone_size_po2_shift;
+}
+
+static inline sector_t target_to_device_sect(struct dm_po2z_target *dmh,
+ sector_t sect)
+{
+ return sect - (po2_zone_no(dmh, sect) * dmh->zone_size_diff);
+}
+
+static inline sector_t device_to_target_sect(struct dm_po2z_target *dmh,
+ sector_t sect)
+{
+ return sect + (npo2_zone_no(dmh, sect) * dmh->zone_size_diff);
+}
+
+/*
+ * This target works on the complete zoned device. Partial mapping is not
+ * supported.
+ * Construct a zoned po2 logical device: <dev-path>
+ */
+static int dm_po2z_ctr(struct dm_target *ti, unsigned int argc, char **argv)
+{
+ struct dm_po2z_target *dmh = NULL;
+ int ret;
+ sector_t zone_size;
+ sector_t dev_capacity;
+
+ if (argc != 1)
+ return -EINVAL;
+
+ dmh = kmalloc(sizeof(*dmh), GFP_KERNEL);
+ if (!dmh)
+ return -ENOMEM;
+
+ ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),
+ &dmh->dev);
+ if (ret) {
+ ti->error = "Device lookup failed";
+ kfree(dmh);
+ return ret;
+ }
+
+ if (!bdev_is_zoned(dmh->dev->bdev)) {
+ DMERR("%pg is not a zoned device", dmh->dev->bdev);
+ kfree(dmh);
+ return -EINVAL;
+ }
+
+ zone_size = bdev_zone_sectors(dmh->dev->bdev);
+ dev_capacity = get_capacity(dmh->dev->bdev->bd_disk);
+ if (ti->len != dev_capacity || ti->begin) {
+ DMERR("%pg Partial mapping of the target not supported",
+ dmh->dev->bdev);
+ kfree(dmh);
+ return -EINVAL;
+ }
+
+ if (is_power_of_2(zone_size))
+ DMWARN("%pg: underlying device has a power-of-2 number of sectors per zone",
+ dmh->dev->bdev);
+
+ dmh->zone_size = zone_size;
+ dmh->zone_size_po2 = 1 << get_count_order_long(zone_size);
+ dmh->zone_size_po2_shift = ilog2(dmh->zone_size_po2);
+ dmh->zone_size_diff = dmh->zone_size_po2 - dmh->zone_size;
+ ti->private = dmh;
+ ti->max_io_len = dmh->zone_size_po2;
+ dmh->nr_zones = npo2_zone_no(dmh, ti->len);
+ ti->len = dmh->zone_size_po2 * dmh->nr_zones;
+
+ return 0;
+}
+
+static int dm_po2z_report_zones_cb(struct blk_zone *zone, unsigned int idx,
+ void *data)
+{
+ struct dm_report_zones_args *args = data;
+ struct dm_po2z_target *dmh = args->tgt->private;
+
+ zone->start = device_to_target_sect(dmh, zone->start);
+ zone->wp = device_to_target_sect(dmh, zone->wp);
+ zone->len = dmh->zone_size_po2;
+ args->next_sector = zone->start + zone->len;
+
+ return args->orig_cb(zone, args->zone_idx++, args->orig_data);
+}
+
+static int dm_po2z_report_zones(struct dm_target *ti,
+ struct dm_report_zones_args *args,
+ unsigned int nr_zones)
+{
+ struct dm_po2z_target *dmh = ti->private;
+ sector_t sect = po2_zone_no(dmh, args->next_sector) * dmh->zone_size;
+
+ return blkdev_report_zones(dmh->dev->bdev, sect, nr_zones,
+ dm_po2z_report_zones_cb, args);
+}
+
+static int dm_po2z_end_io(struct dm_target *ti, struct bio *bio,
+ blk_status_t *error)
+{
+ struct dm_po2z_target *dmh = ti->private;
+
+ if (bio->bi_status == BLK_STS_OK && bio_op(bio) == REQ_OP_ZONE_APPEND)
+ bio->bi_iter.bi_sector =
+ device_to_target_sect(dmh, bio->bi_iter.bi_sector);
+
+ return DM_ENDIO_DONE;
+}
+
+static void dm_po2z_io_hints(struct dm_target *ti, struct queue_limits *limits)
+{
+ struct dm_po2z_target *dmh = ti->private;
+
+ limits->chunk_sectors = dmh->zone_size_po2;
+}
+
+static bool bio_across_emulated_zone_area(struct dm_po2z_target *dmh,
+ struct bio *bio)
+{
+ unsigned int zone_idx = po2_zone_no(dmh, bio->bi_iter.bi_sector);
+ sector_t nr_sectors = bio->bi_iter.bi_size >> SECTOR_SHIFT;
+
+ return (bio->bi_iter.bi_sector + nr_sectors) >
+ (zone_idx << dmh->zone_size_po2_shift) + dmh->zone_size;
+}
+
+static int dm_po2z_map_read_emulated_area(struct dm_po2z_target *dmh,
+ struct bio *bio)
+{
+ sector_t start_sect = bio->bi_iter.bi_sector;
+ unsigned int zone_idx = po2_zone_no(dmh, start_sect);
+ sector_t relative_sect_in_zone = start_sect - (zone_idx << dmh->zone_size_po2_shift);
+ sector_t split_io_pos;
+
+ /*
+ * If the starting sector is in the emulated area then fill
+ * all the bio with zeros. If bio is across emulated zone boundary,
+ * split the bio across boundaries and fill zeros only for the
+ * bio that is between the zone capacity and the zone size.
+ */
+ if (relative_sect_in_zone < dmh->zone_size) {
+ split_io_pos = (zone_idx * dmh->zone_size_po2) + dmh->zone_size;
+ dm_accept_partial_bio(bio, split_io_pos - start_sect);
+ bio->bi_iter.bi_sector = target_to_device_sect(dmh, start_sect);
+
+ return DM_MAPIO_REMAPPED;
+ }
+
+ zero_fill_bio(bio);
+ bio_endio(bio);
+ return DM_MAPIO_SUBMITTED;
+}
+
+static int dm_po2z_map(struct dm_target *ti, struct bio *bio)
+{
+ struct dm_po2z_target *dmh = ti->private;
+
+ bio_set_dev(bio, dmh->dev->bdev);
+ if (bio_sectors(bio) || op_is_zone_mgmt(bio_op(bio))) {
+ if (!bio_across_emulated_zone_area(dmh, bio)) {
+ bio->bi_iter.bi_sector = target_to_device_sect(dmh,
+ bio->bi_iter.bi_sector);
+ return DM_MAPIO_REMAPPED;
+ }
+ /*
+ * Read operation on the emulated zone area (between zone capacity
+ * and zone size) will fill the bio with zeroes. Any other operation
+ * in the emulated area should return an error.
+ */
+ if (bio_op(bio) == REQ_OP_READ)
+ return dm_po2z_map_read_emulated_area(dmh, bio);
+
+ return DM_MAPIO_KILL;
+ }
+ return DM_MAPIO_REMAPPED;
+}
+
+static int dm_po2z_iterate_devices(struct dm_target *ti,
+ iterate_devices_callout_fn fn, void *data)
+{
+ struct dm_po2z_target *dmh = ti->private;
+ sector_t len = dmh->nr_zones * dmh->zone_size;
+
+ return fn(ti, dmh->dev, 0, len, data);
+}
+
+static struct target_type dm_po2z_target = {
+ .name = "po2zone",
+ .version = { 1, 0, 0 },
+ .features = DM_TARGET_ZONED_HM | DM_TARGET_EMULATED_ZONES,
+ .map = dm_po2z_map,
+ .end_io = dm_po2z_end_io,
+ .report_zones = dm_po2z_report_zones,
+ .iterate_devices = dm_po2z_iterate_devices,
+ .module = THIS_MODULE,
+ .io_hints = dm_po2z_io_hints,
+ .ctr = dm_po2z_ctr,
+};
+
+static int __init dm_po2z_init(void)
+{
+ return dm_register_target(&dm_po2z_target);
+}
+
+static void __exit dm_po2z_exit(void)
+{
+ dm_unregister_target(&dm_po2z_target);
+}
+
+/* Module hooks */
+module_init(dm_po2z_init);
+module_exit(dm_po2z_exit);
+
+MODULE_DESCRIPTION(DM_NAME "power-of-2 zoned target");
+MODULE_AUTHOR("Pankaj Raghav <p.raghav@samsung.com>");
+MODULE_LICENSE("GPL");
+
--
2.25.1
^ permalink raw reply related [flat|nested] 24+ messages in thread* Re: [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes
2022-08-11 14:30 ` [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes Pankaj Raghav
@ 2022-08-11 16:15 ` Damien Le Moal
2022-08-12 7:25 ` Pankaj Raghav
2022-08-12 12:03 ` Joel Granados
2022-08-12 15:57 ` Damien Le Moal
2 siblings, 1 reply; 24+ messages in thread
From: Damien Le Moal @ 2022-08-11 16:15 UTC (permalink / raw)
To: Pankaj Raghav, snitzer, axboe, hch, agk
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Damien Le Moal, Joel Granados
On 2022/08/11 7:30, Pankaj Raghav wrote:
> Only zoned devices with power-of-2(po2) number of sectors per zone(zone
> size) were supported in linux but now non power-of-2(npo2) zone sizes
> support has been added to the block layer.
>
> Filesystems such as F2FS and btrfs have support for zoned devices with
> po2 zone size assumption. Before adding native support for npo2 zone
> sizes, it was suggested to create a dm target for npo2 zone size device to
> appear as a po2 size zoned target so that file systems can initially work
> without any explicit changes by using this target.
>
> The design of this target is very simple: remap the device zone size to
> the zone capacity and change the zone size to be the nearest power of 2
> number of sectors.
>
> For e.g., a device with a zone size/capacity of 3M will have an equivalent
> target layout as follows:
>
> Device layout :-
> zone capacity = 3M
> zone size = 3M
>
> |--------------|-------------|
> 0 3M 6M
>
> Target layout :-
> zone capacity=3M
> zone size = 4M
>
> |--------------|---|--------------|---|
> 0 3M 4M 7M 8M
>
> The area between target's zone capacity and zone size will be emulated
> in the target.
> The read IOs that fall in the emulated gap area will return 0 filled
> bio and all the other IOs in that area will result in an error.
> If a read IO span across the emulated area boundary, then the IOs are
> split across them. All other IO operations that span across the emulated
> area boundary will result in an error.
>
> The target can be easily created as follows:
> dmsetup create <label> --table '0 <size_sects> po2zone /dev/nvme<id>'
>
> Note that the target does not support partial mapping of the underlying
> device.
>
> Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
> Suggested-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
> Suggested-by: Damien Le Moal <damien.lemoal@wdc.com>
> Suggested-by: Hannes Reinecke <hare@suse.de>
> Reviewed-by: Joel Granados <j.granados@samsung.com>
You changed this patch. So it needs review again. Please do not carry previous
review tags in that case.
> ---
> .../admin-guide/device-mapper/dm-po2zone.rst | 71 +++++
> .../admin-guide/device-mapper/index.rst | 1 +
> drivers/md/Kconfig | 10 +
> drivers/md/Makefile | 2 +
> drivers/md/dm-po2zone-target.c | 245 ++++++++++++++++++
> 5 files changed, 329 insertions(+)
> create mode 100644 Documentation/admin-guide/device-mapper/dm-po2zone.rst
> create mode 100644 drivers/md/dm-po2zone-target.c
>
> diff --git a/Documentation/admin-guide/device-mapper/dm-po2zone.rst b/Documentation/admin-guide/device-mapper/dm-po2zone.rst
> new file mode 100644
> index 000000000000..19dc215fbcca
> --- /dev/null
> +++ b/Documentation/admin-guide/device-mapper/dm-po2zone.rst
> @@ -0,0 +1,71 @@
> +==========
> +dm-po2zone
> +==========
> +The dm-po2zone device mapper target exposes a zoned block device with a
> +non-power-of-2(npo2) number of sectors per zone as a power-of-2(po2)
> +number of sectors per zone(zone size).
> +The filesystems that support zoned block devices such as F2FS and BTRFS
> +assume po2 zone size as the kernel has traditionally only supported
> +those devices. However, as the kernel now supports zoned block devices with
> +npo2 zone sizes, the filesystems can run on top of the dm-po2zone target before
> +adding native support.
> +
> +Partial mapping of the underlying device is not supported by this target.
> +
> +Algorithm
> +=========
> +The device mapper target maps the underlying device's zone size to the
> +zone capacity and changes the zone size to the nearest po2 zone size.
> +The gap between the zone capacity and the zone size is emulated in the target.
> +E.g., a zoned block device with a zone size (and capacity) of 3M will have an
> +equivalent target layout with mapping as follows:
> +
> +::
> +
> + 0M 3M 4M 6M 8M
> + | | | | |
> + +x------------+--+x---------+--+x------- Target
> + |x | |x | |x
> + x x x
> + x x x
> + x x x
> + x x x
> + |x |x |x
> + +x------------+x------------+x---------- Device
> + | | |
> + 0M 3M 6M
> +
> +A simple remap is performed for all the BIOs that do not cross the
> +emulation gap area, i.e., the area between the zone capacity and size.
> +
> +If a BIO crosses the emulation gap area, the following operations are performed:
> +
> + Read:
> + - If the BIO lies entirely in the emulation gap area, then zero out the BIO and complete it.
> + - If the BIO spans the emulation gap area, split the BIO across the zone capacity boundary
> + and remap only the BIO within the zone capacity boundary. The other part of the split BIO
> + will be zeroed out.
> +
> + Other operations:
> + - Return an error
> +
> +Table parameters
> +================
> +
> +::
> +
> + <dev path>
> +
> +Mandatory parameters:
> +
> + <dev path>:
> + Full pathname to the underlying block-device, or a
> + "major:minor" device-number.
> +
> +Examples
> +========
> +
> +::
> +
> + #!/bin/sh
> + echo "0 `blockdev --getsz $1` po2zone $1" | dmsetup create po2z
> diff --git a/Documentation/admin-guide/device-mapper/index.rst b/Documentation/admin-guide/device-mapper/index.rst
> index cde52cc09645..1fd04b5b0565 100644
> --- a/Documentation/admin-guide/device-mapper/index.rst
> +++ b/Documentation/admin-guide/device-mapper/index.rst
> @@ -23,6 +23,7 @@ Device Mapper
> dm-service-time
> dm-uevent
> dm-zoned
> + dm-po2zone
> era
> kcopyd
> linear
> diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
> index 998a5cfdbc4e..638801b2449a 100644
> --- a/drivers/md/Kconfig
> +++ b/drivers/md/Kconfig
> @@ -518,6 +518,16 @@ config DM_FLAKEY
> help
> A target that intermittently fails I/O for debugging purposes.
>
> +config DM_PO2ZONE
> + tristate "Zoned block devices target emulating a power-of-2 number of sectors per zone"
> + depends on BLK_DEV_DM
> + depends on BLK_DEV_ZONED
> + help
> + A target that converts a zoned block device with non-power-of-2(npo2)
> + number of sectors per zone to be power-of-2(po2). Use this target for
> + zoned block devices with npo2 number of sectors per zone until native
> + support is added to the filesystems and applications.
> +
> config DM_VERITY
> tristate "Verity target support"
> depends on BLK_DEV_DM
> diff --git a/drivers/md/Makefile b/drivers/md/Makefile
> index 84291e38dca8..c23f81cc8789 100644
> --- a/drivers/md/Makefile
> +++ b/drivers/md/Makefile
> @@ -26,6 +26,7 @@ dm-era-y += dm-era-target.o
> dm-clone-y += dm-clone-target.o dm-clone-metadata.o
> dm-verity-y += dm-verity-target.o
> dm-zoned-y += dm-zoned-target.o dm-zoned-metadata.o dm-zoned-reclaim.o
> +dm-po2zone-y += dm-po2zone-target.o
>
> md-mod-y += md.o md-bitmap.o
> raid456-y += raid5.o raid5-cache.o raid5-ppl.o
> @@ -60,6 +61,7 @@ obj-$(CONFIG_DM_CRYPT) += dm-crypt.o
> obj-$(CONFIG_DM_DELAY) += dm-delay.o
> obj-$(CONFIG_DM_DUST) += dm-dust.o
> obj-$(CONFIG_DM_FLAKEY) += dm-flakey.o
> +obj-$(CONFIG_DM_PO2ZONE) += dm-po2zone.o
> obj-$(CONFIG_DM_MULTIPATH) += dm-multipath.o dm-round-robin.o
> obj-$(CONFIG_DM_MULTIPATH_QL) += dm-queue-length.o
> obj-$(CONFIG_DM_MULTIPATH_ST) += dm-service-time.o
> diff --git a/drivers/md/dm-po2zone-target.c b/drivers/md/dm-po2zone-target.c
> new file mode 100644
> index 000000000000..d7610463245d
> --- /dev/null
> +++ b/drivers/md/dm-po2zone-target.c
> @@ -0,0 +1,245 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (C) 2022 Samsung Electronics Co., Ltd.
> + */
> +
> +#include <linux/device-mapper.h>
> +
> +#define DM_MSG_PREFIX "po2zone"
> +
> +struct dm_po2z_target {
> + struct dm_dev *dev;
> + sector_t zone_size; /* Actual zone size of the underlying dev*/
> + sector_t zone_size_po2; /* zone_size rounded to the nearest po2 value */
> + unsigned int zone_size_po2_shift;
> + sector_t zone_size_diff; /* diff between zone_size_po2 and zone_size */
> + unsigned int nr_zones;
> +};
> +
> +static inline unsigned int npo2_zone_no(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return div64_u64(sect, dmh->zone_size);
> +}
> +
> +static inline unsigned int po2_zone_no(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return sect >> dmh->zone_size_po2_shift;
> +}
> +
> +static inline sector_t target_to_device_sect(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return sect - (po2_zone_no(dmh, sect) * dmh->zone_size_diff);
> +}
> +
> +static inline sector_t device_to_target_sect(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return sect + (npo2_zone_no(dmh, sect) * dmh->zone_size_diff);
> +}
> +
> +/*
> + * This target works on the complete zoned device. Partial mapping is not
> + * supported.
> + * Construct a zoned po2 logical device: <dev-path>
> + */
> +static int dm_po2z_ctr(struct dm_target *ti, unsigned int argc, char **argv)
> +{
> + struct dm_po2z_target *dmh = NULL;
> + int ret;
> + sector_t zone_size;
> + sector_t dev_capacity;
> +
> + if (argc != 1)
> + return -EINVAL;
> +
> + dmh = kmalloc(sizeof(*dmh), GFP_KERNEL);
> + if (!dmh)
> + return -ENOMEM;
> +
> + ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),
> + &dmh->dev);
> + if (ret) {
> + ti->error = "Device lookup failed";
> + kfree(dmh);
> + return ret;
> + }
> +
> + if (!bdev_is_zoned(dmh->dev->bdev)) {
> + DMERR("%pg is not a zoned device", dmh->dev->bdev);
> + kfree(dmh);
> + return -EINVAL;
> + }
> +
> + zone_size = bdev_zone_sectors(dmh->dev->bdev);
> + dev_capacity = get_capacity(dmh->dev->bdev->bd_disk);
> + if (ti->len != dev_capacity || ti->begin) {
> + DMERR("%pg Partial mapping of the target not supported",
> + dmh->dev->bdev);
> + kfree(dmh);
> + return -EINVAL;
> + }
> +
> + if (is_power_of_2(zone_size))
> + DMWARN("%pg: underlying device has a power-of-2 number of sectors per zone",
> + dmh->dev->bdev);
> +
> + dmh->zone_size = zone_size;
> + dmh->zone_size_po2 = 1 << get_count_order_long(zone_size);
> + dmh->zone_size_po2_shift = ilog2(dmh->zone_size_po2);
> + dmh->zone_size_diff = dmh->zone_size_po2 - dmh->zone_size;
> + ti->private = dmh;
> + ti->max_io_len = dmh->zone_size_po2;
> + dmh->nr_zones = npo2_zone_no(dmh, ti->len);
> + ti->len = dmh->zone_size_po2 * dmh->nr_zones;
> +
> + return 0;
> +}
> +
> +static int dm_po2z_report_zones_cb(struct blk_zone *zone, unsigned int idx,
> + void *data)
> +{
> + struct dm_report_zones_args *args = data;
> + struct dm_po2z_target *dmh = args->tgt->private;
> +
> + zone->start = device_to_target_sect(dmh, zone->start);
> + zone->wp = device_to_target_sect(dmh, zone->wp);
> + zone->len = dmh->zone_size_po2;
> + args->next_sector = zone->start + zone->len;
> +
> + return args->orig_cb(zone, args->zone_idx++, args->orig_data);
> +}
> +
> +static int dm_po2z_report_zones(struct dm_target *ti,
> + struct dm_report_zones_args *args,
> + unsigned int nr_zones)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> + sector_t sect = po2_zone_no(dmh, args->next_sector) * dmh->zone_size;
> +
> + return blkdev_report_zones(dmh->dev->bdev, sect, nr_zones,
> + dm_po2z_report_zones_cb, args);
> +}
> +
> +static int dm_po2z_end_io(struct dm_target *ti, struct bio *bio,
> + blk_status_t *error)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> +
> + if (bio->bi_status == BLK_STS_OK && bio_op(bio) == REQ_OP_ZONE_APPEND)
> + bio->bi_iter.bi_sector =
> + device_to_target_sect(dmh, bio->bi_iter.bi_sector);
> +
> + return DM_ENDIO_DONE;
> +}
> +
> +static void dm_po2z_io_hints(struct dm_target *ti, struct queue_limits *limits)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> +
> + limits->chunk_sectors = dmh->zone_size_po2;
> +}
> +
> +static bool bio_across_emulated_zone_area(struct dm_po2z_target *dmh,
> + struct bio *bio)
> +{
> + unsigned int zone_idx = po2_zone_no(dmh, bio->bi_iter.bi_sector);
> + sector_t nr_sectors = bio->bi_iter.bi_size >> SECTOR_SHIFT;
> +
> + return (bio->bi_iter.bi_sector + nr_sectors) >
> + (zone_idx << dmh->zone_size_po2_shift) + dmh->zone_size;
> +}
> +
> +static int dm_po2z_map_read_emulated_area(struct dm_po2z_target *dmh,
> + struct bio *bio)
> +{
> + sector_t start_sect = bio->bi_iter.bi_sector;
> + unsigned int zone_idx = po2_zone_no(dmh, start_sect);
> + sector_t relative_sect_in_zone = start_sect - (zone_idx << dmh->zone_size_po2_shift);
> + sector_t split_io_pos;
> +
> + /*
> + * If the starting sector is in the emulated area then fill
> + * all the bio with zeros. If bio is across emulated zone boundary,
> + * split the bio across boundaries and fill zeros only for the
> + * bio that is between the zone capacity and the zone size.
> + */
> + if (relative_sect_in_zone < dmh->zone_size) {
> + split_io_pos = (zone_idx * dmh->zone_size_po2) + dmh->zone_size;
> + dm_accept_partial_bio(bio, split_io_pos - start_sect);
> + bio->bi_iter.bi_sector = target_to_device_sect(dmh, start_sect);
> +
> + return DM_MAPIO_REMAPPED;
> + }
> +
> + zero_fill_bio(bio);
> + bio_endio(bio);
> + return DM_MAPIO_SUBMITTED;
> +}
> +
> +static int dm_po2z_map(struct dm_target *ti, struct bio *bio)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> +
> + bio_set_dev(bio, dmh->dev->bdev);
> + if (bio_sectors(bio) || op_is_zone_mgmt(bio_op(bio))) {
> + if (!bio_across_emulated_zone_area(dmh, bio)) {
> + bio->bi_iter.bi_sector = target_to_device_sect(dmh,
> + bio->bi_iter.bi_sector);
> + return DM_MAPIO_REMAPPED;
> + }
> + /*
> + * Read operation on the emulated zone area (between zone capacity
> + * and zone size) will fill the bio with zeroes. Any other operation
> + * in the emulated area should return an error.
> + */
> + if (bio_op(bio) == REQ_OP_READ)
> + return dm_po2z_map_read_emulated_area(dmh, bio);
> +
> + return DM_MAPIO_KILL;
> + }
> + return DM_MAPIO_REMAPPED;
> +}
> +
> +static int dm_po2z_iterate_devices(struct dm_target *ti,
> + iterate_devices_callout_fn fn, void *data)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> + sector_t len = dmh->nr_zones * dmh->zone_size;
> +
> + return fn(ti, dmh->dev, 0, len, data);
> +}
> +
> +static struct target_type dm_po2z_target = {
> + .name = "po2zone",
> + .version = { 1, 0, 0 },
> + .features = DM_TARGET_ZONED_HM | DM_TARGET_EMULATED_ZONES,
> + .map = dm_po2z_map,
> + .end_io = dm_po2z_end_io,
> + .report_zones = dm_po2z_report_zones,
> + .iterate_devices = dm_po2z_iterate_devices,
> + .module = THIS_MODULE,
> + .io_hints = dm_po2z_io_hints,
> + .ctr = dm_po2z_ctr,
> +};
> +
> +static int __init dm_po2z_init(void)
> +{
> + return dm_register_target(&dm_po2z_target);
> +}
> +
> +static void __exit dm_po2z_exit(void)
> +{
> + dm_unregister_target(&dm_po2z_target);
> +}
> +
> +/* Module hooks */
> +module_init(dm_po2z_init);
> +module_exit(dm_po2z_exit);
> +
> +MODULE_DESCRIPTION(DM_NAME "power-of-2 zoned target");
> +MODULE_AUTHOR("Pankaj Raghav <p.raghav@samsung.com>");
> +MODULE_LICENSE("GPL");
> +
--
Damien Le Moal
Western Digital Research
^ permalink raw reply [flat|nested] 24+ messages in thread* Re: [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes
2022-08-11 16:15 ` Damien Le Moal
@ 2022-08-12 7:25 ` Pankaj Raghav
0 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-12 7:25 UTC (permalink / raw)
To: Damien Le Moal, snitzer, axboe, hch, agk
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Damien Le Moal, Joel Granados
Hi Damien,
>> |--------------|---|--------------|---|
>> 0 3M 4M 7M 8M
>>
>> The area between target's zone capacity and zone size will be emulated
>> in the target.
>> The read IOs that fall in the emulated gap area will return 0 filled
>> bio and all the other IOs in that area will result in an error.
>> If a read IO span across the emulated area boundary, then the IOs are
>> split across them. All other IO operations that span across the emulated
>> area boundary will result in an error.
>>
>> The target can be easily created as follows:
>> dmsetup create <label> --table '0 <size_sects> po2zone /dev/nvme<id>'
>>
>> Note that the target does not support partial mapping of the underlying
>> device.
>>
>> Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
>> Suggested-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
>> Suggested-by: Damien Le Moal <damien.lemoal@wdc.com>
>> Suggested-by: Hannes Reinecke <hare@suse.de>
>> Reviewed-by: Joel Granados <j.granados@samsung.com>
>
> You changed this patch. So it needs review again. Please do not carry previous
> review tags in that case.
> The changes were non-functional such as changing multiplication to
shifts and rephrasing error messages.
While I agree with your comment not to carry forward review tags if the
patch has changed, I thought it might be too much to ask a reviewer to
re-review for non-functional changes such as these. But I will request
Joel to do a quick re-review.
Thanks.
^ permalink raw reply [flat|nested] 24+ messages in thread
* Re: [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes
2022-08-11 14:30 ` [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes Pankaj Raghav
2022-08-11 16:15 ` Damien Le Moal
@ 2022-08-12 12:03 ` Joel Granados
2022-08-12 15:57 ` Damien Le Moal
2 siblings, 0 replies; 24+ messages in thread
From: Joel Granados @ 2022-08-12 12:03 UTC (permalink / raw)
To: Pankaj Raghav
Cc: snitzer, axboe, hch, agk, damien.lemoal, linux-block,
Johannes.Thumshirn, bvanassche, matias.bjorling, hare, gost.dev,
linux-nvme, jaegeuk, pankydev8, linux-kernel, dm-devel,
Damien Le Moal
[-- Attachment #1: Type: text/plain, Size: 15969 bytes --]
On Thu, Aug 11, 2022 at 04:30:43PM +0200, Pankaj Raghav wrote:
> Only zoned devices with power-of-2(po2) number of sectors per zone(zone
> size) were supported in linux but now non power-of-2(npo2) zone sizes
> support has been added to the block layer.
LGTM. I believe the commit message to be more clear like this. I also
looked at the other changes and it seems that they have addressed the
previous comments
Reviewed-by: Joel Granados <j.granados@samsung.com>
>
> Filesystems such as F2FS and btrfs have support for zoned devices with
> po2 zone size assumption. Before adding native support for npo2 zone
> sizes, it was suggested to create a dm target for npo2 zone size device to
> appear as a po2 size zoned target so that file systems can initially work
> without any explicit changes by using this target.
>
> The design of this target is very simple: remap the device zone size to
> the zone capacity and change the zone size to be the nearest power of 2
> number of sectors.
>
> For e.g., a device with a zone size/capacity of 3M will have an equivalent
> target layout as follows:
>
> Device layout :-
> zone capacity = 3M
> zone size = 3M
>
> |--------------|-------------|
> 0 3M 6M
>
> Target layout :-
> zone capacity=3M
> zone size = 4M
>
> |--------------|---|--------------|---|
> 0 3M 4M 7M 8M
>
> The area between target's zone capacity and zone size will be emulated
> in the target.
> The read IOs that fall in the emulated gap area will return 0 filled
> bio and all the other IOs in that area will result in an error.
> If a read IO span across the emulated area boundary, then the IOs are
> split across them. All other IO operations that span across the emulated
> area boundary will result in an error.
>
> The target can be easily created as follows:
> dmsetup create <label> --table '0 <size_sects> po2zone /dev/nvme<id>'
>
> Note that the target does not support partial mapping of the underlying
> device.
>
> Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
> Suggested-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
> Suggested-by: Damien Le Moal <damien.lemoal@wdc.com>
> Suggested-by: Hannes Reinecke <hare@suse.de>
> Reviewed-by: Joel Granados <j.granados@samsung.com>
> ---
> .../admin-guide/device-mapper/dm-po2zone.rst | 71 +++++
> .../admin-guide/device-mapper/index.rst | 1 +
> drivers/md/Kconfig | 10 +
> drivers/md/Makefile | 2 +
> drivers/md/dm-po2zone-target.c | 245 ++++++++++++++++++
> 5 files changed, 329 insertions(+)
> create mode 100644 Documentation/admin-guide/device-mapper/dm-po2zone.rst
> create mode 100644 drivers/md/dm-po2zone-target.c
>
> diff --git a/Documentation/admin-guide/device-mapper/dm-po2zone.rst b/Documentation/admin-guide/device-mapper/dm-po2zone.rst
> new file mode 100644
> index 000000000000..19dc215fbcca
> --- /dev/null
> +++ b/Documentation/admin-guide/device-mapper/dm-po2zone.rst
> @@ -0,0 +1,71 @@
> +==========
> +dm-po2zone
> +==========
> +The dm-po2zone device mapper target exposes a zoned block device with a
> +non-power-of-2(npo2) number of sectors per zone as a power-of-2(po2)
> +number of sectors per zone(zone size).
> +The filesystems that support zoned block devices such as F2FS and BTRFS
> +assume po2 zone size as the kernel has traditionally only supported
> +those devices. However, as the kernel now supports zoned block devices with
> +npo2 zone sizes, the filesystems can run on top of the dm-po2zone target before
> +adding native support.
> +
> +Partial mapping of the underlying device is not supported by this target.
> +
> +Algorithm
> +=========
> +The device mapper target maps the underlying device's zone size to the
> +zone capacity and changes the zone size to the nearest po2 zone size.
> +The gap between the zone capacity and the zone size is emulated in the target.
> +E.g., a zoned block device with a zone size (and capacity) of 3M will have an
> +equivalent target layout with mapping as follows:
> +
> +::
> +
> + 0M 3M 4M 6M 8M
> + | | | | |
> + +x------------+--+x---------+--+x------- Target
> + |x | |x | |x
> + x x x
> + x x x
> + x x x
> + x x x
> + |x |x |x
> + +x------------+x------------+x---------- Device
> + | | |
> + 0M 3M 6M
> +
> +A simple remap is performed for all the BIOs that do not cross the
> +emulation gap area, i.e., the area between the zone capacity and size.
> +
> +If a BIO crosses the emulation gap area, the following operations are performed:
> +
> + Read:
> + - If the BIO lies entirely in the emulation gap area, then zero out the BIO and complete it.
> + - If the BIO spans the emulation gap area, split the BIO across the zone capacity boundary
> + and remap only the BIO within the zone capacity boundary. The other part of the split BIO
> + will be zeroed out.
> +
> + Other operations:
> + - Return an error
> +
> +Table parameters
> +================
> +
> +::
> +
> + <dev path>
> +
> +Mandatory parameters:
> +
> + <dev path>:
> + Full pathname to the underlying block-device, or a
> + "major:minor" device-number.
> +
> +Examples
> +========
> +
> +::
> +
> + #!/bin/sh
> + echo "0 `blockdev --getsz $1` po2zone $1" | dmsetup create po2z
> diff --git a/Documentation/admin-guide/device-mapper/index.rst b/Documentation/admin-guide/device-mapper/index.rst
> index cde52cc09645..1fd04b5b0565 100644
> --- a/Documentation/admin-guide/device-mapper/index.rst
> +++ b/Documentation/admin-guide/device-mapper/index.rst
> @@ -23,6 +23,7 @@ Device Mapper
> dm-service-time
> dm-uevent
> dm-zoned
> + dm-po2zone
> era
> kcopyd
> linear
> diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
> index 998a5cfdbc4e..638801b2449a 100644
> --- a/drivers/md/Kconfig
> +++ b/drivers/md/Kconfig
> @@ -518,6 +518,16 @@ config DM_FLAKEY
> help
> A target that intermittently fails I/O for debugging purposes.
>
> +config DM_PO2ZONE
> + tristate "Zoned block devices target emulating a power-of-2 number of sectors per zone"
> + depends on BLK_DEV_DM
> + depends on BLK_DEV_ZONED
> + help
> + A target that converts a zoned block device with non-power-of-2(npo2)
> + number of sectors per zone to be power-of-2(po2). Use this target for
> + zoned block devices with npo2 number of sectors per zone until native
> + support is added to the filesystems and applications.
> +
> config DM_VERITY
> tristate "Verity target support"
> depends on BLK_DEV_DM
> diff --git a/drivers/md/Makefile b/drivers/md/Makefile
> index 84291e38dca8..c23f81cc8789 100644
> --- a/drivers/md/Makefile
> +++ b/drivers/md/Makefile
> @@ -26,6 +26,7 @@ dm-era-y += dm-era-target.o
> dm-clone-y += dm-clone-target.o dm-clone-metadata.o
> dm-verity-y += dm-verity-target.o
> dm-zoned-y += dm-zoned-target.o dm-zoned-metadata.o dm-zoned-reclaim.o
> +dm-po2zone-y += dm-po2zone-target.o
>
> md-mod-y += md.o md-bitmap.o
> raid456-y += raid5.o raid5-cache.o raid5-ppl.o
> @@ -60,6 +61,7 @@ obj-$(CONFIG_DM_CRYPT) += dm-crypt.o
> obj-$(CONFIG_DM_DELAY) += dm-delay.o
> obj-$(CONFIG_DM_DUST) += dm-dust.o
> obj-$(CONFIG_DM_FLAKEY) += dm-flakey.o
> +obj-$(CONFIG_DM_PO2ZONE) += dm-po2zone.o
> obj-$(CONFIG_DM_MULTIPATH) += dm-multipath.o dm-round-robin.o
> obj-$(CONFIG_DM_MULTIPATH_QL) += dm-queue-length.o
> obj-$(CONFIG_DM_MULTIPATH_ST) += dm-service-time.o
> diff --git a/drivers/md/dm-po2zone-target.c b/drivers/md/dm-po2zone-target.c
> new file mode 100644
> index 000000000000..d7610463245d
> --- /dev/null
> +++ b/drivers/md/dm-po2zone-target.c
> @@ -0,0 +1,245 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (C) 2022 Samsung Electronics Co., Ltd.
> + */
> +
> +#include <linux/device-mapper.h>
> +
> +#define DM_MSG_PREFIX "po2zone"
> +
> +struct dm_po2z_target {
> + struct dm_dev *dev;
> + sector_t zone_size; /* Actual zone size of the underlying dev*/
> + sector_t zone_size_po2; /* zone_size rounded to the nearest po2 value */
> + unsigned int zone_size_po2_shift;
> + sector_t zone_size_diff; /* diff between zone_size_po2 and zone_size */
> + unsigned int nr_zones;
> +};
> +
> +static inline unsigned int npo2_zone_no(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return div64_u64(sect, dmh->zone_size);
> +}
> +
> +static inline unsigned int po2_zone_no(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return sect >> dmh->zone_size_po2_shift;
> +}
> +
> +static inline sector_t target_to_device_sect(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return sect - (po2_zone_no(dmh, sect) * dmh->zone_size_diff);
> +}
> +
> +static inline sector_t device_to_target_sect(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return sect + (npo2_zone_no(dmh, sect) * dmh->zone_size_diff);
> +}
> +
> +/*
> + * This target works on the complete zoned device. Partial mapping is not
> + * supported.
> + * Construct a zoned po2 logical device: <dev-path>
> + */
> +static int dm_po2z_ctr(struct dm_target *ti, unsigned int argc, char **argv)
> +{
> + struct dm_po2z_target *dmh = NULL;
> + int ret;
> + sector_t zone_size;
> + sector_t dev_capacity;
> +
> + if (argc != 1)
> + return -EINVAL;
> +
> + dmh = kmalloc(sizeof(*dmh), GFP_KERNEL);
> + if (!dmh)
> + return -ENOMEM;
> +
> + ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),
> + &dmh->dev);
> + if (ret) {
> + ti->error = "Device lookup failed";
> + kfree(dmh);
> + return ret;
> + }
> +
> + if (!bdev_is_zoned(dmh->dev->bdev)) {
> + DMERR("%pg is not a zoned device", dmh->dev->bdev);
> + kfree(dmh);
> + return -EINVAL;
> + }
> +
> + zone_size = bdev_zone_sectors(dmh->dev->bdev);
> + dev_capacity = get_capacity(dmh->dev->bdev->bd_disk);
> + if (ti->len != dev_capacity || ti->begin) {
> + DMERR("%pg Partial mapping of the target not supported",
> + dmh->dev->bdev);
> + kfree(dmh);
> + return -EINVAL;
> + }
> +
> + if (is_power_of_2(zone_size))
> + DMWARN("%pg: underlying device has a power-of-2 number of sectors per zone",
> + dmh->dev->bdev);
> +
> + dmh->zone_size = zone_size;
> + dmh->zone_size_po2 = 1 << get_count_order_long(zone_size);
> + dmh->zone_size_po2_shift = ilog2(dmh->zone_size_po2);
> + dmh->zone_size_diff = dmh->zone_size_po2 - dmh->zone_size;
> + ti->private = dmh;
> + ti->max_io_len = dmh->zone_size_po2;
> + dmh->nr_zones = npo2_zone_no(dmh, ti->len);
> + ti->len = dmh->zone_size_po2 * dmh->nr_zones;
> +
> + return 0;
> +}
> +
> +static int dm_po2z_report_zones_cb(struct blk_zone *zone, unsigned int idx,
> + void *data)
> +{
> + struct dm_report_zones_args *args = data;
> + struct dm_po2z_target *dmh = args->tgt->private;
> +
> + zone->start = device_to_target_sect(dmh, zone->start);
> + zone->wp = device_to_target_sect(dmh, zone->wp);
> + zone->len = dmh->zone_size_po2;
> + args->next_sector = zone->start + zone->len;
> +
> + return args->orig_cb(zone, args->zone_idx++, args->orig_data);
> +}
> +
> +static int dm_po2z_report_zones(struct dm_target *ti,
> + struct dm_report_zones_args *args,
> + unsigned int nr_zones)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> + sector_t sect = po2_zone_no(dmh, args->next_sector) * dmh->zone_size;
> +
> + return blkdev_report_zones(dmh->dev->bdev, sect, nr_zones,
> + dm_po2z_report_zones_cb, args);
> +}
> +
> +static int dm_po2z_end_io(struct dm_target *ti, struct bio *bio,
> + blk_status_t *error)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> +
> + if (bio->bi_status == BLK_STS_OK && bio_op(bio) == REQ_OP_ZONE_APPEND)
> + bio->bi_iter.bi_sector =
> + device_to_target_sect(dmh, bio->bi_iter.bi_sector);
> +
> + return DM_ENDIO_DONE;
> +}
> +
> +static void dm_po2z_io_hints(struct dm_target *ti, struct queue_limits *limits)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> +
> + limits->chunk_sectors = dmh->zone_size_po2;
> +}
> +
> +static bool bio_across_emulated_zone_area(struct dm_po2z_target *dmh,
> + struct bio *bio)
> +{
> + unsigned int zone_idx = po2_zone_no(dmh, bio->bi_iter.bi_sector);
> + sector_t nr_sectors = bio->bi_iter.bi_size >> SECTOR_SHIFT;
> +
> + return (bio->bi_iter.bi_sector + nr_sectors) >
> + (zone_idx << dmh->zone_size_po2_shift) + dmh->zone_size;
> +}
> +
> +static int dm_po2z_map_read_emulated_area(struct dm_po2z_target *dmh,
> + struct bio *bio)
> +{
> + sector_t start_sect = bio->bi_iter.bi_sector;
> + unsigned int zone_idx = po2_zone_no(dmh, start_sect);
> + sector_t relative_sect_in_zone = start_sect - (zone_idx << dmh->zone_size_po2_shift);
> + sector_t split_io_pos;
> +
> + /*
> + * If the starting sector is in the emulated area then fill
> + * all the bio with zeros. If bio is across emulated zone boundary,
> + * split the bio across boundaries and fill zeros only for the
> + * bio that is between the zone capacity and the zone size.
> + */
> + if (relative_sect_in_zone < dmh->zone_size) {
> + split_io_pos = (zone_idx * dmh->zone_size_po2) + dmh->zone_size;
> + dm_accept_partial_bio(bio, split_io_pos - start_sect);
> + bio->bi_iter.bi_sector = target_to_device_sect(dmh, start_sect);
> +
> + return DM_MAPIO_REMAPPED;
> + }
> +
> + zero_fill_bio(bio);
> + bio_endio(bio);
> + return DM_MAPIO_SUBMITTED;
> +}
> +
> +static int dm_po2z_map(struct dm_target *ti, struct bio *bio)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> +
> + bio_set_dev(bio, dmh->dev->bdev);
> + if (bio_sectors(bio) || op_is_zone_mgmt(bio_op(bio))) {
> + if (!bio_across_emulated_zone_area(dmh, bio)) {
> + bio->bi_iter.bi_sector = target_to_device_sect(dmh,
> + bio->bi_iter.bi_sector);
> + return DM_MAPIO_REMAPPED;
> + }
> + /*
> + * Read operation on the emulated zone area (between zone capacity
> + * and zone size) will fill the bio with zeroes. Any other operation
> + * in the emulated area should return an error.
> + */
> + if (bio_op(bio) == REQ_OP_READ)
> + return dm_po2z_map_read_emulated_area(dmh, bio);
> +
> + return DM_MAPIO_KILL;
> + }
> + return DM_MAPIO_REMAPPED;
> +}
> +
> +static int dm_po2z_iterate_devices(struct dm_target *ti,
> + iterate_devices_callout_fn fn, void *data)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> + sector_t len = dmh->nr_zones * dmh->zone_size;
> +
> + return fn(ti, dmh->dev, 0, len, data);
> +}
> +
> +static struct target_type dm_po2z_target = {
> + .name = "po2zone",
> + .version = { 1, 0, 0 },
> + .features = DM_TARGET_ZONED_HM | DM_TARGET_EMULATED_ZONES,
> + .map = dm_po2z_map,
> + .end_io = dm_po2z_end_io,
> + .report_zones = dm_po2z_report_zones,
> + .iterate_devices = dm_po2z_iterate_devices,
> + .module = THIS_MODULE,
> + .io_hints = dm_po2z_io_hints,
> + .ctr = dm_po2z_ctr,
> +};
> +
> +static int __init dm_po2z_init(void)
> +{
> + return dm_register_target(&dm_po2z_target);
> +}
> +
> +static void __exit dm_po2z_exit(void)
> +{
> + dm_unregister_target(&dm_po2z_target);
> +}
> +
> +/* Module hooks */
> +module_init(dm_po2z_init);
> +module_exit(dm_po2z_exit);
> +
> +MODULE_DESCRIPTION(DM_NAME "power-of-2 zoned target");
> +MODULE_AUTHOR("Pankaj Raghav <p.raghav@samsung.com>");
> +MODULE_LICENSE("GPL");
> +
> --
> 2.25.1
>
[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 659 bytes --]
^ permalink raw reply [flat|nested] 24+ messages in thread* Re: [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes
2022-08-11 14:30 ` [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes Pankaj Raghav
2022-08-11 16:15 ` Damien Le Moal
2022-08-12 12:03 ` Joel Granados
@ 2022-08-12 15:57 ` Damien Le Moal
2022-08-15 13:38 ` Pankaj Raghav
2 siblings, 1 reply; 24+ messages in thread
From: Damien Le Moal @ 2022-08-12 15:57 UTC (permalink / raw)
To: Pankaj Raghav, snitzer, axboe, hch, agk
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Damien Le Moal, Joel Granados
On 2022/08/11 7:30, Pankaj Raghav wrote:
> Only zoned devices with power-of-2(po2) number of sectors per zone(zone
> size) were supported in linux but now non power-of-2(npo2) zone sizes
> support has been added to the block layer.
>
> Filesystems such as F2FS and btrfs have support for zoned devices with
> po2 zone size assumption. Before adding native support for npo2 zone
> sizes, it was suggested to create a dm target for npo2 zone size device to
> appear as a po2 size zoned target so that file systems can initially work
> without any explicit changes by using this target.
>
> The design of this target is very simple: remap the device zone size to
> the zone capacity and change the zone size to be the nearest power of 2
> number of sectors.
>
> For e.g., a device with a zone size/capacity of 3M will have an equivalent
> target layout as follows:
>
> Device layout :-
> zone capacity = 3M
> zone size = 3M
>
> |--------------|-------------|
> 0 3M 6M
>
> Target layout :-
> zone capacity=3M
> zone size = 4M
>
> |--------------|---|--------------|---|
> 0 3M 4M 7M 8M
>
> The area between target's zone capacity and zone size will be emulated
> in the target.
> The read IOs that fall in the emulated gap area will return 0 filled
> bio and all the other IOs in that area will result in an error.
> If a read IO span across the emulated area boundary, then the IOs are
> split across them. All other IO operations that span across the emulated
> area boundary will result in an error.
>
> The target can be easily created as follows:
> dmsetup create <label> --table '0 <size_sects> po2zone /dev/nvme<id>'
>
> Note that the target does not support partial mapping of the underlying
> device.
>
> Signed-off-by: Pankaj Raghav <p.raghav@samsung.com>
> Suggested-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
> Suggested-by: Damien Le Moal <damien.lemoal@wdc.com>
> Suggested-by: Hannes Reinecke <hare@suse.de>
> Reviewed-by: Joel Granados <j.granados@samsung.com>
> ---
> .../admin-guide/device-mapper/dm-po2zone.rst | 71 +++++
> .../admin-guide/device-mapper/index.rst | 1 +
> drivers/md/Kconfig | 10 +
> drivers/md/Makefile | 2 +
> drivers/md/dm-po2zone-target.c | 245 ++++++++++++++++++
> 5 files changed, 329 insertions(+)
> create mode 100644 Documentation/admin-guide/device-mapper/dm-po2zone.rst
> create mode 100644 drivers/md/dm-po2zone-target.c
>
> diff --git a/Documentation/admin-guide/device-mapper/dm-po2zone.rst b/Documentation/admin-guide/device-mapper/dm-po2zone.rst
> new file mode 100644
> index 000000000000..19dc215fbcca
> --- /dev/null
> +++ b/Documentation/admin-guide/device-mapper/dm-po2zone.rst
> @@ -0,0 +1,71 @@
> +==========
> +dm-po2zone
> +==========
> +The dm-po2zone device mapper target exposes a zoned block device with a
> +non-power-of-2(npo2) number of sectors per zone as a power-of-2(po2)
> +number of sectors per zone(zone size).
> +The filesystems that support zoned block devices such as F2FS and BTRFS
> +assume po2 zone size as the kernel has traditionally only supported
> +those devices. However, as the kernel now supports zoned block devices with
> +npo2 zone sizes, the filesystems can run on top of the dm-po2zone target before
> +adding native support.
> +
> +Partial mapping of the underlying device is not supported by this target.
> +
> +Algorithm
> +=========
> +The device mapper target maps the underlying device's zone size to the
> +zone capacity and changes the zone size to the nearest po2 zone size.
> +The gap between the zone capacity and the zone size is emulated in the target.
> +E.g., a zoned block device with a zone size (and capacity) of 3M will have an
> +equivalent target layout with mapping as follows:
> +
> +::
> +
> + 0M 3M 4M 6M 8M
> + | | | | |
> + +x------------+--+x---------+--+x------- Target
> + |x | |x | |x
> + x x x
> + x x x
> + x x x
> + x x x
> + |x |x |x
> + +x------------+x------------+x---------- Device
> + | | |
> + 0M 3M 6M
> +
> +A simple remap is performed for all the BIOs that do not cross the
> +emulation gap area, i.e., the area between the zone capacity and size.
> +
> +If a BIO crosses the emulation gap area, the following operations are performed:
> +
> + Read:
> + - If the BIO lies entirely in the emulation gap area, then zero out the BIO and complete it.
> + - If the BIO spans the emulation gap area, split the BIO across the zone capacity boundary
> + and remap only the BIO within the zone capacity boundary. The other part of the split BIO
> + will be zeroed out.
> +
> + Other operations:
> + - Return an error
> +
> +Table parameters
> +================
> +
> +::
> +
> + <dev path>
> +
> +Mandatory parameters:
> +
> + <dev path>:
> + Full pathname to the underlying block-device, or a
> + "major:minor" device-number.
> +
> +Examples
> +========
> +
> +::
> +
> + #!/bin/sh
> + echo "0 `blockdev --getsz $1` po2zone $1" | dmsetup create po2z
> diff --git a/Documentation/admin-guide/device-mapper/index.rst b/Documentation/admin-guide/device-mapper/index.rst
> index cde52cc09645..1fd04b5b0565 100644
> --- a/Documentation/admin-guide/device-mapper/index.rst
> +++ b/Documentation/admin-guide/device-mapper/index.rst
> @@ -23,6 +23,7 @@ Device Mapper
> dm-service-time
> dm-uevent
> dm-zoned
> + dm-po2zone
> era
> kcopyd
> linear
> diff --git a/drivers/md/Kconfig b/drivers/md/Kconfig
> index 998a5cfdbc4e..638801b2449a 100644
> --- a/drivers/md/Kconfig
> +++ b/drivers/md/Kconfig
> @@ -518,6 +518,16 @@ config DM_FLAKEY
> help
> A target that intermittently fails I/O for debugging purposes.
>
> +config DM_PO2ZONE
> + tristate "Zoned block devices target emulating a power-of-2 number of sectors per zone"
> + depends on BLK_DEV_DM
> + depends on BLK_DEV_ZONED
> + help
> + A target that converts a zoned block device with non-power-of-2(npo2)
> + number of sectors per zone to be power-of-2(po2). Use this target for
> + zoned block devices with npo2 number of sectors per zone until native
> + support is added to the filesystems and applications.
> +
> config DM_VERITY
> tristate "Verity target support"
> depends on BLK_DEV_DM
> diff --git a/drivers/md/Makefile b/drivers/md/Makefile
> index 84291e38dca8..c23f81cc8789 100644
> --- a/drivers/md/Makefile
> +++ b/drivers/md/Makefile
> @@ -26,6 +26,7 @@ dm-era-y += dm-era-target.o
> dm-clone-y += dm-clone-target.o dm-clone-metadata.o
> dm-verity-y += dm-verity-target.o
> dm-zoned-y += dm-zoned-target.o dm-zoned-metadata.o dm-zoned-reclaim.o
> +dm-po2zone-y += dm-po2zone-target.o
>
> md-mod-y += md.o md-bitmap.o
> raid456-y += raid5.o raid5-cache.o raid5-ppl.o
> @@ -60,6 +61,7 @@ obj-$(CONFIG_DM_CRYPT) += dm-crypt.o
> obj-$(CONFIG_DM_DELAY) += dm-delay.o
> obj-$(CONFIG_DM_DUST) += dm-dust.o
> obj-$(CONFIG_DM_FLAKEY) += dm-flakey.o
> +obj-$(CONFIG_DM_PO2ZONE) += dm-po2zone.o
> obj-$(CONFIG_DM_MULTIPATH) += dm-multipath.o dm-round-robin.o
> obj-$(CONFIG_DM_MULTIPATH_QL) += dm-queue-length.o
> obj-$(CONFIG_DM_MULTIPATH_ST) += dm-service-time.o
> diff --git a/drivers/md/dm-po2zone-target.c b/drivers/md/dm-po2zone-target.c
> new file mode 100644
> index 000000000000..d7610463245d
> --- /dev/null
> +++ b/drivers/md/dm-po2zone-target.c
> @@ -0,0 +1,245 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (C) 2022 Samsung Electronics Co., Ltd.
> + */
> +
> +#include <linux/device-mapper.h>
> +
> +#define DM_MSG_PREFIX "po2zone"
> +
> +struct dm_po2z_target {
> + struct dm_dev *dev;
> + sector_t zone_size; /* Actual zone size of the underlying dev*/
> + sector_t zone_size_po2; /* zone_size rounded to the nearest po2 value */
> + unsigned int zone_size_po2_shift;
> + sector_t zone_size_diff; /* diff between zone_size_po2 and zone_size */
> + unsigned int nr_zones;
> +};
> +
> +static inline unsigned int npo2_zone_no(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return div64_u64(sect, dmh->zone_size);
> +}
> +
> +static inline unsigned int po2_zone_no(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return sect >> dmh->zone_size_po2_shift;
> +}
> +
> +static inline sector_t target_to_device_sect(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return sect - (po2_zone_no(dmh, sect) * dmh->zone_size_diff);
> +}
> +
> +static inline sector_t device_to_target_sect(struct dm_po2z_target *dmh,
> + sector_t sect)
> +{
> + return sect + (npo2_zone_no(dmh, sect) * dmh->zone_size_diff);
> +}
> +
> +/*
> + * This target works on the complete zoned device. Partial mapping is not
> + * supported.
> + * Construct a zoned po2 logical device: <dev-path>
> + */
> +static int dm_po2z_ctr(struct dm_target *ti, unsigned int argc, char **argv)
> +{
> + struct dm_po2z_target *dmh = NULL;
> + int ret;
> + sector_t zone_size;
> + sector_t dev_capacity;
> +
> + if (argc != 1)
> + return -EINVAL;
> +
> + dmh = kmalloc(sizeof(*dmh), GFP_KERNEL);
> + if (!dmh)
> + return -ENOMEM;
> +
> + ret = dm_get_device(ti, argv[0], dm_table_get_mode(ti->table),
> + &dmh->dev);
> + if (ret) {
> + ti->error = "Device lookup failed";
> + kfree(dmh);
> + return ret;
> + }
> +
> + if (!bdev_is_zoned(dmh->dev->bdev)) {
> + DMERR("%pg is not a zoned device", dmh->dev->bdev);
> + kfree(dmh);
> + return -EINVAL;
> + }
> +
> + zone_size = bdev_zone_sectors(dmh->dev->bdev);
> + dev_capacity = get_capacity(dmh->dev->bdev->bd_disk);
> + if (ti->len != dev_capacity || ti->begin) {
> + DMERR("%pg Partial mapping of the target not supported",
> + dmh->dev->bdev);
> + kfree(dmh);
> + return -EINVAL;
> + }
> +
> + if (is_power_of_2(zone_size))
> + DMWARN("%pg: underlying device has a power-of-2 number of sectors per zone",
> + dmh->dev->bdev);
> +
> + dmh->zone_size = zone_size;
> + dmh->zone_size_po2 = 1 << get_count_order_long(zone_size);
> + dmh->zone_size_po2_shift = ilog2(dmh->zone_size_po2);
> + dmh->zone_size_diff = dmh->zone_size_po2 - dmh->zone_size;
> + ti->private = dmh;
> + ti->max_io_len = dmh->zone_size_po2;
> + dmh->nr_zones = npo2_zone_no(dmh, ti->len);
> + ti->len = dmh->zone_size_po2 * dmh->nr_zones;
> +
> + return 0;
> +}
> +
> +static int dm_po2z_report_zones_cb(struct blk_zone *zone, unsigned int idx,
> + void *data)
> +{
> + struct dm_report_zones_args *args = data;
> + struct dm_po2z_target *dmh = args->tgt->private;
> +
> + zone->start = device_to_target_sect(dmh, zone->start);
> + zone->wp = device_to_target_sect(dmh, zone->wp);
> + zone->len = dmh->zone_size_po2;
> + args->next_sector = zone->start + zone->len;
> +
> + return args->orig_cb(zone, args->zone_idx++, args->orig_data);
> +}
> +
> +static int dm_po2z_report_zones(struct dm_target *ti,
> + struct dm_report_zones_args *args,
> + unsigned int nr_zones)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> + sector_t sect = po2_zone_no(dmh, args->next_sector) * dmh->zone_size;
> +
> + return blkdev_report_zones(dmh->dev->bdev, sect, nr_zones,
> + dm_po2z_report_zones_cb, args);
> +}
> +
> +static int dm_po2z_end_io(struct dm_target *ti, struct bio *bio,
> + blk_status_t *error)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> +
> + if (bio->bi_status == BLK_STS_OK && bio_op(bio) == REQ_OP_ZONE_APPEND)
> + bio->bi_iter.bi_sector =
> + device_to_target_sect(dmh, bio->bi_iter.bi_sector);
> +
> + return DM_ENDIO_DONE;
> +}
> +
> +static void dm_po2z_io_hints(struct dm_target *ti, struct queue_limits *limits)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> +
> + limits->chunk_sectors = dmh->zone_size_po2;
> +}
> +
> +static bool bio_across_emulated_zone_area(struct dm_po2z_target *dmh,
> + struct bio *bio)
> +{
> + unsigned int zone_idx = po2_zone_no(dmh, bio->bi_iter.bi_sector);
> + sector_t nr_sectors = bio->bi_iter.bi_size >> SECTOR_SHIFT;
> +
> + return (bio->bi_iter.bi_sector + nr_sectors) >
> + (zone_idx << dmh->zone_size_po2_shift) + dmh->zone_size;
> +}
> +
> +static int dm_po2z_map_read_emulated_area(struct dm_po2z_target *dmh,
> + struct bio *bio)
This really should be called dm_po2z_handle_read() since it handles both cases
of read commands, with and without the accept partial. Note that this is
retesting the need for a split after that was already tested in dm_po2z_map()
with bio_across_emulated_zone_area(). So the code should be better organized to
avoid that repetition.
You can simplify the code by having bio_across_emulated_zone_area() return 0 for
a bio that does not cross the zone capacity and return the number of sectors up
to the zone capacity from the bio start if there is a cross. That value can then
be used to call dm_accept_partial_bio() directly in dm_po2z_map() for read
commands. That will make this function much simpler and essentially turn it into
dm_po2z_read_zeroes().
> +{
> + sector_t start_sect = bio->bi_iter.bi_sector;
> + unsigned int zone_idx = po2_zone_no(dmh, start_sect);
> + sector_t relative_sect_in_zone = start_sect - (zone_idx << dmh->zone_size_po2_shift);
Long line. Please split it after the "=".
> + sector_t split_io_pos;
> +
> + /*
> + * If the starting sector is in the emulated area then fill
> + * all the bio with zeros. If bio is across emulated zone boundary,
> + * split the bio across boundaries and fill zeros only for the
> + * bio that is between the zone capacity and the zone size.
> + */
> + if (relative_sect_in_zone < dmh->zone_size) {
> + split_io_pos = (zone_idx * dmh->zone_size_po2) + dmh->zone_size;
Use bit shift here please.
> + dm_accept_partial_bio(bio, split_io_pos - start_sect);
> + bio->bi_iter.bi_sector = target_to_device_sect(dmh, start_sect);
> +
> + return DM_MAPIO_REMAPPED;
> + }
> +
> + zero_fill_bio(bio);
> + bio_endio(bio);
> + return DM_MAPIO_SUBMITTED;
> +}
> +
> +static int dm_po2z_map(struct dm_target *ti, struct bio *bio)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> +
> + bio_set_dev(bio, dmh->dev->bdev);
> + if (bio_sectors(bio) || op_is_zone_mgmt(bio_op(bio))) {
> + if (!bio_across_emulated_zone_area(dmh, bio)) {
> + bio->bi_iter.bi_sector = target_to_device_sect(dmh,
> + bio->bi_iter.bi_sector);
Long line. Split it after "=".
> + return DM_MAPIO_REMAPPED;
> + }
> + /*
> + * Read operation on the emulated zone area (between zone capacity
> + * and zone size) will fill the bio with zeroes. Any other operation
> + * in the emulated area should return an error.
> + */
> + if (bio_op(bio) == REQ_OP_READ)
> + return dm_po2z_map_read_emulated_area(dmh, bio);
> +
> + return DM_MAPIO_KILL;
> + }
> + return DM_MAPIO_REMAPPED;
> +}
> +
> +static int dm_po2z_iterate_devices(struct dm_target *ti,
> + iterate_devices_callout_fn fn, void *data)
> +{
> + struct dm_po2z_target *dmh = ti->private;
> + sector_t len = dmh->nr_zones * dmh->zone_size;
> +
> + return fn(ti, dmh->dev, 0, len, data);
> +}
> +
> +static struct target_type dm_po2z_target = {
> + .name = "po2zone",
> + .version = { 1, 0, 0 },
> + .features = DM_TARGET_ZONED_HM | DM_TARGET_EMULATED_ZONES,
> + .map = dm_po2z_map,
> + .end_io = dm_po2z_end_io,
> + .report_zones = dm_po2z_report_zones,
> + .iterate_devices = dm_po2z_iterate_devices,
> + .module = THIS_MODULE,
> + .io_hints = dm_po2z_io_hints,
> + .ctr = dm_po2z_ctr,
> +};
> +
> +static int __init dm_po2z_init(void)
> +{
> + return dm_register_target(&dm_po2z_target);
> +}
> +
> +static void __exit dm_po2z_exit(void)
> +{
> + dm_unregister_target(&dm_po2z_target);
> +}
> +
> +/* Module hooks */
> +module_init(dm_po2z_init);
> +module_exit(dm_po2z_exit);
> +
> +MODULE_DESCRIPTION(DM_NAME "power-of-2 zoned target");
> +MODULE_AUTHOR("Pankaj Raghav <p.raghav@samsung.com>");
> +MODULE_LICENSE("GPL");
> +
--
Damien Le Moal
Western Digital Research
^ permalink raw reply [flat|nested] 24+ messages in thread* Re: [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes
2022-08-12 15:57 ` Damien Le Moal
@ 2022-08-15 13:38 ` Pankaj Raghav
2022-08-15 18:56 ` Damien Le Moal
0 siblings, 1 reply; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-15 13:38 UTC (permalink / raw)
To: Damien Le Moal, snitzer, axboe, hch, agk
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Damien Le Moal, Joel Granados
Hi Damien,
>> +static int dm_po2z_map_read_emulated_area(struct dm_po2z_target *dmh,
>> + struct bio *bio)
>
> This really should be called dm_po2z_handle_read() since it handles both cases
> of read commands, with and without the accept partial. Note that this is
> retesting the need for a split after that was already tested in dm_po2z_map()
> with bio_across_emulated_zone_area(). So the code should be better organized to
> avoid that repetition.
>
> You can simplify the code by having bio_across_emulated_zone_area() return 0 for
> a bio that does not cross the zone capacity and return the number of sectors up
> to the zone capacity from the bio start if there is a cross. That value can then
The offset will also be zero if the BIO starts at the zone capacity and
dm_po2z_map will assume that the bio did not cross the emulated zone boundary.
> be used to call dm_accept_partial_bio() directly in dm_po2z_map() for read
> commands. That will make this function much simpler and essentially turn it into
> dm_po2z_read_zeroes().
>
>> +{
What about something like this? We have one function:
bio_in_emulated_zone_area() that checks if a BIO is partly or completely in the
emulated zone area and also returns the offset from bio to the emulated zone
boundary (zone capacity of the device).
/**
* bio_in_emulated_zone_area - check if bio is in the emulated zone area
* @dmh: pozone target data
* @bio: bio
* @offset: bio offset to emulated zone boundary
*
* Check if a @bio is partly or completely in the emulated zone area. If the
* @bio is partly in the emulated zone area, @offset
* can be used to split the @bio across the emulated zone boundary. @offset
* will be negative if the @bio completely lies in the emulated area.
* */
static bool bio_in_emulated_zone_area(struct dm_po2z_target *dmh,
struct bio *bio, int *offset)
{
unsigned int zone_idx = po2_zone_no(dmh, bio->bi_iter.bi_sector);
sector_t nr_sectors = bio->bi_iter.bi_size >> SECTOR_SHIFT;
sector_t relative_sect_in_zone =
bio->bi_iter.bi_sector - (zone_idx << dmh->zone_size_po2_shift);
*offset = dmh->zone_size - relative_sect_in_zone;
return (relative_sect_in_zone + nr_sectors) > dmh->zone_size;
}
static int dm_po2z_read_zeroes(struct bio *bio)
{
zero_fill_bio(bio);
bio_endio(bio);
return DM_MAPIO_SUBMITTED;
}
static int dm_po2z_remap_sector(struct dm_po2z_target *dmh, struct bio *bio)
{
bio->bi_iter.bi_sector =
target_to_device_sect(dmh, bio->bi_iter.bi_sector);
return DM_MAPIO_REMAPPED;
}
static int dm_po2z_map(struct dm_target *ti, struct bio *bio)
{
struct dm_po2z_target *dmh = ti->private;
bio_set_dev(bio, dmh->dev->bdev);
if (bio_sectors(bio) || op_is_zone_mgmt(bio_op(bio))) {
int split_io_pos;
if (!bio_in_emulated_zone_area(dmh, bio, &split_io_pos)) {
return dm_po2z_remap_sector(dmh, bio);
}
/*
* Read operation on the emulated zone area (between zone capacity
* and zone size) will fill the bio with zeroes. Any other operation
* in the emulated area should return an error.
*/
if (bio_op(bio) == REQ_OP_READ) {
if (split_io_pos > 0) {
dm_accept_partial_bio(bio, split_io_pos);
return dm_po2z_remap_sector(dmh, bio);
}
return dm_po2z_read_zeroes(bio);
}
return DM_MAPIO_KILL;
}
return DM_MAPIO_REMAPPED;
}
Let me know what you think.
^ permalink raw reply [flat|nested] 24+ messages in thread* Re: [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes
2022-08-15 13:38 ` Pankaj Raghav
@ 2022-08-15 18:56 ` Damien Le Moal
2022-08-16 8:02 ` Pankaj Raghav
0 siblings, 1 reply; 24+ messages in thread
From: Damien Le Moal @ 2022-08-15 18:56 UTC (permalink / raw)
To: Pankaj Raghav, snitzer, axboe, hch, agk
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Damien Le Moal, Joel Granados
On 2022/08/15 6:38, Pankaj Raghav wrote:
> Hi Damien,
>
>>> +static int dm_po2z_map_read_emulated_area(struct dm_po2z_target *dmh,
>>> + struct bio *bio)
>>
>> This really should be called dm_po2z_handle_read() since it handles both cases
>> of read commands, with and without the accept partial. Note that this is
>> retesting the need for a split after that was already tested in dm_po2z_map()
>> with bio_across_emulated_zone_area(). So the code should be better organized to
>> avoid that repetition.
>>
>> You can simplify the code by having bio_across_emulated_zone_area() return 0 for
>> a bio that does not cross the zone capacity and return the number of sectors up
>> to the zone capacity from the bio start if there is a cross. That value can then
> The offset will also be zero if the BIO starts at the zone capacity and
> dm_po2z_map will assume that the bio did not cross the emulated zone boundary.
>
>> be used to call dm_accept_partial_bio() directly in dm_po2z_map() for read
>> commands. That will make this function much simpler and essentially turn it into
>> dm_po2z_read_zeroes().
>>
>>> +{
>
> What about something like this? We have one function:
> bio_in_emulated_zone_area() that checks if a BIO is partly or completely in the
> emulated zone area and also returns the offset from bio to the emulated zone
> boundary (zone capacity of the device).
>
> /**
> * bio_in_emulated_zone_area - check if bio is in the emulated zone area
> * @dmh: pozone target data
> * @bio: bio
> * @offset: bio offset to emulated zone boundary
> *
> * Check if a @bio is partly or completely in the emulated zone area. If the
> * @bio is partly in the emulated zone area, @offset
> * can be used to split the @bio across the emulated zone boundary. @offset
> * will be negative if the @bio completely lies in the emulated area.
> * */
> static bool bio_in_emulated_zone_area(struct dm_po2z_target *dmh,
> struct bio *bio, int *offset)
> {
> unsigned int zone_idx = po2_zone_no(dmh, bio->bi_iter.bi_sector);
> sector_t nr_sectors = bio->bi_iter.bi_size >> SECTOR_SHIFT;
> sector_t relative_sect_in_zone =
Nit: Could simply call this sector_offset.
> bio->bi_iter.bi_sector - (zone_idx << dmh->zone_size_po2_shift);
>
> *offset = dmh->zone_size - relative_sect_in_zone;
>
> return (relative_sect_in_zone + nr_sectors) > dmh->zone_size;
No need for the parenthesis.
> }
>
> static int dm_po2z_read_zeroes(struct bio *bio)
Make that an inline.
> {
> zero_fill_bio(bio);
> bio_endio(bio);
> return DM_MAPIO_SUBMITTED;
> }
>
> static int dm_po2z_remap_sector(struct dm_po2z_target *dmh, struct bio *bio)
Inline this one too.
> {
> bio->bi_iter.bi_sector =
> target_to_device_sect(dmh, bio->bi_iter.bi_sector);
> return DM_MAPIO_REMAPPED;
> }
>
> static int dm_po2z_map(struct dm_target *ti, struct bio *bio)
> {
> struct dm_po2z_target *dmh = ti->private;
>
> bio_set_dev(bio, dmh->dev->bdev);
> if (bio_sectors(bio) || op_is_zone_mgmt(bio_op(bio))) {
> int split_io_pos;
Blank line needed here.
> if (!bio_in_emulated_zone_area(dmh, bio, &split_io_pos)) {
> return dm_po2z_remap_sector(dmh, bio);
> }
No need for the curly brackets.
> /*
> * Read operation on the emulated zone area (between zone capacity
> * and zone size) will fill the bio with zeroes. Any other operation
> * in the emulated area should return an error.
> */
> if (bio_op(bio) == REQ_OP_READ) {
> if (split_io_pos > 0) {
> dm_accept_partial_bio(bio, split_io_pos);
> return dm_po2z_remap_sector(dmh, bio);
> }
> return dm_po2z_read_zeroes(bio);
> }
> return DM_MAPIO_KILL;
> }
> return DM_MAPIO_REMAPPED;
> }
>
> Let me know what you think.
I think this is way better. But I would still reorganize this like this:
static int dm_po2z_map(struct dm_target *ti, struct bio *bio)
{
struct dm_po2z_target *dmh = ti->private;
int split_io_pos;
bio_set_dev(bio, dmh->dev->bdev);
if (op_is_zone_mgmt(bio_op(bio)))
return dm_po2z_remap_sector(dmh, bio);
if (!bio_sectors(bio))
return DM_MAPIO_REMAPPED;
/*
* Read operation on the emulated zone area (between zone capacity
* and zone size) will fill the bio with zeroes. Any other operation
* in the emulated area should return an error.
*/
if (!bio_in_emulated_zone_area(dmh, bio, &split_io_pos))
return dm_po2z_remap_sector(dmh, bio);
if (bio_op(bio) == REQ_OP_READ) {
if (split_io_pos > 0) {
dm_accept_partial_bio(bio, split_io_pos);
return dm_po2z_remap_sector(dmh, bio);
}
return dm_po2z_read_zeroes(bio);
}
return DM_MAPIO_KILL;
}
I find the code easier to follow this way.
--
Damien Le Moal
Western Digital Research
^ permalink raw reply [flat|nested] 24+ messages in thread* Re: [PATCH v10 13/13] dm: add power-of-2 target for zoned devices with non power-of-2 zone sizes
2022-08-15 18:56 ` Damien Le Moal
@ 2022-08-16 8:02 ` Pankaj Raghav
0 siblings, 0 replies; 24+ messages in thread
From: Pankaj Raghav @ 2022-08-16 8:02 UTC (permalink / raw)
To: Damien Le Moal, snitzer, axboe, hch, agk
Cc: linux-block, Johannes.Thumshirn, bvanassche, matias.bjorling,
hare, gost.dev, linux-nvme, jaegeuk, pankydev8, linux-kernel,
dm-devel, Damien Le Moal, Joel Granados
>
> I think this is way better. But I would still reorganize this like this:
>
> static int dm_po2z_map(struct dm_target *ti, struct bio *bio)
> {
> struct dm_po2z_target *dmh = ti->private;
> int split_io_pos;
>
> bio_set_dev(bio, dmh->dev->bdev);
>
> if (op_is_zone_mgmt(bio_op(bio)))
> return dm_po2z_remap_sector(dmh, bio);
>
> if (!bio_sectors(bio))
> return DM_MAPIO_REMAPPED;
>
> /*
> * Read operation on the emulated zone area (between zone capacity
> * and zone size) will fill the bio with zeroes. Any other operation
> * in the emulated area should return an error.
> */
> if (!bio_in_emulated_zone_area(dmh, bio, &split_io_pos))
> return dm_po2z_remap_sector(dmh, bio);
>
> if (bio_op(bio) == REQ_OP_READ) {
> if (split_io_pos > 0) {
> dm_accept_partial_bio(bio, split_io_pos);
> return dm_po2z_remap_sector(dmh, bio);
> }
> return dm_po2z_read_zeroes(bio);
> }
>
> return DM_MAPIO_KILL;
> }
>
> I find the code easier to follow this way.
>
I agree. It is definitely easier to follow. I will make these changes
and send the next version soon.
>
>
^ permalink raw reply [flat|nested] 24+ messages in thread