Series comparison

-[Qemu-devel] [PULL for-2.10 00/15] Block patches
+[PULL v2 00/28] Block patches
-The following changes since commit 248b23735645f7cbb503d9be6f5bf825f2a603ab:
+The following changes since commit ac793156f650ae2d77834932d72224175ee69086:
-  Update version for v2.10.0-rc4 release (2017-08-24 17:34:26 +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:
+are available in the Git repository at:
-  git://github.com/stefanha/qemu.git tags/block-pull-request
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 3e4c705212abfe8c9882a00beb2d1466a8a53cec:
+for you to fetch changes up to 32a3fd65e7e3551337fd26bfc0e2f899d70c028c:
-  qcow2: allocate cluster_cache/cluster_data on demand (2017-08-30 18:02:10 +0100)
+  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
-Alberto Garcia (8):
+Philippe Mathieu-Daudé (1):
-  throttle: Fix wrong variable name in the header documentation
+  block/nvme: Add driver statistics for access alignment and hw errors
   throttle: Update the throttle_fix_bucket() documentation
   throttle: Make throttle_is_valid() a bit less verbose
   throttle: Remove throttle_fix_bucket() / throttle_unfix_bucket()
   throttle: Make LeakyBucket.avg and LeakyBucket.max integer types
   throttle: Make burst_length 64bit and add range checks
   throttle: Test the valid range of config values
   misc: Remove unused Error variables
-Dan Aloni (1):
+Stefan Hajnoczi (16):
-  nvme: Fix get/set number of queues feature, again
+  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
-Eduardo Habkost (1):
+Vladimir Sementsov-Ogievskiy (5):
-  oslib-posix: Print errors before aborting on qemu_alloc_stack()
+  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
-Fred Rolland (1):
+ MAINTAINERS                                |   9 +
-  qemu-doc: Add UUID support in initiator name
+ qapi/block-core.json                       |  24 +-
+ qapi/block-export.json                     |  36 +-
-Stefan Hajnoczi (4):
+ block/coroutines.h                         |   2 +
-  scripts: add argparse module for Python 2.6 compatibility
+ block/export/vhost-user-blk-server.h       |  19 +
-  docker.py: Python 2.6 argparse compatibility
+ contrib/libvhost-user/libvhost-user.h      |  21 +
-  tests: migration/guestperf Python 2.6 argparse compatibility
+ include/qemu/vhost-user-server.h           |  65 +++
-  qcow2: allocate cluster_cache/cluster_data on demand
+ util/block-helpers.h                       |  19 +
+ block/export/export.c                      |  37 +-
- include/qemu/throttle.h            |    8 +-
+ block/export/vhost-user-blk-server.c       | 431 ++++++++++++++++++++
- block/qcow.c                       |   12 +-
+ block/io.c                                 | 132 +++---
- block/qcow2-cluster.c              |   17 +
+ block/nvme.c                               |  27 ++
- block/qcow2.c                      |   20 +-
+ block/qcow2.c                              |  16 +-
- dump.c                             |    4 +-
+ contrib/libvhost-user/libvhost-user-glib.c |   2 +-
- hw/block/nvme.c                    |    4 +-
+ contrib/libvhost-user/libvhost-user.c      |  15 +-
- tests/test-throttle.c              |   80 +-
+ hw/core/qdev-properties-system.c           |  31 +-
- util/oslib-posix.c                 |    2 +
+ nbd/server.c                               |   2 -
- util/throttle.c                    |   86 +-
+ qemu-nbd.c                                 |  21 +-
- COPYING.PYTHON                     |  270 ++++
+ softmmu/vl.c                               |   4 +
- qemu-doc.texi                      |    5 +-
+ stubs/blk-exp-close-all.c                  |   7 +
- scripts/argparse.py                | 2406 ++++++++++++++++++++++++++++++++++++
+ tests/vhost-user-bridge.c                  |   2 +
- tests/docker/docker.py             |    4 +-
+ tools/virtiofsd/fuse_virtio.c              |   4 +-
- tests/migration/guestperf/shell.py |    8 +-
+ util/block-helpers.c                       |  46 +++
-files changed, 2831 insertions(+), 95 deletions(-)
+ util/vhost-user-server.c                   | 446 +++++++++++++++++++++
- create mode 100644 COPYING.PYTHON
+ block/export/meson.build                   |   3 +-
- create mode 100644 scripts/argparse.py
+ contrib/libvhost-user/meson.build          |   1 +
  meson.build                                |  22 +-
  nbd/meson.build                            |   2 +
  storage-daemon/meson.build                 |   3 +-
  stubs/meson.build                          |   1 +
  tests/qemu-iotests/274                     |  20 +
  tests/qemu-iotests/274.out                 |  68 ++++
  util/meson.build                           |   4 +
 files changed, 1420 insertions(+), 122 deletions(-)
  create mode 100644 block/export/vhost-user-blk-server.h
  create mode 100644 include/qemu/vhost-user-server.h
  create mode 100644 util/block-helpers.h
  create mode 100644 block/export/vhost-user-blk-server.c
  create mode 100644 stubs/blk-exp-close-all.c
  create mode 100644 util/block-helpers.c
  create mode 100644 util/vhost-user-server.c
 --
-.13.5
+.26.2

-New patch
+[PULL v2 01/28] block/nvme: Add driver statistics for access alignment and hw errors
+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 +++++++++++++++++++++++++++
+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,
+--
+.26.2

-New patch
+[PULL v2 02/28] libvhost-user: Allow vu_message_read to be replaced
+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 ++--
+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;
+ }
+--
+.26.2

-[Qemu-devel] [PULL for-2.10 04/15] throttle: Make throttle_is_valid() a bit less verbose
+[PULL v2 03/28] libvhost-user: remove watch for kick_fd when de-initialize vu-dev
-From: Alberto Garcia <berto@igalia.com>
+From: Coiby Xu <coiby.xu@gmail.com>
-Use a pointer to the bucket instead of repeating cfg->buckets[i] all
+When the client is running in gdb and quit command is run in gdb,
-the time. This makes the code more concise and will help us expand the
+QEMU will still dispatch the event which will cause segment fault in
-checks later and save a few line breaks.
+the callback function.
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
-Message-id: 763ffc40a26b17d54cf93f5a999e4656049fcf0c.1503580370.git.berto@igalia.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>
 ---
- util/throttle.c | 15 +++++++--------
+ contrib/libvhost-user/libvhost-user.c | 1 +
-file changed, 7 insertions(+), 8 deletions(-)
+file changed, 1 insertion(+)
-diff --git a/util/throttle.c b/util/throttle.c
+diff --git a/contrib/libvhost-user/libvhost-user.c b/contrib/libvhost-user/libvhost-user.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+--- a/contrib/libvhost-user/libvhost-user.c
-+++ b/util/throttle.c
++++ b/contrib/libvhost-user/libvhost-user.c
-@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
+@@ -XXX,XX +XXX,XX @@ vu_deinit(VuDev *dev)
      }
      for (i = 0; i < BUCKETS_COUNT; i++) {
 -        if (cfg->buckets[i].avg < 0 ||
 -            cfg->buckets[i].max < 0 ||
 -            cfg->buckets[i].avg > THROTTLE_VALUE_MAX ||
 -            cfg->buckets[i].max > THROTTLE_VALUE_MAX) {
 +        LeakyBucket *bkt = &cfg->buckets[i];
 +        if (bkt->avg < 0 || bkt->max < 0 ||
 +            bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
              error_setg(errp, "bps/iops/max values must be within [0, %lld]",
                         THROTTLE_VALUE_MAX);
              return false;
          }
--        if (!cfg->buckets[i].burst_length) {
+         if (vq->kick_fd != -1) {
-+        if (!bkt->burst_length) {
++            dev->remove_watch(dev, vq->kick_fd);
-             error_setg(errp, "the burst length cannot be 0");
+             close(vq->kick_fd);
-             return false;
+             vq->kick_fd = -1;
          }
 -        if (cfg->buckets[i].burst_length > 1 && !cfg->buckets[i].max) {
 +        if (bkt->burst_length > 1 && !bkt->max) {
              error_setg(errp, "burst length set without burst rate");
              return false;
          }
 -        if (cfg->buckets[i].max && !cfg->buckets[i].avg) {
 +        if (bkt->max && !bkt->avg) {
              error_setg(errp, "bps_max/iops_max require corresponding"
                         " bps/iops values");
              return false;
          }
 -        if (cfg->buckets[i].max && cfg->buckets[i].max < cfg->buckets[i].avg) {
 +        if (bkt->max && bkt->max < bkt->avg) {
              error_setg(errp, "bps_max/iops_max cannot be lower than bps/iops");
              return false;
          }
 --
-.13.5
+.26.2

-New patch
+[PULL v2 04/28] util/vhost-user-server: generic vhost user server
+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.
+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-4-coiby.xu@gmail.com
+[Fixed size_t %lu -> %zu format string compiler error.
+--Stefan]
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ util/vhost-user-server.h |  65 ++++++
+ util/vhost-user-server.c | 428 +++++++++++++++++++++++++++++++++++++++
+ util/meson.build         |   1 +
+files changed, 494 insertions(+)
+ create mode 100644 util/vhost-user-server.h
+ create mode 100644 util/vhost-user-server.c
+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'))
+--
+.26.2

-[Qemu-devel] [PULL for-2.10 08/15] throttle: Test the valid range of config values
+[PULL v2 05/28] block: move logical block size check function to a common utility function
-From: Alberto Garcia <berto@igalia.com>
+From: Coiby Xu <coiby.xu@gmail.com>
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+Move the constants from hw/core/qdev-properties.c to
-Message-id: a57dd6274e1b6dc9c28769fec4c7ea543be5c5e3.1503580370.git.berto@igalia.com
+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>
 ---
- tests/test-throttle.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ util/block-helpers.h             | 19 +++++++++++++
-file changed, 77 insertions(+)
+ hw/core/qdev-properties-system.c | 31 ++++-----------------
  util/block-helpers.c             | 46 ++++++++++++++++++++++++++++++++
  util/meson.build                 |  1 +
 files changed, 71 insertions(+), 26 deletions(-)
  create mode 100644 util/block-helpers.h
  create mode 100644 util/block-helpers.c
-diff --git a/tests/test-throttle.c b/tests/test-throttle.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/tests/test-throttle.c
+--- a/hw/core/qdev-properties-system.c
-+++ b/tests/test-throttle.c
++++ b/hw/core/qdev-properties-system.c
-@@ -XXX,XX +XXX,XX @@ static void test_is_valid(void)
+@@ -XXX,XX +XXX,XX @@
-     test_is_valid_for_value(1, true);
+ #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;
  }
-+static void test_ranges(void)
+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)
 +{
-+    int i;
++    /* 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;
 +    }
 +
-+    for (i = 0; i < BUCKETS_COUNT; i++) {
++    /* We rely on power-of-2 blocksizes for bitmasks */
-+        LeakyBucket *b = &cfg.buckets[i];
++    if ((value & (value - 1)) != 0) {
-+        throttle_config_init(&cfg);
++        error_setg(errp,
-+
++                   "Property %s.%s doesn't take value '%" PRId64
-+        /* avg = 0 means throttling is disabled, but the config is valid */
++                   "', it's not a power of 2",
-+        b->avg = 0;
++                   id, name, value);
-+        g_assert(throttle_is_valid(&cfg, NULL));
++        return;
 +        g_assert(!throttle_enabled(&cfg));
 +
 +        /* These are valid configurations (values <= THROTTLE_VALUE_MAX) */
 +        b->avg = 1;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = THROTTLE_VALUE_MAX;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = THROTTLE_VALUE_MAX;
 +        b->max = THROTTLE_VALUE_MAX;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        /* Values over THROTTLE_VALUE_MAX are not allowed */
 +        b->avg = THROTTLE_VALUE_MAX + 1;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = THROTTLE_VALUE_MAX;
 +        b->max = THROTTLE_VALUE_MAX + 1;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +
 +        /* burst_length must be between 1 and THROTTLE_VALUE_MAX */
 +        b->avg = 1;
 +        b->max = 1;
 +        b->burst_length = 0;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = 1;
 +        b->burst_length = 1;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = 1;
 +        b->burst_length = THROTTLE_VALUE_MAX;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = 1;
 +        b->burst_length = THROTTLE_VALUE_MAX + 1;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +
 +        /* burst_length * max cannot exceed THROTTLE_VALUE_MAX */
 +        b->avg = 1;
 +        b->max = 2;
 +        b->burst_length = THROTTLE_VALUE_MAX / 2;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = 3;
 +        b->burst_length = THROTTLE_VALUE_MAX / 2;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = THROTTLE_VALUE_MAX;
 +        b->burst_length = 1;
 +        g_assert(throttle_is_valid(&cfg, NULL));
 +
 +        b->avg = 1;
 +        b->max = THROTTLE_VALUE_MAX;
 +        b->burst_length = 2;
 +        g_assert(!throttle_is_valid(&cfg, NULL));
 +    }
 +}
-+
+diff --git a/util/meson.build b/util/meson.build
- static void test_max_is_missing_limit(void)
+index XXXXXXX..XXXXXXX 100644
- {
+--- a/util/meson.build
-     int i;
++++ b/util/meson.build
-@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
+@@ -XXX,XX +XXX,XX @@ if have_block
-     g_test_add_func("/throttle/config/enabled",     test_enabled);
+   util_ss.add(files('nvdimm-utils.c'))
-     g_test_add_func("/throttle/config/conflicting", test_conflicting_config);
+   util_ss.add(files('qemu-coroutine.c', 'qemu-coroutine-lock.c', 'qemu-coroutine-io.c'))
-     g_test_add_func("/throttle/config/is_valid",    test_is_valid);
+   util_ss.add(when: 'CONFIG_LINUX', if_true: files('vhost-user-server.c'))
-+    g_test_add_func("/throttle/config/ranges",      test_ranges);
++  util_ss.add(files('block-helpers.c'))
-     g_test_add_func("/throttle/config/max",         test_max_is_missing_limit);
+   util_ss.add(files('qemu-coroutine-sleep.c'))
-     g_test_add_func("/throttle/config/iops_size",
+   util_ss.add(files('qemu-co-shared-resource.c'))
-                     test_iops_size_is_missing_limit);
+   util_ss.add(files('thread-pool.c', 'qemu-timer.c'))
 --
-.13.5
+.26.2

-[Qemu-devel] [PULL for-2.10 11/15] scripts: add argparse module for Python 2.6 compatibility
+[PULL v2 06/28] block/export: vhost-user block device backend server
-The minimum Python version supported by QEMU is 2.6.  The argparse
+From: Coiby Xu <coiby.xu@gmail.com>
 standard library module was only added in Python 2.7.  Many scripts
 would like to use argparse because it supports command-line
 sub-commands.
-This patch adds argparse.  See the top of argparse.py for details.
+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.
-Suggested-by: Daniel P. Berrange <berrange@redhat.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>
-Acked-by: John Snow <jsnow@redhat.com>
+Signed-off-by: Coiby Xu <coiby.xu@gmail.com>
-Message-id: 20170825155732.15665-2-stefanha@redhat.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
 -bit hosts.
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- COPYING.PYTHON      |  270 ++++++
+ block/export/vhost-user-blk-server.h |  36 ++
- scripts/argparse.py | 2406 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ block/export/vhost-user-blk-server.c | 661 +++++++++++++++++++++++++++
-files changed, 2676 insertions(+)
+ softmmu/vl.c                         |   4 +
- create mode 100644 COPYING.PYTHON
+ block/meson.build                    |   1 +
- create mode 100644 scripts/argparse.py
+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/COPYING.PYTHON b/COPYING.PYTHON
+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/COPYING.PYTHON
++++ b/block/export/vhost-user-blk-server.h
 @@ -XXX,XX +XXX,XX @@
-+A. HISTORY OF THE SOFTWARE
++/*
-+==========================
++ * Sharing QEMU block devices via vhost-user protocal
-+
++ *
-+Python was created in the early 1990s by Guido van Rossum at Stichting
++ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
-+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
++ * Copyright (c) 2020 Red Hat, Inc.
-+as a successor of a language called ABC.  Guido remains Python's
++ *
-+principal author, although it includes many contributions from others.
++ * This work is licensed under the terms of the GNU GPL, version 2 or
-+
++ * later.  See the COPYING file in the top-level directory.
-+In 1995, Guido continued his work on Python at the Corporation for
++ */
-+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
++
-+in Reston, Virginia where he released several versions of the
++#ifndef VHOST_USER_BLK_SERVER_H
-+software.
++#define VHOST_USER_BLK_SERVER_H
-+
++#include "util/vhost-user-server.h"
-+In May 2000, Guido and the Python core development team moved to
++
-+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
++typedef struct VuBlockDev VuBlockDev;
-+year, the PythonLabs team moved to Digital Creations (now Zope
++#define TYPE_VHOST_USER_BLK_SERVER "vhost-user-blk-server"
-+Corporation, see http://www.zope.com).  In 2001, the Python Software
++#define VHOST_USER_BLK_SERVER(obj) \
-+Foundation (PSF, see http://www.python.org/psf/) was formed, a
++   OBJECT_CHECK(VuBlockDev, obj, TYPE_VHOST_USER_BLK_SERVER)
-+non-profit organization created specifically to own Python-related
++
-+Intellectual Property.  Zope Corporation is a sponsoring member of
++/* vhost user block device */
-+the PSF.
++struct VuBlockDev {
-+
++    Object parent_obj;
-+All Python releases are Open Source (see http://www.opensource.org for
++    char *node_name;
-+the Open Source Definition).  Historically, most, but not all, Python
++    SocketAddress *addr;
-+releases have also been GPL-compatible; the table below summarizes
++    AioContext *ctx;
-+the various releases.
++    VuServer vu_server;
-+
++    bool running;
-+    Release         Derived     Year        Owner       GPL-
++    uint32_t blk_size;
-+                    from                                compatible? (1)
++    BlockBackend *backend;
-+
++    QIOChannelSocket *sioc;
-+    0.9.0 thru 1.2              1991-1995   CWI         yes
++    QTAILQ_ENTRY(VuBlockDev) next;
-+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
++    struct virtio_blk_config blkcfg;
-+    1.6             1.5.2       2000        CNRI        no
++    bool writable;
-+    2.0             1.6         2000        BeOpen.com  no
++};
-+    1.6.1           1.6         2001        CNRI        yes (2)
++
-+    2.1             2.0+1.6.1   2001        PSF         no
++#endif /* VHOST_USER_BLK_SERVER_H */
-+    2.0.1           2.0+1.6.1   2001        PSF         yes
+diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
 +    2.1.1           2.1+2.0.1   2001        PSF         yes
 +    2.2             2.1.1       2001        PSF         yes
 +    2.1.2           2.1.1       2002        PSF         yes
 +    2.1.3           2.1.2       2002        PSF         yes
 +    2.2.1           2.2         2002        PSF         yes
 +    2.2.2           2.2.1       2002        PSF         yes
 +    2.2.3           2.2.2       2003        PSF         yes
 +    2.3             2.2.2       2002-2003   PSF         yes
 +    2.3.1           2.3         2002-2003   PSF         yes
 +    2.3.2           2.3.1       2002-2003   PSF         yes
 +    2.3.3           2.3.2       2002-2003   PSF         yes
 +    2.3.4           2.3.3       2004        PSF         yes
 +    2.3.5           2.3.4       2005        PSF         yes
 +    2.4             2.3         2004        PSF         yes
 +    2.4.1           2.4         2005        PSF         yes
 +    2.4.2           2.4.1       2005        PSF         yes
 +    2.4.3           2.4.2       2006        PSF         yes
 +    2.5             2.4         2006        PSF         yes
 +    2.7             2.6         2010        PSF         yes
 +
 +Footnotes:
 +
 +(1) GPL-compatible doesn't mean that we're distributing Python under
 +    the GPL.  All Python licenses, unlike the GPL, let you distribute
 +    a modified version without making your changes open source.  The
 +    GPL-compatible licenses make it possible to combine Python with
 +    other software that is released under the GPL; the others don't.
 +
 +(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
 +    because its license has a choice of law clause.  According to
 +    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
 +    is "not incompatible" with the GPL.
 +
 +Thanks to the many outside volunteers who have worked under Guido's
 +direction to make these releases possible.
 +
 +
 +B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
 +===============================================================
 +
 +PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
 +--------------------------------------------
 +
 +1. This LICENSE AGREEMENT is between the Python Software Foundation
 +("PSF"), and the Individual or Organization ("Licensee") accessing and
 +otherwise using this software ("Python") in source or binary form and
 +its associated documentation.
 +
 +2. Subject to the terms and conditions of this License Agreement, PSF
 +hereby grants Licensee a nonexclusive, royalty-free, world-wide
 +license to reproduce, analyze, test, perform and/or display publicly,
 +prepare derivative works, distribute, and otherwise use Python
 +alone or in any derivative version, provided, however, that PSF's
 +License Agreement and PSF's notice of copyright, i.e., "Copyright (c)
 +2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation; All Rights
 +Reserved" are retained in Python alone or in any derivative version
 +prepared by Licensee.
 +
 +3. In the event Licensee prepares a derivative work that is based on
 +or incorporates Python or any part thereof, and wants to make
 +the derivative work available to others as provided herein, then
 +Licensee hereby agrees to include in any such work a brief summary of
 +the changes made to Python.
 +
 +4. PSF is making Python available to Licensee on an "AS IS"
 +basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
 +IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
 +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
 +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
 +INFRINGE ANY THIRD PARTY RIGHTS.
 +
 +5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
 +FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
 +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
 +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
 +
 +6. This License Agreement will automatically terminate upon a material
 +breach of its terms and conditions.
 +
 +7. Nothing in this License Agreement shall be deemed to create any
 +relationship of agency, partnership, or joint venture between PSF and
 +Licensee.  This License Agreement does not grant permission to use PSF
 +trademarks or trade name in a trademark sense to endorse or promote
 +products or services of Licensee, or any third party.
 +
 +8. By copying, installing or otherwise using Python, Licensee
 +agrees to be bound by the terms and conditions of this License
 +Agreement.
 +
 +
 +BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
 +-------------------------------------------
 +
 +BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
 +
 +1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
 +office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
 +Individual or Organization ("Licensee") accessing and otherwise using
 +this software in source or binary form and its associated
 +documentation ("the Software").
 +
 +2. Subject to the terms and conditions of this BeOpen Python License
 +Agreement, BeOpen hereby grants Licensee a non-exclusive,
 +royalty-free, world-wide license to reproduce, analyze, test, perform
 +and/or display publicly, prepare derivative works, distribute, and
 +otherwise use the Software alone or in any derivative version,
 +provided, however, that the BeOpen Python License is retained in the
 +Software, alone or in any derivative version prepared by Licensee.
 +
 +3. BeOpen is making the Software available to Licensee on an "AS IS"
 +basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
 +IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
 +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
 +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
 +INFRINGE ANY THIRD PARTY RIGHTS.
 +
 +4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
 +SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
 +AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
 +DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
 +
 +5. This License Agreement will automatically terminate upon a material
 +breach of its terms and conditions.
 +
 +6. This License Agreement shall be governed by and interpreted in all
 +respects by the law of the State of California, excluding conflict of
 +law provisions.  Nothing in this License Agreement shall be deemed to
 +create any relationship of agency, partnership, or joint venture
 +between BeOpen and Licensee.  This License Agreement does not grant
 +permission to use BeOpen trademarks or trade names in a trademark
 +sense to endorse or promote products or services of Licensee, or any
 +third party.  As an exception, the "BeOpen Python" logos available at
 +http://www.pythonlabs.com/logos.html may be used according to the
 +permissions granted on that web page.
 +
 +7. By copying, installing or otherwise using the software, Licensee
 +agrees to be bound by the terms and conditions of this License
 +Agreement.
 +
 +
 +CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
 +---------------------------------------
 +
 +1. This LICENSE AGREEMENT is between the Corporation for National
 +Research Initiatives, having an office at 1895 Preston White Drive,
 +Reston, VA 20191 ("CNRI"), and the Individual or Organization
 +("Licensee") accessing and otherwise using Python 1.6.1 software in
 +source or binary form and its associated documentation.
 +
 +2. Subject to the terms and conditions of this License Agreement, CNRI
 +hereby grants Licensee a nonexclusive, royalty-free, world-wide
 +license to reproduce, analyze, test, perform and/or display publicly,
 +prepare derivative works, distribute, and otherwise use Python 1.6.1
 +alone or in any derivative version, provided, however, that CNRI's
 +License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
 +1995-2001 Corporation for National Research Initiatives; All Rights
 +Reserved" are retained in Python 1.6.1 alone or in any derivative
 +version prepared by Licensee.  Alternately, in lieu of CNRI's License
 +Agreement, Licensee may substitute the following text (omitting the
 +quotes): "Python 1.6.1 is made available subject to the terms and
 +conditions in CNRI's License Agreement.  This Agreement together with
 +Python 1.6.1 may be located on the Internet using the following
 +unique, persistent identifier (known as a handle): 1895.22/1013.  This
 +Agreement may also be obtained from a proxy server on the Internet
 +using the following URL: http://hdl.handle.net/1895.22/1013".
 +
 +3. In the event Licensee prepares a derivative work that is based on
 +or incorporates Python 1.6.1 or any part thereof, and wants to make
 +the derivative work available to others as provided herein, then
 +Licensee hereby agrees to include in any such work a brief summary of
 +the changes made to Python 1.6.1.
 +
 +4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
 +basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
 +IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
 +DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
 +FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
 +INFRINGE ANY THIRD PARTY RIGHTS.
 +
 +5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
 +1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
 +A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
 +OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
 +
 +6. This License Agreement will automatically terminate upon a material
 +breach of its terms and conditions.
 +
 +7. This License Agreement shall be governed by the federal
 +intellectual property law of the United States, including without
 +limitation the federal copyright law, and, to the extent such
 +U.S. federal law does not apply, by the law of the Commonwealth of
 +Virginia, excluding Virginia's conflict of law provisions.
 +Notwithstanding the foregoing, with regard to derivative works based
 +on Python 1.6.1 that incorporate non-separable material that was
 +previously distributed under the GNU General Public License (GPL), the
 +law of the Commonwealth of Virginia shall govern this License
 +Agreement only as to issues arising under or with respect to
 +Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
 +License Agreement shall be deemed to create any relationship of
 +agency, partnership, or joint venture between CNRI and Licensee.  This
 +License Agreement does not grant permission to use CNRI trademarks or
 +trade name in a trademark sense to endorse or promote products or
 +services of Licensee, or any third party.
 +
 +8. By clicking on the "ACCEPT" button where indicated, or by copying,
 +installing or otherwise using Python 1.6.1, Licensee agrees to be
 +bound by the terms and conditions of this License Agreement.
 +
 +        ACCEPT
 +
 +
 +CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
 +--------------------------------------------------
 +
 +Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
 +The Netherlands.  All rights reserved.
 +
 +Permission to use, copy, modify, and distribute this software and its
 +documentation for any purpose and without fee is hereby granted,
 +provided that the above copyright notice appear in all copies and that
 +both that copyright notice and this permission notice appear in
 +supporting documentation, and that the name of Stichting Mathematisch
 +Centrum or CWI not be used in advertising or publicity pertaining to
 +distribution of the software without specific, written prior
 +permission.
 +
 +STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
 +THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
 +FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
 +FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 +WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 +ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
 +OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 diff --git a/scripts/argparse.py b/scripts/argparse.py
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/scripts/argparse.py
++++ b/block/export/vhost-user-blk-server.c
 @@ -XXX,XX +XXX,XX @@
-+# This is a local copy of the standard library argparse module taken from PyPI.
++/*
-+# It is licensed under the Python Software Foundation License.  This is a
++ * Sharing QEMU block devices via vhost-user protocal
-+# fallback for Python 2.6 which does not include this module.  Python 2.7+ and
++ *
-+# 3+ will never load this module because built-in modules are loaded before
++ * Parts of the code based on nbd/server.c.
-+# anything in sys.path.
++ *
-+#
++ * Copyright (c) Coiby Xu <coiby.xu@gmail.com>.
-+# If your script is not located in the same directory as this file, import it
++ * Copyright (c) 2020 Red Hat, Inc.
-+# like this:
++ *
-+#
++ * This work is licensed under the terms of the GNU GPL, version 2 or
-+#   import os
++ * later.  See the COPYING file in the top-level directory.
-+#   import sys
++ */
-+#   sys.path.append(os.path.join(os.path.dirname(__file__), ..., 'scripts'))
++#include "qemu/osdep.h"
-+#   import argparse
++#include "block/block.h"
-+
++#include "vhost-user-blk-server.h"
-+# Author: Steven J. Bethard <steven.bethard@gmail.com>.
++#include "qapi/error.h"
-+# Maintainer: Thomas Waldmann <tw@waldmann-edv.de>
++#include "qom/object_interfaces.h"
-+
++#include "sysemu/block-backend.h"
-+"""Command-line parsing library
++#include "util/block-helpers.h"
 +
-+This module is an optparse-inspired command-line parsing library that:
++enum {
-+
++    VHOST_USER_BLK_MAX_QUEUES = 1,
-+    - handles both optional and positional arguments
++};
-+    - produces highly informative usage messages
++struct virtio_blk_inhdr {
-+    - supports parsers that dispatch to sub-parsers
++    unsigned char status;
-+
++};
-+The following is a simple usage example that sums integers from the
++
-+command-line and writes the result to a file::
++typedef struct VuBlockReq {
-+
++    VuVirtqElement *elem;
-+    parser = argparse.ArgumentParser(
++    int64_t sector_num;
-+        description='sum the integers at the command line')
++    size_t size;
-+    parser.add_argument(
++    struct virtio_blk_inhdr *in;
-+        'integers', metavar='int', nargs='+', type=int,
++    struct virtio_blk_outhdr out;
-+        help='an integer to be summed')
++    VuServer *server;
-+    parser.add_argument(
++    struct VuVirtq *vq;
-+        '--log', default=sys.stdout, type=argparse.FileType('w'),
++} VuBlockReq;
-+        help='the file where the sum should be written')
++
-+    args = parser.parse_args()
++static void vu_block_req_complete(VuBlockReq *req)
-+    args.log.write('%s' % sum(args.integers))
++{
-+    args.log.close()
++    VuDev *vu_dev = &req->server->vu_dev;
 +
-+The module contains the following public classes:
++    /* IO size with 1 extra status byte */
-+
++    vu_queue_push(vu_dev, req->vq, req->elem, req->size + 1);
-+    - ArgumentParser -- The main entry point for command-line parsing. As the
++    vu_queue_notify(vu_dev, req->vq);
-+        example above shows, the add_argument() method is used to populate
++
-+        the parser with actions for optional and positional arguments. Then
++    if (req->elem) {
-+        the parse_args() method is invoked to convert the args at the
++        free(req->elem);
-+        command-line into an object with attributes.
++    }
 +
-+    - ArgumentError -- The exception raised by ArgumentParser objects when
++    g_free(req);
-+        there are errors with the parser's actions. Errors raised while
++}
-+        parsing the command-line are caught by ArgumentParser and emitted
++
-+        as command-line messages.
++static VuBlockDev *get_vu_block_device_by_server(VuServer *server)
-+
++{
-+    - FileType -- A factory for defining types of files to be created. As the
++    return container_of(server, VuBlockDev, vu_server);
-+        example above shows, instances of FileType are typically passed as
++}
-+        the type= argument of add_argument() calls.
++
-+
++static int coroutine_fn
-+    - Action -- The base class for parser actions. Typically actions are
++vu_block_discard_write_zeroes(VuBlockReq *req, struct iovec *iov,
-+        selected by passing strings like 'store_true' or 'append_const' to
++                              uint32_t iovcnt, uint32_t type)
-+        the action= argument of add_argument(). However, for greater
++{
-+        customization of ArgumentParser actions, subclasses of Action may
++    struct virtio_blk_discard_write_zeroes desc;
-+        be defined and passed as the action= argument.
++    ssize_t size = iov_to_buf(iov, iovcnt, 0, &desc, sizeof(desc));
-+
++    if (unlikely(size != sizeof(desc))) {
-+    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
++        error_report("Invalid size %zd, expect %zu", size, sizeof(desc));
-+        ArgumentDefaultsHelpFormatter -- Formatter classes which
++        return -EINVAL;
-+        may be passed as the formatter_class= argument to the
++    }
-+        ArgumentParser constructor. HelpFormatter is the default,
++
-+        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
++    VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
-+        not to change the formatting for help text, and
++    uint64_t range[2] = { le64_to_cpu(desc.sector) << 9,
-+        ArgumentDefaultsHelpFormatter adds information about argument defaults
++                          le32_to_cpu(desc.num_sectors) << 9 };
-+        to the help.
++    if (type == VIRTIO_BLK_T_DISCARD) {
-+
++        if (blk_co_pdiscard(vdev_blk->backend, range[0], range[1]) == 0) {
-+All other classes in this module are considered implementation details.
++            return 0;
-+(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
++        }
-+considered public as object names -- the API of the formatter objects is
++    } else if (type == VIRTIO_BLK_T_WRITE_ZEROES) {
-+still considered an implementation detail.)
++        if (blk_co_pwrite_zeroes(vdev_blk->backend,
-+"""
++                                 range[0], range[1], 0) == 0) {
-+
++            return 0;
-+__version__ = '1.4.0'  # we use our own version number independant of the
++        }
-+                       # one in stdlib and we release this on pypi.
++    }
 +
-+__external_lib__ = True  # to make sure the tests really test THIS lib,
++    return -EINVAL;
-+                         # not the builtin one in Python stdlib
++}
 +
-+__all__ = [
++static void coroutine_fn vu_block_flush(VuBlockReq *req)
-+    'ArgumentParser',
++{
-+    'ArgumentError',
++    VuBlockDev *vdev_blk = get_vu_block_device_by_server(req->server);
-+    'ArgumentTypeError',
++    BlockBackend *backend = vdev_blk->backend;
-+    'FileType',
++    blk_co_flush(backend);
-+    'HelpFormatter',
++}
-+    'ArgumentDefaultsHelpFormatter',
++
-+    'RawDescriptionHelpFormatter',
++struct req_data {
-+    'RawTextHelpFormatter',
++    VuServer *server;
-+    'Namespace',
++    VuVirtq *vq;
-+    'Action',
++    VuVirtqElement *elem;
-+    'ONE_OR_MORE',
++};
-+    'OPTIONAL',
++
-+    'PARSER',
++static void coroutine_fn vu_block_virtio_process_req(void *opaque)
-+    'REMAINDER',
++{
-+    'SUPPRESS',
++    struct req_data *data = opaque;
-+    'ZERO_OR_MORE',
++    VuServer *server = data->server;
-+]
++    VuVirtq *vq = data->vq;
-+
++    VuVirtqElement *elem = data->elem;
-+
++    uint32_t type;
-+import copy as _copy
++    VuBlockReq *req;
-+import os as _os
++
-+import re as _re
++    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
-+import sys as _sys
++    BlockBackend *backend = vdev_blk->backend;
-+import textwrap as _textwrap
++
-+
++    struct iovec *in_iov = elem->in_sg;
-+from gettext import gettext as _
++    struct iovec *out_iov = elem->out_sg;
-+
++    unsigned in_num = elem->in_num;
-+try:
++    unsigned out_num = elem->out_num;
-+    set
++    /* refer to hw/block/virtio_blk.c */
-+except NameError:
++    if (elem->out_num < 1 || elem->in_num < 1) {
-+    # for python < 2.4 compatibility (sets module is there since 2.3):
++        error_report("virtio-blk request missing headers");
-+    from sets import Set as set
++        free(elem);
-+
++        return;
-+try:
++    }
-+    basestring
++
-+except NameError:
++    req = g_new0(VuBlockReq, 1);
-+    basestring = str
++    req->server = server;
-+
++    req->vq = vq;
-+try:
++    req->elem = elem;
-+    sorted
++
-+except NameError:
++    if (unlikely(iov_to_buf(out_iov, out_num, 0, &req->out,
-+    # for python < 2.4 compatibility:
++                            sizeof(req->out)) != sizeof(req->out))) {
-+    def sorted(iterable, reverse=False):
++        error_report("virtio-blk request outhdr too short");
-+        result = list(iterable)
++        goto err;
-+        result.sort()
++    }
-+        if reverse:
++
-+            result.reverse()
++    iov_discard_front(&out_iov, &out_num, sizeof(req->out));
-+        return result
++
-+
++    if (in_iov[in_num - 1].iov_len < sizeof(struct virtio_blk_inhdr)) {
-+
++        error_report("virtio-blk request inhdr too short");
-+def _callable(obj):
++        goto err;
-+    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')
++    }
 +
-+
++    /* We always touch the last byte, so just see how big in_iov is.  */
-+SUPPRESS = '==SUPPRESS=='
++    req->in = (void *)in_iov[in_num - 1].iov_base
-+
++              + in_iov[in_num - 1].iov_len
-+OPTIONAL = '?'
++              - sizeof(struct virtio_blk_inhdr);
-+ZERO_OR_MORE = '*'
++    iov_discard_back(in_iov, &in_num, sizeof(struct virtio_blk_inhdr));
-+ONE_OR_MORE = '+'
++
-+PARSER = 'A...'
++    type = le32_to_cpu(req->out.type);
-+REMAINDER = '...'
++    switch (type & ~VIRTIO_BLK_T_BARRIER) {
-+_UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'
++    case VIRTIO_BLK_T_IN:
-+
++    case VIRTIO_BLK_T_OUT: {
-+# =============================
++        ssize_t ret = 0;
-+# Utility functions and classes
++        bool is_write = type & VIRTIO_BLK_T_OUT;
-+# =============================
++        req->sector_num = le64_to_cpu(req->out.sector);
 +
-+class _AttributeHolder(object):
++        int64_t offset = req->sector_num * vdev_blk->blk_size;
-+    """Abstract base class that provides __repr__.
++        QEMUIOVector qiov;
-+
++        if (is_write) {
-+    The __repr__ method returns a string in the format::
++            qemu_iovec_init_external(&qiov, out_iov, out_num);
-+        ClassName(attr=name, attr=name, ...)
++            ret = blk_co_pwritev(backend, offset, qiov.size,
-+    The attributes are determined either by a class-level attribute,
++                                 &qiov, 0);
-+    '_kwarg_names', or by inspecting the instance __dict__.
++        } else {
-+    """
++            qemu_iovec_init_external(&qiov, in_iov, in_num);
-+
++            ret = blk_co_preadv(backend, offset, qiov.size,
-+    def __repr__(self):
++                                &qiov, 0);
-+        type_name = type(self).__name__
++        }
-+        arg_strings = []
++        if (ret >= 0) {
-+        for arg in self._get_args():
++            req->in->status = VIRTIO_BLK_S_OK;
-+            arg_strings.append(repr(arg))
++        } else {
-+        for name, value in self._get_kwargs():
++            req->in->status = VIRTIO_BLK_S_IOERR;
-+            arg_strings.append('%s=%r' % (name, value))
++        }
-+        return '%s(%s)' % (type_name, ', '.join(arg_strings))
++        break;
-+
++    }
-+    def _get_kwargs(self):
++    case VIRTIO_BLK_T_FLUSH:
-+        return sorted(self.__dict__.items())
++        vu_block_flush(req);
-+
++        req->in->status = VIRTIO_BLK_S_OK;
-+    def _get_args(self):
++        break;
-+        return []
++    case VIRTIO_BLK_T_GET_ID: {
-+
++        size_t size = MIN(iov_size(&elem->in_sg[0], in_num),
-+
++                          VIRTIO_BLK_ID_BYTES);
-+def _ensure_value(namespace, name, value):
++        snprintf(elem->in_sg[0].iov_base, size, "%s", "vhost_user_blk");
-+    if getattr(namespace, name, None) is None:
++        req->in->status = VIRTIO_BLK_S_OK;
-+        setattr(namespace, name, value)
++        req->size = elem->in_sg[0].iov_len;
-+    return getattr(namespace, name)
++        break;
-+
++    }
-+
++    case VIRTIO_BLK_T_DISCARD:
-+# ===============
++    case VIRTIO_BLK_T_WRITE_ZEROES: {
-+# Formatting Help
++        int rc;
-+# ===============
++        rc = vu_block_discard_write_zeroes(req, &elem->out_sg[1],
-+
++                                           out_num, type);
-+class HelpFormatter(object):
++        if (rc == 0) {
-+    """Formatter for generating usage messages and argument help strings.
++            req->in->status = VIRTIO_BLK_S_OK;
-+
++        } else {
-+    Only the name of this class is considered a public API. All the methods
++            req->in->status = VIRTIO_BLK_S_IOERR;
-+    provided by the class are considered an implementation detail.
++        }
-+    """
++        break;
-+
++    }
-+    def __init__(self,
++    default:
-+                 prog,
++        req->in->status = VIRTIO_BLK_S_UNSUPP;
-+                 indent_increment=2,
++        break;
-+                 max_help_position=24,
++    }
-+                 width=None):
++
-+
++    vu_block_req_complete(req);
-+        # default setting for width
++    return;
-+        if width is None:
++
-+            try:
++err:
-+                width = int(_os.environ['COLUMNS'])
++    free(elem);
-+            except (KeyError, ValueError):
++    g_free(req);
-+                width = 80
++    return;
-+            width -= 2
++}
 +
-+        self._prog = prog
++static void vu_block_process_vq(VuDev *vu_dev, int idx)
-+        self._indent_increment = indent_increment
++{
-+        self._max_help_position = max_help_position
++    VuServer *server;
-+        self._width = width
++    VuVirtq *vq;
-+
++    struct req_data *req_data;
-+        self._current_indent = 0
++
-+        self._level = 0
++    server = container_of(vu_dev, VuServer, vu_dev);
-+        self._action_max_length = 0
++    assert(server);
 +
-+        self._root_section = self._Section(self, None)
++    vq = vu_get_queue(vu_dev, idx);
-+        self._current_section = self._root_section
++    assert(vq);
-+
++    VuVirtqElement *elem;
-+        self._whitespace_matcher = _re.compile(r'\s+')
++    while (1) {
-+        self._long_break_matcher = _re.compile(r'\n\n\n+')
++        elem = vu_queue_pop(vu_dev, vq, sizeof(VuVirtqElement) +
-+
++                                    sizeof(VuBlockReq));
-+    # ===============================
++        if (elem) {
-+    # Section and indentation methods
++            req_data = g_new0(struct req_data, 1);
-+    # ===============================
++            req_data->server = server;
-+    def _indent(self):
++            req_data->vq = vq;
-+        self._current_indent += self._indent_increment
++            req_data->elem = elem;
-+        self._level += 1
++            Coroutine *co = qemu_coroutine_create(vu_block_virtio_process_req,
-+
++                                                  req_data);
-+    def _dedent(self):
++            aio_co_enter(server->ioc->ctx, co);
-+        self._current_indent -= self._indent_increment
++        } else {
-+        assert self._current_indent >= 0, 'Indent decreased below 0.'
++            break;
-+        self._level -= 1
++        }
-+
++    }
-+    class _Section(object):
++}
 +
-+        def __init__(self, formatter, parent, heading=None):
++static void vu_block_queue_set_started(VuDev *vu_dev, int idx, bool started)
-+            self.formatter = formatter
++{
-+            self.parent = parent
++    VuVirtq *vq;
-+            self.heading = heading
++
-+            self.items = []
++    assert(vu_dev);
 +
-+        def format_help(self):
++    vq = vu_get_queue(vu_dev, idx);
-+            # format the indented section
++    vu_set_queue_handler(vu_dev, vq, started ? vu_block_process_vq : NULL);
-+            if self.parent is not None:
++}
-+                self.formatter._indent()
++
-+            join = self.formatter._join_parts
++static uint64_t vu_block_get_features(VuDev *dev)
-+            for func, args in self.items:
++{
-+                func(*args)
++    uint64_t features;
-+            item_help = join([func(*args) for func, args in self.items])
++    VuServer *server = container_of(dev, VuServer, vu_dev);
-+            if self.parent is not None:
++    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
-+                self.formatter._dedent()
++    features = 1ull << VIRTIO_BLK_F_SIZE_MAX |
-+
++               1ull << VIRTIO_BLK_F_SEG_MAX |
-+            # return nothing if the section was empty
++               1ull << VIRTIO_BLK_F_TOPOLOGY |
-+            if not item_help:
++               1ull << VIRTIO_BLK_F_BLK_SIZE |
-+                return ''
++               1ull << VIRTIO_BLK_F_FLUSH |
-+
++               1ull << VIRTIO_BLK_F_DISCARD |
-+            # add the heading if the section was non-empty
++               1ull << VIRTIO_BLK_F_WRITE_ZEROES |
-+            if self.heading is not SUPPRESS and self.heading is not None:
++               1ull << VIRTIO_BLK_F_CONFIG_WCE |
-+                current_indent = self.formatter._current_indent
++               1ull << VIRTIO_F_VERSION_1 |
-+                heading = '%*s%s:\n' % (current_indent, '', self.heading)
++               1ull << VIRTIO_RING_F_INDIRECT_DESC |
-+            else:
++               1ull << VIRTIO_RING_F_EVENT_IDX |
-+                heading = ''
++               1ull << VHOST_USER_F_PROTOCOL_FEATURES;
 +
-+            # join the section-initial newline, the heading and the help
++    if (!vdev_blk->writable) {
-+            return join(['\n', heading, item_help, '\n'])
++        features |= 1ull << VIRTIO_BLK_F_RO;
-+
++    }
-+    def _add_item(self, func, args):
++
-+        self._current_section.items.append((func, args))
++    return features;
-+
++}
-+    # ========================
++
-+    # Message building methods
++static uint64_t vu_block_get_protocol_features(VuDev *dev)
-+    # ========================
++{
-+    def start_section(self, heading):
++    return 1ull << VHOST_USER_PROTOCOL_F_CONFIG |
-+        self._indent()
++           1ull << VHOST_USER_PROTOCOL_F_INFLIGHT_SHMFD;
-+        section = self._Section(self, self._current_section, heading)
++}
-+        self._add_item(section.format_help, [])
++
-+        self._current_section = section
++static int
-+
++vu_block_get_config(VuDev *vu_dev, uint8_t *config, uint32_t len)
-+    def end_section(self):
++{
-+        self._current_section = self._current_section.parent
++    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
-+        self._dedent()
++    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
-+
++    memcpy(config, &vdev_blk->blkcfg, len);
-+    def add_text(self, text):
++
-+        if text is not SUPPRESS and text is not None:
++    return 0;
-+            self._add_item(self._format_text, [text])
++}
 +
-+    def add_usage(self, usage, actions, groups, prefix=None):
++static int
-+        if usage is not SUPPRESS:
++vu_block_set_config(VuDev *vu_dev, const uint8_t *data,
-+            args = usage, actions, groups, prefix
++                    uint32_t offset, uint32_t size, uint32_t flags)
-+            self._add_item(self._format_usage, args)
++{
-+
++    VuServer *server = container_of(vu_dev, VuServer, vu_dev);
-+    def add_argument(self, action):
++    VuBlockDev *vdev_blk = get_vu_block_device_by_server(server);
-+        if action.help is not SUPPRESS:
++    uint8_t wce;
 +
-+            # find all invocations
++    /* don't support live migration */
-+            get_invocation = self._format_action_invocation
++    if (flags != VHOST_SET_CONFIG_TYPE_MASTER) {
-+            invocations = [get_invocation(action)]
++        return -EINVAL;
-+            for subaction in self._iter_indented_subactions(action):
++    }
-+                invocations.append(get_invocation(subaction))
++
-+
++    if (offset != offsetof(struct virtio_blk_config, wce) ||
-+            # update the maximum item length
++        size != 1) {
-+            invocation_length = max([len(s) for s in invocations])
++        return -EINVAL;
-+            action_length = invocation_length + self._current_indent
++    }
-+            self._action_max_length = max(self._action_max_length,
++
-+                                          action_length)
++    wce = *data;
-+
++    vdev_blk->blkcfg.wce = wce;
-+            # add the item to the list
++    blk_set_enable_write_cache(vdev_blk->backend, wce);
-+            self._add_item(self._format_action, [action])
++    return 0;
-+
++}
-+    def add_arguments(self, actions):
++
-+        for action in actions:
++/*
-+            self.add_argument(action)
++ * 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.
-+    # Help-formatting methods
++ * To avoid this issue,  process VHOST_USER_NONE request ahead
-+    # =======================
++ * of vu_process_message.
-+    def format_help(self):
++ *
-+        help = self._root_section.format_help()
++ */
-+        if help:
++static int vu_block_process_msg(VuDev *dev, VhostUserMsg *vmsg, int *do_reply)
-+            help = self._long_break_matcher.sub('\n\n', help)
++{
-+            help = help.strip('\n') + '\n'
++    if (vmsg->request == VHOST_USER_NONE) {
-+        return help
++        dev->panic(dev, "disconnect");
-+
++        return true;
-+    def _join_parts(self, part_strings):
++    }
-+        return ''.join([part
++    return false;
-+                        for part in part_strings
++}
-+                        if part and part is not SUPPRESS])
++
-+
++static const VuDevIface vu_block_iface = {
-+    def _format_usage(self, usage, actions, groups, prefix):
++    .get_features          = vu_block_get_features,
-+        if prefix is None:
++    .queue_set_started     = vu_block_queue_set_started,
-+            prefix = _('usage: ')
++    .get_protocol_features = vu_block_get_protocol_features,
-+
++    .get_config            = vu_block_get_config,
-+        # if usage is specified, use that
++    .set_config            = vu_block_set_config,
-+        if usage is not None:
++    .process_msg           = vu_block_process_msg,
-+            usage = usage % dict(prog=self._prog)
++};
 +
-+        # if no optionals or positionals are available, usage is just prog
++static void blk_aio_attached(AioContext *ctx, void *opaque)
-+        elif usage is None and not actions:
++{
-+            usage = '%(prog)s' % dict(prog=self._prog)
++    VuBlockDev *vub_dev = opaque;
-+
++    aio_context_acquire(ctx);
-+        # if optionals and positionals are available, calculate usage
++    vhost_user_server_set_aio_context(&vub_dev->vu_server, ctx);
-+        elif usage is None:
++    aio_context_release(ctx);
-+            prog = '%(prog)s' % dict(prog=self._prog)
++}
 +
-+            # split optionals from positionals
++static void blk_aio_detach(void *opaque)
-+            optionals = []
++{
-+            positionals = []
++    VuBlockDev *vub_dev = opaque;
-+            for action in actions:
++    AioContext *ctx = vub_dev->vu_server.ctx;
-+                if action.option_strings:
++    aio_context_acquire(ctx);
-+                    optionals.append(action)
++    vhost_user_server_set_aio_context(&vub_dev->vu_server, NULL);
-+                else:
++    aio_context_release(ctx);
-+                    positionals.append(action)
++}
 +
-+            # build full usage string
++static void
-+            format = self._format_actions_usage
++vu_block_initialize_config(BlockDriverState *bs,
-+            action_usage = format(optionals + positionals, groups)
++                           struct virtio_blk_config *config, uint32_t blk_size)
-+            usage = ' '.join([s for s in [prog, action_usage] if s])
++{
-+
++    config->capacity = bdrv_getlength(bs) >> BDRV_SECTOR_BITS;
-+            # wrap the usage parts if it's too long
++    config->blk_size = blk_size;
-+            text_width = self._width - self._current_indent
++    config->size_max = 0;
-+            if len(prefix) + len(usage) > text_width:
++    config->seg_max = 128 - 2;
-+
++    config->min_io_size = 1;
-+                # break usage into wrappable parts
++    config->opt_io_size = 1;
-+                part_regexp = r'\(.*?\)+|\[.*?\]+|\S+'
++    config->num_queues = VHOST_USER_BLK_MAX_QUEUES;
-+                opt_usage = format(optionals, groups)
++    config->max_discard_sectors = 32768;
-+                pos_usage = format(positionals, groups)
++    config->max_discard_seg = 1;
-+                opt_parts = _re.findall(part_regexp, opt_usage)
++    config->discard_sector_alignment = config->blk_size >> 9;
-+                pos_parts = _re.findall(part_regexp, pos_usage)
++    config->max_write_zeroes_sectors = 32768;
-+                assert ' '.join(opt_parts) == opt_usage
++    config->max_write_zeroes_seg = 1;
-+                assert ' '.join(pos_parts) == pos_usage
++}
 +
-+                # helper for wrapping lines
++static VuBlockDev *vu_block_init(VuBlockDev *vu_block_device, Error **errp)
-+                def get_lines(parts, indent, prefix=None):
++{
-+                    lines = []
++
-+                    line = []
++    BlockBackend *blk;
-+                    if prefix is not None:
++    Error *local_error = NULL;
-+                        line_len = len(prefix) - 1
++    const char *node_name = vu_block_device->node_name;
-+                    else:
++    bool writable = vu_block_device->writable;
-+                        line_len = len(indent) - 1
++    uint64_t perm = BLK_PERM_CONSISTENT_READ;
-+                    for part in parts:
++    int ret;
-+                        if line_len + 1 + len(part) > text_width:
++
-+                            lines.append(indent + ' '.join(line))
++    AioContext *ctx;
-+                            line = []
++
-+                            line_len = len(indent) - 1
++    BlockDriverState *bs = bdrv_lookup_bs(node_name, node_name, &local_error);
-+                        line.append(part)
++
-+                        line_len += len(part) + 1
++    if (!bs) {
-+                    if line:
++        error_propagate(errp, local_error);
-+                        lines.append(indent + ' '.join(line))
++        return NULL;
-+                    if prefix is not None:
++    }
-+                        lines[0] = lines[0][len(indent):]
++
-+                    return lines
++    if (bdrv_is_read_only(bs)) {
-+
++        writable = false;
-+                # if prog is short, follow it with optionals or positionals
++    }
-+                if len(prefix) + len(prog) <= 0.75 * text_width:
++
-+                    indent = ' ' * (len(prefix) + len(prog) + 1)
++    if (writable) {
-+                    if opt_parts:
++        perm |= BLK_PERM_WRITE;
-+                        lines = get_lines([prog] + opt_parts, indent, prefix)
++    }
-+                        lines.extend(get_lines(pos_parts, indent))
++
-+                    elif pos_parts:
++    ctx = bdrv_get_aio_context(bs);
-+                        lines = get_lines([prog] + pos_parts, indent, prefix)
++    aio_context_acquire(ctx);
-+                    else:
++    bdrv_invalidate_cache(bs, NULL);
-+                        lines = [prog]
++    aio_context_release(ctx);
 +
-+                # if prog is long, put it on its own line
++    /*
-+                else:
++     * Don't allow resize while the vhost user server is running,
-+                    indent = ' ' * len(prefix)
++     * otherwise we don't care what happens with the node.
-+                    parts = opt_parts + pos_parts
++     */
-+                    lines = get_lines(parts, indent)
++    blk = blk_new(bdrv_get_aio_context(bs), perm,
-+                    if len(lines) > 1:
++                  BLK_PERM_CONSISTENT_READ | BLK_PERM_WRITE_UNCHANGED |
-+                        lines = []
++                  BLK_PERM_WRITE | BLK_PERM_GRAPH_MOD);
-+                        lines.extend(get_lines(opt_parts, indent))
++    ret = blk_insert_bs(blk, bs, errp);
-+                        lines.extend(get_lines(pos_parts, indent))
++
-+                    lines = [prog] + lines
++    if (ret < 0) {
-+
++        goto fail;
-+                # join lines into usage
++    }
-+                usage = '\n'.join(lines)
++
-+
++    blk_set_enable_write_cache(blk, false);
-+        # prefix with 'usage:'
++
-+        return '%s%s\n\n' % (prefix, usage)
++    blk_set_allow_aio_context_change(blk, true);
 +
-+    def _format_actions_usage(self, actions, groups):
++    vu_block_device->blkcfg.wce = 0;
-+        # find group indices and identify actions in groups
++    vu_block_device->backend = blk;
-+        group_actions = set()
++    if (!vu_block_device->blk_size) {
-+        inserts = {}
++        vu_block_device->blk_size = BDRV_SECTOR_SIZE;
-+        for group in groups:
++    }
-+            try:
++    vu_block_device->blkcfg.blk_size = vu_block_device->blk_size;
-+                start = actions.index(group._group_actions[0])
++    blk_set_guest_block_size(blk, vu_block_device->blk_size);
-+            except ValueError:
++    vu_block_initialize_config(bs, &vu_block_device->blkcfg,
-+                continue
++                                   vu_block_device->blk_size);
-+            else:
++    return vu_block_device;
-+                end = start + len(group._group_actions)
++
-+                if actions[start:end] == group._group_actions:
++fail:
-+                    for action in group._group_actions:
++    blk_unref(blk);
-+                        group_actions.add(action)
++    return NULL;
-+                    if not group.required:
++}
-+                        if start in inserts:
++
-+                            inserts[start] += ' ['
++static void vu_block_deinit(VuBlockDev *vu_block_device)
-+                        else:
++{
-+                            inserts[start] = '['
++    if (vu_block_device->backend) {
-+                        inserts[end] = ']'
++        blk_remove_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
-+                    else:
++                                        blk_aio_detach, vu_block_device);
-+                        if start in inserts:
++    }
-+                            inserts[start] += ' ('
++
-+                        else:
++    blk_unref(vu_block_device->backend);
-+                            inserts[start] = '('
++}
-+                        inserts[end] = ')'
++
-+                    for i in range(start + 1, end):
++static void vhost_user_blk_server_stop(VuBlockDev *vu_block_device)
-+                        inserts[i] = '|'
++{
-+
++    vhost_user_server_stop(&vu_block_device->vu_server);
-+        # collect all actions format strings
++    vu_block_deinit(vu_block_device);
-+        parts = []
++}
-+        for i, action in enumerate(actions):
++
-+
++static void vhost_user_blk_server_start(VuBlockDev *vu_block_device,
-+            # suppressed arguments are marked with None
++                                        Error **errp)
-+            # remove | separators for suppressed arguments
++{
-+            if action.help is SUPPRESS:
++    AioContext *ctx;
-+                parts.append(None)
++    SocketAddress *addr = vu_block_device->addr;
-+                if inserts.get(i) == '|':
++
-+                    inserts.pop(i)
++    if (!vu_block_init(vu_block_device, errp)) {
-+                elif inserts.get(i + 1) == '|':
++        return;
-+                    inserts.pop(i + 1)
++    }
 +
-+            # produce all arg strings
++    ctx = bdrv_get_aio_context(blk_bs(vu_block_device->backend));
-+            elif not action.option_strings:
++
-+                part = self._format_args(action, action.dest)
++    if (!vhost_user_server_start(&vu_block_device->vu_server, addr, ctx,
-+
++                                 VHOST_USER_BLK_MAX_QUEUES,
-+                # if it's in a group, strip the outer []
++                                 NULL, &vu_block_iface,
-+                if action in group_actions:
++                                 errp)) {
-+                    if part[0] == '[' and part[-1] == ']':
++        goto error;
-+                        part = part[1:-1]
++    }
 +
-+                # add the action string to the list
++    blk_add_aio_context_notifier(vu_block_device->backend, blk_aio_attached,
-+                parts.append(part)
++                                 blk_aio_detach, vu_block_device);
-+
++    vu_block_device->running = true;
-+            # produce the first way to invoke the option in brackets
++    return;
-+            else:
++
-+                option_string = action.option_strings[0]
++ error:
-+
++    vu_block_deinit(vu_block_device);
-+                # if the Optional doesn't take a value, format is:
++}
-+                #    -s or --long
++
-+                if action.nargs == 0:
++static bool vu_prop_modifiable(VuBlockDev *vus, Error **errp)
-+                    part = '%s' % option_string
++{
-+
++    if (vus->running) {
-+                # if the Optional takes a value, format is:
++            error_setg(errp, "The property can't be modified "
-+                #    -s ARGS or --long ARGS
++                       "while the server is running");
-+                else:
++            return false;
-+                    default = action.dest.upper()
++    }
-+                    args_string = self._format_args(action, default)
++    return true;
-+                    part = '%s %s' % (option_string, args_string)
++}
 +
-+                # make it look optional if it's not required or in a group
++static void vu_set_node_name(Object *obj, const char *value, Error **errp)
-+                if not action.required and action not in group_actions:
++{
-+                    part = '[%s]' % part
++    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
 +
-+                # add the action string to the list
++    if (!vu_prop_modifiable(vus, errp)) {
-+                parts.append(part)
++        return;
-+
++    }
-+        # insert things at the necessary indices
++
-+        for i in sorted(inserts, reverse=True):
++    if (vus->node_name) {
-+            parts[i:i] = [inserts[i]]
++        g_free(vus->node_name);
-+
++    }
-+        # join all the action items with spaces
++
-+        text = ' '.join([item for item in parts if item is not None])
++    vus->node_name = g_strdup(value);
-+
++}
-+        # clean up separators for mutually exclusive groups
++
-+        open = r'[\[(]'
++static char *vu_get_node_name(Object *obj, Error **errp)
-+        close = r'[\])]'
++{
-+        text = _re.sub(r'(%s) ' % open, r'\1', text)
++    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-+        text = _re.sub(r' (%s)' % close, r'\1', text)
++    return g_strdup(vus->node_name);
-+        text = _re.sub(r'%s *%s' % (open, close), r'', text)
++}
-+        text = _re.sub(r'\(([^|]*)\)', r'\1', text)
++
-+        text = text.strip()
++static void free_socket_addr(SocketAddress *addr)
-+
++{
-+        # return the text
++        g_free(addr->u.q_unix.path);
-+        return text
++        g_free(addr);
-+
++}
-+    def _format_text(self, text):
++
-+        if '%(prog)' in text:
++static void vu_set_unix_socket(Object *obj, const char *value,
-+            text = text % dict(prog=self._prog)
++                               Error **errp)
-+        text_width = self._width - self._current_indent
++{
-+        indent = ' ' * self._current_indent
++    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-+        return self._fill_text(text, text_width, indent) + '\n\n'
++
-+
++    if (!vu_prop_modifiable(vus, errp)) {
-+    def _format_action(self, action):
++        return;
-+        # determine the required width and the entry label
++    }
-+        help_position = min(self._action_max_length + 2,
++
-+                            self._max_help_position)
++    if (vus->addr) {
-+        help_width = self._width - help_position
++        free_socket_addr(vus->addr);
-+        action_width = help_position - self._current_indent - 2
++    }
-+        action_header = self._format_action_invocation(action)
++
-+
++    SocketAddress *addr = g_new0(SocketAddress, 1);
-+        # ho nelp; start on same line and add a final newline
++    addr->type = SOCKET_ADDRESS_TYPE_UNIX;
-+        if not action.help:
++    addr->u.q_unix.path = g_strdup(value);
-+            tup = self._current_indent, '', action_header
++    vus->addr = addr;
-+            action_header = '%*s%s\n' % tup
++}
 +
-+        # short action name; start on the same line and pad two spaces
++static char *vu_get_unix_socket(Object *obj, Error **errp)
-+        elif len(action_header) <= action_width:
++{
-+            tup = self._current_indent, '', action_width, action_header
++    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-+            action_header = '%*s%-*s  ' % tup
++    return g_strdup(vus->addr->u.q_unix.path);
-+            indent_first = 0
++}
 +
-+        # long action name; start on the next line
++static bool vu_get_block_writable(Object *obj, Error **errp)
-+        else:
++{
-+            tup = self._current_indent, '', action_header
++    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-+            action_header = '%*s%s\n' % tup
++    return vus->writable;
-+            indent_first = help_position
++}
 +
-+        # collect the pieces of the action help
++static void vu_set_block_writable(Object *obj, bool value, Error **errp)
-+        parts = [action_header]
++{
-+
++    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-+        # if there was help for the action, add lines of help text
++
-+        if action.help:
++    if (!vu_prop_modifiable(vus, errp)) {
-+            help_text = self._expand_help(action)
++            return;
-+            help_lines = self._split_lines(help_text, help_width)
++    }
-+            parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
++
-+            for line in help_lines[1:]:
++    vus->writable = value;
-+                parts.append('%*s%s\n' % (help_position, '', line))
++}
 +
-+        # or add a newline if the description doesn't end with one
++static void vu_get_blk_size(Object *obj, Visitor *v, const char *name,
-+        elif not action_header.endswith('\n'):
++                            void *opaque, Error **errp)
-+            parts.append('\n')
++{
-+
++    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-+        # if there are any sub-actions, add their help as well
++    uint32_t value = vus->blk_size;
-+        for subaction in self._iter_indented_subactions(action):
++
-+            parts.append(self._format_action(subaction))
++    visit_type_uint32(v, name, &value, errp);
-+
++}
-+        # return a single string
++
-+        return self._join_parts(parts)
++static void vu_set_blk_size(Object *obj, Visitor *v, const char *name,
-+
++                            void *opaque, Error **errp)
-+    def _format_action_invocation(self, action):
++{
-+        if not action.option_strings:
++    VuBlockDev *vus = VHOST_USER_BLK_SERVER(obj);
-+            metavar, = self._metavar_formatter(action, action.dest)(1)
++
-+            return metavar
++    Error *local_err = NULL;
-+
++    uint32_t value;
-+        else:
++
-+            parts = []
++    if (!vu_prop_modifiable(vus, errp)) {
-+
++            return;
-+            # if the Optional doesn't take a value, format is:
++    }
-+            #    -s, --long
++
-+            if action.nargs == 0:
++    visit_type_uint32(v, name, &value, &local_err);
-+                parts.extend(action.option_strings)
++    if (local_err) {
-+
++        goto out;
-+            # if the Optional takes a value, format is:
++    }
-+            #    -s ARGS, --long ARGS
++
-+            else:
++    check_block_size(object_get_typename(obj), name, value, &local_err);
-+                default = action.dest.upper()
++    if (local_err) {
-+                args_string = self._format_args(action, default)
++        goto out;
-+                for option_string in action.option_strings:
++    }
-+                    parts.append('%s %s' % (option_string, args_string))
++
-+
++    vus->blk_size = value;
-+            return ', '.join(parts)
++
-+
++out:
-+    def _metavar_formatter(self, action, default_metavar):
++    error_propagate(errp, local_err);
-+        if action.metavar is not None:
++}
-+            result = action.metavar
++
-+        elif action.choices is not None:
++static void vhost_user_blk_server_instance_finalize(Object *obj)
-+            choice_strs = [str(choice) for choice in action.choices]
++{
-+            result = '{%s}' % ','.join(choice_strs)
++    VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
-+        else:
++
-+            result = default_metavar
++    vhost_user_blk_server_stop(vub);
 +
-+        def format(tuple_size):
++    /*
-+            if isinstance(result, tuple):
++     * Unlike object_property_add_str, object_class_property_add_str
-+                return result
++     * doesn't have a release method. Thus manual memory freeing is
-+            else:
++     * needed.
-+                return (result, ) * tuple_size
++     */
-+        return format
++    free_socket_addr(vub->addr);
-+
++    g_free(vub->node_name);
-+    def _format_args(self, action, default_metavar):
++}
-+        get_metavar = self._metavar_formatter(action, default_metavar)
++
-+        if action.nargs is None:
++static void vhost_user_blk_server_complete(UserCreatable *obj, Error **errp)
-+            result = '%s' % get_metavar(1)
++{
-+        elif action.nargs == OPTIONAL:
++    VuBlockDev *vub = VHOST_USER_BLK_SERVER(obj);
-+            result = '[%s]' % get_metavar(1)
++
-+        elif action.nargs == ZERO_OR_MORE:
++    vhost_user_blk_server_start(vub, errp);
-+            result = '[%s [%s ...]]' % get_metavar(2)
++}
-+        elif action.nargs == ONE_OR_MORE:
++
-+            result = '%s [%s ...]' % get_metavar(2)
++static void vhost_user_blk_server_class_init(ObjectClass *klass,
-+        elif action.nargs == REMAINDER:
++                                             void *class_data)
-+            result = '...'
++{
-+        elif action.nargs == PARSER:
++    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
-+            result = '%s ...' % get_metavar(1)
++    ucc->complete = vhost_user_blk_server_complete;
-+        else:
++
-+            formats = ['%s' for _ in range(action.nargs)]
++    object_class_property_add_bool(klass, "writable",
-+            result = ' '.join(formats) % get_metavar(action.nargs)
++                                   vu_get_block_writable,
-+        return result
++                                   vu_set_block_writable);
 +
-+    def _expand_help(self, action):
++    object_class_property_add_str(klass, "node-name",
-+        params = dict(vars(action), prog=self._prog)
++                                  vu_get_node_name,
-+        for name in list(params):
++                                  vu_set_node_name);
-+            if params[name] is SUPPRESS:
++
-+                del params[name]
++    object_class_property_add_str(klass, "unix-socket",
-+        for name in list(params):
++                                  vu_get_unix_socket,
-+            if hasattr(params[name], '__name__'):
++                                  vu_set_unix_socket);
-+                params[name] = params[name].__name__
++
-+        if params.get('choices') is not None:
++    object_class_property_add(klass, "logical-block-size", "uint32",
-+            choices_str = ', '.join([str(c) for c in params['choices']])
++                              vu_get_blk_size, vu_set_blk_size,
-+            params['choices'] = choices_str
++                              NULL, NULL);
-+        return self._get_help_string(action) % params
++}
 +
-+    def _iter_indented_subactions(self, action):
++static const TypeInfo vhost_user_blk_server_info = {
-+        try:
++    .name = TYPE_VHOST_USER_BLK_SERVER,
-+            get_subactions = action._get_subactions
++    .parent = TYPE_OBJECT,
-+        except AttributeError:
++    .instance_size = sizeof(VuBlockDev),
-+            pass
++    .instance_finalize = vhost_user_blk_server_instance_finalize,
-+        else:
++    .class_init = vhost_user_blk_server_class_init,
-+            self._indent()
++    .interfaces = (InterfaceInfo[]) {
-+            for subaction in get_subactions():
++        {TYPE_USER_CREATABLE},
-+                yield subaction
++        {}
-+            self._dedent()
++    },
-+
++};
-+    def _split_lines(self, text, width):
++
-+        text = self._whitespace_matcher.sub(' ', text).strip()
++static void vhost_user_blk_server_register_types(void)
-+        return _textwrap.wrap(text, width)
++{
-+
++    type_register_static(&vhost_user_blk_server_info);
-+    def _fill_text(self, text, width, indent):
++}
-+        text = self._whitespace_matcher.sub(' ', text).strip()
++
-+        return _textwrap.fill(text, width, initial_indent=indent,
++type_init(vhost_user_blk_server_register_types)
-+                                           subsequent_indent=indent)
+diff --git a/softmmu/vl.c b/softmmu/vl.c
-+
+index XXXXXXX..XXXXXXX 100644
-+    def _get_help_string(self, action):
+--- a/softmmu/vl.c
-+        return action.help
++++ b/softmmu/vl.c
-+
+@@ -XXX,XX +XXX,XX @@ static bool object_create_initial(const char *type, QemuOpts *opts)
-+
+     }
-+class RawDescriptionHelpFormatter(HelpFormatter):
+ #endif
-+    """Help message formatter which retains any formatting in descriptions.
-+
++    /* Reason: vhost-user-blk-server property "node-name" */
-+    Only the name of this class is considered a public API. All the methods
++    if (g_str_equal(type, "vhost-user-blk-server")) {
-+    provided by the class are considered an implementation detail.
++        return false;
-+    """
++    }
-+
+     /*
-+    def _fill_text(self, text, width, indent):
+      * Reason: filter-* property "netdev" etc.
-+        return ''.join([indent + line for line in text.splitlines(True)])
+      */
-+
+diff --git a/block/meson.build b/block/meson.build
-+
+index XXXXXXX..XXXXXXX 100644
-+class RawTextHelpFormatter(RawDescriptionHelpFormatter):
+--- a/block/meson.build
-+    """Help message formatter which retains formatting of all help text.
++++ b/block/meson.build
-+
+@@ -XXX,XX +XXX,XX @@ block_ss.add(when: 'CONFIG_WIN32', if_true: files('file-win32.c', 'win32-aio.c')
-+    Only the name of this class is considered a public API. All the methods
+ block_ss.add(when: 'CONFIG_POSIX', if_true: [files('file-posix.c'), coref, iokit])
-+    provided by the class are considered an implementation detail.
+ 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'))
-+    def _split_lines(self, text, width):
+ block_ss.add(when: 'CONFIG_REPLICATION', if_true: files('replication.c'))
-+        return text.splitlines()
+ 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'))
 +
 +class ArgumentDefaultsHelpFormatter(HelpFormatter):
 +    """Help message formatter which adds default values to argument help.
 +
 +    Only the name of this class is considered a public API. All the methods
 +    provided by the class are considered an implementation detail.
 +    """
 +
 +    def _get_help_string(self, action):
 +        help = action.help
 +        if '%(default)' not in action.help:
 +            if action.default is not SUPPRESS:
 +                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
 +                if action.option_strings or action.nargs in defaulting_nargs:
 +                    help += ' (default: %(default)s)'
 +        return help
 +
 +
 +# =====================
 +# Options and Arguments
 +# =====================
 +
 +def _get_action_name(argument):
 +    if argument is None:
 +        return None
 +    elif argument.option_strings:
 +        return  '/'.join(argument.option_strings)
 +    elif argument.metavar not in (None, SUPPRESS):
 +        return argument.metavar
 +    elif argument.dest not in (None, SUPPRESS):
 +        return argument.dest
 +    else:
 +        return None
 +
 +
 +class ArgumentError(Exception):
 +    """An error from creating or using an argument (optional or positional).
 +
 +    The string value of this exception is the message, augmented with
 +    information about the argument that caused it.
 +    """
 +
 +    def __init__(self, argument, message):
 +        self.argument_name = _get_action_name(argument)
 +        self.message = message
 +
 +    def __str__(self):
 +        if self.argument_name is None:
 +            format = '%(message)s'
 +        else:
 +            format = 'argument %(argument_name)s: %(message)s'
 +        return format % dict(message=self.message,
 +                             argument_name=self.argument_name)
 +
 +
 +class ArgumentTypeError(Exception):
 +    """An error from trying to convert a command line string to a type."""
 +    pass
 +
 +
 +# ==============
 +# Action classes
 +# ==============
 +
 +class Action(_AttributeHolder):
 +    """Information about how to convert command line strings to Python objects.
 +
 +    Action objects are used by an ArgumentParser to represent the information
 +    needed to parse a single argument from one or more strings from the
 +    command line. The keyword arguments to the Action constructor are also
 +    all attributes of Action instances.
 +
 +    Keyword Arguments:
 +
 +        - option_strings -- A list of command-line option strings which
 +            should be associated with this action.
 +
 +        - dest -- The name of the attribute to hold the created object(s)
 +
 +        - nargs -- The number of command-line arguments that should be
 +            consumed. By default, one argument will be consumed and a single
 +            value will be produced.  Other values include:
 +                - N (an integer) consumes N arguments (and produces a list)
 +                - '?' consumes zero or one arguments
 +                - '*' consumes zero or more arguments (and produces a list)
 +                - '+' consumes one or more arguments (and produces a list)
 +            Note that the difference between the default and nargs=1 is that
 +            with the default, a single value will be produced, while with
 +            nargs=1, a list containing a single value will be produced.
 +
 +        - const -- The value to be produced if the option is specified and the
 +            option uses an action that takes no values.
 +
 +        - default -- The value to be produced if the option is not specified.
 +
 +        - type -- The type which the command-line arguments should be converted
 +            to, should be one of 'string', 'int', 'float', 'complex' or a
 +            callable object that accepts a single string argument. If None,
 +            'string' is assumed.
 +
 +        - choices -- A container of values that should be allowed. If not None,
 +            after a command-line argument has been converted to the appropriate
 +            type, an exception will be raised if it is not a member of this
 +            collection.
 +
 +        - required -- True if the action must always be specified at the
 +            command line. This is only meaningful for optional command-line
 +            arguments.
 +
 +        - help -- The help string describing the argument.
 +
 +        - metavar -- The name to be used for the option's argument with the
 +            help string. If None, the 'dest' value will be used as the name.
 +    """
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 nargs=None,
 +                 const=None,
 +                 default=None,
 +                 type=None,
 +                 choices=None,
 +                 required=False,
 +                 help=None,
 +                 metavar=None):
 +        self.option_strings = option_strings
 +        self.dest = dest
 +        self.nargs = nargs
 +        self.const = const
 +        self.default = default
 +        self.type = type
 +        self.choices = choices
 +        self.required = required
 +        self.help = help
 +        self.metavar = metavar
 +
 +    def _get_kwargs(self):
 +        names = [
 +            'option_strings',
 +            'dest',
 +            'nargs',
 +            'const',
 +            'default',
 +            'type',
 +            'choices',
 +            'help',
 +            'metavar',
 +        ]
 +        return [(name, getattr(self, name)) for name in names]
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        raise NotImplementedError(_('.__call__() not defined'))
 +
 +
 +class _StoreAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 nargs=None,
 +                 const=None,
 +                 default=None,
 +                 type=None,
 +                 choices=None,
 +                 required=False,
 +                 help=None,
 +                 metavar=None):
 +        if nargs == 0:
 +            raise ValueError('nargs for store actions must be > 0; if you '
 +                             'have nothing to store, actions such as store '
 +                             'true or store const may be more appropriate')
 +        if const is not None and nargs != OPTIONAL:
 +            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
 +        super(_StoreAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=nargs,
 +            const=const,
 +            default=default,
 +            type=type,
 +            choices=choices,
 +            required=required,
 +            help=help,
 +            metavar=metavar)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        setattr(namespace, self.dest, values)
 +
 +
 +class _StoreConstAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 const,
 +                 default=None,
 +                 required=False,
 +                 help=None,
 +                 metavar=None):
 +        super(_StoreConstAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=0,
 +            const=const,
 +            default=default,
 +            required=required,
 +            help=help)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        setattr(namespace, self.dest, self.const)
 +
 +
 +class _StoreTrueAction(_StoreConstAction):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 default=False,
 +                 required=False,
 +                 help=None):
 +        super(_StoreTrueAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            const=True,
 +            default=default,
 +            required=required,
 +            help=help)
 +
 +
 +class _StoreFalseAction(_StoreConstAction):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 default=True,
 +                 required=False,
 +                 help=None):
 +        super(_StoreFalseAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            const=False,
 +            default=default,
 +            required=required,
 +            help=help)
 +
 +
 +class _AppendAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 nargs=None,
 +                 const=None,
 +                 default=None,
 +                 type=None,
 +                 choices=None,
 +                 required=False,
 +                 help=None,
 +                 metavar=None):
 +        if nargs == 0:
 +            raise ValueError('nargs for append actions must be > 0; if arg '
 +                             'strings are not supplying the value to append, '
 +                             'the append const action may be more appropriate')
 +        if const is not None and nargs != OPTIONAL:
 +            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
 +        super(_AppendAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=nargs,
 +            const=const,
 +            default=default,
 +            type=type,
 +            choices=choices,
 +            required=required,
 +            help=help,
 +            metavar=metavar)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        items = _copy.copy(_ensure_value(namespace, self.dest, []))
 +        items.append(values)
 +        setattr(namespace, self.dest, items)
 +
 +
 +class _AppendConstAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 const,
 +                 default=None,
 +                 required=False,
 +                 help=None,
 +                 metavar=None):
 +        super(_AppendConstAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=0,
 +            const=const,
 +            default=default,
 +            required=required,
 +            help=help,
 +            metavar=metavar)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        items = _copy.copy(_ensure_value(namespace, self.dest, []))
 +        items.append(self.const)
 +        setattr(namespace, self.dest, items)
 +
 +
 +class _CountAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest,
 +                 default=None,
 +                 required=False,
 +                 help=None):
 +        super(_CountAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=0,
 +            default=default,
 +            required=required,
 +            help=help)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        new_count = _ensure_value(namespace, self.dest, 0) + 1
 +        setattr(namespace, self.dest, new_count)
 +
 +
 +class _HelpAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 dest=SUPPRESS,
 +                 default=SUPPRESS,
 +                 help=None):
 +        super(_HelpAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            default=default,
 +            nargs=0,
 +            help=help)
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        parser.print_help()
 +        parser.exit()
 +
 +
 +class _VersionAction(Action):
 +
 +    def __init__(self,
 +                 option_strings,
 +                 version=None,
 +                 dest=SUPPRESS,
 +                 default=SUPPRESS,
 +                 help="show program's version number and exit"):
 +        super(_VersionAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            default=default,
 +            nargs=0,
 +            help=help)
 +        self.version = version
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        version = self.version
 +        if version is None:
 +            version = parser.version
 +        formatter = parser._get_formatter()
 +        formatter.add_text(version)
 +        parser.exit(message=formatter.format_help())
 +
 +
 +class _SubParsersAction(Action):
 +
 +    class _ChoicesPseudoAction(Action):
 +
 +        def __init__(self, name, aliases, help):
 +            metavar = dest = name
 +            if aliases:
 +                metavar += ' (%s)' % ', '.join(aliases)
 +            sup = super(_SubParsersAction._ChoicesPseudoAction, self)
 +            sup.__init__(option_strings=[], dest=dest, help=help,
 +                        metavar=metavar)
 +
 +    def __init__(self,
 +                 option_strings,
 +                 prog,
 +                 parser_class,
 +                 dest=SUPPRESS,
 +                 help=None,
 +                 metavar=None):
 +
 +        self._prog_prefix = prog
 +        self._parser_class = parser_class
 +        self._name_parser_map = {}
 +        self._choices_actions = []
 +
 +        super(_SubParsersAction, self).__init__(
 +            option_strings=option_strings,
 +            dest=dest,
 +            nargs=PARSER,
 +            choices=self._name_parser_map,
 +            help=help,
 +            metavar=metavar)
 +
 +    def add_parser(self, name, **kwargs):
 +        # set prog from the existing prefix
 +        if kwargs.get('prog') is None:
 +            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
 +
 +        aliases = kwargs.pop('aliases', ())
 +
 +        # create a pseudo-action to hold the choice help
 +        if 'help' in kwargs:
 +            help = kwargs.pop('help')
 +            choice_action = self._ChoicesPseudoAction(name, aliases, help)
 +            self._choices_actions.append(choice_action)
 +
 +        # create the parser and add it to the map
 +        parser = self._parser_class(**kwargs)
 +        self._name_parser_map[name] = parser
 +
 +        # make parser available under aliases also
 +        for alias in aliases:
 +            self._name_parser_map[alias] = parser
 +
 +        return parser
 +
 +    def _get_subactions(self):
 +        return self._choices_actions
 +
 +    def __call__(self, parser, namespace, values, option_string=None):
 +        parser_name = values[0]
 +        arg_strings = values[1:]
 +
 +        # set the parser name if requested
 +        if self.dest is not SUPPRESS:
 +            setattr(namespace, self.dest, parser_name)
 +
 +        # select the parser
 +        try:
 +            parser = self._name_parser_map[parser_name]
 +        except KeyError:
 +            tup = parser_name, ', '.join(self._name_parser_map)
 +            msg = _('unknown parser %r (choices: %s)' % tup)
 +            raise ArgumentError(self, msg)
 +
 +        # parse all the remaining options into the namespace
 +        # store any unrecognized options on the object, so that the top
 +        # level parser can decide what to do with them
 +        namespace, arg_strings = parser.parse_known_args(arg_strings, namespace)
 +        if arg_strings:
 +            vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
 +            getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)
 +
 +
 +# ==============
 +# Type classes
 +# ==============
 +
 +class FileType(object):
 +    """Factory for creating file object types
 +
 +    Instances of FileType are typically passed as type= arguments to the
 +    ArgumentParser add_argument() method.
 +
 +    Keyword Arguments:
 +        - mode -- A string indicating how the file is to be opened. Accepts the
 +            same values as the builtin open() function.
 +        - bufsize -- The file's desired buffer size. Accepts the same values as
 +            the builtin open() function.
 +    """
 +
 +    def __init__(self, mode='r', bufsize=None):
 +        self._mode = mode
 +        self._bufsize = bufsize
 +
 +    def __call__(self, string):
 +        # the special argument "-" means sys.std{in,out}
 +        if string == '-':
 +            if 'r' in self._mode:
 +                return _sys.stdin
 +            elif 'w' in self._mode:
 +                return _sys.stdout
 +            else:
 +                msg = _('argument "-" with mode %r' % self._mode)
 +                raise ValueError(msg)
 +
 +        try:
 +            # all other arguments are used as file names
 +            if self._bufsize:
 +                return open(string, self._mode, self._bufsize)
 +            else:
 +                return open(string, self._mode)
 +        except IOError:
 +            err = _sys.exc_info()[1]
 +            message = _("can't open '%s': %s")
 +            raise ArgumentTypeError(message % (string, err))
 +
 +    def __repr__(self):
 +        args = [self._mode, self._bufsize]
 +        args_str = ', '.join([repr(arg) for arg in args if arg is not None])
 +        return '%s(%s)' % (type(self).__name__, args_str)
 +
 +# ===========================
 +# Optional and Positional Parsing
 +# ===========================
 +
 +class Namespace(_AttributeHolder):
 +    """Simple object for storing attributes.
 +
 +    Implements equality by attribute names and values, and provides a simple
 +    string representation.
 +    """
 +
 +    def __init__(self, **kwargs):
 +        for name in kwargs:
 +            setattr(self, name, kwargs[name])
 +
 +    __hash__ = None
 +
 +    def __eq__(self, other):
 +        return vars(self) == vars(other)
 +
 +    def __ne__(self, other):
 +        return not (self == other)
 +
 +    def __contains__(self, key):
 +        return key in self.__dict__
 +
 +
 +class _ActionsContainer(object):
 +
 +    def __init__(self,
 +                 description,
 +                 prefix_chars,
 +                 argument_default,
 +                 conflict_handler):
 +        super(_ActionsContainer, self).__init__()
 +
 +        self.description = description
 +        self.argument_default = argument_default
 +        self.prefix_chars = prefix_chars
 +        self.conflict_handler = conflict_handler
 +
 +        # set up registries
 +        self._registries = {}
 +
 +        # register actions
 +        self.register('action', None, _StoreAction)
 +        self.register('action', 'store', _StoreAction)
 +        self.register('action', 'store_const', _StoreConstAction)
 +        self.register('action', 'store_true', _StoreTrueAction)
 +        self.register('action', 'store_false', _StoreFalseAction)
 +        self.register('action', 'append', _AppendAction)
 +        self.register('action', 'append_const', _AppendConstAction)
 +        self.register('action', 'count', _CountAction)
 +        self.register('action', 'help', _HelpAction)
 +        self.register('action', 'version', _VersionAction)
 +        self.register('action', 'parsers', _SubParsersAction)
 +
 +        # raise an exception if the conflict handler is invalid
 +        self._get_handler()
 +
 +        # action storage
 +        self._actions = []
 +        self._option_string_actions = {}
 +
 +        # groups
 +        self._action_groups = []
 +        self._mutually_exclusive_groups = []
 +
 +        # defaults storage
 +        self._defaults = {}
 +
 +        # determines whether an "option" looks like a negative number
 +        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
 +
 +        # whether or not there are any optionals that look like negative
 +        # numbers -- uses a list so it can be shared and edited
 +        self._has_negative_number_optionals = []
 +
 +    # ====================
 +    # Registration methods
 +    # ====================
 +    def register(self, registry_name, value, object):
 +        registry = self._registries.setdefault(registry_name, {})
 +        registry[value] = object
 +
 +    def _registry_get(self, registry_name, value, default=None):
 +        return self._registries[registry_name].get(value, default)
 +
 +    # ==================================
 +    # Namespace default accessor methods
 +    # ==================================
 +    def set_defaults(self, **kwargs):
 +        self._defaults.update(kwargs)
 +
 +        # if these defaults match any existing arguments, replace
 +        # the previous default on the object with the new one
 +        for action in self._actions:
 +            if action.dest in kwargs:
 +                action.default = kwargs[action.dest]
 +
 +    def get_default(self, dest):
 +        for action in self._actions:
 +            if action.dest == dest and action.default is not None:
 +                return action.default
 +        return self._defaults.get(dest, None)
 +
 +
 +    # =======================
 +    # Adding argument actions
 +    # =======================
 +    def add_argument(self, *args, **kwargs):
 +        """
 +        add_argument(dest, ..., name=value, ...)
 +        add_argument(option_string, option_string, ..., name=value, ...)
 +        """
 +
 +        # if no positional args are supplied or only one is supplied and
 +        # it doesn't look like an option string, parse a positional
 +        # argument
 +        chars = self.prefix_chars
 +        if not args or len(args) == 1 and args[0][0] not in chars:
 +            if args and 'dest' in kwargs:
 +                raise ValueError('dest supplied twice for positional argument')
 +            kwargs = self._get_positional_kwargs(*args, **kwargs)
 +
 +        # otherwise, we're adding an optional argument
 +        else:
 +            kwargs = self._get_optional_kwargs(*args, **kwargs)
 +
 +        # if no default was supplied, use the parser-level default
 +        if 'default' not in kwargs:
 +            dest = kwargs['dest']
 +            if dest in self._defaults:
 +                kwargs['default'] = self._defaults[dest]
 +            elif self.argument_default is not None:
 +                kwargs['default'] = self.argument_default
 +
 +        # create the action object, and add it to the parser
 +        action_class = self._pop_action_class(kwargs)
 +        if not _callable(action_class):
 +            raise ValueError('unknown action "%s"' % action_class)
 +        action = action_class(**kwargs)
 +
 +        # raise an error if the action type is not callable
 +        type_func = self._registry_get('type', action.type, action.type)
 +        if not _callable(type_func):
 +            raise ValueError('%r is not callable' % type_func)
 +
 +        return self._add_action(action)
 +
 +    def add_argument_group(self, *args, **kwargs):
 +        group = _ArgumentGroup(self, *args, **kwargs)
 +        self._action_groups.append(group)
 +        return group
 +
 +    def add_mutually_exclusive_group(self, **kwargs):
 +        group = _MutuallyExclusiveGroup(self, **kwargs)
 +        self._mutually_exclusive_groups.append(group)
 +        return group
 +
 +    def _add_action(self, action):
 +        # resolve any conflicts
 +        self._check_conflict(action)
 +
 +        # add to actions list
 +        self._actions.append(action)
 +        action.container = self
 +
 +        # index the action by any option strings it has
 +        for option_string in action.option_strings:
 +            self._option_string_actions[option_string] = action
 +
 +        # set the flag if any option strings look like negative numbers
 +        for option_string in action.option_strings:
 +            if self._negative_number_matcher.match(option_string):
 +                if not self._has_negative_number_optionals:
 +                    self._has_negative_number_optionals.append(True)
 +
 +        # return the created action
 +        return action
 +
 +    def _remove_action(self, action):
 +        self._actions.remove(action)
 +
 +    def _add_container_actions(self, container):
 +        # collect groups by titles
 +        title_group_map = {}
 +        for group in self._action_groups:
 +            if group.title in title_group_map:
 +                msg = _('cannot merge actions - two groups are named %r')
 +                raise ValueError(msg % (group.title))
 +            title_group_map[group.title] = group
 +
 +        # map each action to its group
 +        group_map = {}
 +        for group in container._action_groups:
 +
 +            # if a group with the title exists, use that, otherwise
 +            # create a new group matching the container's group
 +            if group.title not in title_group_map:
 +                title_group_map[group.title] = self.add_argument_group(
 +                    title=group.title,
 +                    description=group.description,
 +                    conflict_handler=group.conflict_handler)
 +
 +            # map the actions to their new group
 +            for action in group._group_actions:
 +                group_map[action] = title_group_map[group.title]
 +
 +        # add container's mutually exclusive groups
 +        # NOTE: if add_mutually_exclusive_group ever gains title= and
 +        # description= then this code will need to be expanded as above
 +        for group in container._mutually_exclusive_groups:
 +            mutex_group = self.add_mutually_exclusive_group(
 +                required=group.required)
 +
 +            # map the actions to their new mutex group
 +            for action in group._group_actions:
 +                group_map[action] = mutex_group
 +
 +        # add all actions to this container or their group
 +        for action in container._actions:
 +            group_map.get(action, self)._add_action(action)
 +
 +    def _get_positional_kwargs(self, dest, **kwargs):
 +        # make sure required is not specified
 +        if 'required' in kwargs:
 +            msg = _("'required' is an invalid argument for positionals")
 +            raise TypeError(msg)
 +
 +        # mark positional arguments as required if at least one is
 +        # always required
 +        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
 +            kwargs['required'] = True
 +        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
 +            kwargs['required'] = True
 +
 +        # return the keyword arguments with no option strings
 +        return dict(kwargs, dest=dest, option_strings=[])
 +
 +    def _get_optional_kwargs(self, *args, **kwargs):
 +        # determine short and long option strings
 +        option_strings = []
 +        long_option_strings = []
 +        for option_string in args:
 +            # error on strings that don't start with an appropriate prefix
 +            if not option_string[0] in self.prefix_chars:
 +                msg = _('invalid option string %r: '
 +                        'must start with a character %r')
 +                tup = option_string, self.prefix_chars
 +                raise ValueError(msg % tup)
 +
 +            # strings starting with two prefix characters are long options
 +            option_strings.append(option_string)
 +            if option_string[0] in self.prefix_chars:
 +                if len(option_string) > 1:
 +                    if option_string[1] in self.prefix_chars:
 +                        long_option_strings.append(option_string)
 +
 +        # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
 +        dest = kwargs.pop('dest', None)
 +        if dest is None:
 +            if long_option_strings:
 +                dest_option_string = long_option_strings[0]
 +            else:
 +                dest_option_string = option_strings[0]
 +            dest = dest_option_string.lstrip(self.prefix_chars)
 +            if not dest:
 +                msg = _('dest= is required for options like %r')
 +                raise ValueError(msg % option_string)
 +            dest = dest.replace('-', '_')
 +
 +        # return the updated keyword arguments
 +        return dict(kwargs, dest=dest, option_strings=option_strings)
 +
 +    def _pop_action_class(self, kwargs, default=None):
 +        action = kwargs.pop('action', default)
 +        return self._registry_get('action', action, action)
 +
 +    def _get_handler(self):
 +        # determine function from conflict handler string
 +        handler_func_name = '_handle_conflict_%s' % self.conflict_handler
 +        try:
 +            return getattr(self, handler_func_name)
 +        except AttributeError:
 +            msg = _('invalid conflict_resolution value: %r')
 +            raise ValueError(msg % self.conflict_handler)
 +
 +    def _check_conflict(self, action):
 +
 +        # find all options that conflict with this option
 +        confl_optionals = []
 +        for option_string in action.option_strings:
 +            if option_string in self._option_string_actions:
 +                confl_optional = self._option_string_actions[option_string]
 +                confl_optionals.append((option_string, confl_optional))
 +
 +        # resolve any conflicts
 +        if confl_optionals:
 +            conflict_handler = self._get_handler()
 +            conflict_handler(action, confl_optionals)
 +
 +    def _handle_conflict_error(self, action, conflicting_actions):
 +        message = _('conflicting option string(s): %s')
 +        conflict_string = ', '.join([option_string
 +                                     for option_string, action
 +                                     in conflicting_actions])
 +        raise ArgumentError(action, message % conflict_string)
 +
 +    def _handle_conflict_resolve(self, action, conflicting_actions):
 +
 +        # remove all conflicting options
 +        for option_string, action in conflicting_actions:
 +
 +            # remove the conflicting option
 +            action.option_strings.remove(option_string)
 +            self._option_string_actions.pop(option_string, None)
 +
 +            # if the option now has no option string, remove it from the
 +            # container holding it
 +            if not action.option_strings:
 +                action.container._remove_action(action)
 +
 +
 +class _ArgumentGroup(_ActionsContainer):
 +
 +    def __init__(self, container, title=None, description=None, **kwargs):
 +        # add any missing keyword arguments by checking the container
 +        update = kwargs.setdefault
 +        update('conflict_handler', container.conflict_handler)
 +        update('prefix_chars', container.prefix_chars)
 +        update('argument_default', container.argument_default)
 +        super_init = super(_ArgumentGroup, self).__init__
 +        super_init(description=description, **kwargs)
 +
 +        # group attributes
 +        self.title = title
 +        self._group_actions = []
 +
 +        # share most attributes with the container
 +        self._registries = container._registries
 +        self._actions = container._actions
 +        self._option_string_actions = container._option_string_actions
 +        self._defaults = container._defaults
 +        self._has_negative_number_optionals = \
 +            container._has_negative_number_optionals
 +
 +    def _add_action(self, action):
 +        action = super(_ArgumentGroup, self)._add_action(action)
 +        self._group_actions.append(action)
 +        return action
 +
 +    def _remove_action(self, action):
 +        super(_ArgumentGroup, self)._remove_action(action)
 +        self._group_actions.remove(action)
 +
 +
 +class _MutuallyExclusiveGroup(_ArgumentGroup):
 +
 +    def __init__(self, container, required=False):
 +        super(_MutuallyExclusiveGroup, self).__init__(container)
 +        self.required = required
 +        self._container = container
 +
 +    def _add_action(self, action):
 +        if action.required:
 +            msg = _('mutually exclusive arguments must be optional')
 +            raise ValueError(msg)
 +        action = self._container._add_action(action)
 +        self._group_actions.append(action)
 +        return action
 +
 +    def _remove_action(self, action):
 +        self._container._remove_action(action)
 +        self._group_actions.remove(action)
 +
 +
 +class ArgumentParser(_AttributeHolder, _ActionsContainer):
 +    """Object for parsing command line strings into Python objects.
 +
 +    Keyword Arguments:
 +        - prog -- The name of the program (default: sys.argv[0])
 +        - usage -- A usage message (default: auto-generated from arguments)
 +        - description -- A description of what the program does
 +        - epilog -- Text following the argument descriptions
 +        - parents -- Parsers whose arguments should be copied into this one
 +        - formatter_class -- HelpFormatter class for printing help messages
 +        - prefix_chars -- Characters that prefix optional arguments
 +        - fromfile_prefix_chars -- Characters that prefix files containing
 +            additional arguments
 +        - argument_default -- The default value for all arguments
 +        - conflict_handler -- String indicating how to handle conflicts
 +        - add_help -- Add a -h/-help option
 +    """
 +
 +    def __init__(self,
 +                 prog=None,
 +                 usage=None,
 +                 description=None,
 +                 epilog=None,
 +                 version=None,
 +                 parents=[],
 +                 formatter_class=HelpFormatter,
 +                 prefix_chars='-',
 +                 fromfile_prefix_chars=None,
 +                 argument_default=None,
 +                 conflict_handler='error',
 +                 add_help=True):
 +
 +        if version is not None:
 +            import warnings
 +            warnings.warn(
 +                """The "version" argument to ArgumentParser is deprecated. """
 +                """Please use """
 +                """"add_argument(..., action='version', version="N", ...)" """
 +                """instead""", DeprecationWarning)
 +
 +        superinit = super(ArgumentParser, self).__init__
 +        superinit(description=description,
 +                  prefix_chars=prefix_chars,
 +                  argument_default=argument_default,
 +                  conflict_handler=conflict_handler)
 +
 +        # default setting for prog
 +        if prog is None:
 +            prog = _os.path.basename(_sys.argv[0])
 +
 +        self.prog = prog
 +        self.usage = usage
 +        self.epilog = epilog
 +        self.version = version
 +        self.formatter_class = formatter_class
 +        self.fromfile_prefix_chars = fromfile_prefix_chars
 +        self.add_help = add_help
 +
 +        add_group = self.add_argument_group
 +        self._positionals = add_group(_('positional arguments'))
 +        self._optionals = add_group(_('optional arguments'))
 +        self._subparsers = None
 +
 +        # register types
 +        def identity(string):
 +            return string
 +        self.register('type', None, identity)
 +
 +        # add help and version arguments if necessary
 +        # (using explicit default to override global argument_default)
 +        if '-' in prefix_chars:
 +            default_prefix = '-'
 +        else:
 +            default_prefix = prefix_chars[0]
 +        if self.add_help:
 +            self.add_argument(
 +                default_prefix+'h', default_prefix*2+'help',
 +                action='help', default=SUPPRESS,
 +                help=_('show this help message and exit'))
 +        if self.version:
 +            self.add_argument(
 +                default_prefix+'v', default_prefix*2+'version',
 +                action='version', default=SUPPRESS,
 +                version=self.version,
 +                help=_("show program's version number and exit"))
 +
 +        # add parent arguments and defaults
 +        for parent in parents:
 +            self._add_container_actions(parent)
 +            try:
 +                defaults = parent._defaults
 +            except AttributeError:
 +                pass
 +            else:
 +                self._defaults.update(defaults)
 +
 +    # =======================
 +    # Pretty __repr__ methods
 +    # =======================
 +    def _get_kwargs(self):
 +        names = [
 +            'prog',
 +            'usage',
 +            'description',
 +            'version',
 +            'formatter_class',
 +            'conflict_handler',
 +            'add_help',
 +        ]
 +        return [(name, getattr(self, name)) for name in names]
 +
 +    # ==================================
 +    # Optional/Positional adding methods
 +    # ==================================
 +    def add_subparsers(self, **kwargs):
 +        if self._subparsers is not None:
 +            self.error(_('cannot have multiple subparser arguments'))
 +
 +        # add the parser class to the arguments if it's not present
 +        kwargs.setdefault('parser_class', type(self))
 +
 +        if 'title' in kwargs or 'description' in kwargs:
 +            title = _(kwargs.pop('title', 'subcommands'))
 +            description = _(kwargs.pop('description', None))
 +            self._subparsers = self.add_argument_group(title, description)
 +        else:
 +            self._subparsers = self._positionals
 +
 +        # prog defaults to the usage message of this parser, skipping
 +        # optional arguments and with no "usage:" prefix
 +        if kwargs.get('prog') is None:
 +            formatter = self._get_formatter()
 +            positionals = self._get_positional_actions()
 +            groups = self._mutually_exclusive_groups
 +            formatter.add_usage(self.usage, positionals, groups, '')
 +            kwargs['prog'] = formatter.format_help().strip()
 +
 +        # create the parsers action and add it to the positionals list
 +        parsers_class = self._pop_action_class(kwargs, 'parsers')
 +        action = parsers_class(option_strings=[], **kwargs)
 +        self._subparsers._add_action(action)
 +
 +        # return the created parsers action
 +        return action
 +
 +    def _add_action(self, action):
 +        if action.option_strings:
 +            self._optionals._add_action(action)
 +        else:
 +            self._positionals._add_action(action)
 +        return action
 +
 +    def _get_optional_actions(self):
 +        return [action
 +                for action in self._actions
 +                if action.option_strings]
 +
 +    def _get_positional_actions(self):
 +        return [action
 +                for action in self._actions
 +                if not action.option_strings]
 +
 +    # =====================================
 +    # Command line argument parsing methods
 +    # =====================================
 +    def parse_args(self, args=None, namespace=None):
 +        args, argv = self.parse_known_args(args, namespace)
 +        if argv:
 +            msg = _('unrecognized arguments: %s')
 +            self.error(msg % ' '.join(argv))
 +        return args
 +
 +    def parse_known_args(self, args=None, namespace=None):
 +        # args default to the system args
 +        if args is None:
 +            args = _sys.argv[1:]
 +
 +        # default Namespace built from parser defaults
 +        if namespace is None:
 +            namespace = Namespace()
 +
 +        # add any action defaults that aren't present
 +        for action in self._actions:
 +            if action.dest is not SUPPRESS:
 +                if not hasattr(namespace, action.dest):
 +                    if action.default is not SUPPRESS:
 +                        setattr(namespace, action.dest, action.default)
 +
 +        # add any parser defaults that aren't present
 +        for dest in self._defaults:
 +            if not hasattr(namespace, dest):
 +                setattr(namespace, dest, self._defaults[dest])
 +
 +        # parse the arguments and exit if there are any errors
 +        try:
 +            namespace, args = self._parse_known_args(args, namespace)
 +            if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR):
 +                args.extend(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))
 +                delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
 +            return namespace, args
 +        except ArgumentError:
 +            err = _sys.exc_info()[1]
 +            self.error(str(err))
 +
 +    def _parse_known_args(self, arg_strings, namespace):
 +        # replace arg strings that are file references
 +        if self.fromfile_prefix_chars is not None:
 +            arg_strings = self._read_args_from_files(arg_strings)
 +
 +        # map all mutually exclusive arguments to the other arguments
 +        # they can't occur with
 +        action_conflicts = {}
 +        for mutex_group in self._mutually_exclusive_groups:
 +            group_actions = mutex_group._group_actions
 +            for i, mutex_action in enumerate(mutex_group._group_actions):
 +                conflicts = action_conflicts.setdefault(mutex_action, [])
 +                conflicts.extend(group_actions[:i])
 +                conflicts.extend(group_actions[i + 1:])
 +
 +        # find all option indices, and determine the arg_string_pattern
 +        # which has an 'O' if there is an option at an index,
 +        # an 'A' if there is an argument, or a '-' if there is a '--'
 +        option_string_indices = {}
 +        arg_string_pattern_parts = []
 +        arg_strings_iter = iter(arg_strings)
 +        for i, arg_string in enumerate(arg_strings_iter):
 +
 +            # all args after -- are non-options
 +            if arg_string == '--':
 +                arg_string_pattern_parts.append('-')
 +                for arg_string in arg_strings_iter:
 +                    arg_string_pattern_parts.append('A')
 +
 +            # otherwise, add the arg to the arg strings
 +            # and note the index if it was an option
 +            else:
 +                option_tuple = self._parse_optional(arg_string)
 +                if option_tuple is None:
 +                    pattern = 'A'
 +                else:
 +                    option_string_indices[i] = option_tuple
 +                    pattern = 'O'
 +                arg_string_pattern_parts.append(pattern)
 +
 +        # join the pieces together to form the pattern
 +        arg_strings_pattern = ''.join(arg_string_pattern_parts)
 +
 +        # converts arg strings to the appropriate and then takes the action
 +        seen_actions = set()
 +        seen_non_default_actions = set()
 +
 +        def take_action(action, argument_strings, option_string=None):
 +            seen_actions.add(action)
 +            argument_values = self._get_values(action, argument_strings)
 +
 +            # error if this argument is not allowed with other previously
 +            # seen arguments, assuming that actions that use the default
 +            # value don't really count as "present"
 +            if argument_values is not action.default:
 +                seen_non_default_actions.add(action)
 +                for conflict_action in action_conflicts.get(action, []):
 +                    if conflict_action in seen_non_default_actions:
 +                        msg = _('not allowed with argument %s')
 +                        action_name = _get_action_name(conflict_action)
 +                        raise ArgumentError(action, msg % action_name)
 +
 +            # take the action if we didn't receive a SUPPRESS value
 +            # (e.g. from a default)
 +            if argument_values is not SUPPRESS:
 +                action(self, namespace, argument_values, option_string)
 +
 +        # function to convert arg_strings into an optional action
 +        def consume_optional(start_index):
 +
 +            # get the optional identified at this index
 +            option_tuple = option_string_indices[start_index]
 +            action, option_string, explicit_arg = option_tuple
 +
 +            # identify additional optionals in the same arg string
 +            # (e.g. -xyz is the same as -x -y -z if no args are required)
 +            match_argument = self._match_argument
 +            action_tuples = []
 +            while True:
 +
 +                # if we found no optional action, skip it
 +                if action is None:
 +                    extras.append(arg_strings[start_index])
 +                    return start_index + 1
 +
 +                # if there is an explicit argument, try to match the
 +                # optional's string arguments to only this
 +                if explicit_arg is not None:
 +                    arg_count = match_argument(action, 'A')
 +
 +                    # if the action is a single-dash option and takes no
 +                    # arguments, try to parse more single-dash options out
 +                    # of the tail of the option string
 +                    chars = self.prefix_chars
 +                    if arg_count == 0 and option_string[1] not in chars:
 +                        action_tuples.append((action, [], option_string))
 +                        char = option_string[0]
 +                        option_string = char + explicit_arg[0]
 +                        new_explicit_arg = explicit_arg[1:] or None
 +                        optionals_map = self._option_string_actions
 +                        if option_string in optionals_map:
 +                            action = optionals_map[option_string]
 +                            explicit_arg = new_explicit_arg
 +                        else:
 +                            msg = _('ignored explicit argument %r')
 +                            raise ArgumentError(action, msg % explicit_arg)
 +
 +                    # if the action expect exactly one argument, we've
 +                    # successfully matched the option; exit the loop
 +                    elif arg_count == 1:
 +                        stop = start_index + 1
 +                        args = [explicit_arg]
 +                        action_tuples.append((action, args, option_string))
 +                        break
 +
 +                    # error if a double-dash option did not use the
 +                    # explicit argument
 +                    else:
 +                        msg = _('ignored explicit argument %r')
 +                        raise ArgumentError(action, msg % explicit_arg)
 +
 +                # if there is no explicit argument, try to match the
 +                # optional's string arguments with the following strings
 +                # if successful, exit the loop
 +                else:
 +                    start = start_index + 1
 +                    selected_patterns = arg_strings_pattern[start:]
 +                    arg_count = match_argument(action, selected_patterns)
 +                    stop = start + arg_count
 +                    args = arg_strings[start:stop]
 +                    action_tuples.append((action, args, option_string))
 +                    break
 +
 +            # add the Optional to the list and return the index at which
 +            # the Optional's string args stopped
 +            assert action_tuples
 +            for action, args, option_string in action_tuples:
 +                take_action(action, args, option_string)
 +            return stop
 +
 +        # the list of Positionals left to be parsed; this is modified
 +        # by consume_positionals()
 +        positionals = self._get_positional_actions()
 +
 +        # function to convert arg_strings into positional actions
 +        def consume_positionals(start_index):
 +            # match as many Positionals as possible
 +            match_partial = self._match_arguments_partial
 +            selected_pattern = arg_strings_pattern[start_index:]
 +            arg_counts = match_partial(positionals, selected_pattern)
 +
 +            # slice off the appropriate arg strings for each Positional
 +            # and add the Positional and its args to the list
 +            for action, arg_count in zip(positionals, arg_counts):
 +                args = arg_strings[start_index: start_index + arg_count]
 +                start_index += arg_count
 +                take_action(action, args)
 +
 +            # slice off the Positionals that we just parsed and return the
 +            # index at which the Positionals' string args stopped
 +            positionals[:] = positionals[len(arg_counts):]
 +            return start_index
 +
 +        # consume Positionals and Optionals alternately, until we have
 +        # passed the last option string
 +        extras = []
 +        start_index = 0
 +        if option_string_indices:
 +            max_option_string_index = max(option_string_indices)
 +        else:
 +            max_option_string_index = -1
 +        while start_index <= max_option_string_index:
 +
 +            # consume any Positionals preceding the next option
 +            next_option_string_index = min([
 +                index
 +                for index in option_string_indices
 +                if index >= start_index])
 +            if start_index != next_option_string_index:
 +                positionals_end_index = consume_positionals(start_index)
 +
 +                # only try to parse the next optional if we didn't consume
 +                # the option string during the positionals parsing
 +                if positionals_end_index > start_index:
 +                    start_index = positionals_end_index
 +                    continue
 +                else:
 +                    start_index = positionals_end_index
 +
 +            # if we consumed all the positionals we could and we're not
 +            # at the index of an option string, there were extra arguments
 +            if start_index not in option_string_indices:
 +                strings = arg_strings[start_index:next_option_string_index]
 +                extras.extend(strings)
 +                start_index = next_option_string_index
 +
 +            # consume the next optional and any arguments for it
 +            start_index = consume_optional(start_index)
 +
 +        # consume any positionals following the last Optional
 +        stop_index = consume_positionals(start_index)
 +
 +        # if we didn't consume all the argument strings, there were extras
 +        extras.extend(arg_strings[stop_index:])
 +
 +        # if we didn't use all the Positional objects, there were too few
 +        # arg strings supplied.
 +        if positionals:
 +            self.error(_('too few arguments'))
 +
 +        # make sure all required actions were present, and convert defaults.
 +        for action in self._actions:
 +            if action not in seen_actions:
 +                if action.required:
 +                    name = _get_action_name(action)
 +                    self.error(_('argument %s is required') % name)
 +                else:
 +                    # Convert action default now instead of doing it before
 +                    # parsing arguments to avoid calling convert functions
 +                    # twice (which may fail) if the argument was given, but
 +                    # only if it was defined already in the namespace
 +                    if (action.default is not None and
 +                            isinstance(action.default, basestring) and
 +                            hasattr(namespace, action.dest) and
 +                            action.default is getattr(namespace, action.dest)):
 +                        setattr(namespace, action.dest,
 +                                self._get_value(action, action.default))
 +
 +        # make sure all required groups had one option present
 +        for group in self._mutually_exclusive_groups:
 +            if group.required:
 +                for action in group._group_actions:
 +                    if action in seen_non_default_actions:
 +                        break
 +
 +                # if no actions were used, report the error
 +                else:
 +                    names = [_get_action_name(action)
 +                             for action in group._group_actions
 +                             if action.help is not SUPPRESS]
 +                    msg = _('one of the arguments %s is required')
 +                    self.error(msg % ' '.join(names))
 +
 +        # return the updated namespace and the extra arguments
 +        return namespace, extras
 +
 +    def _read_args_from_files(self, arg_strings):
 +        # expand arguments referencing files
 +        new_arg_strings = []
 +        for arg_string in arg_strings:
 +
 +            # for regular arguments, just add them back into the list
 +            if arg_string[0] not in self.fromfile_prefix_chars:
 +                new_arg_strings.append(arg_string)
 +
 +            # replace arguments referencing files with the file content
 +            else:
 +                try:
 +                    args_file = open(arg_string[1:])
 +                    try:
 +                        arg_strings = []
 +                        for arg_line in args_file.read().splitlines():
 +                            for arg in self.convert_arg_line_to_args(arg_line):
 +                                arg_strings.append(arg)
 +                        arg_strings = self._read_args_from_files(arg_strings)
 +                        new_arg_strings.extend(arg_strings)
 +                    finally:
 +                        args_file.close()
 +                except IOError:
 +                    err = _sys.exc_info()[1]
 +                    self.error(str(err))
 +
 +        # return the modified argument list
 +        return new_arg_strings
 +
 +    def convert_arg_line_to_args(self, arg_line):
 +        return [arg_line]
 +
 +    def _match_argument(self, action, arg_strings_pattern):
 +        # match the pattern for this action to the arg strings
 +        nargs_pattern = self._get_nargs_pattern(action)
 +        match = _re.match(nargs_pattern, arg_strings_pattern)
 +
 +        # raise an exception if we weren't able to find a match
 +        if match is None:
 +            nargs_errors = {
 +                None: _('expected one argument'),
 +                OPTIONAL: _('expected at most one argument'),
 +                ONE_OR_MORE: _('expected at least one argument'),
 +            }
 +            default = _('expected %s argument(s)') % action.nargs
 +            msg = nargs_errors.get(action.nargs, default)
 +            raise ArgumentError(action, msg)
 +
 +        # return the number of arguments matched
 +        return len(match.group(1))
 +
 +    def _match_arguments_partial(self, actions, arg_strings_pattern):
 +        # progressively shorten the actions list by slicing off the
 +        # final actions until we find a match
 +        result = []
 +        for i in range(len(actions), 0, -1):
 +            actions_slice = actions[:i]
 +            pattern = ''.join([self._get_nargs_pattern(action)
 +                               for action in actions_slice])
 +            match = _re.match(pattern, arg_strings_pattern)
 +            if match is not None:
 +                result.extend([len(string) for string in match.groups()])
 +                break
 +
 +        # return the list of arg string counts
 +        return result
 +
 +    def _parse_optional(self, arg_string):
 +        # if it's an empty string, it was meant to be a positional
 +        if not arg_string:
 +            return None
 +
 +        # if it doesn't start with a prefix, it was meant to be positional
 +        if not arg_string[0] in self.prefix_chars:
 +            return None
 +
 +        # if the option string is present in the parser, return the action
 +        if arg_string in self._option_string_actions:
 +            action = self._option_string_actions[arg_string]
 +            return action, arg_string, None
 +
 +        # if it's just a single character, it was meant to be positional
 +        if len(arg_string) == 1:
 +            return None
 +
 +        # if the option string before the "=" is present, return the action
 +        if '=' in arg_string:
 +            option_string, explicit_arg = arg_string.split('=', 1)
 +            if option_string in self._option_string_actions:
 +                action = self._option_string_actions[option_string]
 +                return action, option_string, explicit_arg
 +
 +        # search through all possible prefixes of the option string
 +        # and all actions in the parser for possible interpretations
 +        option_tuples = self._get_option_tuples(arg_string)
 +
 +        # if multiple actions match, the option string was ambiguous
 +        if len(option_tuples) > 1:
 +            options = ', '.join([option_string
 +                for action, option_string, explicit_arg in option_tuples])
 +            tup = arg_string, options
 +            self.error(_('ambiguous option: %s could match %s') % tup)
 +
 +        # if exactly one action matched, this segmentation is good,
 +        # so return the parsed action
 +        elif len(option_tuples) == 1:
 +            option_tuple, = option_tuples
 +            return option_tuple
 +
 +        # if it was not found as an option, but it looks like a negative
 +        # number, it was meant to be positional
 +        # unless there are negative-number-like options
 +        if self._negative_number_matcher.match(arg_string):
 +            if not self._has_negative_number_optionals:
 +                return None
 +
 +        # if it contains a space, it was meant to be a positional
 +        if ' ' in arg_string:
 +            return None
 +
 +        # it was meant to be an optional but there is no such option
 +        # in this parser (though it might be a valid option in a subparser)
 +        return None, arg_string, None
 +
 +    def _get_option_tuples(self, option_string):
 +        result = []
 +
 +        # option strings starting with two prefix characters are only
 +        # split at the '='
 +        chars = self.prefix_chars
 +        if option_string[0] in chars and option_string[1] in chars:
 +            if '=' in option_string:
 +                option_prefix, explicit_arg = option_string.split('=', 1)
 +            else:
 +                option_prefix = option_string
 +                explicit_arg = None
 +            for option_string in self._option_string_actions:
 +                if option_string.startswith(option_prefix):
 +                    action = self._option_string_actions[option_string]
 +                    tup = action, option_string, explicit_arg
 +                    result.append(tup)
 +
 +        # single character options can be concatenated with their arguments
 +        # but multiple character options always have to have their argument
 +        # separate
 +        elif option_string[0] in chars and option_string[1] not in chars:
 +            option_prefix = option_string
 +            explicit_arg = None
 +            short_option_prefix = option_string[:2]
 +            short_explicit_arg = option_string[2:]
 +
 +            for option_string in self._option_string_actions:
 +                if option_string == short_option_prefix:
 +                    action = self._option_string_actions[option_string]
 +                    tup = action, option_string, short_explicit_arg
 +                    result.append(tup)
 +                elif option_string.startswith(option_prefix):
 +                    action = self._option_string_actions[option_string]
 +                    tup = action, option_string, explicit_arg
 +                    result.append(tup)
 +
 +        # shouldn't ever get here
 +        else:
 +            self.error(_('unexpected option string: %s') % option_string)
 +
 +        # return the collected option tuples
 +        return result
 +
 +    def _get_nargs_pattern(self, action):
 +        # in all examples below, we have to allow for '--' args
 +        # which are represented as '-' in the pattern
 +        nargs = action.nargs
 +
 +        # the default (None) is assumed to be a single argument
 +        if nargs is None:
 +            nargs_pattern = '(-*A-*)'
 +
 +        # allow zero or one arguments
 +        elif nargs == OPTIONAL:
 +            nargs_pattern = '(-*A?-*)'
 +
 +        # allow zero or more arguments
 +        elif nargs == ZERO_OR_MORE:
 +            nargs_pattern = '(-*[A-]*)'
 +
 +        # allow one or more arguments
 +        elif nargs == ONE_OR_MORE:
 +            nargs_pattern = '(-*A[A-]*)'
 +
 +        # allow any number of options or arguments
 +        elif nargs == REMAINDER:
 +            nargs_pattern = '([-AO]*)'
 +
 +        # allow one argument followed by any number of options or arguments
 +        elif nargs == PARSER:
 +            nargs_pattern = '(-*A[-AO]*)'
 +
 +        # all others should be integers
 +        else:
 +            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
 +
 +        # if this is an optional action, -- is not allowed
 +        if action.option_strings:
 +            nargs_pattern = nargs_pattern.replace('-*', '')
 +            nargs_pattern = nargs_pattern.replace('-', '')
 +
 +        # return the pattern
 +        return nargs_pattern
 +
 +    # ========================
 +    # Value conversion methods
 +    # ========================
 +    def _get_values(self, action, arg_strings):
 +        # for everything but PARSER args, strip out '--'
 +        if action.nargs not in [PARSER, REMAINDER]:
 +            arg_strings = [s for s in arg_strings if s != '--']
 +
 +        # optional argument produces a default when not present
 +        if not arg_strings and action.nargs == OPTIONAL:
 +            if action.option_strings:
 +                value = action.const
 +            else:
 +                value = action.default
 +            if isinstance(value, basestring):
 +                value = self._get_value(action, value)
 +                self._check_value(action, value)
 +
 +        # when nargs='*' on a positional, if there were no command-line
 +        # args, use the default if it is anything other than None
 +        elif (not arg_strings and action.nargs == ZERO_OR_MORE and
 +              not action.option_strings):
 +            if action.default is not None:
 +                value = action.default
 +            else:
 +                value = arg_strings
 +            self._check_value(action, value)
 +
 +        # single argument or optional argument produces a single value
 +        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
 +            arg_string, = arg_strings
 +            value = self._get_value(action, arg_string)
 +            self._check_value(action, value)
 +
 +        # REMAINDER arguments convert all values, checking none
 +        elif action.nargs == REMAINDER:
 +            value = [self._get_value(action, v) for v in arg_strings]
 +
 +        # PARSER arguments convert all values, but check only the first
 +        elif action.nargs == PARSER:
 +            value = [self._get_value(action, v) for v in arg_strings]
 +            self._check_value(action, value[0])
 +
 +        # all other types of nargs produce a list
 +        else:
 +            value = [self._get_value(action, v) for v in arg_strings]
 +            for v in value:
 +                self._check_value(action, v)
 +
 +        # return the converted value
 +        return value
 +
 +    def _get_value(self, action, arg_string):
 +        type_func = self._registry_get('type', action.type, action.type)
 +        if not _callable(type_func):
 +            msg = _('%r is not callable')
 +            raise ArgumentError(action, msg % type_func)
 +
 +        # convert the value to the appropriate type
 +        try:
 +            result = type_func(arg_string)
 +
 +        # ArgumentTypeErrors indicate errors
 +        except ArgumentTypeError:
 +            name = getattr(action.type, '__name__', repr(action.type))
 +            msg = str(_sys.exc_info()[1])
 +            raise ArgumentError(action, msg)
 +
 +        # TypeErrors or ValueErrors also indicate errors
 +        except (TypeError, ValueError):
 +            name = getattr(action.type, '__name__', repr(action.type))
 +            msg = _('invalid %s value: %r')
 +            raise ArgumentError(action, msg % (name, arg_string))
 +
 +        # return the converted value
 +        return result
 +
 +    def _check_value(self, action, value):
 +        # converted value must be one of the choices (if specified)
 +        if action.choices is not None and value not in action.choices:
 +            tup = value, ', '.join(map(repr, action.choices))
 +            msg = _('invalid choice: %r (choose from %s)') % tup
 +            raise ArgumentError(action, msg)
 +
 +    # =======================
 +    # Help-formatting methods
 +    # =======================
 +    def format_usage(self):
 +        formatter = self._get_formatter()
 +        formatter.add_usage(self.usage, self._actions,
 +                            self._mutually_exclusive_groups)
 +        return formatter.format_help()
 +
 +    def format_help(self):
 +        formatter = self._get_formatter()
 +
 +        # usage
 +        formatter.add_usage(self.usage, self._actions,
 +                            self._mutually_exclusive_groups)
 +
 +        # description
 +        formatter.add_text(self.description)
 +
 +        # positionals, optionals and user-defined groups
 +        for action_group in self._action_groups:
 +            formatter.start_section(action_group.title)
 +            formatter.add_text(action_group.description)
 +            formatter.add_arguments(action_group._group_actions)
 +            formatter.end_section()
 +
 +        # epilog
 +        formatter.add_text(self.epilog)
 +
 +        # determine help from format above
 +        return formatter.format_help()
 +
 +    def format_version(self):
 +        import warnings
 +        warnings.warn(
 +            'The format_version method is deprecated -- the "version" '
 +            'argument to ArgumentParser is no longer supported.',
 +            DeprecationWarning)
 +        formatter = self._get_formatter()
 +        formatter.add_text(self.version)
 +        return formatter.format_help()
 +
 +    def _get_formatter(self):
 +        return self.formatter_class(prog=self.prog)
 +
 +    # =====================
 +    # Help-printing methods
 +    # =====================
 +    def print_usage(self, file=None):
 +        if file is None:
 +            file = _sys.stdout
 +        self._print_message(self.format_usage(), file)
 +
 +    def print_help(self, file=None):
 +        if file is None:
 +            file = _sys.stdout
 +        self._print_message(self.format_help(), file)
 +
 +    def print_version(self, file=None):
 +        import warnings
 +        warnings.warn(
 +            'The print_version method is deprecated -- the "version" '
 +            'argument to ArgumentParser is no longer supported.',
 +            DeprecationWarning)
 +        self._print_message(self.format_version(), file)
 +
 +    def _print_message(self, message, file=None):
 +        if message:
 +            if file is None:
 +                file = _sys.stderr
 +            file.write(message)
 +
 +    # ===============
 +    # Exiting methods
 +    # ===============
 +    def exit(self, status=0, message=None):
 +        if message:
 +            self._print_message(message, _sys.stderr)
 +        _sys.exit(status)
 +
 +    def error(self, message):
 +        """error(message: string)
 +
 +        Prints a usage message incorporating the message to stderr and
 +        exits.
 +
 +        If you override this in a subclass, it should not return -- it
 +        should either exit or raise an exception.
 +        """
 +        self.print_usage(_sys.stderr)
 +        self.exit(2, _('%s: error: %s\n') % (self.prog, message))
 --
-.13.5
+.26.2

-New patch
+[PULL v2 07/28] MAINTAINERS: Add vhost-user block device backend server maintainer
+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 +++++++
+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>
+--
+.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

-[Qemu-devel] [PULL for-2.10 02/15] throttle: Fix wrong variable name in the header documentation
+[PULL v2 09/28] util/vhost-user-server: drop unnecessary QOM cast
-From: Alberto Garcia <berto@igalia.com>
+We already have access to the value with the correct type (ioc and sioc
 are the same QIOChannel).
-The level of the burst bucket is stored in bkt.burst_level, not
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-bkt.burst_length.
+Message-id: 20200924151549.913737-4-stefanha@redhat.com
 Signed-off-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Manos Pitsidianakis <el13635@mail.ntua.gr>
 Message-id: 49aab2711d02f285567f3b3b13a113847af33812.1503580370.git.berto@igalia.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/throttle.h | 2 +-
+ util/vhost-user-server.c | 2 +-
 file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
+diff --git a/util/vhost-user-server.c b/util/vhost-user-server.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/util/vhost-user-server.c
-+++ b/include/qemu/throttle.h
++++ b/util/vhost-user-server.c
-@@ -XXX,XX +XXX,XX @@ typedef enum {
+@@ -XXX,XX +XXX,XX @@ static void vu_accept(QIONetListener *listener, QIOChannelSocket *sioc,
-  * - The bkt.avg rate does not apply until the bucket is full,
+     server->ioc = QIO_CHANNEL(sioc);
-  *   allowing the user to do bursts until then. The I/O limit during
+     object_ref(OBJECT(server->ioc));
-  *   bursts is bkt.max. To enforce this limit we keep an additional
+     qio_channel_attach_aio_context(server->ioc, server->ctx);
-- *   bucket in bkt.burst_length that leaks at a rate of bkt.max units
+-    qio_channel_set_blocking(QIO_CHANNEL(server->sioc), false, NULL);
-+ *   bucket in bkt.burst_level that leaks at a rate of bkt.max units
++    qio_channel_set_blocking(server->ioc, false, NULL);
-  *   per second.
+     vu_client_start(server);
-  *
+ }
-  * - Because of all of the above, the user can perform I/O at a
 --
-.13.5
+.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

-[Qemu-devel] [PULL for-2.10 06/15] throttle: Make LeakyBucket.avg and LeakyBucket.max integer types
+[PULL v2 11/28] block/export: consolidate request structs into VuBlockReq
-From: Alberto Garcia <berto@igalia.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.
-Both the throttling limits set with the throttling.iops-* and
+This fixes the req_data memory leak in vu_block_virtio_process_req().
 throttling.bps-* options and their QMP equivalents defined in the
 BlockIOThrottle struct are integer values.
-Those limits are also reported in the BlockDeviceInfo struct and they
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-are integers there as well.
+Message-id: 20200924151549.913737-6-stefanha@redhat.com
 Therefore there's no reason to store them internally as double and do
 the conversion everytime we're setting or querying them, so this patch
 uses uint64_t for those types. Let's also use an unsigned type because
 we don't allow negative values anyway.
 LeakyBucket.level and LeakyBucket.burst_level do however remain double
 because their value changes depending on the fraction of time elapsed
 since the previous I/O operation.
 Signed-off-by: Alberto Garcia <berto@igalia.com>
 Message-id: f29b840422767b5be2c41c2dfdbbbf6c5f8fedf8.1503580370.git.berto@igalia.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/throttle.h | 4 ++--
+ block/export/vhost-user-blk-server.c | 68 +++++++++-------------------
- tests/test-throttle.c   | 3 ++-
+file changed, 21 insertions(+), 47 deletions(-)
  util/throttle.c         | 7 +++----
 files changed, 7 insertions(+), 7 deletions(-)
-diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
+diff --git a/block/export/vhost-user-blk-server.c b/block/export/vhost-user-blk-server.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/block/export/vhost-user-blk-server.c
-+++ b/include/qemu/throttle.h
++++ b/block/export/vhost-user-blk-server.c
-@@ -XXX,XX +XXX,XX @@ typedef enum {
+@@ -XXX,XX +XXX,XX @@ struct virtio_blk_inhdr {
-  */
+ };
- typedef struct LeakyBucket {
+ typedef struct VuBlockReq {
--    double  avg;              /* average goal in units per second */
+-    VuVirtqElement *elem;
--    double  max;              /* leaky bucket max burst in units */
++    VuVirtqElement elem;
-+    uint64_t avg;             /* average goal in units per second */
+     int64_t sector_num;
-+    uint64_t max;             /* leaky bucket max burst in units */
+     size_t size;
-     double  level;            /* bucket level in units */
+     struct virtio_blk_inhdr *in;
-     double  burst_level;      /* bucket level in units (for computing bursts) */
+@@ -XXX,XX +XXX,XX @@ static void vu_block_req_complete(VuBlockReq *req)
-     unsigned burst_length;    /* max length of the burst period, in seconds */
+     VuDev *vu_dev = &req->server->vu_dev;
-diff --git a/tests/test-throttle.c b/tests/test-throttle.c
-index XXXXXXX..XXXXXXX 100644
+     /* IO size with 1 extra status byte */
---- a/tests/test-throttle.c
+-    vu_queue_push(vu_dev, req->vq, req->elem, req->size + 1);
-+++ b/tests/test-throttle.c
++    vu_queue_push(vu_dev, req->vq, &req->elem, req->size + 1);
-@@ -XXX,XX +XXX,XX @@ static void test_enabled(void)
+     vu_queue_notify(vu_dev, req->vq);
-     for (i = 0; i < BUCKETS_COUNT; i++) {
-         throttle_config_init(&cfg);
+-    if (req->elem) {
-         set_cfg_value(false, i, 150);
+-        free(req->elem);
-+        g_assert(throttle_is_valid(&cfg, NULL));
+-    }
-         g_assert(throttle_enabled(&cfg));
+-
 -    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;
      }
-     for (i = 0; i < BUCKETS_COUNT; i++) {
+-    req = g_new0(VuBlockReq, 1);
-         throttle_config_init(&cfg);
+-    req->server = server;
-         set_cfg_value(false, i, -150);
+-    req->vq = vq;
--        g_assert(!throttle_enabled(&cfg));
+-    req->elem = elem;
-+        g_assert(!throttle_is_valid(&cfg, NULL));
+-
      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);
      }
  }
-diff --git a/util/throttle.c b/util/throttle.c
-index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
-+++ b/util/throttle.c
-@@ -XXX,XX +XXX,XX @@ int64_t throttle_compute_wait(LeakyBucket *bkt)
-         /* If bkt->max is 0 we still want to allow short bursts of I/O
-          * from the guest, otherwise every other request will be throttled
-          * and performance will suffer considerably. */
--        bucket_size = bkt->avg / 10;
-+        bucket_size = (double) bkt->avg / 10;
-         burst_bucket_size = 0;
-     } else {
-         /* If we have a burst limit then we have to wait until all I/O
-          * at burst rate has finished before throttling to bkt->avg */
-         bucket_size = bkt->max * bkt->burst_length;
--        burst_bucket_size = bkt->max / 10;
-+        burst_bucket_size = (double) bkt->max / 10;
-     }
-     /* If the main bucket is full then we have to wait */
-@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
-     for (i = 0; i < BUCKETS_COUNT; i++) {
-         LeakyBucket *bkt = &cfg->buckets[i];
--        if (bkt->avg < 0 || bkt->max < 0 ||
--            bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
-+        if (bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
-             error_setg(errp, "bps/iops/max values must be within [0, %lld]",
-                        THROTTLE_VALUE_MAX);
-             return false;
 --
-.13.5
+.26.2

-New patch
+[PULL v2 12/28] util/vhost-user-server: drop unused DevicePanicNotifier
+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 ------
+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");
+--
+.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

-New patch
+[PULL v2 15/28] util/vhost-user-server: rework vu_client_trip() coroutine lifecycle
+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 +++++++++++++++------------
+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,
+--
+.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

-New patch
+[PULL v2 17/28] block/export: convert vhost-user-blk server to block export API
+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 -
 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 |
 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'))
 --
 .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

-[Qemu-devel] [PULL for-2.10 14/15] qemu-doc: Add UUID support in initiator name
+[PULL v2 19/28] util/vhost-user-server: use static library in meson.build
-From: Fred Rolland <rollandf@gmail.com>
+Don't compile contrib/libvhost-user/libvhost-user.c again. Instead build
 the static library once and then reuse it throughout QEMU.
-Update doc with the usage of UUID for initiator name.
+Also switch from CONFIG_LINUX to CONFIG_VHOST_USER, which is what the
 vhost-user tools (vhost-user-gpu, etc) do.
-Related-To: https://bugzilla.redhat.com/1006468
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Fred Rolland <frolland@redhat.com>
+Message-id: 20200924151549.913737-14-stefanha@redhat.com
-Message-id: 20170823084830.30500-1-frolland@redhat.com
+[Added CONFIG_LINUX again because libvhost-user doesn't build on macOS.
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- qemu-doc.texi | 5 +++--
+ block/export/export.c             | 8 ++++----
-file changed, 3 insertions(+), 2 deletions(-)
+ 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/qemu-doc.texi b/qemu-doc.texi
+diff --git a/block/export/export.c b/block/export/export.c
 index XXXXXXX..XXXXXXX 100644
---- a/qemu-doc.texi
+--- a/block/export/export.c
-+++ b/qemu-doc.texi
++++ b/block/export/export.c
-@@ -XXX,XX +XXX,XX @@ in a configuration file provided via '-readconfig' or directly on the
+@@ -XXX,XX +XXX,XX @@
- command line.
+ #include "sysemu/block-backend.h"
+ #include "block/export.h"
- If the initiator-name is not specified qemu will use a default name
+ #include "block/nbd.h"
--of 'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
+-#if CONFIG_LINUX
-+of 'iqn.2008-11.org.linux-kvm[:<uuid>'] where <uuid> is the UUID of the
+-#include "block/export/vhost-user-blk-server.h"
-+virtual machine. If the UUID is not specified qemu will use
+-#endif
-+'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
+ #include "qapi/error.h"
- virtual machine.
+ #include "qapi/qapi-commands-block-export.h"
+ #include "qapi/qapi-events-block-export.h"
--
+ #include "qemu/id.h"
- @example
++#ifdef CONFIG_VHOST_USER
- Setting a specific initiator name to use when logging in to the target
++#include "vhost-user-blk-server.h"
- -iscsi initiator-name=iqn.qemu.test:my-initiator
++#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'))
 --
-.13.5
+.26.2

-[Qemu-devel] [PULL for-2.10 09/15] oslib-posix: Print errors before aborting on qemu_alloc_stack()
+[PULL v2 20/28] qemu-storage-daemon: avoid compiling blockdev_ss twice
-From: Eduardo Habkost <ehabkost@redhat.com>
+Introduce libblkdev.fa to avoid recompiling blockdev_ss twice.
-If QEMU is running on a system that's out of memory and mmap()
+Suggested-by: Paolo Bonzini <pbonzini@redhat.com>
-fails, QEMU aborts with no error message at all, making it hard
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
-to debug the reason for the failure.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-id: 20200929125516.186715-3-stefanha@redhat.com
 Add perror() calls that will print error information before
 aborting.
 Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
 Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Tested-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Message-id: 20170829212053.6003-1-ehabkost@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- util/oslib-posix.c | 2 ++
+ meson.build                | 12 ++++++++++--
-file changed, 2 insertions(+)
+ storage-daemon/meson.build |  3 +--
 files changed, 11 insertions(+), 4 deletions(-)
-diff --git a/util/oslib-posix.c b/util/oslib-posix.c
+diff --git a/meson.build b/meson.build
 index XXXXXXX..XXXXXXX 100644
---- a/util/oslib-posix.c
+--- a/meson.build
-+++ b/util/oslib-posix.c
++++ b/meson.build
-@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
+@@ -XXX,XX +XXX,XX @@ blockdev_ss.add(files(
-     ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE,
+ # os-win32.c does not
-                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ blockdev_ss.add(when: 'CONFIG_POSIX', if_true: files('os-posix.c'))
-     if (ptr == MAP_FAILED) {
+ softmmu_ss.add(when: 'CONFIG_WIN32', if_true: [files('os-win32.c')])
-+        perror("failed to allocate memory for stack");
+-softmmu_ss.add_all(blockdev_ss)
-         abort();
-     }
+ common_ss.add(files('cpus-common.c'))
-@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
+@@ -XXX,XX +XXX,XX @@ block = declare_dependency(link_whole: [libblock],
-     guardpage = ptr;
+                            link_args: '@block.syms',
- #endif
+                            dependencies: [crypto, io])
-     if (mprotect(guardpage, pagesz, PROT_NONE) != 0) {
-+        perror("failed to set up stack guard page");
++blockdev_ss = blockdev_ss.apply(config_host, strict: false)
-         abort();
++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')
 --
-.13.5
+.26.2

-[Qemu-devel] [PULL for-2.10 13/15] tests: migration/guestperf Python 2.6 argparse compatibility
+[PULL v2 21/28] block: move block exports to libblockdev
-Add the scripts/ directory to sys.path so Python 2.6 will be able to
+Block exports are used by softmmu, qemu-storage-daemon, and qemu-nbd.
-import argparse.
+They are not used by other programs and are not otherwise needed in
 libblock.
-Cc: Daniel P. Berrange <berrange@redhat.com>
+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>
-Acked-by: John Snow <jsnow@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
-Acked-by: Fam Zheng <famz@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
-Message-id: 20170825155732.15665-4-stefanha@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>
 ---
- tests/migration/guestperf/shell.py | 8 +++++---
+ qemu-nbd.c                | 21 ++++++++-------------
-file changed, 5 insertions(+), 3 deletions(-)
+ 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/tests/migration/guestperf/shell.py b/tests/migration/guestperf/shell.py
+diff --git a/qemu-nbd.c b/qemu-nbd.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/migration/guestperf/shell.py
+--- a/qemu-nbd.c
-+++ b/tests/migration/guestperf/shell.py
++++ b/qemu-nbd.c
 @@ -XXX,XX +XXX,XX @@
- #
+ #include "qapi/error.h"
+ #include "qemu/cutils.h"
+ #include "sysemu/block-backend.h"
--import argparse
++#include "sysemu/runstate.h" /* for qemu_system_killed() prototype */
--import fnmatch
+ #include "block/block_int.h"
- import os
+ #include "block/nbd.h"
- import os.path
+ #include "qemu/main-loop.h"
--import platform
+@@ -XXX,XX +XXX,XX @@ QEMU_COPYRIGHT "\n"
- import sys
+ }
-+sys.path.append(os.path.join(os.path.dirname(__file__),
-+                             '..', '..', '..', 'scripts'))
+ #ifdef CONFIG_POSIX
-+import argparse
+-static void termsig_handler(int signum)
-+import fnmatch
++/*
-+import platform
++ * The client thread uses SIGTERM to interrupt the server.  A signal
++ * handler ensures that "qemu-nbd -v -c" exits with a nice status code.
- from guestperf.hardware import Hardware
++ */
- from guestperf.engine import Engine
++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'))
 --
-.13.5
+.26.2

-[Qemu-devel] [PULL for-2.10 15/15] qcow2: allocate cluster_cache/cluster_data on demand
+[PULL v2 22/28] block/export: add iothread and fixed-iothread options
-Most qcow2 files are uncompressed so it is wasteful to allocate (32 + 1)
+Make it possible to specify the iothread where the export will run. By
-* cluster_size + 512 bytes upfront.  Allocate s->cluster_cache and
+default the block node can be moved to other AioContexts later and the
-s->cluster_data when the first read operation is performance on a
+export will follow. The fixed-iothread option forces strict behavior
-compressed cluster.
+that prevents changing AioContext while the export is active. See the
 QAPI docs for details.
-The buffers are freed in .bdrv_close().  .bdrv_open() no longer has any
-code paths that can allocate these buffers, so remove the free functions
-in the error code path.
-This patch can result in significant memory savings when many qcow2
-disks are attached or backing file chains are long:
-Before 12.81% (1,023,193,088B)
-After   5.36% (393,893,888B)
-Reported-by: Alexey Kardashevskiy <aik@ozlabs.ru>
-Tested-by: Alexey Kardashevskiy <aik@ozlabs.ru>
-Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-id: 20170821135530.32344-1-stefanha@redhat.com
+Message-id: 20200929125516.186715-5-stefanha@redhat.com
-Cc: Kevin Wolf <kwolf@redhat.com>
+[Fix stray '#' character in block-export.json and add missing "(since:
 .2)" as suggested by Eric Blake.
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/qcow2-cluster.c | 17 +++++++++++++++++
+ qapi/block-export.json               | 11 ++++++++++
- block/qcow2.c         | 12 ------------
+ block/export/export.c                | 31 +++++++++++++++++++++++++++-
-files changed, 17 insertions(+), 12 deletions(-)
+ block/export/vhost-user-blk-server.c |  5 ++++-
  nbd/server.c                         |  2 --
 files changed, 45 insertions(+), 4 deletions(-)
-diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
+diff --git a/qapi/block-export.json b/qapi/block-export.json
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2-cluster.c
+--- a/qapi/block-export.json
-+++ b/block/qcow2-cluster.c
++++ b/qapi/block-export.json
-@@ -XXX,XX +XXX,XX @@ int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
+@@ -XXX,XX +XXX,XX @@
-         nb_csectors = ((cluster_offset >> s->csize_shift) & s->csize_mask) + 1;
+ #                export before completion is signalled. (since: 5.2;
-         sector_offset = coffset & 511;
+ #                default: false)
-         csize = nb_csectors * 512 - sector_offset;
+ #
 +# @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;
 +
-+        /* Allocate buffers on first decompress operation, most images are
++        iothread = iothread_by_id(export->iothread);
-+         * uncompressed and the memory overhead can be avoided.  The buffers
++        if (!iothread) {
-+         * are freed in .bdrv_close().
++            error_setg(errp, "iothread \"%s\" not found", export->iothread);
-+         */
++            goto fail;
 +        if (!s->cluster_data) {
 +            /* one more sector for decompressed data alignment */
 +            s->cluster_data = qemu_try_blockalign(bs->file->bs,
 +                    QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size + 512);
 +            if (!s->cluster_data) {
 +                return -ENOMEM;
 +            }
 +        }
 +        if (!s->cluster_cache) {
 +            s->cluster_cache = g_malloc(s->cluster_size);
 +        }
 +
-         BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
++        new_ctx = iothread_get_aio_context(iothread);
-         ret = bdrv_read(bs->file, coffset >> 9, s->cluster_data,
++
-                         nb_csectors);
++        ret = bdrv_try_set_aio_context(bs, new_ctx, errp);
-diff --git a/block/qcow2.c b/block/qcow2.c
++        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/qcow2.c
+--- a/block/export/vhost-user-blk-server.c
-+++ b/block/qcow2.c
++++ b/block/export/vhost-user-blk-server.c
-@@ -XXX,XX +XXX,XX @@ static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
+@@ -XXX,XX +XXX,XX @@ static const VuDevIface vu_blk_iface = {
-         goto fail;
+ 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;
      }
--    s->cluster_cache = g_malloc(s->cluster_size);
+-    blk_set_allow_aio_context_change(blk, true);
 -    /* one more sector for decompressed data alignment */
 -    s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS
 -                                                    * s->cluster_size + 512);
 -    if (s->cluster_data == NULL) {
 -        error_setg(errp, "Could not allocate temporary cluster buffer");
 -        ret = -ENOMEM;
 -        goto fail;
 -    }
 -
-     s->cluster_cache_offset = -1;
+     QTAILQ_INIT(&exp->clients);
-     s->flags = flags;
+     exp->name = g_strdup(arg->name);
+     exp->description = g_strdup(arg->description);
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
      if (s->refcount_block_cache) {
          qcow2_cache_destroy(bs, s->refcount_block_cache);
      }
 -    g_free(s->cluster_cache);
 -    qemu_vfree(s->cluster_data);
      qcrypto_block_free(s->crypto);
      qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
      return ret;
 --
-.13.5
+.26.2

-[Qemu-devel] [PULL for-2.10 12/15] docker.py: Python 2.6 argparse compatibility
+[PULL v2 23/28] block/export: add vhost-user-blk multi-queue support
-Add the scripts/ directory to sys.path so Python 2.6 will be able to
+Allow the number of queues to be configured using --export
-import argparse.
+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.
-Cc: Fam Zheng <famz@redhat.com>
+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: John Snow <jsnow@redhat.com>
+Acked-by: Markus Armbruster <armbru@redhat.com>
-Acked-by: Fam Zheng <famz@redhat.com>
+Message-id: 20201001144604.559733-2-stefanha@redhat.com
-Message-id: 20170825155732.15665-3-stefanha@redhat.com
+[Fixed accidental tab characters as suggested by Markus Armbruster
 --Stefan]
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/docker/docker.py | 4 +++-
+ qapi/block-export.json               | 10 +++++++---
-file changed, 3 insertions(+), 1 deletion(-)
+ block/export/vhost-user-blk-server.c | 24 ++++++++++++++++++------
 files changed, 25 insertions(+), 9 deletions(-)
-diff --git a/tests/docker/docker.py b/tests/docker/docker.py
+diff --git a/qapi/block-export.json b/qapi/block-export.json
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/docker/docker.py
+--- a/qapi/block-export.json
-+++ b/tests/docker/docker.py
++++ b/qapi/block-export.json
 @@ -XXX,XX +XXX,XX @@
+ #        SocketAddress types are supported. Passed fds must be UNIX domain
- import os
+ #        sockets.
- import sys
+ # @logical-block-size: Logical block size in bytes. Defaults to 512 bytes.
-+sys.path.append(os.path.join(os.path.dirname(__file__),
++# @num-queues: Number of request virtqueues. Must be greater than 0. Defaults
-+                             '..', '..', 'scripts'))
++#              to 1.
-+import argparse
+ #
- import subprocess
+ # Since: 5.2
- import json
+ ##
- import hashlib
+ { 'struct': 'BlockExportOptionsVhostUserBlk',
- import atexit
+-  'data': { 'addr': 'SocketAddress', '*logical-block-size': 'size' } }
- import uuid
++  'data': { 'addr': 'SocketAddress',
--import argparse
++        '*logical-block-size': 'size',
- import tempfile
++            '*num-queues': 'uint16'} }
- import re
- import signal
+ ##
  # @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)
 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;
 --
-.13.5
+.26.2

-[Qemu-devel] [PULL for-2.10 10/15] misc: Remove unused Error variables
+[PULL v2 24/28] block/io: fix bdrv_co_block_status_above
-From: Alberto Garcia <berto@igalia.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-There's a few cases which we're passing an Error pointer to a function
+bdrv_co_block_status_above has several design problems with handling
-only to discard it immediately afterwards without checking it. In
+short backing files:
 these cases we can simply remove the variable and pass NULL instead.
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+. With want_zeros=true, it may return ret with BDRV_BLOCK_ZERO but
-Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
+without BDRV_BLOCK_ALLOCATED flag, when actually short backing file
 which produces these after-EOF zeros is inside requested backing
 sequence.
 . 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: 20170829120836.16091-1-berto@igalia.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/qcow.c  | 12 +++---------
+ block/io.c    | 68 ++++++++++++++++++++++++++++++++++++++++-----------
- block/qcow2.c |  8 ++------
+ block/qcow2.c | 16 ++++++++++--
- dump.c        |  4 +---
+files changed, 68 insertions(+), 16 deletions(-)
 files changed, 6 insertions(+), 18 deletions(-)
-diff --git a/block/qcow.c b/block/qcow.c
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow.c
+--- a/block/io.c
-+++ b/block/qcow.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
-                     start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
+                                   int64_t *map,
-                     for(i = 0; i < s->cluster_sectors; i++) {
+                                   BlockDriverState **file)
-                         if (i < n_start || i >= n_end) {
+ {
--                            Error *err = NULL;
++    int ret;
-                             memset(s->cluster_data, 0x00, 512);
+     BlockDriverState *p;
-                             if (qcrypto_block_encrypt(s->crypto, start_sect + i,
+-    int ret = 0;
-                                                       s->cluster_data,
+-    bool first = true;
-                                                       BDRV_SECTOR_SIZE,
++    int64_t eof = 0;
--                                                      &err) < 0) {
--                                error_free(err);
+     assert(bs != base);
-+                                                      NULL) < 0) {
+-    for (p = bs; p != base; p = bdrv_filter_or_cow_bs(p)) {
-                                 errno = EIO;
++
-                                 return -1;
++    ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);
-                             }
++    if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED) {
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
++        return ret;
-     QEMUIOVector hd_qiov;
++    }
-     uint8_t *buf;
++
-     void *orig_buf;
++    if (ret & BDRV_BLOCK_EOF) {
--    Error *err = NULL;
++        eof = offset + *pnum;
++    }
-     if (qiov->niov > 1) {
++
-         buf = orig_buf = qemu_try_blockalign(bs, qiov->size);
++    assert(*pnum <= bytes);
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
++    bytes = *pnum;
-             if (bs->encrypted) {
++
-                 assert(s->crypto);
++    for (p = bdrv_filter_or_cow_bs(bs); p != base;
-                 if (qcrypto_block_decrypt(s->crypto, sector_num, buf,
++         p = bdrv_filter_or_cow_bs(p))
--                                          n * BDRV_SECTOR_SIZE, &err) < 0) {
++    {
-+                                          n * BDRV_SECTOR_SIZE, NULL) < 0) {
+         ret = bdrv_co_block_status(p, want_zero, offset, bytes, pnum, map,
-                     goto fail;
+                                    file);
-                 }
+         if (ret < 0) {
-             }
+-            break;
-@@ -XXX,XX +XXX,XX @@ done:
++            return ret;
-     return ret;
+         }
+-        if (ret & BDRV_BLOCK_ZERO && ret & BDRV_BLOCK_EOF && !first) {
- fail:
++        if (*pnum == 0) {
--    error_free(err);
+             /*
-     ret = -EIO;
+-             * Reading beyond the end of the file continues to read
-     goto done;
+-             * zeroes, but we can only widen the result to the
- }
+-             * unallocated length we learned from an earlier
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
+-             * 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;
          }
-         if (bs->encrypted) {
+-        /* [offset, pnum] unallocated on this layer, which could be only
--            Error *err = NULL;
+-         * the first part of [offset, bytes].  */
-             assert(s->crypto);
+-        bytes = MIN(bytes, *pnum);
-             if (qcrypto_block_encrypt(s->crypto, sector_num, buf,
+-        first = false;
--                                      n * BDRV_SECTOR_SIZE, &err) < 0) {
++
--                error_free(err);
++        /*
-+                                      n * BDRV_SECTOR_SIZE, NULL) < 0) {
++         * OK, [offset, offset + *pnum) region is unallocated on this layer,
-                 ret = -EIO;
++         * let's continue the diving.
-                 break;
++         */
-             }
++        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 coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
+@@ -XXX,XX +XXX,XX @@ static bool is_zero(BlockDriverState *bs, int64_t offset, int64_t bytes)
-                 assert(s->crypto);
+     if (!bytes) {
-                 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
+         return true;
-                 assert((cur_bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
+     }
--                Error *err = NULL;
+-    res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
-                 if (qcrypto_block_decrypt(s->crypto,
+-    return res >= 0 && (res & BDRV_BLOCK_ZERO) && nr == bytes;
-                                           (s->crypt_physical_offset ?
++
-                                            cluster_offset + offset_in_cluster :
++    /*
-                                            offset) >> BDRV_SECTOR_BITS,
++     * bdrv_block_status_above doesn't merge different types of zeros, for
-                                           cluster_data,
++     * example, zeros which come from the region which is unallocated in
-                                           cur_bytes,
++     * the whole backing chain, and zeros which come because of a short
--                                          &err) < 0) {
++     * backing file. So, we need a loop.
--                    error_free(err);
++     */
-+                                          NULL) < 0) {
++    do {
-                     ret = -EIO;
++        res = bdrv_block_status_above(bs, NULL, offset, bytes, &nr, NULL, NULL);
-                     goto fail;
++        offset += nr;
-                 }
++        bytes -= nr;
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
++    } while (res >= 0 && (res & BDRV_BLOCK_ZERO) && nr && bytes);
-         qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
++
++    return res >= 0 && (res & BDRV_BLOCK_ZERO) && bytes == 0;
          if (bs->encrypted) {
 -            Error *err = NULL;
              assert(s->crypto);
              if (!cluster_data) {
                  cluster_data = qemu_try_blockalign(bs->file->bs,
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
                                         cluster_offset + offset_in_cluster :
                                         offset) >> BDRV_SECTOR_BITS,
                                        cluster_data,
 -                                      cur_bytes, &err) < 0) {
 -                error_free(err);
 +                                      cur_bytes, NULL) < 0) {
                  ret = -EIO;
                  goto fail;
              }
 diff --git a/dump.c b/dump.c
 index XXXXXXX..XXXXXXX 100644
 --- a/dump.c
 +++ b/dump.c
@@ -XXX,XX +XXX,XX @@ static void dump_process(DumpState *s, Error **errp)
  static void *dump_thread(void *data)
  {
 -    Error *err = NULL;
      DumpState *s = (DumpState *)data;
 -    dump_process(s, &err);
 -    error_free(err);
 +    dump_process(s, NULL);
      return NULL;
  }
+ static coroutine_fn int qcow2_co_pwrite_zeroes(BlockDriverState *bs,
 --
-.13.5
+.26.2

-[Qemu-devel] [PULL for-2.10 07/15] throttle: Make burst_length 64bit and add range checks
+[PULL v2 25/28] block/io: bdrv_common_block_status_above: support include_base
-From: Alberto Garcia <berto@igalia.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-LeakyBucket.burst_length is defined as an unsigned integer but the
+In order to reuse bdrv_common_block_status_above in
-code never checks for overflows and it only makes sure that the value
+bdrv_is_allocated_above, let's support include_base parameter.
 is not 0.
-In practice this means that the user can set something like
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-throttling.iops-total-max-length=4294967300 despite being larger than
+Reviewed-by: Alberto Garcia <berto@igalia.com>
-UINT_MAX and the final value after casting to unsigned int will be 4.
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Message-id: 20200924194003.22080-3-vsementsov@virtuozzo.com
 This patch changes the data type to uint64_t. This does not increase
 the storage size of LeakyBucket, and allows us to assign the value
 directly from qemu_opt_get_number() or BlockIOThrottle and then do the
 checks directly in throttle_is_valid().
 The value of burst_length does not have a specific upper limit,
 but since the bucket size is defined by max * burst_length we have
 to prevent overflows. Instead of going for UINT64_MAX or something
 similar this patch reuses THROTTLE_VALUE_MAX, which allows I/O bursts
 of 1 GiB/s for 10 days in a row.
 Signed-off-by: Alberto Garcia <berto@igalia.com>
 Message-id: 1b2e3049803f71cafb2e1fa1be4fb47147a0d398.1503580370.git.berto@igalia.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/qemu/throttle.h | 2 +-
+ block/coroutines.h |  2 ++
- util/throttle.c         | 5 +++++
+ block/io.c         | 21 ++++++++++++++-------
-files changed, 6 insertions(+), 1 deletion(-)
+files changed, 16 insertions(+), 7 deletions(-)
-diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
+diff --git a/block/coroutines.h b/block/coroutines.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/throttle.h
+--- a/block/coroutines.h
-+++ b/include/qemu/throttle.h
++++ b/block/coroutines.h
-@@ -XXX,XX +XXX,XX @@ typedef struct LeakyBucket {
+@@ -XXX,XX +XXX,XX @@ bdrv_pwritev(BdrvChild *child, int64_t offset, unsigned int bytes,
-     uint64_t max;             /* leaky bucket max burst in units */
+ int coroutine_fn
-     double  level;            /* bucket level in units */
+ bdrv_co_common_block_status_above(BlockDriverState *bs,
-     double  burst_level;      /* bucket level in units (for computing bursts) */
+                                   BlockDriverState *base,
--    unsigned burst_length;    /* max length of the burst period, in seconds */
++                                  bool include_base,
-+    uint64_t burst_length;    /* max length of the burst period, in seconds */
+                                   bool want_zero,
- } LeakyBucket;
+                                   int64_t offset,
+                                   int64_t bytes,
- /* The following structure is used to configure a ThrottleState
+@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
-diff --git a/util/throttle.c b/util/throttle.c
+ 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/util/throttle.c
+--- a/block/io.c
-+++ b/util/throttle.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
+@@ -XXX,XX +XXX,XX @@ early_out:
-             return false;
+ 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 (bkt->max && bkt->burst_length > THROTTLE_VALUE_MAX / bkt->max) {
++        if (p == base) {
-+            error_setg(errp, "burst length too high for this burst rate");
++            assert(include_base);
-+            return false;
++            break;
 +        }
 +
-         if (bkt->max && !bkt->avg) {
+         /*
-             error_setg(errp, "bps_max/iops_max require corresponding"
+          * OK, [offset, offset + *pnum) region is unallocated on this layer,
-                        " bps/iops values");
+          * 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;
      }
 --
-.13.5
+.26.2

-[Qemu-devel] [PULL for-2.10 03/15] throttle: Update the throttle_fix_bucket() documentation
+[PULL v2 26/28] block/io: bdrv_common_block_status_above: support bs == base
-From: Alberto Garcia <berto@igalia.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-The way the throttling algorithm works is that requests start being
+We are going to reuse bdrv_common_block_status_above in
-throttled once the bucket level exceeds the burst limit. When we get
+bdrv_is_allocated_above. bdrv_is_allocated_above may be called with
-there the bucket leaks at the level set by the user (bkt->avg), and
+include_base == false and still bs == base (for ex. from img_rebase()).
 that leak rate is what prevents guest I/O from exceeding the desired
 limit.
-If we don't allow bursts (i.e. bkt->max == 0) then we can start
+So, support this corner case.
 throttling requests immediately. The problem with keeping the
 threshold at 0 is that it only allows one request at a time, and as
 soon as there's a bit of I/O from the guest every other request will
 be throttled and performance will suffer considerably. That can even
 make the guest unable to reach the throttle limit if that limit is
 high enough, and that happens regardless of the block scheduler used
 by the guest.
-Increasing that threshold gives flexibility to the guest, allowing it
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-to perform short bursts of I/O before being throttled. Increasing the
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
-threshold too much does not make a difference in the long run (because
+Reviewed-by: Eric Blake <eblake@redhat.com>
-it's the leak rate what defines the actual throughput) but it does
+Reviewed-by: Alberto Garcia <berto@igalia.com>
-allow the guest to perform longer initial bursts and exceed the
+Message-id: 20200924194003.22080-4-vsementsov@virtuozzo.com
 throttle limit for a short while.
 A burst value of bkt->avg / 10 allows the guest to perform 100ms'
 worth of I/O at the target rate without being throttled.
 Signed-off-by: Alberto Garcia <berto@igalia.com>
 Message-id: 31aae6645f0d1fbf3860fb2b528b757236f0c0a7.1503580370.git.berto@igalia.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- util/throttle.c | 11 +++--------
+ block/io.c | 6 +++++-
-file changed, 3 insertions(+), 8 deletions(-)
+file changed, 5 insertions(+), 1 deletion(-)
-diff --git a/util/throttle.c b/util/throttle.c
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+--- a/block/io.c
-+++ b/util/throttle.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static void throttle_fix_bucket(LeakyBucket *bkt)
+@@ -XXX,XX +XXX,XX @@ bdrv_co_common_block_status_above(BlockDriverState *bs,
-     /* zero bucket level */
+     BlockDriverState *p;
-     bkt->level = bkt->burst_level = 0;
+     int64_t eof = 0;
--    /* The following is done to cope with the Linux CFQ block scheduler
+-    assert(include_base || bs != base);
--     * which regroup reads and writes by block of 100ms in the guest.
+     assert(!include_base || base); /* Can't include NULL base */
--     * When they are two process one making reads and one making writes cfq
--     * make a pattern looking like the following:
++    if (!include_base && bs == base) {
--     * WWWWWWWWWWWRRRRRRRRRRRRRRWWWWWWWWWWWWWwRRRRRRRRRRRRRRRRR
++        *pnum = bytes;
--     * Having a max burst value of 100ms of the average will help smooth the
++        return 0;
--     * throttling
++    }
--     */
++
-+    /* If bkt->max is 0 we still want to allow short bursts of I/O
+     ret = bdrv_co_block_status(bs, want_zero, offset, bytes, pnum, map, file);
-+     * from the guest, otherwise every other request will be throttled
+     if (ret < 0 || *pnum == 0 || ret & BDRV_BLOCK_ALLOCATED || bs == base) {
-+     * and performance will suffer considerably. */
+         return ret;
      min = bkt->avg / 10;
      if (bkt->avg && !bkt->max) {
          bkt->max = min;
 --
-.13.5
+.26.2

-[Qemu-devel] [PULL for-2.10 05/15] throttle: Remove throttle_fix_bucket() / throttle_unfix_bucket()
+[PULL v2 27/28] block/io: fix bdrv_is_allocated_above
-From: Alberto Garcia <berto@igalia.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-The throttling code can change internally the value of bkt->max if it
+bdrv_is_allocated_above wrongly handles short backing files: it reports
-hasn't been set by the user. The problem with this is that if we want
+after-EOF space as UNALLOCATED which is wrong, as on read the data is
-to retrieve the original value we have to undo this change first. This
+generated on the level of short backing file (if all overlays have
-is ugly and unnecessary: this patch removes the throttle_fix_bucket()
+unallocated areas at that place).
 and throttle_unfix_bucket() functions completely and moves the logic
 to throttle_compute_wait().
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+Reusing bdrv_common_block_status_above fixes the issue and unifies code
-Reviewed-by: Manos Pitsidianakis <el13635@mail.ntua.gr>
+path.
-Message-id: 5b0b9e1ac6eb208d709eddc7b09e7669a523bff3.1503580370.git.berto@igalia.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-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>
 ---
- util/throttle.c | 62 +++++++++++++++++++++------------------------------------
+ block/io.c | 43 +++++--------------------------------------
-file changed, 23 insertions(+), 39 deletions(-)
+file changed, 5 insertions(+), 38 deletions(-)
-diff --git a/util/throttle.c b/util/throttle.c
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/throttle.c
+--- a/block/io.c
-+++ b/util/throttle.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static int64_t throttle_do_compute_wait(double limit, double extra)
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_is_allocated(BlockDriverState *bs, int64_t offset,
- int64_t throttle_compute_wait(LeakyBucket *bkt)
+  * 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)
  {
-     double extra; /* the number of extra units blocking the io */
+-    BlockDriverState *intermediate;
-+    double bucket_size;   /* I/O before throttling to bkt->avg */
+-    int ret;
-+    double burst_bucket_size; /* Before throttling to bkt->max */
+-    int64_t n = bytes;
+-
-     if (!bkt->avg) {
+-    assert(base || !include_base);
-         return 0;
+-
 -    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;
      }
--    /* If the bucket is full then we have to wait */
+-    *pnum = n;
--    extra = bkt->level - bkt->max * bkt->burst_length;
+-    return 0;
-+    if (!bkt->max) {
++    return !!(ret & BDRV_BLOCK_ALLOCATED);
 +        /* If bkt->max is 0 we still want to allow short bursts of I/O
 +         * from the guest, otherwise every other request will be throttled
 +         * and performance will suffer considerably. */
 +        bucket_size = bkt->avg / 10;
 +        burst_bucket_size = 0;
 +    } else {
 +        /* If we have a burst limit then we have to wait until all I/O
 +         * at burst rate has finished before throttling to bkt->avg */
 +        bucket_size = bkt->max * bkt->burst_length;
 +        burst_bucket_size = bkt->max / 10;
 +    }
 +
 +    /* If the main bucket is full then we have to wait */
 +    extra = bkt->level - bucket_size;
      if (extra > 0) {
          return throttle_do_compute_wait(bkt->avg, extra);
      }
 -    /* If the bucket is not full yet we have to make sure that we
 -     * fulfill the goal of bkt->max units per second. */
 +    /* If the main bucket is not full yet we still have to check the
 +     * burst bucket in order to enforce the burst limit */
      if (bkt->burst_length > 1) {
 -        /* We use 1/10 of the max value to smooth the throttling.
 -         * See throttle_fix_bucket() for more details. */
 -        extra = bkt->burst_level - bkt->max / 10;
 +        extra = bkt->burst_level - burst_bucket_size;
          if (extra > 0) {
              return throttle_do_compute_wait(bkt->max, extra);
          }
@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
      return true;
  }
--/* fix bucket parameters */
+ int coroutine_fn
 -static void throttle_fix_bucket(LeakyBucket *bkt)
 -{
 -    double min;
 -
 -    /* zero bucket level */
 -    bkt->level = bkt->burst_level = 0;
 -
 -    /* If bkt->max is 0 we still want to allow short bursts of I/O
 -     * from the guest, otherwise every other request will be throttled
 -     * and performance will suffer considerably. */
 -    min = bkt->avg / 10;
 -    if (bkt->avg && !bkt->max) {
 -        bkt->max = min;
 -    }
 -}
 -
 -/* undo internal bucket parameter changes (see throttle_fix_bucket()) */
 -static void throttle_unfix_bucket(LeakyBucket *bkt)
 -{
 -    if (bkt->max < bkt->avg) {
 -        bkt->max = 0;
 -    }
 -}
 -
  /* Used to configure the throttle
   *
   * @ts: the throttle state we are working on
@@ -XXX,XX +XXX,XX @@ void throttle_config(ThrottleState *ts,
      ts->cfg = *cfg;
 +    /* Zero bucket level */
      for (i = 0; i < BUCKETS_COUNT; i++) {
 -        throttle_fix_bucket(&ts->cfg.buckets[i]);
 +        ts->cfg.buckets[i].level = 0;
 +        ts->cfg.buckets[i].burst_level = 0;
      }
      ts->previous_leak = qemu_clock_get_ns(clock_type);
@@ -XXX,XX +XXX,XX @@ void throttle_config(ThrottleState *ts,
   */
  void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg)
  {
 -    int i;
 -
      *cfg = ts->cfg;
 -
 -    for (i = 0; i < BUCKETS_COUNT; i++) {
 -        throttle_unfix_bucket(&cfg->buckets[i]);
 -    }
  }
 --
-.13.5
+.26.2

-[Qemu-devel] [PULL for-2.10 01/15] nvme: Fix get/set number of queues feature, again
+[PULL v2 28/28] iotests: add commit top->base cases to 274
-From: Dan Aloni <dan@kernelim.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-The number of queues that should be return by the admin command should:
+These cases are fixed by previous patches around block_status and
 is_allocated.
-) Only mention the number of non-admin queues.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-) It is zero-based, meaning that '0 == one non-admin queue',
+Reviewed-by: Eric Blake <eblake@redhat.com>
-     '1 == two non-admin queues', and so forth.
+Reviewed-by: Alberto Garcia <berto@igalia.com>
+Message-id: 20200924194003.22080-6-vsementsov@virtuozzo.com
 Because our `num_queues` means the number of queues _plus_ the admin
 queue, then the right calculation for the number returned from the admin
 command is `num_queues - 2`, combining the two requirements mentioned.
 The issue was discovered by reducing num_queues from 64 to 8 and running
 a Linux VM with an SMP parameter larger than that (e.g. 22). It tries to
 utilize all queues, and therefore fails with an invalid queue number
 when trying to queue I/Os on the last queue.
 Signed-off-by: Dan Aloni <dan@kernelim.com>
 CC: Alex Friedman <alex@e8storage.com>
 CC: Keith Busch <keith.busch@intel.com>
 CC: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Keith Busch <keith.busch@intel.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- hw/block/nvme.c | 4 ++--
+ tests/qemu-iotests/274     | 20 +++++++++++
-file changed, 2 insertions(+), 2 deletions(-)
+ tests/qemu-iotests/274.out | 68 ++++++++++++++++++++++++++++++++++++++
 files changed, 88 insertions(+)
-diff --git a/hw/block/nvme.c b/hw/block/nvme.c
+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/hw/block/nvme.c
+--- a/tests/qemu-iotests/274.out
-+++ b/hw/block/nvme.c
++++ b/tests/qemu-iotests/274.out
-@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
+@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0
-         result = blk_enable_write_cache(n->conf.blk);
+ read 1048576/1048576 bytes at offset 1048576
-         break;
+MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-     case NVME_NUMBER_OF_QUEUES:
--        result = cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
++=== Testing qemu-img commit (top -> base) ===
-+        result = cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 cluster_size=65536 extended_l2=off compression_type=zlib size=2097152 lazy_refcounts=off refcount_bits=16
-         break;
++
-     default:
++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
-         return NVME_INVALID_FIELD | NVME_DNR;
++
-@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_set_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
++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
-         break;
++
-     case NVME_NUMBER_OF_QUEUES:
++wrote 2097152/2097152 bytes at offset 0
-         req->cqe.result =
++2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--            cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
++
-+            cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
++Image committed.
-         break;
++
-     default:
++image: TEST_IMG
-         return NVME_INVALID_FIELD | NVME_DNR;
++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
 --
-.13.5
+.26.2

The following changes since commit 248b23735645f7cbb503d9be6f5bf825f2a603ab:

Update version for v2.10.0-rc4 release (2017-08-24 17:34:26 +0100)

are available in the git repository at:

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

for you to fetch changes up to 3e4c705212abfe8c9882a00beb2d1466a8a53cec:

qcow2: allocate cluster_cache/cluster_data on demand (2017-08-30 18:02:10 +0100)

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

Alberto Garcia (8):
  throttle: Fix wrong variable name in the header documentation
  throttle: Update the throttle_fix_bucket() documentation
  throttle: Make throttle_is_valid() a bit less verbose
  throttle: Remove throttle_fix_bucket() / throttle_unfix_bucket()
  throttle: Make LeakyBucket.avg and LeakyBucket.max integer types
  throttle: Make burst_length 64bit and add range checks
  throttle: Test the valid range of config values
  misc: Remove unused Error variables

Dan Aloni (1):
  nvme: Fix get/set number of queues feature, again

Eduardo Habkost (1):
  oslib-posix: Print errors before aborting on qemu_alloc_stack()

Fred Rolland (1):
  qemu-doc: Add UUID support in initiator name

Stefan Hajnoczi (4):
  scripts: add argparse module for Python 2.6 compatibility
  docker.py: Python 2.6 argparse compatibility
  tests: migration/guestperf Python 2.6 argparse compatibility
  qcow2: allocate cluster_cache/cluster_data on demand

-- 
2.13.5

From: Dan Aloni <dan@kernelim.com>

The number of queues that should be return by the admin command should:

1) Only mention the number of non-admin queues.
  2) It is zero-based, meaning that '0 == one non-admin queue',
     '1 == two non-admin queues', and so forth.

Because our `num_queues` means the number of queues _plus_ the admin
queue, then the right calculation for the number returned from the admin
command is `num_queues - 2`, combining the two requirements mentioned.

The issue was discovered by reducing num_queues from 64 to 8 and running
a Linux VM with an SMP parameter larger than that (e.g. 22). It tries to
utilize all queues, and therefore fails with an invalid queue number
when trying to queue I/Os on the last queue.

Signed-off-by: Dan Aloni <dan@kernelim.com>
CC: Alex Friedman <alex@e8storage.com>
CC: Keith Busch <keith.busch@intel.com>
CC: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Keith Busch <keith.busch@intel.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/block/nvme.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/hw/block/nvme.c b/hw/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/nvme.c
+++ b/hw/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
         result = blk_enable_write_cache(n->conf.blk);
         break;
     case NVME_NUMBER_OF_QUEUES:
-        result = cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
+        result = cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
         break;
     default:
         return NVME_INVALID_FIELD | NVME_DNR;
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_set_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
         break;
     case NVME_NUMBER_OF_QUEUES:
         req->cqe.result =
-            cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
+            cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
         break;
     default:
         return NVME_INVALID_FIELD | NVME_DNR;
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

The level of the burst bucket is stored in bkt.burst_level, not
bkt.burst_length.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Manos Pitsidianakis <el13635@mail.ntua.gr>
Message-id: 49aab2711d02f285567f3b3b13a113847af33812.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/throttle.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/throttle.h
+++ b/include/qemu/throttle.h
@@ -XXX,XX +XXX,XX @@ typedef enum {
  * - The bkt.avg rate does not apply until the bucket is full,
  *   allowing the user to do bursts until then. The I/O limit during
  *   bursts is bkt.max. To enforce this limit we keep an additional
- *   bucket in bkt.burst_length that leaks at a rate of bkt.max units
+ *   bucket in bkt.burst_level that leaks at a rate of bkt.max units
  *   per second.
  *
  * - Because of all of the above, the user can perform I/O at a
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

The way the throttling algorithm works is that requests start being
throttled once the bucket level exceeds the burst limit. When we get
there the bucket leaks at the level set by the user (bkt->avg), and
that leak rate is what prevents guest I/O from exceeding the desired
limit.

If we don't allow bursts (i.e. bkt->max == 0) then we can start
throttling requests immediately. The problem with keeping the
threshold at 0 is that it only allows one request at a time, and as
soon as there's a bit of I/O from the guest every other request will
be throttled and performance will suffer considerably. That can even
make the guest unable to reach the throttle limit if that limit is
high enough, and that happens regardless of the block scheduler used
by the guest.

Increasing that threshold gives flexibility to the guest, allowing it
to perform short bursts of I/O before being throttled. Increasing the
threshold too much does not make a difference in the long run (because
it's the leak rate what defines the actual throughput) but it does
allow the guest to perform longer initial bursts and exceed the
throttle limit for a short while.

A burst value of bkt->avg / 10 allows the guest to perform 100ms'
worth of I/O at the target rate without being throttled.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 31aae6645f0d1fbf3860fb2b528b757236f0c0a7.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/throttle.c | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/util/throttle.c b/util/throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -XXX,XX +XXX,XX @@ static void throttle_fix_bucket(LeakyBucket *bkt)
     /* zero bucket level */
     bkt->level = bkt->burst_level = 0;
 
-    /* The following is done to cope with the Linux CFQ block scheduler
-     * which regroup reads and writes by block of 100ms in the guest.
-     * When they are two process one making reads and one making writes cfq
-     * make a pattern looking like the following:
-     * WWWWWWWWWWWRRRRRRRRRRRRRRWWWWWWWWWWWWWwRRRRRRRRRRRRRRRRR
-     * Having a max burst value of 100ms of the average will help smooth the
-     * throttling
-     */
+    /* If bkt->max is 0 we still want to allow short bursts of I/O
+     * from the guest, otherwise every other request will be throttled
+     * and performance will suffer considerably. */
     min = bkt->avg / 10;
     if (bkt->avg && !bkt->max) {
         bkt->max = min;
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

Use a pointer to the bucket instead of repeating cfg->buckets[i] all
the time. This makes the code more concise and will help us expand the
checks later and save a few line breaks.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 763ffc40a26b17d54cf93f5a999e4656049fcf0c.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/throttle.c | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/util/throttle.c b/util/throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
     }
 
     for (i = 0; i < BUCKETS_COUNT; i++) {
-        if (cfg->buckets[i].avg < 0 ||
-            cfg->buckets[i].max < 0 ||
-            cfg->buckets[i].avg > THROTTLE_VALUE_MAX ||
-            cfg->buckets[i].max > THROTTLE_VALUE_MAX) {
+        LeakyBucket *bkt = &cfg->buckets[i];
+        if (bkt->avg < 0 || bkt->max < 0 ||
+            bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
             error_setg(errp, "bps/iops/max values must be within [0, %lld]",
                        THROTTLE_VALUE_MAX);
             return false;
         }
 
-        if (!cfg->buckets[i].burst_length) {
+        if (!bkt->burst_length) {
             error_setg(errp, "the burst length cannot be 0");
             return false;
         }
 
-        if (cfg->buckets[i].burst_length > 1 && !cfg->buckets[i].max) {
+        if (bkt->burst_length > 1 && !bkt->max) {
             error_setg(errp, "burst length set without burst rate");
             return false;
         }
 
-        if (cfg->buckets[i].max && !cfg->buckets[i].avg) {
+        if (bkt->max && !bkt->avg) {
             error_setg(errp, "bps_max/iops_max require corresponding"
                        " bps/iops values");
             return false;
         }
 
-        if (cfg->buckets[i].max && cfg->buckets[i].max < cfg->buckets[i].avg) {
+        if (bkt->max && bkt->max < bkt->avg) {
             error_setg(errp, "bps_max/iops_max cannot be lower than bps/iops");
             return false;
         }
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

The throttling code can change internally the value of bkt->max if it
hasn't been set by the user. The problem with this is that if we want
to retrieve the original value we have to undo this change first. This
is ugly and unnecessary: this patch removes the throttle_fix_bucket()
and throttle_unfix_bucket() functions completely and moves the logic
to throttle_compute_wait().

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Manos Pitsidianakis <el13635@mail.ntua.gr>
Message-id: 5b0b9e1ac6eb208d709eddc7b09e7669a523bff3.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/throttle.c | 62 +++++++++++++++++++++------------------------------------
 1 file changed, 23 insertions(+), 39 deletions(-)

diff --git a/util/throttle.c b/util/throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -XXX,XX +XXX,XX @@ static int64_t throttle_do_compute_wait(double limit, double extra)
 int64_t throttle_compute_wait(LeakyBucket *bkt)
 {
     double extra; /* the number of extra units blocking the io */
+    double bucket_size;   /* I/O before throttling to bkt->avg */
+    double burst_bucket_size; /* Before throttling to bkt->max */
 
     if (!bkt->avg) {
         return 0;
     }
 
-    /* If the bucket is full then we have to wait */
-    extra = bkt->level - bkt->max * bkt->burst_length;
+    if (!bkt->max) {
+        /* If bkt->max is 0 we still want to allow short bursts of I/O
+         * from the guest, otherwise every other request will be throttled
+         * and performance will suffer considerably. */
+        bucket_size = bkt->avg / 10;
+        burst_bucket_size = 0;
+    } else {
+        /* If we have a burst limit then we have to wait until all I/O
+         * at burst rate has finished before throttling to bkt->avg */
+        bucket_size = bkt->max * bkt->burst_length;
+        burst_bucket_size = bkt->max / 10;
+    }
+
+    /* If the main bucket is full then we have to wait */
+    extra = bkt->level - bucket_size;
     if (extra > 0) {
         return throttle_do_compute_wait(bkt->avg, extra);
     }
 
-    /* If the bucket is not full yet we have to make sure that we
-     * fulfill the goal of bkt->max units per second. */
+    /* If the main bucket is not full yet we still have to check the
+     * burst bucket in order to enforce the burst limit */
     if (bkt->burst_length > 1) {
-        /* We use 1/10 of the max value to smooth the throttling.
-         * See throttle_fix_bucket() for more details. */
-        extra = bkt->burst_level - bkt->max / 10;
+        extra = bkt->burst_level - burst_bucket_size;
         if (extra > 0) {
             return throttle_do_compute_wait(bkt->max, extra);
         }
@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
     return true;
 }
 
-/* fix bucket parameters */
-static void throttle_fix_bucket(LeakyBucket *bkt)
-{
-    double min;
-
-    /* zero bucket level */
-    bkt->level = bkt->burst_level = 0;
-
-    /* If bkt->max is 0 we still want to allow short bursts of I/O
-     * from the guest, otherwise every other request will be throttled
-     * and performance will suffer considerably. */
-    min = bkt->avg / 10;
-    if (bkt->avg && !bkt->max) {
-        bkt->max = min;
-    }
-}
-
-/* undo internal bucket parameter changes (see throttle_fix_bucket()) */
-static void throttle_unfix_bucket(LeakyBucket *bkt)
-{
-    if (bkt->max < bkt->avg) {
-        bkt->max = 0;
-    }
-}
-
 /* Used to configure the throttle
  *
  * @ts: the throttle state we are working on
@@ -XXX,XX +XXX,XX @@ void throttle_config(ThrottleState *ts,
 
     ts->cfg = *cfg;
 
+    /* Zero bucket level */
     for (i = 0; i < BUCKETS_COUNT; i++) {
-        throttle_fix_bucket(&ts->cfg.buckets[i]);
+        ts->cfg.buckets[i].level = 0;
+        ts->cfg.buckets[i].burst_level = 0;
     }
 
     ts->previous_leak = qemu_clock_get_ns(clock_type);
@@ -XXX,XX +XXX,XX @@ void throttle_config(ThrottleState *ts,
  */
 void throttle_get_config(ThrottleState *ts, ThrottleConfig *cfg)
 {
-    int i;
-
     *cfg = ts->cfg;
-
-    for (i = 0; i < BUCKETS_COUNT; i++) {
-        throttle_unfix_bucket(&cfg->buckets[i]);
-    }
 }
 
 
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

Both the throttling limits set with the throttling.iops-* and
throttling.bps-* options and their QMP equivalents defined in the
BlockIOThrottle struct are integer values.

Those limits are also reported in the BlockDeviceInfo struct and they
are integers there as well.

Therefore there's no reason to store them internally as double and do
the conversion everytime we're setting or querying them, so this patch
uses uint64_t for those types. Let's also use an unsigned type because
we don't allow negative values anyway.

LeakyBucket.level and LeakyBucket.burst_level do however remain double
because their value changes depending on the fraction of time elapsed
since the previous I/O operation.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: f29b840422767b5be2c41c2dfdbbbf6c5f8fedf8.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/throttle.h | 4 ++--
 tests/test-throttle.c   | 3 ++-
 util/throttle.c         | 7 +++----
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/throttle.h
+++ b/include/qemu/throttle.h
@@ -XXX,XX +XXX,XX @@ typedef enum {
  */
 
 typedef struct LeakyBucket {
-    double  avg;              /* average goal in units per second */
-    double  max;              /* leaky bucket max burst in units */
+    uint64_t avg;             /* average goal in units per second */
+    uint64_t max;             /* leaky bucket max burst in units */
     double  level;            /* bucket level in units */
     double  burst_level;      /* bucket level in units (for computing bursts) */
     unsigned burst_length;    /* max length of the burst period, in seconds */
diff --git a/tests/test-throttle.c b/tests/test-throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-throttle.c
+++ b/tests/test-throttle.c
@@ -XXX,XX +XXX,XX @@ static void test_enabled(void)
     for (i = 0; i < BUCKETS_COUNT; i++) {
         throttle_config_init(&cfg);
         set_cfg_value(false, i, 150);
+        g_assert(throttle_is_valid(&cfg, NULL));
         g_assert(throttle_enabled(&cfg));
     }
 
     for (i = 0; i < BUCKETS_COUNT; i++) {
         throttle_config_init(&cfg);
         set_cfg_value(false, i, -150);
-        g_assert(!throttle_enabled(&cfg));
+        g_assert(!throttle_is_valid(&cfg, NULL));
     }
 }
 
diff --git a/util/throttle.c b/util/throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -XXX,XX +XXX,XX @@ int64_t throttle_compute_wait(LeakyBucket *bkt)
         /* If bkt->max is 0 we still want to allow short bursts of I/O
          * from the guest, otherwise every other request will be throttled
          * and performance will suffer considerably. */
-        bucket_size = bkt->avg / 10;
+        bucket_size = (double) bkt->avg / 10;
         burst_bucket_size = 0;
     } else {
         /* If we have a burst limit then we have to wait until all I/O
          * at burst rate has finished before throttling to bkt->avg */
         bucket_size = bkt->max * bkt->burst_length;
-        burst_bucket_size = bkt->max / 10;
+        burst_bucket_size = (double) bkt->max / 10;
     }
 
     /* If the main bucket is full then we have to wait */
@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
 
     for (i = 0; i < BUCKETS_COUNT; i++) {
         LeakyBucket *bkt = &cfg->buckets[i];
-        if (bkt->avg < 0 || bkt->max < 0 ||
-            bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
+        if (bkt->avg > THROTTLE_VALUE_MAX || bkt->max > THROTTLE_VALUE_MAX) {
             error_setg(errp, "bps/iops/max values must be within [0, %lld]",
                        THROTTLE_VALUE_MAX);
             return false;
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

LeakyBucket.burst_length is defined as an unsigned integer but the
code never checks for overflows and it only makes sure that the value
is not 0.

In practice this means that the user can set something like
throttling.iops-total-max-length=4294967300 despite being larger than
UINT_MAX and the final value after casting to unsigned int will be 4.

This patch changes the data type to uint64_t. This does not increase
the storage size of LeakyBucket, and allows us to assign the value
directly from qemu_opt_get_number() or BlockIOThrottle and then do the
checks directly in throttle_is_valid().

The value of burst_length does not have a specific upper limit,
but since the bucket size is defined by max * burst_length we have
to prevent overflows. Instead of going for UINT64_MAX or something
similar this patch reuses THROTTLE_VALUE_MAX, which allows I/O bursts
of 1 GiB/s for 10 days in a row.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: 1b2e3049803f71cafb2e1fa1be4fb47147a0d398.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/throttle.h | 2 +-
 util/throttle.c         | 5 +++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/include/qemu/throttle.h b/include/qemu/throttle.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/throttle.h
+++ b/include/qemu/throttle.h
@@ -XXX,XX +XXX,XX @@ typedef struct LeakyBucket {
     uint64_t max;             /* leaky bucket max burst in units */
     double  level;            /* bucket level in units */
     double  burst_level;      /* bucket level in units (for computing bursts) */
-    unsigned burst_length;    /* max length of the burst period, in seconds */
+    uint64_t burst_length;    /* max length of the burst period, in seconds */
 } LeakyBucket;
 
 /* The following structure is used to configure a ThrottleState
diff --git a/util/throttle.c b/util/throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/util/throttle.c
+++ b/util/throttle.c
@@ -XXX,XX +XXX,XX @@ bool throttle_is_valid(ThrottleConfig *cfg, Error **errp)
             return false;
         }
 
+        if (bkt->max && bkt->burst_length > THROTTLE_VALUE_MAX / bkt->max) {
+            error_setg(errp, "burst length too high for this burst rate");
+            return false;
+        }
+
         if (bkt->max && !bkt->avg) {
             error_setg(errp, "bps_max/iops_max require corresponding"
                        " bps/iops values");
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-id: a57dd6274e1b6dc9c28769fec4c7ea543be5c5e3.1503580370.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/test-throttle.c | 77 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/tests/test-throttle.c b/tests/test-throttle.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-throttle.c
+++ b/tests/test-throttle.c
@@ -XXX,XX +XXX,XX @@ static void test_is_valid(void)
     test_is_valid_for_value(1, true);
 }
 
+static void test_ranges(void)
+{
+    int i;
+
+    for (i = 0; i < BUCKETS_COUNT; i++) {
+        LeakyBucket *b = &cfg.buckets[i];
+        throttle_config_init(&cfg);
+
+        /* avg = 0 means throttling is disabled, but the config is valid */
+        b->avg = 0;
+        g_assert(throttle_is_valid(&cfg, NULL));
+        g_assert(!throttle_enabled(&cfg));
+
+        /* These are valid configurations (values <= THROTTLE_VALUE_MAX) */
+        b->avg = 1;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = THROTTLE_VALUE_MAX;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = THROTTLE_VALUE_MAX;
+        b->max = THROTTLE_VALUE_MAX;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        /* Values over THROTTLE_VALUE_MAX are not allowed */
+        b->avg = THROTTLE_VALUE_MAX + 1;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+
+        b->avg = THROTTLE_VALUE_MAX;
+        b->max = THROTTLE_VALUE_MAX + 1;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+
+        /* burst_length must be between 1 and THROTTLE_VALUE_MAX */
+        b->avg = 1;
+        b->max = 1;
+        b->burst_length = 0;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = 1;
+        b->burst_length = 1;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = 1;
+        b->burst_length = THROTTLE_VALUE_MAX;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = 1;
+        b->burst_length = THROTTLE_VALUE_MAX + 1;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+
+        /* burst_length * max cannot exceed THROTTLE_VALUE_MAX */
+        b->avg = 1;
+        b->max = 2;
+        b->burst_length = THROTTLE_VALUE_MAX / 2;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = 3;
+        b->burst_length = THROTTLE_VALUE_MAX / 2;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = THROTTLE_VALUE_MAX;
+        b->burst_length = 1;
+        g_assert(throttle_is_valid(&cfg, NULL));
+
+        b->avg = 1;
+        b->max = THROTTLE_VALUE_MAX;
+        b->burst_length = 2;
+        g_assert(!throttle_is_valid(&cfg, NULL));
+    }
+}
+
 static void test_max_is_missing_limit(void)
 {
     int i;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/throttle/config/enabled",     test_enabled);
     g_test_add_func("/throttle/config/conflicting", test_conflicting_config);
     g_test_add_func("/throttle/config/is_valid",    test_is_valid);
+    g_test_add_func("/throttle/config/ranges",      test_ranges);
     g_test_add_func("/throttle/config/max",         test_max_is_missing_limit);
     g_test_add_func("/throttle/config/iops_size",
                     test_iops_size_is_missing_limit);
-- 
2.13.5

From: Eduardo Habkost <ehabkost@redhat.com>

If QEMU is running on a system that's out of memory and mmap()
fails, QEMU aborts with no error message at all, making it hard
to debug the reason for the failure.

Add perror() calls that will print error information before
aborting.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Tested-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Message-id: 20170829212053.6003-1-ehabkost@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/oslib-posix.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/util/oslib-posix.c b/util/oslib-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/oslib-posix.c
+++ b/util/oslib-posix.c
@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
     ptr = mmap(NULL, *sz, PROT_READ | PROT_WRITE,
                MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     if (ptr == MAP_FAILED) {
+        perror("failed to allocate memory for stack");
         abort();
     }
 
@@ -XXX,XX +XXX,XX @@ void *qemu_alloc_stack(size_t *sz)
     guardpage = ptr;
 #endif
     if (mprotect(guardpage, pagesz, PROT_NONE) != 0) {
+        perror("failed to set up stack guard page");
         abort();
     }
 
-- 
2.13.5

From: Alberto Garcia <berto@igalia.com>

There's a few cases which we're passing an Error pointer to a function
only to discard it immediately afterwards without checking it. In
these cases we can simply remove the variable and pass NULL instead.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-id: 20170829120836.16091-1-berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/qcow.c  | 12 +++---------
 block/qcow2.c |  8 ++------
 dump.c        |  4 +---
 3 files changed, 6 insertions(+), 18 deletions(-)

diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static uint64_t get_cluster_offset(BlockDriverState *bs,
                     start_sect = (offset & ~(s->cluster_size - 1)) >> 9;
                     for(i = 0; i < s->cluster_sectors; i++) {
                         if (i < n_start || i >= n_end) {
-                            Error *err = NULL;
                             memset(s->cluster_data, 0x00, 512);
                             if (qcrypto_block_encrypt(s->crypto, start_sect + i,
                                                       s->cluster_data,
                                                       BDRV_SECTOR_SIZE,
-                                                      &err) < 0) {
-                                error_free(err);
+                                                      NULL) < 0) {
                                 errno = EIO;
                                 return -1;
                             }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
     QEMUIOVector hd_qiov;
     uint8_t *buf;
     void *orig_buf;
-    Error *err = NULL;
 
     if (qiov->niov > 1) {
         buf = orig_buf = qemu_try_blockalign(bs, qiov->size);
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
             if (bs->encrypted) {
                 assert(s->crypto);
                 if (qcrypto_block_decrypt(s->crypto, sector_num, buf,
-                                          n * BDRV_SECTOR_SIZE, &err) < 0) {
+                                          n * BDRV_SECTOR_SIZE, NULL) < 0) {
                     goto fail;
                 }
             }
@@ -XXX,XX +XXX,XX @@ done:
     return ret;
 
 fail:
-    error_free(err);
     ret = -EIO;
     goto done;
 }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
             break;
         }
         if (bs->encrypted) {
-            Error *err = NULL;
             assert(s->crypto);
             if (qcrypto_block_encrypt(s->crypto, sector_num, buf,
-                                      n * BDRV_SECTOR_SIZE, &err) < 0) {
-                error_free(err);
+                                      n * BDRV_SECTOR_SIZE, NULL) < 0) {
                 ret = -EIO;
                 break;
             }
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 coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
                 assert(s->crypto);
                 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
                 assert((cur_bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
-                Error *err = NULL;
                 if (qcrypto_block_decrypt(s->crypto,
                                           (s->crypt_physical_offset ?
                                            cluster_offset + offset_in_cluster :
                                            offset) >> BDRV_SECTOR_BITS,
                                           cluster_data,
                                           cur_bytes,
-                                          &err) < 0) {
-                    error_free(err);
+                                          NULL) < 0) {
                     ret = -EIO;
                     goto fail;
                 }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
         qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
 
         if (bs->encrypted) {
-            Error *err = NULL;
             assert(s->crypto);
             if (!cluster_data) {
                 cluster_data = qemu_try_blockalign(bs->file->bs,
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
                                        cluster_offset + offset_in_cluster :
                                        offset) >> BDRV_SECTOR_BITS,
                                       cluster_data,
-                                      cur_bytes, &err) < 0) {
-                error_free(err);
+                                      cur_bytes, NULL) < 0) {
                 ret = -EIO;
                 goto fail;
             }
diff --git a/dump.c b/dump.c
index XXXXXXX..XXXXXXX 100644
--- a/dump.c
+++ b/dump.c
@@ -XXX,XX +XXX,XX @@ static void dump_process(DumpState *s, Error **errp)
 
 static void *dump_thread(void *data)
 {
-    Error *err = NULL;
     DumpState *s = (DumpState *)data;
-    dump_process(s, &err);
-    error_free(err);
+    dump_process(s, NULL);
     return NULL;
 }
 
-- 
2.13.5

The minimum Python version supported by QEMU is 2.6.  The argparse
standard library module was only added in Python 2.7.  Many scripts
would like to use argparse because it supports command-line
sub-commands.

This patch adds argparse.  See the top of argparse.py for details.

Suggested-by: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: John Snow <jsnow@redhat.com>
Message-id: 20170825155732.15665-2-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 COPYING.PYTHON      |  270 ++++++
 scripts/argparse.py | 2406 +++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 2676 insertions(+)
 create mode 100644 COPYING.PYTHON
 create mode 100644 scripts/argparse.py

diff --git a/COPYING.PYTHON b/COPYING.PYTHON
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/COPYING.PYTHON
@@ -XXX,XX +XXX,XX @@
+A. HISTORY OF THE SOFTWARE
+==========================
+
+Python was created in the early 1990s by Guido van Rossum at Stichting
+Mathematisch Centrum (CWI, see http://www.cwi.nl) in the Netherlands
+as a successor of a language called ABC.  Guido remains Python's
+principal author, although it includes many contributions from others.
+
+In 1995, Guido continued his work on Python at the Corporation for
+National Research Initiatives (CNRI, see http://www.cnri.reston.va.us)
+in Reston, Virginia where he released several versions of the
+software.
+
+In May 2000, Guido and the Python core development team moved to
+BeOpen.com to form the BeOpen PythonLabs team.  In October of the same
+year, the PythonLabs team moved to Digital Creations (now Zope
+Corporation, see http://www.zope.com).  In 2001, the Python Software
+Foundation (PSF, see http://www.python.org/psf/) was formed, a
+non-profit organization created specifically to own Python-related
+Intellectual Property.  Zope Corporation is a sponsoring member of
+the PSF.
+
+All Python releases are Open Source (see http://www.opensource.org for
+the Open Source Definition).  Historically, most, but not all, Python
+releases have also been GPL-compatible; the table below summarizes
+the various releases.
+
+    Release         Derived     Year        Owner       GPL-
+                    from                                compatible? (1)
+
+    0.9.0 thru 1.2              1991-1995   CWI         yes
+    1.3 thru 1.5.2  1.2         1995-1999   CNRI        yes
+    1.6             1.5.2       2000        CNRI        no
+    2.0             1.6         2000        BeOpen.com  no
+    1.6.1           1.6         2001        CNRI        yes (2)
+    2.1             2.0+1.6.1   2001        PSF         no
+    2.0.1           2.0+1.6.1   2001        PSF         yes
+    2.1.1           2.1+2.0.1   2001        PSF         yes
+    2.2             2.1.1       2001        PSF         yes
+    2.1.2           2.1.1       2002        PSF         yes
+    2.1.3           2.1.2       2002        PSF         yes
+    2.2.1           2.2         2002        PSF         yes
+    2.2.2           2.2.1       2002        PSF         yes
+    2.2.3           2.2.2       2003        PSF         yes
+    2.3             2.2.2       2002-2003   PSF         yes
+    2.3.1           2.3         2002-2003   PSF         yes
+    2.3.2           2.3.1       2002-2003   PSF         yes
+    2.3.3           2.3.2       2002-2003   PSF         yes
+    2.3.4           2.3.3       2004        PSF         yes
+    2.3.5           2.3.4       2005        PSF         yes
+    2.4             2.3         2004        PSF         yes
+    2.4.1           2.4         2005        PSF         yes
+    2.4.2           2.4.1       2005        PSF         yes
+    2.4.3           2.4.2       2006        PSF         yes
+    2.5             2.4         2006        PSF         yes
+    2.7             2.6         2010        PSF         yes
+
+Footnotes:
+
+(1) GPL-compatible doesn't mean that we're distributing Python under
+    the GPL.  All Python licenses, unlike the GPL, let you distribute
+    a modified version without making your changes open source.  The
+    GPL-compatible licenses make it possible to combine Python with
+    other software that is released under the GPL; the others don't.
+
+(2) According to Richard Stallman, 1.6.1 is not GPL-compatible,
+    because its license has a choice of law clause.  According to
+    CNRI, however, Stallman's lawyer has told CNRI's lawyer that 1.6.1
+    is "not incompatible" with the GPL.
+
+Thanks to the many outside volunteers who have worked under Guido's
+direction to make these releases possible.
+
+
+B. TERMS AND CONDITIONS FOR ACCESSING OR OTHERWISE USING PYTHON
+===============================================================
+
+PYTHON SOFTWARE FOUNDATION LICENSE VERSION 2
+--------------------------------------------
+
+1. This LICENSE AGREEMENT is between the Python Software Foundation
+("PSF"), and the Individual or Organization ("Licensee") accessing and
+otherwise using this software ("Python") in source or binary form and
+its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, PSF
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python
+alone or in any derivative version, provided, however, that PSF's
+License Agreement and PSF's notice of copyright, i.e., "Copyright (c)
+2001, 2002, 2003, 2004, 2005, 2006 Python Software Foundation; All Rights
+Reserved" are retained in Python alone or in any derivative version 
+prepared by Licensee.
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python.
+
+4. PSF is making Python available to Licensee on an "AS IS"
+basis.  PSF MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, PSF MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. PSF SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. Nothing in this License Agreement shall be deemed to create any
+relationship of agency, partnership, or joint venture between PSF and
+Licensee.  This License Agreement does not grant permission to use PSF
+trademarks or trade name in a trademark sense to endorse or promote
+products or services of Licensee, or any third party.
+
+8. By copying, installing or otherwise using Python, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+BEOPEN.COM LICENSE AGREEMENT FOR PYTHON 2.0
+-------------------------------------------
+
+BEOPEN PYTHON OPEN SOURCE LICENSE AGREEMENT VERSION 1
+
+1. This LICENSE AGREEMENT is between BeOpen.com ("BeOpen"), having an
+office at 160 Saratoga Avenue, Santa Clara, CA 95051, and the
+Individual or Organization ("Licensee") accessing and otherwise using
+this software in source or binary form and its associated
+documentation ("the Software").
+
+2. Subject to the terms and conditions of this BeOpen Python License
+Agreement, BeOpen hereby grants Licensee a non-exclusive,
+royalty-free, world-wide license to reproduce, analyze, test, perform
+and/or display publicly, prepare derivative works, distribute, and
+otherwise use the Software alone or in any derivative version,
+provided, however, that the BeOpen Python License is retained in the
+Software, alone or in any derivative version prepared by Licensee.
+
+3. BeOpen is making the Software available to Licensee on an "AS IS"
+basis.  BEOPEN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, BEOPEN MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+4. BEOPEN SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF THE
+SOFTWARE FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS
+AS A RESULT OF USING, MODIFYING OR DISTRIBUTING THE SOFTWARE, OR ANY
+DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+5. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+6. This License Agreement shall be governed by and interpreted in all
+respects by the law of the State of California, excluding conflict of
+law provisions.  Nothing in this License Agreement shall be deemed to
+create any relationship of agency, partnership, or joint venture
+between BeOpen and Licensee.  This License Agreement does not grant
+permission to use BeOpen trademarks or trade names in a trademark
+sense to endorse or promote products or services of Licensee, or any
+third party.  As an exception, the "BeOpen Python" logos available at
+http://www.pythonlabs.com/logos.html may be used according to the
+permissions granted on that web page.
+
+7. By copying, installing or otherwise using the software, Licensee
+agrees to be bound by the terms and conditions of this License
+Agreement.
+
+
+CNRI LICENSE AGREEMENT FOR PYTHON 1.6.1
+---------------------------------------
+
+1. This LICENSE AGREEMENT is between the Corporation for National
+Research Initiatives, having an office at 1895 Preston White Drive,
+Reston, VA 20191 ("CNRI"), and the Individual or Organization
+("Licensee") accessing and otherwise using Python 1.6.1 software in
+source or binary form and its associated documentation.
+
+2. Subject to the terms and conditions of this License Agreement, CNRI
+hereby grants Licensee a nonexclusive, royalty-free, world-wide
+license to reproduce, analyze, test, perform and/or display publicly,
+prepare derivative works, distribute, and otherwise use Python 1.6.1
+alone or in any derivative version, provided, however, that CNRI's
+License Agreement and CNRI's notice of copyright, i.e., "Copyright (c)
+1995-2001 Corporation for National Research Initiatives; All Rights
+Reserved" are retained in Python 1.6.1 alone or in any derivative
+version prepared by Licensee.  Alternately, in lieu of CNRI's License
+Agreement, Licensee may substitute the following text (omitting the
+quotes): "Python 1.6.1 is made available subject to the terms and
+conditions in CNRI's License Agreement.  This Agreement together with
+Python 1.6.1 may be located on the Internet using the following
+unique, persistent identifier (known as a handle): 1895.22/1013.  This
+Agreement may also be obtained from a proxy server on the Internet
+using the following URL: http://hdl.handle.net/1895.22/1013".
+
+3. In the event Licensee prepares a derivative work that is based on
+or incorporates Python 1.6.1 or any part thereof, and wants to make
+the derivative work available to others as provided herein, then
+Licensee hereby agrees to include in any such work a brief summary of
+the changes made to Python 1.6.1.
+
+4. CNRI is making Python 1.6.1 available to Licensee on an "AS IS"
+basis.  CNRI MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR
+IMPLIED.  BY WAY OF EXAMPLE, BUT NOT LIMITATION, CNRI MAKES NO AND
+DISCLAIMS ANY REPRESENTATION OR WARRANTY OF MERCHANTABILITY OR FITNESS
+FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF PYTHON 1.6.1 WILL NOT
+INFRINGE ANY THIRD PARTY RIGHTS.
+
+5. CNRI SHALL NOT BE LIABLE TO LICENSEE OR ANY OTHER USERS OF PYTHON
+1.6.1 FOR ANY INCIDENTAL, SPECIAL, OR CONSEQUENTIAL DAMAGES OR LOSS AS
+A RESULT OF MODIFYING, DISTRIBUTING, OR OTHERWISE USING PYTHON 1.6.1,
+OR ANY DERIVATIVE THEREOF, EVEN IF ADVISED OF THE POSSIBILITY THEREOF.
+
+6. This License Agreement will automatically terminate upon a material
+breach of its terms and conditions.
+
+7. This License Agreement shall be governed by the federal
+intellectual property law of the United States, including without
+limitation the federal copyright law, and, to the extent such
+U.S. federal law does not apply, by the law of the Commonwealth of
+Virginia, excluding Virginia's conflict of law provisions.
+Notwithstanding the foregoing, with regard to derivative works based
+on Python 1.6.1 that incorporate non-separable material that was
+previously distributed under the GNU General Public License (GPL), the
+law of the Commonwealth of Virginia shall govern this License
+Agreement only as to issues arising under or with respect to
+Paragraphs 4, 5, and 7 of this License Agreement.  Nothing in this
+License Agreement shall be deemed to create any relationship of
+agency, partnership, or joint venture between CNRI and Licensee.  This
+License Agreement does not grant permission to use CNRI trademarks or
+trade name in a trademark sense to endorse or promote products or
+services of Licensee, or any third party.
+
+8. By clicking on the "ACCEPT" button where indicated, or by copying,
+installing or otherwise using Python 1.6.1, Licensee agrees to be
+bound by the terms and conditions of this License Agreement.
+
+        ACCEPT
+
+
+CWI LICENSE AGREEMENT FOR PYTHON 0.9.0 THROUGH 1.2
+--------------------------------------------------
+
+Copyright (c) 1991 - 1995, Stichting Mathematisch Centrum Amsterdam,
+The Netherlands.  All rights reserved.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Stichting Mathematisch
+Centrum or CWI not be used in advertising or publicity pertaining to
+distribution of the software without specific, written prior
+permission.
+
+STICHTING MATHEMATISCH CENTRUM DISCLAIMS ALL WARRANTIES WITH REGARD TO
+THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH CENTRUM BE LIABLE
+FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
diff --git a/scripts/argparse.py b/scripts/argparse.py
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/scripts/argparse.py
@@ -XXX,XX +XXX,XX @@
+# This is a local copy of the standard library argparse module taken from PyPI.
+# It is licensed under the Python Software Foundation License.  This is a
+# fallback for Python 2.6 which does not include this module.  Python 2.7+ and
+# 3+ will never load this module because built-in modules are loaded before
+# anything in sys.path.
+#
+# If your script is not located in the same directory as this file, import it
+# like this:
+#
+#   import os
+#   import sys
+#   sys.path.append(os.path.join(os.path.dirname(__file__), ..., 'scripts'))
+#   import argparse
+
+# Author: Steven J. Bethard <steven.bethard@gmail.com>.
+# Maintainer: Thomas Waldmann <tw@waldmann-edv.de>
+
+"""Command-line parsing library
+
+This module is an optparse-inspired command-line parsing library that:
+
+    - handles both optional and positional arguments
+    - produces highly informative usage messages
+    - supports parsers that dispatch to sub-parsers
+
+The following is a simple usage example that sums integers from the
+command-line and writes the result to a file::
+
+    parser = argparse.ArgumentParser(
+        description='sum the integers at the command line')
+    parser.add_argument(
+        'integers', metavar='int', nargs='+', type=int,
+        help='an integer to be summed')
+    parser.add_argument(
+        '--log', default=sys.stdout, type=argparse.FileType('w'),
+        help='the file where the sum should be written')
+    args = parser.parse_args()
+    args.log.write('%s' % sum(args.integers))
+    args.log.close()
+
+The module contains the following public classes:
+
+    - ArgumentParser -- The main entry point for command-line parsing. As the
+        example above shows, the add_argument() method is used to populate
+        the parser with actions for optional and positional arguments. Then
+        the parse_args() method is invoked to convert the args at the
+        command-line into an object with attributes.
+
+    - ArgumentError -- The exception raised by ArgumentParser objects when
+        there are errors with the parser's actions. Errors raised while
+        parsing the command-line are caught by ArgumentParser and emitted
+        as command-line messages.
+
+    - FileType -- A factory for defining types of files to be created. As the
+        example above shows, instances of FileType are typically passed as
+        the type= argument of add_argument() calls.
+
+    - Action -- The base class for parser actions. Typically actions are
+        selected by passing strings like 'store_true' or 'append_const' to
+        the action= argument of add_argument(). However, for greater
+        customization of ArgumentParser actions, subclasses of Action may
+        be defined and passed as the action= argument.
+
+    - HelpFormatter, RawDescriptionHelpFormatter, RawTextHelpFormatter,
+        ArgumentDefaultsHelpFormatter -- Formatter classes which
+        may be passed as the formatter_class= argument to the
+        ArgumentParser constructor. HelpFormatter is the default,
+        RawDescriptionHelpFormatter and RawTextHelpFormatter tell the parser
+        not to change the formatting for help text, and
+        ArgumentDefaultsHelpFormatter adds information about argument defaults
+        to the help.
+
+All other classes in this module are considered implementation details.
+(Also note that HelpFormatter and RawDescriptionHelpFormatter are only
+considered public as object names -- the API of the formatter objects is
+still considered an implementation detail.)
+"""
+
+__version__ = '1.4.0'  # we use our own version number independant of the
+                       # one in stdlib and we release this on pypi.
+
+__external_lib__ = True  # to make sure the tests really test THIS lib,
+                         # not the builtin one in Python stdlib
+
+__all__ = [
+    'ArgumentParser',
+    'ArgumentError',
+    'ArgumentTypeError',
+    'FileType',
+    'HelpFormatter',
+    'ArgumentDefaultsHelpFormatter',
+    'RawDescriptionHelpFormatter',
+    'RawTextHelpFormatter',
+    'Namespace',
+    'Action',
+    'ONE_OR_MORE',
+    'OPTIONAL',
+    'PARSER',
+    'REMAINDER',
+    'SUPPRESS',
+    'ZERO_OR_MORE',
+]
+
+
+import copy as _copy
+import os as _os
+import re as _re
+import sys as _sys
+import textwrap as _textwrap
+
+from gettext import gettext as _
+
+try:
+    set
+except NameError:
+    # for python < 2.4 compatibility (sets module is there since 2.3):
+    from sets import Set as set
+
+try:
+    basestring
+except NameError:
+    basestring = str
+
+try:
+    sorted
+except NameError:
+    # for python < 2.4 compatibility:
+    def sorted(iterable, reverse=False):
+        result = list(iterable)
+        result.sort()
+        if reverse:
+            result.reverse()
+        return result
+
+
+def _callable(obj):
+    return hasattr(obj, '__call__') or hasattr(obj, '__bases__')
+
+
+SUPPRESS = '==SUPPRESS=='
+
+OPTIONAL = '?'
+ZERO_OR_MORE = '*'
+ONE_OR_MORE = '+'
+PARSER = 'A...'
+REMAINDER = '...'
+_UNRECOGNIZED_ARGS_ATTR = '_unrecognized_args'
+
+# =============================
+# Utility functions and classes
+# =============================
+
+class _AttributeHolder(object):
+    """Abstract base class that provides __repr__.
+
+    The __repr__ method returns a string in the format::
+        ClassName(attr=name, attr=name, ...)
+    The attributes are determined either by a class-level attribute,
+    '_kwarg_names', or by inspecting the instance __dict__.
+    """
+
+    def __repr__(self):
+        type_name = type(self).__name__
+        arg_strings = []
+        for arg in self._get_args():
+            arg_strings.append(repr(arg))
+        for name, value in self._get_kwargs():
+            arg_strings.append('%s=%r' % (name, value))
+        return '%s(%s)' % (type_name, ', '.join(arg_strings))
+
+    def _get_kwargs(self):
+        return sorted(self.__dict__.items())
+
+    def _get_args(self):
+        return []
+
+
+def _ensure_value(namespace, name, value):
+    if getattr(namespace, name, None) is None:
+        setattr(namespace, name, value)
+    return getattr(namespace, name)
+
+
+# ===============
+# Formatting Help
+# ===============
+
+class HelpFormatter(object):
+    """Formatter for generating usage messages and argument help strings.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def __init__(self,
+                 prog,
+                 indent_increment=2,
+                 max_help_position=24,
+                 width=None):
+
+        # default setting for width
+        if width is None:
+            try:
+                width = int(_os.environ['COLUMNS'])
+            except (KeyError, ValueError):
+                width = 80
+            width -= 2
+
+        self._prog = prog
+        self._indent_increment = indent_increment
+        self._max_help_position = max_help_position
+        self._width = width
+
+        self._current_indent = 0
+        self._level = 0
+        self._action_max_length = 0
+
+        self._root_section = self._Section(self, None)
+        self._current_section = self._root_section
+
+        self._whitespace_matcher = _re.compile(r'\s+')
+        self._long_break_matcher = _re.compile(r'\n\n\n+')
+
+    # ===============================
+    # Section and indentation methods
+    # ===============================
+    def _indent(self):
+        self._current_indent += self._indent_increment
+        self._level += 1
+
+    def _dedent(self):
+        self._current_indent -= self._indent_increment
+        assert self._current_indent >= 0, 'Indent decreased below 0.'
+        self._level -= 1
+
+    class _Section(object):
+
+        def __init__(self, formatter, parent, heading=None):
+            self.formatter = formatter
+            self.parent = parent
+            self.heading = heading
+            self.items = []
+
+        def format_help(self):
+            # format the indented section
+            if self.parent is not None:
+                self.formatter._indent()
+            join = self.formatter._join_parts
+            for func, args in self.items:
+                func(*args)
+            item_help = join([func(*args) for func, args in self.items])
+            if self.parent is not None:
+                self.formatter._dedent()
+
+            # return nothing if the section was empty
+            if not item_help:
+                return ''
+
+            # add the heading if the section was non-empty
+            if self.heading is not SUPPRESS and self.heading is not None:
+                current_indent = self.formatter._current_indent
+                heading = '%*s%s:\n' % (current_indent, '', self.heading)
+            else:
+                heading = ''
+
+            # join the section-initial newline, the heading and the help
+            return join(['\n', heading, item_help, '\n'])
+
+    def _add_item(self, func, args):
+        self._current_section.items.append((func, args))
+
+    # ========================
+    # Message building methods
+    # ========================
+    def start_section(self, heading):
+        self._indent()
+        section = self._Section(self, self._current_section, heading)
+        self._add_item(section.format_help, [])
+        self._current_section = section
+
+    def end_section(self):
+        self._current_section = self._current_section.parent
+        self._dedent()
+
+    def add_text(self, text):
+        if text is not SUPPRESS and text is not None:
+            self._add_item(self._format_text, [text])
+
+    def add_usage(self, usage, actions, groups, prefix=None):
+        if usage is not SUPPRESS:
+            args = usage, actions, groups, prefix
+            self._add_item(self._format_usage, args)
+
+    def add_argument(self, action):
+        if action.help is not SUPPRESS:
+
+            # find all invocations
+            get_invocation = self._format_action_invocation
+            invocations = [get_invocation(action)]
+            for subaction in self._iter_indented_subactions(action):
+                invocations.append(get_invocation(subaction))
+
+            # update the maximum item length
+            invocation_length = max([len(s) for s in invocations])
+            action_length = invocation_length + self._current_indent
+            self._action_max_length = max(self._action_max_length,
+                                          action_length)
+
+            # add the item to the list
+            self._add_item(self._format_action, [action])
+
+    def add_arguments(self, actions):
+        for action in actions:
+            self.add_argument(action)
+
+    # =======================
+    # Help-formatting methods
+    # =======================
+    def format_help(self):
+        help = self._root_section.format_help()
+        if help:
+            help = self._long_break_matcher.sub('\n\n', help)
+            help = help.strip('\n') + '\n'
+        return help
+
+    def _join_parts(self, part_strings):
+        return ''.join([part
+                        for part in part_strings
+                        if part and part is not SUPPRESS])
+
+    def _format_usage(self, usage, actions, groups, prefix):
+        if prefix is None:
+            prefix = _('usage: ')
+
+        # if usage is specified, use that
+        if usage is not None:
+            usage = usage % dict(prog=self._prog)
+
+        # if no optionals or positionals are available, usage is just prog
+        elif usage is None and not actions:
+            usage = '%(prog)s' % dict(prog=self._prog)
+
+        # if optionals and positionals are available, calculate usage
+        elif usage is None:
+            prog = '%(prog)s' % dict(prog=self._prog)
+
+            # split optionals from positionals
+            optionals = []
+            positionals = []
+            for action in actions:
+                if action.option_strings:
+                    optionals.append(action)
+                else:
+                    positionals.append(action)
+
+            # build full usage string
+            format = self._format_actions_usage
+            action_usage = format(optionals + positionals, groups)
+            usage = ' '.join([s for s in [prog, action_usage] if s])
+
+            # wrap the usage parts if it's too long
+            text_width = self._width - self._current_indent
+            if len(prefix) + len(usage) > text_width:
+
+                # break usage into wrappable parts
+                part_regexp = r'$.*?$+|\[.*?\]+|\S+'
+                opt_usage = format(optionals, groups)
+                pos_usage = format(positionals, groups)
+                opt_parts = _re.findall(part_regexp, opt_usage)
+                pos_parts = _re.findall(part_regexp, pos_usage)
+                assert ' '.join(opt_parts) == opt_usage
+                assert ' '.join(pos_parts) == pos_usage
+
+                # helper for wrapping lines
+                def get_lines(parts, indent, prefix=None):
+                    lines = []
+                    line = []
+                    if prefix is not None:
+                        line_len = len(prefix) - 1
+                    else:
+                        line_len = len(indent) - 1
+                    for part in parts:
+                        if line_len + 1 + len(part) > text_width:
+                            lines.append(indent + ' '.join(line))
+                            line = []
+                            line_len = len(indent) - 1
+                        line.append(part)
+                        line_len += len(part) + 1
+                    if line:
+                        lines.append(indent + ' '.join(line))
+                    if prefix is not None:
+                        lines[0] = lines[0][len(indent):]
+                    return lines
+
+                # if prog is short, follow it with optionals or positionals
+                if len(prefix) + len(prog) <= 0.75 * text_width:
+                    indent = ' ' * (len(prefix) + len(prog) + 1)
+                    if opt_parts:
+                        lines = get_lines([prog] + opt_parts, indent, prefix)
+                        lines.extend(get_lines(pos_parts, indent))
+                    elif pos_parts:
+                        lines = get_lines([prog] + pos_parts, indent, prefix)
+                    else:
+                        lines = [prog]
+
+                # if prog is long, put it on its own line
+                else:
+                    indent = ' ' * len(prefix)
+                    parts = opt_parts + pos_parts
+                    lines = get_lines(parts, indent)
+                    if len(lines) > 1:
+                        lines = []
+                        lines.extend(get_lines(opt_parts, indent))
+                        lines.extend(get_lines(pos_parts, indent))
+                    lines = [prog] + lines
+
+                # join lines into usage
+                usage = '\n'.join(lines)
+
+        # prefix with 'usage:'
+        return '%s%s\n\n' % (prefix, usage)
+
+    def _format_actions_usage(self, actions, groups):
+        # find group indices and identify actions in groups
+        group_actions = set()
+        inserts = {}
+        for group in groups:
+            try:
+                start = actions.index(group._group_actions[0])
+            except ValueError:
+                continue
+            else:
+                end = start + len(group._group_actions)
+                if actions[start:end] == group._group_actions:
+                    for action in group._group_actions:
+                        group_actions.add(action)
+                    if not group.required:
+                        if start in inserts:
+                            inserts[start] += ' ['
+                        else:
+                            inserts[start] = '['
+                        inserts[end] = ']'
+                    else:
+                        if start in inserts:
+                            inserts[start] += ' ('
+                        else:
+                            inserts[start] = '('
+                        inserts[end] = ')'
+                    for i in range(start + 1, end):
+                        inserts[i] = '|'
+
+        # collect all actions format strings
+        parts = []
+        for i, action in enumerate(actions):
+
+            # suppressed arguments are marked with None
+            # remove | separators for suppressed arguments
+            if action.help is SUPPRESS:
+                parts.append(None)
+                if inserts.get(i) == '|':
+                    inserts.pop(i)
+                elif inserts.get(i + 1) == '|':
+                    inserts.pop(i + 1)
+
+            # produce all arg strings
+            elif not action.option_strings:
+                part = self._format_args(action, action.dest)
+
+                # if it's in a group, strip the outer []
+                if action in group_actions:
+                    if part[0] == '[' and part[-1] == ']':
+                        part = part[1:-1]
+
+                # add the action string to the list
+                parts.append(part)
+
+            # produce the first way to invoke the option in brackets
+            else:
+                option_string = action.option_strings[0]
+
+                # if the Optional doesn't take a value, format is:
+                #    -s or --long
+                if action.nargs == 0:
+                    part = '%s' % option_string
+
+                # if the Optional takes a value, format is:
+                #    -s ARGS or --long ARGS
+                else:
+                    default = action.dest.upper()
+                    args_string = self._format_args(action, default)
+                    part = '%s %s' % (option_string, args_string)
+
+                # make it look optional if it's not required or in a group
+                if not action.required and action not in group_actions:
+                    part = '[%s]' % part
+
+                # add the action string to the list
+                parts.append(part)
+
+        # insert things at the necessary indices
+        for i in sorted(inserts, reverse=True):
+            parts[i:i] = [inserts[i]]
+
+        # join all the action items with spaces
+        text = ' '.join([item for item in parts if item is not None])
+
+        # clean up separators for mutually exclusive groups
+        open = r'[\[(]'
+        close = r'[\])]'
+        text = _re.sub(r'(%s) ' % open, r'\1', text)
+        text = _re.sub(r' (%s)' % close, r'\1', text)
+        text = _re.sub(r'%s *%s' % (open, close), r'', text)
+        text = _re.sub(r'$([^|]*)$', r'\1', text)
+        text = text.strip()
+
+        # return the text
+        return text
+
+    def _format_text(self, text):
+        if '%(prog)' in text:
+            text = text % dict(prog=self._prog)
+        text_width = self._width - self._current_indent
+        indent = ' ' * self._current_indent
+        return self._fill_text(text, text_width, indent) + '\n\n'
+
+    def _format_action(self, action):
+        # determine the required width and the entry label
+        help_position = min(self._action_max_length + 2,
+                            self._max_help_position)
+        help_width = self._width - help_position
+        action_width = help_position - self._current_indent - 2
+        action_header = self._format_action_invocation(action)
+
+        # ho nelp; start on same line and add a final newline
+        if not action.help:
+            tup = self._current_indent, '', action_header
+            action_header = '%*s%s\n' % tup
+
+        # short action name; start on the same line and pad two spaces
+        elif len(action_header) <= action_width:
+            tup = self._current_indent, '', action_width, action_header
+            action_header = '%*s%-*s  ' % tup
+            indent_first = 0
+
+        # long action name; start on the next line
+        else:
+            tup = self._current_indent, '', action_header
+            action_header = '%*s%s\n' % tup
+            indent_first = help_position
+
+        # collect the pieces of the action help
+        parts = [action_header]
+
+        # if there was help for the action, add lines of help text
+        if action.help:
+            help_text = self._expand_help(action)
+            help_lines = self._split_lines(help_text, help_width)
+            parts.append('%*s%s\n' % (indent_first, '', help_lines[0]))
+            for line in help_lines[1:]:
+                parts.append('%*s%s\n' % (help_position, '', line))
+
+        # or add a newline if the description doesn't end with one
+        elif not action_header.endswith('\n'):
+            parts.append('\n')
+
+        # if there are any sub-actions, add their help as well
+        for subaction in self._iter_indented_subactions(action):
+            parts.append(self._format_action(subaction))
+
+        # return a single string
+        return self._join_parts(parts)
+
+    def _format_action_invocation(self, action):
+        if not action.option_strings:
+            metavar, = self._metavar_formatter(action, action.dest)(1)
+            return metavar
+
+        else:
+            parts = []
+
+            # if the Optional doesn't take a value, format is:
+            #    -s, --long
+            if action.nargs == 0:
+                parts.extend(action.option_strings)
+
+            # if the Optional takes a value, format is:
+            #    -s ARGS, --long ARGS
+            else:
+                default = action.dest.upper()
+                args_string = self._format_args(action, default)
+                for option_string in action.option_strings:
+                    parts.append('%s %s' % (option_string, args_string))
+
+            return ', '.join(parts)
+
+    def _metavar_formatter(self, action, default_metavar):
+        if action.metavar is not None:
+            result = action.metavar
+        elif action.choices is not None:
+            choice_strs = [str(choice) for choice in action.choices]
+            result = '{%s}' % ','.join(choice_strs)
+        else:
+            result = default_metavar
+
+        def format(tuple_size):
+            if isinstance(result, tuple):
+                return result
+            else:
+                return (result, ) * tuple_size
+        return format
+
+    def _format_args(self, action, default_metavar):
+        get_metavar = self._metavar_formatter(action, default_metavar)
+        if action.nargs is None:
+            result = '%s' % get_metavar(1)
+        elif action.nargs == OPTIONAL:
+            result = '[%s]' % get_metavar(1)
+        elif action.nargs == ZERO_OR_MORE:
+            result = '[%s [%s ...]]' % get_metavar(2)
+        elif action.nargs == ONE_OR_MORE:
+            result = '%s [%s ...]' % get_metavar(2)
+        elif action.nargs == REMAINDER:
+            result = '...'
+        elif action.nargs == PARSER:
+            result = '%s ...' % get_metavar(1)
+        else:
+            formats = ['%s' for _ in range(action.nargs)]
+            result = ' '.join(formats) % get_metavar(action.nargs)
+        return result
+
+    def _expand_help(self, action):
+        params = dict(vars(action), prog=self._prog)
+        for name in list(params):
+            if params[name] is SUPPRESS:
+                del params[name]
+        for name in list(params):
+            if hasattr(params[name], '__name__'):
+                params[name] = params[name].__name__
+        if params.get('choices') is not None:
+            choices_str = ', '.join([str(c) for c in params['choices']])
+            params['choices'] = choices_str
+        return self._get_help_string(action) % params
+
+    def _iter_indented_subactions(self, action):
+        try:
+            get_subactions = action._get_subactions
+        except AttributeError:
+            pass
+        else:
+            self._indent()
+            for subaction in get_subactions():
+                yield subaction
+            self._dedent()
+
+    def _split_lines(self, text, width):
+        text = self._whitespace_matcher.sub(' ', text).strip()
+        return _textwrap.wrap(text, width)
+
+    def _fill_text(self, text, width, indent):
+        text = self._whitespace_matcher.sub(' ', text).strip()
+        return _textwrap.fill(text, width, initial_indent=indent,
+                                           subsequent_indent=indent)
+
+    def _get_help_string(self, action):
+        return action.help
+
+
+class RawDescriptionHelpFormatter(HelpFormatter):
+    """Help message formatter which retains any formatting in descriptions.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _fill_text(self, text, width, indent):
+        return ''.join([indent + line for line in text.splitlines(True)])
+
+
+class RawTextHelpFormatter(RawDescriptionHelpFormatter):
+    """Help message formatter which retains formatting of all help text.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _split_lines(self, text, width):
+        return text.splitlines()
+
+
+class ArgumentDefaultsHelpFormatter(HelpFormatter):
+    """Help message formatter which adds default values to argument help.
+
+    Only the name of this class is considered a public API. All the methods
+    provided by the class are considered an implementation detail.
+    """
+
+    def _get_help_string(self, action):
+        help = action.help
+        if '%(default)' not in action.help:
+            if action.default is not SUPPRESS:
+                defaulting_nargs = [OPTIONAL, ZERO_OR_MORE]
+                if action.option_strings or action.nargs in defaulting_nargs:
+                    help += ' (default: %(default)s)'
+        return help
+
+
+# =====================
+# Options and Arguments
+# =====================
+
+def _get_action_name(argument):
+    if argument is None:
+        return None
+    elif argument.option_strings:
+        return  '/'.join(argument.option_strings)
+    elif argument.metavar not in (None, SUPPRESS):
+        return argument.metavar
+    elif argument.dest not in (None, SUPPRESS):
+        return argument.dest
+    else:
+        return None
+
+
+class ArgumentError(Exception):
+    """An error from creating or using an argument (optional or positional).
+
+    The string value of this exception is the message, augmented with
+    information about the argument that caused it.
+    """
+
+    def __init__(self, argument, message):
+        self.argument_name = _get_action_name(argument)
+        self.message = message
+
+    def __str__(self):
+        if self.argument_name is None:
+            format = '%(message)s'
+        else:
+            format = 'argument %(argument_name)s: %(message)s'
+        return format % dict(message=self.message,
+                             argument_name=self.argument_name)
+
+
+class ArgumentTypeError(Exception):
+    """An error from trying to convert a command line string to a type."""
+    pass
+
+
+# ==============
+# Action classes
+# ==============
+
+class Action(_AttributeHolder):
+    """Information about how to convert command line strings to Python objects.
+
+    Action objects are used by an ArgumentParser to represent the information
+    needed to parse a single argument from one or more strings from the
+    command line. The keyword arguments to the Action constructor are also
+    all attributes of Action instances.
+
+    Keyword Arguments:
+
+        - option_strings -- A list of command-line option strings which
+            should be associated with this action.
+
+        - dest -- The name of the attribute to hold the created object(s)
+
+        - nargs -- The number of command-line arguments that should be
+            consumed. By default, one argument will be consumed and a single
+            value will be produced.  Other values include:
+                - N (an integer) consumes N arguments (and produces a list)
+                - '?' consumes zero or one arguments
+                - '*' consumes zero or more arguments (and produces a list)
+                - '+' consumes one or more arguments (and produces a list)
+            Note that the difference between the default and nargs=1 is that
+            with the default, a single value will be produced, while with
+            nargs=1, a list containing a single value will be produced.
+
+        - const -- The value to be produced if the option is specified and the
+            option uses an action that takes no values.
+
+        - default -- The value to be produced if the option is not specified.
+
+        - type -- The type which the command-line arguments should be converted
+            to, should be one of 'string', 'int', 'float', 'complex' or a
+            callable object that accepts a single string argument. If None,
+            'string' is assumed.
+
+        - choices -- A container of values that should be allowed. If not None,
+            after a command-line argument has been converted to the appropriate
+            type, an exception will be raised if it is not a member of this
+            collection.
+
+        - required -- True if the action must always be specified at the
+            command line. This is only meaningful for optional command-line
+            arguments.
+
+        - help -- The help string describing the argument.
+
+        - metavar -- The name to be used for the option's argument with the
+            help string. If None, the 'dest' value will be used as the name.
+    """
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        self.option_strings = option_strings
+        self.dest = dest
+        self.nargs = nargs
+        self.const = const
+        self.default = default
+        self.type = type
+        self.choices = choices
+        self.required = required
+        self.help = help
+        self.metavar = metavar
+
+    def _get_kwargs(self):
+        names = [
+            'option_strings',
+            'dest',
+            'nargs',
+            'const',
+            'default',
+            'type',
+            'choices',
+            'help',
+            'metavar',
+        ]
+        return [(name, getattr(self, name)) for name in names]
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        raise NotImplementedError(_('.__call__() not defined'))
+
+
+class _StoreAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        if nargs == 0:
+            raise ValueError('nargs for store actions must be > 0; if you '
+                             'have nothing to store, actions such as store '
+                             'true or store const may be more appropriate')
+        if const is not None and nargs != OPTIONAL:
+            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
+        super(_StoreAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=nargs,
+            const=const,
+            default=default,
+            type=type,
+            choices=choices,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, values)
+
+
+class _StoreConstAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 const,
+                 default=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        super(_StoreConstAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            const=const,
+            default=default,
+            required=required,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        setattr(namespace, self.dest, self.const)
+
+
+class _StoreTrueAction(_StoreConstAction):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=False,
+                 required=False,
+                 help=None):
+        super(_StoreTrueAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            const=True,
+            default=default,
+            required=required,
+            help=help)
+
+
+class _StoreFalseAction(_StoreConstAction):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=True,
+                 required=False,
+                 help=None):
+        super(_StoreFalseAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            const=False,
+            default=default,
+            required=required,
+            help=help)
+
+
+class _AppendAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 nargs=None,
+                 const=None,
+                 default=None,
+                 type=None,
+                 choices=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        if nargs == 0:
+            raise ValueError('nargs for append actions must be > 0; if arg '
+                             'strings are not supplying the value to append, '
+                             'the append const action may be more appropriate')
+        if const is not None and nargs != OPTIONAL:
+            raise ValueError('nargs must be %r to supply const' % OPTIONAL)
+        super(_AppendAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=nargs,
+            const=const,
+            default=default,
+            type=type,
+            choices=choices,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        items = _copy.copy(_ensure_value(namespace, self.dest, []))
+        items.append(values)
+        setattr(namespace, self.dest, items)
+
+
+class _AppendConstAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 const,
+                 default=None,
+                 required=False,
+                 help=None,
+                 metavar=None):
+        super(_AppendConstAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            const=const,
+            default=default,
+            required=required,
+            help=help,
+            metavar=metavar)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        items = _copy.copy(_ensure_value(namespace, self.dest, []))
+        items.append(self.const)
+        setattr(namespace, self.dest, items)
+
+
+class _CountAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest,
+                 default=None,
+                 required=False,
+                 help=None):
+        super(_CountAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=0,
+            default=default,
+            required=required,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        new_count = _ensure_value(namespace, self.dest, 0) + 1
+        setattr(namespace, self.dest, new_count)
+
+
+class _HelpAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 dest=SUPPRESS,
+                 default=SUPPRESS,
+                 help=None):
+        super(_HelpAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            default=default,
+            nargs=0,
+            help=help)
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        parser.print_help()
+        parser.exit()
+
+
+class _VersionAction(Action):
+
+    def __init__(self,
+                 option_strings,
+                 version=None,
+                 dest=SUPPRESS,
+                 default=SUPPRESS,
+                 help="show program's version number and exit"):
+        super(_VersionAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            default=default,
+            nargs=0,
+            help=help)
+        self.version = version
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        version = self.version
+        if version is None:
+            version = parser.version
+        formatter = parser._get_formatter()
+        formatter.add_text(version)
+        parser.exit(message=formatter.format_help())
+
+
+class _SubParsersAction(Action):
+
+    class _ChoicesPseudoAction(Action):
+
+        def __init__(self, name, aliases, help):
+            metavar = dest = name
+            if aliases:
+                metavar += ' (%s)' % ', '.join(aliases)
+            sup = super(_SubParsersAction._ChoicesPseudoAction, self)
+            sup.__init__(option_strings=[], dest=dest, help=help,
+                        metavar=metavar)
+
+    def __init__(self,
+                 option_strings,
+                 prog,
+                 parser_class,
+                 dest=SUPPRESS,
+                 help=None,
+                 metavar=None):
+
+        self._prog_prefix = prog
+        self._parser_class = parser_class
+        self._name_parser_map = {}
+        self._choices_actions = []
+
+        super(_SubParsersAction, self).__init__(
+            option_strings=option_strings,
+            dest=dest,
+            nargs=PARSER,
+            choices=self._name_parser_map,
+            help=help,
+            metavar=metavar)
+
+    def add_parser(self, name, **kwargs):
+        # set prog from the existing prefix
+        if kwargs.get('prog') is None:
+            kwargs['prog'] = '%s %s' % (self._prog_prefix, name)
+
+        aliases = kwargs.pop('aliases', ())
+
+        # create a pseudo-action to hold the choice help
+        if 'help' in kwargs:
+            help = kwargs.pop('help')
+            choice_action = self._ChoicesPseudoAction(name, aliases, help)
+            self._choices_actions.append(choice_action)
+
+        # create the parser and add it to the map
+        parser = self._parser_class(**kwargs)
+        self._name_parser_map[name] = parser
+
+        # make parser available under aliases also
+        for alias in aliases:
+            self._name_parser_map[alias] = parser
+
+        return parser
+
+    def _get_subactions(self):
+        return self._choices_actions
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        parser_name = values[0]
+        arg_strings = values[1:]
+
+        # set the parser name if requested
+        if self.dest is not SUPPRESS:
+            setattr(namespace, self.dest, parser_name)
+
+        # select the parser
+        try:
+            parser = self._name_parser_map[parser_name]
+        except KeyError:
+            tup = parser_name, ', '.join(self._name_parser_map)
+            msg = _('unknown parser %r (choices: %s)' % tup)
+            raise ArgumentError(self, msg)
+
+        # parse all the remaining options into the namespace
+        # store any unrecognized options on the object, so that the top
+        # level parser can decide what to do with them
+        namespace, arg_strings = parser.parse_known_args(arg_strings, namespace)
+        if arg_strings:
+            vars(namespace).setdefault(_UNRECOGNIZED_ARGS_ATTR, [])
+            getattr(namespace, _UNRECOGNIZED_ARGS_ATTR).extend(arg_strings)
+
+
+# ==============
+# Type classes
+# ==============
+
+class FileType(object):
+    """Factory for creating file object types
+
+    Instances of FileType are typically passed as type= arguments to the
+    ArgumentParser add_argument() method.
+
+    Keyword Arguments:
+        - mode -- A string indicating how the file is to be opened. Accepts the
+            same values as the builtin open() function.
+        - bufsize -- The file's desired buffer size. Accepts the same values as
+            the builtin open() function.
+    """
+
+    def __init__(self, mode='r', bufsize=None):
+        self._mode = mode
+        self._bufsize = bufsize
+
+    def __call__(self, string):
+        # the special argument "-" means sys.std{in,out}
+        if string == '-':
+            if 'r' in self._mode:
+                return _sys.stdin
+            elif 'w' in self._mode:
+                return _sys.stdout
+            else:
+                msg = _('argument "-" with mode %r' % self._mode)
+                raise ValueError(msg)
+
+        try:
+            # all other arguments are used as file names
+            if self._bufsize:
+                return open(string, self._mode, self._bufsize)
+            else:
+                return open(string, self._mode)
+        except IOError:
+            err = _sys.exc_info()[1]
+            message = _("can't open '%s': %s")
+            raise ArgumentTypeError(message % (string, err))
+
+    def __repr__(self):
+        args = [self._mode, self._bufsize]
+        args_str = ', '.join([repr(arg) for arg in args if arg is not None])
+        return '%s(%s)' % (type(self).__name__, args_str)
+
+# ===========================
+# Optional and Positional Parsing
+# ===========================
+
+class Namespace(_AttributeHolder):
+    """Simple object for storing attributes.
+
+    Implements equality by attribute names and values, and provides a simple
+    string representation.
+    """
+
+    def __init__(self, **kwargs):
+        for name in kwargs:
+            setattr(self, name, kwargs[name])
+
+    __hash__ = None
+
+    def __eq__(self, other):
+        return vars(self) == vars(other)
+
+    def __ne__(self, other):
+        return not (self == other)
+
+    def __contains__(self, key):
+        return key in self.__dict__
+
+
+class _ActionsContainer(object):
+
+    def __init__(self,
+                 description,
+                 prefix_chars,
+                 argument_default,
+                 conflict_handler):
+        super(_ActionsContainer, self).__init__()
+
+        self.description = description
+        self.argument_default = argument_default
+        self.prefix_chars = prefix_chars
+        self.conflict_handler = conflict_handler
+
+        # set up registries
+        self._registries = {}
+
+        # register actions
+        self.register('action', None, _StoreAction)
+        self.register('action', 'store', _StoreAction)
+        self.register('action', 'store_const', _StoreConstAction)
+        self.register('action', 'store_true', _StoreTrueAction)
+        self.register('action', 'store_false', _StoreFalseAction)
+        self.register('action', 'append', _AppendAction)
+        self.register('action', 'append_const', _AppendConstAction)
+        self.register('action', 'count', _CountAction)
+        self.register('action', 'help', _HelpAction)
+        self.register('action', 'version', _VersionAction)
+        self.register('action', 'parsers', _SubParsersAction)
+
+        # raise an exception if the conflict handler is invalid
+        self._get_handler()
+
+        # action storage
+        self._actions = []
+        self._option_string_actions = {}
+
+        # groups
+        self._action_groups = []
+        self._mutually_exclusive_groups = []
+
+        # defaults storage
+        self._defaults = {}
+
+        # determines whether an "option" looks like a negative number
+        self._negative_number_matcher = _re.compile(r'^-\d+$|^-\d*\.\d+$')
+
+        # whether or not there are any optionals that look like negative
+        # numbers -- uses a list so it can be shared and edited
+        self._has_negative_number_optionals = []
+
+    # ====================
+    # Registration methods
+    # ====================
+    def register(self, registry_name, value, object):
+        registry = self._registries.setdefault(registry_name, {})
+        registry[value] = object
+
+    def _registry_get(self, registry_name, value, default=None):
+        return self._registries[registry_name].get(value, default)
+
+    # ==================================
+    # Namespace default accessor methods
+    # ==================================
+    def set_defaults(self, **kwargs):
+        self._defaults.update(kwargs)
+
+        # if these defaults match any existing arguments, replace
+        # the previous default on the object with the new one
+        for action in self._actions:
+            if action.dest in kwargs:
+                action.default = kwargs[action.dest]
+
+    def get_default(self, dest):
+        for action in self._actions:
+            if action.dest == dest and action.default is not None:
+                return action.default
+        return self._defaults.get(dest, None)
+
+
+    # =======================
+    # Adding argument actions
+    # =======================
+    def add_argument(self, *args, **kwargs):
+        """
+        add_argument(dest, ..., name=value, ...)
+        add_argument(option_string, option_string, ..., name=value, ...)
+        """
+
+        # if no positional args are supplied or only one is supplied and
+        # it doesn't look like an option string, parse a positional
+        # argument
+        chars = self.prefix_chars
+        if not args or len(args) == 1 and args[0][0] not in chars:
+            if args and 'dest' in kwargs:
+                raise ValueError('dest supplied twice for positional argument')
+            kwargs = self._get_positional_kwargs(*args, **kwargs)
+
+        # otherwise, we're adding an optional argument
+        else:
+            kwargs = self._get_optional_kwargs(*args, **kwargs)
+
+        # if no default was supplied, use the parser-level default
+        if 'default' not in kwargs:
+            dest = kwargs['dest']
+            if dest in self._defaults:
+                kwargs['default'] = self._defaults[dest]
+            elif self.argument_default is not None:
+                kwargs['default'] = self.argument_default
+
+        # create the action object, and add it to the parser
+        action_class = self._pop_action_class(kwargs)
+        if not _callable(action_class):
+            raise ValueError('unknown action "%s"' % action_class)
+        action = action_class(**kwargs)
+
+        # raise an error if the action type is not callable
+        type_func = self._registry_get('type', action.type, action.type)
+        if not _callable(type_func):
+            raise ValueError('%r is not callable' % type_func)
+
+        return self._add_action(action)
+
+    def add_argument_group(self, *args, **kwargs):
+        group = _ArgumentGroup(self, *args, **kwargs)
+        self._action_groups.append(group)
+        return group
+
+    def add_mutually_exclusive_group(self, **kwargs):
+        group = _MutuallyExclusiveGroup(self, **kwargs)
+        self._mutually_exclusive_groups.append(group)
+        return group
+
+    def _add_action(self, action):
+        # resolve any conflicts
+        self._check_conflict(action)
+
+        # add to actions list
+        self._actions.append(action)
+        action.container = self
+
+        # index the action by any option strings it has
+        for option_string in action.option_strings:
+            self._option_string_actions[option_string] = action
+
+        # set the flag if any option strings look like negative numbers
+        for option_string in action.option_strings:
+            if self._negative_number_matcher.match(option_string):
+                if not self._has_negative_number_optionals:
+                    self._has_negative_number_optionals.append(True)
+
+        # return the created action
+        return action
+
+    def _remove_action(self, action):
+        self._actions.remove(action)
+
+    def _add_container_actions(self, container):
+        # collect groups by titles
+        title_group_map = {}
+        for group in self._action_groups:
+            if group.title in title_group_map:
+                msg = _('cannot merge actions - two groups are named %r')
+                raise ValueError(msg % (group.title))
+            title_group_map[group.title] = group
+
+        # map each action to its group
+        group_map = {}
+        for group in container._action_groups:
+
+            # if a group with the title exists, use that, otherwise
+            # create a new group matching the container's group
+            if group.title not in title_group_map:
+                title_group_map[group.title] = self.add_argument_group(
+                    title=group.title,
+                    description=group.description,
+                    conflict_handler=group.conflict_handler)
+
+            # map the actions to their new group
+            for action in group._group_actions:
+                group_map[action] = title_group_map[group.title]
+
+        # add container's mutually exclusive groups
+        # NOTE: if add_mutually_exclusive_group ever gains title= and
+        # description= then this code will need to be expanded as above
+        for group in container._mutually_exclusive_groups:
+            mutex_group = self.add_mutually_exclusive_group(
+                required=group.required)
+
+            # map the actions to their new mutex group
+            for action in group._group_actions:
+                group_map[action] = mutex_group
+
+        # add all actions to this container or their group
+        for action in container._actions:
+            group_map.get(action, self)._add_action(action)
+
+    def _get_positional_kwargs(self, dest, **kwargs):
+        # make sure required is not specified
+        if 'required' in kwargs:
+            msg = _("'required' is an invalid argument for positionals")
+            raise TypeError(msg)
+
+        # mark positional arguments as required if at least one is
+        # always required
+        if kwargs.get('nargs') not in [OPTIONAL, ZERO_OR_MORE]:
+            kwargs['required'] = True
+        if kwargs.get('nargs') == ZERO_OR_MORE and 'default' not in kwargs:
+            kwargs['required'] = True
+
+        # return the keyword arguments with no option strings
+        return dict(kwargs, dest=dest, option_strings=[])
+
+    def _get_optional_kwargs(self, *args, **kwargs):
+        # determine short and long option strings
+        option_strings = []
+        long_option_strings = []
+        for option_string in args:
+            # error on strings that don't start with an appropriate prefix
+            if not option_string[0] in self.prefix_chars:
+                msg = _('invalid option string %r: '
+                        'must start with a character %r')
+                tup = option_string, self.prefix_chars
+                raise ValueError(msg % tup)
+
+            # strings starting with two prefix characters are long options
+            option_strings.append(option_string)
+            if option_string[0] in self.prefix_chars:
+                if len(option_string) > 1:
+                    if option_string[1] in self.prefix_chars:
+                        long_option_strings.append(option_string)
+
+        # infer destination, '--foo-bar' -> 'foo_bar' and '-x' -> 'x'
+        dest = kwargs.pop('dest', None)
+        if dest is None:
+            if long_option_strings:
+                dest_option_string = long_option_strings[0]
+            else:
+                dest_option_string = option_strings[0]
+            dest = dest_option_string.lstrip(self.prefix_chars)
+            if not dest:
+                msg = _('dest= is required for options like %r')
+                raise ValueError(msg % option_string)
+            dest = dest.replace('-', '_')
+
+        # return the updated keyword arguments
+        return dict(kwargs, dest=dest, option_strings=option_strings)
+
+    def _pop_action_class(self, kwargs, default=None):
+        action = kwargs.pop('action', default)
+        return self._registry_get('action', action, action)
+
+    def _get_handler(self):
+        # determine function from conflict handler string
+        handler_func_name = '_handle_conflict_%s' % self.conflict_handler
+        try:
+            return getattr(self, handler_func_name)
+        except AttributeError:
+            msg = _('invalid conflict_resolution value: %r')
+            raise ValueError(msg % self.conflict_handler)
+
+    def _check_conflict(self, action):
+
+        # find all options that conflict with this option
+        confl_optionals = []
+        for option_string in action.option_strings:
+            if option_string in self._option_string_actions:
+                confl_optional = self._option_string_actions[option_string]
+                confl_optionals.append((option_string, confl_optional))
+
+        # resolve any conflicts
+        if confl_optionals:
+            conflict_handler = self._get_handler()
+            conflict_handler(action, confl_optionals)
+
+    def _handle_conflict_error(self, action, conflicting_actions):
+        message = _('conflicting option string(s): %s')
+        conflict_string = ', '.join([option_string
+                                     for option_string, action
+                                     in conflicting_actions])
+        raise ArgumentError(action, message % conflict_string)
+
+    def _handle_conflict_resolve(self, action, conflicting_actions):
+
+        # remove all conflicting options
+        for option_string, action in conflicting_actions:
+
+            # remove the conflicting option
+            action.option_strings.remove(option_string)
+            self._option_string_actions.pop(option_string, None)
+
+            # if the option now has no option string, remove it from the
+            # container holding it
+            if not action.option_strings:
+                action.container._remove_action(action)
+
+
+class _ArgumentGroup(_ActionsContainer):
+
+    def __init__(self, container, title=None, description=None, **kwargs):
+        # add any missing keyword arguments by checking the container
+        update = kwargs.setdefault
+        update('conflict_handler', container.conflict_handler)
+        update('prefix_chars', container.prefix_chars)
+        update('argument_default', container.argument_default)
+        super_init = super(_ArgumentGroup, self).__init__
+        super_init(description=description, **kwargs)
+
+        # group attributes
+        self.title = title
+        self._group_actions = []
+
+        # share most attributes with the container
+        self._registries = container._registries
+        self._actions = container._actions
+        self._option_string_actions = container._option_string_actions
+        self._defaults = container._defaults
+        self._has_negative_number_optionals = \
+            container._has_negative_number_optionals
+
+    def _add_action(self, action):
+        action = super(_ArgumentGroup, self)._add_action(action)
+        self._group_actions.append(action)
+        return action
+
+    def _remove_action(self, action):
+        super(_ArgumentGroup, self)._remove_action(action)
+        self._group_actions.remove(action)
+
+
+class _MutuallyExclusiveGroup(_ArgumentGroup):
+
+    def __init__(self, container, required=False):
+        super(_MutuallyExclusiveGroup, self).__init__(container)
+        self.required = required
+        self._container = container
+
+    def _add_action(self, action):
+        if action.required:
+            msg = _('mutually exclusive arguments must be optional')
+            raise ValueError(msg)
+        action = self._container._add_action(action)
+        self._group_actions.append(action)
+        return action
+
+    def _remove_action(self, action):
+        self._container._remove_action(action)
+        self._group_actions.remove(action)
+
+
+class ArgumentParser(_AttributeHolder, _ActionsContainer):
+    """Object for parsing command line strings into Python objects.
+
+    Keyword Arguments:
+        - prog -- The name of the program (default: sys.argv[0])
+        - usage -- A usage message (default: auto-generated from arguments)
+        - description -- A description of what the program does
+        - epilog -- Text following the argument descriptions
+        - parents -- Parsers whose arguments should be copied into this one
+        - formatter_class -- HelpFormatter class for printing help messages
+        - prefix_chars -- Characters that prefix optional arguments
+        - fromfile_prefix_chars -- Characters that prefix files containing
+            additional arguments
+        - argument_default -- The default value for all arguments
+        - conflict_handler -- String indicating how to handle conflicts
+        - add_help -- Add a -h/-help option
+    """
+
+    def __init__(self,
+                 prog=None,
+                 usage=None,
+                 description=None,
+                 epilog=None,
+                 version=None,
+                 parents=[],
+                 formatter_class=HelpFormatter,
+                 prefix_chars='-',
+                 fromfile_prefix_chars=None,
+                 argument_default=None,
+                 conflict_handler='error',
+                 add_help=True):
+
+        if version is not None:
+            import warnings
+            warnings.warn(
+                """The "version" argument to ArgumentParser is deprecated. """
+                """Please use """
+                """"add_argument(..., action='version', version="N", ...)" """
+                """instead""", DeprecationWarning)
+
+        superinit = super(ArgumentParser, self).__init__
+        superinit(description=description,
+                  prefix_chars=prefix_chars,
+                  argument_default=argument_default,
+                  conflict_handler=conflict_handler)
+
+        # default setting for prog
+        if prog is None:
+            prog = _os.path.basename(_sys.argv[0])
+
+        self.prog = prog
+        self.usage = usage
+        self.epilog = epilog
+        self.version = version
+        self.formatter_class = formatter_class
+        self.fromfile_prefix_chars = fromfile_prefix_chars
+        self.add_help = add_help
+
+        add_group = self.add_argument_group
+        self._positionals = add_group(_('positional arguments'))
+        self._optionals = add_group(_('optional arguments'))
+        self._subparsers = None
+
+        # register types
+        def identity(string):
+            return string
+        self.register('type', None, identity)
+
+        # add help and version arguments if necessary
+        # (using explicit default to override global argument_default)
+        if '-' in prefix_chars:
+            default_prefix = '-'
+        else:
+            default_prefix = prefix_chars[0]
+        if self.add_help:
+            self.add_argument(
+                default_prefix+'h', default_prefix*2+'help',
+                action='help', default=SUPPRESS,
+                help=_('show this help message and exit'))
+        if self.version:
+            self.add_argument(
+                default_prefix+'v', default_prefix*2+'version',
+                action='version', default=SUPPRESS,
+                version=self.version,
+                help=_("show program's version number and exit"))
+
+        # add parent arguments and defaults
+        for parent in parents:
+            self._add_container_actions(parent)
+            try:
+                defaults = parent._defaults
+            except AttributeError:
+                pass
+            else:
+                self._defaults.update(defaults)
+
+    # =======================
+    # Pretty __repr__ methods
+    # =======================
+    def _get_kwargs(self):
+        names = [
+            'prog',
+            'usage',
+            'description',
+            'version',
+            'formatter_class',
+            'conflict_handler',
+            'add_help',
+        ]
+        return [(name, getattr(self, name)) for name in names]
+
+    # ==================================
+    # Optional/Positional adding methods
+    # ==================================
+    def add_subparsers(self, **kwargs):
+        if self._subparsers is not None:
+            self.error(_('cannot have multiple subparser arguments'))
+
+        # add the parser class to the arguments if it's not present
+        kwargs.setdefault('parser_class', type(self))
+
+        if 'title' in kwargs or 'description' in kwargs:
+            title = _(kwargs.pop('title', 'subcommands'))
+            description = _(kwargs.pop('description', None))
+            self._subparsers = self.add_argument_group(title, description)
+        else:
+            self._subparsers = self._positionals
+
+        # prog defaults to the usage message of this parser, skipping
+        # optional arguments and with no "usage:" prefix
+        if kwargs.get('prog') is None:
+            formatter = self._get_formatter()
+            positionals = self._get_positional_actions()
+            groups = self._mutually_exclusive_groups
+            formatter.add_usage(self.usage, positionals, groups, '')
+            kwargs['prog'] = formatter.format_help().strip()
+
+        # create the parsers action and add it to the positionals list
+        parsers_class = self._pop_action_class(kwargs, 'parsers')
+        action = parsers_class(option_strings=[], **kwargs)
+        self._subparsers._add_action(action)
+
+        # return the created parsers action
+        return action
+
+    def _add_action(self, action):
+        if action.option_strings:
+            self._optionals._add_action(action)
+        else:
+            self._positionals._add_action(action)
+        return action
+
+    def _get_optional_actions(self):
+        return [action
+                for action in self._actions
+                if action.option_strings]
+
+    def _get_positional_actions(self):
+        return [action
+                for action in self._actions
+                if not action.option_strings]
+
+    # =====================================
+    # Command line argument parsing methods
+    # =====================================
+    def parse_args(self, args=None, namespace=None):
+        args, argv = self.parse_known_args(args, namespace)
+        if argv:
+            msg = _('unrecognized arguments: %s')
+            self.error(msg % ' '.join(argv))
+        return args
+
+    def parse_known_args(self, args=None, namespace=None):
+        # args default to the system args
+        if args is None:
+            args = _sys.argv[1:]
+
+        # default Namespace built from parser defaults
+        if namespace is None:
+            namespace = Namespace()
+
+        # add any action defaults that aren't present
+        for action in self._actions:
+            if action.dest is not SUPPRESS:
+                if not hasattr(namespace, action.dest):
+                    if action.default is not SUPPRESS:
+                        setattr(namespace, action.dest, action.default)
+
+        # add any parser defaults that aren't present
+        for dest in self._defaults:
+            if not hasattr(namespace, dest):
+                setattr(namespace, dest, self._defaults[dest])
+
+        # parse the arguments and exit if there are any errors
+        try:
+            namespace, args = self._parse_known_args(args, namespace)
+            if hasattr(namespace, _UNRECOGNIZED_ARGS_ATTR):
+                args.extend(getattr(namespace, _UNRECOGNIZED_ARGS_ATTR))
+                delattr(namespace, _UNRECOGNIZED_ARGS_ATTR)
+            return namespace, args
+        except ArgumentError:
+            err = _sys.exc_info()[1]
+            self.error(str(err))
+
+    def _parse_known_args(self, arg_strings, namespace):
+        # replace arg strings that are file references
+        if self.fromfile_prefix_chars is not None:
+            arg_strings = self._read_args_from_files(arg_strings)
+
+        # map all mutually exclusive arguments to the other arguments
+        # they can't occur with
+        action_conflicts = {}
+        for mutex_group in self._mutually_exclusive_groups:
+            group_actions = mutex_group._group_actions
+            for i, mutex_action in enumerate(mutex_group._group_actions):
+                conflicts = action_conflicts.setdefault(mutex_action, [])
+                conflicts.extend(group_actions[:i])
+                conflicts.extend(group_actions[i + 1:])
+
+        # find all option indices, and determine the arg_string_pattern
+        # which has an 'O' if there is an option at an index,
+        # an 'A' if there is an argument, or a '-' if there is a '--'
+        option_string_indices = {}
+        arg_string_pattern_parts = []
+        arg_strings_iter = iter(arg_strings)
+        for i, arg_string in enumerate(arg_strings_iter):
+
+            # all args after -- are non-options
+            if arg_string == '--':
+                arg_string_pattern_parts.append('-')
+                for arg_string in arg_strings_iter:
+                    arg_string_pattern_parts.append('A')
+
+            # otherwise, add the arg to the arg strings
+            # and note the index if it was an option
+            else:
+                option_tuple = self._parse_optional(arg_string)
+                if option_tuple is None:
+                    pattern = 'A'
+                else:
+                    option_string_indices[i] = option_tuple
+                    pattern = 'O'
+                arg_string_pattern_parts.append(pattern)
+
+        # join the pieces together to form the pattern
+        arg_strings_pattern = ''.join(arg_string_pattern_parts)
+
+        # converts arg strings to the appropriate and then takes the action
+        seen_actions = set()
+        seen_non_default_actions = set()
+
+        def take_action(action, argument_strings, option_string=None):
+            seen_actions.add(action)
+            argument_values = self._get_values(action, argument_strings)
+
+            # error if this argument is not allowed with other previously
+            # seen arguments, assuming that actions that use the default
+            # value don't really count as "present"
+            if argument_values is not action.default:
+                seen_non_default_actions.add(action)
+                for conflict_action in action_conflicts.get(action, []):
+                    if conflict_action in seen_non_default_actions:
+                        msg = _('not allowed with argument %s')
+                        action_name = _get_action_name(conflict_action)
+                        raise ArgumentError(action, msg % action_name)
+
+            # take the action if we didn't receive a SUPPRESS value
+            # (e.g. from a default)
+            if argument_values is not SUPPRESS:
+                action(self, namespace, argument_values, option_string)
+
+        # function to convert arg_strings into an optional action
+        def consume_optional(start_index):
+
+            # get the optional identified at this index
+            option_tuple = option_string_indices[start_index]
+            action, option_string, explicit_arg = option_tuple
+
+            # identify additional optionals in the same arg string
+            # (e.g. -xyz is the same as -x -y -z if no args are required)
+            match_argument = self._match_argument
+            action_tuples = []
+            while True:
+
+                # if we found no optional action, skip it
+                if action is None:
+                    extras.append(arg_strings[start_index])
+                    return start_index + 1
+
+                # if there is an explicit argument, try to match the
+                # optional's string arguments to only this
+                if explicit_arg is not None:
+                    arg_count = match_argument(action, 'A')
+
+                    # if the action is a single-dash option and takes no
+                    # arguments, try to parse more single-dash options out
+                    # of the tail of the option string
+                    chars = self.prefix_chars
+                    if arg_count == 0 and option_string[1] not in chars:
+                        action_tuples.append((action, [], option_string))
+                        char = option_string[0]
+                        option_string = char + explicit_arg[0]
+                        new_explicit_arg = explicit_arg[1:] or None
+                        optionals_map = self._option_string_actions
+                        if option_string in optionals_map:
+                            action = optionals_map[option_string]
+                            explicit_arg = new_explicit_arg
+                        else:
+                            msg = _('ignored explicit argument %r')
+                            raise ArgumentError(action, msg % explicit_arg)
+
+                    # if the action expect exactly one argument, we've
+                    # successfully matched the option; exit the loop
+                    elif arg_count == 1:
+                        stop = start_index + 1
+                        args = [explicit_arg]
+                        action_tuples.append((action, args, option_string))
+                        break
+
+                    # error if a double-dash option did not use the
+                    # explicit argument
+                    else:
+                        msg = _('ignored explicit argument %r')
+                        raise ArgumentError(action, msg % explicit_arg)
+
+                # if there is no explicit argument, try to match the
+                # optional's string arguments with the following strings
+                # if successful, exit the loop
+                else:
+                    start = start_index + 1
+                    selected_patterns = arg_strings_pattern[start:]
+                    arg_count = match_argument(action, selected_patterns)
+                    stop = start + arg_count
+                    args = arg_strings[start:stop]
+                    action_tuples.append((action, args, option_string))
+                    break
+
+            # add the Optional to the list and return the index at which
+            # the Optional's string args stopped
+            assert action_tuples
+            for action, args, option_string in action_tuples:
+                take_action(action, args, option_string)
+            return stop
+
+        # the list of Positionals left to be parsed; this is modified
+        # by consume_positionals()
+        positionals = self._get_positional_actions()
+
+        # function to convert arg_strings into positional actions
+        def consume_positionals(start_index):
+            # match as many Positionals as possible
+            match_partial = self._match_arguments_partial
+            selected_pattern = arg_strings_pattern[start_index:]
+            arg_counts = match_partial(positionals, selected_pattern)
+
+            # slice off the appropriate arg strings for each Positional
+            # and add the Positional and its args to the list
+            for action, arg_count in zip(positionals, arg_counts):
+                args = arg_strings[start_index: start_index + arg_count]
+                start_index += arg_count
+                take_action(action, args)
+
+            # slice off the Positionals that we just parsed and return the
+            # index at which the Positionals' string args stopped
+            positionals[:] = positionals[len(arg_counts):]
+            return start_index
+
+        # consume Positionals and Optionals alternately, until we have
+        # passed the last option string
+        extras = []
+        start_index = 0
+        if option_string_indices:
+            max_option_string_index = max(option_string_indices)
+        else:
+            max_option_string_index = -1
+        while start_index <= max_option_string_index:
+
+            # consume any Positionals preceding the next option
+            next_option_string_index = min([
+                index
+                for index in option_string_indices
+                if index >= start_index])
+            if start_index != next_option_string_index:
+                positionals_end_index = consume_positionals(start_index)
+
+                # only try to parse the next optional if we didn't consume
+                # the option string during the positionals parsing
+                if positionals_end_index > start_index:
+                    start_index = positionals_end_index
+                    continue
+                else:
+                    start_index = positionals_end_index
+
+            # if we consumed all the positionals we could and we're not
+            # at the index of an option string, there were extra arguments
+            if start_index not in option_string_indices:
+                strings = arg_strings[start_index:next_option_string_index]
+                extras.extend(strings)
+                start_index = next_option_string_index
+
+            # consume the next optional and any arguments for it
+            start_index = consume_optional(start_index)
+
+        # consume any positionals following the last Optional
+        stop_index = consume_positionals(start_index)
+
+        # if we didn't consume all the argument strings, there were extras
+        extras.extend(arg_strings[stop_index:])
+
+        # if we didn't use all the Positional objects, there were too few
+        # arg strings supplied.
+        if positionals:
+            self.error(_('too few arguments'))
+
+        # make sure all required actions were present, and convert defaults.
+        for action in self._actions:
+            if action not in seen_actions:
+                if action.required:
+                    name = _get_action_name(action)
+                    self.error(_('argument %s is required') % name)
+                else:
+                    # Convert action default now instead of doing it before
+                    # parsing arguments to avoid calling convert functions
+                    # twice (which may fail) if the argument was given, but
+                    # only if it was defined already in the namespace
+                    if (action.default is not None and
+                            isinstance(action.default, basestring) and
+                            hasattr(namespace, action.dest) and
+                            action.default is getattr(namespace, action.dest)):
+                        setattr(namespace, action.dest,
+                                self._get_value(action, action.default))
+
+        # make sure all required groups had one option present
+        for group in self._mutually_exclusive_groups:
+            if group.required:
+                for action in group._group_actions:
+                    if action in seen_non_default_actions:
+                        break
+
+                # if no actions were used, report the error
+                else:
+                    names = [_get_action_name(action)
+                             for action in group._group_actions
+                             if action.help is not SUPPRESS]
+                    msg = _('one of the arguments %s is required')
+                    self.error(msg % ' '.join(names))
+
+        # return the updated namespace and the extra arguments
+        return namespace, extras
+
+    def _read_args_from_files(self, arg_strings):
+        # expand arguments referencing files
+        new_arg_strings = []
+        for arg_string in arg_strings:
+
+            # for regular arguments, just add them back into the list
+            if arg_string[0] not in self.fromfile_prefix_chars:
+                new_arg_strings.append(arg_string)
+
+            # replace arguments referencing files with the file content
+            else:
+                try:
+                    args_file = open(arg_string[1:])
+                    try:
+                        arg_strings = []
+                        for arg_line in args_file.read().splitlines():
+                            for arg in self.convert_arg_line_to_args(arg_line):
+                                arg_strings.append(arg)
+                        arg_strings = self._read_args_from_files(arg_strings)
+                        new_arg_strings.extend(arg_strings)
+                    finally:
+                        args_file.close()
+                except IOError:
+                    err = _sys.exc_info()[1]
+                    self.error(str(err))
+
+        # return the modified argument list
+        return new_arg_strings
+
+    def convert_arg_line_to_args(self, arg_line):
+        return [arg_line]
+
+    def _match_argument(self, action, arg_strings_pattern):
+        # match the pattern for this action to the arg strings
+        nargs_pattern = self._get_nargs_pattern(action)
+        match = _re.match(nargs_pattern, arg_strings_pattern)
+
+        # raise an exception if we weren't able to find a match
+        if match is None:
+            nargs_errors = {
+                None: _('expected one argument'),
+                OPTIONAL: _('expected at most one argument'),
+                ONE_OR_MORE: _('expected at least one argument'),
+            }
+            default = _('expected %s argument(s)') % action.nargs
+            msg = nargs_errors.get(action.nargs, default)
+            raise ArgumentError(action, msg)
+
+        # return the number of arguments matched
+        return len(match.group(1))
+
+    def _match_arguments_partial(self, actions, arg_strings_pattern):
+        # progressively shorten the actions list by slicing off the
+        # final actions until we find a match
+        result = []
+        for i in range(len(actions), 0, -1):
+            actions_slice = actions[:i]
+            pattern = ''.join([self._get_nargs_pattern(action)
+                               for action in actions_slice])
+            match = _re.match(pattern, arg_strings_pattern)
+            if match is not None:
+                result.extend([len(string) for string in match.groups()])
+                break
+
+        # return the list of arg string counts
+        return result
+
+    def _parse_optional(self, arg_string):
+        # if it's an empty string, it was meant to be a positional
+        if not arg_string:
+            return None
+
+        # if it doesn't start with a prefix, it was meant to be positional
+        if not arg_string[0] in self.prefix_chars:
+            return None
+
+        # if the option string is present in the parser, return the action
+        if arg_string in self._option_string_actions:
+            action = self._option_string_actions[arg_string]
+            return action, arg_string, None
+
+        # if it's just a single character, it was meant to be positional
+        if len(arg_string) == 1:
+            return None
+
+        # if the option string before the "=" is present, return the action
+        if '=' in arg_string:
+            option_string, explicit_arg = arg_string.split('=', 1)
+            if option_string in self._option_string_actions:
+                action = self._option_string_actions[option_string]
+                return action, option_string, explicit_arg
+
+        # search through all possible prefixes of the option string
+        # and all actions in the parser for possible interpretations
+        option_tuples = self._get_option_tuples(arg_string)
+
+        # if multiple actions match, the option string was ambiguous
+        if len(option_tuples) > 1:
+            options = ', '.join([option_string
+                for action, option_string, explicit_arg in option_tuples])
+            tup = arg_string, options
+            self.error(_('ambiguous option: %s could match %s') % tup)
+
+        # if exactly one action matched, this segmentation is good,
+        # so return the parsed action
+        elif len(option_tuples) == 1:
+            option_tuple, = option_tuples
+            return option_tuple
+
+        # if it was not found as an option, but it looks like a negative
+        # number, it was meant to be positional
+        # unless there are negative-number-like options
+        if self._negative_number_matcher.match(arg_string):
+            if not self._has_negative_number_optionals:
+                return None
+
+        # if it contains a space, it was meant to be a positional
+        if ' ' in arg_string:
+            return None
+
+        # it was meant to be an optional but there is no such option
+        # in this parser (though it might be a valid option in a subparser)
+        return None, arg_string, None
+
+    def _get_option_tuples(self, option_string):
+        result = []
+
+        # option strings starting with two prefix characters are only
+        # split at the '='
+        chars = self.prefix_chars
+        if option_string[0] in chars and option_string[1] in chars:
+            if '=' in option_string:
+                option_prefix, explicit_arg = option_string.split('=', 1)
+            else:
+                option_prefix = option_string
+                explicit_arg = None
+            for option_string in self._option_string_actions:
+                if option_string.startswith(option_prefix):
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, explicit_arg
+                    result.append(tup)
+
+        # single character options can be concatenated with their arguments
+        # but multiple character options always have to have their argument
+        # separate
+        elif option_string[0] in chars and option_string[1] not in chars:
+            option_prefix = option_string
+            explicit_arg = None
+            short_option_prefix = option_string[:2]
+            short_explicit_arg = option_string[2:]
+
+            for option_string in self._option_string_actions:
+                if option_string == short_option_prefix:
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, short_explicit_arg
+                    result.append(tup)
+                elif option_string.startswith(option_prefix):
+                    action = self._option_string_actions[option_string]
+                    tup = action, option_string, explicit_arg
+                    result.append(tup)
+
+        # shouldn't ever get here
+        else:
+            self.error(_('unexpected option string: %s') % option_string)
+
+        # return the collected option tuples
+        return result
+
+    def _get_nargs_pattern(self, action):
+        # in all examples below, we have to allow for '--' args
+        # which are represented as '-' in the pattern
+        nargs = action.nargs
+
+        # the default (None) is assumed to be a single argument
+        if nargs is None:
+            nargs_pattern = '(-*A-*)'
+
+        # allow zero or one arguments
+        elif nargs == OPTIONAL:
+            nargs_pattern = '(-*A?-*)'
+
+        # allow zero or more arguments
+        elif nargs == ZERO_OR_MORE:
+            nargs_pattern = '(-*[A-]*)'
+
+        # allow one or more arguments
+        elif nargs == ONE_OR_MORE:
+            nargs_pattern = '(-*A[A-]*)'
+
+        # allow any number of options or arguments
+        elif nargs == REMAINDER:
+            nargs_pattern = '([-AO]*)'
+
+        # allow one argument followed by any number of options or arguments
+        elif nargs == PARSER:
+            nargs_pattern = '(-*A[-AO]*)'
+
+        # all others should be integers
+        else:
+            nargs_pattern = '(-*%s-*)' % '-*'.join('A' * nargs)
+
+        # if this is an optional action, -- is not allowed
+        if action.option_strings:
+            nargs_pattern = nargs_pattern.replace('-*', '')
+            nargs_pattern = nargs_pattern.replace('-', '')
+
+        # return the pattern
+        return nargs_pattern
+
+    # ========================
+    # Value conversion methods
+    # ========================
+    def _get_values(self, action, arg_strings):
+        # for everything but PARSER args, strip out '--'
+        if action.nargs not in [PARSER, REMAINDER]:
+            arg_strings = [s for s in arg_strings if s != '--']
+
+        # optional argument produces a default when not present
+        if not arg_strings and action.nargs == OPTIONAL:
+            if action.option_strings:
+                value = action.const
+            else:
+                value = action.default
+            if isinstance(value, basestring):
+                value = self._get_value(action, value)
+                self._check_value(action, value)
+
+        # when nargs='*' on a positional, if there were no command-line
+        # args, use the default if it is anything other than None
+        elif (not arg_strings and action.nargs == ZERO_OR_MORE and
+              not action.option_strings):
+            if action.default is not None:
+                value = action.default
+            else:
+                value = arg_strings
+            self._check_value(action, value)
+
+        # single argument or optional argument produces a single value
+        elif len(arg_strings) == 1 and action.nargs in [None, OPTIONAL]:
+            arg_string, = arg_strings
+            value = self._get_value(action, arg_string)
+            self._check_value(action, value)
+
+        # REMAINDER arguments convert all values, checking none
+        elif action.nargs == REMAINDER:
+            value = [self._get_value(action, v) for v in arg_strings]
+
+        # PARSER arguments convert all values, but check only the first
+        elif action.nargs == PARSER:
+            value = [self._get_value(action, v) for v in arg_strings]
+            self._check_value(action, value[0])
+
+        # all other types of nargs produce a list
+        else:
+            value = [self._get_value(action, v) for v in arg_strings]
+            for v in value:
+                self._check_value(action, v)
+
+        # return the converted value
+        return value
+
+    def _get_value(self, action, arg_string):
+        type_func = self._registry_get('type', action.type, action.type)
+        if not _callable(type_func):
+            msg = _('%r is not callable')
+            raise ArgumentError(action, msg % type_func)
+
+        # convert the value to the appropriate type
+        try:
+            result = type_func(arg_string)
+
+        # ArgumentTypeErrors indicate errors
+        except ArgumentTypeError:
+            name = getattr(action.type, '__name__', repr(action.type))
+            msg = str(_sys.exc_info()[1])
+            raise ArgumentError(action, msg)
+
+        # TypeErrors or ValueErrors also indicate errors
+        except (TypeError, ValueError):
+            name = getattr(action.type, '__name__', repr(action.type))
+            msg = _('invalid %s value: %r')
+            raise ArgumentError(action, msg % (name, arg_string))
+
+        # return the converted value
+        return result
+
+    def _check_value(self, action, value):
+        # converted value must be one of the choices (if specified)
+        if action.choices is not None and value not in action.choices:
+            tup = value, ', '.join(map(repr, action.choices))
+            msg = _('invalid choice: %r (choose from %s)') % tup
+            raise ArgumentError(action, msg)
+
+    # =======================
+    # Help-formatting methods
+    # =======================
+    def format_usage(self):
+        formatter = self._get_formatter()
+        formatter.add_usage(self.usage, self._actions,
+                            self._mutually_exclusive_groups)
+        return formatter.format_help()
+
+    def format_help(self):
+        formatter = self._get_formatter()
+
+        # usage
+        formatter.add_usage(self.usage, self._actions,
+                            self._mutually_exclusive_groups)
+
+        # description
+        formatter.add_text(self.description)
+
+        # positionals, optionals and user-defined groups
+        for action_group in self._action_groups:
+            formatter.start_section(action_group.title)
+            formatter.add_text(action_group.description)
+            formatter.add_arguments(action_group._group_actions)
+            formatter.end_section()
+
+        # epilog
+        formatter.add_text(self.epilog)
+
+        # determine help from format above
+        return formatter.format_help()
+
+    def format_version(self):
+        import warnings
+        warnings.warn(
+            'The format_version method is deprecated -- the "version" '
+            'argument to ArgumentParser is no longer supported.',
+            DeprecationWarning)
+        formatter = self._get_formatter()
+        formatter.add_text(self.version)
+        return formatter.format_help()
+
+    def _get_formatter(self):
+        return self.formatter_class(prog=self.prog)
+
+    # =====================
+    # Help-printing methods
+    # =====================
+    def print_usage(self, file=None):
+        if file is None:
+            file = _sys.stdout
+        self._print_message(self.format_usage(), file)
+
+    def print_help(self, file=None):
+        if file is None:
+            file = _sys.stdout
+        self._print_message(self.format_help(), file)
+
+    def print_version(self, file=None):
+        import warnings
+        warnings.warn(
+            'The print_version method is deprecated -- the "version" '
+            'argument to ArgumentParser is no longer supported.',
+            DeprecationWarning)
+        self._print_message(self.format_version(), file)
+
+    def _print_message(self, message, file=None):
+        if message:
+            if file is None:
+                file = _sys.stderr
+            file.write(message)
+
+    # ===============
+    # Exiting methods
+    # ===============
+    def exit(self, status=0, message=None):
+        if message:
+            self._print_message(message, _sys.stderr)
+        _sys.exit(status)
+
+    def error(self, message):
+        """error(message: string)
+
+        Prints a usage message incorporating the message to stderr and
+        exits.
+
+        If you override this in a subclass, it should not return -- it
+        should either exit or raise an exception.
+        """
+        self.print_usage(_sys.stderr)
+        self.exit(2, _('%s: error: %s\n') % (self.prog, message))
-- 
2.13.5

Add the scripts/ directory to sys.path so Python 2.6 will be able to
import argparse.

Cc: Daniel P. Berrange <berrange@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: John Snow <jsnow@redhat.com>
Acked-by: Fam Zheng <famz@redhat.com>
Message-id: 20170825155732.15665-4-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/migration/guestperf/shell.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tests/migration/guestperf/shell.py b/tests/migration/guestperf/shell.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/migration/guestperf/shell.py
+++ b/tests/migration/guestperf/shell.py
@@ -XXX,XX +XXX,XX @@
 #
 
 
-import argparse
-import fnmatch
 import os
 import os.path
-import platform
 import sys
+sys.path.append(os.path.join(os.path.dirname(__file__),
+                             '..', '..', '..', 'scripts'))
+import argparse
+import fnmatch
+import platform
 
 from guestperf.hardware import Hardware
 from guestperf.engine import Engine
-- 
2.13.5

From: Fred Rolland <rollandf@gmail.com>

Update doc with the usage of UUID for initiator name.

Related-To: https://bugzilla.redhat.com/1006468
Signed-off-by: Fred Rolland <frolland@redhat.com>
Message-id: 20170823084830.30500-1-frolland@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qemu-doc.texi | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/qemu-doc.texi b/qemu-doc.texi
index XXXXXXX..XXXXXXX 100644
--- a/qemu-doc.texi
+++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ in a configuration file provided via '-readconfig' or directly on the
 command line.
 
 If the initiator-name is not specified qemu will use a default name
-of 'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
+of 'iqn.2008-11.org.linux-kvm[:<uuid>'] where <uuid> is the UUID of the
+virtual machine. If the UUID is not specified qemu will use
+'iqn.2008-11.org.linux-kvm[:<name>'] where <name> is the name of the
 virtual machine.
 
-
 @example
 Setting a specific initiator name to use when logging in to the target
 -iscsi initiator-name=iqn.qemu.test:my-initiator
-- 
2.13.5

Most qcow2 files are uncompressed so it is wasteful to allocate (32 + 1)
* cluster_size + 512 bytes upfront.  Allocate s->cluster_cache and
s->cluster_data when the first read operation is performance on a
compressed cluster.

The buffers are freed in .bdrv_close().  .bdrv_open() no longer has any
code paths that can allocate these buffers, so remove the free functions
in the error code path.

This patch can result in significant memory savings when many qcow2
disks are attached or backing file chains are long:

Before 12.81% (1,023,193,088B)
After   5.36% (393,893,888B)

Reported-by: Alexey Kardashevskiy <aik@ozlabs.ru>
Tested-by: Alexey Kardashevskiy <aik@ozlabs.ru>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20170821135530.32344-1-stefanha@redhat.com
Cc: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/qcow2-cluster.c | 17 +++++++++++++++++
 block/qcow2.c         | 12 ------------
 2 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ int qcow2_decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
         nb_csectors = ((cluster_offset >> s->csize_shift) & s->csize_mask) + 1;
         sector_offset = coffset & 511;
         csize = nb_csectors * 512 - sector_offset;
+
+        /* Allocate buffers on first decompress operation, most images are
+         * uncompressed and the memory overhead can be avoided.  The buffers
+         * are freed in .bdrv_close().
+         */
+        if (!s->cluster_data) {
+            /* one more sector for decompressed data alignment */
+            s->cluster_data = qemu_try_blockalign(bs->file->bs,
+                    QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size + 512);
+            if (!s->cluster_data) {
+                return -ENOMEM;
+            }
+        }
+        if (!s->cluster_cache) {
+            s->cluster_cache = g_malloc(s->cluster_size);
+        }
+
         BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
         ret = bdrv_read(bs->file, coffset >> 9, s->cluster_data,
                         nb_csectors);
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 int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail;
     }
 
-    s->cluster_cache = g_malloc(s->cluster_size);
-    /* one more sector for decompressed data alignment */
-    s->cluster_data = qemu_try_blockalign(bs->file->bs, QCOW_MAX_CRYPT_CLUSTERS
-                                                    * s->cluster_size + 512);
-    if (s->cluster_data == NULL) {
-        error_setg(errp, "Could not allocate temporary cluster buffer");
-        ret = -ENOMEM;
-        goto fail;
-    }
-
     s->cluster_cache_offset = -1;
     s->flags = flags;
 
@@ -XXX,XX +XXX,XX @@ static int qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
     if (s->refcount_block_cache) {
         qcow2_cache_destroy(bs, s->refcount_block_cache);
     }
-    g_free(s->cluster_cache);
-    qemu_vfree(s->cluster_data);
     qcrypto_block_free(s->crypto);
     qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
     return ret;
-- 
2.13.5

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