Series comparison

-[Qemu-devel] [PULL 0/7] Block patches
+[Qemu-devel] [PULL v2 00/12] Block patches
-The following changes since commit 0ab4537f08e09b13788db67efd760592fb7db769:
+The following changes since commit 4c55b1d0bad8a703f0499fe62e3761a0cd288da3:
-  Merge remote-tracking branch 'remotes/stefanberger/tags/pull-tpm-2018-03-07-1' into staging (2018-03-08 12:56:39 +0000)
+  Merge remote-tracking branch 'remotes/armbru/tags/pull-error-2017-04-24' into staging (2017-04-24 14:49:48 +0100)
-are available in the Git repository at:
+are available in the git repository at:
-  git://github.com/stefanha/qemu.git tags/block-pull-request
+  git://github.com/codyprime/qemu-kvm-jtc.git tags/block-pull-request
-for you to fetch changes up to 4486e89c219c0d1b9bd8dfa0b1dd5b0d51ff2268:
+for you to fetch changes up to ecfa185400ade2abc9915efa924cbad1e15a21a4:
-  vl: introduce vm_shutdown() (2018-03-08 17:38:51 +0000)
+  qemu-iotests: _cleanup_qemu must be called on exit (2017-04-24 15:09:33 -0400)
 ----------------------------------------------------------------
+Pull v2, with 32-bit errors fixed.  I don't have OS X to test compile on,
 but I think it is safe to assume the cause of the compile error was the same.
 ----------------------------------------------------------------
-Deepa Srinivasan (1):
+Ashish Mittal (2):
-  block: Fix qemu crash when using scsi-block
+  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"
-Fam Zheng (1):
+Jeff Cody (10):
-  README: Fix typo 'git-publish'
+  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
-Sergio Lopez (1):
+ block.c                          |  56 +++-
-  virtio-blk: dataplane: Don't batch notifications if EVENT_IDX is
+ block/Makefile.objs              |   2 +
-    present
+ block/bochs.c                    |   5 +-
+ block/cloop.c                    |   5 +-
-Stefan Hajnoczi (4):
+ block/dmg.c                      |   6 +-
-  block: add aio_wait_bh_oneshot()
+ block/rbd.c                      |  65 +++--
-  virtio-blk: fix race between .ioeventfd_stop() and vq handler
+ block/trace-events               |  17 ++
-  virtio-scsi: fix race between .ioeventfd_stop() and vq handler
+ block/vvfat.c                    |  19 +-
-  vl: introduce vm_shutdown()
+ block/vxhs.c                     | 575 +++++++++++++++++++++++++++++++++++++++
+ configure                        |  39 +++
- include/block/aio-wait.h        | 13 +++++++++++
+ include/block/block.h            |   2 +
- include/sysemu/iothread.h       |  1 -
+ qapi/block-core.json             |  23 +-
- include/sysemu/sysemu.h         |  1 +
+ tests/qemu-iotests/017           |   1 +
- block/block-backend.c           | 51 ++++++++++++++++++++---------------------
+ tests/qemu-iotests/020           |   1 +
- cpus.c                          | 16 ++++++++++---
+ tests/qemu-iotests/028           |   1 +
- hw/block/dataplane/virtio-blk.c | 39 +++++++++++++++++++++++--------
+ tests/qemu-iotests/029           |   1 +
- hw/scsi/virtio-scsi-dataplane.c |  9 ++++----
+ tests/qemu-iotests/073           |   1 +
- iothread.c                      | 31 -------------------------
+ tests/qemu-iotests/094           |  11 +-
- util/aio-wait.c                 | 31 +++++++++++++++++++++++++
+ tests/qemu-iotests/102           |   5 +-
- vl.c                            | 13 +++--------
+ tests/qemu-iotests/109           |   1 +
- README                          |  2 +-
+ tests/qemu-iotests/114           |   1 +
-files changed, 122 insertions(+), 85 deletions(-)
+ 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
 --
-.14.3
+.9.3

-New patch
+[Qemu-devel] [PULL v2 01/12] block/vxhs.c: Add support for a new block device type called "vxhs"
+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"}'
+[Jeff: Modified trace-events with the correct string formatting]
+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 ++-
+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 = %"PRIu64" offset = %"PRIu64" 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 %"PRIu64
++vxhs_complete_aio(void *acb, uint64_t ret) "aio failed acb %p ret %"PRIu64
++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'
+   } }
+ ##
+--
+.9.3

-[Qemu-devel] [PULL 1/7] block: Fix qemu crash when using scsi-block
+[Qemu-devel] [PULL v2 02/12] block/vxhs.c: Add qemu-iotests for new block device type "vxhs"
-From: Deepa Srinivasan <deepa.srinivasan@oracle.com>
+From: Ashish Mittal <ashmit602@gmail.com>
-Starting qemu with the following arguments causes qemu to segfault:
+These changes use a vxhs test server that is a part of the following
-... -device lsi,id=lsi0 -drive file=iscsi:<...>,format=raw,if=none,node-name=
+repository:
-iscsi1 -device scsi-block,bus=lsi0.0,id=<...>,drive=iscsi1
+https://github.com/VeritasHyperScale/libqnio.git
-This patch fixes blk_aio_ioctl() so it does not pass stack addresses to
+Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
-blk_aio_ioctl_entry() which may be invoked after blk_aio_ioctl() returns. More
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-details about the bug follow.
+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(+)
-blk_aio_ioctl() invokes blk_aio_prwv() with blk_aio_ioctl_entry as the
+diff --git a/tests/qemu-iotests/common b/tests/qemu-iotests/common
 coroutine parameter. blk_aio_prwv() ultimately calls aio_co_enter().
 When blk_aio_ioctl() is executed from within a coroutine context (e.g.
 iscsi_bh_cb()), aio_co_enter() adds the coroutine (blk_aio_ioctl_entry) to
 the current coroutine's wakeup queue. blk_aio_ioctl() then returns.
 When blk_aio_ioctl_entry() executes later, it accesses an invalid pointer:
 ....
     BlkRwCo *rwco = &acb->rwco;
     rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset,
                              rwco->qiov->iov[0].iov_base);  <--- qiov is
                                                                  invalid here
 ...
 In the case when blk_aio_ioctl() is called from a non-coroutine context,
 blk_aio_ioctl_entry() executes immediately. But if bdrv_co_ioctl() calls
 qemu_coroutine_yield(), blk_aio_ioctl() will return. When the coroutine
 execution is complete, control returns to blk_aio_ioctl_entry() after the call
 to blk_co_ioctl(). There is no invalid reference after this point, but the
 function is still holding on to invalid pointers.
 The fix is to change blk_aio_prwv() to accept a void pointer for the IO buffer
 rather than a QEMUIOVector. blk_aio_prwv() passes this through in BlkRwCo and the
 coroutine function casts it to QEMUIOVector or uses the void pointer directly.
 Signed-off-by: Deepa Srinivasan <deepa.srinivasan@oracle.com>
 Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
 Reviewed-by: Mark Kanda <mark.kanda@oracle.com>
 Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  block/block-backend.c | 51 +++++++++++++++++++++++++--------------------------
 file changed, 25 insertions(+), 26 deletions(-)
 diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/block-backend.c
+--- a/tests/qemu-iotests/common
-+++ b/block/block-backend.c
++++ b/tests/qemu-iotests/common
-@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
+@@ -XXX,XX +XXX,XX @@ check options
- typedef struct BlkRwCo {
+     -ssh                test ssh
-     BlockBackend *blk;
+     -nfs                test nfs
-     int64_t offset;
+     -luks               test luks
--    QEMUIOVector *qiov;
++    -vxhs               test vxhs
-+    void *iobuf;
+     -xdiff              graphical mode diff
-     int ret;
+     -nocache            use O_DIRECT on backing file
-     BdrvRequestFlags flags;
+     -misalign           misalign memory allocations
- } BlkRwCo;
+@@ -XXX,XX +XXX,XX @@ testlist options
-@@ -XXX,XX +XXX,XX @@ typedef struct BlkRwCo {
+             xpand=false
- static void blk_read_entry(void *opaque)
+             ;;
 +        -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()
  {
-     BlkRwCo *rwco = opaque;
+     (
-+    QEMUIOVector *qiov = rwco->iobuf;
+@@ -XXX,XX +XXX,XX @@ _qemu_nbd_wrapper()
+     )
 -    rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, rwco->qiov->size,
 -                              rwco->qiov, rwco->flags);
 +    rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, qiov->size,
 +                              qiov, rwco->flags);
  }
- static void blk_write_entry(void *opaque)
++_qemu_vxhs_wrapper()
- {
++{
-     BlkRwCo *rwco = opaque;
++    (
-+    QEMUIOVector *qiov = rwco->iobuf;
++        echo $BASHPID > "${TEST_DIR}/qemu-vxhs.pid"
++        exec "$QEMU_VXHS_PROG" $QEMU_VXHS_OPTIONS "$@"
--    rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, rwco->qiov->size,
++    )
--                               rwco->qiov, rwco->flags);
++}
-+    rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, qiov->size,
++
-+                               qiov, rwco->flags);
+ 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
  }
- static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
+ _rm_test_img()
-@@ -XXX,XX +XXX,XX @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
+@@ -XXX,XX +XXX,XX @@ _cleanup_test_img()
-     rwco = (BlkRwCo) {
+             fi
-         .blk    = blk,
+             rm -f "$TEST_IMG_FILE"
-         .offset = offset,
+             ;;
--        .qiov   = &qiov,
++        vxhs)
-+        .iobuf  = &qiov,
++            if [ -f "${TEST_DIR}/qemu-vxhs.pid" ]; then
-         .flags  = flags,
++                local QEMU_VXHS_PID
-         .ret    = NOT_DONE,
++                read QEMU_VXHS_PID < "${TEST_DIR}/qemu-vxhs.pid"
-     };
++                kill ${QEMU_VXHS_PID} >/dev/null 2>&1
-@@ -XXX,XX +XXX,XX @@ static void blk_aio_complete_bh(void *opaque)
++                rm -f "${TEST_DIR}/qemu-vxhs.pid"
- }
++            fi
++            rm -f "$TEST_IMG_FILE"
- static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
++            ;;
 -                                QEMUIOVector *qiov, CoroutineEntry co_entry,
 +                                void *iobuf, CoroutineEntry co_entry,
                                  BdrvRequestFlags flags,
                                  BlockCompletionFunc *cb, void *opaque)
  {
@@ -XXX,XX +XXX,XX @@ static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
      acb->rwco = (BlkRwCo) {
          .blk    = blk,
          .offset = offset,
 -        .qiov   = qiov,
 +        .iobuf  = iobuf,
          .flags  = flags,
          .ret    = NOT_DONE,
      };
@@ -XXX,XX +XXX,XX @@ static void blk_aio_read_entry(void *opaque)
  {
      BlkAioEmAIOCB *acb = opaque;
      BlkRwCo *rwco = &acb->rwco;
 +    QEMUIOVector *qiov = rwco->iobuf;
 -    assert(rwco->qiov->size == acb->bytes);
 +    assert(qiov->size == acb->bytes);
      rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, acb->bytes,
 -                              rwco->qiov, rwco->flags);
 +                              qiov, rwco->flags);
      blk_aio_complete(acb);
  }
@@ -XXX,XX +XXX,XX @@ static void blk_aio_write_entry(void *opaque)
  {
      BlkAioEmAIOCB *acb = opaque;
      BlkRwCo *rwco = &acb->rwco;
 +    QEMUIOVector *qiov = rwco->iobuf;
 -    assert(!rwco->qiov || rwco->qiov->size == acb->bytes);
 +    assert(!qiov || qiov->size == acb->bytes);
      rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, acb->bytes,
 -                               rwco->qiov, rwco->flags);
 +                               qiov, rwco->flags);
      blk_aio_complete(acb);
  }
@@ -XXX,XX +XXX,XX @@ int blk_co_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
  static void blk_ioctl_entry(void *opaque)
  {
      BlkRwCo *rwco = opaque;
 +    QEMUIOVector *qiov = rwco->iobuf;
 +
-     rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset,
+         file)
--                             rwco->qiov->iov[0].iov_base);
+             _rm_test_img "$TEST_DIR/t.$IMGFMT"
-+                             qiov->iov[0].iov_base);
+             _rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
  }
  int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
@@ -XXX,XX +XXX,XX @@ static void blk_aio_ioctl_entry(void *opaque)
      BlkAioEmAIOCB *acb = opaque;
      BlkRwCo *rwco = &acb->rwco;
 -    rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset,
 -                             rwco->qiov->iov[0].iov_base);
 +    rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset, rwco->iobuf);
 +
      blk_aio_complete(acb);
  }
  BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
                            BlockCompletionFunc *cb, void *opaque)
  {
 -    QEMUIOVector qiov;
 -    struct iovec iov;
 -
 -    iov = (struct iovec) {
 -        .iov_base = buf,
 -        .iov_len = 0,
 -    };
 -    qemu_iovec_init_external(&qiov, &iov, 1);
 -
 -    return blk_aio_prwv(blk, req, 0, &qiov, blk_aio_ioctl_entry, 0, cb, opaque);
 +    return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque);
  }
  int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
@@ -XXX,XX +XXX,XX @@ int blk_truncate(BlockBackend *blk, int64_t offset, PreallocMode prealloc,
  static void blk_pdiscard_entry(void *opaque)
  {
      BlkRwCo *rwco = opaque;
 -    rwco->ret = blk_co_pdiscard(rwco->blk, rwco->offset, rwco->qiov->size);
 +    QEMUIOVector *qiov = rwco->iobuf;
 +
 +    rwco->ret = blk_co_pdiscard(rwco->blk, rwco->offset, qiov->size);
  }
  int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
 --
-.14.3
+.9.3

-New patch
+[Qemu-devel] [PULL v2 03/12] qemu-iotests: exclude vxhs from image creation via protocol
+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 4/7] block: add aio_wait_bh_oneshot()
+[Qemu-devel] [PULL v2 04/12] block: add bdrv_set_read_only() helper function
-Sometimes it's necessary for the main loop thread to run a BH in an
+We have a helper wrapper for checking for the BDS read_only flag,
-IOThread and wait for its completion.  This primitive is useful during
+add a helper wrapper to set the read_only flag as well.
 startup/shutdown to synchronize and avoid race conditions.
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Signed-off-by: Jeff Cody <jcody@redhat.com>
-Acked-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: 20180307144205.20619-2-stefanha@redhat.com
+Message-id: 9b18972d05f5fa2ac16c014f0af98d680553048d.1491597120.git.jcody@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/block/aio-wait.h | 13 +++++++++++++
+ block.c               | 5 +++++
- util/aio-wait.c          | 31 +++++++++++++++++++++++++++++++
+ block/bochs.c         | 2 +-
-files changed, 44 insertions(+)
+ 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/include/block/aio-wait.h b/include/block/aio-wait.h
+diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/aio-wait.h
+--- a/block.c
-+++ b/include/block/aio-wait.h
++++ b/block.c
-@@ -XXX,XX +XXX,XX @@ typedef struct {
+@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
   */
  void aio_wait_kick(AioWait *wait);
 +/**
 + * aio_wait_bh_oneshot:
 + * @ctx: the aio context
 + * @cb: the BH callback function
 + * @opaque: user data for the BH callback function
 + *
 + * Run a BH in @ctx and wait for it to complete.
 + *
 + * Must be called from the main loop thread with @ctx acquired exactly once.
 + * Note that main loop event processing may occur.
 + */
 +void aio_wait_bh_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
 +
  #endif /* QEMU_AIO_WAIT */
 diff --git a/util/aio-wait.c b/util/aio-wait.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/aio-wait.c
 +++ b/util/aio-wait.c
@@ -XXX,XX +XXX,XX @@ void aio_wait_kick(AioWait *wait)
          aio_bh_schedule_oneshot(qemu_get_aio_context(), dummy_bh_cb, NULL);
      }
  }
-+
-+typedef struct {
++void bdrv_set_read_only(BlockDriverState *bs, bool read_only)
 +    AioWait wait;
 +    bool done;
 +    QEMUBHFunc *cb;
 +    void *opaque;
 +} AioWaitBHData;
 +
 +/* Context: BH in IOThread */
 +static void aio_wait_bh(void *opaque)
 +{
-+    AioWaitBHData *data = opaque;
++    bs->read_only = read_only;
 +
 +    data->cb(data->opaque);
 +
 +    data->done = true;
 +    aio_wait_kick(&data->wait);
 +}
 +
-+void aio_wait_bh_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
+ void bdrv_get_full_backing_filename_from_filename(const char *backed,
-+{
+                                                   const char *backing,
-+    AioWaitBHData data = {
+                                                   char *dest, size_t sz,
-+        .cb = cb,
+diff --git a/block/bochs.c b/block/bochs.c
-+        .opaque = opaque,
+index XXXXXXX..XXXXXXX 100644
-+    };
+--- a/block/bochs.c
-+
++++ b/block/bochs.c
-+    assert(qemu_get_current_aio_context() == qemu_get_aio_context());
+@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
-+
+         return -EINVAL;
-+    aio_bh_schedule_oneshot(ctx, aio_wait_bh, &data);
+     }
-+    AIO_WAIT_WHILE(&data.wait, ctx, !data.done);
-+}
+-    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);
 --
-.14.3
+.9.3

-New patch
+[Qemu-devel] [PULL v2 05/12] block: do not set BDS read_only if copy_on_read enabled
+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 +-
+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);
+--
+.9.3

-New patch
+[Qemu-devel] [PULL v2 06/12] block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only
+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 7/7] vl: introduce vm_shutdown()
+[Qemu-devel] [PULL v2 07/12] block: code movement
-Commit 00d09fdbbae5f7864ce754913efc84c12fdf9f1a ("vl: pause vcpus before
+Move bdrv_is_read_only() up with its friends.
 stopping iothreads") and commit dce8921b2baaf95974af8176406881872067adfa
 ("iothread: Stop threads before main() quits") tried to work around the
 fact that emulation was still active during termination by stopping
 iothreads.  They suffer from race conditions:
 . virtio_scsi_handle_cmd_vq() racing with iothread_stop_all() hits the
    virtio_scsi_ctx_check() assertion failure because the BDS AioContext
    has been modified by iothread_stop_all().
 . Guest vq kick racing with main loop termination leaves a readable
    ioeventfd that is handled by the next aio_poll() when external
    clients are enabled again, resulting in unwanted emulation activity.
-This patch obsoletes those commits by fully disabling emulation activity
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-when vcpus are stopped.
+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(-)
-Use the new vm_shutdown() function instead of pause_all_vcpus() so that
+diff --git a/block.c b/block.c
 vm change state handlers are invoked too.  Virtio devices will now stop
 their ioeventfds, preventing further emulation activity after vm_stop().
 Note that vm_stop(RUN_STATE_SHUTDOWN) cannot be used because it emits a
 QMP STOP event that may affect existing clients.
 It is no longer necessary to call replay_disable_events() directly since
 vm_shutdown() does so already.
 Drop iothread_stop_all() since it is no longer used.
 Cc: Fam Zheng <famz@redhat.com>
 Cc: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Acked-by: Paolo Bonzini <pbonzini@redhat.com>
 Message-id: 20180307144205.20619-5-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  include/sysemu/iothread.h |  1 -
  include/sysemu/sysemu.h   |  1 +
  cpus.c                    | 16 +++++++++++++---
  iothread.c                | 31 -------------------------------
  vl.c                      | 13 +++----------
 files changed, 17 insertions(+), 45 deletions(-)
 diff --git a/include/sysemu/iothread.h b/include/sysemu/iothread.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/sysemu/iothread.h
+--- a/block.c
-+++ b/include/sysemu/iothread.h
++++ b/block.c
-@@ -XXX,XX +XXX,XX @@ typedef struct {
+@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
  char *iothread_get_id(IOThread *iothread);
  IOThread *iothread_by_id(const char *id);
  AioContext *iothread_get_aio_context(IOThread *iothread);
 -void iothread_stop_all(void);
  GMainContext *iothread_get_g_main_context(IOThread *iothread);
  /*
 diff --git a/include/sysemu/sysemu.h b/include/sysemu/sysemu.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/sysemu.h
 +++ b/include/sysemu/sysemu.h
@@ -XXX,XX +XXX,XX @@ void vm_start(void);
  int vm_prepare_start(void);
  int vm_stop(RunState state);
  int vm_stop_force_state(RunState state);
 +int vm_shutdown(void);
  typedef enum WakeupReason {
      /* Always keep QEMU_WAKEUP_REASON_NONE = 0 */
 diff --git a/cpus.c b/cpus.c
 index XXXXXXX..XXXXXXX 100644
 --- a/cpus.c
 +++ b/cpus.c
@@ -XXX,XX +XXX,XX @@ void cpu_synchronize_all_pre_loadvm(void)
      }
  }
--static int do_vm_stop(RunState state)
++bool bdrv_is_read_only(BlockDriverState *bs)
 +static int do_vm_stop(RunState state, bool send_stop)
  {
      int ret = 0;
@@ -XXX,XX +XXX,XX @@ static int do_vm_stop(RunState state)
          pause_all_vcpus();
          runstate_set(state);
          vm_state_notify(0, state);
 -        qapi_event_send_stop(&error_abort);
 +        if (send_stop) {
 +            qapi_event_send_stop(&error_abort);
 +        }
      }
      bdrv_drain_all();
@@ -XXX,XX +XXX,XX @@ static int do_vm_stop(RunState state)
      return ret;
  }
 +/* Special vm_stop() variant for terminating the process.  Historically clients
 + * did not expect a QMP STOP event and so we need to retain compatibility.
 + */
 +int vm_shutdown(void)
 +{
-+    return do_vm_stop(RUN_STATE_SHUTDOWN, false);
++    return bs->read_only;
 +}
 +
- static bool cpu_can_run(CPUState *cpu)
+ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
  {
-     if (cpu->stop) {
+     /* Do not set read_only if copy_on_read is enabled */
-@@ -XXX,XX +XXX,XX @@ int vm_stop(RunState state)
+@@ -XXX,XX +XXX,XX @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
-         return 0;
+     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
      }
 -    return do_vm_stop(state);
 +    return do_vm_stop(state, true);
  }
- /**
+-bool bdrv_is_read_only(BlockDriverState *bs)
 diff --git a/iothread.c b/iothread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/iothread.c
 +++ b/iothread.c
@@ -XXX,XX +XXX,XX @@ void iothread_stop(IOThread *iothread)
      qemu_thread_join(&iothread->thread);
  }
 -static int iothread_stop_iter(Object *object, void *opaque)
 -{
--    IOThread *iothread;
+-    return bs->read_only;
 -
 -    iothread = (IOThread *)object_dynamic_cast(object, TYPE_IOTHREAD);
 -    if (!iothread) {
 -        return 0;
 -    }
 -    iothread_stop(iothread);
 -    return 0;
 -}
 -
- static void iothread_instance_init(Object *obj)
+ bool bdrv_is_sg(BlockDriverState *bs)
  {
-     IOThread *iothread = IOTHREAD(obj);
+     return bs->sg;
@@ -XXX,XX +XXX,XX @@ IOThreadInfoList *qmp_query_iothreads(Error **errp)
      return head;
  }
 -void iothread_stop_all(void)
 -{
 -    Object *container = object_get_objects_root();
 -    BlockDriverState *bs;
 -    BdrvNextIterator it;
 -
 -    for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
 -        AioContext *ctx = bdrv_get_aio_context(bs);
 -        if (ctx == qemu_get_aio_context()) {
 -            continue;
 -        }
 -        aio_context_acquire(ctx);
 -        bdrv_set_aio_context(bs, qemu_get_aio_context());
 -        aio_context_release(ctx);
 -    }
 -
 -    object_child_foreach(container, iothread_stop_iter, NULL);
 -}
 -
  static gpointer iothread_g_main_context_init(gpointer opaque)
  {
      AioContext *ctx;
 diff --git a/vl.c b/vl.c
 index XXXXXXX..XXXXXXX 100644
 --- a/vl.c
 +++ b/vl.c
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
      os_setup_post();
      main_loop();
 -    replay_disable_events();
 -    /* The ordering of the following is delicate.  Stop vcpus to prevent new
 -     * I/O requests being queued by the guest.  Then stop IOThreads (this
 -     * includes a drain operation and completes all request processing).  At
 -     * this point emulated devices are still associated with their IOThreads
 -     * (if any) but no longer have any work to do.  Only then can we close
 -     * block devices safely because we know there is no more I/O coming.
 -     */
 -    pause_all_vcpus();
 -    iothread_stop_all();
 +    /* No more vcpu or device emulation activity beyond this point */
 +    vm_shutdown();
 +
      bdrv_close_all();
      res_free();
 --
-.14.3
+.9.3

-[Qemu-devel] [PULL 5/7] virtio-blk: fix race between .ioeventfd_stop() and vq handler
+[Qemu-devel] [PULL v2 08/12] block: introduce bdrv_can_set_read_only()
-If the main loop thread invokes .ioeventfd_stop() just as the vq handler
+Introduce check function for setting read_only flags.  Will return < 0 on
-function begins in the IOThread then the handler may lose the race for
+error, with appropriate Error value set.  Does not alter any flags.
 the AioContext lock.  By the time the vq handler is able to acquire the
 AioContext lock the ioeventfd has already been removed and the handler
 isn't supposed to run anymore!
-Use the new aio_wait_bh_oneshot() function to perform ioeventfd removal
+Signed-off-by: Jeff Cody <jcody@redhat.com>
-from within the IOThread.  This way no races with the vq handler are
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-possible.
+Reviewed-by: John Snow <jsnow@redhat.com>
 Message-id: e2bba34ac3bc76a0c42adc390413f358ae0566e8.1491597120.git.jcody@redhat.com
 ---
  block.c               | 14 +++++++++++++-
  include/block/block.h |  1 +
 files changed, 14 insertions(+), 1 deletion(-)
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+diff --git a/block.c b/block.c
 Reviewed-by: Fam Zheng <famz@redhat.com>
 Acked-by: Paolo Bonzini <pbonzini@redhat.com>
 Message-id: 20180307144205.20619-3-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  hw/block/dataplane/virtio-blk.c | 24 +++++++++++++++++-------
 file changed, 17 insertions(+), 7 deletions(-)
 diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/dataplane/virtio-blk.c
+--- a/block.c
-+++ b/hw/block/dataplane/virtio-blk.c
++++ b/block.c
-@@ -XXX,XX +XXX,XX @@ int virtio_blk_data_plane_start(VirtIODevice *vdev)
+@@ -XXX,XX +XXX,XX @@ bool bdrv_is_read_only(BlockDriverState *bs)
-     return -ENOSYS;
+     return bs->read_only;
  }
-+/* Stop notifications for new requests from guest.
+-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)
-+ * Context: BH in IOThread
+ {
-+ */
+     /* Do not set read_only if copy_on_read is enabled */
-+static void virtio_blk_data_plane_stop_bh(void *opaque)
+     if (bs->copy_on_read && read_only) {
-+{
+@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
-+    VirtIOBlockDataPlane *s = opaque;
+         return -EPERM;
-+    unsigned i;
+     }
-+
-+    for (i = 0; i < s->conf->num_queues; i++) {
++    return 0;
 +        VirtQueue *vq = virtio_get_queue(s->vdev, i);
 +
 +        virtio_queue_aio_set_host_notifier_handler(vq, s->ctx, NULL);
 +    }
 +}
 +
- /* Context: QEMU global mutex held */
++int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
- void virtio_blk_data_plane_stop(VirtIODevice *vdev)
++{
- {
++    int ret = 0;
-@@ -XXX,XX +XXX,XX @@ void virtio_blk_data_plane_stop(VirtIODevice *vdev)
++
-     trace_virtio_blk_data_plane_stop(s);
++    ret = bdrv_can_set_read_only(bs, read_only, errp);
++    if (ret < 0) {
-     aio_context_acquire(s->ctx);
++        return ret;
--
++    }
--    /* Stop notifications for new requests from guest */
++
--    for (i = 0; i < nvqs; i++) {
+     bs->read_only = read_only;
--        VirtQueue *vq = virtio_get_queue(s->vdev, i);
+     return 0;
--
+ }
--        virtio_queue_aio_set_host_notifier_handler(vq, s->ctx, NULL);
+diff --git a/include/block/block.h b/include/block/block.h
--    }
+index XXXXXXX..XXXXXXX 100644
-+    aio_wait_bh_oneshot(s->ctx, virtio_blk_data_plane_stop_bh, s);
+--- a/include/block/block.h
++++ b/include/block/block.h
-     /* Drain and switch bs back to the QEMU main loop */
+@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
-     blk_set_aio_context(s->conf->conf.blk, qemu_get_aio_context());
+                             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);
 --
-.14.3
+.9.3

-New patch
+[Qemu-devel] [PULL v2 09/12] block: use bdrv_can_set_read_only() during reopen
+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 6/7] virtio-scsi: fix race between .ioeventfd_stop() and vq handler
+[Qemu-devel] [PULL v2 10/12] block/rbd - update variable names to more apt names
-If the main loop thread invokes .ioeventfd_stop() just as the vq handler
+Update 'clientname' to be 'user', which tracks better with both
-function begins in the IOThread then the handler may lose the race for
+the QAPI and rados variable naming.
 the AioContext lock.  By the time the vq handler is able to acquire the
 AioContext lock the ioeventfd has already been removed and the handler
 isn't supposed to run anymore!
-Use the new aio_wait_bh_oneshot() function to perform ioeventfd removal
+Update 'name' to be 'image_name', as it indicates the rbd image.
-from within the IOThread.  This way no races with the vq handler are
+Naming it 'image' would have been ideal, but we are using that for
-possible.
+the rados_image_t value returned by rbd_open().
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Signed-off-by: Jeff Cody <jcody@redhat.com>
-Acked-by: Paolo Bonzini <pbonzini@redhat.com>
+Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: 20180307144205.20619-4-stefanha@redhat.com
+Message-id: b7ec1fb2e1cf36f9b6911631447a5b0422590b7d.1491597120.git.jcody@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- hw/scsi/virtio-scsi-dataplane.c | 9 +++++----
+ block/rbd.c | 33 +++++++++++++++++----------------
-file changed, 5 insertions(+), 4 deletions(-)
+file changed, 17 insertions(+), 16 deletions(-)
-diff --git a/hw/scsi/virtio-scsi-dataplane.c b/hw/scsi/virtio-scsi-dataplane.c
+diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/scsi/virtio-scsi-dataplane.c
+--- a/block/rbd.c
-+++ b/hw/scsi/virtio-scsi-dataplane.c
++++ b/block/rbd.c
-@@ -XXX,XX +XXX,XX @@ static int virtio_scsi_vring_init(VirtIOSCSI *s, VirtQueue *vq, int n,
+@@ -XXX,XX +XXX,XX @@ typedef struct BDRVRBDState {
-     return 0;
+     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);
  }
--/* assumes s->ctx held */
--static void virtio_scsi_clear_aio(VirtIOSCSI *s)
-+/* Context: BH in IOThread */
-+static void virtio_scsi_dataplane_stop_bh(void *opaque)
- {
-+    VirtIOSCSI *s = opaque;
-     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
-     int i;
-@@ -XXX,XX +XXX,XX @@ int virtio_scsi_dataplane_start(VirtIODevice *vdev)
-     return 0;
- fail_vrings:
--    virtio_scsi_clear_aio(s);
-+    aio_wait_bh_oneshot(s->ctx, virtio_scsi_dataplane_stop_bh, s);
-     aio_context_release(s->ctx);
-     for (i = 0; i < vs->conf.num_queues + 2; i++) {
-         virtio_bus_set_host_notifier(VIRTIO_BUS(qbus), i, false);
-@@ -XXX,XX +XXX,XX @@ void virtio_scsi_dataplane_stop(VirtIODevice *vdev)
-     s->dataplane_stopping = true;
-     aio_context_acquire(s->ctx);
--    virtio_scsi_clear_aio(s);
-+    aio_wait_bh_oneshot(s->ctx, virtio_scsi_dataplane_stop_bh, s);
-     aio_context_release(s->ctx);
-     blk_drain_all(); /* ensure there are no in-flight requests */
 --
-.14.3
+.9.3

-[Qemu-devel] [PULL 3/7] virtio-blk: dataplane: Don't batch notifications if EVENT_IDX is present
+[Qemu-devel] [PULL v2 11/12] block/rbd: Add support for reopen()
-From: Sergio Lopez <slp@redhat.com>
+This adds support for reopen in rbd, for changing between r/w and r/o.
-Commit 5b2ffbe4d99843fd8305c573a100047a8c962327 ("virtio-blk: dataplane:
+Note, that this is only a flag change, but we will block a change from
-notify guest as a batch") deferred guest notification to a BH in order
+r/o to r/w if we are using an RBD internal snapshot.
 batch notifications, with purpose of avoiding flooding the guest with
 interruptions.
-This optimization came with a cost. The average latency perceived in the
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-guest is increased by a few microseconds, but also when multiple IO
+Signed-off-by: Jeff Cody <jcody@redhat.com>
-operations finish at the same time, the guest won't be notified until
+Reviewed-by: John Snow <jsnow@redhat.com>
-all completions from each operation has been run. On the contrary,
+Message-id: d4e87539167ec6527d44c97b164eabcccf96e4f3.1491597120.git.jcody@redhat.com
-virtio-scsi issues the notification at the end of each completion.
+---
  block/rbd.c | 21 +++++++++++++++++++++
 file changed, 21 insertions(+)
-On the other hand, nowadays we have the EVENT_IDX feature that allows a
+diff --git a/block/rbd.c b/block/rbd.c
 better coordination between QEMU and the Guest OS to avoid sending
 unnecessary interruptions.
 With this change, virtio-blk/dataplane only batches notifications if the
 EVENT_IDX feature is not present.
 Some numbers obtained with fio (ioengine=sync, iodepth=1, direct=1):
  - Test specs:
    * fio-3.4 (ioengine=sync, iodepth=1, direct=1)
    * qemu master
    * virtio-blk with a dedicated iothread (default poll-max-ns)
    * backend: null_blk nr_devices=1 irqmode=2 completion_nsec=280000
    * 8 vCPUs pinned to isolated physical cores
    * Emulator and iothread also pinned to separate isolated cores
    * variance between runs < 1%
  - Not patched
    * numjobs=1:  lat_avg=327.32  irqs=29998
    * numjobs=4:  lat_avg=337.89  irqs=29073
    * numjobs=8:  lat_avg=342.98  irqs=28643
  - Patched:
    * numjobs=1:  lat_avg=323.92  irqs=30262
    * numjobs=4:  lat_avg=332.65  irqs=29520
    * numjobs=8:  lat_avg=335.54  irqs=29323
 Signed-off-by: Sergio Lopez <slp@redhat.com>
 Message-id: 20180307114459.26636-1-slp@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  hw/block/dataplane/virtio-blk.c | 15 +++++++++++++--
 file changed, 13 insertions(+), 2 deletions(-)
 diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/dataplane/virtio-blk.c
+--- a/block/rbd.c
-+++ b/hw/block/dataplane/virtio-blk.c
++++ b/block/rbd.c
-@@ -XXX,XX +XXX,XX @@ struct VirtIOBlockDataPlane {
+@@ -XXX,XX +XXX,XX @@ failed_opts:
-     VirtIODevice *vdev;
+     return r;
      QEMUBH *bh;                     /* bh for guest notification */
      unsigned long *batch_notify_vqs;
 +    bool batch_notifications;
      /* Note that these EventNotifiers are assigned by value.  This is
       * fine as long as you do not call event_notifier_cleanup on them
@@ -XXX,XX +XXX,XX @@ struct VirtIOBlockDataPlane {
  /* Raise an interrupt to signal guest, if necessary */
  void virtio_blk_data_plane_notify(VirtIOBlockDataPlane *s, VirtQueue *vq)
  {
 -    set_bit(virtio_get_queue_index(vq), s->batch_notify_vqs);
 -    qemu_bh_schedule(s->bh);
 +    if (s->batch_notifications) {
 +        set_bit(virtio_get_queue_index(vq), s->batch_notify_vqs);
 +        qemu_bh_schedule(s->bh);
 +    } else {
 +        virtio_notify_irqfd(s->vdev, vq);
 +    }
  }
- static void notify_guest_bh(void *opaque)
++
-@@ -XXX,XX +XXX,XX @@ int virtio_blk_data_plane_start(VirtIODevice *vdev)
++/* 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
-     s->starting = true;
++ * order to determine if we will allow it to be R/W */
++static int qemu_rbd_reopen_prepare(BDRVReopenState *state,
-+    if (!virtio_vdev_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX)) {
++                                   BlockReopenQueue *queue, Error **errp)
-+        s->batch_notifications = true;
++{
-+    } else {
++    BDRVRBDState *s = state->bs->opaque;
-+        s->batch_notifications = false;
++    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;
 +    }
 +
-     /* Set up guest notifier (irq) */
++    return ret;
-     r = k->set_guest_notifiers(qbus->parent, nvqs, true);
++}
-     if (r != 0) {
++
  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,
 --
-.14.3
+.9.3

-[Qemu-devel] [PULL 2/7] README: Fix typo 'git-publish'
+[Qemu-devel] [PULL v2 12/12] qemu-iotests: _cleanup_qemu must be called on exit
-From: Fam Zheng <famz@redhat.com>
+For the tests that use the common.qemu functions for running a QEMU
 process, _cleanup_qemu must be called in the exit function.
-Reported-by: Alberto Garcia <berto@igalia.com>
+If it is not, if the qemu process aborts, then not all of the droppings
-Signed-off-by: Fam Zheng <famz@redhat.com>
+are cleaned up (e.g. pidfile, fifos).
-Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
-Message-id: 20180306024328.19195-1-famz@redhat.com
+This updates those tests that did not have a cleanup in qemu-iotests.
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 (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
 ---
- README | 2 +-
+ tests/qemu-iotests/028 |  1 +
-file changed, 1 insertion(+), 1 deletion(-)
+ 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/README b/README
+diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028
-index XXXXXXX..XXXXXXX 100644
+index XXXXXXX..XXXXXXX 100755
---- a/README
+--- a/tests/qemu-iotests/028
-+++ b/README
++++ b/tests/qemu-iotests/028
-@@ -XXX,XX +XXX,XX @@ The QEMU website is also maintained under source control.
+@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
-   git clone git://git.qemu.org/qemu-web.git
-   https://www.qemu.org/2017/02/04/the-new-qemu-website-is-up/
+ _cleanup()
+ {
--A 'git-profile' utility was created to make above process less
++    _cleanup_qemu
-+A 'git-publish' utility was created to make above process less
+     rm -f "${TEST_IMG}.copy"
- cumbersome, and is highly recommended for making regular contributions,
+     _cleanup_test_img
- or even just for sending consecutive patch series revisions. It also
+ }
- requires a working 'git send-email' setup, and by default doesn't
+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
 --
-.14.3
+.9.3

The following changes since commit 0ab4537f08e09b13788db67efd760592fb7db769:

Merge remote-tracking branch 'remotes/stefanberger/tags/pull-tpm-2018-03-07-1' into staging (2018-03-08 12:56:39 +0000)

are available in the Git repository at:

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

for you to fetch changes up to 4486e89c219c0d1b9bd8dfa0b1dd5b0d51ff2268:

vl: introduce vm_shutdown() (2018-03-08 17:38:51 +0000)

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

Deepa Srinivasan (1):
  block: Fix qemu crash when using scsi-block

Fam Zheng (1):
  README: Fix typo 'git-publish'

Sergio Lopez (1):
  virtio-blk: dataplane: Don't batch notifications if EVENT_IDX is
    present

Stefan Hajnoczi (4):
  block: add aio_wait_bh_oneshot()
  virtio-blk: fix race between .ioeventfd_stop() and vq handler
  virtio-scsi: fix race between .ioeventfd_stop() and vq handler
  vl: introduce vm_shutdown()

-- 
2.14.3

From: Deepa Srinivasan <deepa.srinivasan@oracle.com>

Starting qemu with the following arguments causes qemu to segfault:
... -device lsi,id=lsi0 -drive file=iscsi:<...>,format=raw,if=none,node-name=
iscsi1 -device scsi-block,bus=lsi0.0,id=<...>,drive=iscsi1

This patch fixes blk_aio_ioctl() so it does not pass stack addresses to
blk_aio_ioctl_entry() which may be invoked after blk_aio_ioctl() returns. More
details about the bug follow.

blk_aio_ioctl() invokes blk_aio_prwv() with blk_aio_ioctl_entry as the
coroutine parameter. blk_aio_prwv() ultimately calls aio_co_enter().

When blk_aio_ioctl() is executed from within a coroutine context (e.g.
iscsi_bh_cb()), aio_co_enter() adds the coroutine (blk_aio_ioctl_entry) to
the current coroutine's wakeup queue. blk_aio_ioctl() then returns.

When blk_aio_ioctl_entry() executes later, it accesses an invalid pointer:
....
    BlkRwCo *rwco = &acb->rwco;

rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset,
                             rwco->qiov->iov[0].iov_base);  <--- qiov is
                                                                 invalid here
...

In the case when blk_aio_ioctl() is called from a non-coroutine context,
blk_aio_ioctl_entry() executes immediately. But if bdrv_co_ioctl() calls
qemu_coroutine_yield(), blk_aio_ioctl() will return. When the coroutine
execution is complete, control returns to blk_aio_ioctl_entry() after the call
to blk_co_ioctl(). There is no invalid reference after this point, but the
function is still holding on to invalid pointers.

The fix is to change blk_aio_prwv() to accept a void pointer for the IO buffer
rather than a QEMUIOVector. blk_aio_prwv() passes this through in BlkRwCo and the
coroutine function casts it to QEMUIOVector or uses the void pointer directly.

Signed-off-by: Deepa Srinivasan <deepa.srinivasan@oracle.com>
Signed-off-by: Konrad Rzeszutek Wilk <konrad.wilk@oracle.com>
Reviewed-by: Mark Kanda <mark.kanda@oracle.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/block-backend.c | 51 +++++++++++++++++++++++++--------------------------
 1 file changed, 25 insertions(+), 26 deletions(-)

diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
 typedef struct BlkRwCo {
     BlockBackend *blk;
     int64_t offset;
-    QEMUIOVector *qiov;
+    void *iobuf;
     int ret;
     BdrvRequestFlags flags;
 } BlkRwCo;
@@ -XXX,XX +XXX,XX @@ typedef struct BlkRwCo {
 static void blk_read_entry(void *opaque)
 {
     BlkRwCo *rwco = opaque;
+    QEMUIOVector *qiov = rwco->iobuf;
 
-    rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, rwco->qiov->size,
-                              rwco->qiov, rwco->flags);
+    rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, qiov->size,
+                              qiov, rwco->flags);
 }
 
 static void blk_write_entry(void *opaque)
 {
     BlkRwCo *rwco = opaque;
+    QEMUIOVector *qiov = rwco->iobuf;
 
-    rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, rwco->qiov->size,
-                               rwco->qiov, rwco->flags);
+    rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, qiov->size,
+                               qiov, rwco->flags);
 }
 
 static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
@@ -XXX,XX +XXX,XX @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
     rwco = (BlkRwCo) {
         .blk    = blk,
         .offset = offset,
-        .qiov   = &qiov,
+        .iobuf  = &qiov,
         .flags  = flags,
         .ret    = NOT_DONE,
     };
@@ -XXX,XX +XXX,XX @@ static void blk_aio_complete_bh(void *opaque)
 }
 
 static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
-                                QEMUIOVector *qiov, CoroutineEntry co_entry,
+                                void *iobuf, CoroutineEntry co_entry,
                                 BdrvRequestFlags flags,
                                 BlockCompletionFunc *cb, void *opaque)
 {
@@ -XXX,XX +XXX,XX @@ static BlockAIOCB *blk_aio_prwv(BlockBackend *blk, int64_t offset, int bytes,
     acb->rwco = (BlkRwCo) {
         .blk    = blk,
         .offset = offset,
-        .qiov   = qiov,
+        .iobuf  = iobuf,
         .flags  = flags,
         .ret    = NOT_DONE,
     };
@@ -XXX,XX +XXX,XX @@ static void blk_aio_read_entry(void *opaque)
 {
     BlkAioEmAIOCB *acb = opaque;
     BlkRwCo *rwco = &acb->rwco;
+    QEMUIOVector *qiov = rwco->iobuf;
 
-    assert(rwco->qiov->size == acb->bytes);
+    assert(qiov->size == acb->bytes);
     rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, acb->bytes,
-                              rwco->qiov, rwco->flags);
+                              qiov, rwco->flags);
     blk_aio_complete(acb);
 }
 
@@ -XXX,XX +XXX,XX @@ static void blk_aio_write_entry(void *opaque)
 {
     BlkAioEmAIOCB *acb = opaque;
     BlkRwCo *rwco = &acb->rwco;
+    QEMUIOVector *qiov = rwco->iobuf;
 
-    assert(!rwco->qiov || rwco->qiov->size == acb->bytes);
+    assert(!qiov || qiov->size == acb->bytes);
     rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, acb->bytes,
-                               rwco->qiov, rwco->flags);
+                               qiov, rwco->flags);
     blk_aio_complete(acb);
 }
 
@@ -XXX,XX +XXX,XX @@ int blk_co_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
 static void blk_ioctl_entry(void *opaque)
 {
     BlkRwCo *rwco = opaque;
+    QEMUIOVector *qiov = rwco->iobuf;
+
     rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset,
-                             rwco->qiov->iov[0].iov_base);
+                             qiov->iov[0].iov_base);
 }
 
 int blk_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
@@ -XXX,XX +XXX,XX @@ static void blk_aio_ioctl_entry(void *opaque)
     BlkAioEmAIOCB *acb = opaque;
     BlkRwCo *rwco = &acb->rwco;
 
-    rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset,
-                             rwco->qiov->iov[0].iov_base);
+    rwco->ret = blk_co_ioctl(rwco->blk, rwco->offset, rwco->iobuf);
+
     blk_aio_complete(acb);
 }
 
 BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
                           BlockCompletionFunc *cb, void *opaque)
 {
-    QEMUIOVector qiov;
-    struct iovec iov;
-
-    iov = (struct iovec) {
-        .iov_base = buf,
-        .iov_len = 0,
-    };
-    qemu_iovec_init_external(&qiov, &iov, 1);
-
-    return blk_aio_prwv(blk, req, 0, &qiov, blk_aio_ioctl_entry, 0, cb, opaque);
+    return blk_aio_prwv(blk, req, 0, buf, blk_aio_ioctl_entry, 0, cb, opaque);
 }
 
 int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
@@ -XXX,XX +XXX,XX @@ int blk_truncate(BlockBackend *blk, int64_t offset, PreallocMode prealloc,
 static void blk_pdiscard_entry(void *opaque)
 {
     BlkRwCo *rwco = opaque;
-    rwco->ret = blk_co_pdiscard(rwco->blk, rwco->offset, rwco->qiov->size);
+    QEMUIOVector *qiov = rwco->iobuf;
+
+    rwco->ret = blk_co_pdiscard(rwco->blk, rwco->offset, qiov->size);
 }
 
 int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
-- 
2.14.3

From: Sergio Lopez <slp@redhat.com>

Commit 5b2ffbe4d99843fd8305c573a100047a8c962327 ("virtio-blk: dataplane:
notify guest as a batch") deferred guest notification to a BH in order
batch notifications, with purpose of avoiding flooding the guest with
interruptions.

This optimization came with a cost. The average latency perceived in the
guest is increased by a few microseconds, but also when multiple IO
operations finish at the same time, the guest won't be notified until
all completions from each operation has been run. On the contrary,
virtio-scsi issues the notification at the end of each completion.

On the other hand, nowadays we have the EVENT_IDX feature that allows a
better coordination between QEMU and the Guest OS to avoid sending
unnecessary interruptions.

With this change, virtio-blk/dataplane only batches notifications if the
EVENT_IDX feature is not present.

Some numbers obtained with fio (ioengine=sync, iodepth=1, direct=1):
 - Test specs:
   * fio-3.4 (ioengine=sync, iodepth=1, direct=1)
   * qemu master
   * virtio-blk with a dedicated iothread (default poll-max-ns)
   * backend: null_blk nr_devices=1 irqmode=2 completion_nsec=280000
   * 8 vCPUs pinned to isolated physical cores
   * Emulator and iothread also pinned to separate isolated cores
   * variance between runs < 1%

- Not patched
   * numjobs=1:  lat_avg=327.32  irqs=29998
   * numjobs=4:  lat_avg=337.89  irqs=29073
   * numjobs=8:  lat_avg=342.98  irqs=28643

- Patched:
   * numjobs=1:  lat_avg=323.92  irqs=30262
   * numjobs=4:  lat_avg=332.65  irqs=29520
   * numjobs=8:  lat_avg=335.54  irqs=29323

Signed-off-by: Sergio Lopez <slp@redhat.com>
Message-id: 20180307114459.26636-1-slp@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/block/dataplane/virtio-blk.c | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/dataplane/virtio-blk.c
+++ b/hw/block/dataplane/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ struct VirtIOBlockDataPlane {
     VirtIODevice *vdev;
     QEMUBH *bh;                     /* bh for guest notification */
     unsigned long *batch_notify_vqs;
+    bool batch_notifications;
 
     /* Note that these EventNotifiers are assigned by value.  This is
      * fine as long as you do not call event_notifier_cleanup on them
@@ -XXX,XX +XXX,XX @@ struct VirtIOBlockDataPlane {
 /* Raise an interrupt to signal guest, if necessary */
 void virtio_blk_data_plane_notify(VirtIOBlockDataPlane *s, VirtQueue *vq)
 {
-    set_bit(virtio_get_queue_index(vq), s->batch_notify_vqs);
-    qemu_bh_schedule(s->bh);
+    if (s->batch_notifications) {
+        set_bit(virtio_get_queue_index(vq), s->batch_notify_vqs);
+        qemu_bh_schedule(s->bh);
+    } else {
+        virtio_notify_irqfd(s->vdev, vq);
+    }
 }
 
 static void notify_guest_bh(void *opaque)
@@ -XXX,XX +XXX,XX @@ int virtio_blk_data_plane_start(VirtIODevice *vdev)
 
     s->starting = true;
 
+    if (!virtio_vdev_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX)) {
+        s->batch_notifications = true;
+    } else {
+        s->batch_notifications = false;
+    }
+
     /* Set up guest notifier (irq) */
     r = k->set_guest_notifiers(qbus->parent, nvqs, true);
     if (r != 0) {
-- 
2.14.3

Sometimes it's necessary for the main loop thread to run a BH in an
IOThread and wait for its completion.  This primitive is useful during
startup/shutdown to synchronize and avoid race conditions.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20180307144205.20619-2-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/block/aio-wait.h | 13 +++++++++++++
 util/aio-wait.c          | 31 +++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/include/block/aio-wait.h b/include/block/aio-wait.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/aio-wait.h
+++ b/include/block/aio-wait.h
@@ -XXX,XX +XXX,XX @@ typedef struct {
  */
 void aio_wait_kick(AioWait *wait);
 
+/**
+ * aio_wait_bh_oneshot:
+ * @ctx: the aio context
+ * @cb: the BH callback function
+ * @opaque: user data for the BH callback function
+ *
+ * Run a BH in @ctx and wait for it to complete.
+ *
+ * Must be called from the main loop thread with @ctx acquired exactly once.
+ * Note that main loop event processing may occur.
+ */
+void aio_wait_bh_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
+
 #endif /* QEMU_AIO_WAIT */
diff --git a/util/aio-wait.c b/util/aio-wait.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-wait.c
+++ b/util/aio-wait.c
@@ -XXX,XX +XXX,XX @@ void aio_wait_kick(AioWait *wait)
         aio_bh_schedule_oneshot(qemu_get_aio_context(), dummy_bh_cb, NULL);
     }
 }
+
+typedef struct {
+    AioWait wait;
+    bool done;
+    QEMUBHFunc *cb;
+    void *opaque;
+} AioWaitBHData;
+
+/* Context: BH in IOThread */
+static void aio_wait_bh(void *opaque)
+{
+    AioWaitBHData *data = opaque;
+
+    data->cb(data->opaque);
+
+    data->done = true;
+    aio_wait_kick(&data->wait);
+}
+
+void aio_wait_bh_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
+{
+    AioWaitBHData data = {
+        .cb = cb,
+        .opaque = opaque,
+    };
+
+    assert(qemu_get_current_aio_context() == qemu_get_aio_context());
+
+    aio_bh_schedule_oneshot(ctx, aio_wait_bh, &data);
+    AIO_WAIT_WHILE(&data.wait, ctx, !data.done);
+}
-- 
2.14.3

If the main loop thread invokes .ioeventfd_stop() just as the vq handler
function begins in the IOThread then the handler may lose the race for
the AioContext lock.  By the time the vq handler is able to acquire the
AioContext lock the ioeventfd has already been removed and the handler
isn't supposed to run anymore!

Use the new aio_wait_bh_oneshot() function to perform ioeventfd removal
from within the IOThread.  This way no races with the vq handler are
possible.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20180307144205.20619-3-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/block/dataplane/virtio-blk.c | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/hw/block/dataplane/virtio-blk.c b/hw/block/dataplane/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/dataplane/virtio-blk.c
+++ b/hw/block/dataplane/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ int virtio_blk_data_plane_start(VirtIODevice *vdev)
     return -ENOSYS;
 }
 
+/* Stop notifications for new requests from guest.
+ *
+ * Context: BH in IOThread
+ */
+static void virtio_blk_data_plane_stop_bh(void *opaque)
+{
+    VirtIOBlockDataPlane *s = opaque;
+    unsigned i;
+
+    for (i = 0; i < s->conf->num_queues; i++) {
+        VirtQueue *vq = virtio_get_queue(s->vdev, i);
+
+        virtio_queue_aio_set_host_notifier_handler(vq, s->ctx, NULL);
+    }
+}
+
 /* Context: QEMU global mutex held */
 void virtio_blk_data_plane_stop(VirtIODevice *vdev)
 {
@@ -XXX,XX +XXX,XX @@ void virtio_blk_data_plane_stop(VirtIODevice *vdev)
     trace_virtio_blk_data_plane_stop(s);
 
     aio_context_acquire(s->ctx);
-
-    /* Stop notifications for new requests from guest */
-    for (i = 0; i < nvqs; i++) {
-        VirtQueue *vq = virtio_get_queue(s->vdev, i);
-
-        virtio_queue_aio_set_host_notifier_handler(vq, s->ctx, NULL);
-    }
+    aio_wait_bh_oneshot(s->ctx, virtio_blk_data_plane_stop_bh, s);
 
     /* Drain and switch bs back to the QEMU main loop */
     blk_set_aio_context(s->conf->conf.blk, qemu_get_aio_context());
-- 
2.14.3

Use the new aio_wait_bh_oneshot() function to perform ioeventfd removal
from within the IOThread.  This way no races with the vq handler are
possible.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20180307144205.20619-4-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hw/scsi/virtio-scsi-dataplane.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/hw/scsi/virtio-scsi-dataplane.c b/hw/scsi/virtio-scsi-dataplane.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/virtio-scsi-dataplane.c
+++ b/hw/scsi/virtio-scsi-dataplane.c
@@ -XXX,XX +XXX,XX @@ static int virtio_scsi_vring_init(VirtIOSCSI *s, VirtQueue *vq, int n,
     return 0;
 }
 
-/* assumes s->ctx held */
-static void virtio_scsi_clear_aio(VirtIOSCSI *s)
+/* Context: BH in IOThread */
+static void virtio_scsi_dataplane_stop_bh(void *opaque)
 {
+    VirtIOSCSI *s = opaque;
     VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);
     int i;
 
@@ -XXX,XX +XXX,XX @@ int virtio_scsi_dataplane_start(VirtIODevice *vdev)
     return 0;
 
 fail_vrings:
-    virtio_scsi_clear_aio(s);
+    aio_wait_bh_oneshot(s->ctx, virtio_scsi_dataplane_stop_bh, s);
     aio_context_release(s->ctx);
     for (i = 0; i < vs->conf.num_queues + 2; i++) {
         virtio_bus_set_host_notifier(VIRTIO_BUS(qbus), i, false);
@@ -XXX,XX +XXX,XX @@ void virtio_scsi_dataplane_stop(VirtIODevice *vdev)
     s->dataplane_stopping = true;
 
     aio_context_acquire(s->ctx);
-    virtio_scsi_clear_aio(s);
+    aio_wait_bh_oneshot(s->ctx, virtio_scsi_dataplane_stop_bh, s);
     aio_context_release(s->ctx);
 
     blk_drain_all(); /* ensure there are no in-flight requests */
-- 
2.14.3

Commit 00d09fdbbae5f7864ce754913efc84c12fdf9f1a ("vl: pause vcpus before
stopping iothreads") and commit dce8921b2baaf95974af8176406881872067adfa
("iothread: Stop threads before main() quits") tried to work around the
fact that emulation was still active during termination by stopping
iothreads.  They suffer from race conditions:
1. virtio_scsi_handle_cmd_vq() racing with iothread_stop_all() hits the
   virtio_scsi_ctx_check() assertion failure because the BDS AioContext
   has been modified by iothread_stop_all().
2. Guest vq kick racing with main loop termination leaves a readable
   ioeventfd that is handled by the next aio_poll() when external
   clients are enabled again, resulting in unwanted emulation activity.

This patch obsoletes those commits by fully disabling emulation activity
when vcpus are stopped.

Use the new vm_shutdown() function instead of pause_all_vcpus() so that
vm change state handlers are invoked too.  Virtio devices will now stop
their ioeventfds, preventing further emulation activity after vm_stop().

Note that vm_stop(RUN_STATE_SHUTDOWN) cannot be used because it emits a
QMP STOP event that may affect existing clients.

It is no longer necessary to call replay_disable_events() directly since
vm_shutdown() does so already.

Drop iothread_stop_all() since it is no longer used.

Cc: Fam Zheng <famz@redhat.com>
Cc: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Acked-by: Paolo Bonzini <pbonzini@redhat.com>
Message-id: 20180307144205.20619-5-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/sysemu/iothread.h |  1 -
 include/sysemu/sysemu.h   |  1 +
 cpus.c                    | 16 +++++++++++++---
 iothread.c                | 31 -------------------------------
 vl.c                      | 13 +++----------
 5 files changed, 17 insertions(+), 45 deletions(-)

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 @@ typedef struct {
 char *iothread_get_id(IOThread *iothread);
 IOThread *iothread_by_id(const char *id);
 AioContext *iothread_get_aio_context(IOThread *iothread);
-void iothread_stop_all(void);
 GMainContext *iothread_get_g_main_context(IOThread *iothread);
 
 /*
diff --git a/include/sysemu/sysemu.h b/include/sysemu/sysemu.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/sysemu.h
+++ b/include/sysemu/sysemu.h
@@ -XXX,XX +XXX,XX @@ void vm_start(void);
 int vm_prepare_start(void);
 int vm_stop(RunState state);
 int vm_stop_force_state(RunState state);
+int vm_shutdown(void);
 
 typedef enum WakeupReason {
     /* Always keep QEMU_WAKEUP_REASON_NONE = 0 */
diff --git a/cpus.c b/cpus.c
index XXXXXXX..XXXXXXX 100644
--- a/cpus.c
+++ b/cpus.c
@@ -XXX,XX +XXX,XX @@ void cpu_synchronize_all_pre_loadvm(void)
     }
 }
 
-static int do_vm_stop(RunState state)
+static int do_vm_stop(RunState state, bool send_stop)
 {
     int ret = 0;
 
@@ -XXX,XX +XXX,XX @@ static int do_vm_stop(RunState state)
         pause_all_vcpus();
         runstate_set(state);
         vm_state_notify(0, state);
-        qapi_event_send_stop(&error_abort);
+        if (send_stop) {
+            qapi_event_send_stop(&error_abort);
+        }
     }
 
     bdrv_drain_all();
@@ -XXX,XX +XXX,XX @@ static int do_vm_stop(RunState state)
     return ret;
 }
 
+/* Special vm_stop() variant for terminating the process.  Historically clients
+ * did not expect a QMP STOP event and so we need to retain compatibility.
+ */
+int vm_shutdown(void)
+{
+    return do_vm_stop(RUN_STATE_SHUTDOWN, false);
+}
+
 static bool cpu_can_run(CPUState *cpu)
 {
     if (cpu->stop) {
@@ -XXX,XX +XXX,XX @@ int vm_stop(RunState state)
         return 0;
     }
 
-    return do_vm_stop(state);
+    return do_vm_stop(state, true);
 }
 
 /**
diff --git a/iothread.c b/iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/iothread.c
+++ b/iothread.c
@@ -XXX,XX +XXX,XX @@ void iothread_stop(IOThread *iothread)
     qemu_thread_join(&iothread->thread);
 }
 
-static int iothread_stop_iter(Object *object, void *opaque)
-{
-    IOThread *iothread;
-
-    iothread = (IOThread *)object_dynamic_cast(object, TYPE_IOTHREAD);
-    if (!iothread) {
-        return 0;
-    }
-    iothread_stop(iothread);
-    return 0;
-}
-
 static void iothread_instance_init(Object *obj)
 {
     IOThread *iothread = IOTHREAD(obj);
@@ -XXX,XX +XXX,XX @@ IOThreadInfoList *qmp_query_iothreads(Error **errp)
     return head;
 }
 
-void iothread_stop_all(void)
-{
-    Object *container = object_get_objects_root();
-    BlockDriverState *bs;
-    BdrvNextIterator it;
-
-    for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
-        AioContext *ctx = bdrv_get_aio_context(bs);
-        if (ctx == qemu_get_aio_context()) {
-            continue;
-        }
-        aio_context_acquire(ctx);
-        bdrv_set_aio_context(bs, qemu_get_aio_context());
-        aio_context_release(ctx);
-    }
-
-    object_child_foreach(container, iothread_stop_iter, NULL);
-}
-
 static gpointer iothread_g_main_context_init(gpointer opaque)
 {
     AioContext *ctx;
diff --git a/vl.c b/vl.c
index XXXXXXX..XXXXXXX 100644
--- a/vl.c
+++ b/vl.c
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
     os_setup_post();
 
     main_loop();
-    replay_disable_events();
 
-    /* The ordering of the following is delicate.  Stop vcpus to prevent new
-     * I/O requests being queued by the guest.  Then stop IOThreads (this
-     * includes a drain operation and completes all request processing).  At
-     * this point emulated devices are still associated with their IOThreads
-     * (if any) but no longer have any work to do.  Only then can we close
-     * block devices safely because we know there is no more I/O coming.
-     */
-    pause_all_vcpus();
-    iothread_stop_all();
+    /* No more vcpu or device emulation activity beyond this point */
+    vm_shutdown();
+
     bdrv_close_all();
 
     res_free();
-- 
2.14.3

The following changes since commit 4c55b1d0bad8a703f0499fe62e3761a0cd288da3:

Merge remote-tracking branch 'remotes/armbru/tags/pull-error-2017-04-24' into staging (2017-04-24 14:49:48 +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 ecfa185400ade2abc9915efa924cbad1e15a21a4:

qemu-iotests: _cleanup_qemu must be called on exit (2017-04-24 15:09:33 -0400)

----------------------------------------------------------------
Pull v2, with 32-bit errors fixed.  I don't have OS X to test compile on,
but I think it is safe to assume the cause of the compile error was the same.
----------------------------------------------------------------

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"}'

[Jeff: Modified trace-events with the correct string formatting]

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 = %"PRIu64" offset = %"PRIu64" 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 %"PRIu64
+vxhs_complete_aio(void *acb, uint64_t ret) "aio failed acb %p ret %"PRIu64
+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