Series comparison

-[PULL 0/6] Block patches
+[PULL 00/17] Block patches
-The following changes since commit 91f5f7a5df1fda8c34677a7c49ee8a4bb5b56a36:
+The following changes since commit 05d50ba2d4668d43a835c5a502efdec9b92646e6:
-  Merge remote-tracking branch 'remotes/lvivier-gitlab/tags/linux-user-for-7.0-pull-request' into staging (2022-01-12 11:51:47 +0000)
+  Merge tag 'migration-20230427-pull-request' of https://gitlab.com/juan.quintela/qemu into staging (2023-04-28 08:35:06 +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 db608fb78444c58896db69495729e4458eeaace1:
+for you to fetch changes up to d3c760be786571d83d5cea01953e543df4d76f51:
-  virtio: unify dataplane and non-dataplane ->handle_output() (2022-01-12 17:09:39 +0000)
+  docs/zoned-storage:add zoned emulation use case (2023-04-28 08:34:07 -0400)
 ----------------------------------------------------------------
 Pull request
+This pull request contains Sam Li's virtio-blk zoned storage work. These
+patches were dropped from my previous block pull request due to CI failures.
 ----------------------------------------------------------------
-Stefan Hajnoczi (6):
+Sam Li (17):
-  aio-posix: split poll check from ready handler
+  block/block-common: add zoned device structs
-  virtio: get rid of VirtIOHandleAIOOutput
+  block/file-posix: introduce helper functions for sysfs attributes
-  virtio-blk: drop unused virtio_blk_handle_vq() return value
+  block/block-backend: add block layer APIs resembling Linux
-  virtio-scsi: prepare virtio_scsi_handle_cmd for dataplane
+    ZonedBlockDevice ioctls
-  virtio: use ->handle_output() instead of ->handle_aio_output()
+  block/raw-format: add zone operations to pass through requests
-  virtio: unify dataplane and non-dataplane ->handle_output()
+  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
   include: update virtio_blk headers to v6.3-rc1
   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
- include/block/aio.h             |  4 +-
+ docs/devel/index-api.rst                     |   1 +
- include/hw/virtio/virtio-blk.h  |  2 +-
+ docs/devel/zoned-storage.rst                 |  62 ++
- include/hw/virtio/virtio.h      |  5 +-
+ qapi/block-core.json                         |  68 +-
- util/aio-posix.h                |  1 +
+ qapi/block.json                              |   4 +
- block/curl.c                    | 11 ++--
+ meson.build                                  |   4 +
- block/export/fuse.c             |  4 +-
+ include/block/accounting.h                   |   1 +
- block/io_uring.c                | 19 ++++---
+ include/block/block-common.h                 |  57 ++
- block/iscsi.c                   |  4 +-
+ include/block/block-io.h                     |  13 +
- block/linux-aio.c               | 16 +++---
+ include/block/block_int-common.h             |  37 +
- block/nfs.c                     |  6 +--
+ include/block/raw-aio.h                      |   8 +-
- block/nvme.c                    | 51 ++++++++++++-------
+ include/standard-headers/drm/drm_fourcc.h    |  12 +
- block/ssh.c                     |  4 +-
+ include/standard-headers/linux/ethtool.h     |  48 +-
- block/win32-aio.c               |  4 +-
+ include/standard-headers/linux/fuse.h        |  45 +-
- hw/block/dataplane/virtio-blk.c | 16 +-----
+ include/standard-headers/linux/pci_regs.h    |   1 +
- hw/block/virtio-blk.c           | 14 ++----
+ include/standard-headers/linux/vhost_types.h |   2 +
- hw/scsi/virtio-scsi-dataplane.c | 60 +++-------------------
+ include/standard-headers/linux/virtio_blk.h  | 105 +++
- hw/scsi/virtio-scsi.c           |  2 +-
+ include/sysemu/block-backend-io.h            |  27 +
- hw/virtio/virtio.c              | 73 +++++++++------------------
+ linux-headers/asm-arm64/kvm.h                |   1 +
- hw/xen/xen-bus.c                |  6 +--
+ linux-headers/asm-x86/kvm.h                  |  34 +-
- io/channel-command.c            |  6 ++-
+ linux-headers/linux/kvm.h                    |   9 +
- io/channel-file.c               |  3 +-
+ linux-headers/linux/vfio.h                   |  15 +-
- io/channel-socket.c             |  3 +-
+ linux-headers/linux/vhost.h                  |   8 +
- migration/rdma.c                |  8 +--
+ block.c                                      |  19 +
- tests/unit/test-aio.c           |  4 +-
+ block/block-backend.c                        | 198 ++++++
- tests/unit/test-fdmon-epoll.c   |  4 +-
+ block/file-posix.c                           | 696 +++++++++++++++++--
- util/aio-posix.c                | 89 +++++++++++++++++++++++++--------
+ block/io.c                                   |  68 ++
- util/aio-win32.c                |  4 +-
+ block/io_uring.c                             |   4 +
- util/async.c                    | 10 +++-
+ block/linux-aio.c                            |   3 +
- util/main-loop.c                |  4 +-
+ block/qapi-sysemu.c                          |  11 +
- util/qemu-coroutine-io.c        |  5 +-
+ block/qapi.c                                 |  18 +
- util/vhost-user-server.c        | 11 ++--
+ block/raw-format.c                           |  26 +
-files changed, 221 insertions(+), 232 deletions(-)
+ 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/tests/zoned               | 105 +++
  tests/qemu-iotests/tests/zoned.out           |  69 ++
 files changed, 2361 insertions(+), 68 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
 --
-.34.1
+.40.0

-New patch
+[PULL 01/17] block/block-common: add zoned device structs
+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: 20230427172019.3345-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 ++++++++++++++++++++++++++++++++++++
+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;
+--
+.40.0

-[PULL 2/6] virtio: get rid of VirtIOHandleAIOOutput
+[PULL 02/17] block/file-posix: introduce helper functions for sysfs attributes
-The virtqueue host notifier API
+From: Sam Li <faithilikerun@gmail.com>
-virtio_queue_aio_set_host_notifier_handler() polls the virtqueue for new
-buffers. AioContext previously required a bool progress return value
+Use get_sysfs_str_val() to get the string value of device
-indicating whether an event was handled or not. This is no longer
+zoned model. Then get_sysfs_zoned_model() can convert it to
-necessary because the AioContext polling API has been split into a poll
+BlockZoneModel type of QEMU.
-check function and an event handler function. The event handler is only
-run when we know there is work to do, so it doesn't return bool.
+Use get_sysfs_long_val() to get the long value of zoned device
+information.
-The VirtIOHandleAIOOutput function signature is now the same as
-VirtIOHandleOutput. Get rid of the bool return value.
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Reviewed-by: Hannes Reinecke <hare@suse.de>
-Further simplifications will be made for virtio-blk and virtio-scsi in
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-the next patch.
+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>
-Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
+Message-id: 20230427172019.3345-3-faithilikerun@gmail.com
-Message-id: 20211207132336.36627-3-stefanha@redhat.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/hw/virtio/virtio.h      |  3 +--
+ include/block/block_int-common.h |   3 +
- hw/block/dataplane/virtio-blk.c |  4 ++--
+ block/file-posix.c               | 139 ++++++++++++++++++++++---------
- hw/scsi/virtio-scsi-dataplane.c | 18 ++++++------------
+files changed, 104 insertions(+), 38 deletions(-)
- hw/virtio/virtio.c              | 12 ++++--------
-files changed, 13 insertions(+), 24 deletions(-)
+diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
 diff --git a/include/hw/virtio/virtio.h b/include/hw/virtio/virtio.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/hw/virtio/virtio.h
+--- a/include/block/block_int-common.h
-+++ b/include/hw/virtio/virtio.h
++++ b/include/block/block_int-common.h
-@@ -XXX,XX +XXX,XX @@ void virtio_error(VirtIODevice *vdev, const char *fmt, ...) GCC_FMT_ATTR(2, 3);
+@@ -XXX,XX +XXX,XX @@ typedef struct BlockLimits {
- void virtio_device_set_child_bus_name(VirtIODevice *vdev, char *bus_name);
+      * an explicit monitor command to load the disk inside the guest).
+      */
- typedef void (*VirtIOHandleOutput)(VirtIODevice *, VirtQueue *);
+     bool has_variable_length;
--typedef bool (*VirtIOHandleAIOOutput)(VirtIODevice *, VirtQueue *);
++
++    /* device zone model */
- VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
++    BlockZoneModel zoned;
-                             VirtIOHandleOutput handle_output);
+ } BlockLimits;
-@@ -XXX,XX +XXX,XX @@ EventNotifier *virtio_queue_get_host_notifier(VirtQueue *vq);
- void virtio_queue_set_host_notifier_enabled(VirtQueue *vq, bool enabled);
+ typedef struct BdrvOpBlocker BdrvOpBlocker;
- void virtio_queue_host_notifier_read(EventNotifier *n);
+diff --git a/block/file-posix.c b/block/file-posix.c
  void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
 -                                                VirtIOHandleAIOOutput handle_output);
 +        VirtIOHandleOutput handle_output);
  VirtQueue *virtio_vector_first_queue(VirtIODevice *vdev, uint16_t vector);
  VirtQueue *virtio_vector_next_queue(VirtQueue *vq);
 diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/dataplane/virtio-blk.c
+--- a/block/file-posix.c
-+++ b/hw/block/dataplane/virtio-blk.c
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
+@@ -XXX,XX +XXX,XX @@ static int hdev_get_max_hw_transfer(int fd, struct stat *st)
-     g_free(s);
+ #endif
  }
--static bool virtio_blk_data_plane_handle_output(VirtIODevice *vdev,
+-static int hdev_get_max_segments(int fd, struct stat *st)
-+static void virtio_blk_data_plane_handle_output(VirtIODevice *vdev,
++/*
-                                                 VirtQueue *vq)
++ * Get a sysfs attribute value as character string.
 + */
 +static int get_sysfs_str_val(struct stat *st, const char *attribute,
 +                             char **val) {
 +#ifdef CONFIG_LINUX
 +    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;
 +#else
 +    return -ENOTSUP;
 +#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 (ret < 0) {
 +        return ret;
 +    }
 +
 +    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.
 + */
 +static long get_sysfs_long_val(struct stat *st, const char *attribute)
  {
-     VirtIOBlock *s = (VirtIOBlock *)vdev;
+ #ifdef CONFIG_LINUX
-@@ -XXX,XX +XXX,XX @@ static bool virtio_blk_data_plane_handle_output(VirtIODevice *vdev,
+-    char buf[32];
-     assert(s->dataplane);
++    g_autofree char *str = NULL;
-     assert(s->dataplane_started);
+     const char *end;
+-    char *sysfspath = NULL;
--    return virtio_blk_handle_vq(s, vq);
++    long val;
-+    virtio_blk_handle_vq(s, vq);
++    int ret;
 +
 +    ret = get_sysfs_str_val(st, attribute, &str);
 +    if (ret < 0) {
 +        return ret;
 +    }
 +
 +    /* 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;
 +#else
 +    return -ENOTSUP;
 +#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
  }
- /* Context: QEMU global mutex held */
++static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
-diff --git a/hw/scsi/virtio-scsi-dataplane.c b/hw/scsi/virtio-scsi-dataplane.c
++                                     Error **errp)
-index XXXXXXX..XXXXXXX 100644
++{
---- a/hw/scsi/virtio-scsi-dataplane.c
++    BlockZoneModel zoned;
-+++ b/hw/scsi/virtio-scsi-dataplane.c
++    int ret;
-@@ -XXX,XX +XXX,XX @@ void virtio_scsi_dataplane_setup(VirtIOSCSI *s, Error **errp)
++
-     }
++    bs->bl.zoned = BLK_Z_NONE;
- }
++
++    ret = get_sysfs_zoned_model(st, &zoned);
--static bool virtio_scsi_data_plane_handle_cmd(VirtIODevice *vdev,
++    if (ret < 0 || zoned == BLK_Z_NONE) {
-+static void virtio_scsi_data_plane_handle_cmd(VirtIODevice *vdev,
++        return;
-                                               VirtQueue *vq)
++    }
 +    bs->bl.zoned = zoned;
 +}
 +
  static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
  {
--    bool progress = false;
+     BDRVRawState *s = bs->opaque;
-     VirtIOSCSI *s = VIRTIO_SCSI(vdev);
+@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
+             bs->bl.max_hw_iov = ret;
      virtio_scsi_acquire(s);
      if (!s->dataplane_fenced) {
          assert(s->ctx && s->dataplane_started);
 -        progress = virtio_scsi_handle_cmd_vq(s, vq);
 +        virtio_scsi_handle_cmd_vq(s, vq);
      }
      virtio_scsi_release(s);
 -    return progress;
  }
 -static bool virtio_scsi_data_plane_handle_ctrl(VirtIODevice *vdev,
 +static void virtio_scsi_data_plane_handle_ctrl(VirtIODevice *vdev,
                                                 VirtQueue *vq)
  {
 -    bool progress = false;
      VirtIOSCSI *s = VIRTIO_SCSI(vdev);
      virtio_scsi_acquire(s);
      if (!s->dataplane_fenced) {
          assert(s->ctx && s->dataplane_started);
 -        progress = virtio_scsi_handle_ctrl_vq(s, vq);
 +        virtio_scsi_handle_ctrl_vq(s, vq);
      }
      virtio_scsi_release(s);
 -    return progress;
  }
 -static bool virtio_scsi_data_plane_handle_event(VirtIODevice *vdev,
 +static void virtio_scsi_data_plane_handle_event(VirtIODevice *vdev,
                                                  VirtQueue *vq)
  {
 -    bool progress = false;
      VirtIOSCSI *s = VIRTIO_SCSI(vdev);
      virtio_scsi_acquire(s);
      if (!s->dataplane_fenced) {
          assert(s->ctx && s->dataplane_started);
 -        progress = virtio_scsi_handle_event_vq(s, vq);
 +        virtio_scsi_handle_event_vq(s, vq);
      }
      virtio_scsi_release(s);
 -    return progress;
  }
  static int virtio_scsi_set_host_notifier(VirtIOSCSI *s, VirtQueue *vq, int n)
 diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/virtio/virtio.c
 +++ b/hw/virtio/virtio.c
@@ -XXX,XX +XXX,XX @@ struct VirtQueue
      uint16_t vector;
      VirtIOHandleOutput handle_output;
 -    VirtIOHandleAIOOutput handle_aio_output;
 +    VirtIOHandleOutput handle_aio_output;
      VirtIODevice *vdev;
      EventNotifier guest_notifier;
      EventNotifier host_notifier;
@@ -XXX,XX +XXX,XX @@ void virtio_queue_set_align(VirtIODevice *vdev, int n, int align)
      }
  }
 -static bool virtio_queue_notify_aio_vq(VirtQueue *vq)
 +static void virtio_queue_notify_aio_vq(VirtQueue *vq)
  {
 -    bool ret = false;
 -
      if (vq->vring.desc && vq->handle_aio_output) {
          VirtIODevice *vdev = vq->vdev;
          trace_virtio_queue_notify(vdev, vq - vdev->vq, vq);
 -        ret = vq->handle_aio_output(vdev, vq);
 +        vq->handle_aio_output(vdev, vq);
          if (unlikely(vdev->start_on_kick)) {
              virtio_set_started(vdev, true);
          }
      }
--
++
--    return ret;
++    raw_refresh_zoned_limits(bs, &st, errp);
  }
- static void virtio_queue_notify_vq(VirtQueue *vq)
+ static int check_for_dasd(int fd)
@@ -XXX,XX +XXX,XX @@ static void virtio_queue_host_notifier_aio_poll_end(EventNotifier *n)
  }
  void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
 -                                                VirtIOHandleAIOOutput handle_output)
 +        VirtIOHandleOutput handle_output)
  {
      if (handle_output) {
          vq->handle_aio_output = handle_output;
 --
-.34.1
+.40.0

-[PULL 6/6] virtio: unify dataplane and non-dataplane ->handle_output()
+[PULL 03/17] block/block-backend: add block layer APIs resembling Linux ZonedBlockDevice ioctls
-Now that virtio-blk and virtio-scsi are ready, get rid of
+From: Sam Li <faithilikerun@gmail.com>
 the handle_aio_output() callback. It's no longer needed.
+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).
+Qemu-io uses the new APIs to perform zoned storage commands of the device:
+zone_report(zrp), zone_open(zo), zone_close(zc), zone_reset(zrs),
+zone_finish(zf).
+For example, to test zone_report, use following command:
+$ ./build/qemu-io --image-opts -n driver=host_device, filename=/dev/nullb0
+-c "zrp offset nr_zones"
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Reviewed-by: Hannes Reinecke <hare@suse.de>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
+Acked-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
+Message-id: 20230427172019.3345-4-faithilikerun@gmail.com
-Message-id: 20211207132336.36627-7-stefanha@redhat.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>
 ---
- include/hw/virtio/virtio.h      |  4 +--
+ meson.build                       |   4 +
- hw/block/dataplane/virtio-blk.c | 16 ++--------
+ include/block/block-io.h          |   9 +
- hw/scsi/virtio-scsi-dataplane.c | 54 ++++-----------------------------
+ include/block/block_int-common.h  |  21 ++
- hw/virtio/virtio.c              | 32 +++++++++----------
+ include/block/raw-aio.h           |   6 +-
-files changed, 26 insertions(+), 80 deletions(-)
+ 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 ++++++++++++++
 files changed, 695 insertions(+), 3 deletions(-)
-diff --git a/include/hw/virtio/virtio.h b/include/hw/virtio/virtio.h
+diff --git a/meson.build b/meson.build
 index XXXXXXX..XXXXXXX 100644
---- a/include/hw/virtio/virtio.h
+--- a/meson.build
-+++ b/include/hw/virtio/virtio.h
++++ b/meson.build
-@@ -XXX,XX +XXX,XX @@ bool virtio_device_ioeventfd_enabled(VirtIODevice *vdev);
+@@ -XXX,XX +XXX,XX @@ config_host_data.set('CONFIG_REPLICATION', get_option('replication').allowed())
- EventNotifier *virtio_queue_get_host_notifier(VirtQueue *vq);
+ # has_header
- void virtio_queue_set_host_notifier_enabled(VirtQueue *vq, bool enabled);
+ config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
- void virtio_queue_host_notifier_read(EventNotifier *n);
+ config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
--void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
++config_host_data.set('CONFIG_BLKZONED', cc.has_header('linux/blkzoned.h'))
--        VirtIOHandleOutput handle_output);
+ config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
-+void virtio_queue_aio_attach_host_notifier(VirtQueue *vq, AioContext *ctx);
+ config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
-+void virtio_queue_aio_detach_host_notifier(VirtQueue *vq, AioContext *ctx);
+ config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
- VirtQueue *virtio_vector_first_queue(VirtIODevice *vdev, uint16_t vector);
+@@ -XXX,XX +XXX,XX @@ config_host_data.set('HAVE_SIGEV_NOTIFY_THREAD_ID',
- VirtQueue *virtio_vector_next_queue(VirtQueue *vq);
+ config_host_data.set('HAVE_STRUCT_STAT_ST_ATIM',
+                      cc.has_member('struct stat', 'st_atim',
-diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c
+                                    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/hw/block/dataplane/virtio-blk.c
+--- a/include/block/block-io.h
-+++ b/hw/block/dataplane/virtio-blk.c
++++ b/include/block/block-io.h
-@@ -XXX,XX +XXX,XX @@ void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn GRAPH_RDLOCK bdrv_co_flush(BlockDriverState *bs);
-     g_free(s);
+ 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 */
 +    int64_t max_append_sectors;
 +
 +    /* maximum number of open zones */
 +    int64_t max_open_zones;
 +
 +    /* maximum number of active zones */
 +    int64_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 virtio_blk_data_plane_handle_output(VirtIODevice *vdev,
++static void coroutine_fn blk_aio_zone_report_entry(void *opaque)
--                                                VirtQueue *vq)
++{
--{
++    BlkAioEmAIOCB *acb = opaque;
--    VirtIOBlock *s = (VirtIOBlock *)vdev;
++    BlkRwCo *rwco = &acb->rwco;
--
++
--    assert(s->dataplane);
++    rwco->ret = blk_co_zone_report(rwco->blk, rwco->offset,
--    assert(s->dataplane_started);
++                                   (unsigned int*)(uintptr_t)acb->bytes,
--
++                                   rwco->iobuf);
--    virtio_blk_handle_vq(s, vq);
++    blk_aio_complete(acb);
--}
++}
--
++
- /* Context: QEMU global mutex held */
++BlockAIOCB *blk_aio_zone_report(BlockBackend *blk, int64_t offset,
- int virtio_blk_data_plane_start(VirtIODevice *vdev)
++                                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);
 +    return ret;
 +}
 +
 +/*
 + * 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)
  {
-@@ -XXX,XX +XXX,XX @@ int virtio_blk_data_plane_start(VirtIODevice *vdev)
+     BlockDriverState *bs = blk_bs(blk);
-     for (i = 0; i < nvqs; i++) {
+diff --git a/block/file-posix.c b/block/file-posix.c
-         VirtQueue *vq = virtio_get_queue(s->vdev, i);
+index XXXXXXX..XXXXXXX 100644
+--- a/block/file-posix.c
--        virtio_queue_aio_set_host_notifier_handler(vq, s->ctx,
++++ b/block/file-posix.c
--                virtio_blk_data_plane_handle_output);
+@@ -XXX,XX +XXX,XX @@
-+        virtio_queue_aio_attach_host_notifier(vq, s->ctx);
+ #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)
      }
-     aio_context_release(s->ctx);
      return 0;
-@@ -XXX,XX +XXX,XX @@ static void virtio_blk_data_plane_stop_bh(void *opaque)
+ }
-     for (i = 0; i < s->conf->num_queues; i++) {
++#endif /* defined(CONFIG_BLKZONED) */
-         VirtQueue *vq = virtio_get_queue(s->vdev, i);
+ /*
--        virtio_queue_aio_set_host_notifier_handler(vq, s->ctx, NULL);
+  * Get a sysfs attribute value as a long integer.
-+        virtio_queue_aio_detach_host_notifier(vq, s->ctx);
+@@ -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)
      }
  }
-diff --git a/hw/scsi/virtio-scsi-dataplane.c b/hw/scsi/virtio-scsi-dataplane.c
++/*
 + * 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
---- a/hw/scsi/virtio-scsi-dataplane.c
+--- a/block/io.c
-+++ b/hw/scsi/virtio-scsi-dataplane.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ void virtio_scsi_dataplane_setup(VirtIOSCSI *s, Error **errp)
+@@ -XXX,XX +XXX,XX @@ out:
-     }
+     return co.ret;
  }
--static void virtio_scsi_data_plane_handle_cmd(VirtIODevice *vdev,
++int coroutine_fn bdrv_co_zone_report(BlockDriverState *bs, int64_t offset,
--                                              VirtQueue *vq)
++                        unsigned int *nr_zones,
--{
++                        BlockZoneDescriptor *zones)
--    VirtIOSCSI *s = VIRTIO_SCSI(vdev);
++{
--
++    BlockDriver *drv = bs->drv;
--    virtio_scsi_acquire(s);
++    CoroutineIOCompletion co = {
--    if (!s->dataplane_fenced) {
++            .coroutine = qemu_coroutine_self(),
--        assert(s->ctx && s->dataplane_started);
++    };
--        virtio_scsi_handle_cmd_vq(s, vq);
++    IO_CODE();
--    }
++
--    virtio_scsi_release(s);
++    bdrv_inc_in_flight(bs);
--}
++    if (!drv || !drv->bdrv_co_zone_report || bs->bl.zoned == BLK_Z_NONE) {
--
++        co.ret = -ENOTSUP;
--static void virtio_scsi_data_plane_handle_ctrl(VirtIODevice *vdev,
++        goto out;
--                                               VirtQueue *vq)
++    }
--{
++    co.ret = drv->bdrv_co_zone_report(bs, offset, nr_zones, zones);
--    VirtIOSCSI *s = VIRTIO_SCSI(vdev);
++out:
--
++    bdrv_dec_in_flight(bs);
--    virtio_scsi_acquire(s);
++    return co.ret;
--    if (!s->dataplane_fenced) {
++}
--        assert(s->ctx && s->dataplane_started);
++
--        virtio_scsi_handle_ctrl_vq(s, vq);
++int coroutine_fn bdrv_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
--    }
++        int64_t offset, int64_t len)
--    virtio_scsi_release(s);
++{
--}
++    BlockDriver *drv = bs->drv;
--
++    CoroutineIOCompletion co = {
--static void virtio_scsi_data_plane_handle_event(VirtIODevice *vdev,
++            .coroutine = qemu_coroutine_self(),
--                                                VirtQueue *vq)
++    };
--{
++    IO_CODE();
--    VirtIOSCSI *s = VIRTIO_SCSI(vdev);
++
--
++    bdrv_inc_in_flight(bs);
--    virtio_scsi_acquire(s);
++    if (!drv || !drv->bdrv_co_zone_mgmt || bs->bl.zoned == BLK_Z_NONE) {
--    if (!s->dataplane_fenced) {
++        co.ret = -ENOTSUP;
--        assert(s->ctx && s->dataplane_started);
++        goto out;
--        virtio_scsi_handle_event_vq(s, vq);
++    }
--    }
++    co.ret = drv->bdrv_co_zone_mgmt(bs, op, offset, len);
--    virtio_scsi_release(s);
++out:
--}
++    bdrv_dec_in_flight(bs);
--
++    return co.ret;
- static int virtio_scsi_set_host_notifier(VirtIOSCSI *s, VirtQueue *vq, int n)
++}
 +
  void *qemu_blockalign(BlockDriverState *bs, size_t size)
  {
-     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));
+     IO_CODE();
-@@ -XXX,XX +XXX,XX @@ static void virtio_scsi_dataplane_stop_bh(void *opaque)
+diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
      VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
      int i;
 -    virtio_queue_aio_set_host_notifier_handler(vs->ctrl_vq, s->ctx, NULL);
 -    virtio_queue_aio_set_host_notifier_handler(vs->event_vq, s->ctx, NULL);
 +    virtio_queue_aio_detach_host_notifier(vs->ctrl_vq, s->ctx);
 +    virtio_queue_aio_detach_host_notifier(vs->event_vq, s->ctx);
      for (i = 0; i < vs->conf.num_queues; i++) {
 -        virtio_queue_aio_set_host_notifier_handler(vs->cmd_vqs[i], s->ctx, NULL);
 +        virtio_queue_aio_detach_host_notifier(vs->cmd_vqs[i], s->ctx);
      }
  }
@@ -XXX,XX +XXX,XX @@ int virtio_scsi_dataplane_start(VirtIODevice *vdev)
      memory_region_transaction_commit();
      aio_context_acquire(s->ctx);
 -    virtio_queue_aio_set_host_notifier_handler(vs->ctrl_vq, s->ctx,
 -                                            virtio_scsi_data_plane_handle_ctrl);
 -    virtio_queue_aio_set_host_notifier_handler(vs->event_vq, s->ctx,
 -                                           virtio_scsi_data_plane_handle_event);
 +    virtio_queue_aio_attach_host_notifier(vs->ctrl_vq, s->ctx);
 +    virtio_queue_aio_attach_host_notifier(vs->event_vq, s->ctx);
      for (i = 0; i < vs->conf.num_queues; i++) {
 -        virtio_queue_aio_set_host_notifier_handler(vs->cmd_vqs[i], s->ctx,
 -                                             virtio_scsi_data_plane_handle_cmd);
 +        virtio_queue_aio_attach_host_notifier(vs->cmd_vqs[i], s->ctx);
      }
      s->dataplane_starting = false;
 diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/virtio/virtio.c
+--- a/qemu-io-cmds.c
-+++ b/hw/virtio/virtio.c
++++ b/qemu-io-cmds.c
-@@ -XXX,XX +XXX,XX @@ static void virtio_queue_host_notifier_aio_poll_end(EventNotifier *n)
+@@ -XXX,XX +XXX,XX @@ static const cmdinfo_t flush_cmd = {
-     virtio_queue_set_notification(vq, 1);
+     .oneline    = "flush all in-core file state to disk",
- }
+ };
--void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
++static inline int64_t tosector(int64_t bytes)
--        VirtIOHandleOutput handle_output)
++{
-+void virtio_queue_aio_attach_host_notifier(VirtQueue *vq, AioContext *ctx)
++    return bytes >> BDRV_SECTOR_BITS;
- {
++}
--    if (handle_output) {
++
--        aio_set_event_notifier(ctx, &vq->host_notifier, true,
++static int zone_report_f(BlockBackend *blk, int argc, char **argv)
--                               virtio_queue_host_notifier_read,
++{
--                               virtio_queue_host_notifier_aio_poll,
++    int ret;
--                               virtio_queue_host_notifier_aio_poll_ready);
++    int64_t offset;
--        aio_set_event_notifier_poll(ctx, &vq->host_notifier,
++    unsigned int nr_zones;
--                                    virtio_queue_host_notifier_aio_poll_begin,
++
--                                    virtio_queue_host_notifier_aio_poll_end);
++    ++optind;
--    } else {
++    offset = cvtnum(argv[optind]);
--        aio_set_event_notifier(ctx, &vq->host_notifier, true, NULL, NULL, NULL);
++    ++optind;
--        /* Test and clear notifier before after disabling event,
++    nr_zones = cvtnum(argv[optind]);
--         * in case poll callback didn't have time to run. */
++
--        virtio_queue_host_notifier_read(&vq->host_notifier);
++    g_autofree BlockZoneDescriptor *zones = NULL;
--    }
++    zones = g_new(BlockZoneDescriptor, nr_zones);
-+    aio_set_event_notifier(ctx, &vq->host_notifier, true,
++    ret = blk_zone_report(blk, offset, &nr_zones, zones);
-+                           virtio_queue_host_notifier_read,
++    if (ret < 0) {
-+                           virtio_queue_host_notifier_aio_poll,
++        printf("zone report failed: %s\n", strerror(-ret));
-+                           virtio_queue_host_notifier_aio_poll_ready);
++    } else {
-+    aio_set_event_notifier_poll(ctx, &vq->host_notifier,
++        for (int i = 0; i < nr_zones; ++i) {
-+                                virtio_queue_host_notifier_aio_poll_begin,
++            printf("start: 0x%" PRIx64 ", len 0x%" PRIx64 ", "
-+                                virtio_queue_host_notifier_aio_poll_end);
++                   "cap"" 0x%" PRIx64 ", wptr 0x%" PRIx64 ", "
-+}
++                   "zcond:%u, [type: %u]\n",
-+
++                    tosector(zones[i].start), tosector(zones[i].length),
-+void virtio_queue_aio_detach_host_notifier(VirtQueue *vq, AioContext *ctx)
++                    tosector(zones[i].cap), tosector(zones[i].wp),
-+{
++                    zones[i].state, zones[i].type);
-+    aio_set_event_notifier(ctx, &vq->host_notifier, true, NULL, NULL, NULL);
++        }
-+    /* Test and clear notifier before after disabling event,
++    }
-+     * in case poll callback didn't have time to run. */
++    return ret;
-+    virtio_queue_host_notifier_read(&vq->host_notifier);
++}
- }
++
++static const cmdinfo_t zone_report_cmd = {
- void virtio_queue_host_notifier_read(EventNotifier *n)
++    .name = "zone_report",
 +    .altname = "zrp",
 +    .cfunc = zone_report_f,
 +    .argmin = 2,
 +    .argmax = 2,
 +    .args = "offset number",
 +    .oneline = "report zone information",
 +};
 +
 +static int zone_open_f(BlockBackend *blk, int argc, char **argv)
 +{
 +    int ret;
 +    int64_t offset, len;
 +    ++optind;
 +    offset = cvtnum(argv[optind]);
 +    ++optind;
 +    len = cvtnum(argv[optind]);
 +    ret = blk_zone_mgmt(blk, BLK_ZO_OPEN, offset, len);
 +    if (ret < 0) {
 +        printf("zone open failed: %s\n", strerror(-ret));
 +    }
 +    return ret;
 +}
 +
 +static const cmdinfo_t zone_open_cmd = {
 +    .name = "zone_open",
 +    .altname = "zo",
 +    .cfunc = zone_open_f,
 +    .argmin = 2,
 +    .argmax = 2,
 +    .args = "offset len",
 +    .oneline = "explicit open a range of zones in zone block device",
 +};
 +
 +static int zone_close_f(BlockBackend *blk, int argc, char **argv)
 +{
 +    int ret;
 +    int64_t offset, len;
 +    ++optind;
 +    offset = cvtnum(argv[optind]);
 +    ++optind;
 +    len = cvtnum(argv[optind]);
 +    ret = blk_zone_mgmt(blk, BLK_ZO_CLOSE, offset, len);
 +    if (ret < 0) {
 +        printf("zone close failed: %s\n", strerror(-ret));
 +    }
 +    return ret;
 +}
 +
 +static const cmdinfo_t zone_close_cmd = {
 +    .name = "zone_close",
 +    .altname = "zc",
 +    .cfunc = zone_close_f,
 +    .argmin = 2,
 +    .argmax = 2,
 +    .args = "offset len",
 +    .oneline = "close a range of zones in zone block device",
 +};
 +
 +static int zone_finish_f(BlockBackend *blk, int argc, char **argv)
 +{
 +    int ret;
 +    int64_t offset, len;
 +    ++optind;
 +    offset = cvtnum(argv[optind]);
 +    ++optind;
 +    len = cvtnum(argv[optind]);
 +    ret = blk_zone_mgmt(blk, BLK_ZO_FINISH, offset, len);
 +    if (ret < 0) {
 +        printf("zone finish failed: %s\n", strerror(-ret));
 +    }
 +    return ret;
 +}
 +
 +static const cmdinfo_t zone_finish_cmd = {
 +    .name = "zone_finish",
 +    .altname = "zf",
 +    .cfunc = zone_finish_f,
 +    .argmin = 2,
 +    .argmax = 2,
 +    .args = "offset len",
 +    .oneline = "finish a range of zones in zone block device",
 +};
 +
 +static int zone_reset_f(BlockBackend *blk, int argc, char **argv)
 +{
 +    int ret;
 +    int64_t offset, len;
 +    ++optind;
 +    offset = cvtnum(argv[optind]);
 +    ++optind;
 +    len = cvtnum(argv[optind]);
 +    ret = blk_zone_mgmt(blk, BLK_ZO_RESET, offset, len);
 +    if (ret < 0) {
 +        printf("zone reset failed: %s\n", strerror(-ret));
 +    }
 +    return ret;
 +}
 +
 +static const cmdinfo_t zone_reset_cmd = {
 +    .name = "zone_reset",
 +    .altname = "zrs",
 +    .cfunc = zone_reset_f,
 +    .argmin = 2,
 +    .argmax = 2,
 +    .args = "offset len",
 +    .oneline = "reset a zone write pointer in zone block device",
 +};
 +
  static int truncate_f(BlockBackend *blk, int argc, char **argv);
  static const cmdinfo_t truncate_cmd = {
      .name       = "truncate",
@@ -XXX,XX +XXX,XX @@ static void __attribute((constructor)) init_qemuio_commands(void)
      qemuio_add_command(&aio_write_cmd);
      qemuio_add_command(&aio_flush_cmd);
      qemuio_add_command(&flush_cmd);
 +    qemuio_add_command(&zone_report_cmd);
 +    qemuio_add_command(&zone_open_cmd);
 +    qemuio_add_command(&zone_close_cmd);
 +    qemuio_add_command(&zone_finish_cmd);
 +    qemuio_add_command(&zone_reset_cmd);
      qemuio_add_command(&truncate_cmd);
      qemuio_add_command(&length_cmd);
      qemuio_add_command(&info_cmd);
 --
-.34.1
+.40.0

-[PULL 5/6] virtio: use ->handle_output() instead of ->handle_aio_output()
+[PULL 04/17] block/raw-format: add zone operations to pass through requests
-The difference between ->handle_output() and ->handle_aio_output() was
+From: Sam Li <faithilikerun@gmail.com>
 that ->handle_aio_output() returned a bool return value indicating
 progress. This was needed by the old polling API but now that the bool
 return value is gone, the two functions can be unified.
+raw-format driver usually sits on top of file-posix driver. It needs to
+pass through requests of zone commands.
+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>
-Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
+Message-id: 20230427172019.3345-5-faithilikerun@gmail.com
-Message-id: 20211207132336.36627-6-stefanha@redhat.com
+Message-id: 20230324090605.28361-5-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>
 ---
- hw/virtio/virtio.c | 33 +++------------------------------
+ block/raw-format.c | 17 +++++++++++++++++
-file changed, 3 insertions(+), 30 deletions(-)
+file changed, 17 insertions(+)
-diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
+diff --git a/block/raw-format.c b/block/raw-format.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/virtio/virtio.c
+--- a/block/raw-format.c
-+++ b/hw/virtio/virtio.c
++++ b/block/raw-format.c
-@@ -XXX,XX +XXX,XX @@ struct VirtQueue
+@@ -XXX,XX +XXX,XX @@ raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+     return bdrv_co_pdiscard(bs->file, offset, bytes);
      uint16_t vector;
      VirtIOHandleOutput handle_output;
 -    VirtIOHandleOutput handle_aio_output;
      VirtIODevice *vdev;
      EventNotifier guest_notifier;
      EventNotifier host_notifier;
@@ -XXX,XX +XXX,XX @@ void virtio_queue_set_align(VirtIODevice *vdev, int n, int align)
      }
  }
--static void virtio_queue_notify_aio_vq(VirtQueue *vq)
++static int coroutine_fn GRAPH_RDLOCK
--{
++raw_co_zone_report(BlockDriverState *bs, int64_t offset,
--    if (vq->vring.desc && vq->handle_aio_output) {
++                   unsigned int *nr_zones,
--        VirtIODevice *vdev = vq->vdev;
++                   BlockZoneDescriptor *zones)
--
++{
--        trace_virtio_queue_notify(vdev, vq - vdev->vq, vq);
++    return bdrv_co_zone_report(bs->file->bs, offset, nr_zones, zones);
--        vq->handle_aio_output(vdev, vq);
++}
--
++
--        if (unlikely(vdev->start_on_kick)) {
++static int coroutine_fn GRAPH_RDLOCK
--            virtio_set_started(vdev, true);
++raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
--        }
++                 int64_t offset, int64_t len)
--    }
++{
--}
++    return bdrv_co_zone_mgmt(bs->file->bs, op, offset, len);
--
++}
- static void virtio_queue_notify_vq(VirtQueue *vq)
++
  static int64_t coroutine_fn GRAPH_RDLOCK
  raw_co_getlength(BlockDriverState *bs)
  {
-     if (vq->vring.desc && vq->handle_output) {
+@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_raw = {
-@@ -XXX,XX +XXX,XX @@ VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
+     .bdrv_co_pwritev      = &raw_co_pwritev,
-     vdev->vq[i].vring.num_default = queue_size;
+     .bdrv_co_pwrite_zeroes = &raw_co_pwrite_zeroes,
-     vdev->vq[i].vring.align = VIRTIO_PCI_VRING_ALIGN;
+     .bdrv_co_pdiscard     = &raw_co_pdiscard,
-     vdev->vq[i].handle_output = handle_output;
++    .bdrv_co_zone_report  = &raw_co_zone_report,
--    vdev->vq[i].handle_aio_output = NULL;
++    .bdrv_co_zone_mgmt  = &raw_co_zone_mgmt,
-     vdev->vq[i].used_elems = g_malloc0(sizeof(VirtQueueElement) *
+     .bdrv_co_block_status = &raw_co_block_status,
-                                        queue_size);
+     .bdrv_co_copy_range_from = &raw_co_copy_range_from,
+     .bdrv_co_copy_range_to  = &raw_co_copy_range_to,
@@ -XXX,XX +XXX,XX @@ void virtio_delete_queue(VirtQueue *vq)
      vq->vring.num = 0;
      vq->vring.num_default = 0;
      vq->handle_output = NULL;
 -    vq->handle_aio_output = NULL;
      g_free(vq->used_elems);
      vq->used_elems = NULL;
      virtio_virtqueue_reset_region_cache(vq);
@@ -XXX,XX +XXX,XX @@ EventNotifier *virtio_queue_get_guest_notifier(VirtQueue *vq)
      return &vq->guest_notifier;
  }
 -static void virtio_queue_host_notifier_aio_read(EventNotifier *n)
 -{
 -    VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
 -    if (event_notifier_test_and_clear(n)) {
 -        virtio_queue_notify_aio_vq(vq);
 -    }
 -}
 -
  static void virtio_queue_host_notifier_aio_poll_begin(EventNotifier *n)
  {
      VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
@@ -XXX,XX +XXX,XX @@ static void virtio_queue_host_notifier_aio_poll_ready(EventNotifier *n)
  {
      VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
 -    virtio_queue_notify_aio_vq(vq);
 +    virtio_queue_notify_vq(vq);
  }
  static void virtio_queue_host_notifier_aio_poll_end(EventNotifier *n)
@@ -XXX,XX +XXX,XX @@ void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
          VirtIOHandleOutput handle_output)
  {
      if (handle_output) {
 -        vq->handle_aio_output = handle_output;
          aio_set_event_notifier(ctx, &vq->host_notifier, true,
 -                               virtio_queue_host_notifier_aio_read,
 +                               virtio_queue_host_notifier_read,
                                 virtio_queue_host_notifier_aio_poll,
                                 virtio_queue_host_notifier_aio_poll_ready);
          aio_set_event_notifier_poll(ctx, &vq->host_notifier,
@@ -XXX,XX +XXX,XX @@ void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
          aio_set_event_notifier(ctx, &vq->host_notifier, true, NULL, NULL, NULL);
          /* Test and clear notifier before after disabling event,
           * in case poll callback didn't have time to run. */
 -        virtio_queue_host_notifier_aio_read(&vq->host_notifier);
 -        vq->handle_aio_output = NULL;
 +        virtio_queue_host_notifier_read(&vq->host_notifier);
      }
  }
 --
-.34.1
+.40.0

-New patch
+[PULL 05/17] block: add zoned BlockDriver check to block layer
+From: Sam Li <faithilikerun@gmail.com>
+Putting zoned/non-zoned BlockDrivers on top of each other is not
+allowed.
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.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: 20230427172019.3345-6-faithilikerun@gmail.com
+Message-id: 20230324090605.28361-6-faithilikerun@gmail.com
+[Adjust commit message prefix as suggested by Philippe Mathieu-Daudé
+<philmd@linaro.org> and clarify that the check is about zoned
+BlockDrivers.
+--Stefan]
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ include/block/block_int-common.h |  5 +++++
+ block.c                          | 19 +++++++++++++++++++
+ block/file-posix.c               | 12 ++++++++++++
+ block/raw-format.c               |  1 +
+files changed, 37 insertions(+)
+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 {
+      */
+     bool is_format;
++    /*
++     * Set to true if the BlockDriver supports zoned children.
++     */
++    bool supports_zoned_children;
++
+     /*
+      * Drivers not implementing bdrv_parse_filename nor bdrv_open should have
+      * this field set to true, except ones that are defined only by their
+diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block.c
++++ b/block.c
+@@ -XXX,XX +XXX,XX @@ void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
+         return;
+     }
++    /*
++     * Non-zoned block drivers do not follow zoned storage constraints
++     * (i.e. sequential writes to zones). Refuse mixing zoned and non-zoned
++     * drivers in a graph.
++     */
++    if (!parent_bs->drv->supports_zoned_children &&
++        child_bs->bl.zoned == BLK_Z_HM) {
++        /*
++         * The host-aware model allows zoned storage constraints and random
++         * write. Allow mixing host-aware and non-zoned drivers. Using
++         * host-aware device as a regular device.
++         */
++        error_setg(errp, "Cannot add a %s child to a %s parent",
++                   child_bs->bl.zoned == BLK_Z_HM ? "zoned" : "non-zoned",
++                   parent_bs->drv->supports_zoned_children ?
++                   "support zoned children" : "not support zoned children");
++        return;
++    }
++
+     if (!QLIST_EMPTY(&child_bs->parents)) {
+         error_setg(errp, "The node %s already has a parent",
+                    child_bs->node_name);
+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 raw_open_common(BlockDriverState *bs, QDict *options,
+             goto fail;
+         }
+     }
++#ifdef CONFIG_BLKZONED
++    /*
++     * The kernel page cache does not reliably work for writes to SWR zones
++     * of zoned block device because it can not guarantee the order of writes.
++     */
++    if ((bs->bl.zoned != BLK_Z_NONE) &&
++        (!(s->open_flags & O_DIRECT))) {
++        error_setg(errp, "The driver supports zoned devices, and it requires "
++                         "cache.direct=on, which was not specified.");
++        return -EINVAL; /* No host kernel page cache */
++    }
++#endif
+     if (S_ISBLK(st.st_mode)) {
+ #ifdef __linux__
+diff --git a/block/raw-format.c b/block/raw-format.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/raw-format.c
++++ b/block/raw-format.c
+@@ -XXX,XX +XXX,XX @@ static void raw_child_perm(BlockDriverState *bs, BdrvChild *c,
+ BlockDriver bdrv_raw = {
+     .format_name          = "raw",
+     .instance_size        = sizeof(BDRVRawState),
++    .supports_zoned_children = true,
+     .bdrv_probe           = &raw_probe,
+     .bdrv_reopen_prepare  = &raw_reopen_prepare,
+     .bdrv_reopen_commit   = &raw_reopen_commit,
+--
+.40.0

-[PULL 4/6] virtio-scsi: prepare virtio_scsi_handle_cmd for dataplane
+[PULL 06/17] iotests: test new zone operations
-Prepare virtio_scsi_handle_cmd() to be used by both dataplane and
+From: Sam Li <faithilikerun@gmail.com>
 non-dataplane by making the condition for starting ioeventfd more
 specific. This way it won't trigger when dataplane has already been
 started.
+The new block layer APIs of zoned block devices can be tested by:
+$ tests/qemu-iotests/check zoned
+Run each zone operation on a newly created null_blk device
+and see whether it outputs the same zone information.
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Acked-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
+Message-id: 20230427172019.3345-7-faithilikerun@gmail.com
-Message-id: 20211207132336.36627-5-stefanha@redhat.com
+Message-id: 20230324090605.28361-7-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>
 ---
- hw/scsi/virtio-scsi.c | 2 +-
+ tests/qemu-iotests/tests/zoned     | 89 ++++++++++++++++++++++++++++++
-file changed, 1 insertion(+), 1 deletion(-)
+ tests/qemu-iotests/tests/zoned.out | 53 ++++++++++++++++++
 files changed, 142 insertions(+)
  create mode 100755 tests/qemu-iotests/tests/zoned
  create mode 100644 tests/qemu-iotests/tests/zoned.out
-diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c
+diff --git a/tests/qemu-iotests/tests/zoned b/tests/qemu-iotests/tests/zoned
-index XXXXXXX..XXXXXXX 100644
+new file mode 100755
---- a/hw/scsi/virtio-scsi.c
+index XXXXXXX..XXXXXXX
-+++ b/hw/scsi/virtio-scsi.c
+--- /dev/null
-@@ -XXX,XX +XXX,XX @@ static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq)
++++ b/tests/qemu-iotests/tests/zoned
-     /* use non-QOM casts in the data path */
+@@ -XXX,XX +XXX,XX @@
-     VirtIOSCSI *s = (VirtIOSCSI *)vdev;
++#!/usr/bin/env bash
++#
--    if (s->ctx) {
++# Test zone management operations.
-+    if (s->ctx && !s->dataplane_started) {
++#
-         virtio_device_start_ioeventfd(vdev);
++
-         if (!s->dataplane_fenced) {
++seq="$(basename $0)"
-             return;
++echo "QA output created by $seq"
 +status=1 # failure is the default!
 +
 +_cleanup()
 +{
 +  _cleanup_test_img
 +  sudo -n rmmod null_blk
 +}
 +trap "_cleanup; exit \$status" 0 1 2 3 15
 +
 +# get standard environment, filters and checks
 +. ../common.rc
 +. ../common.filter
 +. ../common.qemu
 +
 +# This test only runs on Linux hosts with raw image files.
 +_supported_fmt raw
 +_supported_proto file
 +_supported_os Linux
 +
 +sudo -n true || \
 +    _notrun 'Password-less sudo required'
 +
 +IMG="--image-opts -n driver=host_device,filename=/dev/nullb0"
 +QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT
 +
 +echo "Testing a null_blk device:"
 +echo "case 1: if the operations work"
 +sudo -n modprobe null_blk nr_devices=1 zoned=1
 +sudo -n chmod 0666 /dev/nullb0
 +
 +echo "(1) report the first zone:"
 +$QEMU_IO $IMG -c "zrp 0 1"
 +echo
 +echo "report the first 10 zones"
 +$QEMU_IO $IMG -c "zrp 0 10"
 +echo
 +echo "report the last zone:"
 +$QEMU_IO $IMG -c "zrp 0x3e70000000 2" # 0x3e70000000 / 512 = 0x1f380000
 +echo
 +echo
 +echo "(2) opening the first zone"
 +$QEMU_IO $IMG -c "zo 0 268435456"  # 268435456 / 512 = 524288
 +echo "report after:"
 +$QEMU_IO $IMG -c "zrp 0 1"
 +echo
 +echo "opening the second zone"
 +$QEMU_IO $IMG -c "zo 268435456 268435456" #
 +echo "report after:"
 +$QEMU_IO $IMG -c "zrp 268435456 1"
 +echo
 +echo "opening the last zone"
 +$QEMU_IO $IMG -c "zo 0x3e70000000 268435456"
 +echo "report after:"
 +$QEMU_IO $IMG -c "zrp 0x3e70000000 2"
 +echo
 +echo
 +echo "(3) closing the first zone"
 +$QEMU_IO $IMG -c "zc 0 268435456"
 +echo "report after:"
 +$QEMU_IO $IMG -c "zrp 0 1"
 +echo
 +echo "closing the last zone"
 +$QEMU_IO $IMG -c "zc 0x3e70000000 268435456"
 +echo "report after:"
 +$QEMU_IO $IMG -c "zrp 0x3e70000000 2"
 +echo
 +echo
 +echo "(4) finishing the second zone"
 +$QEMU_IO $IMG -c "zf 268435456 268435456"
 +echo "After finishing a zone:"
 +$QEMU_IO $IMG -c "zrp 268435456 1"
 +echo
 +echo
 +echo "(5) resetting the second zone"
 +$QEMU_IO $IMG -c "zrs 268435456 268435456"
 +echo "After resetting a zone:"
 +$QEMU_IO $IMG -c "zrp 268435456 1"
 +
 +# success, all done
 +echo "*** done"
 +rm -f $seq.full
 +status=0
 diff --git a/tests/qemu-iotests/tests/zoned.out b/tests/qemu-iotests/tests/zoned.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/tests/zoned.out
@@ -XXX,XX +XXX,XX @@
 +QA output created by zoned
 +Testing a null_blk device:
 +case 1: if the operations work
 +(1) report the first zone:
 +start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:1, [type: 2]
 +
 +report the first 10 zones
 +start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:1, [type: 2]
 +start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80000, zcond:1, [type: 2]
 +start: 0x100000, len 0x80000, cap 0x80000, wptr 0x100000, zcond:1, [type: 2]
 +start: 0x180000, len 0x80000, cap 0x80000, wptr 0x180000, zcond:1, [type: 2]
 +start: 0x200000, len 0x80000, cap 0x80000, wptr 0x200000, zcond:1, [type: 2]
 +start: 0x280000, len 0x80000, cap 0x80000, wptr 0x280000, zcond:1, [type: 2]
 +start: 0x300000, len 0x80000, cap 0x80000, wptr 0x300000, zcond:1, [type: 2]
 +start: 0x380000, len 0x80000, cap 0x80000, wptr 0x380000, zcond:1, [type: 2]
 +start: 0x400000, len 0x80000, cap 0x80000, wptr 0x400000, zcond:1, [type: 2]
 +start: 0x480000, len 0x80000, cap 0x80000, wptr 0x480000, zcond:1, [type: 2]
 +
 +report the last zone:
 +start: 0x1f380000, len 0x80000, cap 0x80000, wptr 0x1f380000, zcond:1, [type: 2]
 +
 +
 +(2) opening the first zone
 +report after:
 +start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:3, [type: 2]
 +
 +opening the second zone
 +report after:
 +start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80000, zcond:3, [type: 2]
 +
 +opening the last zone
 +report after:
 +start: 0x1f380000, len 0x80000, cap 0x80000, wptr 0x1f380000, zcond:3, [type: 2]
 +
 +
 +(3) closing the first zone
 +report after:
 +start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:1, [type: 2]
 +
 +closing the last zone
 +report after:
 +start: 0x1f380000, len 0x80000, cap 0x80000, wptr 0x1f380000, zcond:1, [type: 2]
 +
 +
 +(4) finishing the second zone
 +After finishing a zone:
 +start: 0x80000, len 0x80000, cap 0x80000, wptr 0x100000, zcond:14, [type: 2]
 +
 +
 +(5) resetting the second zone
 +After resetting a zone:
 +start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80000, zcond:1, [type: 2]
 +*** done
 --
-.34.1
+.40.0

-New patch
+[PULL 07/17] block: add some trace events for new block layer APIs
+From: Sam Li <faithilikerun@gmail.com>
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.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: 20230427172019.3345-8-faithilikerun@gmail.com
+Message-id: 20230324090605.28361-8-faithilikerun@gmail.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/file-posix.c | 3 +++
+ block/trace-events | 2 ++
+files changed, 5 insertions(+)
+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 coroutine_fn raw_co_zone_report(BlockDriverState *bs, int64_t offset,
+         },
+     };
++    trace_zbd_zone_report(bs, *nr_zones, offset >> BDRV_SECTOR_BITS);
+     return raw_thread_pool_submit(handle_aiocb_zone_report, &acb);
+ }
+ #endif
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
+         },
+     };
++    trace_zbd_zone_mgmt(bs, op_name, offset >> BDRV_SECTOR_BITS,
++                        len >> BDRV_SECTOR_BITS);
+     ret = raw_thread_pool_submit(handle_aiocb_zone_mgmt, &acb);
+     if (ret != 0) {
+         error_report("ioctl %s failed %d", op_name, ret);
+diff --git a/block/trace-events b/block/trace-events
+index XXXXXXX..XXXXXXX 100644
+--- a/block/trace-events
++++ b/block/trace-events
+@@ -XXX,XX +XXX,XX @@ file_FindEjectableOpticalMedia(const char *media) "Matching using %s"
+ file_setup_cdrom(const char *partition) "Using %s as optical disc"
+ file_hdev_is_sg(int type, int version) "SG device found: type=%d, version=%d"
+ file_flush_fdatasync_failed(int err) "errno %d"
++zbd_zone_report(void *bs, unsigned int nr_zones, int64_t sector) "bs %p report %d zones starting at sector offset 0x%" PRIx64 ""
++zbd_zone_mgmt(void *bs, const char *op_name, int64_t sector, int64_t len) "bs %p %s starts at sector offset 0x%" PRIx64 " over a range of 0x%" PRIx64 " sectors"
+ # ssh.c
+ sftp_error(const char *op, const char *ssh_err, int ssh_err_code, int sftp_err_code) "%s failed: %s (libssh error code: %d, sftp error code: %d)"
+--
+.40.0

-New patch
+[PULL 08/17] docs/zoned-storage: add zoned device documentation
+From: Sam Li <faithilikerun@gmail.com>
+Add the documentation about the zoned device support to virtio-blk
+emulation.
+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: Dmitry Fomichev <dmitry.fomichev@wdc.com>
+Acked-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20230427172019.3345-9-faithilikerun@gmail.com
+Message-id: 20230324090605.28361-9-faithilikerun@gmail.com
+[Add index-api.rst to fix "zoned-storage.rst:document isn't included in
+any toctree" error and fix pre-formatted command-line indentation.
+--Stefan]
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ docs/devel/index-api.rst               |  1 +
+ docs/devel/zoned-storage.rst           | 43 ++++++++++++++++++++++++++
+ docs/system/qemu-block-drivers.rst.inc |  6 ++++
+files changed, 50 insertions(+)
+ create mode 100644 docs/devel/zoned-storage.rst
+diff --git a/docs/devel/index-api.rst b/docs/devel/index-api.rst
+index XXXXXXX..XXXXXXX 100644
+--- a/docs/devel/index-api.rst
++++ b/docs/devel/index-api.rst
+@@ -XXX,XX +XXX,XX @@ generated from in-code annotations to function prototypes.
+    memory
+    modules
+    ui
++   zoned-storage
+diff --git a/docs/devel/zoned-storage.rst b/docs/devel/zoned-storage.rst
+new file mode 100644
+index XXXXXXX..XXXXXXX
+--- /dev/null
++++ b/docs/devel/zoned-storage.rst
+@@ -XXX,XX +XXX,XX @@
++=============
++zoned-storage
++=============
++
++Zoned Block Devices (ZBDs) divide the LBA space into block regions called zones
++that are larger than the LBA size. They can only allow sequential writes, which
++can reduce write amplification in SSDs, and potentially lead to higher
++throughput and increased capacity. More details about ZBDs can be found at:
++
++https://zonedstorage.io/docs/introduction/zoned-storage
++
++1. Block layer APIs for zoned storage
++-------------------------------------
++QEMU block layer supports three zoned storage models:
++- BLK_Z_HM: The host-managed zoned model only allows sequential writes access
++to zones. It supports ZBD-specific I/O commands that can be used by a host to
++manage the zones of a device.
++- BLK_Z_HA: The host-aware zoned model allows random write operations in
++zones, making it backward compatible with regular block devices.
++- BLK_Z_NONE: The non-zoned model has no zones support. It includes both
++regular and drive-managed ZBD devices. ZBD-specific I/O commands are not
++supported.
++
++The block device information resides inside BlockDriverState. QEMU uses
++BlockLimits struct(BlockDriverState::bl) that is continuously accessed by the
++block layer while processing I/O requests. A BlockBackend has a root pointer to
++a BlockDriverState graph(for example, raw format on top of file-posix). The
++zoned storage information can be propagated from the leaf BlockDriverState all
++the way up to the BlockBackend. If the zoned storage model in file-posix is
++set to BLK_Z_HM, then block drivers will declare support for zoned host device.
++
++The block layer APIs support commands needed for zoned storage devices,
++including report zones, four zone operations, and zone append.
++
++2. Emulating zoned storage controllers
++--------------------------------------
++When the BlockBackend's BlockLimits model reports a zoned storage device, users
++like the virtio-blk emulation or the qemu-io-cmds.c utility can use block layer
++APIs for zoned storage emulation or testing.
++
++For example, to test zone_report on a null_blk device using qemu-io is::
++
++  $ path/to/qemu-io --image-opts -n driver=host_device,filename=/dev/nullb0 -c "zrp offset nr_zones"
+diff --git a/docs/system/qemu-block-drivers.rst.inc b/docs/system/qemu-block-drivers.rst.inc
+index XXXXXXX..XXXXXXX 100644
+--- a/docs/system/qemu-block-drivers.rst.inc
++++ b/docs/system/qemu-block-drivers.rst.inc
+@@ -XXX,XX +XXX,XX @@ Hard disks
+   you may corrupt your host data (use the ``-snapshot`` command
+   line option or modify the device permissions accordingly).
++Zoned block devices
++  Zoned block devices can be passed through to the guest if the emulated storage
++  controller supports zoned storage. Use ``--blockdev host_device,
++  node-name=drive0,filename=/dev/nullb0,cache.direct=on`` to pass through
++  ``/dev/nullb0`` as ``drive0``.
++
+ Windows
+ ^^^^^^^
+--
+.40.0

-New patch
+[PULL 09/17] file-posix: add tracking of the zone write pointers
+From: Sam Li <faithilikerun@gmail.com>
+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>
+Message-id: 20230427172339.3709-2-faithilikerun@gmail.com
+[Fix errno propagation from handle_aiocb_zone_mgmt()
+--Stefan]
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ include/block/block-common.h     |  14 +++
+ include/block/block_int-common.h |   5 +
+ block/file-posix.c               | 178 ++++++++++++++++++++++++++++++-
+files changed, 193 insertions(+), 4 deletions(-)
+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 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;
+@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX 100644
+--- a/include/block/block_int-common.h
++++ b/include/block/block_int-common.h
+@@ -XXX,XX +XXX,XX @@ typedef struct BlockLimits {
+     /* maximum number of active zones */
+     int64_t max_active_zones;
++
++    int64_t write_granularity;
+ } BlockLimits;
+ typedef struct BdrvOpBlocker BdrvOpBlocker;
+@@ -XXX,XX +XXX,XX @@ 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 {
+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_segments(int fd, struct stat *st)
+ }
+ #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;
++    unsigned int j = offset / bs->bl.zone_size;
++    unsigned int n = 0, i = 0;
++    int ret;
++    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");
++    }
++}
++
+ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
+                                      Error **errp)
+ {
++    BDRVRawState *s = bs->opaque;
+     BlockZoneModel zoned;
+     int ret;
+@@ -XXX,XX +XXX,XX @@ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
+     if (ret > 0) {
+         bs->bl.max_append_sectors = ret >> BDRV_SECTOR_BITS;
+     }
++
++    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);
+ }
+ #else /* !defined(CONFIG_BLKZONED) */
+ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
+@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_zone_mgmt(void *opaque)
+         ret = ioctl(fd, aiocb->zone_mgmt.op, &range);
+     } while (ret != 0 && errno == EINTR);
+-    return ret;
++    return ret < 0 ? -errno : ret;
+ }
+ #endif
+@@ -XXX,XX +XXX,XX @@ 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
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
+ #ifdef CONFIG_LINUX_IO_URING
+     } else if (s->use_linux_io_uring) {
+         assert(qiov->size == bytes);
+-        return luring_co_submit(bs, s->fd, offset, qiov, type);
++        ret = luring_co_submit(bs, s->fd, offset, qiov, type);
++        goto out;
+ #endif
+ #ifdef CONFIG_LINUX_AIO
+     } else if (s->use_linux_aio) {
+         assert(qiov->size == bytes);
+-        return laio_co_submit(s->fd, offset, qiov, type, s->aio_max_batch);
++        ret = laio_co_submit(s->fd, offset, qiov, type,
++                              s->aio_max_batch);
++        goto out;
+ #endif
+     }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
+     };
+     assert(qiov->size == bytes);
+-    return raw_thread_pool_submit(handle_aiocb_rw, &acb);
++    ret = raw_thread_pool_submit(handle_aiocb_rw, &acb);
++    goto out; /* Avoid the compiler err of unused label */
++
++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,
+@@ -XXX,XX +XXX,XX @@ 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;
+     }
+@@ -XXX,XX +XXX,XX @@ 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;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
+         return -EINVAL;
+     }
++    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";
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
+                         len >> BDRV_SECTOR_BITS);
+     ret = raw_thread_pool_submit(handle_aiocb_zone_mgmt, &acb);
+     if (ret != 0) {
++        update_zones_wp(bs, s->fd, offset, i);
+         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 (unsigned int j = 0; j < nrz; ++j) {
++            wp[j] = offset + j * zone_size;
++        }
++    } else if (zo == BLKFINISHZONE) {
++        for (unsigned 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;
+--
+.40.0

-[PULL 1/6] aio-posix: split poll check from ready handler
+[PULL 10/17] block: introduce zone append write for zoned devices
-Adaptive polling measures the execution time of the polling check plus
+From: Sam Li <faithilikerun@gmail.com>
 handlers called when a polled event becomes ready. Handlers can take a
 significant amount of time, making it look like polling was running for
 a long time when in fact the event handler was running for a long time.
-For example, on Linux the io_submit(2) syscall invoked when a virtio-blk
+A zone append command is a write operation that specifies the first
-device's virtqueue becomes ready can take 10s of microseconds. This
+logical block of a zone as the write position. When writing to a zoned
-can exceed the default polling interval (32 microseconds) and cause
+block device using zone append, the byte offset of the call may point at
-adaptive polling to stop polling.
+any position within the zone to which the data is being appended. Upon
 completion the device will respond with the position where the data has
 been written in the zone.
-By excluding the handler's execution time from the polling check we make
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
-the adaptive polling calculation more accurate. As a result, the event
+Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
-loop now stays in polling mode where previously it would have fallen
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-back to file descriptor monitoring.
+Message-id: 20230427172339.3709-3-faithilikerun@gmail.com
 The following data was collected with virtio-blk num-queues=2
 event_idx=off using an IOThread. Before:
 k IOPS, IOThread syscalls:
 .115 ( 0.020 ms): IO iothread1/620155 io_submit(ctx_id: 140512552468480, nr: 16, iocbpp: 0x7fcb9f937db0)    = 16
 .158 ( 0.002 ms): IO iothread1/620155 write(fd: 103, buf: 0x556a2ef71b88, count: 8)                         = 8
 .161 ( 0.001 ms): IO iothread1/620155 write(fd: 104, buf: 0x556a2ef71b88, count: 8)                         = 8
 .163 ( 0.001 ms): IO iothread1/620155 ppoll(ufds: 0x7fcb90002800, nfds: 4, tsp: 0x7fcb9f1342d0, sigsetsize: 8) = 3
 .164 ( 0.001 ms): IO iothread1/620155 read(fd: 107, buf: 0x7fcb9f939cc0, count: 512)                        = 8
 .174 ( 0.001 ms): IO iothread1/620155 read(fd: 105, buf: 0x7fcb9f939cc0, count: 512)                        = 8
 .176 ( 0.001 ms): IO iothread1/620155 read(fd: 106, buf: 0x7fcb9f939cc0, count: 512)                        = 8
 .209 ( 0.035 ms): IO iothread1/620155 io_submit(ctx_id: 140512552468480, nr: 32, iocbpp: 0x7fca7d0cebe0)    = 32
 k IOPS (+3.6%), IOThread syscalls:
 .566 ( 0.036 ms): IO iothread1/623061 io_submit(ctx_id: 140539805028352, nr: 32, iocbpp: 0x7fd0cdd62be0)    = 32
 .625 ( 0.001 ms): IO iothread1/623061 write(fd: 103, buf: 0x5647cfba5f58, count: 8)                         = 8
 .627 ( 0.002 ms): IO iothread1/623061 write(fd: 104, buf: 0x5647cfba5f58, count: 8)                         = 8
 .663 ( 0.036 ms): IO iothread1/623061 io_submit(ctx_id: 140539805028352, nr: 32, iocbpp: 0x7fd0d0388b50)    = 32
 Notice that ppoll(2) and eventfd read(2) syscalls are eliminated because
 the IOThread stays in polling mode instead of falling back to file
 descriptor monitoring.
 As usual, polling is not implemented on Windows so this patch ignores
 the new io_poll_read() callback in aio-win32.c.
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
 Message-id: 20211207132336.36627-2-stefanha@redhat.com
 [Fixed up aio_set_event_notifier() calls in
 tests/unit/test-fdmon-epoll.c added after this series was queued.
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/block/aio.h           |  4 +-
+ include/block/block-io.h          |  4 ++
- util/aio-posix.h              |  1 +
+ include/block/block_int-common.h  |  3 ++
- block/curl.c                  | 11 +++--
+ include/block/raw-aio.h           |  4 +-
- block/export/fuse.c           |  4 +-
+ include/sysemu/block-backend-io.h |  9 +++++
- block/io_uring.c              | 19 ++++----
+ block/block-backend.c             | 61 +++++++++++++++++++++++++++++++
- block/iscsi.c                 |  4 +-
+ block/file-posix.c                | 58 +++++++++++++++++++++++++----
- block/linux-aio.c             | 16 ++++---
+ block/io.c                        | 27 ++++++++++++++
- block/nfs.c                   |  6 +--
+ block/io_uring.c                  |  4 ++
- block/nvme.c                  | 51 +++++++++++++-------
+ block/linux-aio.c                 |  3 ++
- block/ssh.c                   |  4 +-
+ block/raw-format.c                |  8 ++++
- block/win32-aio.c             |  4 +-
+files changed, 173 insertions(+), 8 deletions(-)
  hw/virtio/virtio.c            | 16 ++++---
  hw/xen/xen-bus.c              |  6 +--
  io/channel-command.c          |  6 ++-
  io/channel-file.c             |  3 +-
  io/channel-socket.c           |  3 +-
  migration/rdma.c              |  8 ++--
  tests/unit/test-aio.c         |  4 +-
  tests/unit/test-fdmon-epoll.c |  4 +-
  util/aio-posix.c              | 89 ++++++++++++++++++++++++++---------
  util/aio-win32.c              |  4 +-
  util/async.c                  | 10 +++-
  util/main-loop.c              |  4 +-
  util/qemu-coroutine-io.c      |  5 +-
  util/vhost-user-server.c      | 11 +++--
 files changed, 193 insertions(+), 104 deletions(-)
-diff --git a/include/block/aio.h b/include/block/aio.h
+diff --git a/include/block/block-io.h b/include/block/block-io.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/aio.h
+--- a/include/block/block-io.h
-+++ b/include/block/aio.h
++++ b/include/block/block-io.h
-@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_report(BlockDriverState *bs,
-                         IOHandler *io_read,
+ int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_mgmt(BlockDriverState *bs,
-                         IOHandler *io_write,
+                                                 BlockZoneOp op,
-                         AioPollFn *io_poll,
+                                                 int64_t offset, int64_t len);
-+                        IOHandler *io_poll_ready,
++int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_append(BlockDriverState *bs,
-                         void *opaque);
++                                                  int64_t *offset,
++                                                  QEMUIOVector *qiov,
- /* Set polling begin/end callbacks for a file descriptor that has already been
++                                                  BdrvRequestFlags flags);
-@@ -XXX,XX +XXX,XX @@ void aio_set_event_notifier(AioContext *ctx,
-                             EventNotifier *notifier,
+ bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
-                             bool is_external,
+ int bdrv_block_status(BlockDriverState *bs, int64_t offset,
-                             EventNotifierHandler *io_read,
+diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
--                            AioPollFn *io_poll);
+index XXXXXXX..XXXXXXX 100644
-+                            AioPollFn *io_poll,
+--- a/include/block/block_int-common.h
-+                            EventNotifierHandler *io_poll_ready);
++++ b/include/block/block_int-common.h
+@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
- /* Set polling begin/end callbacks for an event notifier that has already been
+             BlockZoneDescriptor *zones);
-  * registered with aio_set_event_notifier.  Do nothing if the event notifier is
+     int coroutine_fn (*bdrv_co_zone_mgmt)(BlockDriverState *bs, BlockZoneOp op,
-diff --git a/util/aio-posix.h b/util/aio-posix.h
+             int64_t offset, int64_t len);
-index XXXXXXX..XXXXXXX 100644
++    int coroutine_fn (*bdrv_co_zone_append)(BlockDriverState *bs,
---- a/util/aio-posix.h
++            int64_t *offset, QEMUIOVector *qiov,
-+++ b/util/aio-posix.h
++            BdrvRequestFlags flags);
-@@ -XXX,XX +XXX,XX @@ struct AioHandler {
-     IOHandler *io_read;
+     /* removable device specific */
-     IOHandler *io_write;
+     bool coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_is_inserted)(
-     AioPollFn *io_poll;
+diff --git a/include/block/raw-aio.h b/include/block/raw-aio.h
-+    IOHandler *io_poll_ready;
+index XXXXXXX..XXXXXXX 100644
-     IOHandler *io_poll_begin;
+--- a/include/block/raw-aio.h
-     IOHandler *io_poll_end;
++++ b/include/block/raw-aio.h
-     void *opaque;
+@@ -XXX,XX +XXX,XX @@
-diff --git a/block/curl.c b/block/curl.c
+ #define QEMU_AIO_TRUNCATE     0x0080
-index XXXXXXX..XXXXXXX 100644
+ #define QEMU_AIO_ZONE_REPORT  0x0100
---- a/block/curl.c
+ #define QEMU_AIO_ZONE_MGMT    0x0200
-+++ b/block/curl.c
++#define QEMU_AIO_ZONE_APPEND  0x0400
-@@ -XXX,XX +XXX,XX @@ static gboolean curl_drop_socket(void *key, void *value, void *opaque)
+ #define QEMU_AIO_TYPE_MASK \
-     BDRVCURLState *s = socket->s;
+         (QEMU_AIO_READ | \
+          QEMU_AIO_WRITE | \
-     aio_set_fd_handler(s->aio_context, socket->fd, false,
+@@ -XXX,XX +XXX,XX @@
--                       NULL, NULL, NULL, NULL);
+          QEMU_AIO_COPY_RANGE | \
-+                       NULL, NULL, NULL, NULL, NULL);
+          QEMU_AIO_TRUNCATE | \
-     return true;
+          QEMU_AIO_ZONE_REPORT | \
- }
+-         QEMU_AIO_ZONE_MGMT)
++         QEMU_AIO_ZONE_MGMT | \
-@@ -XXX,XX +XXX,XX @@ static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action,
++         QEMU_AIO_ZONE_APPEND)
-     switch (action) {
-         case CURL_POLL_IN:
+ /* AIO flags */
-             aio_set_fd_handler(s->aio_context, fd, false,
+ #define QEMU_AIO_MISALIGNED   0x1000
--                               curl_multi_do, NULL, NULL, socket);
+diff --git a/include/sysemu/block-backend-io.h b/include/sysemu/block-backend-io.h
-+                               curl_multi_do, NULL, NULL, NULL, socket);
+index XXXXXXX..XXXXXXX 100644
-             break;
+--- a/include/sysemu/block-backend-io.h
-         case CURL_POLL_OUT:
++++ b/include/sysemu/block-backend-io.h
-             aio_set_fd_handler(s->aio_context, fd, false,
+@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_aio_zone_report(BlockBackend *blk, int64_t offset,
--                               NULL, curl_multi_do, NULL, socket);
+ BlockAIOCB *blk_aio_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
-+                               NULL, curl_multi_do, NULL, NULL, socket);
+                               int64_t offset, int64_t len,
-             break;
+                               BlockCompletionFunc *cb, void *opaque);
-         case CURL_POLL_INOUT:
++BlockAIOCB *blk_aio_zone_append(BlockBackend *blk, int64_t *offset,
-             aio_set_fd_handler(s->aio_context, fd, false,
++                                QEMUIOVector *qiov, BdrvRequestFlags flags,
--                               curl_multi_do, curl_multi_do, NULL, socket);
++                                BlockCompletionFunc *cb, void *opaque);
-+                               curl_multi_do, curl_multi_do,
+ BlockAIOCB *blk_aio_pdiscard(BlockBackend *blk, int64_t offset, int64_t bytes,
-+                               NULL, NULL, socket);
+                              BlockCompletionFunc *cb, void *opaque);
-             break;
+ void blk_aio_cancel_async(BlockAIOCB *acb);
-         case CURL_POLL_REMOVE:
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
-             aio_set_fd_handler(s->aio_context, fd, false,
+                                   int64_t offset, int64_t len);
--                               NULL, NULL, NULL, NULL);
+ int co_wrapper_mixed blk_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
-+                               NULL, NULL, NULL, NULL, NULL);
+                                        int64_t offset, int64_t len);
-             break;
++int coroutine_fn blk_co_zone_append(BlockBackend *blk, int64_t *offset,
 +                                    QEMUIOVector *qiov,
 +                                    BdrvRequestFlags flags);
 +int co_wrapper_mixed blk_zone_append(BlockBackend *blk, int64_t *offset,
 +                                         QEMUIOVector *qiov,
 +                                         BdrvRequestFlags flags);
  int co_wrapper_mixed blk_pdiscard(BlockBackend *blk, int64_t offset,
                                    int64_t bytes);
 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 @@ BlockAIOCB *blk_aio_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
      return &acb->common;
  }
 +static void coroutine_fn blk_aio_zone_append_entry(void *opaque)
 +{
 +    BlkAioEmAIOCB *acb = opaque;
 +    BlkRwCo *rwco = &acb->rwco;
 +
 +    rwco->ret = blk_co_zone_append(rwco->blk, (int64_t *)(uintptr_t)acb->bytes,
 +                                   rwco->iobuf, rwco->flags);
 +    blk_aio_complete(acb);
 +}
 +
 +BlockAIOCB *blk_aio_zone_append(BlockBackend *blk, int64_t *offset,
 +                                QEMUIOVector *qiov, BdrvRequestFlags flags,
 +                                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,
 +        .ret    = NOT_DONE,
 +        .flags  = flags,
 +        .iobuf  = qiov,
 +    };
 +    acb->bytes = (int64_t)(uintptr_t)offset;
 +    acb->has_returned = false;
 +
 +    co = qemu_coroutine_create(blk_aio_zone_append_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
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
      return ret;
  }
 +/*
 + * Send a zone_append command.
 + */
 +int coroutine_fn blk_co_zone_append(BlockBackend *blk, int64_t *offset,
 +        QEMUIOVector *qiov, BdrvRequestFlags flags)
 +{
 +    int ret;
 +    IO_CODE();
 +
 +    blk_inc_in_flight(blk);
 +    blk_wait_while_drained(blk);
 +    GRAPH_RDLOCK_GUARD();
 +    if (!blk_is_available(blk)) {
 +        blk_dec_in_flight(blk);
 +        return -ENOMEDIUM;
 +    }
 +
 +    ret = bdrv_co_zone_append(blk_bs(blk), offset, qiov, flags);
 +    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 @@ typedef struct BDRVRawState {
      bool has_write_zeroes:1;
      bool use_linux_aio:1;
      bool use_linux_io_uring:1;
 +    int64_t *offset; /* offset of zone append operation */
      int page_cache_inconsistent; /* errno from fdatasync failure */
      bool has_fallocate;
      bool needs_alignment;
@@ -XXX,XX +XXX,XX @@ static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
      ssize_t len;
      len = RETRY_ON_EINTR(
 -        (aiocb->aio_type & QEMU_AIO_WRITE) ?
 +        (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) ?
              qemu_pwritev(aiocb->aio_fildes,
                             aiocb->io.iov,
                             aiocb->io.niov,
@@ -XXX,XX +XXX,XX @@ static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
      ssize_t len;
      while (offset < aiocb->aio_nbytes) {
 -        if (aiocb->aio_type & QEMU_AIO_WRITE) {
 +        if (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) {
              len = pwrite(aiocb->aio_fildes,
                           (const char *)buf + offset,
                           aiocb->aio_nbytes - offset,
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_rw(void *opaque)
      }
-diff --git a/block/export/fuse.c b/block/export/fuse.c
+     nbytes = handle_aiocb_rw_linear(aiocb, buf);
-index XXXXXXX..XXXXXXX 100644
+-    if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
---- a/block/export/fuse.c
++    if (!(aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))) {
-+++ b/block/export/fuse.c
+         char *p = buf;
-@@ -XXX,XX +XXX,XX @@ static int setup_fuse_export(FuseExport *exp, const char *mountpoint,
+         size_t count = aiocb->aio_nbytes, copy;
+         int i;
-     aio_set_fd_handler(exp->common.ctx,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
-                        fuse_session_fd(exp->fuse_session), true,
+     if (fd_open(bs) < 0)
--                       read_from_fuse_export, NULL, NULL, exp);
+         return -EIO;
-+                       read_from_fuse_export, NULL, NULL, NULL, exp);
+ #if defined(CONFIG_BLKZONED)
-     exp->fd_handler_set_up = true;
+-    if (type & QEMU_AIO_WRITE && bs->wps) {
++    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) && bs->wps) {
-     return 0;
+         qemu_co_mutex_lock(&bs->wps->colock);
-@@ -XXX,XX +XXX,XX @@ static void fuse_export_shutdown(BlockExport *blk_exp)
++        if (type & QEMU_AIO_ZONE_APPEND && bs->bl.zone_size) {
-         if (exp->fd_handler_set_up) {
++            int index = offset / bs->bl.zone_size;
-             aio_set_fd_handler(exp->common.ctx,
++            offset = bs->wps->wp[index];
-                                fuse_session_fd(exp->fuse_session), true,
++        }
--                               NULL, NULL, NULL, NULL);
+     }
-+                               NULL, NULL, NULL, NULL, NULL);
+ #endif
-             exp->fd_handler_set_up = false;
@@ -XXX,XX +XXX,XX @@ out:
  {
      BlockZoneWps *wps = bs->wps;
      if (ret == 0) {
 -        if (type & QEMU_AIO_WRITE && wps && bs->bl.zone_size) {
 +        if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))
 +            && wps && bs->bl.zone_size) {
              uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
              if (!BDRV_ZT_IS_CONV(*wp)) {
 +                if (type & QEMU_AIO_ZONE_APPEND) {
 +                    *s->offset = *wp;
 +                }
                  /* Advance the wp if needed */
                  if (offset + bytes > *wp) {
                      *wp = offset + bytes;
@@ -XXX,XX +XXX,XX @@ out:
              }
          }
      } else {
 -        if (type & QEMU_AIO_WRITE) {
 +        if (type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) {
              update_zones_wp(bs, s->fd, 0, 1);
          }
      }
+-    if (type & QEMU_AIO_WRITE && wps) {
++    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) && wps) {
+         qemu_co_mutex_unlock(&wps->colock);
+     }
+ }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
+ }
+ #endif
++#if defined(CONFIG_BLKZONED)
++static int coroutine_fn raw_co_zone_append(BlockDriverState *bs,
++                                           int64_t *offset,
++                                           QEMUIOVector *qiov,
++                                           BdrvRequestFlags flags) {
++    assert(flags == 0);
++    int64_t zone_size_mask = bs->bl.zone_size - 1;
++    int64_t iov_len = 0;
++    int64_t len = 0;
++    BDRVRawState *s = bs->opaque;
++    s->offset = offset;
++
++    if (*offset & zone_size_mask) {
++        error_report("sector offset %" PRId64 " is not aligned to zone size "
++                     "%" PRId32 "", *offset / 512, bs->bl.zone_size / 512);
++        return -EINVAL;
++    }
++
++    int64_t wg = bs->bl.write_granularity;
++    int64_t wg_mask = wg - 1;
++    for (int i = 0; i < qiov->niov; i++) {
++        iov_len = qiov->iov[i].iov_len;
++        if (iov_len & wg_mask) {
++            error_report("len of IOVector[%d] %" PRId64 " is not aligned to "
++                         "block size %" PRId64 "", i, iov_len, wg);
++            return -EINVAL;
++        }
++        len += iov_len;
++    }
++
++    return raw_co_prw(bs, *offset, len, qiov, QEMU_AIO_ZONE_APPEND);
++}
++#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 = {
+     /* zone management operations */
+     .bdrv_co_zone_report = raw_co_zone_report,
+     .bdrv_co_zone_mgmt = raw_co_zone_mgmt,
++    .bdrv_co_zone_append = raw_co_zone_append,
+ #endif
+ };
+diff --git a/block/io.c b/block/io.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/io.c
++++ b/block/io.c
+@@ -XXX,XX +XXX,XX @@ out:
+     return co.ret;
+ }
++int coroutine_fn bdrv_co_zone_append(BlockDriverState *bs, int64_t *offset,
++                        QEMUIOVector *qiov,
++                        BdrvRequestFlags flags)
++{
++    int ret;
++    BlockDriver *drv = bs->drv;
++    CoroutineIOCompletion co = {
++            .coroutine = qemu_coroutine_self(),
++    };
++    IO_CODE();
++
++    ret = bdrv_check_qiov_request(*offset, qiov->size, qiov, 0, NULL);
++    if (ret < 0) {
++        return ret;
++    }
++
++    bdrv_inc_in_flight(bs);
++    if (!drv || !drv->bdrv_co_zone_append || bs->bl.zoned == BLK_Z_NONE) {
++        co.ret = -ENOTSUP;
++        goto out;
++    }
++    co.ret = drv->bdrv_co_zone_append(bs, offset, qiov, flags);
++out:
++    bdrv_dec_in_flight(bs);
++    return co.ret;
++}
++
+ void *qemu_blockalign(BlockDriverState *bs, size_t size)
+ {
+     IO_CODE();
 diff --git a/block/io_uring.c b/block/io_uring.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io_uring.c
 +++ b/block/io_uring.c
-@@ -XXX,XX +XXX,XX @@ static bool qemu_luring_poll_cb(void *opaque)
+@@ -XXX,XX +XXX,XX @@ static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
- {
+         io_uring_prep_writev(sqes, fd, luringcb->qiov->iov,
-     LuringState *s = opaque;
+                              luringcb->qiov->niov, offset);
+         break;
--    if (io_uring_cq_ready(&s->ring)) {
++    case QEMU_AIO_ZONE_APPEND:
--        luring_process_completions_and_submit(s);
++        io_uring_prep_writev(sqes, fd, luringcb->qiov->iov,
--        return true;
++                             luringcb->qiov->niov, offset);
--    }
++        break;
-+    return io_uring_cq_ready(&s->ring);
+     case QEMU_AIO_READ:
-+}
+         io_uring_prep_readv(sqes, fd, luringcb->qiov->iov,
+                             luringcb->qiov->niov, offset);
 -    return false;
 +static void qemu_luring_poll_ready(void *opaque)
 +{
 +    LuringState *s = opaque;
 +
 +    luring_process_completions_and_submit(s);
  }
  static void ioq_init(LuringQueue *io_q)
@@ -XXX,XX +XXX,XX @@ int coroutine_fn luring_co_submit(BlockDriverState *bs, LuringState *s, int fd,
  void luring_detach_aio_context(LuringState *s, AioContext *old_context)
  {
 -    aio_set_fd_handler(old_context, s->ring.ring_fd, false, NULL, NULL, NULL,
 -                       s);
 +    aio_set_fd_handler(old_context, s->ring.ring_fd, false,
 +                       NULL, NULL, NULL, NULL, s);
      qemu_bh_delete(s->completion_bh);
      s->aio_context = NULL;
  }
@@ -XXX,XX +XXX,XX @@ void luring_attach_aio_context(LuringState *s, AioContext *new_context)
      s->aio_context = new_context;
      s->completion_bh = aio_bh_new(new_context, qemu_luring_completion_bh, s);
      aio_set_fd_handler(s->aio_context, s->ring.ring_fd, false,
 -                       qemu_luring_completion_cb, NULL, qemu_luring_poll_cb, s);
 +                       qemu_luring_completion_cb, NULL,
 +                       qemu_luring_poll_cb, qemu_luring_poll_ready, s);
  }
  LuringState *luring_init(Error **errp)
 diff --git a/block/iscsi.c b/block/iscsi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/iscsi.c
 +++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ iscsi_set_events(IscsiLun *iscsilun)
                             false,
                             (ev & POLLIN) ? iscsi_process_read : NULL,
                             (ev & POLLOUT) ? iscsi_process_write : NULL,
 -                           NULL,
 +                           NULL, NULL,
                             iscsilun);
          iscsilun->events = ev;
      }
@@ -XXX,XX +XXX,XX @@ static void iscsi_detach_aio_context(BlockDriverState *bs)
      IscsiLun *iscsilun = bs->opaque;
      aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsilun->iscsi),
 -                       false, NULL, NULL, NULL, NULL);
 +                       false, NULL, NULL, NULL, NULL, NULL);
      iscsilun->events = 0;
      if (iscsilun->nop_timer) {
 diff --git a/block/linux-aio.c b/block/linux-aio.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/linux-aio.c
 +++ b/block/linux-aio.c
-@@ -XXX,XX +XXX,XX @@ static bool qemu_laio_poll_cb(void *opaque)
+@@ -XXX,XX +XXX,XX @@ static int laio_do_submit(int fd, struct qemu_laiocb *laiocb, off_t offset,
-     LinuxAioState *s = container_of(e, LinuxAioState, e);
+     case QEMU_AIO_WRITE:
-     struct io_event *events;
+         io_prep_pwritev(iocbs, fd, qiov->iov, qiov->niov, offset);
+         break;
--    if (!io_getevents_peek(s->ctx, &events)) {
++    case QEMU_AIO_ZONE_APPEND:
--        return false;
++        io_prep_pwritev(iocbs, fd, qiov->iov, qiov->niov, offset);
--    }
++        break;
-+    return io_getevents_peek(s->ctx, &events);
+     case QEMU_AIO_READ:
-+}
+         io_prep_preadv(iocbs, fd, qiov->iov, qiov->niov, offset);
-+
+         break;
-+static void qemu_laio_poll_ready(EventNotifier *opaque)
+diff --git a/block/raw-format.c b/block/raw-format.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/raw-format.c
 +++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
      return bdrv_co_zone_mgmt(bs->file->bs, op, offset, len);
  }
 +static int coroutine_fn GRAPH_RDLOCK
 +raw_co_zone_append(BlockDriverState *bs,int64_t *offset, QEMUIOVector *qiov,
 +                   BdrvRequestFlags flags)
 +{
-+    EventNotifier *e = opaque;
++    return bdrv_co_zone_append(bs->file->bs, offset, qiov, flags);
-+    LinuxAioState *s = container_of(e, LinuxAioState, e);
++}
++
-     qemu_laio_process_completions_and_submit(s);
+ static int64_t coroutine_fn GRAPH_RDLOCK
--    return true;
+ raw_co_getlength(BlockDriverState *bs)
  }
  static void ioq_init(LaioQueue *io_q)
@@ -XXX,XX +XXX,XX @@ int coroutine_fn laio_co_submit(BlockDriverState *bs, LinuxAioState *s, int fd,
  void laio_detach_aio_context(LinuxAioState *s, AioContext *old_context)
  {
--    aio_set_event_notifier(old_context, &s->e, false, NULL, NULL);
+@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_raw = {
-+    aio_set_event_notifier(old_context, &s->e, false, NULL, NULL, NULL);
+     .bdrv_co_pdiscard     = &raw_co_pdiscard,
-     qemu_bh_delete(s->completion_bh);
+     .bdrv_co_zone_report  = &raw_co_zone_report,
-     s->aio_context = NULL;
+     .bdrv_co_zone_mgmt  = &raw_co_zone_mgmt,
- }
++    .bdrv_co_zone_append = &raw_co_zone_append,
-@@ -XXX,XX +XXX,XX @@ void laio_attach_aio_context(LinuxAioState *s, AioContext *new_context)
+     .bdrv_co_block_status = &raw_co_block_status,
-     s->completion_bh = aio_bh_new(new_context, qemu_laio_completion_bh, s);
+     .bdrv_co_copy_range_from = &raw_co_copy_range_from,
-     aio_set_event_notifier(new_context, &s->e, false,
+     .bdrv_co_copy_range_to  = &raw_co_copy_range_to,
                             qemu_laio_completion_cb,
 -                           qemu_laio_poll_cb);
 +                           qemu_laio_poll_cb,
 +                           qemu_laio_poll_ready);
  }
  LinuxAioState *laio_init(Error **errp)
 diff --git a/block/nfs.c b/block/nfs.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/nfs.c
 +++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static void nfs_set_events(NFSClient *client)
                             false,
                             (ev & POLLIN) ? nfs_process_read : NULL,
                             (ev & POLLOUT) ? nfs_process_write : NULL,
 -                           NULL, client);
 +                           NULL, NULL, client);
      }
      client->events = ev;
@@ -XXX,XX +XXX,XX @@ static void nfs_detach_aio_context(BlockDriverState *bs)
      NFSClient *client = bs->opaque;
      aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
 -                       false, NULL, NULL, NULL, NULL);
 +                       false, NULL, NULL, NULL, NULL, NULL);
      client->events = 0;
  }
@@ -XXX,XX +XXX,XX @@ static void nfs_client_close(NFSClient *client)
      if (client->context) {
          qemu_mutex_lock(&client->mutex);
          aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
 -                           false, NULL, NULL, NULL, NULL);
 +                           false, NULL, NULL, NULL, NULL, NULL);
          qemu_mutex_unlock(&client->mutex);
          if (client->fh) {
              nfs_close(client->context, client->fh);
 diff --git a/block/nvme.c b/block/nvme.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/nvme.c
 +++ b/block/nvme.c
@@ -XXX,XX +XXX,XX @@ out:
      return ret;
  }
 -static bool nvme_poll_queue(NVMeQueuePair *q)
 +static void nvme_poll_queue(NVMeQueuePair *q)
  {
 -    bool progress = false;
 -
      const size_t cqe_offset = q->cq.head * NVME_CQ_ENTRY_BYTES;
      NvmeCqe *cqe = (NvmeCqe *)&q->cq.queue[cqe_offset];
@@ -XXX,XX +XXX,XX @@ static bool nvme_poll_queue(NVMeQueuePair *q)
       * cannot race with itself.
       */
      if ((le16_to_cpu(cqe->status) & 0x1) == q->cq_phase) {
 -        return false;
 +        return;
      }
      qemu_mutex_lock(&q->lock);
      while (nvme_process_completion(q)) {
          /* Keep polling */
 -        progress = true;
      }
      qemu_mutex_unlock(&q->lock);
 -
 -    return progress;
  }
 -static bool nvme_poll_queues(BDRVNVMeState *s)
 +static void nvme_poll_queues(BDRVNVMeState *s)
  {
 -    bool progress = false;
      int i;
      for (i = 0; i < s->queue_count; i++) {
 -        if (nvme_poll_queue(s->queues[i])) {
 -            progress = true;
 -        }
 +        nvme_poll_queue(s->queues[i]);
      }
 -    return progress;
  }
  static void nvme_handle_event(EventNotifier *n)
@@ -XXX,XX +XXX,XX @@ static bool nvme_poll_cb(void *opaque)
      EventNotifier *e = opaque;
      BDRVNVMeState *s = container_of(e, BDRVNVMeState,
                                      irq_notifier[MSIX_SHARED_IRQ_IDX]);
 +    int i;
 -    return nvme_poll_queues(s);
 +    for (i = 0; i < s->queue_count; i++) {
 +        NVMeQueuePair *q = s->queues[i];
 +        const size_t cqe_offset = q->cq.head * NVME_CQ_ENTRY_BYTES;
 +        NvmeCqe *cqe = (NvmeCqe *)&q->cq.queue[cqe_offset];
 +
 +        /*
 +         * q->lock isn't needed because nvme_process_completion() only runs in
 +         * the event loop thread and cannot race with itself.
 +         */
 +        if ((le16_to_cpu(cqe->status) & 0x1) != q->cq_phase) {
 +            return true;
 +        }
 +    }
 +    return false;
 +}
 +
 +static void nvme_poll_ready(EventNotifier *e)
 +{
 +    BDRVNVMeState *s = container_of(e, BDRVNVMeState,
 +                                    irq_notifier[MSIX_SHARED_IRQ_IDX]);
 +
 +    nvme_poll_queues(s);
  }
  static int nvme_init(BlockDriverState *bs, const char *device, int namespace,
@@ -XXX,XX +XXX,XX @@ static int nvme_init(BlockDriverState *bs, const char *device, int namespace,
      }
      aio_set_event_notifier(bdrv_get_aio_context(bs),
                             &s->irq_notifier[MSIX_SHARED_IRQ_IDX],
 -                           false, nvme_handle_event, nvme_poll_cb);
 +                           false, nvme_handle_event, nvme_poll_cb,
 +                           nvme_poll_ready);
      if (!nvme_identify(bs, namespace, errp)) {
          ret = -EIO;
@@ -XXX,XX +XXX,XX @@ static void nvme_close(BlockDriverState *bs)
      g_free(s->queues);
      aio_set_event_notifier(bdrv_get_aio_context(bs),
                             &s->irq_notifier[MSIX_SHARED_IRQ_IDX],
 -                           false, NULL, NULL);
 +                           false, NULL, NULL, NULL);
      event_notifier_cleanup(&s->irq_notifier[MSIX_SHARED_IRQ_IDX]);
      qemu_vfio_pci_unmap_bar(s->vfio, 0, s->bar0_wo_map,
 , sizeof(NvmeBar) + NVME_DOORBELL_SIZE);
@@ -XXX,XX +XXX,XX @@ static void nvme_detach_aio_context(BlockDriverState *bs)
      aio_set_event_notifier(bdrv_get_aio_context(bs),
                             &s->irq_notifier[MSIX_SHARED_IRQ_IDX],
 -                           false, NULL, NULL);
 +                           false, NULL, NULL, NULL);
  }
  static void nvme_attach_aio_context(BlockDriverState *bs,
@@ -XXX,XX +XXX,XX @@ static void nvme_attach_aio_context(BlockDriverState *bs,
      s->aio_context = new_context;
      aio_set_event_notifier(new_context, &s->irq_notifier[MSIX_SHARED_IRQ_IDX],
 -                           false, nvme_handle_event, nvme_poll_cb);
 +                           false, nvme_handle_event, nvme_poll_cb,
 +                           nvme_poll_ready);
      for (unsigned i = 0; i < s->queue_count; i++) {
          NVMeQueuePair *q = s->queues[i];
 diff --git a/block/ssh.c b/block/ssh.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/ssh.c
 +++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static void restart_coroutine(void *opaque)
      AioContext *ctx = bdrv_get_aio_context(bs);
      trace_ssh_restart_coroutine(restart->co);
 -    aio_set_fd_handler(ctx, s->sock, false, NULL, NULL, NULL, NULL);
 +    aio_set_fd_handler(ctx, s->sock, false, NULL, NULL, NULL, NULL, NULL);
      aio_co_wake(restart->co);
  }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs)
      trace_ssh_co_yield(s->sock, rd_handler, wr_handler);
      aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
 -                       false, rd_handler, wr_handler, NULL, &restart);
 +                       false, rd_handler, wr_handler, NULL, NULL, &restart);
      qemu_coroutine_yield();
      trace_ssh_co_yield_back(s->sock);
  }
 diff --git a/block/win32-aio.c b/block/win32-aio.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/win32-aio.c
 +++ b/block/win32-aio.c
@@ -XXX,XX +XXX,XX @@ int win32_aio_attach(QEMUWin32AIOState *aio, HANDLE hfile)
  void win32_aio_detach_aio_context(QEMUWin32AIOState *aio,
                                    AioContext *old_context)
  {
 -    aio_set_event_notifier(old_context, &aio->e, false, NULL, NULL);
 +    aio_set_event_notifier(old_context, &aio->e, false, NULL, NULL, NULL);
      aio->aio_ctx = NULL;
  }
@@ -XXX,XX +XXX,XX @@ void win32_aio_attach_aio_context(QEMUWin32AIOState *aio,
  {
      aio->aio_ctx = new_context;
      aio_set_event_notifier(new_context, &aio->e, false,
 -                           win32_aio_completion_cb, NULL);
 +                           win32_aio_completion_cb, NULL, NULL);
  }
  QEMUWin32AIOState *win32_aio_init(void)
 diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/virtio/virtio.c
 +++ b/hw/virtio/virtio.c
@@ -XXX,XX +XXX,XX @@ static bool virtio_queue_host_notifier_aio_poll(void *opaque)
      EventNotifier *n = opaque;
      VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
 -    if (!vq->vring.desc || virtio_queue_empty(vq)) {
 -        return false;
 -    }
 +    return vq->vring.desc && !virtio_queue_empty(vq);
 +}
 -    return virtio_queue_notify_aio_vq(vq);
 +static void virtio_queue_host_notifier_aio_poll_ready(EventNotifier *n)
 +{
 +    VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
 +
 +    virtio_queue_notify_aio_vq(vq);
  }
  static void virtio_queue_host_notifier_aio_poll_end(EventNotifier *n)
@@ -XXX,XX +XXX,XX @@ void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
          vq->handle_aio_output = handle_output;
          aio_set_event_notifier(ctx, &vq->host_notifier, true,
                                 virtio_queue_host_notifier_aio_read,
 -                               virtio_queue_host_notifier_aio_poll);
 +                               virtio_queue_host_notifier_aio_poll,
 +                               virtio_queue_host_notifier_aio_poll_ready);
          aio_set_event_notifier_poll(ctx, &vq->host_notifier,
                                      virtio_queue_host_notifier_aio_poll_begin,
                                      virtio_queue_host_notifier_aio_poll_end);
      } else {
 -        aio_set_event_notifier(ctx, &vq->host_notifier, true, NULL, NULL);
 +        aio_set_event_notifier(ctx, &vq->host_notifier, true, NULL, NULL, NULL);
          /* Test and clear notifier before after disabling event,
           * in case poll callback didn't have time to run. */
          virtio_queue_host_notifier_aio_read(&vq->host_notifier);
 diff --git a/hw/xen/xen-bus.c b/hw/xen/xen-bus.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/xen/xen-bus.c
 +++ b/hw/xen/xen-bus.c
@@ -XXX,XX +XXX,XX @@ void xen_device_set_event_channel_context(XenDevice *xendev,
      if (channel->ctx)
          aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
 -                           NULL, NULL, NULL, NULL);
 +                           NULL, NULL, NULL, NULL, NULL);
      channel->ctx = ctx;
      aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
 -                       xen_device_event, NULL, xen_device_poll, channel);
 +                       xen_device_event, NULL, xen_device_poll, NULL, channel);
  }
  XenEventChannel *xen_device_bind_event_channel(XenDevice *xendev,
@@ -XXX,XX +XXX,XX @@ void xen_device_unbind_event_channel(XenDevice *xendev,
      QLIST_REMOVE(channel, list);
      aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
 -                       NULL, NULL, NULL, NULL);
 +                       NULL, NULL, NULL, NULL, NULL);
      if (xenevtchn_unbind(channel->xeh, channel->local_port) < 0) {
          error_setg_errno(errp, errno, "xenevtchn_unbind failed");
 diff --git a/io/channel-command.c b/io/channel-command.c
 index XXXXXXX..XXXXXXX 100644
 --- a/io/channel-command.c
 +++ b/io/channel-command.c
@@ -XXX,XX +XXX,XX @@ static void qio_channel_command_set_aio_fd_handler(QIOChannel *ioc,
                                                     void *opaque)
  {
      QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
 -    aio_set_fd_handler(ctx, cioc->readfd, false, io_read, NULL, NULL, opaque);
 -    aio_set_fd_handler(ctx, cioc->writefd, false, NULL, io_write, NULL, opaque);
 +    aio_set_fd_handler(ctx, cioc->readfd, false,
 +                       io_read, NULL, NULL, NULL, opaque);
 +    aio_set_fd_handler(ctx, cioc->writefd, false,
 +                       NULL, io_write, NULL, NULL, opaque);
  }
 diff --git a/io/channel-file.c b/io/channel-file.c
 index XXXXXXX..XXXXXXX 100644
 --- a/io/channel-file.c
 +++ b/io/channel-file.c
@@ -XXX,XX +XXX,XX @@ static void qio_channel_file_set_aio_fd_handler(QIOChannel *ioc,
                                                  void *opaque)
  {
      QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
 -    aio_set_fd_handler(ctx, fioc->fd, false, io_read, io_write, NULL, opaque);
 +    aio_set_fd_handler(ctx, fioc->fd, false, io_read, io_write,
 +                       NULL, NULL, opaque);
  }
  static GSource *qio_channel_file_create_watch(QIOChannel *ioc,
 diff --git a/io/channel-socket.c b/io/channel-socket.c
 index XXXXXXX..XXXXXXX 100644
 --- a/io/channel-socket.c
 +++ b/io/channel-socket.c
@@ -XXX,XX +XXX,XX @@ static void qio_channel_socket_set_aio_fd_handler(QIOChannel *ioc,
                                                    void *opaque)
  {
      QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
 -    aio_set_fd_handler(ctx, sioc->fd, false, io_read, io_write, NULL, opaque);
 +    aio_set_fd_handler(ctx, sioc->fd, false,
 +                       io_read, io_write, NULL, NULL, opaque);
  }
  static GSource *qio_channel_socket_create_watch(QIOChannel *ioc,
 diff --git a/migration/rdma.c b/migration/rdma.c
 index XXXXXXX..XXXXXXX 100644
 --- a/migration/rdma.c
 +++ b/migration/rdma.c
@@ -XXX,XX +XXX,XX @@ static void qio_channel_rdma_set_aio_fd_handler(QIOChannel *ioc,
      QIOChannelRDMA *rioc = QIO_CHANNEL_RDMA(ioc);
      if (io_read) {
          aio_set_fd_handler(ctx, rioc->rdmain->recv_comp_channel->fd,
 -                           false, io_read, io_write, NULL, opaque);
 +                           false, io_read, io_write, NULL, NULL, opaque);
          aio_set_fd_handler(ctx, rioc->rdmain->send_comp_channel->fd,
 -                           false, io_read, io_write, NULL, opaque);
 +                           false, io_read, io_write, NULL, NULL, opaque);
      } else {
          aio_set_fd_handler(ctx, rioc->rdmaout->recv_comp_channel->fd,
 -                           false, io_read, io_write, NULL, opaque);
 +                           false, io_read, io_write, NULL, NULL, opaque);
          aio_set_fd_handler(ctx, rioc->rdmaout->send_comp_channel->fd,
 -                           false, io_read, io_write, NULL, opaque);
 +                           false, io_read, io_write, NULL, NULL, opaque);
      }
  }
 diff --git a/tests/unit/test-aio.c b/tests/unit/test-aio.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/unit/test-aio.c
 +++ b/tests/unit/test-aio.c
@@ -XXX,XX +XXX,XX @@ static void *test_acquire_thread(void *opaque)
  static void set_event_notifier(AioContext *ctx, EventNotifier *notifier,
                                 EventNotifierHandler *handler)
  {
 -    aio_set_event_notifier(ctx, notifier, false, handler, NULL);
 +    aio_set_event_notifier(ctx, notifier, false, handler, NULL, NULL);
  }
  static void dummy_notifier_read(EventNotifier *n)
@@ -XXX,XX +XXX,XX @@ static void test_aio_external_client(void)
      for (i = 1; i < 3; i++) {
          EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
          event_notifier_init(&data.e, false);
 -        aio_set_event_notifier(ctx, &data.e, true, event_ready_cb, NULL);
 +        aio_set_event_notifier(ctx, &data.e, true, event_ready_cb, NULL, NULL);
          event_notifier_set(&data.e);
          for (j = 0; j < i; j++) {
              aio_disable_external(ctx);
 diff --git a/tests/unit/test-fdmon-epoll.c b/tests/unit/test-fdmon-epoll.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/unit/test-fdmon-epoll.c
 +++ b/tests/unit/test-fdmon-epoll.c
@@ -XXX,XX +XXX,XX @@ static void add_event_notifiers(EventNotifier *notifiers, size_t n)
      for (size_t i = 0; i < n; i++) {
          event_notifier_init(&notifiers[i], false);
          aio_set_event_notifier(ctx, &notifiers[i], false,
 -                               dummy_fd_handler, NULL);
 +                               dummy_fd_handler, NULL, NULL);
      }
  }
  static void remove_event_notifiers(EventNotifier *notifiers, size_t n)
  {
      for (size_t i = 0; i < n; i++) {
 -        aio_set_event_notifier(ctx, &notifiers[i], false, NULL, NULL);
 +        aio_set_event_notifier(ctx, &notifiers[i], false, NULL, NULL, NULL);
          event_notifier_cleanup(&notifiers[i]);
      }
  }
 diff --git a/util/aio-posix.c b/util/aio-posix.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/aio-posix.c
 +++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@
  #include "trace.h"
  #include "aio-posix.h"
 +/*
 + * G_IO_IN and G_IO_OUT are not appropriate revents values for polling, since
 + * the handler may not need to access the file descriptor. For example, the
 + * handler doesn't need to read from an EventNotifier if it polled a memory
 + * location and a read syscall would be slow. Define our own unique revents
 + * value to indicate that polling determined this AioHandler is ready.
 + */
 +#define REVENTS_POLL_READY 0
 +
  /* Stop userspace polling on a handler if it isn't active for some time */
  #define POLL_IDLE_INTERVAL_NS (7 * NANOSECONDS_PER_SECOND)
@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
                          IOHandler *io_read,
                          IOHandler *io_write,
                          AioPollFn *io_poll,
 +                        IOHandler *io_poll_ready,
                          void *opaque)
  {
      AioHandler *node;
@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
      bool deleted = false;
      int poll_disable_change;
 +    if (io_poll && !io_poll_ready) {
 +        io_poll = NULL; /* polling only makes sense if there is a handler */
 +    }
 +
      qemu_lockcnt_lock(&ctx->list_lock);
      node = find_aio_handler(ctx, fd);
@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
          new_node->io_read = io_read;
          new_node->io_write = io_write;
          new_node->io_poll = io_poll;
 +        new_node->io_poll_ready = io_poll_ready;
          new_node->opaque = opaque;
          new_node->is_external = is_external;
@@ -XXX,XX +XXX,XX @@ void aio_set_event_notifier(AioContext *ctx,
                              EventNotifier *notifier,
                              bool is_external,
                              EventNotifierHandler *io_read,
 -                            AioPollFn *io_poll)
 +                            AioPollFn *io_poll,
 +                            EventNotifierHandler *io_poll_ready)
  {
      aio_set_fd_handler(ctx, event_notifier_get_fd(notifier), is_external,
 -                       (IOHandler *)io_read, NULL, io_poll, notifier);
 +                       (IOHandler *)io_read, NULL, io_poll,
 +                       (IOHandler *)io_poll_ready, notifier);
  }
  void aio_set_event_notifier_poll(AioContext *ctx,
@@ -XXX,XX +XXX,XX @@ void aio_set_event_notifier_poll(AioContext *ctx,
                      (IOHandler *)io_poll_end);
  }
 -static bool poll_set_started(AioContext *ctx, bool started)
 +static bool poll_set_started(AioContext *ctx, AioHandlerList *ready_list,
 +                             bool started)
  {
      AioHandler *node;
      bool progress = false;
@@ -XXX,XX +XXX,XX @@ static bool poll_set_started(AioContext *ctx, bool started)
          }
          /* Poll one last time in case ->io_poll_end() raced with the event */
 -        if (!started) {
 -            progress = node->io_poll(node->opaque) || progress;
 +        if (!started && node->io_poll(node->opaque)) {
 +            aio_add_ready_handler(ready_list, node, REVENTS_POLL_READY);
 +            progress = true;
          }
      }
      qemu_lockcnt_dec(&ctx->list_lock);
@@ -XXX,XX +XXX,XX @@ static bool poll_set_started(AioContext *ctx, bool started)
  bool aio_prepare(AioContext *ctx)
  {
 +    AioHandlerList ready_list = QLIST_HEAD_INITIALIZER(ready_list);
 +
      /* Poll mode cannot be used with glib's event loop, disable it. */
 -    poll_set_started(ctx, false);
 +    poll_set_started(ctx, &ready_list, false);
 +    /* TODO what to do with this list? */
      return false;
  }
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handler(AioContext *ctx, AioHandler *node)
          }
          QLIST_INSERT_HEAD(&ctx->poll_aio_handlers, node, node_poll);
      }
 +    if (!QLIST_IS_INSERTED(node, node_deleted) &&
 +        revents == 0 &&
 +        aio_node_check(ctx, node->is_external) &&
 +        node->io_poll_ready) {
 +        node->io_poll_ready(node->opaque);
 +
 +        /*
 +         * Return early since revents was zero. aio_notify() does not count as
 +         * progress.
 +         */
 +        return node->opaque != &ctx->notifier;
 +    }
      if (!QLIST_IS_INSERTED(node, node_deleted) &&
          (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) &&
@@ -XXX,XX +XXX,XX @@ void aio_dispatch(AioContext *ctx)
  }
  static bool run_poll_handlers_once(AioContext *ctx,
 +                                   AioHandlerList *ready_list,
                                     int64_t now,
                                     int64_t *timeout)
  {
@@ -XXX,XX +XXX,XX @@ static bool run_poll_handlers_once(AioContext *ctx,
      QLIST_FOREACH_SAFE(node, &ctx->poll_aio_handlers, node_poll, tmp) {
          if (aio_node_check(ctx, node->is_external) &&
              node->io_poll(node->opaque)) {
 +            aio_add_ready_handler(ready_list, node, REVENTS_POLL_READY);
 +
              node->poll_idle_timeout = now + POLL_IDLE_INTERVAL_NS;
              /*
@@ -XXX,XX +XXX,XX @@ static bool fdmon_supports_polling(AioContext *ctx)
      return ctx->fdmon_ops->need_wait != aio_poll_disabled;
  }
 -static bool remove_idle_poll_handlers(AioContext *ctx, int64_t now)
 +static bool remove_idle_poll_handlers(AioContext *ctx,
 +                                      AioHandlerList *ready_list,
 +                                      int64_t now)
  {
      AioHandler *node;
      AioHandler *tmp;
@@ -XXX,XX +XXX,XX @@ static bool remove_idle_poll_handlers(AioContext *ctx, int64_t now)
                   * Nevermind about re-adding the handler in the rare case where
                   * this causes progress.
                   */
 -                progress = node->io_poll(node->opaque) || progress;
 +                if (node->io_poll(node->opaque)) {
 +                    aio_add_ready_handler(ready_list, node,
 +                                          REVENTS_POLL_READY);
 +                    progress = true;
 +                }
              }
          }
      }
@@ -XXX,XX +XXX,XX @@ static bool remove_idle_poll_handlers(AioContext *ctx, int64_t now)
  /* run_poll_handlers:
   * @ctx: the AioContext
 + * @ready_list: the list to place ready handlers on
   * @max_ns: maximum time to poll for, in nanoseconds
   *
   * Polls for a given time.
@@ -XXX,XX +XXX,XX @@ static bool remove_idle_poll_handlers(AioContext *ctx, int64_t now)
   *
   * Returns: true if progress was made, false otherwise
   */
 -static bool run_poll_handlers(AioContext *ctx, int64_t max_ns, int64_t *timeout)
 +static bool run_poll_handlers(AioContext *ctx, AioHandlerList *ready_list,
 +                              int64_t max_ns, int64_t *timeout)
  {
      bool progress;
      int64_t start_time, elapsed_time;
@@ -XXX,XX +XXX,XX @@ static bool run_poll_handlers(AioContext *ctx, int64_t max_ns, int64_t *timeout)
      start_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
      do {
 -        progress = run_poll_handlers_once(ctx, start_time, timeout);
 +        progress = run_poll_handlers_once(ctx, ready_list,
 +                                          start_time, timeout);
          elapsed_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - start_time;
          max_ns = qemu_soonest_timeout(*timeout, max_ns);
          assert(!(max_ns && progress));
      } while (elapsed_time < max_ns && !ctx->fdmon_ops->need_wait(ctx));
 -    if (remove_idle_poll_handlers(ctx, start_time + elapsed_time)) {
 +    if (remove_idle_poll_handlers(ctx, ready_list,
 +                                  start_time + elapsed_time)) {
          *timeout = 0;
          progress = true;
      }
@@ -XXX,XX +XXX,XX @@ static bool run_poll_handlers(AioContext *ctx, int64_t max_ns, int64_t *timeout)
  /* try_poll_mode:
   * @ctx: the AioContext
 + * @ready_list: list to add handlers that need to be run
   * @timeout: timeout for blocking wait, computed by the caller and updated if
   *    polling succeeds.
   *
@@ -XXX,XX +XXX,XX @@ static bool run_poll_handlers(AioContext *ctx, int64_t max_ns, int64_t *timeout)
   *
   * Returns: true if progress was made, false otherwise
   */
 -static bool try_poll_mode(AioContext *ctx, int64_t *timeout)
 +static bool try_poll_mode(AioContext *ctx, AioHandlerList *ready_list,
 +                          int64_t *timeout)
  {
      int64_t max_ns;
@@ -XXX,XX +XXX,XX @@ static bool try_poll_mode(AioContext *ctx, int64_t *timeout)
      max_ns = qemu_soonest_timeout(*timeout, ctx->poll_ns);
      if (max_ns && !ctx->fdmon_ops->need_wait(ctx)) {
 -        poll_set_started(ctx, true);
 +        poll_set_started(ctx, ready_list, true);
 -        if (run_poll_handlers(ctx, max_ns, timeout)) {
 +        if (run_poll_handlers(ctx, ready_list, max_ns, timeout)) {
              return true;
          }
      }
 -    if (poll_set_started(ctx, false)) {
 +    if (poll_set_started(ctx, ready_list, false)) {
          *timeout = 0;
          return true;
      }
@@ -XXX,XX +XXX,XX @@ static bool try_poll_mode(AioContext *ctx, int64_t *timeout)
  bool aio_poll(AioContext *ctx, bool blocking)
  {
      AioHandlerList ready_list = QLIST_HEAD_INITIALIZER(ready_list);
 -    int ret = 0;
      bool progress;
      bool use_notify_me;
      int64_t timeout;
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
      }
      timeout = blocking ? aio_compute_timeout(ctx) : 0;
 -    progress = try_poll_mode(ctx, &timeout);
 +    progress = try_poll_mode(ctx, &ready_list, &timeout);
      assert(!(timeout && progress));
      /*
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
       * system call---a single round of run_poll_handlers_once suffices.
       */
      if (timeout || ctx->fdmon_ops->need_wait(ctx)) {
 -        ret = ctx->fdmon_ops->wait(ctx, &ready_list, timeout);
 +        ctx->fdmon_ops->wait(ctx, &ready_list, timeout);
      }
      if (use_notify_me) {
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
      }
      progress |= aio_bh_poll(ctx);
 -
 -    if (ret > 0) {
 -        progress |= aio_dispatch_ready_handlers(ctx, &ready_list);
 -    }
 +    progress |= aio_dispatch_ready_handlers(ctx, &ready_list);
      aio_free_deleted_handlers(ctx);
 diff --git a/util/aio-win32.c b/util/aio-win32.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/aio-win32.c
 +++ b/util/aio-win32.c
@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
                          IOHandler *io_read,
                          IOHandler *io_write,
                          AioPollFn *io_poll,
 +                        IOHandler *io_poll_ready,
                          void *opaque)
  {
      /* fd is a SOCKET in our case */
@@ -XXX,XX +XXX,XX @@ void aio_set_event_notifier(AioContext *ctx,
                              EventNotifier *e,
                              bool is_external,
                              EventNotifierHandler *io_notify,
 -                            AioPollFn *io_poll)
 +                            AioPollFn *io_poll,
 +                            EventNotifierHandler *io_poll_ready)
  {
      AioHandler *node;
 diff --git a/util/async.c b/util/async.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/async.c
 +++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ aio_ctx_finalize(GSource     *source)
          g_free(bh);
      }
 -    aio_set_event_notifier(ctx, &ctx->notifier, false, NULL, NULL);
 +    aio_set_event_notifier(ctx, &ctx->notifier, false, NULL, NULL, NULL);
      event_notifier_cleanup(&ctx->notifier);
      qemu_rec_mutex_destroy(&ctx->lock);
      qemu_lockcnt_destroy(&ctx->list_lock);
@@ -XXX,XX +XXX,XX @@ static bool aio_context_notifier_poll(void *opaque)
      return qatomic_read(&ctx->notified);
  }
 +static void aio_context_notifier_poll_ready(EventNotifier *e)
 +{
 +    /* Do nothing, we just wanted to kick the event loop */
 +}
 +
  static void co_schedule_bh_cb(void *opaque)
  {
      AioContext *ctx = opaque;
@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
      aio_set_event_notifier(ctx, &ctx->notifier,
                             false,
                             aio_context_notifier_cb,
 -                           aio_context_notifier_poll);
 +                           aio_context_notifier_poll,
 +                           aio_context_notifier_poll_ready);
  #ifdef CONFIG_LINUX_AIO
      ctx->linux_aio = NULL;
  #endif
 diff --git a/util/main-loop.c b/util/main-loop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/main-loop.c
 +++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@ void qemu_set_fd_handler(int fd,
  {
      iohandler_init();
      aio_set_fd_handler(iohandler_ctx, fd, false,
 -                       fd_read, fd_write, NULL, opaque);
 +                       fd_read, fd_write, NULL, NULL, opaque);
  }
  void event_notifier_set_handler(EventNotifier *e,
@@ -XXX,XX +XXX,XX @@ void event_notifier_set_handler(EventNotifier *e,
  {
      iohandler_init();
      aio_set_event_notifier(iohandler_ctx, e, false,
 -                           handler, NULL);
 +                           handler, NULL, NULL);
  }
 diff --git a/util/qemu-coroutine-io.c b/util/qemu-coroutine-io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/qemu-coroutine-io.c
 +++ b/util/qemu-coroutine-io.c
@@ -XXX,XX +XXX,XX @@ typedef struct {
  static void fd_coroutine_enter(void *opaque)
  {
      FDYieldUntilData *data = opaque;
 -    aio_set_fd_handler(data->ctx, data->fd, false, NULL, NULL, NULL, NULL);
 +    aio_set_fd_handler(data->ctx, data->fd, false,
 +                       NULL, NULL, NULL, NULL, NULL);
      qemu_coroutine_enter(data->co);
  }
@@ -XXX,XX +XXX,XX @@ void coroutine_fn yield_until_fd_readable(int fd)
      data.co = qemu_coroutine_self();
      data.fd = fd;
      aio_set_fd_handler(
 -        data.ctx, fd, false, fd_coroutine_enter, NULL, NULL, &data);
 +        data.ctx, fd, false, fd_coroutine_enter, NULL, NULL, NULL, &data);
      qemu_coroutine_yield();
  }
 diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/vhost-user-server.c
 +++ b/util/vhost-user-server.c
@@ -XXX,XX +XXX,XX @@ set_watch(VuDev *vu_dev, int fd, int vu_evt,
          vu_fd_watch->cb = cb;
          qemu_set_nonblock(fd);
          aio_set_fd_handler(server->ioc->ctx, fd, true, kick_handler,
 -                           NULL, NULL, vu_fd_watch);
 +                           NULL, NULL, NULL, vu_fd_watch);
          vu_fd_watch->vu_dev = vu_dev;
          vu_fd_watch->pvt = pvt;
      }
@@ -XXX,XX +XXX,XX @@ static void remove_watch(VuDev *vu_dev, int fd)
      if (!vu_fd_watch) {
          return;
      }
 -    aio_set_fd_handler(server->ioc->ctx, fd, true, NULL, NULL, NULL, NULL);
 +    aio_set_fd_handler(server->ioc->ctx, fd, true,
 +                       NULL, NULL, NULL, NULL, NULL);
      QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next);
      g_free(vu_fd_watch);
@@ -XXX,XX +XXX,XX @@ void vhost_user_server_stop(VuServer *server)
          QTAILQ_FOREACH(vu_fd_watch, &server->vu_fd_watches, next) {
              aio_set_fd_handler(server->ctx, vu_fd_watch->fd, true,
 -                               NULL, NULL, NULL, vu_fd_watch);
 +                               NULL, NULL, NULL, NULL, vu_fd_watch);
          }
          qio_channel_shutdown(server->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
@@ -XXX,XX +XXX,XX @@ void vhost_user_server_attach_aio_context(VuServer *server, AioContext *ctx)
      QTAILQ_FOREACH(vu_fd_watch, &server->vu_fd_watches, next) {
          aio_set_fd_handler(ctx, vu_fd_watch->fd, true, kick_handler, NULL,
 -                           NULL, vu_fd_watch);
 +                           NULL, NULL, vu_fd_watch);
      }
      aio_co_schedule(ctx, server->co_trip);
@@ -XXX,XX +XXX,XX @@ void vhost_user_server_detach_aio_context(VuServer *server)
          QTAILQ_FOREACH(vu_fd_watch, &server->vu_fd_watches, next) {
              aio_set_fd_handler(server->ctx, vu_fd_watch->fd, true,
 -                               NULL, NULL, NULL, vu_fd_watch);
 +                               NULL, NULL, NULL, NULL, vu_fd_watch);
          }
          qio_channel_detach_aio_context(server->ioc);
 --
-.34.1
+.40.0

-New patch
+[PULL 11/17] qemu-iotests: test zone append operation
+From: Sam Li <faithilikerun@gmail.com>
+The patch tests zone append writes by reporting the zone wp after
+the completion of the call. "zap -p" option can print the sector
+offset value after completion, which should be the start sector
+where the append write begins.
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20230427172339.3709-4-faithilikerun@gmail.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ qemu-io-cmds.c                     | 75 ++++++++++++++++++++++++++++++
+ tests/qemu-iotests/tests/zoned     | 16 +++++++
+ tests/qemu-iotests/tests/zoned.out | 16 +++++++
+files changed, 107 insertions(+)
+diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
+index XXXXXXX..XXXXXXX 100644
+--- a/qemu-io-cmds.c
++++ b/qemu-io-cmds.c
+@@ -XXX,XX +XXX,XX @@ static const cmdinfo_t zone_reset_cmd = {
+     .oneline = "reset a zone write pointer in zone block device",
+ };
++static int do_aio_zone_append(BlockBackend *blk, QEMUIOVector *qiov,
++                              int64_t *offset, int flags, int *total)
++{
++    int async_ret = NOT_DONE;
++
++    blk_aio_zone_append(blk, offset, qiov, flags, aio_rw_done, &async_ret);
++    while (async_ret == NOT_DONE) {
++        main_loop_wait(false);
++    }
++
++    *total = qiov->size;
++    return async_ret < 0 ? async_ret : 1;
++}
++
++static int zone_append_f(BlockBackend *blk, int argc, char **argv)
++{
++    int ret;
++    bool pflag = false;
++    int flags = 0;
++    int total = 0;
++    int64_t offset;
++    char *buf;
++    int c, nr_iov;
++    int pattern = 0xcd;
++    QEMUIOVector qiov;
++
++    if (optind > argc - 3) {
++        return -EINVAL;
++    }
++
++    if ((c = getopt(argc, argv, "p")) != -1) {
++        pflag = true;
++    }
++
++    offset = cvtnum(argv[optind]);
++    if (offset < 0) {
++        print_cvtnum_err(offset, argv[optind]);
++        return offset;
++    }
++    optind++;
++    nr_iov = argc - optind;
++    buf = create_iovec(blk, &qiov, &argv[optind], nr_iov, pattern,
++                       flags & BDRV_REQ_REGISTERED_BUF);
++    if (buf == NULL) {
++        return -EINVAL;
++    }
++    ret = do_aio_zone_append(blk, &qiov, &offset, flags, &total);
++    if (ret < 0) {
++        printf("zone append failed: %s\n", strerror(-ret));
++        goto out;
++    }
++
++    if (pflag) {
++        printf("After zap done, the append sector is 0x%" PRIx64 "\n",
++               tosector(offset));
++    }
++
++out:
++    qemu_io_free(blk, buf, qiov.size,
++                 flags & BDRV_REQ_REGISTERED_BUF);
++    qemu_iovec_destroy(&qiov);
++    return ret;
++}
++
++static const cmdinfo_t zone_append_cmd = {
++    .name = "zone_append",
++    .altname = "zap",
++    .cfunc = zone_append_f,
++    .argmin = 3,
++    .argmax = 4,
++    .args = "offset len [len..]",
++    .oneline = "append write a number of bytes at a specified offset",
++};
++
+ static int truncate_f(BlockBackend *blk, int argc, char **argv);
+ static const cmdinfo_t truncate_cmd = {
+     .name       = "truncate",
+@@ -XXX,XX +XXX,XX @@ static void __attribute((constructor)) init_qemuio_commands(void)
+     qemuio_add_command(&zone_close_cmd);
+     qemuio_add_command(&zone_finish_cmd);
+     qemuio_add_command(&zone_reset_cmd);
++    qemuio_add_command(&zone_append_cmd);
+     qemuio_add_command(&truncate_cmd);
+     qemuio_add_command(&length_cmd);
+     qemuio_add_command(&info_cmd);
+diff --git a/tests/qemu-iotests/tests/zoned b/tests/qemu-iotests/tests/zoned
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/tests/zoned
++++ b/tests/qemu-iotests/tests/zoned
+@@ -XXX,XX +XXX,XX @@ echo "(5) resetting the second zone"
+ $QEMU_IO $IMG -c "zrs 268435456 268435456"
+ echo "After resetting a zone:"
+ $QEMU_IO $IMG -c "zrp 268435456 1"
++echo
++echo
++echo "(6) append write" # the physical block size of the device is 4096
++$QEMU_IO $IMG -c "zrp 0 1"
++$QEMU_IO $IMG -c "zap -p 0 0x1000 0x2000"
++echo "After appending the first zone firstly:"
++$QEMU_IO $IMG -c "zrp 0 1"
++$QEMU_IO $IMG -c "zap -p 0 0x1000 0x2000"
++echo "After appending the first zone secondly:"
++$QEMU_IO $IMG -c "zrp 0 1"
++$QEMU_IO $IMG -c "zap -p 268435456 0x1000 0x2000"
++echo "After appending the second zone firstly:"
++$QEMU_IO $IMG -c "zrp 268435456 1"
++$QEMU_IO $IMG -c "zap -p 268435456 0x1000 0x2000"
++echo "After appending the second zone secondly:"
++$QEMU_IO $IMG -c "zrp 268435456 1"
+ # success, all done
+ echo "*** done"
+diff --git a/tests/qemu-iotests/tests/zoned.out b/tests/qemu-iotests/tests/zoned.out
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/tests/zoned.out
++++ b/tests/qemu-iotests/tests/zoned.out
+@@ -XXX,XX +XXX,XX @@ start: 0x80000, len 0x80000, cap 0x80000, wptr 0x100000, zcond:14, [type: 2]
+ (5) resetting the second zone
+ After resetting a zone:
+ start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80000, zcond:1, [type: 2]
++
++
++(6) append write
++start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:1, [type: 2]
++After zap done, the append sector is 0x0
++After appending the first zone firstly:
++start: 0x0, len 0x80000, cap 0x80000, wptr 0x18, zcond:2, [type: 2]
++After zap done, the append sector is 0x18
++After appending the first zone secondly:
++start: 0x0, len 0x80000, cap 0x80000, wptr 0x30, zcond:2, [type: 2]
++After zap done, the append sector is 0x80000
++After appending the second zone firstly:
++start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80018, zcond:2, [type: 2]
++After zap done, the append sector is 0x80018
++After appending the second zone secondly:
++start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80030, zcond:2, [type: 2]
+ *** done
+--
+.40.0

-New patch
+[PULL 12/17] block: add some trace events for zone append
+From: Sam Li <faithilikerun@gmail.com>
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20230427172339.3709-5-faithilikerun@gmail.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/file-posix.c | 3 +++
+ block/trace-events | 2 ++
+files changed, 5 insertions(+)
+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 @@ out:
+             if (!BDRV_ZT_IS_CONV(*wp)) {
+                 if (type & QEMU_AIO_ZONE_APPEND) {
+                     *s->offset = *wp;
++                    trace_zbd_zone_append_complete(bs, *s->offset
++                        >> BDRV_SECTOR_BITS);
+                 }
+                 /* Advance the wp if needed */
+                 if (offset + bytes > *wp) {
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_append(BlockDriverState *bs,
+         len += iov_len;
+     }
++    trace_zbd_zone_append(bs, *offset >> BDRV_SECTOR_BITS);
+     return raw_co_prw(bs, *offset, len, qiov, QEMU_AIO_ZONE_APPEND);
+ }
+ #endif
+diff --git a/block/trace-events b/block/trace-events
+index XXXXXXX..XXXXXXX 100644
+--- a/block/trace-events
++++ b/block/trace-events
+@@ -XXX,XX +XXX,XX @@ file_hdev_is_sg(int type, int version) "SG device found: type=%d, version=%d"
+ file_flush_fdatasync_failed(int err) "errno %d"
+ zbd_zone_report(void *bs, unsigned int nr_zones, int64_t sector) "bs %p report %d zones starting at sector offset 0x%" PRIx64 ""
+ zbd_zone_mgmt(void *bs, const char *op_name, int64_t sector, int64_t len) "bs %p %s starts at sector offset 0x%" PRIx64 " over a range of 0x%" PRIx64 " sectors"
++zbd_zone_append(void *bs, int64_t sector) "bs %p append at sector offset 0x%" PRIx64 ""
++zbd_zone_append_complete(void *bs, int64_t sector) "bs %p returns append sector 0x%" PRIx64 ""
+ # ssh.c
+ sftp_error(const char *op, const char *ssh_err, int ssh_err_code, int sftp_err_code) "%s failed: %s (libssh error code: %d, sftp error code: %d)"
+--
+.40.0

-New patch
+[PULL 13/17] include: update virtio_blk headers to v6.3-rc1
+From: Sam Li <faithilikerun@gmail.com>
+Use scripts/update-linux-headers.sh to update headers to 6.3-rc1.
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+[Reran scripts/update-linux-headers.sh on Linux v6.3. The only change
+was the use of __virtioXX types instead of uintXX_t.
+--Stefan]
+Message-Id: <20230407082528.18841-2-faithilikerun@gmail.com>
+---
+ include/standard-headers/drm/drm_fourcc.h    |  12 +++
+ include/standard-headers/linux/ethtool.h     |  48 ++++++++-
+ include/standard-headers/linux/fuse.h        |  45 +++++++-
+ include/standard-headers/linux/pci_regs.h    |   1 +
+ include/standard-headers/linux/vhost_types.h |   2 +
+ include/standard-headers/linux/virtio_blk.h  | 105 +++++++++++++++++++
+ linux-headers/asm-arm64/kvm.h                |   1 +
+ linux-headers/asm-x86/kvm.h                  |  34 +++++-
+ linux-headers/linux/kvm.h                    |   9 ++
+ linux-headers/linux/vfio.h                   |  15 +--
+ linux-headers/linux/vhost.h                  |   8 ++
+files changed, 270 insertions(+), 10 deletions(-)
+diff --git a/include/standard-headers/drm/drm_fourcc.h b/include/standard-headers/drm/drm_fourcc.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/standard-headers/drm/drm_fourcc.h
++++ b/include/standard-headers/drm/drm_fourcc.h
+@@ -XXX,XX +XXX,XX @@ extern "C" {
+  *
+  * The authoritative list of format modifier codes is found in
+  * `include/uapi/drm/drm_fourcc.h`
++ *
++ * Open Source User Waiver
++ * -----------------------
++ *
++ * Because this is the authoritative source for pixel formats and modifiers
++ * referenced by GL, Vulkan extensions and other standards and hence used both
++ * by open source and closed source driver stacks, the usual requirement for an
++ * upstream in-kernel or open source userspace user does not apply.
++ *
++ * To ensure, as much as feasible, compatibility across stacks and avoid
++ * confusion with incompatible enumerations stakeholders for all relevant driver
++ * stacks should approve additions.
+  */
+ #define fourcc_code(a, b, c, d) ((uint32_t)(a) | ((uint32_t)(b) << 8) | \
+diff --git a/include/standard-headers/linux/ethtool.h b/include/standard-headers/linux/ethtool.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/standard-headers/linux/ethtool.h
++++ b/include/standard-headers/linux/ethtool.h
+@@ -XXX,XX +XXX,XX @@ enum ethtool_stringset {
+     ETH_SS_COUNT
+ };
++/**
++ * enum ethtool_mac_stats_src - source of ethtool MAC statistics
++ * @ETHTOOL_MAC_STATS_SRC_AGGREGATE:
++ *    if device supports a MAC merge layer, this retrieves the aggregate
++ *    statistics of the eMAC and pMAC. Otherwise, it retrieves just the
++ *    statistics of the single (express) MAC.
++ * @ETHTOOL_MAC_STATS_SRC_EMAC:
++ *    if device supports a MM layer, this retrieves the eMAC statistics.
++ *    Otherwise, it retrieves the statistics of the single (express) MAC.
++ * @ETHTOOL_MAC_STATS_SRC_PMAC:
++ *    if device supports a MM layer, this retrieves the pMAC statistics.
++ */
++enum ethtool_mac_stats_src {
++    ETHTOOL_MAC_STATS_SRC_AGGREGATE,
++    ETHTOOL_MAC_STATS_SRC_EMAC,
++    ETHTOOL_MAC_STATS_SRC_PMAC,
++};
++
+ /**
+  * enum ethtool_module_power_mode_policy - plug-in module power mode policy
+  * @ETHTOOL_MODULE_POWER_MODE_POLICY_HIGH: Module is always in high power mode.
+@@ -XXX,XX +XXX,XX @@ enum ethtool_podl_pse_pw_d_status {
+     ETHTOOL_PODL_PSE_PW_D_STATUS_ERROR,
+ };
++/**
++ * enum ethtool_mm_verify_status - status of MAC Merge Verify function
++ * @ETHTOOL_MM_VERIFY_STATUS_UNKNOWN:
++ *    verification status is unknown
++ * @ETHTOOL_MM_VERIFY_STATUS_INITIAL:
++ *    the 802.3 Verify State diagram is in the state INIT_VERIFICATION
++ * @ETHTOOL_MM_VERIFY_STATUS_VERIFYING:
++ *    the Verify State diagram is in the state VERIFICATION_IDLE,
++ *    SEND_VERIFY or WAIT_FOR_RESPONSE
++ * @ETHTOOL_MM_VERIFY_STATUS_SUCCEEDED:
++ *    indicates that the Verify State diagram is in the state VERIFIED
++ * @ETHTOOL_MM_VERIFY_STATUS_FAILED:
++ *    the Verify State diagram is in the state VERIFY_FAIL
++ * @ETHTOOL_MM_VERIFY_STATUS_DISABLED:
++ *    verification of preemption operation is disabled
++ */
++enum ethtool_mm_verify_status {
++    ETHTOOL_MM_VERIFY_STATUS_UNKNOWN,
++    ETHTOOL_MM_VERIFY_STATUS_INITIAL,
++    ETHTOOL_MM_VERIFY_STATUS_VERIFYING,
++    ETHTOOL_MM_VERIFY_STATUS_SUCCEEDED,
++    ETHTOOL_MM_VERIFY_STATUS_FAILED,
++    ETHTOOL_MM_VERIFY_STATUS_DISABLED,
++};
++
+ /**
+  * struct ethtool_gstrings - string set for data tagging
+  * @cmd: Command number = %ETHTOOL_GSTRINGS
+@@ -XXX,XX +XXX,XX @@ struct ethtool_rxnfc {
+         uint32_t            rule_cnt;
+         uint32_t            rss_context;
+     };
+-    uint32_t                rule_locs[0];
++    uint32_t                rule_locs[];
+ };
+@@ -XXX,XX +XXX,XX @@ enum ethtool_link_mode_bit_indices {
+     ETHTOOL_LINK_MODE_800000baseDR8_2_Full_BIT     = 96,
+     ETHTOOL_LINK_MODE_800000baseSR8_Full_BIT     = 97,
+     ETHTOOL_LINK_MODE_800000baseVR8_Full_BIT     = 98,
++    ETHTOOL_LINK_MODE_10baseT1S_Full_BIT         = 99,
++    ETHTOOL_LINK_MODE_10baseT1S_Half_BIT         = 100,
++    ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT     = 101,
+     /* must be last entry */
+     __ETHTOOL_LINK_MODE_MASK_NBITS
+diff --git a/include/standard-headers/linux/fuse.h b/include/standard-headers/linux/fuse.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/standard-headers/linux/fuse.h
++++ b/include/standard-headers/linux/fuse.h
+@@ -XXX,XX +XXX,XX @@
+  *  7.38
+  *  - add FUSE_EXPIRE_ONLY flag to fuse_notify_inval_entry
+  *  - add FOPEN_PARALLEL_DIRECT_WRITES
++ *  - add total_extlen to fuse_in_header
++ *  - add FUSE_MAX_NR_SECCTX
++ *  - add extension header
++ *  - add FUSE_EXT_GROUPS
++ *  - add FUSE_CREATE_SUPP_GROUP
+  */
+ #ifndef _LINUX_FUSE_H
+@@ -XXX,XX +XXX,XX @@ struct fuse_file_lock {
+  * FUSE_SECURITY_CTX:    add security context to create, mkdir, symlink, and
+  *            mknod
+  * FUSE_HAS_INODE_DAX:  use per inode DAX
++ * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir,
++ *            symlink and mknod (single group that matches parent)
+  */
+ #define FUSE_ASYNC_READ        (1 << 0)
+ #define FUSE_POSIX_LOCKS    (1 << 1)
+@@ -XXX,XX +XXX,XX @@ struct fuse_file_lock {
+ /* bits 32..63 get shifted down 32 bits into the flags2 field */
+ #define FUSE_SECURITY_CTX    (1ULL << 32)
+ #define FUSE_HAS_INODE_DAX    (1ULL << 33)
++#define FUSE_CREATE_SUPP_GROUP    (1ULL << 34)
+ /**
+  * CUSE INIT request/reply flags
+@@ -XXX,XX +XXX,XX @@ struct fuse_file_lock {
+  */
+ #define FUSE_EXPIRE_ONLY        (1 << 0)
++/**
++ * extension type
++ * FUSE_MAX_NR_SECCTX: maximum value of &fuse_secctx_header.nr_secctx
++ * FUSE_EXT_GROUPS: &fuse_supp_groups extension
++ */
++enum fuse_ext_type {
++    /* Types 0..31 are reserved for fuse_secctx_header */
++    FUSE_MAX_NR_SECCTX    = 31,
++    FUSE_EXT_GROUPS        = 32,
++};
++
+ enum fuse_opcode {
+     FUSE_LOOKUP        = 1,
+     FUSE_FORGET        = 2,  /* no reply */
+@@ -XXX,XX +XXX,XX @@ struct fuse_in_header {
+     uint32_t    uid;
+     uint32_t    gid;
+     uint32_t    pid;
+-    uint32_t    padding;
++    uint16_t    total_extlen; /* length of extensions in 8byte units */
++    uint16_t    padding;
+ };
+ struct fuse_out_header {
+@@ -XXX,XX +XXX,XX @@ struct fuse_secctx_header {
+     uint32_t    nr_secctx;
+ };
++/**
++ * struct fuse_ext_header - extension header
++ * @size: total size of this extension including this header
++ * @type: type of extension
++ *
++ * This is made compatible with fuse_secctx_header by using type values >
++ * FUSE_MAX_NR_SECCTX
++ */
++struct fuse_ext_header {
++    uint32_t    size;
++    uint32_t    type;
++};
++
++/**
++ * struct fuse_supp_groups - Supplementary group extension
++ * @nr_groups: number of supplementary groups
++ * @groups: flexible array of group IDs
++ */
++struct fuse_supp_groups {
++    uint32_t    nr_groups;
++    uint32_t    groups[];
++};
++
+ #endif /* _LINUX_FUSE_H */
+diff --git a/include/standard-headers/linux/pci_regs.h b/include/standard-headers/linux/pci_regs.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/standard-headers/linux/pci_regs.h
++++ b/include/standard-headers/linux/pci_regs.h
+@@ -XXX,XX +XXX,XX @@
+ #define  PCI_EXP_LNKCTL2_TX_MARGIN    0x0380 /* Transmit Margin */
+ #define  PCI_EXP_LNKCTL2_HASD        0x0020 /* HW Autonomous Speed Disable */
+ #define PCI_EXP_LNKSTA2        0x32    /* Link Status 2 */
++#define  PCI_EXP_LNKSTA2_FLIT        0x0400 /* Flit Mode Status */
+ #define PCI_CAP_EXP_ENDPOINT_SIZEOF_V2    0x32    /* end of v2 EPs w/ link */
+ #define PCI_EXP_SLTCAP2        0x34    /* Slot Capabilities 2 */
+ #define  PCI_EXP_SLTCAP2_IBPD    0x00000001 /* In-band PD Disable Supported */
+diff --git a/include/standard-headers/linux/vhost_types.h b/include/standard-headers/linux/vhost_types.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/standard-headers/linux/vhost_types.h
++++ b/include/standard-headers/linux/vhost_types.h
+@@ -XXX,XX +XXX,XX @@ struct vhost_vdpa_iova_range {
+ #define VHOST_BACKEND_F_IOTLB_ASID  0x3
+ /* Device can be suspended */
+ #define VHOST_BACKEND_F_SUSPEND  0x4
++/* Device can be resumed */
++#define VHOST_BACKEND_F_RESUME  0x5
+ #endif
+diff --git a/include/standard-headers/linux/virtio_blk.h b/include/standard-headers/linux/virtio_blk.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/standard-headers/linux/virtio_blk.h
++++ b/include/standard-headers/linux/virtio_blk.h
+@@ -XXX,XX +XXX,XX @@
+ #define VIRTIO_BLK_F_DISCARD    13    /* DISCARD is supported */
+ #define VIRTIO_BLK_F_WRITE_ZEROES    14    /* WRITE ZEROES is supported */
+ #define VIRTIO_BLK_F_SECURE_ERASE    16 /* Secure Erase is supported */
++#define VIRTIO_BLK_F_ZONED        17    /* Zoned block device */
+ /* Legacy feature bits */
+ #ifndef VIRTIO_BLK_NO_LEGACY
+@@ -XXX,XX +XXX,XX @@ struct virtio_blk_config {
+     /* Secure erase commands must be aligned to this number of sectors. */
+     __virtio32 secure_erase_sector_alignment;
++    /* Zoned block device characteristics (if VIRTIO_BLK_F_ZONED) */
++    struct virtio_blk_zoned_characteristics {
++        __virtio32 zone_sectors;
++        __virtio32 max_open_zones;
++        __virtio32 max_active_zones;
++        __virtio32 max_append_sectors;
++        __virtio32 write_granularity;
++        uint8_t model;
++        uint8_t unused2[3];
++    } zoned;
+ } QEMU_PACKED;
+ /*
+@@ -XXX,XX +XXX,XX @@ struct virtio_blk_config {
+ /* Secure erase command */
+ #define VIRTIO_BLK_T_SECURE_ERASE    14
++/* Zone append command */
++#define VIRTIO_BLK_T_ZONE_APPEND    15
++
++/* Report zones command */
++#define VIRTIO_BLK_T_ZONE_REPORT    16
++
++/* Open zone command */
++#define VIRTIO_BLK_T_ZONE_OPEN      18
++
++/* Close zone command */
++#define VIRTIO_BLK_T_ZONE_CLOSE     20
++
++/* Finish zone command */
++#define VIRTIO_BLK_T_ZONE_FINISH    22
++
++/* Reset zone command */
++#define VIRTIO_BLK_T_ZONE_RESET     24
++
++/* Reset All zones command */
++#define VIRTIO_BLK_T_ZONE_RESET_ALL 26
++
+ #ifndef VIRTIO_BLK_NO_LEGACY
+ /* Barrier before this op. */
+ #define VIRTIO_BLK_T_BARRIER    0x80000000
+@@ -XXX,XX +XXX,XX @@ struct virtio_blk_outhdr {
+     __virtio64 sector;
+ };
++/*
++ * Supported zoned device models.
++ */
++
++/* Regular block device */
++#define VIRTIO_BLK_Z_NONE      0
++/* Host-managed zoned device */
++#define VIRTIO_BLK_Z_HM        1
++/* Host-aware zoned device */
++#define VIRTIO_BLK_Z_HA        2
++
++/*
++ * Zone descriptor. A part of VIRTIO_BLK_T_ZONE_REPORT command reply.
++ */
++struct virtio_blk_zone_descriptor {
++    /* Zone capacity */
++    __virtio64 z_cap;
++    /* The starting sector of the zone */
++    __virtio64 z_start;
++    /* Zone write pointer position in sectors */
++    __virtio64 z_wp;
++    /* Zone type */
++    uint8_t z_type;
++    /* Zone state */
++    uint8_t z_state;
++    uint8_t reserved[38];
++};
++
++struct virtio_blk_zone_report {
++    __virtio64 nr_zones;
++    uint8_t reserved[56];
++    struct virtio_blk_zone_descriptor zones[];
++};
++
++/*
++ * Supported zone types.
++ */
++
++/* Conventional zone */
++#define VIRTIO_BLK_ZT_CONV         1
++/* Sequential Write Required zone */
++#define VIRTIO_BLK_ZT_SWR          2
++/* Sequential Write Preferred zone */
++#define VIRTIO_BLK_ZT_SWP          3
++
++/*
++ * Zone states that are available for zones of all types.
++ */
++
++/* Not a write pointer (conventional zones only) */
++#define VIRTIO_BLK_ZS_NOT_WP       0
++/* Empty */
++#define VIRTIO_BLK_ZS_EMPTY        1
++/* Implicitly Open */
++#define VIRTIO_BLK_ZS_IOPEN        2
++/* Explicitly Open */
++#define VIRTIO_BLK_ZS_EOPEN        3
++/* Closed */
++#define VIRTIO_BLK_ZS_CLOSED       4
++/* Read-Only */
++#define VIRTIO_BLK_ZS_RDONLY       13
++/* Full */
++#define VIRTIO_BLK_ZS_FULL         14
++/* Offline */
++#define VIRTIO_BLK_ZS_OFFLINE      15
++
+ /* Unmap this range (only valid for write zeroes command) */
+ #define VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP    0x00000001
+@@ -XXX,XX +XXX,XX @@ struct virtio_scsi_inhdr {
+ #define VIRTIO_BLK_S_OK        0
+ #define VIRTIO_BLK_S_IOERR    1
+ #define VIRTIO_BLK_S_UNSUPP    2
++
++/* Error codes that are specific to zoned block devices */
++#define VIRTIO_BLK_S_ZONE_INVALID_CMD     3
++#define VIRTIO_BLK_S_ZONE_UNALIGNED_WP    4
++#define VIRTIO_BLK_S_ZONE_OPEN_RESOURCE   5
++#define VIRTIO_BLK_S_ZONE_ACTIVE_RESOURCE 6
++
+ #endif /* _LINUX_VIRTIO_BLK_H */
+diff --git a/linux-headers/asm-arm64/kvm.h b/linux-headers/asm-arm64/kvm.h
+index XXXXXXX..XXXXXXX 100644
+--- a/linux-headers/asm-arm64/kvm.h
++++ b/linux-headers/asm-arm64/kvm.h
+@@ -XXX,XX +XXX,XX @@ struct kvm_regs {
+ #define KVM_ARM_VCPU_SVE        4 /* enable SVE for this CPU */
+ #define KVM_ARM_VCPU_PTRAUTH_ADDRESS    5 /* VCPU uses address authentication */
+ #define KVM_ARM_VCPU_PTRAUTH_GENERIC    6 /* VCPU uses generic authentication */
++#define KVM_ARM_VCPU_HAS_EL2        7 /* Support nested virtualization */
+ struct kvm_vcpu_init {
+     __u32 target;
+diff --git a/linux-headers/asm-x86/kvm.h b/linux-headers/asm-x86/kvm.h
+index XXXXXXX..XXXXXXX 100644
+--- a/linux-headers/asm-x86/kvm.h
++++ b/linux-headers/asm-x86/kvm.h
+@@ -XXX,XX +XXX,XX @@
+ #include <linux/types.h>
+ #include <linux/ioctl.h>
++#include <linux/stddef.h>
+ #define KVM_PIO_PAGE_OFFSET 1
+ #define KVM_COALESCED_MMIO_PAGE_OFFSET 2
+@@ -XXX,XX +XXX,XX @@ struct kvm_nested_state {
+      * KVM_{GET,PUT}_NESTED_STATE ioctl values.
+      */
+     union {
+-        struct kvm_vmx_nested_state_data vmx[0];
+-        struct kvm_svm_nested_state_data svm[0];
++        __DECLARE_FLEX_ARRAY(struct kvm_vmx_nested_state_data, vmx);
++        __DECLARE_FLEX_ARRAY(struct kvm_svm_nested_state_data, svm);
+     } data;
+ };
+@@ -XXX,XX +XXX,XX @@ struct kvm_pmu_event_filter {
+ #define KVM_PMU_EVENT_ALLOW 0
+ #define KVM_PMU_EVENT_DENY 1
++#define KVM_PMU_EVENT_FLAG_MASKED_EVENTS BIT(0)
++#define KVM_PMU_EVENT_FLAGS_VALID_MASK (KVM_PMU_EVENT_FLAG_MASKED_EVENTS)
++
++/*
++ * Masked event layout.
++ * Bits   Description
++ * ----   -----------
++ * 7:0    event select (low bits)
++ * 15:8   umask match
++ * 31:16  unused
++ * 35:32  event select (high bits)
++ * 36:54  unused
++ * 55     exclude bit
++ * 63:56  umask mask
++ */
++
++#define KVM_PMU_ENCODE_MASKED_ENTRY(event_select, mask, match, exclude) \
++    (((event_select) & 0xFFULL) | (((event_select) & 0XF00ULL) << 24) | \
++    (((mask) & 0xFFULL) << 56) | \
++    (((match) & 0xFFULL) << 8) | \
++    ((__u64)(!!(exclude)) << 55))
++
++#define KVM_PMU_MASKED_ENTRY_EVENT_SELECT \
++    (GENMASK_ULL(7, 0) | GENMASK_ULL(35, 32))
++#define KVM_PMU_MASKED_ENTRY_UMASK_MASK        (GENMASK_ULL(63, 56))
++#define KVM_PMU_MASKED_ENTRY_UMASK_MATCH    (GENMASK_ULL(15, 8))
++#define KVM_PMU_MASKED_ENTRY_EXCLUDE        (BIT_ULL(55))
++#define KVM_PMU_MASKED_ENTRY_UMASK_MASK_SHIFT    (56)
++
+ /* for KVM_{GET,SET,HAS}_DEVICE_ATTR */
+ #define KVM_VCPU_TSC_CTRL 0 /* control group for the timestamp counter (TSC) */
+ #define   KVM_VCPU_TSC_OFFSET 0 /* attribute for the TSC offset */
+diff --git a/linux-headers/linux/kvm.h b/linux-headers/linux/kvm.h
+index XXXXXXX..XXXXXXX 100644
+--- a/linux-headers/linux/kvm.h
++++ b/linux-headers/linux/kvm.h
+@@ -XXX,XX +XXX,XX @@ struct kvm_s390_mem_op {
+         struct {
+             __u8 ar;    /* the access register number */
+             __u8 key;    /* access key, ignored if flag unset */
++            __u8 pad1[6];    /* ignored */
++            __u64 old_addr;    /* ignored if cmpxchg flag unset */
+         };
+         __u32 sida_offset; /* offset into the sida */
+         __u8 reserved[32]; /* ignored */
+@@ -XXX,XX +XXX,XX @@ struct kvm_s390_mem_op {
+ #define KVM_S390_MEMOP_SIDA_WRITE    3
+ #define KVM_S390_MEMOP_ABSOLUTE_READ    4
+ #define KVM_S390_MEMOP_ABSOLUTE_WRITE    5
++#define KVM_S390_MEMOP_ABSOLUTE_CMPXCHG    6
++
+ /* flags for kvm_s390_mem_op->flags */
+ #define KVM_S390_MEMOP_F_CHECK_ONLY        (1ULL << 0)
+ #define KVM_S390_MEMOP_F_INJECT_EXCEPTION    (1ULL << 1)
+ #define KVM_S390_MEMOP_F_SKEY_PROTECTION    (1ULL << 2)
++/* flags specifying extension support via KVM_CAP_S390_MEM_OP_EXTENSION */
++#define KVM_S390_MEMOP_EXTENSION_CAP_BASE    (1 << 0)
++#define KVM_S390_MEMOP_EXTENSION_CAP_CMPXCHG    (1 << 1)
++
+ /* for KVM_INTERRUPT */
+ struct kvm_interrupt {
+     /* in */
+@@ -XXX,XX +XXX,XX @@ struct kvm_ppc_resize_hpt {
+ #define KVM_CAP_DIRTY_LOG_RING_ACQ_REL 223
+ #define KVM_CAP_S390_PROTECTED_ASYNC_DISABLE 224
+ #define KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP 225
++#define KVM_CAP_PMU_EVENT_MASKED_EVENTS 226
+ #ifdef KVM_CAP_IRQ_ROUTING
+diff --git a/linux-headers/linux/vfio.h b/linux-headers/linux/vfio.h
+index XXXXXXX..XXXXXXX 100644
+--- a/linux-headers/linux/vfio.h
++++ b/linux-headers/linux/vfio.h
+@@ -XXX,XX +XXX,XX @@
+ /* Supports VFIO_DMA_UNMAP_FLAG_ALL */
+ #define VFIO_UNMAP_ALL            9
+-/* Supports the vaddr flag for DMA map and unmap */
++/*
++ * Supports the vaddr flag for DMA map and unmap.  Not supported for mediated
++ * devices, so this capability is subject to change as groups are added or
++ * removed.
++ */
+ #define VFIO_UPDATE_VADDR        10
+ /*
+@@ -XXX,XX +XXX,XX @@ struct vfio_iommu_type1_info_dma_avail {
+  * Map process virtual addresses to IO virtual addresses using the
+  * provided struct vfio_dma_map. Caller sets argsz. READ &/ WRITE required.
+  *
+- * If flags & VFIO_DMA_MAP_FLAG_VADDR, update the base vaddr for iova, and
+- * unblock translation of host virtual addresses in the iova range.  The vaddr
++ * If flags & VFIO_DMA_MAP_FLAG_VADDR, update the base vaddr for iova. The vaddr
+  * must have previously been invalidated with VFIO_DMA_UNMAP_FLAG_VADDR.  To
+  * maintain memory consistency within the user application, the updated vaddr
+  * must address the same memory object as originally mapped.  Failure to do so
+@@ -XXX,XX +XXX,XX @@ struct vfio_bitmap {
+  * must be 0.  This cannot be combined with the get-dirty-bitmap flag.
+  *
+  * If flags & VFIO_DMA_UNMAP_FLAG_VADDR, do not unmap, but invalidate host
+- * virtual addresses in the iova range.  Tasks that attempt to translate an
+- * iova's vaddr will block.  DMA to already-mapped pages continues.  This
+- * cannot be combined with the get-dirty-bitmap flag.
++ * virtual addresses in the iova range.  DMA to already-mapped pages continues.
++ * Groups may not be added to the container while any addresses are invalid.
++ * This cannot be combined with the get-dirty-bitmap flag.
+  */
+ struct vfio_iommu_type1_dma_unmap {
+     __u32    argsz;
+diff --git a/linux-headers/linux/vhost.h b/linux-headers/linux/vhost.h
+index XXXXXXX..XXXXXXX 100644
+--- a/linux-headers/linux/vhost.h
++++ b/linux-headers/linux/vhost.h
+@@ -XXX,XX +XXX,XX @@
+  */
+ #define VHOST_VDPA_SUSPEND        _IO(VHOST_VIRTIO, 0x7D)
++/* Resume a device so it can resume processing virtqueue requests
++ *
++ * After the return of this ioctl the device will have restored all the
++ * necessary states and it is fully operational to continue processing the
++ * virtqueue descriptors.
++ */
++#define VHOST_VDPA_RESUME        _IO(VHOST_VIRTIO, 0x7E)
++
+ #endif
+--
+.40.0

-[PULL 3/6] virtio-blk: drop unused virtio_blk_handle_vq() return value
+[PULL 14/17] virtio-blk: add zoned storage emulation for zoned devices
-The return value of virtio_blk_handle_vq() is no longer used. Get rid of
+From: Sam Li <faithilikerun@gmail.com>
 it. This is a step towards unifying the dataplane and non-dataplane
 virtqueue handler functions.
-Prepare virtio_blk_handle_output() to be used by both dataplane and
+This patch extends virtio-blk emulation to handle zoned device commands
-non-dataplane by making the condition for starting ioeventfd more
+by calling the new block layer APIs to perform zoned device I/O on
-specific. This way it won't trigger when dataplane has already been
+behalf of the guest. It supports Report Zone, four zone oparations (open,
-started.
+close, finish, reset), and Append Zone.
+The VIRTIO_BLK_F_ZONED feature bit will only be set if the host does
+support zoned block devices. Regular block devices(conventional zones)
+will not be set.
+The guest os can use blktests, fio to test those commands on zoned devices.
+Furthermore, using zonefs to test zone append write is also supported.
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
+Message-Id: <20230407082528.18841-3-faithilikerun@gmail.com>
 Message-id: 20211207132336.36627-4-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/hw/virtio/virtio-blk.h |  2 +-
+ hw/block/virtio-blk-common.c |   2 +
- hw/block/virtio-blk.c          | 14 +++-----------
+ hw/block/virtio-blk.c        | 389 +++++++++++++++++++++++++++++++++++
-files changed, 4 insertions(+), 12 deletions(-)
+ hw/virtio/virtio-qmp.c       |   2 +
 files changed, 393 insertions(+)
-diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h
+diff --git a/hw/block/virtio-blk-common.c b/hw/block/virtio-blk-common.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/hw/virtio/virtio-blk.h
+--- a/hw/block/virtio-blk-common.c
-+++ b/include/hw/virtio/virtio-blk.h
++++ b/hw/block/virtio-blk-common.c
-@@ -XXX,XX +XXX,XX @@ typedef struct MultiReqBuffer {
+@@ -XXX,XX +XXX,XX @@ static const VirtIOFeature feature_sizes[] = {
-     bool is_write;
+      .end = endof(struct virtio_blk_config, discard_sector_alignment)},
- } MultiReqBuffer;
+     {.flags = 1ULL << VIRTIO_BLK_F_WRITE_ZEROES,
+      .end = endof(struct virtio_blk_config, write_zeroes_may_unmap)},
--bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq);
++    {.flags = 1ULL << VIRTIO_BLK_F_ZONED,
-+void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq);
++     .end = endof(struct virtio_blk_config, zoned)},
- void virtio_blk_process_queued_requests(VirtIOBlock *s, bool is_bh);
+     {}
+ };
- #endif
 diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/virtio-blk.c
 +++ b/hw/block/virtio-blk.c
+@@ -XXX,XX +XXX,XX @@
+ #include "qemu/module.h"
+ #include "qemu/error-report.h"
+ #include "qemu/main-loop.h"
++#include "block/block_int.h"
+ #include "trace.h"
+ #include "hw/block/block.h"
+ #include "hw/qdev-properties.h"
+@@ -XXX,XX +XXX,XX @@ err:
+     return err_status;
+ }
++typedef struct ZoneCmdData {
++    VirtIOBlockReq *req;
++    struct iovec *in_iov;
++    unsigned in_num;
++    union {
++        struct {
++            unsigned int nr_zones;
++            BlockZoneDescriptor *zones;
++        } zone_report_data;
++        struct {
++            int64_t offset;
++        } zone_append_data;
++    };
++} ZoneCmdData;
++
++/*
++ * check zoned_request: error checking before issuing requests. If all checks
++ * passed, return true.
++ * append: true if only zone append requests issued.
++ */
++static bool check_zoned_request(VirtIOBlock *s, int64_t offset, int64_t len,
++                             bool append, uint8_t *status) {
++    BlockDriverState *bs = blk_bs(s->blk);
++    int index;
++
++    if (!virtio_has_feature(s->host_features, VIRTIO_BLK_F_ZONED)) {
++        *status = VIRTIO_BLK_S_UNSUPP;
++        return false;
++    }
++
++    if (offset < 0 || len < 0 || len > (bs->total_sectors << BDRV_SECTOR_BITS)
++        || offset > (bs->total_sectors << BDRV_SECTOR_BITS) - len) {
++        *status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
++        return false;
++    }
++
++    if (append) {
++        if (bs->bl.write_granularity) {
++            if ((offset % bs->bl.write_granularity) != 0) {
++                *status = VIRTIO_BLK_S_ZONE_UNALIGNED_WP;
++                return false;
++            }
++        }
++
++        index = offset / bs->bl.zone_size;
++        if (BDRV_ZT_IS_CONV(bs->wps->wp[index])) {
++            *status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
++            return false;
++        }
++
++        if (len / 512 > bs->bl.max_append_sectors) {
++            if (bs->bl.max_append_sectors == 0) {
++                *status = VIRTIO_BLK_S_UNSUPP;
++            } else {
++                *status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
++            }
++            return false;
++        }
++    }
++    return true;
++}
++
++static void virtio_blk_zone_report_complete(void *opaque, int ret)
++{
++    ZoneCmdData *data = opaque;
++    VirtIOBlockReq *req = data->req;
++    VirtIOBlock *s = req->dev;
++    VirtIODevice *vdev = VIRTIO_DEVICE(req->dev);
++    struct iovec *in_iov = data->in_iov;
++    unsigned in_num = data->in_num;
++    int64_t zrp_size, n, j = 0;
++    int64_t nz = data->zone_report_data.nr_zones;
++    int8_t err_status = VIRTIO_BLK_S_OK;
++
++    if (ret) {
++        err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
++        goto out;
++    }
++
++    struct virtio_blk_zone_report zrp_hdr = (struct virtio_blk_zone_report) {
++        .nr_zones = cpu_to_le64(nz),
++    };
++    zrp_size = sizeof(struct virtio_blk_zone_report)
++               + sizeof(struct virtio_blk_zone_descriptor) * nz;
++    n = iov_from_buf(in_iov, in_num, 0, &zrp_hdr, sizeof(zrp_hdr));
++    if (n != sizeof(zrp_hdr)) {
++        virtio_error(vdev, "Driver provided input buffer that is too small!");
++        err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
++        goto out;
++    }
++
++    for (size_t i = sizeof(zrp_hdr); i < zrp_size;
++        i += sizeof(struct virtio_blk_zone_descriptor), ++j) {
++        struct virtio_blk_zone_descriptor desc =
++            (struct virtio_blk_zone_descriptor) {
++                .z_start = cpu_to_le64(data->zone_report_data.zones[j].start
++                    >> BDRV_SECTOR_BITS),
++                .z_cap = cpu_to_le64(data->zone_report_data.zones[j].cap
++                    >> BDRV_SECTOR_BITS),
++                .z_wp = cpu_to_le64(data->zone_report_data.zones[j].wp
++                    >> BDRV_SECTOR_BITS),
++        };
++
++        switch (data->zone_report_data.zones[j].type) {
++        case BLK_ZT_CONV:
++            desc.z_type = VIRTIO_BLK_ZT_CONV;
++            break;
++        case BLK_ZT_SWR:
++            desc.z_type = VIRTIO_BLK_ZT_SWR;
++            break;
++        case BLK_ZT_SWP:
++            desc.z_type = VIRTIO_BLK_ZT_SWP;
++            break;
++        default:
++            g_assert_not_reached();
++        }
++
++        switch (data->zone_report_data.zones[j].state) {
++        case BLK_ZS_RDONLY:
++            desc.z_state = VIRTIO_BLK_ZS_RDONLY;
++            break;
++        case BLK_ZS_OFFLINE:
++            desc.z_state = VIRTIO_BLK_ZS_OFFLINE;
++            break;
++        case BLK_ZS_EMPTY:
++            desc.z_state = VIRTIO_BLK_ZS_EMPTY;
++            break;
++        case BLK_ZS_CLOSED:
++            desc.z_state = VIRTIO_BLK_ZS_CLOSED;
++            break;
++        case BLK_ZS_FULL:
++            desc.z_state = VIRTIO_BLK_ZS_FULL;
++            break;
++        case BLK_ZS_EOPEN:
++            desc.z_state = VIRTIO_BLK_ZS_EOPEN;
++            break;
++        case BLK_ZS_IOPEN:
++            desc.z_state = VIRTIO_BLK_ZS_IOPEN;
++            break;
++        case BLK_ZS_NOT_WP:
++            desc.z_state = VIRTIO_BLK_ZS_NOT_WP;
++            break;
++        default:
++            g_assert_not_reached();
++        }
++
++        /* TODO: it takes O(n^2) time complexity. Optimizations required. */
++        n = iov_from_buf(in_iov, in_num, i, &desc, sizeof(desc));
++        if (n != sizeof(desc)) {
++            virtio_error(vdev, "Driver provided input buffer "
++                               "for descriptors that is too small!");
++            err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
++        }
++    }
++
++out:
++    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
++    virtio_blk_req_complete(req, err_status);
++    virtio_blk_free_request(req);
++    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
++    g_free(data->zone_report_data.zones);
++    g_free(data);
++}
++
++static void virtio_blk_handle_zone_report(VirtIOBlockReq *req,
++                                         struct iovec *in_iov,
++                                         unsigned in_num)
++{
++    VirtIOBlock *s = req->dev;
++    VirtIODevice *vdev = VIRTIO_DEVICE(s);
++    unsigned int nr_zones;
++    ZoneCmdData *data;
++    int64_t zone_size, offset;
++    uint8_t err_status;
++
++    if (req->in_len < sizeof(struct virtio_blk_inhdr) +
++            sizeof(struct virtio_blk_zone_report) +
++            sizeof(struct virtio_blk_zone_descriptor)) {
++        virtio_error(vdev, "in buffer too small for zone report");
++        return;
++    }
++
++    /* start byte offset of the zone report */
++    offset = virtio_ldq_p(vdev, &req->out.sector) << BDRV_SECTOR_BITS;
++    if (!check_zoned_request(s, offset, 0, false, &err_status)) {
++        goto out;
++    }
++    nr_zones = (req->in_len - sizeof(struct virtio_blk_inhdr) -
++                sizeof(struct virtio_blk_zone_report)) /
++               sizeof(struct virtio_blk_zone_descriptor);
++
++    zone_size = sizeof(BlockZoneDescriptor) * nr_zones;
++    data = g_malloc(sizeof(ZoneCmdData));
++    data->req = req;
++    data->in_iov = in_iov;
++    data->in_num = in_num;
++    data->zone_report_data.nr_zones = nr_zones;
++    data->zone_report_data.zones = g_malloc(zone_size),
++
++    blk_aio_zone_report(s->blk, offset, &data->zone_report_data.nr_zones,
++                        data->zone_report_data.zones,
++                        virtio_blk_zone_report_complete, data);
++    return;
++out:
++    virtio_blk_req_complete(req, err_status);
++    virtio_blk_free_request(req);
++}
++
++static void virtio_blk_zone_mgmt_complete(void *opaque, int ret)
++{
++    VirtIOBlockReq *req = opaque;
++    VirtIOBlock *s = req->dev;
++    int8_t err_status = VIRTIO_BLK_S_OK;
++
++    if (ret) {
++        err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
++    }
++
++    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
++    virtio_blk_req_complete(req, err_status);
++    virtio_blk_free_request(req);
++    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
++}
++
++static int virtio_blk_handle_zone_mgmt(VirtIOBlockReq *req, BlockZoneOp op)
++{
++    VirtIOBlock *s = req->dev;
++    VirtIODevice *vdev = VIRTIO_DEVICE(s);
++    BlockDriverState *bs = blk_bs(s->blk);
++    int64_t offset = virtio_ldq_p(vdev, &req->out.sector) << BDRV_SECTOR_BITS;
++    uint64_t len;
++    uint64_t capacity = bs->total_sectors << BDRV_SECTOR_BITS;
++    uint8_t err_status = VIRTIO_BLK_S_OK;
++
++    uint32_t type = virtio_ldl_p(vdev, &req->out.type);
++    if (type == VIRTIO_BLK_T_ZONE_RESET_ALL) {
++        /* Entire drive capacity */
++        offset = 0;
++        len = capacity;
++    } else {
++        if (bs->bl.zone_size > capacity - offset) {
++            /* The zoned device allows the last smaller zone. */
++            len = capacity - bs->bl.zone_size * (bs->bl.nr_zones - 1);
++        } else {
++            len = bs->bl.zone_size;
++        }
++    }
++
++    if (!check_zoned_request(s, offset, len, false, &err_status)) {
++        goto out;
++    }
++
++    blk_aio_zone_mgmt(s->blk, op, offset, len,
++                      virtio_blk_zone_mgmt_complete, req);
++
++    return 0;
++out:
++    virtio_blk_req_complete(req, err_status);
++    virtio_blk_free_request(req);
++    return err_status;
++}
++
++static void virtio_blk_zone_append_complete(void *opaque, int ret)
++{
++    ZoneCmdData *data = opaque;
++    VirtIOBlockReq *req = data->req;
++    VirtIOBlock *s = req->dev;
++    VirtIODevice *vdev = VIRTIO_DEVICE(req->dev);
++    int64_t append_sector, n;
++    uint8_t err_status = VIRTIO_BLK_S_OK;
++
++    if (ret) {
++        err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
++        goto out;
++    }
++
++    virtio_stq_p(vdev, &append_sector,
++                 data->zone_append_data.offset >> BDRV_SECTOR_BITS);
++    n = iov_from_buf(data->in_iov, data->in_num, 0, &append_sector,
++                     sizeof(append_sector));
++    if (n != sizeof(append_sector)) {
++        virtio_error(vdev, "Driver provided input buffer less than size of "
++                           "append_sector");
++        err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
++        goto out;
++    }
++
++out:
++    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
++    virtio_blk_req_complete(req, err_status);
++    virtio_blk_free_request(req);
++    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
++    g_free(data);
++}
++
++static int virtio_blk_handle_zone_append(VirtIOBlockReq *req,
++                                         struct iovec *out_iov,
++                                         struct iovec *in_iov,
++                                         uint64_t out_num,
++                                         unsigned in_num) {
++    VirtIOBlock *s = req->dev;
++    VirtIODevice *vdev = VIRTIO_DEVICE(s);
++    uint8_t err_status = VIRTIO_BLK_S_OK;
++
++    int64_t offset = virtio_ldq_p(vdev, &req->out.sector) << BDRV_SECTOR_BITS;
++    int64_t len = iov_size(out_iov, out_num);
++
++    if (!check_zoned_request(s, offset, len, true, &err_status)) {
++        goto out;
++    }
++
++    ZoneCmdData *data = g_malloc(sizeof(ZoneCmdData));
++    data->req = req;
++    data->in_iov = in_iov;
++    data->in_num = in_num;
++    data->zone_append_data.offset = offset;
++    qemu_iovec_init_external(&req->qiov, out_iov, out_num);
++    blk_aio_zone_append(s->blk, &data->zone_append_data.offset, &req->qiov, 0,
++                        virtio_blk_zone_append_complete, data);
++    return 0;
++
++out:
++    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
++    virtio_blk_req_complete(req, err_status);
++    virtio_blk_free_request(req);
++    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
++    return err_status;
++}
++
+ static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
+ {
+     uint32_t type;
 @@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
-     return 0;
+     case VIRTIO_BLK_T_FLUSH:
          virtio_blk_handle_flush(req, mrb);
          break;
 +    case VIRTIO_BLK_T_ZONE_REPORT:
 +        virtio_blk_handle_zone_report(req, in_iov, in_num);
 +        break;
 +    case VIRTIO_BLK_T_ZONE_OPEN:
 +        virtio_blk_handle_zone_mgmt(req, BLK_ZO_OPEN);
 +        break;
 +    case VIRTIO_BLK_T_ZONE_CLOSE:
 +        virtio_blk_handle_zone_mgmt(req, BLK_ZO_CLOSE);
 +        break;
 +    case VIRTIO_BLK_T_ZONE_FINISH:
 +        virtio_blk_handle_zone_mgmt(req, BLK_ZO_FINISH);
 +        break;
 +    case VIRTIO_BLK_T_ZONE_RESET:
 +        virtio_blk_handle_zone_mgmt(req, BLK_ZO_RESET);
 +        break;
 +    case VIRTIO_BLK_T_ZONE_RESET_ALL:
 +        virtio_blk_handle_zone_mgmt(req, BLK_ZO_RESET);
 +        break;
      case VIRTIO_BLK_T_SCSI_CMD:
          virtio_blk_handle_scsi(req);
          break;
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
          virtio_blk_free_request(req);
          break;
      }
 +    case VIRTIO_BLK_T_ZONE_APPEND & ~VIRTIO_BLK_T_OUT:
 +        /*
 +         * Passing out_iov/out_num and in_iov/in_num is not safe
 +         * to access req->elem.out_sg directly because it may be
 +         * modified by virtio_blk_handle_request().
 +         */
 +        virtio_blk_handle_zone_append(req, out_iov, in_iov, out_num, in_num);
 +        break;
      /*
       * VIRTIO_BLK_T_DISCARD and VIRTIO_BLK_T_WRITE_ZEROES are defined with
       * VIRTIO_BLK_T_OUT flag set. We masked this flag in the switch statement,
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
  {
      VirtIOBlock *s = VIRTIO_BLK(vdev);
      BlockConf *conf = &s->conf.conf;
 +    BlockDriverState *bs = blk_bs(s->blk);
      struct virtio_blk_config blkcfg;
      uint64_t capacity;
      int64_t length;
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
          blkcfg.write_zeroes_may_unmap = 1;
          virtio_stl_p(vdev, &blkcfg.max_write_zeroes_seg, 1);
      }
 +    if (bs->bl.zoned != BLK_Z_NONE) {
 +        switch (bs->bl.zoned) {
 +        case BLK_Z_HM:
 +            blkcfg.zoned.model = VIRTIO_BLK_Z_HM;
 +            break;
 +        case BLK_Z_HA:
 +            blkcfg.zoned.model = VIRTIO_BLK_Z_HA;
 +            break;
 +        default:
 +            g_assert_not_reached();
 +        }
 +
 +        virtio_stl_p(vdev, &blkcfg.zoned.zone_sectors,
 +                     bs->bl.zone_size / 512);
 +        virtio_stl_p(vdev, &blkcfg.zoned.max_active_zones,
 +                     bs->bl.max_active_zones);
 +        virtio_stl_p(vdev, &blkcfg.zoned.max_open_zones,
 +                     bs->bl.max_open_zones);
 +        virtio_stl_p(vdev, &blkcfg.zoned.write_granularity, blk_size);
 +        virtio_stl_p(vdev, &blkcfg.zoned.max_append_sectors,
 +                     bs->bl.max_append_sectors);
 +    } else {
 +        blkcfg.zoned.model = VIRTIO_BLK_Z_NONE;
 +    }
      memcpy(config, &blkcfg, s->config_size);
  }
--bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
-+void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
+     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
- {
+     VirtIOBlock *s = VIRTIO_BLK(dev);
-     VirtIOBlockReq *req;
+     VirtIOBlkConf *conf = &s->conf;
-     MultiReqBuffer mrb = {};
++    BlockDriverState *bs = blk_bs(conf->conf.blk);
-     bool suppress_notifications = virtio_queue_get_notification(vq);
+     Error *err = NULL;
--    bool progress = false;
+     unsigned i;
-     aio_context_acquire(blk_get_aio_context(s->blk));
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
-     blk_io_plug(s->blk);
+         return;
@@ -XXX,XX +XXX,XX @@ bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
          }
          while ((req = virtio_blk_get_request(s, vq))) {
 -            progress = true;
              if (virtio_blk_handle_request(req, &mrb)) {
                  virtqueue_detach_element(req->vq, &req->elem, 0);
                  virtio_blk_free_request(req);
@@ -XXX,XX +XXX,XX @@ bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
      blk_io_unplug(s->blk);
      aio_context_release(blk_get_aio_context(s->blk));
 -    return progress;
 -}
 -
 -static void virtio_blk_handle_output_do(VirtIOBlock *s, VirtQueue *vq)
 -{
 -    virtio_blk_handle_vq(s, vq);
  }
  static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
  {
      VirtIOBlock *s = (VirtIOBlock *)vdev;
 -    if (s->dataplane) {
 +    if (s->dataplane && !s->dataplane_started) {
          /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start
           * dataplane here instead of waiting for .set_status().
           */
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
              return;
          }
      }
--    virtio_blk_handle_output_do(s, vq);
-+    virtio_blk_handle_vq(s, vq);
++    if (bs->bl.zoned != BLK_Z_NONE) {
- }
++        virtio_add_feature(&s->host_features, VIRTIO_BLK_F_ZONED);
++        if (bs->bl.zoned == BLK_Z_HM) {
- void virtio_blk_process_queued_requests(VirtIOBlock *s, bool is_bh)
++            virtio_clear_feature(&s->host_features, VIRTIO_BLK_F_DISCARD);
 +        }
 +    }
 +
      if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD) &&
          (!conf->max_discard_sectors ||
           conf->max_discard_sectors > BDRV_REQUEST_MAX_SECTORS)) {
 diff --git a/hw/virtio/virtio-qmp.c b/hw/virtio/virtio-qmp.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/virtio/virtio-qmp.c
 +++ b/hw/virtio/virtio-qmp.c
@@ -XXX,XX +XXX,XX @@ static const qmp_virtio_feature_map_t virtio_blk_feature_map[] = {
              "VIRTIO_BLK_F_DISCARD: Discard command supported"),
      FEATURE_ENTRY(VIRTIO_BLK_F_WRITE_ZEROES, \
              "VIRTIO_BLK_F_WRITE_ZEROES: Write zeroes command supported"),
 +    FEATURE_ENTRY(VIRTIO_BLK_F_ZONED, \
 +            "VIRTIO_BLK_F_ZONED: Zoned block devices"),
  #ifndef VIRTIO_BLK_NO_LEGACY
      FEATURE_ENTRY(VIRTIO_BLK_F_BARRIER, \
              "VIRTIO_BLK_F_BARRIER: Request barriers supported"),
 --
-.34.1
+.40.0

-New patch
+[PULL 15/17] block: add accounting for zone append operation
+From: Sam Li <faithilikerun@gmail.com>
+Taking account of the new zone append write operation for zoned devices,
+BLOCK_ACCT_ZONE_APPEND enum is introduced as other I/O request type (read,
+write, flush).
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20230407082528.18841-4-faithilikerun@gmail.com>
+---
+ qapi/block-core.json       | 68 ++++++++++++++++++++++++++++++++------
+ qapi/block.json            |  4 +++
+ include/block/accounting.h |  1 +
+ block/qapi-sysemu.c        | 11 ++++++
+ block/qapi.c               | 18 ++++++++++
+ hw/block/virtio-blk.c      |  4 +++
+files changed, 95 insertions(+), 11 deletions(-)
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index XXXXXXX..XXXXXXX 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -XXX,XX +XXX,XX @@
+ # @min_wr_latency_ns: Minimum latency of write operations in the
+ #                     defined interval, in nanoseconds.
+ #
++# @min_zone_append_latency_ns: Minimum latency of zone append operations
++#                              in the defined interval, in nanoseconds
++#                              (since 8.1)
++#
+ # @min_flush_latency_ns: Minimum latency of flush operations in the
+ #                        defined interval, in nanoseconds.
+ #
+@@ -XXX,XX +XXX,XX @@
+ # @max_wr_latency_ns: Maximum latency of write operations in the
+ #                     defined interval, in nanoseconds.
+ #
++# @max_zone_append_latency_ns: Maximum latency of zone append operations
++#                              in the defined interval, in nanoseconds
++#                              (since 8.1)
++#
+ # @max_flush_latency_ns: Maximum latency of flush operations in the
+ #                        defined interval, in nanoseconds.
+ #
+@@ -XXX,XX +XXX,XX @@
+ # @avg_wr_latency_ns: Average latency of write operations in the
+ #                     defined interval, in nanoseconds.
+ #
++# @avg_zone_append_latency_ns: Average latency of zone append operations
++#                              in the defined interval, in nanoseconds
++#                              (since 8.1)
++#
+ # @avg_flush_latency_ns: Average latency of flush operations in the
+ #                        defined interval, in nanoseconds.
+ #
+@@ -XXX,XX +XXX,XX @@
+ # @avg_wr_queue_depth: Average number of pending write operations
+ #                      in the defined interval.
+ #
++# @avg_zone_append_queue_depth: Average number of pending zone append
++#                               operations in the defined interval
++#                               (since 8.1).
++#
+ # Since: 2.5
+ ##
+ { 'struct': 'BlockDeviceTimedStats',
+   'data': { 'interval_length': 'int', 'min_rd_latency_ns': 'int',
+             'max_rd_latency_ns': 'int', 'avg_rd_latency_ns': 'int',
+             'min_wr_latency_ns': 'int', 'max_wr_latency_ns': 'int',
+-            'avg_wr_latency_ns': 'int', 'min_flush_latency_ns': 'int',
+-            'max_flush_latency_ns': 'int', 'avg_flush_latency_ns': 'int',
+-            'avg_rd_queue_depth': 'number', 'avg_wr_queue_depth': 'number' } }
++            'avg_wr_latency_ns': 'int', 'min_zone_append_latency_ns': 'int',
++            'max_zone_append_latency_ns': 'int',
++            'avg_zone_append_latency_ns': 'int',
++            'min_flush_latency_ns': 'int', 'max_flush_latency_ns': 'int',
++            'avg_flush_latency_ns': 'int', 'avg_rd_queue_depth': 'number',
++            'avg_wr_queue_depth': 'number',
++            'avg_zone_append_queue_depth': 'number'  } }
+ ##
+ # @BlockDeviceStats:
+@@ -XXX,XX +XXX,XX @@
+ #
+ # @wr_bytes: The number of bytes written by the device.
+ #
++# @zone_append_bytes: The number of bytes appended by the zoned devices
++#                     (since 8.1)
++#
+ # @unmap_bytes: The number of bytes unmapped by the device (Since 4.2)
+ #
+ # @rd_operations: The number of read operations performed by the device.
+ #
+ # @wr_operations: The number of write operations performed by the device.
+ #
++# @zone_append_operations: The number of zone append operations performed
++#                          by the zoned devices (since 8.1)
++#
+ # @flush_operations: The number of cache flush operations performed by the
+ #                    device (since 0.15)
+ #
+@@ -XXX,XX +XXX,XX @@
+ #
+ # @wr_total_time_ns: Total time spent on writes in nanoseconds (since 0.15).
+ #
++# @zone_append_total_time_ns: Total time spent on zone append writes
++#                             in nanoseconds (since 8.1)
++#
+ # @flush_total_time_ns: Total time spent on cache flushes in nanoseconds
+ #                       (since 0.15).
+ #
+@@ -XXX,XX +XXX,XX @@
+ # @wr_merged: Number of write requests that have been merged into another
+ #             request (Since 2.3).
+ #
++# @zone_append_merged: Number of zone append requests that have been merged
++#                      into another request (since 8.1)
++#
+ # @unmap_merged: Number of unmap requests that have been merged into another
+ #                request (Since 4.2)
+ #
+@@ -XXX,XX +XXX,XX @@
+ # @failed_wr_operations: The number of failed write operations
+ #                        performed by the device (Since 2.5)
+ #
++# @failed_zone_append_operations: The number of failed zone append write
++#                                 operations performed by the zoned devices
++#                                 (since 8.1)
++#
+ # @failed_flush_operations: The number of failed flush operations
+ #                           performed by the device (Since 2.5)
+ #
+@@ -XXX,XX +XXX,XX @@
+ # @invalid_wr_operations: The number of invalid write operations
+ #                         performed by the device (Since 2.5)
+ #
++# @invalid_zone_append_operations: The number of invalid zone append operations
++#                                  performed by the zoned device (since 8.1)
++#
+ # @invalid_flush_operations: The number of invalid flush operations
+ #                            performed by the device (Since 2.5)
+ #
+@@ -XXX,XX +XXX,XX @@
+ #
+ # @wr_latency_histogram: @BlockLatencyHistogramInfo. (Since 4.0)
+ #
++# @zone_append_latency_histogram: @BlockLatencyHistogramInfo. (since 8.1)
++#
+ # @flush_latency_histogram: @BlockLatencyHistogramInfo. (Since 4.0)
+ #
+ # Since: 0.14
+ ##
+ { 'struct': 'BlockDeviceStats',
+-  'data': {'rd_bytes': 'int', 'wr_bytes': 'int', 'unmap_bytes' : 'int',
+-           'rd_operations': 'int', 'wr_operations': 'int',
++  'data': {'rd_bytes': 'int', 'wr_bytes': 'int', 'zone_append_bytes': 'int',
++           'unmap_bytes' : 'int', 'rd_operations': 'int',
++           'wr_operations': 'int', 'zone_append_operations': 'int',
+            'flush_operations': 'int', 'unmap_operations': 'int',
+            'rd_total_time_ns': 'int', 'wr_total_time_ns': 'int',
+-           'flush_total_time_ns': 'int', 'unmap_total_time_ns': 'int',
+-           'wr_highest_offset': 'int',
+-           'rd_merged': 'int', 'wr_merged': 'int', 'unmap_merged': 'int',
+-           '*idle_time_ns': 'int',
++           'zone_append_total_time_ns': 'int', 'flush_total_time_ns': 'int',
++           'unmap_total_time_ns': 'int', 'wr_highest_offset': 'int',
++           'rd_merged': 'int', 'wr_merged': 'int', 'zone_append_merged': 'int',
++           'unmap_merged': 'int', '*idle_time_ns': 'int',
+            'failed_rd_operations': 'int', 'failed_wr_operations': 'int',
+-           'failed_flush_operations': 'int', 'failed_unmap_operations': 'int',
+-           'invalid_rd_operations': 'int', 'invalid_wr_operations': 'int',
++           'failed_zone_append_operations': 'int',
++           'failed_flush_operations': 'int',
++           'failed_unmap_operations': 'int', 'invalid_rd_operations': 'int',
++           'invalid_wr_operations': 'int',
++           'invalid_zone_append_operations': 'int',
+            'invalid_flush_operations': 'int', 'invalid_unmap_operations': 'int',
+            'account_invalid': 'bool', 'account_failed': 'bool',
+            'timed_stats': ['BlockDeviceTimedStats'],
+            '*rd_latency_histogram': 'BlockLatencyHistogramInfo',
+            '*wr_latency_histogram': 'BlockLatencyHistogramInfo',
++           '*zone_append_latency_histogram': 'BlockLatencyHistogramInfo',
+            '*flush_latency_histogram': 'BlockLatencyHistogramInfo' } }
+ ##
+diff --git a/qapi/block.json b/qapi/block.json
+index XXXXXXX..XXXXXXX 100644
+--- a/qapi/block.json
++++ b/qapi/block.json
+@@ -XXX,XX +XXX,XX @@
+ # @boundaries-write: list of interval boundary values for write latency
+ #                    histogram.
+ #
++# @boundaries-zap: list of interval boundary values for zone append write
++#                  latency histogram.
++#
+ # @boundaries-flush: list of interval boundary values for flush latency
+ #                    histogram.
+ #
+@@ -XXX,XX +XXX,XX @@
+            '*boundaries': ['uint64'],
+            '*boundaries-read': ['uint64'],
+            '*boundaries-write': ['uint64'],
++           '*boundaries-zap': ['uint64'],
+            '*boundaries-flush': ['uint64'] },
+   'allow-preconfig': true }
+diff --git a/include/block/accounting.h b/include/block/accounting.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/block/accounting.h
++++ b/include/block/accounting.h
+@@ -XXX,XX +XXX,XX @@ enum BlockAcctType {
+     BLOCK_ACCT_READ,
+     BLOCK_ACCT_WRITE,
+     BLOCK_ACCT_FLUSH,
++    BLOCK_ACCT_ZONE_APPEND,
+     BLOCK_ACCT_UNMAP,
+     BLOCK_MAX_IOTYPE,
+ };
+diff --git a/block/qapi-sysemu.c b/block/qapi-sysemu.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qapi-sysemu.c
++++ b/block/qapi-sysemu.c
+@@ -XXX,XX +XXX,XX @@ void qmp_block_latency_histogram_set(
+     bool has_boundaries, uint64List *boundaries,
+     bool has_boundaries_read, uint64List *boundaries_read,
+     bool has_boundaries_write, uint64List *boundaries_write,
++    bool has_boundaries_append, uint64List *boundaries_append,
+     bool has_boundaries_flush, uint64List *boundaries_flush,
+     Error **errp)
+ {
+@@ -XXX,XX +XXX,XX @@ void qmp_block_latency_histogram_set(
+         }
+     }
++    if (has_boundaries || has_boundaries_append) {
++        ret = block_latency_histogram_set(
++                stats, BLOCK_ACCT_ZONE_APPEND,
++                has_boundaries_append ? boundaries_append : boundaries);
++        if (ret) {
++            error_setg(errp, "Device '%s' set append write boundaries fail", id);
++            return;
++        }
++    }
++
+     if (has_boundaries || has_boundaries_flush) {
+         ret = block_latency_histogram_set(
+             stats, BLOCK_ACCT_FLUSH,
+diff --git a/block/qapi.c b/block/qapi.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qapi.c
++++ b/block/qapi.c
+@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
+     ds->rd_bytes = stats->nr_bytes[BLOCK_ACCT_READ];
+     ds->wr_bytes = stats->nr_bytes[BLOCK_ACCT_WRITE];
++    ds->zone_append_bytes = stats->nr_bytes[BLOCK_ACCT_ZONE_APPEND];
+     ds->unmap_bytes = stats->nr_bytes[BLOCK_ACCT_UNMAP];
+     ds->rd_operations = stats->nr_ops[BLOCK_ACCT_READ];
+     ds->wr_operations = stats->nr_ops[BLOCK_ACCT_WRITE];
++    ds->zone_append_operations = stats->nr_ops[BLOCK_ACCT_ZONE_APPEND];
+     ds->unmap_operations = stats->nr_ops[BLOCK_ACCT_UNMAP];
+     ds->failed_rd_operations = stats->failed_ops[BLOCK_ACCT_READ];
+     ds->failed_wr_operations = stats->failed_ops[BLOCK_ACCT_WRITE];
++    ds->failed_zone_append_operations =
++        stats->failed_ops[BLOCK_ACCT_ZONE_APPEND];
+     ds->failed_flush_operations = stats->failed_ops[BLOCK_ACCT_FLUSH];
+     ds->failed_unmap_operations = stats->failed_ops[BLOCK_ACCT_UNMAP];
+     ds->invalid_rd_operations = stats->invalid_ops[BLOCK_ACCT_READ];
+     ds->invalid_wr_operations = stats->invalid_ops[BLOCK_ACCT_WRITE];
++    ds->invalid_zone_append_operations =
++        stats->invalid_ops[BLOCK_ACCT_ZONE_APPEND];
+     ds->invalid_flush_operations =
+         stats->invalid_ops[BLOCK_ACCT_FLUSH];
+     ds->invalid_unmap_operations = stats->invalid_ops[BLOCK_ACCT_UNMAP];
+     ds->rd_merged = stats->merged[BLOCK_ACCT_READ];
+     ds->wr_merged = stats->merged[BLOCK_ACCT_WRITE];
++    ds->zone_append_merged = stats->merged[BLOCK_ACCT_ZONE_APPEND];
+     ds->unmap_merged = stats->merged[BLOCK_ACCT_UNMAP];
+     ds->flush_operations = stats->nr_ops[BLOCK_ACCT_FLUSH];
+     ds->wr_total_time_ns = stats->total_time_ns[BLOCK_ACCT_WRITE];
++    ds->zone_append_total_time_ns =
++        stats->total_time_ns[BLOCK_ACCT_ZONE_APPEND];
+     ds->rd_total_time_ns = stats->total_time_ns[BLOCK_ACCT_READ];
+     ds->flush_total_time_ns = stats->total_time_ns[BLOCK_ACCT_FLUSH];
+     ds->unmap_total_time_ns = stats->total_time_ns[BLOCK_ACCT_UNMAP];
+@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
+         TimedAverage *rd = &ts->latency[BLOCK_ACCT_READ];
+         TimedAverage *wr = &ts->latency[BLOCK_ACCT_WRITE];
++        TimedAverage *zap = &ts->latency[BLOCK_ACCT_ZONE_APPEND];
+         TimedAverage *fl = &ts->latency[BLOCK_ACCT_FLUSH];
+         dev_stats->interval_length = ts->interval_length;
+@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
+         dev_stats->max_wr_latency_ns = timed_average_max(wr);
+         dev_stats->avg_wr_latency_ns = timed_average_avg(wr);
++        dev_stats->min_zone_append_latency_ns = timed_average_min(zap);
++        dev_stats->max_zone_append_latency_ns = timed_average_max(zap);
++        dev_stats->avg_zone_append_latency_ns = timed_average_avg(zap);
++
+         dev_stats->min_flush_latency_ns = timed_average_min(fl);
+         dev_stats->max_flush_latency_ns = timed_average_max(fl);
+         dev_stats->avg_flush_latency_ns = timed_average_avg(fl);
+@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
+             block_acct_queue_depth(ts, BLOCK_ACCT_READ);
+         dev_stats->avg_wr_queue_depth =
+             block_acct_queue_depth(ts, BLOCK_ACCT_WRITE);
++        dev_stats->avg_zone_append_queue_depth =
++            block_acct_queue_depth(ts, BLOCK_ACCT_ZONE_APPEND);
+         QAPI_LIST_PREPEND(ds->timed_stats, dev_stats);
+     }
+@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
+         = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_READ]);
+     ds->wr_latency_histogram
+         = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_WRITE]);
++    ds->zone_append_latency_histogram
++        = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_ZONE_APPEND]);
+     ds->flush_latency_histogram
+         = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_FLUSH]);
+ }
+diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/virtio-blk.c
++++ b/hw/block/virtio-blk.c
+@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_zone_append(VirtIOBlockReq *req,
+     data->in_num = in_num;
+     data->zone_append_data.offset = offset;
+     qemu_iovec_init_external(&req->qiov, out_iov, out_num);
++
++    block_acct_start(blk_get_stats(s->blk), &req->acct, len,
++                     BLOCK_ACCT_ZONE_APPEND);
++
+     blk_aio_zone_append(s->blk, &data->zone_append_data.offset, &req->qiov, 0,
+                         virtio_blk_zone_append_complete, data);
+     return 0;
+--
+.40.0

-New patch
+[PULL 16/17] virtio-blk: add some trace events for zoned emulation
+From: Sam Li <faithilikerun@gmail.com>
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20230407082528.18841-5-faithilikerun@gmail.com>
+---
+ hw/block/virtio-blk.c | 12 ++++++++++++
+ hw/block/trace-events |  7 +++++++
+files changed, 19 insertions(+)
+diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/virtio-blk.c
++++ b/hw/block/virtio-blk.c
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_zone_report_complete(void *opaque, int ret)
+     int64_t nz = data->zone_report_data.nr_zones;
+     int8_t err_status = VIRTIO_BLK_S_OK;
++    trace_virtio_blk_zone_report_complete(vdev, req, nz, ret);
+     if (ret) {
+         err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+         goto out;
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_handle_zone_report(VirtIOBlockReq *req,
+     nr_zones = (req->in_len - sizeof(struct virtio_blk_inhdr) -
+                 sizeof(struct virtio_blk_zone_report)) /
+                sizeof(struct virtio_blk_zone_descriptor);
++    trace_virtio_blk_handle_zone_report(vdev, req,
++                                        offset >> BDRV_SECTOR_BITS, nr_zones);
+     zone_size = sizeof(BlockZoneDescriptor) * nr_zones;
+     data = g_malloc(sizeof(ZoneCmdData));
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_zone_mgmt_complete(void *opaque, int ret)
+ {
+     VirtIOBlockReq *req = opaque;
+     VirtIOBlock *s = req->dev;
++    VirtIODevice *vdev = VIRTIO_DEVICE(s);
+     int8_t err_status = VIRTIO_BLK_S_OK;
++    trace_virtio_blk_zone_mgmt_complete(vdev, req,ret);
+     if (ret) {
+         err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_zone_mgmt(VirtIOBlockReq *req, BlockZoneOp op)
+         /* Entire drive capacity */
+         offset = 0;
+         len = capacity;
++        trace_virtio_blk_handle_zone_reset_all(vdev, req, 0,
++                                               bs->total_sectors);
+     } else {
+         if (bs->bl.zone_size > capacity - offset) {
+             /* The zoned device allows the last smaller zone. */
+@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_zone_mgmt(VirtIOBlockReq *req, BlockZoneOp op)
+         } else {
+             len = bs->bl.zone_size;
+         }
++        trace_virtio_blk_handle_zone_mgmt(vdev, req, op,
++                                          offset >> BDRV_SECTOR_BITS,
++                                          len >> BDRV_SECTOR_BITS);
+     }
+     if (!check_zoned_request(s, offset, len, false, &err_status)) {
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_zone_append_complete(void *opaque, int ret)
+         err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+         goto out;
+     }
++    trace_virtio_blk_zone_append_complete(vdev, req, append_sector, ret);
+ out:
+     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
+@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_zone_append(VirtIOBlockReq *req,
+     int64_t offset = virtio_ldq_p(vdev, &req->out.sector) << BDRV_SECTOR_BITS;
+     int64_t len = iov_size(out_iov, out_num);
++    trace_virtio_blk_handle_zone_append(vdev, req, offset >> BDRV_SECTOR_BITS);
+     if (!check_zoned_request(s, offset, len, true, &err_status)) {
+         goto out;
+     }
+diff --git a/hw/block/trace-events b/hw/block/trace-events
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/trace-events
++++ b/hw/block/trace-events
+@@ -XXX,XX +XXX,XX @@ pflash_write_unknown(const char *name, uint8_t cmd) "%s: unknown command 0x%02x"
+ # virtio-blk.c
+ virtio_blk_req_complete(void *vdev, void *req, int status) "vdev %p req %p status %d"
+ virtio_blk_rw_complete(void *vdev, void *req, int ret) "vdev %p req %p ret %d"
++virtio_blk_zone_report_complete(void *vdev, void *req, unsigned int nr_zones, int ret) "vdev %p req %p nr_zones %u ret %d"
++virtio_blk_zone_mgmt_complete(void *vdev, void *req, int ret) "vdev %p req %p ret %d"
++virtio_blk_zone_append_complete(void *vdev, void *req, int64_t sector, int ret) "vdev %p req %p, append sector 0x%" PRIx64 " ret %d"
+ virtio_blk_handle_write(void *vdev, void *req, uint64_t sector, size_t nsectors) "vdev %p req %p sector %"PRIu64" nsectors %zu"
+ virtio_blk_handle_read(void *vdev, void *req, uint64_t sector, size_t nsectors) "vdev %p req %p sector %"PRIu64" nsectors %zu"
+ virtio_blk_submit_multireq(void *vdev, void *mrb, int start, int num_reqs, uint64_t offset, size_t size, bool is_write) "vdev %p mrb %p start %d num_reqs %d offset %"PRIu64" size %zu is_write %d"
++virtio_blk_handle_zone_report(void *vdev, void *req, int64_t sector, unsigned int nr_zones) "vdev %p req %p sector 0x%" PRIx64 " nr_zones %u"
++virtio_blk_handle_zone_mgmt(void *vdev, void *req, uint8_t op, int64_t sector, int64_t len) "vdev %p req %p op 0x%x sector 0x%" PRIx64 " len 0x%" PRIx64 ""
++virtio_blk_handle_zone_reset_all(void *vdev, void *req, int64_t sector, int64_t len) "vdev %p req %p sector 0x%" PRIx64 " cap 0x%" PRIx64 ""
++virtio_blk_handle_zone_append(void *vdev, void *req, int64_t sector) "vdev %p req %p, append sector 0x%" PRIx64 ""
+ # hd-geometry.c
+ hd_geometry_lchs_guess(void *blk, int cyls, int heads, int secs) "blk %p LCHS %d %d %d"
+--
+.40.0

-New patch
+[PULL 17/17] docs/zoned-storage:add zoned emulation use case
+From: Sam Li <faithilikerun@gmail.com>
+Add the documentation about the example of using virtio-blk driver
+to pass the zoned block devices through to the guest.
+Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+[Fix rST syntax
+--Stefan]
+Message-Id: <20230407082528.18841-6-faithilikerun@gmail.com>
+---
+ docs/devel/zoned-storage.rst | 19 +++++++++++++++++++
+file changed, 19 insertions(+)
+diff --git a/docs/devel/zoned-storage.rst b/docs/devel/zoned-storage.rst
+index XXXXXXX..XXXXXXX 100644
+--- a/docs/devel/zoned-storage.rst
++++ b/docs/devel/zoned-storage.rst
+@@ -XXX,XX +XXX,XX @@ APIs for zoned storage emulation or testing.
+ For example, to test zone_report on a null_blk device using qemu-io is::
+   $ path/to/qemu-io --image-opts -n driver=host_device,filename=/dev/nullb0 -c "zrp offset nr_zones"
++
++To expose the host's zoned block device through virtio-blk, the command line
++can be (includes the -device parameter)::
++
++  -blockdev node-name=drive0,driver=host_device,filename=/dev/nullb0,cache.direct=on \
++      -device virtio-blk-pci,drive=drive0
++
++Or only use the -drive parameter::
++
++  -driver driver=host_device,file=/dev/nullb0,if=virtio,cache.direct=on
++
++Additionally, QEMU has several ways of supporting zoned storage, including:
++(1) Using virtio-scsi: --device scsi-block allows for the passing through of
++SCSI ZBC devices, enabling the attachment of ZBC or ZAC HDDs to QEMU.
++(2) PCI device pass-through: While NVMe ZNS emulation is available for testing
++purposes, it cannot yet pass through a zoned device from the host. To pass on
++the NVMe ZNS device to the guest, use VFIO PCI pass the entire NVMe PCI adapter
++through to the guest. Likewise, an HDD HBA can be passed on to QEMU all HDDs
++attached to the HBA.
+--
+.40.0

The following changes since commit 91f5f7a5df1fda8c34677a7c49ee8a4bb5b56a36:

Merge remote-tracking branch 'remotes/lvivier-gitlab/tags/linux-user-for-7.0-pull-request' into staging (2022-01-12 11:51:47 +0000)

are available in the Git repository at:

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

for you to fetch changes up to db608fb78444c58896db69495729e4458eeaace1:

virtio: unify dataplane and non-dataplane ->handle_output() (2022-01-12 17:09:39 +0000)

----------------------------------------------------------------
Pull request

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

Stefan Hajnoczi (6):
  aio-posix: split poll check from ready handler
  virtio: get rid of VirtIOHandleAIOOutput
  virtio-blk: drop unused virtio_blk_handle_vq() return value
  virtio-scsi: prepare virtio_scsi_handle_cmd for dataplane
  virtio: use ->handle_output() instead of ->handle_aio_output()
  virtio: unify dataplane and non-dataplane ->handle_output()

-- 
2.34.1

Adaptive polling measures the execution time of the polling check plus
handlers called when a polled event becomes ready. Handlers can take a
significant amount of time, making it look like polling was running for
a long time when in fact the event handler was running for a long time.

For example, on Linux the io_submit(2) syscall invoked when a virtio-blk
device's virtqueue becomes ready can take 10s of microseconds. This
can exceed the default polling interval (32 microseconds) and cause
adaptive polling to stop polling.

By excluding the handler's execution time from the polling check we make
the adaptive polling calculation more accurate. As a result, the event
loop now stays in polling mode where previously it would have fallen
back to file descriptor monitoring.

The following data was collected with virtio-blk num-queues=2
event_idx=off using an IOThread. Before:

168k IOPS, IOThread syscalls:

9837.115 ( 0.020 ms): IO iothread1/620155 io_submit(ctx_id: 140512552468480, nr: 16, iocbpp: 0x7fcb9f937db0)    = 16
  9837.158 ( 0.002 ms): IO iothread1/620155 write(fd: 103, buf: 0x556a2ef71b88, count: 8)                         = 8
  9837.161 ( 0.001 ms): IO iothread1/620155 write(fd: 104, buf: 0x556a2ef71b88, count: 8)                         = 8
  9837.163 ( 0.001 ms): IO iothread1/620155 ppoll(ufds: 0x7fcb90002800, nfds: 4, tsp: 0x7fcb9f1342d0, sigsetsize: 8) = 3
  9837.164 ( 0.001 ms): IO iothread1/620155 read(fd: 107, buf: 0x7fcb9f939cc0, count: 512)                        = 8
  9837.174 ( 0.001 ms): IO iothread1/620155 read(fd: 105, buf: 0x7fcb9f939cc0, count: 512)                        = 8
  9837.176 ( 0.001 ms): IO iothread1/620155 read(fd: 106, buf: 0x7fcb9f939cc0, count: 512)                        = 8
  9837.209 ( 0.035 ms): IO iothread1/620155 io_submit(ctx_id: 140512552468480, nr: 32, iocbpp: 0x7fca7d0cebe0)    = 32

174k IOPS (+3.6%), IOThread syscalls:

9809.566 ( 0.036 ms): IO iothread1/623061 io_submit(ctx_id: 140539805028352, nr: 32, iocbpp: 0x7fd0cdd62be0)    = 32
  9809.625 ( 0.001 ms): IO iothread1/623061 write(fd: 103, buf: 0x5647cfba5f58, count: 8)                         = 8
  9809.627 ( 0.002 ms): IO iothread1/623061 write(fd: 104, buf: 0x5647cfba5f58, count: 8)                         = 8
  9809.663 ( 0.036 ms): IO iothread1/623061 io_submit(ctx_id: 140539805028352, nr: 32, iocbpp: 0x7fd0d0388b50)    = 32

Notice that ppoll(2) and eventfd read(2) syscalls are eliminated because
the IOThread stays in polling mode instead of falling back to file
descriptor monitoring.

As usual, polling is not implemented on Windows so this patch ignores
the new io_poll_read() callback in aio-win32.c.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20211207132336.36627-2-stefanha@redhat.com

[Fixed up aio_set_event_notifier() calls in
tests/unit/test-fdmon-epoll.c added after this series was queued.
--Stefan]

diff --git a/include/block/aio.h b/include/block/aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
                         IOHandler *io_read,
                         IOHandler *io_write,
                         AioPollFn *io_poll,
+                        IOHandler *io_poll_ready,
                         void *opaque);
 
 /* Set polling begin/end callbacks for a file descriptor that has already been
@@ -XXX,XX +XXX,XX @@ void aio_set_event_notifier(AioContext *ctx,
                             EventNotifier *notifier,
                             bool is_external,
                             EventNotifierHandler *io_read,
-                            AioPollFn *io_poll);
+                            AioPollFn *io_poll,
+                            EventNotifierHandler *io_poll_ready);
 
 /* Set polling begin/end callbacks for an event notifier that has already been
  * registered with aio_set_event_notifier.  Do nothing if the event notifier is
diff --git a/util/aio-posix.h b/util/aio-posix.h
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.h
+++ b/util/aio-posix.h
@@ -XXX,XX +XXX,XX @@ struct AioHandler {
     IOHandler *io_read;
     IOHandler *io_write;
     AioPollFn *io_poll;
+    IOHandler *io_poll_ready;
     IOHandler *io_poll_begin;
     IOHandler *io_poll_end;
     void *opaque;
diff --git a/block/curl.c b/block/curl.c
index XXXXXXX..XXXXXXX 100644
--- a/block/curl.c
+++ b/block/curl.c
@@ -XXX,XX +XXX,XX @@ static gboolean curl_drop_socket(void *key, void *value, void *opaque)
     BDRVCURLState *s = socket->s;
 
     aio_set_fd_handler(s->aio_context, socket->fd, false,
-                       NULL, NULL, NULL, NULL);
+                       NULL, NULL, NULL, NULL, NULL);
     return true;
 }
 
@@ -XXX,XX +XXX,XX @@ static int curl_sock_cb(CURL *curl, curl_socket_t fd, int action,
     switch (action) {
         case CURL_POLL_IN:
             aio_set_fd_handler(s->aio_context, fd, false,
-                               curl_multi_do, NULL, NULL, socket);
+                               curl_multi_do, NULL, NULL, NULL, socket);
             break;
         case CURL_POLL_OUT:
             aio_set_fd_handler(s->aio_context, fd, false,
-                               NULL, curl_multi_do, NULL, socket);
+                               NULL, curl_multi_do, NULL, NULL, socket);
             break;
         case CURL_POLL_INOUT:
             aio_set_fd_handler(s->aio_context, fd, false,
-                               curl_multi_do, curl_multi_do, NULL, socket);
+                               curl_multi_do, curl_multi_do,
+                               NULL, NULL, socket);
             break;
         case CURL_POLL_REMOVE:
             aio_set_fd_handler(s->aio_context, fd, false,
-                               NULL, NULL, NULL, NULL);
+                               NULL, NULL, NULL, NULL, NULL);
             break;
     }
 
diff --git a/block/export/fuse.c b/block/export/fuse.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/fuse.c
+++ b/block/export/fuse.c
@@ -XXX,XX +XXX,XX @@ static int setup_fuse_export(FuseExport *exp, const char *mountpoint,
 
     aio_set_fd_handler(exp->common.ctx,
                        fuse_session_fd(exp->fuse_session), true,
-                       read_from_fuse_export, NULL, NULL, exp);
+                       read_from_fuse_export, NULL, NULL, NULL, exp);
     exp->fd_handler_set_up = true;
 
     return 0;
@@ -XXX,XX +XXX,XX @@ static void fuse_export_shutdown(BlockExport *blk_exp)
         if (exp->fd_handler_set_up) {
             aio_set_fd_handler(exp->common.ctx,
                                fuse_session_fd(exp->fuse_session), true,
-                               NULL, NULL, NULL, NULL);
+                               NULL, NULL, NULL, NULL, NULL);
             exp->fd_handler_set_up = false;
         }
     }
diff --git a/block/io_uring.c b/block/io_uring.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io_uring.c
+++ b/block/io_uring.c
@@ -XXX,XX +XXX,XX @@ static bool qemu_luring_poll_cb(void *opaque)
 {
     LuringState *s = opaque;
 
-    if (io_uring_cq_ready(&s->ring)) {
-        luring_process_completions_and_submit(s);
-        return true;
-    }
+    return io_uring_cq_ready(&s->ring);
+}
 
-    return false;
+static void qemu_luring_poll_ready(void *opaque)
+{
+    LuringState *s = opaque;
+
+    luring_process_completions_and_submit(s);
 }
 
 static void ioq_init(LuringQueue *io_q)
@@ -XXX,XX +XXX,XX @@ int coroutine_fn luring_co_submit(BlockDriverState *bs, LuringState *s, int fd,
 
 void luring_detach_aio_context(LuringState *s, AioContext *old_context)
 {
-    aio_set_fd_handler(old_context, s->ring.ring_fd, false, NULL, NULL, NULL,
-                       s);
+    aio_set_fd_handler(old_context, s->ring.ring_fd, false,
+                       NULL, NULL, NULL, NULL, s);
     qemu_bh_delete(s->completion_bh);
     s->aio_context = NULL;
 }
@@ -XXX,XX +XXX,XX @@ void luring_attach_aio_context(LuringState *s, AioContext *new_context)
     s->aio_context = new_context;
     s->completion_bh = aio_bh_new(new_context, qemu_luring_completion_bh, s);
     aio_set_fd_handler(s->aio_context, s->ring.ring_fd, false,
-                       qemu_luring_completion_cb, NULL, qemu_luring_poll_cb, s);
+                       qemu_luring_completion_cb, NULL,
+                       qemu_luring_poll_cb, qemu_luring_poll_ready, s);
 }
 
 LuringState *luring_init(Error **errp)
diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ iscsi_set_events(IscsiLun *iscsilun)
                            false,
                            (ev & POLLIN) ? iscsi_process_read : NULL,
                            (ev & POLLOUT) ? iscsi_process_write : NULL,
-                           NULL,
+                           NULL, NULL,
                            iscsilun);
         iscsilun->events = ev;
     }
@@ -XXX,XX +XXX,XX @@ static void iscsi_detach_aio_context(BlockDriverState *bs)
     IscsiLun *iscsilun = bs->opaque;
 
     aio_set_fd_handler(iscsilun->aio_context, iscsi_get_fd(iscsilun->iscsi),
-                       false, NULL, NULL, NULL, NULL);
+                       false, NULL, NULL, NULL, NULL, NULL);
     iscsilun->events = 0;
 
     if (iscsilun->nop_timer) {
diff --git a/block/linux-aio.c b/block/linux-aio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/linux-aio.c
+++ b/block/linux-aio.c
@@ -XXX,XX +XXX,XX @@ static bool qemu_laio_poll_cb(void *opaque)
     LinuxAioState *s = container_of(e, LinuxAioState, e);
     struct io_event *events;
 
-    if (!io_getevents_peek(s->ctx, &events)) {
-        return false;
-    }
+    return io_getevents_peek(s->ctx, &events);
+}
+
+static void qemu_laio_poll_ready(EventNotifier *opaque)
+{
+    EventNotifier *e = opaque;
+    LinuxAioState *s = container_of(e, LinuxAioState, e);
 
     qemu_laio_process_completions_and_submit(s);
-    return true;
 }
 
 static void ioq_init(LaioQueue *io_q)
@@ -XXX,XX +XXX,XX @@ int coroutine_fn laio_co_submit(BlockDriverState *bs, LinuxAioState *s, int fd,
 
 void laio_detach_aio_context(LinuxAioState *s, AioContext *old_context)
 {
-    aio_set_event_notifier(old_context, &s->e, false, NULL, NULL);
+    aio_set_event_notifier(old_context, &s->e, false, NULL, NULL, NULL);
     qemu_bh_delete(s->completion_bh);
     s->aio_context = NULL;
 }
@@ -XXX,XX +XXX,XX @@ void laio_attach_aio_context(LinuxAioState *s, AioContext *new_context)
     s->completion_bh = aio_bh_new(new_context, qemu_laio_completion_bh, s);
     aio_set_event_notifier(new_context, &s->e, false,
                            qemu_laio_completion_cb,
-                           qemu_laio_poll_cb);
+                           qemu_laio_poll_cb,
+                           qemu_laio_poll_ready);
 }
 
 LinuxAioState *laio_init(Error **errp)
diff --git a/block/nfs.c b/block/nfs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static void nfs_set_events(NFSClient *client)
                            false,
                            (ev & POLLIN) ? nfs_process_read : NULL,
                            (ev & POLLOUT) ? nfs_process_write : NULL,
-                           NULL, client);
+                           NULL, NULL, client);
 
     }
     client->events = ev;
@@ -XXX,XX +XXX,XX @@ static void nfs_detach_aio_context(BlockDriverState *bs)
     NFSClient *client = bs->opaque;
 
     aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
-                       false, NULL, NULL, NULL, NULL);
+                       false, NULL, NULL, NULL, NULL, NULL);
     client->events = 0;
 }
 
@@ -XXX,XX +XXX,XX @@ static void nfs_client_close(NFSClient *client)
     if (client->context) {
         qemu_mutex_lock(&client->mutex);
         aio_set_fd_handler(client->aio_context, nfs_get_fd(client->context),
-                           false, NULL, NULL, NULL, NULL);
+                           false, NULL, NULL, NULL, NULL, NULL);
         qemu_mutex_unlock(&client->mutex);
         if (client->fh) {
             nfs_close(client->context, client->fh);
diff --git a/block/nvme.c b/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nvme.c
+++ b/block/nvme.c
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
-static bool nvme_poll_queue(NVMeQueuePair *q)
+static void nvme_poll_queue(NVMeQueuePair *q)
 {
-    bool progress = false;
-
     const size_t cqe_offset = q->cq.head * NVME_CQ_ENTRY_BYTES;
     NvmeCqe *cqe = (NvmeCqe *)&q->cq.queue[cqe_offset];
 
@@ -XXX,XX +XXX,XX @@ static bool nvme_poll_queue(NVMeQueuePair *q)
      * cannot race with itself.
      */
     if ((le16_to_cpu(cqe->status) & 0x1) == q->cq_phase) {
-        return false;
+        return;
     }
 
     qemu_mutex_lock(&q->lock);
     while (nvme_process_completion(q)) {
         /* Keep polling */
-        progress = true;
     }
     qemu_mutex_unlock(&q->lock);
-
-    return progress;
 }
 
-static bool nvme_poll_queues(BDRVNVMeState *s)
+static void nvme_poll_queues(BDRVNVMeState *s)
 {
-    bool progress = false;
     int i;
 
     for (i = 0; i < s->queue_count; i++) {
-        if (nvme_poll_queue(s->queues[i])) {
-            progress = true;
-        }
+        nvme_poll_queue(s->queues[i]);
     }
-    return progress;
 }
 
 static void nvme_handle_event(EventNotifier *n)
@@ -XXX,XX +XXX,XX @@ static bool nvme_poll_cb(void *opaque)
     EventNotifier *e = opaque;
     BDRVNVMeState *s = container_of(e, BDRVNVMeState,
                                     irq_notifier[MSIX_SHARED_IRQ_IDX]);
+    int i;
 
-    return nvme_poll_queues(s);
+    for (i = 0; i < s->queue_count; i++) {
+        NVMeQueuePair *q = s->queues[i];
+        const size_t cqe_offset = q->cq.head * NVME_CQ_ENTRY_BYTES;
+        NvmeCqe *cqe = (NvmeCqe *)&q->cq.queue[cqe_offset];
+
+        /*
+         * q->lock isn't needed because nvme_process_completion() only runs in
+         * the event loop thread and cannot race with itself.
+         */
+        if ((le16_to_cpu(cqe->status) & 0x1) != q->cq_phase) {
+            return true;
+        }
+    }
+    return false;
+}
+
+static void nvme_poll_ready(EventNotifier *e)
+{
+    BDRVNVMeState *s = container_of(e, BDRVNVMeState,
+                                    irq_notifier[MSIX_SHARED_IRQ_IDX]);
+
+    nvme_poll_queues(s);
 }
 
 static int nvme_init(BlockDriverState *bs, const char *device, int namespace,
@@ -XXX,XX +XXX,XX @@ static int nvme_init(BlockDriverState *bs, const char *device, int namespace,
     }
     aio_set_event_notifier(bdrv_get_aio_context(bs),
                            &s->irq_notifier[MSIX_SHARED_IRQ_IDX],
-                           false, nvme_handle_event, nvme_poll_cb);
+                           false, nvme_handle_event, nvme_poll_cb,
+                           nvme_poll_ready);
 
     if (!nvme_identify(bs, namespace, errp)) {
         ret = -EIO;
@@ -XXX,XX +XXX,XX @@ static void nvme_close(BlockDriverState *bs)
     g_free(s->queues);
     aio_set_event_notifier(bdrv_get_aio_context(bs),
                            &s->irq_notifier[MSIX_SHARED_IRQ_IDX],
-                           false, NULL, NULL);
+                           false, NULL, NULL, NULL);
     event_notifier_cleanup(&s->irq_notifier[MSIX_SHARED_IRQ_IDX]);
     qemu_vfio_pci_unmap_bar(s->vfio, 0, s->bar0_wo_map,
                             0, sizeof(NvmeBar) + NVME_DOORBELL_SIZE);
@@ -XXX,XX +XXX,XX @@ static void nvme_detach_aio_context(BlockDriverState *bs)
 
     aio_set_event_notifier(bdrv_get_aio_context(bs),
                            &s->irq_notifier[MSIX_SHARED_IRQ_IDX],
-                           false, NULL, NULL);
+                           false, NULL, NULL, NULL);
 }
 
 static void nvme_attach_aio_context(BlockDriverState *bs,
@@ -XXX,XX +XXX,XX @@ static void nvme_attach_aio_context(BlockDriverState *bs,
 
     s->aio_context = new_context;
     aio_set_event_notifier(new_context, &s->irq_notifier[MSIX_SHARED_IRQ_IDX],
-                           false, nvme_handle_event, nvme_poll_cb);
+                           false, nvme_handle_event, nvme_poll_cb,
+                           nvme_poll_ready);
 
     for (unsigned i = 0; i < s->queue_count; i++) {
         NVMeQueuePair *q = s->queues[i];
diff --git a/block/ssh.c b/block/ssh.c
index XXXXXXX..XXXXXXX 100644
--- a/block/ssh.c
+++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static void restart_coroutine(void *opaque)
     AioContext *ctx = bdrv_get_aio_context(bs);
 
     trace_ssh_restart_coroutine(restart->co);
-    aio_set_fd_handler(ctx, s->sock, false, NULL, NULL, NULL, NULL);
+    aio_set_fd_handler(ctx, s->sock, false, NULL, NULL, NULL, NULL, NULL);
 
     aio_co_wake(restart->co);
 }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void co_yield(BDRVSSHState *s, BlockDriverState *bs)
     trace_ssh_co_yield(s->sock, rd_handler, wr_handler);
 
     aio_set_fd_handler(bdrv_get_aio_context(bs), s->sock,
-                       false, rd_handler, wr_handler, NULL, &restart);
+                       false, rd_handler, wr_handler, NULL, NULL, &restart);
     qemu_coroutine_yield();
     trace_ssh_co_yield_back(s->sock);
 }
diff --git a/block/win32-aio.c b/block/win32-aio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/win32-aio.c
+++ b/block/win32-aio.c
@@ -XXX,XX +XXX,XX @@ int win32_aio_attach(QEMUWin32AIOState *aio, HANDLE hfile)
 void win32_aio_detach_aio_context(QEMUWin32AIOState *aio,
                                   AioContext *old_context)
 {
-    aio_set_event_notifier(old_context, &aio->e, false, NULL, NULL);
+    aio_set_event_notifier(old_context, &aio->e, false, NULL, NULL, NULL);
     aio->aio_ctx = NULL;
 }
 
@@ -XXX,XX +XXX,XX @@ void win32_aio_attach_aio_context(QEMUWin32AIOState *aio,
 {
     aio->aio_ctx = new_context;
     aio_set_event_notifier(new_context, &aio->e, false,
-                           win32_aio_completion_cb, NULL);
+                           win32_aio_completion_cb, NULL, NULL);
 }
 
 QEMUWin32AIOState *win32_aio_init(void)
diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/virtio.c
+++ b/hw/virtio/virtio.c
@@ -XXX,XX +XXX,XX @@ static bool virtio_queue_host_notifier_aio_poll(void *opaque)
     EventNotifier *n = opaque;
     VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
 
-    if (!vq->vring.desc || virtio_queue_empty(vq)) {
-        return false;
-    }
+    return vq->vring.desc && !virtio_queue_empty(vq);
+}
 
-    return virtio_queue_notify_aio_vq(vq);
+static void virtio_queue_host_notifier_aio_poll_ready(EventNotifier *n)
+{
+    VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
+
+    virtio_queue_notify_aio_vq(vq);
 }
 
 static void virtio_queue_host_notifier_aio_poll_end(EventNotifier *n)
@@ -XXX,XX +XXX,XX @@ void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
         vq->handle_aio_output = handle_output;
         aio_set_event_notifier(ctx, &vq->host_notifier, true,
                                virtio_queue_host_notifier_aio_read,
-                               virtio_queue_host_notifier_aio_poll);
+                               virtio_queue_host_notifier_aio_poll,
+                               virtio_queue_host_notifier_aio_poll_ready);
         aio_set_event_notifier_poll(ctx, &vq->host_notifier,
                                     virtio_queue_host_notifier_aio_poll_begin,
                                     virtio_queue_host_notifier_aio_poll_end);
     } else {
-        aio_set_event_notifier(ctx, &vq->host_notifier, true, NULL, NULL);
+        aio_set_event_notifier(ctx, &vq->host_notifier, true, NULL, NULL, NULL);
         /* Test and clear notifier before after disabling event,
          * in case poll callback didn't have time to run. */
         virtio_queue_host_notifier_aio_read(&vq->host_notifier);
diff --git a/hw/xen/xen-bus.c b/hw/xen/xen-bus.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/xen/xen-bus.c
+++ b/hw/xen/xen-bus.c
@@ -XXX,XX +XXX,XX @@ void xen_device_set_event_channel_context(XenDevice *xendev,
 
     if (channel->ctx)
         aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
-                           NULL, NULL, NULL, NULL);
+                           NULL, NULL, NULL, NULL, NULL);
 
     channel->ctx = ctx;
     aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
-                       xen_device_event, NULL, xen_device_poll, channel);
+                       xen_device_event, NULL, xen_device_poll, NULL, channel);
 }
 
 XenEventChannel *xen_device_bind_event_channel(XenDevice *xendev,
@@ -XXX,XX +XXX,XX @@ void xen_device_unbind_event_channel(XenDevice *xendev,
     QLIST_REMOVE(channel, list);
 
     aio_set_fd_handler(channel->ctx, xenevtchn_fd(channel->xeh), true,
-                       NULL, NULL, NULL, NULL);
+                       NULL, NULL, NULL, NULL, NULL);
 
     if (xenevtchn_unbind(channel->xeh, channel->local_port) < 0) {
         error_setg_errno(errp, errno, "xenevtchn_unbind failed");
diff --git a/io/channel-command.c b/io/channel-command.c
index XXXXXXX..XXXXXXX 100644
--- a/io/channel-command.c
+++ b/io/channel-command.c
@@ -XXX,XX +XXX,XX @@ static void qio_channel_command_set_aio_fd_handler(QIOChannel *ioc,
                                                    void *opaque)
 {
     QIOChannelCommand *cioc = QIO_CHANNEL_COMMAND(ioc);
-    aio_set_fd_handler(ctx, cioc->readfd, false, io_read, NULL, NULL, opaque);
-    aio_set_fd_handler(ctx, cioc->writefd, false, NULL, io_write, NULL, opaque);
+    aio_set_fd_handler(ctx, cioc->readfd, false,
+                       io_read, NULL, NULL, NULL, opaque);
+    aio_set_fd_handler(ctx, cioc->writefd, false,
+                       NULL, io_write, NULL, NULL, opaque);
 }
 
 
diff --git a/io/channel-file.c b/io/channel-file.c
index XXXXXXX..XXXXXXX 100644
--- a/io/channel-file.c
+++ b/io/channel-file.c
@@ -XXX,XX +XXX,XX @@ static void qio_channel_file_set_aio_fd_handler(QIOChannel *ioc,
                                                 void *opaque)
 {
     QIOChannelFile *fioc = QIO_CHANNEL_FILE(ioc);
-    aio_set_fd_handler(ctx, fioc->fd, false, io_read, io_write, NULL, opaque);
+    aio_set_fd_handler(ctx, fioc->fd, false, io_read, io_write,
+                       NULL, NULL, opaque);
 }
 
 static GSource *qio_channel_file_create_watch(QIOChannel *ioc,
diff --git a/io/channel-socket.c b/io/channel-socket.c
index XXXXXXX..XXXXXXX 100644
--- a/io/channel-socket.c
+++ b/io/channel-socket.c
@@ -XXX,XX +XXX,XX @@ static void qio_channel_socket_set_aio_fd_handler(QIOChannel *ioc,
                                                   void *opaque)
 {
     QIOChannelSocket *sioc = QIO_CHANNEL_SOCKET(ioc);
-    aio_set_fd_handler(ctx, sioc->fd, false, io_read, io_write, NULL, opaque);
+    aio_set_fd_handler(ctx, sioc->fd, false,
+                       io_read, io_write, NULL, NULL, opaque);
 }
 
 static GSource *qio_channel_socket_create_watch(QIOChannel *ioc,
diff --git a/migration/rdma.c b/migration/rdma.c
index XXXXXXX..XXXXXXX 100644
--- a/migration/rdma.c
+++ b/migration/rdma.c
@@ -XXX,XX +XXX,XX @@ static void qio_channel_rdma_set_aio_fd_handler(QIOChannel *ioc,
     QIOChannelRDMA *rioc = QIO_CHANNEL_RDMA(ioc);
     if (io_read) {
         aio_set_fd_handler(ctx, rioc->rdmain->recv_comp_channel->fd,
-                           false, io_read, io_write, NULL, opaque);
+                           false, io_read, io_write, NULL, NULL, opaque);
         aio_set_fd_handler(ctx, rioc->rdmain->send_comp_channel->fd,
-                           false, io_read, io_write, NULL, opaque);
+                           false, io_read, io_write, NULL, NULL, opaque);
     } else {
         aio_set_fd_handler(ctx, rioc->rdmaout->recv_comp_channel->fd,
-                           false, io_read, io_write, NULL, opaque);
+                           false, io_read, io_write, NULL, NULL, opaque);
         aio_set_fd_handler(ctx, rioc->rdmaout->send_comp_channel->fd,
-                           false, io_read, io_write, NULL, opaque);
+                           false, io_read, io_write, NULL, NULL, opaque);
     }
 }
 
diff --git a/tests/unit/test-aio.c b/tests/unit/test-aio.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-aio.c
+++ b/tests/unit/test-aio.c
@@ -XXX,XX +XXX,XX @@ static void *test_acquire_thread(void *opaque)
 static void set_event_notifier(AioContext *ctx, EventNotifier *notifier,
                                EventNotifierHandler *handler)
 {
-    aio_set_event_notifier(ctx, notifier, false, handler, NULL);
+    aio_set_event_notifier(ctx, notifier, false, handler, NULL, NULL);
 }
 
 static void dummy_notifier_read(EventNotifier *n)
@@ -XXX,XX +XXX,XX @@ static void test_aio_external_client(void)
     for (i = 1; i < 3; i++) {
         EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
         event_notifier_init(&data.e, false);
-        aio_set_event_notifier(ctx, &data.e, true, event_ready_cb, NULL);
+        aio_set_event_notifier(ctx, &data.e, true, event_ready_cb, NULL, NULL);
         event_notifier_set(&data.e);
         for (j = 0; j < i; j++) {
             aio_disable_external(ctx);
diff --git a/tests/unit/test-fdmon-epoll.c b/tests/unit/test-fdmon-epoll.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-fdmon-epoll.c
+++ b/tests/unit/test-fdmon-epoll.c
@@ -XXX,XX +XXX,XX @@ static void add_event_notifiers(EventNotifier *notifiers, size_t n)
     for (size_t i = 0; i < n; i++) {
         event_notifier_init(&notifiers[i], false);
         aio_set_event_notifier(ctx, &notifiers[i], false,
-                               dummy_fd_handler, NULL);
+                               dummy_fd_handler, NULL, NULL);
     }
 }
 
 static void remove_event_notifiers(EventNotifier *notifiers, size_t n)
 {
     for (size_t i = 0; i < n; i++) {
-        aio_set_event_notifier(ctx, &notifiers[i], false, NULL, NULL);
+        aio_set_event_notifier(ctx, &notifiers[i], false, NULL, NULL, NULL);
         event_notifier_cleanup(&notifiers[i]);
     }
 }
diff --git a/util/aio-posix.c b/util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@
 #include "trace.h"
 #include "aio-posix.h"
 
+/*
+ * G_IO_IN and G_IO_OUT are not appropriate revents values for polling, since
+ * the handler may not need to access the file descriptor. For example, the
+ * handler doesn't need to read from an EventNotifier if it polled a memory
+ * location and a read syscall would be slow. Define our own unique revents
+ * value to indicate that polling determined this AioHandler is ready.
+ */
+#define REVENTS_POLL_READY 0
+
 /* Stop userspace polling on a handler if it isn't active for some time */
 #define POLL_IDLE_INTERVAL_NS (7 * NANOSECONDS_PER_SECOND)
 
@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
                         IOHandler *io_read,
                         IOHandler *io_write,
                         AioPollFn *io_poll,
+                        IOHandler *io_poll_ready,
                         void *opaque)
 {
     AioHandler *node;
@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
     bool deleted = false;
     int poll_disable_change;
 
+    if (io_poll && !io_poll_ready) {
+        io_poll = NULL; /* polling only makes sense if there is a handler */
+    }
+
     qemu_lockcnt_lock(&ctx->list_lock);
 
     node = find_aio_handler(ctx, fd);
@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
         new_node->io_read = io_read;
         new_node->io_write = io_write;
         new_node->io_poll = io_poll;
+        new_node->io_poll_ready = io_poll_ready;
         new_node->opaque = opaque;
         new_node->is_external = is_external;
 
@@ -XXX,XX +XXX,XX @@ void aio_set_event_notifier(AioContext *ctx,
                             EventNotifier *notifier,
                             bool is_external,
                             EventNotifierHandler *io_read,
-                            AioPollFn *io_poll)
+                            AioPollFn *io_poll,
+                            EventNotifierHandler *io_poll_ready)
 {
     aio_set_fd_handler(ctx, event_notifier_get_fd(notifier), is_external,
-                       (IOHandler *)io_read, NULL, io_poll, notifier);
+                       (IOHandler *)io_read, NULL, io_poll,
+                       (IOHandler *)io_poll_ready, notifier);
 }
 
 void aio_set_event_notifier_poll(AioContext *ctx,
@@ -XXX,XX +XXX,XX @@ void aio_set_event_notifier_poll(AioContext *ctx,
                     (IOHandler *)io_poll_end);
 }
 
-static bool poll_set_started(AioContext *ctx, bool started)
+static bool poll_set_started(AioContext *ctx, AioHandlerList *ready_list,
+                             bool started)
 {
     AioHandler *node;
     bool progress = false;
@@ -XXX,XX +XXX,XX @@ static bool poll_set_started(AioContext *ctx, bool started)
         }
 
         /* Poll one last time in case ->io_poll_end() raced with the event */
-        if (!started) {
-            progress = node->io_poll(node->opaque) || progress;
+        if (!started && node->io_poll(node->opaque)) {
+            aio_add_ready_handler(ready_list, node, REVENTS_POLL_READY);
+            progress = true;
         }
     }
     qemu_lockcnt_dec(&ctx->list_lock);
@@ -XXX,XX +XXX,XX @@ static bool poll_set_started(AioContext *ctx, bool started)
 
 bool aio_prepare(AioContext *ctx)
 {
+    AioHandlerList ready_list = QLIST_HEAD_INITIALIZER(ready_list);
+
     /* Poll mode cannot be used with glib's event loop, disable it. */
-    poll_set_started(ctx, false);
+    poll_set_started(ctx, &ready_list, false);
+    /* TODO what to do with this list? */
 
     return false;
 }
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handler(AioContext *ctx, AioHandler *node)
         }
         QLIST_INSERT_HEAD(&ctx->poll_aio_handlers, node, node_poll);
     }
+    if (!QLIST_IS_INSERTED(node, node_deleted) &&
+        revents == 0 &&
+        aio_node_check(ctx, node->is_external) &&
+        node->io_poll_ready) {
+        node->io_poll_ready(node->opaque);
+
+        /*
+         * Return early since revents was zero. aio_notify() does not count as
+         * progress.
+         */
+        return node->opaque != &ctx->notifier;
+    }
 
     if (!QLIST_IS_INSERTED(node, node_deleted) &&
         (revents & (G_IO_IN | G_IO_HUP | G_IO_ERR)) &&
@@ -XXX,XX +XXX,XX @@ void aio_dispatch(AioContext *ctx)
 }
 
 static bool run_poll_handlers_once(AioContext *ctx,
+                                   AioHandlerList *ready_list,
                                    int64_t now,
                                    int64_t *timeout)
 {
@@ -XXX,XX +XXX,XX @@ static bool run_poll_handlers_once(AioContext *ctx,
     QLIST_FOREACH_SAFE(node, &ctx->poll_aio_handlers, node_poll, tmp) {
         if (aio_node_check(ctx, node->is_external) &&
             node->io_poll(node->opaque)) {
+            aio_add_ready_handler(ready_list, node, REVENTS_POLL_READY);
+
             node->poll_idle_timeout = now + POLL_IDLE_INTERVAL_NS;
 
             /*
@@ -XXX,XX +XXX,XX @@ static bool fdmon_supports_polling(AioContext *ctx)
     return ctx->fdmon_ops->need_wait != aio_poll_disabled;
 }
 
-static bool remove_idle_poll_handlers(AioContext *ctx, int64_t now)
+static bool remove_idle_poll_handlers(AioContext *ctx,
+                                      AioHandlerList *ready_list,
+                                      int64_t now)
 {
     AioHandler *node;
     AioHandler *tmp;
@@ -XXX,XX +XXX,XX @@ static bool remove_idle_poll_handlers(AioContext *ctx, int64_t now)
                  * Nevermind about re-adding the handler in the rare case where
                  * this causes progress.
                  */
-                progress = node->io_poll(node->opaque) || progress;
+                if (node->io_poll(node->opaque)) {
+                    aio_add_ready_handler(ready_list, node,
+                                          REVENTS_POLL_READY);
+                    progress = true;
+                }
             }
         }
     }
@@ -XXX,XX +XXX,XX @@ static bool remove_idle_poll_handlers(AioContext *ctx, int64_t now)
 
 /* run_poll_handlers:
  * @ctx: the AioContext
+ * @ready_list: the list to place ready handlers on
  * @max_ns: maximum time to poll for, in nanoseconds
  *
  * Polls for a given time.
@@ -XXX,XX +XXX,XX @@ static bool remove_idle_poll_handlers(AioContext *ctx, int64_t now)
  *
  * Returns: true if progress was made, false otherwise
  */
-static bool run_poll_handlers(AioContext *ctx, int64_t max_ns, int64_t *timeout)
+static bool run_poll_handlers(AioContext *ctx, AioHandlerList *ready_list,
+                              int64_t max_ns, int64_t *timeout)
 {
     bool progress;
     int64_t start_time, elapsed_time;
@@ -XXX,XX +XXX,XX @@ static bool run_poll_handlers(AioContext *ctx, int64_t max_ns, int64_t *timeout)
 
     start_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
     do {
-        progress = run_poll_handlers_once(ctx, start_time, timeout);
+        progress = run_poll_handlers_once(ctx, ready_list,
+                                          start_time, timeout);
         elapsed_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - start_time;
         max_ns = qemu_soonest_timeout(*timeout, max_ns);
         assert(!(max_ns && progress));
     } while (elapsed_time < max_ns && !ctx->fdmon_ops->need_wait(ctx));
 
-    if (remove_idle_poll_handlers(ctx, start_time + elapsed_time)) {
+    if (remove_idle_poll_handlers(ctx, ready_list,
+                                  start_time + elapsed_time)) {
         *timeout = 0;
         progress = true;
     }
@@ -XXX,XX +XXX,XX @@ static bool run_poll_handlers(AioContext *ctx, int64_t max_ns, int64_t *timeout)
 
 /* try_poll_mode:
  * @ctx: the AioContext
+ * @ready_list: list to add handlers that need to be run
  * @timeout: timeout for blocking wait, computed by the caller and updated if
  *    polling succeeds.
  *
@@ -XXX,XX +XXX,XX @@ static bool run_poll_handlers(AioContext *ctx, int64_t max_ns, int64_t *timeout)
  *
  * Returns: true if progress was made, false otherwise
  */
-static bool try_poll_mode(AioContext *ctx, int64_t *timeout)
+static bool try_poll_mode(AioContext *ctx, AioHandlerList *ready_list,
+                          int64_t *timeout)
 {
     int64_t max_ns;
 
@@ -XXX,XX +XXX,XX @@ static bool try_poll_mode(AioContext *ctx, int64_t *timeout)
 
     max_ns = qemu_soonest_timeout(*timeout, ctx->poll_ns);
     if (max_ns && !ctx->fdmon_ops->need_wait(ctx)) {
-        poll_set_started(ctx, true);
+        poll_set_started(ctx, ready_list, true);
 
-        if (run_poll_handlers(ctx, max_ns, timeout)) {
+        if (run_poll_handlers(ctx, ready_list, max_ns, timeout)) {
             return true;
         }
     }
 
-    if (poll_set_started(ctx, false)) {
+    if (poll_set_started(ctx, ready_list, false)) {
         *timeout = 0;
         return true;
     }
@@ -XXX,XX +XXX,XX @@ static bool try_poll_mode(AioContext *ctx, int64_t *timeout)
 bool aio_poll(AioContext *ctx, bool blocking)
 {
     AioHandlerList ready_list = QLIST_HEAD_INITIALIZER(ready_list);
-    int ret = 0;
     bool progress;
     bool use_notify_me;
     int64_t timeout;
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
     }
 
     timeout = blocking ? aio_compute_timeout(ctx) : 0;
-    progress = try_poll_mode(ctx, &timeout);
+    progress = try_poll_mode(ctx, &ready_list, &timeout);
     assert(!(timeout && progress));
 
     /*
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
      * system call---a single round of run_poll_handlers_once suffices.
      */
     if (timeout || ctx->fdmon_ops->need_wait(ctx)) {
-        ret = ctx->fdmon_ops->wait(ctx, &ready_list, timeout);
+        ctx->fdmon_ops->wait(ctx, &ready_list, timeout);
     }
 
     if (use_notify_me) {
@@ -XXX,XX +XXX,XX @@ bool aio_poll(AioContext *ctx, bool blocking)
     }
 
     progress |= aio_bh_poll(ctx);
-
-    if (ret > 0) {
-        progress |= aio_dispatch_ready_handlers(ctx, &ready_list);
-    }
+    progress |= aio_dispatch_ready_handlers(ctx, &ready_list);
 
     aio_free_deleted_handlers(ctx);
 
diff --git a/util/aio-win32.c b/util/aio-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-win32.c
+++ b/util/aio-win32.c
@@ -XXX,XX +XXX,XX @@ void aio_set_fd_handler(AioContext *ctx,
                         IOHandler *io_read,
                         IOHandler *io_write,
                         AioPollFn *io_poll,
+                        IOHandler *io_poll_ready,
                         void *opaque)
 {
     /* fd is a SOCKET in our case */
@@ -XXX,XX +XXX,XX @@ void aio_set_event_notifier(AioContext *ctx,
                             EventNotifier *e,
                             bool is_external,
                             EventNotifierHandler *io_notify,
-                            AioPollFn *io_poll)
+                            AioPollFn *io_poll,
+                            EventNotifierHandler *io_poll_ready)
 {
     AioHandler *node;
 
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ aio_ctx_finalize(GSource     *source)
         g_free(bh);
     }
 
-    aio_set_event_notifier(ctx, &ctx->notifier, false, NULL, NULL);
+    aio_set_event_notifier(ctx, &ctx->notifier, false, NULL, NULL, NULL);
     event_notifier_cleanup(&ctx->notifier);
     qemu_rec_mutex_destroy(&ctx->lock);
     qemu_lockcnt_destroy(&ctx->list_lock);
@@ -XXX,XX +XXX,XX @@ static bool aio_context_notifier_poll(void *opaque)
     return qatomic_read(&ctx->notified);
 }
 
+static void aio_context_notifier_poll_ready(EventNotifier *e)
+{
+    /* Do nothing, we just wanted to kick the event loop */
+}
+
 static void co_schedule_bh_cb(void *opaque)
 {
     AioContext *ctx = opaque;
@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
     aio_set_event_notifier(ctx, &ctx->notifier,
                            false,
                            aio_context_notifier_cb,
-                           aio_context_notifier_poll);
+                           aio_context_notifier_poll,
+                           aio_context_notifier_poll_ready);
 #ifdef CONFIG_LINUX_AIO
     ctx->linux_aio = NULL;
 #endif
diff --git a/util/main-loop.c b/util/main-loop.c
index XXXXXXX..XXXXXXX 100644
--- a/util/main-loop.c
+++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@ void qemu_set_fd_handler(int fd,
 {
     iohandler_init();
     aio_set_fd_handler(iohandler_ctx, fd, false,
-                       fd_read, fd_write, NULL, opaque);
+                       fd_read, fd_write, NULL, NULL, opaque);
 }
 
 void event_notifier_set_handler(EventNotifier *e,
@@ -XXX,XX +XXX,XX @@ void event_notifier_set_handler(EventNotifier *e,
 {
     iohandler_init();
     aio_set_event_notifier(iohandler_ctx, e, false,
-                           handler, NULL);
+                           handler, NULL, NULL);
 }
diff --git a/util/qemu-coroutine-io.c b/util/qemu-coroutine-io.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine-io.c
+++ b/util/qemu-coroutine-io.c
@@ -XXX,XX +XXX,XX @@ typedef struct {
 static void fd_coroutine_enter(void *opaque)
 {
     FDYieldUntilData *data = opaque;
-    aio_set_fd_handler(data->ctx, data->fd, false, NULL, NULL, NULL, NULL);
+    aio_set_fd_handler(data->ctx, data->fd, false,
+                       NULL, NULL, NULL, NULL, NULL);
     qemu_coroutine_enter(data->co);
 }
 
@@ -XXX,XX +XXX,XX @@ void coroutine_fn yield_until_fd_readable(int fd)
     data.co = qemu_coroutine_self();
     data.fd = fd;
     aio_set_fd_handler(
-        data.ctx, fd, false, fd_coroutine_enter, NULL, NULL, &data);
+        data.ctx, fd, false, fd_coroutine_enter, NULL, NULL, NULL, &data);
     qemu_coroutine_yield();
 }
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vhost-user-server.c
+++ b/util/vhost-user-server.c
@@ -XXX,XX +XXX,XX @@ set_watch(VuDev *vu_dev, int fd, int vu_evt,
         vu_fd_watch->cb = cb;
         qemu_set_nonblock(fd);
         aio_set_fd_handler(server->ioc->ctx, fd, true, kick_handler,
-                           NULL, NULL, vu_fd_watch);
+                           NULL, NULL, NULL, vu_fd_watch);
         vu_fd_watch->vu_dev = vu_dev;
         vu_fd_watch->pvt = pvt;
     }
@@ -XXX,XX +XXX,XX @@ static void remove_watch(VuDev *vu_dev, int fd)
     if (!vu_fd_watch) {
         return;
     }
-    aio_set_fd_handler(server->ioc->ctx, fd, true, NULL, NULL, NULL, NULL);
+    aio_set_fd_handler(server->ioc->ctx, fd, true,
+                       NULL, NULL, NULL, NULL, NULL);
 
     QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next);
     g_free(vu_fd_watch);
@@ -XXX,XX +XXX,XX @@ void vhost_user_server_stop(VuServer *server)
 
         QTAILQ_FOREACH(vu_fd_watch, &server->vu_fd_watches, next) {
             aio_set_fd_handler(server->ctx, vu_fd_watch->fd, true,
-                               NULL, NULL, NULL, vu_fd_watch);
+                               NULL, NULL, NULL, NULL, vu_fd_watch);
         }
 
         qio_channel_shutdown(server->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
@@ -XXX,XX +XXX,XX @@ void vhost_user_server_attach_aio_context(VuServer *server, AioContext *ctx)
 
     QTAILQ_FOREACH(vu_fd_watch, &server->vu_fd_watches, next) {
         aio_set_fd_handler(ctx, vu_fd_watch->fd, true, kick_handler, NULL,
-                           NULL, vu_fd_watch);
+                           NULL, NULL, vu_fd_watch);
     }
 
     aio_co_schedule(ctx, server->co_trip);
@@ -XXX,XX +XXX,XX @@ void vhost_user_server_detach_aio_context(VuServer *server)
 
         QTAILQ_FOREACH(vu_fd_watch, &server->vu_fd_watches, next) {
             aio_set_fd_handler(server->ctx, vu_fd_watch->fd, true,
-                               NULL, NULL, NULL, vu_fd_watch);
+                               NULL, NULL, NULL, NULL, vu_fd_watch);
         }
 
         qio_channel_detach_aio_context(server->ioc);
-- 
2.34.1

The virtqueue host notifier API
virtio_queue_aio_set_host_notifier_handler() polls the virtqueue for new
buffers. AioContext previously required a bool progress return value
indicating whether an event was handled or not. This is no longer
necessary because the AioContext polling API has been split into a poll
check function and an event handler function. The event handler is only
run when we know there is work to do, so it doesn't return bool.

The VirtIOHandleAIOOutput function signature is now the same as
VirtIOHandleOutput. Get rid of the bool return value.

Further simplifications will be made for virtio-blk and virtio-scsi in
the next patch.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20211207132336.36627-3-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/virtio/virtio.h      |  3 +--
 hw/block/dataplane/virtio-blk.c |  4 ++--
 hw/scsi/virtio-scsi-dataplane.c | 18 ++++++------------
 hw/virtio/virtio.c              | 12 ++++--------
 4 files changed, 13 insertions(+), 24 deletions(-)

diff --git a/include/hw/virtio/virtio.h b/include/hw/virtio/virtio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/virtio/virtio.h
+++ b/include/hw/virtio/virtio.h
@@ -XXX,XX +XXX,XX @@ void virtio_error(VirtIODevice *vdev, const char *fmt, ...) GCC_FMT_ATTR(2, 3);
 void virtio_device_set_child_bus_name(VirtIODevice *vdev, char *bus_name);
 
 typedef void (*VirtIOHandleOutput)(VirtIODevice *, VirtQueue *);
-typedef bool (*VirtIOHandleAIOOutput)(VirtIODevice *, VirtQueue *);
 
 VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
                             VirtIOHandleOutput handle_output);
@@ -XXX,XX +XXX,XX @@ EventNotifier *virtio_queue_get_host_notifier(VirtQueue *vq);
 void virtio_queue_set_host_notifier_enabled(VirtQueue *vq, bool enabled);
 void virtio_queue_host_notifier_read(EventNotifier *n);
 void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
-                                                VirtIOHandleAIOOutput handle_output);
+        VirtIOHandleOutput handle_output);
 VirtQueue *virtio_vector_first_queue(VirtIODevice *vdev, uint16_t vector);
 VirtQueue *virtio_vector_next_queue(VirtQueue *vq);
 
diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/dataplane/virtio-blk.c
+++ b/hw/block/dataplane/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
     g_free(s);
 }
 
-static bool virtio_blk_data_plane_handle_output(VirtIODevice *vdev,
+static void virtio_blk_data_plane_handle_output(VirtIODevice *vdev,
                                                 VirtQueue *vq)
 {
     VirtIOBlock *s = (VirtIOBlock *)vdev;
@@ -XXX,XX +XXX,XX @@ static bool virtio_blk_data_plane_handle_output(VirtIODevice *vdev,
     assert(s->dataplane);
     assert(s->dataplane_started);
 
-    return virtio_blk_handle_vq(s, vq);
+    virtio_blk_handle_vq(s, vq);
 }
 
 /* Context: QEMU global mutex held */
diff --git a/hw/scsi/virtio-scsi-dataplane.c b/hw/scsi/virtio-scsi-dataplane.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/virtio-scsi-dataplane.c
+++ b/hw/scsi/virtio-scsi-dataplane.c
@@ -XXX,XX +XXX,XX @@ void virtio_scsi_dataplane_setup(VirtIOSCSI *s, Error **errp)
     }
 }
 
-static bool virtio_scsi_data_plane_handle_cmd(VirtIODevice *vdev,
+static void virtio_scsi_data_plane_handle_cmd(VirtIODevice *vdev,
                                               VirtQueue *vq)
 {
-    bool progress = false;
     VirtIOSCSI *s = VIRTIO_SCSI(vdev);
 
     virtio_scsi_acquire(s);
     if (!s->dataplane_fenced) {
         assert(s->ctx && s->dataplane_started);
-        progress = virtio_scsi_handle_cmd_vq(s, vq);
+        virtio_scsi_handle_cmd_vq(s, vq);
     }
     virtio_scsi_release(s);
-    return progress;
 }
 
-static bool virtio_scsi_data_plane_handle_ctrl(VirtIODevice *vdev,
+static void virtio_scsi_data_plane_handle_ctrl(VirtIODevice *vdev,
                                                VirtQueue *vq)
 {
-    bool progress = false;
     VirtIOSCSI *s = VIRTIO_SCSI(vdev);
 
     virtio_scsi_acquire(s);
     if (!s->dataplane_fenced) {
         assert(s->ctx && s->dataplane_started);
-        progress = virtio_scsi_handle_ctrl_vq(s, vq);
+        virtio_scsi_handle_ctrl_vq(s, vq);
     }
     virtio_scsi_release(s);
-    return progress;
 }
 
-static bool virtio_scsi_data_plane_handle_event(VirtIODevice *vdev,
+static void virtio_scsi_data_plane_handle_event(VirtIODevice *vdev,
                                                 VirtQueue *vq)
 {
-    bool progress = false;
     VirtIOSCSI *s = VIRTIO_SCSI(vdev);
 
     virtio_scsi_acquire(s);
     if (!s->dataplane_fenced) {
         assert(s->ctx && s->dataplane_started);
-        progress = virtio_scsi_handle_event_vq(s, vq);
+        virtio_scsi_handle_event_vq(s, vq);
     }
     virtio_scsi_release(s);
-    return progress;
 }
 
 static int virtio_scsi_set_host_notifier(VirtIOSCSI *s, VirtQueue *vq, int n)
diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/virtio.c
+++ b/hw/virtio/virtio.c
@@ -XXX,XX +XXX,XX @@ struct VirtQueue
 
     uint16_t vector;
     VirtIOHandleOutput handle_output;
-    VirtIOHandleAIOOutput handle_aio_output;
+    VirtIOHandleOutput handle_aio_output;
     VirtIODevice *vdev;
     EventNotifier guest_notifier;
     EventNotifier host_notifier;
@@ -XXX,XX +XXX,XX @@ void virtio_queue_set_align(VirtIODevice *vdev, int n, int align)
     }
 }
 
-static bool virtio_queue_notify_aio_vq(VirtQueue *vq)
+static void virtio_queue_notify_aio_vq(VirtQueue *vq)
 {
-    bool ret = false;
-
     if (vq->vring.desc && vq->handle_aio_output) {
         VirtIODevice *vdev = vq->vdev;
 
         trace_virtio_queue_notify(vdev, vq - vdev->vq, vq);
-        ret = vq->handle_aio_output(vdev, vq);
+        vq->handle_aio_output(vdev, vq);
 
         if (unlikely(vdev->start_on_kick)) {
             virtio_set_started(vdev, true);
         }
     }
-
-    return ret;
 }
 
 static void virtio_queue_notify_vq(VirtQueue *vq)
@@ -XXX,XX +XXX,XX @@ static void virtio_queue_host_notifier_aio_poll_end(EventNotifier *n)
 }
 
 void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
-                                                VirtIOHandleAIOOutput handle_output)
+        VirtIOHandleOutput handle_output)
 {
     if (handle_output) {
         vq->handle_aio_output = handle_output;
-- 
2.34.1

The return value of virtio_blk_handle_vq() is no longer used. Get rid of
it. This is a step towards unifying the dataplane and non-dataplane
virtqueue handler functions.

Prepare virtio_blk_handle_output() to be used by both dataplane and
non-dataplane by making the condition for starting ioeventfd more
specific. This way it won't trigger when dataplane has already been
started.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20211207132336.36627-4-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/virtio/virtio-blk.h |  2 +-
 hw/block/virtio-blk.c          | 14 +++-----------
 2 files changed, 4 insertions(+), 12 deletions(-)

diff --git a/include/hw/virtio/virtio-blk.h b/include/hw/virtio/virtio-blk.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/virtio/virtio-blk.h
+++ b/include/hw/virtio/virtio-blk.h
@@ -XXX,XX +XXX,XX @@ typedef struct MultiReqBuffer {
     bool is_write;
 } MultiReqBuffer;
 
-bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq);
+void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq);
 void virtio_blk_process_queued_requests(VirtIOBlock *s, bool is_bh);
 
 #endif
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
     return 0;
 }
 
-bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
+void virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
 {
     VirtIOBlockReq *req;
     MultiReqBuffer mrb = {};
     bool suppress_notifications = virtio_queue_get_notification(vq);
-    bool progress = false;
 
     aio_context_acquire(blk_get_aio_context(s->blk));
     blk_io_plug(s->blk);
@@ -XXX,XX +XXX,XX @@ bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
         }
 
         while ((req = virtio_blk_get_request(s, vq))) {
-            progress = true;
             if (virtio_blk_handle_request(req, &mrb)) {
                 virtqueue_detach_element(req->vq, &req->elem, 0);
                 virtio_blk_free_request(req);
@@ -XXX,XX +XXX,XX @@ bool virtio_blk_handle_vq(VirtIOBlock *s, VirtQueue *vq)
 
     blk_io_unplug(s->blk);
     aio_context_release(blk_get_aio_context(s->blk));
-    return progress;
-}
-
-static void virtio_blk_handle_output_do(VirtIOBlock *s, VirtQueue *vq)
-{
-    virtio_blk_handle_vq(s, vq);
 }
 
 static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
 {
     VirtIOBlock *s = (VirtIOBlock *)vdev;
 
-    if (s->dataplane) {
+    if (s->dataplane && !s->dataplane_started) {
         /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start
          * dataplane here instead of waiting for .set_status().
          */
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq)
             return;
         }
     }
-    virtio_blk_handle_output_do(s, vq);
+    virtio_blk_handle_vq(s, vq);
 }
 
 void virtio_blk_process_queued_requests(VirtIOBlock *s, bool is_bh)
-- 
2.34.1

Prepare virtio_scsi_handle_cmd() to be used by both dataplane and
non-dataplane by making the condition for starting ioeventfd more
specific. This way it won't trigger when dataplane has already been
started.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20211207132336.36627-5-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/scsi/virtio-scsi.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/virtio-scsi.c
+++ b/hw/scsi/virtio-scsi.c
@@ -XXX,XX +XXX,XX @@ static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq)
     /* use non-QOM casts in the data path */
     VirtIOSCSI *s = (VirtIOSCSI *)vdev;
 
-    if (s->ctx) {
+    if (s->ctx && !s->dataplane_started) {
         virtio_device_start_ioeventfd(vdev);
         if (!s->dataplane_fenced) {
             return;
-- 
2.34.1

The difference between ->handle_output() and ->handle_aio_output() was
that ->handle_aio_output() returned a bool return value indicating
progress. This was needed by the old polling API but now that the bool
return value is gone, the two functions can be unified.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20211207132336.36627-6-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/virtio/virtio.c | 33 +++------------------------------
 1 file changed, 3 insertions(+), 30 deletions(-)

diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/virtio.c
+++ b/hw/virtio/virtio.c
@@ -XXX,XX +XXX,XX @@ struct VirtQueue
 
     uint16_t vector;
     VirtIOHandleOutput handle_output;
-    VirtIOHandleOutput handle_aio_output;
     VirtIODevice *vdev;
     EventNotifier guest_notifier;
     EventNotifier host_notifier;
@@ -XXX,XX +XXX,XX @@ void virtio_queue_set_align(VirtIODevice *vdev, int n, int align)
     }
 }
 
-static void virtio_queue_notify_aio_vq(VirtQueue *vq)
-{
-    if (vq->vring.desc && vq->handle_aio_output) {
-        VirtIODevice *vdev = vq->vdev;
-
-        trace_virtio_queue_notify(vdev, vq - vdev->vq, vq);
-        vq->handle_aio_output(vdev, vq);
-
-        if (unlikely(vdev->start_on_kick)) {
-            virtio_set_started(vdev, true);
-        }
-    }
-}
-
 static void virtio_queue_notify_vq(VirtQueue *vq)
 {
     if (vq->vring.desc && vq->handle_output) {
@@ -XXX,XX +XXX,XX @@ VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
     vdev->vq[i].vring.num_default = queue_size;
     vdev->vq[i].vring.align = VIRTIO_PCI_VRING_ALIGN;
     vdev->vq[i].handle_output = handle_output;
-    vdev->vq[i].handle_aio_output = NULL;
     vdev->vq[i].used_elems = g_malloc0(sizeof(VirtQueueElement) *
                                        queue_size);
 
@@ -XXX,XX +XXX,XX @@ void virtio_delete_queue(VirtQueue *vq)
     vq->vring.num = 0;
     vq->vring.num_default = 0;
     vq->handle_output = NULL;
-    vq->handle_aio_output = NULL;
     g_free(vq->used_elems);
     vq->used_elems = NULL;
     virtio_virtqueue_reset_region_cache(vq);
@@ -XXX,XX +XXX,XX @@ EventNotifier *virtio_queue_get_guest_notifier(VirtQueue *vq)
     return &vq->guest_notifier;
 }
 
-static void virtio_queue_host_notifier_aio_read(EventNotifier *n)
-{
-    VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
-    if (event_notifier_test_and_clear(n)) {
-        virtio_queue_notify_aio_vq(vq);
-    }
-}
-
 static void virtio_queue_host_notifier_aio_poll_begin(EventNotifier *n)
 {
     VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
@@ -XXX,XX +XXX,XX @@ static void virtio_queue_host_notifier_aio_poll_ready(EventNotifier *n)
 {
     VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
 
-    virtio_queue_notify_aio_vq(vq);
+    virtio_queue_notify_vq(vq);
 }
 
 static void virtio_queue_host_notifier_aio_poll_end(EventNotifier *n)
@@ -XXX,XX +XXX,XX @@ void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
         VirtIOHandleOutput handle_output)
 {
     if (handle_output) {
-        vq->handle_aio_output = handle_output;
         aio_set_event_notifier(ctx, &vq->host_notifier, true,
-                               virtio_queue_host_notifier_aio_read,
+                               virtio_queue_host_notifier_read,
                                virtio_queue_host_notifier_aio_poll,
                                virtio_queue_host_notifier_aio_poll_ready);
         aio_set_event_notifier_poll(ctx, &vq->host_notifier,
@@ -XXX,XX +XXX,XX @@ void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
         aio_set_event_notifier(ctx, &vq->host_notifier, true, NULL, NULL, NULL);
         /* Test and clear notifier before after disabling event,
          * in case poll callback didn't have time to run. */
-        virtio_queue_host_notifier_aio_read(&vq->host_notifier);
-        vq->handle_aio_output = NULL;
+        virtio_queue_host_notifier_read(&vq->host_notifier);
     }
 }
 
-- 
2.34.1

Now that virtio-blk and virtio-scsi are ready, get rid of
the handle_aio_output() callback. It's no longer needed.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
Message-id: 20211207132336.36627-7-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/virtio/virtio.h      |  4 +--
 hw/block/dataplane/virtio-blk.c | 16 ++--------
 hw/scsi/virtio-scsi-dataplane.c | 54 ++++-----------------------------
 hw/virtio/virtio.c              | 32 +++++++++----------
 4 files changed, 26 insertions(+), 80 deletions(-)

diff --git a/include/hw/virtio/virtio.h b/include/hw/virtio/virtio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/virtio/virtio.h
+++ b/include/hw/virtio/virtio.h
@@ -XXX,XX +XXX,XX @@ bool virtio_device_ioeventfd_enabled(VirtIODevice *vdev);
 EventNotifier *virtio_queue_get_host_notifier(VirtQueue *vq);
 void virtio_queue_set_host_notifier_enabled(VirtQueue *vq, bool enabled);
 void virtio_queue_host_notifier_read(EventNotifier *n);
-void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
-        VirtIOHandleOutput handle_output);
+void virtio_queue_aio_attach_host_notifier(VirtQueue *vq, AioContext *ctx);
+void virtio_queue_aio_detach_host_notifier(VirtQueue *vq, AioContext *ctx);
 VirtQueue *virtio_vector_first_queue(VirtIODevice *vdev, uint16_t vector);
 VirtQueue *virtio_vector_next_queue(VirtQueue *vq);
 
diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/dataplane/virtio-blk.c
+++ b/hw/block/dataplane/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
     g_free(s);
 }
 
-static void virtio_blk_data_plane_handle_output(VirtIODevice *vdev,
-                                                VirtQueue *vq)
-{
-    VirtIOBlock *s = (VirtIOBlock *)vdev;
-
-    assert(s->dataplane);
-    assert(s->dataplane_started);
-
-    virtio_blk_handle_vq(s, vq);
-}
-
 /* Context: QEMU global mutex held */
 int virtio_blk_data_plane_start(VirtIODevice *vdev)
 {
@@ -XXX,XX +XXX,XX @@ int virtio_blk_data_plane_start(VirtIODevice *vdev)
     for (i = 0; i < nvqs; i++) {
         VirtQueue *vq = virtio_get_queue(s->vdev, i);
 
-        virtio_queue_aio_set_host_notifier_handler(vq, s->ctx,
-                virtio_blk_data_plane_handle_output);
+        virtio_queue_aio_attach_host_notifier(vq, s->ctx);
     }
     aio_context_release(s->ctx);
     return 0;
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_data_plane_stop_bh(void *opaque)
     for (i = 0; i < s->conf->num_queues; i++) {
         VirtQueue *vq = virtio_get_queue(s->vdev, i);
 
-        virtio_queue_aio_set_host_notifier_handler(vq, s->ctx, NULL);
+        virtio_queue_aio_detach_host_notifier(vq, s->ctx);
     }
 }
 
diff --git a/hw/scsi/virtio-scsi-dataplane.c b/hw/scsi/virtio-scsi-dataplane.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/virtio-scsi-dataplane.c
+++ b/hw/scsi/virtio-scsi-dataplane.c
@@ -XXX,XX +XXX,XX @@ void virtio_scsi_dataplane_setup(VirtIOSCSI *s, Error **errp)
     }
 }
 
-static void virtio_scsi_data_plane_handle_cmd(VirtIODevice *vdev,
-                                              VirtQueue *vq)
-{
-    VirtIOSCSI *s = VIRTIO_SCSI(vdev);
-
-    virtio_scsi_acquire(s);
-    if (!s->dataplane_fenced) {
-        assert(s->ctx && s->dataplane_started);
-        virtio_scsi_handle_cmd_vq(s, vq);
-    }
-    virtio_scsi_release(s);
-}
-
-static void virtio_scsi_data_plane_handle_ctrl(VirtIODevice *vdev,
-                                               VirtQueue *vq)
-{
-    VirtIOSCSI *s = VIRTIO_SCSI(vdev);
-
-    virtio_scsi_acquire(s);
-    if (!s->dataplane_fenced) {
-        assert(s->ctx && s->dataplane_started);
-        virtio_scsi_handle_ctrl_vq(s, vq);
-    }
-    virtio_scsi_release(s);
-}
-
-static void virtio_scsi_data_plane_handle_event(VirtIODevice *vdev,
-                                                VirtQueue *vq)
-{
-    VirtIOSCSI *s = VIRTIO_SCSI(vdev);
-
-    virtio_scsi_acquire(s);
-    if (!s->dataplane_fenced) {
-        assert(s->ctx && s->dataplane_started);
-        virtio_scsi_handle_event_vq(s, vq);
-    }
-    virtio_scsi_release(s);
-}
-
 static int virtio_scsi_set_host_notifier(VirtIOSCSI *s, VirtQueue *vq, int n)
 {
     BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s)));
@@ -XXX,XX +XXX,XX @@ static void virtio_scsi_dataplane_stop_bh(void *opaque)
     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
     int i;
 
-    virtio_queue_aio_set_host_notifier_handler(vs->ctrl_vq, s->ctx, NULL);
-    virtio_queue_aio_set_host_notifier_handler(vs->event_vq, s->ctx, NULL);
+    virtio_queue_aio_detach_host_notifier(vs->ctrl_vq, s->ctx);
+    virtio_queue_aio_detach_host_notifier(vs->event_vq, s->ctx);
     for (i = 0; i < vs->conf.num_queues; i++) {
-        virtio_queue_aio_set_host_notifier_handler(vs->cmd_vqs[i], s->ctx, NULL);
+        virtio_queue_aio_detach_host_notifier(vs->cmd_vqs[i], s->ctx);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ int virtio_scsi_dataplane_start(VirtIODevice *vdev)
     memory_region_transaction_commit();
 
     aio_context_acquire(s->ctx);
-    virtio_queue_aio_set_host_notifier_handler(vs->ctrl_vq, s->ctx,
-                                            virtio_scsi_data_plane_handle_ctrl);
-    virtio_queue_aio_set_host_notifier_handler(vs->event_vq, s->ctx,
-                                           virtio_scsi_data_plane_handle_event);
+    virtio_queue_aio_attach_host_notifier(vs->ctrl_vq, s->ctx);
+    virtio_queue_aio_attach_host_notifier(vs->event_vq, s->ctx);
 
     for (i = 0; i < vs->conf.num_queues; i++) {
-        virtio_queue_aio_set_host_notifier_handler(vs->cmd_vqs[i], s->ctx,
-                                             virtio_scsi_data_plane_handle_cmd);
+        virtio_queue_aio_attach_host_notifier(vs->cmd_vqs[i], s->ctx);
     }
 
     s->dataplane_starting = false;
diff --git a/hw/virtio/virtio.c b/hw/virtio/virtio.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/virtio.c
+++ b/hw/virtio/virtio.c
@@ -XXX,XX +XXX,XX @@ static void virtio_queue_host_notifier_aio_poll_end(EventNotifier *n)
     virtio_queue_set_notification(vq, 1);
 }
 
-void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
-        VirtIOHandleOutput handle_output)
+void virtio_queue_aio_attach_host_notifier(VirtQueue *vq, AioContext *ctx)
 {
-    if (handle_output) {
-        aio_set_event_notifier(ctx, &vq->host_notifier, true,
-                               virtio_queue_host_notifier_read,
-                               virtio_queue_host_notifier_aio_poll,
-                               virtio_queue_host_notifier_aio_poll_ready);
-        aio_set_event_notifier_poll(ctx, &vq->host_notifier,
-                                    virtio_queue_host_notifier_aio_poll_begin,
-                                    virtio_queue_host_notifier_aio_poll_end);
-    } else {
-        aio_set_event_notifier(ctx, &vq->host_notifier, true, NULL, NULL, NULL);
-        /* Test and clear notifier before after disabling event,
-         * in case poll callback didn't have time to run. */
-        virtio_queue_host_notifier_read(&vq->host_notifier);
-    }
+    aio_set_event_notifier(ctx, &vq->host_notifier, true,
+                           virtio_queue_host_notifier_read,
+                           virtio_queue_host_notifier_aio_poll,
+                           virtio_queue_host_notifier_aio_poll_ready);
+    aio_set_event_notifier_poll(ctx, &vq->host_notifier,
+                                virtio_queue_host_notifier_aio_poll_begin,
+                                virtio_queue_host_notifier_aio_poll_end);
+}
+
+void virtio_queue_aio_detach_host_notifier(VirtQueue *vq, AioContext *ctx)
+{
+    aio_set_event_notifier(ctx, &vq->host_notifier, true, NULL, NULL, NULL);
+    /* Test and clear notifier before after disabling event,
+     * in case poll callback didn't have time to run. */
+    virtio_queue_host_notifier_read(&vq->host_notifier);
 }
 
 void virtio_queue_host_notifier_read(EventNotifier *n)
-- 
2.34.1

The following changes since commit 05d50ba2d4668d43a835c5a502efdec9b92646e6:

Merge tag 'migration-20230427-pull-request' of https://gitlab.com/juan.quintela/qemu into staging (2023-04-28 08:35:06 +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 d3c760be786571d83d5cea01953e543df4d76f51:

docs/zoned-storage:add zoned emulation use case (2023-04-28 08:34:07 -0400)

----------------------------------------------------------------
Pull request

This pull request contains Sam Li's virtio-blk zoned storage work. These
patches were dropped from my previous block pull request due to CI failures.

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

Sam Li (17):
  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
  include: update virtio_blk headers to v6.3-rc1
  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

-- 
2.40.0

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: 20230427172019.3345-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.0

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: Stefan Hajnoczi <stefanha@redhat.com>
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: 20230427172019.3345-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               | 139 ++++++++++++++++++++++---------
 2 files changed, 104 insertions(+), 38 deletions(-)

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 @@ 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.
+ */
+static int get_sysfs_str_val(struct stat *st, const char *attribute,
+                             char **val) {
+#ifdef CONFIG_LINUX
+    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;
+#else
+    return -ENOTSUP;
+#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 (ret < 0) {
+        return ret;
+    }
+
+    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.
+ */
+static long get_sysfs_long_val(struct stat *st, const char *attribute)
 {
 #ifdef CONFIG_LINUX
-    char buf[32];
+    g_autofree char *str = NULL;
     const char *end;
-    char *sysfspath = NULL;
+    long val;
+    int ret;
+
+    ret = get_sysfs_str_val(st, attribute, &str);
+    if (ret < 0) {
+        return ret;
+    }
+
+    /* 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;
+#else
+    return -ENOTSUP;
+#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.0

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).

Qemu-io uses the new APIs to perform zoned storage commands of the device:
zone_report(zrp), zone_open(zo), zone_close(zc), zone_reset(zrs),
zone_finish(zf).

For example, to test zone_report, use following command:
$ ./build/qemu-io --image-opts -n driver=host_device, filename=/dev/nullb0
-c "zrp offset nr_zones"

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Reviewed-by: Hannes Reinecke <hare@suse.de>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.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: 20230427172019.3345-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                       |   4 +
 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, 695 insertions(+), 3 deletions(-)

diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ config_host_data.set('CONFIG_REPLICATION', get_option('replication').allowed())
 # has_header
 config_host_data.set('CONFIG_EPOLL', cc.has_header('sys/epoll.h'))
 config_host_data.set('CONFIG_LINUX_MAGIC_H', cc.has_header('linux/magic.h'))
+config_host_data.set('CONFIG_BLKZONED', cc.has_header('linux/blkzoned.h'))
 config_host_data.set('CONFIG_VALGRIND_H', cc.has_header('valgrind/valgrind.h'))
 config_host_data.set('HAVE_BTRFS_H', cc.has_header('linux/btrfs.h'))
 config_host_data.set('HAVE_DRM_H', cc.has_header('libdrm/drm.h'))
@@ -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 */
+    int64_t max_append_sectors;
+
+    /* maximum number of open zones */
+    int64_t max_open_zones;
+
+    /* maximum number of active zones */
+    int64_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);
+    return ret;
+}
+
+/*
+ * 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
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ out:
     return co.ret;
 }
 
+int coroutine_fn bdrv_co_zone_report(BlockDriverState *bs, int64_t offset,
+                        unsigned int *nr_zones,
+                        BlockZoneDescriptor *zones)
+{
+    BlockDriver *drv = bs->drv;
+    CoroutineIOCompletion co = {
+            .coroutine = qemu_coroutine_self(),
+    };
+    IO_CODE();
+
+    bdrv_inc_in_flight(bs);
+    if (!drv || !drv->bdrv_co_zone_report || bs->bl.zoned == BLK_Z_NONE) {
+        co.ret = -ENOTSUP;
+        goto out;
+    }
+    co.ret = drv->bdrv_co_zone_report(bs, offset, nr_zones, zones);
+out:
+    bdrv_dec_in_flight(bs);
+    return co.ret;
+}
+
+int coroutine_fn bdrv_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
+        int64_t offset, int64_t len)
+{
+    BlockDriver *drv = bs->drv;
+    CoroutineIOCompletion co = {
+            .coroutine = qemu_coroutine_self(),
+    };
+    IO_CODE();
+
+    bdrv_inc_in_flight(bs);
+    if (!drv || !drv->bdrv_co_zone_mgmt || bs->bl.zoned == BLK_Z_NONE) {
+        co.ret = -ENOTSUP;
+        goto out;
+    }
+    co.ret = drv->bdrv_co_zone_mgmt(bs, op, offset, len);
+out:
+    bdrv_dec_in_flight(bs);
+    return co.ret;
+}
+
 void *qemu_blockalign(BlockDriverState *bs, size_t size)
 {
     IO_CODE();
diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -XXX,XX +XXX,XX @@ static const cmdinfo_t flush_cmd = {
     .oneline    = "flush all in-core file state to disk",
 };
 
+static inline int64_t tosector(int64_t bytes)
+{
+    return bytes >> BDRV_SECTOR_BITS;
+}
+
+static int zone_report_f(BlockBackend *blk, int argc, char **argv)
+{
+    int ret;
+    int64_t offset;
+    unsigned int nr_zones;
+
+    ++optind;
+    offset = cvtnum(argv[optind]);
+    ++optind;
+    nr_zones = cvtnum(argv[optind]);
+
+    g_autofree BlockZoneDescriptor *zones = NULL;
+    zones = g_new(BlockZoneDescriptor, nr_zones);
+    ret = blk_zone_report(blk, offset, &nr_zones, zones);
+    if (ret < 0) {
+        printf("zone report failed: %s\n", strerror(-ret));
+    } else {
+        for (int i = 0; i < nr_zones; ++i) {
+            printf("start: 0x%" PRIx64 ", len 0x%" PRIx64 ", "
+                   "cap"" 0x%" PRIx64 ", wptr 0x%" PRIx64 ", "
+                   "zcond:%u, [type: %u]\n",
+                    tosector(zones[i].start), tosector(zones[i].length),
+                    tosector(zones[i].cap), tosector(zones[i].wp),
+                    zones[i].state, zones[i].type);
+        }
+    }
+    return ret;
+}
+
+static const cmdinfo_t zone_report_cmd = {
+    .name = "zone_report",
+    .altname = "zrp",
+    .cfunc = zone_report_f,
+    .argmin = 2,
+    .argmax = 2,
+    .args = "offset number",
+    .oneline = "report zone information",
+};
+
+static int zone_open_f(BlockBackend *blk, int argc, char **argv)
+{
+    int ret;
+    int64_t offset, len;
+    ++optind;
+    offset = cvtnum(argv[optind]);
+    ++optind;
+    len = cvtnum(argv[optind]);
+    ret = blk_zone_mgmt(blk, BLK_ZO_OPEN, offset, len);
+    if (ret < 0) {
+        printf("zone open failed: %s\n", strerror(-ret));
+    }
+    return ret;
+}
+
+static const cmdinfo_t zone_open_cmd = {
+    .name = "zone_open",
+    .altname = "zo",
+    .cfunc = zone_open_f,
+    .argmin = 2,
+    .argmax = 2,
+    .args = "offset len",
+    .oneline = "explicit open a range of zones in zone block device",
+};
+
+static int zone_close_f(BlockBackend *blk, int argc, char **argv)
+{
+    int ret;
+    int64_t offset, len;
+    ++optind;
+    offset = cvtnum(argv[optind]);
+    ++optind;
+    len = cvtnum(argv[optind]);
+    ret = blk_zone_mgmt(blk, BLK_ZO_CLOSE, offset, len);
+    if (ret < 0) {
+        printf("zone close failed: %s\n", strerror(-ret));
+    }
+    return ret;
+}
+
+static const cmdinfo_t zone_close_cmd = {
+    .name = "zone_close",
+    .altname = "zc",
+    .cfunc = zone_close_f,
+    .argmin = 2,
+    .argmax = 2,
+    .args = "offset len",
+    .oneline = "close a range of zones in zone block device",
+};
+
+static int zone_finish_f(BlockBackend *blk, int argc, char **argv)
+{
+    int ret;
+    int64_t offset, len;
+    ++optind;
+    offset = cvtnum(argv[optind]);
+    ++optind;
+    len = cvtnum(argv[optind]);
+    ret = blk_zone_mgmt(blk, BLK_ZO_FINISH, offset, len);
+    if (ret < 0) {
+        printf("zone finish failed: %s\n", strerror(-ret));
+    }
+    return ret;
+}
+
+static const cmdinfo_t zone_finish_cmd = {
+    .name = "zone_finish",
+    .altname = "zf",
+    .cfunc = zone_finish_f,
+    .argmin = 2,
+    .argmax = 2,
+    .args = "offset len",
+    .oneline = "finish a range of zones in zone block device",
+};
+
+static int zone_reset_f(BlockBackend *blk, int argc, char **argv)
+{
+    int ret;
+    int64_t offset, len;
+    ++optind;
+    offset = cvtnum(argv[optind]);
+    ++optind;
+    len = cvtnum(argv[optind]);
+    ret = blk_zone_mgmt(blk, BLK_ZO_RESET, offset, len);
+    if (ret < 0) {
+        printf("zone reset failed: %s\n", strerror(-ret));
+    }
+    return ret;
+}
+
+static const cmdinfo_t zone_reset_cmd = {
+    .name = "zone_reset",
+    .altname = "zrs",
+    .cfunc = zone_reset_f,
+    .argmin = 2,
+    .argmax = 2,
+    .args = "offset len",
+    .oneline = "reset a zone write pointer in zone block device",
+};
+
 static int truncate_f(BlockBackend *blk, int argc, char **argv);
 static const cmdinfo_t truncate_cmd = {
     .name       = "truncate",
@@ -XXX,XX +XXX,XX @@ static void __attribute((constructor)) init_qemuio_commands(void)
     qemuio_add_command(&aio_write_cmd);
     qemuio_add_command(&aio_flush_cmd);
     qemuio_add_command(&flush_cmd);
+    qemuio_add_command(&zone_report_cmd);
+    qemuio_add_command(&zone_open_cmd);
+    qemuio_add_command(&zone_close_cmd);
+    qemuio_add_command(&zone_finish_cmd);
+    qemuio_add_command(&zone_reset_cmd);
     qemuio_add_command(&truncate_cmd);
     qemuio_add_command(&length_cmd);
     qemuio_add_command(&info_cmd);
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

raw-format driver usually sits on top of file-posix driver. It needs to
pass through requests of zone commands.

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: 20230427172019.3345-5-faithilikerun@gmail.com
Message-id: 20230324090605.28361-5-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>
---
 block/raw-format.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
     return bdrv_co_pdiscard(bs->file, offset, bytes);
 }
 
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_zone_report(BlockDriverState *bs, int64_t offset,
+                   unsigned int *nr_zones,
+                   BlockZoneDescriptor *zones)
+{
+    return bdrv_co_zone_report(bs->file->bs, offset, nr_zones, zones);
+}
+
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
+                 int64_t offset, int64_t len)
+{
+    return bdrv_co_zone_mgmt(bs->file->bs, op, offset, len);
+}
+
 static int64_t coroutine_fn GRAPH_RDLOCK
 raw_co_getlength(BlockDriverState *bs)
 {
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_raw = {
     .bdrv_co_pwritev      = &raw_co_pwritev,
     .bdrv_co_pwrite_zeroes = &raw_co_pwrite_zeroes,
     .bdrv_co_pdiscard     = &raw_co_pdiscard,
+    .bdrv_co_zone_report  = &raw_co_zone_report,
+    .bdrv_co_zone_mgmt  = &raw_co_zone_mgmt,
     .bdrv_co_block_status = &raw_co_block_status,
     .bdrv_co_copy_range_from = &raw_co_copy_range_from,
     .bdrv_co_copy_range_to  = &raw_co_copy_range_to,
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

Putting zoned/non-zoned BlockDrivers on top of each other is not
allowed.

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.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: 20230427172019.3345-6-faithilikerun@gmail.com
Message-id: 20230324090605.28361-6-faithilikerun@gmail.com
[Adjust commit message prefix as suggested by Philippe Mathieu-Daudé
<philmd@linaro.org> and clarify that the check is about zoned
BlockDrivers.
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/block/block_int-common.h |  5 +++++
 block.c                          | 19 +++++++++++++++++++
 block/file-posix.c               | 12 ++++++++++++
 block/raw-format.c               |  1 +
 4 files changed, 37 insertions(+)

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 {
      */
     bool is_format;
 
+    /*
+     * Set to true if the BlockDriver supports zoned children.
+     */
+    bool supports_zoned_children;
+
     /*
      * Drivers not implementing bdrv_parse_filename nor bdrv_open should have
      * this field set to true, except ones that are defined only by their
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
         return;
     }
 
+    /*
+     * Non-zoned block drivers do not follow zoned storage constraints
+     * (i.e. sequential writes to zones). Refuse mixing zoned and non-zoned
+     * drivers in a graph.
+     */
+    if (!parent_bs->drv->supports_zoned_children &&
+        child_bs->bl.zoned == BLK_Z_HM) {
+        /*
+         * The host-aware model allows zoned storage constraints and random
+         * write. Allow mixing host-aware and non-zoned drivers. Using
+         * host-aware device as a regular device.
+         */
+        error_setg(errp, "Cannot add a %s child to a %s parent",
+                   child_bs->bl.zoned == BLK_Z_HM ? "zoned" : "non-zoned",
+                   parent_bs->drv->supports_zoned_children ?
+                   "support zoned children" : "not support zoned children");
+        return;
+    }
+
     if (!QLIST_EMPTY(&child_bs->parents)) {
         error_setg(errp, "The node %s already has a parent",
                    child_bs->node_name);
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 raw_open_common(BlockDriverState *bs, QDict *options,
             goto fail;
         }
     }
+#ifdef CONFIG_BLKZONED
+    /*
+     * The kernel page cache does not reliably work for writes to SWR zones
+     * of zoned block device because it can not guarantee the order of writes.
+     */
+    if ((bs->bl.zoned != BLK_Z_NONE) &&
+        (!(s->open_flags & O_DIRECT))) {
+        error_setg(errp, "The driver supports zoned devices, and it requires "
+                         "cache.direct=on, which was not specified.");
+        return -EINVAL; /* No host kernel page cache */
+    }
+#endif
 
     if (S_ISBLK(st.st_mode)) {
 #ifdef __linux__
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static void raw_child_perm(BlockDriverState *bs, BdrvChild *c,
 BlockDriver bdrv_raw = {
     .format_name          = "raw",
     .instance_size        = sizeof(BDRVRawState),
+    .supports_zoned_children = true,
     .bdrv_probe           = &raw_probe,
     .bdrv_reopen_prepare  = &raw_reopen_prepare,
     .bdrv_reopen_commit   = &raw_reopen_commit,
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

The new block layer APIs of zoned block devices can be tested by:
$ tests/qemu-iotests/check zoned
Run each zone operation on a newly created null_blk device
and see whether it outputs the same zone information.

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20230427172019.3345-7-faithilikerun@gmail.com
Message-id: 20230324090605.28361-7-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>
---
 tests/qemu-iotests/tests/zoned     | 89 ++++++++++++++++++++++++++++++
 tests/qemu-iotests/tests/zoned.out | 53 ++++++++++++++++++
 2 files changed, 142 insertions(+)
 create mode 100755 tests/qemu-iotests/tests/zoned
 create mode 100644 tests/qemu-iotests/tests/zoned.out

diff --git a/tests/qemu-iotests/tests/zoned b/tests/qemu-iotests/tests/zoned
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/zoned
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env bash
+#
+# Test zone management operations.
+#
+
+seq="$(basename $0)"
+echo "QA output created by $seq"
+status=1 # failure is the default!
+
+_cleanup()
+{
+  _cleanup_test_img
+  sudo -n rmmod null_blk
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ../common.rc
+. ../common.filter
+. ../common.qemu
+
+# This test only runs on Linux hosts with raw image files.
+_supported_fmt raw
+_supported_proto file
+_supported_os Linux
+
+sudo -n true || \
+    _notrun 'Password-less sudo required'
+
+IMG="--image-opts -n driver=host_device,filename=/dev/nullb0"
+QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT
+
+echo "Testing a null_blk device:"
+echo "case 1: if the operations work"
+sudo -n modprobe null_blk nr_devices=1 zoned=1
+sudo -n chmod 0666 /dev/nullb0
+
+echo "(1) report the first zone:"
+$QEMU_IO $IMG -c "zrp 0 1"
+echo
+echo "report the first 10 zones"
+$QEMU_IO $IMG -c "zrp 0 10"
+echo
+echo "report the last zone:"
+$QEMU_IO $IMG -c "zrp 0x3e70000000 2" # 0x3e70000000 / 512 = 0x1f380000
+echo
+echo
+echo "(2) opening the first zone"
+$QEMU_IO $IMG -c "zo 0 268435456"  # 268435456 / 512 = 524288
+echo "report after:"
+$QEMU_IO $IMG -c "zrp 0 1"
+echo
+echo "opening the second zone"
+$QEMU_IO $IMG -c "zo 268435456 268435456" #
+echo "report after:"
+$QEMU_IO $IMG -c "zrp 268435456 1"
+echo
+echo "opening the last zone"
+$QEMU_IO $IMG -c "zo 0x3e70000000 268435456"
+echo "report after:"
+$QEMU_IO $IMG -c "zrp 0x3e70000000 2"
+echo
+echo
+echo "(3) closing the first zone"
+$QEMU_IO $IMG -c "zc 0 268435456"
+echo "report after:"
+$QEMU_IO $IMG -c "zrp 0 1"
+echo
+echo "closing the last zone"
+$QEMU_IO $IMG -c "zc 0x3e70000000 268435456"
+echo "report after:"
+$QEMU_IO $IMG -c "zrp 0x3e70000000 2"
+echo
+echo
+echo "(4) finishing the second zone"
+$QEMU_IO $IMG -c "zf 268435456 268435456"
+echo "After finishing a zone:"
+$QEMU_IO $IMG -c "zrp 268435456 1"
+echo
+echo
+echo "(5) resetting the second zone"
+$QEMU_IO $IMG -c "zrs 268435456 268435456"
+echo "After resetting a zone:"
+$QEMU_IO $IMG -c "zrp 268435456 1"
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/tests/zoned.out b/tests/qemu-iotests/tests/zoned.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/zoned.out
@@ -XXX,XX +XXX,XX @@
+QA output created by zoned
+Testing a null_blk device:
+case 1: if the operations work
+(1) report the first zone:
+start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:1, [type: 2]
+
+report the first 10 zones
+start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:1, [type: 2]
+start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80000, zcond:1, [type: 2]
+start: 0x100000, len 0x80000, cap 0x80000, wptr 0x100000, zcond:1, [type: 2]
+start: 0x180000, len 0x80000, cap 0x80000, wptr 0x180000, zcond:1, [type: 2]
+start: 0x200000, len 0x80000, cap 0x80000, wptr 0x200000, zcond:1, [type: 2]
+start: 0x280000, len 0x80000, cap 0x80000, wptr 0x280000, zcond:1, [type: 2]
+start: 0x300000, len 0x80000, cap 0x80000, wptr 0x300000, zcond:1, [type: 2]
+start: 0x380000, len 0x80000, cap 0x80000, wptr 0x380000, zcond:1, [type: 2]
+start: 0x400000, len 0x80000, cap 0x80000, wptr 0x400000, zcond:1, [type: 2]
+start: 0x480000, len 0x80000, cap 0x80000, wptr 0x480000, zcond:1, [type: 2]
+
+report the last zone:
+start: 0x1f380000, len 0x80000, cap 0x80000, wptr 0x1f380000, zcond:1, [type: 2]
+
+
+(2) opening the first zone
+report after:
+start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:3, [type: 2]
+
+opening the second zone
+report after:
+start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80000, zcond:3, [type: 2]
+
+opening the last zone
+report after:
+start: 0x1f380000, len 0x80000, cap 0x80000, wptr 0x1f380000, zcond:3, [type: 2]
+
+
+(3) closing the first zone
+report after:
+start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:1, [type: 2]
+
+closing the last zone
+report after:
+start: 0x1f380000, len 0x80000, cap 0x80000, wptr 0x1f380000, zcond:1, [type: 2]
+
+
+(4) finishing the second zone
+After finishing a zone:
+start: 0x80000, len 0x80000, cap 0x80000, wptr 0x100000, zcond:14, [type: 2]
+
+
+(5) resetting the second zone
+After resetting a zone:
+start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80000, zcond:1, [type: 2]
+*** done
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.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: 20230427172019.3345-8-faithilikerun@gmail.com
Message-id: 20230324090605.28361-8-faithilikerun@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/file-posix.c | 3 +++
 block/trace-events | 2 ++
 2 files changed, 5 insertions(+)

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 coroutine_fn raw_co_zone_report(BlockDriverState *bs, int64_t offset,
         },
     };
 
+    trace_zbd_zone_report(bs, *nr_zones, offset >> BDRV_SECTOR_BITS);
     return raw_thread_pool_submit(handle_aiocb_zone_report, &acb);
 }
 #endif
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
         },
     };
 
+    trace_zbd_zone_mgmt(bs, op_name, offset >> BDRV_SECTOR_BITS,
+                        len >> BDRV_SECTOR_BITS);
     ret = raw_thread_pool_submit(handle_aiocb_zone_mgmt, &acb);
     if (ret != 0) {
         error_report("ioctl %s failed %d", op_name, ret);
diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ file_FindEjectableOpticalMedia(const char *media) "Matching using %s"
 file_setup_cdrom(const char *partition) "Using %s as optical disc"
 file_hdev_is_sg(int type, int version) "SG device found: type=%d, version=%d"
 file_flush_fdatasync_failed(int err) "errno %d"
+zbd_zone_report(void *bs, unsigned int nr_zones, int64_t sector) "bs %p report %d zones starting at sector offset 0x%" PRIx64 ""
+zbd_zone_mgmt(void *bs, const char *op_name, int64_t sector, int64_t len) "bs %p %s starts at sector offset 0x%" PRIx64 " over a range of 0x%" PRIx64 " sectors"
 
 # ssh.c
 sftp_error(const char *op, const char *ssh_err, int ssh_err_code, int sftp_err_code) "%s failed: %s (libssh error code: %d, sftp error code: %d)"
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

Add the documentation about the zoned device support to virtio-blk
emulation.

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: Dmitry Fomichev <dmitry.fomichev@wdc.com>
Acked-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20230427172019.3345-9-faithilikerun@gmail.com
Message-id: 20230324090605.28361-9-faithilikerun@gmail.com
[Add index-api.rst to fix "zoned-storage.rst:document isn't included in
any toctree" error and fix pre-formatted command-line indentation.
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 docs/devel/index-api.rst               |  1 +
 docs/devel/zoned-storage.rst           | 43 ++++++++++++++++++++++++++
 docs/system/qemu-block-drivers.rst.inc |  6 ++++
 3 files changed, 50 insertions(+)
 create mode 100644 docs/devel/zoned-storage.rst

diff --git a/docs/devel/index-api.rst b/docs/devel/index-api.rst
index XXXXXXX..XXXXXXX 100644
--- a/docs/devel/index-api.rst
+++ b/docs/devel/index-api.rst
@@ -XXX,XX +XXX,XX @@ generated from in-code annotations to function prototypes.
    memory
    modules
    ui
+   zoned-storage
diff --git a/docs/devel/zoned-storage.rst b/docs/devel/zoned-storage.rst
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/docs/devel/zoned-storage.rst
@@ -XXX,XX +XXX,XX @@
+=============
+zoned-storage
+=============
+
+Zoned Block Devices (ZBDs) divide the LBA space into block regions called zones
+that are larger than the LBA size. They can only allow sequential writes, which
+can reduce write amplification in SSDs, and potentially lead to higher
+throughput and increased capacity. More details about ZBDs can be found at:
+
+https://zonedstorage.io/docs/introduction/zoned-storage
+
+1. Block layer APIs for zoned storage
+-------------------------------------
+QEMU block layer supports three zoned storage models:
+- BLK_Z_HM: The host-managed zoned model only allows sequential writes access
+to zones. It supports ZBD-specific I/O commands that can be used by a host to
+manage the zones of a device.
+- BLK_Z_HA: The host-aware zoned model allows random write operations in
+zones, making it backward compatible with regular block devices.
+- BLK_Z_NONE: The non-zoned model has no zones support. It includes both
+regular and drive-managed ZBD devices. ZBD-specific I/O commands are not
+supported.
+
+The block device information resides inside BlockDriverState. QEMU uses
+BlockLimits struct(BlockDriverState::bl) that is continuously accessed by the
+block layer while processing I/O requests. A BlockBackend has a root pointer to
+a BlockDriverState graph(for example, raw format on top of file-posix). The
+zoned storage information can be propagated from the leaf BlockDriverState all
+the way up to the BlockBackend. If the zoned storage model in file-posix is
+set to BLK_Z_HM, then block drivers will declare support for zoned host device.
+
+The block layer APIs support commands needed for zoned storage devices,
+including report zones, four zone operations, and zone append.
+
+2. Emulating zoned storage controllers
+--------------------------------------
+When the BlockBackend's BlockLimits model reports a zoned storage device, users
+like the virtio-blk emulation or the qemu-io-cmds.c utility can use block layer
+APIs for zoned storage emulation or testing.
+
+For example, to test zone_report on a null_blk device using qemu-io is::
+
+  $ path/to/qemu-io --image-opts -n driver=host_device,filename=/dev/nullb0 -c "zrp offset nr_zones"
diff --git a/docs/system/qemu-block-drivers.rst.inc b/docs/system/qemu-block-drivers.rst.inc
index XXXXXXX..XXXXXXX 100644
--- a/docs/system/qemu-block-drivers.rst.inc
+++ b/docs/system/qemu-block-drivers.rst.inc
@@ -XXX,XX +XXX,XX @@ Hard disks
   you may corrupt your host data (use the ``-snapshot`` command
   line option or modify the device permissions accordingly).
 
+Zoned block devices
+  Zoned block devices can be passed through to the guest if the emulated storage
+  controller supports zoned storage. Use ``--blockdev host_device,
+  node-name=drive0,filename=/dev/nullb0,cache.direct=on`` to pass through
+  ``/dev/nullb0`` as ``drive0``.
+
 Windows
 ^^^^^^^
 
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

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>
Message-id: 20230427172339.3709-2-faithilikerun@gmail.com
[Fix errno propagation from handle_aiocb_zone_mgmt()
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/block/block-common.h     |  14 +++
 include/block/block_int-common.h |   5 +
 block/file-posix.c               | 178 ++++++++++++++++++++++++++++++-
 3 files changed, 193 insertions(+), 4 deletions(-)

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 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;
@@ -XXX,XX +XXX,XX @@ 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 XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int-common.h
+++ b/include/block/block_int-common.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockLimits {
 
     /* maximum number of active zones */
     int64_t max_active_zones;
+
+    int64_t write_granularity;
 } BlockLimits;
 
 typedef struct BdrvOpBlocker BdrvOpBlocker;
@@ -XXX,XX +XXX,XX @@ 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 {
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_segments(int fd, struct stat *st)
 }
 
 #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;
+    unsigned int j = offset / bs->bl.zone_size;
+    unsigned int n = 0, i = 0;
+    int ret;
+    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");
+    }
+}
+
 static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
                                      Error **errp)
 {
+    BDRVRawState *s = bs->opaque;
     BlockZoneModel zoned;
     int ret;
 
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
     if (ret > 0) {
         bs->bl.max_append_sectors = ret >> BDRV_SECTOR_BITS;
     }
+
+    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);
 }
 #else /* !defined(CONFIG_BLKZONED) */
 static void raw_refresh_zoned_limits(BlockDriverState *bs, struct stat *st,
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_zone_mgmt(void *opaque)
         ret = ioctl(fd, aiocb->zone_mgmt.op, &range);
     } while (ret != 0 && errno == EINTR);
 
-    return ret;
+    return ret < 0 ? -errno : ret;
 }
 #endif
 
@@ -XXX,XX +XXX,XX @@ 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
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
 #ifdef CONFIG_LINUX_IO_URING
     } else if (s->use_linux_io_uring) {
         assert(qiov->size == bytes);
-        return luring_co_submit(bs, s->fd, offset, qiov, type);
+        ret = luring_co_submit(bs, s->fd, offset, qiov, type);
+        goto out;
 #endif
 #ifdef CONFIG_LINUX_AIO
     } else if (s->use_linux_aio) {
         assert(qiov->size == bytes);
-        return laio_co_submit(s->fd, offset, qiov, type, s->aio_max_batch);
+        ret = laio_co_submit(s->fd, offset, qiov, type,
+                              s->aio_max_batch);
+        goto out;
 #endif
     }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
     };
 
     assert(qiov->size == bytes);
-    return raw_thread_pool_submit(handle_aiocb_rw, &acb);
+    ret = raw_thread_pool_submit(handle_aiocb_rw, &acb);
+    goto out; /* Avoid the compiler err of unused label */
+
+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,
@@ -XXX,XX +XXX,XX @@ 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;
     }
@@ -XXX,XX +XXX,XX @@ 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;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
         return -EINVAL;
     }
 
+    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";
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
                         len >> BDRV_SECTOR_BITS);
     ret = raw_thread_pool_submit(handle_aiocb_zone_mgmt, &acb);
     if (ret != 0) {
+        update_zones_wp(bs, s->fd, offset, i);
         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 (unsigned int j = 0; j < nrz; ++j) {
+            wp[j] = offset + j * zone_size;
+        }
+    } else if (zo == BLKFINISHZONE) {
+        for (unsigned 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;
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

A zone append command is a write operation that specifies the first
logical block of a zone as the write position. When writing to a zoned
block device using zone append, the byte offset of the call may point at
any position within the zone to which the data is being appended. Upon
completion the device will respond with the position where the data has
been written in the zone.

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20230427172339.3709-3-faithilikerun@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/block/block-io.h          |  4 ++
 include/block/block_int-common.h  |  3 ++
 include/block/raw-aio.h           |  4 +-
 include/sysemu/block-backend-io.h |  9 +++++
 block/block-backend.c             | 61 +++++++++++++++++++++++++++++++
 block/file-posix.c                | 58 +++++++++++++++++++++++++----
 block/io.c                        | 27 ++++++++++++++
 block/io_uring.c                  |  4 ++
 block/linux-aio.c                 |  3 ++
 block/raw-format.c                |  8 ++++
 10 files changed, 173 insertions(+), 8 deletions(-)

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_zone_report(BlockDriverState *bs,
 int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_mgmt(BlockDriverState *bs,
                                                 BlockZoneOp op,
                                                 int64_t offset, int64_t len);
+int coroutine_fn GRAPH_RDLOCK bdrv_co_zone_append(BlockDriverState *bs,
+                                                  int64_t *offset,
+                                                  QEMUIOVector *qiov,
+                                                  BdrvRequestFlags flags);
 
 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
 int bdrv_block_status(BlockDriverState *bs, int64_t offset,
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 {
             BlockZoneDescriptor *zones);
     int coroutine_fn (*bdrv_co_zone_mgmt)(BlockDriverState *bs, BlockZoneOp op,
             int64_t offset, int64_t len);
+    int coroutine_fn (*bdrv_co_zone_append)(BlockDriverState *bs,
+            int64_t *offset, QEMUIOVector *qiov,
+            BdrvRequestFlags flags);
 
     /* removable device specific */
     bool coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_is_inserted)(
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_TRUNCATE     0x0080
 #define QEMU_AIO_ZONE_REPORT  0x0100
 #define QEMU_AIO_ZONE_MGMT    0x0200
+#define QEMU_AIO_ZONE_APPEND  0x0400
 #define QEMU_AIO_TYPE_MASK \
         (QEMU_AIO_READ | \
          QEMU_AIO_WRITE | \
@@ -XXX,XX +XXX,XX @@
          QEMU_AIO_COPY_RANGE | \
          QEMU_AIO_TRUNCATE | \
          QEMU_AIO_ZONE_REPORT | \
-         QEMU_AIO_ZONE_MGMT)
+         QEMU_AIO_ZONE_MGMT | \
+         QEMU_AIO_ZONE_APPEND)
 
 /* 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_zone_report(BlockBackend *blk, int64_t offset,
 BlockAIOCB *blk_aio_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
                               int64_t offset, int64_t len,
                               BlockCompletionFunc *cb, void *opaque);
+BlockAIOCB *blk_aio_zone_append(BlockBackend *blk, int64_t *offset,
+                                QEMUIOVector *qiov, BdrvRequestFlags flags,
+                                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 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 coroutine_fn blk_co_zone_append(BlockBackend *blk, int64_t *offset,
+                                    QEMUIOVector *qiov,
+                                    BdrvRequestFlags flags);
+int co_wrapper_mixed blk_zone_append(BlockBackend *blk, int64_t *offset,
+                                         QEMUIOVector *qiov,
+                                         BdrvRequestFlags flags);
 
 int co_wrapper_mixed blk_pdiscard(BlockBackend *blk, int64_t offset,
                                   int64_t bytes);
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 @@ BlockAIOCB *blk_aio_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
     return &acb->common;
 }
 
+static void coroutine_fn blk_aio_zone_append_entry(void *opaque)
+{
+    BlkAioEmAIOCB *acb = opaque;
+    BlkRwCo *rwco = &acb->rwco;
+
+    rwco->ret = blk_co_zone_append(rwco->blk, (int64_t *)(uintptr_t)acb->bytes,
+                                   rwco->iobuf, rwco->flags);
+    blk_aio_complete(acb);
+}
+
+BlockAIOCB *blk_aio_zone_append(BlockBackend *blk, int64_t *offset,
+                                QEMUIOVector *qiov, BdrvRequestFlags flags,
+                                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,
+        .ret    = NOT_DONE,
+        .flags  = flags,
+        .iobuf  = qiov,
+    };
+    acb->bytes = (int64_t)(uintptr_t)offset;
+    acb->has_returned = false;
+
+    co = qemu_coroutine_create(blk_aio_zone_append_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
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_zone_mgmt(BlockBackend *blk, BlockZoneOp op,
     return ret;
 }
 
+/*
+ * Send a zone_append command.
+ */
+int coroutine_fn blk_co_zone_append(BlockBackend *blk, int64_t *offset,
+        QEMUIOVector *qiov, BdrvRequestFlags flags)
+{
+    int ret;
+    IO_CODE();
+
+    blk_inc_in_flight(blk);
+    blk_wait_while_drained(blk);
+    GRAPH_RDLOCK_GUARD();
+    if (!blk_is_available(blk)) {
+        blk_dec_in_flight(blk);
+        return -ENOMEDIUM;
+    }
+
+    ret = bdrv_co_zone_append(blk_bs(blk), offset, qiov, flags);
+    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 @@ typedef struct BDRVRawState {
     bool has_write_zeroes:1;
     bool use_linux_aio:1;
     bool use_linux_io_uring:1;
+    int64_t *offset; /* offset of zone append operation */
     int page_cache_inconsistent; /* errno from fdatasync failure */
     bool has_fallocate;
     bool needs_alignment;
@@ -XXX,XX +XXX,XX @@ static ssize_t handle_aiocb_rw_vector(RawPosixAIOData *aiocb)
     ssize_t len;
 
     len = RETRY_ON_EINTR(
-        (aiocb->aio_type & QEMU_AIO_WRITE) ?
+        (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) ?
             qemu_pwritev(aiocb->aio_fildes,
                            aiocb->io.iov,
                            aiocb->io.niov,
@@ -XXX,XX +XXX,XX @@ static ssize_t handle_aiocb_rw_linear(RawPosixAIOData *aiocb, char *buf)
     ssize_t len;
 
     while (offset < aiocb->aio_nbytes) {
-        if (aiocb->aio_type & QEMU_AIO_WRITE) {
+        if (aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) {
             len = pwrite(aiocb->aio_fildes,
                          (const char *)buf + offset,
                          aiocb->aio_nbytes - offset,
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_rw(void *opaque)
     }
 
     nbytes = handle_aiocb_rw_linear(aiocb, buf);
-    if (!(aiocb->aio_type & QEMU_AIO_WRITE)) {
+    if (!(aiocb->aio_type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))) {
         char *p = buf;
         size_t count = aiocb->aio_nbytes, copy;
         int i;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_prw(BlockDriverState *bs, uint64_t offset,
     if (fd_open(bs) < 0)
         return -EIO;
 #if defined(CONFIG_BLKZONED)
-    if (type & QEMU_AIO_WRITE && bs->wps) {
+    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) && bs->wps) {
         qemu_co_mutex_lock(&bs->wps->colock);
+        if (type & QEMU_AIO_ZONE_APPEND && bs->bl.zone_size) {
+            int index = offset / bs->bl.zone_size;
+            offset = bs->wps->wp[index];
+        }
     }
 #endif
 
@@ -XXX,XX +XXX,XX @@ out:
 {
     BlockZoneWps *wps = bs->wps;
     if (ret == 0) {
-        if (type & QEMU_AIO_WRITE && wps && bs->bl.zone_size) {
+        if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND))
+            && wps && bs->bl.zone_size) {
             uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
             if (!BDRV_ZT_IS_CONV(*wp)) {
+                if (type & QEMU_AIO_ZONE_APPEND) {
+                    *s->offset = *wp;
+                }
                 /* Advance the wp if needed */
                 if (offset + bytes > *wp) {
                     *wp = offset + bytes;
@@ -XXX,XX +XXX,XX @@ out:
             }
         }
     } else {
-        if (type & QEMU_AIO_WRITE) {
+        if (type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) {
             update_zones_wp(bs, s->fd, 0, 1);
         }
     }
 
-    if (type & QEMU_AIO_WRITE && wps) {
+    if ((type & (QEMU_AIO_WRITE | QEMU_AIO_ZONE_APPEND)) && wps) {
         qemu_co_mutex_unlock(&wps->colock);
     }
 }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
 }
 #endif
 
+#if defined(CONFIG_BLKZONED)
+static int coroutine_fn raw_co_zone_append(BlockDriverState *bs,
+                                           int64_t *offset,
+                                           QEMUIOVector *qiov,
+                                           BdrvRequestFlags flags) {
+    assert(flags == 0);
+    int64_t zone_size_mask = bs->bl.zone_size - 1;
+    int64_t iov_len = 0;
+    int64_t len = 0;
+    BDRVRawState *s = bs->opaque;
+    s->offset = offset;
+
+    if (*offset & zone_size_mask) {
+        error_report("sector offset %" PRId64 " is not aligned to zone size "
+                     "%" PRId32 "", *offset / 512, bs->bl.zone_size / 512);
+        return -EINVAL;
+    }
+
+    int64_t wg = bs->bl.write_granularity;
+    int64_t wg_mask = wg - 1;
+    for (int i = 0; i < qiov->niov; i++) {
+        iov_len = qiov->iov[i].iov_len;
+        if (iov_len & wg_mask) {
+            error_report("len of IOVector[%d] %" PRId64 " is not aligned to "
+                         "block size %" PRId64 "", i, iov_len, wg);
+            return -EINVAL;
+        }
+        len += iov_len;
+    }
+
+    return raw_co_prw(bs, *offset, len, qiov, QEMU_AIO_ZONE_APPEND);
+}
+#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 = {
     /* zone management operations */
     .bdrv_co_zone_report = raw_co_zone_report,
     .bdrv_co_zone_mgmt = raw_co_zone_mgmt,
+    .bdrv_co_zone_append = raw_co_zone_append,
 #endif
 };
 
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ out:
     return co.ret;
 }
 
+int coroutine_fn bdrv_co_zone_append(BlockDriverState *bs, int64_t *offset,
+                        QEMUIOVector *qiov,
+                        BdrvRequestFlags flags)
+{
+    int ret;
+    BlockDriver *drv = bs->drv;
+    CoroutineIOCompletion co = {
+            .coroutine = qemu_coroutine_self(),
+    };
+    IO_CODE();
+
+    ret = bdrv_check_qiov_request(*offset, qiov->size, qiov, 0, NULL);
+    if (ret < 0) {
+        return ret;
+    }
+
+    bdrv_inc_in_flight(bs);
+    if (!drv || !drv->bdrv_co_zone_append || bs->bl.zoned == BLK_Z_NONE) {
+        co.ret = -ENOTSUP;
+        goto out;
+    }
+    co.ret = drv->bdrv_co_zone_append(bs, offset, qiov, flags);
+out:
+    bdrv_dec_in_flight(bs);
+    return co.ret;
+}
+
 void *qemu_blockalign(BlockDriverState *bs, size_t size)
 {
     IO_CODE();
diff --git a/block/io_uring.c b/block/io_uring.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io_uring.c
+++ b/block/io_uring.c
@@ -XXX,XX +XXX,XX @@ static int luring_do_submit(int fd, LuringAIOCB *luringcb, LuringState *s,
         io_uring_prep_writev(sqes, fd, luringcb->qiov->iov,
                              luringcb->qiov->niov, offset);
         break;
+    case QEMU_AIO_ZONE_APPEND:
+        io_uring_prep_writev(sqes, fd, luringcb->qiov->iov,
+                             luringcb->qiov->niov, offset);
+        break;
     case QEMU_AIO_READ:
         io_uring_prep_readv(sqes, fd, luringcb->qiov->iov,
                             luringcb->qiov->niov, offset);
diff --git a/block/linux-aio.c b/block/linux-aio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/linux-aio.c
+++ b/block/linux-aio.c
@@ -XXX,XX +XXX,XX @@ static int laio_do_submit(int fd, struct qemu_laiocb *laiocb, off_t offset,
     case QEMU_AIO_WRITE:
         io_prep_pwritev(iocbs, fd, qiov->iov, qiov->niov, offset);
         break;
+    case QEMU_AIO_ZONE_APPEND:
+        io_prep_pwritev(iocbs, fd, qiov->iov, qiov->niov, offset);
+        break;
     case QEMU_AIO_READ:
         io_prep_preadv(iocbs, fd, qiov->iov, qiov->niov, offset);
         break;
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
     return bdrv_co_zone_mgmt(bs->file->bs, op, offset, len);
 }
 
+static int coroutine_fn GRAPH_RDLOCK
+raw_co_zone_append(BlockDriverState *bs,int64_t *offset, QEMUIOVector *qiov,
+                   BdrvRequestFlags flags)
+{
+    return bdrv_co_zone_append(bs->file->bs, offset, qiov, flags);
+}
+
 static int64_t coroutine_fn GRAPH_RDLOCK
 raw_co_getlength(BlockDriverState *bs)
 {
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_raw = {
     .bdrv_co_pdiscard     = &raw_co_pdiscard,
     .bdrv_co_zone_report  = &raw_co_zone_report,
     .bdrv_co_zone_mgmt  = &raw_co_zone_mgmt,
+    .bdrv_co_zone_append = &raw_co_zone_append,
     .bdrv_co_block_status = &raw_co_block_status,
     .bdrv_co_copy_range_from = &raw_co_copy_range_from,
     .bdrv_co_copy_range_to  = &raw_co_copy_range_to,
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

The patch tests zone append writes by reporting the zone wp after
the completion of the call. "zap -p" option can print the sector
offset value after completion, which should be the start sector
where the append write begins.

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20230427172339.3709-4-faithilikerun@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qemu-io-cmds.c                     | 75 ++++++++++++++++++++++++++++++
 tests/qemu-iotests/tests/zoned     | 16 +++++++
 tests/qemu-iotests/tests/zoned.out | 16 +++++++
 3 files changed, 107 insertions(+)

diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -XXX,XX +XXX,XX @@ static const cmdinfo_t zone_reset_cmd = {
     .oneline = "reset a zone write pointer in zone block device",
 };
 
+static int do_aio_zone_append(BlockBackend *blk, QEMUIOVector *qiov,
+                              int64_t *offset, int flags, int *total)
+{
+    int async_ret = NOT_DONE;
+
+    blk_aio_zone_append(blk, offset, qiov, flags, aio_rw_done, &async_ret);
+    while (async_ret == NOT_DONE) {
+        main_loop_wait(false);
+    }
+
+    *total = qiov->size;
+    return async_ret < 0 ? async_ret : 1;
+}
+
+static int zone_append_f(BlockBackend *blk, int argc, char **argv)
+{
+    int ret;
+    bool pflag = false;
+    int flags = 0;
+    int total = 0;
+    int64_t offset;
+    char *buf;
+    int c, nr_iov;
+    int pattern = 0xcd;
+    QEMUIOVector qiov;
+
+    if (optind > argc - 3) {
+        return -EINVAL;
+    }
+
+    if ((c = getopt(argc, argv, "p")) != -1) {
+        pflag = true;
+    }
+
+    offset = cvtnum(argv[optind]);
+    if (offset < 0) {
+        print_cvtnum_err(offset, argv[optind]);
+        return offset;
+    }
+    optind++;
+    nr_iov = argc - optind;
+    buf = create_iovec(blk, &qiov, &argv[optind], nr_iov, pattern,
+                       flags & BDRV_REQ_REGISTERED_BUF);
+    if (buf == NULL) {
+        return -EINVAL;
+    }
+    ret = do_aio_zone_append(blk, &qiov, &offset, flags, &total);
+    if (ret < 0) {
+        printf("zone append failed: %s\n", strerror(-ret));
+        goto out;
+    }
+
+    if (pflag) {
+        printf("After zap done, the append sector is 0x%" PRIx64 "\n",
+               tosector(offset));
+    }
+
+out:
+    qemu_io_free(blk, buf, qiov.size,
+                 flags & BDRV_REQ_REGISTERED_BUF);
+    qemu_iovec_destroy(&qiov);
+    return ret;
+}
+
+static const cmdinfo_t zone_append_cmd = {
+    .name = "zone_append",
+    .altname = "zap",
+    .cfunc = zone_append_f,
+    .argmin = 3,
+    .argmax = 4,
+    .args = "offset len [len..]",
+    .oneline = "append write a number of bytes at a specified offset",
+};
+
 static int truncate_f(BlockBackend *blk, int argc, char **argv);
 static const cmdinfo_t truncate_cmd = {
     .name       = "truncate",
@@ -XXX,XX +XXX,XX @@ static void __attribute((constructor)) init_qemuio_commands(void)
     qemuio_add_command(&zone_close_cmd);
     qemuio_add_command(&zone_finish_cmd);
     qemuio_add_command(&zone_reset_cmd);
+    qemuio_add_command(&zone_append_cmd);
     qemuio_add_command(&truncate_cmd);
     qemuio_add_command(&length_cmd);
     qemuio_add_command(&info_cmd);
diff --git a/tests/qemu-iotests/tests/zoned b/tests/qemu-iotests/tests/zoned
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/tests/zoned
+++ b/tests/qemu-iotests/tests/zoned
@@ -XXX,XX +XXX,XX @@ echo "(5) resetting the second zone"
 $QEMU_IO $IMG -c "zrs 268435456 268435456"
 echo "After resetting a zone:"
 $QEMU_IO $IMG -c "zrp 268435456 1"
+echo
+echo
+echo "(6) append write" # the physical block size of the device is 4096
+$QEMU_IO $IMG -c "zrp 0 1"
+$QEMU_IO $IMG -c "zap -p 0 0x1000 0x2000"
+echo "After appending the first zone firstly:"
+$QEMU_IO $IMG -c "zrp 0 1"
+$QEMU_IO $IMG -c "zap -p 0 0x1000 0x2000"
+echo "After appending the first zone secondly:"
+$QEMU_IO $IMG -c "zrp 0 1"
+$QEMU_IO $IMG -c "zap -p 268435456 0x1000 0x2000"
+echo "After appending the second zone firstly:"
+$QEMU_IO $IMG -c "zrp 268435456 1"
+$QEMU_IO $IMG -c "zap -p 268435456 0x1000 0x2000"
+echo "After appending the second zone secondly:"
+$QEMU_IO $IMG -c "zrp 268435456 1"
 
 # success, all done
 echo "*** done"
diff --git a/tests/qemu-iotests/tests/zoned.out b/tests/qemu-iotests/tests/zoned.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/tests/zoned.out
+++ b/tests/qemu-iotests/tests/zoned.out
@@ -XXX,XX +XXX,XX @@ start: 0x80000, len 0x80000, cap 0x80000, wptr 0x100000, zcond:14, [type: 2]
 (5) resetting the second zone
 After resetting a zone:
 start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80000, zcond:1, [type: 2]
+
+
+(6) append write
+start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:1, [type: 2]
+After zap done, the append sector is 0x0
+After appending the first zone firstly:
+start: 0x0, len 0x80000, cap 0x80000, wptr 0x18, zcond:2, [type: 2]
+After zap done, the append sector is 0x18
+After appending the first zone secondly:
+start: 0x0, len 0x80000, cap 0x80000, wptr 0x30, zcond:2, [type: 2]
+After zap done, the append sector is 0x80000
+After appending the second zone firstly:
+start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80018, zcond:2, [type: 2]
+After zap done, the append sector is 0x80018
+After appending the second zone secondly:
+start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80030, zcond:2, [type: 2]
 *** done
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

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 @@ out:
             if (!BDRV_ZT_IS_CONV(*wp)) {
                 if (type & QEMU_AIO_ZONE_APPEND) {
                     *s->offset = *wp;
+                    trace_zbd_zone_append_complete(bs, *s->offset
+                        >> BDRV_SECTOR_BITS);
                 }
                 /* Advance the wp if needed */
                 if (offset + bytes > *wp) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_append(BlockDriverState *bs,
         len += iov_len;
     }
 
+    trace_zbd_zone_append(bs, *offset >> BDRV_SECTOR_BITS);
     return raw_co_prw(bs, *offset, len, qiov, QEMU_AIO_ZONE_APPEND);
 }
 #endif
diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ file_hdev_is_sg(int type, int version) "SG device found: type=%d, version=%d"
 file_flush_fdatasync_failed(int err) "errno %d"
 zbd_zone_report(void *bs, unsigned int nr_zones, int64_t sector) "bs %p report %d zones starting at sector offset 0x%" PRIx64 ""
 zbd_zone_mgmt(void *bs, const char *op_name, int64_t sector, int64_t len) "bs %p %s starts at sector offset 0x%" PRIx64 " over a range of 0x%" PRIx64 " sectors"
+zbd_zone_append(void *bs, int64_t sector) "bs %p append at sector offset 0x%" PRIx64 ""
+zbd_zone_append_complete(void *bs, int64_t sector) "bs %p returns append sector 0x%" PRIx64 ""
 
 # ssh.c
 sftp_error(const char *op, const char *ssh_err, int ssh_err_code, int sftp_err_code) "%s failed: %s (libssh error code: %d, sftp error code: %d)"
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

Use scripts/update-linux-headers.sh to update headers to 6.3-rc1.

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
[Reran scripts/update-linux-headers.sh on Linux v6.3. The only change
was the use of __virtioXX types instead of uintXX_t.
--Stefan]
Message-Id: <20230407082528.18841-2-faithilikerun@gmail.com>
---
 include/standard-headers/drm/drm_fourcc.h    |  12 +++
 include/standard-headers/linux/ethtool.h     |  48 ++++++++-
 include/standard-headers/linux/fuse.h        |  45 +++++++-
 include/standard-headers/linux/pci_regs.h    |   1 +
 include/standard-headers/linux/vhost_types.h |   2 +
 include/standard-headers/linux/virtio_blk.h  | 105 +++++++++++++++++++
 linux-headers/asm-arm64/kvm.h                |   1 +
 linux-headers/asm-x86/kvm.h                  |  34 +++++-
 linux-headers/linux/kvm.h                    |   9 ++
 linux-headers/linux/vfio.h                   |  15 +--
 linux-headers/linux/vhost.h                  |   8 ++
 11 files changed, 270 insertions(+), 10 deletions(-)

diff --git a/include/standard-headers/drm/drm_fourcc.h b/include/standard-headers/drm/drm_fourcc.h
index XXXXXXX..XXXXXXX 100644
--- a/include/standard-headers/drm/drm_fourcc.h
+++ b/include/standard-headers/drm/drm_fourcc.h
@@ -XXX,XX +XXX,XX @@ extern "C" {
  *
  * The authoritative list of format modifier codes is found in
  * `include/uapi/drm/drm_fourcc.h`
+ *
+ * Open Source User Waiver
+ * -----------------------
+ *
+ * Because this is the authoritative source for pixel formats and modifiers
+ * referenced by GL, Vulkan extensions and other standards and hence used both
+ * by open source and closed source driver stacks, the usual requirement for an
+ * upstream in-kernel or open source userspace user does not apply.
+ *
+ * To ensure, as much as feasible, compatibility across stacks and avoid
+ * confusion with incompatible enumerations stakeholders for all relevant driver
+ * stacks should approve additions.
  */
 
 #define fourcc_code(a, b, c, d) ((uint32_t)(a) | ((uint32_t)(b) << 8) | \
diff --git a/include/standard-headers/linux/ethtool.h b/include/standard-headers/linux/ethtool.h
index XXXXXXX..XXXXXXX 100644
--- a/include/standard-headers/linux/ethtool.h
+++ b/include/standard-headers/linux/ethtool.h
@@ -XXX,XX +XXX,XX @@ enum ethtool_stringset {
 	ETH_SS_COUNT
 };
 
+/**
+ * enum ethtool_mac_stats_src - source of ethtool MAC statistics
+ * @ETHTOOL_MAC_STATS_SRC_AGGREGATE:
+ *	if device supports a MAC merge layer, this retrieves the aggregate
+ *	statistics of the eMAC and pMAC. Otherwise, it retrieves just the
+ *	statistics of the single (express) MAC.
+ * @ETHTOOL_MAC_STATS_SRC_EMAC:
+ *	if device supports a MM layer, this retrieves the eMAC statistics.
+ *	Otherwise, it retrieves the statistics of the single (express) MAC.
+ * @ETHTOOL_MAC_STATS_SRC_PMAC:
+ *	if device supports a MM layer, this retrieves the pMAC statistics.
+ */
+enum ethtool_mac_stats_src {
+	ETHTOOL_MAC_STATS_SRC_AGGREGATE,
+	ETHTOOL_MAC_STATS_SRC_EMAC,
+	ETHTOOL_MAC_STATS_SRC_PMAC,
+};
+
 /**
  * enum ethtool_module_power_mode_policy - plug-in module power mode policy
  * @ETHTOOL_MODULE_POWER_MODE_POLICY_HIGH: Module is always in high power mode.
@@ -XXX,XX +XXX,XX @@ enum ethtool_podl_pse_pw_d_status {
 	ETHTOOL_PODL_PSE_PW_D_STATUS_ERROR,
 };
 
+/**
+ * enum ethtool_mm_verify_status - status of MAC Merge Verify function
+ * @ETHTOOL_MM_VERIFY_STATUS_UNKNOWN:
+ *	verification status is unknown
+ * @ETHTOOL_MM_VERIFY_STATUS_INITIAL:
+ *	the 802.3 Verify State diagram is in the state INIT_VERIFICATION
+ * @ETHTOOL_MM_VERIFY_STATUS_VERIFYING:
+ *	the Verify State diagram is in the state VERIFICATION_IDLE,
+ *	SEND_VERIFY or WAIT_FOR_RESPONSE
+ * @ETHTOOL_MM_VERIFY_STATUS_SUCCEEDED:
+ *	indicates that the Verify State diagram is in the state VERIFIED
+ * @ETHTOOL_MM_VERIFY_STATUS_FAILED:
+ *	the Verify State diagram is in the state VERIFY_FAIL
+ * @ETHTOOL_MM_VERIFY_STATUS_DISABLED:
+ *	verification of preemption operation is disabled
+ */
+enum ethtool_mm_verify_status {
+	ETHTOOL_MM_VERIFY_STATUS_UNKNOWN,
+	ETHTOOL_MM_VERIFY_STATUS_INITIAL,
+	ETHTOOL_MM_VERIFY_STATUS_VERIFYING,
+	ETHTOOL_MM_VERIFY_STATUS_SUCCEEDED,
+	ETHTOOL_MM_VERIFY_STATUS_FAILED,
+	ETHTOOL_MM_VERIFY_STATUS_DISABLED,
+};
+
 /**
  * struct ethtool_gstrings - string set for data tagging
  * @cmd: Command number = %ETHTOOL_GSTRINGS
@@ -XXX,XX +XXX,XX @@ struct ethtool_rxnfc {
 		uint32_t			rule_cnt;
 		uint32_t			rss_context;
 	};
-	uint32_t				rule_locs[0];
+	uint32_t				rule_locs[];
 };
 
 
@@ -XXX,XX +XXX,XX @@ enum ethtool_link_mode_bit_indices {
 	ETHTOOL_LINK_MODE_800000baseDR8_2_Full_BIT	 = 96,
 	ETHTOOL_LINK_MODE_800000baseSR8_Full_BIT	 = 97,
 	ETHTOOL_LINK_MODE_800000baseVR8_Full_BIT	 = 98,
+	ETHTOOL_LINK_MODE_10baseT1S_Full_BIT		 = 99,
+	ETHTOOL_LINK_MODE_10baseT1S_Half_BIT		 = 100,
+	ETHTOOL_LINK_MODE_10baseT1S_P2MP_Half_BIT	 = 101,
 
 	/* must be last entry */
 	__ETHTOOL_LINK_MODE_MASK_NBITS
diff --git a/include/standard-headers/linux/fuse.h b/include/standard-headers/linux/fuse.h
index XXXXXXX..XXXXXXX 100644
--- a/include/standard-headers/linux/fuse.h
+++ b/include/standard-headers/linux/fuse.h
@@ -XXX,XX +XXX,XX @@
  *  7.38
  *  - add FUSE_EXPIRE_ONLY flag to fuse_notify_inval_entry
  *  - add FOPEN_PARALLEL_DIRECT_WRITES
+ *  - add total_extlen to fuse_in_header
+ *  - add FUSE_MAX_NR_SECCTX
+ *  - add extension header
+ *  - add FUSE_EXT_GROUPS
+ *  - add FUSE_CREATE_SUPP_GROUP
  */
 
 #ifndef _LINUX_FUSE_H
@@ -XXX,XX +XXX,XX @@ struct fuse_file_lock {
  * FUSE_SECURITY_CTX:	add security context to create, mkdir, symlink, and
  *			mknod
  * FUSE_HAS_INODE_DAX:  use per inode DAX
+ * FUSE_CREATE_SUPP_GROUP: add supplementary group info to create, mkdir,
+ *			symlink and mknod (single group that matches parent)
  */
 #define FUSE_ASYNC_READ		(1 << 0)
 #define FUSE_POSIX_LOCKS	(1 << 1)
@@ -XXX,XX +XXX,XX @@ struct fuse_file_lock {
 /* bits 32..63 get shifted down 32 bits into the flags2 field */
 #define FUSE_SECURITY_CTX	(1ULL << 32)
 #define FUSE_HAS_INODE_DAX	(1ULL << 33)
+#define FUSE_CREATE_SUPP_GROUP	(1ULL << 34)
 
 /**
  * CUSE INIT request/reply flags
@@ -XXX,XX +XXX,XX @@ struct fuse_file_lock {
  */
 #define FUSE_EXPIRE_ONLY		(1 << 0)
 
+/**
+ * extension type
+ * FUSE_MAX_NR_SECCTX: maximum value of &fuse_secctx_header.nr_secctx
+ * FUSE_EXT_GROUPS: &fuse_supp_groups extension
+ */
+enum fuse_ext_type {
+	/* Types 0..31 are reserved for fuse_secctx_header */
+	FUSE_MAX_NR_SECCTX	= 31,
+	FUSE_EXT_GROUPS		= 32,
+};
+
 enum fuse_opcode {
 	FUSE_LOOKUP		= 1,
 	FUSE_FORGET		= 2,  /* no reply */
@@ -XXX,XX +XXX,XX @@ struct fuse_in_header {
 	uint32_t	uid;
 	uint32_t	gid;
 	uint32_t	pid;
-	uint32_t	padding;
+	uint16_t	total_extlen; /* length of extensions in 8byte units */
+	uint16_t	padding;
 };
 
 struct fuse_out_header {
@@ -XXX,XX +XXX,XX @@ struct fuse_secctx_header {
 	uint32_t	nr_secctx;
 };
 
+/**
+ * struct fuse_ext_header - extension header
+ * @size: total size of this extension including this header
+ * @type: type of extension
+ *
+ * This is made compatible with fuse_secctx_header by using type values >
+ * FUSE_MAX_NR_SECCTX
+ */
+struct fuse_ext_header {
+	uint32_t	size;
+	uint32_t	type;
+};
+
+/**
+ * struct fuse_supp_groups - Supplementary group extension
+ * @nr_groups: number of supplementary groups
+ * @groups: flexible array of group IDs
+ */
+struct fuse_supp_groups {
+	uint32_t	nr_groups;
+	uint32_t	groups[];
+};
+
 #endif /* _LINUX_FUSE_H */
diff --git a/include/standard-headers/linux/pci_regs.h b/include/standard-headers/linux/pci_regs.h
index XXXXXXX..XXXXXXX 100644
--- a/include/standard-headers/linux/pci_regs.h
+++ b/include/standard-headers/linux/pci_regs.h
@@ -XXX,XX +XXX,XX @@
 #define  PCI_EXP_LNKCTL2_TX_MARGIN	0x0380 /* Transmit Margin */
 #define  PCI_EXP_LNKCTL2_HASD		0x0020 /* HW Autonomous Speed Disable */
 #define PCI_EXP_LNKSTA2		0x32	/* Link Status 2 */
+#define  PCI_EXP_LNKSTA2_FLIT		0x0400 /* Flit Mode Status */
 #define PCI_CAP_EXP_ENDPOINT_SIZEOF_V2	0x32	/* end of v2 EPs w/ link */
 #define PCI_EXP_SLTCAP2		0x34	/* Slot Capabilities 2 */
 #define  PCI_EXP_SLTCAP2_IBPD	0x00000001 /* In-band PD Disable Supported */
diff --git a/include/standard-headers/linux/vhost_types.h b/include/standard-headers/linux/vhost_types.h
index XXXXXXX..XXXXXXX 100644
--- a/include/standard-headers/linux/vhost_types.h
+++ b/include/standard-headers/linux/vhost_types.h
@@ -XXX,XX +XXX,XX @@ struct vhost_vdpa_iova_range {
 #define VHOST_BACKEND_F_IOTLB_ASID  0x3
 /* Device can be suspended */
 #define VHOST_BACKEND_F_SUSPEND  0x4
+/* Device can be resumed */
+#define VHOST_BACKEND_F_RESUME  0x5
 
 #endif
diff --git a/include/standard-headers/linux/virtio_blk.h b/include/standard-headers/linux/virtio_blk.h
index XXXXXXX..XXXXXXX 100644
--- a/include/standard-headers/linux/virtio_blk.h
+++ b/include/standard-headers/linux/virtio_blk.h
@@ -XXX,XX +XXX,XX @@
 #define VIRTIO_BLK_F_DISCARD	13	/* DISCARD is supported */
 #define VIRTIO_BLK_F_WRITE_ZEROES	14	/* WRITE ZEROES is supported */
 #define VIRTIO_BLK_F_SECURE_ERASE	16 /* Secure Erase is supported */
+#define VIRTIO_BLK_F_ZONED		17	/* Zoned block device */
 
 /* Legacy feature bits */
 #ifndef VIRTIO_BLK_NO_LEGACY
@@ -XXX,XX +XXX,XX @@ struct virtio_blk_config {
 	/* Secure erase commands must be aligned to this number of sectors. */
 	__virtio32 secure_erase_sector_alignment;
 
+	/* Zoned block device characteristics (if VIRTIO_BLK_F_ZONED) */
+	struct virtio_blk_zoned_characteristics {
+		__virtio32 zone_sectors;
+		__virtio32 max_open_zones;
+		__virtio32 max_active_zones;
+		__virtio32 max_append_sectors;
+		__virtio32 write_granularity;
+		uint8_t model;
+		uint8_t unused2[3];
+	} zoned;
 } QEMU_PACKED;
 
 /*
@@ -XXX,XX +XXX,XX @@ struct virtio_blk_config {
 /* Secure erase command */
 #define VIRTIO_BLK_T_SECURE_ERASE	14
 
+/* Zone append command */
+#define VIRTIO_BLK_T_ZONE_APPEND    15
+
+/* Report zones command */
+#define VIRTIO_BLK_T_ZONE_REPORT    16
+
+/* Open zone command */
+#define VIRTIO_BLK_T_ZONE_OPEN      18
+
+/* Close zone command */
+#define VIRTIO_BLK_T_ZONE_CLOSE     20
+
+/* Finish zone command */
+#define VIRTIO_BLK_T_ZONE_FINISH    22
+
+/* Reset zone command */
+#define VIRTIO_BLK_T_ZONE_RESET     24
+
+/* Reset All zones command */
+#define VIRTIO_BLK_T_ZONE_RESET_ALL 26
+
 #ifndef VIRTIO_BLK_NO_LEGACY
 /* Barrier before this op. */
 #define VIRTIO_BLK_T_BARRIER	0x80000000
@@ -XXX,XX +XXX,XX @@ struct virtio_blk_outhdr {
 	__virtio64 sector;
 };
 
+/*
+ * Supported zoned device models.
+ */
+
+/* Regular block device */
+#define VIRTIO_BLK_Z_NONE      0
+/* Host-managed zoned device */
+#define VIRTIO_BLK_Z_HM        1
+/* Host-aware zoned device */
+#define VIRTIO_BLK_Z_HA        2
+
+/*
+ * Zone descriptor. A part of VIRTIO_BLK_T_ZONE_REPORT command reply.
+ */
+struct virtio_blk_zone_descriptor {
+	/* Zone capacity */
+	__virtio64 z_cap;
+	/* The starting sector of the zone */
+	__virtio64 z_start;
+	/* Zone write pointer position in sectors */
+	__virtio64 z_wp;
+	/* Zone type */
+	uint8_t z_type;
+	/* Zone state */
+	uint8_t z_state;
+	uint8_t reserved[38];
+};
+
+struct virtio_blk_zone_report {
+	__virtio64 nr_zones;
+	uint8_t reserved[56];
+	struct virtio_blk_zone_descriptor zones[];
+};
+
+/*
+ * Supported zone types.
+ */
+
+/* Conventional zone */
+#define VIRTIO_BLK_ZT_CONV         1
+/* Sequential Write Required zone */
+#define VIRTIO_BLK_ZT_SWR          2
+/* Sequential Write Preferred zone */
+#define VIRTIO_BLK_ZT_SWP          3
+
+/*
+ * Zone states that are available for zones of all types.
+ */
+
+/* Not a write pointer (conventional zones only) */
+#define VIRTIO_BLK_ZS_NOT_WP       0
+/* Empty */
+#define VIRTIO_BLK_ZS_EMPTY        1
+/* Implicitly Open */
+#define VIRTIO_BLK_ZS_IOPEN        2
+/* Explicitly Open */
+#define VIRTIO_BLK_ZS_EOPEN        3
+/* Closed */
+#define VIRTIO_BLK_ZS_CLOSED       4
+/* Read-Only */
+#define VIRTIO_BLK_ZS_RDONLY       13
+/* Full */
+#define VIRTIO_BLK_ZS_FULL         14
+/* Offline */
+#define VIRTIO_BLK_ZS_OFFLINE      15
+
 /* Unmap this range (only valid for write zeroes command) */
 #define VIRTIO_BLK_WRITE_ZEROES_FLAG_UNMAP	0x00000001
 
@@ -XXX,XX +XXX,XX @@ struct virtio_scsi_inhdr {
 #define VIRTIO_BLK_S_OK		0
 #define VIRTIO_BLK_S_IOERR	1
 #define VIRTIO_BLK_S_UNSUPP	2
+
+/* Error codes that are specific to zoned block devices */
+#define VIRTIO_BLK_S_ZONE_INVALID_CMD     3
+#define VIRTIO_BLK_S_ZONE_UNALIGNED_WP    4
+#define VIRTIO_BLK_S_ZONE_OPEN_RESOURCE   5
+#define VIRTIO_BLK_S_ZONE_ACTIVE_RESOURCE 6
+
 #endif /* _LINUX_VIRTIO_BLK_H */
diff --git a/linux-headers/asm-arm64/kvm.h b/linux-headers/asm-arm64/kvm.h
index XXXXXXX..XXXXXXX 100644
--- a/linux-headers/asm-arm64/kvm.h
+++ b/linux-headers/asm-arm64/kvm.h
@@ -XXX,XX +XXX,XX @@ struct kvm_regs {
 #define KVM_ARM_VCPU_SVE		4 /* enable SVE for this CPU */
 #define KVM_ARM_VCPU_PTRAUTH_ADDRESS	5 /* VCPU uses address authentication */
 #define KVM_ARM_VCPU_PTRAUTH_GENERIC	6 /* VCPU uses generic authentication */
+#define KVM_ARM_VCPU_HAS_EL2		7 /* Support nested virtualization */
 
 struct kvm_vcpu_init {
 	__u32 target;
diff --git a/linux-headers/asm-x86/kvm.h b/linux-headers/asm-x86/kvm.h
index XXXXXXX..XXXXXXX 100644
--- a/linux-headers/asm-x86/kvm.h
+++ b/linux-headers/asm-x86/kvm.h
@@ -XXX,XX +XXX,XX @@
 
 #include <linux/types.h>
 #include <linux/ioctl.h>
+#include <linux/stddef.h>
 
 #define KVM_PIO_PAGE_OFFSET 1
 #define KVM_COALESCED_MMIO_PAGE_OFFSET 2
@@ -XXX,XX +XXX,XX @@ struct kvm_nested_state {
 	 * KVM_{GET,PUT}_NESTED_STATE ioctl values.
 	 */
 	union {
-		struct kvm_vmx_nested_state_data vmx[0];
-		struct kvm_svm_nested_state_data svm[0];
+		__DECLARE_FLEX_ARRAY(struct kvm_vmx_nested_state_data, vmx);
+		__DECLARE_FLEX_ARRAY(struct kvm_svm_nested_state_data, svm);
 	} data;
 };
 
@@ -XXX,XX +XXX,XX @@ struct kvm_pmu_event_filter {
 #define KVM_PMU_EVENT_ALLOW 0
 #define KVM_PMU_EVENT_DENY 1
 
+#define KVM_PMU_EVENT_FLAG_MASKED_EVENTS BIT(0)
+#define KVM_PMU_EVENT_FLAGS_VALID_MASK (KVM_PMU_EVENT_FLAG_MASKED_EVENTS)
+
+/*
+ * Masked event layout.
+ * Bits   Description
+ * ----   -----------
+ * 7:0    event select (low bits)
+ * 15:8   umask match
+ * 31:16  unused
+ * 35:32  event select (high bits)
+ * 36:54  unused
+ * 55     exclude bit
+ * 63:56  umask mask
+ */
+
+#define KVM_PMU_ENCODE_MASKED_ENTRY(event_select, mask, match, exclude) \
+	(((event_select) & 0xFFULL) | (((event_select) & 0XF00ULL) << 24) | \
+	(((mask) & 0xFFULL) << 56) | \
+	(((match) & 0xFFULL) << 8) | \
+	((__u64)(!!(exclude)) << 55))
+
+#define KVM_PMU_MASKED_ENTRY_EVENT_SELECT \
+	(GENMASK_ULL(7, 0) | GENMASK_ULL(35, 32))
+#define KVM_PMU_MASKED_ENTRY_UMASK_MASK		(GENMASK_ULL(63, 56))
+#define KVM_PMU_MASKED_ENTRY_UMASK_MATCH	(GENMASK_ULL(15, 8))
+#define KVM_PMU_MASKED_ENTRY_EXCLUDE		(BIT_ULL(55))
+#define KVM_PMU_MASKED_ENTRY_UMASK_MASK_SHIFT	(56)
+
 /* for KVM_{GET,SET,HAS}_DEVICE_ATTR */
 #define KVM_VCPU_TSC_CTRL 0 /* control group for the timestamp counter (TSC) */
 #define   KVM_VCPU_TSC_OFFSET 0 /* attribute for the TSC offset */
diff --git a/linux-headers/linux/kvm.h b/linux-headers/linux/kvm.h
index XXXXXXX..XXXXXXX 100644
--- a/linux-headers/linux/kvm.h
+++ b/linux-headers/linux/kvm.h
@@ -XXX,XX +XXX,XX @@ struct kvm_s390_mem_op {
 		struct {
 			__u8 ar;	/* the access register number */
 			__u8 key;	/* access key, ignored if flag unset */
+			__u8 pad1[6];	/* ignored */
+			__u64 old_addr;	/* ignored if cmpxchg flag unset */
 		};
 		__u32 sida_offset; /* offset into the sida */
 		__u8 reserved[32]; /* ignored */
@@ -XXX,XX +XXX,XX @@ struct kvm_s390_mem_op {
 #define KVM_S390_MEMOP_SIDA_WRITE	3
 #define KVM_S390_MEMOP_ABSOLUTE_READ	4
 #define KVM_S390_MEMOP_ABSOLUTE_WRITE	5
+#define KVM_S390_MEMOP_ABSOLUTE_CMPXCHG	6
+
 /* flags for kvm_s390_mem_op->flags */
 #define KVM_S390_MEMOP_F_CHECK_ONLY		(1ULL << 0)
 #define KVM_S390_MEMOP_F_INJECT_EXCEPTION	(1ULL << 1)
 #define KVM_S390_MEMOP_F_SKEY_PROTECTION	(1ULL << 2)
 
+/* flags specifying extension support via KVM_CAP_S390_MEM_OP_EXTENSION */
+#define KVM_S390_MEMOP_EXTENSION_CAP_BASE	(1 << 0)
+#define KVM_S390_MEMOP_EXTENSION_CAP_CMPXCHG	(1 << 1)
+
 /* for KVM_INTERRUPT */
 struct kvm_interrupt {
 	/* in */
@@ -XXX,XX +XXX,XX @@ struct kvm_ppc_resize_hpt {
 #define KVM_CAP_DIRTY_LOG_RING_ACQ_REL 223
 #define KVM_CAP_S390_PROTECTED_ASYNC_DISABLE 224
 #define KVM_CAP_DIRTY_LOG_RING_WITH_BITMAP 225
+#define KVM_CAP_PMU_EVENT_MASKED_EVENTS 226
 
 #ifdef KVM_CAP_IRQ_ROUTING
 
diff --git a/linux-headers/linux/vfio.h b/linux-headers/linux/vfio.h
index XXXXXXX..XXXXXXX 100644
--- a/linux-headers/linux/vfio.h
+++ b/linux-headers/linux/vfio.h
@@ -XXX,XX +XXX,XX @@
 /* Supports VFIO_DMA_UNMAP_FLAG_ALL */
 #define VFIO_UNMAP_ALL			9
 
-/* Supports the vaddr flag for DMA map and unmap */
+/*
+ * Supports the vaddr flag for DMA map and unmap.  Not supported for mediated
+ * devices, so this capability is subject to change as groups are added or
+ * removed.
+ */
 #define VFIO_UPDATE_VADDR		10
 
 /*
@@ -XXX,XX +XXX,XX @@ struct vfio_iommu_type1_info_dma_avail {
  * Map process virtual addresses to IO virtual addresses using the
  * provided struct vfio_dma_map. Caller sets argsz. READ &/ WRITE required.
  *
- * If flags & VFIO_DMA_MAP_FLAG_VADDR, update the base vaddr for iova, and
- * unblock translation of host virtual addresses in the iova range.  The vaddr
+ * If flags & VFIO_DMA_MAP_FLAG_VADDR, update the base vaddr for iova. The vaddr
  * must have previously been invalidated with VFIO_DMA_UNMAP_FLAG_VADDR.  To
  * maintain memory consistency within the user application, the updated vaddr
  * must address the same memory object as originally mapped.  Failure to do so
@@ -XXX,XX +XXX,XX @@ struct vfio_bitmap {
  * must be 0.  This cannot be combined with the get-dirty-bitmap flag.
  *
  * If flags & VFIO_DMA_UNMAP_FLAG_VADDR, do not unmap, but invalidate host
- * virtual addresses in the iova range.  Tasks that attempt to translate an
- * iova's vaddr will block.  DMA to already-mapped pages continues.  This
- * cannot be combined with the get-dirty-bitmap flag.
+ * virtual addresses in the iova range.  DMA to already-mapped pages continues.
+ * Groups may not be added to the container while any addresses are invalid.
+ * This cannot be combined with the get-dirty-bitmap flag.
  */
 struct vfio_iommu_type1_dma_unmap {
 	__u32	argsz;
diff --git a/linux-headers/linux/vhost.h b/linux-headers/linux/vhost.h
index XXXXXXX..XXXXXXX 100644
--- a/linux-headers/linux/vhost.h
+++ b/linux-headers/linux/vhost.h
@@ -XXX,XX +XXX,XX @@
  */
 #define VHOST_VDPA_SUSPEND		_IO(VHOST_VIRTIO, 0x7D)
 
+/* Resume a device so it can resume processing virtqueue requests
+ *
+ * After the return of this ioctl the device will have restored all the
+ * necessary states and it is fully operational to continue processing the
+ * virtqueue descriptors.
+ */
+#define VHOST_VDPA_RESUME		_IO(VHOST_VIRTIO, 0x7E)
+
 #endif
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

This patch extends virtio-blk emulation to handle zoned device commands
by calling the new block layer APIs to perform zoned device I/O on
behalf of the guest. It supports Report Zone, four zone oparations (open,
close, finish, reset), and Append Zone.

The VIRTIO_BLK_F_ZONED feature bit will only be set if the host does
support zoned block devices. Regular block devices(conventional zones)
will not be set.

The guest os can use blktests, fio to test those commands on zoned devices.
Furthermore, using zonefs to test zone append write is also supported.

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20230407082528.18841-3-faithilikerun@gmail.com>
---
 hw/block/virtio-blk-common.c |   2 +
 hw/block/virtio-blk.c        | 389 +++++++++++++++++++++++++++++++++++
 hw/virtio/virtio-qmp.c       |   2 +
 3 files changed, 393 insertions(+)

diff --git a/hw/block/virtio-blk-common.c b/hw/block/virtio-blk-common.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk-common.c
+++ b/hw/block/virtio-blk-common.c
@@ -XXX,XX +XXX,XX @@ static const VirtIOFeature feature_sizes[] = {
      .end = endof(struct virtio_blk_config, discard_sector_alignment)},
     {.flags = 1ULL << VIRTIO_BLK_F_WRITE_ZEROES,
      .end = endof(struct virtio_blk_config, write_zeroes_may_unmap)},
+    {.flags = 1ULL << VIRTIO_BLK_F_ZONED,
+     .end = endof(struct virtio_blk_config, zoned)},
     {}
 };
 
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/module.h"
 #include "qemu/error-report.h"
 #include "qemu/main-loop.h"
+#include "block/block_int.h"
 #include "trace.h"
 #include "hw/block/block.h"
 #include "hw/qdev-properties.h"
@@ -XXX,XX +XXX,XX @@ err:
     return err_status;
 }
 
+typedef struct ZoneCmdData {
+    VirtIOBlockReq *req;
+    struct iovec *in_iov;
+    unsigned in_num;
+    union {
+        struct {
+            unsigned int nr_zones;
+            BlockZoneDescriptor *zones;
+        } zone_report_data;
+        struct {
+            int64_t offset;
+        } zone_append_data;
+    };
+} ZoneCmdData;
+
+/*
+ * check zoned_request: error checking before issuing requests. If all checks
+ * passed, return true.
+ * append: true if only zone append requests issued.
+ */
+static bool check_zoned_request(VirtIOBlock *s, int64_t offset, int64_t len,
+                             bool append, uint8_t *status) {
+    BlockDriverState *bs = blk_bs(s->blk);
+    int index;
+
+    if (!virtio_has_feature(s->host_features, VIRTIO_BLK_F_ZONED)) {
+        *status = VIRTIO_BLK_S_UNSUPP;
+        return false;
+    }
+
+    if (offset < 0 || len < 0 || len > (bs->total_sectors << BDRV_SECTOR_BITS)
+        || offset > (bs->total_sectors << BDRV_SECTOR_BITS) - len) {
+        *status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+        return false;
+    }
+
+    if (append) {
+        if (bs->bl.write_granularity) {
+            if ((offset % bs->bl.write_granularity) != 0) {
+                *status = VIRTIO_BLK_S_ZONE_UNALIGNED_WP;
+                return false;
+            }
+        }
+
+        index = offset / bs->bl.zone_size;
+        if (BDRV_ZT_IS_CONV(bs->wps->wp[index])) {
+            *status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+            return false;
+        }
+
+        if (len / 512 > bs->bl.max_append_sectors) {
+            if (bs->bl.max_append_sectors == 0) {
+                *status = VIRTIO_BLK_S_UNSUPP;
+            } else {
+                *status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+            }
+            return false;
+        }
+    }
+    return true;
+}
+
+static void virtio_blk_zone_report_complete(void *opaque, int ret)
+{
+    ZoneCmdData *data = opaque;
+    VirtIOBlockReq *req = data->req;
+    VirtIOBlock *s = req->dev;
+    VirtIODevice *vdev = VIRTIO_DEVICE(req->dev);
+    struct iovec *in_iov = data->in_iov;
+    unsigned in_num = data->in_num;
+    int64_t zrp_size, n, j = 0;
+    int64_t nz = data->zone_report_data.nr_zones;
+    int8_t err_status = VIRTIO_BLK_S_OK;
+
+    if (ret) {
+        err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+        goto out;
+    }
+
+    struct virtio_blk_zone_report zrp_hdr = (struct virtio_blk_zone_report) {
+        .nr_zones = cpu_to_le64(nz),
+    };
+    zrp_size = sizeof(struct virtio_blk_zone_report)
+               + sizeof(struct virtio_blk_zone_descriptor) * nz;
+    n = iov_from_buf(in_iov, in_num, 0, &zrp_hdr, sizeof(zrp_hdr));
+    if (n != sizeof(zrp_hdr)) {
+        virtio_error(vdev, "Driver provided input buffer that is too small!");
+        err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+        goto out;
+    }
+
+    for (size_t i = sizeof(zrp_hdr); i < zrp_size;
+        i += sizeof(struct virtio_blk_zone_descriptor), ++j) {
+        struct virtio_blk_zone_descriptor desc =
+            (struct virtio_blk_zone_descriptor) {
+                .z_start = cpu_to_le64(data->zone_report_data.zones[j].start
+                    >> BDRV_SECTOR_BITS),
+                .z_cap = cpu_to_le64(data->zone_report_data.zones[j].cap
+                    >> BDRV_SECTOR_BITS),
+                .z_wp = cpu_to_le64(data->zone_report_data.zones[j].wp
+                    >> BDRV_SECTOR_BITS),
+        };
+
+        switch (data->zone_report_data.zones[j].type) {
+        case BLK_ZT_CONV:
+            desc.z_type = VIRTIO_BLK_ZT_CONV;
+            break;
+        case BLK_ZT_SWR:
+            desc.z_type = VIRTIO_BLK_ZT_SWR;
+            break;
+        case BLK_ZT_SWP:
+            desc.z_type = VIRTIO_BLK_ZT_SWP;
+            break;
+        default:
+            g_assert_not_reached();
+        }
+
+        switch (data->zone_report_data.zones[j].state) {
+        case BLK_ZS_RDONLY:
+            desc.z_state = VIRTIO_BLK_ZS_RDONLY;
+            break;
+        case BLK_ZS_OFFLINE:
+            desc.z_state = VIRTIO_BLK_ZS_OFFLINE;
+            break;
+        case BLK_ZS_EMPTY:
+            desc.z_state = VIRTIO_BLK_ZS_EMPTY;
+            break;
+        case BLK_ZS_CLOSED:
+            desc.z_state = VIRTIO_BLK_ZS_CLOSED;
+            break;
+        case BLK_ZS_FULL:
+            desc.z_state = VIRTIO_BLK_ZS_FULL;
+            break;
+        case BLK_ZS_EOPEN:
+            desc.z_state = VIRTIO_BLK_ZS_EOPEN;
+            break;
+        case BLK_ZS_IOPEN:
+            desc.z_state = VIRTIO_BLK_ZS_IOPEN;
+            break;
+        case BLK_ZS_NOT_WP:
+            desc.z_state = VIRTIO_BLK_ZS_NOT_WP;
+            break;
+        default:
+            g_assert_not_reached();
+        }
+
+        /* TODO: it takes O(n^2) time complexity. Optimizations required. */
+        n = iov_from_buf(in_iov, in_num, i, &desc, sizeof(desc));
+        if (n != sizeof(desc)) {
+            virtio_error(vdev, "Driver provided input buffer "
+                               "for descriptors that is too small!");
+            err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+        }
+    }
+
+out:
+    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
+    virtio_blk_req_complete(req, err_status);
+    virtio_blk_free_request(req);
+    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
+    g_free(data->zone_report_data.zones);
+    g_free(data);
+}
+
+static void virtio_blk_handle_zone_report(VirtIOBlockReq *req,
+                                         struct iovec *in_iov,
+                                         unsigned in_num)
+{
+    VirtIOBlock *s = req->dev;
+    VirtIODevice *vdev = VIRTIO_DEVICE(s);
+    unsigned int nr_zones;
+    ZoneCmdData *data;
+    int64_t zone_size, offset;
+    uint8_t err_status;
+
+    if (req->in_len < sizeof(struct virtio_blk_inhdr) +
+            sizeof(struct virtio_blk_zone_report) +
+            sizeof(struct virtio_blk_zone_descriptor)) {
+        virtio_error(vdev, "in buffer too small for zone report");
+        return;
+    }
+
+    /* start byte offset of the zone report */
+    offset = virtio_ldq_p(vdev, &req->out.sector) << BDRV_SECTOR_BITS;
+    if (!check_zoned_request(s, offset, 0, false, &err_status)) {
+        goto out;
+    }
+    nr_zones = (req->in_len - sizeof(struct virtio_blk_inhdr) -
+                sizeof(struct virtio_blk_zone_report)) /
+               sizeof(struct virtio_blk_zone_descriptor);
+
+    zone_size = sizeof(BlockZoneDescriptor) * nr_zones;
+    data = g_malloc(sizeof(ZoneCmdData));
+    data->req = req;
+    data->in_iov = in_iov;
+    data->in_num = in_num;
+    data->zone_report_data.nr_zones = nr_zones;
+    data->zone_report_data.zones = g_malloc(zone_size),
+
+    blk_aio_zone_report(s->blk, offset, &data->zone_report_data.nr_zones,
+                        data->zone_report_data.zones,
+                        virtio_blk_zone_report_complete, data);
+    return;
+out:
+    virtio_blk_req_complete(req, err_status);
+    virtio_blk_free_request(req);
+}
+
+static void virtio_blk_zone_mgmt_complete(void *opaque, int ret)
+{
+    VirtIOBlockReq *req = opaque;
+    VirtIOBlock *s = req->dev;
+    int8_t err_status = VIRTIO_BLK_S_OK;
+
+    if (ret) {
+        err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+    }
+
+    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
+    virtio_blk_req_complete(req, err_status);
+    virtio_blk_free_request(req);
+    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
+}
+
+static int virtio_blk_handle_zone_mgmt(VirtIOBlockReq *req, BlockZoneOp op)
+{
+    VirtIOBlock *s = req->dev;
+    VirtIODevice *vdev = VIRTIO_DEVICE(s);
+    BlockDriverState *bs = blk_bs(s->blk);
+    int64_t offset = virtio_ldq_p(vdev, &req->out.sector) << BDRV_SECTOR_BITS;
+    uint64_t len;
+    uint64_t capacity = bs->total_sectors << BDRV_SECTOR_BITS;
+    uint8_t err_status = VIRTIO_BLK_S_OK;
+
+    uint32_t type = virtio_ldl_p(vdev, &req->out.type);
+    if (type == VIRTIO_BLK_T_ZONE_RESET_ALL) {
+        /* Entire drive capacity */
+        offset = 0;
+        len = capacity;
+    } else {
+        if (bs->bl.zone_size > capacity - offset) {
+            /* The zoned device allows the last smaller zone. */
+            len = capacity - bs->bl.zone_size * (bs->bl.nr_zones - 1);
+        } else {
+            len = bs->bl.zone_size;
+        }
+    }
+
+    if (!check_zoned_request(s, offset, len, false, &err_status)) {
+        goto out;
+    }
+
+    blk_aio_zone_mgmt(s->blk, op, offset, len,
+                      virtio_blk_zone_mgmt_complete, req);
+
+    return 0;
+out:
+    virtio_blk_req_complete(req, err_status);
+    virtio_blk_free_request(req);
+    return err_status;
+}
+
+static void virtio_blk_zone_append_complete(void *opaque, int ret)
+{
+    ZoneCmdData *data = opaque;
+    VirtIOBlockReq *req = data->req;
+    VirtIOBlock *s = req->dev;
+    VirtIODevice *vdev = VIRTIO_DEVICE(req->dev);
+    int64_t append_sector, n;
+    uint8_t err_status = VIRTIO_BLK_S_OK;
+
+    if (ret) {
+        err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+        goto out;
+    }
+
+    virtio_stq_p(vdev, &append_sector,
+                 data->zone_append_data.offset >> BDRV_SECTOR_BITS);
+    n = iov_from_buf(data->in_iov, data->in_num, 0, &append_sector,
+                     sizeof(append_sector));
+    if (n != sizeof(append_sector)) {
+        virtio_error(vdev, "Driver provided input buffer less than size of "
+                           "append_sector");
+        err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+        goto out;
+    }
+
+out:
+    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
+    virtio_blk_req_complete(req, err_status);
+    virtio_blk_free_request(req);
+    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
+    g_free(data);
+}
+
+static int virtio_blk_handle_zone_append(VirtIOBlockReq *req,
+                                         struct iovec *out_iov,
+                                         struct iovec *in_iov,
+                                         uint64_t out_num,
+                                         unsigned in_num) {
+    VirtIOBlock *s = req->dev;
+    VirtIODevice *vdev = VIRTIO_DEVICE(s);
+    uint8_t err_status = VIRTIO_BLK_S_OK;
+
+    int64_t offset = virtio_ldq_p(vdev, &req->out.sector) << BDRV_SECTOR_BITS;
+    int64_t len = iov_size(out_iov, out_num);
+
+    if (!check_zoned_request(s, offset, len, true, &err_status)) {
+        goto out;
+    }
+
+    ZoneCmdData *data = g_malloc(sizeof(ZoneCmdData));
+    data->req = req;
+    data->in_iov = in_iov;
+    data->in_num = in_num;
+    data->zone_append_data.offset = offset;
+    qemu_iovec_init_external(&req->qiov, out_iov, out_num);
+    blk_aio_zone_append(s->blk, &data->zone_append_data.offset, &req->qiov, 0,
+                        virtio_blk_zone_append_complete, data);
+    return 0;
+
+out:
+    aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
+    virtio_blk_req_complete(req, err_status);
+    virtio_blk_free_request(req);
+    aio_context_release(blk_get_aio_context(s->conf.conf.blk));
+    return err_status;
+}
+
 static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
 {
     uint32_t type;
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
     case VIRTIO_BLK_T_FLUSH:
         virtio_blk_handle_flush(req, mrb);
         break;
+    case VIRTIO_BLK_T_ZONE_REPORT:
+        virtio_blk_handle_zone_report(req, in_iov, in_num);
+        break;
+    case VIRTIO_BLK_T_ZONE_OPEN:
+        virtio_blk_handle_zone_mgmt(req, BLK_ZO_OPEN);
+        break;
+    case VIRTIO_BLK_T_ZONE_CLOSE:
+        virtio_blk_handle_zone_mgmt(req, BLK_ZO_CLOSE);
+        break;
+    case VIRTIO_BLK_T_ZONE_FINISH:
+        virtio_blk_handle_zone_mgmt(req, BLK_ZO_FINISH);
+        break;
+    case VIRTIO_BLK_T_ZONE_RESET:
+        virtio_blk_handle_zone_mgmt(req, BLK_ZO_RESET);
+        break;
+    case VIRTIO_BLK_T_ZONE_RESET_ALL:
+        virtio_blk_handle_zone_mgmt(req, BLK_ZO_RESET);
+        break;
     case VIRTIO_BLK_T_SCSI_CMD:
         virtio_blk_handle_scsi(req);
         break;
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb)
         virtio_blk_free_request(req);
         break;
     }
+    case VIRTIO_BLK_T_ZONE_APPEND & ~VIRTIO_BLK_T_OUT:
+        /*
+         * Passing out_iov/out_num and in_iov/in_num is not safe
+         * to access req->elem.out_sg directly because it may be
+         * modified by virtio_blk_handle_request().
+         */
+        virtio_blk_handle_zone_append(req, out_iov, in_iov, out_num, in_num);
+        break;
     /*
      * VIRTIO_BLK_T_DISCARD and VIRTIO_BLK_T_WRITE_ZEROES are defined with
      * VIRTIO_BLK_T_OUT flag set. We masked this flag in the switch statement,
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
 {
     VirtIOBlock *s = VIRTIO_BLK(vdev);
     BlockConf *conf = &s->conf.conf;
+    BlockDriverState *bs = blk_bs(s->blk);
     struct virtio_blk_config blkcfg;
     uint64_t capacity;
     int64_t length;
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_update_config(VirtIODevice *vdev, uint8_t *config)
         blkcfg.write_zeroes_may_unmap = 1;
         virtio_stl_p(vdev, &blkcfg.max_write_zeroes_seg, 1);
     }
+    if (bs->bl.zoned != BLK_Z_NONE) {
+        switch (bs->bl.zoned) {
+        case BLK_Z_HM:
+            blkcfg.zoned.model = VIRTIO_BLK_Z_HM;
+            break;
+        case BLK_Z_HA:
+            blkcfg.zoned.model = VIRTIO_BLK_Z_HA;
+            break;
+        default:
+            g_assert_not_reached();
+        }
+
+        virtio_stl_p(vdev, &blkcfg.zoned.zone_sectors,
+                     bs->bl.zone_size / 512);
+        virtio_stl_p(vdev, &blkcfg.zoned.max_active_zones,
+                     bs->bl.max_active_zones);
+        virtio_stl_p(vdev, &blkcfg.zoned.max_open_zones,
+                     bs->bl.max_open_zones);
+        virtio_stl_p(vdev, &blkcfg.zoned.write_granularity, blk_size);
+        virtio_stl_p(vdev, &blkcfg.zoned.max_append_sectors,
+                     bs->bl.max_append_sectors);
+    } else {
+        blkcfg.zoned.model = VIRTIO_BLK_Z_NONE;
+    }
     memcpy(config, &blkcfg, s->config_size);
 }
 
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
     VirtIODevice *vdev = VIRTIO_DEVICE(dev);
     VirtIOBlock *s = VIRTIO_BLK(dev);
     VirtIOBlkConf *conf = &s->conf;
+    BlockDriverState *bs = blk_bs(conf->conf.blk);
     Error *err = NULL;
     unsigned i;
 
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
         return;
     }
 
+    if (bs->bl.zoned != BLK_Z_NONE) {
+        virtio_add_feature(&s->host_features, VIRTIO_BLK_F_ZONED);
+        if (bs->bl.zoned == BLK_Z_HM) {
+            virtio_clear_feature(&s->host_features, VIRTIO_BLK_F_DISCARD);
+        }
+    }
+
     if (virtio_has_feature(s->host_features, VIRTIO_BLK_F_DISCARD) &&
         (!conf->max_discard_sectors ||
          conf->max_discard_sectors > BDRV_REQUEST_MAX_SECTORS)) {
diff --git a/hw/virtio/virtio-qmp.c b/hw/virtio/virtio-qmp.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/virtio/virtio-qmp.c
+++ b/hw/virtio/virtio-qmp.c
@@ -XXX,XX +XXX,XX @@ static const qmp_virtio_feature_map_t virtio_blk_feature_map[] = {
             "VIRTIO_BLK_F_DISCARD: Discard command supported"),
     FEATURE_ENTRY(VIRTIO_BLK_F_WRITE_ZEROES, \
             "VIRTIO_BLK_F_WRITE_ZEROES: Write zeroes command supported"),
+    FEATURE_ENTRY(VIRTIO_BLK_F_ZONED, \
+            "VIRTIO_BLK_F_ZONED: Zoned block devices"),
 #ifndef VIRTIO_BLK_NO_LEGACY
     FEATURE_ENTRY(VIRTIO_BLK_F_BARRIER, \
             "VIRTIO_BLK_F_BARRIER: Request barriers supported"),
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

Taking account of the new zone append write operation for zoned devices,
BLOCK_ACCT_ZONE_APPEND enum is introduced as other I/O request type (read,
write, flush).

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20230407082528.18841-4-faithilikerun@gmail.com>
---
 qapi/block-core.json       | 68 ++++++++++++++++++++++++++++++++------
 qapi/block.json            |  4 +++
 include/block/accounting.h |  1 +
 block/qapi-sysemu.c        | 11 ++++++
 block/qapi.c               | 18 ++++++++++
 hw/block/virtio-blk.c      |  4 +++
 6 files changed, 95 insertions(+), 11 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 # @min_wr_latency_ns: Minimum latency of write operations in the
 #                     defined interval, in nanoseconds.
 #
+# @min_zone_append_latency_ns: Minimum latency of zone append operations
+#                              in the defined interval, in nanoseconds
+#                              (since 8.1)
+#
 # @min_flush_latency_ns: Minimum latency of flush operations in the
 #                        defined interval, in nanoseconds.
 #
@@ -XXX,XX +XXX,XX @@
 # @max_wr_latency_ns: Maximum latency of write operations in the
 #                     defined interval, in nanoseconds.
 #
+# @max_zone_append_latency_ns: Maximum latency of zone append operations
+#                              in the defined interval, in nanoseconds
+#                              (since 8.1)
+#
 # @max_flush_latency_ns: Maximum latency of flush operations in the
 #                        defined interval, in nanoseconds.
 #
@@ -XXX,XX +XXX,XX @@
 # @avg_wr_latency_ns: Average latency of write operations in the
 #                     defined interval, in nanoseconds.
 #
+# @avg_zone_append_latency_ns: Average latency of zone append operations
+#                              in the defined interval, in nanoseconds
+#                              (since 8.1)
+#
 # @avg_flush_latency_ns: Average latency of flush operations in the
 #                        defined interval, in nanoseconds.
 #
@@ -XXX,XX +XXX,XX @@
 # @avg_wr_queue_depth: Average number of pending write operations
 #                      in the defined interval.
 #
+# @avg_zone_append_queue_depth: Average number of pending zone append
+#                               operations in the defined interval
+#                               (since 8.1).
+#
 # Since: 2.5
 ##
 { 'struct': 'BlockDeviceTimedStats',
   'data': { 'interval_length': 'int', 'min_rd_latency_ns': 'int',
             'max_rd_latency_ns': 'int', 'avg_rd_latency_ns': 'int',
             'min_wr_latency_ns': 'int', 'max_wr_latency_ns': 'int',
-            'avg_wr_latency_ns': 'int', 'min_flush_latency_ns': 'int',
-            'max_flush_latency_ns': 'int', 'avg_flush_latency_ns': 'int',
-            'avg_rd_queue_depth': 'number', 'avg_wr_queue_depth': 'number' } }
+            'avg_wr_latency_ns': 'int', 'min_zone_append_latency_ns': 'int',
+            'max_zone_append_latency_ns': 'int',
+            'avg_zone_append_latency_ns': 'int',
+            'min_flush_latency_ns': 'int', 'max_flush_latency_ns': 'int',
+            'avg_flush_latency_ns': 'int', 'avg_rd_queue_depth': 'number',
+            'avg_wr_queue_depth': 'number',
+            'avg_zone_append_queue_depth': 'number'  } }
 
 ##
 # @BlockDeviceStats:
@@ -XXX,XX +XXX,XX @@
 #
 # @wr_bytes: The number of bytes written by the device.
 #
+# @zone_append_bytes: The number of bytes appended by the zoned devices
+#                     (since 8.1)
+#
 # @unmap_bytes: The number of bytes unmapped by the device (Since 4.2)
 #
 # @rd_operations: The number of read operations performed by the device.
 #
 # @wr_operations: The number of write operations performed by the device.
 #
+# @zone_append_operations: The number of zone append operations performed
+#                          by the zoned devices (since 8.1)
+#
 # @flush_operations: The number of cache flush operations performed by the
 #                    device (since 0.15)
 #
@@ -XXX,XX +XXX,XX @@
 #
 # @wr_total_time_ns: Total time spent on writes in nanoseconds (since 0.15).
 #
+# @zone_append_total_time_ns: Total time spent on zone append writes
+#                             in nanoseconds (since 8.1)
+#
 # @flush_total_time_ns: Total time spent on cache flushes in nanoseconds
 #                       (since 0.15).
 #
@@ -XXX,XX +XXX,XX @@
 # @wr_merged: Number of write requests that have been merged into another
 #             request (Since 2.3).
 #
+# @zone_append_merged: Number of zone append requests that have been merged
+#                      into another request (since 8.1)
+#
 # @unmap_merged: Number of unmap requests that have been merged into another
 #                request (Since 4.2)
 #
@@ -XXX,XX +XXX,XX @@
 # @failed_wr_operations: The number of failed write operations
 #                        performed by the device (Since 2.5)
 #
+# @failed_zone_append_operations: The number of failed zone append write
+#                                 operations performed by the zoned devices
+#                                 (since 8.1)
+#
 # @failed_flush_operations: The number of failed flush operations
 #                           performed by the device (Since 2.5)
 #
@@ -XXX,XX +XXX,XX @@
 # @invalid_wr_operations: The number of invalid write operations
 #                         performed by the device (Since 2.5)
 #
+# @invalid_zone_append_operations: The number of invalid zone append operations
+#                                  performed by the zoned device (since 8.1)
+#
 # @invalid_flush_operations: The number of invalid flush operations
 #                            performed by the device (Since 2.5)
 #
@@ -XXX,XX +XXX,XX @@
 #
 # @wr_latency_histogram: @BlockLatencyHistogramInfo. (Since 4.0)
 #
+# @zone_append_latency_histogram: @BlockLatencyHistogramInfo. (since 8.1)
+#
 # @flush_latency_histogram: @BlockLatencyHistogramInfo. (Since 4.0)
 #
 # Since: 0.14
 ##
 { 'struct': 'BlockDeviceStats',
-  'data': {'rd_bytes': 'int', 'wr_bytes': 'int', 'unmap_bytes' : 'int',
-           'rd_operations': 'int', 'wr_operations': 'int',
+  'data': {'rd_bytes': 'int', 'wr_bytes': 'int', 'zone_append_bytes': 'int',
+           'unmap_bytes' : 'int', 'rd_operations': 'int',
+           'wr_operations': 'int', 'zone_append_operations': 'int',
            'flush_operations': 'int', 'unmap_operations': 'int',
            'rd_total_time_ns': 'int', 'wr_total_time_ns': 'int',
-           'flush_total_time_ns': 'int', 'unmap_total_time_ns': 'int',
-           'wr_highest_offset': 'int',
-           'rd_merged': 'int', 'wr_merged': 'int', 'unmap_merged': 'int',
-           '*idle_time_ns': 'int',
+           'zone_append_total_time_ns': 'int', 'flush_total_time_ns': 'int',
+           'unmap_total_time_ns': 'int', 'wr_highest_offset': 'int',
+           'rd_merged': 'int', 'wr_merged': 'int', 'zone_append_merged': 'int',
+           'unmap_merged': 'int', '*idle_time_ns': 'int',
            'failed_rd_operations': 'int', 'failed_wr_operations': 'int',
-           'failed_flush_operations': 'int', 'failed_unmap_operations': 'int',
-           'invalid_rd_operations': 'int', 'invalid_wr_operations': 'int',
+           'failed_zone_append_operations': 'int',
+           'failed_flush_operations': 'int',
+           'failed_unmap_operations': 'int', 'invalid_rd_operations': 'int',
+           'invalid_wr_operations': 'int',
+           'invalid_zone_append_operations': 'int',
            'invalid_flush_operations': 'int', 'invalid_unmap_operations': 'int',
            'account_invalid': 'bool', 'account_failed': 'bool',
            'timed_stats': ['BlockDeviceTimedStats'],
            '*rd_latency_histogram': 'BlockLatencyHistogramInfo',
            '*wr_latency_histogram': 'BlockLatencyHistogramInfo',
+           '*zone_append_latency_histogram': 'BlockLatencyHistogramInfo',
            '*flush_latency_histogram': 'BlockLatencyHistogramInfo' } }
 
 ##
diff --git a/qapi/block.json b/qapi/block.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block.json
+++ b/qapi/block.json
@@ -XXX,XX +XXX,XX @@
 # @boundaries-write: list of interval boundary values for write latency
 #                    histogram.
 #
+# @boundaries-zap: list of interval boundary values for zone append write
+#                  latency histogram.
+#
 # @boundaries-flush: list of interval boundary values for flush latency
 #                    histogram.
 #
@@ -XXX,XX +XXX,XX @@
            '*boundaries': ['uint64'],
            '*boundaries-read': ['uint64'],
            '*boundaries-write': ['uint64'],
+           '*boundaries-zap': ['uint64'],
            '*boundaries-flush': ['uint64'] },
   'allow-preconfig': true }
diff --git a/include/block/accounting.h b/include/block/accounting.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/accounting.h
+++ b/include/block/accounting.h
@@ -XXX,XX +XXX,XX @@ enum BlockAcctType {
     BLOCK_ACCT_READ,
     BLOCK_ACCT_WRITE,
     BLOCK_ACCT_FLUSH,
+    BLOCK_ACCT_ZONE_APPEND,
     BLOCK_ACCT_UNMAP,
     BLOCK_MAX_IOTYPE,
 };
diff --git a/block/qapi-sysemu.c b/block/qapi-sysemu.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qapi-sysemu.c
+++ b/block/qapi-sysemu.c
@@ -XXX,XX +XXX,XX @@ void qmp_block_latency_histogram_set(
     bool has_boundaries, uint64List *boundaries,
     bool has_boundaries_read, uint64List *boundaries_read,
     bool has_boundaries_write, uint64List *boundaries_write,
+    bool has_boundaries_append, uint64List *boundaries_append,
     bool has_boundaries_flush, uint64List *boundaries_flush,
     Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ void qmp_block_latency_histogram_set(
         }
     }
 
+    if (has_boundaries || has_boundaries_append) {
+        ret = block_latency_histogram_set(
+                stats, BLOCK_ACCT_ZONE_APPEND,
+                has_boundaries_append ? boundaries_append : boundaries);
+        if (ret) {
+            error_setg(errp, "Device '%s' set append write boundaries fail", id);
+            return;
+        }
+    }
+
     if (has_boundaries || has_boundaries_flush) {
         ret = block_latency_histogram_set(
             stats, BLOCK_ACCT_FLUSH,
diff --git a/block/qapi.c b/block/qapi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qapi.c
+++ b/block/qapi.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
 
     ds->rd_bytes = stats->nr_bytes[BLOCK_ACCT_READ];
     ds->wr_bytes = stats->nr_bytes[BLOCK_ACCT_WRITE];
+    ds->zone_append_bytes = stats->nr_bytes[BLOCK_ACCT_ZONE_APPEND];
     ds->unmap_bytes = stats->nr_bytes[BLOCK_ACCT_UNMAP];
     ds->rd_operations = stats->nr_ops[BLOCK_ACCT_READ];
     ds->wr_operations = stats->nr_ops[BLOCK_ACCT_WRITE];
+    ds->zone_append_operations = stats->nr_ops[BLOCK_ACCT_ZONE_APPEND];
     ds->unmap_operations = stats->nr_ops[BLOCK_ACCT_UNMAP];
 
     ds->failed_rd_operations = stats->failed_ops[BLOCK_ACCT_READ];
     ds->failed_wr_operations = stats->failed_ops[BLOCK_ACCT_WRITE];
+    ds->failed_zone_append_operations =
+        stats->failed_ops[BLOCK_ACCT_ZONE_APPEND];
     ds->failed_flush_operations = stats->failed_ops[BLOCK_ACCT_FLUSH];
     ds->failed_unmap_operations = stats->failed_ops[BLOCK_ACCT_UNMAP];
 
     ds->invalid_rd_operations = stats->invalid_ops[BLOCK_ACCT_READ];
     ds->invalid_wr_operations = stats->invalid_ops[BLOCK_ACCT_WRITE];
+    ds->invalid_zone_append_operations =
+        stats->invalid_ops[BLOCK_ACCT_ZONE_APPEND];
     ds->invalid_flush_operations =
         stats->invalid_ops[BLOCK_ACCT_FLUSH];
     ds->invalid_unmap_operations = stats->invalid_ops[BLOCK_ACCT_UNMAP];
 
     ds->rd_merged = stats->merged[BLOCK_ACCT_READ];
     ds->wr_merged = stats->merged[BLOCK_ACCT_WRITE];
+    ds->zone_append_merged = stats->merged[BLOCK_ACCT_ZONE_APPEND];
     ds->unmap_merged = stats->merged[BLOCK_ACCT_UNMAP];
     ds->flush_operations = stats->nr_ops[BLOCK_ACCT_FLUSH];
     ds->wr_total_time_ns = stats->total_time_ns[BLOCK_ACCT_WRITE];
+    ds->zone_append_total_time_ns =
+        stats->total_time_ns[BLOCK_ACCT_ZONE_APPEND];
     ds->rd_total_time_ns = stats->total_time_ns[BLOCK_ACCT_READ];
     ds->flush_total_time_ns = stats->total_time_ns[BLOCK_ACCT_FLUSH];
     ds->unmap_total_time_ns = stats->total_time_ns[BLOCK_ACCT_UNMAP];
@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
 
         TimedAverage *rd = &ts->latency[BLOCK_ACCT_READ];
         TimedAverage *wr = &ts->latency[BLOCK_ACCT_WRITE];
+        TimedAverage *zap = &ts->latency[BLOCK_ACCT_ZONE_APPEND];
         TimedAverage *fl = &ts->latency[BLOCK_ACCT_FLUSH];
 
         dev_stats->interval_length = ts->interval_length;
@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
         dev_stats->max_wr_latency_ns = timed_average_max(wr);
         dev_stats->avg_wr_latency_ns = timed_average_avg(wr);
 
+        dev_stats->min_zone_append_latency_ns = timed_average_min(zap);
+        dev_stats->max_zone_append_latency_ns = timed_average_max(zap);
+        dev_stats->avg_zone_append_latency_ns = timed_average_avg(zap);
+
         dev_stats->min_flush_latency_ns = timed_average_min(fl);
         dev_stats->max_flush_latency_ns = timed_average_max(fl);
         dev_stats->avg_flush_latency_ns = timed_average_avg(fl);
@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
             block_acct_queue_depth(ts, BLOCK_ACCT_READ);
         dev_stats->avg_wr_queue_depth =
             block_acct_queue_depth(ts, BLOCK_ACCT_WRITE);
+        dev_stats->avg_zone_append_queue_depth =
+            block_acct_queue_depth(ts, BLOCK_ACCT_ZONE_APPEND);
 
         QAPI_LIST_PREPEND(ds->timed_stats, dev_stats);
     }
@@ -XXX,XX +XXX,XX @@ static void bdrv_query_blk_stats(BlockDeviceStats *ds, BlockBackend *blk)
         = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_READ]);
     ds->wr_latency_histogram
         = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_WRITE]);
+    ds->zone_append_latency_histogram
+        = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_ZONE_APPEND]);
     ds->flush_latency_histogram
         = bdrv_latency_histogram_stats(&hgram[BLOCK_ACCT_FLUSH]);
 }
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_zone_append(VirtIOBlockReq *req,
     data->in_num = in_num;
     data->zone_append_data.offset = offset;
     qemu_iovec_init_external(&req->qiov, out_iov, out_num);
+
+    block_acct_start(blk_get_stats(s->blk), &req->acct, len,
+                     BLOCK_ACCT_ZONE_APPEND);
+
     blk_aio_zone_append(s->blk, &data->zone_append_data.offset, &req->qiov, 0,
                         virtio_blk_zone_append_complete, data);
     return 0;
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20230407082528.18841-5-faithilikerun@gmail.com>
---
 hw/block/virtio-blk.c | 12 ++++++++++++
 hw/block/trace-events |  7 +++++++
 2 files changed, 19 insertions(+)

diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_zone_report_complete(void *opaque, int ret)
     int64_t nz = data->zone_report_data.nr_zones;
     int8_t err_status = VIRTIO_BLK_S_OK;
 
+    trace_virtio_blk_zone_report_complete(vdev, req, nz, ret);
     if (ret) {
         err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
         goto out;
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_handle_zone_report(VirtIOBlockReq *req,
     nr_zones = (req->in_len - sizeof(struct virtio_blk_inhdr) -
                 sizeof(struct virtio_blk_zone_report)) /
                sizeof(struct virtio_blk_zone_descriptor);
+    trace_virtio_blk_handle_zone_report(vdev, req,
+                                        offset >> BDRV_SECTOR_BITS, nr_zones);
 
     zone_size = sizeof(BlockZoneDescriptor) * nr_zones;
     data = g_malloc(sizeof(ZoneCmdData));
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_zone_mgmt_complete(void *opaque, int ret)
 {
     VirtIOBlockReq *req = opaque;
     VirtIOBlock *s = req->dev;
+    VirtIODevice *vdev = VIRTIO_DEVICE(s);
     int8_t err_status = VIRTIO_BLK_S_OK;
+    trace_virtio_blk_zone_mgmt_complete(vdev, req,ret);
 
     if (ret) {
         err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_zone_mgmt(VirtIOBlockReq *req, BlockZoneOp op)
         /* Entire drive capacity */
         offset = 0;
         len = capacity;
+        trace_virtio_blk_handle_zone_reset_all(vdev, req, 0,
+                                               bs->total_sectors);
     } else {
         if (bs->bl.zone_size > capacity - offset) {
             /* The zoned device allows the last smaller zone. */
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_zone_mgmt(VirtIOBlockReq *req, BlockZoneOp op)
         } else {
             len = bs->bl.zone_size;
         }
+        trace_virtio_blk_handle_zone_mgmt(vdev, req, op,
+                                          offset >> BDRV_SECTOR_BITS,
+                                          len >> BDRV_SECTOR_BITS);
     }
 
     if (!check_zoned_request(s, offset, len, false, &err_status)) {
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_zone_append_complete(void *opaque, int ret)
         err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
         goto out;
     }
+    trace_virtio_blk_zone_append_complete(vdev, req, append_sector, ret);
 
 out:
     aio_context_acquire(blk_get_aio_context(s->conf.conf.blk));
@@ -XXX,XX +XXX,XX @@ static int virtio_blk_handle_zone_append(VirtIOBlockReq *req,
     int64_t offset = virtio_ldq_p(vdev, &req->out.sector) << BDRV_SECTOR_BITS;
     int64_t len = iov_size(out_iov, out_num);
 
+    trace_virtio_blk_handle_zone_append(vdev, req, offset >> BDRV_SECTOR_BITS);
     if (!check_zoned_request(s, offset, len, true, &err_status)) {
         goto out;
     }
diff --git a/hw/block/trace-events b/hw/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/trace-events
+++ b/hw/block/trace-events
@@ -XXX,XX +XXX,XX @@ pflash_write_unknown(const char *name, uint8_t cmd) "%s: unknown command 0x%02x"
 # virtio-blk.c
 virtio_blk_req_complete(void *vdev, void *req, int status) "vdev %p req %p status %d"
 virtio_blk_rw_complete(void *vdev, void *req, int ret) "vdev %p req %p ret %d"
+virtio_blk_zone_report_complete(void *vdev, void *req, unsigned int nr_zones, int ret) "vdev %p req %p nr_zones %u ret %d"
+virtio_blk_zone_mgmt_complete(void *vdev, void *req, int ret) "vdev %p req %p ret %d"
+virtio_blk_zone_append_complete(void *vdev, void *req, int64_t sector, int ret) "vdev %p req %p, append sector 0x%" PRIx64 " ret %d"
 virtio_blk_handle_write(void *vdev, void *req, uint64_t sector, size_t nsectors) "vdev %p req %p sector %"PRIu64" nsectors %zu"
 virtio_blk_handle_read(void *vdev, void *req, uint64_t sector, size_t nsectors) "vdev %p req %p sector %"PRIu64" nsectors %zu"
 virtio_blk_submit_multireq(void *vdev, void *mrb, int start, int num_reqs, uint64_t offset, size_t size, bool is_write) "vdev %p mrb %p start %d num_reqs %d offset %"PRIu64" size %zu is_write %d"
+virtio_blk_handle_zone_report(void *vdev, void *req, int64_t sector, unsigned int nr_zones) "vdev %p req %p sector 0x%" PRIx64 " nr_zones %u"
+virtio_blk_handle_zone_mgmt(void *vdev, void *req, uint8_t op, int64_t sector, int64_t len) "vdev %p req %p op 0x%x sector 0x%" PRIx64 " len 0x%" PRIx64 ""
+virtio_blk_handle_zone_reset_all(void *vdev, void *req, int64_t sector, int64_t len) "vdev %p req %p sector 0x%" PRIx64 " cap 0x%" PRIx64 ""
+virtio_blk_handle_zone_append(void *vdev, void *req, int64_t sector) "vdev %p req %p, append sector 0x%" PRIx64 ""
 
 # hd-geometry.c
 hd_geometry_lchs_guess(void *blk, int cyls, int heads, int secs) "blk %p LCHS %d %d %d"
-- 
2.40.0

From: Sam Li <faithilikerun@gmail.com>

Add the documentation about the example of using virtio-blk driver
to pass the zoned block devices through to the guest.

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
[Fix rST syntax
--Stefan]
Message-Id: <20230407082528.18841-6-faithilikerun@gmail.com>
---
 docs/devel/zoned-storage.rst | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/docs/devel/zoned-storage.rst b/docs/devel/zoned-storage.rst
index XXXXXXX..XXXXXXX 100644
--- a/docs/devel/zoned-storage.rst
+++ b/docs/devel/zoned-storage.rst
@@ -XXX,XX +XXX,XX @@ APIs for zoned storage emulation or testing.
 For example, to test zone_report on a null_blk device using qemu-io is::
 
   $ path/to/qemu-io --image-opts -n driver=host_device,filename=/dev/nullb0 -c "zrp offset nr_zones"
+
+To expose the host's zoned block device through virtio-blk, the command line
+can be (includes the -device parameter)::
+
+  -blockdev node-name=drive0,driver=host_device,filename=/dev/nullb0,cache.direct=on \
+      -device virtio-blk-pci,drive=drive0
+
+Or only use the -drive parameter::
+
+  -driver driver=host_device,file=/dev/nullb0,if=virtio,cache.direct=on
+
+Additionally, QEMU has several ways of supporting zoned storage, including:
+(1) Using virtio-scsi: --device scsi-block allows for the passing through of
+SCSI ZBC devices, enabling the attachment of ZBC or ZAC HDDs to QEMU.
+(2) PCI device pass-through: While NVMe ZNS emulation is available for testing
+purposes, it cannot yet pass through a zoned device from the host. To pass on
+the NVMe ZNS device to the guest, use VFIO PCI pass the entire NVMe PCI adapter
+through to the guest. Likewise, an HDD HBA can be passed on to QEMU all HDDs
+attached to the HBA.
-- 
2.40.0