Series comparison

-[PULL 00/20] Block patches
+[PULL v2 00/28] Block patches
-The following changes since commit c1eb2ddf0f8075faddc5f7c3d39feae3e8e9d6b4:
+The following changes since commit ac793156f650ae2d77834932d72224175ee69086:
-  Update version for v8.0.0 release (2023-04-19 17:27:13 +0100)
+  Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20201020-1' into staging (2020-10-20 21:11:35 +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 36e5e9b22abe56aa00ca067851555ad8127a7966:
+for you to fetch changes up to 32a3fd65e7e3551337fd26bfc0e2f899d70c028c:
-  tracing: install trace events file only if necessary (2023-04-20 07:39:43 -0400)
+  iotests: add commit top->base cases to 274 (2020-10-22 09:55:39 +0100)
 ----------------------------------------------------------------
 Pull request
-Sam Li's zoned storage work and fixes I collected during the 8.0 freeze.
+v2:
  * Fix format string issues on 32-bit hosts [Peter]
  * Fix qemu-nbd.c CONFIG_POSIX ifdef issue [Eric]
  * Fix missing eventfd.h header on macOS [Peter]
  * Drop unreliable vhost-user-blk test (will send a new patch when ready) [Peter]
 This pull request contains the vhost-user-blk server by Coiby Xu along with my
 additions, block/nvme.c alignment and hardware error statistics by Philippe
 Mathieu-Daudé, and bdrv_co_block_status_above() fixes by Vladimir
 Sementsov-Ogievskiy.
 ----------------------------------------------------------------
-Carlos Santos (1):
+Coiby Xu (6):
-  tracing: install trace events file only if necessary
+  libvhost-user: Allow vu_message_read to be replaced
   libvhost-user: remove watch for kick_fd when de-initialize vu-dev
   util/vhost-user-server: generic vhost user server
   block: move logical block size check function to a common utility
     function
   block/export: vhost-user block device backend server
   MAINTAINERS: Add vhost-user block device backend server maintainer
 Philippe Mathieu-Daudé (1):
-  block/dmg: Declare a type definition for DMG uncompress function
+  block/nvme: Add driver statistics for access alignment and hw errors
-Sam Li (17):
+Stefan Hajnoczi (16):
-  block/block-common: add zoned device structs
+  util/vhost-user-server: s/fileds/fields/ typo fix
-  block/file-posix: introduce helper functions for sysfs attributes
+  util/vhost-user-server: drop unnecessary QOM cast
-  block/block-backend: add block layer APIs resembling Linux
+  util/vhost-user-server: drop unnecessary watch deletion
-    ZonedBlockDevice ioctls
+  block/export: consolidate request structs into VuBlockReq
-  block/raw-format: add zone operations to pass through requests
+  util/vhost-user-server: drop unused DevicePanicNotifier
-  block: add zoned BlockDriver check to block layer
+  util/vhost-user-server: fix memory leak in vu_message_read()
-  iotests: test new zone operations
+  util/vhost-user-server: check EOF when reading payload
-  block: add some trace events for new block layer APIs
+  util/vhost-user-server: rework vu_client_trip() coroutine lifecycle
-  docs/zoned-storage: add zoned device documentation
+  block/export: report flush errors
-  file-posix: add tracking of the zone write pointers
+  block/export: convert vhost-user-blk server to block export API
-  block: introduce zone append write for zoned devices
+  util/vhost-user-server: move header to include/
-  qemu-iotests: test zone append operation
+  util/vhost-user-server: use static library in meson.build
-  block: add some trace events for zone append
+  qemu-storage-daemon: avoid compiling blockdev_ss twice
-  include: update virtio_blk headers to v6.3-rc1
+  block: move block exports to libblockdev
-  virtio-blk: add zoned storage emulation for zoned devices
+  block/export: add iothread and fixed-iothread options
-  block: add accounting for zone append operation
+  block/export: add vhost-user-blk multi-queue support
   virtio-blk: add some trace events for zoned emulation
   docs/zoned-storage:add zoned emulation use case
-Thomas De Schampheleire (1):
+Vladimir Sementsov-Ogievskiy (5):
-  tracetool: use relative paths for '#line' preprocessor directives
+  block/io: fix bdrv_co_block_status_above
   block/io: bdrv_common_block_status_above: support include_base
   block/io: bdrv_common_block_status_above: support bs == base
   block/io: fix bdrv_is_allocated_above
   iotests: add commit top->base cases to 274
- docs/devel/index-api.rst                     |   1 +
+ MAINTAINERS                                |   9 +
- docs/devel/zoned-storage.rst                 |  62 ++
+ qapi/block-core.json                       |  24 +-
- qapi/block-core.json                         |  68 +-
+ qapi/block-export.json                     |  36 +-
- qapi/block.json                              |   4 +
+ block/coroutines.h                         |   2 +
- meson.build                                  |   4 +
+ block/export/vhost-user-blk-server.h       |  19 +
- block/dmg.h                                  |   8 +-
+ contrib/libvhost-user/libvhost-user.h      |  21 +
- include/block/accounting.h                   |   1 +
+ include/qemu/vhost-user-server.h           |  65 +++
- include/block/block-common.h                 |  57 ++
+ util/block-helpers.h                       |  19 +
- include/block/block-io.h                     |  13 +
+ block/export/export.c                      |  37 +-
- include/block/block_int-common.h             |  37 +
+ block/export/vhost-user-blk-server.c       | 431 ++++++++++++++++++++
- include/block/raw-aio.h                      |   8 +-
+ block/io.c                                 | 132 +++---
- include/standard-headers/drm/drm_fourcc.h    |  12 +
+ block/nvme.c                               |  27 ++
- include/standard-headers/linux/ethtool.h     |  48 +-
+ block/qcow2.c                              |  16 +-
- include/standard-headers/linux/fuse.h        |  45 +-
+ contrib/libvhost-user/libvhost-user-glib.c |   2 +-
- include/standard-headers/linux/pci_regs.h    |   1 +
+ contrib/libvhost-user/libvhost-user.c      |  15 +-
- include/standard-headers/linux/vhost_types.h |   2 +
+ hw/core/qdev-properties-system.c           |  31 +-
- include/standard-headers/linux/virtio_blk.h  | 105 +++
+ nbd/server.c                               |   2 -
- include/sysemu/block-backend-io.h            |  27 +
+ qemu-nbd.c                                 |  21 +-
- linux-headers/asm-arm64/kvm.h                |   1 +
+ softmmu/vl.c                               |   4 +
- linux-headers/asm-x86/kvm.h                  |  34 +-
+ stubs/blk-exp-close-all.c                  |   7 +
- linux-headers/linux/kvm.h                    |   9 +
+ tests/vhost-user-bridge.c                  |   2 +
- linux-headers/linux/vfio.h                   |  15 +-
+ tools/virtiofsd/fuse_virtio.c              |   4 +-
- linux-headers/linux/vhost.h                  |   8 +
+ util/block-helpers.c                       |  46 +++
- block.c                                      |  19 +
+ util/vhost-user-server.c                   | 446 +++++++++++++++++++++
- block/block-backend.c                        | 193 ++++++
+ block/export/meson.build                   |   3 +-
- block/dmg.c                                  |   7 +-
+ contrib/libvhost-user/meson.build          |   1 +
- block/file-posix.c                           | 677 +++++++++++++++++--
+ meson.build                                |  22 +-
- block/io.c                                   |  68 ++
+ nbd/meson.build                            |   2 +
- block/io_uring.c                             |   4 +
+ storage-daemon/meson.build                 |   3 +-
- block/linux-aio.c                            |   3 +
+ stubs/meson.build                          |   1 +
- block/qapi-sysemu.c                          |  11 +
+ tests/qemu-iotests/274                     |  20 +
- block/qapi.c                                 |  18 +
+ tests/qemu-iotests/274.out                 |  68 ++++
- block/raw-format.c                           |  26 +
+ util/meson.build                           |   4 +
- hw/block/virtio-blk-common.c                 |   2 +
+files changed, 1420 insertions(+), 122 deletions(-)
- hw/block/virtio-blk.c                        | 405 +++++++++++
+ create mode 100644 block/export/vhost-user-blk-server.h
- hw/virtio/virtio-qmp.c                       |   2 +
+ create mode 100644 include/qemu/vhost-user-server.h
- qemu-io-cmds.c                               | 224 ++++++
+ create mode 100644 util/block-helpers.h
- block/trace-events                           |   4 +
+ create mode 100644 block/export/vhost-user-blk-server.c
- docs/system/qemu-block-drivers.rst.inc       |   6 +
+ create mode 100644 stubs/blk-exp-close-all.c
- hw/block/trace-events                        |   7 +
+ create mode 100644 util/block-helpers.c
- scripts/tracetool/backend/ftrace.py          |   4 +-
+ create mode 100644 util/vhost-user-server.c
  scripts/tracetool/backend/log.py             |   4 +-
  scripts/tracetool/backend/syslog.py          |   4 +-
  tests/qemu-iotests/tests/zoned               | 105 +++
  tests/qemu-iotests/tests/zoned.out           |  69 ++
  trace/meson.build                            |   2 +-
 files changed, 2353 insertions(+), 81 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
 --
-.39.2
+.26.2

-[PULL 17/20] block: add accounting for zone append operation
+[PULL v2 01/28] block/nvme: Add driver statistics for access alignment and hw errors
-From: Sam Li <faithilikerun@gmail.com>
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
-Taking account of the new zone append write operation for zoned devices,
+Keep statistics of some hardware errors, and number of
-BLOCK_ACCT_ZONE_APPEND enum is introduced as other I/O request type (read,
+aligned/unaligned I/O accesses.
 write, flush).
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+QMP example booting a full RHEL 8.3 aarch64 guest:
-Message-id: 20230407082528.18841-4-faithilikerun@gmail.com
 { "execute": "query-blockstats" }
 {
     "return": [
         {
             "device": "",
             "node-name": "drive0",
             "stats": {
                 "flush_total_time_ns": 6026948,
                 "wr_highest_offset": 3383991230464,
                 "wr_total_time_ns": 807450995,
                 "failed_wr_operations": 0,
                 "failed_rd_operations": 0,
                 "wr_merged": 3,
                 "wr_bytes": 50133504,
                 "failed_unmap_operations": 0,
                 "failed_flush_operations": 0,
                 "account_invalid": false,
                 "rd_total_time_ns": 1846979900,
                 "flush_operations": 130,
                 "wr_operations": 659,
                 "rd_merged": 1192,
                 "rd_bytes": 218244096,
                 "account_failed": false,
                 "idle_time_ns": 2678641497,
                 "rd_operations": 7406,
             },
             "driver-specific": {
                 "driver": "nvme",
                 "completion-errors": 0,
                 "unaligned-accesses": 2959,
                 "aligned-accesses": 4477
             },
             "qdev": "/machine/peripheral-anon/device[0]/virtio-backend"
         }
     ]
 }
 Suggested-by: Stefan Hajnoczi <stefanha@gmail.com>
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Acked-by: Markus Armbruster <armbru@redhat.com>
 Message-id: 20201001162939.1567915-1-philmd@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- qapi/block-core.json       | 68 ++++++++++++++++++++++++++++++++------
+ qapi/block-core.json | 24 +++++++++++++++++++++++-
- qapi/block.json            |  4 +++
+ block/nvme.c         | 27 +++++++++++++++++++++++++++
- include/block/accounting.h |  1 +
+files changed, 50 insertions(+), 1 deletion(-)
  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
+       'discard-nb-failed': 'uint64',
- #                     defined interval, in nanoseconds.
+       'discard-bytes-ok': 'uint64' } }
- #
-+# @min_zone_append_latency_ns: Minimum latency of zone append operations
++##
-+#                              in the defined interval, in nanoseconds
++# @BlockStatsSpecificNvme:
 +#                              (since 8.1)
 +#
- # @min_flush_latency_ns: Minimum latency of flush operations in the
++# NVMe driver statistics
- #                        defined interval, in nanoseconds.
++#
 +# @completion-errors: The number of completion errors.
 +#
 +# @aligned-accesses: The number of aligned accesses performed by
 +#                    the driver.
 +#
 +# @unaligned-accesses: The number of unaligned accesses performed by
 +#                      the driver.
 +#
 +# Since: 5.2
 +##
 +{ 'struct': 'BlockStatsSpecificNvme',
 +  'data': {
 +      'completion-errors': 'uint64',
 +      'aligned-accesses': 'uint64',
 +      'unaligned-accesses': 'uint64' } }
 +
  ##
  # @BlockStatsSpecific:
  #
 @@ -XXX,XX +XXX,XX @@
- # @max_wr_latency_ns: Maximum latency of write operations in the
+   'discriminator': 'driver',
- #                     defined interval, in nanoseconds.
+   'data': {
- #
+       'file': 'BlockStatsSpecificFile',
-+# @max_zone_append_latency_ns: Maximum latency of zone append operations
+-      'host_device': 'BlockStatsSpecificFile' } }
-+#                              in the defined interval, in nanoseconds
++      'host_device': 'BlockStatsSpecificFile',
-+#                              (since 8.1)
++      'nvme': 'BlockStatsSpecificNvme' } }
-+#
  # @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',
+ # @BlockStats:
-   'data': { 'interval_length': 'int', 'min_rd_latency_ns': 'int',
+diff --git a/block/nvme.c b/block/nvme.c
              '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
+--- a/block/nvme.c
-+++ b/qapi/block.json
++++ b/block/nvme.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ struct BDRVNVMeState {
- # @boundaries-write: list of interval boundary values for write latency
- #                    histogram.
+     /* PCI address (required for nvme_refresh_filename()) */
- #
+     char *device;
-+# @boundaries-zap: list of interval boundary values for zone append write
++
-+#                  latency histogram.
++    struct {
-+#
++        uint64_t completion_errors;
- # @boundaries-flush: list of interval boundary values for flush latency
++        uint64_t aligned_accesses;
- #                    histogram.
++        uint64_t unaligned_accesses;
- #
++    } stats;
@@ -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
+ #define NVME_BLOCK_OPT_DEVICE "device"
---- a/block/qapi-sysemu.c
+@@ -XXX,XX +XXX,XX @@ static bool nvme_process_completion(NVMeQueuePair *q)
-+++ b/block/qapi-sysemu.c
+             break;
@@ -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(
          }
+         ret = nvme_translate_error(c);
++        if (ret) {
++            s->stats.completion_errors++;
++        }
+         q->cq.head = (q->cq.head + 1) % NVME_QUEUE_SIZE;
+         if (!q->cq.head) {
+             q->cq_phase = !q->cq_phase;
+@@ -XXX,XX +XXX,XX @@ static int nvme_co_prw(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
+     assert(QEMU_IS_ALIGNED(bytes, s->page_size));
+     assert(bytes <= s->max_transfer);
+     if (nvme_qiov_aligned(bs, qiov)) {
++        s->stats.aligned_accesses++;
+         return nvme_co_prw_aligned(bs, offset, bytes, qiov, is_write, flags);
      }
++    s->stats.unaligned_accesses++;
-+    if (has_boundaries || has_boundaries_append) {
+     trace_nvme_prw_buffered(s, offset, bytes, qiov->niov, is_write);
-+        ret = block_latency_histogram_set(
+     buf = qemu_try_memalign(s->page_size, bytes);
-+                stats, BLOCK_ACCT_ZONE_APPEND,
-+                has_boundaries_append ? boundaries_append : boundaries);
+@@ -XXX,XX +XXX,XX @@ static void nvme_unregister_buf(BlockDriverState *bs, void *host)
-+        if (ret) {
+     qemu_vfio_dma_unmap(s->vfio, host);
-+            error_setg(errp, "Device '%s' set append write boundaries fail", id);
+ }
-+            return;
-+        }
++static BlockStatsSpecific *nvme_get_specific_stats(BlockDriverState *bs)
-+    }
++{
 +    BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
 +    BDRVNVMeState *s = bs->opaque;
 +
-     if (has_boundaries || has_boundaries_flush) {
++    stats->driver = BLOCKDEV_DRIVER_NVME;
-         ret = block_latency_histogram_set(
++    stats->u.nvme = (BlockStatsSpecificNvme) {
-             stats, BLOCK_ACCT_FLUSH,
++        .completion_errors = s->stats.completion_errors,
-diff --git a/block/qapi.c b/block/qapi.c
++        .aligned_accesses = s->stats.aligned_accesses,
-index XXXXXXX..XXXXXXX 100644
++        .unaligned_accesses = s->stats.unaligned_accesses,
---- 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);
++    return stats;
-         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,
+ static const char *const nvme_strong_runtime_opts[] = {
-+                     BLOCK_ACCT_ZONE_APPEND);
+     NVME_BLOCK_OPT_DEVICE,
-+
+     NVME_BLOCK_OPT_NAMESPACE,
-     blk_aio_zone_append(s->blk, &data->zone_append_data.offset, &req->qiov, 0,
+@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_nvme = {
-                         virtio_blk_zone_append_complete, data);
+     .bdrv_refresh_filename    = nvme_refresh_filename,
-     return 0;
+     .bdrv_refresh_limits      = nvme_refresh_limits,
      .strong_runtime_opts      = nvme_strong_runtime_opts,
 +    .bdrv_get_specific_stats  = nvme_get_specific_stats,
      .bdrv_detach_aio_context  = nvme_detach_aio_context,
      .bdrv_attach_aio_context  = nvme_attach_aio_context,
 --
-.39.2
+.26.2

-[PULL 18/20] virtio-blk: add some trace events for zoned emulation
+[PULL v2 02/28] libvhost-user: Allow vu_message_read to be replaced
-From: Sam Li <faithilikerun@gmail.com>
+From: Coiby Xu <coiby.xu@gmail.com>
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Allow vu_message_read to be replaced by one which will make use of the
 QIOChannel functions. Thus reading vhost-user message won't stall the
 guest. For slave channel, we still use the default vu_message_read.
 Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
 Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-id: 20230407082528.18841-5-faithilikerun@gmail.com
+Message-id: 20200918080912.321299-2-coiby.xu@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- hw/block/virtio-blk.c | 12 ++++++++++++
+ contrib/libvhost-user/libvhost-user.h      | 21 +++++++++++++++++++++
- hw/block/trace-events |  7 +++++++
+ contrib/libvhost-user/libvhost-user-glib.c |  2 +-
-files changed, 19 insertions(+)
+ contrib/libvhost-user/libvhost-user.c      | 14 +++++++-------
  tests/vhost-user-bridge.c                  |  2 ++
  tools/virtiofsd/fuse_virtio.c              |  4 ++--
 files changed, 33 insertions(+), 10 deletions(-)
-diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
+diff --git a/contrib/libvhost-user/libvhost-user.h b/contrib/libvhost-user/libvhost-user.h
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/virtio-blk.c
+--- a/contrib/libvhost-user/libvhost-user.h
-+++ b/hw/block/virtio-blk.c
++++ b/contrib/libvhost-user/libvhost-user.h
-@@ -XXX,XX +XXX,XX @@ static void virtio_blk_zone_report_complete(void *opaque, int ret)
+@@ -XXX,XX +XXX,XX @@
-     int64_t nz = data->zone_report_data.nr_zones;
+  */
-     int8_t err_status = VIRTIO_BLK_S_OK;
+ #define VHOST_USER_MAX_RAM_SLOTS 32
-+    trace_virtio_blk_zone_report_complete(vdev, req, nz, ret);
++#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64)
-     if (ret) {
++
-         err_status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
+ typedef enum VhostSetConfigType {
-         goto out;
+     VHOST_SET_CONFIG_TYPE_MASTER = 0,
-@@ -XXX,XX +XXX,XX @@ static void virtio_blk_handle_zone_report(VirtIOBlockReq *req,
+     VHOST_SET_CONFIG_TYPE_MIGRATION = 1,
-     nr_zones = (req->in_len - sizeof(struct virtio_blk_inhdr) -
+@@ -XXX,XX +XXX,XX @@ typedef uint64_t (*vu_get_features_cb) (VuDev *dev);
-                 sizeof(struct virtio_blk_zone_report)) /
+ typedef void (*vu_set_features_cb) (VuDev *dev, uint64_t features);
-                sizeof(struct virtio_blk_zone_descriptor);
+ typedef int (*vu_process_msg_cb) (VuDev *dev, VhostUserMsg *vmsg,
-+    trace_virtio_blk_handle_zone_report(vdev, req,
+                                   int *do_reply);
-+                                        offset >> BDRV_SECTOR_BITS, nr_zones);
++typedef bool (*vu_read_msg_cb) (VuDev *dev, int sock, VhostUserMsg *vmsg);
+ typedef void (*vu_queue_set_started_cb) (VuDev *dev, int qidx, bool started);
-     zone_size = sizeof(BlockZoneDescriptor) * nr_zones;
+ typedef bool (*vu_queue_is_processed_in_order_cb) (VuDev *dev, int qidx);
-     data = g_malloc(sizeof(ZoneCmdData));
+ typedef int (*vu_get_config_cb) (VuDev *dev, uint8_t *config, uint32_t len);
-@@ -XXX,XX +XXX,XX @@ static void virtio_blk_zone_mgmt_complete(void *opaque, int ret)
+@@ -XXX,XX +XXX,XX @@ struct VuDev {
      bool broken;
      uint16_t max_queues;
 +    /* @read_msg: custom method to read vhost-user message
 +     *
 +     * Read data from vhost_user socket fd and fill up
 +     * the passed VhostUserMsg *vmsg struct.
 +     *
 +     * If reading fails, it should close the received set of file
 +     * descriptors as socket message's auxiliary data.
 +     *
 +     * For the details, please refer to vu_message_read in libvhost-user.c
 +     * which will be used by default if not custom method is provided when
 +     * calling vu_init
 +     *
 +     * Returns: true if vhost-user message successfully received,
 +     *          otherwise return false.
 +     *
 +     */
 +    vu_read_msg_cb read_msg;
      /* @set_watch: add or update the given fd to the watch set,
       * call cb when condition is met */
      vu_set_watch_cb set_watch;
@@ -XXX,XX +XXX,XX @@ bool vu_init(VuDev *dev,
               uint16_t max_queues,
               int socket,
               vu_panic_cb panic,
 +             vu_read_msg_cb read_msg,
               vu_set_watch_cb set_watch,
               vu_remove_watch_cb remove_watch,
               const VuDevIface *iface);
 diff --git a/contrib/libvhost-user/libvhost-user-glib.c b/contrib/libvhost-user/libvhost-user-glib.c
 index XXXXXXX..XXXXXXX 100644
 --- a/contrib/libvhost-user/libvhost-user-glib.c
 +++ b/contrib/libvhost-user/libvhost-user-glib.c
@@ -XXX,XX +XXX,XX @@ vug_init(VugDev *dev, uint16_t max_queues, int socket,
      g_assert(dev);
      g_assert(iface);
 -    if (!vu_init(&dev->parent, max_queues, socket, panic, set_watch,
 +    if (!vu_init(&dev->parent, max_queues, socket, panic, NULL, set_watch,
                   remove_watch, iface)) {
          return false;
      }
 diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/libvhost-user.c
 index XXXXXXX..XXXXXXX 100644
 --- a/contrib/libvhost-user/libvhost-user.c
 +++ b/contrib/libvhost-user/libvhost-user.c
@@ -XXX,XX +XXX,XX @@
  /* The version of inflight buffer */
  #define INFLIGHT_VERSION 1
 -#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64)
 -
  /* The version of the protocol we support */
  #define VHOST_USER_VERSION 1
  #define LIBVHOST_USER_DEBUG 0
@@ -XXX,XX +XXX,XX @@ have_userfault(void)
  }
  static bool
 -vu_message_read(VuDev *dev, int conn_fd, VhostUserMsg *vmsg)
 +vu_message_read_default(VuDev *dev, int conn_fd, VhostUserMsg *vmsg)
  {
-     VirtIOBlockReq *req = opaque;
+     char control[CMSG_SPACE(VHOST_MEMORY_BASELINE_NREGIONS * sizeof(int))] = {};
-     VirtIOBlock *s = req->dev;
+     struct iovec iov = {
-+    VirtIODevice *vdev = VIRTIO_DEVICE(s);
+@@ -XXX,XX +XXX,XX @@ vu_process_message_reply(VuDev *dev, const VhostUserMsg *vmsg)
      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);
+-    if (!vu_message_read(dev, dev->slave_fd, &msg_reply)) {
- out:
++    if (!vu_message_read_default(dev, dev->slave_fd, &msg_reply)) {
      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
@@ -XXX,XX +XXX,XX @@ vu_set_mem_table_exec_postcopy(VuDev *dev, VhostUserMsg *vmsg)
      /* Wait for QEMU to confirm that it's registered the handler for the
       * faults.
       */
 -    if (!vu_message_read(dev, dev->sock, vmsg) ||
 +    if (!dev->read_msg(dev, dev->sock, vmsg) ||
          vmsg->size != sizeof(vmsg->payload.u64) ||
          vmsg->payload.u64 != 0) {
          vu_panic(dev, "failed to receive valid ack for postcopy set-mem-table");
@@ -XXX,XX +XXX,XX @@ vu_dispatch(VuDev *dev)
      int reply_requested;
      bool need_reply, success = false;
 -    if (!vu_message_read(dev, dev->sock, &vmsg)) {
 +    if (!dev->read_msg(dev, dev->sock, &vmsg)) {
          goto end;
      }
@@ -XXX,XX +XXX,XX @@ vu_init(VuDev *dev,
          uint16_t max_queues,
          int socket,
          vu_panic_cb panic,
 +        vu_read_msg_cb read_msg,
          vu_set_watch_cb set_watch,
          vu_remove_watch_cb remove_watch,
          const VuDevIface *iface)
@@ -XXX,XX +XXX,XX @@ vu_init(VuDev *dev,
      dev->sock = socket;
      dev->panic = panic;
 +    dev->read_msg = read_msg ? read_msg : vu_message_read_default;
      dev->set_watch = set_watch;
      dev->remove_watch = remove_watch;
      dev->iface = iface;
@@ -XXX,XX +XXX,XX @@ static void _vu_queue_notify(VuDev *dev, VuVirtq *vq, bool sync)
          vu_message_write(dev, dev->slave_fd, &vmsg);
          if (ack) {
 -            vu_message_read(dev, dev->slave_fd, &vmsg);
 +            vu_message_read_default(dev, dev->slave_fd, &vmsg);
          }
          return;
      }
 diff --git a/tests/vhost-user-bridge.c b/tests/vhost-user-bridge.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/trace-events
+--- a/tests/vhost-user-bridge.c
-+++ b/hw/block/trace-events
++++ b/tests/vhost-user-bridge.c
-@@ -XXX,XX +XXX,XX @@ pflash_write_unknown(const char *name, uint8_t cmd) "%s: unknown command 0x%02x"
+@@ -XXX,XX +XXX,XX @@ vubr_accept_cb(int sock, void *ctx)
- # virtio-blk.c
+                  VHOST_USER_BRIDGE_MAX_QUEUES,
- virtio_blk_req_complete(void *vdev, void *req, int status) "vdev %p req %p status %d"
+                  conn_fd,
- virtio_blk_rw_complete(void *vdev, void *req, int ret) "vdev %p req %p ret %d"
+                  vubr_panic,
-+virtio_blk_zone_report_complete(void *vdev, void *req, unsigned int nr_zones, int ret) "vdev %p req %p nr_zones %u ret %d"
++                 NULL,
-+virtio_blk_zone_mgmt_complete(void *vdev, void *req, int ret) "vdev %p req %p ret %d"
+                  vubr_set_watch,
-+virtio_blk_zone_append_complete(void *vdev, void *req, int64_t sector, int ret) "vdev %p req %p, append sector 0x%" PRIx64 " ret %d"
+                  vubr_remove_watch,
- virtio_blk_handle_write(void *vdev, void *req, uint64_t sector, size_t nsectors) "vdev %p req %p sector %"PRIu64" nsectors %zu"
+                  &vuiface)) {
- virtio_blk_handle_read(void *vdev, void *req, uint64_t sector, size_t nsectors) "vdev %p req %p sector %"PRIu64" nsectors %zu"
+@@ -XXX,XX +XXX,XX @@ vubr_new(const char *path, bool client)
- 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"
+                      VHOST_USER_BRIDGE_MAX_QUEUES,
-+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"
+                      dev->sock,
-+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 ""
+                      vubr_panic,
-+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 ""
++                     NULL,
-+virtio_blk_handle_zone_append(void *vdev, void *req, int64_t sector) "vdev %p req %p, append sector 0x%" PRIx64 ""
+                      vubr_set_watch,
+                      vubr_remove_watch,
- # hd-geometry.c
+                      &vuiface)) {
- hd_geometry_lchs_guess(void *blk, int cyls, int heads, int secs) "blk %p LCHS %d %d %d"
+diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tools/virtiofsd/fuse_virtio.c
 +++ b/tools/virtiofsd/fuse_virtio.c
@@ -XXX,XX +XXX,XX @@ int virtio_session_mount(struct fuse_session *se)
      se->vu_socketfd = data_sock;
      se->virtio_dev->se = se;
      pthread_rwlock_init(&se->virtio_dev->vu_dispatch_rwlock, NULL);
 -    vu_init(&se->virtio_dev->dev, 2, se->vu_socketfd, fv_panic, fv_set_watch,
 -            fv_remove_watch, &fv_iface);
 +    vu_init(&se->virtio_dev->dev, 2, se->vu_socketfd, fv_panic, NULL,
 +            fv_set_watch, fv_remove_watch, &fv_iface);
      return 0;
  }
 --
-.39.2
+.26.2

-New patch
+[PULL v2 03/28] libvhost-user: remove watch for kick_fd when de-initialize vu-dev
+From: Coiby Xu <coiby.xu@gmail.com>
+When the client is running in gdb and quit command is run in gdb,
+QEMU will still dispatch the event which will cause segment fault in
+the callback function.
+Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
+Message-id: 20200918080912.321299-3-coiby.xu@gmail.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ contrib/libvhost-user/libvhost-user.c | 1 +
+file changed, 1 insertion(+)
+diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/libvhost-user.c
+index XXXXXXX..XXXXXXX 100644
+--- a/contrib/libvhost-user/libvhost-user.c
++++ b/contrib/libvhost-user/libvhost-user.c
+@@ -XXX,XX +XXX,XX @@ vu_deinit(VuDev *dev)
+         }
+         if (vq->kick_fd != -1) {
++            dev->remove_watch(dev, vq->kick_fd);
+             close(vq->kick_fd);
+             vq->kick_fd = -1;
+         }
+--
+.26.2

-[PULL 08/20] docs/zoned-storage: add zoned device documentation
+[PULL v2 04/28] util/vhost-user-server: generic vhost user server
-From: Sam Li <faithilikerun@gmail.com>
+From: Coiby Xu <coiby.xu@gmail.com>
-Add the documentation about the zoned device support to virtio-blk
+Sharing QEMU devices via vhost-user protocol.
 emulation.
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Only one vhost-user client can connect to the server one time.
 Suggested-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
+Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
-Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
+Message-id: 20200918080912.321299-4-coiby.xu@gmail.com
-Acked-by: Kevin Wolf <kwolf@redhat.com>
+[Fixed size_t %lu -> %zu format string compiler error.
 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.
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- docs/devel/index-api.rst               |  1 +
+ util/vhost-user-server.h |  65 ++++++
- docs/devel/zoned-storage.rst           | 43 ++++++++++++++++++++++++++
+ util/vhost-user-server.c | 428 +++++++++++++++++++++++++++++++++++++++
- docs/system/qemu-block-drivers.rst.inc |  6 ++++
+ util/meson.build         |   1 +
-files changed, 50 insertions(+)
+files changed, 494 insertions(+)
- create mode 100644 docs/devel/zoned-storage.rst
+ create mode 100644 util/vhost-user-server.h
  create mode 100644 util/vhost-user-server.c
-diff --git a/docs/devel/index-api.rst b/docs/devel/index-api.rst
+diff --git a/util/vhost-user-server.h b/util/vhost-user-server.h
 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
++++ b/util/vhost-user-server.h
 @@ -XXX,XX +XXX,XX @@
-+=============
++/*
-+zoned-storage
++ * Sharing QEMU devices via vhost-user protocol
-+=============
++ *
-+
++ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
-+Zoned Block Devices (ZBDs) divide the LBA space into block regions called zones
++ * Copyright (c) 2020 Red Hat, Inc.
-+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
++ * This work is licensed under the terms of the GNU GPL, version 2 or
-+throughput and increased capacity. More details about ZBDs can be found at:
++ * later.  See the COPYING file in the top-level directory.
-+
++ */
-+https://zonedstorage.io/docs/introduction/zoned-storage
++
-+
++#ifndef VHOST_USER_SERVER_H
-+1. Block layer APIs for zoned storage
++#define VHOST_USER_SERVER_H
-+-------------------------------------
++
-+QEMU block layer supports three zoned storage models:
++#include "contrib/libvhost-user/libvhost-user.h"
-+- BLK_Z_HM: The host-managed zoned model only allows sequential writes access
++#include "io/channel-socket.h"
-+to zones. It supports ZBD-specific I/O commands that can be used by a host to
++#include "io/channel-file.h"
-+manage the zones of a device.
++#include "io/net-listener.h"
-+- BLK_Z_HA: The host-aware zoned model allows random write operations in
++#include "qemu/error-report.h"
-+zones, making it backward compatible with regular block devices.
++#include "qapi/error.h"
-+- BLK_Z_NONE: The non-zoned model has no zones support. It includes both
++#include "standard-headers/linux/virtio_blk.h"
-+regular and drive-managed ZBD devices. ZBD-specific I/O commands are not
++
-+supported.
++typedef struct VuFdWatch {
-+
++    VuDev *vu_dev;
-+The block device information resides inside BlockDriverState. QEMU uses
++    int fd; /*kick fd*/
-+BlockLimits struct(BlockDriverState::bl) that is continuously accessed by the
++    void *pvt;
-+block layer while processing I/O requests. A BlockBackend has a root pointer to
++    vu_watch_cb cb;
-+a BlockDriverState graph(for example, raw format on top of file-posix). The
++    bool processing;
-+zoned storage information can be propagated from the leaf BlockDriverState all
++    QTAILQ_ENTRY(VuFdWatch) next;
-+the way up to the BlockBackend. If the zoned storage model in file-posix is
++} VuFdWatch;
-+set to BLK_Z_HM, then block drivers will declare support for zoned host device.
++
-+
++typedef struct VuServer VuServer;
-+The block layer APIs support commands needed for zoned storage devices,
++typedef void DevicePanicNotifierFn(VuServer *server);
-+including report zones, four zone operations, and zone append.
++
-+
++struct VuServer {
-+2. Emulating zoned storage controllers
++    QIONetListener *listener;
-+--------------------------------------
++    AioContext *ctx;
-+When the BlockBackend's BlockLimits model reports a zoned storage device, users
++    DevicePanicNotifierFn *device_panic_notifier;
-+like the virtio-blk emulation or the qemu-io-cmds.c utility can use block layer
++    int max_queues;
-+APIs for zoned storage emulation or testing.
++    const VuDevIface *vu_iface;
-+
++    VuDev vu_dev;
-+For example, to test zone_report on a null_blk device using qemu-io is:
++    QIOChannel *ioc; /* The I/O channel with the client */
-+$ path/to/qemu-io --image-opts -n driver=host_device,filename=/dev/nullb0
++    QIOChannelSocket *sioc; /* The underlying data channel with the client */
-+-c "zrp offset nr_zones"
++    /* IOChannel for fd provided via VHOST_USER_SET_SLAVE_REQ_FD */
-diff --git a/docs/system/qemu-block-drivers.rst.inc b/docs/system/qemu-block-drivers.rst.inc
++    QIOChannel *ioc_slave;
 +    QIOChannelSocket *sioc_slave;
 +    Coroutine *co_trip; /* coroutine for processing VhostUserMsg */
 +    QTAILQ_HEAD(, VuFdWatch) vu_fd_watches;
 +    /* restart coroutine co_trip if AIOContext is changed */
 +    bool aio_context_changed;
 +    bool processing_msg;
 +};
 +
 +bool vhost_user_server_start(VuServer *server,
 +                             SocketAddress *unix_socket,
 +                             AioContext *ctx,
 +                             uint16_t max_queues,
 +                             DevicePanicNotifierFn *device_panic_notifier,
 +                             const VuDevIface *vu_iface,
 +                             Error **errp);
 +
 +void vhost_user_server_stop(VuServer *server);
 +
 +void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx);
 +
 +#endif /* VHOST_USER_SERVER_H */
 diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/util/vhost-user-server.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * Sharing QEMU devices via vhost-user protocol
 + *
 + * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
 + * Copyright (c) 2020 Red Hat, Inc.
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or
 + * later.  See the COPYING file in the top-level directory.
 + */
 +#include "qemu/osdep.h"
 +#include "qemu/main-loop.h"
 +#include "vhost-user-server.h"
 +
 +static void vmsg_close_fds(VhostUserMsg *vmsg)
 +{
 +    int i;
 +    for (i = 0; i < vmsg->fd_num; i++) {
 +        close(vmsg->fds[i]);
 +    }
 +}
 +
 +static void vmsg_unblock_fds(VhostUserMsg *vmsg)
 +{
 +    int i;
 +    for (i = 0; i < vmsg->fd_num; i++) {
 +        qemu_set_nonblock(vmsg->fds[i]);
 +    }
 +}
 +
 +static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
 +                      gpointer opaque);
 +
 +static void close_client(VuServer *server)
 +{
 +    /*
 +     * Before closing the client
 +     *
 +     * 1. Let vu_client_trip stop processing new vhost-user msg
 +     *
 +     * 2. remove kick_handler
 +     *
 +     * 3. wait for the kick handler to be finished
 +     *
 +     * 4. wait for the current vhost-user msg to be finished processing
 +     */
 +
 +    QIOChannelSocket *sioc = server->sioc;
 +    /* When this is set vu_client_trip will stop new processing vhost-user message */
 +    server->sioc = NULL;
 +
 +    VuFdWatch *vu_fd_watch, *next;
 +    QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
 +        aio_set_fd_handler(server->ioc->ctx, vu_fd_watch->fd, true, NULL,
 +                           NULL, NULL, NULL);
 +    }
 +
 +    while (!QTAILQ_EMPTY(&server->vu_fd_watches)) {
 +        QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
 +            if (!vu_fd_watch->processing) {
 +                QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next);
 +                g_free(vu_fd_watch);
 +            }
 +        }
 +    }
 +
 +    while (server->processing_msg) {
 +        if (server->ioc->read_coroutine) {
 +            server->ioc->read_coroutine = NULL;
 +            qio_channel_set_aio_fd_handler(server->ioc, server->ioc->ctx, NULL,
 +                                           NULL, server->ioc);
 +            server->processing_msg = false;
 +        }
 +    }
 +
 +    vu_deinit(&server->vu_dev);
 +    object_unref(OBJECT(sioc));
 +    object_unref(OBJECT(server->ioc));
 +}
 +
 +static void panic_cb(VuDev *vu_dev, const char *buf)
 +{
 +    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 +
 +    /* avoid while loop in close_client */
 +    server->processing_msg = false;
 +
 +    if (buf) {
 +        error_report("vu_panic: %s", buf);
 +    }
 +
 +    if (server->sioc) {
 +        close_client(server);
 +    }
 +
 +    if (server->device_panic_notifier) {
 +        server->device_panic_notifier(server);
 +    }
 +
 +    /*
 +     * Set the callback function for network listener so another
 +     * vhost-user client can connect to this server
 +     */
 +    qio_net_listener_set_client_func(server->listener,
 +                                     vu_accept,
 +                                     server,
 +                                     NULL);
 +}
 +
 +static bool coroutine_fn
 +vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg)
 +{
 +    struct iovec iov = {
 +        .iov_base = (char *)vmsg,
 +        .iov_len = VHOST_USER_HDR_SIZE,
 +    };
 +    int rc, read_bytes = 0;
 +    Error *local_err = NULL;
 +    /*
 +     * Store fds/nfds returned from qio_channel_readv_full into
 +     * temporary variables.
 +     *
 +     * VhostUserMsg is a packed structure, gcc will complain about passing
 +     * pointer to a packed structure member if we pass &VhostUserMsg.fd_num
 +     * and &VhostUserMsg.fds directly when calling qio_channel_readv_full,
 +     * thus two temporary variables nfds and fds are used here.
 +     */
 +    size_t nfds = 0, nfds_t = 0;
 +    const size_t max_fds = G_N_ELEMENTS(vmsg->fds);
 +    int *fds_t = NULL;
 +    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 +    QIOChannel *ioc = server->ioc;
 +
 +    if (!ioc) {
 +        error_report_err(local_err);
 +        goto fail;
 +    }
 +
 +    assert(qemu_in_coroutine());
 +    do {
 +        /*
 +         * qio_channel_readv_full may have short reads, keeping calling it
 +         * until getting VHOST_USER_HDR_SIZE or 0 bytes in total
 +         */
 +        rc = qio_channel_readv_full(ioc, &iov, 1, &fds_t, &nfds_t, &local_err);
 +        if (rc < 0) {
 +            if (rc == QIO_CHANNEL_ERR_BLOCK) {
 +                qio_channel_yield(ioc, G_IO_IN);
 +                continue;
 +            } else {
 +                error_report_err(local_err);
 +                return false;
 +            }
 +        }
 +        read_bytes += rc;
 +        if (nfds_t > 0) {
 +            if (nfds + nfds_t > max_fds) {
 +                error_report("A maximum of %zu fds are allowed, "
 +                             "however got %zu fds now",
 +                             max_fds, nfds + nfds_t);
 +                goto fail;
 +            }
 +            memcpy(vmsg->fds + nfds, fds_t,
 +                   nfds_t *sizeof(vmsg->fds[0]));
 +            nfds += nfds_t;
 +            g_free(fds_t);
 +        }
 +        if (read_bytes == VHOST_USER_HDR_SIZE || rc == 0) {
 +            break;
 +        }
 +        iov.iov_base = (char *)vmsg + read_bytes;
 +        iov.iov_len = VHOST_USER_HDR_SIZE - read_bytes;
 +    } while (true);
 +
 +    vmsg->fd_num = nfds;
 +    /* qio_channel_readv_full will make socket fds blocking, unblock them */
 +    vmsg_unblock_fds(vmsg);
 +    if (vmsg->size > sizeof(vmsg->payload)) {
 +        error_report("Error: too big message request: %d, "
 +                     "size: vmsg->size: %u, "
 +                     "while sizeof(vmsg->payload) = %zu",
 +                     vmsg->request, vmsg->size, sizeof(vmsg->payload));
 +        goto fail;
 +    }
 +
 +    struct iovec iov_payload = {
 +        .iov_base = (char *)&vmsg->payload,
 +        .iov_len = vmsg->size,
 +    };
 +    if (vmsg->size) {
 +        rc = qio_channel_readv_all_eof(ioc, &iov_payload, 1, &local_err);
 +        if (rc == -1) {
 +            error_report_err(local_err);
 +            goto fail;
 +        }
 +    }
 +
 +    return true;
 +
 +fail:
 +    vmsg_close_fds(vmsg);
 +
 +    return false;
 +}
 +
 +
 +static void vu_client_start(VuServer *server);
 +static coroutine_fn void vu_client_trip(void *opaque)
 +{
 +    VuServer *server = opaque;
 +
 +    while (!server->aio_context_changed && server->sioc) {
 +        server->processing_msg = true;
 +        vu_dispatch(&server->vu_dev);
 +        server->processing_msg = false;
 +    }
 +
 +    if (server->aio_context_changed && server->sioc) {
 +        server->aio_context_changed = false;
 +        vu_client_start(server);
 +    }
 +}
 +
 +static void vu_client_start(VuServer *server)
 +{
 +    server->co_trip = qemu_coroutine_create(vu_client_trip, server);
 +    aio_co_enter(server->ctx, server->co_trip);
 +}
 +
 +/*
 + * a wrapper for vu_kick_cb
 + *
 + * since aio_dispatch can only pass one user data pointer to the
 + * callback function, pack VuDev and pvt into a struct. Then unpack it
 + * and pass them to vu_kick_cb
 + */
 +static void kick_handler(void *opaque)
 +{
 +    VuFdWatch *vu_fd_watch = opaque;
 +    vu_fd_watch->processing = true;
 +    vu_fd_watch->cb(vu_fd_watch->vu_dev, 0, vu_fd_watch->pvt);
 +    vu_fd_watch->processing = false;
 +}
 +
 +
 +static VuFdWatch *find_vu_fd_watch(VuServer *server, int fd)
 +{
 +
 +    VuFdWatch *vu_fd_watch, *next;
 +    QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
 +        if (vu_fd_watch->fd == fd) {
 +            return vu_fd_watch;
 +        }
 +    }
 +    return NULL;
 +}
 +
 +static void
 +set_watch(VuDev *vu_dev, int fd, int vu_evt,
 +          vu_watch_cb cb, void *pvt)
 +{
 +
 +    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 +    g_assert(vu_dev);
 +    g_assert(fd >= 0);
 +    g_assert(cb);
 +
 +    VuFdWatch *vu_fd_watch = find_vu_fd_watch(server, fd);
 +
 +    if (!vu_fd_watch) {
 +        VuFdWatch *vu_fd_watch = g_new0(VuFdWatch, 1);
 +
 +        QTAILQ_INSERT_TAIL(&server->vu_fd_watches, vu_fd_watch, next);
 +
 +        vu_fd_watch->fd = fd;
 +        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);
 +        vu_fd_watch->vu_dev = vu_dev;
 +        vu_fd_watch->pvt = pvt;
 +    }
 +}
 +
 +
 +static void remove_watch(VuDev *vu_dev, int fd)
 +{
 +    VuServer *server;
 +    g_assert(vu_dev);
 +    g_assert(fd >= 0);
 +
 +    server = container_of(vu_dev, VuServer, vu_dev);
 +
 +    VuFdWatch *vu_fd_watch = find_vu_fd_watch(server, fd);
 +
 +    if (!vu_fd_watch) {
 +        return;
 +    }
 +    aio_set_fd_handler(server->ioc->ctx, fd, true, NULL, NULL, NULL, NULL);
 +
 +    QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next);
 +    g_free(vu_fd_watch);
 +}
 +
 +
 +static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
 +                      gpointer opaque)
 +{
 +    VuServer *server = opaque;
 +
 +    if (server->sioc) {
 +        warn_report("Only one vhost-user client is allowed to "
 +                    "connect the server one time");
 +        return;
 +    }
 +
 +    if (!vu_init(&server->vu_dev, server->max_queues, sioc->fd, panic_cb,
 +                 vu_message_read, set_watch, remove_watch, server->vu_iface)) {
 +        error_report("Failed to initialize libvhost-user");
 +        return;
 +    }
 +
 +    /*
 +     * Unset the callback function for network listener to make another
 +     * vhost-user client keeping waiting until this client disconnects
 +     */
 +    qio_net_listener_set_client_func(server->listener,
 +                                     NULL,
 +                                     NULL,
 +                                     NULL);
 +    server->sioc = sioc;
 +    /*
 +     * Increase the object reference, so sioc will not freed by
 +     * qio_net_listener_channel_func which will call object_unref(OBJECT(sioc))
 +     */
 +    object_ref(OBJECT(server->sioc));
 +    qio_channel_set_name(QIO_CHANNEL(sioc), "vhost-user client");
 +    server->ioc = QIO_CHANNEL(sioc);
 +    object_ref(OBJECT(server->ioc));
 +    qio_channel_attach_aio_context(server->ioc, server->ctx);
 +    qio_channel_set_blocking(QIO_CHANNEL(server->sioc), false, NULL);
 +    vu_client_start(server);
 +}
 +
 +
 +void vhost_user_server_stop(VuServer *server)
 +{
 +    if (server->sioc) {
 +        close_client(server);
 +    }
 +
 +    if (server->listener) {
 +        qio_net_listener_disconnect(server->listener);
 +        object_unref(OBJECT(server->listener));
 +    }
 +
 +}
 +
 +void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx)
 +{
 +    VuFdWatch *vu_fd_watch, *next;
 +    void *opaque = NULL;
 +    IOHandler *io_read = NULL;
 +    bool attach;
 +
 +    server->ctx = ctx ? ctx : qemu_get_aio_context();
 +
 +    if (!server->sioc) {
 +        /* not yet serving any client*/
 +        return;
 +    }
 +
 +    if (ctx) {
 +        qio_channel_attach_aio_context(server->ioc, ctx);
 +        server->aio_context_changed = true;
 +        io_read = kick_handler;
 +        attach = true;
 +    } else {
 +        qio_channel_detach_aio_context(server->ioc);
 +        /* server->ioc->ctx keeps the old AioConext */
 +        ctx = server->ioc->ctx;
 +        attach = false;
 +    }
 +
 +    QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
 +        if (vu_fd_watch->cb) {
 +            opaque = attach ? vu_fd_watch : NULL;
 +            aio_set_fd_handler(ctx, vu_fd_watch->fd, true,
 +                               io_read, NULL, NULL,
 +                               opaque);
 +        }
 +    }
 +}
 +
 +
 +bool vhost_user_server_start(VuServer *server,
 +                             SocketAddress *socket_addr,
 +                             AioContext *ctx,
 +                             uint16_t max_queues,
 +                             DevicePanicNotifierFn *device_panic_notifier,
 +                             const VuDevIface *vu_iface,
 +                             Error **errp)
 +{
 +    QIONetListener *listener = qio_net_listener_new();
 +    if (qio_net_listener_open_sync(listener, socket_addr, 1,
 +                                   errp) < 0) {
 +        object_unref(OBJECT(listener));
 +        return false;
 +    }
 +
 +    /* zero out unspecified fileds */
 +    *server = (VuServer) {
 +        .listener              = listener,
 +        .vu_iface              = vu_iface,
 +        .max_queues            = max_queues,
 +        .ctx                   = ctx,
 +        .device_panic_notifier = device_panic_notifier,
 +    };
 +
 +    qio_net_listener_set_name(server->listener, "vhost-user-backend-listener");
 +
 +    qio_net_listener_set_client_func(server->listener,
 +                                     vu_accept,
 +                                     server,
 +                                     NULL);
 +
 +    QTAILQ_INIT(&server->vu_fd_watches);
 +    return true;
 +}
 diff --git a/util/meson.build b/util/meson.build
 index XXXXXXX..XXXXXXX 100644
---- a/docs/system/qemu-block-drivers.rst.inc
+--- a/util/meson.build
-+++ b/docs/system/qemu-block-drivers.rst.inc
++++ b/util/meson.build
-@@ -XXX,XX +XXX,XX @@ Hard disks
+@@ -XXX,XX +XXX,XX @@ if have_block
-   you may corrupt your host data (use the ``-snapshot`` command
+   util_ss.add(files('main-loop.c'))
-   line option or modify the device permissions accordingly).
+   util_ss.add(files('nvdimm-utils.c'))
+   util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c'))
-+Zoned block devices
++  util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c'))
-+  Zoned block devices can be passed through to the guest if the emulated storage
+   util_ss.add(files('qemu-coroutine-sleep.c'))
-+  controller supports zoned storage. Use ``--blockdev host_device,
+   util_ss.add(files('qemu-co-shared-resource.c'))
-+  node-name=drive0,filename=/dev/nullb0,cache.direct=on`` to pass through
+   util_ss.add(files('thread-pool.c', 'qemu-timer.c'))
 +  ``/dev/nullb0`` as ``drive0``.
 +
  Windows
  ^^^^^^^
 --
-.39.2
+.26.2

-[PULL 05/20] block: add zoned BlockDriver check to block layer
+[PULL v2 05/28] block: move logical block size check function to a common utility function
-From: Sam Li <faithilikerun@gmail.com>
+From: Coiby Xu <coiby.xu@gmail.com>
-Putting zoned/non-zoned BlockDrivers on top of each other is not
+Move the constants from hw/core/qdev-properties.c to
-allowed.
+util/block-helpers.h so that knowledge of the min/max values is
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Hannes Reinecke <hare@suse.de>
+Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
-Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
+Acked-by: Eduardo Habkost <ehabkost@redhat.com>
-Acked-by: Kevin Wolf <kwolf@redhat.com>
+Message-id: 20200918080912.321299-5-coiby.xu@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 +++++
+ util/block-helpers.h             | 19 +++++++++++++
- block.c                          | 19 +++++++++++++++++++
+ hw/core/qdev-properties-system.c | 31 ++++-----------------
- block/file-posix.c               | 12 ++++++++++++
+ util/block-helpers.c             | 46 ++++++++++++++++++++++++++++++++
- block/raw-format.c               |  1 +
+ util/meson.build                 |  1 +
-files changed, 37 insertions(+)
+files changed, 71 insertions(+), 26 deletions(-)
  create mode 100644 util/block-helpers.h
  create mode 100644 util/block-helpers.c
-diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
+diff --git a/util/block-helpers.h b/util/block-helpers.h
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/util/block-helpers.h
@@ -XXX,XX +XXX,XX @@
 +#ifndef BLOCK_HELPERS_H
 +#define BLOCK_HELPERS_H
 +
 +#include "qemu/units.h"
 +
 +/* lower limit is sector size */
 +#define MIN_BLOCK_SIZE          INT64_C(512)
 +#define MIN_BLOCK_SIZE_STR      "512 B"
 +/*
 + * upper limit is arbitrary, 2 MiB looks sufficient for all sensible uses, and
 + * matches qcow2 cluster size limit
 + */
 +#define MAX_BLOCK_SIZE          (2 * MiB)
 +#define MAX_BLOCK_SIZE_STR      "2 MiB"
 +
 +void check_block_size(const char *id, const char *name, int64_t value,
 +                      Error **errp);
 +
 +#endif /* BLOCK_HELPERS_H */
 diff --git a/hw/core/qdev-properties-system.c b/hw/core/qdev-properties-system.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/block_int-common.h
+--- a/hw/core/qdev-properties-system.c
-+++ b/include/block/block_int-common.h
++++ b/hw/core/qdev-properties-system.c
-@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
+@@ -XXX,XX +XXX,XX @@
-      */
+ #include "sysemu/blockdev.h"
-     bool is_format;
+ #include "net/net.h"
+ #include "hw/pci/pci.h"
-+    /*
++#include "util/block-helpers.h"
-+     * Set to true if the BlockDriver supports zoned children.
-+     */
+ static bool check_prop_still_unset(DeviceState *dev, const char *name,
-+    bool supports_zoned_children;
+                                    const void *old_val, const char *new_val,
-+
+@@ -XXX,XX +XXX,XX @@ const PropertyInfo qdev_prop_losttickpolicy = {
-     /*
-      * Drivers not implementing bdrv_parse_filename nor bdrv_open should have
+ /* --- blocksize --- */
-      * this field set to true, except ones that are defined only by their
-diff --git a/block.c b/block.c
+-/* lower limit is sector size */
-index XXXXXXX..XXXXXXX 100644
+-#define MIN_BLOCK_SIZE          512
---- a/block.c
+-#define MIN_BLOCK_SIZE_STR      "512 B"
-+++ b/block.c
+-/*
-@@ -XXX,XX +XXX,XX @@ void bdrv_add_child(BlockDriverState *parent_bs, BlockDriverState *child_bs,
+- * upper limit is arbitrary, 2 MiB looks sufficient for all sensible uses, and
 - * matches qcow2 cluster size limit
 - */
 -#define MAX_BLOCK_SIZE          (2 * MiB)
 -#define MAX_BLOCK_SIZE_STR      "2 MiB"
 -
  static void set_blocksize(Object *obj, Visitor *v, const char *name,
                            void *opaque, Error **errp)
  {
@@ -XXX,XX +XXX,XX @@ static void set_blocksize(Object *obj, Visitor *v, const char *name,
      Property *prop = opaque;
      uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
      uint64_t value;
 +    Error *local_err = NULL;
      if (dev->realized) {
          qdev_prop_set_after_realize(dev, name, errp);
@@ -XXX,XX +XXX,XX @@ static void set_blocksize(Object *obj, Visitor *v, const char *name,
      if (!visit_type_size(v, name, &value, errp)) {
          return;
      }
+-    /* value of 0 means "unset" */
-+    /*
+-    if (value && (value < MIN_BLOCK_SIZE || value > MAX_BLOCK_SIZE)) {
-+     * Non-zoned block drivers do not follow zoned storage constraints
+-        error_setg(errp,
-+     * (i.e. sequential writes to zones). Refuse mixing zoned and non-zoned
+-                   "Property %s.%s doesn't take value %" PRIu64
-+     * drivers in a graph.
+-                   " (minimum: " MIN_BLOCK_SIZE_STR
-+     */
+-                   ", maximum: " MAX_BLOCK_SIZE_STR ")",
-+    if (!parent_bs->drv->supports_zoned_children &&
+-                   dev->id ? : "", name, value);
-+        child_bs->bl.zoned == BLK_Z_HM) {
++    check_block_size(dev->id ? : "", name, value, &local_err);
-+        /*
++    if (local_err) {
-+         * The host-aware model allows zoned storage constraints and random
++        error_propagate(errp, local_err);
-+         * write. Allow mixing host-aware and non-zoned drivers. Using
+         return;
-+         * host-aware device as a regular device.
+     }
-+         */
+-
-+        error_setg(errp, "Cannot add a %s child to a %s parent",
+-    /* We rely on power-of-2 blocksizes for bitmasks */
-+                   child_bs->bl.zoned == BLK_Z_HM ? "zoned" : "non-zoned",
+-    if ((value & (value - 1)) != 0) {
-+                   parent_bs->drv->supports_zoned_children ?
+-        error_setg(errp,
-+                   "support zoned children" : "not support zoned children");
+-                  "Property %s.%s doesn't take value '%" PRId64 "', "
 -                  "it's not a power of 2", dev->id ?: "", name, (int64_t)value);
 -        return;
 -    }
 -
      *ptr = value;
  }
 diff --git a/util/block-helpers.c b/util/block-helpers.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/util/block-helpers.c
@@ -XXX,XX +XXX,XX @@
 +/*
 + * Block utility functions
 + *
 + * Copyright IBM, Corp. 2011
 + * Copyright (c) 2020 Coiby Xu <coiby.xu@gmail.com>
 + *
 + * This work is licensed under the terms of the GNU GPL, version 2 or later.
 + * See the COPYING file in the top-level directory.
 + */
 +
 +#include "qemu/osdep.h"
 +#include "qapi/error.h"
 +#include "qapi/qmp/qerror.h"
 +#include "block-helpers.h"
 +
 +/**
 + * check_block_size:
 + * @id: The unique ID of the object
 + * @name: The name of the property being validated
 + * @value: The block size in bytes
 + * @errp: A pointer to an area to store an error
 + *
 + * This function checks that the block size meets the following conditions:
 + * 1. At least MIN_BLOCK_SIZE
 + * 2. No larger than MAX_BLOCK_SIZE
 + * 3. A power of 2
 + */
 +void check_block_size(const char *id, const char *name, int64_t value,
 +                      Error **errp)
 +{
 +    /* value of 0 means "unset" */
 +    if (value && (value < MIN_BLOCK_SIZE || value > MAX_BLOCK_SIZE)) {
 +        error_setg(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
 +                   id, name, value, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE);
 +        return;
 +    }
 +
-     if (!QLIST_EMPTY(&child_bs->parents)) {
++    /* We rely on power-of-2 blocksizes for bitmasks */
-         error_setg(errp, "The node %s already has a parent",
++    if ((value & (value - 1)) != 0) {
-                    child_bs->node_name);
++        error_setg(errp,
-diff --git a/block/file-posix.c b/block/file-posix.c
++                   "Property %s.%s doesn't take value '%" PRId64
 +                   "', it's not a power of 2",
 +                   id, name, value);
 +        return;
 +    }
 +}
 diff --git a/util/meson.build b/util/meson.build
 index XXXXXXX..XXXXXXX 100644
---- a/block/file-posix.c
+--- a/util/meson.build
-+++ b/block/file-posix.c
++++ b/util/meson.build
-@@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
+@@ -XXX,XX +XXX,XX @@ if have_block
-             goto fail;
+   util_ss.add(files('nvdimm-utils.c'))
-         }
+   util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c'))
-     }
+   util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c'))
-+#ifdef CONFIG_BLKZONED
++  util_ss.add(files('block-helpers.c'))
-+    /*
+   util_ss.add(files('qemu-coroutine-sleep.c'))
-+     * The kernel page cache does not reliably work for writes to SWR zones
+   util_ss.add(files('qemu-co-shared-resource.c'))
-+     * of zoned block device because it can not guarantee the order of writes.
+   util_ss.add(files('thread-pool.c', 'qemu-timer.c'))
 +     */
 +    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,
 --
-.39.2
+.26.2

-[PULL 06/20] iotests: test new zone operations
+[PULL v2 06/28] block/export: vhost-user block device backend server
-From: Sam Li <faithilikerun@gmail.com>
+From: Coiby Xu <coiby.xu@gmail.com>
-The new block layer APIs of zoned block devices can be tested by:
+By making use of libvhost-user, block device drive can be shared to
-$ tests/qemu-iotests/check zoned
+the connected vhost-user client. Only one client can connect to the
-Run each zone operation on a newly created null_blk device
+server one time.
 and see whether it outputs the same zone information.
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Since vhost-user-server needs a block drive to be created first, delay
 the creation of this object.
 Suggested-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Acked-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
-Message-id: 20230324090605.28361-7-faithilikerun@gmail.com
+Message-id: 20200918080912.321299-6-coiby.xu@gmail.com
-[Adjust commit message prefix as suggested by Philippe Mathieu-Daudé
+[Shorten "vhost_user_blk_server" string to "vhost_user_blk" to avoid the
-<philmd@linaro.org>.
+following compiler warning:
 ../block/export/vhost-user-blk-server.c:178:50: error: ‘%s’ directive output truncated writing 21 bytes into a region of size 20 [-Werror=format-truncation=]
 and fix "Invalid size %ld ..." ssize_t format string arguments for
 -bit hosts.
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/tests/zoned     | 89 ++++++++++++++++++++++++++++++
+ block/export/vhost-user-blk-server.h |  36 ++
- tests/qemu-iotests/tests/zoned.out | 53 ++++++++++++++++++
+ block/export/vhost-user-blk-server.c | 661 +++++++++++++++++++++++++++
-files changed, 142 insertions(+)
+ softmmu/vl.c                         |   4 +
- create mode 100755 tests/qemu-iotests/tests/zoned
+ block/meson.build                    |   1 +
- create mode 100644 tests/qemu-iotests/tests/zoned.out
+files changed, 702 insertions(+)
  create mode 100644 block/export/vhost-user-blk-server.h
  create mode 100644 block/export/vhost-user-blk-server.c
-diff --git a/tests/qemu-iotests/tests/zoned b/tests/qemu-iotests/tests/zoned
+diff --git a/block/export/vhost-user-blk-server.h b/block/export/vhost-user-blk-server.h
 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
++++ b/block/export/vhost-user-blk-server.h
 @@ -XXX,XX +XXX,XX @@
-+QA output created by zoned
++/*
-+Testing a null_blk device:
++ * Sharing QEMU block devices via vhost-user protocal
-+case 1: if the operations work
++ *
-+(1) report the first zone:
++ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
-+start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:1, [type: 2]
++ * Copyright (c) 2020 Red Hat, Inc.
-+
++ *
-+report the first 10 zones
++ * This work is licensed under the terms of the GNU GPL, version 2 or
-+start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:1, [type: 2]
++ * later.  See the COPYING file in the top-level directory.
-+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]
++#ifndef VHOST_USER_BLK_SERVER_H
-+start: 0x200000, len 0x80000, cap 0x80000, wptr 0x200000, zcond:1, [type: 2]
++#define VHOST_USER_BLK_SERVER_H
-+start: 0x280000, len 0x80000, cap 0x80000, wptr 0x280000, zcond:1, [type: 2]
++#include "util/vhost-user-server.h"
-+start: 0x300000, len 0x80000, cap 0x80000, wptr 0x300000, zcond:1, [type: 2]
++
-+start: 0x380000, len 0x80000, cap 0x80000, wptr 0x380000, zcond:1, [type: 2]
++typedef struct VuBlockDev VuBlockDev;
-+start: 0x400000, len 0x80000, cap 0x80000, wptr 0x400000, zcond:1, [type: 2]
++#define TYPE_VHOST_USER_BLK_SERVER "vhost-user-blk-server"
-+start: 0x480000, len 0x80000, cap 0x80000, wptr 0x480000, zcond:1, [type: 2]
++#define VHOST_USER_BLK_SERVER(obj) \
-+
++   OBJECT_CHECK(VuBlockDev, obj, TYPE_VHOST_USER_BLK_SERVER)
-+report the last zone:
++
-+start: 0x1f380000, len 0x80000, cap 0x80000, wptr 0x1f380000, zcond:1, [type: 2]
++/* vhost user block device */
-+
++struct VuBlockDev {
-+
++    Object parent_obj;
-+(2) opening the first zone
++    char *node_name;
-+report after:
++    SocketAddress *addr;
-+start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:3, [type: 2]
++    AioContext *ctx;
-+
++    VuServer vu_server;
-+opening the second zone
++    bool running;
-+report after:
++    uint32_t blk_size;
-+start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80000, zcond:3, [type: 2]
++    BlockBackend *backend;
-+
++    QIOChannelSocket *sioc;
-+opening the last zone
++    QTAILQ_ENTRY(VuBlockDev) next;
-+report after:
++    struct virtio_blk_config blkcfg;
-+start: 0x1f380000, len 0x80000, cap 0x80000, wptr 0x1f380000, zcond:3, [type: 2]
++    bool writable;
-+
++};
 +
-+(3) closing the first zone
++#endif /* VHOST_USER_BLK_SERVER_H */
-+report after:
+diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
-+start: 0x0, len 0x80000, cap 0x80000, wptr 0x0, zcond:1, [type: 2]
+new file mode 100644
-+
+index XXXXXXX..XXXXXXX
-+closing the last zone
+--- /dev/null
-+report after:
++++ b/block/export/vhost-user-blk-server.c
-+start: 0x1f380000, len 0x80000, cap 0x80000, wptr 0x1f380000, zcond:1, [type: 2]
+@@ -XXX,XX +XXX,XX @@
-+
++/*
-+
++ * Sharing QEMU block devices via vhost-user protocal
-+(4) finishing the second zone
++ *
-+After finishing a zone:
++ * Parts of the code based on nbd/server.c.
-+start: 0x80000, len 0x80000, cap 0x80000, wptr 0x100000, zcond:14, [type: 2]
++ *
-+
++ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
-+
++ * Copyright (c) 2020 Red Hat, Inc.
-+(5) resetting the second zone
++ *
-+After resetting a zone:
++ * This work is licensed under the terms of the GNU GPL, version 2 or
-+start: 0x80000, len 0x80000, cap 0x80000, wptr 0x80000, zcond:1, [type: 2]
++ * later.  See the COPYING file in the top-level directory.
-+*** done
++ */
 +#include "qemu/osdep.h"
 +#include "block/block.h"
 +#include "vhost-user-blk-server.h"
 +#include "qapi/error.h"
 +#include "qom/object_interfaces.h"
 +#include "sysemu/block-backend.h"
 +#include "util/block-helpers.h"
 +
 +enum {
 +    VHOST_USER_BLK_MAX_QUEUES = 1,
 +};
 +struct virtio_blk_inhdr {
 +    unsigned char status;
 +};
 +
 +typedef struct VuBlockReq {
 +    VuVirtqElement *elem;
 +    int64_t sector_num;
 +    size_t size;
 +    struct virtio_blk_inhdr *in;
 +    struct virtio_blk_outhdr out;
 +    VuServer *server;
 +    struct VuVirtq *vq;
 +} VuBlockReq;
 +
 +static void vu_block_req_complete(VuBlockReq *req)
 +{
 +    VuDev *vu_dev = &req->server->vu_dev;
 +
 +    /* IO size with 1 extra status byte */
 +    vu_queue_push(vu_dev, req->vq, req->elem, req->size + 1);
 +    vu_queue_notify(vu_dev, req->vq);
 +
 +    if (req->elem) {
 +        free(req->elem);
 +    }
 +
 +    g_free(req);
 +}
 +
 +static VuBlockDev *get_vu_block_device_by_server(VuServer *server)
 +{
 +    return container_of(server, VuBlockDev, vu_server);
 +}
 +
 +static int coroutine_fn
 +vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
 +                              uint32_t iovcnt, uint32_t type)
 +{
 +    struct virtio_blk_discard_write_zeroes desc;
 +    ssize_t size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc));
 +    if (unlikely(size != sizeof(desc))) {
 +        error_report("Invalid size %zd, expect %zu", size, sizeof(desc));
 +        return -EINVAL;
 +    }
 +
 +    VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
 +    uint64_t range[2] = { le64_to_cpu(desc.sector) << 9,
 +                          le32_to_cpu(desc.num_sectors) << 9 };
 +    if (type == VIRTIO_BLK_T_DISCARD) {
 +        if (blk_co_pdiscard(vdev_blk->backend, range[0], range[1]) == 0) {
 +            return 0;
 +        }
 +    } else if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
 +        if (blk_co_pwrite_zeroes(vdev_blk->backend,
 +                                 range[0], range[1], 0) == 0) {
 +            return 0;
 +        }
 +    }
 +
 +    return -EINVAL;
 +}
 +
 +static void coroutine_fn vu_block_flush(VuBlockReq *req)
 +{
 +    VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
 +    BlockBackend *backend = vdev_blk->backend;
 +    blk_co_flush(backend);
 +}
 +
 +struct req_data {
 +    VuServer *server;
 +    VuVirtq *vq;
 +    VuVirtqElement *elem;
 +};
 +
 +static void coroutine_fn vu_block_virtio_process_req(void *opaque)
 +{
 +    struct req_data *data = opaque;
 +    VuServer *server = data->server;
 +    VuVirtq *vq = data->vq;
 +    VuVirtqElement *elem = data->elem;
 +    uint32_t type;
 +    VuBlockReq *req;
 +
 +    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
 +    BlockBackend *backend = vdev_blk->backend;
 +
 +    struct iovec *in_iov = elem->in_sg;
 +    struct iovec *out_iov = elem->out_sg;
 +    unsigned in_num = elem->in_num;
 +    unsigned out_num = elem->out_num;
 +    /* refer to hw/block/virtio_blk.c */
 +    if (elem->out_num < 1 || elem->in_num < 1) {
 +        error_report("virtio-blk request missing headers");
 +        free(elem);
 +        return;
 +    }
 +
 +    req = g_new0(VuBlockReq, 1);
 +    req->server = server;
 +    req->vq = vq;
 +    req->elem = elem;
 +
 +    if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
 +                            sizeof(req->out)) != sizeof(req->out))) {
 +        error_report("virtio-blk request outhdr too short");
 +        goto err;
 +    }
 +
 +    iov_discard_front(&out_iov, &out_num, sizeof(req->out));
 +
 +    if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {
 +        error_report("virtio-blk request inhdr too short");
 +        goto err;
 +    }
 +
 +    /* We always touch the last byte, so just see how big in_iov is.  */
 +    req->in = (void *)in_iov[in_num - 1].iov_base
 +              + in_iov[in_num - 1].iov_len
 +              - sizeof(struct virtio_blk_inhdr);
 +    iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr));
 +
 +    type = le32_to_cpu(req->out.type);
 +    switch (type & ~VIRTIO_BLK_T_BARRIER) {
 +    case VIRTIO_BLK_T_IN:
 +    case VIRTIO_BLK_T_OUT: {
 +        ssize_t ret = 0;
 +        bool is_write = type & VIRTIO_BLK_T_OUT;
 +        req->sector_num = le64_to_cpu(req->out.sector);
 +
 +        int64_t offset = req->sector_num * vdev_blk->blk_size;
 +        QEMUIOVector qiov;
 +        if (is_write) {
 +            qemu_iovec_init_external(&qiov, out_iov, out_num);
 +            ret = blk_co_pwritev(backend, offset, qiov.size,
 +                                 &qiov, 0);
 +        } else {
 +            qemu_iovec_init_external(&qiov, in_iov, in_num);
 +            ret = blk_co_preadv(backend, offset, qiov.size,
 +                                &qiov, 0);
 +        }
 +        if (ret >= 0) {
 +            req->in->status = VIRTIO_BLK_S_OK;
 +        } else {
 +            req->in->status = VIRTIO_BLK_S_IOERR;
 +        }
 +        break;
 +    }
 +    case VIRTIO_BLK_T_FLUSH:
 +        vu_block_flush(req);
 +        req->in->status = VIRTIO_BLK_S_OK;
 +        break;
 +    case VIRTIO_BLK_T_GET_ID: {
 +        size_t size = MIN(iov_size(&elem->in_sg[0], in_num),
 +                          VIRTIO_BLK_ID_BYTES);
 +        snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk");
 +        req->in->status = VIRTIO_BLK_S_OK;
 +        req->size = elem->in_sg[0].iov_len;
 +        break;
 +    }
 +    case VIRTIO_BLK_T_DISCARD:
 +    case VIRTIO_BLK_T_WRITE_ZEROES: {
 +        int rc;
 +        rc = vu_block_discard_write_zeroes(req, &elem->out_sg[1],
 +                                           out_num, type);
 +        if (rc == 0) {
 +            req->in->status = VIRTIO_BLK_S_OK;
 +        } else {
 +            req->in->status = VIRTIO_BLK_S_IOERR;
 +        }
 +        break;
 +    }
 +    default:
 +        req->in->status = VIRTIO_BLK_S_UNSUPP;
 +        break;
 +    }
 +
 +    vu_block_req_complete(req);
 +    return;
 +
 +err:
 +    free(elem);
 +    g_free(req);
 +    return;
 +}
 +
 +static void vu_block_process_vq(VuDev *vu_dev, int idx)
 +{
 +    VuServer *server;
 +    VuVirtq *vq;
 +    struct req_data *req_data;
 +
 +    server = container_of(vu_dev, VuServer, vu_dev);
 +    assert(server);
 +
 +    vq = vu_get_queue(vu_dev, idx);
 +    assert(vq);
 +    VuVirtqElement *elem;
 +    while (1) {
 +        elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) +
 +                                    sizeof(VuBlockReq));
 +        if (elem) {
 +            req_data = g_new0(struct req_data, 1);
 +            req_data->server = server;
 +            req_data->vq = vq;
 +            req_data->elem = elem;
 +            Coroutine *co = qemu_coroutine_create(vu_block_virtio_process_req,
 +                                                  req_data);
 +            aio_co_enter(server->ioc->ctx, co);
 +        } else {
 +            break;
 +        }
 +    }
 +}
 +
 +static void vu_block_queue_set_started(VuDev *vu_dev, int idx, bool started)
 +{
 +    VuVirtq *vq;
 +
 +    assert(vu_dev);
 +
 +    vq = vu_get_queue(vu_dev, idx);
 +    vu_set_queue_handler(vu_dev, vq, started ? vu_block_process_vq : NULL);
 +}
 +
 +static uint64_t vu_block_get_features(VuDev *dev)
 +{
 +    uint64_t features;
 +    VuServer *server = container_of(dev, VuServer, vu_dev);
 +    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
 +    features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
 +               1ull << VIRTIO_BLK_F_SEG_MAX |
 +               1ull << VIRTIO_BLK_F_TOPOLOGY |
 +               1ull << VIRTIO_BLK_F_BLK_SIZE |
 +               1ull << VIRTIO_BLK_F_FLUSH |
 +               1ull << VIRTIO_BLK_F_DISCARD |
 +               1ull << VIRTIO_BLK_F_WRITE_ZEROES |
 +               1ull << VIRTIO_BLK_F_CONFIG_WCE |
 +               1ull << VIRTIO_F_VERSION_1 |
 +               1ull << VIRTIO_RING_F_INDIRECT_DESC |
 +               1ull << VIRTIO_RING_F_EVENT_IDX |
 +               1ull << VHOST_USER_F_PROTOCOL_FEATURES;
 +
 +    if (!vdev_blk->writable) {
 +        features |= 1ull << VIRTIO_BLK_F_RO;
 +    }
 +
 +    return features;
 +}
 +
 +static uint64_t vu_block_get_protocol_features(VuDev *dev)
 +{
 +    return 1ull << VHOST_USER_PROTOCOL_F_CONFIG |
 +           1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD;
 +}
 +
 +static int
 +vu_block_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
 +{
 +    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 +    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
 +    memcpy(config, &vdev_blk->blkcfg, len);
 +
 +    return 0;
 +}
 +
 +static int
 +vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
 +                    uint32_t offset, uint32_t size, uint32_t flags)
 +{
 +    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 +    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
 +    uint8_t wce;
 +
 +    /* don't support live migration */
 +    if (flags != VHOST_SET_CONFIG_TYPE_MASTER) {
 +        return -EINVAL;
 +    }
 +
 +    if (offset != offsetof(struct virtio_blk_config, wce) ||
 +        size != 1) {
 +        return -EINVAL;
 +    }
 +
 +    wce = *data;
 +    vdev_blk->blkcfg.wce = wce;
 +    blk_set_enable_write_cache(vdev_blk->backend, wce);
 +    return 0;
 +}
 +
 +/*
 + * When the client disconnects, it sends a VHOST_USER_NONE request
 + * and vu_process_message will simple call exit which cause the VM
 + * to exit abruptly.
 + * To avoid this issue,  process VHOST_USER_NONE request ahead
 + * of vu_process_message.
 + *
 + */
 +static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
 +{
 +    if (vmsg->request == VHOST_USER_NONE) {
 +        dev->panic(dev, "disconnect");
 +        return true;
 +    }
 +    return false;
 +}
 +
 +static const VuDevIface vu_block_iface = {
 +    .get_features          = vu_block_get_features,
 +    .queue_set_started     = vu_block_queue_set_started,
 +    .get_protocol_features = vu_block_get_protocol_features,
 +    .get_config            = vu_block_get_config,
 +    .set_config            = vu_block_set_config,
 +    .process_msg           = vu_block_process_msg,
 +};
 +
 +static void blk_aio_attached(AioContext *ctx, void *opaque)
 +{
 +    VuBlockDev *vub_dev = opaque;
 +    aio_context_acquire(ctx);
 +    vhost_user_server_set_aio_context(&vub_dev->vu_server, ctx);
 +    aio_context_release(ctx);
 +}
 +
 +static void blk_aio_detach(void *opaque)
 +{
 +    VuBlockDev *vub_dev = opaque;
 +    AioContext *ctx = vub_dev->vu_server.ctx;
 +    aio_context_acquire(ctx);
 +    vhost_user_server_set_aio_context(&vub_dev->vu_server, NULL);
 +    aio_context_release(ctx);
 +}
 +
 +static void
 +vu_block_initialize_config(BlockDriverState *bs,
 +                           struct virtio_blk_config *config, uint32_t blk_size)
 +{
 +    config->capacity = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
 +    config->blk_size = blk_size;
 +    config->size_max = 0;
 +    config->seg_max = 128 - 2;
 +    config->min_io_size = 1;
 +    config->opt_io_size = 1;
 +    config->num_queues = VHOST_USER_BLK_MAX_QUEUES;
 +    config->max_discard_sectors = 32768;
 +    config->max_discard_seg = 1;
 +    config->discard_sector_alignment = config->blk_size >> 9;
 +    config->max_write_zeroes_sectors = 32768;
 +    config->max_write_zeroes_seg = 1;
 +}
 +
 +static VuBlockDev *vu_block_init(VuBlockDev *vu_block_device, Error **errp)
 +{
 +
 +    BlockBackend *blk;
 +    Error *local_error = NULL;
 +    const char *node_name = vu_block_device->node_name;
 +    bool writable = vu_block_device->writable;
 +    uint64_t perm = BLK_PERM_CONSISTENT_READ;
 +    int ret;
 +
 +    AioContext *ctx;
 +
 +    BlockDriverState *bs = bdrv_lookup_bs(node_name, node_name, &local_error);
 +
 +    if (!bs) {
 +        error_propagate(errp, local_error);
 +        return NULL;
 +    }
 +
 +    if (bdrv_is_read_only(bs)) {
 +        writable = false;
 +    }
 +
 +    if (writable) {
 +        perm |= BLK_PERM_WRITE;
 +    }
 +
 +    ctx = bdrv_get_aio_context(bs);
 +    aio_context_acquire(ctx);
 +    bdrv_invalidate_cache(bs, NULL);
 +    aio_context_release(ctx);
 +
 +    /*
 +     * Don't allow resize while the vhost user server is running,
 +     * otherwise we don't care what happens with the node.
 +     */
 +    blk = blk_new(bdrv_get_aio_context(bs), perm,
 +                  BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
 +                  BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD);
 +    ret = blk_insert_bs(blk, bs, errp);
 +
 +    if (ret < 0) {
 +        goto fail;
 +    }
 +
 +    blk_set_enable_write_cache(blk, false);
 +
 +    blk_set_allow_aio_context_change(blk, true);
 +
 +    vu_block_device->blkcfg.wce = 0;
 +    vu_block_device->backend = blk;
 +    if (!vu_block_device->blk_size) {
 +        vu_block_device->blk_size = BDRV_SECTOR_SIZE;
 +    }
 +    vu_block_device->blkcfg.blk_size = vu_block_device->blk_size;
 +    blk_set_guest_block_size(blk, vu_block_device->blk_size);
 +    vu_block_initialize_config(bs, &vu_block_device->blkcfg,
 +                                   vu_block_device->blk_size);
 +    return vu_block_device;
 +
 +fail:
 +    blk_unref(blk);
 +    return NULL;
 +}
 +
 +static void vu_block_deinit(VuBlockDev *vu_block_device)
 +{
 +    if (vu_block_device->backend) {
 +        blk_remove_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
 +                                        blk_aio_detach, vu_block_device);
 +    }
 +
 +    blk_unref(vu_block_device->backend);
 +}
 +
 +static void vhost_user_blk_server_stop(VuBlockDev *vu_block_device)
 +{
 +    vhost_user_server_stop(&vu_block_device->vu_server);
 +    vu_block_deinit(vu_block_device);
 +}
 +
 +static void vhost_user_blk_server_start(VuBlockDev *vu_block_device,
 +                                        Error **errp)
 +{
 +    AioContext *ctx;
 +    SocketAddress *addr = vu_block_device->addr;
 +
 +    if (!vu_block_init(vu_block_device, errp)) {
 +        return;
 +    }
 +
 +    ctx = bdrv_get_aio_context(blk_bs(vu_block_device->backend));
 +
 +    if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx,
 +                                 VHOST_USER_BLK_MAX_QUEUES,
 +                                 NULL, &vu_block_iface,
 +                                 errp)) {
 +        goto error;
 +    }
 +
 +    blk_add_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
 +                                 blk_aio_detach, vu_block_device);
 +    vu_block_device->running = true;
 +    return;
 +
 + error:
 +    vu_block_deinit(vu_block_device);
 +}
 +
 +static bool vu_prop_modifiable(VuBlockDev *vus, Error **errp)
 +{
 +    if (vus->running) {
 +            error_setg(errp, "The property can't be modified "
 +                       "while the server is running");
 +            return false;
 +    }
 +    return true;
 +}
 +
 +static void vu_set_node_name(Object *obj, const char *value, Error **errp)
 +{
 +    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 +
 +    if (!vu_prop_modifiable(vus, errp)) {
 +        return;
 +    }
 +
 +    if (vus->node_name) {
 +        g_free(vus->node_name);
 +    }
 +
 +    vus->node_name = g_strdup(value);
 +}
 +
 +static char *vu_get_node_name(Object *obj, Error **errp)
 +{
 +    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 +    return g_strdup(vus->node_name);
 +}
 +
 +static void free_socket_addr(SocketAddress *addr)
 +{
 +        g_free(addr->u.q_unix.path);
 +        g_free(addr);
 +}
 +
 +static void vu_set_unix_socket(Object *obj, const char *value,
 +                               Error **errp)
 +{
 +    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 +
 +    if (!vu_prop_modifiable(vus, errp)) {
 +        return;
 +    }
 +
 +    if (vus->addr) {
 +        free_socket_addr(vus->addr);
 +    }
 +
 +    SocketAddress *addr = g_new0(SocketAddress, 1);
 +    addr->type = SOCKET_ADDRESS_TYPE_UNIX;
 +    addr->u.q_unix.path = g_strdup(value);
 +    vus->addr = addr;
 +}
 +
 +static char *vu_get_unix_socket(Object *obj, Error **errp)
 +{
 +    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 +    return g_strdup(vus->addr->u.q_unix.path);
 +}
 +
 +static bool vu_get_block_writable(Object *obj, Error **errp)
 +{
 +    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 +    return vus->writable;
 +}
 +
 +static void vu_set_block_writable(Object *obj, bool value, Error **errp)
 +{
 +    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 +
 +    if (!vu_prop_modifiable(vus, errp)) {
 +            return;
 +    }
 +
 +    vus->writable = value;
 +}
 +
 +static void vu_get_blk_size(Object *obj, Visitor *v, const char *name,
 +                            void *opaque, Error **errp)
 +{
 +    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 +    uint32_t value = vus->blk_size;
 +
 +    visit_type_uint32(v, name, &value, errp);
 +}
 +
 +static void vu_set_blk_size(Object *obj, Visitor *v, const char *name,
 +                            void *opaque, Error **errp)
 +{
 +    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 +
 +    Error *local_err = NULL;
 +    uint32_t value;
 +
 +    if (!vu_prop_modifiable(vus, errp)) {
 +            return;
 +    }
 +
 +    visit_type_uint32(v, name, &value, &local_err);
 +    if (local_err) {
 +        goto out;
 +    }
 +
 +    check_block_size(object_get_typename(obj), name, value, &local_err);
 +    if (local_err) {
 +        goto out;
 +    }
 +
 +    vus->blk_size = value;
 +
 +out:
 +    error_propagate(errp, local_err);
 +}
 +
 +static void vhost_user_blk_server_instance_finalize(Object *obj)
 +{
 +    VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
 +
 +    vhost_user_blk_server_stop(vub);
 +
 +    /*
 +     * Unlike object_property_add_str, object_class_property_add_str
 +     * doesn't have a release method. Thus manual memory freeing is
 +     * needed.
 +     */
 +    free_socket_addr(vub->addr);
 +    g_free(vub->node_name);
 +}
 +
 +static void vhost_user_blk_server_complete(UserCreatable *obj, Error **errp)
 +{
 +    VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
 +
 +    vhost_user_blk_server_start(vub, errp);
 +}
 +
 +static void vhost_user_blk_server_class_init(ObjectClass *klass,
 +                                             void *class_data)
 +{
 +    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
 +    ucc->complete = vhost_user_blk_server_complete;
 +
 +    object_class_property_add_bool(klass, "writable",
 +                                   vu_get_block_writable,
 +                                   vu_set_block_writable);
 +
 +    object_class_property_add_str(klass, "node-name",
 +                                  vu_get_node_name,
 +                                  vu_set_node_name);
 +
 +    object_class_property_add_str(klass, "unix-socket",
 +                                  vu_get_unix_socket,
 +                                  vu_set_unix_socket);
 +
 +    object_class_property_add(klass, "logical-block-size", "uint32",
 +                              vu_get_blk_size, vu_set_blk_size,
 +                              NULL, NULL);
 +}
 +
 +static const TypeInfo vhost_user_blk_server_info = {
 +    .name = TYPE_VHOST_USER_BLK_SERVER,
 +    .parent = TYPE_OBJECT,
 +    .instance_size = sizeof(VuBlockDev),
 +    .instance_finalize = vhost_user_blk_server_instance_finalize,
 +    .class_init = vhost_user_blk_server_class_init,
 +    .interfaces = (InterfaceInfo[]) {
 +        {TYPE_USER_CREATABLE},
 +        {}
 +    },
 +};
 +
 +static void vhost_user_blk_server_register_types(void)
 +{
 +    type_register_static(&vhost_user_blk_server_info);
 +}
 +
 +type_init(vhost_user_blk_server_register_types)
 diff --git a/softmmu/vl.c b/softmmu/vl.c
 index XXXXXXX..XXXXXXX 100644
 --- a/softmmu/vl.c
 +++ b/softmmu/vl.c
@@ -XXX,XX +XXX,XX @@ static bool object_create_initial(const char *type, QemuOpts *opts)
      }
  #endif
 +    /* Reason: vhost-user-blk-server property "node-name" */
 +    if (g_str_equal(type, "vhost-user-blk-server")) {
 +        return false;
 +    }
      /*
       * Reason: filter-* property "netdev" etc.
       */
 diff --git a/block/meson.build b/block/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/block/meson.build
 +++ b/block/meson.build
@@ -XXX,XX +XXX,XX @@ block_ss.add(when: 'CONFIG_WIN32', if_true: files('file-win32.c', 'win32-aio.c')
  block_ss.add(when: 'CONFIG_POSIX', if_true: [files('file-posix.c'), coref, iokit])
  block_ss.add(when: 'CONFIG_LIBISCSI', if_true: files('iscsi-opts.c'))
  block_ss.add(when: 'CONFIG_LINUX', if_true: files('nvme.c'))
 +block_ss.add(when: 'CONFIG_LINUX', if_true: files('export/vhost-user-blk-server.c', '../contrib/libvhost-user/libvhost-user.c'))
  block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
  block_ss.add(when: 'CONFIG_SHEEPDOG', if_true: files('sheepdog.c'))
  block_ss.add(when: ['CONFIG_LINUX_AIO', libaio], if_true: files('linux-aio.c'))
 --
-.39.2
+.26.2

-[PULL 19/20] docs/zoned-storage:add zoned emulation use case
+[PULL v2 07/28] MAINTAINERS: Add vhost-user block device backend server maintainer
-From: Sam Li <faithilikerun@gmail.com>
+From: Coiby Xu <coiby.xu@gmail.com>
-Add the documentation about the example of using virtio-blk driver
+Suggested-by: Stefano Garzarella <sgarzare@redhat.com>
-to pass the zoned block devices through to the guest.
+Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
-Message-id: 20230407082528.18841-6-faithilikerun@gmail.com
+Message-id: 20200918080912.321299-8-coiby.xu@gmail.com
-[Fix Sphinx indentation error by turning command-lines into
+[Removed reference to vhost-user-blk-test.c, it will be sent in a
-pre-formatted text.
+separate pull request.
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- docs/devel/zoned-storage.rst | 25 ++++++++++++++++++++++---
+ MAINTAINERS | 7 +++++++
-file changed, 22 insertions(+), 3 deletions(-)
+file changed, 7 insertions(+)
-diff --git a/docs/devel/zoned-storage.rst b/docs/devel/zoned-storage.rst
+diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
---- a/docs/devel/zoned-storage.rst
+--- a/MAINTAINERS
-+++ b/docs/devel/zoned-storage.rst
++++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ When the BlockBackend's BlockLimits model reports a zoned storage device, users
+@@ -XXX,XX +XXX,XX @@ L: qemu-block@nongnu.org
- like the virtio-blk emulation or the qemu-io-cmds.c utility can use block layer
+ S: Supported
- APIs for zoned storage emulation or testing.
+ F: tests/image-fuzzer/
--For example, to test zone_report on a null_blk device using qemu-io is:
++Vhost-user block device backend server
--$ path/to/qemu-io --image-opts -n driver=host_device,filename=/dev/nullb0
++M: Coiby Xu <Coiby.Xu@gmail.com>
---c "zrp offset nr_zones"
++S: Maintained
-+For example, to test zone_report on a null_blk device using qemu-io is::
++F: block/export/vhost-user-blk-server.c
 +F: util/vhost-user-server.c
 +F: tests/qtest/libqos/vhost-user-blk.c
 +
-+  $ path/to/qemu-io --image-opts -n driver=host_device,filename=/dev/nullb0 -c "zrp offset nr_zones"
+ Replication
-+
+ M: Wen Congyang <wencongyang2@huawei.com>
-+To expose the host's zoned block device through virtio-blk, the command line
+ M: Xie Changlong <xiechanglong.d@gmail.com>
 +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.
 --
-.39.2
+.26.2

-New patch
+[PULL v2 08/28] util/vhost-user-server: s/fileds/fields/ typo fix
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200924151549.913737-3-stefanha@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ util/vhost-user-server.c | 2 +-
+file changed, 1 insertion(+), 1 deletion(-)
+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 @@ bool vhost_user_server_start(VuServer *server,
+         return false;
+     }
+-    /* zero out unspecified fileds */
++    /* zero out unspecified fields */
+     *server = (VuServer) {
+         .listener              = listener,
+         .vu_iface              = vu_iface,
+--
+.26.2

-[PULL 20/20] tracing: install trace events file only if necessary
+[PULL v2 09/28] util/vhost-user-server: drop unnecessary QOM cast
-From: Carlos Santos <casantos@redhat.com>
+We already have access to the value with the correct type (ioc and sioc
 are the same QIOChannel).
-It is not useful when configuring with --enable-trace-backends=nop.
-Signed-off-by: Carlos Santos <casantos@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-Id: <20230408010410.281263-1-casantos@redhat.com>
+Message-id: 20200924151549.913737-4-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- trace/meson.build | 2 +-
+ util/vhost-user-server.c | 2 +-
 file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/trace/meson.build b/trace/meson.build
+diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
 index XXXXXXX..XXXXXXX 100644
---- a/trace/meson.build
+--- a/util/vhost-user-server.c
-+++ b/trace/meson.build
++++ b/util/vhost-user-server.c
-@@ -XXX,XX +XXX,XX @@ trace_events_all = custom_target('trace-events-all',
+@@ -XXX,XX +XXX,XX @@ static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
-                                  input: trace_events_files,
+     server->ioc = QIO_CHANNEL(sioc);
-                                  command: [ 'cat', '@INPUT@' ],
+     object_ref(OBJECT(server->ioc));
-                                  capture: true,
+     qio_channel_attach_aio_context(server->ioc, server->ctx);
--                                 install: true,
+-    qio_channel_set_blocking(QIO_CHANNEL(server->sioc), false, NULL);
-+                                 install: get_option('trace_backends') != [ 'nop' ],
++    qio_channel_set_blocking(server->ioc, false, NULL);
-                                  install_dir: qemu_datadir)
+     vu_client_start(server);
+ }
- if 'ust' in get_option('trace_backends')
 --
-.39.2
+.26.2

-New patch
+[PULL v2 10/28] util/vhost-user-server: drop unnecessary watch deletion
+Explicitly deleting watches is not necessary since libvhost-user calls
+remove_watch() during vu_deinit(). Add an assertion to check this
+though.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200924151549.913737-5-stefanha@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ util/vhost-user-server.c | 19 ++++---------------
+file changed, 4 insertions(+), 15 deletions(-)
+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 @@ static void close_client(VuServer *server)
+     /* When this is set vu_client_trip will stop new processing vhost-user message */
+     server->sioc = NULL;
+-    VuFdWatch *vu_fd_watch, *next;
+-    QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
+-        aio_set_fd_handler(server->ioc->ctx, vu_fd_watch->fd, true, NULL,
+-                           NULL, NULL, NULL);
+-    }
+-
+-    while (!QTAILQ_EMPTY(&server->vu_fd_watches)) {
+-        QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
+-            if (!vu_fd_watch->processing) {
+-                QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next);
+-                g_free(vu_fd_watch);
+-            }
+-        }
+-    }
+-
+     while (server->processing_msg) {
+         if (server->ioc->read_coroutine) {
+             server->ioc->read_coroutine = NULL;
+@@ -XXX,XX +XXX,XX @@ static void close_client(VuServer *server)
+     }
+     vu_deinit(&server->vu_dev);
++
++    /* vu_deinit() should have called remove_watch() */
++    assert(QTAILQ_EMPTY(&server->vu_fd_watches));
++
+     object_unref(OBJECT(sioc));
+     object_unref(OBJECT(server->ioc));
+ }
+--
+.26.2

-[PULL 16/20] virtio-blk: add zoned storage emulation for zoned devices
+[PULL v2 11/28] block/export: consolidate request structs into VuBlockReq
-From: Sam Li <faithilikerun@gmail.com>
+Only one struct is needed per request. Drop req_data and the separate
 VuBlockReq instance. Instead let vu_queue_pop() allocate everything at
 once.
-This patch extends virtio-blk emulation to handle zoned device commands
+This fixes the req_data memory leak in vu_block_virtio_process_req().
 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
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-support zoned block devices. Regular block devices(conventional zones)
+Message-id: 20200924151549.913737-6-stefanha@redhat.com
 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>
 Message-id: 20230407082528.18841-3-faithilikerun@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- hw/block/virtio-blk-common.c |   2 +
+ block/export/vhost-user-blk-server.c | 68 +++++++++-------------------
- hw/block/virtio-blk.c        | 389 +++++++++++++++++++++++++++++++++++
+file changed, 21 insertions(+), 47 deletions(-)
  hw/virtio/virtio-qmp.c       |   2 +
 files changed, 393 insertions(+)
-diff --git a/hw/block/virtio-blk-common.c b/hw/block/virtio-blk-common.c
+diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/virtio-blk-common.c
+--- a/block/export/vhost-user-blk-server.c
-+++ b/hw/block/virtio-blk-common.c
++++ b/block/export/vhost-user-blk-server.c
-@@ -XXX,XX +XXX,XX @@ static const VirtIOFeature feature_sizes[] = {
+@@ -XXX,XX +XXX,XX @@ struct virtio_blk_inhdr {
       .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
+ typedef struct VuBlockReq {
-index XXXXXXX..XXXXXXX 100644
+-    VuVirtqElement *elem;
---- a/hw/block/virtio-blk.c
++    VuVirtqElement elem;
-+++ b/hw/block/virtio-blk.c
+     int64_t sector_num;
-@@ -XXX,XX +XXX,XX @@
+     size_t size;
- #include "qemu/module.h"
+     struct virtio_blk_inhdr *in;
- #include "qemu/error-report.h"
+@@ -XXX,XX +XXX,XX @@ static void vu_block_req_complete(VuBlockReq *req)
- #include "qemu/main-loop.h"
+     VuDev *vu_dev = &req->server->vu_dev;
-+#include "block/block_int.h"
- #include "trace.h"
+     /* IO size with 1 extra status byte */
- #include "hw/block/block.h"
+-    vu_queue_push(vu_dev, req->vq, req->elem, req->size + 1);
- #include "hw/qdev-properties.h"
++    vu_queue_push(vu_dev, req->vq, &req->elem, req->size + 1);
-@@ -XXX,XX +XXX,XX @@ err:
+     vu_queue_notify(vu_dev, req->vq);
-     return err_status;
 -    if (req->elem) {
 -        free(req->elem);
 -    }
 -
 -    g_free(req);
 +    free(req);
  }
-+typedef struct ZoneCmdData {
+ static VuBlockDev *get_vu_block_device_by_server(VuServer *server)
-+    VirtIOBlockReq *req;
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_flush(VuBlockReq *req)
-+    struct iovec *in_iov;
+     blk_co_flush(backend);
-+    unsigned in_num;
+ }
-+    union {
-+        struct {
+-struct req_data {
-+            unsigned int nr_zones;
+-    VuServer *server;
-+            BlockZoneDescriptor *zones;
+-    VuVirtq *vq;
-+        } zone_report_data;
+-    VuVirtqElement *elem;
-+        struct {
+-};
-+            int64_t offset;
+-
-+        } zone_append_data;
+ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
-+    };
+ {
-+} ZoneCmdData;
+-    struct req_data *data = opaque;
 -    VuServer *server = data->server;
 -    VuVirtq *vq = data->vq;
 -    VuVirtqElement *elem = data->elem;
 +    VuBlockReq *req = opaque;
 +    VuServer *server = req->server;
 +    VuVirtqElement *elem = &req->elem;
      uint32_t type;
 -    VuBlockReq *req;
      VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
      BlockBackend *backend = vdev_blk->backend;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
      struct iovec *out_iov = elem->out_sg;
      unsigned in_num = elem->in_num;
      unsigned out_num = elem->out_num;
 +
-+/*
+     /* refer to hw/block/virtio_blk.c */
-+ * check zoned_request: error checking before issuing requests. If all checks
+     if (elem->out_num < 1 || elem->in_num < 1) {
-+ * passed, return true.
+         error_report("virtio-blk request missing headers");
-+ * append: true if only zone append requests issued.
+-        free(elem);
-+ */
+-        return;
-+static bool check_zoned_request(VirtIOBlock *s, int64_t offset, int64_t len,
++        goto err;
-+                             bool append, uint8_t *status) {
+     }
-+    BlockDriverState *bs = blk_bs(s->blk);
-+    int index;
+-    req = g_new0(VuBlockReq, 1);
 -    req->server = server;
 -    req->vq = vq;
 -    req->elem = elem;
 -
      if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
                              sizeof(req->out)) != sizeof(req->out))) {
          error_report("virtio-blk request outhdr too short");
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
  err:
      free(elem);
 -    g_free(req);
 -    return;
  }
  static void vu_block_process_vq(VuDev *vu_dev, int idx)
  {
 -    VuServer *server;
 -    VuVirtq *vq;
 -    struct req_data *req_data;
 +    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 +    VuVirtq *vq = vu_get_queue(vu_dev, idx);
 -    server = container_of(vu_dev, VuServer, vu_dev);
 -    assert(server);
 -
 -    vq = vu_get_queue(vu_dev, idx);
 -    assert(vq);
 -    VuVirtqElement *elem;
      while (1) {
 -        elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) +
 -                                    sizeof(VuBlockReq));
 -        if (elem) {
 -            req_data = g_new0(struct req_data, 1);
 -            req_data->server = server;
 -            req_data->vq = vq;
 -            req_data->elem = elem;
 -            Coroutine *co = qemu_coroutine_create(vu_block_virtio_process_req,
 -                                                  req_data);
 -            aio_co_enter(server->ioc->ctx, co);
 -        } else {
 +        VuBlockReq *req;
 +
-+    if (!virtio_has_feature(s->host_features, VIRTIO_BLK_F_ZONED)) {
++        req = vu_queue_pop(vu_dev, vq, sizeof(VuBlockReq));
-+        *status = VIRTIO_BLK_S_UNSUPP;
++        if (!req) {
-+        return false;
+             break;
-+    }
+         }
 +
-+    if (offset < 0 || len < 0 || len > (bs->total_sectors << BDRV_SECTOR_BITS)
++        req->server = server;
-+        || offset > (bs->total_sectors << BDRV_SECTOR_BITS) - len) {
++        req->vq = vq;
 +        *status = VIRTIO_BLK_S_ZONE_INVALID_CMD;
 +        return false;
 +    }
 +
-+    if (append) {
++        Coroutine *co =
-+        if (bs->bl.write_granularity) {
++            qemu_coroutine_create(vu_block_virtio_process_req, req);
-+            if ((offset % bs->bl.write_granularity) != 0) {
++        qemu_coroutine_enter(co);
 +                *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"),
 --
-.39.2
+.26.2

-[PULL 07/20] block: add some trace events for new block layer APIs
+[PULL v2 12/28] util/vhost-user-server: drop unused DevicePanicNotifier
-From: Sam Li <faithilikerun@gmail.com>
+The device panic notifier callback is not used. Drop it.
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200924151549.913737-7-stefanha@redhat.com
 Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
 Acked-by: Kevin Wolf <kwolf@redhat.com>
 Message-id: 20230324090605.28361-8-faithilikerun@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/file-posix.c | 3 +++
+ util/vhost-user-server.h             | 3 ---
- block/trace-events | 2 ++
+ block/export/vhost-user-blk-server.c | 3 +--
-files changed, 5 insertions(+)
+ util/vhost-user-server.c             | 6 ------
 files changed, 1 insertion(+), 11 deletions(-)
-diff --git a/block/file-posix.c b/block/file-posix.c
+diff --git a/util/vhost-user-server.h b/util/vhost-user-server.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/file-posix.c
+--- a/util/vhost-user-server.h
-+++ b/block/file-posix.c
++++ b/util/vhost-user-server.h
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_report(BlockDriverState *bs, int64_t offset,
+@@ -XXX,XX +XXX,XX @@ typedef struct VuFdWatch {
-         },
+ } VuFdWatch;
  typedef struct VuServer VuServer;
 -typedef void DevicePanicNotifierFn(VuServer *server);
  struct VuServer {
      QIONetListener *listener;
      AioContext *ctx;
 -    DevicePanicNotifierFn *device_panic_notifier;
      int max_queues;
      const VuDevIface *vu_iface;
      VuDev vu_dev;
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
                               SocketAddress *unix_socket,
                               AioContext *ctx,
                               uint16_t max_queues,
 -                             DevicePanicNotifierFn *device_panic_notifier,
                               const VuDevIface *vu_iface,
                               Error **errp);
 diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/export/vhost-user-blk-server.c
 +++ b/block/export/vhost-user-blk-server.c
@@ -XXX,XX +XXX,XX @@ static void vhost_user_blk_server_start(VuBlockDev *vu_block_device,
      ctx = bdrv_get_aio_context(blk_bs(vu_block_device->backend));
      if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx,
 -                                 VHOST_USER_BLK_MAX_QUEUES,
 -                                 NULL, &vu_block_iface,
 +                                 VHOST_USER_BLK_MAX_QUEUES, &vu_block_iface,
                                   errp)) {
          goto error;
      }
 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 @@ static void panic_cb(VuDev *vu_dev, const char *buf)
          close_client(server);
      }
 -    if (server->device_panic_notifier) {
 -        server->device_panic_notifier(server);
 -    }
 -
      /*
       * Set the callback function for network listener so another
       * vhost-user client can connect to this server
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
                               SocketAddress *socket_addr,
                               AioContext *ctx,
                               uint16_t max_queues,
 -                             DevicePanicNotifierFn *device_panic_notifier,
                               const VuDevIface *vu_iface,
                               Error **errp)
  {
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
          .vu_iface              = vu_iface,
          .max_queues            = max_queues,
          .ctx                   = ctx,
 -        .device_panic_notifier = device_panic_notifier,
      };
-+    trace_zbd_zone_report(bs, *nr_zones, offset >> BDRV_SECTOR_BITS);
+     qio_net_listener_set_name(server->listener, "vhost-user-backend-listener");
      return raw_thread_pool_submit(bs, 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(bs, 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)"
 --
-.39.2
+.26.2

-New patch
+[PULL v2 13/28] util/vhost-user-server: fix memory leak in vu_message_read()
+fds[] is leaked when qio_channel_readv_full() fails.
+Use vmsg->fds[] instead of keeping a local fds[] array. Then we can
+reuse goto fail to clean up fds. vmsg->fd_num must be zeroed before the
+loop to make this safe.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200924151549.913737-8-stefanha@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ util/vhost-user-server.c | 50 ++++++++++++++++++----------------------
+file changed, 23 insertions(+), 27 deletions(-)
+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 @@ vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg)
+     };
+     int rc, read_bytes = 0;
+     Error *local_err = NULL;
+-    /*
+-     * Store fds/nfds returned from qio_channel_readv_full into
+-     * temporary variables.
+-     *
+-     * VhostUserMsg is a packed structure, gcc will complain about passing
+-     * pointer to a packed structure member if we pass &VhostUserMsg.fd_num
+-     * and &VhostUserMsg.fds directly when calling qio_channel_readv_full,
+-     * thus two temporary variables nfds and fds are used here.
+-     */
+-    size_t nfds = 0, nfds_t = 0;
+     const size_t max_fds = G_N_ELEMENTS(vmsg->fds);
+-    int *fds_t = NULL;
+     VuServer *server = container_of(vu_dev, VuServer, vu_dev);
+     QIOChannel *ioc = server->ioc;
++    vmsg->fd_num = 0;
+     if (!ioc) {
+         error_report_err(local_err);
+         goto fail;
+@@ -XXX,XX +XXX,XX @@ vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg)
+     assert(qemu_in_coroutine());
+     do {
++        size_t nfds = 0;
++        int *fds = NULL;
++
+         /*
+          * qio_channel_readv_full may have short reads, keeping calling it
+          * until getting VHOST_USER_HDR_SIZE or 0 bytes in total
+          */
+-        rc = qio_channel_readv_full(ioc, &iov, 1, &fds_t, &nfds_t, &local_err);
++        rc = qio_channel_readv_full(ioc, &iov, 1, &fds, &nfds, &local_err);
+         if (rc < 0) {
+             if (rc == QIO_CHANNEL_ERR_BLOCK) {
++                assert(local_err == NULL);
+                 qio_channel_yield(ioc, G_IO_IN);
+                 continue;
+             } else {
+                 error_report_err(local_err);
+-                return false;
++                goto fail;
+             }
+         }
+-        read_bytes += rc;
+-        if (nfds_t > 0) {
+-            if (nfds + nfds_t > max_fds) {
++
++        if (nfds > 0) {
++            if (vmsg->fd_num + nfds > max_fds) {
+                 error_report("A maximum of %zu fds are allowed, "
+                              "however got %zu fds now",
+-                             max_fds, nfds + nfds_t);
++                             max_fds, vmsg->fd_num + nfds);
++                g_free(fds);
+                 goto fail;
+             }
+-            memcpy(vmsg->fds + nfds, fds_t,
+-                   nfds_t *sizeof(vmsg->fds[0]));
+-            nfds += nfds_t;
+-            g_free(fds_t);
++            memcpy(vmsg->fds + vmsg->fd_num, fds, nfds * sizeof(vmsg->fds[0]));
++            vmsg->fd_num += nfds;
++            g_free(fds);
+         }
+-        if (read_bytes == VHOST_USER_HDR_SIZE || rc == 0) {
+-            break;
++
++        if (rc == 0) { /* socket closed */
++            goto fail;
+         }
+-        iov.iov_base = (char *)vmsg + read_bytes;
+-        iov.iov_len = VHOST_USER_HDR_SIZE - read_bytes;
+-    } while (true);
+-    vmsg->fd_num = nfds;
++        iov.iov_base += rc;
++        iov.iov_len -= rc;
++        read_bytes += rc;
++    } while (read_bytes != VHOST_USER_HDR_SIZE);
++
+     /* qio_channel_readv_full will make socket fds blocking, unblock them */
+     vmsg_unblock_fds(vmsg);
+     if (vmsg->size > sizeof(vmsg->payload)) {
+--
+.26.2

-New patch
+[PULL v2 14/28] util/vhost-user-server: check EOF when reading payload
+Unexpected EOF is an error that must be reported.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200924151549.913737-9-stefanha@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ util/vhost-user-server.c | 6 ++++--
+file changed, 4 insertions(+), 2 deletions(-)
+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 @@ vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg)
+     };
+     if (vmsg->size) {
+         rc = qio_channel_readv_all_eof(ioc, &iov_payload, 1, &local_err);
+-        if (rc == -1) {
+-            error_report_err(local_err);
++        if (rc != 1) {
++            if (local_err) {
++                error_report_err(local_err);
++            }
+             goto fail;
+         }
+     }
+--
+.26.2

-[PULL 13/20] qemu-iotests: test zone append operation
+[PULL v2 15/28] util/vhost-user-server: rework vu_client_trip() coroutine lifecycle
-From: Sam Li <faithilikerun@gmail.com>
+The vu_client_trip() coroutine is leaked during AioContext switching. It
 is also unsafe to destroy the vu_dev in panic_cb() since its callers
 still access it in some cases.
-The patch tests zone append writes by reporting the zone wp after
+Rework the lifecycle to solve these safety issues.
 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>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200924151549.913737-10-stefanha@redhat.com
 Message-id: 20230407081657.17947-4-faithilikerun@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- qemu-io-cmds.c                     | 75 ++++++++++++++++++++++++++++++
+ util/vhost-user-server.h             |  29 ++--
- tests/qemu-iotests/tests/zoned     | 16 +++++++
+ block/export/vhost-user-blk-server.c |   9 +-
- tests/qemu-iotests/tests/zoned.out | 16 +++++++
+ util/vhost-user-server.c             | 245 +++++++++++++++------------
-files changed, 107 insertions(+)
+files changed, 155 insertions(+), 128 deletions(-)
-diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
+diff --git a/util/vhost-user-server.h b/util/vhost-user-server.h
 index XXXXXXX..XXXXXXX 100644
---- a/qemu-io-cmds.c
+--- a/util/vhost-user-server.h
-+++ b/qemu-io-cmds.c
++++ b/util/vhost-user-server.h
-@@ -XXX,XX +XXX,XX @@ static const cmdinfo_t zone_reset_cmd = {
+@@ -XXX,XX +XXX,XX @@
-     .oneline = "reset a zone write pointer in zone block device",
+ #include "qapi/error.h"
- };
+ #include "standard-headers/linux/virtio_blk.h"
-+static int do_aio_zone_append(BlockBackend *blk, QEMUIOVector *qiov,
++/* A kick fd that we monitor on behalf of libvhost-user */
-+                              int64_t *offset, int flags, int *total)
+ typedef struct VuFdWatch {
      VuDev *vu_dev;
      int fd; /*kick fd*/
      void *pvt;
      vu_watch_cb cb;
 -    bool processing;
      QTAILQ_ENTRY(VuFdWatch) next;
  } VuFdWatch;
 -typedef struct VuServer VuServer;
 -
 -struct VuServer {
 +/**
 + * VuServer:
 + * A vhost-user server instance with user-defined VuDevIface callbacks.
 + * Vhost-user device backends can be implemented using VuServer. VuDevIface
 + * callbacks and virtqueue kicks run in the given AioContext.
 + */
 +typedef struct {
      QIONetListener *listener;
 +    QEMUBH *restart_listener_bh;
      AioContext *ctx;
      int max_queues;
      const VuDevIface *vu_iface;
 +
 +    /* Protected by ctx lock */
      VuDev vu_dev;
      QIOChannel *ioc; /* The I/O channel with the client */
      QIOChannelSocket *sioc; /* The underlying data channel with the client */
 -    /* IOChannel for fd provided via VHOST_USER_SET_SLAVE_REQ_FD */
 -    QIOChannel *ioc_slave;
 -    QIOChannelSocket *sioc_slave;
 -    Coroutine *co_trip; /* coroutine for processing VhostUserMsg */
      QTAILQ_HEAD(, VuFdWatch) vu_fd_watches;
 -    /* restart coroutine co_trip if AIOContext is changed */
 -    bool aio_context_changed;
 -    bool processing_msg;
 -};
 +
 +    Coroutine *co_trip; /* coroutine for processing VhostUserMsg */
 +} VuServer;
  bool vhost_user_server_start(VuServer *server,
                               SocketAddress *unix_socket,
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
  void vhost_user_server_stop(VuServer *server);
 -void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx);
 +void vhost_user_server_attach_aio_context(VuServer *server, AioContext *ctx);
 +void vhost_user_server_detach_aio_context(VuServer *server);
  #endif /* VHOST_USER_SERVER_H */
 diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/export/vhost-user-blk-server.c
 +++ b/block/export/vhost-user-blk-server.c
@@ -XXX,XX +XXX,XX @@ static const VuDevIface vu_block_iface = {
  static void blk_aio_attached(AioContext *ctx, void *opaque)
  {
      VuBlockDev *vub_dev = opaque;
 -    aio_context_acquire(ctx);
 -    vhost_user_server_set_aio_context(&vub_dev->vu_server, ctx);
 -    aio_context_release(ctx);
 +    vhost_user_server_attach_aio_context(&vub_dev->vu_server, ctx);
  }
  static void blk_aio_detach(void *opaque)
  {
      VuBlockDev *vub_dev = opaque;
 -    AioContext *ctx = vub_dev->vu_server.ctx;
 -    aio_context_acquire(ctx);
 -    vhost_user_server_set_aio_context(&vub_dev->vu_server, NULL);
 -    aio_context_release(ctx);
 +    vhost_user_server_detach_aio_context(&vub_dev->vu_server);
  }
  static void
 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 @@
   */
  #include "qemu/osdep.h"
  #include "qemu/main-loop.h"
 +#include "block/aio-wait.h"
  #include "vhost-user-server.h"
 +/*
 + * Theory of operation:
 + *
 + * VuServer is started and stopped by vhost_user_server_start() and
 + * vhost_user_server_stop() from the main loop thread. Starting the server
 + * opens a vhost-user UNIX domain socket and listens for incoming connections.
 + * Only one connection is allowed at a time.
 + *
 + * The connection is handled by the vu_client_trip() coroutine in the
 + * VuServer->ctx AioContext. The coroutine consists of a vu_dispatch() loop
 + * where libvhost-user calls vu_message_read() to receive the next vhost-user
 + * protocol messages over the UNIX domain socket.
 + *
 + * When virtqueues are set up libvhost-user calls set_watch() to monitor kick
 + * fds. These fds are also handled in the VuServer->ctx AioContext.
 + *
 + * Both vu_client_trip() and kick fd monitoring can be stopped by shutting down
 + * the socket connection. Shutting down the socket connection causes
 + * vu_message_read() to fail since no more data can be received from the socket.
 + * After vu_dispatch() fails, vu_client_trip() calls vu_deinit() to stop
 + * libvhost-user before terminating the coroutine. vu_deinit() calls
 + * remove_watch() to stop monitoring kick fds and this stops virtqueue
 + * processing.
 + *
 + * When vu_client_trip() has finished cleaning up it schedules a BH in the main
 + * loop thread to accept the next client connection.
 + *
 + * When libvhost-user detects an error it calls panic_cb() and sets the
 + * dev->broken flag. Both vu_client_trip() and kick fd processing stop when
 + * the dev->broken flag is set.
 + *
 + * It is possible to switch AioContexts using
 + * vhost_user_server_detach_aio_context() and
 + * vhost_user_server_attach_aio_context(). They stop monitoring fds in the old
 + * AioContext and resume monitoring in the new AioContext. The vu_client_trip()
 + * coroutine remains in a yielded state during the switch. This is made
 + * possible by QIOChannel's support for spurious coroutine re-entry in
 + * qio_channel_yield(). The coroutine will restart I/O when re-entered from the
 + * new AioContext.
 + */
 +
  static void vmsg_close_fds(VhostUserMsg *vmsg)
  {
      int i;
@@ -XXX,XX +XXX,XX @@ static void vmsg_unblock_fds(VhostUserMsg *vmsg)
      }
  }
 -static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
 -                      gpointer opaque);
 -
 -static void close_client(VuServer *server)
 -{
 -    /*
 -     * Before closing the client
 -     *
 -     * 1. Let vu_client_trip stop processing new vhost-user msg
 -     *
 -     * 2. remove kick_handler
 -     *
 -     * 3. wait for the kick handler to be finished
 -     *
 -     * 4. wait for the current vhost-user msg to be finished processing
 -     */
 -
 -    QIOChannelSocket *sioc = server->sioc;
 -    /* When this is set vu_client_trip will stop new processing vhost-user message */
 -    server->sioc = NULL;
 -
 -    while (server->processing_msg) {
 -        if (server->ioc->read_coroutine) {
 -            server->ioc->read_coroutine = NULL;
 -            qio_channel_set_aio_fd_handler(server->ioc, server->ioc->ctx, NULL,
 -                                           NULL, server->ioc);
 -            server->processing_msg = false;
 -        }
 -    }
 -
 -    vu_deinit(&server->vu_dev);
 -
 -    /* vu_deinit() should have called remove_watch() */
 -    assert(QTAILQ_EMPTY(&server->vu_fd_watches));
 -
 -    object_unref(OBJECT(sioc));
 -    object_unref(OBJECT(server->ioc));
 -}
 -
  static void panic_cb(VuDev *vu_dev, const char *buf)
  {
 -    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 -
 -    /* avoid while loop in close_client */
 -    server->processing_msg = false;
 -
 -    if (buf) {
 -        error_report("vu_panic: %s", buf);
 -    }
 -
 -    if (server->sioc) {
 -        close_client(server);
 -    }
 -
 -    /*
 -     * Set the callback function for network listener so another
 -     * vhost-user client can connect to this server
 -     */
 -    qio_net_listener_set_client_func(server->listener,
 -                                     vu_accept,
 -                                     server,
 -                                     NULL);
 +    error_report("vu_panic: %s", buf);
  }
  static bool coroutine_fn
@@ -XXX,XX +XXX,XX @@ fail:
      return false;
  }
 -
 -static void vu_client_start(VuServer *server);
  static coroutine_fn void vu_client_trip(void *opaque)
  {
      VuServer *server = opaque;
 +    VuDev *vu_dev = &server->vu_dev;
 -    while (!server->aio_context_changed && server->sioc) {
 -        server->processing_msg = true;
 -        vu_dispatch(&server->vu_dev);
 -        server->processing_msg = false;
 +    while (!vu_dev->broken && vu_dispatch(vu_dev)) {
 +        /* Keep running */
      }
 -    if (server->aio_context_changed && server->sioc) {
 -        server->aio_context_changed = false;
 -        vu_client_start(server);
 -    }
 -}
 +    vu_deinit(vu_dev);
 +
 +    /* vu_deinit() should have called remove_watch() */
 +    assert(QTAILQ_EMPTY(&server->vu_fd_watches));
 +
 +    object_unref(OBJECT(server->sioc));
 +    server->sioc = NULL;
 -static void vu_client_start(VuServer *server)
 -{
 -    server->co_trip = qemu_coroutine_create(vu_client_trip, server);
 -    aio_co_enter(server->ctx, server->co_trip);
 +    object_unref(OBJECT(server->ioc));
 +    server->ioc = NULL;
 +
 +    server->co_trip = NULL;
 +    if (server->restart_listener_bh) {
 +        qemu_bh_schedule(server->restart_listener_bh);
 +    }
 +    aio_wait_kick();
  }
  /*
@@ -XXX,XX +XXX,XX @@ static void vu_client_start(VuServer *server)
  static void kick_handler(void *opaque)
  {
      VuFdWatch *vu_fd_watch = opaque;
 -    vu_fd_watch->processing = true;
 -    vu_fd_watch->cb(vu_fd_watch->vu_dev, 0, vu_fd_watch->pvt);
 -    vu_fd_watch->processing = false;
 +    VuDev *vu_dev = vu_fd_watch->vu_dev;
 +
 +    vu_fd_watch->cb(vu_dev, 0, vu_fd_watch->pvt);
 +
 +    /* Stop vu_client_trip() if an error occurred in vu_fd_watch->cb() */
 +    if (vu_dev->broken) {
 +        VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 +
 +        qio_channel_shutdown(server->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
 +    }
  }
 -
  static VuFdWatch *find_vu_fd_watch(VuServer *server, int fd)
  {
@@ -XXX,XX +XXX,XX @@ static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
      qio_channel_set_name(QIO_CHANNEL(sioc), "vhost-user client");
      server->ioc = QIO_CHANNEL(sioc);
      object_ref(OBJECT(server->ioc));
 -    qio_channel_attach_aio_context(server->ioc, server->ctx);
 +
 +    /* TODO vu_message_write() spins if non-blocking! */
      qio_channel_set_blocking(server->ioc, false, NULL);
 -    vu_client_start(server);
 +
 +    server->co_trip = qemu_coroutine_create(vu_client_trip, server);
 +
 +    aio_context_acquire(server->ctx);
 +    vhost_user_server_attach_aio_context(server, server->ctx);
 +    aio_context_release(server->ctx);
  }
 -
  void vhost_user_server_stop(VuServer *server)
  {
 +    aio_context_acquire(server->ctx);
 +
 +    qemu_bh_delete(server->restart_listener_bh);
 +    server->restart_listener_bh = NULL;
 +
      if (server->sioc) {
 -        close_client(server);
 +        VuFdWatch *vu_fd_watch;
 +
 +        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);
 +        }
 +
 +        qio_channel_shutdown(server->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
 +
 +        AIO_WAIT_WHILE(server->ctx, server->co_trip);
      }
 +    aio_context_release(server->ctx);
 +
      if (server->listener) {
          qio_net_listener_disconnect(server->listener);
          object_unref(OBJECT(server->listener));
      }
 +}
 +
 +/*
 + * Allow the next client to connect to the server. Called from a BH in the main
 + * loop.
 + */
 +static void restart_listener_bh(void *opaque)
 +{
-+    int async_ret = NOT_DONE;
++    VuServer *server = opaque;
-+
-+    blk_aio_zone_append(blk, offset, qiov, flags, aio_rw_done, &async_ret);
++    qio_net_listener_set_client_func(server->listener, vu_accept, server,
-+    while (async_ret == NOT_DONE) {
++                                     NULL);
-+        main_loop_wait(false);
+ }
 -void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx)
 +/* Called with ctx acquired */
 +void vhost_user_server_attach_aio_context(VuServer *server, AioContext *ctx)
  {
 -    VuFdWatch *vu_fd_watch, *next;
 -    void *opaque = NULL;
 -    IOHandler *io_read = NULL;
 -    bool attach;
 +    VuFdWatch *vu_fd_watch;
 -    server->ctx = ctx ? ctx : qemu_get_aio_context();
 +    server->ctx = ctx;
      if (!server->sioc) {
 -        /* not yet serving any client*/
          return;
      }
 -    if (ctx) {
 -        qio_channel_attach_aio_context(server->ioc, ctx);
 -        server->aio_context_changed = true;
 -        io_read = kick_handler;
 -        attach = true;
 -    } else {
 +    qio_channel_attach_aio_context(server->ioc, 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);
 +    }
 +
-+    *total = qiov->size;
++    aio_co_schedule(ctx, server->co_trip);
 +    return async_ret < 0 ? async_ret : 1;
 +}
 +
-+static int zone_append_f(BlockBackend *blk, int argc, char **argv)
++/* Called with server->ctx acquired */
 +void vhost_user_server_detach_aio_context(VuServer *server)
 +{
-+    int ret;
++    if (server->sioc) {
-+    bool pflag = false;
++        VuFdWatch *vu_fd_watch;
-+    int flags = 0;
++
-+    int total = 0;
++        QTAILQ_FOREACH(vu_fd_watch, &server->vu_fd_watches, next) {
-+    int64_t offset;
++            aio_set_fd_handler(server->ctx, vu_fd_watch->fd, true,
-+    char *buf;
++                               NULL, NULL, NULL, vu_fd_watch);
-+    int c, nr_iov;
++        }
-+    int pattern = 0xcd;
++
-+    QEMUIOVector qiov;
+         qio_channel_detach_aio_context(server->ioc);
-+
+-        /* server->ioc->ctx keeps the old AioConext */
-+    if (optind > argc - 3) {
+-        ctx = server->ioc->ctx;
-+        return -EINVAL;
+-        attach = false;
-+    }
+     }
-+
-+    if ((c = getopt(argc, argv, "p")) != -1) {
+-    QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
-+        pflag = true;
+-        if (vu_fd_watch->cb) {
-+    }
+-            opaque = attach ? vu_fd_watch : NULL;
-+
+-            aio_set_fd_handler(ctx, vu_fd_watch->fd, true,
-+    offset = cvtnum(argv[optind]);
+-                               io_read, NULL, NULL,
-+    if (offset < 0) {
+-                               opaque);
-+        print_cvtnum_err(offset, argv[optind]);
+-        }
-+        return offset;
+-    }
-+    }
++    server->ctx = NULL;
-+    optind++;
+ }
-+    nr_iov = argc - optind;
-+    buf = create_iovec(blk, &qiov, &argv[optind], nr_iov, pattern,
+-
-+                       flags & BDRV_REQ_REGISTERED_BUF);
+ bool vhost_user_server_start(VuServer *server,
-+    if (buf == NULL) {
+                              SocketAddress *socket_addr,
-+        return -EINVAL;
+                              AioContext *ctx,
-+    }
+@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
-+    ret = do_aio_zone_append(blk, &qiov, &offset, flags, &total);
+                              const VuDevIface *vu_iface,
-+    if (ret < 0) {
+                              Error **errp)
-+        printf("zone append failed: %s\n", strerror(-ret));
+ {
-+        goto out;
++    QEMUBH *bh;
-+    }
+     QIONetListener *listener = qio_net_listener_new();
-+
+     if (qio_net_listener_open_sync(listener, socket_addr, 1,
-+    if (pflag) {
+                                    errp) < 0) {
-+        printf("After zap done, the append sector is 0x%" PRIx64 "\n",
+@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
-+               tosector(offset));
+         return false;
-+    }
+     }
-+
-+out:
++    bh = qemu_bh_new(restart_listener_bh, server);
-+    qemu_io_free(blk, buf, qiov.size,
++
-+                 flags & BDRV_REQ_REGISTERED_BUF);
+     /* zero out unspecified fields */
-+    qemu_iovec_destroy(&qiov);
+     *server = (VuServer) {
-+    return ret;
+         .listener              = listener,
-+}
++        .restart_listener_bh   = bh,
-+
+         .vu_iface              = vu_iface,
-+static const cmdinfo_t zone_append_cmd = {
+         .max_queues            = max_queues,
-+    .name = "zone_append",
+         .ctx                   = ctx,
 +    .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
 --
-.39.2
+.26.2

-New patch
+[PULL v2 16/28] block/export: report flush errors
+Propagate the flush return value since errors are possible.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200924151549.913737-11-stefanha@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/export/vhost-user-blk-server.c | 11 +++++++----
+file changed, 7 insertions(+), 4 deletions(-)
+diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/export/vhost-user-blk-server.c
++++ b/block/export/vhost-user-blk-server.c
+@@ -XXX,XX +XXX,XX @@ vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
+     return -EINVAL;
+ }
+-static void coroutine_fn vu_block_flush(VuBlockReq *req)
++static int coroutine_fn vu_block_flush(VuBlockReq *req)
+ {
+     VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
+     BlockBackend *backend = vdev_blk->backend;
+-    blk_co_flush(backend);
++    return blk_co_flush(backend);
+ }
+ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
+         break;
+     }
+     case VIRTIO_BLK_T_FLUSH:
+-        vu_block_flush(req);
+-        req->in->status = VIRTIO_BLK_S_OK;
++        if (vu_block_flush(req) == 0) {
++            req->in->status = VIRTIO_BLK_S_OK;
++        } else {
++            req->in->status = VIRTIO_BLK_S_IOERR;
++        }
+         break;
+     case VIRTIO_BLK_T_GET_ID: {
+         size_t size = MIN(iov_size(&elem->in_sg[0], in_num),
+--
+.26.2

-[PULL 15/20] include: update virtio_blk headers to v6.3-rc1
+[PULL v2 17/28] block/export: convert vhost-user-blk server to block export API
-From: Sam Li <faithilikerun@gmail.com>
+Use the new QAPI block exports API instead of defining our own QOM
+objects.
-Use scripts/update-linux-headers.sh to update headers to 6.3-rc1.
+This is a large change because the lifecycle of VuBlockDev needs to
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+follow BlockExportDriver. QOM properties are replaced by QAPI options
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+objects.
-Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
-Message-id: 20230407082528.18841-2-faithilikerun@gmail.com
+VuBlockDev is renamed VuBlkExport and contains a BlockExport field.
 Several fields can be dropped since BlockExport already has equivalents.
 The file names and meson build integration will be adjusted in a future
 patch. libvhost-user should probably be built as a static library that
 is linked into QEMU instead of as a .c file that results in duplicate
 compilation.
 The new command-line syntax is:
   $ qemu-storage-daemon \
       --blockdev file,node-name=drive0,filename=test.img \
       --export vhost-user-blk,node-name=drive0,id=export0,unix-socket=/tmp/vhost-user-blk.sock
 Note that unix-socket is optional because we may wish to accept chardevs
 too in the future.
 Markus noted that supported address families are not explicit in the
 QAPI schema. It is unlikely that support for more address families will
 be added since file descriptor passing is required and few address
 families support it. If a new address family needs to be added, then the
 QAPI 'features' syntax can be used to advertize them.
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Acked-by: Markus Armbruster <armbru@redhat.com>
 Message-id: 20200924151549.913737-12-stefanha@redhat.com
 [Skip test on big-endian host architectures because this device doesn't
 support them yet (as already mentioned in a code comment).
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/standard-headers/drm/drm_fourcc.h    |  12 +++
+ qapi/block-export.json               |  21 +-
- include/standard-headers/linux/ethtool.h     |  48 ++++++++-
+ block/export/vhost-user-blk-server.h |  23 +-
- include/standard-headers/linux/fuse.h        |  45 +++++++-
+ block/export/export.c                |   6 +
- include/standard-headers/linux/pci_regs.h    |   1 +
+ block/export/vhost-user-blk-server.c | 452 +++++++--------------------
- include/standard-headers/linux/vhost_types.h |   2 +
+ util/vhost-user-server.c             |  10 +-
- include/standard-headers/linux/virtio_blk.h  | 105 +++++++++++++++++++
+ block/export/meson.build             |   1 +
- linux-headers/asm-arm64/kvm.h                |   1 +
+ block/meson.build                    |   1 -
- linux-headers/asm-x86/kvm.h                  |  34 +++++-
+files changed, 156 insertions(+), 358 deletions(-)
- linux-headers/linux/kvm.h                    |   9 ++
- linux-headers/linux/vfio.h                   |  15 +--
+diff --git a/qapi/block-export.json b/qapi/block-export.json
  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
+--- a/qapi/block-export.json
-+++ b/include/standard-headers/drm/drm_fourcc.h
++++ b/qapi/block-export.json
-@@ -XXX,XX +XXX,XX @@ extern "C" {
+@@ -XXX,XX +XXX,XX @@
-  *
+   'data': { '*name': 'str', '*description': 'str',
-  * The authoritative list of format modifier codes is found in
+             '*bitmap': 'str' } }
-  * `include/uapi/drm/drm_fourcc.h`
-+ *
++##
-+ * Open Source User Waiver
++# @BlockExportOptionsVhostUserBlk:
-+ * -----------------------
++#
-+ *
++# A vhost-user-blk block export.
-+ * Because this is the authoritative source for pixel formats and modifiers
++#
-+ * referenced by GL, Vulkan extensions and other standards and hence used both
++# @addr: The vhost-user socket on which to listen. Both 'unix' and 'fd'
-+ * by open source and closed source driver stacks, the usual requirement for an
++#        SocketAddress types are supported. Passed fds must be UNIX domain
-+ * upstream in-kernel or open source userspace user does not apply.
++#        sockets.
-+ *
++# @logical-block-size: Logical block size in bytes. Defaults to 512 bytes.
-+ * To ensure, as much as feasible, compatibility across stacks and avoid
++#
-+ * confusion with incompatible enumerations stakeholders for all relevant driver
++# Since: 5.2
-+ * stacks should approve additions.
++##
-  */
++{ 'struct': 'BlockExportOptionsVhostUserBlk',
++  'data': { 'addr': 'SocketAddress', '*logical-block-size': 'size' } }
- #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
+ ##
  # @NbdServerAddOptions:
  #
@@ -XXX,XX +XXX,XX @@
  # An enumeration of block export types
  #
  # @nbd: NBD export
 +# @vhost-user-blk: vhost-user-blk export (since 5.2)
  #
  # Since: 4.2
  ##
  { 'enum': 'BlockExportType',
 -  'data': [ 'nbd' ] }
 +  'data': [ 'nbd', 'vhost-user-blk' ] }
  ##
  # @BlockExportOptions:
@@ -XXX,XX +XXX,XX @@
              '*writethrough': 'bool' },
    'discriminator': 'type',
    'data': {
 -      'nbd': 'BlockExportOptionsNbd'
 +      'nbd': 'BlockExportOptionsNbd',
 +      'vhost-user-blk': 'BlockExportOptionsVhostUserBlk'
     } }
  ##
 diff --git a/block/export/vhost-user-blk-server.h b/block/export/vhost-user-blk-server.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/standard-headers/linux/ethtool.h
+--- a/block/export/vhost-user-blk-server.h
-+++ b/include/standard-headers/linux/ethtool.h
++++ b/block/export/vhost-user-blk-server.h
-@@ -XXX,XX +XXX,XX @@ enum ethtool_stringset {
+@@ -XXX,XX +XXX,XX @@
-     ETH_SS_COUNT
  #ifndef VHOST_USER_BLK_SERVER_H
  #define VHOST_USER_BLK_SERVER_H
 -#include "util/vhost-user-server.h"
 -typedef struct VuBlockDev VuBlockDev;
 -#define TYPE_VHOST_USER_BLK_SERVER "vhost-user-blk-server"
 -#define VHOST_USER_BLK_SERVER(obj) \
 -   OBJECT_CHECK(VuBlockDev, obj, TYPE_VHOST_USER_BLK_SERVER)
 +#include "block/export.h"
 -/* vhost user block device */
 -struct VuBlockDev {
 -    Object parent_obj;
 -    char *node_name;
 -    SocketAddress *addr;
 -    AioContext *ctx;
 -    VuServer vu_server;
 -    bool running;
 -    uint32_t blk_size;
 -    BlockBackend *backend;
 -    QIOChannelSocket *sioc;
 -    QTAILQ_ENTRY(VuBlockDev) next;
 -    struct virtio_blk_config blkcfg;
 -    bool writable;
 -};
 +/* For block/export/export.c */
 +extern const BlockExportDriver blk_exp_vhost_user_blk;
  #endif /* VHOST_USER_BLK_SERVER_H */
 diff --git a/block/export/export.c b/block/export/export.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/export/export.c
 +++ b/block/export/export.c
@@ -XXX,XX +XXX,XX @@
  #include "sysemu/block-backend.h"
  #include "block/export.h"
  #include "block/nbd.h"
 +#if CONFIG_LINUX
 +#include "block/export/vhost-user-blk-server.h"
 +#endif
  #include "qapi/error.h"
  #include "qapi/qapi-commands-block-export.h"
  #include "qapi/qapi-events-block-export.h"
@@ -XXX,XX +XXX,XX @@
  static const BlockExportDriver *blk_exp_drivers[] = {
      &blk_exp_nbd,
 +#if CONFIG_LINUX
 +    &blk_exp_vhost_user_blk,
 +#endif
  };
-+/**
+ /* Only accessed from the main thread */
-+ * enum ethtool_mac_stats_src - source of ethtool MAC statistics
+diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
 + * @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
+--- a/block/export/vhost-user-blk-server.c
-+++ b/include/standard-headers/linux/fuse.h
++++ b/block/export/vhost-user-blk-server.c
@@ -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 {
 +        uint32_t zone_sectors;
 +        uint32_t max_open_zones;
 +        uint32_t max_active_zones;
 +        uint32_t max_append_sectors;
 +        uint32_t 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 */
 +    uint64_t z_cap;
 +    /* The starting sector of the zone */
 +    uint64_t z_start;
 +    /* Zone write pointer position in sectors */
 +    uint64_t z_wp;
 +    /* Zone type */
 +    uint8_t z_type;
 +    /* Zone state */
 +    uint8_t z_state;
 +    uint8_t reserved[38];
 +};
 +
 +struct virtio_blk_zone_report {
 +    uint64_t 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)
+ #include "qemu/osdep.h"
+ #include "block/block.h"
-+/* Resume a device so it can resume processing virtqueue requests
++#include "contrib/libvhost-user/libvhost-user.h"
-+ *
++#include "standard-headers/linux/virtio_blk.h"
-+ * After the return of this ioctl the device will have restored all the
++#include "util/vhost-user-server.h"
-+ * necessary states and it is fully operational to continue processing the
+ #include "vhost-user-blk-server.h"
-+ * virtqueue descriptors.
+ #include "qapi/error.h"
-+ */
+ #include "qom/object_interfaces.h"
-+#define VHOST_VDPA_RESUME        _IO(VHOST_VIRTIO, 0x7E)
+@@ -XXX,XX +XXX,XX @@ struct virtio_blk_inhdr {
      unsigned char status;
  };
 -typedef struct VuBlockReq {
 +typedef struct VuBlkReq {
      VuVirtqElement elem;
      int64_t sector_num;
      size_t size;
@@ -XXX,XX +XXX,XX @@ typedef struct VuBlockReq {
      struct virtio_blk_outhdr out;
      VuServer *server;
      struct VuVirtq *vq;
 -} VuBlockReq;
 +} VuBlkReq;
 -static void vu_block_req_complete(VuBlockReq *req)
 +/* vhost user block device */
 +typedef struct {
 +    BlockExport export;
 +    VuServer vu_server;
 +    uint32_t blk_size;
 +    QIOChannelSocket *sioc;
 +    struct virtio_blk_config blkcfg;
 +    bool writable;
 +} VuBlkExport;
 +
- #endif
++static void vu_blk_req_complete(VuBlkReq *req)
  {
      VuDev *vu_dev = &req->server->vu_dev;
@@ -XXX,XX +XXX,XX @@ static void vu_block_req_complete(VuBlockReq *req)
      free(req);
  }
 -static VuBlockDev *get_vu_block_device_by_server(VuServer *server)
 -{
 -    return container_of(server, VuBlockDev, vu_server);
 -}
 -
  static int coroutine_fn
 -vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
 -                              uint32_t iovcnt, uint32_t type)
 +vu_blk_discard_write_zeroes(BlockBackend *blk, struct iovec *iov,
 +                            uint32_t iovcnt, uint32_t type)
  {
      struct virtio_blk_discard_write_zeroes desc;
      ssize_t size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc));
@@ -XXX,XX +XXX,XX @@ vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
          return -EINVAL;
      }
 -    VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
      uint64_t range[2] = { le64_to_cpu(desc.sector) << 9,
                            le32_to_cpu(desc.num_sectors) << 9 };
      if (type == VIRTIO_BLK_T_DISCARD) {
 -        if (blk_co_pdiscard(vdev_blk->backend, range[0], range[1]) == 0) {
 +        if (blk_co_pdiscard(blk, range[0], range[1]) == 0) {
              return 0;
          }
      } else if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
 -        if (blk_co_pwrite_zeroes(vdev_blk->backend,
 -                                 range[0], range[1], 0) == 0) {
 +        if (blk_co_pwrite_zeroes(blk, range[0], range[1], 0) == 0) {
              return 0;
          }
      }
@@ -XXX,XX +XXX,XX @@ vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
      return -EINVAL;
  }
 -static int coroutine_fn vu_block_flush(VuBlockReq *req)
 +static void coroutine_fn vu_blk_virtio_process_req(void *opaque)
  {
 -    VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
 -    BlockBackend *backend = vdev_blk->backend;
 -    return blk_co_flush(backend);
 -}
 -
 -static void coroutine_fn vu_block_virtio_process_req(void *opaque)
 -{
 -    VuBlockReq *req = opaque;
 +    VuBlkReq *req = opaque;
      VuServer *server = req->server;
      VuVirtqElement *elem = &req->elem;
      uint32_t type;
 -    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
 -    BlockBackend *backend = vdev_blk->backend;
 +    VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
 +    BlockBackend *blk = vexp->export.blk;
      struct iovec *in_iov = elem->in_sg;
      struct iovec *out_iov = elem->out_sg;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
          bool is_write = type & VIRTIO_BLK_T_OUT;
          req->sector_num = le64_to_cpu(req->out.sector);
 -        int64_t offset = req->sector_num * vdev_blk->blk_size;
 +        if (is_write && !vexp->writable) {
 +            req->in->status = VIRTIO_BLK_S_IOERR;
 +            break;
 +        }
 +
 +        int64_t offset = req->sector_num * vexp->blk_size;
          QEMUIOVector qiov;
          if (is_write) {
              qemu_iovec_init_external(&qiov, out_iov, out_num);
 -            ret = blk_co_pwritev(backend, offset, qiov.size,
 -                                 &qiov, 0);
 +            ret = blk_co_pwritev(blk, offset, qiov.size, &qiov, 0);
          } else {
              qemu_iovec_init_external(&qiov, in_iov, in_num);
 -            ret = blk_co_preadv(backend, offset, qiov.size,
 -                                &qiov, 0);
 +            ret = blk_co_preadv(blk, offset, qiov.size, &qiov, 0);
          }
          if (ret >= 0) {
              req->in->status = VIRTIO_BLK_S_OK;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
          break;
      }
      case VIRTIO_BLK_T_FLUSH:
 -        if (vu_block_flush(req) == 0) {
 +        if (blk_co_flush(blk) == 0) {
              req->in->status = VIRTIO_BLK_S_OK;
          } else {
              req->in->status = VIRTIO_BLK_S_IOERR;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
      case VIRTIO_BLK_T_DISCARD:
      case VIRTIO_BLK_T_WRITE_ZEROES: {
          int rc;
 -        rc = vu_block_discard_write_zeroes(req, &elem->out_sg[1],
 -                                           out_num, type);
 +
 +        if (!vexp->writable) {
 +            req->in->status = VIRTIO_BLK_S_IOERR;
 +            break;
 +        }
 +
 +        rc = vu_blk_discard_write_zeroes(blk, &elem->out_sg[1], out_num, type);
          if (rc == 0) {
              req->in->status = VIRTIO_BLK_S_OK;
          } else {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
          break;
      }
 -    vu_block_req_complete(req);
 +    vu_blk_req_complete(req);
      return;
  err:
 -    free(elem);
 +    free(req);
  }
 -static void vu_block_process_vq(VuDev *vu_dev, int idx)
 +static void vu_blk_process_vq(VuDev *vu_dev, int idx)
  {
      VuServer *server = container_of(vu_dev, VuServer, vu_dev);
      VuVirtq *vq = vu_get_queue(vu_dev, idx);
      while (1) {
 -        VuBlockReq *req;
 +        VuBlkReq *req;
 -        req = vu_queue_pop(vu_dev, vq, sizeof(VuBlockReq));
 +        req = vu_queue_pop(vu_dev, vq, sizeof(VuBlkReq));
          if (!req) {
              break;
          }
@@ -XXX,XX +XXX,XX @@ static void vu_block_process_vq(VuDev *vu_dev, int idx)
          req->vq = vq;
          Coroutine *co =
 -            qemu_coroutine_create(vu_block_virtio_process_req, req);
 +            qemu_coroutine_create(vu_blk_virtio_process_req, req);
          qemu_coroutine_enter(co);
      }
  }
 -static void vu_block_queue_set_started(VuDev *vu_dev, int idx, bool started)
 +static void vu_blk_queue_set_started(VuDev *vu_dev, int idx, bool started)
  {
      VuVirtq *vq;
      assert(vu_dev);
      vq = vu_get_queue(vu_dev, idx);
 -    vu_set_queue_handler(vu_dev, vq, started ? vu_block_process_vq : NULL);
 +    vu_set_queue_handler(vu_dev, vq, started ? vu_blk_process_vq : NULL);
  }
 -static uint64_t vu_block_get_features(VuDev *dev)
 +static uint64_t vu_blk_get_features(VuDev *dev)
  {
      uint64_t features;
      VuServer *server = container_of(dev, VuServer, vu_dev);
 -    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
 +    VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
      features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
 ull << VIRTIO_BLK_F_SEG_MAX |
 ull << VIRTIO_BLK_F_TOPOLOGY |
@@ -XXX,XX +XXX,XX @@ static uint64_t vu_block_get_features(VuDev *dev)
 ull << VIRTIO_RING_F_EVENT_IDX |
 ull << VHOST_USER_F_PROTOCOL_FEATURES;
 -    if (!vdev_blk->writable) {
 +    if (!vexp->writable) {
          features |= 1ull << VIRTIO_BLK_F_RO;
      }
      return features;
  }
 -static uint64_t vu_block_get_protocol_features(VuDev *dev)
 +static uint64_t vu_blk_get_protocol_features(VuDev *dev)
  {
      return 1ull << VHOST_USER_PROTOCOL_F_CONFIG |
 ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD;
  }
  static int
 -vu_block_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
 +vu_blk_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
  {
 +    /* TODO blkcfg must be little-endian for VIRTIO 1.0 */
      VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 -    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
 -    memcpy(config, &vdev_blk->blkcfg, len);
 -
 +    VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
 +    memcpy(config, &vexp->blkcfg, len);
      return 0;
  }
  static int
 -vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
 +vu_blk_set_config(VuDev *vu_dev, const uint8_t *data,
                      uint32_t offset, uint32_t size, uint32_t flags)
  {
      VuServer *server = container_of(vu_dev, VuServer, vu_dev);
 -    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
 +    VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
      uint8_t wce;
      /* don't support live migration */
@@ -XXX,XX +XXX,XX @@ vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
      }
      wce = *data;
 -    vdev_blk->blkcfg.wce = wce;
 -    blk_set_enable_write_cache(vdev_blk->backend, wce);
 +    vexp->blkcfg.wce = wce;
 +    blk_set_enable_write_cache(vexp->export.blk, wce);
      return 0;
  }
@@ -XXX,XX +XXX,XX @@ vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
   * of vu_process_message.
   *
   */
 -static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
 +static int vu_blk_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
  {
      if (vmsg->request == VHOST_USER_NONE) {
          dev->panic(dev, "disconnect");
@@ -XXX,XX +XXX,XX @@ static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
      return false;
  }
 -static const VuDevIface vu_block_iface = {
 -    .get_features          = vu_block_get_features,
 -    .queue_set_started     = vu_block_queue_set_started,
 -    .get_protocol_features = vu_block_get_protocol_features,
 -    .get_config            = vu_block_get_config,
 -    .set_config            = vu_block_set_config,
 -    .process_msg           = vu_block_process_msg,
 +static const VuDevIface vu_blk_iface = {
 +    .get_features          = vu_blk_get_features,
 +    .queue_set_started     = vu_blk_queue_set_started,
 +    .get_protocol_features = vu_blk_get_protocol_features,
 +    .get_config            = vu_blk_get_config,
 +    .set_config            = vu_blk_set_config,
 +    .process_msg           = vu_blk_process_msg,
  };
  static void blk_aio_attached(AioContext *ctx, void *opaque)
  {
 -    VuBlockDev *vub_dev = opaque;
 -    vhost_user_server_attach_aio_context(&vub_dev->vu_server, ctx);
 +    VuBlkExport *vexp = opaque;
 +    vhost_user_server_attach_aio_context(&vexp->vu_server, ctx);
  }
  static void blk_aio_detach(void *opaque)
  {
 -    VuBlockDev *vub_dev = opaque;
 -    vhost_user_server_detach_aio_context(&vub_dev->vu_server);
 +    VuBlkExport *vexp = opaque;
 +    vhost_user_server_detach_aio_context(&vexp->vu_server);
  }
  static void
 -vu_block_initialize_config(BlockDriverState *bs,
 +vu_blk_initialize_config(BlockDriverState *bs,
                             struct virtio_blk_config *config, uint32_t blk_size)
  {
      config->capacity = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
@@ -XXX,XX +XXX,XX @@ vu_block_initialize_config(BlockDriverState *bs,
      config->max_write_zeroes_seg = 1;
  }
 -static VuBlockDev *vu_block_init(VuBlockDev *vu_block_device, Error **errp)
 +static void vu_blk_exp_request_shutdown(BlockExport *exp)
  {
 +    VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
 -    BlockBackend *blk;
 -    Error *local_error = NULL;
 -    const char *node_name = vu_block_device->node_name;
 -    bool writable = vu_block_device->writable;
 -    uint64_t perm = BLK_PERM_CONSISTENT_READ;
 -    int ret;
 -
 -    AioContext *ctx;
 -
 -    BlockDriverState *bs = bdrv_lookup_bs(node_name, node_name, &local_error);
 -
 -    if (!bs) {
 -        error_propagate(errp, local_error);
 -        return NULL;
 -    }
 -
 -    if (bdrv_is_read_only(bs)) {
 -        writable = false;
 -    }
 -
 -    if (writable) {
 -        perm |= BLK_PERM_WRITE;
 -    }
 -
 -    ctx = bdrv_get_aio_context(bs);
 -    aio_context_acquire(ctx);
 -    bdrv_invalidate_cache(bs, NULL);
 -    aio_context_release(ctx);
 -
 -    /*
 -     * Don't allow resize while the vhost user server is running,
 -     * otherwise we don't care what happens with the node.
 -     */
 -    blk = blk_new(bdrv_get_aio_context(bs), perm,
 -                  BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
 -                  BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD);
 -    ret = blk_insert_bs(blk, bs, errp);
 -
 -    if (ret < 0) {
 -        goto fail;
 -    }
 -
 -    blk_set_enable_write_cache(blk, false);
 -
 -    blk_set_allow_aio_context_change(blk, true);
 -
 -    vu_block_device->blkcfg.wce = 0;
 -    vu_block_device->backend = blk;
 -    if (!vu_block_device->blk_size) {
 -        vu_block_device->blk_size = BDRV_SECTOR_SIZE;
 -    }
 -    vu_block_device->blkcfg.blk_size = vu_block_device->blk_size;
 -    blk_set_guest_block_size(blk, vu_block_device->blk_size);
 -    vu_block_initialize_config(bs, &vu_block_device->blkcfg,
 -                                   vu_block_device->blk_size);
 -    return vu_block_device;
 -
 -fail:
 -    blk_unref(blk);
 -    return NULL;
 -}
 -
 -static void vu_block_deinit(VuBlockDev *vu_block_device)
 -{
 -    if (vu_block_device->backend) {
 -        blk_remove_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
 -                                        blk_aio_detach, vu_block_device);
 -    }
 -
 -    blk_unref(vu_block_device->backend);
 -}
 -
 -static void vhost_user_blk_server_stop(VuBlockDev *vu_block_device)
 -{
 -    vhost_user_server_stop(&vu_block_device->vu_server);
 -    vu_block_deinit(vu_block_device);
 -}
 -
 -static void vhost_user_blk_server_start(VuBlockDev *vu_block_device,
 -                                        Error **errp)
 -{
 -    AioContext *ctx;
 -    SocketAddress *addr = vu_block_device->addr;
 -
 -    if (!vu_block_init(vu_block_device, errp)) {
 -        return;
 -    }
 -
 -    ctx = bdrv_get_aio_context(blk_bs(vu_block_device->backend));
 -
 -    if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx,
 -                                 VHOST_USER_BLK_MAX_QUEUES, &vu_block_iface,
 -                                 errp)) {
 -        goto error;
 -    }
 -
 -    blk_add_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
 -                                 blk_aio_detach, vu_block_device);
 -    vu_block_device->running = true;
 -    return;
 -
 - error:
 -    vu_block_deinit(vu_block_device);
 -}
 -
 -static bool vu_prop_modifiable(VuBlockDev *vus, Error **errp)
 -{
 -    if (vus->running) {
 -            error_setg(errp, "The property can't be modified "
 -                       "while the server is running");
 -            return false;
 -    }
 -    return true;
 -}
 -
 -static void vu_set_node_name(Object *obj, const char *value, Error **errp)
 -{
 -    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 -
 -    if (!vu_prop_modifiable(vus, errp)) {
 -        return;
 -    }
 -
 -    if (vus->node_name) {
 -        g_free(vus->node_name);
 -    }
 -
 -    vus->node_name = g_strdup(value);
 -}
 -
 -static char *vu_get_node_name(Object *obj, Error **errp)
 -{
 -    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 -    return g_strdup(vus->node_name);
 -}
 -
 -static void free_socket_addr(SocketAddress *addr)
 -{
 -        g_free(addr->u.q_unix.path);
 -        g_free(addr);
 -}
 -
 -static void vu_set_unix_socket(Object *obj, const char *value,
 -                               Error **errp)
 -{
 -    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 -
 -    if (!vu_prop_modifiable(vus, errp)) {
 -        return;
 -    }
 -
 -    if (vus->addr) {
 -        free_socket_addr(vus->addr);
 -    }
 -
 -    SocketAddress *addr = g_new0(SocketAddress, 1);
 -    addr->type = SOCKET_ADDRESS_TYPE_UNIX;
 -    addr->u.q_unix.path = g_strdup(value);
 -    vus->addr = addr;
 +    vhost_user_server_stop(&vexp->vu_server);
  }
 -static char *vu_get_unix_socket(Object *obj, Error **errp)
 +static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
 +                             Error **errp)
  {
 -    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 -    return g_strdup(vus->addr->u.q_unix.path);
 -}
 -
 -static bool vu_get_block_writable(Object *obj, Error **errp)
 -{
 -    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 -    return vus->writable;
 -}
 -
 -static void vu_set_block_writable(Object *obj, bool value, Error **errp)
 -{
 -    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 -
 -    if (!vu_prop_modifiable(vus, errp)) {
 -            return;
 -    }
 -
 -    vus->writable = value;
 -}
 -
 -static void vu_get_blk_size(Object *obj, Visitor *v, const char *name,
 -                            void *opaque, Error **errp)
 -{
 -    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 -    uint32_t value = vus->blk_size;
 -
 -    visit_type_uint32(v, name, &value, errp);
 -}
 -
 -static void vu_set_blk_size(Object *obj, Visitor *v, const char *name,
 -                            void *opaque, Error **errp)
 -{
 -    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 -
 +    VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
 +    BlockExportOptionsVhostUserBlk *vu_opts = &opts->u.vhost_user_blk;
      Error *local_err = NULL;
 -    uint32_t value;
 +    uint64_t logical_block_size;
 -    if (!vu_prop_modifiable(vus, errp)) {
 -            return;
 -    }
 +    vexp->writable = opts->writable;
 +    vexp->blkcfg.wce = 0;
 -    visit_type_uint32(v, name, &value, &local_err);
 -    if (local_err) {
 -        goto out;
 +    if (vu_opts->has_logical_block_size) {
 +        logical_block_size = vu_opts->logical_block_size;
 +    } else {
 +        logical_block_size = BDRV_SECTOR_SIZE;
      }
 -
 -    check_block_size(object_get_typename(obj), name, value, &local_err);
 +    check_block_size(exp->id, "logical-block-size", logical_block_size,
 +                     &local_err);
      if (local_err) {
 -        goto out;
 +        error_propagate(errp, local_err);
 +        return -EINVAL;
 +    }
 +    vexp->blk_size = logical_block_size;
 +    blk_set_guest_block_size(exp->blk, logical_block_size);
 +    vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
 +                               logical_block_size);
 +
 +    blk_set_allow_aio_context_change(exp->blk, true);
 +    blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
 +                                 vexp);
 +
 +    if (!vhost_user_server_start(&vexp->vu_server, vu_opts->addr, exp->ctx,
 +                                 VHOST_USER_BLK_MAX_QUEUES, &vu_blk_iface,
 +                                 errp)) {
 +        blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
 +                                        blk_aio_detach, vexp);
 +        return -EADDRNOTAVAIL;
      }
 -    vus->blk_size = value;
 -
 -out:
 -    error_propagate(errp, local_err);
 -}
 -
 -static void vhost_user_blk_server_instance_finalize(Object *obj)
 -{
 -    VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
 -
 -    vhost_user_blk_server_stop(vub);
 -
 -    /*
 -     * Unlike object_property_add_str, object_class_property_add_str
 -     * doesn't have a release method. Thus manual memory freeing is
 -     * needed.
 -     */
 -    free_socket_addr(vub->addr);
 -    g_free(vub->node_name);
 -}
 -
 -static void vhost_user_blk_server_complete(UserCreatable *obj, Error **errp)
 -{
 -    VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
 -
 -    vhost_user_blk_server_start(vub, errp);
 +    return 0;
  }
 -static void vhost_user_blk_server_class_init(ObjectClass *klass,
 -                                             void *class_data)
 +static void vu_blk_exp_delete(BlockExport *exp)
  {
 -    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
 -    ucc->complete = vhost_user_blk_server_complete;
 -
 -    object_class_property_add_bool(klass, "writable",
 -                                   vu_get_block_writable,
 -                                   vu_set_block_writable);
 -
 -    object_class_property_add_str(klass, "node-name",
 -                                  vu_get_node_name,
 -                                  vu_set_node_name);
 -
 -    object_class_property_add_str(klass, "unix-socket",
 -                                  vu_get_unix_socket,
 -                                  vu_set_unix_socket);
 +    VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
 -    object_class_property_add(klass, "logical-block-size", "uint32",
 -                              vu_get_blk_size, vu_set_blk_size,
 -                              NULL, NULL);
 +    blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
 +                                    vexp);
  }
 -static const TypeInfo vhost_user_blk_server_info = {
 -    .name = TYPE_VHOST_USER_BLK_SERVER,
 -    .parent = TYPE_OBJECT,
 -    .instance_size = sizeof(VuBlockDev),
 -    .instance_finalize = vhost_user_blk_server_instance_finalize,
 -    .class_init = vhost_user_blk_server_class_init,
 -    .interfaces = (InterfaceInfo[]) {
 -        {TYPE_USER_CREATABLE},
 -        {}
 -    },
 +const BlockExportDriver blk_exp_vhost_user_blk = {
 +    .type               = BLOCK_EXPORT_TYPE_VHOST_USER_BLK,
 +    .instance_size      = sizeof(VuBlkExport),
 +    .create             = vu_blk_exp_create,
 +    .delete             = vu_blk_exp_delete,
 +    .request_shutdown   = vu_blk_exp_request_shutdown,
  };
 -
 -static void vhost_user_blk_server_register_types(void)
 -{
 -    type_register_static(&vhost_user_blk_server_info);
 -}
 -
 -type_init(vhost_user_blk_server_register_types)
 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 @@ bool vhost_user_server_start(VuServer *server,
                               Error **errp)
  {
      QEMUBH *bh;
 -    QIONetListener *listener = qio_net_listener_new();
 +    QIONetListener *listener;
 +
 +    if (socket_addr->type != SOCKET_ADDRESS_TYPE_UNIX &&
 +        socket_addr->type != SOCKET_ADDRESS_TYPE_FD) {
 +        error_setg(errp, "Only socket address types 'unix' and 'fd' are supported");
 +        return false;
 +    }
 +
 +    listener = qio_net_listener_new();
      if (qio_net_listener_open_sync(listener, socket_addr, 1,
                                     errp) < 0) {
          object_unref(OBJECT(listener));
 diff --git a/block/export/meson.build b/block/export/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/block/export/meson.build
 +++ b/block/export/meson.build
@@ -1 +1,2 @@
  block_ss.add(files('export.c'))
 +block_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-blk-server.c', '../../contrib/libvhost-user/libvhost-user.c'))
 diff --git a/block/meson.build b/block/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/block/meson.build
 +++ b/block/meson.build
@@ -XXX,XX +XXX,XX @@ block_ss.add(when: 'CONFIG_WIN32', if_true: files('file-win32.c', 'win32-aio.c')
  block_ss.add(when: 'CONFIG_POSIX', if_true: [files('file-posix.c'), coref, iokit])
  block_ss.add(when: 'CONFIG_LIBISCSI', if_true: files('iscsi-opts.c'))
  block_ss.add(when: 'CONFIG_LINUX', if_true: files('nvme.c'))
 -block_ss.add(when: 'CONFIG_LINUX', if_true: files('export/vhost-user-blk-server.c', '../contrib/libvhost-user/libvhost-user.c'))
  block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
  block_ss.add(when: 'CONFIG_SHEEPDOG', if_true: files('sheepdog.c'))
  block_ss.add(when: ['CONFIG_LINUX_AIO', libaio], if_true: files('linux-aio.c'))
 --
-.39.2
+.26.2

-New patch
+[PULL v2 18/28] util/vhost-user-server: move header to include/
+Headers used by other subsystems are located in include/. Also add the
+vhost-user-server and vhost-user-blk-server headers to MAINTAINERS.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200924151549.913737-13-stefanha@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ MAINTAINERS                                | 4 +++-
+ {util => include/qemu}/vhost-user-server.h | 0
+ block/export/vhost-user-blk-server.c       | 2 +-
+ util/vhost-user-server.c                   | 2 +-
+files changed, 5 insertions(+), 3 deletions(-)
+ rename {util => include/qemu}/vhost-user-server.h (100%)
+diff --git a/MAINTAINERS b/MAINTAINERS
+index XXXXXXX..XXXXXXX 100644
+--- a/MAINTAINERS
++++ b/MAINTAINERS
+@@ -XXX,XX +XXX,XX @@ Vhost-user block device backend server
+ M: Coiby Xu <Coiby.Xu@gmail.com>
+ S: Maintained
+ F: block/export/vhost-user-blk-server.c
+-F: util/vhost-user-server.c
++F: block/export/vhost-user-blk-server.h
++F: include/qemu/vhost-user-server.h
+ F: tests/qtest/libqos/vhost-user-blk.c
++F: util/vhost-user-server.c
+ Replication
+ M: Wen Congyang <wencongyang2@huawei.com>
+diff --git a/util/vhost-user-server.h b/include/qemu/vhost-user-server.h
+similarity index 100%
+rename from util/vhost-user-server.h
+rename to include/qemu/vhost-user-server.h
+diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/export/vhost-user-blk-server.c
++++ b/block/export/vhost-user-blk-server.c
+@@ -XXX,XX +XXX,XX @@
+ #include "block/block.h"
+ #include "contrib/libvhost-user/libvhost-user.h"
+ #include "standard-headers/linux/virtio_blk.h"
+-#include "util/vhost-user-server.h"
++#include "qemu/vhost-user-server.h"
+ #include "vhost-user-blk-server.h"
+ #include "qapi/error.h"
+ #include "qom/object_interfaces.h"
+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 @@
+  */
+ #include "qemu/osdep.h"
+ #include "qemu/main-loop.h"
++#include "qemu/vhost-user-server.h"
+ #include "block/aio-wait.h"
+-#include "vhost-user-server.h"
+ /*
+  * Theory of operation:
+--
+.26.2

-[PULL 01/20] block/block-common: add zoned device structs
+[PULL v2 19/28] util/vhost-user-server: use static library in meson.build
-From: Sam Li <faithilikerun@gmail.com>
+Don't compile contrib/libvhost-user/libvhost-user.c again. Instead build
 the static library once and then reuse it throughout QEMU.
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Also switch from CONFIG_LINUX to CONFIG_VHOST_USER, which is what the
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+vhost-user tools (vhost-user-gpu, etc) do.
-Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
-Reviewed-by: Hannes Reinecke <hare@suse.de>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
+Message-id: 20200924151549.913737-14-stefanha@redhat.com
-Acked-by: Kevin Wolf <kwolf@redhat.com>
+[Added CONFIG_LINUX again because libvhost-user doesn't build on macOS.
 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 ++++++++++++++++++++++++++++++++++++
+ block/export/export.c             | 8 ++++----
-file changed, 43 insertions(+)
+ block/export/meson.build          | 2 +-
  contrib/libvhost-user/meson.build | 1 +
  meson.build                       | 6 +++++-
  util/meson.build                  | 4 +++-
 files changed, 14 insertions(+), 7 deletions(-)
-diff --git a/include/block/block-common.h b/include/block/block-common.h
+diff --git a/block/export/export.c b/block/export/export.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/block-common.h
+--- a/block/export/export.c
-+++ b/include/block/block-common.h
++++ b/block/export/export.c
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockDriver BlockDriver;
+@@ -XXX,XX +XXX,XX @@
- typedef struct BdrvChild BdrvChild;
+ #include "sysemu/block-backend.h"
- typedef struct BdrvChildClass BdrvChildClass;
+ #include "block/export.h"
+ #include "block/nbd.h"
-+typedef enum BlockZoneOp {
+-#if CONFIG_LINUX
-+    BLK_ZO_OPEN,
+-#include "block/export/vhost-user-blk-server.h"
-+    BLK_ZO_CLOSE,
+-#endif
-+    BLK_ZO_FINISH,
+ #include "qapi/error.h"
-+    BLK_ZO_RESET,
+ #include "qapi/qapi-commands-block-export.h"
-+} BlockZoneOp;
+ #include "qapi/qapi-events-block-export.h"
  #include "qemu/id.h"
 +#ifdef CONFIG_VHOST_USER
 +#include "vhost-user-blk-server.h"
 +#endif
  static const BlockExportDriver *blk_exp_drivers[] = {
      &blk_exp_nbd,
 -#if CONFIG_LINUX
 +#ifdef CONFIG_VHOST_USER
      &blk_exp_vhost_user_blk,
  #endif
  };
 diff --git a/block/export/meson.build b/block/export/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/block/export/meson.build
 +++ b/block/export/meson.build
@@ -XXX,XX +XXX,XX @@
  block_ss.add(files('export.c'))
 -block_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-blk-server.c', '../../contrib/libvhost-user/libvhost-user.c'))
 +block_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: files('vhost-user-blk-server.c'))
 diff --git a/contrib/libvhost-user/meson.build b/contrib/libvhost-user/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/contrib/libvhost-user/meson.build
 +++ b/contrib/libvhost-user/meson.build
@@ -XXX,XX +XXX,XX @@
  libvhost_user = static_library('vhost-user',
                                 files('libvhost-user.c', 'libvhost-user-glib.c'),
                                 build_by_default: false)
 +vhost_user = declare_dependency(link_with: libvhost_user)
 diff --git a/meson.build b/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/meson.build
 +++ b/meson.build
@@ -XXX,XX +XXX,XX @@ trace_events_subdirs += [
    'util',
  ]
 +vhost_user = not_found
 +if 'CONFIG_VHOST_USER' in config_host
 +  subdir('contrib/libvhost-user')
 +endif
 +
-+typedef enum BlockZoneModel {
+ subdir('qapi')
-+    BLK_Z_NONE = 0x0, /* Regular block device */
+ subdir('qobject')
-+    BLK_Z_HM = 0x1, /* Host-managed zoned block device */
+ subdir('stubs')
-+    BLK_Z_HA = 0x2, /* Host-aware zoned block device */
+@@ -XXX,XX +XXX,XX @@ if have_tools
-+} BlockZoneModel;
+              install: true)
-+
-+typedef enum BlockZoneState {
+   if 'CONFIG_VHOST_USER' in config_host
-+    BLK_ZS_NOT_WP = 0x0,
+-    subdir('contrib/libvhost-user')
-+    BLK_ZS_EMPTY = 0x1,
+     subdir('contrib/vhost-user-blk')
-+    BLK_ZS_IOPEN = 0x2,
+     subdir('contrib/vhost-user-gpu')
-+    BLK_ZS_EOPEN = 0x3,
+     subdir('contrib/vhost-user-input')
-+    BLK_ZS_CLOSED = 0x4,
+diff --git a/util/meson.build b/util/meson.build
-+    BLK_ZS_RDONLY = 0xD,
+index XXXXXXX..XXXXXXX 100644
-+    BLK_ZS_FULL = 0xE,
+--- a/util/meson.build
-+    BLK_ZS_OFFLINE = 0xF,
++++ b/util/meson.build
-+} BlockZoneState;
+@@ -XXX,XX +XXX,XX @@ if have_block
-+
+   util_ss.add(files('main-loop.c'))
-+typedef enum BlockZoneType {
+   util_ss.add(files('nvdimm-utils.c'))
-+    BLK_ZT_CONV = 0x1, /* Conventional random writes supported */
+   util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c'))
-+    BLK_ZT_SWR = 0x2, /* Sequential writes required */
+-  util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c'))
-+    BLK_ZT_SWP = 0x3, /* Sequential writes preferred */
++  util_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: [
-+} BlockZoneType;
++    files('vhost-user-server.c'), vhost_user
-+
++  ])
-+/*
+   util_ss.add(files('block-helpers.c'))
-+ * Zone descriptor data structure.
+   util_ss.add(files('qemu-coroutine-sleep.c'))
-+ * Provides information on a zone with all position and size values in bytes.
+   util_ss.add(files('qemu-co-shared-resource.c'))
 + */
 +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;
 --
-.39.2
+.26.2

-New patch
+[PULL v2 20/28] qemu-storage-daemon: avoid compiling blockdev_ss twice
+Introduce libblkdev.fa to avoid recompiling blockdev_ss twice.
+Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200929125516.186715-3-stefanha@redhat.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ meson.build                | 12 ++++++++++--
+ storage-daemon/meson.build |  3 +--
+files changed, 11 insertions(+), 4 deletions(-)
+diff --git a/meson.build b/meson.build
+index XXXXXXX..XXXXXXX 100644
+--- a/meson.build
++++ b/meson.build
+@@ -XXX,XX +XXX,XX @@ blockdev_ss.add(files(
+ # os-win32.c does not
+ blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
+ softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
+-softmmu_ss.add_all(blockdev_ss)
+ common_ss.add(files('cpus-common.c'))
+@@ -XXX,XX +XXX,XX @@ block = declare_dependency(link_whole: [libblock],
+                            link_args: '@block.syms',
+                            dependencies: [crypto, io])
++blockdev_ss = blockdev_ss.apply(config_host, strict: false)
++libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
++                             dependencies: blockdev_ss.dependencies(),
++                             name_suffix: 'fa',
++                             build_by_default: false)
++
++blockdev = declare_dependency(link_whole: [libblockdev],
++                              dependencies: [block])
++
+ qmp_ss = qmp_ss.apply(config_host, strict: false)
+ libqmp = static_library('qmp', qmp_ss.sources() + genh,
+                         dependencies: qmp_ss.dependencies(),
+@@ -XXX,XX +XXX,XX @@ foreach m : block_mods + softmmu_mods
+                 install_dir: config_host['qemu_moddir'])
+ endforeach
+-softmmu_ss.add(authz, block, chardev, crypto, io, qmp)
++softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
+ common_ss.add(qom, qemuutil)
+ common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
+diff --git a/storage-daemon/meson.build b/storage-daemon/meson.build
+index XXXXXXX..XXXXXXX 100644
+--- a/storage-daemon/meson.build
++++ b/storage-daemon/meson.build
+@@ -XXX,XX +XXX,XX @@
+ qsd_ss = ss.source_set()
+ qsd_ss.add(files('qemu-storage-daemon.c'))
+-qsd_ss.add(block, chardev, qmp, qom, qemuutil)
+-qsd_ss.add_all(blockdev_ss)
++qsd_ss.add(blockdev, chardev, qmp, qom, qemuutil)
+ subdir('qapi')
+--
+.26.2

-[PULL 04/20] block/raw-format: add zone operations to pass through requests
+[PULL v2 21/28] block: move block exports to libblockdev
-From: Sam Li <faithilikerun@gmail.com>
+Block exports are used by softmmu, qemu-storage-daemon, and qemu-nbd.
 They are not used by other programs and are not otherwise needed in
 libblock.
-raw-format driver usually sits on top of file-posix driver. It needs to
+Undo the recent move of blockdev-nbd.c from blockdev_ss into block_ss.
-pass through requests of zone commands.
+Since bdrv_close_all() (libblock) calls blk_exp_close_all()
 (libblockdev) a stub function is required..
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+Make qemu-nbd.c use signal handling utility functions instead of
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+duplicating the code. This helps because os-posix.c is in libblockdev
-Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
+and it depends on a qemu_system_killed() symbol that qemu-nbd.c lacks.
-Reviewed-by: Hannes Reinecke <hare@suse.de>
+Once we use the signal handling utility functions we also end up
-Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
+providing the necessary symbol.
-Acked-by: Kevin Wolf <kwolf@redhat.com>
-Message-id: 20230324090605.28361-5-faithilikerun@gmail.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-[Adjust commit message prefix as suggested by Philippe Mathieu-Daudé
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
-<philmd@linaro.org>.
+Reviewed-by: Eric Blake <eblake@redhat.com>
 Message-id: 20200929125516.186715-4-stefanha@redhat.com
 [Fixed s/ndb/nbd/ typo in commit description as suggested by Eric Blake
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/raw-format.c | 17 +++++++++++++++++
+ qemu-nbd.c                | 21 ++++++++-------------
-file changed, 17 insertions(+)
+ stubs/blk-exp-close-all.c |  7 +++++++
  block/export/meson.build  |  4 ++--
  meson.build               |  4 ++--
  nbd/meson.build           |  2 ++
  stubs/meson.build         |  1 +
 files changed, 22 insertions(+), 17 deletions(-)
  create mode 100644 stubs/blk-exp-close-all.c
-diff --git a/block/raw-format.c b/block/raw-format.c
+diff --git a/qemu-nbd.c b/qemu-nbd.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/raw-format.c
+--- a/qemu-nbd.c
-+++ b/block/raw-format.c
++++ b/qemu-nbd.c
-@@ -XXX,XX +XXX,XX @@ raw_co_pdiscard(BlockDriverState *bs, int64_t offset, int64_t bytes)
+@@ -XXX,XX +XXX,XX @@
-     return bdrv_co_pdiscard(bs->file, offset, bytes);
+ #include "qapi/error.h"
  #include "qemu/cutils.h"
  #include "sysemu/block-backend.h"
 +#include "sysemu/runstate.h" /* for qemu_system_killed() prototype */
  #include "block/block_int.h"
  #include "block/nbd.h"
  #include "qemu/main-loop.h"
@@ -XXX,XX +XXX,XX @@ QEMU_COPYRIGHT "\n"
  }
-+static int coroutine_fn GRAPH_RDLOCK
+ #ifdef CONFIG_POSIX
-+raw_co_zone_report(BlockDriverState *bs, int64_t offset,
+-static void termsig_handler(int signum)
-+                   unsigned int *nr_zones,
++/*
-+                   BlockZoneDescriptor *zones)
++ * The client thread uses SIGTERM to interrupt the server.  A signal
 + * handler ensures that "qemu-nbd -v -c" exits with a nice status code.
 + */
 +void qemu_system_killed(int signum, pid_t pid)
  {
      qatomic_cmpxchg(&state, RUNNING, TERMINATE);
      qemu_notify_event();
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
      BlockExportOptions *export_opts;
  #ifdef CONFIG_POSIX
 -    /*
 -     * Exit gracefully on various signals, which includes SIGTERM used
 -     * by 'qemu-nbd -v -c'.
 -     */
 -    struct sigaction sa_sigterm;
 -    memset(&sa_sigterm, 0, sizeof(sa_sigterm));
 -    sa_sigterm.sa_handler = termsig_handler;
 -    sigaction(SIGTERM, &sa_sigterm, NULL);
 -    sigaction(SIGINT, &sa_sigterm, NULL);
 -    sigaction(SIGHUP, &sa_sigterm, NULL);
 -
 -    signal(SIGPIPE, SIG_IGN);
 +    os_setup_early_signal_handling();
 +    os_setup_signal_handling();
  #endif
      socket_init();
 diff --git a/stubs/blk-exp-close-all.c b/stubs/blk-exp-close-all.c
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/stubs/blk-exp-close-all.c
@@ -XXX,XX +XXX,XX @@
 +#include "qemu/osdep.h"
 +#include "block/export.h"
 +
 +/* Only used in programs that support block exports (libblockdev.fa) */
 +void blk_exp_close_all(void)
 +{
-+    return bdrv_co_zone_report(bs->file->bs, offset, nr_zones, zones);
 +}
-+
+diff --git a/block/export/meson.build b/block/export/meson.build
-+static int coroutine_fn GRAPH_RDLOCK
+index XXXXXXX..XXXXXXX 100644
-+raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
+--- a/block/export/meson.build
-+                 int64_t offset, int64_t len)
++++ b/block/export/meson.build
-+{
+@@ -XXX,XX +XXX,XX @@
-+    return bdrv_co_zone_mgmt(bs->file->bs, op, offset, len);
+-block_ss.add(files('export.c'))
-+}
+-block_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: files('vhost-user-blk-server.c'))
-+
++blockdev_ss.add(files('export.c'))
- static int64_t coroutine_fn GRAPH_RDLOCK
++blockdev_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: files('vhost-user-blk-server.c'))
- raw_co_getlength(BlockDriverState *bs)
+diff --git a/meson.build b/meson.build
- {
+index XXXXXXX..XXXXXXX 100644
-@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_raw = {
+--- a/meson.build
-     .bdrv_co_pwritev      = &raw_co_pwritev,
++++ b/meson.build
-     .bdrv_co_pwrite_zeroes = &raw_co_pwrite_zeroes,
+@@ -XXX,XX +XXX,XX @@ subdir('dump')
-     .bdrv_co_pdiscard     = &raw_co_pdiscard,
-+    .bdrv_co_zone_report  = &raw_co_zone_report,
+ block_ss.add(files(
-+    .bdrv_co_zone_mgmt  = &raw_co_zone_mgmt,
+   'block.c',
-     .bdrv_co_block_status = &raw_co_block_status,
+-  'blockdev-nbd.c',
-     .bdrv_co_copy_range_from = &raw_co_copy_range_from,
+   'blockjob.c',
-     .bdrv_co_copy_range_to  = &raw_co_copy_range_to,
+   'job.c',
    'qemu-io-cmds.c',
@@ -XXX,XX +XXX,XX @@ subdir('block')
  blockdev_ss.add(files(
    'blockdev.c',
 +  'blockdev-nbd.c',
    'iothread.c',
    'job-qmp.c',
  ))
@@ -XXX,XX +XXX,XX @@ if have_tools
    qemu_io = executable('qemu-io', files('qemu-io.c'),
               dependencies: [block, qemuutil], install: true)
    qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
 -               dependencies: [block, qemuutil], install: true)
 +               dependencies: [blockdev, qemuutil], install: true)
    subdir('storage-daemon')
    subdir('contrib/rdmacm-mux')
 diff --git a/nbd/meson.build b/nbd/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/nbd/meson.build
 +++ b/nbd/meson.build
@@ -XXX,XX +XXX,XX @@
  block_ss.add(files(
    'client.c',
    'common.c',
 +))
 +blockdev_ss.add(files(
    'server.c',
  ))
 diff --git a/stubs/meson.build b/stubs/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/stubs/meson.build
 +++ b/stubs/meson.build
@@ -XXX,XX +XXX,XX @@
  stub_ss.add(files('arch_type.c'))
  stub_ss.add(files('bdrv-next-monitor-owned.c'))
  stub_ss.add(files('blk-commit-all.c'))
 +stub_ss.add(files('blk-exp-close-all.c'))
  stub_ss.add(files('blockdev-close-all-bdrv-states.c'))
  stub_ss.add(files('change-state-handler.c'))
  stub_ss.add(files('cmos.c'))
 --
-.39.2
+.26.2

-[PULL 11/20] file-posix: add tracking of the zone write pointers
+[PULL v2 22/28] block/export: add iothread and fixed-iothread options
-From: Sam Li <faithilikerun@gmail.com>
+Make it possible to specify the iothread where the export will run. By
 default the block node can be moved to other AioContexts later and the
 export will follow. The fixed-iothread option forces strict behavior
 that prevents changing AioContext while the export is active. See the
 QAPI docs for details.
-Since Linux doesn't have a user API to issue zone append operations to
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-zoned devices from user space, the file-posix driver is modified to add
+Message-id: 20200929125516.186715-5-stefanha@redhat.com
-zone append emulation using regular writes. To do this, the file-posix
+[Fix stray '#' character in block-export.json and add missing "(since:
-driver tracks the wp location of all zones of the device. It uses an
+.2)" as suggested by Eric Blake.
-array of uint64_t. The most significant bit of each wp location indicates
+--Stefan]
 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: 20230407081657.17947-2-faithilikerun@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/block/block-common.h     |  14 +++
+ qapi/block-export.json               | 11 ++++++++++
- include/block/block_int-common.h |   5 +
+ block/export/export.c                | 31 +++++++++++++++++++++++++++-
- block/file-posix.c               | 173 ++++++++++++++++++++++++++++++-
+ block/export/vhost-user-blk-server.c |  5 ++++-
-files changed, 189 insertions(+), 3 deletions(-)
+ nbd/server.c                         |  2 --
 files changed, 45 insertions(+), 4 deletions(-)
-diff --git a/include/block/block-common.h b/include/block/block-common.h
+diff --git a/qapi/block-export.json b/qapi/block-export.json
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/block-common.h
+--- a/qapi/block-export.json
-+++ b/include/block/block-common.h
++++ b/qapi/block-export.json
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockZoneDescriptor {
+@@ -XXX,XX +XXX,XX @@
-     BlockZoneState state;
+ #                export before completion is signalled. (since: 5.2;
- } BlockZoneDescriptor;
+ #                default: false)
+ #
-+/*
++# @iothread: The name of the iothread object where the export will run. The
-+ * Track write pointers of a zone in bytes.
++#            default is to use the thread currently associated with the
-+ */
++#            block node. (since: 5.2)
-+typedef struct BlockZoneWps {
++#
-+    CoMutex colock;
++# @fixed-iothread: True prevents the block node from being moved to another
-+    uint64_t wp[];
++#                  thread while the export is active. If true and @iothread is
-+} BlockZoneWps;
++#                  given, export creation fails if the block node cannot be
 +#                  moved to the iothread. The default is false. (since: 5.2)
 +#
  # Since: 4.2
  ##
  { 'union': 'BlockExportOptions',
    'base': { 'type': 'BlockExportType',
              'id': 'str',
 +        '*fixed-iothread': 'bool',
 +        '*iothread': 'str',
              'node-name': 'str',
              '*writable': 'bool',
              '*writethrough': 'bool' },
 diff --git a/block/export/export.c b/block/export/export.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/export/export.c
 +++ b/block/export/export.c
@@ -XXX,XX +XXX,XX @@
  #include "block/block.h"
  #include "sysemu/block-backend.h"
 +#include "sysemu/iothread.h"
  #include "block/export.h"
  #include "block/nbd.h"
  #include "qapi/error.h"
@@ -XXX,XX +XXX,XX @@ static const BlockExportDriver *blk_exp_find_driver(BlockExportType type)
  BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
  {
 +    bool fixed_iothread = export->has_fixed_iothread && export->fixed_iothread;
      const BlockExportDriver *drv;
      BlockExport *exp = NULL;
      BlockDriverState *bs;
 -    BlockBackend *blk;
 +    BlockBackend *blk = NULL;
      AioContext *ctx;
      uint64_t perm;
      int ret;
@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
      ctx = bdrv_get_aio_context(bs);
      aio_context_acquire(ctx);
 +    if (export->has_iothread) {
 +        IOThread *iothread;
 +        AioContext *new_ctx;
 +
- typedef struct BlockDriverInfo {
++        iothread = iothread_by_id(export->iothread);
-     /* in bytes, 0 if irrelevant */
++        if (!iothread) {
-     int cluster_size;
++            error_setg(errp, "iothread \"%s\" not found", export->iothread);
-@@ -XXX,XX +XXX,XX @@ typedef enum {
++            goto fail;
  #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)
  #endif
  }
 +#if defined(CONFIG_BLKZONED)
 +/*
 + * If the reset_all flag is true, then the wps of zone whose state is
 + * not readonly or offline should be all reset to the start sector.
 + * Else, take the real wp of the device.
 + */
 +static int get_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
 +                        unsigned int nrz, bool reset_all)
 +{
 +    struct blk_zone *blkz;
 +    size_t rep_size;
 +    uint64_t sector = offset >> BDRV_SECTOR_BITS;
 +    BlockZoneWps *wps = bs->wps;
 +    int j = offset / bs->bl.zone_size;
 +    int ret, n = 0, i = 0;
 +    rep_size = sizeof(struct blk_zone_report) + nrz * sizeof(struct blk_zone);
 +    g_autofree struct blk_zone_report *rep = NULL;
 +
 +    rep = g_malloc(rep_size);
 +    blkz = (struct blk_zone *)(rep + 1);
 +    while (n < nrz) {
 +        memset(rep, 0, rep_size);
 +        rep->sector = sector;
 +        rep->nr_zones = nrz - n;
 +
 +        do {
 +            ret = ioctl(fd, BLKREPORTZONE, rep);
 +        } while (ret != 0 && errno == EINTR);
 +        if (ret != 0) {
 +            error_report("%d: ioctl BLKREPORTZONE at %" PRId64 " failed %d",
 +                    fd, offset, errno);
 +            return -errno;
 +        }
 +
-+        if (!rep->nr_zones) {
++        new_ctx = iothread_get_aio_context(iothread);
 +            break;
 +        }
 +
-+        for (i = 0; i < rep->nr_zones; ++i, ++n, ++j) {
++        ret = bdrv_try_set_aio_context(bs, new_ctx, errp);
-+            /*
++        if (ret == 0) {
-+             * The wp tracking cares only about sequential writes required and
++            aio_context_release(ctx);
-+             * sequential write preferred zones so that the wp can advance to
++            aio_context_acquire(new_ctx);
-+             * the right location.
++            ctx = new_ctx;
-+             * Use the most significant bit of the wp location to indicate the
++        } else if (fixed_iothread) {
-+             * zone type: 0 for SWR/SWP zones and 1 for conventional zones.
++            goto fail;
 +             */
 +            if (blkz[i].type == BLK_ZONE_TYPE_CONVENTIONAL) {
 +                wps->wp[j] |= 1ULL << 63;
 +            } else {
 +                switch(blkz[i].cond) {
 +                case BLK_ZONE_COND_FULL:
 +                case BLK_ZONE_COND_READONLY:
 +                    /* Zone not writable */
 +                    wps->wp[j] = (blkz[i].start + blkz[i].len) << BDRV_SECTOR_BITS;
 +                    break;
 +                case BLK_ZONE_COND_OFFLINE:
 +                    /* Zone not writable nor readable */
 +                    wps->wp[j] = (blkz[i].start) << BDRV_SECTOR_BITS;
 +                    break;
 +                default:
 +                    if (reset_all) {
 +                        wps->wp[j] = blkz[i].start << BDRV_SECTOR_BITS;
 +                    } else {
 +                        wps->wp[j] = blkz[i].wp << BDRV_SECTOR_BITS;
 +                    }
 +                    break;
 +                }
 +            }
 +        }
 +        sector = blkz[i - 1].start + blkz[i - 1].len;
 +    }
 +
 +    return 0;
 +}
 +
 +static void update_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
 +                            unsigned int nrz)
 +{
 +    if (get_zones_wp(bs, fd, offset, nrz, 0) < 0) {
 +        error_report("update zone wp failed");
 +    }
 +}
 +#endif
 +
  static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
  {
      BDRVRawState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
          if (ret >= 0) {
              bs->bl.max_active_zones = ret;
          }
 +
 +        ret = get_sysfs_long_val(&st, "physical_block_size");
 +        if (ret >= 0) {
 +            bs->bl.write_granularity = ret;
 +        }
 +
 +        /* The refresh_limits() function can be called multiple times. */
 +        g_free(bs->wps);
 +        bs->wps = g_malloc(sizeof(BlockZoneWps) +
 +                sizeof(int64_t) * bs->bl.nr_zones);
 +        ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 0);
 +        if (ret < 0) {
 +            error_setg_errno(errp, -ret, "report wps failed");
 +            bs->wps = NULL;
 +            return;
 +        }
 +        qemu_co_mutex_init(&bs->wps->colock);
          return;
      }
  out:
@@ -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,
      } else if (s->use_linux_io_uring) {
          LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
          assert(qiov->size == bytes);
 -        return luring_co_submit(bs, aio, s->fd, offset, qiov, type);
 +        ret = luring_co_submit(bs, aio, s->fd, offset, qiov, type);
 +        goto out;
  #endif
  #ifdef CONFIG_LINUX_AIO
      } else if (s->use_linux_aio) {
          LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
          assert(qiov->size == bytes);
 -        return laio_co_submit(bs, aio, s->fd, offset, qiov, type,
 +        ret = laio_co_submit(bs, aio, s->fd, offset, qiov, type,
                                s->aio_max_batch);
 +        goto out;
  #endif
      }
@@ -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(bs, handle_aiocb_rw, &acb);
 +    ret = raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
 +
 +out:
 +#if defined(CONFIG_BLKZONED)
 +    BlockZoneWps *wps = bs->wps;
 +    if (ret == 0) {
 +        if (type & QEMU_AIO_WRITE && wps && bs->bl.zone_size) {
 +            uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
 +            if (!BDRV_ZT_IS_CONV(*wp)) {
 +                /* Advance the wp if needed */
 +                if (offset + bytes > *wp) {
 +                    *wp = offset + bytes;
 +                }
 +            }
 +        }
 +    } else {
 +        if (type & QEMU_AIO_WRITE) {
 +            update_zones_wp(bs, s->fd, 0, 1);
 +        }
 +    }
 +
-+    if (type & QEMU_AIO_WRITE && wps) {
+     /*
-+        qemu_co_mutex_unlock(&wps->colock);
+      * Block exports are used for non-shared storage migration. Make sure
-+    }
+      * that BDRV_O_INACTIVE is cleared and the image is ready for write
-+#endif
+@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
 +    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;
+     blk = blk_new(ctx, perm, BLK_PERM_ALL);
-     unsigned long zo;
++
-     int ret;
++    if (!fixed_iothread) {
-+    BlockZoneWps *wps = bs->wps;
++        blk_set_allow_aio_context_change(blk, true);
      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;
      }
 +    QEMU_LOCK_GUARD(&wps->colock);
 +    uint32_t i = offset / bs->bl.zone_size;
 +    uint32_t nrz = len / bs->bl.zone_size;
 +    uint64_t *wp = &wps->wp[i];
 +    if (BDRV_ZT_IS_CONV(*wp) && len != capacity) {
 +        error_report("zone mgmt operations are not allowed for conventional zones");
 +        return -EIO;
 +    }
 +
-     switch (op) {
+     ret = blk_insert_bs(blk, bs, errp);
-     case BLK_ZO_OPEN:
+     if (ret < 0) {
-         op_name = "BLKOPENZONE";
+         goto fail;
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_mgmt(BlockDriverState *bs, BlockZoneOp op,
+diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
-                         len >> BDRV_SECTOR_BITS);
+index XXXXXXX..XXXXXXX 100644
-     ret = raw_thread_pool_submit(bs, handle_aiocb_zone_mgmt, &acb);
+--- a/block/export/vhost-user-blk-server.c
-     if (ret != 0) {
++++ b/block/export/vhost-user-blk-server.c
-+        update_zones_wp(bs, s->fd, offset, i);
+@@ -XXX,XX +XXX,XX @@ static const VuDevIface vu_blk_iface = {
-         error_report("ioctl %s failed %d", op_name, ret);
+ static void blk_aio_attached(AioContext *ctx, void *opaque)
-+        return ret;
+ {
-+    }
+     VuBlkExport *vexp = opaque;
 +
-+    if (zo == BLKRESETZONE && len == capacity) {
++    vexp->export.ctx = ctx;
-+        ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 1);
+     vhost_user_server_attach_aio_context(&vexp->vu_server, ctx);
-+        if (ret < 0) {
+ }
-+            error_report("reporting single wp failed");
-+            return ret;
+ static void blk_aio_detach(void *opaque)
-+        }
+ {
-+    } else if (zo == BLKRESETZONE) {
+     VuBlkExport *vexp = opaque;
-+        for (int j = 0; j < nrz; ++j) {
++
-+            wp[j] = offset + j * zone_size;
+     vhost_user_server_detach_aio_context(&vexp->vu_server);
-+        }
++    vexp->export.ctx = NULL;
-+    } else if (zo == BLKFINISHZONE) {
+ }
-+        for (int j = 0; j < nrz; ++j) {
-+            /* The zoned device allows the last zone smaller that the
+ static void
-+             * zone size. */
+@@ -XXX,XX +XXX,XX @@ static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
-+            wp[j] = MIN(offset + (j + 1) * zone_size, offset + len);
+     vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
-+        }
+                                logical_block_size);
 -    blk_set_allow_aio_context_change(exp->blk, true);
      blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
                                   vexp);
 diff --git a/nbd/server.c b/nbd/server.c
 index XXXXXXX..XXXXXXX 100644
 --- a/nbd/server.c
 +++ b/nbd/server.c
@@ -XXX,XX +XXX,XX @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
          return ret;
      }
-     return ret;
+-    blk_set_allow_aio_context_change(blk, true);
 -
      QTAILQ_INIT(&exp->clients);
      exp->name = g_strdup(arg->name);
      exp->description = g_strdup(arg->description);
 --
-.39.2
+.26.2

-[PULL 09/20] block/dmg: Declare a type definition for DMG uncompress function
+[PULL v2 23/28] block/export: add vhost-user-blk multi-queue support
-From: Philippe Mathieu-Daudé <philmd@linaro.org>
+Allow the number of queues to be configured using --export
 vhost-user-blk,num-queues=N. This setting should match the QEMU --device
 vhost-user-blk-pci,num-queues=N setting but QEMU vhost-user-blk.c lowers
 its own value if the vhost-user-blk backend offers fewer queues than
 QEMU.
-Introduce the BdrvDmgUncompressFunc type defintion. To emphasis
+The vhost-user-blk-server.c code is already capable of multi-queue. All
-dmg_uncompress_bz2 and dmg_uncompress_lzfse are pointer to functions,
+virtqueue processing runs in the same AioContext. No new locking is
-declare them using this new typedef.
+needed.
-Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>
+Add the num-queues=N option and set the VIRTIO_BLK_F_MQ feature bit.
-Message-id: 20230320152610.32052-1-philmd@linaro.org
+Note that the feature bit only announces the presence of the num_queues
 configuration space field. It does not promise that there is more than 1
 virtqueue, so we can set it unconditionally.
 I tested multi-queue by running a random read fio test with numjobs=4 on
 an -smp 4 guest. After the benchmark finished the guest /proc/interrupts
 file showed activity on all 4 virtio-blk MSI-X. The /sys/block/vda/mq/
 directory shows that Linux blk-mq has 4 queues configured.
 An automated test is included in the next commit.
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Acked-by: Markus Armbruster <armbru@redhat.com>
 Message-id: 20201001144604.559733-2-stefanha@redhat.com
 [Fixed accidental tab characters as suggested by Markus Armbruster
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/dmg.h | 8 ++++----
+ qapi/block-export.json               | 10 +++++++---
- block/dmg.c | 7 ++-----
+ block/export/vhost-user-blk-server.c | 24 ++++++++++++++++++------
-files changed, 6 insertions(+), 9 deletions(-)
+files changed, 25 insertions(+), 9 deletions(-)
-diff --git a/block/dmg.h b/block/dmg.h
+diff --git a/qapi/block-export.json b/qapi/block-export.json
 index XXXXXXX..XXXXXXX 100644
---- a/block/dmg.h
+--- a/qapi/block-export.json
-+++ b/block/dmg.h
++++ b/qapi/block-export.json
-@@ -XXX,XX +XXX,XX @@ typedef struct BDRVDMGState {
+@@ -XXX,XX +XXX,XX @@
-     z_stream zstream;
+ #        SocketAddress types are supported. Passed fds must be UNIX domain
- } BDRVDMGState;
+ #        sockets.
+ # @logical-block-size: Logical block size in bytes. Defaults to 512 bytes.
--extern int (*dmg_uncompress_bz2)(char *next_in, unsigned int avail_in,
++# @num-queues: Number of request virtqueues. Must be greater than 0. Defaults
--                                 char *next_out, unsigned int avail_out);
++#              to 1.
-+typedef int BdrvDmgUncompressFunc(char *next_in, unsigned int avail_in,
+ #
-+                                  char *next_out, unsigned int avail_out);
+ # Since: 5.2
+ ##
--extern int (*dmg_uncompress_lzfse)(char *next_in, unsigned int avail_in,
+ { 'struct': 'BlockExportOptionsVhostUserBlk',
--                                   char *next_out, unsigned int avail_out);
+-  'data': { 'addr': 'SocketAddress', '*logical-block-size': 'size' } }
-+extern BdrvDmgUncompressFunc *dmg_uncompress_bz2;
++  'data': { 'addr': 'SocketAddress',
-+extern BdrvDmgUncompressFunc *dmg_uncompress_lzfse;
++        '*logical-block-size': 'size',
++            '*num-queues': 'uint16'} }
- #endif
-diff --git a/block/dmg.c b/block/dmg.c
+ ##
  # @NbdServerAddOptions:
@@ -XXX,XX +XXX,XX @@
  { 'union': 'BlockExportOptions',
    'base': { 'type': 'BlockExportType',
              'id': 'str',
 -        '*fixed-iothread': 'bool',
 -        '*iothread': 'str',
 +            '*fixed-iothread': 'bool',
 +            '*iothread': 'str',
              'node-name': 'str',
              '*writable': 'bool',
              '*writethrough': 'bool' },
 diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/dmg.c
+--- a/block/export/vhost-user-blk-server.c
-+++ b/block/dmg.c
++++ b/block/export/vhost-user-blk-server.c
 @@ -XXX,XX +XXX,XX @@
- #include "qemu/memalign.h"
+ #include "util/block-helpers.h"
  #include "dmg.h"
 -int (*dmg_uncompress_bz2)(char *next_in, unsigned int avail_in,
 -                          char *next_out, unsigned int avail_out);
 -
 -int (*dmg_uncompress_lzfse)(char *next_in, unsigned int avail_in,
 -                            char *next_out, unsigned int avail_out);
 +BdrvDmgUncompressFunc *dmg_uncompress_bz2;
 +BdrvDmgUncompressFunc *dmg_uncompress_lzfse;
  enum {
-     /* Limit chunk sizes to prevent unreasonable amounts of memory being used
+-    VHOST_USER_BLK_MAX_QUEUES = 1,
 +    VHOST_USER_BLK_NUM_QUEUES_DEFAULT = 1,
  };
  struct virtio_blk_inhdr {
      unsigned char status;
@@ -XXX,XX +XXX,XX @@ static uint64_t vu_blk_get_features(VuDev *dev)
 ull << VIRTIO_BLK_F_DISCARD |
 ull << VIRTIO_BLK_F_WRITE_ZEROES |
 ull << VIRTIO_BLK_F_CONFIG_WCE |
 +               1ull << VIRTIO_BLK_F_MQ |
 ull << VIRTIO_F_VERSION_1 |
 ull << VIRTIO_RING_F_INDIRECT_DESC |
 ull << VIRTIO_RING_F_EVENT_IDX |
@@ -XXX,XX +XXX,XX @@ static void blk_aio_detach(void *opaque)
  static void
  vu_blk_initialize_config(BlockDriverState *bs,
 -                           struct virtio_blk_config *config, uint32_t blk_size)
 +                         struct virtio_blk_config *config,
 +                         uint32_t blk_size,
 +                         uint16_t num_queues)
  {
      config->capacity = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
      config->blk_size = blk_size;
@@ -XXX,XX +XXX,XX @@ vu_blk_initialize_config(BlockDriverState *bs,
      config->seg_max = 128 - 2;
      config->min_io_size = 1;
      config->opt_io_size = 1;
 -    config->num_queues = VHOST_USER_BLK_MAX_QUEUES;
 +    config->num_queues = num_queues;
      config->max_discard_sectors = 32768;
      config->max_discard_seg = 1;
      config->discard_sector_alignment = config->blk_size >> 9;
@@ -XXX,XX +XXX,XX @@ static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
      BlockExportOptionsVhostUserBlk *vu_opts = &opts->u.vhost_user_blk;
      Error *local_err = NULL;
      uint64_t logical_block_size;
 +    uint16_t num_queues = VHOST_USER_BLK_NUM_QUEUES_DEFAULT;
      vexp->writable = opts->writable;
      vexp->blkcfg.wce = 0;
@@ -XXX,XX +XXX,XX @@ static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
      }
      vexp->blk_size = logical_block_size;
      blk_set_guest_block_size(exp->blk, logical_block_size);
 +
 +    if (vu_opts->has_num_queues) {
 +        num_queues = vu_opts->num_queues;
 +    }
 +    if (num_queues == 0) {
 +        error_setg(errp, "num-queues must be greater than 0");
 +        return -EINVAL;
 +    }
 +
      vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
 -                               logical_block_size);
 +                             logical_block_size, num_queues);
      blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
                                   vexp);
      if (!vhost_user_server_start(&vexp->vu_server, vu_opts->addr, exp->ctx,
 -                                 VHOST_USER_BLK_MAX_QUEUES, &vu_blk_iface,
 -                                 errp)) {
 +                                 num_queues, &vu_blk_iface, errp)) {
          blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
                                          blk_aio_detach, vexp);
          return -EADDRNOTAVAIL;
 --
-.39.2
+.26.2

-[PULL 02/20] block/file-posix: introduce helper functions for sysfs attributes
+[PULL v2 24/28] block/io: fix bdrv_co_block_status_above
-From: Sam Li <faithilikerun@gmail.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Use get_sysfs_str_val() to get the string value of device
+bdrv_co_block_status_above has several design problems with handling
-zoned model. Then get_sysfs_zoned_model() can convert it to
+short backing files:
 BlockZoneModel type of QEMU.
-Use get_sysfs_long_val() to get the long value of zoned device
+. With want_zeros=true, it may return ret with BDRV_BLOCK_ZERO but
-information.
+without BDRV_BLOCK_ALLOCATED flag, when actually short backing file
 which produces these after-EOF zeros is inside requested backing
 sequence.
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+. With want_zero=false, it may return pnum=0 prior to actual EOF,
-Reviewed-by: Hannes Reinecke <hare@suse.de>
+because of EOF of short backing file.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
+Fix these things, making logic about short backing files clearer.
-Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
-Acked-by: Kevin Wolf <kwolf@redhat.com>
+With fixed bdrv_block_status_above we also have to improve is_zero in
-Message-id: 20230324090605.28361-3-faithilikerun@gmail.com
+qcow2 code, otherwise iotest 154 will fail, because with this patch we
-[Adjust commit message prefix as suggested by Philippe Mathieu-Daudé
+stop to merge zeros of different types (produced by fully unallocated
-<philmd@linaro.org>.
+in the whole backing chain regions vs produced by short backing files).
 Note also, that this patch leaves for another day the general problem
 around block-status: misuse of BDRV_BLOCK_ALLOCATED as is-fs-allocated
 vs go-to-backing.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Message-id: 20200924194003.22080-2-vsementsov@virtuozzo.com
 [Fix s/comes/come/ as suggested by Eric Blake
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/block/block_int-common.h |   3 +
+ block/io.c    | 68 ++++++++++++++++++++++++++++++++++++++++-----------
- block/file-posix.c               | 130 ++++++++++++++++++++++---------
+ block/qcow2.c | 16 ++++++++++--
-files changed, 95 insertions(+), 38 deletions(-)
+files changed, 68 insertions(+), 16 deletions(-)
-diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/block_int-common.h
+--- a/block/io.c
-+++ b/include/block/block_int-common.h
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockLimits {
+@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
-      * an explicit monitor command to load the disk inside the guest).
+                                   int64_t *map,
-      */
+                                   BlockDriverState **file)
-     bool has_variable_length;
+ {
 +    int ret;
      BlockDriverState *p;
 -    int ret = 0;
 -    bool first = true;
 +    int64_t eof = 0;
      assert(bs != base);
 -    for (p = bs; p != base; p = bdrv_filter_or_cow_bs(p)) {
 +
-+    /* device zone model */
++    ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);
-+    BlockZoneModel zoned;
++    if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED) {
  } 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) {
++    if (ret & BDRV_BLOCK_EOF) {
-+        *zoned = BLK_Z_HM;
++        eof = offset + *pnum;
 +    } 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. */
++    assert(*pnum <= bytes);
-+    ret = qemu_strtol(str, &end, 10, &val);
++    bytes = *pnum;
-+    if (ret == 0 && end && *end == '\0') {
++
-+        ret = val;
++    for (p = bdrv_filter_or_cow_bs(bs); p != base;
 +         p = bdrv_filter_or_cow_bs(p))
 +    {
          ret = bdrv_co_block_status(p, want_zero, offset, bytes, pnum, map,
                                     file);
          if (ret < 0) {
 -            break;
 +            return ret;
          }
 -        if (ret & BDRV_BLOCK_ZERO && ret & BDRV_BLOCK_EOF && !first) {
 +        if (*pnum == 0) {
              /*
 -             * Reading beyond the end of the file continues to read
 -             * zeroes, but we can only widen the result to the
 -             * unallocated length we learned from an earlier
 -             * iteration.
 +             * The top layer deferred to this layer, and because this layer is
 +             * short, any zeroes that we synthesize beyond EOF behave as if they
 +             * were allocated at this layer.
 +             *
 +             * We don't include BDRV_BLOCK_EOF into ret, as upper layer may be
 +             * larger. We'll add BDRV_BLOCK_EOF if needed at function end, see
 +             * below.
               */
 +            assert(ret & BDRV_BLOCK_EOF);
              *pnum = bytes;
 +            if (file) {
 +                *file = p;
 +            }
 +            ret = BDRV_BLOCK_ZERO | BDRV_BLOCK_ALLOCATED;
 +            break;
          }
 -        if (ret & (BDRV_BLOCK_ZERO | BDRV_BLOCK_DATA)) {
 +        if (ret & BDRV_BLOCK_ALLOCATED) {
 +            /*
 +             * We've found the node and the status, we must break.
 +             *
 +             * Drop BDRV_BLOCK_EOF, as it's not for upper layer, which may be
 +             * larger. We'll add BDRV_BLOCK_EOF if needed at function end, see
 +             * below.
 +             */
 +            ret &= ~BDRV_BLOCK_EOF;
              break;
          }
 -        /* [offset, pnum] unallocated on this layer, which could be only
 -         * the first part of [offset, bytes].  */
 -        bytes = MIN(bytes, *pnum);
 -        first = false;
 +
 +        /*
 +         * OK, [offset, offset + *pnum) region is unallocated on this layer,
 +         * let's continue the diving.
 +         */
 +        assert(*pnum <= bytes);
 +        bytes = *pnum;
 +    }
-+    return ret;
-+#else
-+    return -ENOTSUP;
-+#endif
-+}
 +
-+static int hdev_get_max_segments(int fd, struct stat *st)
++    if (offset + *pnum == eof) {
-+{
++        ret |= BDRV_BLOCK_EOF;
 +#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
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
  {
      BDRVRawState *s = bs->opaque;
      struct stat st;
 +    int ret;
 +    BlockZoneModel zoned;
      s->needs_alignment = raw_needs_alignment(bs);
      raw_probe_alignment(bs, s->fd, errp);
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
              bs->bl.max_hw_iov = ret;
          }
      }
 +
-+    ret = get_sysfs_zoned_model(&st, &zoned);
+     return ret;
 +    if (ret < 0) {
 +        zoned = BLK_Z_NONE;
 +    }
 +    bs->bl.zoned = zoned;
  }
- static int check_for_dasd(int fd)
+diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)
      if (!bytes) {
          return true;
      }
 -    res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
 -    return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == bytes;
 +
 +    /*
 +     * bdrv_block_status_above doesn't merge different types of zeros, for
 +     * example, zeros which come from the region which is unallocated in
 +     * the whole backing chain, and zeros which come because of a short
 +     * backing file. So, we need a loop.
 +     */
 +    do {
 +        res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
 +        offset += nr;
 +        bytes -= nr;
 +    } while (res >= 0 && (res & BDRV_BLOCK_ZERO) && nr && bytes);
 +
 +    return res >= 0 && (res & BDRV_BLOCK_ZERO) && bytes == 0;
  }
  static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,
 --
-.39.2
+.26.2

-[PULL 14/20] block: add some trace events for zone append
+[PULL v2 25/28] block/io: bdrv_common_block_status_above: support include_base
-From: Sam Li <faithilikerun@gmail.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+In order to reuse bdrv_common_block_status_above in
-Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
+bdrv_is_allocated_above, let's support include_base parameter.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-id: 20230407081657.17947-5-faithilikerun@gmail.com
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Message-id: 20200924194003.22080-3-vsementsov@virtuozzo.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/file-posix.c | 3 +++
+ block/coroutines.h |  2 ++
- block/trace-events | 2 ++
+ block/io.c         | 21 ++++++++++++++-------
-files changed, 5 insertions(+)
+files changed, 16 insertions(+), 7 deletions(-)
-diff --git a/block/file-posix.c b/block/file-posix.c
+diff --git a/block/coroutines.h b/block/coroutines.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/file-posix.c
+--- a/block/coroutines.h
-+++ b/block/file-posix.c
++++ b/block/coroutines.h
-@@ -XXX,XX +XXX,XX @@ out:
+@@ -XXX,XX +XXX,XX @@ bdrv_pwritev(BdrvChild *child, int64_t offset, unsigned int bytes,
-             if (!BDRV_ZT_IS_CONV(*wp)) {
+ int coroutine_fn
-                 if (type & QEMU_AIO_ZONE_APPEND) {
+ bdrv_co_common_block_status_above(BlockDriverState *bs,
-                     *s->offset = *wp;
+                                   BlockDriverState *base,
-+                    trace_zbd_zone_append_complete(bs, *s->offset
++                                  bool include_base,
-+                        >> BDRV_SECTOR_BITS);
+                                   bool want_zero,
-                 }
+                                   int64_t offset,
-                 /* Advance the wp if needed */
+                                   int64_t bytes,
-                 if (offset + bytes > *wp) {
+@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_zone_append(BlockDriverState *bs,
+ int generated_co_wrapper
-         len += iov_len;
+ bdrv_common_block_status_above(BlockDriverState *bs,
                                 BlockDriverState *base,
 +                               bool include_base,
                                 bool want_zero,
                                 int64_t offset,
                                 int64_t bytes,
 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 @@ early_out:
  int coroutine_fn
  bdrv_co_common_block_status_above(BlockDriverState *bs,
                                    BlockDriverState *base,
 +                                  bool include_base,
                                    bool want_zero,
                                    int64_t offset,
                                    int64_t bytes,
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
      BlockDriverState *p;
      int64_t eof = 0;
 -    assert(bs != base);
 +    assert(include_base || bs != base);
 +    assert(!include_base || base); /* Can't include NULL base */
      ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);
 -    if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED) {
 +    if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED || bs == base) {
          return ret;
      }
-+    trace_zbd_zone_append(bs, *offset >> BDRV_SECTOR_BITS);
+@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
-     return raw_co_prw(bs, *offset, len, qiov, QEMU_AIO_ZONE_APPEND);
+     assert(*pnum <= bytes);
      bytes = *pnum;
 -    for (p = bdrv_filter_or_cow_bs(bs); p != base;
 +    for (p = bdrv_filter_or_cow_bs(bs); include_base || p != base;
           p = bdrv_filter_or_cow_bs(p))
      {
          ret = bdrv_co_block_status(p, want_zero, offset, bytes, pnum, map,
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
              break;
          }
 +        if (p == base) {
 +            assert(include_base);
 +            break;
 +        }
 +
          /*
           * OK, [offset, offset + *pnum) region is unallocated on this layer,
           * let's continue the diving.
@@ -XXX,XX +XXX,XX @@ int bdrv_block_status_above(BlockDriverState *bs, BlockDriverState *base,
                              int64_t offset, int64_t bytes, int64_t *pnum,
                              int64_t *map, BlockDriverState **file)
  {
 -    return bdrv_common_block_status_above(bs, base, true, offset, bytes,
 +    return bdrv_common_block_status_above(bs, base, false, true, offset, bytes,
                                            pnum, map, file);
  }
- #endif
-diff --git a/block/trace-events b/block/trace-events
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,
-index XXXXXXX..XXXXXXX 100644
+     int ret;
---- a/block/trace-events
+     int64_t dummy;
-+++ b/block/trace-events
-@@ -XXX,XX +XXX,XX @@ file_hdev_is_sg(int type, int version) "SG device found: type=%d, version=%d"
+-    ret = bdrv_common_block_status_above(bs, bdrv_filter_or_cow_bs(bs), false,
- file_flush_fdatasync_failed(int err) "errno %d"
+-                                         offset, bytes, pnum ? pnum : &dummy,
- zbd_zone_report(void *bs, unsigned int nr_zones, int64_t sector) "bs %p report %d zones starting at sector offset 0x%" PRIx64 ""
+-                                         NULL, NULL);
- 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"
++    ret = bdrv_common_block_status_above(bs, bs, true, false, offset,
-+zbd_zone_append(void *bs, int64_t sector) "bs %p append at sector offset 0x%" PRIx64 ""
++                                         bytes, pnum ? pnum : &dummy, NULL,
-+zbd_zone_append_complete(void *bs, int64_t sector) "bs %p returns append sector 0x%" PRIx64 ""
++                                         NULL);
+     if (ret < 0) {
- # ssh.c
+         return ret;
- 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)"
+     }
 --
-.39.2
+.26.2

-[PULL 12/20] block: introduce zone append write for zoned devices
+[PULL v2 26/28] block/io: bdrv_common_block_status_above: support bs == base
-From: Sam Li <faithilikerun@gmail.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-A zone append command is a write operation that specifies the first
+We are going to reuse bdrv_common_block_status_above in
-logical block of a zone as the write position. When writing to a zoned
+bdrv_is_allocated_above. bdrv_is_allocated_above may be called with
-block device using zone append, the byte offset of the call may point at
+include_base == false and still bs == base (for ex. from img_rebase()).
 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>
+So, support this corner case.
-Reviewed-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-id: 20230407081657.17947-3-faithilikerun@gmail.com
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Message-id: 20200924194003.22080-4-vsementsov@virtuozzo.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/block/block-io.h          |  4 +++
+ block/io.c | 6 +++++-
- include/block/block_int-common.h  |  3 ++
+file changed, 5 insertions(+), 1 deletion(-)
  include/block/raw-aio.h           |  4 ++-
  include/sysemu/block-backend-io.h |  9 +++++
  block/block-backend.c             | 60 +++++++++++++++++++++++++++++++
  block/file-posix.c                | 58 ++++++++++++++++++++++++++----
  block/io.c                        | 27 ++++++++++++++
  block/io_uring.c                  |  4 +++
  block/linux-aio.c                 |  3 ++
  block/raw-format.c                |  8 +++++
 files changed, 172 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 *)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)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);
-+    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:
- #if defined(CONFIG_BLKZONED)
-     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);
-     }
- #endif
-@@ -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:
+@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
-     return co.ret;
+     BlockDriverState *p;
- }
+     int64_t eof = 0;
-+int coroutine_fn bdrv_co_zone_append(BlockDriverState *bs, int64_t *offset,
+-    assert(include_base || bs != base);
-+                        QEMUIOVector *qiov,
+     assert(!include_base || base); /* Can't include NULL base */
-+                        BdrvRequestFlags flags)
-+{
++    if (!include_base && bs == base) {
-+    int ret;
++        *pnum = bytes;
-+    BlockDriver *drv = bs->drv;
++        return 0;
 +    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);
+     ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);
-+    if (!drv || !drv->bdrv_co_zone_append || bs->bl.zoned == BLK_Z_NONE) {
+     if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED || bs == base) {
-+        co.ret = -ENOTSUP;
+         return ret;
 +        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,
 --
-.39.2
+.26.2

-[PULL 03/20] block/block-backend: add block layer APIs resembling Linux ZonedBlockDevice ioctls
+[PULL v2 27/28] block/io: fix bdrv_is_allocated_above
-From: Sam Li <faithilikerun@gmail.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Add zoned device option to host_device BlockDriver. It will be presented only
+bdrv_is_allocated_above wrongly handles short backing files: it reports
-for zoned host block devices. By adding zone management operations to the
+after-EOF space as UNALLOCATED which is wrong, as on read the data is
-host_block_device BlockDriver, users can use the new block layer APIs
+generated on the level of short backing file (if all overlays have
-including Report Zone and four zone management operations
+unallocated areas at that place).
 (open, close, finish, reset, reset_all).
-Qemu-io uses the new APIs to perform zoned storage commands of the device:
+Reusing bdrv_common_block_status_above fixes the issue and unifies code
-zone_report(zrp), zone_open(zo), zone_close(zc), zone_reset(zrs),
+path.
 zone_finish(zf).
-For example, to test zone_report, use following command:
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-$ ./build/qemu-io --image-opts -n driver=host_device, filename=/dev/nullb0
+Reviewed-by: Eric Blake <eblake@redhat.com>
--c "zrp offset nr_zones"
+Reviewed-by: Alberto Garcia <berto@igalia.com>
+Message-id: 20200924194003.22080-5-vsementsov@virtuozzo.com
-Signed-off-by: Sam Li <faithilikerun@gmail.com>
+[Fix s/has/have/ as suggested by Eric Blake. Fix s/area/areas/.
 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>
 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 +
+ block/io.c | 43 +++++--------------------------------------
- include/block/block-io.h          |   9 +
+file changed, 5 insertions(+), 38 deletions(-)
  include/block/block_int-common.h  |  21 ++
  include/block/raw-aio.h           |   6 +-
  include/sysemu/block-backend-io.h |  18 ++
  block/block-backend.c             | 133 +++++++++++++
  block/file-posix.c                | 306 +++++++++++++++++++++++++++++-
  block/io.c                        |  41 ++++
  qemu-io-cmds.c                    | 149 +++++++++++++++
 files changed, 684 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*)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)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)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 *)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);
-+    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);
-+
-+    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 void raw_refresh_limits(BlockDriverState *bs, Error **errp)
-         zoned = BLK_Z_NONE;
-     }
-     bs->bl.zoned = zoned;
-+    if (zoned != BLK_Z_NONE) {
-+        /*
-+         * 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");
-+            goto out;
-+        } else if (!ret) {
-+            error_setg(errp, "Read 0 from chunk_sectors sysfs attribute");
-+            goto out;
-+        }
-+        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");
-+            goto out;
-+        } else if (!ret) {
-+            error_setg(errp, "Read 0 from nr_zones sysfs attribute");
-+            goto out;
-+        }
-+        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;
-+        }
-+
-+        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;
-+        }
-+        return;
-+    }
-+out:
-+    bs->bl.zoned = BLK_Z_NONE;
- }
- static int check_for_dasd(int fd)
-@@ -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, 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(bs, 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(bs, 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:
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,
-     return co.ret;
+  * at 'offset + *pnum' may return the same allocation status (in other
   * words, the result is not necessarily the maximum possible range);
   * but 'pnum' will only be 0 when end of file is reached.
 - *
   */
  int bdrv_is_allocated_above(BlockDriverState *top,
                              BlockDriverState *base,
                              bool include_base, int64_t offset,
                              int64_t bytes, int64_t *pnum)
  {
 -    BlockDriverState *intermediate;
 -    int ret;
 -    int64_t n = bytes;
 -
 -    assert(base || !include_base);
 -
 -    intermediate = top;
 -    while (include_base || intermediate != base) {
 -        int64_t pnum_inter;
 -        int64_t size_inter;
 -
 -        assert(intermediate);
 -        ret = bdrv_is_allocated(intermediate, offset, bytes, &pnum_inter);
 -        if (ret < 0) {
 -            return ret;
 -        }
 -        if (ret) {
 -            *pnum = pnum_inter;
 -            return 1;
 -        }
 -
 -        size_inter = bdrv_getlength(intermediate);
 -        if (size_inter < 0) {
 -            return size_inter;
 -        }
 -        if (n > pnum_inter &&
 -            (intermediate == top || offset + pnum_inter < size_inter)) {
 -            n = pnum_inter;
 -        }
 -
 -        if (intermediate == base) {
 -            break;
 -        }
 -
 -        intermediate = bdrv_filter_or_cow_bs(intermediate);
 +    int ret = bdrv_common_block_status_above(top, base, include_base, false,
 +                                             offset, bytes, pnum, NULL, NULL);
 +    if (ret < 0) {
 +        return ret;
      }
 -    *pnum = n;
 -    return 0;
 +    return !!(ret & BDRV_BLOCK_ALLOCATED);
  }
-+int coroutine_fn bdrv_co_zone_report(BlockDriverState *bs, int64_t offset,
+ int coroutine_fn
 +                        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);
 --
-.39.2
+.26.2

-[PULL 10/20] tracetool: use relative paths for '#line' preprocessor directives
+[PULL v2 28/28] iotests: add commit top->base cases to 274
-From: Thomas De Schampheleire <thomas.de_schampheleire@nokia.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-The event filename is an absolute path. Convert it to a relative path when
+These cases are fixed by previous patches around block_status and
-writing '#line' directives, to preserve reproducibility of the generated
+is_allocated.
 output when different base paths are used.
-Signed-off-by: Thomas De Schampheleire <thomas.de_schampheleire@nokia.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Message-id: 20200924194003.22080-6-vsementsov@virtuozzo.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-Id: <20230406080045.21696-1-thomas.de_schampheleire@nokia.com>
 ---
- scripts/tracetool/backend/ftrace.py | 4 +++-
+ tests/qemu-iotests/274     | 20 +++++++++++
- scripts/tracetool/backend/log.py    | 4 +++-
+ tests/qemu-iotests/274.out | 68 ++++++++++++++++++++++++++++++++++++++
- scripts/tracetool/backend/syslog.py | 4 +++-
+files changed, 88 insertions(+)
 files changed, 9 insertions(+), 3 deletions(-)
-diff --git a/scripts/tracetool/backend/ftrace.py b/scripts/tracetool/backend/ftrace.py
+diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/274
 +++ b/tests/qemu-iotests/274
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('base') as base, \
      iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
      iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
 +    iotests.log('=== Testing qemu-img commit (top -> base) ===')
 +
 +    create_chain()
 +    iotests.qemu_img_log('commit', '-b', base, top)
 +    iotests.img_info_log(base)
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, base)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), base)
 +
 +    iotests.log('=== Testing QMP active commit (top -> base) ===')
 +
 +    create_chain()
 +    with create_vm() as vm:
 +        vm.launch()
 +        vm.qmp_log('block-commit', device='top', base_node='base',
 +                   job_id='job0', auto_dismiss=False)
 +        vm.run_job('job0', wait=5)
 +
 +    iotests.img_info_log(mid)
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, base)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), base)
      iotests.log('== Resize tests ==')
 diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
 index XXXXXXX..XXXXXXX 100644
---- a/scripts/tracetool/backend/ftrace.py
+--- a/tests/qemu-iotests/274.out
-+++ b/scripts/tracetool/backend/ftrace.py
++++ b/tests/qemu-iotests/274.out
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0
- __email__      = "stefanha@redhat.com"
+ read 1048576/1048576 bytes at offset 1048576
+MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+import os.path
++=== Testing qemu-img commit (top -> base) ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 lazy_refcounts=off refcount_bits=16
 +
- from tracetool import out
++Formatting 'TEST_DIR/PID-mid', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=1048576 backing_file=TEST_DIR/PID-base backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
@@ -XXX,XX +XXX,XX @@ def generate_h(event, group):
          args=event.args,
          event_id="TRACE_" + event.name.upper(),
          event_lineno=event.lineno,
 -        event_filename=event.filename,
 +        event_filename=os.path.relpath(event.filename),
          fmt=event.fmt.rstrip("\n"),
          argnames=argnames)
 diff --git a/scripts/tracetool/backend/log.py b/scripts/tracetool/backend/log.py
 index XXXXXXX..XXXXXXX 100644
 --- a/scripts/tracetool/backend/log.py
 +++ b/scripts/tracetool/backend/log.py
@@ -XXX,XX +XXX,XX @@
  __email__      = "stefanha@redhat.com"
 +import os.path
 +
- from tracetool import out
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 backing_file=TEST_DIR/PID-mid backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
@@ -XXX,XX +XXX,XX @@ def generate_h(event, group):
          '    }',
          cond=cond,
          event_lineno=event.lineno,
 -        event_filename=event.filename,
 +        event_filename=os.path.relpath(event.filename),
          name=event.name,
          fmt=event.fmt.rstrip("\n"),
          argnames=argnames)
 diff --git a/scripts/tracetool/backend/syslog.py b/scripts/tracetool/backend/syslog.py
 index XXXXXXX..XXXXXXX 100644
 --- a/scripts/tracetool/backend/syslog.py
 +++ b/scripts/tracetool/backend/syslog.py
@@ -XXX,XX +XXX,XX @@
  __email__      = "stefanha@redhat.com"
 +import os.path
 +
- from tracetool import out
++wrote 2097152/2097152 bytes at offset 0
++2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
-@@ -XXX,XX +XXX,XX @@ def generate_h(event, group):
++Image committed.
-         '    }',
++
-         cond=cond,
++image: TEST_IMG
-         event_lineno=event.lineno,
++file format: IMGFMT
--        event_filename=event.filename,
++virtual size: 2 MiB (2097152 bytes)
-+        event_filename=os.path.relpath(event.filename),
++cluster_size: 65536
-         name=event.name,
++Format specific information:
-         fmt=event.fmt.rstrip("\n"),
++    compat: 1.1
-         argnames=argnames)
++    compression type: zlib
 +    lazy refcounts: false
 +    refcount bits: 16
 +    corrupt: false
 +    extended l2: false
 +
 +read 1048576/1048576 bytes at offset 0
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +read 1048576/1048576 bytes at offset 1048576
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +=== Testing QMP active commit (top -> base) ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-mid', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=1048576 backing_file=TEST_DIR/PID-base backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 backing_file=TEST_DIR/PID-mid backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
 +
 +wrote 2097152/2097152 bytes at offset 0
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +{"execute": "block-commit", "arguments": {"auto-dismiss": false, "base-node": "base", "device": "top", "job-id": "job0"}}
 +{"return": {}}
 +{"execute": "job-complete", "arguments": {"id": "job0"}}
 +{"return": {}}
 +{"data": {"device": "job0", "len": 1048576, "offset": 1048576, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"data": {"device": "job0", "len": 1048576, "offset": 1048576, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"execute": "job-dismiss", "arguments": {"id": "job0"}}
 +{"return": {}}
 +image: TEST_IMG
 +file format: IMGFMT
 +virtual size: 1 MiB (1048576 bytes)
 +cluster_size: 65536
 +backing file: TEST_DIR/PID-base
 +backing file format: IMGFMT
 +Format specific information:
 +    compat: 1.1
 +    compression type: zlib
 +    lazy refcounts: false
 +    refcount bits: 16
 +    corrupt: false
 +    extended l2: false
 +
 +read 1048576/1048576 bytes at offset 0
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +read 1048576/1048576 bytes at offset 1048576
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
  == Resize tests ==
  === preallocation=off ===
  Formatting 'TEST_DIR/PID-base', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=6442450944 lazy_refcounts=off refcount_bits=16
 --
-.39.2
+.26.2

The following changes since commit c1eb2ddf0f8075faddc5f7c3d39feae3e8e9d6b4:

Update version for v8.0.0 release (2023-04-19 17:27:13 +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 36e5e9b22abe56aa00ca067851555ad8127a7966:

tracing: install trace events file only if necessary (2023-04-20 07:39:43 -0400)

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

Sam Li's zoned storage work and fixes I collected during the 8.0 freeze.

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

Carlos Santos (1):
  tracing: install trace events file only if necessary

Philippe Mathieu-Daudé (1):
  block/dmg: Declare a type definition for DMG uncompress function

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

Thomas De Schampheleire (1):
  tracetool: use relative paths for '#line' preprocessor directives

-- 
2.39.2

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

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>
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               | 130 ++++++++++++++++++++++---------
 2 files changed, 95 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
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
 {
     BDRVRawState *s = bs->opaque;
     struct stat st;
+    int ret;
+    BlockZoneModel zoned;
 
     s->needs_alignment = raw_needs_alignment(bs);
     raw_probe_alignment(bs, s->fd, errp);
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
             bs->bl.max_hw_iov = ret;
         }
     }
+
+    ret = get_sysfs_zoned_model(&st, &zoned);
+    if (ret < 0) {
+        zoned = BLK_Z_NONE;
+    }
+    bs->bl.zoned = zoned;
 }
 
 static int check_for_dasd(int fd)
-- 
2.39.2

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>
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             | 133 +++++++++++++
 block/file-posix.c                | 306 +++++++++++++++++++++++++++++-
 block/io.c                        |  41 ++++
 qemu-io-cmds.c                    | 149 +++++++++++++++
 9 files changed, 684 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*)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)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)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 *)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);
+    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);
+
+    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 void raw_refresh_limits(BlockDriverState *bs, Error **errp)
         zoned = BLK_Z_NONE;
     }
     bs->bl.zoned = zoned;
+    if (zoned != BLK_Z_NONE) {
+        /*
+         * 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");
+            goto out;
+        } else if (!ret) {
+            error_setg(errp, "Read 0 from chunk_sectors sysfs attribute");
+            goto out;
+        }
+        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");
+            goto out;
+        } else if (!ret) {
+            error_setg(errp, "Read 0 from nr_zones sysfs attribute");
+            goto out;
+        }
+        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;
+        }
+
+        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;
+        }
+        return;
+    }
+out:
+    bs->bl.zoned = BLK_Z_NONE;
 }
 
 static int check_for_dasd(int fd)
@@ -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, 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(bs, 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(bs, 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.39.2

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

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

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

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>
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(bs, 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(bs, 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.39.2

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

From: Philippe Mathieu-Daudé <philmd@linaro.org>

Introduce the BdrvDmgUncompressFunc type defintion. To emphasis
dmg_uncompress_bz2 and dmg_uncompress_lzfse are pointer to functions,
declare them using this new typedef.

Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Message-id: 20230320152610.32052-1-philmd@linaro.org
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/dmg.h | 8 ++++----
 block/dmg.c | 7 ++-----
 2 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/block/dmg.h b/block/dmg.h
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.h
+++ b/block/dmg.h
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVDMGState {
     z_stream zstream;
 } BDRVDMGState;
 
-extern int (*dmg_uncompress_bz2)(char *next_in, unsigned int avail_in,
-                                 char *next_out, unsigned int avail_out);
+typedef int BdrvDmgUncompressFunc(char *next_in, unsigned int avail_in,
+                                  char *next_out, unsigned int avail_out);
 
-extern int (*dmg_uncompress_lzfse)(char *next_in, unsigned int avail_in,
-                                   char *next_out, unsigned int avail_out);
+extern BdrvDmgUncompressFunc *dmg_uncompress_bz2;
+extern BdrvDmgUncompressFunc *dmg_uncompress_lzfse;
 
 #endif
diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/memalign.h"
 #include "dmg.h"
 
-int (*dmg_uncompress_bz2)(char *next_in, unsigned int avail_in,
-                          char *next_out, unsigned int avail_out);
-
-int (*dmg_uncompress_lzfse)(char *next_in, unsigned int avail_in,
-                            char *next_out, unsigned int avail_out);
+BdrvDmgUncompressFunc *dmg_uncompress_bz2;
+BdrvDmgUncompressFunc *dmg_uncompress_lzfse;
 
 enum {
     /* Limit chunk sizes to prevent unreasonable amounts of memory being used
-- 
2.39.2

From: Thomas De Schampheleire <thomas.de_schampheleire@nokia.com>

The event filename is an absolute path. Convert it to a relative path when
writing '#line' directives, to preserve reproducibility of the generated
output when different base paths are used.

Signed-off-by: Thomas De Schampheleire <thomas.de_schampheleire@nokia.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20230406080045.21696-1-thomas.de_schampheleire@nokia.com>
---
 scripts/tracetool/backend/ftrace.py | 4 +++-
 scripts/tracetool/backend/log.py    | 4 +++-
 scripts/tracetool/backend/syslog.py | 4 +++-
 3 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/scripts/tracetool/backend/ftrace.py b/scripts/tracetool/backend/ftrace.py
index XXXXXXX..XXXXXXX 100644
--- a/scripts/tracetool/backend/ftrace.py
+++ b/scripts/tracetool/backend/ftrace.py
@@ -XXX,XX +XXX,XX @@
 __email__      = "stefanha@redhat.com"
 
 
+import os.path
+
 from tracetool import out
 
 
@@ -XXX,XX +XXX,XX @@ def generate_h(event, group):
         args=event.args,
         event_id="TRACE_" + event.name.upper(),
         event_lineno=event.lineno,
-        event_filename=event.filename,
+        event_filename=os.path.relpath(event.filename),
         fmt=event.fmt.rstrip("\n"),
         argnames=argnames)
 
diff --git a/scripts/tracetool/backend/log.py b/scripts/tracetool/backend/log.py
index XXXXXXX..XXXXXXX 100644
--- a/scripts/tracetool/backend/log.py
+++ b/scripts/tracetool/backend/log.py
@@ -XXX,XX +XXX,XX @@
 __email__      = "stefanha@redhat.com"
 
 
+import os.path
+
 from tracetool import out
 
 
@@ -XXX,XX +XXX,XX @@ def generate_h(event, group):
         '    }',
         cond=cond,
         event_lineno=event.lineno,
-        event_filename=event.filename,
+        event_filename=os.path.relpath(event.filename),
         name=event.name,
         fmt=event.fmt.rstrip("\n"),
         argnames=argnames)
diff --git a/scripts/tracetool/backend/syslog.py b/scripts/tracetool/backend/syslog.py
index XXXXXXX..XXXXXXX 100644
--- a/scripts/tracetool/backend/syslog.py
+++ b/scripts/tracetool/backend/syslog.py
@@ -XXX,XX +XXX,XX @@
 __email__      = "stefanha@redhat.com"
 
 
+import os.path
+
 from tracetool import out
 
 
@@ -XXX,XX +XXX,XX @@ def generate_h(event, group):
         '    }',
         cond=cond,
         event_lineno=event.lineno,
-        event_filename=event.filename,
+        event_filename=os.path.relpath(event.filename),
         name=event.name,
         fmt=event.fmt.rstrip("\n"),
         argnames=argnames)
-- 
2.39.2

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: 20230407081657.17947-2-faithilikerun@gmail.com
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               | 173 ++++++++++++++++++++++++++++++-
 3 files changed, 189 insertions(+), 3 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)
 #endif
 }
 
+#if defined(CONFIG_BLKZONED)
+/*
+ * If the reset_all flag is true, then the wps of zone whose state is
+ * not readonly or offline should be all reset to the start sector.
+ * Else, take the real wp of the device.
+ */
+static int get_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
+                        unsigned int nrz, bool reset_all)
+{
+    struct blk_zone *blkz;
+    size_t rep_size;
+    uint64_t sector = offset >> BDRV_SECTOR_BITS;
+    BlockZoneWps *wps = bs->wps;
+    int j = offset / bs->bl.zone_size;
+    int ret, n = 0, i = 0;
+    rep_size = sizeof(struct blk_zone_report) + nrz * sizeof(struct blk_zone);
+    g_autofree struct blk_zone_report *rep = NULL;
+
+    rep = g_malloc(rep_size);
+    blkz = (struct blk_zone *)(rep + 1);
+    while (n < nrz) {
+        memset(rep, 0, rep_size);
+        rep->sector = sector;
+        rep->nr_zones = nrz - n;
+
+        do {
+            ret = ioctl(fd, BLKREPORTZONE, rep);
+        } while (ret != 0 && errno == EINTR);
+        if (ret != 0) {
+            error_report("%d: ioctl BLKREPORTZONE at %" PRId64 " failed %d",
+                    fd, offset, errno);
+            return -errno;
+        }
+
+        if (!rep->nr_zones) {
+            break;
+        }
+
+        for (i = 0; i < rep->nr_zones; ++i, ++n, ++j) {
+            /*
+             * The wp tracking cares only about sequential writes required and
+             * sequential write preferred zones so that the wp can advance to
+             * the right location.
+             * Use the most significant bit of the wp location to indicate the
+             * zone type: 0 for SWR/SWP zones and 1 for conventional zones.
+             */
+            if (blkz[i].type == BLK_ZONE_TYPE_CONVENTIONAL) {
+                wps->wp[j] |= 1ULL << 63;
+            } else {
+                switch(blkz[i].cond) {
+                case BLK_ZONE_COND_FULL:
+                case BLK_ZONE_COND_READONLY:
+                    /* Zone not writable */
+                    wps->wp[j] = (blkz[i].start + blkz[i].len) << BDRV_SECTOR_BITS;
+                    break;
+                case BLK_ZONE_COND_OFFLINE:
+                    /* Zone not writable nor readable */
+                    wps->wp[j] = (blkz[i].start) << BDRV_SECTOR_BITS;
+                    break;
+                default:
+                    if (reset_all) {
+                        wps->wp[j] = blkz[i].start << BDRV_SECTOR_BITS;
+                    } else {
+                        wps->wp[j] = blkz[i].wp << BDRV_SECTOR_BITS;
+                    }
+                    break;
+                }
+            }
+        }
+        sector = blkz[i - 1].start + blkz[i - 1].len;
+    }
+
+    return 0;
+}
+
+static void update_zones_wp(BlockDriverState *bs, int fd, int64_t offset,
+                            unsigned int nrz)
+{
+    if (get_zones_wp(bs, fd, offset, nrz, 0) < 0) {
+        error_report("update zone wp failed");
+    }
+}
+#endif
+
 static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
 {
     BDRVRawState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
         if (ret >= 0) {
             bs->bl.max_active_zones = ret;
         }
+
+        ret = get_sysfs_long_val(&st, "physical_block_size");
+        if (ret >= 0) {
+            bs->bl.write_granularity = ret;
+        }
+
+        /* The refresh_limits() function can be called multiple times. */
+        g_free(bs->wps);
+        bs->wps = g_malloc(sizeof(BlockZoneWps) +
+                sizeof(int64_t) * bs->bl.nr_zones);
+        ret = get_zones_wp(bs, s->fd, 0, bs->bl.nr_zones, 0);
+        if (ret < 0) {
+            error_setg_errno(errp, -ret, "report wps failed");
+            bs->wps = NULL;
+            return;
+        }
+        qemu_co_mutex_init(&bs->wps->colock);
         return;
     }
 out:
@@ -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,
     } else if (s->use_linux_io_uring) {
         LuringState *aio = aio_get_linux_io_uring(bdrv_get_aio_context(bs));
         assert(qiov->size == bytes);
-        return luring_co_submit(bs, aio, s->fd, offset, qiov, type);
+        ret = luring_co_submit(bs, aio, s->fd, offset, qiov, type);
+        goto out;
 #endif
 #ifdef CONFIG_LINUX_AIO
     } else if (s->use_linux_aio) {
         LinuxAioState *aio = aio_get_linux_aio(bdrv_get_aio_context(bs));
         assert(qiov->size == bytes);
-        return laio_co_submit(bs, aio, s->fd, offset, qiov, type,
+        ret = laio_co_submit(bs, aio, s->fd, offset, qiov, type,
                               s->aio_max_batch);
+        goto out;
 #endif
     }
 
@@ -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(bs, handle_aiocb_rw, &acb);
+    ret = raw_thread_pool_submit(bs, handle_aiocb_rw, &acb);
+
+out:
+#if defined(CONFIG_BLKZONED)
+    BlockZoneWps *wps = bs->wps;
+    if (ret == 0) {
+        if (type & QEMU_AIO_WRITE && wps && bs->bl.zone_size) {
+            uint64_t *wp = &wps->wp[offset / bs->bl.zone_size];
+            if (!BDRV_ZT_IS_CONV(*wp)) {
+                /* Advance the wp if needed */
+                if (offset + bytes > *wp) {
+                    *wp = offset + bytes;
+                }
+            }
+        }
+    } else {
+        if (type & QEMU_AIO_WRITE) {
+            update_zones_wp(bs, s->fd, 0, 1);
+        }
+    }
+
+    if (type & QEMU_AIO_WRITE && wps) {
+        qemu_co_mutex_unlock(&wps->colock);
+    }
+#endif
+    return ret;
 }
 
 static int coroutine_fn raw_co_preadv(BlockDriverState *bs, int64_t offset,
@@ -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;
     }
 
+    QEMU_LOCK_GUARD(&wps->colock);
+    uint32_t i = offset / bs->bl.zone_size;
+    uint32_t nrz = len / bs->bl.zone_size;
+    uint64_t *wp = &wps->wp[i];
+    if (BDRV_ZT_IS_CONV(*wp) && len != capacity) {
+        error_report("zone mgmt operations are not allowed for conventional zones");
+        return -EIO;
+    }
+
     switch (op) {
     case BLK_ZO_OPEN:
         op_name = "BLKOPENZONE";
@@ -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(bs, 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 (int j = 0; j < nrz; ++j) {
+            wp[j] = offset + j * zone_size;
+        }
+    } else if (zo == BLKFINISHZONE) {
+        for (int j = 0; j < nrz; ++j) {
+            /* The zoned device allows the last zone smaller that the
+             * zone size. */
+            wp[j] = MIN(offset + (j + 1) * zone_size, offset + len);
+        }
     }
 
     return ret;
-- 
2.39.2

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: 20230407081657.17947-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             | 60 +++++++++++++++++++++++++++++++
 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, 172 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 *)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)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);
+    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:
 #if defined(CONFIG_BLKZONED)
     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);
     }
 #endif
@@ -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.39.2

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: 20230407081657.17947-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.39.2

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

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>
Message-id: 20230407082528.18841-2-faithilikerun@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.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 {
+		uint32_t zone_sectors;
+		uint32_t max_open_zones;
+		uint32_t max_active_zones;
+		uint32_t max_append_sectors;
+		uint32_t 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 */
+	uint64_t z_cap;
+	/* The starting sector of the zone */
+	uint64_t z_start;
+	/* Zone write pointer position in sectors */
+	uint64_t z_wp;
+	/* Zone type */
+	uint8_t z_type;
+	/* Zone state */
+	uint8_t z_state;
+	uint8_t reserved[38];
+};
+
+struct virtio_blk_zone_report {
+	uint64_t 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.39.2

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>
Message-id: 20230407082528.18841-3-faithilikerun@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.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.39.2

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>
Message-id: 20230407082528.18841-4-faithilikerun@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.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.39.2

From: Sam Li <faithilikerun@gmail.com>

Signed-off-by: Sam Li <faithilikerun@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20230407082528.18841-5-faithilikerun@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.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.39.2

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>
Message-id: 20230407082528.18841-6-faithilikerun@gmail.com
[Fix Sphinx indentation error by turning command-lines into
pre-formatted text.
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 docs/devel/zoned-storage.rst | 25 ++++++++++++++++++++++---
 1 file changed, 22 insertions(+), 3 deletions(-)

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 @@ 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"
+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.39.2

The following changes since commit ac793156f650ae2d77834932d72224175ee69086:

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20201020-1' into staging (2020-10-20 21:11:35 +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 32a3fd65e7e3551337fd26bfc0e2f899d70c028c:

iotests: add commit top->base cases to 274 (2020-10-22 09:55:39 +0100)

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

v2:
 * Fix format string issues on 32-bit hosts [Peter]
 * Fix qemu-nbd.c CONFIG_POSIX ifdef issue [Eric]
 * Fix missing eventfd.h header on macOS [Peter]
 * Drop unreliable vhost-user-blk test (will send a new patch when ready) [Peter]

This pull request contains the vhost-user-blk server by Coiby Xu along with my
additions, block/nvme.c alignment and hardware error statistics by Philippe
Mathieu-Daudé, and bdrv_co_block_status_above() fixes by Vladimir
Sementsov-Ogievskiy.

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

Coiby Xu (6):
  libvhost-user: Allow vu_message_read to be replaced
  libvhost-user: remove watch for kick_fd when de-initialize vu-dev
  util/vhost-user-server: generic vhost user server
  block: move logical block size check function to a common utility
    function
  block/export: vhost-user block device backend server
  MAINTAINERS: Add vhost-user block device backend server maintainer

Philippe Mathieu-Daudé (1):
  block/nvme: Add driver statistics for access alignment and hw errors

Stefan Hajnoczi (16):
  util/vhost-user-server: s/fileds/fields/ typo fix
  util/vhost-user-server: drop unnecessary QOM cast
  util/vhost-user-server: drop unnecessary watch deletion
  block/export: consolidate request structs into VuBlockReq
  util/vhost-user-server: drop unused DevicePanicNotifier
  util/vhost-user-server: fix memory leak in vu_message_read()
  util/vhost-user-server: check EOF when reading payload
  util/vhost-user-server: rework vu_client_trip() coroutine lifecycle
  block/export: report flush errors
  block/export: convert vhost-user-blk server to block export API
  util/vhost-user-server: move header to include/
  util/vhost-user-server: use static library in meson.build
  qemu-storage-daemon: avoid compiling blockdev_ss twice
  block: move block exports to libblockdev
  block/export: add iothread and fixed-iothread options
  block/export: add vhost-user-blk multi-queue support

Vladimir Sementsov-Ogievskiy (5):
  block/io: fix bdrv_co_block_status_above
  block/io: bdrv_common_block_status_above: support include_base
  block/io: bdrv_common_block_status_above: support bs == base
  block/io: fix bdrv_is_allocated_above
  iotests: add commit top->base cases to 274

-- 
2.26.2

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Keep statistics of some hardware errors, and number of
aligned/unaligned I/O accesses.

QMP example booting a full RHEL 8.3 aarch64 guest:

{ "execute": "query-blockstats" }
{
    "return": [
        {
            "device": "",
            "node-name": "drive0",
            "stats": {
                "flush_total_time_ns": 6026948,
                "wr_highest_offset": 3383991230464,
                "wr_total_time_ns": 807450995,
                "failed_wr_operations": 0,
                "failed_rd_operations": 0,
                "wr_merged": 3,
                "wr_bytes": 50133504,
                "failed_unmap_operations": 0,
                "failed_flush_operations": 0,
                "account_invalid": false,
                "rd_total_time_ns": 1846979900,
                "flush_operations": 130,
                "wr_operations": 659,
                "rd_merged": 1192,
                "rd_bytes": 218244096,
                "account_failed": false,
                "idle_time_ns": 2678641497,
                "rd_operations": 7406,
            },
            "driver-specific": {
                "driver": "nvme",
                "completion-errors": 0,
                "unaligned-accesses": 2959,
                "aligned-accesses": 4477
            },
            "qdev": "/machine/peripheral-anon/device[0]/virtio-backend"
        }
    ]
}

Suggested-by: Stefan Hajnoczi <stefanha@gmail.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20201001162939.1567915-1-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/block-core.json | 24 +++++++++++++++++++++++-
 block/nvme.c         | 27 +++++++++++++++++++++++++++
 2 files changed, 50 insertions(+), 1 deletion(-)

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 @@
       'discard-nb-failed': 'uint64',
       'discard-bytes-ok': 'uint64' } }
 
+##
+# @BlockStatsSpecificNvme:
+#
+# NVMe driver statistics
+#
+# @completion-errors: The number of completion errors.
+#
+# @aligned-accesses: The number of aligned accesses performed by
+#                    the driver.
+#
+# @unaligned-accesses: The number of unaligned accesses performed by
+#                      the driver.
+#
+# Since: 5.2
+##
+{ 'struct': 'BlockStatsSpecificNvme',
+  'data': {
+      'completion-errors': 'uint64',
+      'aligned-accesses': 'uint64',
+      'unaligned-accesses': 'uint64' } }
+
 ##
 # @BlockStatsSpecific:
 #
@@ -XXX,XX +XXX,XX @@
   'discriminator': 'driver',
   'data': {
       'file': 'BlockStatsSpecificFile',
-      'host_device': 'BlockStatsSpecificFile' } }
+      'host_device': 'BlockStatsSpecificFile',
+      'nvme': 'BlockStatsSpecificNvme' } }
 
 ##
 # @BlockStats:
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 @@ struct BDRVNVMeState {
 
     /* PCI address (required for nvme_refresh_filename()) */
     char *device;
+
+    struct {
+        uint64_t completion_errors;
+        uint64_t aligned_accesses;
+        uint64_t unaligned_accesses;
+    } stats;
 };
 
 #define NVME_BLOCK_OPT_DEVICE "device"
@@ -XXX,XX +XXX,XX @@ static bool nvme_process_completion(NVMeQueuePair *q)
             break;
         }
         ret = nvme_translate_error(c);
+        if (ret) {
+            s->stats.completion_errors++;
+        }
         q->cq.head = (q->cq.head + 1) % NVME_QUEUE_SIZE;
         if (!q->cq.head) {
             q->cq_phase = !q->cq_phase;
@@ -XXX,XX +XXX,XX @@ static int nvme_co_prw(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
     assert(QEMU_IS_ALIGNED(bytes, s->page_size));
     assert(bytes <= s->max_transfer);
     if (nvme_qiov_aligned(bs, qiov)) {
+        s->stats.aligned_accesses++;
         return nvme_co_prw_aligned(bs, offset, bytes, qiov, is_write, flags);
     }
+    s->stats.unaligned_accesses++;
     trace_nvme_prw_buffered(s, offset, bytes, qiov->niov, is_write);
     buf = qemu_try_memalign(s->page_size, bytes);
 
@@ -XXX,XX +XXX,XX @@ static void nvme_unregister_buf(BlockDriverState *bs, void *host)
     qemu_vfio_dma_unmap(s->vfio, host);
 }
 
+static BlockStatsSpecific *nvme_get_specific_stats(BlockDriverState *bs)
+{
+    BlockStatsSpecific *stats = g_new(BlockStatsSpecific, 1);
+    BDRVNVMeState *s = bs->opaque;
+
+    stats->driver = BLOCKDEV_DRIVER_NVME;
+    stats->u.nvme = (BlockStatsSpecificNvme) {
+        .completion_errors = s->stats.completion_errors,
+        .aligned_accesses = s->stats.aligned_accesses,
+        .unaligned_accesses = s->stats.unaligned_accesses,
+    };
+
+    return stats;
+}
+
 static const char *const nvme_strong_runtime_opts[] = {
     NVME_BLOCK_OPT_DEVICE,
     NVME_BLOCK_OPT_NAMESPACE,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_nvme = {
     .bdrv_refresh_filename    = nvme_refresh_filename,
     .bdrv_refresh_limits      = nvme_refresh_limits,
     .strong_runtime_opts      = nvme_strong_runtime_opts,
+    .bdrv_get_specific_stats  = nvme_get_specific_stats,
 
     .bdrv_detach_aio_context  = nvme_detach_aio_context,
     .bdrv_attach_aio_context  = nvme_attach_aio_context,
-- 
2.26.2

From: Coiby Xu <coiby.xu@gmail.com>

Allow vu_message_read to be replaced by one which will make use of the
QIOChannel functions. Thus reading vhost-user message won't stall the
guest. For slave channel, we still use the default vu_message_read.

Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200918080912.321299-2-coiby.xu@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 contrib/libvhost-user/libvhost-user.h      | 21 +++++++++++++++++++++
 contrib/libvhost-user/libvhost-user-glib.c |  2 +-
 contrib/libvhost-user/libvhost-user.c      | 14 +++++++-------
 tests/vhost-user-bridge.c                  |  2 ++
 tools/virtiofsd/fuse_virtio.c              |  4 ++--
 5 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/contrib/libvhost-user/libvhost-user.h b/contrib/libvhost-user/libvhost-user.h
index XXXXXXX..XXXXXXX 100644
--- a/contrib/libvhost-user/libvhost-user.h
+++ b/contrib/libvhost-user/libvhost-user.h
@@ -XXX,XX +XXX,XX @@
  */
 #define VHOST_USER_MAX_RAM_SLOTS 32
 
+#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64)
+
 typedef enum VhostSetConfigType {
     VHOST_SET_CONFIG_TYPE_MASTER = 0,
     VHOST_SET_CONFIG_TYPE_MIGRATION = 1,
@@ -XXX,XX +XXX,XX @@ typedef uint64_t (*vu_get_features_cb) (VuDev *dev);
 typedef void (*vu_set_features_cb) (VuDev *dev, uint64_t features);
 typedef int (*vu_process_msg_cb) (VuDev *dev, VhostUserMsg *vmsg,
                                   int *do_reply);
+typedef bool (*vu_read_msg_cb) (VuDev *dev, int sock, VhostUserMsg *vmsg);
 typedef void (*vu_queue_set_started_cb) (VuDev *dev, int qidx, bool started);
 typedef bool (*vu_queue_is_processed_in_order_cb) (VuDev *dev, int qidx);
 typedef int (*vu_get_config_cb) (VuDev *dev, uint8_t *config, uint32_t len);
@@ -XXX,XX +XXX,XX @@ struct VuDev {
     bool broken;
     uint16_t max_queues;
 
+    /* @read_msg: custom method to read vhost-user message
+     *
+     * Read data from vhost_user socket fd and fill up
+     * the passed VhostUserMsg *vmsg struct.
+     *
+     * If reading fails, it should close the received set of file
+     * descriptors as socket message's auxiliary data.
+     *
+     * For the details, please refer to vu_message_read in libvhost-user.c
+     * which will be used by default if not custom method is provided when
+     * calling vu_init
+     *
+     * Returns: true if vhost-user message successfully received,
+     *          otherwise return false.
+     *
+     */
+    vu_read_msg_cb read_msg;
     /* @set_watch: add or update the given fd to the watch set,
      * call cb when condition is met */
     vu_set_watch_cb set_watch;
@@ -XXX,XX +XXX,XX @@ bool vu_init(VuDev *dev,
              uint16_t max_queues,
              int socket,
              vu_panic_cb panic,
+             vu_read_msg_cb read_msg,
              vu_set_watch_cb set_watch,
              vu_remove_watch_cb remove_watch,
              const VuDevIface *iface);
diff --git a/contrib/libvhost-user/libvhost-user-glib.c b/contrib/libvhost-user/libvhost-user-glib.c
index XXXXXXX..XXXXXXX 100644
--- a/contrib/libvhost-user/libvhost-user-glib.c
+++ b/contrib/libvhost-user/libvhost-user-glib.c
@@ -XXX,XX +XXX,XX @@ vug_init(VugDev *dev, uint16_t max_queues, int socket,
     g_assert(dev);
     g_assert(iface);
 
-    if (!vu_init(&dev->parent, max_queues, socket, panic, set_watch,
+    if (!vu_init(&dev->parent, max_queues, socket, panic, NULL, set_watch,
                  remove_watch, iface)) {
         return false;
     }
diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/libvhost-user.c
index XXXXXXX..XXXXXXX 100644
--- a/contrib/libvhost-user/libvhost-user.c
+++ b/contrib/libvhost-user/libvhost-user.c
@@ -XXX,XX +XXX,XX @@
 /* The version of inflight buffer */
 #define INFLIGHT_VERSION 1
 
-#define VHOST_USER_HDR_SIZE offsetof(VhostUserMsg, payload.u64)
-
 /* The version of the protocol we support */
 #define VHOST_USER_VERSION 1
 #define LIBVHOST_USER_DEBUG 0
@@ -XXX,XX +XXX,XX @@ have_userfault(void)
 }
 
 static bool
-vu_message_read(VuDev *dev, int conn_fd, VhostUserMsg *vmsg)
+vu_message_read_default(VuDev *dev, int conn_fd, VhostUserMsg *vmsg)
 {
     char control[CMSG_SPACE(VHOST_MEMORY_BASELINE_NREGIONS * sizeof(int))] = {};
     struct iovec iov = {
@@ -XXX,XX +XXX,XX @@ vu_process_message_reply(VuDev *dev, const VhostUserMsg *vmsg)
         goto out;
     }
 
-    if (!vu_message_read(dev, dev->slave_fd, &msg_reply)) {
+    if (!vu_message_read_default(dev, dev->slave_fd, &msg_reply)) {
         goto out;
     }
 
@@ -XXX,XX +XXX,XX @@ vu_set_mem_table_exec_postcopy(VuDev *dev, VhostUserMsg *vmsg)
     /* Wait for QEMU to confirm that it's registered the handler for the
      * faults.
      */
-    if (!vu_message_read(dev, dev->sock, vmsg) ||
+    if (!dev->read_msg(dev, dev->sock, vmsg) ||
         vmsg->size != sizeof(vmsg->payload.u64) ||
         vmsg->payload.u64 != 0) {
         vu_panic(dev, "failed to receive valid ack for postcopy set-mem-table");
@@ -XXX,XX +XXX,XX @@ vu_dispatch(VuDev *dev)
     int reply_requested;
     bool need_reply, success = false;
 
-    if (!vu_message_read(dev, dev->sock, &vmsg)) {
+    if (!dev->read_msg(dev, dev->sock, &vmsg)) {
         goto end;
     }
 
@@ -XXX,XX +XXX,XX @@ vu_init(VuDev *dev,
         uint16_t max_queues,
         int socket,
         vu_panic_cb panic,
+        vu_read_msg_cb read_msg,
         vu_set_watch_cb set_watch,
         vu_remove_watch_cb remove_watch,
         const VuDevIface *iface)
@@ -XXX,XX +XXX,XX @@ vu_init(VuDev *dev,
 
     dev->sock = socket;
     dev->panic = panic;
+    dev->read_msg = read_msg ? read_msg : vu_message_read_default;
     dev->set_watch = set_watch;
     dev->remove_watch = remove_watch;
     dev->iface = iface;
@@ -XXX,XX +XXX,XX @@ static void _vu_queue_notify(VuDev *dev, VuVirtq *vq, bool sync)
 
         vu_message_write(dev, dev->slave_fd, &vmsg);
         if (ack) {
-            vu_message_read(dev, dev->slave_fd, &vmsg);
+            vu_message_read_default(dev, dev->slave_fd, &vmsg);
         }
         return;
     }
diff --git a/tests/vhost-user-bridge.c b/tests/vhost-user-bridge.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/vhost-user-bridge.c
+++ b/tests/vhost-user-bridge.c
@@ -XXX,XX +XXX,XX @@ vubr_accept_cb(int sock, void *ctx)
                  VHOST_USER_BRIDGE_MAX_QUEUES,
                  conn_fd,
                  vubr_panic,
+                 NULL,
                  vubr_set_watch,
                  vubr_remove_watch,
                  &vuiface)) {
@@ -XXX,XX +XXX,XX @@ vubr_new(const char *path, bool client)
                      VHOST_USER_BRIDGE_MAX_QUEUES,
                      dev->sock,
                      vubr_panic,
+                     NULL,
                      vubr_set_watch,
                      vubr_remove_watch,
                      &vuiface)) {
diff --git a/tools/virtiofsd/fuse_virtio.c b/tools/virtiofsd/fuse_virtio.c
index XXXXXXX..XXXXXXX 100644
--- a/tools/virtiofsd/fuse_virtio.c
+++ b/tools/virtiofsd/fuse_virtio.c
@@ -XXX,XX +XXX,XX @@ int virtio_session_mount(struct fuse_session *se)
     se->vu_socketfd = data_sock;
     se->virtio_dev->se = se;
     pthread_rwlock_init(&se->virtio_dev->vu_dispatch_rwlock, NULL);
-    vu_init(&se->virtio_dev->dev, 2, se->vu_socketfd, fv_panic, fv_set_watch,
-            fv_remove_watch, &fv_iface);
+    vu_init(&se->virtio_dev->dev, 2, se->vu_socketfd, fv_panic, NULL,
+            fv_set_watch, fv_remove_watch, &fv_iface);
 
     return 0;
 }
-- 
2.26.2

From: Coiby Xu <coiby.xu@gmail.com>

Sharing QEMU devices via vhost-user protocol.

Only one vhost-user client can connect to the server one time.

diff --git a/util/vhost-user-server.h b/util/vhost-user-server.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/util/vhost-user-server.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * Sharing QEMU devices via vhost-user protocol
+ *
+ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
+ * Copyright (c) 2020 Red Hat, Inc.
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or
+ * later.  See the COPYING file in the top-level directory.
+ */
+
+#ifndef VHOST_USER_SERVER_H
+#define VHOST_USER_SERVER_H
+
+#include "contrib/libvhost-user/libvhost-user.h"
+#include "io/channel-socket.h"
+#include "io/channel-file.h"
+#include "io/net-listener.h"
+#include "qemu/error-report.h"
+#include "qapi/error.h"
+#include "standard-headers/linux/virtio_blk.h"
+
+typedef struct VuFdWatch {
+    VuDev *vu_dev;
+    int fd; /*kick fd*/
+    void *pvt;
+    vu_watch_cb cb;
+    bool processing;
+    QTAILQ_ENTRY(VuFdWatch) next;
+} VuFdWatch;
+
+typedef struct VuServer VuServer;
+typedef void DevicePanicNotifierFn(VuServer *server);
+
+struct VuServer {
+    QIONetListener *listener;
+    AioContext *ctx;
+    DevicePanicNotifierFn *device_panic_notifier;
+    int max_queues;
+    const VuDevIface *vu_iface;
+    VuDev vu_dev;
+    QIOChannel *ioc; /* The I/O channel with the client */
+    QIOChannelSocket *sioc; /* The underlying data channel with the client */
+    /* IOChannel for fd provided via VHOST_USER_SET_SLAVE_REQ_FD */
+    QIOChannel *ioc_slave;
+    QIOChannelSocket *sioc_slave;
+    Coroutine *co_trip; /* coroutine for processing VhostUserMsg */
+    QTAILQ_HEAD(, VuFdWatch) vu_fd_watches;
+    /* restart coroutine co_trip if AIOContext is changed */
+    bool aio_context_changed;
+    bool processing_msg;
+};
+
+bool vhost_user_server_start(VuServer *server,
+                             SocketAddress *unix_socket,
+                             AioContext *ctx,
+                             uint16_t max_queues,
+                             DevicePanicNotifierFn *device_panic_notifier,
+                             const VuDevIface *vu_iface,
+                             Error **errp);
+
+void vhost_user_server_stop(VuServer *server);
+
+void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx);
+
+#endif /* VHOST_USER_SERVER_H */
diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/util/vhost-user-server.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Sharing QEMU devices via vhost-user protocol
+ *
+ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
+ * Copyright (c) 2020 Red Hat, Inc.
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or
+ * later.  See the COPYING file in the top-level directory.
+ */
+#include "qemu/osdep.h"
+#include "qemu/main-loop.h"
+#include "vhost-user-server.h"
+
+static void vmsg_close_fds(VhostUserMsg *vmsg)
+{
+    int i;
+    for (i = 0; i < vmsg->fd_num; i++) {
+        close(vmsg->fds[i]);
+    }
+}
+
+static void vmsg_unblock_fds(VhostUserMsg *vmsg)
+{
+    int i;
+    for (i = 0; i < vmsg->fd_num; i++) {
+        qemu_set_nonblock(vmsg->fds[i]);
+    }
+}
+
+static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
+                      gpointer opaque);
+
+static void close_client(VuServer *server)
+{
+    /*
+     * Before closing the client
+     *
+     * 1. Let vu_client_trip stop processing new vhost-user msg
+     *
+     * 2. remove kick_handler
+     *
+     * 3. wait for the kick handler to be finished
+     *
+     * 4. wait for the current vhost-user msg to be finished processing
+     */
+
+    QIOChannelSocket *sioc = server->sioc;
+    /* When this is set vu_client_trip will stop new processing vhost-user message */
+    server->sioc = NULL;
+
+    VuFdWatch *vu_fd_watch, *next;
+    QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
+        aio_set_fd_handler(server->ioc->ctx, vu_fd_watch->fd, true, NULL,
+                           NULL, NULL, NULL);
+    }
+
+    while (!QTAILQ_EMPTY(&server->vu_fd_watches)) {
+        QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
+            if (!vu_fd_watch->processing) {
+                QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next);
+                g_free(vu_fd_watch);
+            }
+        }
+    }
+
+    while (server->processing_msg) {
+        if (server->ioc->read_coroutine) {
+            server->ioc->read_coroutine = NULL;
+            qio_channel_set_aio_fd_handler(server->ioc, server->ioc->ctx, NULL,
+                                           NULL, server->ioc);
+            server->processing_msg = false;
+        }
+    }
+
+    vu_deinit(&server->vu_dev);
+    object_unref(OBJECT(sioc));
+    object_unref(OBJECT(server->ioc));
+}
+
+static void panic_cb(VuDev *vu_dev, const char *buf)
+{
+    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
+
+    /* avoid while loop in close_client */
+    server->processing_msg = false;
+
+    if (buf) {
+        error_report("vu_panic: %s", buf);
+    }
+
+    if (server->sioc) {
+        close_client(server);
+    }
+
+    if (server->device_panic_notifier) {
+        server->device_panic_notifier(server);
+    }
+
+    /*
+     * Set the callback function for network listener so another
+     * vhost-user client can connect to this server
+     */
+    qio_net_listener_set_client_func(server->listener,
+                                     vu_accept,
+                                     server,
+                                     NULL);
+}
+
+static bool coroutine_fn
+vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg)
+{
+    struct iovec iov = {
+        .iov_base = (char *)vmsg,
+        .iov_len = VHOST_USER_HDR_SIZE,
+    };
+    int rc, read_bytes = 0;
+    Error *local_err = NULL;
+    /*
+     * Store fds/nfds returned from qio_channel_readv_full into
+     * temporary variables.
+     *
+     * VhostUserMsg is a packed structure, gcc will complain about passing
+     * pointer to a packed structure member if we pass &VhostUserMsg.fd_num
+     * and &VhostUserMsg.fds directly when calling qio_channel_readv_full,
+     * thus two temporary variables nfds and fds are used here.
+     */
+    size_t nfds = 0, nfds_t = 0;
+    const size_t max_fds = G_N_ELEMENTS(vmsg->fds);
+    int *fds_t = NULL;
+    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
+    QIOChannel *ioc = server->ioc;
+
+    if (!ioc) {
+        error_report_err(local_err);
+        goto fail;
+    }
+
+    assert(qemu_in_coroutine());
+    do {
+        /*
+         * qio_channel_readv_full may have short reads, keeping calling it
+         * until getting VHOST_USER_HDR_SIZE or 0 bytes in total
+         */
+        rc = qio_channel_readv_full(ioc, &iov, 1, &fds_t, &nfds_t, &local_err);
+        if (rc < 0) {
+            if (rc == QIO_CHANNEL_ERR_BLOCK) {
+                qio_channel_yield(ioc, G_IO_IN);
+                continue;
+            } else {
+                error_report_err(local_err);
+                return false;
+            }
+        }
+        read_bytes += rc;
+        if (nfds_t > 0) {
+            if (nfds + nfds_t > max_fds) {
+                error_report("A maximum of %zu fds are allowed, "
+                             "however got %zu fds now",
+                             max_fds, nfds + nfds_t);
+                goto fail;
+            }
+            memcpy(vmsg->fds + nfds, fds_t,
+                   nfds_t *sizeof(vmsg->fds[0]));
+            nfds += nfds_t;
+            g_free(fds_t);
+        }
+        if (read_bytes == VHOST_USER_HDR_SIZE || rc == 0) {
+            break;
+        }
+        iov.iov_base = (char *)vmsg + read_bytes;
+        iov.iov_len = VHOST_USER_HDR_SIZE - read_bytes;
+    } while (true);
+
+    vmsg->fd_num = nfds;
+    /* qio_channel_readv_full will make socket fds blocking, unblock them */
+    vmsg_unblock_fds(vmsg);
+    if (vmsg->size > sizeof(vmsg->payload)) {
+        error_report("Error: too big message request: %d, "
+                     "size: vmsg->size: %u, "
+                     "while sizeof(vmsg->payload) = %zu",
+                     vmsg->request, vmsg->size, sizeof(vmsg->payload));
+        goto fail;
+    }
+
+    struct iovec iov_payload = {
+        .iov_base = (char *)&vmsg->payload,
+        .iov_len = vmsg->size,
+    };
+    if (vmsg->size) {
+        rc = qio_channel_readv_all_eof(ioc, &iov_payload, 1, &local_err);
+        if (rc == -1) {
+            error_report_err(local_err);
+            goto fail;
+        }
+    }
+
+    return true;
+
+fail:
+    vmsg_close_fds(vmsg);
+
+    return false;
+}
+
+
+static void vu_client_start(VuServer *server);
+static coroutine_fn void vu_client_trip(void *opaque)
+{
+    VuServer *server = opaque;
+
+    while (!server->aio_context_changed && server->sioc) {
+        server->processing_msg = true;
+        vu_dispatch(&server->vu_dev);
+        server->processing_msg = false;
+    }
+
+    if (server->aio_context_changed && server->sioc) {
+        server->aio_context_changed = false;
+        vu_client_start(server);
+    }
+}
+
+static void vu_client_start(VuServer *server)
+{
+    server->co_trip = qemu_coroutine_create(vu_client_trip, server);
+    aio_co_enter(server->ctx, server->co_trip);
+}
+
+/*
+ * a wrapper for vu_kick_cb
+ *
+ * since aio_dispatch can only pass one user data pointer to the
+ * callback function, pack VuDev and pvt into a struct. Then unpack it
+ * and pass them to vu_kick_cb
+ */
+static void kick_handler(void *opaque)
+{
+    VuFdWatch *vu_fd_watch = opaque;
+    vu_fd_watch->processing = true;
+    vu_fd_watch->cb(vu_fd_watch->vu_dev, 0, vu_fd_watch->pvt);
+    vu_fd_watch->processing = false;
+}
+
+
+static VuFdWatch *find_vu_fd_watch(VuServer *server, int fd)
+{
+
+    VuFdWatch *vu_fd_watch, *next;
+    QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
+        if (vu_fd_watch->fd == fd) {
+            return vu_fd_watch;
+        }
+    }
+    return NULL;
+}
+
+static void
+set_watch(VuDev *vu_dev, int fd, int vu_evt,
+          vu_watch_cb cb, void *pvt)
+{
+
+    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
+    g_assert(vu_dev);
+    g_assert(fd >= 0);
+    g_assert(cb);
+
+    VuFdWatch *vu_fd_watch = find_vu_fd_watch(server, fd);
+
+    if (!vu_fd_watch) {
+        VuFdWatch *vu_fd_watch = g_new0(VuFdWatch, 1);
+
+        QTAILQ_INSERT_TAIL(&server->vu_fd_watches, vu_fd_watch, next);
+
+        vu_fd_watch->fd = fd;
+        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);
+        vu_fd_watch->vu_dev = vu_dev;
+        vu_fd_watch->pvt = pvt;
+    }
+}
+
+
+static void remove_watch(VuDev *vu_dev, int fd)
+{
+    VuServer *server;
+    g_assert(vu_dev);
+    g_assert(fd >= 0);
+
+    server = container_of(vu_dev, VuServer, vu_dev);
+
+    VuFdWatch *vu_fd_watch = find_vu_fd_watch(server, fd);
+
+    if (!vu_fd_watch) {
+        return;
+    }
+    aio_set_fd_handler(server->ioc->ctx, fd, true, NULL, NULL, NULL, NULL);
+
+    QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next);
+    g_free(vu_fd_watch);
+}
+
+
+static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
+                      gpointer opaque)
+{
+    VuServer *server = opaque;
+
+    if (server->sioc) {
+        warn_report("Only one vhost-user client is allowed to "
+                    "connect the server one time");
+        return;
+    }
+
+    if (!vu_init(&server->vu_dev, server->max_queues, sioc->fd, panic_cb,
+                 vu_message_read, set_watch, remove_watch, server->vu_iface)) {
+        error_report("Failed to initialize libvhost-user");
+        return;
+    }
+
+    /*
+     * Unset the callback function for network listener to make another
+     * vhost-user client keeping waiting until this client disconnects
+     */
+    qio_net_listener_set_client_func(server->listener,
+                                     NULL,
+                                     NULL,
+                                     NULL);
+    server->sioc = sioc;
+    /*
+     * Increase the object reference, so sioc will not freed by
+     * qio_net_listener_channel_func which will call object_unref(OBJECT(sioc))
+     */
+    object_ref(OBJECT(server->sioc));
+    qio_channel_set_name(QIO_CHANNEL(sioc), "vhost-user client");
+    server->ioc = QIO_CHANNEL(sioc);
+    object_ref(OBJECT(server->ioc));
+    qio_channel_attach_aio_context(server->ioc, server->ctx);
+    qio_channel_set_blocking(QIO_CHANNEL(server->sioc), false, NULL);
+    vu_client_start(server);
+}
+
+
+void vhost_user_server_stop(VuServer *server)
+{
+    if (server->sioc) {
+        close_client(server);
+    }
+
+    if (server->listener) {
+        qio_net_listener_disconnect(server->listener);
+        object_unref(OBJECT(server->listener));
+    }
+
+}
+
+void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx)
+{
+    VuFdWatch *vu_fd_watch, *next;
+    void *opaque = NULL;
+    IOHandler *io_read = NULL;
+    bool attach;
+
+    server->ctx = ctx ? ctx : qemu_get_aio_context();
+
+    if (!server->sioc) {
+        /* not yet serving any client*/
+        return;
+    }
+
+    if (ctx) {
+        qio_channel_attach_aio_context(server->ioc, ctx);
+        server->aio_context_changed = true;
+        io_read = kick_handler;
+        attach = true;
+    } else {
+        qio_channel_detach_aio_context(server->ioc);
+        /* server->ioc->ctx keeps the old AioConext */
+        ctx = server->ioc->ctx;
+        attach = false;
+    }
+
+    QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
+        if (vu_fd_watch->cb) {
+            opaque = attach ? vu_fd_watch : NULL;
+            aio_set_fd_handler(ctx, vu_fd_watch->fd, true,
+                               io_read, NULL, NULL,
+                               opaque);
+        }
+    }
+}
+
+
+bool vhost_user_server_start(VuServer *server,
+                             SocketAddress *socket_addr,
+                             AioContext *ctx,
+                             uint16_t max_queues,
+                             DevicePanicNotifierFn *device_panic_notifier,
+                             const VuDevIface *vu_iface,
+                             Error **errp)
+{
+    QIONetListener *listener = qio_net_listener_new();
+    if (qio_net_listener_open_sync(listener, socket_addr, 1,
+                                   errp) < 0) {
+        object_unref(OBJECT(listener));
+        return false;
+    }
+
+    /* zero out unspecified fileds */
+    *server = (VuServer) {
+        .listener              = listener,
+        .vu_iface              = vu_iface,
+        .max_queues            = max_queues,
+        .ctx                   = ctx,
+        .device_panic_notifier = device_panic_notifier,
+    };
+
+    qio_net_listener_set_name(server->listener, "vhost-user-backend-listener");
+
+    qio_net_listener_set_client_func(server->listener,
+                                     vu_accept,
+                                     server,
+                                     NULL);
+
+    QTAILQ_INIT(&server->vu_fd_watches);
+    return true;
+}
diff --git a/util/meson.build b/util/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/util/meson.build
+++ b/util/meson.build
@@ -XXX,XX +XXX,XX @@ if have_block
   util_ss.add(files('main-loop.c'))
   util_ss.add(files('nvdimm-utils.c'))
   util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c'))
+  util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c'))
   util_ss.add(files('qemu-coroutine-sleep.c'))
   util_ss.add(files('qemu-co-shared-resource.c'))
   util_ss.add(files('thread-pool.c', 'qemu-timer.c'))
-- 
2.26.2

From: Coiby Xu <coiby.xu@gmail.com>

Move the constants from hw/core/qdev-properties.c to
util/block-helpers.h so that knowledge of the min/max values is

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Acked-by: Eduardo Habkost <ehabkost@redhat.com>
Message-id: 20200918080912.321299-5-coiby.xu@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/block-helpers.h             | 19 +++++++++++++
 hw/core/qdev-properties-system.c | 31 ++++-----------------
 util/block-helpers.c             | 46 ++++++++++++++++++++++++++++++++
 util/meson.build                 |  1 +
 4 files changed, 71 insertions(+), 26 deletions(-)
 create mode 100644 util/block-helpers.h
 create mode 100644 util/block-helpers.c

diff --git a/util/block-helpers.h b/util/block-helpers.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/util/block-helpers.h
@@ -XXX,XX +XXX,XX @@
+#ifndef BLOCK_HELPERS_H
+#define BLOCK_HELPERS_H
+
+#include "qemu/units.h"
+
+/* lower limit is sector size */
+#define MIN_BLOCK_SIZE          INT64_C(512)
+#define MIN_BLOCK_SIZE_STR      "512 B"
+/*
+ * upper limit is arbitrary, 2 MiB looks sufficient for all sensible uses, and
+ * matches qcow2 cluster size limit
+ */
+#define MAX_BLOCK_SIZE          (2 * MiB)
+#define MAX_BLOCK_SIZE_STR      "2 MiB"
+
+void check_block_size(const char *id, const char *name, int64_t value,
+                      Error **errp);
+
+#endif /* BLOCK_HELPERS_H */
diff --git a/hw/core/qdev-properties-system.c b/hw/core/qdev-properties-system.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/core/qdev-properties-system.c
+++ b/hw/core/qdev-properties-system.c
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/blockdev.h"
 #include "net/net.h"
 #include "hw/pci/pci.h"
+#include "util/block-helpers.h"
 
 static bool check_prop_still_unset(DeviceState *dev, const char *name,
                                    const void *old_val, const char *new_val,
@@ -XXX,XX +XXX,XX @@ const PropertyInfo qdev_prop_losttickpolicy = {
 
 /* --- blocksize --- */
 
-/* lower limit is sector size */
-#define MIN_BLOCK_SIZE          512
-#define MIN_BLOCK_SIZE_STR      "512 B"
-/*
- * upper limit is arbitrary, 2 MiB looks sufficient for all sensible uses, and
- * matches qcow2 cluster size limit
- */
-#define MAX_BLOCK_SIZE          (2 * MiB)
-#define MAX_BLOCK_SIZE_STR      "2 MiB"
-
 static void set_blocksize(Object *obj, Visitor *v, const char *name,
                           void *opaque, Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ static void set_blocksize(Object *obj, Visitor *v, const char *name,
     Property *prop = opaque;
     uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
     uint64_t value;
+    Error *local_err = NULL;
 
     if (dev->realized) {
         qdev_prop_set_after_realize(dev, name, errp);
@@ -XXX,XX +XXX,XX @@ static void set_blocksize(Object *obj, Visitor *v, const char *name,
     if (!visit_type_size(v, name, &value, errp)) {
         return;
     }
-    /* value of 0 means "unset" */
-    if (value && (value < MIN_BLOCK_SIZE || value > MAX_BLOCK_SIZE)) {
-        error_setg(errp,
-                   "Property %s.%s doesn't take value %" PRIu64
-                   " (minimum: " MIN_BLOCK_SIZE_STR
-                   ", maximum: " MAX_BLOCK_SIZE_STR ")",
-                   dev->id ? : "", name, value);
+    check_block_size(dev->id ? : "", name, value, &local_err);
+    if (local_err) {
+        error_propagate(errp, local_err);
         return;
     }
-
-    /* We rely on power-of-2 blocksizes for bitmasks */
-    if ((value & (value - 1)) != 0) {
-        error_setg(errp,
-                  "Property %s.%s doesn't take value '%" PRId64 "', "
-                  "it's not a power of 2", dev->id ?: "", name, (int64_t)value);
-        return;
-    }
-
     *ptr = value;
 }
 
diff --git a/util/block-helpers.c b/util/block-helpers.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/util/block-helpers.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Block utility functions
+ *
+ * Copyright IBM, Corp. 2011
+ * Copyright (c) 2020 Coiby Xu <coiby.xu@gmail.com>
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
+ * See the COPYING file in the top-level directory.
+ */
+
+#include "qemu/osdep.h"
+#include "qapi/error.h"
+#include "qapi/qmp/qerror.h"
+#include "block-helpers.h"
+
+/**
+ * check_block_size:
+ * @id: The unique ID of the object
+ * @name: The name of the property being validated
+ * @value: The block size in bytes
+ * @errp: A pointer to an area to store an error
+ *
+ * This function checks that the block size meets the following conditions:
+ * 1. At least MIN_BLOCK_SIZE
+ * 2. No larger than MAX_BLOCK_SIZE
+ * 3. A power of 2
+ */
+void check_block_size(const char *id, const char *name, int64_t value,
+                      Error **errp)
+{
+    /* value of 0 means "unset" */
+    if (value && (value < MIN_BLOCK_SIZE || value > MAX_BLOCK_SIZE)) {
+        error_setg(errp, QERR_PROPERTY_VALUE_OUT_OF_RANGE,
+                   id, name, value, MIN_BLOCK_SIZE, MAX_BLOCK_SIZE);
+        return;
+    }
+
+    /* We rely on power-of-2 blocksizes for bitmasks */
+    if ((value & (value - 1)) != 0) {
+        error_setg(errp,
+                   "Property %s.%s doesn't take value '%" PRId64
+                   "', it's not a power of 2",
+                   id, name, value);
+        return;
+    }
+}
diff --git a/util/meson.build b/util/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/util/meson.build
+++ b/util/meson.build
@@ -XXX,XX +XXX,XX @@ if have_block
   util_ss.add(files('nvdimm-utils.c'))
   util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c'))
   util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c'))
+  util_ss.add(files('block-helpers.c'))
   util_ss.add(files('qemu-coroutine-sleep.c'))
   util_ss.add(files('qemu-co-shared-resource.c'))
   util_ss.add(files('thread-pool.c', 'qemu-timer.c'))
-- 
2.26.2

From: Coiby Xu <coiby.xu@gmail.com>

By making use of libvhost-user, block device drive can be shared to
the connected vhost-user client. Only one client can connect to the
server one time.

Since vhost-user-server needs a block drive to be created first, delay
the creation of this object.

Suggested-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-id: 20200918080912.321299-6-coiby.xu@gmail.com
[Shorten "vhost_user_blk_server" string to "vhost_user_blk" to avoid the
following compiler warning:
../block/export/vhost-user-blk-server.c:178:50: error: ‘%s’ directive output truncated writing 21 bytes into a region of size 20 [-Werror=format-truncation=]
and fix "Invalid size %ld ..." ssize_t format string arguments for
32-bit hosts.
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/export/vhost-user-blk-server.h |  36 ++
 block/export/vhost-user-blk-server.c | 661 +++++++++++++++++++++++++++
 softmmu/vl.c                         |   4 +
 block/meson.build                    |   1 +
 4 files changed, 702 insertions(+)
 create mode 100644 block/export/vhost-user-blk-server.h
 create mode 100644 block/export/vhost-user-blk-server.c

diff --git a/block/export/vhost-user-blk-server.h b/block/export/vhost-user-blk-server.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/block/export/vhost-user-blk-server.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * Sharing QEMU block devices via vhost-user protocal
+ *
+ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
+ * Copyright (c) 2020 Red Hat, Inc.
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or
+ * later.  See the COPYING file in the top-level directory.
+ */
+
+#ifndef VHOST_USER_BLK_SERVER_H
+#define VHOST_USER_BLK_SERVER_H
+#include "util/vhost-user-server.h"
+
+typedef struct VuBlockDev VuBlockDev;
+#define TYPE_VHOST_USER_BLK_SERVER "vhost-user-blk-server"
+#define VHOST_USER_BLK_SERVER(obj) \
+   OBJECT_CHECK(VuBlockDev, obj, TYPE_VHOST_USER_BLK_SERVER)
+
+/* vhost user block device */
+struct VuBlockDev {
+    Object parent_obj;
+    char *node_name;
+    SocketAddress *addr;
+    AioContext *ctx;
+    VuServer vu_server;
+    bool running;
+    uint32_t blk_size;
+    BlockBackend *backend;
+    QIOChannelSocket *sioc;
+    QTAILQ_ENTRY(VuBlockDev) next;
+    struct virtio_blk_config blkcfg;
+    bool writable;
+};
+
+#endif /* VHOST_USER_BLK_SERVER_H */
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/block/export/vhost-user-blk-server.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Sharing QEMU block devices via vhost-user protocal
+ *
+ * Parts of the code based on nbd/server.c.
+ *
+ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
+ * Copyright (c) 2020 Red Hat, Inc.
+ *
+ * This work is licensed under the terms of the GNU GPL, version 2 or
+ * later.  See the COPYING file in the top-level directory.
+ */
+#include "qemu/osdep.h"
+#include "block/block.h"
+#include "vhost-user-blk-server.h"
+#include "qapi/error.h"
+#include "qom/object_interfaces.h"
+#include "sysemu/block-backend.h"
+#include "util/block-helpers.h"
+
+enum {
+    VHOST_USER_BLK_MAX_QUEUES = 1,
+};
+struct virtio_blk_inhdr {
+    unsigned char status;
+};
+
+typedef struct VuBlockReq {
+    VuVirtqElement *elem;
+    int64_t sector_num;
+    size_t size;
+    struct virtio_blk_inhdr *in;
+    struct virtio_blk_outhdr out;
+    VuServer *server;
+    struct VuVirtq *vq;
+} VuBlockReq;
+
+static void vu_block_req_complete(VuBlockReq *req)
+{
+    VuDev *vu_dev = &req->server->vu_dev;
+
+    /* IO size with 1 extra status byte */
+    vu_queue_push(vu_dev, req->vq, req->elem, req->size + 1);
+    vu_queue_notify(vu_dev, req->vq);
+
+    if (req->elem) {
+        free(req->elem);
+    }
+
+    g_free(req);
+}
+
+static VuBlockDev *get_vu_block_device_by_server(VuServer *server)
+{
+    return container_of(server, VuBlockDev, vu_server);
+}
+
+static int coroutine_fn
+vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
+                              uint32_t iovcnt, uint32_t type)
+{
+    struct virtio_blk_discard_write_zeroes desc;
+    ssize_t size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc));
+    if (unlikely(size != sizeof(desc))) {
+        error_report("Invalid size %zd, expect %zu", size, sizeof(desc));
+        return -EINVAL;
+    }
+
+    VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
+    uint64_t range[2] = { le64_to_cpu(desc.sector) << 9,
+                          le32_to_cpu(desc.num_sectors) << 9 };
+    if (type == VIRTIO_BLK_T_DISCARD) {
+        if (blk_co_pdiscard(vdev_blk->backend, range[0], range[1]) == 0) {
+            return 0;
+        }
+    } else if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
+        if (blk_co_pwrite_zeroes(vdev_blk->backend,
+                                 range[0], range[1], 0) == 0) {
+            return 0;
+        }
+    }
+
+    return -EINVAL;
+}
+
+static void coroutine_fn vu_block_flush(VuBlockReq *req)
+{
+    VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
+    BlockBackend *backend = vdev_blk->backend;
+    blk_co_flush(backend);
+}
+
+struct req_data {
+    VuServer *server;
+    VuVirtq *vq;
+    VuVirtqElement *elem;
+};
+
+static void coroutine_fn vu_block_virtio_process_req(void *opaque)
+{
+    struct req_data *data = opaque;
+    VuServer *server = data->server;
+    VuVirtq *vq = data->vq;
+    VuVirtqElement *elem = data->elem;
+    uint32_t type;
+    VuBlockReq *req;
+
+    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
+    BlockBackend *backend = vdev_blk->backend;
+
+    struct iovec *in_iov = elem->in_sg;
+    struct iovec *out_iov = elem->out_sg;
+    unsigned in_num = elem->in_num;
+    unsigned out_num = elem->out_num;
+    /* refer to hw/block/virtio_blk.c */
+    if (elem->out_num < 1 || elem->in_num < 1) {
+        error_report("virtio-blk request missing headers");
+        free(elem);
+        return;
+    }
+
+    req = g_new0(VuBlockReq, 1);
+    req->server = server;
+    req->vq = vq;
+    req->elem = elem;
+
+    if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
+                            sizeof(req->out)) != sizeof(req->out))) {
+        error_report("virtio-blk request outhdr too short");
+        goto err;
+    }
+
+    iov_discard_front(&out_iov, &out_num, sizeof(req->out));
+
+    if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {
+        error_report("virtio-blk request inhdr too short");
+        goto err;
+    }
+
+    /* We always touch the last byte, so just see how big in_iov is.  */
+    req->in = (void *)in_iov[in_num - 1].iov_base
+              + in_iov[in_num - 1].iov_len
+              - sizeof(struct virtio_blk_inhdr);
+    iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr));
+
+    type = le32_to_cpu(req->out.type);
+    switch (type & ~VIRTIO_BLK_T_BARRIER) {
+    case VIRTIO_BLK_T_IN:
+    case VIRTIO_BLK_T_OUT: {
+        ssize_t ret = 0;
+        bool is_write = type & VIRTIO_BLK_T_OUT;
+        req->sector_num = le64_to_cpu(req->out.sector);
+
+        int64_t offset = req->sector_num * vdev_blk->blk_size;
+        QEMUIOVector qiov;
+        if (is_write) {
+            qemu_iovec_init_external(&qiov, out_iov, out_num);
+            ret = blk_co_pwritev(backend, offset, qiov.size,
+                                 &qiov, 0);
+        } else {
+            qemu_iovec_init_external(&qiov, in_iov, in_num);
+            ret = blk_co_preadv(backend, offset, qiov.size,
+                                &qiov, 0);
+        }
+        if (ret >= 0) {
+            req->in->status = VIRTIO_BLK_S_OK;
+        } else {
+            req->in->status = VIRTIO_BLK_S_IOERR;
+        }
+        break;
+    }
+    case VIRTIO_BLK_T_FLUSH:
+        vu_block_flush(req);
+        req->in->status = VIRTIO_BLK_S_OK;
+        break;
+    case VIRTIO_BLK_T_GET_ID: {
+        size_t size = MIN(iov_size(&elem->in_sg[0], in_num),
+                          VIRTIO_BLK_ID_BYTES);
+        snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk");
+        req->in->status = VIRTIO_BLK_S_OK;
+        req->size = elem->in_sg[0].iov_len;
+        break;
+    }
+    case VIRTIO_BLK_T_DISCARD:
+    case VIRTIO_BLK_T_WRITE_ZEROES: {
+        int rc;
+        rc = vu_block_discard_write_zeroes(req, &elem->out_sg[1],
+                                           out_num, type);
+        if (rc == 0) {
+            req->in->status = VIRTIO_BLK_S_OK;
+        } else {
+            req->in->status = VIRTIO_BLK_S_IOERR;
+        }
+        break;
+    }
+    default:
+        req->in->status = VIRTIO_BLK_S_UNSUPP;
+        break;
+    }
+
+    vu_block_req_complete(req);
+    return;
+
+err:
+    free(elem);
+    g_free(req);
+    return;
+}
+
+static void vu_block_process_vq(VuDev *vu_dev, int idx)
+{
+    VuServer *server;
+    VuVirtq *vq;
+    struct req_data *req_data;
+
+    server = container_of(vu_dev, VuServer, vu_dev);
+    assert(server);
+
+    vq = vu_get_queue(vu_dev, idx);
+    assert(vq);
+    VuVirtqElement *elem;
+    while (1) {
+        elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) +
+                                    sizeof(VuBlockReq));
+        if (elem) {
+            req_data = g_new0(struct req_data, 1);
+            req_data->server = server;
+            req_data->vq = vq;
+            req_data->elem = elem;
+            Coroutine *co = qemu_coroutine_create(vu_block_virtio_process_req,
+                                                  req_data);
+            aio_co_enter(server->ioc->ctx, co);
+        } else {
+            break;
+        }
+    }
+}
+
+static void vu_block_queue_set_started(VuDev *vu_dev, int idx, bool started)
+{
+    VuVirtq *vq;
+
+    assert(vu_dev);
+
+    vq = vu_get_queue(vu_dev, idx);
+    vu_set_queue_handler(vu_dev, vq, started ? vu_block_process_vq : NULL);
+}
+
+static uint64_t vu_block_get_features(VuDev *dev)
+{
+    uint64_t features;
+    VuServer *server = container_of(dev, VuServer, vu_dev);
+    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
+    features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
+               1ull << VIRTIO_BLK_F_SEG_MAX |
+               1ull << VIRTIO_BLK_F_TOPOLOGY |
+               1ull << VIRTIO_BLK_F_BLK_SIZE |
+               1ull << VIRTIO_BLK_F_FLUSH |
+               1ull << VIRTIO_BLK_F_DISCARD |
+               1ull << VIRTIO_BLK_F_WRITE_ZEROES |
+               1ull << VIRTIO_BLK_F_CONFIG_WCE |
+               1ull << VIRTIO_F_VERSION_1 |
+               1ull << VIRTIO_RING_F_INDIRECT_DESC |
+               1ull << VIRTIO_RING_F_EVENT_IDX |
+               1ull << VHOST_USER_F_PROTOCOL_FEATURES;
+
+    if (!vdev_blk->writable) {
+        features |= 1ull << VIRTIO_BLK_F_RO;
+    }
+
+    return features;
+}
+
+static uint64_t vu_block_get_protocol_features(VuDev *dev)
+{
+    return 1ull << VHOST_USER_PROTOCOL_F_CONFIG |
+           1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD;
+}
+
+static int
+vu_block_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
+{
+    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
+    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
+    memcpy(config, &vdev_blk->blkcfg, len);
+
+    return 0;
+}
+
+static int
+vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
+                    uint32_t offset, uint32_t size, uint32_t flags)
+{
+    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
+    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
+    uint8_t wce;
+
+    /* don't support live migration */
+    if (flags != VHOST_SET_CONFIG_TYPE_MASTER) {
+        return -EINVAL;
+    }
+
+    if (offset != offsetof(struct virtio_blk_config, wce) ||
+        size != 1) {
+        return -EINVAL;
+    }
+
+    wce = *data;
+    vdev_blk->blkcfg.wce = wce;
+    blk_set_enable_write_cache(vdev_blk->backend, wce);
+    return 0;
+}
+
+/*
+ * When the client disconnects, it sends a VHOST_USER_NONE request
+ * and vu_process_message will simple call exit which cause the VM
+ * to exit abruptly.
+ * To avoid this issue,  process VHOST_USER_NONE request ahead
+ * of vu_process_message.
+ *
+ */
+static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
+{
+    if (vmsg->request == VHOST_USER_NONE) {
+        dev->panic(dev, "disconnect");
+        return true;
+    }
+    return false;
+}
+
+static const VuDevIface vu_block_iface = {
+    .get_features          = vu_block_get_features,
+    .queue_set_started     = vu_block_queue_set_started,
+    .get_protocol_features = vu_block_get_protocol_features,
+    .get_config            = vu_block_get_config,
+    .set_config            = vu_block_set_config,
+    .process_msg           = vu_block_process_msg,
+};
+
+static void blk_aio_attached(AioContext *ctx, void *opaque)
+{
+    VuBlockDev *vub_dev = opaque;
+    aio_context_acquire(ctx);
+    vhost_user_server_set_aio_context(&vub_dev->vu_server, ctx);
+    aio_context_release(ctx);
+}
+
+static void blk_aio_detach(void *opaque)
+{
+    VuBlockDev *vub_dev = opaque;
+    AioContext *ctx = vub_dev->vu_server.ctx;
+    aio_context_acquire(ctx);
+    vhost_user_server_set_aio_context(&vub_dev->vu_server, NULL);
+    aio_context_release(ctx);
+}
+
+static void
+vu_block_initialize_config(BlockDriverState *bs,
+                           struct virtio_blk_config *config, uint32_t blk_size)
+{
+    config->capacity = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
+    config->blk_size = blk_size;
+    config->size_max = 0;
+    config->seg_max = 128 - 2;
+    config->min_io_size = 1;
+    config->opt_io_size = 1;
+    config->num_queues = VHOST_USER_BLK_MAX_QUEUES;
+    config->max_discard_sectors = 32768;
+    config->max_discard_seg = 1;
+    config->discard_sector_alignment = config->blk_size >> 9;
+    config->max_write_zeroes_sectors = 32768;
+    config->max_write_zeroes_seg = 1;
+}
+
+static VuBlockDev *vu_block_init(VuBlockDev *vu_block_device, Error **errp)
+{
+
+    BlockBackend *blk;
+    Error *local_error = NULL;
+    const char *node_name = vu_block_device->node_name;
+    bool writable = vu_block_device->writable;
+    uint64_t perm = BLK_PERM_CONSISTENT_READ;
+    int ret;
+
+    AioContext *ctx;
+
+    BlockDriverState *bs = bdrv_lookup_bs(node_name, node_name, &local_error);
+
+    if (!bs) {
+        error_propagate(errp, local_error);
+        return NULL;
+    }
+
+    if (bdrv_is_read_only(bs)) {
+        writable = false;
+    }
+
+    if (writable) {
+        perm |= BLK_PERM_WRITE;
+    }
+
+    ctx = bdrv_get_aio_context(bs);
+    aio_context_acquire(ctx);
+    bdrv_invalidate_cache(bs, NULL);
+    aio_context_release(ctx);
+
+    /*
+     * Don't allow resize while the vhost user server is running,
+     * otherwise we don't care what happens with the node.
+     */
+    blk = blk_new(bdrv_get_aio_context(bs), perm,
+                  BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
+                  BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD);
+    ret = blk_insert_bs(blk, bs, errp);
+
+    if (ret < 0) {
+        goto fail;
+    }
+
+    blk_set_enable_write_cache(blk, false);
+
+    blk_set_allow_aio_context_change(blk, true);
+
+    vu_block_device->blkcfg.wce = 0;
+    vu_block_device->backend = blk;
+    if (!vu_block_device->blk_size) {
+        vu_block_device->blk_size = BDRV_SECTOR_SIZE;
+    }
+    vu_block_device->blkcfg.blk_size = vu_block_device->blk_size;
+    blk_set_guest_block_size(blk, vu_block_device->blk_size);
+    vu_block_initialize_config(bs, &vu_block_device->blkcfg,
+                                   vu_block_device->blk_size);
+    return vu_block_device;
+
+fail:
+    blk_unref(blk);
+    return NULL;
+}
+
+static void vu_block_deinit(VuBlockDev *vu_block_device)
+{
+    if (vu_block_device->backend) {
+        blk_remove_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
+                                        blk_aio_detach, vu_block_device);
+    }
+
+    blk_unref(vu_block_device->backend);
+}
+
+static void vhost_user_blk_server_stop(VuBlockDev *vu_block_device)
+{
+    vhost_user_server_stop(&vu_block_device->vu_server);
+    vu_block_deinit(vu_block_device);
+}
+
+static void vhost_user_blk_server_start(VuBlockDev *vu_block_device,
+                                        Error **errp)
+{
+    AioContext *ctx;
+    SocketAddress *addr = vu_block_device->addr;
+
+    if (!vu_block_init(vu_block_device, errp)) {
+        return;
+    }
+
+    ctx = bdrv_get_aio_context(blk_bs(vu_block_device->backend));
+
+    if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx,
+                                 VHOST_USER_BLK_MAX_QUEUES,
+                                 NULL, &vu_block_iface,
+                                 errp)) {
+        goto error;
+    }
+
+    blk_add_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
+                                 blk_aio_detach, vu_block_device);
+    vu_block_device->running = true;
+    return;
+
+ error:
+    vu_block_deinit(vu_block_device);
+}
+
+static bool vu_prop_modifiable(VuBlockDev *vus, Error **errp)
+{
+    if (vus->running) {
+            error_setg(errp, "The property can't be modified "
+                       "while the server is running");
+            return false;
+    }
+    return true;
+}
+
+static void vu_set_node_name(Object *obj, const char *value, Error **errp)
+{
+    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
+
+    if (!vu_prop_modifiable(vus, errp)) {
+        return;
+    }
+
+    if (vus->node_name) {
+        g_free(vus->node_name);
+    }
+
+    vus->node_name = g_strdup(value);
+}
+
+static char *vu_get_node_name(Object *obj, Error **errp)
+{
+    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
+    return g_strdup(vus->node_name);
+}
+
+static void free_socket_addr(SocketAddress *addr)
+{
+        g_free(addr->u.q_unix.path);
+        g_free(addr);
+}
+
+static void vu_set_unix_socket(Object *obj, const char *value,
+                               Error **errp)
+{
+    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
+
+    if (!vu_prop_modifiable(vus, errp)) {
+        return;
+    }
+
+    if (vus->addr) {
+        free_socket_addr(vus->addr);
+    }
+
+    SocketAddress *addr = g_new0(SocketAddress, 1);
+    addr->type = SOCKET_ADDRESS_TYPE_UNIX;
+    addr->u.q_unix.path = g_strdup(value);
+    vus->addr = addr;
+}
+
+static char *vu_get_unix_socket(Object *obj, Error **errp)
+{
+    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
+    return g_strdup(vus->addr->u.q_unix.path);
+}
+
+static bool vu_get_block_writable(Object *obj, Error **errp)
+{
+    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
+    return vus->writable;
+}
+
+static void vu_set_block_writable(Object *obj, bool value, Error **errp)
+{
+    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
+
+    if (!vu_prop_modifiable(vus, errp)) {
+            return;
+    }
+
+    vus->writable = value;
+}
+
+static void vu_get_blk_size(Object *obj, Visitor *v, const char *name,
+                            void *opaque, Error **errp)
+{
+    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
+    uint32_t value = vus->blk_size;
+
+    visit_type_uint32(v, name, &value, errp);
+}
+
+static void vu_set_blk_size(Object *obj, Visitor *v, const char *name,
+                            void *opaque, Error **errp)
+{
+    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
+
+    Error *local_err = NULL;
+    uint32_t value;
+
+    if (!vu_prop_modifiable(vus, errp)) {
+            return;
+    }
+
+    visit_type_uint32(v, name, &value, &local_err);
+    if (local_err) {
+        goto out;
+    }
+
+    check_block_size(object_get_typename(obj), name, value, &local_err);
+    if (local_err) {
+        goto out;
+    }
+
+    vus->blk_size = value;
+
+out:
+    error_propagate(errp, local_err);
+}
+
+static void vhost_user_blk_server_instance_finalize(Object *obj)
+{
+    VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
+
+    vhost_user_blk_server_stop(vub);
+
+    /*
+     * Unlike object_property_add_str, object_class_property_add_str
+     * doesn't have a release method. Thus manual memory freeing is
+     * needed.
+     */
+    free_socket_addr(vub->addr);
+    g_free(vub->node_name);
+}
+
+static void vhost_user_blk_server_complete(UserCreatable *obj, Error **errp)
+{
+    VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
+
+    vhost_user_blk_server_start(vub, errp);
+}
+
+static void vhost_user_blk_server_class_init(ObjectClass *klass,
+                                             void *class_data)
+{
+    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
+    ucc->complete = vhost_user_blk_server_complete;
+
+    object_class_property_add_bool(klass, "writable",
+                                   vu_get_block_writable,
+                                   vu_set_block_writable);
+
+    object_class_property_add_str(klass, "node-name",
+                                  vu_get_node_name,
+                                  vu_set_node_name);
+
+    object_class_property_add_str(klass, "unix-socket",
+                                  vu_get_unix_socket,
+                                  vu_set_unix_socket);
+
+    object_class_property_add(klass, "logical-block-size", "uint32",
+                              vu_get_blk_size, vu_set_blk_size,
+                              NULL, NULL);
+}
+
+static const TypeInfo vhost_user_blk_server_info = {
+    .name = TYPE_VHOST_USER_BLK_SERVER,
+    .parent = TYPE_OBJECT,
+    .instance_size = sizeof(VuBlockDev),
+    .instance_finalize = vhost_user_blk_server_instance_finalize,
+    .class_init = vhost_user_blk_server_class_init,
+    .interfaces = (InterfaceInfo[]) {
+        {TYPE_USER_CREATABLE},
+        {}
+    },
+};
+
+static void vhost_user_blk_server_register_types(void)
+{
+    type_register_static(&vhost_user_blk_server_info);
+}
+
+type_init(vhost_user_blk_server_register_types)
diff --git a/softmmu/vl.c b/softmmu/vl.c
index XXXXXXX..XXXXXXX 100644
--- a/softmmu/vl.c
+++ b/softmmu/vl.c
@@ -XXX,XX +XXX,XX @@ static bool object_create_initial(const char *type, QemuOpts *opts)
     }
 #endif
 
+    /* Reason: vhost-user-blk-server property "node-name" */
+    if (g_str_equal(type, "vhost-user-blk-server")) {
+        return false;
+    }
     /*
      * Reason: filter-* property "netdev" etc.
      */
diff --git a/block/meson.build b/block/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/block/meson.build
+++ b/block/meson.build
@@ -XXX,XX +XXX,XX @@ block_ss.add(when: 'CONFIG_WIN32', if_true: files('file-win32.c', 'win32-aio.c')
 block_ss.add(when: 'CONFIG_POSIX', if_true: [files('file-posix.c'), coref, iokit])
 block_ss.add(when: 'CONFIG_LIBISCSI', if_true: files('iscsi-opts.c'))
 block_ss.add(when: 'CONFIG_LINUX', if_true: files('nvme.c'))
+block_ss.add(when: 'CONFIG_LINUX', if_true: files('export/vhost-user-blk-server.c', '../contrib/libvhost-user/libvhost-user.c'))
 block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
 block_ss.add(when: 'CONFIG_SHEEPDOG', if_true: files('sheepdog.c'))
 block_ss.add(when: ['CONFIG_LINUX_AIO', libaio], if_true: files('linux-aio.c'))
-- 
2.26.2

From: Coiby Xu <coiby.xu@gmail.com>

Suggested-by: Stefano Garzarella <sgarzare@redhat.com>
Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Message-id: 20200918080912.321299-8-coiby.xu@gmail.com
[Removed reference to vhost-user-blk-test.c, it will be sent in a
separate pull request.
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 MAINTAINERS | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ L: qemu-block@nongnu.org
 S: Supported
 F: tests/image-fuzzer/
 
+Vhost-user block device backend server
+M: Coiby Xu <Coiby.Xu@gmail.com>
+S: Maintained
+F: block/export/vhost-user-blk-server.c
+F: util/vhost-user-server.c
+F: tests/qtest/libqos/vhost-user-blk.c
+
 Replication
 M: Wen Congyang <wencongyang2@huawei.com>
 M: Xie Changlong <xiechanglong.d@gmail.com>
-- 
2.26.2

Explicitly deleting watches is not necessary since libvhost-user calls
remove_watch() during vu_deinit(). Add an assertion to check this
though.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200924151549.913737-5-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vhost-user-server.c | 19 ++++---------------
 1 file changed, 4 insertions(+), 15 deletions(-)

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 @@ static void close_client(VuServer *server)
     /* When this is set vu_client_trip will stop new processing vhost-user message */
     server->sioc = NULL;
 
-    VuFdWatch *vu_fd_watch, *next;
-    QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
-        aio_set_fd_handler(server->ioc->ctx, vu_fd_watch->fd, true, NULL,
-                           NULL, NULL, NULL);
-    }
-
-    while (!QTAILQ_EMPTY(&server->vu_fd_watches)) {
-        QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
-            if (!vu_fd_watch->processing) {
-                QTAILQ_REMOVE(&server->vu_fd_watches, vu_fd_watch, next);
-                g_free(vu_fd_watch);
-            }
-        }
-    }
-
     while (server->processing_msg) {
         if (server->ioc->read_coroutine) {
             server->ioc->read_coroutine = NULL;
@@ -XXX,XX +XXX,XX @@ static void close_client(VuServer *server)
     }
 
     vu_deinit(&server->vu_dev);
+
+    /* vu_deinit() should have called remove_watch() */
+    assert(QTAILQ_EMPTY(&server->vu_fd_watches));
+
     object_unref(OBJECT(sioc));
     object_unref(OBJECT(server->ioc));
 }
-- 
2.26.2

Only one struct is needed per request. Drop req_data and the separate
VuBlockReq instance. Instead let vu_queue_pop() allocate everything at
once.

This fixes the req_data memory leak in vu_block_virtio_process_req().

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200924151549.913737-6-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/export/vhost-user-blk-server.c | 68 +++++++++-------------------
 1 file changed, 21 insertions(+), 47 deletions(-)

diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/vhost-user-blk-server.c
+++ b/block/export/vhost-user-blk-server.c
@@ -XXX,XX +XXX,XX @@ struct virtio_blk_inhdr {
 };
 
 typedef struct VuBlockReq {
-    VuVirtqElement *elem;
+    VuVirtqElement elem;
     int64_t sector_num;
     size_t size;
     struct virtio_blk_inhdr *in;
@@ -XXX,XX +XXX,XX @@ static void vu_block_req_complete(VuBlockReq *req)
     VuDev *vu_dev = &req->server->vu_dev;
 
     /* IO size with 1 extra status byte */
-    vu_queue_push(vu_dev, req->vq, req->elem, req->size + 1);
+    vu_queue_push(vu_dev, req->vq, &req->elem, req->size + 1);
     vu_queue_notify(vu_dev, req->vq);
 
-    if (req->elem) {
-        free(req->elem);
-    }
-
-    g_free(req);
+    free(req);
 }
 
 static VuBlockDev *get_vu_block_device_by_server(VuServer *server)
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_flush(VuBlockReq *req)
     blk_co_flush(backend);
 }
 
-struct req_data {
-    VuServer *server;
-    VuVirtq *vq;
-    VuVirtqElement *elem;
-};
-
 static void coroutine_fn vu_block_virtio_process_req(void *opaque)
 {
-    struct req_data *data = opaque;
-    VuServer *server = data->server;
-    VuVirtq *vq = data->vq;
-    VuVirtqElement *elem = data->elem;
+    VuBlockReq *req = opaque;
+    VuServer *server = req->server;
+    VuVirtqElement *elem = &req->elem;
     uint32_t type;
-    VuBlockReq *req;
 
     VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
     BlockBackend *backend = vdev_blk->backend;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
     struct iovec *out_iov = elem->out_sg;
     unsigned in_num = elem->in_num;
     unsigned out_num = elem->out_num;
+
     /* refer to hw/block/virtio_blk.c */
     if (elem->out_num < 1 || elem->in_num < 1) {
         error_report("virtio-blk request missing headers");
-        free(elem);
-        return;
+        goto err;
     }
 
-    req = g_new0(VuBlockReq, 1);
-    req->server = server;
-    req->vq = vq;
-    req->elem = elem;
-
     if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
                             sizeof(req->out)) != sizeof(req->out))) {
         error_report("virtio-blk request outhdr too short");
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
 
 err:
     free(elem);
-    g_free(req);
-    return;
 }
 
 static void vu_block_process_vq(VuDev *vu_dev, int idx)
 {
-    VuServer *server;
-    VuVirtq *vq;
-    struct req_data *req_data;
+    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
+    VuVirtq *vq = vu_get_queue(vu_dev, idx);
 
-    server = container_of(vu_dev, VuServer, vu_dev);
-    assert(server);
-
-    vq = vu_get_queue(vu_dev, idx);
-    assert(vq);
-    VuVirtqElement *elem;
     while (1) {
-        elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) +
-                                    sizeof(VuBlockReq));
-        if (elem) {
-            req_data = g_new0(struct req_data, 1);
-            req_data->server = server;
-            req_data->vq = vq;
-            req_data->elem = elem;
-            Coroutine *co = qemu_coroutine_create(vu_block_virtio_process_req,
-                                                  req_data);
-            aio_co_enter(server->ioc->ctx, co);
-        } else {
+        VuBlockReq *req;
+
+        req = vu_queue_pop(vu_dev, vq, sizeof(VuBlockReq));
+        if (!req) {
             break;
         }
+
+        req->server = server;
+        req->vq = vq;
+
+        Coroutine *co =
+            qemu_coroutine_create(vu_block_virtio_process_req, req);
+        qemu_coroutine_enter(co);
     }
 }
 
-- 
2.26.2

The device panic notifier callback is not used. Drop it.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200924151549.913737-7-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vhost-user-server.h             | 3 ---
 block/export/vhost-user-blk-server.c | 3 +--
 util/vhost-user-server.c             | 6 ------
 3 files changed, 1 insertion(+), 11 deletions(-)

diff --git a/util/vhost-user-server.h b/util/vhost-user-server.h
index XXXXXXX..XXXXXXX 100644
--- a/util/vhost-user-server.h
+++ b/util/vhost-user-server.h
@@ -XXX,XX +XXX,XX @@ typedef struct VuFdWatch {
 } VuFdWatch;
 
 typedef struct VuServer VuServer;
-typedef void DevicePanicNotifierFn(VuServer *server);
 
 struct VuServer {
     QIONetListener *listener;
     AioContext *ctx;
-    DevicePanicNotifierFn *device_panic_notifier;
     int max_queues;
     const VuDevIface *vu_iface;
     VuDev vu_dev;
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
                              SocketAddress *unix_socket,
                              AioContext *ctx,
                              uint16_t max_queues,
-                             DevicePanicNotifierFn *device_panic_notifier,
                              const VuDevIface *vu_iface,
                              Error **errp);
 
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/vhost-user-blk-server.c
+++ b/block/export/vhost-user-blk-server.c
@@ -XXX,XX +XXX,XX @@ static void vhost_user_blk_server_start(VuBlockDev *vu_block_device,
     ctx = bdrv_get_aio_context(blk_bs(vu_block_device->backend));
 
     if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx,
-                                 VHOST_USER_BLK_MAX_QUEUES,
-                                 NULL, &vu_block_iface,
+                                 VHOST_USER_BLK_MAX_QUEUES, &vu_block_iface,
                                  errp)) {
         goto error;
     }
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 @@ static void panic_cb(VuDev *vu_dev, const char *buf)
         close_client(server);
     }
 
-    if (server->device_panic_notifier) {
-        server->device_panic_notifier(server);
-    }
-
     /*
      * Set the callback function for network listener so another
      * vhost-user client can connect to this server
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
                              SocketAddress *socket_addr,
                              AioContext *ctx,
                              uint16_t max_queues,
-                             DevicePanicNotifierFn *device_panic_notifier,
                              const VuDevIface *vu_iface,
                              Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
         .vu_iface              = vu_iface,
         .max_queues            = max_queues,
         .ctx                   = ctx,
-        .device_panic_notifier = device_panic_notifier,
     };
 
     qio_net_listener_set_name(server->listener, "vhost-user-backend-listener");
-- 
2.26.2

fds[] is leaked when qio_channel_readv_full() fails.

Use vmsg->fds[] instead of keeping a local fds[] array. Then we can
reuse goto fail to clean up fds. vmsg->fd_num must be zeroed before the
loop to make this safe.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200924151549.913737-8-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vhost-user-server.c | 50 ++++++++++++++++++----------------------
 1 file changed, 23 insertions(+), 27 deletions(-)

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 @@ vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg)
     };
     int rc, read_bytes = 0;
     Error *local_err = NULL;
-    /*
-     * Store fds/nfds returned from qio_channel_readv_full into
-     * temporary variables.
-     *
-     * VhostUserMsg is a packed structure, gcc will complain about passing
-     * pointer to a packed structure member if we pass &VhostUserMsg.fd_num
-     * and &VhostUserMsg.fds directly when calling qio_channel_readv_full,
-     * thus two temporary variables nfds and fds are used here.
-     */
-    size_t nfds = 0, nfds_t = 0;
     const size_t max_fds = G_N_ELEMENTS(vmsg->fds);
-    int *fds_t = NULL;
     VuServer *server = container_of(vu_dev, VuServer, vu_dev);
     QIOChannel *ioc = server->ioc;
 
+    vmsg->fd_num = 0;
     if (!ioc) {
         error_report_err(local_err);
         goto fail;
@@ -XXX,XX +XXX,XX @@ vu_message_read(VuDev *vu_dev, int conn_fd, VhostUserMsg *vmsg)
 
     assert(qemu_in_coroutine());
     do {
+        size_t nfds = 0;
+        int *fds = NULL;
+
         /*
          * qio_channel_readv_full may have short reads, keeping calling it
          * until getting VHOST_USER_HDR_SIZE or 0 bytes in total
          */
-        rc = qio_channel_readv_full(ioc, &iov, 1, &fds_t, &nfds_t, &local_err);
+        rc = qio_channel_readv_full(ioc, &iov, 1, &fds, &nfds, &local_err);
         if (rc < 0) {
             if (rc == QIO_CHANNEL_ERR_BLOCK) {
+                assert(local_err == NULL);
                 qio_channel_yield(ioc, G_IO_IN);
                 continue;
             } else {
                 error_report_err(local_err);
-                return false;
+                goto fail;
             }
         }
-        read_bytes += rc;
-        if (nfds_t > 0) {
-            if (nfds + nfds_t > max_fds) {
+
+        if (nfds > 0) {
+            if (vmsg->fd_num + nfds > max_fds) {
                 error_report("A maximum of %zu fds are allowed, "
                              "however got %zu fds now",
-                             max_fds, nfds + nfds_t);
+                             max_fds, vmsg->fd_num + nfds);
+                g_free(fds);
                 goto fail;
             }
-            memcpy(vmsg->fds + nfds, fds_t,
-                   nfds_t *sizeof(vmsg->fds[0]));
-            nfds += nfds_t;
-            g_free(fds_t);
+            memcpy(vmsg->fds + vmsg->fd_num, fds, nfds * sizeof(vmsg->fds[0]));
+            vmsg->fd_num += nfds;
+            g_free(fds);
         }
-        if (read_bytes == VHOST_USER_HDR_SIZE || rc == 0) {
-            break;
+
+        if (rc == 0) { /* socket closed */
+            goto fail;
         }
-        iov.iov_base = (char *)vmsg + read_bytes;
-        iov.iov_len = VHOST_USER_HDR_SIZE - read_bytes;
-    } while (true);
 
-    vmsg->fd_num = nfds;
+        iov.iov_base += rc;
+        iov.iov_len -= rc;
+        read_bytes += rc;
+    } while (read_bytes != VHOST_USER_HDR_SIZE);
+
     /* qio_channel_readv_full will make socket fds blocking, unblock them */
     vmsg_unblock_fds(vmsg);
     if (vmsg->size > sizeof(vmsg->payload)) {
-- 
2.26.2

The vu_client_trip() coroutine is leaked during AioContext switching. It
is also unsafe to destroy the vu_dev in panic_cb() since its callers
still access it in some cases.

Rework the lifecycle to solve these safety issues.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200924151549.913737-10-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vhost-user-server.h             |  29 ++--
 block/export/vhost-user-blk-server.c |   9 +-
 util/vhost-user-server.c             | 245 +++++++++++++++------------
 3 files changed, 155 insertions(+), 128 deletions(-)

diff --git a/util/vhost-user-server.h b/util/vhost-user-server.h
index XXXXXXX..XXXXXXX 100644
--- a/util/vhost-user-server.h
+++ b/util/vhost-user-server.h
@@ -XXX,XX +XXX,XX @@
 #include "qapi/error.h"
 #include "standard-headers/linux/virtio_blk.h"
 
+/* A kick fd that we monitor on behalf of libvhost-user */
 typedef struct VuFdWatch {
     VuDev *vu_dev;
     int fd; /*kick fd*/
     void *pvt;
     vu_watch_cb cb;
-    bool processing;
     QTAILQ_ENTRY(VuFdWatch) next;
 } VuFdWatch;
 
-typedef struct VuServer VuServer;
-
-struct VuServer {
+/**
+ * VuServer:
+ * A vhost-user server instance with user-defined VuDevIface callbacks.
+ * Vhost-user device backends can be implemented using VuServer. VuDevIface
+ * callbacks and virtqueue kicks run in the given AioContext.
+ */
+typedef struct {
     QIONetListener *listener;
+    QEMUBH *restart_listener_bh;
     AioContext *ctx;
     int max_queues;
     const VuDevIface *vu_iface;
+
+    /* Protected by ctx lock */
     VuDev vu_dev;
     QIOChannel *ioc; /* The I/O channel with the client */
     QIOChannelSocket *sioc; /* The underlying data channel with the client */
-    /* IOChannel for fd provided via VHOST_USER_SET_SLAVE_REQ_FD */
-    QIOChannel *ioc_slave;
-    QIOChannelSocket *sioc_slave;
-    Coroutine *co_trip; /* coroutine for processing VhostUserMsg */
     QTAILQ_HEAD(, VuFdWatch) vu_fd_watches;
-    /* restart coroutine co_trip if AIOContext is changed */
-    bool aio_context_changed;
-    bool processing_msg;
-};
+
+    Coroutine *co_trip; /* coroutine for processing VhostUserMsg */
+} VuServer;
 
 bool vhost_user_server_start(VuServer *server,
                              SocketAddress *unix_socket,
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
 
 void vhost_user_server_stop(VuServer *server);
 
-void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx);
+void vhost_user_server_attach_aio_context(VuServer *server, AioContext *ctx);
+void vhost_user_server_detach_aio_context(VuServer *server);
 
 #endif /* VHOST_USER_SERVER_H */
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/vhost-user-blk-server.c
+++ b/block/export/vhost-user-blk-server.c
@@ -XXX,XX +XXX,XX @@ static const VuDevIface vu_block_iface = {
 static void blk_aio_attached(AioContext *ctx, void *opaque)
 {
     VuBlockDev *vub_dev = opaque;
-    aio_context_acquire(ctx);
-    vhost_user_server_set_aio_context(&vub_dev->vu_server, ctx);
-    aio_context_release(ctx);
+    vhost_user_server_attach_aio_context(&vub_dev->vu_server, ctx);
 }
 
 static void blk_aio_detach(void *opaque)
 {
     VuBlockDev *vub_dev = opaque;
-    AioContext *ctx = vub_dev->vu_server.ctx;
-    aio_context_acquire(ctx);
-    vhost_user_server_set_aio_context(&vub_dev->vu_server, NULL);
-    aio_context_release(ctx);
+    vhost_user_server_detach_aio_context(&vub_dev->vu_server);
 }
 
 static void
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 @@
  */
 #include "qemu/osdep.h"
 #include "qemu/main-loop.h"
+#include "block/aio-wait.h"
 #include "vhost-user-server.h"
 
+/*
+ * Theory of operation:
+ *
+ * VuServer is started and stopped by vhost_user_server_start() and
+ * vhost_user_server_stop() from the main loop thread. Starting the server
+ * opens a vhost-user UNIX domain socket and listens for incoming connections.
+ * Only one connection is allowed at a time.
+ *
+ * The connection is handled by the vu_client_trip() coroutine in the
+ * VuServer->ctx AioContext. The coroutine consists of a vu_dispatch() loop
+ * where libvhost-user calls vu_message_read() to receive the next vhost-user
+ * protocol messages over the UNIX domain socket.
+ *
+ * When virtqueues are set up libvhost-user calls set_watch() to monitor kick
+ * fds. These fds are also handled in the VuServer->ctx AioContext.
+ *
+ * Both vu_client_trip() and kick fd monitoring can be stopped by shutting down
+ * the socket connection. Shutting down the socket connection causes
+ * vu_message_read() to fail since no more data can be received from the socket.
+ * After vu_dispatch() fails, vu_client_trip() calls vu_deinit() to stop
+ * libvhost-user before terminating the coroutine. vu_deinit() calls
+ * remove_watch() to stop monitoring kick fds and this stops virtqueue
+ * processing.
+ *
+ * When vu_client_trip() has finished cleaning up it schedules a BH in the main
+ * loop thread to accept the next client connection.
+ *
+ * When libvhost-user detects an error it calls panic_cb() and sets the
+ * dev->broken flag. Both vu_client_trip() and kick fd processing stop when
+ * the dev->broken flag is set.
+ *
+ * It is possible to switch AioContexts using
+ * vhost_user_server_detach_aio_context() and
+ * vhost_user_server_attach_aio_context(). They stop monitoring fds in the old
+ * AioContext and resume monitoring in the new AioContext. The vu_client_trip()
+ * coroutine remains in a yielded state during the switch. This is made
+ * possible by QIOChannel's support for spurious coroutine re-entry in
+ * qio_channel_yield(). The coroutine will restart I/O when re-entered from the
+ * new AioContext.
+ */
+
 static void vmsg_close_fds(VhostUserMsg *vmsg)
 {
     int i;
@@ -XXX,XX +XXX,XX @@ static void vmsg_unblock_fds(VhostUserMsg *vmsg)
     }
 }
 
-static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
-                      gpointer opaque);
-
-static void close_client(VuServer *server)
-{
-    /*
-     * Before closing the client
-     *
-     * 1. Let vu_client_trip stop processing new vhost-user msg
-     *
-     * 2. remove kick_handler
-     *
-     * 3. wait for the kick handler to be finished
-     *
-     * 4. wait for the current vhost-user msg to be finished processing
-     */
-
-    QIOChannelSocket *sioc = server->sioc;
-    /* When this is set vu_client_trip will stop new processing vhost-user message */
-    server->sioc = NULL;
-
-    while (server->processing_msg) {
-        if (server->ioc->read_coroutine) {
-            server->ioc->read_coroutine = NULL;
-            qio_channel_set_aio_fd_handler(server->ioc, server->ioc->ctx, NULL,
-                                           NULL, server->ioc);
-            server->processing_msg = false;
-        }
-    }
-
-    vu_deinit(&server->vu_dev);
-
-    /* vu_deinit() should have called remove_watch() */
-    assert(QTAILQ_EMPTY(&server->vu_fd_watches));
-
-    object_unref(OBJECT(sioc));
-    object_unref(OBJECT(server->ioc));
-}
-
 static void panic_cb(VuDev *vu_dev, const char *buf)
 {
-    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
-
-    /* avoid while loop in close_client */
-    server->processing_msg = false;
-
-    if (buf) {
-        error_report("vu_panic: %s", buf);
-    }
-
-    if (server->sioc) {
-        close_client(server);
-    }
-
-    /*
-     * Set the callback function for network listener so another
-     * vhost-user client can connect to this server
-     */
-    qio_net_listener_set_client_func(server->listener,
-                                     vu_accept,
-                                     server,
-                                     NULL);
+    error_report("vu_panic: %s", buf);
 }
 
 static bool coroutine_fn
@@ -XXX,XX +XXX,XX @@ fail:
     return false;
 }
 
-
-static void vu_client_start(VuServer *server);
 static coroutine_fn void vu_client_trip(void *opaque)
 {
     VuServer *server = opaque;
+    VuDev *vu_dev = &server->vu_dev;
 
-    while (!server->aio_context_changed && server->sioc) {
-        server->processing_msg = true;
-        vu_dispatch(&server->vu_dev);
-        server->processing_msg = false;
+    while (!vu_dev->broken && vu_dispatch(vu_dev)) {
+        /* Keep running */
     }
 
-    if (server->aio_context_changed && server->sioc) {
-        server->aio_context_changed = false;
-        vu_client_start(server);
-    }
-}
+    vu_deinit(vu_dev);
+
+    /* vu_deinit() should have called remove_watch() */
+    assert(QTAILQ_EMPTY(&server->vu_fd_watches));
+
+    object_unref(OBJECT(server->sioc));
+    server->sioc = NULL;
 
-static void vu_client_start(VuServer *server)
-{
-    server->co_trip = qemu_coroutine_create(vu_client_trip, server);
-    aio_co_enter(server->ctx, server->co_trip);
+    object_unref(OBJECT(server->ioc));
+    server->ioc = NULL;
+
+    server->co_trip = NULL;
+    if (server->restart_listener_bh) {
+        qemu_bh_schedule(server->restart_listener_bh);
+    }
+    aio_wait_kick();
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ static void vu_client_start(VuServer *server)
 static void kick_handler(void *opaque)
 {
     VuFdWatch *vu_fd_watch = opaque;
-    vu_fd_watch->processing = true;
-    vu_fd_watch->cb(vu_fd_watch->vu_dev, 0, vu_fd_watch->pvt);
-    vu_fd_watch->processing = false;
+    VuDev *vu_dev = vu_fd_watch->vu_dev;
+
+    vu_fd_watch->cb(vu_dev, 0, vu_fd_watch->pvt);
+
+    /* Stop vu_client_trip() if an error occurred in vu_fd_watch->cb() */
+    if (vu_dev->broken) {
+        VuServer *server = container_of(vu_dev, VuServer, vu_dev);
+
+        qio_channel_shutdown(server->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
+    }
 }
 
-
 static VuFdWatch *find_vu_fd_watch(VuServer *server, int fd)
 {
 
@@ -XXX,XX +XXX,XX @@ static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
     qio_channel_set_name(QIO_CHANNEL(sioc), "vhost-user client");
     server->ioc = QIO_CHANNEL(sioc);
     object_ref(OBJECT(server->ioc));
-    qio_channel_attach_aio_context(server->ioc, server->ctx);
+
+    /* TODO vu_message_write() spins if non-blocking! */
     qio_channel_set_blocking(server->ioc, false, NULL);
-    vu_client_start(server);
+
+    server->co_trip = qemu_coroutine_create(vu_client_trip, server);
+
+    aio_context_acquire(server->ctx);
+    vhost_user_server_attach_aio_context(server, server->ctx);
+    aio_context_release(server->ctx);
 }
 
-
 void vhost_user_server_stop(VuServer *server)
 {
+    aio_context_acquire(server->ctx);
+
+    qemu_bh_delete(server->restart_listener_bh);
+    server->restart_listener_bh = NULL;
+
     if (server->sioc) {
-        close_client(server);
+        VuFdWatch *vu_fd_watch;
+
+        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);
+        }
+
+        qio_channel_shutdown(server->ioc, QIO_CHANNEL_SHUTDOWN_BOTH, NULL);
+
+        AIO_WAIT_WHILE(server->ctx, server->co_trip);
     }
 
+    aio_context_release(server->ctx);
+
     if (server->listener) {
         qio_net_listener_disconnect(server->listener);
         object_unref(OBJECT(server->listener));
     }
+}
+
+/*
+ * Allow the next client to connect to the server. Called from a BH in the main
+ * loop.
+ */
+static void restart_listener_bh(void *opaque)
+{
+    VuServer *server = opaque;
 
+    qio_net_listener_set_client_func(server->listener, vu_accept, server,
+                                     NULL);
 }
 
-void vhost_user_server_set_aio_context(VuServer *server, AioContext *ctx)
+/* Called with ctx acquired */
+void vhost_user_server_attach_aio_context(VuServer *server, AioContext *ctx)
 {
-    VuFdWatch *vu_fd_watch, *next;
-    void *opaque = NULL;
-    IOHandler *io_read = NULL;
-    bool attach;
+    VuFdWatch *vu_fd_watch;
 
-    server->ctx = ctx ? ctx : qemu_get_aio_context();
+    server->ctx = ctx;
 
     if (!server->sioc) {
-        /* not yet serving any client*/
         return;
     }
 
-    if (ctx) {
-        qio_channel_attach_aio_context(server->ioc, ctx);
-        server->aio_context_changed = true;
-        io_read = kick_handler;
-        attach = true;
-    } else {
+    qio_channel_attach_aio_context(server->ioc, 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);
+    }
+
+    aio_co_schedule(ctx, server->co_trip);
+}
+
+/* Called with server->ctx acquired */
+void vhost_user_server_detach_aio_context(VuServer *server)
+{
+    if (server->sioc) {
+        VuFdWatch *vu_fd_watch;
+
+        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);
+        }
+
         qio_channel_detach_aio_context(server->ioc);
-        /* server->ioc->ctx keeps the old AioConext */
-        ctx = server->ioc->ctx;
-        attach = false;
     }
 
-    QTAILQ_FOREACH_SAFE(vu_fd_watch, &server->vu_fd_watches, next, next) {
-        if (vu_fd_watch->cb) {
-            opaque = attach ? vu_fd_watch : NULL;
-            aio_set_fd_handler(ctx, vu_fd_watch->fd, true,
-                               io_read, NULL, NULL,
-                               opaque);
-        }
-    }
+    server->ctx = NULL;
 }
 
-
 bool vhost_user_server_start(VuServer *server,
                              SocketAddress *socket_addr,
                              AioContext *ctx,
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
                              const VuDevIface *vu_iface,
                              Error **errp)
 {
+    QEMUBH *bh;
     QIONetListener *listener = qio_net_listener_new();
     if (qio_net_listener_open_sync(listener, socket_addr, 1,
                                    errp) < 0) {
@@ -XXX,XX +XXX,XX @@ bool vhost_user_server_start(VuServer *server,
         return false;
     }
 
+    bh = qemu_bh_new(restart_listener_bh, server);
+
     /* zero out unspecified fields */
     *server = (VuServer) {
         .listener              = listener,
+        .restart_listener_bh   = bh,
         .vu_iface              = vu_iface,
         .max_queues            = max_queues,
         .ctx                   = ctx,
-- 
2.26.2

Propagate the flush return value since errors are possible.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200924151549.913737-11-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/export/vhost-user-blk-server.c | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

Use the new QAPI block exports API instead of defining our own QOM
objects.

This is a large change because the lifecycle of VuBlockDev needs to
follow BlockExportDriver. QOM properties are replaced by QAPI options
objects.

VuBlockDev is renamed VuBlkExport and contains a BlockExport field.
Several fields can be dropped since BlockExport already has equivalents.

The file names and meson build integration will be adjusted in a future
patch. libvhost-user should probably be built as a static library that
is linked into QEMU instead of as a .c file that results in duplicate
compilation.

The new command-line syntax is:

$ qemu-storage-daemon \
      --blockdev file,node-name=drive0,filename=test.img \
      --export vhost-user-blk,node-name=drive0,id=export0,unix-socket=/tmp/vhost-user-blk.sock

Note that unix-socket is optional because we may wish to accept chardevs
too in the future.

Markus noted that supported address families are not explicit in the
QAPI schema. It is unlikely that support for more address families will
be added since file descriptor passing is required and few address
families support it. If a new address family needs to be added, then the
QAPI 'features' syntax can be used to advertize them.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20200924151549.913737-12-stefanha@redhat.com
[Skip test on big-endian host architectures because this device doesn't
support them yet (as already mentioned in a code comment).
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/block-export.json               |  21 +-
 block/export/vhost-user-blk-server.h |  23 +-
 block/export/export.c                |   6 +
 block/export/vhost-user-blk-server.c | 452 +++++++--------------------
 util/vhost-user-server.c             |  10 +-
 block/export/meson.build             |   1 +
 block/meson.build                    |   1 -
 7 files changed, 156 insertions(+), 358 deletions(-)

diff --git a/qapi/block-export.json b/qapi/block-export.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-export.json
+++ b/qapi/block-export.json
@@ -XXX,XX +XXX,XX @@
   'data': { '*name': 'str', '*description': 'str',
             '*bitmap': 'str' } }
 
+##
+# @BlockExportOptionsVhostUserBlk:
+#
+# A vhost-user-blk block export.
+#
+# @addr: The vhost-user socket on which to listen. Both 'unix' and 'fd'
+#        SocketAddress types are supported. Passed fds must be UNIX domain
+#        sockets.
+# @logical-block-size: Logical block size in bytes. Defaults to 512 bytes.
+#
+# Since: 5.2
+##
+{ 'struct': 'BlockExportOptionsVhostUserBlk',
+  'data': { 'addr': 'SocketAddress', '*logical-block-size': 'size' } }
+
 ##
 # @NbdServerAddOptions:
 #
@@ -XXX,XX +XXX,XX @@
 # An enumeration of block export types
 #
 # @nbd: NBD export
+# @vhost-user-blk: vhost-user-blk export (since 5.2)
 #
 # Since: 4.2
 ##
 { 'enum': 'BlockExportType',
-  'data': [ 'nbd' ] }
+  'data': [ 'nbd', 'vhost-user-blk' ] }
 
 ##
 # @BlockExportOptions:
@@ -XXX,XX +XXX,XX @@
             '*writethrough': 'bool' },
   'discriminator': 'type',
   'data': {
-      'nbd': 'BlockExportOptionsNbd'
+      'nbd': 'BlockExportOptionsNbd',
+      'vhost-user-blk': 'BlockExportOptionsVhostUserBlk'
    } }
 
 ##
diff --git a/block/export/vhost-user-blk-server.h b/block/export/vhost-user-blk-server.h
index XXXXXXX..XXXXXXX 100644
--- a/block/export/vhost-user-blk-server.h
+++ b/block/export/vhost-user-blk-server.h
@@ -XXX,XX +XXX,XX @@
 
 #ifndef VHOST_USER_BLK_SERVER_H
 #define VHOST_USER_BLK_SERVER_H
-#include "util/vhost-user-server.h"
 
-typedef struct VuBlockDev VuBlockDev;
-#define TYPE_VHOST_USER_BLK_SERVER "vhost-user-blk-server"
-#define VHOST_USER_BLK_SERVER(obj) \
-   OBJECT_CHECK(VuBlockDev, obj, TYPE_VHOST_USER_BLK_SERVER)
+#include "block/export.h"
 
-/* vhost user block device */
-struct VuBlockDev {
-    Object parent_obj;
-    char *node_name;
-    SocketAddress *addr;
-    AioContext *ctx;
-    VuServer vu_server;
-    bool running;
-    uint32_t blk_size;
-    BlockBackend *backend;
-    QIOChannelSocket *sioc;
-    QTAILQ_ENTRY(VuBlockDev) next;
-    struct virtio_blk_config blkcfg;
-    bool writable;
-};
+/* For block/export/export.c */
+extern const BlockExportDriver blk_exp_vhost_user_blk;
 
 #endif /* VHOST_USER_BLK_SERVER_H */
diff --git a/block/export/export.c b/block/export/export.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/export.c
+++ b/block/export/export.c
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/block-backend.h"
 #include "block/export.h"
 #include "block/nbd.h"
+#if CONFIG_LINUX
+#include "block/export/vhost-user-blk-server.h"
+#endif
 #include "qapi/error.h"
 #include "qapi/qapi-commands-block-export.h"
 #include "qapi/qapi-events-block-export.h"
@@ -XXX,XX +XXX,XX @@
 
 static const BlockExportDriver *blk_exp_drivers[] = {
     &blk_exp_nbd,
+#if CONFIG_LINUX
+    &blk_exp_vhost_user_blk,
+#endif
 };
 
 /* Only accessed from the main thread */
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/vhost-user-blk-server.c
+++ b/block/export/vhost-user-blk-server.c
@@ -XXX,XX +XXX,XX @@
  */
 #include "qemu/osdep.h"
 #include "block/block.h"
+#include "contrib/libvhost-user/libvhost-user.h"
+#include "standard-headers/linux/virtio_blk.h"
+#include "util/vhost-user-server.h"
 #include "vhost-user-blk-server.h"
 #include "qapi/error.h"
 #include "qom/object_interfaces.h"
@@ -XXX,XX +XXX,XX @@ struct virtio_blk_inhdr {
     unsigned char status;
 };
 
-typedef struct VuBlockReq {
+typedef struct VuBlkReq {
     VuVirtqElement elem;
     int64_t sector_num;
     size_t size;
@@ -XXX,XX +XXX,XX @@ typedef struct VuBlockReq {
     struct virtio_blk_outhdr out;
     VuServer *server;
     struct VuVirtq *vq;
-} VuBlockReq;
+} VuBlkReq;
 
-static void vu_block_req_complete(VuBlockReq *req)
+/* vhost user block device */
+typedef struct {
+    BlockExport export;
+    VuServer vu_server;
+    uint32_t blk_size;
+    QIOChannelSocket *sioc;
+    struct virtio_blk_config blkcfg;
+    bool writable;
+} VuBlkExport;
+
+static void vu_blk_req_complete(VuBlkReq *req)
 {
     VuDev *vu_dev = &req->server->vu_dev;
 
@@ -XXX,XX +XXX,XX @@ static void vu_block_req_complete(VuBlockReq *req)
     free(req);
 }
 
-static VuBlockDev *get_vu_block_device_by_server(VuServer *server)
-{
-    return container_of(server, VuBlockDev, vu_server);
-}
-
 static int coroutine_fn
-vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
-                              uint32_t iovcnt, uint32_t type)
+vu_blk_discard_write_zeroes(BlockBackend *blk, struct iovec *iov,
+                            uint32_t iovcnt, uint32_t type)
 {
     struct virtio_blk_discard_write_zeroes desc;
     ssize_t size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc));
@@ -XXX,XX +XXX,XX @@ vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
         return -EINVAL;
     }
 
-    VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
     uint64_t range[2] = { le64_to_cpu(desc.sector) << 9,
                           le32_to_cpu(desc.num_sectors) << 9 };
     if (type == VIRTIO_BLK_T_DISCARD) {
-        if (blk_co_pdiscard(vdev_blk->backend, range[0], range[1]) == 0) {
+        if (blk_co_pdiscard(blk, range[0], range[1]) == 0) {
             return 0;
         }
     } else if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
-        if (blk_co_pwrite_zeroes(vdev_blk->backend,
-                                 range[0], range[1], 0) == 0) {
+        if (blk_co_pwrite_zeroes(blk, range[0], range[1], 0) == 0) {
             return 0;
         }
     }
@@ -XXX,XX +XXX,XX @@ vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
     return -EINVAL;
 }
 
-static int coroutine_fn vu_block_flush(VuBlockReq *req)
+static void coroutine_fn vu_blk_virtio_process_req(void *opaque)
 {
-    VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
-    BlockBackend *backend = vdev_blk->backend;
-    return blk_co_flush(backend);
-}
-
-static void coroutine_fn vu_block_virtio_process_req(void *opaque)
-{
-    VuBlockReq *req = opaque;
+    VuBlkReq *req = opaque;
     VuServer *server = req->server;
     VuVirtqElement *elem = &req->elem;
     uint32_t type;
 
-    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
-    BlockBackend *backend = vdev_blk->backend;
+    VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
+    BlockBackend *blk = vexp->export.blk;
 
     struct iovec *in_iov = elem->in_sg;
     struct iovec *out_iov = elem->out_sg;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
         bool is_write = type & VIRTIO_BLK_T_OUT;
         req->sector_num = le64_to_cpu(req->out.sector);
 
-        int64_t offset = req->sector_num * vdev_blk->blk_size;
+        if (is_write && !vexp->writable) {
+            req->in->status = VIRTIO_BLK_S_IOERR;
+            break;
+        }
+
+        int64_t offset = req->sector_num * vexp->blk_size;
         QEMUIOVector qiov;
         if (is_write) {
             qemu_iovec_init_external(&qiov, out_iov, out_num);
-            ret = blk_co_pwritev(backend, offset, qiov.size,
-                                 &qiov, 0);
+            ret = blk_co_pwritev(blk, offset, qiov.size, &qiov, 0);
         } else {
             qemu_iovec_init_external(&qiov, in_iov, in_num);
-            ret = blk_co_preadv(backend, offset, qiov.size,
-                                &qiov, 0);
+            ret = blk_co_preadv(blk, offset, qiov.size, &qiov, 0);
         }
         if (ret >= 0) {
             req->in->status = VIRTIO_BLK_S_OK;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
         break;
     }
     case VIRTIO_BLK_T_FLUSH:
-        if (vu_block_flush(req) == 0) {
+        if (blk_co_flush(blk) == 0) {
             req->in->status = VIRTIO_BLK_S_OK;
         } else {
             req->in->status = VIRTIO_BLK_S_IOERR;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
     case VIRTIO_BLK_T_DISCARD:
     case VIRTIO_BLK_T_WRITE_ZEROES: {
         int rc;
-        rc = vu_block_discard_write_zeroes(req, &elem->out_sg[1],
-                                           out_num, type);
+
+        if (!vexp->writable) {
+            req->in->status = VIRTIO_BLK_S_IOERR;
+            break;
+        }
+
+        rc = vu_blk_discard_write_zeroes(blk, &elem->out_sg[1], out_num, type);
         if (rc == 0) {
             req->in->status = VIRTIO_BLK_S_OK;
         } else {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn vu_block_virtio_process_req(void *opaque)
         break;
     }
 
-    vu_block_req_complete(req);
+    vu_blk_req_complete(req);
     return;
 
 err:
-    free(elem);
+    free(req);
 }
 
-static void vu_block_process_vq(VuDev *vu_dev, int idx)
+static void vu_blk_process_vq(VuDev *vu_dev, int idx)
 {
     VuServer *server = container_of(vu_dev, VuServer, vu_dev);
     VuVirtq *vq = vu_get_queue(vu_dev, idx);
 
     while (1) {
-        VuBlockReq *req;
+        VuBlkReq *req;
 
-        req = vu_queue_pop(vu_dev, vq, sizeof(VuBlockReq));
+        req = vu_queue_pop(vu_dev, vq, sizeof(VuBlkReq));
         if (!req) {
             break;
         }
@@ -XXX,XX +XXX,XX @@ static void vu_block_process_vq(VuDev *vu_dev, int idx)
         req->vq = vq;
 
         Coroutine *co =
-            qemu_coroutine_create(vu_block_virtio_process_req, req);
+            qemu_coroutine_create(vu_blk_virtio_process_req, req);
         qemu_coroutine_enter(co);
     }
 }
 
-static void vu_block_queue_set_started(VuDev *vu_dev, int idx, bool started)
+static void vu_blk_queue_set_started(VuDev *vu_dev, int idx, bool started)
 {
     VuVirtq *vq;
 
     assert(vu_dev);
 
     vq = vu_get_queue(vu_dev, idx);
-    vu_set_queue_handler(vu_dev, vq, started ? vu_block_process_vq : NULL);
+    vu_set_queue_handler(vu_dev, vq, started ? vu_blk_process_vq : NULL);
 }
 
-static uint64_t vu_block_get_features(VuDev *dev)
+static uint64_t vu_blk_get_features(VuDev *dev)
 {
     uint64_t features;
     VuServer *server = container_of(dev, VuServer, vu_dev);
-    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
+    VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
     features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
                1ull << VIRTIO_BLK_F_SEG_MAX |
                1ull << VIRTIO_BLK_F_TOPOLOGY |
@@ -XXX,XX +XXX,XX @@ static uint64_t vu_block_get_features(VuDev *dev)
                1ull << VIRTIO_RING_F_EVENT_IDX |
                1ull << VHOST_USER_F_PROTOCOL_FEATURES;
 
-    if (!vdev_blk->writable) {
+    if (!vexp->writable) {
         features |= 1ull << VIRTIO_BLK_F_RO;
     }
 
     return features;
 }
 
-static uint64_t vu_block_get_protocol_features(VuDev *dev)
+static uint64_t vu_blk_get_protocol_features(VuDev *dev)
 {
     return 1ull << VHOST_USER_PROTOCOL_F_CONFIG |
            1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD;
 }
 
 static int
-vu_block_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
+vu_blk_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
 {
+    /* TODO blkcfg must be little-endian for VIRTIO 1.0 */
     VuServer *server = container_of(vu_dev, VuServer, vu_dev);
-    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
-    memcpy(config, &vdev_blk->blkcfg, len);
-
+    VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
+    memcpy(config, &vexp->blkcfg, len);
     return 0;
 }
 
 static int
-vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
+vu_blk_set_config(VuDev *vu_dev, const uint8_t *data,
                     uint32_t offset, uint32_t size, uint32_t flags)
 {
     VuServer *server = container_of(vu_dev, VuServer, vu_dev);
-    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
+    VuBlkExport *vexp = container_of(server, VuBlkExport, vu_server);
     uint8_t wce;
 
     /* don't support live migration */
@@ -XXX,XX +XXX,XX @@ vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
     }
 
     wce = *data;
-    vdev_blk->blkcfg.wce = wce;
-    blk_set_enable_write_cache(vdev_blk->backend, wce);
+    vexp->blkcfg.wce = wce;
+    blk_set_enable_write_cache(vexp->export.blk, wce);
     return 0;
 }
 
@@ -XXX,XX +XXX,XX @@ vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
  * of vu_process_message.
  *
  */
-static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
+static int vu_blk_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
 {
     if (vmsg->request == VHOST_USER_NONE) {
         dev->panic(dev, "disconnect");
@@ -XXX,XX +XXX,XX @@ static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
     return false;
 }
 
-static const VuDevIface vu_block_iface = {
-    .get_features          = vu_block_get_features,
-    .queue_set_started     = vu_block_queue_set_started,
-    .get_protocol_features = vu_block_get_protocol_features,
-    .get_config            = vu_block_get_config,
-    .set_config            = vu_block_set_config,
-    .process_msg           = vu_block_process_msg,
+static const VuDevIface vu_blk_iface = {
+    .get_features          = vu_blk_get_features,
+    .queue_set_started     = vu_blk_queue_set_started,
+    .get_protocol_features = vu_blk_get_protocol_features,
+    .get_config            = vu_blk_get_config,
+    .set_config            = vu_blk_set_config,
+    .process_msg           = vu_blk_process_msg,
 };
 
 static void blk_aio_attached(AioContext *ctx, void *opaque)
 {
-    VuBlockDev *vub_dev = opaque;
-    vhost_user_server_attach_aio_context(&vub_dev->vu_server, ctx);
+    VuBlkExport *vexp = opaque;
+    vhost_user_server_attach_aio_context(&vexp->vu_server, ctx);
 }
 
 static void blk_aio_detach(void *opaque)
 {
-    VuBlockDev *vub_dev = opaque;
-    vhost_user_server_detach_aio_context(&vub_dev->vu_server);
+    VuBlkExport *vexp = opaque;
+    vhost_user_server_detach_aio_context(&vexp->vu_server);
 }
 
 static void
-vu_block_initialize_config(BlockDriverState *bs,
+vu_blk_initialize_config(BlockDriverState *bs,
                            struct virtio_blk_config *config, uint32_t blk_size)
 {
     config->capacity = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
@@ -XXX,XX +XXX,XX @@ vu_block_initialize_config(BlockDriverState *bs,
     config->max_write_zeroes_seg = 1;
 }
 
-static VuBlockDev *vu_block_init(VuBlockDev *vu_block_device, Error **errp)
+static void vu_blk_exp_request_shutdown(BlockExport *exp)
 {
+    VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
 
-    BlockBackend *blk;
-    Error *local_error = NULL;
-    const char *node_name = vu_block_device->node_name;
-    bool writable = vu_block_device->writable;
-    uint64_t perm = BLK_PERM_CONSISTENT_READ;
-    int ret;
-
-    AioContext *ctx;
-
-    BlockDriverState *bs = bdrv_lookup_bs(node_name, node_name, &local_error);
-
-    if (!bs) {
-        error_propagate(errp, local_error);
-        return NULL;
-    }
-
-    if (bdrv_is_read_only(bs)) {
-        writable = false;
-    }
-
-    if (writable) {
-        perm |= BLK_PERM_WRITE;
-    }
-
-    ctx = bdrv_get_aio_context(bs);
-    aio_context_acquire(ctx);
-    bdrv_invalidate_cache(bs, NULL);
-    aio_context_release(ctx);
-
-    /*
-     * Don't allow resize while the vhost user server is running,
-     * otherwise we don't care what happens with the node.
-     */
-    blk = blk_new(bdrv_get_aio_context(bs), perm,
-                  BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
-                  BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD);
-    ret = blk_insert_bs(blk, bs, errp);
-
-    if (ret < 0) {
-        goto fail;
-    }
-
-    blk_set_enable_write_cache(blk, false);
-
-    blk_set_allow_aio_context_change(blk, true);
-
-    vu_block_device->blkcfg.wce = 0;
-    vu_block_device->backend = blk;
-    if (!vu_block_device->blk_size) {
-        vu_block_device->blk_size = BDRV_SECTOR_SIZE;
-    }
-    vu_block_device->blkcfg.blk_size = vu_block_device->blk_size;
-    blk_set_guest_block_size(blk, vu_block_device->blk_size);
-    vu_block_initialize_config(bs, &vu_block_device->blkcfg,
-                                   vu_block_device->blk_size);
-    return vu_block_device;
-
-fail:
-    blk_unref(blk);
-    return NULL;
-}
-
-static void vu_block_deinit(VuBlockDev *vu_block_device)
-{
-    if (vu_block_device->backend) {
-        blk_remove_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
-                                        blk_aio_detach, vu_block_device);
-    }
-
-    blk_unref(vu_block_device->backend);
-}
-
-static void vhost_user_blk_server_stop(VuBlockDev *vu_block_device)
-{
-    vhost_user_server_stop(&vu_block_device->vu_server);
-    vu_block_deinit(vu_block_device);
-}
-
-static void vhost_user_blk_server_start(VuBlockDev *vu_block_device,
-                                        Error **errp)
-{
-    AioContext *ctx;
-    SocketAddress *addr = vu_block_device->addr;
-
-    if (!vu_block_init(vu_block_device, errp)) {
-        return;
-    }
-
-    ctx = bdrv_get_aio_context(blk_bs(vu_block_device->backend));
-
-    if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx,
-                                 VHOST_USER_BLK_MAX_QUEUES, &vu_block_iface,
-                                 errp)) {
-        goto error;
-    }
-
-    blk_add_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
-                                 blk_aio_detach, vu_block_device);
-    vu_block_device->running = true;
-    return;
-
- error:
-    vu_block_deinit(vu_block_device);
-}
-
-static bool vu_prop_modifiable(VuBlockDev *vus, Error **errp)
-{
-    if (vus->running) {
-            error_setg(errp, "The property can't be modified "
-                       "while the server is running");
-            return false;
-    }
-    return true;
-}
-
-static void vu_set_node_name(Object *obj, const char *value, Error **errp)
-{
-    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-
-    if (!vu_prop_modifiable(vus, errp)) {
-        return;
-    }
-
-    if (vus->node_name) {
-        g_free(vus->node_name);
-    }
-
-    vus->node_name = g_strdup(value);
-}
-
-static char *vu_get_node_name(Object *obj, Error **errp)
-{
-    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-    return g_strdup(vus->node_name);
-}
-
-static void free_socket_addr(SocketAddress *addr)
-{
-        g_free(addr->u.q_unix.path);
-        g_free(addr);
-}
-
-static void vu_set_unix_socket(Object *obj, const char *value,
-                               Error **errp)
-{
-    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-
-    if (!vu_prop_modifiable(vus, errp)) {
-        return;
-    }
-
-    if (vus->addr) {
-        free_socket_addr(vus->addr);
-    }
-
-    SocketAddress *addr = g_new0(SocketAddress, 1);
-    addr->type = SOCKET_ADDRESS_TYPE_UNIX;
-    addr->u.q_unix.path = g_strdup(value);
-    vus->addr = addr;
+    vhost_user_server_stop(&vexp->vu_server);
 }
 
-static char *vu_get_unix_socket(Object *obj, Error **errp)
+static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
+                             Error **errp)
 {
-    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-    return g_strdup(vus->addr->u.q_unix.path);
-}
-
-static bool vu_get_block_writable(Object *obj, Error **errp)
-{
-    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-    return vus->writable;
-}
-
-static void vu_set_block_writable(Object *obj, bool value, Error **errp)
-{
-    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-
-    if (!vu_prop_modifiable(vus, errp)) {
-            return;
-    }
-
-    vus->writable = value;
-}
-
-static void vu_get_blk_size(Object *obj, Visitor *v, const char *name,
-                            void *opaque, Error **errp)
-{
-    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-    uint32_t value = vus->blk_size;
-
-    visit_type_uint32(v, name, &value, errp);
-}
-
-static void vu_set_blk_size(Object *obj, Visitor *v, const char *name,
-                            void *opaque, Error **errp)
-{
-    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-
+    VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
+    BlockExportOptionsVhostUserBlk *vu_opts = &opts->u.vhost_user_blk;
     Error *local_err = NULL;
-    uint32_t value;
+    uint64_t logical_block_size;
 
-    if (!vu_prop_modifiable(vus, errp)) {
-            return;
-    }
+    vexp->writable = opts->writable;
+    vexp->blkcfg.wce = 0;
 
-    visit_type_uint32(v, name, &value, &local_err);
-    if (local_err) {
-        goto out;
+    if (vu_opts->has_logical_block_size) {
+        logical_block_size = vu_opts->logical_block_size;
+    } else {
+        logical_block_size = BDRV_SECTOR_SIZE;
     }
-
-    check_block_size(object_get_typename(obj), name, value, &local_err);
+    check_block_size(exp->id, "logical-block-size", logical_block_size,
+                     &local_err);
     if (local_err) {
-        goto out;
+        error_propagate(errp, local_err);
+        return -EINVAL;
+    }
+    vexp->blk_size = logical_block_size;
+    blk_set_guest_block_size(exp->blk, logical_block_size);
+    vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
+                               logical_block_size);
+
+    blk_set_allow_aio_context_change(exp->blk, true);
+    blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
+                                 vexp);
+
+    if (!vhost_user_server_start(&vexp->vu_server, vu_opts->addr, exp->ctx,
+                                 VHOST_USER_BLK_MAX_QUEUES, &vu_blk_iface,
+                                 errp)) {
+        blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
+                                        blk_aio_detach, vexp);
+        return -EADDRNOTAVAIL;
     }
 
-    vus->blk_size = value;
-
-out:
-    error_propagate(errp, local_err);
-}
-
-static void vhost_user_blk_server_instance_finalize(Object *obj)
-{
-    VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
-
-    vhost_user_blk_server_stop(vub);
-
-    /*
-     * Unlike object_property_add_str, object_class_property_add_str
-     * doesn't have a release method. Thus manual memory freeing is
-     * needed.
-     */
-    free_socket_addr(vub->addr);
-    g_free(vub->node_name);
-}
-
-static void vhost_user_blk_server_complete(UserCreatable *obj, Error **errp)
-{
-    VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
-
-    vhost_user_blk_server_start(vub, errp);
+    return 0;
 }
 
-static void vhost_user_blk_server_class_init(ObjectClass *klass,
-                                             void *class_data)
+static void vu_blk_exp_delete(BlockExport *exp)
 {
-    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
-    ucc->complete = vhost_user_blk_server_complete;
-
-    object_class_property_add_bool(klass, "writable",
-                                   vu_get_block_writable,
-                                   vu_set_block_writable);
-
-    object_class_property_add_str(klass, "node-name",
-                                  vu_get_node_name,
-                                  vu_set_node_name);
-
-    object_class_property_add_str(klass, "unix-socket",
-                                  vu_get_unix_socket,
-                                  vu_set_unix_socket);
+    VuBlkExport *vexp = container_of(exp, VuBlkExport, export);
 
-    object_class_property_add(klass, "logical-block-size", "uint32",
-                              vu_get_blk_size, vu_set_blk_size,
-                              NULL, NULL);
+    blk_remove_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
+                                    vexp);
 }
 
-static const TypeInfo vhost_user_blk_server_info = {
-    .name = TYPE_VHOST_USER_BLK_SERVER,
-    .parent = TYPE_OBJECT,
-    .instance_size = sizeof(VuBlockDev),
-    .instance_finalize = vhost_user_blk_server_instance_finalize,
-    .class_init = vhost_user_blk_server_class_init,
-    .interfaces = (InterfaceInfo[]) {
-        {TYPE_USER_CREATABLE},
-        {}
-    },
+const BlockExportDriver blk_exp_vhost_user_blk = {
+    .type               = BLOCK_EXPORT_TYPE_VHOST_USER_BLK,
+    .instance_size      = sizeof(VuBlkExport),
+    .create             = vu_blk_exp_create,
+    .delete             = vu_blk_exp_delete,
+    .request_shutdown   = vu_blk_exp_request_shutdown,
 };
-
-static void vhost_user_blk_server_register_types(void)
-{
-    type_register_static(&vhost_user_blk_server_info);
-}
-
-type_init(vhost_user_blk_server_register_types)
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 @@ bool vhost_user_server_start(VuServer *server,
                              Error **errp)
 {
     QEMUBH *bh;
-    QIONetListener *listener = qio_net_listener_new();
+    QIONetListener *listener;
+
+    if (socket_addr->type != SOCKET_ADDRESS_TYPE_UNIX &&
+        socket_addr->type != SOCKET_ADDRESS_TYPE_FD) {
+        error_setg(errp, "Only socket address types 'unix' and 'fd' are supported");
+        return false;
+    }
+
+    listener = qio_net_listener_new();
     if (qio_net_listener_open_sync(listener, socket_addr, 1,
                                    errp) < 0) {
         object_unref(OBJECT(listener));
diff --git a/block/export/meson.build b/block/export/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/block/export/meson.build
+++ b/block/export/meson.build
@@ -1 +1,2 @@
 block_ss.add(files('export.c'))
+block_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-blk-server.c', '../../contrib/libvhost-user/libvhost-user.c'))
diff --git a/block/meson.build b/block/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/block/meson.build
+++ b/block/meson.build
@@ -XXX,XX +XXX,XX @@ block_ss.add(when: 'CONFIG_WIN32', if_true: files('file-win32.c', 'win32-aio.c')
 block_ss.add(when: 'CONFIG_POSIX', if_true: [files('file-posix.c'), coref, iokit])
 block_ss.add(when: 'CONFIG_LIBISCSI', if_true: files('iscsi-opts.c'))
 block_ss.add(when: 'CONFIG_LINUX', if_true: files('nvme.c'))
-block_ss.add(when: 'CONFIG_LINUX', if_true: files('export/vhost-user-blk-server.c', '../contrib/libvhost-user/libvhost-user.c'))
 block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
 block_ss.add(when: 'CONFIG_SHEEPDOG', if_true: files('sheepdog.c'))
 block_ss.add(when: ['CONFIG_LINUX_AIO', libaio], if_true: files('linux-aio.c'))
-- 
2.26.2

Headers used by other subsystems are located in include/. Also add the
vhost-user-server and vhost-user-blk-server headers to MAINTAINERS.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200924151549.913737-13-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 MAINTAINERS                                | 4 +++-
 {util => include/qemu}/vhost-user-server.h | 0
 block/export/vhost-user-blk-server.c       | 2 +-
 util/vhost-user-server.c                   | 2 +-
 4 files changed, 5 insertions(+), 3 deletions(-)
 rename {util => include/qemu}/vhost-user-server.h (100%)

diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ Vhost-user block device backend server
 M: Coiby Xu <Coiby.Xu@gmail.com>
 S: Maintained
 F: block/export/vhost-user-blk-server.c
-F: util/vhost-user-server.c
+F: block/export/vhost-user-blk-server.h
+F: include/qemu/vhost-user-server.h
 F: tests/qtest/libqos/vhost-user-blk.c
+F: util/vhost-user-server.c
 
 Replication
 M: Wen Congyang <wencongyang2@huawei.com>
diff --git a/util/vhost-user-server.h b/include/qemu/vhost-user-server.h
similarity index 100%
rename from util/vhost-user-server.h
rename to include/qemu/vhost-user-server.h
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/vhost-user-blk-server.c
+++ b/block/export/vhost-user-blk-server.c
@@ -XXX,XX +XXX,XX @@
 #include "block/block.h"
 #include "contrib/libvhost-user/libvhost-user.h"
 #include "standard-headers/linux/virtio_blk.h"
-#include "util/vhost-user-server.h"
+#include "qemu/vhost-user-server.h"
 #include "vhost-user-blk-server.h"
 #include "qapi/error.h"
 #include "qom/object_interfaces.h"
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 @@
  */
 #include "qemu/osdep.h"
 #include "qemu/main-loop.h"
+#include "qemu/vhost-user-server.h"
 #include "block/aio-wait.h"
-#include "vhost-user-server.h"
 
 /*
  * Theory of operation:
-- 
2.26.2

Don't compile contrib/libvhost-user/libvhost-user.c again. Instead build
the static library once and then reuse it throughout QEMU.

Also switch from CONFIG_LINUX to CONFIG_VHOST_USER, which is what the
vhost-user tools (vhost-user-gpu, etc) do.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200924151549.913737-14-stefanha@redhat.com
[Added CONFIG_LINUX again because libvhost-user doesn't build on macOS.
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/export/export.c             | 8 ++++----
 block/export/meson.build          | 2 +-
 contrib/libvhost-user/meson.build | 1 +
 meson.build                       | 6 +++++-
 util/meson.build                  | 4 +++-
 5 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/block/export/export.c b/block/export/export.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/export.c
+++ b/block/export/export.c
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/block-backend.h"
 #include "block/export.h"
 #include "block/nbd.h"
-#if CONFIG_LINUX
-#include "block/export/vhost-user-blk-server.h"
-#endif
 #include "qapi/error.h"
 #include "qapi/qapi-commands-block-export.h"
 #include "qapi/qapi-events-block-export.h"
 #include "qemu/id.h"
+#ifdef CONFIG_VHOST_USER
+#include "vhost-user-blk-server.h"
+#endif
 
 static const BlockExportDriver *blk_exp_drivers[] = {
     &blk_exp_nbd,
-#if CONFIG_LINUX
+#ifdef CONFIG_VHOST_USER
     &blk_exp_vhost_user_blk,
 #endif
 };
diff --git a/block/export/meson.build b/block/export/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/block/export/meson.build
+++ b/block/export/meson.build
@@ -XXX,XX +XXX,XX @@
 block_ss.add(files('export.c'))
-block_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-blk-server.c', '../../contrib/libvhost-user/libvhost-user.c'))
+block_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: files('vhost-user-blk-server.c'))
diff --git a/contrib/libvhost-user/meson.build b/contrib/libvhost-user/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/contrib/libvhost-user/meson.build
+++ b/contrib/libvhost-user/meson.build
@@ -XXX,XX +XXX,XX @@
 libvhost_user = static_library('vhost-user',
                                files('libvhost-user.c', 'libvhost-user-glib.c'),
                                build_by_default: false)
+vhost_user = declare_dependency(link_with: libvhost_user)
diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ trace_events_subdirs += [
   'util',
 ]
 
+vhost_user = not_found
+if 'CONFIG_VHOST_USER' in config_host
+  subdir('contrib/libvhost-user')
+endif
+
 subdir('qapi')
 subdir('qobject')
 subdir('stubs')
@@ -XXX,XX +XXX,XX @@ if have_tools
              install: true)
 
   if 'CONFIG_VHOST_USER' in config_host
-    subdir('contrib/libvhost-user')
     subdir('contrib/vhost-user-blk')
     subdir('contrib/vhost-user-gpu')
     subdir('contrib/vhost-user-input')
diff --git a/util/meson.build b/util/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/util/meson.build
+++ b/util/meson.build
@@ -XXX,XX +XXX,XX @@ if have_block
   util_ss.add(files('main-loop.c'))
   util_ss.add(files('nvdimm-utils.c'))
   util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c'))
-  util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c'))
+  util_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: [
+    files('vhost-user-server.c'), vhost_user
+  ])
   util_ss.add(files('block-helpers.c'))
   util_ss.add(files('qemu-coroutine-sleep.c'))
   util_ss.add(files('qemu-co-shared-resource.c'))
-- 
2.26.2

Introduce libblkdev.fa to avoid recompiling blockdev_ss twice.

Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200929125516.186715-3-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 meson.build                | 12 ++++++++++--
 storage-daemon/meson.build |  3 +--
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ blockdev_ss.add(files(
 # os-win32.c does not
 blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
 softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
-softmmu_ss.add_all(blockdev_ss)
 
 common_ss.add(files('cpus-common.c'))
 
@@ -XXX,XX +XXX,XX @@ block = declare_dependency(link_whole: [libblock],
                            link_args: '@block.syms',
                            dependencies: [crypto, io])
 
+blockdev_ss = blockdev_ss.apply(config_host, strict: false)
+libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
+                             dependencies: blockdev_ss.dependencies(),
+                             name_suffix: 'fa',
+                             build_by_default: false)
+
+blockdev = declare_dependency(link_whole: [libblockdev],
+                              dependencies: [block])
+
 qmp_ss = qmp_ss.apply(config_host, strict: false)
 libqmp = static_library('qmp', qmp_ss.sources() + genh,
                         dependencies: qmp_ss.dependencies(),
@@ -XXX,XX +XXX,XX @@ foreach m : block_mods + softmmu_mods
                 install_dir: config_host['qemu_moddir'])
 endforeach
 
-softmmu_ss.add(authz, block, chardev, crypto, io, qmp)
+softmmu_ss.add(authz, blockdev, chardev, crypto, io, qmp)
 common_ss.add(qom, qemuutil)
 
 common_ss.add_all(when: 'CONFIG_SOFTMMU', if_true: [softmmu_ss])
diff --git a/storage-daemon/meson.build b/storage-daemon/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/storage-daemon/meson.build
+++ b/storage-daemon/meson.build
@@ -XXX,XX +XXX,XX @@
 qsd_ss = ss.source_set()
 qsd_ss.add(files('qemu-storage-daemon.c'))
-qsd_ss.add(block, chardev, qmp, qom, qemuutil)
-qsd_ss.add_all(blockdev_ss)
+qsd_ss.add(blockdev, chardev, qmp, qom, qemuutil)
 
 subdir('qapi')
 
-- 
2.26.2

Block exports are used by softmmu, qemu-storage-daemon, and qemu-nbd.
They are not used by other programs and are not otherwise needed in
libblock.

Undo the recent move of blockdev-nbd.c from blockdev_ss into block_ss.
Since bdrv_close_all() (libblock) calls blk_exp_close_all()
(libblockdev) a stub function is required..

Make qemu-nbd.c use signal handling utility functions instead of
duplicating the code. This helps because os-posix.c is in libblockdev
and it depends on a qemu_system_killed() symbol that qemu-nbd.c lacks.
Once we use the signal handling utility functions we also end up
providing the necessary symbol.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20200929125516.186715-4-stefanha@redhat.com
[Fixed s/ndb/nbd/ typo in commit description as suggested by Eric Blake
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qemu-nbd.c                | 21 ++++++++-------------
 stubs/blk-exp-close-all.c |  7 +++++++
 block/export/meson.build  |  4 ++--
 meson.build               |  4 ++--
 nbd/meson.build           |  2 ++
 stubs/meson.build         |  1 +
 6 files changed, 22 insertions(+), 17 deletions(-)
 create mode 100644 stubs/blk-exp-close-all.c

diff --git a/qemu-nbd.c b/qemu-nbd.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-nbd.c
+++ b/qemu-nbd.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/error.h"
 #include "qemu/cutils.h"
 #include "sysemu/block-backend.h"
+#include "sysemu/runstate.h" /* for qemu_system_killed() prototype */
 #include "block/block_int.h"
 #include "block/nbd.h"
 #include "qemu/main-loop.h"
@@ -XXX,XX +XXX,XX @@ QEMU_COPYRIGHT "\n"
 }
 
 #ifdef CONFIG_POSIX
-static void termsig_handler(int signum)
+/*
+ * The client thread uses SIGTERM to interrupt the server.  A signal
+ * handler ensures that "qemu-nbd -v -c" exits with a nice status code.
+ */
+void qemu_system_killed(int signum, pid_t pid)
 {
     qatomic_cmpxchg(&state, RUNNING, TERMINATE);
     qemu_notify_event();
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     BlockExportOptions *export_opts;
 
 #ifdef CONFIG_POSIX
-    /*
-     * Exit gracefully on various signals, which includes SIGTERM used
-     * by 'qemu-nbd -v -c'.
-     */
-    struct sigaction sa_sigterm;
-    memset(&sa_sigterm, 0, sizeof(sa_sigterm));
-    sa_sigterm.sa_handler = termsig_handler;
-    sigaction(SIGTERM, &sa_sigterm, NULL);
-    sigaction(SIGINT, &sa_sigterm, NULL);
-    sigaction(SIGHUP, &sa_sigterm, NULL);
-
-    signal(SIGPIPE, SIG_IGN);
+    os_setup_early_signal_handling();
+    os_setup_signal_handling();
 #endif
 
     socket_init();
diff --git a/stubs/blk-exp-close-all.c b/stubs/blk-exp-close-all.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/stubs/blk-exp-close-all.c
@@ -XXX,XX +XXX,XX @@
+#include "qemu/osdep.h"
+#include "block/export.h"
+
+/* Only used in programs that support block exports (libblockdev.fa) */
+void blk_exp_close_all(void)
+{
+}
diff --git a/block/export/meson.build b/block/export/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/block/export/meson.build
+++ b/block/export/meson.build
@@ -XXX,XX +XXX,XX @@
-block_ss.add(files('export.c'))
-block_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: files('vhost-user-blk-server.c'))
+blockdev_ss.add(files('export.c'))
+blockdev_ss.add(when: ['CONFIG_LINUX', 'CONFIG_VHOST_USER'], if_true: files('vhost-user-blk-server.c'))
diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ subdir('dump')
 
 block_ss.add(files(
   'block.c',
-  'blockdev-nbd.c',
   'blockjob.c',
   'job.c',
   'qemu-io-cmds.c',
@@ -XXX,XX +XXX,XX @@ subdir('block')
 
 blockdev_ss.add(files(
   'blockdev.c',
+  'blockdev-nbd.c',
   'iothread.c',
   'job-qmp.c',
 ))
@@ -XXX,XX +XXX,XX @@ if have_tools
   qemu_io = executable('qemu-io', files('qemu-io.c'),
              dependencies: [block, qemuutil], install: true)
   qemu_nbd = executable('qemu-nbd', files('qemu-nbd.c'),
-               dependencies: [block, qemuutil], install: true)
+               dependencies: [blockdev, qemuutil], install: true)
 
   subdir('storage-daemon')
   subdir('contrib/rdmacm-mux')
diff --git a/nbd/meson.build b/nbd/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/nbd/meson.build
+++ b/nbd/meson.build
@@ -XXX,XX +XXX,XX @@
 block_ss.add(files(
   'client.c',
   'common.c',
+))
+blockdev_ss.add(files(
   'server.c',
 ))
diff --git a/stubs/meson.build b/stubs/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/stubs/meson.build
+++ b/stubs/meson.build
@@ -XXX,XX +XXX,XX @@
 stub_ss.add(files('arch_type.c'))
 stub_ss.add(files('bdrv-next-monitor-owned.c'))
 stub_ss.add(files('blk-commit-all.c'))
+stub_ss.add(files('blk-exp-close-all.c'))
 stub_ss.add(files('blockdev-close-all-bdrv-states.c'))
 stub_ss.add(files('change-state-handler.c'))
 stub_ss.add(files('cmos.c'))
-- 
2.26.2

Make it possible to specify the iothread where the export will run. By
default the block node can be moved to other AioContexts later and the
export will follow. The fixed-iothread option forces strict behavior
that prevents changing AioContext while the export is active. See the
QAPI docs for details.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20200929125516.186715-5-stefanha@redhat.com
[Fix stray '#' character in block-export.json and add missing "(since:
5.2)" as suggested by Eric Blake.
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/block-export.json               | 11 ++++++++++
 block/export/export.c                | 31 +++++++++++++++++++++++++++-
 block/export/vhost-user-blk-server.c |  5 ++++-
 nbd/server.c                         |  2 --
 4 files changed, 45 insertions(+), 4 deletions(-)

diff --git a/qapi/block-export.json b/qapi/block-export.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-export.json
+++ b/qapi/block-export.json
@@ -XXX,XX +XXX,XX @@
 #                export before completion is signalled. (since: 5.2;
 #                default: false)
 #
+# @iothread: The name of the iothread object where the export will run. The
+#            default is to use the thread currently associated with the
+#            block node. (since: 5.2)
+#
+# @fixed-iothread: True prevents the block node from being moved to another
+#                  thread while the export is active. If true and @iothread is
+#                  given, export creation fails if the block node cannot be
+#                  moved to the iothread. The default is false. (since: 5.2)
+#
 # Since: 4.2
 ##
 { 'union': 'BlockExportOptions',
   'base': { 'type': 'BlockExportType',
             'id': 'str',
+	    '*fixed-iothread': 'bool',
+	    '*iothread': 'str',
             'node-name': 'str',
             '*writable': 'bool',
             '*writethrough': 'bool' },
diff --git a/block/export/export.c b/block/export/export.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/export.c
+++ b/block/export/export.c
@@ -XXX,XX +XXX,XX @@
 
 #include "block/block.h"
 #include "sysemu/block-backend.h"
+#include "sysemu/iothread.h"
 #include "block/export.h"
 #include "block/nbd.h"
 #include "qapi/error.h"
@@ -XXX,XX +XXX,XX @@ static const BlockExportDriver *blk_exp_find_driver(BlockExportType type)
 
 BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
 {
+    bool fixed_iothread = export->has_fixed_iothread && export->fixed_iothread;
     const BlockExportDriver *drv;
     BlockExport *exp = NULL;
     BlockDriverState *bs;
-    BlockBackend *blk;
+    BlockBackend *blk = NULL;
     AioContext *ctx;
     uint64_t perm;
     int ret;
@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
     ctx = bdrv_get_aio_context(bs);
     aio_context_acquire(ctx);
 
+    if (export->has_iothread) {
+        IOThread *iothread;
+        AioContext *new_ctx;
+
+        iothread = iothread_by_id(export->iothread);
+        if (!iothread) {
+            error_setg(errp, "iothread \"%s\" not found", export->iothread);
+            goto fail;
+        }
+
+        new_ctx = iothread_get_aio_context(iothread);
+
+        ret = bdrv_try_set_aio_context(bs, new_ctx, errp);
+        if (ret == 0) {
+            aio_context_release(ctx);
+            aio_context_acquire(new_ctx);
+            ctx = new_ctx;
+        } else if (fixed_iothread) {
+            goto fail;
+        }
+    }
+
     /*
      * Block exports are used for non-shared storage migration. Make sure
      * that BDRV_O_INACTIVE is cleared and the image is ready for write
@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
     }
 
     blk = blk_new(ctx, perm, BLK_PERM_ALL);
+
+    if (!fixed_iothread) {
+        blk_set_allow_aio_context_change(blk, true);
+    }
+
     ret = blk_insert_bs(blk, bs, errp);
     if (ret < 0) {
         goto fail;
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/vhost-user-blk-server.c
+++ b/block/export/vhost-user-blk-server.c
@@ -XXX,XX +XXX,XX @@ static const VuDevIface vu_blk_iface = {
 static void blk_aio_attached(AioContext *ctx, void *opaque)
 {
     VuBlkExport *vexp = opaque;
+
+    vexp->export.ctx = ctx;
     vhost_user_server_attach_aio_context(&vexp->vu_server, ctx);
 }
 
 static void blk_aio_detach(void *opaque)
 {
     VuBlkExport *vexp = opaque;
+
     vhost_user_server_detach_aio_context(&vexp->vu_server);
+    vexp->export.ctx = NULL;
 }
 
 static void
@@ -XXX,XX +XXX,XX @@ static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
     vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
                                logical_block_size);
 
-    blk_set_allow_aio_context_change(exp->blk, true);
     blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
                                  vexp);
 
diff --git a/nbd/server.c b/nbd/server.c
index XXXXXXX..XXXXXXX 100644
--- a/nbd/server.c
+++ b/nbd/server.c
@@ -XXX,XX +XXX,XX @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
         return ret;
     }
 
-    blk_set_allow_aio_context_change(blk, true);
-
     QTAILQ_INIT(&exp->clients);
     exp->name = g_strdup(arg->name);
     exp->description = g_strdup(arg->description);
-- 
2.26.2

Allow the number of queues to be configured using --export
vhost-user-blk,num-queues=N. This setting should match the QEMU --device
vhost-user-blk-pci,num-queues=N setting but QEMU vhost-user-blk.c lowers
its own value if the vhost-user-blk backend offers fewer queues than
QEMU.

The vhost-user-blk-server.c code is already capable of multi-queue. All
virtqueue processing runs in the same AioContext. No new locking is
needed.

Add the num-queues=N option and set the VIRTIO_BLK_F_MQ feature bit.
Note that the feature bit only announces the presence of the num_queues
configuration space field. It does not promise that there is more than 1
virtqueue, so we can set it unconditionally.

I tested multi-queue by running a random read fio test with numjobs=4 on
an -smp 4 guest. After the benchmark finished the guest /proc/interrupts
file showed activity on all 4 virtio-blk MSI-X. The /sys/block/vda/mq/
directory shows that Linux blk-mq has 4 queues configured.

An automated test is included in the next commit.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20201001144604.559733-2-stefanha@redhat.com
[Fixed accidental tab characters as suggested by Markus Armbruster
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/block-export.json               | 10 +++++++---
 block/export/vhost-user-blk-server.c | 24 ++++++++++++++++++------
 2 files changed, 25 insertions(+), 9 deletions(-)

diff --git a/qapi/block-export.json b/qapi/block-export.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-export.json
+++ b/qapi/block-export.json
@@ -XXX,XX +XXX,XX @@
 #        SocketAddress types are supported. Passed fds must be UNIX domain
 #        sockets.
 # @logical-block-size: Logical block size in bytes. Defaults to 512 bytes.
+# @num-queues: Number of request virtqueues. Must be greater than 0. Defaults
+#              to 1.
 #
 # Since: 5.2
 ##
 { 'struct': 'BlockExportOptionsVhostUserBlk',
-  'data': { 'addr': 'SocketAddress', '*logical-block-size': 'size' } }
+  'data': { 'addr': 'SocketAddress',
+	    '*logical-block-size': 'size',
+            '*num-queues': 'uint16'} }
 
 ##
 # @NbdServerAddOptions:
@@ -XXX,XX +XXX,XX @@
 { 'union': 'BlockExportOptions',
   'base': { 'type': 'BlockExportType',
             'id': 'str',
-	    '*fixed-iothread': 'bool',
-	    '*iothread': 'str',
+            '*fixed-iothread': 'bool',
+            '*iothread': 'str',
             'node-name': 'str',
             '*writable': 'bool',
             '*writethrough': 'bool' },
diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/vhost-user-blk-server.c
+++ b/block/export/vhost-user-blk-server.c
@@ -XXX,XX +XXX,XX @@
 #include "util/block-helpers.h"
 
 enum {
-    VHOST_USER_BLK_MAX_QUEUES = 1,
+    VHOST_USER_BLK_NUM_QUEUES_DEFAULT = 1,
 };
 struct virtio_blk_inhdr {
     unsigned char status;
@@ -XXX,XX +XXX,XX @@ static uint64_t vu_blk_get_features(VuDev *dev)
                1ull << VIRTIO_BLK_F_DISCARD |
                1ull << VIRTIO_BLK_F_WRITE_ZEROES |
                1ull << VIRTIO_BLK_F_CONFIG_WCE |
+               1ull << VIRTIO_BLK_F_MQ |
                1ull << VIRTIO_F_VERSION_1 |
                1ull << VIRTIO_RING_F_INDIRECT_DESC |
                1ull << VIRTIO_RING_F_EVENT_IDX |
@@ -XXX,XX +XXX,XX @@ static void blk_aio_detach(void *opaque)
 
 static void
 vu_blk_initialize_config(BlockDriverState *bs,
-                           struct virtio_blk_config *config, uint32_t blk_size)
+                         struct virtio_blk_config *config,
+                         uint32_t blk_size,
+                         uint16_t num_queues)
 {
     config->capacity = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
     config->blk_size = blk_size;
@@ -XXX,XX +XXX,XX @@ vu_blk_initialize_config(BlockDriverState *bs,
     config->seg_max = 128 - 2;
     config->min_io_size = 1;
     config->opt_io_size = 1;
-    config->num_queues = VHOST_USER_BLK_MAX_QUEUES;
+    config->num_queues = num_queues;
     config->max_discard_sectors = 32768;
     config->max_discard_seg = 1;
     config->discard_sector_alignment = config->blk_size >> 9;
@@ -XXX,XX +XXX,XX @@ static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
     BlockExportOptionsVhostUserBlk *vu_opts = &opts->u.vhost_user_blk;
     Error *local_err = NULL;
     uint64_t logical_block_size;
+    uint16_t num_queues = VHOST_USER_BLK_NUM_QUEUES_DEFAULT;
 
     vexp->writable = opts->writable;
     vexp->blkcfg.wce = 0;
@@ -XXX,XX +XXX,XX @@ static int vu_blk_exp_create(BlockExport *exp, BlockExportOptions *opts,
     }
     vexp->blk_size = logical_block_size;
     blk_set_guest_block_size(exp->blk, logical_block_size);
+
+    if (vu_opts->has_num_queues) {
+        num_queues = vu_opts->num_queues;
+    }
+    if (num_queues == 0) {
+        error_setg(errp, "num-queues must be greater than 0");
+        return -EINVAL;
+    }
+
     vu_blk_initialize_config(blk_bs(exp->blk), &vexp->blkcfg,
-                               logical_block_size);
+                             logical_block_size, num_queues);
 
     blk_add_aio_context_notifier(exp->blk, blk_aio_attached, blk_aio_detach,
                                  vexp);
 
     if (!vhost_user_server_start(&vexp->vu_server, vu_opts->addr, exp->ctx,
-                                 VHOST_USER_BLK_MAX_QUEUES, &vu_blk_iface,
-                                 errp)) {
+                                 num_queues, &vu_blk_iface, errp)) {
         blk_remove_aio_context_notifier(exp->blk, blk_aio_attached,
                                         blk_aio_detach, vexp);
         return -EADDRNOTAVAIL;
-- 
2.26.2

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

bdrv_co_block_status_above has several design problems with handling
short backing files:

1. With want_zeros=true, it may return ret with BDRV_BLOCK_ZERO but
without BDRV_BLOCK_ALLOCATED flag, when actually short backing file
which produces these after-EOF zeros is inside requested backing
sequence.

2. With want_zero=false, it may return pnum=0 prior to actual EOF,
because of EOF of short backing file.

Fix these things, making logic about short backing files clearer.

With fixed bdrv_block_status_above we also have to improve is_zero in
qcow2 code, otherwise iotest 154 will fail, because with this patch we
stop to merge zeros of different types (produced by fully unallocated
in the whole backing chain regions vs produced by short backing files).

Note also, that this patch leaves for another day the general problem
around block-status: misuse of BDRV_BLOCK_ALLOCATED as is-fs-allocated
vs go-to-backing.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20200924194003.22080-2-vsementsov@virtuozzo.com
[Fix s/comes/come/ as suggested by Eric Blake
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c    | 68 ++++++++++++++++++++++++++++++++++++++++-----------
 block/qcow2.c | 16 ++++++++++--
 2 files changed, 68 insertions(+), 16 deletions(-)

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 @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
                                   int64_t *map,
                                   BlockDriverState **file)
 {
+    int ret;
     BlockDriverState *p;
-    int ret = 0;
-    bool first = true;
+    int64_t eof = 0;
 
     assert(bs != base);
-    for (p = bs; p != base; p = bdrv_filter_or_cow_bs(p)) {
+
+    ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);
+    if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED) {
+        return ret;
+    }
+
+    if (ret & BDRV_BLOCK_EOF) {
+        eof = offset + *pnum;
+    }
+
+    assert(*pnum <= bytes);
+    bytes = *pnum;
+
+    for (p = bdrv_filter_or_cow_bs(bs); p != base;
+         p = bdrv_filter_or_cow_bs(p))
+    {
         ret = bdrv_co_block_status(p, want_zero, offset, bytes, pnum, map,
                                    file);
         if (ret < 0) {
-            break;
+            return ret;
         }
-        if (ret & BDRV_BLOCK_ZERO && ret & BDRV_BLOCK_EOF && !first) {
+        if (*pnum == 0) {
             /*
-             * Reading beyond the end of the file continues to read
-             * zeroes, but we can only widen the result to the
-             * unallocated length we learned from an earlier
-             * iteration.
+             * The top layer deferred to this layer, and because this layer is
+             * short, any zeroes that we synthesize beyond EOF behave as if they
+             * were allocated at this layer.
+             *
+             * We don't include BDRV_BLOCK_EOF into ret, as upper layer may be
+             * larger. We'll add BDRV_BLOCK_EOF if needed at function end, see
+             * below.
              */
+            assert(ret & BDRV_BLOCK_EOF);
             *pnum = bytes;
+            if (file) {
+                *file = p;
+            }
+            ret = BDRV_BLOCK_ZERO | BDRV_BLOCK_ALLOCATED;
+            break;
         }
-        if (ret & (BDRV_BLOCK_ZERO | BDRV_BLOCK_DATA)) {
+        if (ret & BDRV_BLOCK_ALLOCATED) {
+            /*
+             * We've found the node and the status, we must break.
+             *
+             * Drop BDRV_BLOCK_EOF, as it's not for upper layer, which may be
+             * larger. We'll add BDRV_BLOCK_EOF if needed at function end, see
+             * below.
+             */
+            ret &= ~BDRV_BLOCK_EOF;
             break;
         }
-        /* [offset, pnum] unallocated on this layer, which could be only
-         * the first part of [offset, bytes].  */
-        bytes = MIN(bytes, *pnum);
-        first = false;
+
+        /*
+         * OK, [offset, offset + *pnum) region is unallocated on this layer,
+         * let's continue the diving.
+         */
+        assert(*pnum <= bytes);
+        bytes = *pnum;
+    }
+
+    if (offset + *pnum == eof) {
+        ret |= BDRV_BLOCK_EOF;
     }
+
     return ret;
 }
 
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)
     if (!bytes) {
         return true;
     }
-    res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
-    return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == bytes;
+
+    /*
+     * bdrv_block_status_above doesn't merge different types of zeros, for
+     * example, zeros which come from the region which is unallocated in
+     * the whole backing chain, and zeros which come because of a short
+     * backing file. So, we need a loop.
+     */
+    do {
+        res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
+        offset += nr;
+        bytes -= nr;
+    } while (res >= 0 && (res & BDRV_BLOCK_ZERO) && nr && bytes);
+
+    return res >= 0 && (res & BDRV_BLOCK_ZERO) && bytes == 0;
 }
 
 static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,
-- 
2.26.2

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

In order to reuse bdrv_common_block_status_above in
bdrv_is_allocated_above, let's support include_base parameter.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20200924194003.22080-3-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/coroutines.h |  2 ++
 block/io.c         | 21 ++++++++++++++-------
 2 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/block/coroutines.h b/block/coroutines.h
index XXXXXXX..XXXXXXX 100644
--- a/block/coroutines.h
+++ b/block/coroutines.h
@@ -XXX,XX +XXX,XX @@ bdrv_pwritev(BdrvChild *child, int64_t offset, unsigned int bytes,
 int coroutine_fn
 bdrv_co_common_block_status_above(BlockDriverState *bs,
                                   BlockDriverState *base,
+                                  bool include_base,
                                   bool want_zero,
                                   int64_t offset,
                                   int64_t bytes,
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
 int generated_co_wrapper
 bdrv_common_block_status_above(BlockDriverState *bs,
                                BlockDriverState *base,
+                               bool include_base,
                                bool want_zero,
                                int64_t offset,
                                int64_t bytes,
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 @@ early_out:
 int coroutine_fn
 bdrv_co_common_block_status_above(BlockDriverState *bs,
                                   BlockDriverState *base,
+                                  bool include_base,
                                   bool want_zero,
                                   int64_t offset,
                                   int64_t bytes,
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
     BlockDriverState *p;
     int64_t eof = 0;
 
-    assert(bs != base);
+    assert(include_base || bs != base);
+    assert(!include_base || base); /* Can't include NULL base */
 
     ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);
-    if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED) {
+    if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED || bs == base) {
         return ret;
     }
 
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
     assert(*pnum <= bytes);
     bytes = *pnum;
 
-    for (p = bdrv_filter_or_cow_bs(bs); p != base;
+    for (p = bdrv_filter_or_cow_bs(bs); include_base || p != base;
          p = bdrv_filter_or_cow_bs(p))
     {
         ret = bdrv_co_block_status(p, want_zero, offset, bytes, pnum, map,
@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
             break;
         }
 
+        if (p == base) {
+            assert(include_base);
+            break;
+        }
+
         /*
          * OK, [offset, offset + *pnum) region is unallocated on this layer,
          * let's continue the diving.
@@ -XXX,XX +XXX,XX @@ int bdrv_block_status_above(BlockDriverState *bs, BlockDriverState *base,
                             int64_t offset, int64_t bytes, int64_t *pnum,
                             int64_t *map, BlockDriverState **file)
 {
-    return bdrv_common_block_status_above(bs, base, true, offset, bytes,
+    return bdrv_common_block_status_above(bs, base, false, true, offset, bytes,
                                           pnum, map, file);
 }
 
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,
     int ret;
     int64_t dummy;
 
-    ret = bdrv_common_block_status_above(bs, bdrv_filter_or_cow_bs(bs), false,
-                                         offset, bytes, pnum ? pnum : &dummy,
-                                         NULL, NULL);
+    ret = bdrv_common_block_status_above(bs, bs, true, false, offset,
+                                         bytes, pnum ? pnum : &dummy, NULL,
+                                         NULL);
     if (ret < 0) {
         return ret;
     }
-- 
2.26.2

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

We are going to reuse bdrv_common_block_status_above in
bdrv_is_allocated_above. bdrv_is_allocated_above may be called with
include_base == false and still bs == base (for ex. from img_rebase()).

So, support this corner case.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Message-id: 20200924194003.22080-4-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

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 @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
     BlockDriverState *p;
     int64_t eof = 0;
 
-    assert(include_base || bs != base);
     assert(!include_base || base); /* Can't include NULL base */
 
+    if (!include_base && bs == base) {
+        *pnum = bytes;
+        return 0;
+    }
+
     ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);
     if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED || bs == base) {
         return ret;
-- 
2.26.2

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

bdrv_is_allocated_above wrongly handles short backing files: it reports
after-EOF space as UNALLOCATED which is wrong, as on read the data is
generated on the level of short backing file (if all overlays have
unallocated areas at that place).

Reusing bdrv_common_block_status_above fixes the issue and unifies code
path.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Message-id: 20200924194003.22080-5-vsementsov@virtuozzo.com
[Fix s/has/have/ as suggested by Eric Blake. Fix s/area/areas/.
--Stefan]
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 43 +++++--------------------------------------
 1 file changed, 5 insertions(+), 38 deletions(-)

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 @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,
  * at 'offset + *pnum' may return the same allocation status (in other
  * words, the result is not necessarily the maximum possible range);
  * but 'pnum' will only be 0 when end of file is reached.
- *
  */
 int bdrv_is_allocated_above(BlockDriverState *top,
                             BlockDriverState *base,
                             bool include_base, int64_t offset,
                             int64_t bytes, int64_t *pnum)
 {
-    BlockDriverState *intermediate;
-    int ret;
-    int64_t n = bytes;
-
-    assert(base || !include_base);
-
-    intermediate = top;
-    while (include_base || intermediate != base) {
-        int64_t pnum_inter;
-        int64_t size_inter;
-
-        assert(intermediate);
-        ret = bdrv_is_allocated(intermediate, offset, bytes, &pnum_inter);
-        if (ret < 0) {
-            return ret;
-        }
-        if (ret) {
-            *pnum = pnum_inter;
-            return 1;
-        }
-
-        size_inter = bdrv_getlength(intermediate);
-        if (size_inter < 0) {
-            return size_inter;
-        }
-        if (n > pnum_inter &&
-            (intermediate == top || offset + pnum_inter < size_inter)) {
-            n = pnum_inter;
-        }
-
-        if (intermediate == base) {
-            break;
-        }
-
-        intermediate = bdrv_filter_or_cow_bs(intermediate);
+    int ret = bdrv_common_block_status_above(top, base, include_base, false,
+                                             offset, bytes, pnum, NULL, NULL);
+    if (ret < 0) {
+        return ret;
     }
 
-    *pnum = n;
-    return 0;
+    return !!(ret & BDRV_BLOCK_ALLOCATED);
 }
 
 int coroutine_fn
-- 
2.26.2

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

These cases are fixed by previous patches around block_status and
is_allocated.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Message-id: 20200924194003.22080-6-vsementsov@virtuozzo.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/qemu-iotests/274     | 20 +++++++++++
 tests/qemu-iotests/274.out | 68 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 88 insertions(+)

diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/274
+++ b/tests/qemu-iotests/274
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('base') as base, \
     iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
     iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
 
+    iotests.log('=== Testing qemu-img commit (top -> base) ===')
+
+    create_chain()
+    iotests.qemu_img_log('commit', '-b', base, top)
+    iotests.img_info_log(base)
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, base)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), base)
+
+    iotests.log('=== Testing QMP active commit (top -> base) ===')
+
+    create_chain()
+    with create_vm() as vm:
+        vm.launch()
+        vm.qmp_log('block-commit', device='top', base_node='base',
+                   job_id='job0', auto_dismiss=False)
+        vm.run_job('job0', wait=5)
+
+    iotests.img_info_log(mid)
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, base)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), base)
 
     iotests.log('== Resize tests ==')
 
diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/274.out
+++ b/tests/qemu-iotests/274.out
@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0
 read 1048576/1048576 bytes at offset 1048576
 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
+=== Testing qemu-img commit (top -> base) ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=1048576 backing_file=TEST_DIR/PID-base backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 backing_file=TEST_DIR/PID-mid backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
+
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image committed.
+
+image: TEST_IMG
+file format: IMGFMT
+virtual size: 2 MiB (2097152 bytes)
+cluster_size: 65536
+Format specific information:
+    compat: 1.1
+    compression type: zlib
+    lazy refcounts: false
+    refcount bits: 16
+    corrupt: false
+    extended l2: false
+
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Testing QMP active commit (top -> base) ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=1048576 backing_file=TEST_DIR/PID-base backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 backing_file=TEST_DIR/PID-mid backing_fmt=qcow2 lazy_refcounts=off refcount_bits=16
+
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+{"execute": "block-commit", "arguments": {"auto-dismiss": false, "base-node": "base", "device": "top", "job-id": "job0"}}
+{"return": {}}
+{"execute": "job-complete", "arguments": {"id": "job0"}}
+{"return": {}}
+{"data": {"device": "job0", "len": 1048576, "offset": 1048576, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"device": "job0", "len": 1048576, "offset": 1048576, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
+{"return": {}}
+image: TEST_IMG
+file format: IMGFMT
+virtual size: 1 MiB (1048576 bytes)
+cluster_size: 65536
+backing file: TEST_DIR/PID-base
+backing file format: IMGFMT
+Format specific information:
+    compat: 1.1
+    compression type: zlib
+    lazy refcounts: false
+    refcount bits: 16
+    corrupt: false
+    extended l2: false
+
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
 == Resize tests ==
 === preallocation=off ===
 Formatting 'TEST_DIR/PID-base', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=6442450944 lazy_refcounts=off refcount_bits=16
-- 
2.26.2