Since Linux doesn't have a user API to issue zone append operations to
zoned devices from user space, the file-posix driver is modified to add
zone append emulation using regular writes. To do this, the file-posix
driver tracks the wp location of all zones of the device. It uses an
array of uint64_t. The most significant bit of each wp location indicates
if the zone type is conventional zones.
The zones wp can be changed due to the following operations issued:
- zone reset: change the wp to the start offset of that zone
- zone finish: change to the end location of that zone
- write to a zone
- zone append
Signed-off-by: Sam Li <faithilikerun@gmail.com>
---
block/file-posix.c | 173 ++++++++++++++++++++++++++++++-
include/block/block-common.h | 14 +++
include/block/block_int-common.h | 5 +
3 files changed, 189 insertions(+), 3 deletions(-)
diff --git a/block/file-posix.c b/block/file-posix.c
index 65efe5147e..e7957f5559 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -1324,6 +1324,90 @@ static int hdev_get_max_segments(int fd, struct stat *st)
#endif
}
+#if defined(CONFIG_BLKZONED)
+/*
+ * If the reset_all flag is true, then the wps of zone whose state is
+ * not readonly or offline should be all reset to the start sector.
+ * Else, take the real wp of the device.
+ */
+static int get_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
+ unsigned int nrz, bool reset_all)
+{
+ struct blk_zone *blkz;
+ size_t rep_size;
+ uint64_t sector = offset >> BDRV_SECTOR_BITS;
+ BlockZoneWps *wps = bs->wps;
+ int j = offset / bs->bl.zone_size;
+ int ret, n = 0, i = 0;
+ rep_size = sizeof(struct blk_zone_report) + nrz * sizeof(struct blk_zone);
+ g_autofree struct blk_zone_report *rep = NULL;
+
+ rep = g_malloc(rep_size);
+ blkz = (struct blk_zone *)(rep + 1);
+ while (n < nrz) {
+ memset(rep, 0, rep_size);
+ rep->sector = sector;
+ rep->nr_zones = nrz - n;
+
+ do {
+ ret = ioctl(fd, BLKREPORTZONE, rep);
+ } while (ret != 0 && errno == EINTR);
+ if (ret != 0) {
+ error_report("%d: ioctl BLKREPORTZONE at %" PRId64 " failed %d",
+ fd, offset, errno);
+ return -errno;
+ }
+
+ if (!rep->nr_zones) {
+ break;
+ }
+
+ for (i = 0; i < rep->nr_zones; ++i, ++n, ++j) {
+ /*
+ * The wp tracking cares only about sequential writes required and
+ * sequential write preferred zones so that the wp can advance to
+ * the right location.
+ * Use the most significant bit of the wp location to indicate the
+ * zone type: 0 for SWR/SWP zones and 1 for conventional zones.
+ */
+ if (blkz[i].type == BLK_ZONE_TYPE_CONVENTIONAL) {
+ wps->wp[j] |= 1ULL << 63;
+ } else {
+ switch(blkz[i].cond) {
+ case BLK_ZONE_COND_FULL:
+ case BLK_ZONE_COND_READONLY:
+ /* Zone not writable */
+ wps->wp[j] = (blkz[i].start + blkz[i].len) << BDRV_SECTOR_BITS;
+ break;
+ case BLK_ZONE_COND_OFFLINE:
+ /* Zone not writable nor readable */
+ wps->wp[j] = (blkz[i].start) << BDRV_SECTOR_BITS;
+ break;
+ default:
+ if (reset_all) {
+ wps->wp[j] = blkz[i].start << BDRV_SECTOR_BITS;
+ } else {
+ wps->wp[j] = blkz[i].wp << BDRV_SECTOR_BITS;
+ }
+ break;
+ }
+ }
+ }
+ sector = blkz[i - 1].start + blkz[i - 1].len;
+ }
+
+ return 0;
+}
+
+static void update_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
+ unsigned int nrz)
+{
+ if (get_zones_wp(bs, fd, offset, nrz, 0) < 0) {
+ error_report("update zone wp failed");
+ }
+}
+#endif
+
static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
{
BDRVRawState *s = bs->opaque;
@@ -1413,6 +1497,23 @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
if (ret >= 0) {
bs->bl.max_active_zones = ret;
}
+
+ ret = get_sysfs_long_val(&st, "physical_block_size");
+ if (ret >= 0) {
+ bs->bl.write_granularity = ret;
+ }
+
+ /* The refresh_limits() function can be called multiple times. */
+ g_free(bs->wps);
+ bs->wps = g_malloc(sizeof(BlockZoneWps) +
+ sizeof(int64_t) * bs->bl.nr_zones);
+ ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 0);
+ if (ret < 0) {
+ error_setg_errno(errp, -ret, "report wps failed");
+ bs->wps = NULL;
+ return;
+ }
+ qemu_co_mutex_init(&bs->wps->colock);
return;
}
out:
@@ -2338,9 +2439,15 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
{
BDRVRawState *s = bs->opaque;
RawPosixAIOData acb;
+ int ret;
if (fd_open(bs) < 0)
return -EIO;
+#if defined(CONFIG_BLKZONED)
+ if (type & QEMU_AIO_WRITE && bs->wps) {
+ qemu_co_mutex_lock(&bs->wps->colock);
+ }
+#endif
/*
* When using O_DIRECT, the request must be aligned to be able to use
@@ -2354,14 +2461,16 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
} else if (s->use_linux_io_uring) {
LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
assert(qiov->size == bytes);
- return luring_co_submit(bs, aio, s->fd, offset, qiov, type);
+ ret = luring_co_submit(bs, aio, s->fd, offset, qiov, type);
+ goto out;
#endif
#ifdef CONFIG_LINUX_AIO
} else if (s->use_linux_aio) {
LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
assert(qiov->size == bytes);
- return laio_co_submit(bs, aio, s->fd, offset, qiov, type,
+ ret = laio_co_submit(bs, aio, s->fd, offset, qiov, type,
s->aio_max_batch);
+ goto out;
#endif
}
@@ -2378,7 +2487,32 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
};
assert(qiov->size == bytes);
- return raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
+ ret = raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
+
+out:
+#if defined(CONFIG_BLKZONED)
+ BlockZoneWps *wps = bs->wps;
+ if (ret == 0) {
+ if (type & QEMU_AIO_WRITE && wps && bs->bl.zone_size) {
+ uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
+ if (!BDRV_ZT_IS_CONV(*wp)) {
+ /* Advance the wp if needed */
+ if (offset + bytes > *wp) {
+ *wp = offset + bytes;
+ }
+ }
+ }
+ } else {
+ if (type & QEMU_AIO_WRITE) {
+ update_zones_wp(bs, s->fd, 0, 1);
+ }
+ }
+
+ if (type & QEMU_AIO_WRITE && wps) {
+ qemu_co_mutex_unlock(&wps->colock);
+ }
+#endif
+ return ret;
}
static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
@@ -2486,6 +2620,9 @@ static void raw_close(BlockDriverState *bs)
BDRVRawState *s = bs->opaque;
if (s->fd >= 0) {
+#if defined(CONFIG_BLKZONED)
+ g_free(bs->wps);
+#endif
qemu_close(s->fd);
s->fd = -1;
}
@@ -3283,6 +3420,7 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
const char *op_name;
unsigned long zo;
int ret;
+ BlockZoneWps *wps = bs->wps;
int64_t capacity = bs->total_sectors << BDRV_SECTOR_BITS;
zone_size = bs->bl.zone_size;
@@ -3300,6 +3438,15 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
return -EINVAL;
}
+ QEMU_LOCK_GUARD(&wps->colock);
+ uint32_t i = offset / bs->bl.zone_size;
+ uint32_t nrz = len / bs->bl.zone_size;
+ uint64_t *wp = &wps->wp[i];
+ if (BDRV_ZT_IS_CONV(*wp) && len != capacity) {
+ error_report("zone mgmt operations are not allowed for conventional zones");
+ return -EIO;
+ }
+
switch (op) {
case BLK_ZO_OPEN:
op_name = "BLKOPENZONE";
@@ -3337,8 +3484,28 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
len >> BDRV_SECTOR_BITS);
ret = raw_thread_pool_submit(bs, handle_aiocb_zone_mgmt, &acb);
if (ret != 0) {
+ update_zones_wp(bs, s->fd, offset, i);
ret = -errno;
error_report("ioctl %s failed %d", op_name, ret);
+ return ret;
+ }
+
+ if (zo == BLKRESETZONE && len == capacity) {
+ ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 1);
+ if (ret < 0) {
+ error_report("reporting single wp failed");
+ return ret;
+ }
+ } else if (zo == BLKRESETZONE) {
+ for (int j = 0; j < nrz; ++j) {
+ wp[j] = offset + j * zone_size;
+ }
+ } else if (zo == BLKFINISHZONE) {
+ for (int j = 0; j < nrz; ++j) {
+ /* The zoned device allows the last zone smaller that the
+ * zone size. */
+ wp[j] = MIN(offset + (j + 1) * zone_size, offset + len);
+ }
}
return ret;
diff --git a/include/block/block-common.h b/include/block/block-common.h
index 1576fcf2ed..93196229ac 100644
--- a/include/block/block-common.h
+++ b/include/block/block-common.h
@@ -118,6 +118,14 @@ typedef struct BlockZoneDescriptor {
BlockZoneState state;
} BlockZoneDescriptor;
+/*
+ * Track write pointers of a zone in bytes.
+ */
+typedef struct BlockZoneWps {
+ CoMutex colock;
+ uint64_t wp[];
+} BlockZoneWps;
+
typedef struct BlockDriverInfo {
/* in bytes, 0 if irrelevant */
int cluster_size;
@@ -240,6 +248,12 @@ typedef enum {
#define BDRV_SECTOR_BITS 9
#define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
+/*
+ * Get the first most significant bit of wp. If it is zero, then
+ * the zone type is SWR.
+ */
+#define BDRV_ZT_IS_CONV(wp) (wp & (1ULL << 63))
+
#define BDRV_REQUEST_MAX_SECTORS MIN_CONST(SIZE_MAX >> BDRV_SECTOR_BITS, \
INT_MAX >> BDRV_SECTOR_BITS)
#define BDRV_REQUEST_MAX_BYTES (BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS)
diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
index 1bd2aef4d5..b34a7f175d 100644
--- a/include/block/block_int-common.h
+++ b/include/block/block_int-common.h
@@ -884,6 +884,8 @@ typedef struct BlockLimits {
/* maximum number of active zones */
int64_t max_active_zones;
+
+ int64_t write_granularity;
} BlockLimits;
typedef struct BdrvOpBlocker BdrvOpBlocker;
@@ -1245,6 +1247,9 @@ struct BlockDriverState {
CoMutex bsc_modify_lock;
/* Always non-NULL, but must only be dereferenced under an RCU read guard */
BdrvBlockStatusCache *block_status_cache;
+
+ /* array of write pointers' location of each zone in the zoned device. */
+ BlockZoneWps *wps;
};
struct BlockBackendRootState {
--
2.39.2On Fri, Apr 07, 2023 at 04:16:54PM +0800, Sam Li wrote:
> Since Linux doesn't have a user API to issue zone append operations to
> zoned devices from user space, the file-posix driver is modified to add
> zone append emulation using regular writes. To do this, the file-posix
> driver tracks the wp location of all zones of the device. It uses an
> array of uint64_t. The most significant bit of each wp location indicates
> if the zone type is conventional zones.
>
> The zones wp can be changed due to the following operations issued:
> - zone reset: change the wp to the start offset of that zone
> - zone finish: change to the end location of that zone
> - write to a zone
> - zone append
>
> Signed-off-by: Sam Li <faithilikerun@gmail.com>
> ---
> block/file-posix.c | 173 ++++++++++++++++++++++++++++++-
> include/block/block-common.h | 14 +++
> include/block/block_int-common.h | 5 +
> 3 files changed, 189 insertions(+), 3 deletions(-)
>
> diff --git a/block/file-posix.c b/block/file-posix.c
> index 65efe5147e..e7957f5559 100644
> --- a/block/file-posix.c
> +++ b/block/file-posix.c
> @@ -1324,6 +1324,90 @@ static int hdev_get_max_segments(int fd, struct stat *st)
> #endif
> }
>
> +#if defined(CONFIG_BLKZONED)
> +/*
> + * If the reset_all flag is true, then the wps of zone whose state is
> + * not readonly or offline should be all reset to the start sector.
> + * Else, take the real wp of the device.
> + */
> +static int get_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
> + unsigned int nrz, bool reset_all)
> +{
> + struct blk_zone *blkz;
> + size_t rep_size;
> + uint64_t sector = offset >> BDRV_SECTOR_BITS;
> + BlockZoneWps *wps = bs->wps;
> + int j = offset / bs->bl.zone_size;
> + int ret, n = 0, i = 0;
I would feel more comfortable if i, j, and n were unsigned int like nrz.
That way we don't need to worry about negative array indices when int
wraps to INT_MIN.
In practice we'll probably hit scalability problems before nrz becomes
greater than INT_MAX. Also, such devices probably don't exist. A 5 TB
drive with 256 MB zones only has 20,480 zones.
So for now I think you can keep the code the way it is.
> + rep_size = sizeof(struct blk_zone_report) + nrz * sizeof(struct blk_zone);
> + g_autofree struct blk_zone_report *rep = NULL;
> +
> + rep = g_malloc(rep_size);
> + blkz = (struct blk_zone *)(rep + 1);
> + while (n < nrz) {
> + memset(rep, 0, rep_size);
> + rep->sector = sector;
> + rep->nr_zones = nrz - n;
> +
> + do {
> + ret = ioctl(fd, BLKREPORTZONE, rep);
> + } while (ret != 0 && errno == EINTR);
> + if (ret != 0) {
> + error_report("%d: ioctl BLKREPORTZONE at %" PRId64 " failed %d",
> + fd, offset, errno);
> + return -errno;
> + }
> +
> + if (!rep->nr_zones) {
> + break;
> + }
> +
> + for (i = 0; i < rep->nr_zones; ++i, ++n, ++j) {
> + /*
> + * The wp tracking cares only about sequential writes required and
> + * sequential write preferred zones so that the wp can advance to
> + * the right location.
> + * Use the most significant bit of the wp location to indicate the
> + * zone type: 0 for SWR/SWP zones and 1 for conventional zones.
> + */
> + if (blkz[i].type == BLK_ZONE_TYPE_CONVENTIONAL) {
> + wps->wp[j] |= 1ULL << 63;
> + } else {
> + switch(blkz[i].cond) {
> + case BLK_ZONE_COND_FULL:
> + case BLK_ZONE_COND_READONLY:
> + /* Zone not writable */
> + wps->wp[j] = (blkz[i].start + blkz[i].len) << BDRV_SECTOR_BITS;
> + break;
> + case BLK_ZONE_COND_OFFLINE:
> + /* Zone not writable nor readable */
> + wps->wp[j] = (blkz[i].start) << BDRV_SECTOR_BITS;
> + break;
> + default:
> + if (reset_all) {
> + wps->wp[j] = blkz[i].start << BDRV_SECTOR_BITS;
> + } else {
> + wps->wp[j] = blkz[i].wp << BDRV_SECTOR_BITS;
> + }
> + break;
> + }
> + }
> + }
> + sector = blkz[i - 1].start + blkz[i - 1].len;
> + }
> +
> + return 0;
> +}
> +
> +static void update_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
> + unsigned int nrz)
> +{
> + if (get_zones_wp(bs, fd, offset, nrz, 0) < 0) {
> + error_report("update zone wp failed");
> + }
> +}
> +#endif
> +
> static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
> {
> BDRVRawState *s = bs->opaque;
> @@ -1413,6 +1497,23 @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
> if (ret >= 0) {
> bs->bl.max_active_zones = ret;
> }
> +
> + ret = get_sysfs_long_val(&st, "physical_block_size");
> + if (ret >= 0) {
> + bs->bl.write_granularity = ret;
> + }
> +
> + /* The refresh_limits() function can be called multiple times. */
> + g_free(bs->wps);
> + bs->wps = g_malloc(sizeof(BlockZoneWps) +
> + sizeof(int64_t) * bs->bl.nr_zones);
> + ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 0);
> + if (ret < 0) {
> + error_setg_errno(errp, -ret, "report wps failed");
> + bs->wps = NULL;
> + return;
> + }
> + qemu_co_mutex_init(&bs->wps->colock);
I suggest moving qemu_co_mutex_init() to raw_open_common() in the future
to eliminate the assumption that raw_refresh_limits() is called before
other functions that use colock. But there is no need to resend the
patch series.
> return;
> }
> out:
> @@ -2338,9 +2439,15 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
> {
> BDRVRawState *s = bs->opaque;
> RawPosixAIOData acb;
> + int ret;
>
> if (fd_open(bs) < 0)
> return -EIO;
> +#if defined(CONFIG_BLKZONED)
> + if (type & QEMU_AIO_WRITE && bs->wps) {
> + qemu_co_mutex_lock(&bs->wps->colock);
> + }
> +#endif
>
> /*
> * When using O_DIRECT, the request must be aligned to be able to use
> @@ -2354,14 +2461,16 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
> } else if (s->use_linux_io_uring) {
> LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
> assert(qiov->size == bytes);
> - return luring_co_submit(bs, aio, s->fd, offset, qiov, type);
> + ret = luring_co_submit(bs, aio, s->fd, offset, qiov, type);
> + goto out;
> #endif
> #ifdef CONFIG_LINUX_AIO
> } else if (s->use_linux_aio) {
> LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
> assert(qiov->size == bytes);
> - return laio_co_submit(bs, aio, s->fd, offset, qiov, type,
> + ret = laio_co_submit(bs, aio, s->fd, offset, qiov, type,
> s->aio_max_batch);
> + goto out;
> #endif
> }
>
> @@ -2378,7 +2487,32 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
> };
>
> assert(qiov->size == bytes);
> - return raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
> + ret = raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
> +
> +out:
> +#if defined(CONFIG_BLKZONED)
> + BlockZoneWps *wps = bs->wps;
> + if (ret == 0) {
> + if (type & QEMU_AIO_WRITE && wps && bs->bl.zone_size) {
> + uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
> + if (!BDRV_ZT_IS_CONV(*wp)) {
> + /* Advance the wp if needed */
> + if (offset + bytes > *wp) {
> + *wp = offset + bytes;
> + }
> + }
> + }
> + } else {
> + if (type & QEMU_AIO_WRITE) {
> + update_zones_wp(bs, s->fd, 0, 1);
> + }
> + }
> +
> + if (type & QEMU_AIO_WRITE && wps) {
> + qemu_co_mutex_unlock(&wps->colock);
> + }
> +#endif
> + return ret;
> }
>
> static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
> @@ -2486,6 +2620,9 @@ static void raw_close(BlockDriverState *bs)
> BDRVRawState *s = bs->opaque;
>
> if (s->fd >= 0) {
> +#if defined(CONFIG_BLKZONED)
> + g_free(bs->wps);
> +#endif
> qemu_close(s->fd);
> s->fd = -1;
> }
> @@ -3283,6 +3420,7 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
> const char *op_name;
> unsigned long zo;
> int ret;
> + BlockZoneWps *wps = bs->wps;
> int64_t capacity = bs->total_sectors << BDRV_SECTOR_BITS;
>
> zone_size = bs->bl.zone_size;
> @@ -3300,6 +3438,15 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
> return -EINVAL;
> }
>
> + QEMU_LOCK_GUARD(&wps->colock);
> + uint32_t i = offset / bs->bl.zone_size;
> + uint32_t nrz = len / bs->bl.zone_size;
> + uint64_t *wp = &wps->wp[i];
> + if (BDRV_ZT_IS_CONV(*wp) && len != capacity) {
> + error_report("zone mgmt operations are not allowed for conventional zones");
> + return -EIO;
> + }
> +
> switch (op) {
> case BLK_ZO_OPEN:
> op_name = "BLKOPENZONE";
> @@ -3337,8 +3484,28 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
> len >> BDRV_SECTOR_BITS);
> ret = raw_thread_pool_submit(bs, handle_aiocb_zone_mgmt, &acb);
> if (ret != 0) {
> + update_zones_wp(bs, s->fd, offset, i);
> ret = -errno;
> error_report("ioctl %s failed %d", op_name, ret);
> + return ret;
> + }
> +
> + if (zo == BLKRESETZONE && len == capacity) {
> + ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 1);
> + if (ret < 0) {
> + error_report("reporting single wp failed");
> + return ret;
> + }
> + } else if (zo == BLKRESETZONE) {
> + for (int j = 0; j < nrz; ++j) {
> + wp[j] = offset + j * zone_size;
> + }
> + } else if (zo == BLKFINISHZONE) {
> + for (int j = 0; j < nrz; ++j) {
> + /* The zoned device allows the last zone smaller that the
> + * zone size. */
> + wp[j] = MIN(offset + (j + 1) * zone_size, offset + len);
> + }
> }
>
> return ret;
> diff --git a/include/block/block-common.h b/include/block/block-common.h
> index 1576fcf2ed..93196229ac 100644
> --- a/include/block/block-common.h
> +++ b/include/block/block-common.h
> @@ -118,6 +118,14 @@ typedef struct BlockZoneDescriptor {
> BlockZoneState state;
> } BlockZoneDescriptor;
>
> +/*
> + * Track write pointers of a zone in bytes.
> + */
> +typedef struct BlockZoneWps {
> + CoMutex colock;
> + uint64_t wp[];
> +} BlockZoneWps;
> +
> typedef struct BlockDriverInfo {
> /* in bytes, 0 if irrelevant */
> int cluster_size;
> @@ -240,6 +248,12 @@ typedef enum {
> #define BDRV_SECTOR_BITS 9
> #define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
>
> +/*
> + * Get the first most significant bit of wp. If it is zero, then
> + * the zone type is SWR.
> + */
> +#define BDRV_ZT_IS_CONV(wp) (wp & (1ULL << 63))
> +
> #define BDRV_REQUEST_MAX_SECTORS MIN_CONST(SIZE_MAX >> BDRV_SECTOR_BITS, \
> INT_MAX >> BDRV_SECTOR_BITS)
> #define BDRV_REQUEST_MAX_BYTES (BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS)
> diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
> index 1bd2aef4d5..b34a7f175d 100644
> --- a/include/block/block_int-common.h
> +++ b/include/block/block_int-common.h
> @@ -884,6 +884,8 @@ typedef struct BlockLimits {
>
> /* maximum number of active zones */
> int64_t max_active_zones;
> +
> + int64_t write_granularity;
> } BlockLimits;
>
> typedef struct BdrvOpBlocker BdrvOpBlocker;
> @@ -1245,6 +1247,9 @@ struct BlockDriverState {
> CoMutex bsc_modify_lock;
> /* Always non-NULL, but must only be dereferenced under an RCU read guard */
> BdrvBlockStatusCache *block_status_cache;
> +
> + /* array of write pointers' location of each zone in the zoned device. */
> + BlockZoneWps *wps;
> };
>
> struct BlockBackendRootState {
> --
> 2.39.2
>
Stefan Hajnoczi <stefanha@redhat.com> 于2023年4月10日周一 21:04写道：
>
> On Fri, Apr 07, 2023 at 04:16:54PM +0800, Sam Li wrote:
> > Since Linux doesn't have a user API to issue zone append operations to
> > zoned devices from user space, the file-posix driver is modified to add
> > zone append emulation using regular writes. To do this, the file-posix
> > driver tracks the wp location of all zones of the device. It uses an
> > array of uint64_t. The most significant bit of each wp location indicates
> > if the zone type is conventional zones.
> >
> > The zones wp can be changed due to the following operations issued:
> > - zone reset: change the wp to the start offset of that zone
> > - zone finish: change to the end location of that zone
> > - write to a zone
> > - zone append
> >
> > Signed-off-by: Sam Li <faithilikerun@gmail.com>
> > ---
> > block/file-posix.c | 173 ++++++++++++++++++++++++++++++-
> > include/block/block-common.h | 14 +++
> > include/block/block_int-common.h | 5 +
> > 3 files changed, 189 insertions(+), 3 deletions(-)
> >
> > diff --git a/block/file-posix.c b/block/file-posix.c
> > index 65efe5147e..e7957f5559 100644
> > --- a/block/file-posix.c
> > +++ b/block/file-posix.c
> > @@ -1324,6 +1324,90 @@ static int hdev_get_max_segments(int fd, struct stat *st)
> > #endif
> > }
> >
> > +#if defined(CONFIG_BLKZONED)
> > +/*
> > + * If the reset_all flag is true, then the wps of zone whose state is
> > + * not readonly or offline should be all reset to the start sector.
> > + * Else, take the real wp of the device.
> > + */
> > +static int get_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
> > + unsigned int nrz, bool reset_all)
> > +{
> > + struct blk_zone *blkz;
> > + size_t rep_size;
> > + uint64_t sector = offset >> BDRV_SECTOR_BITS;
> > + BlockZoneWps *wps = bs->wps;
> > + int j = offset / bs->bl.zone_size;
> > + int ret, n = 0, i = 0;
>
> I would feel more comfortable if i, j, and n were unsigned int like nrz.
> That way we don't need to worry about negative array indices when int
> wraps to INT_MIN.
>
> In practice we'll probably hit scalability problems before nrz becomes
> greater than INT_MAX. Also, such devices probably don't exist. A 5 TB
> drive with 256 MB zones only has 20,480 zones.
>
> So for now I think you can keep the code the way it is.
>
> > + rep_size = sizeof(struct blk_zone_report) + nrz * sizeof(struct blk_zone);
> > + g_autofree struct blk_zone_report *rep = NULL;
> > +
> > + rep = g_malloc(rep_size);
> > + blkz = (struct blk_zone *)(rep + 1);
> > + while (n < nrz) {
> > + memset(rep, 0, rep_size);
> > + rep->sector = sector;
> > + rep->nr_zones = nrz - n;
> > +
> > + do {
> > + ret = ioctl(fd, BLKREPORTZONE, rep);
> > + } while (ret != 0 && errno == EINTR);
> > + if (ret != 0) {
> > + error_report("%d: ioctl BLKREPORTZONE at %" PRId64 " failed %d",
> > + fd, offset, errno);
> > + return -errno;
> > + }
> > +
> > + if (!rep->nr_zones) {
> > + break;
> > + }
> > +
> > + for (i = 0; i < rep->nr_zones; ++i, ++n, ++j) {
> > + /*
> > + * The wp tracking cares only about sequential writes required and
> > + * sequential write preferred zones so that the wp can advance to
> > + * the right location.
> > + * Use the most significant bit of the wp location to indicate the
> > + * zone type: 0 for SWR/SWP zones and 1 for conventional zones.
> > + */
> > + if (blkz[i].type == BLK_ZONE_TYPE_CONVENTIONAL) {
> > + wps->wp[j] |= 1ULL << 63;
> > + } else {
> > + switch(blkz[i].cond) {
> > + case BLK_ZONE_COND_FULL:
> > + case BLK_ZONE_COND_READONLY:
> > + /* Zone not writable */
> > + wps->wp[j] = (blkz[i].start + blkz[i].len) << BDRV_SECTOR_BITS;
> > + break;
> > + case BLK_ZONE_COND_OFFLINE:
> > + /* Zone not writable nor readable */
> > + wps->wp[j] = (blkz[i].start) << BDRV_SECTOR_BITS;
> > + break;
> > + default:
> > + if (reset_all) {
> > + wps->wp[j] = blkz[i].start << BDRV_SECTOR_BITS;
> > + } else {
> > + wps->wp[j] = blkz[i].wp << BDRV_SECTOR_BITS;
> > + }
> > + break;
> > + }
> > + }
> > + }
> > + sector = blkz[i - 1].start + blkz[i - 1].len;
> > + }
> > +
> > + return 0;
> > +}
> > +
> > +static void update_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
> > + unsigned int nrz)
> > +{
> > + if (get_zones_wp(bs, fd, offset, nrz, 0) < 0) {
> > + error_report("update zone wp failed");
> > + }
> > +}
> > +#endif
> > +
> > static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
> > {
> > BDRVRawState *s = bs->opaque;
> > @@ -1413,6 +1497,23 @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
> > if (ret >= 0) {
> > bs->bl.max_active_zones = ret;
> > }
> > +
> > + ret = get_sysfs_long_val(&st, "physical_block_size");
> > + if (ret >= 0) {
> > + bs->bl.write_granularity = ret;
> > + }
> > +
> > + /* The refresh_limits() function can be called multiple times. */
> > + g_free(bs->wps);
> > + bs->wps = g_malloc(sizeof(BlockZoneWps) +
> > + sizeof(int64_t) * bs->bl.nr_zones);
> > + ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 0);
> > + if (ret < 0) {
> > + error_setg_errno(errp, -ret, "report wps failed");
> > + bs->wps = NULL;
> > + return;
> > + }
> > + qemu_co_mutex_init(&bs->wps->colock);
>
> I suggest moving qemu_co_mutex_init() to raw_open_common() in the future
> to eliminate the assumption that raw_refresh_limits() is called before
> other functions that use colock. But there is no need to resend the
> patch series.
Ok, I see. This can be done in the future. Thanks!
>
> > return;
> > }
> > out:
> > @@ -2338,9 +2439,15 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
> > {
> > BDRVRawState *s = bs->opaque;
> > RawPosixAIOData acb;
> > + int ret;
> >
> > if (fd_open(bs) < 0)
> > return -EIO;
> > +#if defined(CONFIG_BLKZONED)
> > + if (type & QEMU_AIO_WRITE && bs->wps) {
> > + qemu_co_mutex_lock(&bs->wps->colock);
> > + }
> > +#endif
> >
> > /*
> > * When using O_DIRECT, the request must be aligned to be able to use
> > @@ -2354,14 +2461,16 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
> > } else if (s->use_linux_io_uring) {
> > LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
> > assert(qiov->size == bytes);
> > - return luring_co_submit(bs, aio, s->fd, offset, qiov, type);
> > + ret = luring_co_submit(bs, aio, s->fd, offset, qiov, type);
> > + goto out;
> > #endif
> > #ifdef CONFIG_LINUX_AIO
> > } else if (s->use_linux_aio) {
> > LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
> > assert(qiov->size == bytes);
> > - return laio_co_submit(bs, aio, s->fd, offset, qiov, type,
> > + ret = laio_co_submit(bs, aio, s->fd, offset, qiov, type,
> > s->aio_max_batch);
> > + goto out;
> > #endif
> > }
> >
> > @@ -2378,7 +2487,32 @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
> > };
> >
> > assert(qiov->size == bytes);
> > - return raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
> > + ret = raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
> > +
> > +out:
> > +#if defined(CONFIG_BLKZONED)
> > + BlockZoneWps *wps = bs->wps;
> > + if (ret == 0) {
> > + if (type & QEMU_AIO_WRITE && wps && bs->bl.zone_size) {
> > + uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
> > + if (!BDRV_ZT_IS_CONV(*wp)) {
> > + /* Advance the wp if needed */
> > + if (offset + bytes > *wp) {
> > + *wp = offset + bytes;
> > + }
> > + }
> > + }
> > + } else {
> > + if (type & QEMU_AIO_WRITE) {
> > + update_zones_wp(bs, s->fd, 0, 1);
> > + }
> > + }
> > +
> > + if (type & QEMU_AIO_WRITE && wps) {
> > + qemu_co_mutex_unlock(&wps->colock);
> > + }
> > +#endif
> > + return ret;
> > }
> >
> > static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
> > @@ -2486,6 +2620,9 @@ static void raw_close(BlockDriverState *bs)
> > BDRVRawState *s = bs->opaque;
> >
> > if (s->fd >= 0) {
> > +#if defined(CONFIG_BLKZONED)
> > + g_free(bs->wps);
> > +#endif
> > qemu_close(s->fd);
> > s->fd = -1;
> > }
> > @@ -3283,6 +3420,7 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
> > const char *op_name;
> > unsigned long zo;
> > int ret;
> > + BlockZoneWps *wps = bs->wps;
> > int64_t capacity = bs->total_sectors << BDRV_SECTOR_BITS;
> >
> > zone_size = bs->bl.zone_size;
> > @@ -3300,6 +3438,15 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
> > return -EINVAL;
> > }
> >
> > + QEMU_LOCK_GUARD(&wps->colock);
> > + uint32_t i = offset / bs->bl.zone_size;
> > + uint32_t nrz = len / bs->bl.zone_size;
> > + uint64_t *wp = &wps->wp[i];
> > + if (BDRV_ZT_IS_CONV(*wp) && len != capacity) {
> > + error_report("zone mgmt operations are not allowed for conventional zones");
> > + return -EIO;
> > + }
> > +
> > switch (op) {
> > case BLK_ZO_OPEN:
> > op_name = "BLKOPENZONE";
> > @@ -3337,8 +3484,28 @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
> > len >> BDRV_SECTOR_BITS);
> > ret = raw_thread_pool_submit(bs, handle_aiocb_zone_mgmt, &acb);
> > if (ret != 0) {
> > + update_zones_wp(bs, s->fd, offset, i);
> > ret = -errno;
> > error_report("ioctl %s failed %d", op_name, ret);
> > + return ret;
> > + }
> > +
> > + if (zo == BLKRESETZONE && len == capacity) {
> > + ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 1);
> > + if (ret < 0) {
> > + error_report("reporting single wp failed");
> > + return ret;
> > + }
> > + } else if (zo == BLKRESETZONE) {
> > + for (int j = 0; j < nrz; ++j) {
> > + wp[j] = offset + j * zone_size;
> > + }
> > + } else if (zo == BLKFINISHZONE) {
> > + for (int j = 0; j < nrz; ++j) {
> > + /* The zoned device allows the last zone smaller that the
> > + * zone size. */
> > + wp[j] = MIN(offset + (j + 1) * zone_size, offset + len);
> > + }
> > }
> >
> > return ret;
> > diff --git a/include/block/block-common.h b/include/block/block-common.h
> > index 1576fcf2ed..93196229ac 100644
> > --- a/include/block/block-common.h
> > +++ b/include/block/block-common.h
> > @@ -118,6 +118,14 @@ typedef struct BlockZoneDescriptor {
> > BlockZoneState state;
> > } BlockZoneDescriptor;
> >
> > +/*
> > + * Track write pointers of a zone in bytes.
> > + */
> > +typedef struct BlockZoneWps {
> > + CoMutex colock;
> > + uint64_t wp[];
> > +} BlockZoneWps;
> > +
> > typedef struct BlockDriverInfo {
> > /* in bytes, 0 if irrelevant */
> > int cluster_size;
> > @@ -240,6 +248,12 @@ typedef enum {
> > #define BDRV_SECTOR_BITS 9
> > #define BDRV_SECTOR_SIZE (1ULL << BDRV_SECTOR_BITS)
> >
> > +/*
> > + * Get the first most significant bit of wp. If it is zero, then
> > + * the zone type is SWR.
> > + */
> > +#define BDRV_ZT_IS_CONV(wp) (wp & (1ULL << 63))
> > +
> > #define BDRV_REQUEST_MAX_SECTORS MIN_CONST(SIZE_MAX >> BDRV_SECTOR_BITS, \
> > INT_MAX >> BDRV_SECTOR_BITS)
> > #define BDRV_REQUEST_MAX_BYTES (BDRV_REQUEST_MAX_SECTORS << BDRV_SECTOR_BITS)
> > diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
> > index 1bd2aef4d5..b34a7f175d 100644
> > --- a/include/block/block_int-common.h
> > +++ b/include/block/block_int-common.h
> > @@ -884,6 +884,8 @@ typedef struct BlockLimits {
> >
> > /* maximum number of active zones */
> > int64_t max_active_zones;
> > +
> > + int64_t write_granularity;
> > } BlockLimits;
> >
> > typedef struct BdrvOpBlocker BdrvOpBlocker;
> > @@ -1245,6 +1247,9 @@ struct BlockDriverState {
> > CoMutex bsc_modify_lock;
> > /* Always non-NULL, but must only be dereferenced under an RCU read guard */
> > BdrvBlockStatusCache *block_status_cache;
> > +
> > + /* array of write pointers' location of each zone in the zoned device. */
> > + BlockZoneWps *wps;
> > };
> >
> > struct BlockBackendRootState {
> > --
> > 2.39.2
> >
© 2016 - 2026 Red Hat, Inc.