The following changes since commit 8844bb8d896595ee1d25d21c770e6e6f29803097:

Merge tag 'or1k-pull-request-20230513' of https://github.com/stffrdhrn/qemu into staging (2023-05-13 11:23:14 +0100)

are available in the Git repository at:

https://gitlab.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 01562fee5f3ad4506d57dbcf4b1903b565eceec7:

docs/zoned-storage:add zoned emulation use case (2023-05-15 08:19:04 -0400)

----------------------------------------------------------------

Pull request

This pull request contain's Sam Li's zoned storage support in the QEMU block

layer and virtio-blk emulation.

v2:

- Sam fixed the CI failures. CI passes for me now. [Richard]

Sam Li (16):

block/block-common: add zoned device structs

block/file-posix: introduce helper functions for sysfs attributes

block/block-backend: add block layer APIs resembling Linux

ZonedBlockDevice ioctls

block/raw-format: add zone operations to pass through requests

block: add zoned BlockDriver check to block layer

iotests: test new zone operations

block: add some trace events for new block layer APIs

docs/zoned-storage: add zoned device documentation

file-posix: add tracking of the zone write pointers

block: introduce zone append write for zoned devices

qemu-iotests: test zone append operation

block: add some trace events for zone append

virtio-blk: add zoned storage emulation for zoned devices

block: add accounting for zone append operation

virtio-blk: add some trace events for zoned emulation

docs/zoned-storage:add zoned emulation use case

docs/devel/index-api.rst | 1 +

docs/devel/zoned-storage.rst | 62 +++

qapi/block-core.json | 68 ++-

qapi/block.json | 4 +

meson.build | 5 +

include/block/accounting.h | 1 +

include/block/block-common.h | 57 ++

include/block/block-io.h | 13 +

include/block/block_int-common.h | 37 ++

include/block/raw-aio.h | 8 +-

include/sysemu/block-backend-io.h | 27 +

block.c | 19 +

block/block-backend.c | 198 +++++++

block/file-posix.c | 692 +++++++++++++++++++++++--

block/io.c | 68 +++

block/io_uring.c | 4 +

block/linux-aio.c | 3 +

block/qapi-sysemu.c | 11 +

block/qapi.c | 18 +

block/raw-format.c | 26 +

hw/block/virtio-blk-common.c | 2 +

hw/block/virtio-blk.c | 405 +++++++++++++++

hw/virtio/virtio-qmp.c | 2 +

qemu-io-cmds.c | 224 ++++++++

block/trace-events | 4 +

docs/system/qemu-block-drivers.rst.inc | 6 +

hw/block/trace-events | 7 +

tests/qemu-iotests/227.out | 18 +

tests/qemu-iotests/tests/zoned | 105 ++++

tests/qemu-iotests/tests/zoned.out | 69 +++

30 files changed, 2106 insertions(+), 58 deletions(-)

create mode 100644 docs/devel/zoned-storage.rst

create mode 100755 tests/qemu-iotests/tests/zoned

create mode 100644 tests/qemu-iotests/tests/zoned.out

2.40.1

From: Sam Li <faithilikerun@gmail.com>

Signed-off-by: Sam Li <faithilikerun@gmail.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>

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

Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>

Acked-by: Kevin Wolf <kwolf@redhat.com>

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

Message-id: 20230508045533.175575-2-faithilikerun@gmail.com

Message-id: 20230324090605.28361-2-faithilikerun@gmail.com

[Adjust commit message prefix as suggested by Philippe Mathieu-Daudé

<philmd@linaro.org>.

--Stefan]

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

include/block/block-common.h | 43 ++++++++++++++++++++++++++++++++++++

1 file changed, 43 insertions(+)

diff --git a/include/block/block-common.h b/include/block/block-common.h

index XXXXXXX..XXXXXXX 100644

--- a/include/block/block-common.h

+++ b/include/block/block-common.h

@@ -XXX,XX +XXX,XX @@ typedef struct BlockDriver BlockDriver;

typedef struct BdrvChild BdrvChild;

typedef struct BdrvChildClass BdrvChildClass;

+typedef enum BlockZoneOp {

+ BLK_ZO_OPEN,

+ BLK_ZO_CLOSE,

+ BLK_ZO_FINISH,

+ BLK_ZO_RESET,

+} BlockZoneOp;

+

+typedef enum BlockZoneModel {

+ BLK_Z_NONE = 0x0, /* Regular block device */

+ BLK_Z_HM = 0x1, /* Host-managed zoned block device */

+ BLK_Z_HA = 0x2, /* Host-aware zoned block device */

+} BlockZoneModel;

+

+typedef enum BlockZoneState {

+ BLK_ZS_NOT_WP = 0x0,

+ BLK_ZS_EMPTY = 0x1,

+ BLK_ZS_IOPEN = 0x2,

+ BLK_ZS_EOPEN = 0x3,

+ BLK_ZS_CLOSED = 0x4,

+ BLK_ZS_RDONLY = 0xD,

+ BLK_ZS_FULL = 0xE,

+ BLK_ZS_OFFLINE = 0xF,

+} BlockZoneState;

+

+typedef enum BlockZoneType {

+ BLK_ZT_CONV = 0x1, /* Conventional random writes supported */

+ BLK_ZT_SWR = 0x2, /* Sequential writes required */

+ BLK_ZT_SWP = 0x3, /* Sequential writes preferred */

+} BlockZoneType;

+

+/*

+ * Zone descriptor data structure.

+ * Provides information on a zone with all position and size values in bytes.

+ */

+typedef struct BlockZoneDescriptor {

+ uint64_t start;

+ uint64_t length;

+ uint64_t cap;

+ uint64_t wp;

+ BlockZoneType type;

+ BlockZoneState state;

+} BlockZoneDescriptor;

+

typedef struct BlockDriverInfo {

/* in bytes, 0 if irrelevant */

int cluster_size;

2.40.1

From: Sam Li <faithilikerun@gmail.com>

Use get_sysfs_str_val() to get the string value of device

zoned model. Then get_sysfs_zoned_model() can convert it to

BlockZoneModel type of QEMU.

Use get_sysfs_long_val() to get the long value of zoned device

information.

Signed-off-by: Sam Li <faithilikerun@gmail.com>

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

Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>

Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>

Acked-by: Kevin Wolf <kwolf@redhat.com>

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

Message-id: 20230508045533.175575-3-faithilikerun@gmail.com

Message-id: 20230324090605.28361-3-faithilikerun@gmail.com

[Adjust commit message prefix as suggested by Philippe Mathieu-Daudé

<philmd@linaro.org>.

--Stefan]

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

include/block/block_int-common.h | 3 +

block/file-posix.c | 135 ++++++++++++++++++++++---------

2 files changed, 100 insertions(+), 38 deletions(-)

diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h

--- a/include/block/block_int-common.h

+++ b/include/block/block_int-common.h

@@ -XXX,XX +XXX,XX @@ typedef struct BlockLimits {

* an explicit monitor command to load the disk inside the guest).

*/

bool has_variable_length;

+

+ /* device zone model */

+ BlockZoneModel zoned;

} BlockLimits;

typedef struct BdrvOpBlocker BdrvOpBlocker;

diff --git a/block/file-posix.c b/block/file-posix.c

index XXXXXXX..XXXXXXX 100644

--- a/block/file-posix.c

+++ b/block/file-posix.c

@@ -XXX,XX +XXX,XX @@ static int hdev_get_max_hw_transfer(int fd, struct stat *st)

#endif

-static int hdev_get_max_segments(int fd, struct stat *st)

+/*

+ * Get a sysfs attribute value as character string.

+ */

+#ifdef CONFIG_LINUX

+static int get_sysfs_str_val(struct stat *st, const char *attribute,

+ char **val) {

+ g_autofree char *sysfspath = NULL;

+ int ret;

+ size_t len;

+

+ if (!S_ISBLK(st->st_mode)) {

+ return -ENOTSUP;

+ }

+

+ sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/%s",

+ major(st->st_rdev), minor(st->st_rdev),

+ attribute);

+ ret = g_file_get_contents(sysfspath, val, &len, NULL);

+ if (ret == -1) {

+ return -ENOENT;

+ }

+

+ /* The file is ended with '\n' */

+ char *p;

+ p = *val;

+ if (*(p + len - 1) == '\n') {

+ *(p + len - 1) = '\0';

+ }

+ return ret;

+}

+#endif

+

+static int get_sysfs_zoned_model(struct stat *st, BlockZoneModel *zoned)

+ g_autofree char *val = NULL;

+ int ret;

+

+ ret = get_sysfs_str_val(st, "zoned", &val);

+

+ if (strcmp(val, "host-managed") == 0) {

+ *zoned = BLK_Z_HM;

+ } else if (strcmp(val, "host-aware") == 0) {

+ *zoned = BLK_Z_HA;

+ } else if (strcmp(val, "none") == 0) {

+ *zoned = BLK_Z_NONE;

+ } else {

+ return -ENOTSUP;

+ }

+ return 0;

+}

+

+/*

+ * Get a sysfs attribute value as a long integer.

+ */

#ifdef CONFIG_LINUX

- char buf[32];

+static long get_sysfs_long_val(struct stat *st, const char *attribute)

+{

+ g_autofree char *str = NULL;

const char *end;

- char *sysfspath = NULL;

+ long val;

+ int ret;

+

+ ret = get_sysfs_str_val(st, attribute, &str);

+

+ /* The file is ended with '\n', pass 'end' to accept that. */

+ ret = qemu_strtol(str, &end, 10, &val);

+ if (ret == 0 && end && *end == '\0') {

+ ret = val;

+ }

+ return ret;

+}

+#endif

+

+static int hdev_get_max_segments(int fd, struct stat *st)

+{

+#ifdef CONFIG_LINUX

int ret;

- int sysfd = -1;

- long max_segments;

if (S_ISCHR(st->st_mode)) {

if (ioctl(fd, SG_GET_SG_TABLESIZE, &ret) == 0) {

@@ -XXX,XX +XXX,XX @@ static int hdev_get_max_segments(int fd, struct stat *st)

}

return -ENOTSUP;

-

- if (!S_ISBLK(st->st_mode)) {

- return -ENOTSUP;

- }

-

- sysfspath = g_strdup_printf("/sys/dev/block/%u:%u/queue/max_segments",

- major(st->st_rdev), minor(st->st_rdev));

- sysfd = open(sysfspath, O_RDONLY);

- if (sysfd == -1) {

- ret = -errno;

- goto out;

- }

- ret = RETRY_ON_EINTR(read(sysfd, buf, sizeof(buf) - 1));

- if (ret < 0) {

- ret = -errno;

- goto out;

- } else if (ret == 0) {

- ret = -EIO;

- goto out;

- }

- buf[ret] = 0;

- /* The file is ended with '\n', pass 'end' to accept that. */

- ret = qemu_strtol(buf, &end, 10, &max_segments);

- if (ret == 0 && end && *end == '\n') {

- ret = max_segments;

- }

-

-out:

- if (sysfd != -1) {

- close(sysfd);

- }

- g_free(sysfspath);

- return ret;

+ return get_sysfs_long_val(st, "max_segments");

#else

return -ENOTSUP;

#endif

}

+static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,

+ Error **errp)

+{

+ BlockZoneModel zoned;

+ int ret;

+

+ bs->bl.zoned = BLK_Z_NONE;

+

+ ret = get_sysfs_zoned_model(st, &zoned);

+ if (ret < 0 || zoned == BLK_Z_NONE) {

+ return;

+ }

+ bs->bl.zoned = zoned;

+}

+

static void raw_refresh_limits(BlockDriverState *bs, Error **errp)

{

BDRVRawState *s = bs->opaque;

@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)

bs->bl.max_hw_iov = ret;

}

+

+ raw_refresh_zoned_limits(bs, &st, errp);

}

static int check_for_dasd(int fd)

2.40.1

From: Sam Li <faithilikerun@gmail.com>

Add zoned device option to host_device BlockDriver. It will be presented only

for zoned host block devices. By adding zone management operations to the

host_block_device BlockDriver, users can use the new block layer APIs

including Report Zone and four zone management operations

(open, close, finish, reset, reset_all).

Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>

Acked-by: Kevin Wolf <kwolf@redhat.com>

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

Message-id: 20230508045533.175575-4-faithilikerun@gmail.com

Message-id: 20230324090605.28361-4-faithilikerun@gmail.com

[Adjust commit message prefix as suggested by Philippe Mathieu-Daudé

<philmd@linaro.org> and remove spurious ret = -errno in

raw_co_zone_mgmt().

--Stefan]

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>

meson.build | 5 +

include/block/block-io.h | 9 +

include/block/block_int-common.h | 21 ++

include/block/raw-aio.h | 6 +-

include/sysemu/block-backend-io.h | 18 ++

block/block-backend.c | 137 +++++++++++++

block/file-posix.c | 313 +++++++++++++++++++++++++++++-

block/io.c | 41 ++++

qemu-io-cmds.c | 149 ++++++++++++++

9 files changed, 696 insertions(+), 3 deletions(-)

diff --git a/meson.build b/meson.build

--- a/meson.build

+++ b/meson.build

@@ -XXX,XX +XXX,XX @@ if rdma.found()

endif

# has_header_symbol

+config_host_data.set('CONFIG_BLKZONED',

+ cc.has_header_symbol('linux/blkzoned.h', 'BLKOPENZONE'))

config_host_data.set('CONFIG_EPOLL_CREATE1',

cc.has_header_symbol('sys/epoll.h', 'epoll_create1'))

config_host_data.set('CONFIG_FALLOCATE_PUNCH_HOLE',

@@ -XXX,XX +XXX,XX @@ config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',

config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',

cc.has_member('struct stat', 'st_atim',

prefix: '#include <sys/stat.h>'))

+config_host_data.set('HAVE_BLK_ZONE_REP_CAPACITY',

+ cc.has_member('struct blk_zone', 'capacity',

+ prefix: '#include <linux/blkzoned.h>'))

# has_type

config_host_data.set('CONFIG_IOVEC',

diff --git a/include/block/block-io.h b/include/block/block-io.h

index XXXXXXX..XXXXXXX 100644

--- a/include/block/block-io.h

+++ b/include/block/block-io.h

@@ -XXX,XX +XXX,XX @@ int coroutine_fn GRAPH_RDLOCK bdrv_co_flush(BlockDriverState *bs);

int coroutine_fn GRAPH_RDLOCK bdrv_co_pdiscard(BdrvChild *child, int64_t offset,

int64_t bytes);

+/* Report zone information of zone block device. */

+int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_report(BlockDriverState *bs,

+ int64_t offset,

+ unsigned int *nr_zones,

+ BlockZoneDescriptor *zones);

+int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_mgmt(BlockDriverState *bs,

+ BlockZoneOp op,

+ int64_t offset, int64_t len);

+

bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);

int bdrv_block_status(BlockDriverState *bs, int64_t offset,

int64_t bytes, int64_t *pnum, int64_t *map,

diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h

index XXXXXXX..XXXXXXX 100644

--- a/include/block/block_int-common.h

+++ b/include/block/block_int-common.h

@@ -XXX,XX +XXX,XX @@ struct BlockDriver {

int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_load_vmstate)(

BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos);

+ int coroutine_fn (*bdrv_co_zone_report)(BlockDriverState *bs,

+ int64_t offset, unsigned int *nr_zones,

+ BlockZoneDescriptor *zones);

+ int coroutine_fn (*bdrv_co_zone_mgmt)(BlockDriverState *bs, BlockZoneOp op,

+ int64_t offset, int64_t len);

+

/* removable device specific */

bool coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_is_inserted)(

BlockDriverState *bs);

@@ -XXX,XX +XXX,XX @@ typedef struct BlockLimits {

/* device zone model */

BlockZoneModel zoned;

+

+ /* zone size expressed in bytes */

+ uint32_t zone_size;

+

+ /* total number of zones */

+ uint32_t nr_zones;

+

+ /* maximum sectors of a zone append write operation */

+ uint32_t max_append_sectors;

+

+ /* maximum number of open zones */

+ uint32_t max_open_zones;

+

+ /* maximum number of active zones */

+ uint32_t max_active_zones;

} BlockLimits;

typedef struct BdrvOpBlocker BdrvOpBlocker;

diff --git a/include/block/raw-aio.h b/include/block/raw-aio.h

index XXXXXXX..XXXXXXX 100644

--- a/include/block/raw-aio.h

+++ b/include/block/raw-aio.h

@@ -XXX,XX +XXX,XX @@

#define QEMU_AIO_WRITE_ZEROES 0x0020

#define QEMU_AIO_COPY_RANGE 0x0040

#define QEMU_AIO_TRUNCATE 0x0080

+#define QEMU_AIO_ZONE_REPORT 0x0100

+#define QEMU_AIO_ZONE_MGMT 0x0200

#define QEMU_AIO_TYPE_MASK \

(QEMU_AIO_READ | \

QEMU_AIO_WRITE | \

@@ -XXX,XX +XXX,XX @@

QEMU_AIO_DISCARD | \

QEMU_AIO_WRITE_ZEROES | \

QEMU_AIO_COPY_RANGE | \

- QEMU_AIO_TRUNCATE)

+ QEMU_AIO_TRUNCATE | \

+ QEMU_AIO_ZONE_REPORT | \

+ QEMU_AIO_ZONE_MGMT)

/* AIO flags */

#define QEMU_AIO_MISALIGNED 0x1000

diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h

index XXXXXXX..XXXXXXX 100644

--- a/include/sysemu/block-backend-io.h

+++ b/include/sysemu/block-backend-io.h

@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_aio_pwritev(BlockBackend *blk, int64_t offset,

BlockCompletionFunc *cb, void *opaque);

BlockAIOCB *blk_aio_flush(BlockBackend *blk,

BlockCompletionFunc *cb, void *opaque);

+BlockAIOCB *blk_aio_zone_report(BlockBackend *blk, int64_t offset,

+ unsigned int *nr_zones,

+ BlockZoneDescriptor *zones,

+ BlockCompletionFunc *cb, void *opaque);

+BlockAIOCB *blk_aio_zone_mgmt(BlockBackend *blk, BlockZoneOp op,

+ int64_t offset, int64_t len,

+ BlockCompletionFunc *cb, void *opaque);

BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes,

BlockCompletionFunc *cb, void *opaque);

void blk_aio_cancel_async(BlockAIOCB *acb);

@@ -XXX,XX +XXX,XX @@ int co_wrapper_mixed blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,

int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,

int64_t bytes, BdrvRequestFlags flags);

+int coroutine_fn blk_co_zone_report(BlockBackend *blk, int64_t offset,

+ unsigned int *nr_zones,

+ BlockZoneDescriptor *zones);

+int co_wrapper_mixed blk_zone_report(BlockBackend *blk, int64_t offset,

+ unsigned int *nr_zones,

+ BlockZoneDescriptor *zones);

+int coroutine_fn blk_co_zone_mgmt(BlockBackend *blk, BlockZoneOp op,

+ int64_t offset, int64_t len);

+int co_wrapper_mixed blk_zone_mgmt(BlockBackend *blk, BlockZoneOp op,

+ int64_t offset, int64_t len);

+

int co_wrapper_mixed blk_pdiscard(BlockBackend *blk, int64_t offset,

int64_t bytes);

int coroutine_fn blk_co_pdiscard(BlockBackend *blk, int64_t offset,

diff --git a/block/block-backend.c b/block/block-backend.c

index XXXXXXX..XXXXXXX 100644

--- a/block/block-backend.c

+++ b/block/block-backend.c

@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_flush(BlockBackend *blk)

return ret;

+static void coroutine_fn blk_aio_zone_report_entry(void *opaque)

+{

+ BlkAioEmAIOCB *acb = opaque;

+ BlkRwCo *rwco = &acb->rwco;

+

+ rwco->ret = blk_co_zone_report(rwco->blk, rwco->offset,

+ (unsigned int*)(uintptr_t)acb->bytes,

+ rwco->iobuf);

+ blk_aio_complete(acb);

+}

+

+BlockAIOCB *blk_aio_zone_report(BlockBackend *blk, int64_t offset,

+ unsigned int *nr_zones,

+ BlockZoneDescriptor *zones,

+ BlockCompletionFunc *cb, void *opaque)

+{

+ BlkAioEmAIOCB *acb;

+ Coroutine *co;

+ IO_CODE();

+

+ blk_inc_in_flight(blk);

+ acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);

+ acb->rwco = (BlkRwCo) {

+ .blk = blk,

+ .offset = offset,

+ .iobuf = zones,

+ .ret = NOT_DONE,

+ };

+ acb->bytes = (int64_t)(uintptr_t)nr_zones,

+ acb->has_returned = false;

+

+ co = qemu_coroutine_create(blk_aio_zone_report_entry, acb);

+ aio_co_enter(blk_get_aio_context(blk), co);

+

+ acb->has_returned = true;

+ if (acb->rwco.ret != NOT_DONE) {

+ replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),

+ blk_aio_complete_bh, acb);

+ }

+

+ return &acb->common;

+}

+

+static void coroutine_fn blk_aio_zone_mgmt_entry(void *opaque)

+{

+ BlkAioEmAIOCB *acb = opaque;

+ BlkRwCo *rwco = &acb->rwco;

+

+ rwco->ret = blk_co_zone_mgmt(rwco->blk,

+ (BlockZoneOp)(uintptr_t)rwco->iobuf,

+ rwco->offset, acb->bytes);

+ blk_aio_complete(acb);

+}

+

+BlockAIOCB *blk_aio_zone_mgmt(BlockBackend *blk, BlockZoneOp op,

+ int64_t offset, int64_t len,

+ BlockCompletionFunc *cb, void *opaque) {

+ BlkAioEmAIOCB *acb;

+ Coroutine *co;

+ IO_CODE();

+

+ blk_inc_in_flight(blk);

+ acb = blk_aio_get(&blk_aio_em_aiocb_info, blk, cb, opaque);

+ acb->rwco = (BlkRwCo) {

+ .blk = blk,

+ .offset = offset,

+ .iobuf = (void *)(uintptr_t)op,

+ .ret = NOT_DONE,

+ };

+ acb->bytes = len;

+ acb->has_returned = false;

+

+ co = qemu_coroutine_create(blk_aio_zone_mgmt_entry, acb);

+ aio_co_enter(blk_get_aio_context(blk), co);

+

+ acb->has_returned = true;

+ if (acb->rwco.ret != NOT_DONE) {

+ replay_bh_schedule_oneshot_event(blk_get_aio_context(blk),

+ blk_aio_complete_bh, acb);

+ }

+

+ return &acb->common;

+}

+

+/*

+ * Send a zone_report command.

+ * offset is a byte offset from the start of the device. No alignment

+ * required for offset.

+ * nr_zones represents IN maximum and OUT actual.

+ */

+int coroutine_fn blk_co_zone_report(BlockBackend *blk, int64_t offset,

+ unsigned int *nr_zones,

+ BlockZoneDescriptor *zones)

+{

+ int ret;

+ IO_CODE();

+

+ blk_inc_in_flight(blk); /* increase before waiting */

+ blk_wait_while_drained(blk);

+ GRAPH_RDLOCK_GUARD();

+ if (!blk_is_available(blk)) {

+ blk_dec_in_flight(blk);

+ return -ENOMEDIUM;

+ }

+ ret = bdrv_co_zone_report(blk_bs(blk), offset, nr_zones, zones);

+ blk_dec_in_flight(blk);

+/*

+ * Send a zone_management command.

+ * op is the zone operation;

+ * offset is the byte offset from the start of the zoned device;

+ * len is the maximum number of bytes the command should operate on. It

+ * should be aligned with the device zone size.

+ */

+int coroutine_fn blk_co_zone_mgmt(BlockBackend *blk, BlockZoneOp op,

+ int64_t offset, int64_t len)

+{

+ int ret;

+ IO_CODE();

+

+ blk_inc_in_flight(blk);

+ blk_wait_while_drained(blk);

+ GRAPH_RDLOCK_GUARD();

+

+ ret = blk_check_byte_request(blk, offset, len);

+ if (ret < 0) {

+ blk_dec_in_flight(blk);

+ return ret;

+ }

+

+ ret = bdrv_co_zone_mgmt(blk_bs(blk), op, offset, len);

+ blk_dec_in_flight(blk);

+ return ret;

+}

+

void blk_drain(BlockBackend *blk)

BlockDriverState *bs = blk_bs(blk);

diff --git a/block/file-posix.c b/block/file-posix.c

index XXXXXXX..XXXXXXX 100644

--- a/block/file-posix.c

+++ b/block/file-posix.c

@@ -XXX,XX +XXX,XX @@

#include <sys/param.h>

#include <sys/syscall.h>

#include <sys/vfs.h>

+#if defined(CONFIG_BLKZONED)

+#include <linux/blkzoned.h>

+#endif

#include <linux/cdrom.h>

#include <linux/fd.h>

#include <linux/fs.h>

@@ -XXX,XX +XXX,XX @@ typedef struct RawPosixAIOData {

PreallocMode prealloc;

Error **errp;

} truncate;

+ struct {

+ unsigned int *nr_zones;

+ BlockZoneDescriptor *zones;

+ } zone_report;

+ struct {

+ unsigned long op;

+ } zone_mgmt;

};

} RawPosixAIOData;

@@ -XXX,XX +XXX,XX @@ static int get_sysfs_str_val(struct stat *st, const char *attribute,

}

#endif

+#if defined(CONFIG_BLKZONED)

static int get_sysfs_zoned_model(struct stat *st, BlockZoneModel *zoned)

{

g_autofree char *val = NULL;

@@ -XXX,XX +XXX,XX @@ static int get_sysfs_zoned_model(struct stat *st, BlockZoneModel *zoned)

}

return 0;

}

+#endif /* defined(CONFIG_BLKZONED) */

/*

* Get a sysfs attribute value as a long integer.

@@ -XXX,XX +XXX,XX @@ static int hdev_get_max_segments(int fd, struct stat *st)

#endif

}

+#if defined(CONFIG_BLKZONED)

static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,

Error **errp)

{

@@ -XXX,XX +XXX,XX @@ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,

return;

}

bs->bl.zoned = zoned;

+

+ ret = get_sysfs_long_val(st, "max_open_zones");

+ if (ret >= 0) {

+ bs->bl.max_open_zones = ret;

+ }

+

+ ret = get_sysfs_long_val(st, "max_active_zones");

+ if (ret >= 0) {

+ bs->bl.max_active_zones = ret;

+ }

+

+ /*

+ * The zoned device must at least have zone size and nr_zones fields.

+ */

+ ret = get_sysfs_long_val(st, "chunk_sectors");

+ if (ret < 0) {

+ error_setg_errno(errp, -ret, "Unable to read chunk_sectors "

+ "sysfs attribute");

+ return;

+ } else if (!ret) {

+ error_setg(errp, "Read 0 from chunk_sectors sysfs attribute");

+ return;

+ }

+ bs->bl.zone_size = ret << BDRV_SECTOR_BITS;

+

+ ret = get_sysfs_long_val(st, "nr_zones");

+ if (ret < 0) {

+ error_setg_errno(errp, -ret, "Unable to read nr_zones "

+ "sysfs attribute");

+ return;

+ } else if (!ret) {

+ error_setg(errp, "Read 0 from nr_zones sysfs attribute");

+ return;

+ }

+ bs->bl.nr_zones = ret;

+

+ ret = get_sysfs_long_val(st, "zone_append_max_bytes");

+ if (ret > 0) {

+ bs->bl.max_append_sectors = ret >> BDRV_SECTOR_BITS;

+ }

}

+#else /* !defined(CONFIG_BLKZONED) */

+static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,

+ Error **errp)

+{

+ bs->bl.zoned = BLK_Z_NONE;

+}

+#endif /* !defined(CONFIG_BLKZONED) */

static void raw_refresh_limits(BlockDriverState *bs, Error **errp)

{

@@ -XXX,XX +XXX,XX @@ static int hdev_probe_blocksizes(BlockDriverState *bs, BlockSizes *bsz)

BDRVRawState *s = bs->opaque;

int ret;

- /* If DASD, get blocksizes */

+ /* If DASD or zoned devices, get blocksizes */

if (check_for_dasd(s->fd) < 0) {

- return -ENOTSUP;

+ /* zoned devices are not DASD */

+ if (bs->bl.zoned == BLK_Z_NONE) {

+ return -ENOTSUP;

+ }

}

ret = probe_logical_blocksize(s->fd, &bsz->log);

if (ret < 0) {

@@ -XXX,XX +XXX,XX @@ static off_t copy_file_range(int in_fd, off_t *in_off, int out_fd,

}

#endif

+/*

+ * parse_zone - Fill a zone descriptor

+ */

+#if defined(CONFIG_BLKZONED)

+static inline int parse_zone(struct BlockZoneDescriptor *zone,

+ const struct blk_zone *blkz) {

+ zone->start = blkz->start << BDRV_SECTOR_BITS;

+ zone->length = blkz->len << BDRV_SECTOR_BITS;

+ zone->wp = blkz->wp << BDRV_SECTOR_BITS;

+

+#ifdef HAVE_BLK_ZONE_REP_CAPACITY

+ zone->cap = blkz->capacity << BDRV_SECTOR_BITS;

+#else

+ zone->cap = blkz->len << BDRV_SECTOR_BITS;

+#endif

+

+ switch (blkz->type) {

+ case BLK_ZONE_TYPE_SEQWRITE_REQ:

+ zone->type = BLK_ZT_SWR;

+ break;

+ case BLK_ZONE_TYPE_SEQWRITE_PREF:

+ zone->type = BLK_ZT_SWP;

+ break;

+ case BLK_ZONE_TYPE_CONVENTIONAL:

+ zone->type = BLK_ZT_CONV;

+ break;

+ default:

+ error_report("Unsupported zone type: 0x%x", blkz->type);

+ return -ENOTSUP;

+ }

+

+ switch (blkz->cond) {

+ case BLK_ZONE_COND_NOT_WP:

+ zone->state = BLK_ZS_NOT_WP;

+ break;

+ case BLK_ZONE_COND_EMPTY:

+ zone->state = BLK_ZS_EMPTY;

+ break;

+ case BLK_ZONE_COND_IMP_OPEN:

+ zone->state = BLK_ZS_IOPEN;

+ break;

+ case BLK_ZONE_COND_EXP_OPEN:

+ zone->state = BLK_ZS_EOPEN;

+ break;

+ case BLK_ZONE_COND_CLOSED:

+ zone->state = BLK_ZS_CLOSED;

+ break;

+ case BLK_ZONE_COND_READONLY:

+ zone->state = BLK_ZS_RDONLY;

+ break;

+ case BLK_ZONE_COND_FULL:

+ zone->state = BLK_ZS_FULL;

+ break;

+ case BLK_ZONE_COND_OFFLINE:

+ zone->state = BLK_ZS_OFFLINE;

+ break;

+ default:

+ error_report("Unsupported zone state: 0x%x", blkz->cond);

+ return -ENOTSUP;

+ }

+ return 0;

+}

+#endif

+

+#if defined(CONFIG_BLKZONED)

+static int handle_aiocb_zone_report(void *opaque)

+{

+ RawPosixAIOData *aiocb = opaque;

+ int fd = aiocb->aio_fildes;

+ unsigned int *nr_zones = aiocb->zone_report.nr_zones;

+ BlockZoneDescriptor *zones = aiocb->zone_report.zones;

+ /* zoned block devices use 512-byte sectors */

+ uint64_t sector = aiocb->aio_offset / 512;

+

+ struct blk_zone *blkz;

+ size_t rep_size;

+ unsigned int nrz;

+ int ret;

+ unsigned int n = 0, i = 0;

+

+ nrz = *nr_zones;

+ 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, sector, errno);

+ return -errno;

+ }

+

+ if (!rep->nr_zones) {

+ break;

+ }

+

+ for (i = 0; i < rep->nr_zones; i++, n++) {

+ ret = parse_zone(&zones[n], &blkz[i]);

+ if (ret != 0) {

+ return ret;

+ }

+

+ /* The next report should start after the last zone reported */

+ sector = blkz[i].start + blkz[i].len;

+ }

+ }

+

+ *nr_zones = n;

+ return 0;

+}

+#endif

+

+#if defined(CONFIG_BLKZONED)

+static int handle_aiocb_zone_mgmt(void *opaque)

+{

+ RawPosixAIOData *aiocb = opaque;

+ int fd = aiocb->aio_fildes;

+ uint64_t sector = aiocb->aio_offset / 512;

+ int64_t nr_sectors = aiocb->aio_nbytes / 512;

+ struct blk_zone_range range;

+ int ret;

+

+ /* Execute the operation */

+ range.sector = sector;

+ range.nr_sectors = nr_sectors;

+ do {

+ ret = ioctl(fd, aiocb->zone_mgmt.op, &range);

+ } while (ret != 0 && errno == EINTR);

+

+ return ret;

+}

+#endif

+

static int handle_aiocb_copy_range(void *opaque)

{

RawPosixAIOData *aiocb = opaque;

@@ -XXX,XX +XXX,XX @@ static void raw_account_discard(BDRVRawState *s, uint64_t nbytes, int ret)

}

}

+/*

+ * zone report - Get a zone block device's information in the form

+ * of an array of zone descriptors.

+ * zones is an array of zone descriptors to hold zone information on reply;

+ * offset can be any byte within the entire size of the device;

+ * nr_zones is the maxium number of sectors the command should operate on.

+ */

+#if defined(CONFIG_BLKZONED)

+static int coroutine_fn raw_co_zone_report(BlockDriverState *bs, int64_t offset,

+ unsigned int *nr_zones,

+ BlockZoneDescriptor *zones) {

+ BDRVRawState *s = bs->opaque;

+ RawPosixAIOData acb = (RawPosixAIOData) {

+ .bs = bs,

+ .aio_fildes = s->fd,

+ .aio_type = QEMU_AIO_ZONE_REPORT,

+ .aio_offset = offset,

+ .zone_report = {

+ .nr_zones = nr_zones,

+ .zones = zones,

+ },

+ };

+

+ return raw_thread_pool_submit(handle_aiocb_zone_report, &acb);

+}

+#endif

+

+/*

+ * zone management operations - Execute an operation on a zone

+ */

+#if defined(CONFIG_BLKZONED)

+static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,

+ int64_t offset, int64_t len) {

+ BDRVRawState *s = bs->opaque;

+ RawPosixAIOData acb;

+ int64_t zone_size, zone_size_mask;

+ const char *op_name;

+ unsigned long zo;

+ int ret;

+ int64_t capacity = bs->total_sectors << BDRV_SECTOR_BITS;

+

+ zone_size = bs->bl.zone_size;

+ zone_size_mask = zone_size - 1;

+ if (offset & zone_size_mask) {

+ error_report("sector offset %" PRId64 " is not aligned to zone size "

+ "%" PRId64 "", offset / 512, zone_size / 512);

+ return -EINVAL;

+ }

+

+ if (((offset + len) < capacity && len & zone_size_mask) ||

+ offset + len > capacity) {

+ error_report("number of sectors %" PRId64 " is not aligned to zone size"

+ " %" PRId64 "", len / 512, zone_size / 512);

+ return -EINVAL;

+ }

+

+ switch (op) {

+ case BLK_ZO_OPEN:

+ op_name = "BLKOPENZONE";

+ zo = BLKOPENZONE;

+ break;

+ case BLK_ZO_CLOSE:

+ op_name = "BLKCLOSEZONE";

+ zo = BLKCLOSEZONE;

+ break;

+ case BLK_ZO_FINISH:

+ op_name = "BLKFINISHZONE";

+ zo = BLKFINISHZONE;

+ break;

+ case BLK_ZO_RESET:

+ op_name = "BLKRESETZONE";

+ zo = BLKRESETZONE;

+ break;

+ default:

+ error_report("Unsupported zone op: 0x%x", op);

+ return -ENOTSUP;

+ }

+

+ acb = (RawPosixAIOData) {

+ .bs = bs,

+ .aio_fildes = s->fd,

+ .aio_type = QEMU_AIO_ZONE_MGMT,

+ .aio_offset = offset,

+ .aio_nbytes = len,

+ .zone_mgmt = {

+ .op = zo,

+ },

+ };

+

+ ret = raw_thread_pool_submit(handle_aiocb_zone_mgmt, &acb);

+ if (ret != 0) {

+ error_report("ioctl %s failed %d", op_name, ret);

+ }

+

+ return ret;

+}

+#endif

+

static coroutine_fn int

raw_do_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes,

bool blkdev)

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_device = {

#ifdef __linux__

.bdrv_co_ioctl = hdev_co_ioctl,

#endif

+

+ /* zoned device */

+#if defined(CONFIG_BLKZONED)

+ /* zone management operations */

+ .bdrv_co_zone_report = raw_co_zone_report,

+ .bdrv_co_zone_mgmt = raw_co_zone_mgmt,

+#endif

};

#if defined(__linux__) || defined(__FreeBSD__) || defined(__FreeBSD_kernel__)

diff --git a/block/io.c b/block/io.c

index XXXXXXX..XXXXXXX 100644