Series comparison

-[Qemu-devel] [PULL 00/12] Block patches
+[PULL 0/3] Block patches
-The following changes since commit bfec359afba088aaacc7d316f43302f28c6e642a:
+The following changes since commit 9cf289af47bcfae5c75de37d8e5d6fd23705322c:
-  Merge remote-tracking branch 'remotes/armbru/tags/pull-qdev-2017-04-21' into staging (2017-04-21 11:42:03 +0100)
+  Merge tag 'qga-pull-request' of gitlab.com:marcandre.lureau/qemu into staging (2022-05-04 03:42:49 -0700)
-are available in the git repository at:
+are available in the Git repository at:
-  git://github.com/codyprime/qemu-kvm-jtc.git tags/block-pull-request
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 1507631e438930bc07f776f303af127a9cdb4d41:
+for you to fetch changes up to bef2e050d6a7feb865854c65570c496ac5a8cf53:
-  qemu-iotests: _cleanup_qemu must be called on exit (2017-04-21 08:32:44 -0400)
+  util/event-loop-base: Introduce options to set the thread pool size (2022-05-04 17:02:19 +0100)
 ----------------------------------------------------------------
 Pull request
 Add new thread-pool-min/thread-pool-max parameters to control the thread pool
 used for async I/O.
 ----------------------------------------------------------------
-Block patches for 2.10
+Nicolas Saenz Julienne (3):
   Introduce event-loop-base abstract class
   util/main-loop: Introduce the main loop into QOM
   util/event-loop-base: Introduce options to set the thread pool size
-----------------------------------------------------------------
+ qapi/qom.json                    |  43 ++++++++--
+ meson.build                      |  26 +++---
-Ashish Mittal (2):
+ include/block/aio.h              |  10 +++
-  block/vxhs.c: Add support for a new block device type called "vxhs"
+ include/block/thread-pool.h      |   3 +
-  block/vxhs.c: Add qemu-iotests for new block device type "vxhs"
+ include/qemu/main-loop.h         |  10 +++
+ include/sysemu/event-loop-base.h |  41 +++++++++
-Jeff Cody (10):
+ include/sysemu/iothread.h        |   6 +-
-  qemu-iotests: exclude vxhs from image creation via protocol
+ event-loop-base.c                | 140 +++++++++++++++++++++++++++++++
-  block: add bdrv_set_read_only() helper function
+ iothread.c                       |  68 +++++----------
-  block: do not set BDS read_only if copy_on_read enabled
+ util/aio-posix.c                 |   1 +
-  block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only
+ util/async.c                     |  20 +++++
-  block: code movement
+ util/main-loop.c                 |  65 ++++++++++++++
-  block: introduce bdrv_can_set_read_only()
+ util/thread-pool.c               |  55 +++++++++++-
-  block: use bdrv_can_set_read_only() during reopen
+files changed, 419 insertions(+), 69 deletions(-)
-  block/rbd - update variable names to more apt names
+ create mode 100644 include/sysemu/event-loop-base.h
-  block/rbd: Add support for reopen()
+ create mode 100644 event-loop-base.c
   qemu-iotests: _cleanup_qemu must be called on exit
  block.c                          |  56 +++-
  block/Makefile.objs              |   2 +
  block/bochs.c                    |   5 +-
  block/cloop.c                    |   5 +-
  block/dmg.c                      |   6 +-
  block/rbd.c                      |  65 +++--
  block/trace-events               |  17 ++
  block/vvfat.c                    |  19 +-
  block/vxhs.c                     | 575 +++++++++++++++++++++++++++++++++++++++
  configure                        |  39 +++
  include/block/block.h            |   2 +
  qapi/block-core.json             |  23 +-
  tests/qemu-iotests/017           |   1 +
  tests/qemu-iotests/020           |   1 +
  tests/qemu-iotests/028           |   1 +
  tests/qemu-iotests/029           |   1 +
  tests/qemu-iotests/073           |   1 +
  tests/qemu-iotests/094           |  11 +-
  tests/qemu-iotests/102           |   5 +-
  tests/qemu-iotests/109           |   1 +
  tests/qemu-iotests/114           |   1 +
  tests/qemu-iotests/117           |   1 +
  tests/qemu-iotests/130           |   2 +
  tests/qemu-iotests/134           |   1 +
  tests/qemu-iotests/140           |   1 +
  tests/qemu-iotests/141           |   1 +
  tests/qemu-iotests/143           |   1 +
  tests/qemu-iotests/156           |   2 +
  tests/qemu-iotests/158           |   1 +
  tests/qemu-iotests/common        |   6 +
  tests/qemu-iotests/common.config |  13 +
  tests/qemu-iotests/common.filter |   1 +
  tests/qemu-iotests/common.rc     |  19 ++
 files changed, 844 insertions(+), 42 deletions(-)
  create mode 100644 block/vxhs.c
 --
-.9.3
+.35.1

-[Qemu-devel] [PULL 01/12] block/vxhs.c: Add support for a new block device type called "vxhs"
+[PULL 1/3] Introduce event-loop-base abstract class
-From: Ashish Mittal <ashmit602@gmail.com>
+From: Nicolas Saenz Julienne <nsaenzju@redhat.com>
-Source code for the qnio library that this code loads can be downloaded from:
+Introduce the 'event-loop-base' abstract class, it'll hold the
-https://github.com/VeritasHyperScale/libqnio.git
+properties common to all event loops and provide the necessary hooks for
+their creation and maintenance. Then have iothread inherit from it.
-Sample command line using JSON syntax:
-./x86_64-softmmu/qemu-system-x86_64 -name instance-00000008 -S -vnc 0.0.0.0:0
+EventLoopBaseClass is defined as user creatable and provides a hook for
--k en-us -vga cirrus -device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x5
+its children to attach themselves to the user creatable class 'complete'
--msg timestamp=on
+function. It also provides an update_params() callback to propagate
-'json:{"driver":"vxhs","vdisk-id":"c3e9095a-a5ee-4dce-afeb-2a59fb387410",
+property changes onto its children.
-"server":{"host":"172.172.17.4","port":"9999"}}'
+The new 'event-loop-base' class will live in the root directory. It is
-Sample command line using URI syntax:
+built on its own using the 'link_whole' option (there are no direct
-qemu-img convert -f raw -O raw -n
+function dependencies between the class and its children, it all happens
-/var/lib/nova/instances/_base/0c5eacd5ebea5ed914b6a3e7b18f1ce734c386ad
+trough 'constructor' magic). And also imposes new compilation
-vxhs://192.168.0.1:9999/c6718f6b-0401-441d-a8c3-1f0064d75ee0
+dependencies:
-Sample command line using TLS credentials (run in secure mode):
+    qom <- event-loop-base <- blockdev (iothread.c)
-./qemu-io --object
-tls-creds-x509,id=tls0,dir=/etc/pki/qemu/vxhs,endpoint=client -c 'read
+And in subsequent patches:
--v 66000 2.5k' 'json:{"server.host": "127.0.0.1", "server.port": "9999",
-"vdisk-id": "/test.raw", "driver": "vxhs", "tls-creds":"tls0"}'
+    qom <- event-loop-base <- qemuutil (util/main-loop.c)
-Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
+All this forced some amount of reordering in meson.build:
  - Moved qom build definition before qemuutil. Doing it the other way
    around (i.e. moving qemuutil after qom) isn't possible as a lot of
    core libraries that live in between the two depend on it.
  - Process the 'hw' subdir earlier, as it introduces files into the
    'qom' source set.
 No functional changes intended.
 Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+Acked-by: Markus Armbruster <armbru@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Message-id: 20220425075723.20019-2-nsaenzju@redhat.com
-Message-id: 1491277689-24949-2-git-send-email-Ashish.Mittal@veritas.com
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/Makefile.objs  |   2 +
+ qapi/qom.json                    |  22 +++++--
- block/trace-events   |  17 ++
+ meson.build                      |  23 ++++---
- block/vxhs.c         | 575 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ include/sysemu/event-loop-base.h |  36 +++++++++++
- configure            |  39 ++++
+ include/sysemu/iothread.h        |   6 +-
- qapi/block-core.json |  23 ++-
+ event-loop-base.c                | 104 +++++++++++++++++++++++++++++++
-files changed, 654 insertions(+), 2 deletions(-)
+ iothread.c                       |  65 ++++++-------------
- create mode 100644 block/vxhs.c
+files changed, 192 insertions(+), 64 deletions(-)
+ create mode 100644 include/sysemu/event-loop-base.h
-diff --git a/block/Makefile.objs b/block/Makefile.objs
+ create mode 100644 event-loop-base.c
 diff --git a/qapi/qom.json b/qapi/qom.json
 index XXXXXXX..XXXXXXX 100644
---- a/block/Makefile.objs
+--- a/qapi/qom.json
-+++ b/block/Makefile.objs
++++ b/qapi/qom.json
-@@ -XXX,XX +XXX,XX @@ block-obj-$(CONFIG_LIBNFS) += nfs.o
+@@ -XXX,XX +XXX,XX @@
- block-obj-$(CONFIG_CURL) += curl.o
+             '*repeat': 'bool',
- block-obj-$(CONFIG_RBD) += rbd.o
+             '*grab-toggle': 'GrabToggleKeys' } }
- block-obj-$(CONFIG_GLUSTERFS) += gluster.o
-+block-obj-$(CONFIG_VXHS) += vxhs.o
++##
- block-obj-$(CONFIG_LIBSSH2) += ssh.o
++# @EventLoopBaseProperties:
- block-obj-y += accounting.o dirty-bitmap.o
++#
- block-obj-y += write-threshold.o
++# Common properties for event loops
-@@ -XXX,XX +XXX,XX @@ rbd.o-cflags       := $(RBD_CFLAGS)
++#
- rbd.o-libs         := $(RBD_LIBS)
++# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
- gluster.o-cflags   := $(GLUSTERFS_CFLAGS)
++#                 0 means that the engine will use its default.
- gluster.o-libs     := $(GLUSTERFS_LIBS)
++#                 (default: 0)
-+vxhs.o-libs        := $(VXHS_LIBS)
++#
- ssh.o-cflags       := $(LIBSSH2_CFLAGS)
++# Since: 7.1
- ssh.o-libs         := $(LIBSSH2_LIBS)
++##
- block-obj-$(if $(CONFIG_BZIP2),m,n) += dmg-bz2.o
++{ 'struct': 'EventLoopBaseProperties',
-diff --git a/block/trace-events b/block/trace-events
++  'data': { '*aio-max-batch': 'int' } }
 +
  ##
  # @IothreadProperties:
  #
@@ -XXX,XX +XXX,XX @@
  #               algorithm detects it is spending too long polling without
  #               encountering events. 0 selects a default behaviour (default: 0)
  #
 -# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
 -#                 0 means that the engine will use its default
 -#                 (default:0, since 6.1)
 +# The @aio-max-batch option is available since 6.1.
  #
  # Since: 2.0
  ##
  { 'struct': 'IothreadProperties',
 +  'base': 'EventLoopBaseProperties',
    'data': { '*poll-max-ns': 'int',
              '*poll-grow': 'int',
 -            '*poll-shrink': 'int',
 -            '*aio-max-batch': 'int' } }
 +            '*poll-shrink': 'int' } }
  ##
  # @MemoryBackendProperties:
 diff --git a/meson.build b/meson.build
 index XXXXXXX..XXXXXXX 100644
---- a/block/trace-events
+--- a/meson.build
-+++ b/block/trace-events
++++ b/meson.build
-@@ -XXX,XX +XXX,XX @@ qed_aio_write_data(void *s, void *acb, int ret, uint64_t offset, size_t len) "s
+@@ -XXX,XX +XXX,XX @@ subdir('qom')
- qed_aio_write_prefill(void *s, void *acb, uint64_t start, size_t len, uint64_t offset) "s %p acb %p start %"PRIu64" len %zu offset %"PRIu64
+ subdir('authz')
- qed_aio_write_postfill(void *s, void *acb, uint64_t start, size_t len, uint64_t offset) "s %p acb %p start %"PRIu64" len %zu offset %"PRIu64
+ subdir('crypto')
- qed_aio_write_main(void *s, void *acb, int ret, uint64_t offset, size_t len) "s %p acb %p ret %d offset %"PRIu64" len %zu"
+ subdir('ui')
-+
++subdir('hw')
-+# block/vxhs.c
-+vxhs_iio_callback(int error) "ctx is NULL: error %d"
-+vxhs_iio_callback_chnfail(int err, int error) "QNIO channel failed, no i/o %d, %d"
+ if enable_modules
-+vxhs_iio_callback_unknwn(int opcode, int err) "unexpected opcode %d, errno %d"
+@@ -XXX,XX +XXX,XX @@ if enable_modules
-+vxhs_aio_rw_invalid(int req) "Invalid I/O request iodir %d"
+   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
-+vxhs_aio_rw_ioerr(char *guid, int iodir, uint64_t size, uint64_t off, void *acb, int ret, int err) "IO ERROR (vDisk %s) FOR : Read/Write = %d size = %lu offset = %lu ACB = %p. Error = %d, errno = %d"
+ endif
-+vxhs_get_vdisk_stat_err(char *guid, int ret, int err) "vDisk (%s) stat ioctl failed, ret = %d, errno = %d"
-+vxhs_get_vdisk_stat(char *vdisk_guid, uint64_t vdisk_size) "vDisk %s stat ioctl returned size %lu"
++qom_ss = qom_ss.apply(config_host, strict: false)
-+vxhs_complete_aio(void *acb, uint64_t ret) "aio failed acb %p ret %ld"
++libqom = static_library('qom', qom_ss.sources() + genh,
-+vxhs_parse_uri_filename(const char *filename) "URI passed via bdrv_parse_filename %s"
++                        dependencies: [qom_ss.dependencies()],
-+vxhs_open_vdiskid(const char *vdisk_id) "Opening vdisk-id %s"
++                        name_suffix: 'fa')
-+vxhs_open_hostinfo(char *of_vsa_addr, int port) "Adding host %s:%d to BDRVVXHSState"
++qom = declare_dependency(link_whole: libqom)
-+vxhs_open_iio_open(const char *host) "Failed to connect to storage agent on host %s"
++
-+vxhs_parse_uri_hostinfo(char *host, int port) "Host: IP %s, Port %d"
++event_loop_base = files('event-loop-base.c')
-+vxhs_close(char *vdisk_guid) "Closing vdisk %s"
++event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh,
-+vxhs_get_creds(const char *cacert, const char *client_key, const char *client_cert) "cacert %s, client_key %s, client_cert %s"
++                                 build_by_default: true)
-diff --git a/block/vxhs.c b/block/vxhs.c
++event_loop_base = declare_dependency(link_whole: event_loop_base,
 +                                     dependencies: [qom])
 +
  stub_ss = stub_ss.apply(config_all, strict: false)
  util_ss.add_all(trace_ss)
@@ -XXX,XX +XXX,XX @@ subdir('monitor')
  subdir('net')
  subdir('replay')
  subdir('semihosting')
 -subdir('hw')
  subdir('tcg')
  subdir('fpu')
  subdir('accel')
@@ -XXX,XX +XXX,XX @@ qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
                               capture: true,
                               command: [undefsym, nm, '@INPUT@'])
 -qom_ss = qom_ss.apply(config_host, strict: false)
 -libqom = static_library('qom', qom_ss.sources() + genh,
 -                        dependencies: [qom_ss.dependencies()],
 -                        name_suffix: 'fa')
 -
 -qom = declare_dependency(link_whole: libqom)
 -
  authz_ss = authz_ss.apply(config_host, strict: false)
  libauthz = static_library('authz', authz_ss.sources() + genh,
                            dependencies: [authz_ss.dependencies()],
@@ -XXX,XX +XXX,XX @@ libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
                               build_by_default: false)
  blockdev = declare_dependency(link_whole: [libblockdev],
 -                              dependencies: [block])
 +                              dependencies: [block, event_loop_base])
  qmp_ss = qmp_ss.apply(config_host, strict: false)
  libqmp = static_library('qmp', qmp_ss.sources() + genh,
 diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/block/vxhs.c
++++ b/include/sysemu/event-loop-base.h
 @@ -XXX,XX +XXX,XX @@
 +/*
-+ * QEMU Block driver for Veritas HyperScale (VxHS)
++ * QEMU event-loop backend
 + *
-+ * Copyright (c) 2017 Veritas Technologies LLC.
++ * Copyright (C) 2022 Red Hat Inc
 + *
 + * Authors:
 + *  Nicolas Saenz Julienne <nsaenzju@redhat.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.
-+ *
 + */
++#ifndef QEMU_EVENT_LOOP_BASE_H
++#define QEMU_EVENT_LOOP_BASE_H
++
++#include "qom/object.h"
++#include "block/aio.h"
++#include "qemu/typedefs.h"
++
++#define TYPE_EVENT_LOOP_BASE         "event-loop-base"
++OBJECT_DECLARE_TYPE(EventLoopBase, EventLoopBaseClass,
++                    EVENT_LOOP_BASE)
++
++struct EventLoopBaseClass {
++    ObjectClass parent_class;
++
++    void (*init)(EventLoopBase *base, Error **errp);
++    void (*update_params)(EventLoopBase *base, Error **errp);
++};
++
++struct EventLoopBase {
++    Object parent;
++
++    /* AioContext AIO engine parameters */
++    int64_t aio_max_batch;
++};
++#endif
+diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/sysemu/iothread.h
++++ b/include/sysemu/iothread.h
+@@ -XXX,XX +XXX,XX @@
+ #include "block/aio.h"
+ #include "qemu/thread.h"
+ #include "qom/object.h"
++#include "sysemu/event-loop-base.h"
+ #define TYPE_IOTHREAD "iothread"
+ struct IOThread {
+-    Object parent_obj;
++    EventLoopBase parent_obj;
+     QemuThread thread;
+     AioContext *ctx;
+@@ -XXX,XX +XXX,XX @@ struct IOThread {
+     int64_t poll_max_ns;
+     int64_t poll_grow;
+     int64_t poll_shrink;
+-
+-    /* AioContext AIO engine parameters */
+-    int64_t aio_max_batch;
+ };
+ typedef struct IOThread IOThread;
+diff --git a/event-loop-base.c b/event-loop-base.c
+new file mode 100644
+index XXXXXXX..XXXXXXX
+--- /dev/null
++++ b/event-loop-base.c
+@@ -XXX,XX +XXX,XX @@
++/*
++ * QEMU event-loop base
++ *
++ * Copyright (C) 2022 Red Hat Inc
++ *
++ * Authors:
++ *  Stefan Hajnoczi <stefanha@redhat.com>
++ *  Nicolas Saenz Julienne <nsaenzju@redhat.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 <qnio/qnio_api.h>
++#include "qom/object_interfaces.h"
 +#include <sys/param.h>
 +#include "block/block_int.h"
 +#include "qapi/qmp/qerror.h"
 +#include "qapi/qmp/qdict.h"
 +#include "qapi/qmp/qstring.h"
 +#include "trace.h"
 +#include "qemu/uri.h"
 +#include "qapi/error.h"
-+#include "qemu/uuid.h"
++#include "sysemu/event-loop-base.h"
-+#include "crypto/tlscredsx509.h"
++
-+
++typedef struct {
-+#define VXHS_OPT_FILENAME           "filename"
++    const char *name;
-+#define VXHS_OPT_VDISK_ID           "vdisk-id"
++    ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
-+#define VXHS_OPT_SERVER             "server"
++} EventLoopBaseParamInfo;
-+#define VXHS_OPT_HOST               "host"
++
-+#define VXHS_OPT_PORT               "port"
++static EventLoopBaseParamInfo aio_max_batch_info = {
-+
++    "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
-+/* Only accessed under QEMU global mutex */
++};
-+static uint32_t vxhs_ref;
++
-+
++static void event_loop_base_get_param(Object *obj, Visitor *v,
-+typedef enum {
++        const char *name, void *opaque, Error **errp)
 +    VDISK_AIO_READ,
 +    VDISK_AIO_WRITE,
 +} VDISKAIOCmd;
 +
 +/*
 + * HyperScale AIO callbacks structure
 + */
 +typedef struct VXHSAIOCB {
 +    BlockAIOCB common;
 +    int err;
 +} VXHSAIOCB;
 +
 +typedef struct VXHSvDiskHostsInfo {
 +    void *dev_handle; /* Device handle */
 +    char *host; /* Host name or IP */
 +    int port; /* Host's port number */
 +} VXHSvDiskHostsInfo;
 +
 +/*
 + * Structure per vDisk maintained for state
 + */
 +typedef struct BDRVVXHSState {
 +    VXHSvDiskHostsInfo vdisk_hostinfo; /* Per host info */
 +    char *vdisk_guid;
 +    char *tlscredsid; /* tlscredsid */
 +} BDRVVXHSState;
 +
 +static void vxhs_complete_aio_bh(void *opaque)
 +{
-+    VXHSAIOCB *acb = opaque;
++    EventLoopBase *event_loop_base = EVENT_LOOP_BASE(obj);
-+    BlockCompletionFunc *cb = acb->common.cb;
++    EventLoopBaseParamInfo *info = opaque;
-+    void *cb_opaque = acb->common.opaque;
++    int64_t *field = (void *)event_loop_base + info->offset;
-+    int ret = 0;
++
-+
++    visit_type_int64(v, name, field, errp);
 +    if (acb->err != 0) {
 +        trace_vxhs_complete_aio(acb, acb->err);
 +        ret = (-EIO);
 +    }
 +
 +    qemu_aio_unref(acb);
 +    cb(cb_opaque, ret);
 +}
 +
-+/*
++static void event_loop_base_set_param(Object *obj, Visitor *v,
-+ * Called from a libqnio thread
++        const char *name, void *opaque, Error **errp)
 + */
 +static void vxhs_iio_callback(void *ctx, uint32_t opcode, uint32_t error)
 +{
-+    VXHSAIOCB *acb = NULL;
++    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(obj);
-+
++    EventLoopBase *base = EVENT_LOOP_BASE(obj);
-+    switch (opcode) {
++    EventLoopBaseParamInfo *info = opaque;
-+    case IRP_READ_REQUEST:
++    int64_t *field = (void *)base + info->offset;
-+    case IRP_WRITE_REQUEST:
++    int64_t value;
 +
-+        /*
++    if (!visit_type_int64(v, name, &value, errp)) {
-+         * ctx is VXHSAIOCB*
++        return;
-+         * ctx is NULL if error is QNIOERROR_CHANNEL_HUP
++    }
-+         */
++
-+        if (ctx) {
++    if (value < 0) {
-+            acb = ctx;
++        error_setg(errp, "%s value must be in range [0, %" PRId64 "]",
-+        } else {
++                   info->name, INT64_MAX);
-+            trace_vxhs_iio_callback(error);
++        return;
-+            goto out;
++    }
-+        }
++
-+
++    *field = value;
-+        if (error) {
++
-+            if (!acb->err) {
++    if (bc->update_params) {
-+                acb->err = error;
++        bc->update_params(base, errp);
-+            }
++    }
-+            trace_vxhs_iio_callback(error);
++
 +        }
 +
 +        aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs),
 +                                vxhs_complete_aio_bh, acb);
 +        break;
 +
 +    default:
 +        if (error == QNIOERROR_HUP) {
 +            /*
 +             * Channel failed, spontaneous notification,
 +             * not in response to I/O
 +             */
 +            trace_vxhs_iio_callback_chnfail(error, errno);
 +        } else {
 +            trace_vxhs_iio_callback_unknwn(opcode, error);
 +        }
 +        break;
 +    }
 +out:
 +    return;
 +}
 +
-+static QemuOptsList runtime_opts = {
++static void event_loop_base_complete(UserCreatable *uc, Error **errp)
-+    .name = "vxhs",
++{
-+    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
++    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
-+    .desc = {
++    EventLoopBase *base = EVENT_LOOP_BASE(uc);
-+        {
++
-+            .name = VXHS_OPT_FILENAME,
++    if (bc->init) {
-+            .type = QEMU_OPT_STRING,
++        bc->init(base, errp);
-+            .help = "URI to the Veritas HyperScale image",
++    }
-+        },
++}
-+        {
++
-+            .name = VXHS_OPT_VDISK_ID,
++static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
-+            .type = QEMU_OPT_STRING,
++{
-+            .help = "UUID of the VxHS vdisk",
++    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
-+        },
++    ucc->complete = event_loop_base_complete;
-+        {
++
-+            .name = "tls-creds",
++    object_class_property_add(klass, "aio-max-batch", "int",
-+            .type = QEMU_OPT_STRING,
++                              event_loop_base_get_param,
-+            .help = "ID of the TLS/SSL credentials to use",
++                              event_loop_base_set_param,
-+        },
++                              NULL, &aio_max_batch_info);
-+        { /* end of list */ }
++}
-+    },
++
 +static const TypeInfo event_loop_base_info = {
 +    .name = TYPE_EVENT_LOOP_BASE,
 +    .parent = TYPE_OBJECT,
 +    .instance_size = sizeof(EventLoopBase),
 +    .class_size = sizeof(EventLoopBaseClass),
 +    .class_init = event_loop_base_class_init,
 +    .abstract = true,
 +    .interfaces = (InterfaceInfo[]) {
 +        { TYPE_USER_CREATABLE },
 +        { }
 +    }
 +};
 +
-+static QemuOptsList runtime_tcp_opts = {
++static void register_types(void)
 +    .name = "vxhs_tcp",
 +    .head = QTAILQ_HEAD_INITIALIZER(runtime_tcp_opts.head),
 +    .desc = {
 +        {
 +            .name = VXHS_OPT_HOST,
 +            .type = QEMU_OPT_STRING,
 +            .help = "host address (ipv4 addresses)",
 +        },
 +        {
 +            .name = VXHS_OPT_PORT,
 +            .type = QEMU_OPT_NUMBER,
 +            .help = "port number on which VxHSD is listening (default 9999)",
 +            .def_value_str = "9999"
 +        },
 +        { /* end of list */ }
 +    },
 +};
 +
 +/*
 + * Parse incoming URI and populate *options with the host
 + * and device information
 + */
 +static int vxhs_parse_uri(const char *filename, QDict *options)
 +{
-+    URI *uri = NULL;
++    type_register_static(&event_loop_base_info);
 +    char *port;
 +    int ret = 0;
 +
 +    trace_vxhs_parse_uri_filename(filename);
 +    uri = uri_parse(filename);
 +    if (!uri || !uri->server || !uri->path) {
 +        uri_free(uri);
 +        return -EINVAL;
 +    }
 +
 +    qdict_put(options, VXHS_OPT_SERVER".host", qstring_from_str(uri->server));
 +
 +    if (uri->port) {
 +        port = g_strdup_printf("%d", uri->port);
 +        qdict_put(options, VXHS_OPT_SERVER".port", qstring_from_str(port));
 +        g_free(port);
 +    }
 +
 +    qdict_put(options, "vdisk-id", qstring_from_str(uri->path));
 +
 +    trace_vxhs_parse_uri_hostinfo(uri->server, uri->port);
 +    uri_free(uri);
 +
 +    return ret;
 +}
-+
++type_init(register_types);
-+static void vxhs_parse_filename(const char *filename, QDict *options,
+diff --git a/iothread.c b/iothread.c
-+                                Error **errp)
+index XXXXXXX..XXXXXXX 100644
-+{
+--- a/iothread.c
-+    if (qdict_haskey(options, "vdisk-id") || qdict_haskey(options, "server")) {
++++ b/iothread.c
-+        error_setg(errp, "vdisk-id/server and a file name may not be specified "
+@@ -XXX,XX +XXX,XX @@
-+                         "at the same time");
+ #include "qemu/module.h"
  #include "block/aio.h"
  #include "block/block.h"
 +#include "sysemu/event-loop-base.h"
  #include "sysemu/iothread.h"
  #include "qapi/error.h"
  #include "qapi/qapi-commands-misc.h"
@@ -XXX,XX +XXX,XX @@ static void iothread_init_gcontext(IOThread *iothread)
      iothread->main_loop = g_main_loop_new(iothread->worker_context, TRUE);
  }
 -static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
 +static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp)
  {
 +    IOThread *iothread = IOTHREAD(base);
      ERRP_GUARD();
 +    if (!iothread->ctx) {
 +        return;
 +    }
 +
-+    if (strstr(filename, "://")) {
+     aio_context_set_poll_params(iothread->ctx,
-+        int ret = vxhs_parse_uri(filename, options);
+                                 iothread->poll_max_ns,
-+        if (ret < 0) {
+                                 iothread->poll_grow,
-+            error_setg(errp, "Invalid URI. URI should be of the form "
+@@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
-+                       "  vxhs://<host_ip>:<port>/<vdisk-id>");
+     }
-+        }
-+    }
+     aio_context_set_aio_params(iothread->ctx,
-+}
+-                               iothread->aio_max_batch,
-+
++                               iothread->parent_obj.aio_max_batch,
-+static int vxhs_init_and_ref(void)
+                                errp);
-+{
+ }
-+    if (vxhs_ref++ == 0) {
-+        if (iio_init(QNIO_VERSION, vxhs_iio_callback)) {
+-static void iothread_complete(UserCreatable *obj, Error **errp)
-+            return -ENODEV;
++
-+        }
++static void iothread_init(EventLoopBase *base, Error **errp)
-+    }
+ {
-+    return 0;
+     Error *local_error = NULL;
-+}
+-    IOThread *iothread = IOTHREAD(obj);
-+
++    IOThread *iothread = IOTHREAD(base);
-+static void vxhs_unref(void)
+     char *thread_name;
-+{
-+    if (--vxhs_ref == 0) {
+     iothread->stopping = false;
-+        iio_fini();
+@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
-+    }
+      */
-+}
+     iothread_init_gcontext(iothread);
-+
-+static void vxhs_get_tls_creds(const char *id, char **cacert,
+-    iothread_set_aio_context_params(iothread, &local_error);
-+                               char **key, char **cert, Error **errp)
++    iothread_set_aio_context_params(base, &local_error);
-+{
+     if (local_error) {
-+    Object *obj;
+         error_propagate(errp, local_error);
-+    QCryptoTLSCreds *creds;
+         aio_context_unref(iothread->ctx);
-+    QCryptoTLSCredsX509 *creds_x509;
+@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
-+
+      * to inherit.
-+    obj = object_resolve_path_component(
+      */
-+        object_get_objects_root(), id);
+     thread_name = g_strdup_printf("IO %s",
-+
+-                        object_get_canonical_path_component(OBJECT(obj)));
-+    if (!obj) {
++                        object_get_canonical_path_component(OBJECT(base)));
-+        error_setg(errp, "No TLS credentials with id '%s'",
+     qemu_thread_create(&iothread->thread, thread_name, iothread_run,
-+                   id);
+                        iothread, QEMU_THREAD_JOINABLE);
-+        return;
+     g_free(thread_name);
-+    }
+@@ -XXX,XX +XXX,XX @@ static IOThreadParamInfo poll_grow_info = {
-+
+ static IOThreadParamInfo poll_shrink_info = {
-+    creds_x509 = (QCryptoTLSCredsX509 *)
+     "poll-shrink", offsetof(IOThread, poll_shrink),
-+        object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS_X509);
+ };
-+
+-static IOThreadParamInfo aio_max_batch_info = {
-+    if (!creds_x509) {
+-    "aio-max-batch", offsetof(IOThread, aio_max_batch),
-+        error_setg(errp, "Object with id '%s' is not TLS credentials",
+-};
-+                   id);
-+        return;
+ static void iothread_get_param(Object *obj, Visitor *v,
-+    }
+         const char *name, IOThreadParamInfo *info, Error **errp)
-+
+@@ -XXX,XX +XXX,XX @@ static void iothread_set_poll_param(Object *obj, Visitor *v,
-+    creds = &creds_x509->parent_obj;
+     }
-+
+ }
-+    if (creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT) {
-+        error_setg(errp,
+-static void iothread_get_aio_param(Object *obj, Visitor *v,
-+                   "Expecting TLS credentials with a client endpoint");
+-        const char *name, void *opaque, Error **errp)
-+        return;
+-{
-+    }
+-    IOThreadParamInfo *info = opaque;
-+
+-
-+    /*
+-    iothread_get_param(obj, v, name, info, errp);
-+     * Get the cacert, client_cert and client_key file names.
+-}
-+     */
+-
-+    if (!creds->dir) {
+-static void iothread_set_aio_param(Object *obj, Visitor *v,
-+        error_setg(errp, "TLS object missing 'dir' property value");
+-        const char *name, void *opaque, Error **errp)
-+        return;
+-{
-+    }
+-    IOThread *iothread = IOTHREAD(obj);
-+
+-    IOThreadParamInfo *info = opaque;
-+    *cacert = g_strdup_printf("%s/%s", creds->dir,
+-
-+                              QCRYPTO_TLS_CREDS_X509_CA_CERT);
+-    if (!iothread_set_param(obj, v, name, info, errp)) {
-+    *cert = g_strdup_printf("%s/%s", creds->dir,
+-        return;
-+                            QCRYPTO_TLS_CREDS_X509_CLIENT_CERT);
+-    }
-+    *key = g_strdup_printf("%s/%s", creds->dir,
+-
-+                           QCRYPTO_TLS_CREDS_X509_CLIENT_KEY);
+-    if (iothread->ctx) {
-+}
+-        aio_context_set_aio_params(iothread->ctx,
-+
+-                                   iothread->aio_max_batch,
-+static int vxhs_open(BlockDriverState *bs, QDict *options,
+-                                   errp);
-+                     int bdrv_flags, Error **errp)
+-    }
-+{
+-}
-+    BDRVVXHSState *s = bs->opaque;
+-
-+    void *dev_handlep;
+ static void iothread_class_init(ObjectClass *klass, void *class_data)
-+    QDict *backing_options = NULL;
+ {
-+    QemuOpts *opts = NULL;
+-    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
-+    QemuOpts *tcp_opts = NULL;
+-    ucc->complete = iothread_complete;
-+    char *of_vsa_addr = NULL;
++    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(klass);
-+    Error *local_err = NULL;
++
-+    const char *vdisk_id_opt;
++    bc->init = iothread_init;
-+    const char *server_host_opt;
++    bc->update_params = iothread_set_aio_context_params;
-+    int ret = 0;
-+    char *cacert = NULL;
+     object_class_property_add(klass, "poll-max-ns", "int",
-+    char *client_key = NULL;
+                               iothread_get_poll_param,
-+    char *client_cert = NULL;
+@@ -XXX,XX +XXX,XX @@ static void iothread_class_init(ObjectClass *klass, void *class_data)
-+
+                               iothread_get_poll_param,
-+    ret = vxhs_init_and_ref();
+                               iothread_set_poll_param,
-+    if (ret < 0) {
+                               NULL, &poll_shrink_info);
-+        ret = -EINVAL;
+-    object_class_property_add(klass, "aio-max-batch", "int",
-+        goto out;
+-                              iothread_get_aio_param,
-+    }
+-                              iothread_set_aio_param,
-+
+-                              NULL, &aio_max_batch_info);
-+    /* Create opts info from runtime_opts and runtime_tcp_opts list */
+ }
-+    opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
-+    tcp_opts = qemu_opts_create(&runtime_tcp_opts, NULL, 0, &error_abort);
+ static const TypeInfo iothread_info = {
-+
+     .name = TYPE_IOTHREAD,
-+    qemu_opts_absorb_qdict(opts, options, &local_err);
+-    .parent = TYPE_OBJECT,
-+    if (local_err) {
++    .parent = TYPE_EVENT_LOOP_BASE,
-+        ret = -EINVAL;
+     .class_init = iothread_class_init,
-+        goto out;
+     .instance_size = sizeof(IOThread),
-+    }
+     .instance_init = iothread_instance_init,
-+
+     .instance_finalize = iothread_instance_finalize,
-+    /* vdisk-id is the disk UUID */
+-    .interfaces = (InterfaceInfo[]) {
-+    vdisk_id_opt = qemu_opt_get(opts, VXHS_OPT_VDISK_ID);
+-        {TYPE_USER_CREATABLE},
-+    if (!vdisk_id_opt) {
+-        {}
-+        error_setg(&local_err, QERR_MISSING_PARAMETER, VXHS_OPT_VDISK_ID);
+-    },
-+        ret = -EINVAL;
+ };
-+        goto out;
-+    }
+ static void iothread_register_types(void)
-+
+@@ -XXX,XX +XXX,XX @@ static int query_one_iothread(Object *object, void *opaque)
-+    /* vdisk-id may contain a leading '/' */
+     info->poll_max_ns = iothread->poll_max_ns;
-+    if (strlen(vdisk_id_opt) > UUID_FMT_LEN + 1) {
+     info->poll_grow = iothread->poll_grow;
-+        error_setg(&local_err, "vdisk-id cannot be more than %d characters",
+     info->poll_shrink = iothread->poll_shrink;
-+                   UUID_FMT_LEN);
+-    info->aio_max_batch = iothread->aio_max_batch;
-+        ret = -EINVAL;
++    info->aio_max_batch = iothread->parent_obj.aio_max_batch;
-+        goto out;
-+    }
+     QAPI_LIST_APPEND(*tail, info);
-+
+     return 0;
 +    s->vdisk_guid = g_strdup(vdisk_id_opt);
 +    trace_vxhs_open_vdiskid(vdisk_id_opt);
 +
 +    /* get the 'server.' arguments */
 +    qdict_extract_subqdict(options, &backing_options, VXHS_OPT_SERVER".");
 +
 +    qemu_opts_absorb_qdict(tcp_opts, backing_options, &local_err);
 +    if (local_err != NULL) {
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +
 +    server_host_opt = qemu_opt_get(tcp_opts, VXHS_OPT_HOST);
 +    if (!server_host_opt) {
 +        error_setg(&local_err, QERR_MISSING_PARAMETER,
 +                   VXHS_OPT_SERVER"."VXHS_OPT_HOST);
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +
 +    if (strlen(server_host_opt) > MAXHOSTNAMELEN) {
 +        error_setg(&local_err, "server.host cannot be more than %d characters",
 +                   MAXHOSTNAMELEN);
 +        ret = -EINVAL;
 +        goto out;
 +    }
 +
 +    /* check if we got tls-creds via the --object argument */
 +    s->tlscredsid = g_strdup(qemu_opt_get(opts, "tls-creds"));
 +    if (s->tlscredsid) {
 +        vxhs_get_tls_creds(s->tlscredsid, &cacert, &client_key,
 +                           &client_cert, &local_err);
 +        if (local_err != NULL) {
 +            ret = -EINVAL;
 +            goto out;
 +        }
 +        trace_vxhs_get_creds(cacert, client_key, client_cert);
 +    }
 +
 +    s->vdisk_hostinfo.host = g_strdup(server_host_opt);
 +    s->vdisk_hostinfo.port = g_ascii_strtoll(qemu_opt_get(tcp_opts,
 +                                                          VXHS_OPT_PORT),
 +                                                          NULL, 0);
 +
 +    trace_vxhs_open_hostinfo(s->vdisk_hostinfo.host,
 +                             s->vdisk_hostinfo.port);
 +
 +    of_vsa_addr = g_strdup_printf("of://%s:%d",
 +                                  s->vdisk_hostinfo.host,
 +                                  s->vdisk_hostinfo.port);
 +
 +    /*
 +     * Open qnio channel to storage agent if not opened before
 +     */
 +    dev_handlep = iio_open(of_vsa_addr, s->vdisk_guid, 0,
 +                           cacert, client_key, client_cert);
 +    if (dev_handlep == NULL) {
 +        trace_vxhs_open_iio_open(of_vsa_addr);
 +        ret = -ENODEV;
 +        goto out;
 +    }
 +    s->vdisk_hostinfo.dev_handle = dev_handlep;
 +
 +out:
 +    g_free(of_vsa_addr);
 +    QDECREF(backing_options);
 +    qemu_opts_del(tcp_opts);
 +    qemu_opts_del(opts);
 +    g_free(cacert);
 +    g_free(client_key);
 +    g_free(client_cert);
 +
 +    if (ret < 0) {
 +        vxhs_unref();
 +        error_propagate(errp, local_err);
 +        g_free(s->vdisk_hostinfo.host);
 +        g_free(s->vdisk_guid);
 +        g_free(s->tlscredsid);
 +        s->vdisk_guid = NULL;
 +    }
 +
 +    return ret;
 +}
 +
 +static const AIOCBInfo vxhs_aiocb_info = {
 +    .aiocb_size = sizeof(VXHSAIOCB)
 +};
 +
 +/*
 + * This allocates QEMU-VXHS callback for each IO
 + * and is passed to QNIO. When QNIO completes the work,
 + * it will be passed back through the callback.
 + */
 +static BlockAIOCB *vxhs_aio_rw(BlockDriverState *bs, int64_t sector_num,
 +                               QEMUIOVector *qiov, int nb_sectors,
 +                               BlockCompletionFunc *cb, void *opaque,
 +                               VDISKAIOCmd iodir)
 +{
 +    VXHSAIOCB *acb = NULL;
 +    BDRVVXHSState *s = bs->opaque;
 +    size_t size;
 +    uint64_t offset;
 +    int iio_flags = 0;
 +    int ret = 0;
 +    void *dev_handle = s->vdisk_hostinfo.dev_handle;
 +
 +    offset = sector_num * BDRV_SECTOR_SIZE;
 +    size = nb_sectors * BDRV_SECTOR_SIZE;
 +    acb = qemu_aio_get(&vxhs_aiocb_info, bs, cb, opaque);
 +
 +    /*
 +     * Initialize VXHSAIOCB.
 +     */
 +    acb->err = 0;
 +
 +    iio_flags = IIO_FLAG_ASYNC;
 +
 +    switch (iodir) {
 +    case VDISK_AIO_WRITE:
 +            ret = iio_writev(dev_handle, acb, qiov->iov, qiov->niov,
 +                             offset, (uint64_t)size, iio_flags);
 +            break;
 +    case VDISK_AIO_READ:
 +            ret = iio_readv(dev_handle, acb, qiov->iov, qiov->niov,
 +                            offset, (uint64_t)size, iio_flags);
 +            break;
 +    default:
 +            trace_vxhs_aio_rw_invalid(iodir);
 +            goto errout;
 +    }
 +
 +    if (ret != 0) {
 +        trace_vxhs_aio_rw_ioerr(s->vdisk_guid, iodir, size, offset,
 +                                acb, ret, errno);
 +        goto errout;
 +    }
 +    return &acb->common;
 +
 +errout:
 +    qemu_aio_unref(acb);
 +    return NULL;
 +}
 +
 +static BlockAIOCB *vxhs_aio_readv(BlockDriverState *bs,
 +                                   int64_t sector_num, QEMUIOVector *qiov,
 +                                   int nb_sectors,
 +                                   BlockCompletionFunc *cb, void *opaque)
 +{
 +    return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors, cb,
 +                       opaque, VDISK_AIO_READ);
 +}
 +
 +static BlockAIOCB *vxhs_aio_writev(BlockDriverState *bs,
 +                                   int64_t sector_num, QEMUIOVector *qiov,
 +                                   int nb_sectors,
 +                                   BlockCompletionFunc *cb, void *opaque)
 +{
 +    return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors,
 +                       cb, opaque, VDISK_AIO_WRITE);
 +}
 +
 +static void vxhs_close(BlockDriverState *bs)
 +{
 +    BDRVVXHSState *s = bs->opaque;
 +
 +    trace_vxhs_close(s->vdisk_guid);
 +
 +    g_free(s->vdisk_guid);
 +    s->vdisk_guid = NULL;
 +
 +    /*
 +     * Close vDisk device
 +     */
 +    if (s->vdisk_hostinfo.dev_handle) {
 +        iio_close(s->vdisk_hostinfo.dev_handle);
 +        s->vdisk_hostinfo.dev_handle = NULL;
 +    }
 +
 +    vxhs_unref();
 +
 +    /*
 +     * Free the dynamically allocated host string etc
 +     */
 +    g_free(s->vdisk_hostinfo.host);
 +    g_free(s->tlscredsid);
 +    s->tlscredsid = NULL;
 +    s->vdisk_hostinfo.host = NULL;
 +    s->vdisk_hostinfo.port = 0;
 +}
 +
 +static int64_t vxhs_get_vdisk_stat(BDRVVXHSState *s)
 +{
 +    int64_t vdisk_size = -1;
 +    int ret = 0;
 +    void *dev_handle = s->vdisk_hostinfo.dev_handle;
 +
 +    ret = iio_ioctl(dev_handle, IOR_VDISK_STAT, &vdisk_size, 0);
 +    if (ret < 0) {
 +        trace_vxhs_get_vdisk_stat_err(s->vdisk_guid, ret, errno);
 +        return -EIO;
 +    }
 +
 +    trace_vxhs_get_vdisk_stat(s->vdisk_guid, vdisk_size);
 +    return vdisk_size;
 +}
 +
 +/*
 + * Returns the size of vDisk in bytes. This is required
 + * by QEMU block upper block layer so that it is visible
 + * to guest.
 + */
 +static int64_t vxhs_getlength(BlockDriverState *bs)
 +{
 +    BDRVVXHSState *s = bs->opaque;
 +    int64_t vdisk_size;
 +
 +    vdisk_size = vxhs_get_vdisk_stat(s);
 +    if (vdisk_size < 0) {
 +        return -EIO;
 +    }
 +
 +    return vdisk_size;
 +}
 +
 +static BlockDriver bdrv_vxhs = {
 +    .format_name                  = "vxhs",
 +    .protocol_name                = "vxhs",
 +    .instance_size                = sizeof(BDRVVXHSState),
 +    .bdrv_file_open               = vxhs_open,
 +    .bdrv_parse_filename          = vxhs_parse_filename,
 +    .bdrv_close                   = vxhs_close,
 +    .bdrv_getlength               = vxhs_getlength,
 +    .bdrv_aio_readv               = vxhs_aio_readv,
 +    .bdrv_aio_writev              = vxhs_aio_writev,
 +};
 +
 +static void bdrv_vxhs_init(void)
 +{
 +    bdrv_register(&bdrv_vxhs);
 +}
 +
 +block_init(bdrv_vxhs_init);
 diff --git a/configure b/configure
 index XXXXXXX..XXXXXXX 100755
 --- a/configure
 +++ b/configure
@@ -XXX,XX +XXX,XX @@ numa=""
  tcmalloc="no"
  jemalloc="no"
  replication="yes"
 +vxhs=""
  supported_cpu="no"
  supported_os="no"
@@ -XXX,XX +XXX,XX @@ for opt do
    ;;
    --enable-replication) replication="yes"
    ;;
 +  --disable-vxhs) vxhs="no"
 +  ;;
 +  --enable-vxhs) vxhs="yes"
 +  ;;
    *)
        echo "ERROR: unknown option $opt"
        echo "Try '$0 --help' for more information"
@@ -XXX,XX +XXX,XX @@ disabled with --disable-FEATURE, default is enabled if available:
    xfsctl          xfsctl support
    qom-cast-debug  cast debugging support
    tools           build qemu-io, qemu-nbd and qemu-image tools
 +  vxhs            Veritas HyperScale vDisk backend support
  NOTE: The object files are built at the place where configure is launched
  EOF
@@ -XXX,XX +XXX,XX @@ if compile_prog "" "" ; then
  fi
  ##########################################
 +# Veritas HyperScale block driver VxHS
 +# Check if libvxhs is installed
 +
 +if test "$vxhs" != "no" ; then
 +  cat > $TMPC <<EOF
 +#include <stdint.h>
 +#include <qnio/qnio_api.h>
 +
 +void *vxhs_callback;
 +
 +int main(void) {
 +    iio_init(QNIO_VERSION, vxhs_callback);
 +    return 0;
 +}
 +EOF
 +  vxhs_libs="-lvxhs -lssl"
 +  if compile_prog "" "$vxhs_libs" ; then
 +    vxhs=yes
 +  else
 +    if test "$vxhs" = "yes" ; then
 +      feature_not_found "vxhs block device" "Install libvxhs See github"
 +    fi
 +    vxhs=no
 +  fi
 +fi
 +
 +##########################################
  # End of CC checks
  # After here, no more $cc or $ld runs
@@ -XXX,XX +XXX,XX @@ echo "tcmalloc support  $tcmalloc"
  echo "jemalloc support  $jemalloc"
  echo "avx2 optimization $avx2_opt"
  echo "replication support $replication"
 +echo "VxHS block device $vxhs"
  if test "$sdl_too_old" = "yes"; then
  echo "-> Your SDL version is too old - please upgrade to have SDL support"
@@ -XXX,XX +XXX,XX @@ if test "$pthread_setname_np" = "yes" ; then
    echo "CONFIG_PTHREAD_SETNAME_NP=y" >> $config_host_mak
  fi
 +if test "$vxhs" = "yes" ; then
 +  echo "CONFIG_VXHS=y" >> $config_host_mak
 +  echo "VXHS_LIBS=$vxhs_libs" >> $config_host_mak
 +fi
 +
  if test "$tcg_interpreter" = "yes"; then
    QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/tci $QEMU_INCLUDES"
  elif test "$ARCH" = "sparc64" ; then
 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 @@
  #
  # Drivers that are supported in block device operations.
  #
 +# @vxhs: Since 2.10
 +#
  # Since: 2.9
  ##
  { 'enum': 'BlockdevDriver',
@@ -XXX,XX +XXX,XX @@
              'host_device', 'http', 'https', 'iscsi', 'luks', 'nbd', 'nfs',
              'null-aio', 'null-co', 'parallels', 'qcow', 'qcow2', 'qed',
              'quorum', 'raw', 'rbd', 'replication', 'sheepdog', 'ssh',
 -            'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat' ] }
 +            'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] }
  ##
  # @BlockdevOptionsFile:
@@ -XXX,XX +XXX,XX @@
    'data': { '*offset': 'int', '*size': 'int' } }
  ##
 +# @BlockdevOptionsVxHS:
 +#
 +# Driver specific block device options for VxHS
 +#
 +# @vdisk-id:    UUID of VxHS volume
 +# @server:      vxhs server IP, port
 +# @tls-creds:   TLS credentials ID
 +#
 +# Since: 2.10
 +##
 +{ 'struct': 'BlockdevOptionsVxHS',
 +  'data': { 'vdisk-id': 'str',
 +            'server': 'InetSocketAddressBase',
 +            '*tls-creds': 'str' } }
 +
 +##
  # @BlockdevOptions:
  #
  # Options for creating a block device.  Many options are available for all
@@ -XXX,XX +XXX,XX @@
        'vhdx':       'BlockdevOptionsGenericFormat',
        'vmdk':       'BlockdevOptionsGenericCOWFormat',
        'vpc':        'BlockdevOptionsGenericFormat',
 -      'vvfat':      'BlockdevOptionsVVFAT'
 +      'vvfat':      'BlockdevOptionsVVFAT',
 +      'vxhs':       'BlockdevOptionsVxHS'
    } }
  ##
 --
-.9.3
+.35.1

-[Qemu-devel] [PULL 02/12] block/vxhs.c: Add qemu-iotests for new block device type "vxhs"
+Deleted patch
-From: Ashish Mittal <ashmit602@gmail.com>
-These changes use a vxhs test server that is a part of the following
-repository:
-https://github.com/VeritasHyperScale/libqnio.git
-Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
-Message-id: 1491277689-24949-3-git-send-email-Ashish.Mittal@veritas.com
----
- tests/qemu-iotests/common        |  6 ++++++
- tests/qemu-iotests/common.config | 13 +++++++++++++
- tests/qemu-iotests/common.filter |  1 +
- tests/qemu-iotests/common.rc     | 19 +++++++++++++++++++
-files changed, 39 insertions(+)
-diff --git a/tests/qemu-iotests/common b/tests/qemu-iotests/common
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common
-+++ b/tests/qemu-iotests/common
-@@ -XXX,XX +XXX,XX @@ check options
-     -ssh                test ssh
-     -nfs                test nfs
-     -luks               test luks
-+    -vxhs               test vxhs
-     -xdiff              graphical mode diff
-     -nocache            use O_DIRECT on backing file
-     -misalign           misalign memory allocations
-@@ -XXX,XX +XXX,XX @@ testlist options
-             xpand=false
-             ;;
-+        -vxhs)
-+            IMGPROTO=vxhs
-+            xpand=false
-+            ;;
-+
-         -ssh)
-             IMGPROTO=ssh
-             xpand=false
-diff --git a/tests/qemu-iotests/common.config b/tests/qemu-iotests/common.config
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.config
-+++ b/tests/qemu-iotests/common.config
-@@ -XXX,XX +XXX,XX @@ if [ -z "$QEMU_NBD_PROG" ]; then
-     export QEMU_NBD_PROG="`set_prog_path qemu-nbd`"
- fi
-+if [ -z "$QEMU_VXHS_PROG" ]; then
-+    export QEMU_VXHS_PROG="`set_prog_path qnio_server`"
-+fi
-+
- _qemu_wrapper()
- {
-     (
-@@ -XXX,XX +XXX,XX @@ _qemu_nbd_wrapper()
-     )
- }
-+_qemu_vxhs_wrapper()
-+{
-+    (
-+        echo $BASHPID > "${TEST_DIR}/qemu-vxhs.pid"
-+        exec "$QEMU_VXHS_PROG" $QEMU_VXHS_OPTIONS "$@"
-+    )
-+}
-+
- export QEMU=_qemu_wrapper
- export QEMU_IMG=_qemu_img_wrapper
- export QEMU_IO=_qemu_io_wrapper
- export QEMU_NBD=_qemu_nbd_wrapper
-+export QEMU_VXHS=_qemu_vxhs_wrapper
- QEMU_IMG_EXTRA_ARGS=
- if [ "$IMGOPTSSYNTAX" = "true" ]; then
-diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.filter
-+++ b/tests/qemu-iotests/common.filter
-@@ -XXX,XX +XXX,XX @@ _filter_img_info()
-         -e "s#$TEST_DIR#TEST_DIR#g" \
-         -e "s#$IMGFMT#IMGFMT#g" \
-         -e 's#nbd://127.0.0.1:10810$#TEST_DIR/t.IMGFMT#g' \
-+        -e 's#json.*vdisk-id.*vxhs"}}#TEST_DIR/t.IMGFMT#' \
-         -e "/encrypted: yes/d" \
-         -e "/cluster_size: [0-9]\\+/d" \
-         -e "/table_size: [0-9]\\+/d" \
-diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.rc
-+++ b/tests/qemu-iotests/common.rc
-@@ -XXX,XX +XXX,XX @@ else
-     elif [ "$IMGPROTO" = "nfs" ]; then
-         TEST_DIR="nfs://127.0.0.1/$TEST_DIR"
-         TEST_IMG=$TEST_DIR/t.$IMGFMT
-+    elif [ "$IMGPROTO" = "vxhs" ]; then
-+        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
-+        TEST_IMG="vxhs://127.0.0.1:9999/t.$IMGFMT"
-     else
-         TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT
-     fi
-@@ -XXX,XX +XXX,XX @@ _make_test_img()
-         eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT  $TEST_IMG_FILE >/dev/null &"
-         sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
-     fi
-+
-+    # Start QNIO server on image directory for vxhs protocol
-+    if [ $IMGPROTO = "vxhs" ]; then
-+        eval "$QEMU_VXHS -d  $TEST_DIR > /dev/null &"
-+        sleep 1 # Wait for server to come up.
-+    fi
- }
- _rm_test_img()
-@@ -XXX,XX +XXX,XX @@ _cleanup_test_img()
-             fi
-             rm -f "$TEST_IMG_FILE"
-             ;;
-+        vxhs)
-+            if [ -f "${TEST_DIR}/qemu-vxhs.pid" ]; then
-+                local QEMU_VXHS_PID
-+                read QEMU_VXHS_PID < "${TEST_DIR}/qemu-vxhs.pid"
-+                kill ${QEMU_VXHS_PID} >/dev/null 2>&1
-+                rm -f "${TEST_DIR}/qemu-vxhs.pid"
-+            fi
-+            rm -f "$TEST_IMG_FILE"
-+            ;;
-+
-         file)
-             _rm_test_img "$TEST_DIR/t.$IMGFMT"
-             _rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
---
-.9.3

-[Qemu-devel] [PULL 03/12] qemu-iotests: exclude vxhs from image creation via protocol
+Deleted patch
-The protocol VXHS does not support image creation.  Some tests expect
-to be able to create images through the protocol.  Exclude VXHS from
-these tests.
-Signed-off-by: Jeff Cody <jcody@redhat.com>
----
- tests/qemu-iotests/017 | 1 +
- tests/qemu-iotests/020 | 1 +
- tests/qemu-iotests/029 | 1 +
- tests/qemu-iotests/073 | 1 +
- tests/qemu-iotests/114 | 1 +
- tests/qemu-iotests/130 | 1 +
- tests/qemu-iotests/134 | 1 +
- tests/qemu-iotests/156 | 1 +
- tests/qemu-iotests/158 | 1 +
-files changed, 9 insertions(+)
-diff --git a/tests/qemu-iotests/017 b/tests/qemu-iotests/017
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/017
-+++ b/tests/qemu-iotests/017
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- # Any format supporting backing files
- _supported_fmt qcow qcow2 vmdk qed
- _supported_proto generic
-+_unsupported_proto vxhs
- _supported_os Linux
- _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
-diff --git a/tests/qemu-iotests/020 b/tests/qemu-iotests/020
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/020
-+++ b/tests/qemu-iotests/020
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- # Any format supporting backing files
- _supported_fmt qcow qcow2 vmdk qed
- _supported_proto generic
-+_unsupported_proto vxhs
- _supported_os Linux
- _unsupported_imgopts "subformat=monolithicFlat" \
-                      "subformat=twoGbMaxExtentFlat" \
-diff --git a/tests/qemu-iotests/029 b/tests/qemu-iotests/029
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/029
-+++ b/tests/qemu-iotests/029
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- # Any format supporting intenal snapshots
- _supported_fmt qcow2
- _supported_proto generic
-+_unsupported_proto vxhs
- _supported_os Linux
- # Internal snapshots are (currently) impossible with refcount_bits=1
- _unsupported_imgopts 'refcount_bits=1[^0-9]'
-diff --git a/tests/qemu-iotests/073 b/tests/qemu-iotests/073
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/073
-+++ b/tests/qemu-iotests/073
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow2
- _supported_proto generic
-+_unsupported_proto vxhs
- _supported_os Linux
- CLUSTER_SIZE=64k
-diff --git a/tests/qemu-iotests/114 b/tests/qemu-iotests/114
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/114
-+++ b/tests/qemu-iotests/114
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow2
- _supported_proto generic
-+_unsupported_proto vxhs
- _supported_os Linux
-diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/130
-+++ b/tests/qemu-iotests/130
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow2
- _supported_proto generic
-+_unsupported_proto vxhs
- _supported_os Linux
- qemu_comm_method="monitor"
-diff --git a/tests/qemu-iotests/134 b/tests/qemu-iotests/134
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/134
-+++ b/tests/qemu-iotests/134
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow2
- _supported_proto generic
-+_unsupported_proto vxhs
- _supported_os Linux
-diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/156
-+++ b/tests/qemu-iotests/156
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow2 qed
- _supported_proto generic
-+_unsupported_proto vxhs
- _supported_os Linux
- # Create source disk
-diff --git a/tests/qemu-iotests/158 b/tests/qemu-iotests/158
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/158
-+++ b/tests/qemu-iotests/158
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow2
- _supported_proto generic
-+_unsupported_proto vxhs
- _supported_os Linux
---
-.9.3

-[Qemu-devel] [PULL 04/12] block: add bdrv_set_read_only() helper function
+Deleted patch
-We have a helper wrapper for checking for the BDS read_only flag,
-add a helper wrapper to set the read_only flag as well.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: 9b18972d05f5fa2ac16c014f0af98d680553048d.1491597120.git.jcody@redhat.com
----
- block.c               | 5 +++++
- block/bochs.c         | 2 +-
- block/cloop.c         | 2 +-
- block/dmg.c           | 2 +-
- block/rbd.c           | 2 +-
- block/vvfat.c         | 4 ++--
- include/block/block.h | 1 +
-files changed, 12 insertions(+), 6 deletions(-)
-diff --git a/block.c b/block.c
-index XXXXXXX..XXXXXXX 100644
---- a/block.c
-+++ b/block.c
-@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
-     }
- }
-+void bdrv_set_read_only(BlockDriverState *bs, bool read_only)
-+{
-+    bs->read_only = read_only;
-+}
-+
- void bdrv_get_full_backing_filename_from_filename(const char *backed,
-                                                   const char *backing,
-                                                   char *dest, size_t sz,
-diff --git a/block/bochs.c b/block/bochs.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/bochs.c
-+++ b/block/bochs.c
-@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
-         return -EINVAL;
-     }
--    bs->read_only = true; /* no write support yet */
-+    bdrv_set_read_only(bs, true); /* no write support yet */
-     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
-     if (ret < 0) {
-diff --git a/block/cloop.c b/block/cloop.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/cloop.c
-+++ b/block/cloop.c
-@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
-         return -EINVAL;
-     }
--    bs->read_only = true;
-+    bdrv_set_read_only(bs, true);
-     /* read header */
-     ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
-diff --git a/block/dmg.c b/block/dmg.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/dmg.c
-+++ b/block/dmg.c
-@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
-     }
-     block_module_load_one("dmg-bz2");
--    bs->read_only = true;
-+    bdrv_set_read_only(bs, true);
-     s->n_chunks = 0;
-     s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;
-diff --git a/block/rbd.c b/block/rbd.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/rbd.c
-+++ b/block/rbd.c
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
-         goto failed_open;
-     }
--    bs->read_only = (s->snap != NULL);
-+    bdrv_set_read_only(bs, (s->snap != NULL));
-     qemu_opts_del(opts);
-     return 0;
-diff --git a/block/vvfat.c b/block/vvfat.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/vvfat.c
-+++ b/block/vvfat.c
-@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
-     s->current_cluster=0xffffffff;
-     /* read only is the default for safety */
--    bs->read_only = true;
-+    bdrv_set_read_only(bs, true);
-     s->qcow = NULL;
-     s->qcow_filename = NULL;
-     s->fat2 = NULL;
-@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
-         if (ret < 0) {
-             goto fail;
-         }
--        bs->read_only = false;
-+        bdrv_set_read_only(bs, false);
-     }
-     bs->total_sectors = cyls * heads * secs;
-diff --git a/include/block/block.h b/include/block/block.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/block.h
-+++ b/include/block/block.h
-@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
-                             int64_t sector_num, int nb_sectors, int *pnum);
- bool bdrv_is_read_only(BlockDriverState *bs);
-+void bdrv_set_read_only(BlockDriverState *bs, bool read_only);
- bool bdrv_is_sg(BlockDriverState *bs);
- bool bdrv_is_inserted(BlockDriverState *bs);
- int bdrv_media_changed(BlockDriverState *bs);
---
-.9.3

-[Qemu-devel] [PULL 05/12] block: do not set BDS read_only if copy_on_read enabled
+[PULL 2/3] util/main-loop: Introduce the main loop into QOM
-A few block drivers will set the BDS read_only flag from their
+From: Nicolas Saenz Julienne <nsaenzju@redhat.com>
-.bdrv_open() function.  This means the bs->read_only flag could
-be set after we enable copy_on_read, as the BDRV_O_COPY_ON_READ
+'event-loop-base' provides basic property handling for all 'AioContext'
-flag check occurs prior to the call to bdrv->bdrv_open().
+based event loops. So let's define a new 'MainLoopClass' that inherits
+from it. This will permit tweaking the main loop's properties through
-This adds an error return to bdrv_set_read_only(), and an error will be
+qapi as well as through the command line using the '-object' keyword[1].
-return if we try to set the BDS to read_only while copy_on_read is
+Only one instance of 'MainLoopClass' might be created at any time.
-enabled.
+'EventLoopBaseClass' learns a new callback, 'can_be_deleted()' so as to
-This patch also changes the behavior of vvfat.  Before, vvfat could
+mark 'MainLoop' as non-deletable.
-override the drive 'readonly' flag with its own, internal 'rw' flag.
+[1] For example:
-For instance, this -drive parameter would result in a writable image:
+      -object main-loop,id=main-loop,aio-max-batch=<value>
-"-drive format=vvfat,dir=/tmp/vvfat,rw,if=virtio,readonly=on"
+Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
 This is not correct.  Now, attempting to use the above -drive parameter
 will result in an error (i.e., 'rw' is incompatible with 'readonly=on').
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+Acked-by: Markus Armbruster <armbru@redhat.com>
-Message-id: 0c5b4c1cc2c651471b131f21376dfd5ea24d2196.1491597120.git.jcody@redhat.com
+Message-id: 20220425075723.20019-3-nsaenzju@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block.c               | 10 +++++++++-
+ qapi/qom.json                    | 13 ++++++++
- block/bochs.c         |  5 ++++-
+ meson.build                      |  3 +-
- block/cloop.c         |  5 ++++-
+ include/qemu/main-loop.h         | 10 ++++++
- block/dmg.c           |  6 +++++-
+ include/sysemu/event-loop-base.h |  1 +
- block/rbd.c           | 11 ++++++++++-
+ event-loop-base.c                | 13 ++++++++
- block/vvfat.c         | 19 +++++++++++++++----
+ util/main-loop.c                 | 56 ++++++++++++++++++++++++++++++++
- include/block/block.h |  2 +-
+files changed, 95 insertions(+), 1 deletion(-)
-files changed, 48 insertions(+), 10 deletions(-)
+diff --git a/qapi/qom.json b/qapi/qom.json
-diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
-index XXXXXXX..XXXXXXX 100644
+--- a/qapi/qom.json
---- a/block.c
++++ b/qapi/qom.json
-+++ b/block.c
+@@ -XXX,XX +XXX,XX @@
-@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
+             '*poll-grow': 'int',
              '*poll-shrink': 'int' } }
 +##
 +# @MainLoopProperties:
 +#
 +# Properties for the main-loop object.
 +#
 +# Since: 7.1
 +##
 +{ 'struct': 'MainLoopProperties',
 +  'base': 'EventLoopBaseProperties',
 +  'data': {} }
 +
  ##
  # @MemoryBackendProperties:
  #
@@ -XXX,XX +XXX,XX @@
      { 'name': 'input-linux',
        'if': 'CONFIG_LINUX' },
      'iothread',
 +    'main-loop',
      { 'name': 'memory-backend-epc',
        'if': 'CONFIG_LINUX' },
      'memory-backend-file',
@@ -XXX,XX +XXX,XX @@
        'input-linux':                { 'type': 'InputLinuxProperties',
                                        'if': 'CONFIG_LINUX' },
        'iothread':                   'IothreadProperties',
 +      'main-loop':                  'MainLoopProperties',
        'memory-backend-epc':         { 'type': 'MemoryBackendEpcProperties',
                                        'if': 'CONFIG_LINUX' },
        'memory-backend-file':        'MemoryBackendFileProperties',
 diff --git a/meson.build b/meson.build
 index XXXXXXX..XXXXXXX 100644
 --- a/meson.build
 +++ b/meson.build
@@ -XXX,XX +XXX,XX @@ libqemuutil = static_library('qemuutil',
                               sources: util_ss.sources() + stub_ss.sources() + genh,
                               dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
  qemuutil = declare_dependency(link_with: libqemuutil,
 -                              sources: genh + version_res)
 +                              sources: genh + version_res,
 +                              dependencies: [event_loop_base])
  if have_system or have_user
    decodetree = generator(find_program('scripts/decodetree.py'),
 diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/qemu/main-loop.h
 +++ b/include/qemu/main-loop.h
@@ -XXX,XX +XXX,XX @@
  #define QEMU_MAIN_LOOP_H
  #include "block/aio.h"
 +#include "qom/object.h"
 +#include "sysemu/event-loop-base.h"
  #define SIG_IPI SIGUSR1
 +#define TYPE_MAIN_LOOP  "main-loop"
 +OBJECT_DECLARE_TYPE(MainLoop, MainLoopClass, MAIN_LOOP)
 +
 +struct MainLoop {
 +    EventLoopBase parent_obj;
 +};
 +typedef struct MainLoop MainLoop;
 +
  /**
   * qemu_init_main_loop: Set up the process so that it can run the main loop.
   *
 diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/event-loop-base.h
 +++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBaseClass {
      void (*init)(EventLoopBase *base, Error **errp);
      void (*update_params)(EventLoopBase *base, Error **errp);
 +    bool (*can_be_deleted)(EventLoopBase *base);
  };
  struct EventLoopBase {
 diff --git a/event-loop-base.c b/event-loop-base.c
 index XXXXXXX..XXXXXXX 100644
 --- a/event-loop-base.c
 +++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_complete(UserCreatable *uc, Error **errp)
      }
  }
--void bdrv_set_read_only(BlockDriverState *bs, bool read_only)
++static bool event_loop_base_can_be_deleted(UserCreatable *uc)
-+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
++{
 +    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
 +    EventLoopBase *backend = EVENT_LOOP_BASE(uc);
 +
 +    if (bc->can_be_deleted) {
 +        return bc->can_be_deleted(backend);
 +    }
 +
 +    return true;
 +}
 +
  static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
  {
-+    /* Do not set read_only if copy_on_read is enabled */
+     UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
-+    if (bs->copy_on_read && read_only) {
+     ucc->complete = event_loop_base_complete;
-+        error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
++    ucc->can_be_deleted = event_loop_base_can_be_deleted;
-+                   bdrv_get_device_or_node_name(bs));
-+        return -EINVAL;
+     object_class_property_add(klass, "aio-max-batch", "int",
                                event_loop_base_get_param,
 diff --git a/util/main-loop.c b/util/main-loop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/main-loop.c
 +++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/error-report.h"
  #include "qemu/queue.h"
  #include "qemu/compiler.h"
 +#include "qom/object.h"
  #ifndef _WIN32
  #include <sys/wait.h>
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
      return 0;
  }
 +static void main_loop_update_params(EventLoopBase *base, Error **errp)
 +{
 +    if (!qemu_aio_context) {
 +        error_setg(errp, "qemu aio context not ready");
 +        return;
 +    }
 +
-     bs->read_only = read_only;
++    aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
-+    return 0;
++}
- }
++
++MainLoop *mloop;
- void bdrv_get_full_backing_filename_from_filename(const char *backed,
++
-diff --git a/block/bochs.c b/block/bochs.c
++static void main_loop_init(EventLoopBase *base, Error **errp)
-index XXXXXXX..XXXXXXX 100644
++{
---- a/block/bochs.c
++    MainLoop *m = MAIN_LOOP(base);
-+++ b/block/bochs.c
++
-@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
++    if (mloop) {
-         return -EINVAL;
++        error_setg(errp, "only one main-loop instance allowed");
-     }
++        return;
 -    bdrv_set_read_only(bs, true); /* no write support yet */
 +    ret = bdrv_set_read_only(bs, true, errp); /* no write support yet */
 +    if (ret < 0) {
 +        return ret;
 +    }
++
-     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
++    main_loop_update_params(base, errp);
-     if (ret < 0) {
++
-diff --git a/block/cloop.c b/block/cloop.c
++    mloop = m;
-index XXXXXXX..XXXXXXX 100644
++    return;
---- a/block/cloop.c
++}
-+++ b/block/cloop.c
++
-@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
++static bool main_loop_can_be_deleted(EventLoopBase *base)
-         return -EINVAL;
++{
-     }
++    return false;
++}
--    bdrv_set_read_only(bs, true);
++
-+    ret = bdrv_set_read_only(bs, true, errp);
++static void main_loop_class_init(ObjectClass *oc, void *class_data)
-+    if (ret < 0) {
++{
-+        return ret;
++    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(oc);
-+    }
++
++    bc->init = main_loop_init;
-     /* read header */
++    bc->update_params = main_loop_update_params;
-     ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
++    bc->can_be_deleted = main_loop_can_be_deleted;
-diff --git a/block/dmg.c b/block/dmg.c
++}
-index XXXXXXX..XXXXXXX 100644
++
---- a/block/dmg.c
++static const TypeInfo main_loop_info = {
-+++ b/block/dmg.c
++    .name = TYPE_MAIN_LOOP,
-@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
++    .parent = TYPE_EVENT_LOOP_BASE,
-         return -EINVAL;
++    .class_init = main_loop_class_init,
-     }
++    .instance_size = sizeof(MainLoop),
++};
-+    ret = bdrv_set_read_only(bs, true, errp);
++
-+    if (ret < 0) {
++static void main_loop_register_types(void)
-+        return ret;
++{
-+    }
++    type_register_static(&main_loop_info);
-+
++}
-     block_module_load_one("dmg-bz2");
++
--    bdrv_set_read_only(bs, true);
++type_init(main_loop_register_types)
++
-     s->n_chunks = 0;
+ static int max_priority;
-     s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;
-diff --git a/block/rbd.c b/block/rbd.c
+ #ifndef _WIN32
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
          goto failed_shutdown;
      }
 +    /* rbd_open is always r/w */
      r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);
      if (r < 0) {
          error_setg_errno(errp, -r, "error reading header from %s", s->name);
          goto failed_open;
      }
 -    bdrv_set_read_only(bs, (s->snap != NULL));
 +    /* If we are using an rbd snapshot, we must be r/o, otherwise
 +     * leave as-is */
 +    if (s->snap != NULL) {
 +        r = bdrv_set_read_only(bs, true, &local_err);
 +        if (r < 0) {
 +            error_propagate(errp, local_err);
 +            goto failed_open;
 +        }
 +    }
      qemu_opts_del(opts);
      return 0;
 diff --git a/block/vvfat.c b/block/vvfat.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vvfat.c
 +++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
      s->current_cluster=0xffffffff;
 -    /* read only is the default for safety */
 -    bdrv_set_read_only(bs, true);
      s->qcow = NULL;
      s->qcow_filename = NULL;
      s->fat2 = NULL;
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
      s->sector_count = cyls * heads * secs - (s->first_sectors_number - 1);
      if (qemu_opt_get_bool(opts, "rw", false)) {
 -        ret = enable_write_target(bs, errp);
 +        if (!bdrv_is_read_only(bs)) {
 +            ret = enable_write_target(bs, errp);
 +            if (ret < 0) {
 +                goto fail;
 +            }
 +        } else {
 +            ret = -EPERM;
 +            error_setg(errp,
 +                       "Unable to set VVFAT to 'rw' when drive is read-only");
 +            goto fail;
 +        }
 +    } else  {
 +        /* read only is the default for safety */
 +        ret = bdrv_set_read_only(bs, true, &local_err);
          if (ret < 0) {
 +            error_propagate(errp, local_err);
              goto fail;
          }
 -        bdrv_set_read_only(bs, false);
      }
      bs->total_sectors = cyls * heads * secs;
 diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block.h
 +++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                              int64_t sector_num, int nb_sectors, int *pnum);
  bool bdrv_is_read_only(BlockDriverState *bs);
 -void bdrv_set_read_only(BlockDriverState *bs, bool read_only);
 +int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
  bool bdrv_is_sg(BlockDriverState *bs);
  bool bdrv_is_inserted(BlockDriverState *bs);
  int bdrv_media_changed(BlockDriverState *bs);
 --
-.9.3
+.35.1

-[Qemu-devel] [PULL 06/12] block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only
+Deleted patch
-The BDRV_O_ALLOW_RDWR flag allows / prohibits the changing of
-the BDS 'read_only' state, but there are a few places where it
-is ignored.  In the bdrv_set_read_only() helper, make sure to
-honor the flag.
-Signed-off-by: Jeff Cody <jcody@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: be2e5fb2d285cbece2b6d06bed54a6f56520d251.1491597120.git.jcody@redhat.com
----
- block.c | 7 +++++++
-file changed, 7 insertions(+)
-diff --git a/block.c b/block.c
-index XXXXXXX..XXXXXXX 100644
---- a/block.c
-+++ b/block.c
-@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
-         return -EINVAL;
-     }
-+    /* Do not clear read_only if it is prohibited */
-+    if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR)) {
-+        error_setg(errp, "Node '%s' is read only",
-+                   bdrv_get_device_or_node_name(bs));
-+        return -EPERM;
-+    }
-+
-     bs->read_only = read_only;
-     return 0;
- }
---
-.9.3

-[Qemu-devel] [PULL 07/12] block: code movement
+Deleted patch
-Move bdrv_is_read_only() up with its friends.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
-Message-id: 73b2399459760c32506f9407efb9dddb3a2789de.1491597120.git.jcody@redhat.com
----
- block.c | 10 +++++-----
-file changed, 5 insertions(+), 5 deletions(-)
-diff --git a/block.c b/block.c
-index XXXXXXX..XXXXXXX 100644
---- a/block.c
-+++ b/block.c
-@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
-     }
- }
-+bool bdrv_is_read_only(BlockDriverState *bs)
-+{
-+    return bs->read_only;
-+}
-+
- int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
- {
-     /* Do not set read_only if copy_on_read is enabled */
-@@ -XXX,XX +XXX,XX @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
-     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
- }
--bool bdrv_is_read_only(BlockDriverState *bs)
--{
--    return bs->read_only;
--}
--
- bool bdrv_is_sg(BlockDriverState *bs)
- {
-     return bs->sg;
---
-.9.3

-[Qemu-devel] [PULL 08/12] block: introduce bdrv_can_set_read_only()
+[PULL 3/3] util/event-loop-base: Introduce options to set the thread pool size
-Introduce check function for setting read_only flags.  Will return < 0 on
+From: Nicolas Saenz Julienne <nsaenzju@redhat.com>
 error, with appropriate Error value set.  Does not alter any flags.
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+The thread pool regulates itself: when idle, it kills threads until
 empty, when in demand, it creates new threads until full. This behaviour
 doesn't play well with latency sensitive workloads where the price of
 creating a new thread is too high. For example, when paired with qemu's
 '-mlock', or using safety features like SafeStack, creating a new thread
 has been measured take multiple milliseconds.
 In order to mitigate this let's introduce a new 'EventLoopBase'
 property to set the thread pool size. The threads will be created during
 the pool's initialization or upon updating the property's value, remain
 available during its lifetime regardless of demand, and destroyed upon
 freeing it. A properly characterized workload will then be able to
 configure the pool to avoid any latency spikes.
 Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+Acked-by: Markus Armbruster <armbru@redhat.com>
-Message-id: e2bba34ac3bc76a0c42adc390413f358ae0566e8.1491597120.git.jcody@redhat.com
+Message-id: 20220425075723.20019-4-nsaenzju@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block.c               | 14 +++++++++++++-
+ qapi/qom.json                    | 10 +++++-
- include/block/block.h |  1 +
+ include/block/aio.h              | 10 ++++++
-files changed, 14 insertions(+), 1 deletion(-)
+ include/block/thread-pool.h      |  3 ++
  include/sysemu/event-loop-base.h |  4 +++
  event-loop-base.c                | 23 +++++++++++++
  iothread.c                       |  3 ++
  util/aio-posix.c                 |  1 +
  util/async.c                     | 20 ++++++++++++
  util/main-loop.c                 |  9 ++++++
  util/thread-pool.c               | 55 +++++++++++++++++++++++++++++---
 files changed, 133 insertions(+), 5 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/qapi/qom.json b/qapi/qom.json
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/qapi/qom.json
-+++ b/block.c
++++ b/qapi/qom.json
-@@ -XXX,XX +XXX,XX @@ bool bdrv_is_read_only(BlockDriverState *bs)
+@@ -XXX,XX +XXX,XX @@
-     return bs->read_only;
+ #                 0 means that the engine will use its default.
- }
+ #                 (default: 0)
+ #
--int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
++# @thread-pool-min: minimum number of threads reserved in the thread pool
-+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
++#                   (default:0)
 +#
 +# @thread-pool-max: maximum number of threads the thread pool can contain
 +#                   (default:64)
 +#
  # Since: 7.1
  ##
  { 'struct': 'EventLoopBaseProperties',
 -  'data': { '*aio-max-batch': 'int' } }
 +  'data': { '*aio-max-batch': 'int',
 +            '*thread-pool-min': 'int',
 +            '*thread-pool-max': 'int' } }
  ##
  # @IothreadProperties:
 diff --git a/include/block/aio.h b/include/block/aio.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/aio.h
 +++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ struct AioContext {
      QSLIST_HEAD(, Coroutine) scheduled_coroutines;
      QEMUBH *co_schedule_bh;
 +    int thread_pool_min;
 +    int thread_pool_max;
      /* Thread pool for performing work and receiving completion callbacks.
       * Has its own locking.
       */
@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
  void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
                                  Error **errp);
 +/**
 + * aio_context_set_thread_pool_params:
 + * @ctx: the aio context
 + * @min: min number of threads to have readily available in the thread pool
 + * @min: max number of threads the thread pool can contain
 + */
 +void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
 +                                        int64_t max, Error **errp);
  #endif
 diff --git a/include/block/thread-pool.h b/include/block/thread-pool.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/thread-pool.h
 +++ b/include/block/thread-pool.h
@@ -XXX,XX +XXX,XX @@
  #include "block/block.h"
 +#define THREAD_POOL_MAX_THREADS_DEFAULT         64
 +
  typedef int ThreadPoolFunc(void *opaque);
  typedef struct ThreadPool ThreadPool;
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool,
  int coroutine_fn thread_pool_submit_co(ThreadPool *pool,
          ThreadPoolFunc *func, void *arg);
  void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg);
 +void thread_pool_update_params(ThreadPool *pool, struct AioContext *ctx);
  #endif
 diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/event-loop-base.h
 +++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBase {
      /* AioContext AIO engine parameters */
      int64_t aio_max_batch;
 +
 +    /* AioContext thread pool parameters */
 +    int64_t thread_pool_min;
 +    int64_t thread_pool_max;
  };
  #endif
 diff --git a/event-loop-base.c b/event-loop-base.c
 index XXXXXXX..XXXXXXX 100644
 --- a/event-loop-base.c
 +++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
  #include "qom/object_interfaces.h"
  #include "qapi/error.h"
 +#include "block/thread-pool.h"
  #include "sysemu/event-loop-base.h"
  typedef struct {
@@ -XXX,XX +XXX,XX @@ typedef struct {
      ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
  } EventLoopBaseParamInfo;
 +static void event_loop_base_instance_init(Object *obj)
 +{
 +    EventLoopBase *base = EVENT_LOOP_BASE(obj);
 +
 +    base->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
 +}
 +
  static EventLoopBaseParamInfo aio_max_batch_info = {
      "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
  };
 +static EventLoopBaseParamInfo thread_pool_min_info = {
 +    "thread-pool-min", offsetof(EventLoopBase, thread_pool_min),
 +};
 +static EventLoopBaseParamInfo thread_pool_max_info = {
 +    "thread-pool-max", offsetof(EventLoopBase, thread_pool_max),
 +};
  static void event_loop_base_get_param(Object *obj, Visitor *v,
          const char *name, void *opaque, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
                                event_loop_base_get_param,
                                event_loop_base_set_param,
                                NULL, &aio_max_batch_info);
 +    object_class_property_add(klass, "thread-pool-min", "int",
 +                              event_loop_base_get_param,
 +                              event_loop_base_set_param,
 +                              NULL, &thread_pool_min_info);
 +    object_class_property_add(klass, "thread-pool-max", "int",
 +                              event_loop_base_get_param,
 +                              event_loop_base_set_param,
 +                              NULL, &thread_pool_max_info);
  }
  static const TypeInfo event_loop_base_info = {
      .name = TYPE_EVENT_LOOP_BASE,
      .parent = TYPE_OBJECT,
      .instance_size = sizeof(EventLoopBase),
 +    .instance_init = event_loop_base_instance_init,
      .class_size = sizeof(EventLoopBaseClass),
      .class_init = event_loop_base_class_init,
      .abstract = true,
 diff --git a/iothread.c b/iothread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/iothread.c
 +++ b/iothread.c
@@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp)
      aio_context_set_aio_params(iothread->ctx,
                                 iothread->parent_obj.aio_max_batch,
                                 errp);
 +
 +    aio_context_set_thread_pool_params(iothread->ctx, base->thread_pool_min,
 +                                       base->thread_pool_max, errp);
  }
 diff --git a/util/aio-posix.c b/util/aio-posix.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/aio-posix.c
 +++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/osdep.h"
  #include "block/block.h"
 +#include "block/thread-pool.h"
  #include "qemu/main-loop.h"
  #include "qemu/rcu.h"
  #include "qemu/rcu_queue.h"
 diff --git a/util/async.c b/util/async.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/async.c
 +++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
      ctx->aio_max_batch = 0;
 +    ctx->thread_pool_min = 0;
 +    ctx->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
 +
      return ctx;
  fail:
      g_source_destroy(&ctx->source);
@@ -XXX,XX +XXX,XX @@ void qemu_set_current_aio_context(AioContext *ctx)
      assert(!get_my_aiocontext());
      set_my_aiocontext(ctx);
  }
 +
 +void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
 +                                        int64_t max, Error **errp)
 +{
 +
 +    if (min > max || !max || min > INT_MAX || max > INT_MAX) {
 +        error_setg(errp, "bad thread-pool-min/thread-pool-max values");
 +        return;
 +    }
 +
 +    ctx->thread_pool_min = min;
 +    ctx->thread_pool_max = max;
 +
 +    if (ctx->thread_pool) {
 +        thread_pool_update_params(ctx->thread_pool, ctx);
 +    }
 +}
 diff --git a/util/main-loop.c b/util/main-loop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/main-loop.c
 +++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@
  #include "sysemu/replay.h"
  #include "qemu/main-loop.h"
  #include "block/aio.h"
 +#include "block/thread-pool.h"
  #include "qemu/error-report.h"
  #include "qemu/queue.h"
  #include "qemu/compiler.h"
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
  static void main_loop_update_params(EventLoopBase *base, Error **errp)
  {
-     /* Do not set read_only if copy_on_read is enabled */
++    ERRP_GUARD();
-     if (bs->copy_on_read && read_only) {
++
-@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+     if (!qemu_aio_context) {
-         return -EPERM;
+         error_setg(errp, "qemu aio context not ready");
          return;
      }
-+    return 0;
+     aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
 +    if (*errp) {
 +        return;
 +    }
 +
 +    aio_context_set_thread_pool_params(qemu_aio_context, base->thread_pool_min,
 +                                       base->thread_pool_max, errp);
  }
  MainLoop *mloop;
 diff --git a/util/thread-pool.c b/util/thread-pool.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/thread-pool.c
 +++ b/util/thread-pool.c
@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
      QemuMutex lock;
      QemuCond worker_stopped;
      QemuSemaphore sem;
 -    int max_threads;
      QEMUBH *new_thread_bh;
      /* The following variables are only accessed from one AioContext. */
@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
      int new_threads;     /* backlog of threads we need to create */
      int pending_threads; /* threads created but not running yet */
      bool stopping;
 +    int min_threads;
 +    int max_threads;
  };
 +static inline bool back_to_sleep(ThreadPool *pool, int ret)
 +{
 +    /*
 +     * The semaphore timed out, we should exit the loop except when:
 +     *  - There is work to do, we raced with the signal.
 +     *  - The max threads threshold just changed, we raced with the signal.
 +     *  - The thread pool forces a minimum number of readily available threads.
 +     */
 +    if (ret == -1 && (!QTAILQ_EMPTY(&pool->request_list) ||
 +            pool->cur_threads > pool->max_threads ||
 +            pool->cur_threads <= pool->min_threads)) {
 +            return true;
 +    }
 +
 +    return false;
 +}
 +
-+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+ static void *worker_thread(void *opaque)
  {
      ThreadPool *pool = opaque;
@@ -XXX,XX +XXX,XX @@ static void *worker_thread(void *opaque)
              ret = qemu_sem_timedwait(&pool->sem, 10000);
              qemu_mutex_lock(&pool->lock);
              pool->idle_threads--;
 -        } while (ret == -1 && !QTAILQ_EMPTY(&pool->request_list));
 -        if (ret == -1 || pool->stopping) {
 +        } while (back_to_sleep(pool, ret));
 +        if (ret == -1 || pool->stopping ||
 +            pool->cur_threads > pool->max_threads) {
              break;
          }
@@ -XXX,XX +XXX,XX @@ void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg)
      thread_pool_submit_aio(pool, func, arg, NULL, NULL);
  }
 +void thread_pool_update_params(ThreadPool *pool, AioContext *ctx)
 +{
-+    int ret = 0;
++    qemu_mutex_lock(&pool->lock);
 +
-+    ret = bdrv_can_set_read_only(bs, read_only, errp);
++    pool->min_threads = ctx->thread_pool_min;
-+    if (ret < 0) {
++    pool->max_threads = ctx->thread_pool_max;
-+        return ret;
++
-+    }
++    /*
-+
++     * We either have to:
-     bs->read_only = read_only;
++     *  - Increase the number available of threads until over the min_threads
-     return 0;
++     *    threshold.
- }
++     *  - Decrease the number of available threads until under the max_threads
-diff --git a/include/block/block.h b/include/block/block.h
++     *    threshold.
-index XXXXXXX..XXXXXXX 100644
++     *  - Do nothing. The current number of threads fall in between the min and
---- a/include/block/block.h
++     *    max thresholds. We'll let the pool manage itself.
-+++ b/include/block/block.h
++     */
-@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
++    for (int i = pool->cur_threads; i < pool->min_threads; i++) {
-                             int64_t sector_num, int nb_sectors, int *pnum);
++        spawn_thread(pool);
++    }
- bool bdrv_is_read_only(BlockDriverState *bs);
++
-+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
++    for (int i = pool->cur_threads; i > pool->max_threads; i--) {
- int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
++        qemu_sem_post(&pool->sem);
- bool bdrv_is_sg(BlockDriverState *bs);
++    }
- bool bdrv_is_inserted(BlockDriverState *bs);
++
 +    qemu_mutex_unlock(&pool->lock);
 +}
 +
  static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
  {
      if (!ctx) {
@@ -XXX,XX +XXX,XX @@ static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
      qemu_mutex_init(&pool->lock);
      qemu_cond_init(&pool->worker_stopped);
      qemu_sem_init(&pool->sem, 0);
 -    pool->max_threads = 64;
      pool->new_thread_bh = aio_bh_new(ctx, spawn_thread_bh_fn, pool);
      QLIST_INIT(&pool->head);
      QTAILQ_INIT(&pool->request_list);
 +
 +    thread_pool_update_params(pool, ctx);
  }
  ThreadPool *thread_pool_new(AioContext *ctx)
 --
-.9.3
+.35.1

-[Qemu-devel] [PULL 09/12] block: use bdrv_can_set_read_only() during reopen
+Deleted patch
-Signed-off-by: Jeff Cody <jcody@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: 00aed7ffdd7be4b9ed9ce1007d50028a72b34ebe.1491597120.git.jcody@redhat.com
----
- block.c | 14 ++++++++------
-file changed, 8 insertions(+), 6 deletions(-)
-diff --git a/block.c b/block.c
-index XXXXXXX..XXXXXXX 100644
---- a/block.c
-+++ b/block.c
-@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
-     BlockDriver *drv;
-     QemuOpts *opts;
-     const char *value;
-+    bool read_only;
-     assert(reopen_state != NULL);
-     assert(reopen_state->bs->drv != NULL);
-@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
-         qdict_put(reopen_state->options, "driver", qstring_from_str(value));
-     }
--    /* if we are to stay read-only, do not allow permission change
--     * to r/w */
--    if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
--        reopen_state->flags & BDRV_O_RDWR) {
--        error_setg(errp, "Node '%s' is read only",
--                   bdrv_get_device_or_node_name(reopen_state->bs));
-+    /* If we are to stay read-only, do not allow permission change
-+     * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is
-+     * not set, or if the BDS still has copy_on_read enabled */
-+    read_only = !(reopen_state->flags & BDRV_O_RDWR);
-+    ret = bdrv_can_set_read_only(reopen_state->bs, read_only, &local_err);
-+    if (local_err) {
-+        error_propagate(errp, local_err);
-         goto error;
-     }
---
-.9.3

-[Qemu-devel] [PULL 10/12] block/rbd - update variable names to more apt names
+Deleted patch
-Update 'clientname' to be 'user', which tracks better with both
-the QAPI and rados variable naming.
-Update 'name' to be 'image_name', as it indicates the rbd image.
-Naming it 'image' would have been ideal, but we are using that for
-the rados_image_t value returned by rbd_open().
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: b7ec1fb2e1cf36f9b6911631447a5b0422590b7d.1491597120.git.jcody@redhat.com
----
- block/rbd.c | 33 +++++++++++++++++----------------
-file changed, 17 insertions(+), 16 deletions(-)
-diff --git a/block/rbd.c b/block/rbd.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/rbd.c
-+++ b/block/rbd.c
-@@ -XXX,XX +XXX,XX @@ typedef struct BDRVRBDState {
-     rados_t cluster;
-     rados_ioctx_t io_ctx;
-     rbd_image_t image;
--    char *name;
-+    char *image_name;
-     char *snap;
- } BDRVRBDState;
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
-     int64_t bytes = 0;
-     int64_t objsize;
-     int obj_order = 0;
--    const char *pool, *name, *conf, *clientname, *keypairs;
-+    const char *pool, *image_name, *conf, *user, *keypairs;
-     const char *secretid;
-     rados_t cluster;
-     rados_ioctx_t io_ctx;
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
-      */
-     pool       = qdict_get_try_str(options, "pool");
-     conf       = qdict_get_try_str(options, "conf");
--    clientname = qdict_get_try_str(options, "user");
--    name       = qdict_get_try_str(options, "image");
-+    user       = qdict_get_try_str(options, "user");
-+    image_name = qdict_get_try_str(options, "image");
-     keypairs   = qdict_get_try_str(options, "=keyvalue-pairs");
--    ret = rados_create(&cluster, clientname);
-+    ret = rados_create(&cluster, user);
-     if (ret < 0) {
-         error_setg_errno(errp, -ret, "error initializing");
-         goto exit;
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
-         goto shutdown;
-     }
--    ret = rbd_create(io_ctx, name, bytes, &obj_order);
-+    ret = rbd_create(io_ctx, image_name, bytes, &obj_order);
-     if (ret < 0) {
-         error_setg_errno(errp, -ret, "error rbd create");
-     }
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
-                          Error **errp)
- {
-     BDRVRBDState *s = bs->opaque;
--    const char *pool, *snap, *conf, *clientname, *name, *keypairs;
-+    const char *pool, *snap, *conf, *user, *image_name, *keypairs;
-     const char *secretid;
-     QemuOpts *opts;
-     Error *local_err = NULL;
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
-     pool           = qemu_opt_get(opts, "pool");
-     conf           = qemu_opt_get(opts, "conf");
-     snap           = qemu_opt_get(opts, "snapshot");
--    clientname     = qemu_opt_get(opts, "user");
--    name           = qemu_opt_get(opts, "image");
-+    user           = qemu_opt_get(opts, "user");
-+    image_name     = qemu_opt_get(opts, "image");
-     keypairs       = qemu_opt_get(opts, "=keyvalue-pairs");
--    if (!pool || !name) {
-+    if (!pool || !image_name) {
-         error_setg(errp, "Parameters 'pool' and 'image' are required");
-         r = -EINVAL;
-         goto failed_opts;
-     }
--    r = rados_create(&s->cluster, clientname);
-+    r = rados_create(&s->cluster, user);
-     if (r < 0) {
-         error_setg_errno(errp, -r, "error initializing");
-         goto failed_opts;
-     }
-     s->snap = g_strdup(snap);
--    s->name = g_strdup(name);
-+    s->image_name = g_strdup(image_name);
-     /* try default location when conf=NULL, but ignore failure */
-     r = rados_conf_read_file(s->cluster, conf);
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
-     }
-     /* rbd_open is always r/w */
--    r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);
-+    r = rbd_open(s->io_ctx, s->image_name, &s->image, s->snap);
-     if (r < 0) {
--        error_setg_errno(errp, -r, "error reading header from %s", s->name);
-+        error_setg_errno(errp, -r, "error reading header from %s",
-+                         s->image_name);
-         goto failed_open;
-     }
-@@ -XXX,XX +XXX,XX @@ failed_open:
- failed_shutdown:
-     rados_shutdown(s->cluster);
-     g_free(s->snap);
--    g_free(s->name);
-+    g_free(s->image_name);
- failed_opts:
-     qemu_opts_del(opts);
-     g_free(mon_host);
-@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_close(BlockDriverState *bs)
-     rbd_close(s->image);
-     rados_ioctx_destroy(s->io_ctx);
-     g_free(s->snap);
--    g_free(s->name);
-+    g_free(s->image_name);
-     rados_shutdown(s->cluster);
- }
---
-.9.3

-[Qemu-devel] [PULL 11/12] block/rbd: Add support for reopen()
+Deleted patch
-This adds support for reopen in rbd, for changing between r/w and r/o.
-Note, that this is only a flag change, but we will block a change from
-r/o to r/w if we are using an RBD internal snapshot.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: d4e87539167ec6527d44c97b164eabcccf96e4f3.1491597120.git.jcody@redhat.com
----
- block/rbd.c | 21 +++++++++++++++++++++
-file changed, 21 insertions(+)
-diff --git a/block/rbd.c b/block/rbd.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/rbd.c
-+++ b/block/rbd.c
-@@ -XXX,XX +XXX,XX @@ failed_opts:
-     return r;
- }
-+
-+/* Since RBD is currently always opened R/W via the API,
-+ * we just need to check if we are using a snapshot or not, in
-+ * order to determine if we will allow it to be R/W */
-+static int qemu_rbd_reopen_prepare(BDRVReopenState *state,
-+                                   BlockReopenQueue *queue, Error **errp)
-+{
-+    BDRVRBDState *s = state->bs->opaque;
-+    int ret = 0;
-+
-+    if (s->snap && state->flags & BDRV_O_RDWR) {
-+        error_setg(errp,
-+                   "Cannot change node '%s' to r/w when using RBD snapshot",
-+                   bdrv_get_device_or_node_name(state->bs));
-+        ret = -EINVAL;
-+    }
-+
-+    return ret;
-+}
-+
- static void qemu_rbd_close(BlockDriverState *bs)
- {
-     BDRVRBDState *s = bs->opaque;
-@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_rbd = {
-     .bdrv_parse_filename    = qemu_rbd_parse_filename,
-     .bdrv_file_open         = qemu_rbd_open,
-     .bdrv_close             = qemu_rbd_close,
-+    .bdrv_reopen_prepare    = qemu_rbd_reopen_prepare,
-     .bdrv_create            = qemu_rbd_create,
-     .bdrv_has_zero_init     = bdrv_has_zero_init_1,
-     .bdrv_get_info          = qemu_rbd_getinfo,
---
-.9.3

-[Qemu-devel] [PULL 12/12] qemu-iotests: _cleanup_qemu must be called on exit
+Deleted patch
-For the tests that use the common.qemu functions for running a QEMU
-process, _cleanup_qemu must be called in the exit function.
-If it is not, if the qemu process aborts, then not all of the droppings
-are cleaned up (e.g. pidfile, fifos).
-This updates those tests that did not have a cleanup in qemu-iotests.
-(I swapped spaces for tabs in test 102 as well)
-Reported-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
-Message-id: d59c2f6ad6c1da8b9b3c7f357c94a7122ccfc55a.1492544096.git.jcody@redhat.com
----
- tests/qemu-iotests/028 |  1 +
- tests/qemu-iotests/094 | 11 ++++++++---
- tests/qemu-iotests/102 |  5 +++--
- tests/qemu-iotests/109 |  1 +
- tests/qemu-iotests/117 |  1 +
- tests/qemu-iotests/130 |  1 +
- tests/qemu-iotests/140 |  1 +
- tests/qemu-iotests/141 |  1 +
- tests/qemu-iotests/143 |  1 +
- tests/qemu-iotests/156 |  1 +
-files changed, 19 insertions(+), 5 deletions(-)
-diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/028
-+++ b/tests/qemu-iotests/028
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
- _cleanup()
- {
-+    _cleanup_qemu
-     rm -f "${TEST_IMG}.copy"
-     _cleanup_test_img
- }
-diff --git a/tests/qemu-iotests/094 b/tests/qemu-iotests/094
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/094
-+++ b/tests/qemu-iotests/094
-@@ -XXX,XX +XXX,XX @@ echo "QA output created by $seq"
- here="$PWD"
- status=1    # failure is the default!
--trap "exit \$status" 0 1 2 3 15
-+_cleanup()
-+{
-+    _cleanup_qemu
-+    _cleanup_test_img
-+    rm -f "$TEST_DIR/source.$IMGFMT"
-+}
-+
-+trap "_cleanup; exit \$status" 0 1 2 3 15
- # get standard environment, filters and checks
- . ./common.rc
-@@ -XXX,XX +XXX,XX @@ _send_qemu_cmd $QEMU_HANDLE \
- wait=1 _cleanup_qemu
--_cleanup_test_img
--rm -f "$TEST_DIR/source.$IMGFMT"
- # success, all done
- echo '*** done'
-diff --git a/tests/qemu-iotests/102 b/tests/qemu-iotests/102
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/102
-+++ b/tests/qemu-iotests/102
-@@ -XXX,XX +XXX,XX @@ seq=$(basename $0)
- echo "QA output created by $seq"
- here=$PWD
--status=1    # failure is the default!
-+status=1    # failure is the default!
- _cleanup()
- {
--    _cleanup_test_img
-+    _cleanup_qemu
-+    _cleanup_test_img
- }
- trap "_cleanup; exit \$status" 0 1 2 3 15
-diff --git a/tests/qemu-iotests/109 b/tests/qemu-iotests/109
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/109
-+++ b/tests/qemu-iotests/109
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
- _cleanup()
- {
-+    _cleanup_qemu
-     rm -f $TEST_IMG.src
-     _cleanup_test_img
- }
-diff --git a/tests/qemu-iotests/117 b/tests/qemu-iotests/117
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/117
-+++ b/tests/qemu-iotests/117
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
- _cleanup()
- {
-+    _cleanup_qemu
-     _cleanup_test_img
- }
- trap "_cleanup; exit \$status" 0 1 2 3 15
-diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/130
-+++ b/tests/qemu-iotests/130
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
- _cleanup()
- {
-+    _cleanup_qemu
-     _cleanup_test_img
- }
- trap "_cleanup; exit \$status" 0 1 2 3 15
-diff --git a/tests/qemu-iotests/140 b/tests/qemu-iotests/140
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/140
-+++ b/tests/qemu-iotests/140
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
- _cleanup()
- {
-+    _cleanup_qemu
-     _cleanup_test_img
-     rm -f "$TEST_DIR/nbd"
- }
-diff --git a/tests/qemu-iotests/141 b/tests/qemu-iotests/141
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/141
-+++ b/tests/qemu-iotests/141
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
- _cleanup()
- {
-+    _cleanup_qemu
-     _cleanup_test_img
-     rm -f "$TEST_DIR/{b,m,o}.$IMGFMT"
- }
-diff --git a/tests/qemu-iotests/143 b/tests/qemu-iotests/143
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/143
-+++ b/tests/qemu-iotests/143
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
- _cleanup()
- {
-+    _cleanup_qemu
-     rm -f "$TEST_DIR/nbd"
- }
- trap "_cleanup; exit \$status" 0 1 2 3 15
-diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/156
-+++ b/tests/qemu-iotests/156
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
- _cleanup()
- {
-+    _cleanup_qemu
-     rm -f "$TEST_IMG{,.target}{,.backing,.overlay}"
- }
- trap "_cleanup; exit \$status" 0 1 2 3 15
---
-.9.3

The following changes since commit bfec359afba088aaacc7d316f43302f28c6e642a:

Merge remote-tracking branch 'remotes/armbru/tags/pull-qdev-2017-04-21' into staging (2017-04-21 11:42:03 +0100)

are available in the git repository at:

git://github.com/codyprime/qemu-kvm-jtc.git tags/block-pull-request

for you to fetch changes up to 1507631e438930bc07f776f303af127a9cdb4d41:

qemu-iotests: _cleanup_qemu must be called on exit (2017-04-21 08:32:44 -0400)

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

Block patches for 2.10

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

Ashish Mittal (2):
  block/vxhs.c: Add support for a new block device type called "vxhs"
  block/vxhs.c: Add qemu-iotests for new block device type "vxhs"

Jeff Cody (10):
  qemu-iotests: exclude vxhs from image creation via protocol
  block: add bdrv_set_read_only() helper function
  block: do not set BDS read_only if copy_on_read enabled
  block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only
  block: code movement
  block: introduce bdrv_can_set_read_only()
  block: use bdrv_can_set_read_only() during reopen
  block/rbd - update variable names to more apt names
  block/rbd: Add support for reopen()
  qemu-iotests: _cleanup_qemu must be called on exit

-- 
2.9.3

From: Ashish Mittal <ashmit602@gmail.com>

Source code for the qnio library that this code loads can be downloaded from:
https://github.com/VeritasHyperScale/libqnio.git

Sample command line using JSON syntax:
./x86_64-softmmu/qemu-system-x86_64 -name instance-00000008 -S -vnc 0.0.0.0:0
-k en-us -vga cirrus -device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x5
-msg timestamp=on
'json:{"driver":"vxhs","vdisk-id":"c3e9095a-a5ee-4dce-afeb-2a59fb387410",
"server":{"host":"172.172.17.4","port":"9999"}}'

Sample command line using URI syntax:
qemu-img convert -f raw -O raw -n
/var/lib/nova/instances/_base/0c5eacd5ebea5ed914b6a3e7b18f1ce734c386ad
vxhs://192.168.0.1:9999/c6718f6b-0401-441d-a8c3-1f0064d75ee0

Sample command line using TLS credentials (run in secure mode):
./qemu-io --object
tls-creds-x509,id=tls0,dir=/etc/pki/qemu/vxhs,endpoint=client -c 'read
-v 66000 2.5k' 'json:{"server.host": "127.0.0.1", "server.port": "9999",
"vdisk-id": "/test.raw", "driver": "vxhs", "tls-creds":"tls0"}'

Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Message-id: 1491277689-24949-2-git-send-email-Ashish.Mittal@veritas.com
---
 block/Makefile.objs  |   2 +
 block/trace-events   |  17 ++
 block/vxhs.c         | 575 +++++++++++++++++++++++++++++++++++++++++++++++++++
 configure            |  39 ++++
 qapi/block-core.json |  23 ++-
 5 files changed, 654 insertions(+), 2 deletions(-)
 create mode 100644 block/vxhs.c

diff --git a/block/Makefile.objs b/block/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/block/Makefile.objs
+++ b/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ block-obj-$(CONFIG_LIBNFS) += nfs.o
 block-obj-$(CONFIG_CURL) += curl.o
 block-obj-$(CONFIG_RBD) += rbd.o
 block-obj-$(CONFIG_GLUSTERFS) += gluster.o
+block-obj-$(CONFIG_VXHS) += vxhs.o
 block-obj-$(CONFIG_LIBSSH2) += ssh.o
 block-obj-y += accounting.o dirty-bitmap.o
 block-obj-y += write-threshold.o
@@ -XXX,XX +XXX,XX @@ rbd.o-cflags       := $(RBD_CFLAGS)
 rbd.o-libs         := $(RBD_LIBS)
 gluster.o-cflags   := $(GLUSTERFS_CFLAGS)
 gluster.o-libs     := $(GLUSTERFS_LIBS)
+vxhs.o-libs        := $(VXHS_LIBS)
 ssh.o-cflags       := $(LIBSSH2_CFLAGS)
 ssh.o-libs         := $(LIBSSH2_LIBS)
 block-obj-$(if $(CONFIG_BZIP2),m,n) += dmg-bz2.o
diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ qed_aio_write_data(void *s, void *acb, int ret, uint64_t offset, size_t len) "s
 qed_aio_write_prefill(void *s, void *acb, uint64_t start, size_t len, uint64_t offset) "s %p acb %p start %"PRIu64" len %zu offset %"PRIu64
 qed_aio_write_postfill(void *s, void *acb, uint64_t start, size_t len, uint64_t offset) "s %p acb %p start %"PRIu64" len %zu offset %"PRIu64
 qed_aio_write_main(void *s, void *acb, int ret, uint64_t offset, size_t len) "s %p acb %p ret %d offset %"PRIu64" len %zu"
+
+# block/vxhs.c
+vxhs_iio_callback(int error) "ctx is NULL: error %d"
+vxhs_iio_callback_chnfail(int err, int error) "QNIO channel failed, no i/o %d, %d"
+vxhs_iio_callback_unknwn(int opcode, int err) "unexpected opcode %d, errno %d"
+vxhs_aio_rw_invalid(int req) "Invalid I/O request iodir %d"
+vxhs_aio_rw_ioerr(char *guid, int iodir, uint64_t size, uint64_t off, void *acb, int ret, int err) "IO ERROR (vDisk %s) FOR : Read/Write = %d size = %lu offset = %lu ACB = %p. Error = %d, errno = %d"
+vxhs_get_vdisk_stat_err(char *guid, int ret, int err) "vDisk (%s) stat ioctl failed, ret = %d, errno = %d"
+vxhs_get_vdisk_stat(char *vdisk_guid, uint64_t vdisk_size) "vDisk %s stat ioctl returned size %lu"
+vxhs_complete_aio(void *acb, uint64_t ret) "aio failed acb %p ret %ld"
+vxhs_parse_uri_filename(const char *filename) "URI passed via bdrv_parse_filename %s"
+vxhs_open_vdiskid(const char *vdisk_id) "Opening vdisk-id %s"
+vxhs_open_hostinfo(char *of_vsa_addr, int port) "Adding host %s:%d to BDRVVXHSState"
+vxhs_open_iio_open(const char *host) "Failed to connect to storage agent on host %s"
+vxhs_parse_uri_hostinfo(char *host, int port) "Host: IP %s, Port %d"
+vxhs_close(char *vdisk_guid) "Closing vdisk %s"
+vxhs_get_creds(const char *cacert, const char *client_key, const char *client_cert) "cacert %s, client_key %s, client_cert %s"
diff --git a/block/vxhs.c b/block/vxhs.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/block/vxhs.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU Block driver for Veritas HyperScale (VxHS)
+ *
+ * Copyright (c) 2017 Veritas Technologies LLC.
+ *
+ * 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 <qnio/qnio_api.h>
+#include <sys/param.h>
+#include "block/block_int.h"
+#include "qapi/qmp/qerror.h"
+#include "qapi/qmp/qdict.h"
+#include "qapi/qmp/qstring.h"
+#include "trace.h"
+#include "qemu/uri.h"
+#include "qapi/error.h"
+#include "qemu/uuid.h"
+#include "crypto/tlscredsx509.h"
+
+#define VXHS_OPT_FILENAME           "filename"
+#define VXHS_OPT_VDISK_ID           "vdisk-id"
+#define VXHS_OPT_SERVER             "server"
+#define VXHS_OPT_HOST               "host"
+#define VXHS_OPT_PORT               "port"
+
+/* Only accessed under QEMU global mutex */
+static uint32_t vxhs_ref;
+
+typedef enum {
+    VDISK_AIO_READ,
+    VDISK_AIO_WRITE,
+} VDISKAIOCmd;
+
+/*
+ * HyperScale AIO callbacks structure
+ */
+typedef struct VXHSAIOCB {
+    BlockAIOCB common;
+    int err;
+} VXHSAIOCB;
+
+typedef struct VXHSvDiskHostsInfo {
+    void *dev_handle; /* Device handle */
+    char *host; /* Host name or IP */
+    int port; /* Host's port number */
+} VXHSvDiskHostsInfo;
+
+/*
+ * Structure per vDisk maintained for state
+ */
+typedef struct BDRVVXHSState {
+    VXHSvDiskHostsInfo vdisk_hostinfo; /* Per host info */
+    char *vdisk_guid;
+    char *tlscredsid; /* tlscredsid */
+} BDRVVXHSState;
+
+static void vxhs_complete_aio_bh(void *opaque)
+{
+    VXHSAIOCB *acb = opaque;
+    BlockCompletionFunc *cb = acb->common.cb;
+    void *cb_opaque = acb->common.opaque;
+    int ret = 0;
+
+    if (acb->err != 0) {
+        trace_vxhs_complete_aio(acb, acb->err);
+        ret = (-EIO);
+    }
+
+    qemu_aio_unref(acb);
+    cb(cb_opaque, ret);
+}
+
+/*
+ * Called from a libqnio thread
+ */
+static void vxhs_iio_callback(void *ctx, uint32_t opcode, uint32_t error)
+{
+    VXHSAIOCB *acb = NULL;
+
+    switch (opcode) {
+    case IRP_READ_REQUEST:
+    case IRP_WRITE_REQUEST:
+
+        /*
+         * ctx is VXHSAIOCB*
+         * ctx is NULL if error is QNIOERROR_CHANNEL_HUP
+         */
+        if (ctx) {
+            acb = ctx;
+        } else {
+            trace_vxhs_iio_callback(error);
+            goto out;
+        }
+
+        if (error) {
+            if (!acb->err) {
+                acb->err = error;
+            }
+            trace_vxhs_iio_callback(error);
+        }
+
+        aio_bh_schedule_oneshot(bdrv_get_aio_context(acb->common.bs),
+                                vxhs_complete_aio_bh, acb);
+        break;
+
+    default:
+        if (error == QNIOERROR_HUP) {
+            /*
+             * Channel failed, spontaneous notification,
+             * not in response to I/O
+             */
+            trace_vxhs_iio_callback_chnfail(error, errno);
+        } else {
+            trace_vxhs_iio_callback_unknwn(opcode, error);
+        }
+        break;
+    }
+out:
+    return;
+}
+
+static QemuOptsList runtime_opts = {
+    .name = "vxhs",
+    .head = QTAILQ_HEAD_INITIALIZER(runtime_opts.head),
+    .desc = {
+        {
+            .name = VXHS_OPT_FILENAME,
+            .type = QEMU_OPT_STRING,
+            .help = "URI to the Veritas HyperScale image",
+        },
+        {
+            .name = VXHS_OPT_VDISK_ID,
+            .type = QEMU_OPT_STRING,
+            .help = "UUID of the VxHS vdisk",
+        },
+        {
+            .name = "tls-creds",
+            .type = QEMU_OPT_STRING,
+            .help = "ID of the TLS/SSL credentials to use",
+        },
+        { /* end of list */ }
+    },
+};
+
+static QemuOptsList runtime_tcp_opts = {
+    .name = "vxhs_tcp",
+    .head = QTAILQ_HEAD_INITIALIZER(runtime_tcp_opts.head),
+    .desc = {
+        {
+            .name = VXHS_OPT_HOST,
+            .type = QEMU_OPT_STRING,
+            .help = "host address (ipv4 addresses)",
+        },
+        {
+            .name = VXHS_OPT_PORT,
+            .type = QEMU_OPT_NUMBER,
+            .help = "port number on which VxHSD is listening (default 9999)",
+            .def_value_str = "9999"
+        },
+        { /* end of list */ }
+    },
+};
+
+/*
+ * Parse incoming URI and populate *options with the host
+ * and device information
+ */
+static int vxhs_parse_uri(const char *filename, QDict *options)
+{
+    URI *uri = NULL;
+    char *port;
+    int ret = 0;
+
+    trace_vxhs_parse_uri_filename(filename);
+    uri = uri_parse(filename);
+    if (!uri || !uri->server || !uri->path) {
+        uri_free(uri);
+        return -EINVAL;
+    }
+
+    qdict_put(options, VXHS_OPT_SERVER".host", qstring_from_str(uri->server));
+
+    if (uri->port) {
+        port = g_strdup_printf("%d", uri->port);
+        qdict_put(options, VXHS_OPT_SERVER".port", qstring_from_str(port));
+        g_free(port);
+    }
+
+    qdict_put(options, "vdisk-id", qstring_from_str(uri->path));
+
+    trace_vxhs_parse_uri_hostinfo(uri->server, uri->port);
+    uri_free(uri);
+
+    return ret;
+}
+
+static void vxhs_parse_filename(const char *filename, QDict *options,
+                                Error **errp)
+{
+    if (qdict_haskey(options, "vdisk-id") || qdict_haskey(options, "server")) {
+        error_setg(errp, "vdisk-id/server and a file name may not be specified "
+                         "at the same time");
+        return;
+    }
+
+    if (strstr(filename, "://")) {
+        int ret = vxhs_parse_uri(filename, options);
+        if (ret < 0) {
+            error_setg(errp, "Invalid URI. URI should be of the form "
+                       "  vxhs://<host_ip>:<port>/<vdisk-id>");
+        }
+    }
+}
+
+static int vxhs_init_and_ref(void)
+{
+    if (vxhs_ref++ == 0) {
+        if (iio_init(QNIO_VERSION, vxhs_iio_callback)) {
+            return -ENODEV;
+        }
+    }
+    return 0;
+}
+
+static void vxhs_unref(void)
+{
+    if (--vxhs_ref == 0) {
+        iio_fini();
+    }
+}
+
+static void vxhs_get_tls_creds(const char *id, char **cacert,
+                               char **key, char **cert, Error **errp)
+{
+    Object *obj;
+    QCryptoTLSCreds *creds;
+    QCryptoTLSCredsX509 *creds_x509;
+
+    obj = object_resolve_path_component(
+        object_get_objects_root(), id);
+
+    if (!obj) {
+        error_setg(errp, "No TLS credentials with id '%s'",
+                   id);
+        return;
+    }
+
+    creds_x509 = (QCryptoTLSCredsX509 *)
+        object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS_X509);
+
+    if (!creds_x509) {
+        error_setg(errp, "Object with id '%s' is not TLS credentials",
+                   id);
+        return;
+    }
+
+    creds = &creds_x509->parent_obj;
+
+    if (creds->endpoint != QCRYPTO_TLS_CREDS_ENDPOINT_CLIENT) {
+        error_setg(errp,
+                   "Expecting TLS credentials with a client endpoint");
+        return;
+    }
+
+    /*
+     * Get the cacert, client_cert and client_key file names.
+     */
+    if (!creds->dir) {
+        error_setg(errp, "TLS object missing 'dir' property value");
+        return;
+    }
+
+    *cacert = g_strdup_printf("%s/%s", creds->dir,
+                              QCRYPTO_TLS_CREDS_X509_CA_CERT);
+    *cert = g_strdup_printf("%s/%s", creds->dir,
+                            QCRYPTO_TLS_CREDS_X509_CLIENT_CERT);
+    *key = g_strdup_printf("%s/%s", creds->dir,
+                           QCRYPTO_TLS_CREDS_X509_CLIENT_KEY);
+}
+
+static int vxhs_open(BlockDriverState *bs, QDict *options,
+                     int bdrv_flags, Error **errp)
+{
+    BDRVVXHSState *s = bs->opaque;
+    void *dev_handlep;
+    QDict *backing_options = NULL;
+    QemuOpts *opts = NULL;
+    QemuOpts *tcp_opts = NULL;
+    char *of_vsa_addr = NULL;
+    Error *local_err = NULL;
+    const char *vdisk_id_opt;
+    const char *server_host_opt;
+    int ret = 0;
+    char *cacert = NULL;
+    char *client_key = NULL;
+    char *client_cert = NULL;
+
+    ret = vxhs_init_and_ref();
+    if (ret < 0) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    /* Create opts info from runtime_opts and runtime_tcp_opts list */
+    opts = qemu_opts_create(&runtime_opts, NULL, 0, &error_abort);
+    tcp_opts = qemu_opts_create(&runtime_tcp_opts, NULL, 0, &error_abort);
+
+    qemu_opts_absorb_qdict(opts, options, &local_err);
+    if (local_err) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    /* vdisk-id is the disk UUID */
+    vdisk_id_opt = qemu_opt_get(opts, VXHS_OPT_VDISK_ID);
+    if (!vdisk_id_opt) {
+        error_setg(&local_err, QERR_MISSING_PARAMETER, VXHS_OPT_VDISK_ID);
+        ret = -EINVAL;
+        goto out;
+    }
+
+    /* vdisk-id may contain a leading '/' */
+    if (strlen(vdisk_id_opt) > UUID_FMT_LEN + 1) {
+        error_setg(&local_err, "vdisk-id cannot be more than %d characters",
+                   UUID_FMT_LEN);
+        ret = -EINVAL;
+        goto out;
+    }
+
+    s->vdisk_guid = g_strdup(vdisk_id_opt);
+    trace_vxhs_open_vdiskid(vdisk_id_opt);
+
+    /* get the 'server.' arguments */
+    qdict_extract_subqdict(options, &backing_options, VXHS_OPT_SERVER".");
+
+    qemu_opts_absorb_qdict(tcp_opts, backing_options, &local_err);
+    if (local_err != NULL) {
+        ret = -EINVAL;
+        goto out;
+    }
+
+    server_host_opt = qemu_opt_get(tcp_opts, VXHS_OPT_HOST);
+    if (!server_host_opt) {
+        error_setg(&local_err, QERR_MISSING_PARAMETER,
+                   VXHS_OPT_SERVER"."VXHS_OPT_HOST);
+        ret = -EINVAL;
+        goto out;
+    }
+
+    if (strlen(server_host_opt) > MAXHOSTNAMELEN) {
+        error_setg(&local_err, "server.host cannot be more than %d characters",
+                   MAXHOSTNAMELEN);
+        ret = -EINVAL;
+        goto out;
+    }
+
+    /* check if we got tls-creds via the --object argument */
+    s->tlscredsid = g_strdup(qemu_opt_get(opts, "tls-creds"));
+    if (s->tlscredsid) {
+        vxhs_get_tls_creds(s->tlscredsid, &cacert, &client_key,
+                           &client_cert, &local_err);
+        if (local_err != NULL) {
+            ret = -EINVAL;
+            goto out;
+        }
+        trace_vxhs_get_creds(cacert, client_key, client_cert);
+    }
+
+    s->vdisk_hostinfo.host = g_strdup(server_host_opt);
+    s->vdisk_hostinfo.port = g_ascii_strtoll(qemu_opt_get(tcp_opts,
+                                                          VXHS_OPT_PORT),
+                                                          NULL, 0);
+
+    trace_vxhs_open_hostinfo(s->vdisk_hostinfo.host,
+                             s->vdisk_hostinfo.port);
+
+    of_vsa_addr = g_strdup_printf("of://%s:%d",
+                                  s->vdisk_hostinfo.host,
+                                  s->vdisk_hostinfo.port);
+
+    /*
+     * Open qnio channel to storage agent if not opened before
+     */
+    dev_handlep = iio_open(of_vsa_addr, s->vdisk_guid, 0,
+                           cacert, client_key, client_cert);
+    if (dev_handlep == NULL) {
+        trace_vxhs_open_iio_open(of_vsa_addr);
+        ret = -ENODEV;
+        goto out;
+    }
+    s->vdisk_hostinfo.dev_handle = dev_handlep;
+
+out:
+    g_free(of_vsa_addr);
+    QDECREF(backing_options);
+    qemu_opts_del(tcp_opts);
+    qemu_opts_del(opts);
+    g_free(cacert);
+    g_free(client_key);
+    g_free(client_cert);
+
+    if (ret < 0) {
+        vxhs_unref();
+        error_propagate(errp, local_err);
+        g_free(s->vdisk_hostinfo.host);
+        g_free(s->vdisk_guid);
+        g_free(s->tlscredsid);
+        s->vdisk_guid = NULL;
+    }
+
+    return ret;
+}
+
+static const AIOCBInfo vxhs_aiocb_info = {
+    .aiocb_size = sizeof(VXHSAIOCB)
+};
+
+/*
+ * This allocates QEMU-VXHS callback for each IO
+ * and is passed to QNIO. When QNIO completes the work,
+ * it will be passed back through the callback.
+ */
+static BlockAIOCB *vxhs_aio_rw(BlockDriverState *bs, int64_t sector_num,
+                               QEMUIOVector *qiov, int nb_sectors,
+                               BlockCompletionFunc *cb, void *opaque,
+                               VDISKAIOCmd iodir)
+{
+    VXHSAIOCB *acb = NULL;
+    BDRVVXHSState *s = bs->opaque;
+    size_t size;
+    uint64_t offset;
+    int iio_flags = 0;
+    int ret = 0;
+    void *dev_handle = s->vdisk_hostinfo.dev_handle;
+
+    offset = sector_num * BDRV_SECTOR_SIZE;
+    size = nb_sectors * BDRV_SECTOR_SIZE;
+    acb = qemu_aio_get(&vxhs_aiocb_info, bs, cb, opaque);
+
+    /*
+     * Initialize VXHSAIOCB.
+     */
+    acb->err = 0;
+
+    iio_flags = IIO_FLAG_ASYNC;
+
+    switch (iodir) {
+    case VDISK_AIO_WRITE:
+            ret = iio_writev(dev_handle, acb, qiov->iov, qiov->niov,
+                             offset, (uint64_t)size, iio_flags);
+            break;
+    case VDISK_AIO_READ:
+            ret = iio_readv(dev_handle, acb, qiov->iov, qiov->niov,
+                            offset, (uint64_t)size, iio_flags);
+            break;
+    default:
+            trace_vxhs_aio_rw_invalid(iodir);
+            goto errout;
+    }
+
+    if (ret != 0) {
+        trace_vxhs_aio_rw_ioerr(s->vdisk_guid, iodir, size, offset,
+                                acb, ret, errno);
+        goto errout;
+    }
+    return &acb->common;
+
+errout:
+    qemu_aio_unref(acb);
+    return NULL;
+}
+
+static BlockAIOCB *vxhs_aio_readv(BlockDriverState *bs,
+                                   int64_t sector_num, QEMUIOVector *qiov,
+                                   int nb_sectors,
+                                   BlockCompletionFunc *cb, void *opaque)
+{
+    return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors, cb,
+                       opaque, VDISK_AIO_READ);
+}
+
+static BlockAIOCB *vxhs_aio_writev(BlockDriverState *bs,
+                                   int64_t sector_num, QEMUIOVector *qiov,
+                                   int nb_sectors,
+                                   BlockCompletionFunc *cb, void *opaque)
+{
+    return vxhs_aio_rw(bs, sector_num, qiov, nb_sectors,
+                       cb, opaque, VDISK_AIO_WRITE);
+}
+
+static void vxhs_close(BlockDriverState *bs)
+{
+    BDRVVXHSState *s = bs->opaque;
+
+    trace_vxhs_close(s->vdisk_guid);
+
+    g_free(s->vdisk_guid);
+    s->vdisk_guid = NULL;
+
+    /*
+     * Close vDisk device
+     */
+    if (s->vdisk_hostinfo.dev_handle) {
+        iio_close(s->vdisk_hostinfo.dev_handle);
+        s->vdisk_hostinfo.dev_handle = NULL;
+    }
+
+    vxhs_unref();
+
+    /*
+     * Free the dynamically allocated host string etc
+     */
+    g_free(s->vdisk_hostinfo.host);
+    g_free(s->tlscredsid);
+    s->tlscredsid = NULL;
+    s->vdisk_hostinfo.host = NULL;
+    s->vdisk_hostinfo.port = 0;
+}
+
+static int64_t vxhs_get_vdisk_stat(BDRVVXHSState *s)
+{
+    int64_t vdisk_size = -1;
+    int ret = 0;
+    void *dev_handle = s->vdisk_hostinfo.dev_handle;
+
+    ret = iio_ioctl(dev_handle, IOR_VDISK_STAT, &vdisk_size, 0);
+    if (ret < 0) {
+        trace_vxhs_get_vdisk_stat_err(s->vdisk_guid, ret, errno);
+        return -EIO;
+    }
+
+    trace_vxhs_get_vdisk_stat(s->vdisk_guid, vdisk_size);
+    return vdisk_size;
+}
+
+/*
+ * Returns the size of vDisk in bytes. This is required
+ * by QEMU block upper block layer so that it is visible
+ * to guest.
+ */
+static int64_t vxhs_getlength(BlockDriverState *bs)
+{
+    BDRVVXHSState *s = bs->opaque;
+    int64_t vdisk_size;
+
+    vdisk_size = vxhs_get_vdisk_stat(s);
+    if (vdisk_size < 0) {
+        return -EIO;
+    }
+
+    return vdisk_size;
+}
+
+static BlockDriver bdrv_vxhs = {
+    .format_name                  = "vxhs",
+    .protocol_name                = "vxhs",
+    .instance_size                = sizeof(BDRVVXHSState),
+    .bdrv_file_open               = vxhs_open,
+    .bdrv_parse_filename          = vxhs_parse_filename,
+    .bdrv_close                   = vxhs_close,
+    .bdrv_getlength               = vxhs_getlength,
+    .bdrv_aio_readv               = vxhs_aio_readv,
+    .bdrv_aio_writev              = vxhs_aio_writev,
+};
+
+static void bdrv_vxhs_init(void)
+{
+    bdrv_register(&bdrv_vxhs);
+}
+
+block_init(bdrv_vxhs_init);
diff --git a/configure b/configure
index XXXXXXX..XXXXXXX 100755
--- a/configure
+++ b/configure
@@ -XXX,XX +XXX,XX @@ numa=""
 tcmalloc="no"
 jemalloc="no"
 replication="yes"
+vxhs=""
 
 supported_cpu="no"
 supported_os="no"
@@ -XXX,XX +XXX,XX @@ for opt do
   ;;
   --enable-replication) replication="yes"
   ;;
+  --disable-vxhs) vxhs="no"
+  ;;
+  --enable-vxhs) vxhs="yes"
+  ;;
   *)
       echo "ERROR: unknown option $opt"
       echo "Try '$0 --help' for more information"
@@ -XXX,XX +XXX,XX @@ disabled with --disable-FEATURE, default is enabled if available:
   xfsctl          xfsctl support
   qom-cast-debug  cast debugging support
   tools           build qemu-io, qemu-nbd and qemu-image tools
+  vxhs            Veritas HyperScale vDisk backend support
 
 NOTE: The object files are built at the place where configure is launched
 EOF
@@ -XXX,XX +XXX,XX @@ if compile_prog "" "" ; then
 fi
 
 ##########################################
+# Veritas HyperScale block driver VxHS
+# Check if libvxhs is installed
+
+if test "$vxhs" != "no" ; then
+  cat > $TMPC <<EOF
+#include <stdint.h>
+#include <qnio/qnio_api.h>
+
+void *vxhs_callback;
+
+int main(void) {
+    iio_init(QNIO_VERSION, vxhs_callback);
+    return 0;
+}
+EOF
+  vxhs_libs="-lvxhs -lssl"
+  if compile_prog "" "$vxhs_libs" ; then
+    vxhs=yes
+  else
+    if test "$vxhs" = "yes" ; then
+      feature_not_found "vxhs block device" "Install libvxhs See github"
+    fi
+    vxhs=no
+  fi
+fi
+
+##########################################
 # End of CC checks
 # After here, no more $cc or $ld runs
 
@@ -XXX,XX +XXX,XX @@ echo "tcmalloc support  $tcmalloc"
 echo "jemalloc support  $jemalloc"
 echo "avx2 optimization $avx2_opt"
 echo "replication support $replication"
+echo "VxHS block device $vxhs"
 
 if test "$sdl_too_old" = "yes"; then
 echo "-> Your SDL version is too old - please upgrade to have SDL support"
@@ -XXX,XX +XXX,XX @@ if test "$pthread_setname_np" = "yes" ; then
   echo "CONFIG_PTHREAD_SETNAME_NP=y" >> $config_host_mak
 fi
 
+if test "$vxhs" = "yes" ; then
+  echo "CONFIG_VXHS=y" >> $config_host_mak
+  echo "VXHS_LIBS=$vxhs_libs" >> $config_host_mak
+fi
+
 if test "$tcg_interpreter" = "yes"; then
   QEMU_INCLUDES="-I\$(SRC_PATH)/tcg/tci $QEMU_INCLUDES"
 elif test "$ARCH" = "sparc64" ; then
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 @@
 #
 # Drivers that are supported in block device operations.
 #
+# @vxhs: Since 2.10
+#
 # Since: 2.9
 ##
 { 'enum': 'BlockdevDriver',
@@ -XXX,XX +XXX,XX @@
             'host_device', 'http', 'https', 'iscsi', 'luks', 'nbd', 'nfs',
             'null-aio', 'null-co', 'parallels', 'qcow', 'qcow2', 'qed',
             'quorum', 'raw', 'rbd', 'replication', 'sheepdog', 'ssh',
-            'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat' ] }
+            'vdi', 'vhdx', 'vmdk', 'vpc', 'vvfat', 'vxhs' ] }
 
 ##
 # @BlockdevOptionsFile:
@@ -XXX,XX +XXX,XX @@
   'data': { '*offset': 'int', '*size': 'int' } }
 
 ##
+# @BlockdevOptionsVxHS:
+#
+# Driver specific block device options for VxHS
+#
+# @vdisk-id:    UUID of VxHS volume
+# @server:      vxhs server IP, port
+# @tls-creds:   TLS credentials ID
+#
+# Since: 2.10
+##
+{ 'struct': 'BlockdevOptionsVxHS',
+  'data': { 'vdisk-id': 'str',
+            'server': 'InetSocketAddressBase',
+            '*tls-creds': 'str' } }
+
+##
 # @BlockdevOptions:
 #
 # Options for creating a block device.  Many options are available for all
@@ -XXX,XX +XXX,XX @@
       'vhdx':       'BlockdevOptionsGenericFormat',
       'vmdk':       'BlockdevOptionsGenericCOWFormat',
       'vpc':        'BlockdevOptionsGenericFormat',
-      'vvfat':      'BlockdevOptionsVVFAT'
+      'vvfat':      'BlockdevOptionsVVFAT',
+      'vxhs':       'BlockdevOptionsVxHS'
   } }
 
 ##
-- 
2.9.3

From: Ashish Mittal <ashmit602@gmail.com>

These changes use a vxhs test server that is a part of the following
repository:
https://github.com/VeritasHyperScale/libqnio.git

Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Jeff Cody <jcody@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Message-id: 1491277689-24949-3-git-send-email-Ashish.Mittal@veritas.com
---
 tests/qemu-iotests/common        |  6 ++++++
 tests/qemu-iotests/common.config | 13 +++++++++++++
 tests/qemu-iotests/common.filter |  1 +
 tests/qemu-iotests/common.rc     | 19 +++++++++++++++++++
 4 files changed, 39 insertions(+)

diff --git a/tests/qemu-iotests/common b/tests/qemu-iotests/common
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common
+++ b/tests/qemu-iotests/common
@@ -XXX,XX +XXX,XX @@ check options
     -ssh                test ssh
     -nfs                test nfs
     -luks               test luks
+    -vxhs               test vxhs
     -xdiff              graphical mode diff
     -nocache            use O_DIRECT on backing file
     -misalign           misalign memory allocations
@@ -XXX,XX +XXX,XX @@ testlist options
             xpand=false
             ;;
 
+        -vxhs)
+            IMGPROTO=vxhs
+            xpand=false
+            ;;
+
         -ssh)
             IMGPROTO=ssh
             xpand=false
diff --git a/tests/qemu-iotests/common.config b/tests/qemu-iotests/common.config
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.config
+++ b/tests/qemu-iotests/common.config
@@ -XXX,XX +XXX,XX @@ if [ -z "$QEMU_NBD_PROG" ]; then
     export QEMU_NBD_PROG="`set_prog_path qemu-nbd`"
 fi
 
+if [ -z "$QEMU_VXHS_PROG" ]; then
+    export QEMU_VXHS_PROG="`set_prog_path qnio_server`"
+fi
+
 _qemu_wrapper()
 {
     (
@@ -XXX,XX +XXX,XX @@ _qemu_nbd_wrapper()
     )
 }
 
+_qemu_vxhs_wrapper()
+{
+    (
+        echo $BASHPID > "${TEST_DIR}/qemu-vxhs.pid"
+        exec "$QEMU_VXHS_PROG" $QEMU_VXHS_OPTIONS "$@"
+    )
+}
+
 export QEMU=_qemu_wrapper
 export QEMU_IMG=_qemu_img_wrapper
 export QEMU_IO=_qemu_io_wrapper
 export QEMU_NBD=_qemu_nbd_wrapper
+export QEMU_VXHS=_qemu_vxhs_wrapper
 
 QEMU_IMG_EXTRA_ARGS=
 if [ "$IMGOPTSSYNTAX" = "true" ]; then
diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.filter
+++ b/tests/qemu-iotests/common.filter
@@ -XXX,XX +XXX,XX @@ _filter_img_info()
         -e "s#$TEST_DIR#TEST_DIR#g" \
         -e "s#$IMGFMT#IMGFMT#g" \
         -e 's#nbd://127.0.0.1:10810$#TEST_DIR/t.IMGFMT#g' \
+        -e 's#json.*vdisk-id.*vxhs"}}#TEST_DIR/t.IMGFMT#' \
         -e "/encrypted: yes/d" \
         -e "/cluster_size: [0-9]\\+/d" \
         -e "/table_size: [0-9]\\+/d" \
diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@ else
     elif [ "$IMGPROTO" = "nfs" ]; then
         TEST_DIR="nfs://127.0.0.1/$TEST_DIR"
         TEST_IMG=$TEST_DIR/t.$IMGFMT
+    elif [ "$IMGPROTO" = "vxhs" ]; then
+        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
+        TEST_IMG="vxhs://127.0.0.1:9999/t.$IMGFMT"
     else
         TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT
     fi
@@ -XXX,XX +XXX,XX @@ _make_test_img()
         eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT  $TEST_IMG_FILE >/dev/null &"
         sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
     fi
+
+    # Start QNIO server on image directory for vxhs protocol
+    if [ $IMGPROTO = "vxhs" ]; then
+        eval "$QEMU_VXHS -d  $TEST_DIR > /dev/null &"
+        sleep 1 # Wait for server to come up.
+    fi
 }
 
 _rm_test_img()
@@ -XXX,XX +XXX,XX @@ _cleanup_test_img()
             fi
             rm -f "$TEST_IMG_FILE"
             ;;
+        vxhs)
+            if [ -f "${TEST_DIR}/qemu-vxhs.pid" ]; then
+                local QEMU_VXHS_PID
+                read QEMU_VXHS_PID < "${TEST_DIR}/qemu-vxhs.pid"
+                kill ${QEMU_VXHS_PID} >/dev/null 2>&1
+                rm -f "${TEST_DIR}/qemu-vxhs.pid"
+            fi
+            rm -f "$TEST_IMG_FILE"
+            ;;
+
         file)
             _rm_test_img "$TEST_DIR/t.$IMGFMT"
             _rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
-- 
2.9.3

The protocol VXHS does not support image creation.  Some tests expect
to be able to create images through the protocol.  Exclude VXHS from
these tests.

diff --git a/tests/qemu-iotests/017 b/tests/qemu-iotests/017
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/017
+++ b/tests/qemu-iotests/017
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # Any format supporting backing files
 _supported_fmt qcow qcow2 vmdk qed
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
 
diff --git a/tests/qemu-iotests/020 b/tests/qemu-iotests/020
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/020
+++ b/tests/qemu-iotests/020
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # Any format supporting backing files
 _supported_fmt qcow qcow2 vmdk qed
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
diff --git a/tests/qemu-iotests/029 b/tests/qemu-iotests/029
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/029
+++ b/tests/qemu-iotests/029
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # Any format supporting intenal snapshots
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 # Internal snapshots are (currently) impossible with refcount_bits=1
 _unsupported_imgopts 'refcount_bits=1[^0-9]'
diff --git a/tests/qemu-iotests/073 b/tests/qemu-iotests/073
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/073
+++ b/tests/qemu-iotests/073
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 CLUSTER_SIZE=64k
diff --git a/tests/qemu-iotests/114 b/tests/qemu-iotests/114
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/114
+++ b/tests/qemu-iotests/114
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 
diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/130
+++ b/tests/qemu-iotests/130
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 qemu_comm_method="monitor"
diff --git a/tests/qemu-iotests/134 b/tests/qemu-iotests/134
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/134
+++ b/tests/qemu-iotests/134
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 
diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/156
+++ b/tests/qemu-iotests/156
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2 qed
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 # Create source disk
diff --git a/tests/qemu-iotests/158 b/tests/qemu-iotests/158
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/158
+++ b/tests/qemu-iotests/158
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto generic
+_unsupported_proto vxhs
 _supported_os Linux
 
 
-- 
2.9.3

We have a helper wrapper for checking for the BDS read_only flag,
add a helper wrapper to set the read_only flag as well.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 9b18972d05f5fa2ac16c014f0af98d680553048d.1491597120.git.jcody@redhat.com
---
 block.c               | 5 +++++
 block/bochs.c         | 2 +-
 block/cloop.c         | 2 +-
 block/dmg.c           | 2 +-
 block/rbd.c           | 2 +-
 block/vvfat.c         | 4 ++--
 include/block/block.h | 1 +
 7 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
     }
 }
 
+void bdrv_set_read_only(BlockDriverState *bs, bool read_only)
+{
+    bs->read_only = read_only;
+}
+
 void bdrv_get_full_backing_filename_from_filename(const char *backed,
                                                   const char *backing,
                                                   char *dest, size_t sz,
diff --git a/block/bochs.c b/block/bochs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    bs->read_only = true; /* no write support yet */
+    bdrv_set_read_only(bs, true); /* no write support yet */
 
     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
     if (ret < 0) {
diff --git a/block/cloop.c b/block/cloop.c
index XXXXXXX..XXXXXXX 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    bs->read_only = true;
+    bdrv_set_read_only(bs, true);
 
     /* read header */
     ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     block_module_load_one("dmg-bz2");
-    bs->read_only = true;
+    bdrv_set_read_only(bs, true);
 
     s->n_chunks = 0;
     s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
         goto failed_open;
     }
 
-    bs->read_only = (s->snap != NULL);
+    bdrv_set_read_only(bs, (s->snap != NULL));
 
     qemu_opts_del(opts);
     return 0;
diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
     s->current_cluster=0xffffffff;
 
     /* read only is the default for safety */
-    bs->read_only = true;
+    bdrv_set_read_only(bs, true);
     s->qcow = NULL;
     s->qcow_filename = NULL;
     s->fat2 = NULL;
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
         if (ret < 0) {
             goto fail;
         }
-        bs->read_only = false;
+        bdrv_set_read_only(bs, false);
     }
 
     bs->total_sectors = cyls * heads * secs;
diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                             int64_t sector_num, int nb_sectors, int *pnum);
 
 bool bdrv_is_read_only(BlockDriverState *bs);
+void bdrv_set_read_only(BlockDriverState *bs, bool read_only);
 bool bdrv_is_sg(BlockDriverState *bs);
 bool bdrv_is_inserted(BlockDriverState *bs);
 int bdrv_media_changed(BlockDriverState *bs);
-- 
2.9.3

A few block drivers will set the BDS read_only flag from their
.bdrv_open() function.  This means the bs->read_only flag could
be set after we enable copy_on_read, as the BDRV_O_COPY_ON_READ
flag check occurs prior to the call to bdrv->bdrv_open().

This adds an error return to bdrv_set_read_only(), and an error will be
return if we try to set the BDS to read_only while copy_on_read is
enabled.

This patch also changes the behavior of vvfat.  Before, vvfat could
override the drive 'readonly' flag with its own, internal 'rw' flag.

For instance, this -drive parameter would result in a writable image:

"-drive format=vvfat,dir=/tmp/vvfat,rw,if=virtio,readonly=on"

This is not correct.  Now, attempting to use the above -drive parameter
will result in an error (i.e., 'rw' is incompatible with 'readonly=on').

Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 0c5b4c1cc2c651471b131f21376dfd5ea24d2196.1491597120.git.jcody@redhat.com
---
 block.c               | 10 +++++++++-
 block/bochs.c         |  5 ++++-
 block/cloop.c         |  5 ++++-
 block/dmg.c           |  6 +++++-
 block/rbd.c           | 11 ++++++++++-
 block/vvfat.c         | 19 +++++++++++++++----
 include/block/block.h |  2 +-
 7 files changed, 48 insertions(+), 10 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
     }
 }
 
-void bdrv_set_read_only(BlockDriverState *bs, bool read_only)
+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
 {
+    /* Do not set read_only if copy_on_read is enabled */
+    if (bs->copy_on_read && read_only) {
+        error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
+                   bdrv_get_device_or_node_name(bs));
+        return -EINVAL;
+    }
+
     bs->read_only = read_only;
+    return 0;
 }
 
 void bdrv_get_full_backing_filename_from_filename(const char *backed,
diff --git a/block/bochs.c b/block/bochs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    bdrv_set_read_only(bs, true); /* no write support yet */
+    ret = bdrv_set_read_only(bs, true, errp); /* no write support yet */
+    if (ret < 0) {
+        return ret;
+    }
 
     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
     if (ret < 0) {
diff --git a/block/cloop.c b/block/cloop.c
index XXXXXXX..XXXXXXX 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
-    bdrv_set_read_only(bs, true);
+    ret = bdrv_set_read_only(bs, true, errp);
+    if (ret < 0) {
+        return ret;
+    }
 
     /* read header */
     ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
         return -EINVAL;
     }
 
+    ret = bdrv_set_read_only(bs, true, errp);
+    if (ret < 0) {
+        return ret;
+    }
+
     block_module_load_one("dmg-bz2");
-    bdrv_set_read_only(bs, true);
 
     s->n_chunks = 0;
     s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
         goto failed_shutdown;
     }
 
+    /* rbd_open is always r/w */
     r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);
     if (r < 0) {
         error_setg_errno(errp, -r, "error reading header from %s", s->name);
         goto failed_open;
     }
 
-    bdrv_set_read_only(bs, (s->snap != NULL));
+    /* If we are using an rbd snapshot, we must be r/o, otherwise
+     * leave as-is */
+    if (s->snap != NULL) {
+        r = bdrv_set_read_only(bs, true, &local_err);
+        if (r < 0) {
+            error_propagate(errp, local_err);
+            goto failed_open;
+        }
+    }
 
     qemu_opts_del(opts);
     return 0;
diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
 
     s->current_cluster=0xffffffff;
 
-    /* read only is the default for safety */
-    bdrv_set_read_only(bs, true);
     s->qcow = NULL;
     s->qcow_filename = NULL;
     s->fat2 = NULL;
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
     s->sector_count = cyls * heads * secs - (s->first_sectors_number - 1);
 
     if (qemu_opt_get_bool(opts, "rw", false)) {
-        ret = enable_write_target(bs, errp);
+        if (!bdrv_is_read_only(bs)) {
+            ret = enable_write_target(bs, errp);
+            if (ret < 0) {
+                goto fail;
+            }
+        } else {
+            ret = -EPERM;
+            error_setg(errp,
+                       "Unable to set VVFAT to 'rw' when drive is read-only");
+            goto fail;
+        }
+    } else  {
+        /* read only is the default for safety */
+        ret = bdrv_set_read_only(bs, true, &local_err);
         if (ret < 0) {
+            error_propagate(errp, local_err);
             goto fail;
         }
-        bdrv_set_read_only(bs, false);
     }
 
     bs->total_sectors = cyls * heads * secs;
diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                             int64_t sector_num, int nb_sectors, int *pnum);
 
 bool bdrv_is_read_only(BlockDriverState *bs);
-void bdrv_set_read_only(BlockDriverState *bs, bool read_only);
+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
 bool bdrv_is_sg(BlockDriverState *bs);
 bool bdrv_is_inserted(BlockDriverState *bs);
 int bdrv_media_changed(BlockDriverState *bs);
-- 
2.9.3

The BDRV_O_ALLOW_RDWR flag allows / prohibits the changing of
the BDS 'read_only' state, but there are a few places where it
is ignored.  In the bdrv_set_read_only() helper, make sure to
honor the flag.

Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: be2e5fb2d285cbece2b6d06bed54a6f56520d251.1491597120.git.jcody@redhat.com
---
 block.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
         return -EINVAL;
     }
 
+    /* Do not clear read_only if it is prohibited */
+    if (!read_only && !(bs->open_flags & BDRV_O_ALLOW_RDWR)) {
+        error_setg(errp, "Node '%s' is read only",
+                   bdrv_get_device_or_node_name(bs));
+        return -EPERM;
+    }
+
     bs->read_only = read_only;
     return 0;
 }
-- 
2.9.3

Move bdrv_is_read_only() up with its friends.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Message-id: 73b2399459760c32506f9407efb9dddb3a2789de.1491597120.git.jcody@redhat.com
---
 block.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
     }
 }
 
+bool bdrv_is_read_only(BlockDriverState *bs)
+{
+    return bs->read_only;
+}
+
 int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
 {
     /* Do not set read_only if copy_on_read is enabled */
@@ -XXX,XX +XXX,XX @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
 }
 
-bool bdrv_is_read_only(BlockDriverState *bs)
-{
-    return bs->read_only;
-}
-
 bool bdrv_is_sg(BlockDriverState *bs)
 {
     return bs->sg;
-- 
2.9.3

Introduce check function for setting read_only flags.  Will return < 0 on
error, with appropriate Error value set.  Does not alter any flags.

Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: e2bba34ac3bc76a0c42adc390413f358ae0566e8.1491597120.git.jcody@redhat.com
---
 block.c               | 14 +++++++++++++-
 include/block/block.h |  1 +
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ bool bdrv_is_read_only(BlockDriverState *bs)
     return bs->read_only;
 }
 
-int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
 {
     /* Do not set read_only if copy_on_read is enabled */
     if (bs->copy_on_read && read_only) {
@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
         return -EPERM;
     }
 
+    return 0;
+}
+
+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+{
+    int ret = 0;
+
+    ret = bdrv_can_set_read_only(bs, read_only, errp);
+    if (ret < 0) {
+        return ret;
+    }
+
     bs->read_only = read_only;
     return 0;
 }
diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                             int64_t sector_num, int nb_sectors, int *pnum);
 
 bool bdrv_is_read_only(BlockDriverState *bs);
+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
 int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp);
 bool bdrv_is_sg(BlockDriverState *bs);
 bool bdrv_is_inserted(BlockDriverState *bs);
-- 
2.9.3

Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 00aed7ffdd7be4b9ed9ce1007d50028a72b34ebe.1491597120.git.jcody@redhat.com
---
 block.c | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
     BlockDriver *drv;
     QemuOpts *opts;
     const char *value;
+    bool read_only;
 
     assert(reopen_state != NULL);
     assert(reopen_state->bs->drv != NULL);
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
         qdict_put(reopen_state->options, "driver", qstring_from_str(value));
     }
 
-    /* if we are to stay read-only, do not allow permission change
-     * to r/w */
-    if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
-        reopen_state->flags & BDRV_O_RDWR) {
-        error_setg(errp, "Node '%s' is read only",
-                   bdrv_get_device_or_node_name(reopen_state->bs));
+    /* If we are to stay read-only, do not allow permission change
+     * to r/w. Attempting to set to r/w may fail if either BDRV_O_ALLOW_RDWR is
+     * not set, or if the BDS still has copy_on_read enabled */
+    read_only = !(reopen_state->flags & BDRV_O_RDWR);
+    ret = bdrv_can_set_read_only(reopen_state->bs, read_only, &local_err);
+    if (local_err) {
+        error_propagate(errp, local_err);
         goto error;
     }
 
-- 
2.9.3

Update 'clientname' to be 'user', which tracks better with both
the QAPI and rados variable naming.

Update 'name' to be 'image_name', as it indicates the rbd image.
Naming it 'image' would have been ideal, but we are using that for
the rados_image_t value returned by rbd_open().

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: b7ec1fb2e1cf36f9b6911631447a5b0422590b7d.1491597120.git.jcody@redhat.com
---
 block/rbd.c | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVRBDState {
     rados_t cluster;
     rados_ioctx_t io_ctx;
     rbd_image_t image;
-    char *name;
+    char *image_name;
     char *snap;
 } BDRVRBDState;
 
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
     int64_t bytes = 0;
     int64_t objsize;
     int obj_order = 0;
-    const char *pool, *name, *conf, *clientname, *keypairs;
+    const char *pool, *image_name, *conf, *user, *keypairs;
     const char *secretid;
     rados_t cluster;
     rados_ioctx_t io_ctx;
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
      */
     pool       = qdict_get_try_str(options, "pool");
     conf       = qdict_get_try_str(options, "conf");
-    clientname = qdict_get_try_str(options, "user");
-    name       = qdict_get_try_str(options, "image");
+    user       = qdict_get_try_str(options, "user");
+    image_name = qdict_get_try_str(options, "image");
     keypairs   = qdict_get_try_str(options, "=keyvalue-pairs");
 
-    ret = rados_create(&cluster, clientname);
+    ret = rados_create(&cluster, user);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "error initializing");
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_create(const char *filename, QemuOpts *opts, Error **errp)
         goto shutdown;
     }
 
-    ret = rbd_create(io_ctx, name, bytes, &obj_order);
+    ret = rbd_create(io_ctx, image_name, bytes, &obj_order);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "error rbd create");
     }
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
                          Error **errp)
 {
     BDRVRBDState *s = bs->opaque;
-    const char *pool, *snap, *conf, *clientname, *name, *keypairs;
+    const char *pool, *snap, *conf, *user, *image_name, *keypairs;
     const char *secretid;
     QemuOpts *opts;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
     pool           = qemu_opt_get(opts, "pool");
     conf           = qemu_opt_get(opts, "conf");
     snap           = qemu_opt_get(opts, "snapshot");
-    clientname     = qemu_opt_get(opts, "user");
-    name           = qemu_opt_get(opts, "image");
+    user           = qemu_opt_get(opts, "user");
+    image_name     = qemu_opt_get(opts, "image");
     keypairs       = qemu_opt_get(opts, "=keyvalue-pairs");
 
-    if (!pool || !name) {
+    if (!pool || !image_name) {
         error_setg(errp, "Parameters 'pool' and 'image' are required");
         r = -EINVAL;
         goto failed_opts;
     }
 
-    r = rados_create(&s->cluster, clientname);
+    r = rados_create(&s->cluster, user);
     if (r < 0) {
         error_setg_errno(errp, -r, "error initializing");
         goto failed_opts;
     }
 
     s->snap = g_strdup(snap);
-    s->name = g_strdup(name);
+    s->image_name = g_strdup(image_name);
 
     /* try default location when conf=NULL, but ignore failure */
     r = rados_conf_read_file(s->cluster, conf);
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
     }
 
     /* rbd_open is always r/w */
-    r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);
+    r = rbd_open(s->io_ctx, s->image_name, &s->image, s->snap);
     if (r < 0) {
-        error_setg_errno(errp, -r, "error reading header from %s", s->name);
+        error_setg_errno(errp, -r, "error reading header from %s",
+                         s->image_name);
         goto failed_open;
     }
 
@@ -XXX,XX +XXX,XX @@ failed_open:
 failed_shutdown:
     rados_shutdown(s->cluster);
     g_free(s->snap);
-    g_free(s->name);
+    g_free(s->image_name);
 failed_opts:
     qemu_opts_del(opts);
     g_free(mon_host);
@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_close(BlockDriverState *bs)
     rbd_close(s->image);
     rados_ioctx_destroy(s->io_ctx);
     g_free(s->snap);
-    g_free(s->name);
+    g_free(s->image_name);
     rados_shutdown(s->cluster);
 }
 
-- 
2.9.3

This adds support for reopen in rbd, for changing between r/w and r/o.

Note, that this is only a flag change, but we will block a change from
r/o to r/w if we are using an RBD internal snapshot.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: d4e87539167ec6527d44c97b164eabcccf96e4f3.1491597120.git.jcody@redhat.com
---
 block/rbd.c | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ failed_opts:
     return r;
 }
 
+
+/* Since RBD is currently always opened R/W via the API,
+ * we just need to check if we are using a snapshot or not, in
+ * order to determine if we will allow it to be R/W */
+static int qemu_rbd_reopen_prepare(BDRVReopenState *state,
+                                   BlockReopenQueue *queue, Error **errp)
+{
+    BDRVRBDState *s = state->bs->opaque;
+    int ret = 0;
+
+    if (s->snap && state->flags & BDRV_O_RDWR) {
+        error_setg(errp,
+                   "Cannot change node '%s' to r/w when using RBD snapshot",
+                   bdrv_get_device_or_node_name(state->bs));
+        ret = -EINVAL;
+    }
+
+    return ret;
+}
+
 static void qemu_rbd_close(BlockDriverState *bs)
 {
     BDRVRBDState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_rbd = {
     .bdrv_parse_filename    = qemu_rbd_parse_filename,
     .bdrv_file_open         = qemu_rbd_open,
     .bdrv_close             = qemu_rbd_close,
+    .bdrv_reopen_prepare    = qemu_rbd_reopen_prepare,
     .bdrv_create            = qemu_rbd_create,
     .bdrv_has_zero_init     = bdrv_has_zero_init_1,
     .bdrv_get_info          = qemu_rbd_getinfo,
-- 
2.9.3

For the tests that use the common.qemu functions for running a QEMU
process, _cleanup_qemu must be called in the exit function.

If it is not, if the qemu process aborts, then not all of the droppings
are cleaned up (e.g. pidfile, fifos).

This updates those tests that did not have a cleanup in qemu-iotests.

(I swapped spaces for tabs in test 102 as well)

Reported-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Jeff Cody <jcody@redhat.com>
Message-id: d59c2f6ad6c1da8b9b3c7f357c94a7122ccfc55a.1492544096.git.jcody@redhat.com
---
 tests/qemu-iotests/028 |  1 +
 tests/qemu-iotests/094 | 11 ++++++++---
 tests/qemu-iotests/102 |  5 +++--
 tests/qemu-iotests/109 |  1 +
 tests/qemu-iotests/117 |  1 +
 tests/qemu-iotests/130 |  1 +
 tests/qemu-iotests/140 |  1 +
 tests/qemu-iotests/141 |  1 +
 tests/qemu-iotests/143 |  1 +
 tests/qemu-iotests/156 |  1 +
 10 files changed, 19 insertions(+), 5 deletions(-)

diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/028
+++ b/tests/qemu-iotests/028
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     rm -f "${TEST_IMG}.copy"
     _cleanup_test_img
 }
diff --git a/tests/qemu-iotests/094 b/tests/qemu-iotests/094
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/094
+++ b/tests/qemu-iotests/094
@@ -XXX,XX +XXX,XX @@ echo "QA output created by $seq"
 here="$PWD"
 status=1	# failure is the default!
 
-trap "exit \$status" 0 1 2 3 15
+_cleanup()
+{
+    _cleanup_qemu
+    _cleanup_test_img
+    rm -f "$TEST_DIR/source.$IMGFMT"
+}
+
+trap "_cleanup; exit \$status" 0 1 2 3 15
 
 # get standard environment, filters and checks
 . ./common.rc
@@ -XXX,XX +XXX,XX @@ _send_qemu_cmd $QEMU_HANDLE \
 
 wait=1 _cleanup_qemu
 
-_cleanup_test_img
-rm -f "$TEST_DIR/source.$IMGFMT"
 
 # success, all done
 echo '*** done'
diff --git a/tests/qemu-iotests/102 b/tests/qemu-iotests/102
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/102
+++ b/tests/qemu-iotests/102
@@ -XXX,XX +XXX,XX @@ seq=$(basename $0)
 echo "QA output created by $seq"
 
 here=$PWD
-status=1	# failure is the default!
+status=1    # failure is the default!
 
 _cleanup()
 {
-	_cleanup_test_img
+    _cleanup_qemu
+    _cleanup_test_img
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
 
diff --git a/tests/qemu-iotests/109 b/tests/qemu-iotests/109
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/109
+++ b/tests/qemu-iotests/109
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     rm -f $TEST_IMG.src
 	_cleanup_test_img
 }
diff --git a/tests/qemu-iotests/117 b/tests/qemu-iotests/117
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/117
+++ b/tests/qemu-iotests/117
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
 	_cleanup_test_img
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/130
+++ b/tests/qemu-iotests/130
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     _cleanup_test_img
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
diff --git a/tests/qemu-iotests/140 b/tests/qemu-iotests/140
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/140
+++ b/tests/qemu-iotests/140
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     _cleanup_test_img
     rm -f "$TEST_DIR/nbd"
 }
diff --git a/tests/qemu-iotests/141 b/tests/qemu-iotests/141
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/141
+++ b/tests/qemu-iotests/141
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     _cleanup_test_img
     rm -f "$TEST_DIR/{b,m,o}.$IMGFMT"
 }
diff --git a/tests/qemu-iotests/143 b/tests/qemu-iotests/143
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/143
+++ b/tests/qemu-iotests/143
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     rm -f "$TEST_DIR/nbd"
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/156
+++ b/tests/qemu-iotests/156
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 
 _cleanup()
 {
+    _cleanup_qemu
     rm -f "$TEST_IMG{,.target}{,.backing,.overlay}"
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
-- 
2.9.3

The following changes since commit 9cf289af47bcfae5c75de37d8e5d6fd23705322c:

Merge tag 'qga-pull-request' of gitlab.com:marcandre.lureau/qemu into staging (2022-05-04 03:42:49 -0700)

are available in the Git repository at:

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

for you to fetch changes up to bef2e050d6a7feb865854c65570c496ac5a8cf53:

util/event-loop-base: Introduce options to set the thread pool size (2022-05-04 17:02:19 +0100)

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

Add new thread-pool-min/thread-pool-max parameters to control the thread pool
used for async I/O.

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

Nicolas Saenz Julienne (3):
  Introduce event-loop-base abstract class
  util/main-loop: Introduce the main loop into QOM
  util/event-loop-base: Introduce options to set the thread pool size

-- 
2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

Introduce the 'event-loop-base' abstract class, it'll hold the
properties common to all event loops and provide the necessary hooks for
their creation and maintenance. Then have iothread inherit from it.

EventLoopBaseClass is defined as user creatable and provides a hook for
its children to attach themselves to the user creatable class 'complete'
function. It also provides an update_params() callback to propagate
property changes onto its children.

The new 'event-loop-base' class will live in the root directory. It is
built on its own using the 'link_whole' option (there are no direct
function dependencies between the class and its children, it all happens
trough 'constructor' magic). And also imposes new compilation
dependencies:

qom <- event-loop-base <- blockdev (iothread.c)

And in subsequent patches:

qom <- event-loop-base <- qemuutil (util/main-loop.c)

All this forced some amount of reordering in meson.build:

- Moved qom build definition before qemuutil. Doing it the other way
   around (i.e. moving qemuutil after qom) isn't possible as a lot of
   core libraries that live in between the two depend on it.

- Process the 'hw' subdir earlier, as it introduces files into the
   'qom' source set.

No functional changes intended.

Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20220425075723.20019-2-nsaenzju@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/qom.json                    |  22 +++++--
 meson.build                      |  23 ++++---
 include/sysemu/event-loop-base.h |  36 +++++++++++
 include/sysemu/iothread.h        |   6 +-
 event-loop-base.c                | 104 +++++++++++++++++++++++++++++++
 iothread.c                       |  65 ++++++-------------
 6 files changed, 192 insertions(+), 64 deletions(-)
 create mode 100644 include/sysemu/event-loop-base.h
 create mode 100644 event-loop-base.c

diff --git a/qapi/qom.json b/qapi/qom.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/qom.json
+++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
             '*repeat': 'bool',
             '*grab-toggle': 'GrabToggleKeys' } }
 
+##
+# @EventLoopBaseProperties:
+#
+# Common properties for event loops
+#
+# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
+#                 0 means that the engine will use its default.
+#                 (default: 0)
+#
+# Since: 7.1
+##
+{ 'struct': 'EventLoopBaseProperties',
+  'data': { '*aio-max-batch': 'int' } }
+
 ##
 # @IothreadProperties:
 #
@@ -XXX,XX +XXX,XX @@
 #               algorithm detects it is spending too long polling without
 #               encountering events. 0 selects a default behaviour (default: 0)
 #
-# @aio-max-batch: maximum number of requests in a batch for the AIO engine,
-#                 0 means that the engine will use its default
-#                 (default:0, since 6.1)
+# The @aio-max-batch option is available since 6.1.
 #
 # Since: 2.0
 ##
 { 'struct': 'IothreadProperties',
+  'base': 'EventLoopBaseProperties',
   'data': { '*poll-max-ns': 'int',
             '*poll-grow': 'int',
-            '*poll-shrink': 'int',
-            '*aio-max-batch': 'int' } }
+            '*poll-shrink': 'int' } }
 
 ##
 # @MemoryBackendProperties:
diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ subdir('qom')
 subdir('authz')
 subdir('crypto')
 subdir('ui')
+subdir('hw')
 
 
 if enable_modules
@@ -XXX,XX +XXX,XX @@ if enable_modules
   modulecommon = declare_dependency(link_whole: libmodulecommon, compile_args: '-DBUILD_DSO')
 endif
 
+qom_ss = qom_ss.apply(config_host, strict: false)
+libqom = static_library('qom', qom_ss.sources() + genh,
+                        dependencies: [qom_ss.dependencies()],
+                        name_suffix: 'fa')
+qom = declare_dependency(link_whole: libqom)
+
+event_loop_base = files('event-loop-base.c')
+event_loop_base = static_library('event-loop-base', sources: event_loop_base + genh,
+                                 build_by_default: true)
+event_loop_base = declare_dependency(link_whole: event_loop_base,
+                                     dependencies: [qom])
+
 stub_ss = stub_ss.apply(config_all, strict: false)
 
 util_ss.add_all(trace_ss)
@@ -XXX,XX +XXX,XX @@ subdir('monitor')
 subdir('net')
 subdir('replay')
 subdir('semihosting')
-subdir('hw')
 subdir('tcg')
 subdir('fpu')
 subdir('accel')
@@ -XXX,XX +XXX,XX @@ qemu_syms = custom_target('qemu.syms', output: 'qemu.syms',
                              capture: true,
                              command: [undefsym, nm, '@INPUT@'])
 
-qom_ss = qom_ss.apply(config_host, strict: false)
-libqom = static_library('qom', qom_ss.sources() + genh,
-                        dependencies: [qom_ss.dependencies()],
-                        name_suffix: 'fa')
-
-qom = declare_dependency(link_whole: libqom)
-
 authz_ss = authz_ss.apply(config_host, strict: false)
 libauthz = static_library('authz', authz_ss.sources() + genh,
                           dependencies: [authz_ss.dependencies()],
@@ -XXX,XX +XXX,XX @@ libblockdev = static_library('blockdev', blockdev_ss.sources() + genh,
                              build_by_default: false)
 
 blockdev = declare_dependency(link_whole: [libblockdev],
-                              dependencies: [block])
+                              dependencies: [block, event_loop_base])
 
 qmp_ss = qmp_ss.apply(config_host, strict: false)
 libqmp = static_library('qmp', qmp_ss.sources() + genh,
diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU event-loop backend
+ *
+ * Copyright (C) 2022 Red Hat Inc
+ *
+ * Authors:
+ *  Nicolas Saenz Julienne <nsaenzju@redhat.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.
+ */
+#ifndef QEMU_EVENT_LOOP_BASE_H
+#define QEMU_EVENT_LOOP_BASE_H
+
+#include "qom/object.h"
+#include "block/aio.h"
+#include "qemu/typedefs.h"
+
+#define TYPE_EVENT_LOOP_BASE         "event-loop-base"
+OBJECT_DECLARE_TYPE(EventLoopBase, EventLoopBaseClass,
+                    EVENT_LOOP_BASE)
+
+struct EventLoopBaseClass {
+    ObjectClass parent_class;
+
+    void (*init)(EventLoopBase *base, Error **errp);
+    void (*update_params)(EventLoopBase *base, Error **errp);
+};
+
+struct EventLoopBase {
+    Object parent;
+
+    /* AioContext AIO engine parameters */
+    int64_t aio_max_batch;
+};
+#endif
diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/iothread.h
+++ b/include/sysemu/iothread.h
@@ -XXX,XX +XXX,XX @@
 #include "block/aio.h"
 #include "qemu/thread.h"
 #include "qom/object.h"
+#include "sysemu/event-loop-base.h"
 
 #define TYPE_IOTHREAD "iothread"
 
 struct IOThread {
-    Object parent_obj;
+    EventLoopBase parent_obj;
 
     QemuThread thread;
     AioContext *ctx;
@@ -XXX,XX +XXX,XX @@ struct IOThread {
     int64_t poll_max_ns;
     int64_t poll_grow;
     int64_t poll_shrink;
-
-    /* AioContext AIO engine parameters */
-    int64_t aio_max_batch;
 };
 typedef struct IOThread IOThread;
 
diff --git a/event-loop-base.c b/event-loop-base.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * QEMU event-loop base
+ *
+ * Copyright (C) 2022 Red Hat Inc
+ *
+ * Authors:
+ *  Stefan Hajnoczi <stefanha@redhat.com>
+ *  Nicolas Saenz Julienne <nsaenzju@redhat.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 "qom/object_interfaces.h"
+#include "qapi/error.h"
+#include "sysemu/event-loop-base.h"
+
+typedef struct {
+    const char *name;
+    ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
+} EventLoopBaseParamInfo;
+
+static EventLoopBaseParamInfo aio_max_batch_info = {
+    "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
+};
+
+static void event_loop_base_get_param(Object *obj, Visitor *v,
+        const char *name, void *opaque, Error **errp)
+{
+    EventLoopBase *event_loop_base = EVENT_LOOP_BASE(obj);
+    EventLoopBaseParamInfo *info = opaque;
+    int64_t *field = (void *)event_loop_base + info->offset;
+
+    visit_type_int64(v, name, field, errp);
+}
+
+static void event_loop_base_set_param(Object *obj, Visitor *v,
+        const char *name, void *opaque, Error **errp)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(obj);
+    EventLoopBase *base = EVENT_LOOP_BASE(obj);
+    EventLoopBaseParamInfo *info = opaque;
+    int64_t *field = (void *)base + info->offset;
+    int64_t value;
+
+    if (!visit_type_int64(v, name, &value, errp)) {
+        return;
+    }
+
+    if (value < 0) {
+        error_setg(errp, "%s value must be in range [0, %" PRId64 "]",
+                   info->name, INT64_MAX);
+        return;
+    }
+
+    *field = value;
+
+    if (bc->update_params) {
+        bc->update_params(base, errp);
+    }
+
+    return;
+}
+
+static void event_loop_base_complete(UserCreatable *uc, Error **errp)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
+    EventLoopBase *base = EVENT_LOOP_BASE(uc);
+
+    if (bc->init) {
+        bc->init(base, errp);
+    }
+}
+
+static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
+{
+    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
+    ucc->complete = event_loop_base_complete;
+
+    object_class_property_add(klass, "aio-max-batch", "int",
+                              event_loop_base_get_param,
+                              event_loop_base_set_param,
+                              NULL, &aio_max_batch_info);
+}
+
+static const TypeInfo event_loop_base_info = {
+    .name = TYPE_EVENT_LOOP_BASE,
+    .parent = TYPE_OBJECT,
+    .instance_size = sizeof(EventLoopBase),
+    .class_size = sizeof(EventLoopBaseClass),
+    .class_init = event_loop_base_class_init,
+    .abstract = true,
+    .interfaces = (InterfaceInfo[]) {
+        { TYPE_USER_CREATABLE },
+        { }
+    }
+};
+
+static void register_types(void)
+{
+    type_register_static(&event_loop_base_info);
+}
+type_init(register_types);
diff --git a/iothread.c b/iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/iothread.c
+++ b/iothread.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/module.h"
 #include "block/aio.h"
 #include "block/block.h"
+#include "sysemu/event-loop-base.h"
 #include "sysemu/iothread.h"
 #include "qapi/error.h"
 #include "qapi/qapi-commands-misc.h"
@@ -XXX,XX +XXX,XX @@ static void iothread_init_gcontext(IOThread *iothread)
     iothread->main_loop = g_main_loop_new(iothread->worker_context, TRUE);
 }
 
-static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
+static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp)
 {
+    IOThread *iothread = IOTHREAD(base);
     ERRP_GUARD();
 
+    if (!iothread->ctx) {
+        return;
+    }
+
     aio_context_set_poll_params(iothread->ctx,
                                 iothread->poll_max_ns,
                                 iothread->poll_grow,
@@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(IOThread *iothread, Error **errp)
     }
 
     aio_context_set_aio_params(iothread->ctx,
-                               iothread->aio_max_batch,
+                               iothread->parent_obj.aio_max_batch,
                                errp);
 }
 
-static void iothread_complete(UserCreatable *obj, Error **errp)
+
+static void iothread_init(EventLoopBase *base, Error **errp)
 {
     Error *local_error = NULL;
-    IOThread *iothread = IOTHREAD(obj);
+    IOThread *iothread = IOTHREAD(base);
     char *thread_name;
 
     iothread->stopping = false;
@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
      */
     iothread_init_gcontext(iothread);
 
-    iothread_set_aio_context_params(iothread, &local_error);
+    iothread_set_aio_context_params(base, &local_error);
     if (local_error) {
         error_propagate(errp, local_error);
         aio_context_unref(iothread->ctx);
@@ -XXX,XX +XXX,XX @@ static void iothread_complete(UserCreatable *obj, Error **errp)
      * to inherit.
      */
     thread_name = g_strdup_printf("IO %s",
-                        object_get_canonical_path_component(OBJECT(obj)));
+                        object_get_canonical_path_component(OBJECT(base)));
     qemu_thread_create(&iothread->thread, thread_name, iothread_run,
                        iothread, QEMU_THREAD_JOINABLE);
     g_free(thread_name);
@@ -XXX,XX +XXX,XX @@ static IOThreadParamInfo poll_grow_info = {
 static IOThreadParamInfo poll_shrink_info = {
     "poll-shrink", offsetof(IOThread, poll_shrink),
 };
-static IOThreadParamInfo aio_max_batch_info = {
-    "aio-max-batch", offsetof(IOThread, aio_max_batch),
-};
 
 static void iothread_get_param(Object *obj, Visitor *v,
         const char *name, IOThreadParamInfo *info, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void iothread_set_poll_param(Object *obj, Visitor *v,
     }
 }
 
-static void iothread_get_aio_param(Object *obj, Visitor *v,
-        const char *name, void *opaque, Error **errp)
-{
-    IOThreadParamInfo *info = opaque;
-
-    iothread_get_param(obj, v, name, info, errp);
-}
-
-static void iothread_set_aio_param(Object *obj, Visitor *v,
-        const char *name, void *opaque, Error **errp)
-{
-    IOThread *iothread = IOTHREAD(obj);
-    IOThreadParamInfo *info = opaque;
-
-    if (!iothread_set_param(obj, v, name, info, errp)) {
-        return;
-    }
-
-    if (iothread->ctx) {
-        aio_context_set_aio_params(iothread->ctx,
-                                   iothread->aio_max_batch,
-                                   errp);
-    }
-}
-
 static void iothread_class_init(ObjectClass *klass, void *class_data)
 {
-    UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
-    ucc->complete = iothread_complete;
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(klass);
+
+    bc->init = iothread_init;
+    bc->update_params = iothread_set_aio_context_params;
 
     object_class_property_add(klass, "poll-max-ns", "int",
                               iothread_get_poll_param,
@@ -XXX,XX +XXX,XX @@ static void iothread_class_init(ObjectClass *klass, void *class_data)
                               iothread_get_poll_param,
                               iothread_set_poll_param,
                               NULL, &poll_shrink_info);
-    object_class_property_add(klass, "aio-max-batch", "int",
-                              iothread_get_aio_param,
-                              iothread_set_aio_param,
-                              NULL, &aio_max_batch_info);
 }
 
 static const TypeInfo iothread_info = {
     .name = TYPE_IOTHREAD,
-    .parent = TYPE_OBJECT,
+    .parent = TYPE_EVENT_LOOP_BASE,
     .class_init = iothread_class_init,
     .instance_size = sizeof(IOThread),
     .instance_init = iothread_instance_init,
     .instance_finalize = iothread_instance_finalize,
-    .interfaces = (InterfaceInfo[]) {
-        {TYPE_USER_CREATABLE},
-        {}
-    },
 };
 
 static void iothread_register_types(void)
@@ -XXX,XX +XXX,XX @@ static int query_one_iothread(Object *object, void *opaque)
     info->poll_max_ns = iothread->poll_max_ns;
     info->poll_grow = iothread->poll_grow;
     info->poll_shrink = iothread->poll_shrink;
-    info->aio_max_batch = iothread->aio_max_batch;
+    info->aio_max_batch = iothread->parent_obj.aio_max_batch;
 
     QAPI_LIST_APPEND(*tail, info);
     return 0;
-- 
2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

'event-loop-base' provides basic property handling for all 'AioContext'
based event loops. So let's define a new 'MainLoopClass' that inherits
from it. This will permit tweaking the main loop's properties through
qapi as well as through the command line using the '-object' keyword[1].
Only one instance of 'MainLoopClass' might be created at any time.

'EventLoopBaseClass' learns a new callback, 'can_be_deleted()' so as to
mark 'MainLoop' as non-deletable.

[1] For example:
      -object main-loop,id=main-loop,aio-max-batch=<value>

Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20220425075723.20019-3-nsaenzju@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/qom.json                    | 13 ++++++++
 meson.build                      |  3 +-
 include/qemu/main-loop.h         | 10 ++++++
 include/sysemu/event-loop-base.h |  1 +
 event-loop-base.c                | 13 ++++++++
 util/main-loop.c                 | 56 ++++++++++++++++++++++++++++++++
 6 files changed, 95 insertions(+), 1 deletion(-)

diff --git a/qapi/qom.json b/qapi/qom.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/qom.json
+++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
             '*poll-grow': 'int',
             '*poll-shrink': 'int' } }
 
+##
+# @MainLoopProperties:
+#
+# Properties for the main-loop object.
+#
+# Since: 7.1
+##
+{ 'struct': 'MainLoopProperties',
+  'base': 'EventLoopBaseProperties',
+  'data': {} }
+
 ##
 # @MemoryBackendProperties:
 #
@@ -XXX,XX +XXX,XX @@
     { 'name': 'input-linux',
       'if': 'CONFIG_LINUX' },
     'iothread',
+    'main-loop',
     { 'name': 'memory-backend-epc',
       'if': 'CONFIG_LINUX' },
     'memory-backend-file',
@@ -XXX,XX +XXX,XX @@
       'input-linux':                { 'type': 'InputLinuxProperties',
                                       'if': 'CONFIG_LINUX' },
       'iothread':                   'IothreadProperties',
+      'main-loop':                  'MainLoopProperties',
       'memory-backend-epc':         { 'type': 'MemoryBackendEpcProperties',
                                       'if': 'CONFIG_LINUX' },
       'memory-backend-file':        'MemoryBackendFileProperties',
diff --git a/meson.build b/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/meson.build
+++ b/meson.build
@@ -XXX,XX +XXX,XX @@ libqemuutil = static_library('qemuutil',
                              sources: util_ss.sources() + stub_ss.sources() + genh,
                              dependencies: [util_ss.dependencies(), libm, threads, glib, socket, malloc, pixman])
 qemuutil = declare_dependency(link_with: libqemuutil,
-                              sources: genh + version_res)
+                              sources: genh + version_res,
+                              dependencies: [event_loop_base])
 
 if have_system or have_user
   decodetree = generator(find_program('scripts/decodetree.py'),
diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/main-loop.h
+++ b/include/qemu/main-loop.h
@@ -XXX,XX +XXX,XX @@
 #define QEMU_MAIN_LOOP_H
 
 #include "block/aio.h"
+#include "qom/object.h"
+#include "sysemu/event-loop-base.h"
 
 #define SIG_IPI SIGUSR1
 
+#define TYPE_MAIN_LOOP  "main-loop"
+OBJECT_DECLARE_TYPE(MainLoop, MainLoopClass, MAIN_LOOP)
+
+struct MainLoop {
+    EventLoopBase parent_obj;
+};
+typedef struct MainLoop MainLoop;
+
 /**
  * qemu_init_main_loop: Set up the process so that it can run the main loop.
  *
diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/event-loop-base.h
+++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBaseClass {
 
     void (*init)(EventLoopBase *base, Error **errp);
     void (*update_params)(EventLoopBase *base, Error **errp);
+    bool (*can_be_deleted)(EventLoopBase *base);
 };
 
 struct EventLoopBase {
diff --git a/event-loop-base.c b/event-loop-base.c
index XXXXXXX..XXXXXXX 100644
--- a/event-loop-base.c
+++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_complete(UserCreatable *uc, Error **errp)
     }
 }
 
+static bool event_loop_base_can_be_deleted(UserCreatable *uc)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_GET_CLASS(uc);
+    EventLoopBase *backend = EVENT_LOOP_BASE(uc);
+
+    if (bc->can_be_deleted) {
+        return bc->can_be_deleted(backend);
+    }
+
+    return true;
+}
+
 static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
 {
     UserCreatableClass *ucc = USER_CREATABLE_CLASS(klass);
     ucc->complete = event_loop_base_complete;
+    ucc->can_be_deleted = event_loop_base_can_be_deleted;
 
     object_class_property_add(klass, "aio-max-batch", "int",
                               event_loop_base_get_param,
diff --git a/util/main-loop.c b/util/main-loop.c
index XXXXXXX..XXXXXXX 100644
--- a/util/main-loop.c
+++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/error-report.h"
 #include "qemu/queue.h"
 #include "qemu/compiler.h"
+#include "qom/object.h"
 
 #ifndef _WIN32
 #include <sys/wait.h>
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
     return 0;
 }
 
+static void main_loop_update_params(EventLoopBase *base, Error **errp)
+{
+    if (!qemu_aio_context) {
+        error_setg(errp, "qemu aio context not ready");
+        return;
+    }
+
+    aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
+}
+
+MainLoop *mloop;
+
+static void main_loop_init(EventLoopBase *base, Error **errp)
+{
+    MainLoop *m = MAIN_LOOP(base);
+
+    if (mloop) {
+        error_setg(errp, "only one main-loop instance allowed");
+        return;
+    }
+
+    main_loop_update_params(base, errp);
+
+    mloop = m;
+    return;
+}
+
+static bool main_loop_can_be_deleted(EventLoopBase *base)
+{
+    return false;
+}
+
+static void main_loop_class_init(ObjectClass *oc, void *class_data)
+{
+    EventLoopBaseClass *bc = EVENT_LOOP_BASE_CLASS(oc);
+
+    bc->init = main_loop_init;
+    bc->update_params = main_loop_update_params;
+    bc->can_be_deleted = main_loop_can_be_deleted;
+}
+
+static const TypeInfo main_loop_info = {
+    .name = TYPE_MAIN_LOOP,
+    .parent = TYPE_EVENT_LOOP_BASE,
+    .class_init = main_loop_class_init,
+    .instance_size = sizeof(MainLoop),
+};
+
+static void main_loop_register_types(void)
+{
+    type_register_static(&main_loop_info);
+}
+
+type_init(main_loop_register_types)
+
 static int max_priority;
 
 #ifndef _WIN32
-- 
2.35.1

From: Nicolas Saenz Julienne <nsaenzju@redhat.com>

The thread pool regulates itself: when idle, it kills threads until
empty, when in demand, it creates new threads until full. This behaviour
doesn't play well with latency sensitive workloads where the price of
creating a new thread is too high. For example, when paired with qemu's
'-mlock', or using safety features like SafeStack, creating a new thread
has been measured take multiple milliseconds.

In order to mitigate this let's introduce a new 'EventLoopBase'
property to set the thread pool size. The threads will be created during
the pool's initialization or upon updating the property's value, remain
available during its lifetime regardless of demand, and destroyed upon
freeing it. A properly characterized workload will then be able to
configure the pool to avoid any latency spikes.

Signed-off-by: Nicolas Saenz Julienne <nsaenzju@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Acked-by: Markus Armbruster <armbru@redhat.com>
Message-id: 20220425075723.20019-4-nsaenzju@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 qapi/qom.json                    | 10 +++++-
 include/block/aio.h              | 10 ++++++
 include/block/thread-pool.h      |  3 ++
 include/sysemu/event-loop-base.h |  4 +++
 event-loop-base.c                | 23 +++++++++++++
 iothread.c                       |  3 ++
 util/aio-posix.c                 |  1 +
 util/async.c                     | 20 ++++++++++++
 util/main-loop.c                 |  9 ++++++
 util/thread-pool.c               | 55 +++++++++++++++++++++++++++++---
 10 files changed, 133 insertions(+), 5 deletions(-)

diff --git a/qapi/qom.json b/qapi/qom.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/qom.json
+++ b/qapi/qom.json
@@ -XXX,XX +XXX,XX @@
 #                 0 means that the engine will use its default.
 #                 (default: 0)
 #
+# @thread-pool-min: minimum number of threads reserved in the thread pool
+#                   (default:0)
+#
+# @thread-pool-max: maximum number of threads the thread pool can contain
+#                   (default:64)
+#
 # Since: 7.1
 ##
 { 'struct': 'EventLoopBaseProperties',
-  'data': { '*aio-max-batch': 'int' } }
+  'data': { '*aio-max-batch': 'int',
+            '*thread-pool-min': 'int',
+            '*thread-pool-max': 'int' } }
 
 ##
 # @IothreadProperties:
diff --git a/include/block/aio.h b/include/block/aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ struct AioContext {
     QSLIST_HEAD(, Coroutine) scheduled_coroutines;
     QEMUBH *co_schedule_bh;
 
+    int thread_pool_min;
+    int thread_pool_max;
     /* Thread pool for performing work and receiving completion callbacks.
      * Has its own locking.
      */
@@ -XXX,XX +XXX,XX @@ void aio_context_set_poll_params(AioContext *ctx, int64_t max_ns,
 void aio_context_set_aio_params(AioContext *ctx, int64_t max_batch,
                                 Error **errp);
 
+/**
+ * aio_context_set_thread_pool_params:
+ * @ctx: the aio context
+ * @min: min number of threads to have readily available in the thread pool
+ * @min: max number of threads the thread pool can contain
+ */
+void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
+                                        int64_t max, Error **errp);
 #endif
diff --git a/include/block/thread-pool.h b/include/block/thread-pool.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/thread-pool.h
+++ b/include/block/thread-pool.h
@@ -XXX,XX +XXX,XX @@
 
 #include "block/block.h"
 
+#define THREAD_POOL_MAX_THREADS_DEFAULT         64
+
 typedef int ThreadPoolFunc(void *opaque);
 
 typedef struct ThreadPool ThreadPool;
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *thread_pool_submit_aio(ThreadPool *pool,
 int coroutine_fn thread_pool_submit_co(ThreadPool *pool,
         ThreadPoolFunc *func, void *arg);
 void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg);
+void thread_pool_update_params(ThreadPool *pool, struct AioContext *ctx);
 
 #endif
diff --git a/include/sysemu/event-loop-base.h b/include/sysemu/event-loop-base.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/event-loop-base.h
+++ b/include/sysemu/event-loop-base.h
@@ -XXX,XX +XXX,XX @@ struct EventLoopBase {
 
     /* AioContext AIO engine parameters */
     int64_t aio_max_batch;
+
+    /* AioContext thread pool parameters */
+    int64_t thread_pool_min;
+    int64_t thread_pool_max;
 };
 #endif
diff --git a/event-loop-base.c b/event-loop-base.c
index XXXXXXX..XXXXXXX 100644
--- a/event-loop-base.c
+++ b/event-loop-base.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/osdep.h"
 #include "qom/object_interfaces.h"
 #include "qapi/error.h"
+#include "block/thread-pool.h"
 #include "sysemu/event-loop-base.h"
 
 typedef struct {
@@ -XXX,XX +XXX,XX @@ typedef struct {
     ptrdiff_t offset; /* field's byte offset in EventLoopBase struct */
 } EventLoopBaseParamInfo;
 
+static void event_loop_base_instance_init(Object *obj)
+{
+    EventLoopBase *base = EVENT_LOOP_BASE(obj);
+
+    base->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
+}
+
 static EventLoopBaseParamInfo aio_max_batch_info = {
     "aio-max-batch", offsetof(EventLoopBase, aio_max_batch),
 };
+static EventLoopBaseParamInfo thread_pool_min_info = {
+    "thread-pool-min", offsetof(EventLoopBase, thread_pool_min),
+};
+static EventLoopBaseParamInfo thread_pool_max_info = {
+    "thread-pool-max", offsetof(EventLoopBase, thread_pool_max),
+};
 
 static void event_loop_base_get_param(Object *obj, Visitor *v,
         const char *name, void *opaque, Error **errp)
@@ -XXX,XX +XXX,XX @@ static void event_loop_base_class_init(ObjectClass *klass, void *class_data)
                               event_loop_base_get_param,
                               event_loop_base_set_param,
                               NULL, &aio_max_batch_info);
+    object_class_property_add(klass, "thread-pool-min", "int",
+                              event_loop_base_get_param,
+                              event_loop_base_set_param,
+                              NULL, &thread_pool_min_info);
+    object_class_property_add(klass, "thread-pool-max", "int",
+                              event_loop_base_get_param,
+                              event_loop_base_set_param,
+                              NULL, &thread_pool_max_info);
 }
 
 static const TypeInfo event_loop_base_info = {
     .name = TYPE_EVENT_LOOP_BASE,
     .parent = TYPE_OBJECT,
     .instance_size = sizeof(EventLoopBase),
+    .instance_init = event_loop_base_instance_init,
     .class_size = sizeof(EventLoopBaseClass),
     .class_init = event_loop_base_class_init,
     .abstract = true,
diff --git a/iothread.c b/iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/iothread.c
+++ b/iothread.c
@@ -XXX,XX +XXX,XX @@ static void iothread_set_aio_context_params(EventLoopBase *base, Error **errp)
     aio_context_set_aio_params(iothread->ctx,
                                iothread->parent_obj.aio_max_batch,
                                errp);
+
+    aio_context_set_thread_pool_params(iothread->ctx, base->thread_pool_min,
+                                       base->thread_pool_max, errp);
 }
 
 
diff --git a/util/aio-posix.c b/util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu/osdep.h"
 #include "block/block.h"
+#include "block/thread-pool.h"
 #include "qemu/main-loop.h"
 #include "qemu/rcu.h"
 #include "qemu/rcu_queue.h"
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ AioContext *aio_context_new(Error **errp)
 
     ctx->aio_max_batch = 0;
 
+    ctx->thread_pool_min = 0;
+    ctx->thread_pool_max = THREAD_POOL_MAX_THREADS_DEFAULT;
+
     return ctx;
 fail:
     g_source_destroy(&ctx->source);
@@ -XXX,XX +XXX,XX @@ void qemu_set_current_aio_context(AioContext *ctx)
     assert(!get_my_aiocontext());
     set_my_aiocontext(ctx);
 }
+
+void aio_context_set_thread_pool_params(AioContext *ctx, int64_t min,
+                                        int64_t max, Error **errp)
+{
+
+    if (min > max || !max || min > INT_MAX || max > INT_MAX) {
+        error_setg(errp, "bad thread-pool-min/thread-pool-max values");
+        return;
+    }
+
+    ctx->thread_pool_min = min;
+    ctx->thread_pool_max = max;
+
+    if (ctx->thread_pool) {
+        thread_pool_update_params(ctx->thread_pool, ctx);
+    }
+}
diff --git a/util/main-loop.c b/util/main-loop.c
index XXXXXXX..XXXXXXX 100644
--- a/util/main-loop.c
+++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/replay.h"
 #include "qemu/main-loop.h"
 #include "block/aio.h"
+#include "block/thread-pool.h"
 #include "qemu/error-report.h"
 #include "qemu/queue.h"
 #include "qemu/compiler.h"
@@ -XXX,XX +XXX,XX @@ int qemu_init_main_loop(Error **errp)
 
 static void main_loop_update_params(EventLoopBase *base, Error **errp)
 {
+    ERRP_GUARD();
+
     if (!qemu_aio_context) {
         error_setg(errp, "qemu aio context not ready");
         return;
     }
 
     aio_context_set_aio_params(qemu_aio_context, base->aio_max_batch, errp);
+    if (*errp) {
+        return;
+    }
+
+    aio_context_set_thread_pool_params(qemu_aio_context, base->thread_pool_min,
+                                       base->thread_pool_max, errp);
 }
 
 MainLoop *mloop;
diff --git a/util/thread-pool.c b/util/thread-pool.c
index XXXXXXX..XXXXXXX 100644
--- a/util/thread-pool.c
+++ b/util/thread-pool.c
@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
     QemuMutex lock;
     QemuCond worker_stopped;
     QemuSemaphore sem;
-    int max_threads;
     QEMUBH *new_thread_bh;
 
     /* The following variables are only accessed from one AioContext. */
@@ -XXX,XX +XXX,XX @@ struct ThreadPool {
     int new_threads;     /* backlog of threads we need to create */
     int pending_threads; /* threads created but not running yet */
     bool stopping;
+    int min_threads;
+    int max_threads;
 };
 
+static inline bool back_to_sleep(ThreadPool *pool, int ret)
+{
+    /*
+     * The semaphore timed out, we should exit the loop except when:
+     *  - There is work to do, we raced with the signal.
+     *  - The max threads threshold just changed, we raced with the signal.
+     *  - The thread pool forces a minimum number of readily available threads.
+     */
+    if (ret == -1 && (!QTAILQ_EMPTY(&pool->request_list) ||
+            pool->cur_threads > pool->max_threads ||
+            pool->cur_threads <= pool->min_threads)) {
+            return true;
+    }
+
+    return false;
+}
+
 static void *worker_thread(void *opaque)
 {
     ThreadPool *pool = opaque;
@@ -XXX,XX +XXX,XX @@ static void *worker_thread(void *opaque)
             ret = qemu_sem_timedwait(&pool->sem, 10000);
             qemu_mutex_lock(&pool->lock);
             pool->idle_threads--;
-        } while (ret == -1 && !QTAILQ_EMPTY(&pool->request_list));
-        if (ret == -1 || pool->stopping) {
+        } while (back_to_sleep(pool, ret));
+        if (ret == -1 || pool->stopping ||
+            pool->cur_threads > pool->max_threads) {
             break;
         }
 
@@ -XXX,XX +XXX,XX @@ void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg)
     thread_pool_submit_aio(pool, func, arg, NULL, NULL);
 }
 
+void thread_pool_update_params(ThreadPool *pool, AioContext *ctx)
+{
+    qemu_mutex_lock(&pool->lock);
+
+    pool->min_threads = ctx->thread_pool_min;
+    pool->max_threads = ctx->thread_pool_max;
+
+    /*
+     * We either have to:
+     *  - Increase the number available of threads until over the min_threads
+     *    threshold.
+     *  - Decrease the number of available threads until under the max_threads
+     *    threshold.
+     *  - Do nothing. The current number of threads fall in between the min and
+     *    max thresholds. We'll let the pool manage itself.
+     */
+    for (int i = pool->cur_threads; i < pool->min_threads; i++) {
+        spawn_thread(pool);
+    }
+
+    for (int i = pool->cur_threads; i > pool->max_threads; i--) {
+        qemu_sem_post(&pool->sem);
+    }
+
+    qemu_mutex_unlock(&pool->lock);
+}
+
 static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
 {
     if (!ctx) {
@@ -XXX,XX +XXX,XX @@ static void thread_pool_init_one(ThreadPool *pool, AioContext *ctx)
     qemu_mutex_init(&pool->lock);
     qemu_cond_init(&pool->worker_stopped);
     qemu_sem_init(&pool->sem, 0);
-    pool->max_threads = 64;
     pool->new_thread_bh = aio_bh_new(ctx, spawn_thread_bh_fn, pool);
 
     QLIST_INIT(&pool->head);
     QTAILQ_INIT(&pool->request_list);
+
+    thread_pool_update_params(pool, ctx);
 }
 
 ThreadPool *thread_pool_new(AioContext *ctx)
-- 
2.35.1