Series comparison

-[Qemu-devel] [PULL 00/12] Block patches
+[PULL 00/19] Block patches
-The following changes since commit bfec359afba088aaacc7d316f43302f28c6e642a:
+The following changes since commit ba29883206d92a29ad5a466e679ccfc2ee6132ef:
-  Merge remote-tracking branch 'remotes/armbru/tags/pull-qdev-2017-04-21' into staging (2017-04-21 11:42:03 +0100)
+  Merge remote-tracking branch 'remotes/borntraeger/tags/s390x-20200310' into staging (2020-03-10 16:50:28 +0000)
-are available in the git repository at:
+are available in the Git repository at:
-  git://github.com/codyprime/qemu-kvm-jtc.git tags/block-pull-request
+  https://github.com/XanClic/qemu.git tags/pull-block-2020-03-11
-for you to fetch changes up to 1507631e438930bc07f776f303af127a9cdb4d41:
+for you to fetch changes up to 397f4e9d83e9c0000905f0a988ba1aeda162571c:
-  qemu-iotests: _cleanup_qemu must be called on exit (2017-04-21 08:32:44 -0400)
+  block/block-copy: hide structure definitions (2020-03-11 12:42:30 +0100)
 ----------------------------------------------------------------
+Block patches for the 5.0 softfreeze:
-Block patches for 2.10
+- qemu-img measure for LUKS
 - Improve block-copy's performance by reducing inter-request
   dependencies
 - Make curl's detection of accept-ranges more robust
 - Memleak fixes
 - iotest fix
 ----------------------------------------------------------------
+David Edmondson (2):
+  block/curl: HTTP header fields allow whitespace around values
+  block/curl: HTTP header field names are case insensitive
-Ashish Mittal (2):
+Eric Blake (1):
-  block/vxhs.c: Add support for a new block device type called "vxhs"
+  iotests: Fix nonportable use of od --endian
   block/vxhs.c: Add qemu-iotests for new block device type "vxhs"
-Jeff Cody (10):
+Pan Nengyuan (2):
-  qemu-iotests: exclude vxhs from image creation via protocol
+  block/qcow2: do free crypto_opts in qcow2_close()
-  block: add bdrv_set_read_only() helper function
+  qemu-img: free memory before re-assign
   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
- block.c                          |  56 +++-
+Stefan Hajnoczi (4):
- block/Makefile.objs              |   2 +
+  luks: extract qcrypto_block_calculate_payload_offset()
- block/bochs.c                    |   5 +-
+  luks: implement .bdrv_measure()
- block/cloop.c                    |   5 +-
+  qemu-img: allow qemu-img measure --object without a filename
- block/dmg.c                      |   6 +-
+  iotests: add 288 luks qemu-img measure test
- block/rbd.c                      |  65 +++--
- block/trace-events               |  17 ++
+Vladimir Sementsov-Ogievskiy (10):
- block/vvfat.c                    |  19 +-
+  block/qcow2-threads: fix qcow2_decompress
- block/vxhs.c                     | 575 +++++++++++++++++++++++++++++++++++++++
+  job: refactor progress to separate object
- configure                        |  39 +++
+  block/block-copy: fix progress calculation
- include/block/block.h            |   2 +
+  block/block-copy: specialcase first copy_range request
- qapi/block-core.json             |  23 +-
+  block/block-copy: use block_status
- tests/qemu-iotests/017           |   1 +
+  block/block-copy: factor out find_conflicting_inflight_req
- tests/qemu-iotests/020           |   1 +
+  block/block-copy: refactor interfaces to use bytes instead of end
- tests/qemu-iotests/028           |   1 +
+  block/block-copy: rename start to offset in interfaces
- tests/qemu-iotests/029           |   1 +
+  block/block-copy: reduce intersecting request lock
- tests/qemu-iotests/073           |   1 +
+  block/block-copy: hide structure definitions
- tests/qemu-iotests/094           |  11 +-
- tests/qemu-iotests/102           |   5 +-
+ block/backup-top.c               |   6 +-
- tests/qemu-iotests/109           |   1 +
+ block/backup.c                   |  38 ++-
- tests/qemu-iotests/114           |   1 +
+ block/block-copy.c               | 405 ++++++++++++++++++++++++-------
- tests/qemu-iotests/117           |   1 +
+ block/crypto.c                   |  62 +++++
- tests/qemu-iotests/130           |   2 +
+ block/curl.c                     |  32 ++-
- tests/qemu-iotests/134           |   1 +
+ block/qcow2-threads.c            |  12 +-
- tests/qemu-iotests/140           |   1 +
+ block/qcow2.c                    |  75 ++----
- tests/qemu-iotests/141           |   1 +
+ block/trace-events               |   1 +
- tests/qemu-iotests/143           |   1 +
+ blockjob.c                       |  16 +-
- tests/qemu-iotests/156           |   2 +
+ crypto/block.c                   |  36 +++
- tests/qemu-iotests/158           |   1 +
+ include/block/block-copy.h       |  65 +----
- tests/qemu-iotests/common        |   6 +
+ include/crypto/block.h           |  22 ++
- tests/qemu-iotests/common.config |  13 +
+ include/qemu/job.h               |  11 +-
- tests/qemu-iotests/common.filter |   1 +
+ include/qemu/progress_meter.h    |  58 +++++
- tests/qemu-iotests/common.rc     |  19 ++
+ job-qmp.c                        |   4 +-
-files changed, 844 insertions(+), 42 deletions(-)
+ job.c                            |   6 +-
- create mode 100644 block/vxhs.c
+ qemu-img.c                       |  14 +-
  tests/qemu-iotests/178           |   2 +-
  tests/qemu-iotests/178.out.qcow2 |   8 +-
  tests/qemu-iotests/178.out.raw   |   8 +-
  tests/qemu-iotests/288           |  93 +++++++
  tests/qemu-iotests/288.out       |  30 +++
  tests/qemu-iotests/common.rc     |  22 +-
  tests/qemu-iotests/group         |   1 +
 files changed, 749 insertions(+), 278 deletions(-)
  create mode 100644 include/qemu/progress_meter.h
  create mode 100755 tests/qemu-iotests/288
  create mode 100644 tests/qemu-iotests/288.out
 --
-.9.3
+.24.1

-New patch
+[PULL 01/19] luks: extract qcrypto_block_calculate_payload_offset()
+From: Stefan Hajnoczi <stefanha@redhat.com>
 The qcow2 .bdrv_measure() code calculates the crypto payload offset.
 This logic really belongs in crypto/block.c where it can be reused by
 other image formats.
 The "luks" block driver will need this same logic in order to implement
 .bdrv_measure(), so extract the qcrypto_block_calculate_payload_offset()
 function now.
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200221112522.1497712-2-stefanha@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block/qcow2.c          | 74 +++++++++++-------------------------------
  crypto/block.c         | 36 ++++++++++++++++++++
  include/crypto/block.h | 22 +++++++++++++
 files changed, 77 insertions(+), 55 deletions(-)
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
      return ret;
  }
 -static ssize_t qcow2_measure_crypto_hdr_init_func(QCryptoBlock *block,
 -        size_t headerlen, void *opaque, Error **errp)
 -{
 -    size_t *headerlenp = opaque;
 -
 -    /* Stash away the payload size */
 -    *headerlenp = headerlen;
 -    return 0;
 -}
 -
 -static ssize_t qcow2_measure_crypto_hdr_write_func(QCryptoBlock *block,
 -        size_t offset, const uint8_t *buf, size_t buflen,
 -        void *opaque, Error **errp)
 -{
 -    /* Discard the bytes, we're not actually writing to an image */
 -    return buflen;
 -}
 -
 -/* Determine the number of bytes for the LUKS payload */
 -static bool qcow2_measure_luks_headerlen(QemuOpts *opts, size_t *len,
 -                                         Error **errp)
 -{
 -    QDict *opts_qdict;
 -    QDict *cryptoopts_qdict;
 -    QCryptoBlockCreateOptions *cryptoopts;
 -    QCryptoBlock *crypto;
 -
 -    /* Extract "encrypt." options into a qdict */
 -    opts_qdict = qemu_opts_to_qdict(opts, NULL);
 -    qdict_extract_subqdict(opts_qdict, &cryptoopts_qdict, "encrypt.");
 -    qobject_unref(opts_qdict);
 -
 -    /* Build QCryptoBlockCreateOptions object from qdict */
 -    qdict_put_str(cryptoopts_qdict, "format", "luks");
 -    cryptoopts = block_crypto_create_opts_init(cryptoopts_qdict, errp);
 -    qobject_unref(cryptoopts_qdict);
 -    if (!cryptoopts) {
 -        return false;
 -    }
 -
 -    /* Fake LUKS creation in order to determine the payload size */
 -    crypto = qcrypto_block_create(cryptoopts, "encrypt.",
 -                                  qcow2_measure_crypto_hdr_init_func,
 -                                  qcow2_measure_crypto_hdr_write_func,
 -                                  len, errp);
 -    qapi_free_QCryptoBlockCreateOptions(cryptoopts);
 -    if (!crypto) {
 -        return false;
 -    }
 -
 -    qcrypto_block_free(crypto);
 -    return true;
 -}
 -
  static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,
                                         Error **errp)
  {
@@ -XXX,XX +XXX,XX @@ static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,
      g_free(optstr);
      if (has_luks) {
 +        g_autoptr(QCryptoBlockCreateOptions) create_opts = NULL;
 +        QDict *opts_qdict;
 +        QDict *cryptoopts;
          size_t headerlen;
 -        if (!qcow2_measure_luks_headerlen(opts, &headerlen, &local_err)) {
 +        opts_qdict = qemu_opts_to_qdict(opts, NULL);
 +        qdict_extract_subqdict(opts_qdict, &cryptoopts, "encrypt.");
 +        qobject_unref(opts_qdict);
 +
 +        qdict_put_str(cryptoopts, "format", "luks");
 +
 +        create_opts = block_crypto_create_opts_init(cryptoopts, errp);
 +        qobject_unref(cryptoopts);
 +        if (!create_opts) {
 +            goto err;
 +        }
 +
 +        if (!qcrypto_block_calculate_payload_offset(create_opts,
 +                                                    "encrypt.",
 +                                                    &headerlen,
 +                                                    &local_err)) {
              goto err;
          }
 diff --git a/crypto/block.c b/crypto/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/crypto/block.c
 +++ b/crypto/block.c
@@ -XXX,XX +XXX,XX @@ QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
  }
 +static ssize_t qcrypto_block_headerlen_hdr_init_func(QCryptoBlock *block,
 +        size_t headerlen, void *opaque, Error **errp)
 +{
 +    size_t *headerlenp = opaque;
 +
 +    /* Stash away the payload size */
 +    *headerlenp = headerlen;
 +    return 0;
 +}
 +
 +
 +static ssize_t qcrypto_block_headerlen_hdr_write_func(QCryptoBlock *block,
 +        size_t offset, const uint8_t *buf, size_t buflen,
 +        void *opaque, Error **errp)
 +{
 +    /* Discard the bytes, we're not actually writing to an image */
 +    return buflen;
 +}
 +
 +
 +bool
 +qcrypto_block_calculate_payload_offset(QCryptoBlockCreateOptions *create_opts,
 +                                       const char *optprefix,
 +                                       size_t *len,
 +                                       Error **errp)
 +{
 +    /* Fake LUKS creation in order to determine the payload size */
 +    g_autoptr(QCryptoBlock) crypto =
 +        qcrypto_block_create(create_opts, optprefix,
 +                             qcrypto_block_headerlen_hdr_init_func,
 +                             qcrypto_block_headerlen_hdr_write_func,
 +                             len, errp);
 +    return crypto != NULL;
 +}
 +
 +
  QCryptoBlockInfo *qcrypto_block_get_info(QCryptoBlock *block,
                                           Error **errp)
  {
 diff --git a/include/crypto/block.h b/include/crypto/block.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/crypto/block.h
 +++ b/include/crypto/block.h
@@ -XXX,XX +XXX,XX @@ QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
                                     Error **errp);
 +/**
 + * qcrypto_block_calculate_payload_offset:
 + * @create_opts: the encryption options
 + * @optprefix: name prefix for options
 + * @len: output for number of header bytes before payload
 + * @errp: pointer to a NULL-initialized error object
 + *
 + * Calculate the number of header bytes before the payload in an encrypted
 + * storage volume.  The header is an area before the payload that is reserved
 + * for encryption metadata.
 + *
 + * Returns: true on success, false on error
 + */
 +bool
 +qcrypto_block_calculate_payload_offset(QCryptoBlockCreateOptions *create_opts,
 +                                       const char *optprefix,
 +                                       size_t *len,
 +                                       Error **errp);
 +
 +
  /**
   * qcrypto_block_get_info:
   * @block: the block encryption object
@@ -XXX,XX +XXX,XX @@ uint64_t qcrypto_block_get_sector_size(QCryptoBlock *block);
  void qcrypto_block_free(QCryptoBlock *block);
  G_DEFINE_AUTOPTR_CLEANUP_FUNC(QCryptoBlock, qcrypto_block_free)
 +G_DEFINE_AUTOPTR_CLEANUP_FUNC(QCryptoBlockCreateOptions,
 +                              qapi_free_QCryptoBlockCreateOptions)
  #endif /* QCRYPTO_BLOCK_H */
 --
 .24.1

-[Qemu-devel] [PULL 05/12] block: do not set BDS read_only if copy_on_read enabled
+[PULL 02/19] luks: implement .bdrv_measure()
-A few block drivers will set the BDS read_only flag from their
+From: Stefan Hajnoczi <stefanha@redhat.com>
 .bdrv_open() function.  This means the bs->read_only flag could
 be set after we enable copy_on_read, as the BDRV_O_COPY_ON_READ
 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
+Add qemu-img measure support in the "luks" block driver.
 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
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-override the drive 'readonly' flag with its own, internal 'rw' flag.
+Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200221112522.1497712-3-stefanha@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block/crypto.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++
 file changed, 62 insertions(+)
-For instance, this -drive parameter would result in a writable image:
+diff --git a/block/crypto.c b/block/crypto.c
 "-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
+--- a/block/crypto.c
-+++ b/block.c
++++ b/block/crypto.c
-@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
+@@ -XXX,XX +XXX,XX @@ static int64_t block_crypto_getlength(BlockDriverState *bs)
      }
  }
--void bdrv_set_read_only(BlockDriverState *bs, bool read_only)
-+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
++static BlockMeasureInfo *block_crypto_measure(QemuOpts *opts,
- {
++                                              BlockDriverState *in_bs,
-+    /* Do not set read_only if copy_on_read is enabled */
++                                              Error **errp)
-+    if (bs->copy_on_read && read_only) {
++{
-+        error_setg(errp, "Can't set node '%s' to r/o with copy-on-read enabled",
++    g_autoptr(QCryptoBlockCreateOptions) create_opts = NULL;
-+                   bdrv_get_device_or_node_name(bs));
++    Error *local_err = NULL;
-+        return -EINVAL;
++    BlockMeasureInfo *info;
 +    uint64_t size;
 +    size_t luks_payload_size;
 +    QDict *cryptoopts;
 +
 +    /*
 +     * Preallocation mode doesn't affect size requirements but we must consume
 +     * the option.
 +     */
 +    g_free(qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC));
 +
 +    size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
 +
 +    if (in_bs) {
 +        int64_t ssize = bdrv_getlength(in_bs);
 +
 +        if (ssize < 0) {
 +            error_setg_errno(&local_err, -ssize,
 +                             "Unable to get image virtual_size");
 +            goto err;
 +        }
 +
 +        size = ssize;
 +    }
 +
-     bs->read_only = read_only;
++    cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL,
-+    return 0;
++            &block_crypto_create_opts_luks, true);
- }
++    qdict_put_str(cryptoopts, "format", "luks");
++    create_opts = block_crypto_create_opts_init(cryptoopts, &local_err);
- void bdrv_get_full_backing_filename_from_filename(const char *backed,
++    qobject_unref(cryptoopts);
-diff --git a/block/bochs.c b/block/bochs.c
++    if (!create_opts) {
-index XXXXXXX..XXXXXXX 100644
++        goto err;
 --- 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");
++    if (!qcrypto_block_calculate_payload_offset(create_opts, NULL,
--    bdrv_set_read_only(bs, true);
++                                                &luks_payload_size,
++                                                &local_err)) {
-     s->n_chunks = 0;
++        goto err;
      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;
++     * Unallocated blocks are still encrypted so allocation status makes no
-diff --git a/block/vvfat.c b/block/vvfat.c
++     * difference to the file size.
-index XXXXXXX..XXXXXXX 100644
++     */
---- a/block/vvfat.c
++    info = g_new(BlockMeasureInfo, 1);
-+++ b/block/vvfat.c
++    info->fully_allocated = luks_payload_size + size;
-@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
++    info->required = luks_payload_size + size;
++    return info;
-     s->current_cluster=0xffffffff;
++
++err:
--    /* read only is the default for safety */
++    error_propagate(errp, local_err);
--    bdrv_set_read_only(bs, true);
++    return NULL;
-     s->qcow = NULL;
++}
-     s->qcow_filename = NULL;
++
-     s->fat2 = NULL;
++
-@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
+ static int block_crypto_probe_luks(const uint8_t *buf,
-     s->sector_count = cyls * heads * secs - (s->first_sectors_number - 1);
+                                    int buf_size,
+                                    const char *filename) {
-     if (qemu_opt_get_bool(opts, "rw", false)) {
+@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_crypto_luks = {
--        ret = enable_write_target(bs, errp);
+     .bdrv_co_preadv     = block_crypto_co_preadv,
-+        if (!bdrv_is_read_only(bs)) {
+     .bdrv_co_pwritev    = block_crypto_co_pwritev,
-+            ret = enable_write_target(bs, errp);
+     .bdrv_getlength     = block_crypto_getlength,
-+            if (ret < 0) {
++    .bdrv_measure       = block_crypto_measure,
-+                goto fail;
+     .bdrv_get_info      = block_crypto_get_info_luks,
-+            }
+     .bdrv_get_specific_info = block_crypto_get_specific_info_luks,
-+        } 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
+.24.1

-[Qemu-devel] [PULL 10/12] block/rbd - update variable names to more apt names
+[PULL 03/19] qemu-img: allow qemu-img measure --object without a filename
-Update 'clientname' to be 'user', which tracks better with both
+From: Stefan Hajnoczi <stefanha@redhat.com>
 the QAPI and rados variable naming.
-Update 'name' to be 'image_name', as it indicates the rbd image.
+In most qemu-img sub-commands the --object option only makes sense when
-Naming it 'image' would have been ideal, but we are using that for
+there is a filename.  qemu-img measure is an exception because objects
-the rados_image_t value returned by rbd_open().
+may be referenced from the image creation options instead of an existing
 image file.  Allow --object without a filename.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Reviewed-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+Message-Id: <20200221112522.1497712-4-stefanha@redhat.com>
-Message-id: b7ec1fb2e1cf36f9b6911631447a5b0422590b7d.1491597120.git.jcody@redhat.com
+Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block/rbd.c | 33 +++++++++++++++++----------------
+ qemu-img.c                       | 6 ++----
-file changed, 17 insertions(+), 16 deletions(-)
+ tests/qemu-iotests/178           | 2 +-
  tests/qemu-iotests/178.out.qcow2 | 8 ++++----
  tests/qemu-iotests/178.out.raw   | 8 ++++----
 files changed, 11 insertions(+), 13 deletions(-)
-diff --git a/block/rbd.c b/block/rbd.c
+diff --git a/qemu-img.c b/qemu-img.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/rbd.c
+--- a/qemu-img.c
-+++ b/block/rbd.c
++++ b/qemu-img.c
-@@ -XXX,XX +XXX,XX @@ typedef struct BDRVRBDState {
+@@ -XXX,XX +XXX,XX @@ static int img_measure(int argc, char **argv)
-     rados_t cluster;
+         filename = argv[optind];
      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);
+-    if (!filename &&
-+    ret = rbd_create(io_ctx, image_name, bytes, &obj_order);
+-        (object_opts || image_opts || fmt || snapshot_name || sn_opts)) {
-     if (ret < 0) {
+-        error_report("--object, --image-opts, -f, and -l "
-         error_setg_errno(errp, -ret, "error rbd create");
+-                     "require a filename argument.");
 +    if (!filename && (image_opts || fmt || snapshot_name || sn_opts)) {
 +        error_report("--image-opts, -f, and -l require a filename argument.");
          goto out;
      }
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
+     if (filename && img_size != UINT64_MAX) {
-                          Error **errp)
+diff --git a/tests/qemu-iotests/178 b/tests/qemu-iotests/178
- {
+index XXXXXXX..XXXXXXX 100755
-     BDRVRBDState *s = bs->opaque;
+--- a/tests/qemu-iotests/178
--    const char *pool, *snap, *conf, *clientname, *name, *keypairs;
++++ b/tests/qemu-iotests/178
-+    const char *pool, *snap, *conf, *user, *image_name, *keypairs;
+@@ -XXX,XX +XXX,XX @@ _make_test_img 1G
-     const char *secretid;
+ $QEMU_IMG measure # missing arguments
-     QemuOpts *opts;
+ $QEMU_IMG measure --size 2G "$TEST_IMG" # only one allowed
-     Error *local_err = NULL;
+ $QEMU_IMG measure "$TEST_IMG" a # only one filename allowed
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
+-$QEMU_IMG measure --object secret,id=sec0,data=MTIzNDU2,format=base64 # missing filename
-     pool           = qemu_opt_get(opts, "pool");
++$QEMU_IMG measure --object secret,id=sec0,data=MTIzNDU2,format=base64 # size or filename needed
-     conf           = qemu_opt_get(opts, "conf");
+ $QEMU_IMG measure --image-opts # missing filename
-     snap           = qemu_opt_get(opts, "snapshot");
+ $QEMU_IMG measure -f qcow2 # missing filename
--    clientname     = qemu_opt_get(opts, "user");
+ $QEMU_IMG measure -l snap1 # missing filename
--    name           = qemu_opt_get(opts, "image");
+diff --git a/tests/qemu-iotests/178.out.qcow2 b/tests/qemu-iotests/178.out.qcow2
-+    user           = qemu_opt_get(opts, "user");
+index XXXXXXX..XXXXXXX 100644
-+    image_name     = qemu_opt_get(opts, "image");
+--- a/tests/qemu-iotests/178.out.qcow2
-     keypairs       = qemu_opt_get(opts, "=keyvalue-pairs");
++++ b/tests/qemu-iotests/178.out.qcow2
+@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
--    if (!pool || !name) {
+ qemu-img: Either --size N or one filename must be specified.
-+    if (!pool || !image_name) {
+ qemu-img: --size N cannot be used together with a filename.
-         error_setg(errp, "Parameters 'pool' and 'image' are required");
+ qemu-img: At most one filename argument is allowed.
-         r = -EINVAL;
+-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
-         goto failed_opts;
+-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
-     }
+-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
+-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
--    r = rados_create(&s->cluster, clientname);
++qemu-img: Either --size N or one filename must be specified.
-+    r = rados_create(&s->cluster, user);
++qemu-img: --image-opts, -f, and -l require a filename argument.
-     if (r < 0) {
++qemu-img: --image-opts, -f, and -l require a filename argument.
-         error_setg_errno(errp, -r, "error initializing");
++qemu-img: --image-opts, -f, and -l require a filename argument.
-         goto failed_opts;
+ qemu-img: Invalid option list: ,
-     }
+ qemu-img: Invalid parameter 'snapshot.foo'
+ qemu-img: Failed in parsing snapshot param 'snapshot.foo'
-     s->snap = g_strdup(snap);
+diff --git a/tests/qemu-iotests/178.out.raw b/tests/qemu-iotests/178.out.raw
--    s->name = g_strdup(name);
+index XXXXXXX..XXXXXXX 100644
-+    s->image_name = g_strdup(image_name);
+--- a/tests/qemu-iotests/178.out.raw
++++ b/tests/qemu-iotests/178.out.raw
-     /* try default location when conf=NULL, but ignore failure */
+@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
-     r = rados_conf_read_file(s->cluster, conf);
+ qemu-img: Either --size N or one filename must be specified.
-@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
+ qemu-img: --size N cannot be used together with a filename.
-     }
+ qemu-img: At most one filename argument is allowed.
+-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
-     /* rbd_open is always r/w */
+-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
--    r = rbd_open(s->io_ctx, s->name, &s->image, s->snap);
+-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
-+    r = rbd_open(s->io_ctx, s->image_name, &s->image, s->snap);
+-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
-     if (r < 0) {
++qemu-img: Either --size N or one filename must be specified.
--        error_setg_errno(errp, -r, "error reading header from %s", s->name);
++qemu-img: --image-opts, -f, and -l require a filename argument.
-+        error_setg_errno(errp, -r, "error reading header from %s",
++qemu-img: --image-opts, -f, and -l require a filename argument.
-+                         s->image_name);
++qemu-img: --image-opts, -f, and -l require a filename argument.
-         goto failed_open;
+ qemu-img: Invalid option list: ,
-     }
+ qemu-img: Invalid parameter 'snapshot.foo'
+ qemu-img: Failed in parsing snapshot param 'snapshot.foo'
@@ -XXX,XX +XXX,XX @@ failed_open:
  failed_shutdown:
      rados_shutdown(s->cluster);
      g_free(s->snap);
 -    g_free(s->name);
 +    g_free(s->image_name);
  failed_opts:
      qemu_opts_del(opts);
      g_free(mon_host);
@@ -XXX,XX +XXX,XX @@ static void qemu_rbd_close(BlockDriverState *bs)
      rbd_close(s->image);
      rados_ioctx_destroy(s->io_ctx);
      g_free(s->snap);
 -    g_free(s->name);
 +    g_free(s->image_name);
      rados_shutdown(s->cluster);
  }
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 12/12] qemu-iotests: _cleanup_qemu must be called on exit
+[PULL 04/19] iotests: add 288 luks qemu-img measure test
-For the tests that use the common.qemu functions for running a QEMU
+From: Stefan Hajnoczi <stefanha@redhat.com>
 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
+This test exercises the block/crypto.c "luks" block driver
-are cleaned up (e.g. pidfile, fifos).
+.bdrv_measure() code.
-This updates those tests that did not have a cleanup in qemu-iotests.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200221112522.1497712-5-stefanha@redhat.com>
 [mreitz: Renamed test from 282 to 288]
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  tests/qemu-iotests/288     | 93 ++++++++++++++++++++++++++++++++++++++
  tests/qemu-iotests/288.out | 30 ++++++++++++
  tests/qemu-iotests/group   |  1 +
 files changed, 124 insertions(+)
  create mode 100755 tests/qemu-iotests/288
  create mode 100644 tests/qemu-iotests/288.out
-(I swapped spaces for tabs in test 102 as well)
+diff --git a/tests/qemu-iotests/288 b/tests/qemu-iotests/288
+new file mode 100755
-Reported-by: Eric Blake <eblake@redhat.com>
+index XXXXXXX..XXXXXXX
-Reviewed-by: Eric Blake <eblake@redhat.com>
+--- /dev/null
-Signed-off-by: Jeff Cody <jcody@redhat.com>
++++ b/tests/qemu-iotests/288
-Message-id: d59c2f6ad6c1da8b9b3c7f357c94a7122ccfc55a.1492544096.git.jcody@redhat.com
+@@ -XXX,XX +XXX,XX @@
----
++#!/usr/bin/env bash
- tests/qemu-iotests/028 |  1 +
++#
- tests/qemu-iotests/094 | 11 ++++++++---
++# qemu-img measure tests for LUKS images
- tests/qemu-iotests/102 |  5 +++--
++#
- tests/qemu-iotests/109 |  1 +
++# Copyright (C) 2020 Red Hat, Inc.
- tests/qemu-iotests/117 |  1 +
++#
- tests/qemu-iotests/130 |  1 +
++# This program is free software; you can redistribute it and/or modify
- tests/qemu-iotests/140 |  1 +
++# it under the terms of the GNU General Public License as published by
- tests/qemu-iotests/141 |  1 +
++# the Free Software Foundation; either version 2 of the License, or
- tests/qemu-iotests/143 |  1 +
++# (at your option) any later version.
- tests/qemu-iotests/156 |  1 +
++#
-files changed, 19 insertions(+), 5 deletions(-)
++# This program is distributed in the hope that it will be useful,
++# but WITHOUT ANY WARRANTY; without even the implied warranty of
-diff --git a/tests/qemu-iotests/028 b/tests/qemu-iotests/028
++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-index XXXXXXX..XXXXXXX 100755
++# GNU General Public License for more details.
---- a/tests/qemu-iotests/028
++#
-+++ b/tests/qemu-iotests/028
++# You should have received a copy of the GNU General Public License
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
++# along with this program.  If not, see <http://www.gnu.org/licenses/>.
++#
- _cleanup()
++
- {
++# creator
-+    _cleanup_qemu
++owner=stefanha@redhat.com
-     rm -f "${TEST_IMG}.copy"
++
-     _cleanup_test_img
++seq=`basename $0`
- }
++echo "QA output created by $seq"
-diff --git a/tests/qemu-iotests/094 b/tests/qemu-iotests/094
++
-index XXXXXXX..XXXXXXX 100755
++status=1    # failure is the default!
---- 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"
++    rm -f "$TEST_IMG.converted"
 +}
++trap "_cleanup; exit \$status" 0 1 2 3 15
 +
-+trap "_cleanup; exit \$status" 0 1 2 3 15
++# get standard environment, filters and checks
++. ./common.rc
- # get standard environment, filters and checks
++. ./common.filter
- . ./common.rc
++. ./common.pattern
-@@ -XXX,XX +XXX,XX @@ _send_qemu_cmd $QEMU_HANDLE \
++
++_supported_fmt luks
- wait=1 _cleanup_qemu
++_supported_proto file
++_supported_os Linux
--_cleanup_test_img
++
--rm -f "$TEST_DIR/source.$IMGFMT"
++SECRET=secret,id=sec0,data=passphrase
++
- # success, all done
++echo "== measure 1G image file =="
- echo '*** done'
++echo
-diff --git a/tests/qemu-iotests/102 b/tests/qemu-iotests/102
++
-index XXXXXXX..XXXXXXX 100755
++$QEMU_IMG measure --object "$SECRET" \
---- a/tests/qemu-iotests/102
++              -O "$IMGFMT" \
-+++ b/tests/qemu-iotests/102
++          -o key-secret=sec0,iter-time=10 \
-@@ -XXX,XX +XXX,XX @@ seq=$(basename $0)
++          --size 1G
- echo "QA output created by $seq"
++
++echo
- here=$PWD
++echo "== create 1G image file (size should be no greater than measured) =="
--status=1    # failure is the default!
++echo
-+status=1    # failure is the default!
++
++_make_test_img 1G
- _cleanup()
++stat -c "image file size in bytes: %s" "$TEST_IMG_FILE"
- {
++
--    _cleanup_test_img
++echo
-+    _cleanup_qemu
++echo "== modified 1G image file (size should be no greater than measured) =="
-+    _cleanup_test_img
++echo
- }
++
- trap "_cleanup; exit \$status" 0 1 2 3 15
++$QEMU_IO --object "$SECRET" --image-opts "$TEST_IMG" -c "write -P 0x51 0x10000 0x400" | _filter_qemu_io | _filter_testdir
++stat -c "image file size in bytes: %s" "$TEST_IMG_FILE"
-diff --git a/tests/qemu-iotests/109 b/tests/qemu-iotests/109
++
-index XXXXXXX..XXXXXXX 100755
++echo
---- a/tests/qemu-iotests/109
++echo "== measure preallocation=falloc 1G image file =="
-+++ b/tests/qemu-iotests/109
++echo
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
++
++$QEMU_IMG measure --object "$SECRET" \
- _cleanup()
++              -O "$IMGFMT" \
- {
++          -o key-secret=sec0,iter-time=10,preallocation=falloc \
-+    _cleanup_qemu
++          --size 1G
-     rm -f $TEST_IMG.src
++
-     _cleanup_test_img
++echo
- }
++echo "== measure with input image file =="
-diff --git a/tests/qemu-iotests/117 b/tests/qemu-iotests/117
++echo
-index XXXXXXX..XXXXXXX 100755
++
---- a/tests/qemu-iotests/117
++IMGFMT=raw IMGKEYSECRET= IMGOPTS= _make_test_img 1G | _filter_imgfmt
-+++ b/tests/qemu-iotests/117
++QEMU_IO_OPTIONS= IMGOPTSSYNTAX= $QEMU_IO -f raw -c "write -P 0x51 0x10000 0x400" "$TEST_IMG_FILE" | _filter_qemu_io | _filter_testdir
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
++$QEMU_IMG measure --object "$SECRET" \
++              -O "$IMGFMT" \
- _cleanup()
++          -o key-secret=sec0,iter-time=10 \
- {
++          -f raw \
-+    _cleanup_qemu
++          "$TEST_IMG_FILE"
-     _cleanup_test_img
++
- }
++# success, all done
- trap "_cleanup; exit \$status" 0 1 2 3 15
++echo "*** done"
-diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
++rm -f $seq.full
-index XXXXXXX..XXXXXXX 100755
++status=0
---- a/tests/qemu-iotests/130
+diff --git a/tests/qemu-iotests/288.out b/tests/qemu-iotests/288.out
-+++ b/tests/qemu-iotests/130
+new file mode 100644
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
+index XXXXXXX..XXXXXXX
+--- /dev/null
- _cleanup()
++++ b/tests/qemu-iotests/288.out
- {
+@@ -XXX,XX +XXX,XX @@
-+    _cleanup_qemu
++QA output created by 288
-     _cleanup_test_img
++== measure 1G image file ==
- }
++
- trap "_cleanup; exit \$status" 0 1 2 3 15
++required size: 1075810304
-diff --git a/tests/qemu-iotests/140 b/tests/qemu-iotests/140
++fully allocated size: 1075810304
-index XXXXXXX..XXXXXXX 100755
++
---- a/tests/qemu-iotests/140
++== create 1G image file (size should be no greater than measured) ==
-+++ b/tests/qemu-iotests/140
++
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
++image file size in bytes: 1075810304
- _cleanup()
++
- {
++== modified 1G image file (size should be no greater than measured) ==
-+    _cleanup_qemu
++
-     _cleanup_test_img
++wrote 1024/1024 bytes at offset 65536
-     rm -f "$TEST_DIR/nbd"
++1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- }
++image file size in bytes: 1075810304
-diff --git a/tests/qemu-iotests/141 b/tests/qemu-iotests/141
++
-index XXXXXXX..XXXXXXX 100755
++== measure preallocation=falloc 1G image file ==
---- a/tests/qemu-iotests/141
++
-+++ b/tests/qemu-iotests/141
++required size: 1075810304
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
++fully allocated size: 1075810304
++
- _cleanup()
++== measure with input image file ==
- {
++
-+    _cleanup_qemu
++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
-     _cleanup_test_img
++wrote 1024/1024 bytes at offset 65536
-     rm -f "$TEST_DIR/{b,m,o}.$IMGFMT"
++1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- }
++required size: 1075810304
-diff --git a/tests/qemu-iotests/143 b/tests/qemu-iotests/143
++fully allocated size: 1075810304
-index XXXXXXX..XXXXXXX 100755
++*** done
---- a/tests/qemu-iotests/143
+diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
-+++ b/tests/qemu-iotests/143
+index XXXXXXX..XXXXXXX 100644
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
+--- a/tests/qemu-iotests/group
++++ b/tests/qemu-iotests/group
- _cleanup()
+@@ -XXX,XX +XXX,XX @@
- {
+auto quick
-+    _cleanup_qemu
+rw
-     rm -f "$TEST_DIR/nbd"
+rw quick
- }
++288 quick
  trap "_cleanup; exit \$status" 0 1 2 3 15
 diff --git a/tests/qemu-iotests/156 b/tests/qemu-iotests/156
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/156
 +++ b/tests/qemu-iotests/156
@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
  _cleanup()
  {
 +    _cleanup_qemu
      rm -f "$TEST_IMG{,.target}{,.backing,.overlay}"
  }
  trap "_cleanup; exit \$status" 0 1 2 3 15
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 06/12] block: honor BDRV_O_ALLOW_RDWR when clearing bs->read_only
+[PULL 05/19] block/curl: HTTP header fields allow whitespace around values
-The BDRV_O_ALLOW_RDWR flag allows / prohibits the changing of
+From: David Edmondson <david.edmondson@oracle.com>
 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>
+RFC 7230 section 3.2 indicates that whitespace is permitted between
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+the field name and field value and after the field value.
-Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: be2e5fb2d285cbece2b6d06bed54a6f56520d251.1491597120.git.jcody@redhat.com
+Signed-off-by: David Edmondson <david.edmondson@oracle.com>
 Message-Id: <20200224101310.101169-2-david.edmondson@oracle.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block.c | 7 +++++++
+ block/curl.c | 31 +++++++++++++++++++++++++++----
-file changed, 7 insertions(+)
+file changed, 27 insertions(+), 4 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/block/curl.c b/block/curl.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/block/curl.c
-+++ b/block.c
++++ b/block/curl.c
-@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static size_t curl_header_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
-         return -EINVAL;
+ {
      BDRVCURLState *s = opaque;
      size_t realsize = size * nmemb;
 -    const char *accept_line = "Accept-Ranges: bytes";
 +    const char *header = (char *)ptr;
 +    const char *end = header + realsize;
 +    const char *accept_ranges = "Accept-Ranges:";
 +    const char *bytes = "bytes";
 -    if (realsize >= strlen(accept_line)
 -        && strncmp((char *)ptr, accept_line, strlen(accept_line)) == 0) {
 -        s->accept_range = true;
 +    if (realsize >= strlen(accept_ranges)
 +        && strncmp(header, accept_ranges, strlen(accept_ranges)) == 0) {
 +
 +        char *p = strchr(header, ':') + 1;
 +
 +        /* Skip whitespace between the header name and value. */
 +        while (p < end && *p && g_ascii_isspace(*p)) {
 +            p++;
 +        }
 +
 +        if (end - p >= strlen(bytes)
 +            && strncmp(p, bytes, strlen(bytes)) == 0) {
 +
 +            /* Check that there is nothing but whitespace after the value. */
 +            p += strlen(bytes);
 +            while (p < end && *p && g_ascii_isspace(*p)) {
 +                p++;
 +            }
 +
 +            if (p == end || !*p) {
 +                s->accept_range = true;
 +            }
 +        }
      }
-+    /* Do not clear read_only if it is prohibited */
+     return realsize;
 +    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
+.24.1

-[Qemu-devel] [PULL 03/12] qemu-iotests: exclude vxhs from image creation via protocol
+[PULL 06/19] block/curl: HTTP header field names are case insensitive
-The protocol VXHS does not support image creation.  Some tests expect
+From: David Edmondson <david.edmondson@oracle.com>
 to be able to create images through the protocol.  Exclude VXHS from
 these tests.
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+RFC 7230 section 3.2 indicates that HTTP header field names are case
 insensitive.
 Signed-off-by: David Edmondson <david.edmondson@oracle.com>
 Message-Id: <20200224101310.101169-3-david.edmondson@oracle.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- tests/qemu-iotests/017 | 1 +
+ block/curl.c | 5 +++--
- tests/qemu-iotests/020 | 1 +
+file changed, 3 insertions(+), 2 deletions(-)
  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
+diff --git a/block/curl.c b/block/curl.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/017
+--- a/block/curl.c
-+++ b/tests/qemu-iotests/017
++++ b/block/curl.c
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+@@ -XXX,XX +XXX,XX @@ static size_t curl_header_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
- # Any format supporting backing files
+     size_t realsize = size * nmemb;
- _supported_fmt qcow qcow2 vmdk qed
+     const char *header = (char *)ptr;
- _supported_proto generic
+     const char *end = header + realsize;
-+_unsupported_proto vxhs
+-    const char *accept_ranges = "Accept-Ranges:";
- _supported_os Linux
++    const char *accept_ranges = "accept-ranges:";
- _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
+     const char *bytes = "bytes";
-diff --git a/tests/qemu-iotests/020 b/tests/qemu-iotests/020
+     if (realsize >= strlen(accept_ranges)
-index XXXXXXX..XXXXXXX 100755
+-        && strncmp(header, accept_ranges, strlen(accept_ranges)) == 0) {
---- a/tests/qemu-iotests/020
++        && g_ascii_strncasecmp(header, accept_ranges,
-+++ b/tests/qemu-iotests/020
++                               strlen(accept_ranges)) == 0) {
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- # Any format supporting backing files
+         char *p = strchr(header, ':') + 1;
  _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
+.24.1

-[Qemu-devel] [PULL 02/12] block/vxhs.c: Add qemu-iotests for new block device type "vxhs"
+[PULL 07/19] iotests: Fix nonportable use of od --endian
-From: Ashish Mittal <ashmit602@gmail.com>
+From: Eric Blake <eblake@redhat.com>
-These changes use a vxhs test server that is a part of the following
+Tests 261 and 272 fail on RHEL 7 with coreutils 8.22, since od
-repository:
+--endian was not added until coreutils 8.23.  Fix this by manually
-https://github.com/VeritasHyperScale/libqnio.git
+constructing the final value one byte at a time.
-Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
+Fixes: fc8ba423
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reported-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
-Reviewed-by: Jeff Cody <jcody@redhat.com>
+Signed-off-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Reviewed-by: Max Reitz <mreitz@redhat.com>
-Message-id: 1491277689-24949-3-git-send-email-Ashish.Mittal@veritas.com
+Message-Id: <20200226125424.481840-1-eblake@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- tests/qemu-iotests/common        |  6 ++++++
+ tests/qemu-iotests/common.rc | 22 +++++++++++++++++-----
- tests/qemu-iotests/common.config | 13 +++++++++++++
+file changed, 17 insertions(+), 5 deletions(-)
  tests/qemu-iotests/common.filter |  1 +
  tests/qemu-iotests/common.rc     | 19 +++++++++++++++++++
 files changed, 39 insertions(+)
-diff --git a/tests/qemu-iotests/common b/tests/qemu-iotests/common
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common
-+++ b/tests/qemu-iotests/common
-@@ -XXX,XX +XXX,XX @@ check options
-     -ssh                test ssh
-     -nfs                test nfs
-     -luks               test luks
-+    -vxhs               test vxhs
-     -xdiff              graphical mode diff
-     -nocache            use O_DIRECT on backing file
-     -misalign           misalign memory allocations
-@@ -XXX,XX +XXX,XX @@ testlist options
-             xpand=false
-             ;;
-+        -vxhs)
-+            IMGPROTO=vxhs
-+            xpand=false
-+            ;;
-+
-         -ssh)
-             IMGPROTO=ssh
-             xpand=false
-diff --git a/tests/qemu-iotests/common.config b/tests/qemu-iotests/common.config
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.config
-+++ b/tests/qemu-iotests/common.config
-@@ -XXX,XX +XXX,XX @@ if [ -z "$QEMU_NBD_PROG" ]; then
-     export QEMU_NBD_PROG="`set_prog_path qemu-nbd`"
- fi
-+if [ -z "$QEMU_VXHS_PROG" ]; then
-+    export QEMU_VXHS_PROG="`set_prog_path qnio_server`"
-+fi
-+
- _qemu_wrapper()
- {
-     (
-@@ -XXX,XX +XXX,XX @@ _qemu_nbd_wrapper()
-     )
- }
-+_qemu_vxhs_wrapper()
-+{
-+    (
-+        echo $BASHPID > "${TEST_DIR}/qemu-vxhs.pid"
-+        exec "$QEMU_VXHS_PROG" $QEMU_VXHS_OPTIONS "$@"
-+    )
-+}
-+
- export QEMU=_qemu_wrapper
- export QEMU_IMG=_qemu_img_wrapper
- export QEMU_IO=_qemu_io_wrapper
- export QEMU_NBD=_qemu_nbd_wrapper
-+export QEMU_VXHS=_qemu_vxhs_wrapper
- QEMU_IMG_EXTRA_ARGS=
- if [ "$IMGOPTSSYNTAX" = "true" ]; then
-diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.filter
-+++ b/tests/qemu-iotests/common.filter
-@@ -XXX,XX +XXX,XX @@ _filter_img_info()
-         -e "s#$TEST_DIR#TEST_DIR#g" \
-         -e "s#$IMGFMT#IMGFMT#g" \
-         -e 's#nbd://127.0.0.1:10810$#TEST_DIR/t.IMGFMT#g' \
-+        -e 's#json.*vdisk-id.*vxhs"}}#TEST_DIR/t.IMGFMT#' \
-         -e "/encrypted: yes/d" \
-         -e "/cluster_size: [0-9]\\+/d" \
-         -e "/table_size: [0-9]\\+/d" \
 diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/common.rc
 +++ b/tests/qemu-iotests/common.rc
-@@ -XXX,XX +XXX,XX @@ else
+@@ -XXX,XX +XXX,XX @@ poke_file()
-     elif [ "$IMGPROTO" = "nfs" ]; then
+ # peek_file_le 'test.img' 512 2 => 65534
-         TEST_DIR="nfs://127.0.0.1/$TEST_DIR"
+ peek_file_le()
-         TEST_IMG=$TEST_DIR/t.$IMGFMT
+ {
-+    elif [ "$IMGPROTO" = "vxhs" ]; then
+-    # Wrap in echo $() to strip spaces
-+        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
+-    echo $(od -j"$2" -N"$3" --endian=little -An -vtu"$3" "$1")
-+        TEST_IMG="vxhs://127.0.0.1:9999/t.$IMGFMT"
++    local val=0 shift=0 byte
      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
++    # coreutils' od --endian is not portable, so manually assemble bytes.
-+    if [ $IMGPROTO = "vxhs" ]; then
++    for byte in $(od -j"$2" -N"$3" -An -v -tu1 "$1"); do
-+        eval "$QEMU_VXHS -d  $TEST_DIR > /dev/null &"
++        val=$(( val | (byte << shift) ))
-+        sleep 1 # Wait for server to come up.
++        shift=$((shift + 8))
-+    fi
++    done
 +    printf %llu $val
  }
- _rm_test_img()
+ # peek_file_be 'test.img' 512 2 => 65279
-@@ -XXX,XX +XXX,XX @@ _cleanup_test_img()
+ peek_file_be()
-             fi
+ {
-             rm -f "$TEST_IMG_FILE"
+-    # Wrap in echo $() to strip spaces
-             ;;
+-    echo $(od -j"$2" -N"$3" --endian=big -An -vtu"$3" "$1")
-+        vxhs)
++    local val=0 byte
 +            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)
++    # coreutils' od --endian is not portable, so manually assemble bytes.
-             _rm_test_img "$TEST_DIR/t.$IMGFMT"
++    for byte in $(od -j"$2" -N"$3" -An -v -tu1 "$1"); do
-             _rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
++        val=$(( (val << 8) | byte ))
 +    done
 +    printf %llu $val
  }
 -# peek_file_raw 'test.img' 512 2 => '\xff\xfe'
 +# peek_file_raw 'test.img' 512 2 => '\xff\xfe'. Do not use if the raw data
 +# is likely to contain \0 or trailing \n.
  peek_file_raw()
  {
      dd if="$1" bs=1 skip="$2" count="$3" status=none
 --
-.9.3
+.24.1

-New patch
+[PULL 08/19] block/qcow2: do free crypto_opts in qcow2_close()
+From: Pan Nengyuan <pannengyuan@huawei.com>
+'crypto_opts' forgot to free in qcow2_close(), this patch fix the bellow leak stack:
+Direct leak of 24 byte(s) in 1 object(s) allocated from:
+    #0 0x7f0edd81f970 in __interceptor_calloc (/lib64/libasan.so.5+0xef970)
+    #1 0x7f0edc6d149d in g_malloc0 (/lib64/libglib-2.0.so.0+0x5249d)
+    #2 0x55d7eaede63d in qobject_input_start_struct /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qobject-input-visitor.c:295
+    #3 0x55d7eaed78b8 in visit_start_struct /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qapi-visit-core.c:49
+    #4 0x55d7eaf5140b in visit_type_QCryptoBlockOpenOptions qapi/qapi-visit-crypto.c:290
+    #5 0x55d7eae43af3 in block_crypto_open_opts_init /mnt/sdb/qemu-new/qemu_test/qemu/block/crypto.c:163
+    #6 0x55d7eacd2924 in qcow2_update_options_prepare /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:1148
+    #7 0x55d7eacd33f7 in qcow2_update_options /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:1232
+    #8 0x55d7eacd9680 in qcow2_do_open /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:1512
+    #9 0x55d7eacdc55e in qcow2_open_entry /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:1792
+    #10 0x55d7eacdc8fe in qcow2_open /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:1819
+    #11 0x55d7eac3742d in bdrv_open_driver /mnt/sdb/qemu-new/qemu_test/qemu/block.c:1317
+    #12 0x55d7eac3e990 in bdrv_open_common /mnt/sdb/qemu-new/qemu_test/qemu/block.c:1575
+    #13 0x55d7eac4442c in bdrv_open_inherit /mnt/sdb/qemu-new/qemu_test/qemu/block.c:3126
+    #14 0x55d7eac45c3f in bdrv_open /mnt/sdb/qemu-new/qemu_test/qemu/block.c:3219
+    #15 0x55d7ead8e8a4 in blk_new_open /mnt/sdb/qemu-new/qemu_test/qemu/block/block-backend.c:397
+    #16 0x55d7eacde74c in qcow2_co_create /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:3534
+    #17 0x55d7eacdfa6d in qcow2_co_create_opts /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:3668
+    #18 0x55d7eac1c678 in bdrv_create_co_entry /mnt/sdb/qemu-new/qemu_test/qemu/block.c:485
+    #19 0x55d7eb0024d2 in coroutine_trampoline /mnt/sdb/qemu-new/qemu_test/qemu/util/coroutine-ucontext.c:115
+Reported-by: Euler Robot <euler.robot@huawei.com>
+Signed-off-by: Pan Nengyuan <pannengyuan@huawei.com>
+Reviewed-by: Max Reitz <mreitz@redhat.com>
+Message-Id: <20200227012950.12256-2-pannengyuan@huawei.com>
+Signed-off-by: Max Reitz <mreitz@redhat.com>
+---
+ block/qcow2.c | 1 +
+file changed, 1 insertion(+)
+diff --git a/block/qcow2.c b/block/qcow2.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2.c
++++ b/block/qcow2.c
+@@ -XXX,XX +XXX,XX @@ static void qcow2_close(BlockDriverState *bs)
+     qcrypto_block_free(s->crypto);
+     s->crypto = NULL;
++    qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
+     g_free(s->unknown_header_fields);
+     cleanup_unknown_header_ext(bs);
+--
+.24.1

-New patch
+[PULL 09/19] qemu-img: free memory before re-assign
+From: Pan Nengyuan <pannengyuan@huawei.com>
+collect_image_check() is called twice in img_check(), the filename/format will be alloced without free the original memory.
+It is not a big deal since the process will exit anyway, but seems like a clean code and it will remove the warning spotted by asan.
+Reported-by: Euler Robot <euler.robot@huawei.com>
+Signed-off-by: Pan Nengyuan <pannengyuan@huawei.com>
+Message-Id: <20200227012950.12256-3-pannengyuan@huawei.com>
+Signed-off-by: Max Reitz <mreitz@redhat.com>
+---
+ qemu-img.c | 2 ++
+file changed, 2 insertions(+)
+diff --git a/qemu-img.c b/qemu-img.c
+index XXXXXXX..XXXXXXX 100644
+--- a/qemu-img.c
++++ b/qemu-img.c
+@@ -XXX,XX +XXX,XX @@ static int img_check(int argc, char **argv)
+                     check->corruptions_fixed);
+         }
++        qapi_free_ImageCheck(check);
++        check = g_new0(ImageCheck, 1);
+         ret = collect_image_check(bs, check, filename, fmt, 0);
+         check->leaks_fixed          = leaks_fixed;
+--
+.24.1

-[Qemu-devel] [PULL 09/12] block: use bdrv_can_set_read_only() during reopen
+[PULL 10/19] block/qcow2-threads: fix qcow2_decompress
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+On success path we return what inflate() returns instead of 0. And it
-Message-id: 00aed7ffdd7be4b9ed9ce1007d50028a72b34ebe.1491597120.git.jcody@redhat.com
+most probably works for Z_STREAM_END as it is positive, but is
 definitely broken for Z_BUF_ERROR.
 While being here, switch to errno return code, to be closer to
 qcow2_compress API (and usual expectations).
 Revert condition in if to be more positive. Drop dead initialization of
 ret.
 Cc: qemu-stable@nongnu.org # v4.0
 Fixes: 341926ab83e2b
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Message-Id: <20200302150930.16218-1-vsementsov@virtuozzo.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Ján Tomko <jtomko@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block.c | 14 ++++++++------
+ block/qcow2-threads.c | 12 +++++++-----
-file changed, 8 insertions(+), 6 deletions(-)
+file changed, 7 insertions(+), 5 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/block/qcow2-threads.c b/block/qcow2-threads.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/block/qcow2-threads.c
-+++ b/block.c
++++ b/block/qcow2-threads.c
-@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
+@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_compress(void *dest, size_t dest_size,
-     BlockDriver *drv;
+  * @src - source buffer, @src_size bytes
-     QemuOpts *opts;
+  *
-     const char *value;
+  * Returns: 0 on success
-+    bool read_only;
+- *          -1 on fail
++ *          -EIO on fail
-     assert(reopen_state != NULL);
+  */
-     assert(reopen_state->bs->drv != NULL);
+ static ssize_t qcow2_decompress(void *dest, size_t dest_size,
-@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
+                                 const void *src, size_t src_size)
-         qdict_put(reopen_state->options, "driver", qstring_from_str(value));
+ {
 -    int ret = 0;
 +    int ret;
      z_stream strm;
      memset(&strm, 0, sizeof(strm));
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_decompress(void *dest, size_t dest_size,
      ret = inflateInit2(&strm, -12);
      if (ret != Z_OK) {
 -        return -1;
 +        return -EIO;
      }
--    /* if we are to stay read-only, do not allow permission change
+     ret = inflate(&strm, Z_FINISH);
--     * to r/w */
+-    if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) || strm.avail_out != 0) {
--    if (!(reopen_state->bs->open_flags & BDRV_O_ALLOW_RDWR) &&
++    if ((ret == Z_STREAM_END || ret == Z_BUF_ERROR) && strm.avail_out == 0) {
--        reopen_state->flags & BDRV_O_RDWR) {
+         /*
--        error_setg(errp, "Node '%s' is read only",
+          * We approve Z_BUF_ERROR because we need @dest buffer to be filled, but
--                   bdrv_get_device_or_node_name(reopen_state->bs));
+          * @src buffer may be processed partly (because in qcow2 we know size of
-+    /* If we are to stay read-only, do not allow permission change
+          * compressed data with precision of one sector)
-+     * 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 */
+-        ret = -1;
-+    read_only = !(reopen_state->flags & BDRV_O_RDWR);
++        ret = 0;
-+    ret = bdrv_can_set_read_only(reopen_state->bs, read_only, &local_err);
++    } else {
-+    if (local_err) {
++        ret = -EIO;
 +        error_propagate(errp, local_err);
          goto error;
      }
+     inflateEnd(&strm);
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 01/12] block/vxhs.c: Add support for a new block device type called "vxhs"
+[PULL 11/19] job: refactor progress to separate object
-From: Ashish Mittal <ashmit602@gmail.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Source code for the qnio library that this code loads can be downloaded from:
+We need it in separate to pass to the block-copy object in the next
-https://github.com/VeritasHyperScale/libqnio.git
+commit.
-Sample command line using JSON syntax:
+Cc: qemu-stable@nongnu.org
-./x86_64-softmmu/qemu-system-x86_64 -name instance-00000008 -S -vnc 0.0.0.0:0
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
--k en-us -vga cirrus -device virtio-balloon-pci,id=balloon0,bus=pci.0,addr=0x5
+Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
--msg timestamp=on
+Reviewed-by: Max Reitz <mreitz@redhat.com>
-'json:{"driver":"vxhs","vdisk-id":"c3e9095a-a5ee-4dce-afeb-2a59fb387410",
+Message-Id: <20200311103004.7649-2-vsementsov@virtuozzo.com>
-"server":{"host":"172.172.17.4","port":"9999"}}'
+Signed-off-by: Max Reitz <mreitz@redhat.com>
 Sample command line using URI syntax:
 qemu-img convert -f raw -O raw -n
 /var/lib/nova/instances/_base/0c5eacd5ebea5ed914b6a3e7b18f1ce734c386ad
 vxhs://192.168.0.1:9999/c6718f6b-0401-441d-a8c3-1f0064d75ee0
 Sample command line using TLS credentials (run in secure mode):
 ./qemu-io --object
 tls-creds-x509,id=tls0,dir=/etc/pki/qemu/vxhs,endpoint=client -c 'read
 -v 66000 2.5k' 'json:{"server.host": "127.0.0.1", "server.port": "9999",
 "vdisk-id": "/test.raw", "driver": "vxhs", "tls-creds":"tls0"}'
 Signed-off-by: Ashish Mittal <Ashish.Mittal@veritas.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Jeff Cody <jcody@redhat.com>
 Signed-off-by: Jeff Cody <jcody@redhat.com>
 Message-id: 1491277689-24949-2-git-send-email-Ashish.Mittal@veritas.com
 ---
- block/Makefile.objs  |   2 +
+ blockjob.c                    | 16 +++++-----
- block/trace-events   |  17 ++
+ include/qemu/job.h            | 11 ++-----
- block/vxhs.c         | 575 +++++++++++++++++++++++++++++++++++++++++++++++++++
+ include/qemu/progress_meter.h | 58 +++++++++++++++++++++++++++++++++++
- configure            |  39 ++++
+ job-qmp.c                     |  4 +--
- qapi/block-core.json |  23 ++-
+ job.c                         |  6 ++--
-files changed, 654 insertions(+), 2 deletions(-)
+ qemu-img.c                    |  6 ++--
- create mode 100644 block/vxhs.c
+files changed, 76 insertions(+), 25 deletions(-)
+ create mode 100644 include/qemu/progress_meter.h
-diff --git a/block/Makefile.objs b/block/Makefile.objs
-index XXXXXXX..XXXXXXX 100644
+diff --git a/blockjob.c b/blockjob.c
---- a/block/Makefile.objs
+index XXXXXXX..XXXXXXX 100644
-+++ b/block/Makefile.objs
+--- a/blockjob.c
-@@ -XXX,XX +XXX,XX @@ block-obj-$(CONFIG_LIBNFS) += nfs.o
++++ b/blockjob.c
- block-obj-$(CONFIG_CURL) += curl.o
+@@ -XXX,XX +XXX,XX @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
- block-obj-$(CONFIG_RBD) += rbd.o
+     info->device    = g_strdup(job->job.id);
- block-obj-$(CONFIG_GLUSTERFS) += gluster.o
+     info->busy      = atomic_read(&job->job.busy);
-+block-obj-$(CONFIG_VXHS) += vxhs.o
+     info->paused    = job->job.pause_count > 0;
- block-obj-$(CONFIG_LIBSSH2) += ssh.o
+-    info->offset    = job->job.progress_current;
- block-obj-y += accounting.o dirty-bitmap.o
+-    info->len       = job->job.progress_total;
- block-obj-y += write-threshold.o
++    info->offset    = job->job.progress.current;
-@@ -XXX,XX +XXX,XX @@ rbd.o-cflags       := $(RBD_CFLAGS)
++    info->len       = job->job.progress.total;
- rbd.o-libs         := $(RBD_LIBS)
+     info->speed     = job->speed;
- gluster.o-cflags   := $(GLUSTERFS_CFLAGS)
+     info->io_status = job->iostatus;
- gluster.o-libs     := $(GLUSTERFS_LIBS)
+     info->ready     = job_is_ready(&job->job),
-+vxhs.o-libs        := $(VXHS_LIBS)
+@@ -XXX,XX +XXX,XX @@ static void block_job_event_cancelled(Notifier *n, void *opaque)
- ssh.o-cflags       := $(LIBSSH2_CFLAGS)
- ssh.o-libs         := $(LIBSSH2_LIBS)
+     qapi_event_send_block_job_cancelled(job_type(&job->job),
- block-obj-$(if $(CONFIG_BZIP2),m,n) += dmg-bz2.o
+                                         job->job.id,
-diff --git a/block/trace-events b/block/trace-events
+-                                        job->job.progress_total,
-index XXXXXXX..XXXXXXX 100644
+-                                        job->job.progress_current,
---- a/block/trace-events
++                                        job->job.progress.total,
-+++ b/block/trace-events
++                                        job->job.progress.current,
-@@ -XXX,XX +XXX,XX @@ qed_aio_write_data(void *s, void *acb, int ret, uint64_t offset, size_t len) "s
+                                         job->speed);
- 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"
+@@ -XXX,XX +XXX,XX @@ static void block_job_event_completed(Notifier *n, void *opaque)
-+
-+# block/vxhs.c
+     qapi_event_send_block_job_completed(job_type(&job->job),
-+vxhs_iio_callback(int error) "ctx is NULL: error %d"
+                                         job->job.id,
-+vxhs_iio_callback_chnfail(int err, int error) "QNIO channel failed, no i/o %d, %d"
+-                                        job->job.progress_total,
-+vxhs_iio_callback_unknwn(int opcode, int err) "unexpected opcode %d, errno %d"
+-                                        job->job.progress_current,
-+vxhs_aio_rw_invalid(int req) "Invalid I/O request iodir %d"
++                                        job->job.progress.total,
-+vxhs_aio_rw_ioerr(char *guid, int iodir, uint64_t size, uint64_t off, void *acb, int ret, int err) "IO ERROR (vDisk %s) FOR : Read/Write = %d size = %lu offset = %lu ACB = %p. Error = %d, errno = %d"
++                                        job->job.progress.current,
-+vxhs_get_vdisk_stat_err(char *guid, int ret, int err) "vDisk (%s) stat ioctl failed, ret = %d, errno = %d"
+                                         job->speed,
-+vxhs_get_vdisk_stat(char *vdisk_guid, uint64_t vdisk_size) "vDisk %s stat ioctl returned size %lu"
+                                         !!msg,
-+vxhs_complete_aio(void *acb, uint64_t ret) "aio failed acb %p ret %ld"
+                                         msg);
-+vxhs_parse_uri_filename(const char *filename) "URI passed via bdrv_parse_filename %s"
+@@ -XXX,XX +XXX,XX @@ static void block_job_event_ready(Notifier *n, void *opaque)
-+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"
+     qapi_event_send_block_job_ready(job_type(&job->job),
-+vxhs_open_iio_open(const char *host) "Failed to connect to storage agent on host %s"
+                                     job->job.id,
-+vxhs_parse_uri_hostinfo(char *host, int port) "Host: IP %s, Port %d"
+-                                    job->job.progress_total,
-+vxhs_close(char *vdisk_guid) "Closing vdisk %s"
+-                                    job->job.progress_current,
-+vxhs_get_creds(const char *cacert, const char *client_key, const char *client_cert) "cacert %s, client_key %s, client_cert %s"
++                                    job->job.progress.total,
-diff --git a/block/vxhs.c b/block/vxhs.c
++                                    job->job.progress.current,
                                      job->speed);
  }
 diff --git a/include/qemu/job.h b/include/qemu/job.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/qemu/job.h
 +++ b/include/qemu/job.h
@@ -XXX,XX +XXX,XX @@
  #include "qapi/qapi-types-job.h"
  #include "qemu/queue.h"
 +#include "qemu/progress_meter.h"
  #include "qemu/coroutine.h"
  #include "block/aio.h"
@@ -XXX,XX +XXX,XX @@ typedef struct Job {
      /** True if this job should automatically dismiss itself */
      bool auto_dismiss;
 -    /**
 -     * Current progress. The unit is arbitrary as long as the ratio between
 -     * progress_current and progress_total represents the estimated percentage
 -     * of work already done.
 -     */
 -    int64_t progress_current;
 -
 -    /** Estimated progress_current value at the completion of the job */
 -    int64_t progress_total;
 +    ProgressMeter progress;
      /**
       * Return code from @run and/or @prepare callback(s).
 diff --git a/include/qemu/progress_meter.h b/include/qemu/progress_meter.h
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/block/vxhs.c
++++ b/include/qemu/progress_meter.h
 @@ -XXX,XX +XXX,XX @@
 +/*
-+ * QEMU Block driver for Veritas HyperScale (VxHS)
++ * Helper functionality for some process progress tracking.
 + *
-+ * Copyright (c) 2017 Veritas Technologies LLC.
++ * Copyright (c) 2011 IBM Corp.
-+ *
++ * Copyright (c) 2012, 2018 Red Hat, Inc.
-+ * This work is licensed under the terms of the GNU GPL, version 2 or later.
++ * Copyright (c) 2020 Virtuozzo International GmbH
-+ * See the COPYING file in the top-level directory.
++ *
-+ *
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
 + * of this software and associated documentation files (the "Software"), to deal
 + * in the Software without restriction, including without limitation the rights
 + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 + * copies of the Software, and to permit persons to whom the Software is
 + * furnished to do so, subject to the following conditions:
 + *
 + * The above copyright notice and this permission notice shall be included in
 + * all copies or substantial portions of the Software.
 + *
 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 + * THE SOFTWARE.
 + */
 +
-+#include "qemu/osdep.h"
++#ifndef QEMU_PROGRESS_METER_H
-+#include <qnio/qnio_api.h>
++#define QEMU_PROGRESS_METER_H
-+#include <sys/param.h>
++
-+#include "block/block_int.h"
++typedef struct ProgressMeter {
-+#include "qapi/qmp/qerror.h"
++    /**
-+#include "qapi/qmp/qdict.h"
++     * Current progress. The unit is arbitrary as long as the ratio between
-+#include "qapi/qmp/qstring.h"
++     * current and total represents the estimated percentage
-+#include "trace.h"
++     * of work already done.
-+#include "qemu/uri.h"
++     */
-+#include "qapi/error.h"
++    uint64_t current;
-+#include "qemu/uuid.h"
++
-+#include "crypto/tlscredsx509.h"
++    /** Estimated current value at the completion of the process */
-+
++    uint64_t total;
-+#define VXHS_OPT_FILENAME           "filename"
++} ProgressMeter;
-+#define VXHS_OPT_VDISK_ID           "vdisk-id"
++
-+#define VXHS_OPT_SERVER             "server"
++static inline void progress_work_done(ProgressMeter *pm, uint64_t done)
 +#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;
++    pm->current += done;
 +    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);
 +}
 +
-+/*
++static inline void progress_set_remaining(ProgressMeter *pm, uint64_t remaining)
 + * Called from a libqnio thread
 + */
 +static void vxhs_iio_callback(void *ctx, uint32_t opcode, uint32_t error)
 +{
-+    VXHSAIOCB *acb = NULL;
++    pm->total = pm->current + remaining;
 +
 +    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 = {
++static inline void progress_increase_remaining(ProgressMeter *pm,
-+    .name = "vxhs",
++                                               uint64_t delta)
 +    .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;
++    pm->total += delta;
 +    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,
++#endif /* QEMU_PROGRESS_METER_H */
-+                                Error **errp)
+diff --git a/job-qmp.c b/job-qmp.c
-+{
+index XXXXXXX..XXXXXXX 100644
-+    if (qdict_haskey(options, "vdisk-id") || qdict_haskey(options, "server")) {
+--- a/job-qmp.c
-+        error_setg(errp, "vdisk-id/server and a file name may not be specified "
++++ b/job-qmp.c
-+                         "at the same time");
+@@ -XXX,XX +XXX,XX @@ static JobInfo *job_query_single(Job *job, Error **errp)
-+        return;
+         .id                 = g_strdup(job->id),
-+    }
+         .type               = job_type(job),
-+
+         .status             = job->status,
-+    if (strstr(filename, "://")) {
+-        .current_progress   = job->progress_current,
-+        int ret = vxhs_parse_uri(filename, options);
+-        .total_progress     = job->progress_total,
-+        if (ret < 0) {
++        .current_progress   = job->progress.current,
-+            error_setg(errp, "Invalid URI. URI should be of the form "
++        .total_progress     = job->progress.total,
-+                       "  vxhs://<host_ip>:<port>/<vdisk-id>");
+         .has_error          = !!job->err,
-+        }
+         .error              = job->err ? \
-+    }
+                               g_strdup(error_get_pretty(job->err)) : NULL,
-+}
+diff --git a/job.c b/job.c
-+
+index XXXXXXX..XXXXXXX 100644
-+static int vxhs_init_and_ref(void)
+--- a/job.c
-+{
++++ b/job.c
-+    if (vxhs_ref++ == 0) {
+@@ -XXX,XX +XXX,XX @@ void job_unref(Job *job)
-+        if (iio_init(QNIO_VERSION, vxhs_iio_callback)) {
-+            return -ENODEV;
+ void job_progress_update(Job *job, uint64_t done)
-+        }
+ {
-+    }
+-    job->progress_current += done;
-+    return 0;
++    progress_work_done(&job->progress, done);
-+}
+ }
-+
-+static void vxhs_unref(void)
+ void job_progress_set_remaining(Job *job, uint64_t remaining)
-+{
+ {
-+    if (--vxhs_ref == 0) {
+-    job->progress_total = job->progress_current + remaining;
-+        iio_fini();
++    progress_set_remaining(&job->progress, remaining);
-+    }
+ }
-+}
-+
+ void job_progress_increase_remaining(Job *job, uint64_t delta)
-+static void vxhs_get_tls_creds(const char *id, char **cacert,
+ {
-+                               char **key, char **cert, Error **errp)
+-    job->progress_total += delta;
-+{
++    progress_increase_remaining(&job->progress, delta);
-+    Object *obj;
+ }
-+    QCryptoTLSCreds *creds;
-+    QCryptoTLSCredsX509 *creds_x509;
+ void job_event_cancelled(Job *job)
-+
+diff --git a/qemu-img.c b/qemu-img.c
-+    obj = object_resolve_path_component(
+index XXXXXXX..XXXXXXX 100644
-+        object_get_objects_root(), id);
+--- a/qemu-img.c
-+
++++ b/qemu-img.c
-+    if (!obj) {
+@@ -XXX,XX +XXX,XX @@ static void run_block_job(BlockJob *job, Error **errp)
-+        error_setg(errp, "No TLS credentials with id '%s'",
+     do {
-+                   id);
+         float progress = 0.0f;
-+        return;
+         aio_poll(aio_context, true);
-+    }
+-        if (job->job.progress_total) {
-+
+-            progress = (float)job->job.progress_current /
-+    creds_x509 = (QCryptoTLSCredsX509 *)
+-                       job->job.progress_total * 100.f;
-+        object_dynamic_cast(obj, TYPE_QCRYPTO_TLS_CREDS_X509);
++        if (job->job.progress.total) {
-+
++            progress = (float)job->job.progress.current /
-+    if (!creds_x509) {
++                       job->job.progress.total * 100.f;
-+        error_setg(errp, "Object with id '%s' is not TLS credentials",
+         }
-+                   id);
+         qemu_progress_print(progress, 0);
-+        return;
+     } while (!job_is_ready(&job->job) && !job_is_completed(&job->job));
 +    }
 +
 +    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
+.24.1

-[Qemu-devel] [PULL 08/12] block: introduce bdrv_can_set_read_only()
+[PULL 12/19] block/block-copy: fix progress calculation
-Introduce check function for setting read_only flags.  Will return < 0 on
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 error, with appropriate Error value set.  Does not alter any flags.
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Assume we have two regions, A and B, and region B is in-flight now,
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+region A is not yet touched, but it is unallocated and should be
-Reviewed-by: John Snow <jsnow@redhat.com>
+skipped.
-Message-id: e2bba34ac3bc76a0c42adc390413f358ae0566e8.1491597120.git.jcody@redhat.com
 Correspondingly, as progress we have
   total = A + B
   current = 0
 If we reset unallocated region A and call progress_reset_callback,
 it will calculate 0 bytes dirty in the bitmap and call
 job_progress_set_remaining, which will set
    total = current + 0 = 0 + 0 = 0
 So, B bytes are actually removed from total accounting. When job
 finishes we'll have
    total = 0
    current = B
 , which doesn't sound good.
 This is because we didn't considered in-flight bytes, actually when
 calculating remaining, we should have set (in_flight + dirty_bytes)
 as remaining, not only dirty_bytes.
 To fix it, let's refactor progress calculation, moving it to block-copy
 itself instead of fixing callback. And, of course, track in_flight
 bytes count.
 We still have to keep one callback, to maintain backup job bytes_read
 calculation, but it will go on soon, when we turn the whole backup
 process into one block_copy call.
 Cc: qemu-stable@nongnu.org
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
 Message-Id: <20200311103004.7649-3-vsementsov@virtuozzo.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block.c               | 14 +++++++++++++-
+ block/backup.c             | 13 ++-----------
- include/block/block.h |  1 +
+ block/block-copy.c         | 16 ++++++++++++----
-files changed, 14 insertions(+), 1 deletion(-)
+ include/block/block-copy.h | 15 +++++----------
 files changed, 19 insertions(+), 25 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/block/backup.c b/block/backup.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/block/backup.c
-+++ b/block.c
++++ b/block/backup.c
-@@ -XXX,XX +XXX,XX @@ bool bdrv_is_read_only(BlockDriverState *bs)
+@@ -XXX,XX +XXX,XX @@ static void backup_progress_bytes_callback(int64_t bytes, void *opaque)
-     return bs->read_only;
+     BackupBlockJob *s = opaque;
      s->bytes_read += bytes;
 -    job_progress_update(&s->common.job, bytes);
 -}
 -
 -static void backup_progress_reset_callback(void *opaque)
 -{
 -    BackupBlockJob *s = opaque;
 -    uint64_t estimate = bdrv_get_dirty_count(s->bcs->copy_bitmap);
 -
 -    job_progress_set_remaining(&s->common.job, estimate);
  }
--int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+ static int coroutine_fn backup_do_cow(BackupBlockJob *job,
-+int bdrv_can_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
      job->cluster_size = cluster_size;
      job->len = len;
 -    block_copy_set_callbacks(bcs, backup_progress_bytes_callback,
 -                             backup_progress_reset_callback, job);
 +    block_copy_set_progress_callback(bcs, backup_progress_bytes_callback, job);
 +    block_copy_set_progress_meter(bcs, &job->common.job.progress);
      /* Required permissions are already taken by backup-top target */
      block_job_add_bdrv(&job->common, "target", target, 0, BLK_PERM_ALL,
 diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-copy.c
 +++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
      return s;
  }
 -void block_copy_set_callbacks(
 +void block_copy_set_progress_callback(
          BlockCopyState *s,
          ProgressBytesCallbackFunc progress_bytes_callback,
 -        ProgressResetCallbackFunc progress_reset_callback,
          void *progress_opaque)
  {
-     /* Do not set read_only if copy_on_read is enabled */
+     s->progress_bytes_callback = progress_bytes_callback;
-     if (bs->copy_on_read && read_only) {
+-    s->progress_reset_callback = progress_reset_callback;
-@@ -XXX,XX +XXX,XX @@ int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+     s->progress_opaque = progress_opaque;
-         return -EPERM;
+ }
-     }
++void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm)
-+    return 0;
++{
 +    s->progress = pm;
 +}
 +
-+int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+ /*
-+{
+  * block_copy_do_copy
-+    int ret = 0;
+  *
@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
      if (!ret) {
          bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
 -        s->progress_reset_callback(s->progress_opaque);
 +        progress_set_remaining(s->progress,
 +                               bdrv_get_dirty_count(s->copy_bitmap) +
 +                               s->in_flight_bytes);
      }
      *count = bytes;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
          trace_block_copy_process(s, start);
          bdrv_reset_dirty_bitmap(s->copy_bitmap, start, chunk_end - start);
 +        s->in_flight_bytes += chunk_end - start;
          co_get_from_shres(s->mem, chunk_end - start);
          ret = block_copy_do_copy(s, start, chunk_end, error_is_read);
          co_put_to_shres(s->mem, chunk_end - start);
 +        s->in_flight_bytes -= chunk_end - start;
          if (ret < 0) {
              bdrv_set_dirty_bitmap(s->copy_bitmap, start, chunk_end - start);
              break;
          }
 +        progress_work_done(s->progress, chunk_end - start);
          s->progress_bytes_callback(chunk_end - start, s->progress_opaque);
          start = chunk_end;
          ret = 0;
 diff --git a/include/block/block-copy.h b/include/block/block-copy.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block-copy.h
 +++ b/include/block/block-copy.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyInFlightReq {
  } BlockCopyInFlightReq;
  typedef void (*ProgressBytesCallbackFunc)(int64_t bytes, void *opaque);
 -typedef void (*ProgressResetCallbackFunc)(void *opaque);
  typedef struct BlockCopyState {
      /*
       * BdrvChild objects are not owned or managed by block-copy. They are
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState {
      BdrvChild *source;
      BdrvChild *target;
      BdrvDirtyBitmap *copy_bitmap;
 +    int64_t in_flight_bytes;
      int64_t cluster_size;
      bool use_copy_range;
      int64_t copy_size;
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState {
       */
      bool skip_unallocated;
 +    ProgressMeter *progress;
      /* progress_bytes_callback: called when some copying progress is done. */
      ProgressBytesCallbackFunc progress_bytes_callback;
 -
 -    /*
 -     * progress_reset_callback: called when some bytes reset from copy_bitmap
 -     * (see @skip_unallocated above). The callee is assumed to recalculate how
 -     * many bytes remain based on the dirty bit count of copy_bitmap.
 -     */
 -    ProgressResetCallbackFunc progress_reset_callback;
      void *progress_opaque;
      SharedResource *mem;
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
                                       BdrvRequestFlags write_flags,
                                       Error **errp);
 -void block_copy_set_callbacks(
 +void block_copy_set_progress_callback(
          BlockCopyState *s,
          ProgressBytesCallbackFunc progress_bytes_callback,
 -        ProgressResetCallbackFunc progress_reset_callback,
          void *progress_opaque);
 +void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm);
 +
-+    ret = bdrv_can_set_read_only(bs, read_only, errp);
+ void block_copy_state_free(BlockCopyState *s);
-+    if (ret < 0) {
-+        return ret;
+ int64_t block_copy_reset_unallocated(BlockCopyState *s,
 +    }
 +
      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);
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 04/12] block: add bdrv_set_read_only() helper function
+[PULL 13/19] block/block-copy: specialcase first copy_range request
-We have a helper wrapper for checking for the BDS read_only flag,
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 add a helper wrapper to set the read_only flag as well.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+In block_copy_do_copy we fallback to read+write if copy_range failed.
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+In this case copy_size is larger than defined for buffered IO, and
-Reviewed-by: John Snow <jsnow@redhat.com>
+there is corresponding commit. Still, backup copies data cluster by
-Message-id: 9b18972d05f5fa2ac16c014f0af98d680553048d.1491597120.git.jcody@redhat.com
+cluster, and most of requests are limited to one cluster anyway, so the
 only source of this one bad-limited request is copy-before-write
 operation.
 Further patch will move backup to use block_copy directly, than for
 cases where copy_range is not supported, first request will be
 oversized in each backup. It's not good, let's change it now.
 Fix is simple: just limit first copy_range request like buffer-based
 request. If it succeed, set larger copy_range limit.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200311103004.7649-4-vsementsov@virtuozzo.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block.c               | 5 +++++
+ block/block-copy.c | 41 +++++++++++++++++++++++++++++++----------
- block/bochs.c         | 2 +-
+file changed, 31 insertions(+), 10 deletions(-)
  block/cloop.c         | 2 +-
  block/dmg.c           | 2 +-
  block/rbd.c           | 2 +-
  block/vvfat.c         | 4 ++--
  include/block/block.h | 1 +
 files changed, 12 insertions(+), 6 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/block/block-copy.c
-+++ b/block.c
++++ b/block/block-copy.c
-@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
+@@ -XXX,XX +XXX,XX @@ void block_copy_state_free(BlockCopyState *s)
-     }
+     g_free(s);
  }
-+void bdrv_set_read_only(BlockDriverState *bs, bool read_only)
++static uint32_t block_copy_max_transfer(BdrvChild *source, BdrvChild *target)
 +{
-+    bs->read_only = read_only;
++    return MIN_NON_ZERO(INT_MAX,
 +                        MIN_NON_ZERO(source->bs->bl.max_transfer,
 +                                     target->bs->bl.max_transfer));
 +}
 +
- void bdrv_get_full_backing_filename_from_filename(const char *backed,
+ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
-                                                   const char *backing,
+                                      int64_t cluster_size,
-                                                   char *dest, size_t sz,
+                                      BdrvRequestFlags write_flags, Error **errp)
-diff --git a/block/bochs.c b/block/bochs.c
+ {
-index XXXXXXX..XXXXXXX 100644
+     BlockCopyState *s;
---- a/block/bochs.c
+     BdrvDirtyBitmap *copy_bitmap;
-+++ b/block/bochs.c
+-    uint32_t max_transfer =
-@@ -XXX,XX +XXX,XX @@ static int bochs_open(BlockDriverState *bs, QDict *options, int flags,
+-            MIN_NON_ZERO(INT_MAX,
-         return -EINVAL;
+-                         MIN_NON_ZERO(source->bs->bl.max_transfer,
 -                                      target->bs->bl.max_transfer));
      copy_bitmap = bdrv_create_dirty_bitmap(source->bs, cluster_size, NULL,
                                             errp);
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
          .mem = shres_create(BLOCK_COPY_MAX_MEM),
      };
 -    if (max_transfer < cluster_size) {
 +    if (block_copy_max_transfer(source, target) < cluster_size) {
          /*
           * copy_range does not respect max_transfer. We don't want to bother
           * with requests smaller than block-copy cluster size, so fallback to
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
          s->copy_size = cluster_size;
      } else {
          /*
 -         * copy_range does not respect max_transfer (it's a TODO), so we factor
 -         * that in here.
 +         * We enable copy-range, but keep small copy_size, until first
 +         * successful copy_range (look at block_copy_do_copy).
           */
          s->use_copy_range = true;
 -        s->copy_size = MIN(MAX(cluster_size, BLOCK_COPY_MAX_COPY_RANGE),
 -                           QEMU_ALIGN_DOWN(max_transfer, cluster_size));
 +        s->copy_size = MAX(s->cluster_size, BLOCK_COPY_MAX_BUFFER);
      }
--    bs->read_only = true; /* no write support yet */
+     QLIST_INIT(&s->inflight_reqs);
-+    bdrv_set_read_only(bs, true); /* no write support yet */
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
+             s->copy_size = MAX(s->cluster_size, BLOCK_COPY_MAX_BUFFER);
-     ret = bdrv_pread(bs->file, 0, &bochs, sizeof(bochs));
+             /* Fallback to read+write with allocated buffer */
-     if (ret < 0) {
+         } else {
-diff --git a/block/cloop.c b/block/cloop.c
++            if (s->use_copy_range) {
-index XXXXXXX..XXXXXXX 100644
++                /*
---- a/block/cloop.c
++                 * Successful copy-range. Now increase copy_size.  copy_range
-+++ b/block/cloop.c
++                 * does not respect max_transfer (it's a TODO), so we factor
-@@ -XXX,XX +XXX,XX @@ static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
++                 * that in here.
-         return -EINVAL;
++                 *
 +                 * Note: we double-check s->use_copy_range for the case when
 +                 * parallel block-copy request unsets it during previous
 +                 * bdrv_co_copy_range call.
 +                 */
 +                s->copy_size =
 +                        MIN(MAX(s->cluster_size, BLOCK_COPY_MAX_COPY_RANGE),
 +                            QEMU_ALIGN_DOWN(block_copy_max_transfer(s->source,
 +                                                                    s->target),
 +                                            s->cluster_size));
 +            }
              goto out;
          }
      }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
--    bs->read_only = true;
+     /*
-+    bdrv_set_read_only(bs, true);
+      * In case of failed copy_range request above, we may proceed with buffered
+      * request larger than BLOCK_COPY_MAX_BUFFER. Still, further requests will
-     /* read header */
+-     * be properly limited, so don't care too much.
-     ret = bdrv_pread(bs->file, 128, &s->block_size, 4);
++     * be properly limited, so don't care too much. Moreover the most likely
-diff --git a/block/dmg.c b/block/dmg.c
++     * case (copy_range is unsupported for the configuration, so the very first
-index XXXXXXX..XXXXXXX 100644
++     * copy_range request fails) is handled by setting large copy_size only
---- a/block/dmg.c
++     * after first successful copy_range.
-+++ b/block/dmg.c
+      */
-@@ -XXX,XX +XXX,XX @@ static int dmg_open(BlockDriverState *bs, QDict *options, int flags,
-     }
+     bounce_buffer = qemu_blockalign(s->source->bs, nbytes);
      block_module_load_one("dmg-bz2");
 -    bs->read_only = true;
 +    bdrv_set_read_only(bs, true);
      s->n_chunks = 0;
      s->offsets = s->lengths = s->sectors = s->sectorcounts = NULL;
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
          goto failed_open;
      }
 -    bs->read_only = (s->snap != NULL);
 +    bdrv_set_read_only(bs, (s->snap != NULL));
      qemu_opts_del(opts);
      return 0;
 diff --git a/block/vvfat.c b/block/vvfat.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vvfat.c
 +++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
      s->current_cluster=0xffffffff;
      /* read only is the default for safety */
 -    bs->read_only = true;
 +    bdrv_set_read_only(bs, true);
      s->qcow = NULL;
      s->qcow_filename = NULL;
      s->fat2 = NULL;
@@ -XXX,XX +XXX,XX @@ static int vvfat_open(BlockDriverState *bs, QDict *options, int flags,
          if (ret < 0) {
              goto fail;
          }
 -        bs->read_only = false;
 +        bdrv_set_read_only(bs, false);
      }
      bs->total_sectors = cyls * heads * secs;
 diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block.h
 +++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_is_allocated_above(BlockDriverState *top, BlockDriverState *base,
                              int64_t sector_num, int nb_sectors, int *pnum);
  bool bdrv_is_read_only(BlockDriverState *bs);
 +void bdrv_set_read_only(BlockDriverState *bs, bool read_only);
  bool bdrv_is_sg(BlockDriverState *bs);
  bool bdrv_is_inserted(BlockDriverState *bs);
  int bdrv_media_changed(BlockDriverState *bs);
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 11/12] block/rbd: Add support for reopen()
+[PULL 14/19] block/block-copy: use block_status
-This adds support for reopen in rbd, for changing between r/w and r/o.
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Note, that this is only a flag change, but we will block a change from
+Use bdrv_block_status_above to chose effective chunk size and to handle
-r/o to r/w if we are using an RBD internal snapshot.
+zeroes effectively.
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+This substitutes checking for just being allocated or not, and drops
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+old code path for it. Assistance by backup job is dropped too, as
-Reviewed-by: John Snow <jsnow@redhat.com>
+caching block-status information is more difficult than just caching
-Message-id: d4e87539167ec6527d44c97b164eabcccf96e4f3.1491597120.git.jcody@redhat.com
+is-allocated information in our dirty bitmap, and backup job is not
 good place for this caching anyway.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200311103004.7649-5-vsementsov@virtuozzo.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block/rbd.c | 21 +++++++++++++++++++++
+ block/block-copy.c | 73 +++++++++++++++++++++++++++++++++++++---------
-file changed, 21 insertions(+)
+ block/trace-events |  1 +
 files changed, 61 insertions(+), 13 deletions(-)
-diff --git a/block/rbd.c b/block/rbd.c
+diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/rbd.c
+--- a/block/block-copy.c
-+++ b/block/rbd.c
++++ b/block/block-copy.c
-@@ -XXX,XX +XXX,XX @@ failed_opts:
+@@ -XXX,XX +XXX,XX @@ void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm)
-     return r;
+  */
- }
+ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
+                                            int64_t start, int64_t end,
-+
+-                                           bool *error_is_read)
-+/* Since RBD is currently always opened R/W via the API,
++                                           bool zeroes, bool *error_is_read)
-+ * 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 */
+     int ret;
-+static int qemu_rbd_reopen_prepare(BDRVReopenState *state,
+     int nbytes = MIN(end, s->len) - start;
-+                                   BlockReopenQueue *queue, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
-+{
+     assert(QEMU_IS_ALIGNED(end, s->cluster_size));
-+    BDRVRBDState *s = state->bs->opaque;
+     assert(end < s->len || end == QEMU_ALIGN_UP(s->len, s->cluster_size));
-+    int ret = 0;
-+
++    if (zeroes) {
-+    if (s->snap && state->flags & BDRV_O_RDWR) {
++        ret = bdrv_co_pwrite_zeroes(s->target, start, nbytes, s->write_flags &
-+        error_setg(errp,
++                                    ~BDRV_REQ_WRITE_COMPRESSED);
-+                   "Cannot change node '%s' to r/w when using RBD snapshot",
++        if (ret < 0) {
-+                   bdrv_get_device_or_node_name(state->bs));
++            trace_block_copy_write_zeroes_fail(s, start, ret);
-+        ret = -EINVAL;
++            if (error_is_read) {
 +                *error_is_read = false;
 +            }
 +        }
 +        return ret;
 +    }
 +
+     if (s->use_copy_range) {
+         ret = bdrv_co_copy_range(s->source, start, s->target, start, nbytes,
+, s->write_flags);
+@@ -XXX,XX +XXX,XX @@ out:
+     return ret;
+ }
++static int block_copy_block_status(BlockCopyState *s, int64_t offset,
++                                   int64_t bytes, int64_t *pnum)
++{
++    int64_t num;
++    BlockDriverState *base;
++    int ret;
++
++    if (s->skip_unallocated && s->source->bs->backing) {
++        base = s->source->bs->backing->bs;
++    } else {
++        base = NULL;
++    }
++
++    ret = bdrv_block_status_above(s->source->bs, base, offset, bytes, &num,
++                                  NULL, NULL);
++    if (ret < 0 || num < s->cluster_size) {
++        /*
++         * On error or if failed to obtain large enough chunk just fallback to
++         * copy one cluster.
++         */
++        num = s->cluster_size;
++        ret = BDRV_BLOCK_ALLOCATED | BDRV_BLOCK_DATA;
++    } else if (offset + num == s->len) {
++        num = QEMU_ALIGN_UP(num, s->cluster_size);
++    } else {
++        num = QEMU_ALIGN_DOWN(num, s->cluster_size);
++    }
++
++    *pnum = num;
 +    return ret;
 +}
 +
- static void qemu_rbd_close(BlockDriverState *bs)
+ /*
   * Check if the cluster starting at offset is allocated or not.
   * return via pnum the number of contiguous clusters sharing this allocation.
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
  {
-     BDRVRBDState *s = bs->opaque;
+     int ret = 0;
-@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_rbd = {
+     int64_t end = bytes + start; /* bytes */
-     .bdrv_parse_filename    = qemu_rbd_parse_filename,
+-    int64_t status_bytes;
-     .bdrv_file_open         = qemu_rbd_open,
+     BlockCopyInFlightReq req;
-     .bdrv_close             = qemu_rbd_close,
-+    .bdrv_reopen_prepare    = qemu_rbd_reopen_prepare,
+     /*
-     .bdrv_create            = qemu_rbd_create,
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
-     .bdrv_has_zero_init     = bdrv_has_zero_init_1,
+     block_copy_inflight_req_begin(s, &req, start, end);
-     .bdrv_get_info          = qemu_rbd_getinfo,
      while (start < end) {
 -        int64_t next_zero, chunk_end;
 +        int64_t next_zero, chunk_end, status_bytes;
          if (!bdrv_dirty_bitmap_get(s->copy_bitmap, start)) {
              trace_block_copy_skip(s, start);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
              chunk_end = next_zero;
          }
 -        if (s->skip_unallocated) {
 -            ret = block_copy_reset_unallocated(s, start, &status_bytes);
 -            if (ret == 0) {
 -                trace_block_copy_skip_range(s, start, status_bytes);
 -                start += status_bytes;
 -                continue;
 -            }
 -            /* Clamp to known allocated region */
 -            chunk_end = MIN(chunk_end, start + status_bytes);
 +        ret = block_copy_block_status(s, start, chunk_end - start,
 +                                      &status_bytes);
 +        if (s->skip_unallocated && !(ret & BDRV_BLOCK_ALLOCATED)) {
 +            bdrv_reset_dirty_bitmap(s->copy_bitmap, start, status_bytes);
 +            progress_set_remaining(s->progress,
 +                                   bdrv_get_dirty_count(s->copy_bitmap) +
 +                                   s->in_flight_bytes);
 +            trace_block_copy_skip_range(s, start, status_bytes);
 +            start += status_bytes;
 +            continue;
          }
 +        chunk_end = MIN(chunk_end, start + status_bytes);
 +
          trace_block_copy_process(s, start);
          bdrv_reset_dirty_bitmap(s->copy_bitmap, start, chunk_end - start);
          s->in_flight_bytes += chunk_end - start;
          co_get_from_shres(s->mem, chunk_end - start);
 -        ret = block_copy_do_copy(s, start, chunk_end, error_is_read);
 +        ret = block_copy_do_copy(s, start, chunk_end, ret & BDRV_BLOCK_ZERO,
 +                                 error_is_read);
          co_put_to_shres(s->mem, chunk_end - start);
          s->in_flight_bytes -= chunk_end - start;
          if (ret < 0) {
 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 @@ block_copy_process(void *bcs, int64_t start) "bcs %p start %"PRId64
  block_copy_copy_range_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d"
  block_copy_read_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d"
  block_copy_write_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d"
 +block_copy_write_zeroes_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d"
  # ../blockdev.c
  qmp_block_job_cancel(void *job) "job %p"
 --
-.9.3
+.24.1

-[Qemu-devel] [PULL 07/12] block: code movement
+[PULL 15/19] block/block-copy: factor out find_conflicting_inflight_req
-Move bdrv_is_read_only() up with its friends.
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Split find_conflicting_inflight_req to be used separately.
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Jeff Cody <jcody@redhat.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-id: 73b2399459760c32506f9407efb9dddb3a2789de.1491597120.git.jcody@redhat.com
+Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200311103004.7649-6-vsementsov@virtuozzo.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block.c | 10 +++++-----
+ block/block-copy.c | 31 +++++++++++++++++++------------
-file changed, 5 insertions(+), 5 deletions(-)
+file changed, 19 insertions(+), 12 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/block/block-copy.c
-+++ b/block.c
++++ b/block/block-copy.c
-@@ -XXX,XX +XXX,XX @@ void path_combine(char *dest, int dest_size,
+@@ -XXX,XX +XXX,XX @@
-     }
+ #define BLOCK_COPY_MAX_BUFFER (1 * MiB)
- }
+ #define BLOCK_COPY_MAX_MEM (128 * MiB)
-+bool bdrv_is_read_only(BlockDriverState *bs)
++static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
 +                                                           int64_t start,
 +                                                           int64_t end)
 +{
-+    return bs->read_only;
++    BlockCopyInFlightReq *req;
 +
 +    QLIST_FOREACH(req, &s->inflight_reqs, list) {
 +        if (end > req->start_byte && start < req->end_byte) {
 +            return req;
 +        }
 +    }
 +
 +    return NULL;
 +}
 +
- int bdrv_set_read_only(BlockDriverState *bs, bool read_only, Error **errp)
+ static void coroutine_fn block_copy_wait_inflight_reqs(BlockCopyState *s,
                                                         int64_t start,
                                                         int64_t end)
  {
-     /* Do not set read_only if copy_on_read is enabled */
+     BlockCopyInFlightReq *req;
-@@ -XXX,XX +XXX,XX @@ void bdrv_get_geometry(BlockDriverState *bs, uint64_t *nb_sectors_ptr)
+-    bool waited;
-     *nb_sectors_ptr = nb_sectors < 0 ? 0 : nb_sectors;
+-
 -    do {
 -        waited = false;
 -        QLIST_FOREACH(req, &s->inflight_reqs, list) {
 -            if (end > req->start_byte && start < req->end_byte) {
 -                qemu_co_queue_wait(&req->wait_queue, NULL);
 -                waited = true;
 -                break;
 -            }
 -        }
 -    } while (waited);
 +
 +    while ((req = find_conflicting_inflight_req(s, start, end))) {
 +        qemu_co_queue_wait(&req->wait_queue, NULL);
 +    }
  }
--bool bdrv_is_read_only(BlockDriverState *bs)
+ static void block_copy_inflight_req_begin(BlockCopyState *s,
 -{
 -    return bs->read_only;
 -}
 -
  bool bdrv_is_sg(BlockDriverState *bs)
  {
      return bs->sg;
 --
-.9.3
+.24.1

-New patch
+[PULL 16/19] block/block-copy: refactor interfaces to use bytes instead of end
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 We have a lot of "chunk_end - start" invocations, let's switch to
 bytes/cur_bytes scheme instead.
 While being here, improve check on block_copy_do_copy parameters to not
 overflow when calculating nbytes and use int64_t for bytes in
 block_copy for consistency.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200311103004.7649-7-vsementsov@virtuozzo.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block/block-copy.c         | 78 ++++++++++++++++++++------------------
  include/block/block-copy.h |  6 +--
 files changed, 44 insertions(+), 40 deletions(-)
 diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-copy.c
 +++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@
  static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
                                                             int64_t start,
 -                                                           int64_t end)
 +                                                           int64_t bytes)
  {
      BlockCopyInFlightReq *req;
      QLIST_FOREACH(req, &s->inflight_reqs, list) {
 -        if (end > req->start_byte && start < req->end_byte) {
 +        if (start + bytes > req->start && start < req->start + req->bytes) {
              return req;
          }
      }
@@ -XXX,XX +XXX,XX @@ static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
  static void coroutine_fn block_copy_wait_inflight_reqs(BlockCopyState *s,
                                                         int64_t start,
 -                                                       int64_t end)
 +                                                       int64_t bytes)
  {
      BlockCopyInFlightReq *req;
 -    while ((req = find_conflicting_inflight_req(s, start, end))) {
 +    while ((req = find_conflicting_inflight_req(s, start, bytes))) {
          qemu_co_queue_wait(&req->wait_queue, NULL);
      }
  }
  static void block_copy_inflight_req_begin(BlockCopyState *s,
                                            BlockCopyInFlightReq *req,
 -                                          int64_t start, int64_t end)
 +                                          int64_t start, int64_t bytes)
  {
 -    req->start_byte = start;
 -    req->end_byte = end;
 +    req->start = start;
 +    req->bytes = bytes;
      qemu_co_queue_init(&req->wait_queue);
      QLIST_INSERT_HEAD(&s->inflight_reqs, req, list);
  }
@@ -XXX,XX +XXX,XX @@ void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm)
  /*
   * block_copy_do_copy
   *
 - * Do copy of cluser-aligned chunk. @end is allowed to exceed s->len only to
 - * cover last cluster when s->len is not aligned to clusters.
 + * Do copy of cluster-aligned chunk. Requested region is allowed to exceed
 + * s->len only to cover last cluster when s->len is not aligned to clusters.
   *
   * No sync here: nor bitmap neighter intersecting requests handling, only copy.
   *
   * Returns 0 on success.
   */
  static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
 -                                           int64_t start, int64_t end,
 +                                           int64_t start, int64_t bytes,
                                             bool zeroes, bool *error_is_read)
  {
      int ret;
 -    int nbytes = MIN(end, s->len) - start;
 +    int64_t nbytes = MIN(start + bytes, s->len) - start;
      void *bounce_buffer = NULL;
 +    assert(start >= 0 && bytes > 0 && INT64_MAX - start >= bytes);
      assert(QEMU_IS_ALIGNED(start, s->cluster_size));
 -    assert(QEMU_IS_ALIGNED(end, s->cluster_size));
 -    assert(end < s->len || end == QEMU_ALIGN_UP(s->len, s->cluster_size));
 +    assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
 +    assert(start < s->len);
 +    assert(start + bytes <= s->len ||
 +           start + bytes == QEMU_ALIGN_UP(s->len, s->cluster_size));
 +    assert(nbytes < INT_MAX);
      if (zeroes) {
          ret = bdrv_co_pwrite_zeroes(s->target, start, nbytes, s->write_flags &
@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
  }
  int coroutine_fn block_copy(BlockCopyState *s,
 -                            int64_t start, uint64_t bytes,
 +                            int64_t start, int64_t bytes,
                              bool *error_is_read)
  {
      int ret = 0;
 -    int64_t end = bytes + start; /* bytes */
      BlockCopyInFlightReq req;
      /*
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
             bdrv_get_aio_context(s->target->bs));
      assert(QEMU_IS_ALIGNED(start, s->cluster_size));
 -    assert(QEMU_IS_ALIGNED(end, s->cluster_size));
 +    assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
      block_copy_wait_inflight_reqs(s, start, bytes);
 -    block_copy_inflight_req_begin(s, &req, start, end);
 +    block_copy_inflight_req_begin(s, &req, start, bytes);
 -    while (start < end) {
 -        int64_t next_zero, chunk_end, status_bytes;
 +    while (bytes) {
 +        int64_t next_zero, cur_bytes, status_bytes;
          if (!bdrv_dirty_bitmap_get(s->copy_bitmap, start)) {
              trace_block_copy_skip(s, start);
              start += s->cluster_size;
 +            bytes -= s->cluster_size;
              continue; /* already copied */
          }
 -        chunk_end = MIN(end, start + s->copy_size);
 +        cur_bytes = MIN(bytes, s->copy_size);
          next_zero = bdrv_dirty_bitmap_next_zero(s->copy_bitmap, start,
 -                                                chunk_end - start);
 +                                                cur_bytes);
          if (next_zero >= 0) {
              assert(next_zero > start); /* start is dirty */
 -            assert(next_zero < chunk_end); /* no need to do MIN() */
 -            chunk_end = next_zero;
 +            assert(next_zero < start + cur_bytes); /* no need to do MIN() */
 +            cur_bytes = next_zero - start;
          }
 -        ret = block_copy_block_status(s, start, chunk_end - start,
 -                                      &status_bytes);
 +        ret = block_copy_block_status(s, start, cur_bytes, &status_bytes);
          if (s->skip_unallocated && !(ret & BDRV_BLOCK_ALLOCATED)) {
              bdrv_reset_dirty_bitmap(s->copy_bitmap, start, status_bytes);
              progress_set_remaining(s->progress,
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
                                     s->in_flight_bytes);
              trace_block_copy_skip_range(s, start, status_bytes);
              start += status_bytes;
 +            bytes -= status_bytes;
              continue;
          }
 -        chunk_end = MIN(chunk_end, start + status_bytes);
 +        cur_bytes = MIN(cur_bytes, status_bytes);
          trace_block_copy_process(s, start);
 -        bdrv_reset_dirty_bitmap(s->copy_bitmap, start, chunk_end - start);
 -        s->in_flight_bytes += chunk_end - start;
 +        bdrv_reset_dirty_bitmap(s->copy_bitmap, start, cur_bytes);
 +        s->in_flight_bytes += cur_bytes;
 -        co_get_from_shres(s->mem, chunk_end - start);
 -        ret = block_copy_do_copy(s, start, chunk_end, ret & BDRV_BLOCK_ZERO,
 +        co_get_from_shres(s->mem, cur_bytes);
 +        ret = block_copy_do_copy(s, start, cur_bytes, ret & BDRV_BLOCK_ZERO,
                                   error_is_read);
 -        co_put_to_shres(s->mem, chunk_end - start);
 -        s->in_flight_bytes -= chunk_end - start;
 +        co_put_to_shres(s->mem, cur_bytes);
 +        s->in_flight_bytes -= cur_bytes;
          if (ret < 0) {
 -            bdrv_set_dirty_bitmap(s->copy_bitmap, start, chunk_end - start);
 +            bdrv_set_dirty_bitmap(s->copy_bitmap, start, cur_bytes);
              break;
          }
 -        progress_work_done(s->progress, chunk_end - start);
 -        s->progress_bytes_callback(chunk_end - start, s->progress_opaque);
 -        start = chunk_end;
 -        ret = 0;
 +        progress_work_done(s->progress, cur_bytes);
 +        s->progress_bytes_callback(cur_bytes, s->progress_opaque);
 +        start += cur_bytes;
 +        bytes -= cur_bytes;
      }
      block_copy_inflight_req_end(&req);
 diff --git a/include/block/block-copy.h b/include/block/block-copy.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block-copy.h
 +++ b/include/block/block-copy.h
@@ -XXX,XX +XXX,XX @@
  #include "qemu/co-shared-resource.h"
  typedef struct BlockCopyInFlightReq {
 -    int64_t start_byte;
 -    int64_t end_byte;
 +    int64_t start;
 +    int64_t bytes;
      QLIST_ENTRY(BlockCopyInFlightReq) list;
      CoQueue wait_queue; /* coroutines blocked on this request */
  } BlockCopyInFlightReq;
@@ -XXX,XX +XXX,XX @@ void block_copy_state_free(BlockCopyState *s);
  int64_t block_copy_reset_unallocated(BlockCopyState *s,
                                       int64_t offset, int64_t *count);
 -int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes,
 +int coroutine_fn block_copy(BlockCopyState *s, int64_t start, int64_t bytes,
                              bool *error_is_read);
  #endif /* BLOCK_COPY_H */
 --
 .24.1

-New patch
+[PULL 17/19] block/block-copy: rename start to offset in interfaces
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 offset/bytes pair is more usual naming in block layer, let's use it.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200311103004.7649-8-vsementsov@virtuozzo.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block/block-copy.c         | 82 +++++++++++++++++++-------------------
  include/block/block-copy.h |  4 +-
 files changed, 43 insertions(+), 43 deletions(-)
 diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-copy.c
 +++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@
  #define BLOCK_COPY_MAX_MEM (128 * MiB)
  static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
 -                                                           int64_t start,
 +                                                           int64_t offset,
                                                             int64_t bytes)
  {
      BlockCopyInFlightReq *req;
      QLIST_FOREACH(req, &s->inflight_reqs, list) {
 -        if (start + bytes > req->start && start < req->start + req->bytes) {
 +        if (offset + bytes > req->offset && offset < req->offset + req->bytes) {
              return req;
          }
      }
@@ -XXX,XX +XXX,XX @@ static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
  }
  static void coroutine_fn block_copy_wait_inflight_reqs(BlockCopyState *s,
 -                                                       int64_t start,
 +                                                       int64_t offset,
                                                         int64_t bytes)
  {
      BlockCopyInFlightReq *req;
 -    while ((req = find_conflicting_inflight_req(s, start, bytes))) {
 +    while ((req = find_conflicting_inflight_req(s, offset, bytes))) {
          qemu_co_queue_wait(&req->wait_queue, NULL);
      }
  }
  static void block_copy_inflight_req_begin(BlockCopyState *s,
                                            BlockCopyInFlightReq *req,
 -                                          int64_t start, int64_t bytes)
 +                                          int64_t offset, int64_t bytes)
  {
 -    req->start = start;
 +    req->offset = offset;
      req->bytes = bytes;
      qemu_co_queue_init(&req->wait_queue);
      QLIST_INSERT_HEAD(&s->inflight_reqs, req, list);
@@ -XXX,XX +XXX,XX @@ void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm)
   * Returns 0 on success.
   */
  static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
 -                                           int64_t start, int64_t bytes,
 +                                           int64_t offset, int64_t bytes,
                                             bool zeroes, bool *error_is_read)
  {
      int ret;
 -    int64_t nbytes = MIN(start + bytes, s->len) - start;
 +    int64_t nbytes = MIN(offset + bytes, s->len) - offset;
      void *bounce_buffer = NULL;
 -    assert(start >= 0 && bytes > 0 && INT64_MAX - start >= bytes);
 -    assert(QEMU_IS_ALIGNED(start, s->cluster_size));
 +    assert(offset >= 0 && bytes > 0 && INT64_MAX - offset >= bytes);
 +    assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
      assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
 -    assert(start < s->len);
 -    assert(start + bytes <= s->len ||
 -           start + bytes == QEMU_ALIGN_UP(s->len, s->cluster_size));
 +    assert(offset < s->len);
 +    assert(offset + bytes <= s->len ||
 +           offset + bytes == QEMU_ALIGN_UP(s->len, s->cluster_size));
      assert(nbytes < INT_MAX);
      if (zeroes) {
 -        ret = bdrv_co_pwrite_zeroes(s->target, start, nbytes, s->write_flags &
 +        ret = bdrv_co_pwrite_zeroes(s->target, offset, nbytes, s->write_flags &
                                      ~BDRV_REQ_WRITE_COMPRESSED);
          if (ret < 0) {
 -            trace_block_copy_write_zeroes_fail(s, start, ret);
 +            trace_block_copy_write_zeroes_fail(s, offset, ret);
              if (error_is_read) {
                  *error_is_read = false;
              }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
      }
      if (s->use_copy_range) {
 -        ret = bdrv_co_copy_range(s->source, start, s->target, start, nbytes,
 +        ret = bdrv_co_copy_range(s->source, offset, s->target, offset, nbytes,
 , s->write_flags);
          if (ret < 0) {
 -            trace_block_copy_copy_range_fail(s, start, ret);
 +            trace_block_copy_copy_range_fail(s, offset, ret);
              s->use_copy_range = false;
              s->copy_size = MAX(s->cluster_size, BLOCK_COPY_MAX_BUFFER);
              /* Fallback to read+write with allocated buffer */
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
      bounce_buffer = qemu_blockalign(s->source->bs, nbytes);
 -    ret = bdrv_co_pread(s->source, start, nbytes, bounce_buffer, 0);
 +    ret = bdrv_co_pread(s->source, offset, nbytes, bounce_buffer, 0);
      if (ret < 0) {
 -        trace_block_copy_read_fail(s, start, ret);
 +        trace_block_copy_read_fail(s, offset, ret);
          if (error_is_read) {
              *error_is_read = true;
          }
          goto out;
      }
 -    ret = bdrv_co_pwrite(s->target, start, nbytes, bounce_buffer,
 +    ret = bdrv_co_pwrite(s->target, offset, nbytes, bounce_buffer,
                           s->write_flags);
      if (ret < 0) {
 -        trace_block_copy_write_fail(s, start, ret);
 +        trace_block_copy_write_fail(s, offset, ret);
          if (error_is_read) {
              *error_is_read = false;
          }
@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
  }
  int coroutine_fn block_copy(BlockCopyState *s,
 -                            int64_t start, int64_t bytes,
 +                            int64_t offset, int64_t bytes,
                              bool *error_is_read)
  {
      int ret = 0;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
      assert(bdrv_get_aio_context(s->source->bs) ==
             bdrv_get_aio_context(s->target->bs));
 -    assert(QEMU_IS_ALIGNED(start, s->cluster_size));
 +    assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
      assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
 -    block_copy_wait_inflight_reqs(s, start, bytes);
 -    block_copy_inflight_req_begin(s, &req, start, bytes);
 +    block_copy_wait_inflight_reqs(s, offset, bytes);
 +    block_copy_inflight_req_begin(s, &req, offset, bytes);
      while (bytes) {
          int64_t next_zero, cur_bytes, status_bytes;
 -        if (!bdrv_dirty_bitmap_get(s->copy_bitmap, start)) {
 -            trace_block_copy_skip(s, start);
 -            start += s->cluster_size;
 +        if (!bdrv_dirty_bitmap_get(s->copy_bitmap, offset)) {
 +            trace_block_copy_skip(s, offset);
 +            offset += s->cluster_size;
              bytes -= s->cluster_size;
              continue; /* already copied */
          }
          cur_bytes = MIN(bytes, s->copy_size);
 -        next_zero = bdrv_dirty_bitmap_next_zero(s->copy_bitmap, start,
 +        next_zero = bdrv_dirty_bitmap_next_zero(s->copy_bitmap, offset,
                                                  cur_bytes);
          if (next_zero >= 0) {
 -            assert(next_zero > start); /* start is dirty */
 -            assert(next_zero < start + cur_bytes); /* no need to do MIN() */
 -            cur_bytes = next_zero - start;
 +            assert(next_zero > offset); /* offset is dirty */
 +            assert(next_zero < offset + cur_bytes); /* no need to do MIN() */
 +            cur_bytes = next_zero - offset;
          }
 -        ret = block_copy_block_status(s, start, cur_bytes, &status_bytes);
 +        ret = block_copy_block_status(s, offset, cur_bytes, &status_bytes);
          if (s->skip_unallocated && !(ret & BDRV_BLOCK_ALLOCATED)) {
 -            bdrv_reset_dirty_bitmap(s->copy_bitmap, start, status_bytes);
 +            bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, status_bytes);
              progress_set_remaining(s->progress,
                                     bdrv_get_dirty_count(s->copy_bitmap) +
                                     s->in_flight_bytes);
 -            trace_block_copy_skip_range(s, start, status_bytes);
 -            start += status_bytes;
 +            trace_block_copy_skip_range(s, offset, status_bytes);
 +            offset += status_bytes;
              bytes -= status_bytes;
              continue;
          }
          cur_bytes = MIN(cur_bytes, status_bytes);
 -        trace_block_copy_process(s, start);
 +        trace_block_copy_process(s, offset);
 -        bdrv_reset_dirty_bitmap(s->copy_bitmap, start, cur_bytes);
 +        bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, cur_bytes);
          s->in_flight_bytes += cur_bytes;
          co_get_from_shres(s->mem, cur_bytes);
 -        ret = block_copy_do_copy(s, start, cur_bytes, ret & BDRV_BLOCK_ZERO,
 +        ret = block_copy_do_copy(s, offset, cur_bytes, ret & BDRV_BLOCK_ZERO,
                                   error_is_read);
          co_put_to_shres(s->mem, cur_bytes);
          s->in_flight_bytes -= cur_bytes;
          if (ret < 0) {
 -            bdrv_set_dirty_bitmap(s->copy_bitmap, start, cur_bytes);
 +            bdrv_set_dirty_bitmap(s->copy_bitmap, offset, cur_bytes);
              break;
          }
          progress_work_done(s->progress, cur_bytes);
          s->progress_bytes_callback(cur_bytes, s->progress_opaque);
 -        start += cur_bytes;
 +        offset += cur_bytes;
          bytes -= cur_bytes;
      }
 diff --git a/include/block/block-copy.h b/include/block/block-copy.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block-copy.h
 +++ b/include/block/block-copy.h
@@ -XXX,XX +XXX,XX @@
  #include "qemu/co-shared-resource.h"
  typedef struct BlockCopyInFlightReq {
 -    int64_t start;
 +    int64_t offset;
      int64_t bytes;
      QLIST_ENTRY(BlockCopyInFlightReq) list;
      CoQueue wait_queue; /* coroutines blocked on this request */
@@ -XXX,XX +XXX,XX @@ void block_copy_state_free(BlockCopyState *s);
  int64_t block_copy_reset_unallocated(BlockCopyState *s,
                                       int64_t offset, int64_t *count);
 -int coroutine_fn block_copy(BlockCopyState *s, int64_t start, int64_t bytes,
 +int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes,
                              bool *error_is_read);
  #endif /* BLOCK_COPY_H */
 --
 .24.1

-New patch
+[PULL 18/19] block/block-copy: reduce intersecting request lock
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Currently, block_copy operation lock the whole requested region. But
 there is no reason to lock clusters, which are already copied, it will
 disturb other parallel block_copy requests for no reason.
 Let's instead do the following:
 Lock only sub-region, which we are going to operate on. Then, after
 copying all dirty sub-regions, we should wait for intersecting
 requests block-copy, if they failed, we should retry these new dirty
 clusters.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
 Message-Id: <20200311103004.7649-9-vsementsov@virtuozzo.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block/block-copy.c | 129 ++++++++++++++++++++++++++++++++++++---------
 file changed, 105 insertions(+), 24 deletions(-)
 diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-copy.c
 +++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
      return NULL;
  }
 -static void coroutine_fn block_copy_wait_inflight_reqs(BlockCopyState *s,
 -                                                       int64_t offset,
 -                                                       int64_t bytes)
 +/*
 + * If there are no intersecting requests return false. Otherwise, wait for the
 + * first found intersecting request to finish and return true.
 + */
 +static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t offset,
 +                                             int64_t bytes)
  {
 -    BlockCopyInFlightReq *req;
 +    BlockCopyInFlightReq *req = find_conflicting_inflight_req(s, offset, bytes);
 -    while ((req = find_conflicting_inflight_req(s, offset, bytes))) {
 -        qemu_co_queue_wait(&req->wait_queue, NULL);
 +    if (!req) {
 +        return false;
      }
 +
 +    qemu_co_queue_wait(&req->wait_queue, NULL);
 +
 +    return true;
  }
 +/* Called only on full-dirty region */
  static void block_copy_inflight_req_begin(BlockCopyState *s,
                                            BlockCopyInFlightReq *req,
                                            int64_t offset, int64_t bytes)
  {
 +    assert(!find_conflicting_inflight_req(s, offset, bytes));
 +
 +    bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
 +    s->in_flight_bytes += bytes;
 +
      req->offset = offset;
      req->bytes = bytes;
      qemu_co_queue_init(&req->wait_queue);
      QLIST_INSERT_HEAD(&s->inflight_reqs, req, list);
  }
 -static void coroutine_fn block_copy_inflight_req_end(BlockCopyInFlightReq *req)
 +/*
 + * block_copy_inflight_req_shrink
 + *
 + * Drop the tail of the request to be handled later. Set dirty bits back and
 + * wake up all requests waiting for us (may be some of them are not intersecting
 + * with shrunk request)
 + */
 +static void coroutine_fn block_copy_inflight_req_shrink(BlockCopyState *s,
 +        BlockCopyInFlightReq *req, int64_t new_bytes)
  {
 +    if (new_bytes == req->bytes) {
 +        return;
 +    }
 +
 +    assert(new_bytes > 0 && new_bytes < req->bytes);
 +
 +    s->in_flight_bytes -= req->bytes - new_bytes;
 +    bdrv_set_dirty_bitmap(s->copy_bitmap,
 +                          req->offset + new_bytes, req->bytes - new_bytes);
 +
 +    req->bytes = new_bytes;
 +    qemu_co_queue_restart_all(&req->wait_queue);
 +}
 +
 +static void coroutine_fn block_copy_inflight_req_end(BlockCopyState *s,
 +                                                     BlockCopyInFlightReq *req,
 +                                                     int ret)
 +{
 +    s->in_flight_bytes -= req->bytes;
 +    if (ret < 0) {
 +        bdrv_set_dirty_bitmap(s->copy_bitmap, req->offset, req->bytes);
 +    }
      QLIST_REMOVE(req, list);
      qemu_co_queue_restart_all(&req->wait_queue);
  }
@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
      return ret;
  }
 -int coroutine_fn block_copy(BlockCopyState *s,
 -                            int64_t offset, int64_t bytes,
 -                            bool *error_is_read)
 +/*
 + * block_copy_dirty_clusters
 + *
 + * Copy dirty clusters in @offset/@bytes range.
 + * Returns 1 if dirty clusters found and successfully copied, 0 if no dirty
 + * clusters found and -errno on failure.
 + */
 +static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s,
 +                                                  int64_t offset, int64_t bytes,
 +                                                  bool *error_is_read)
  {
      int ret = 0;
 -    BlockCopyInFlightReq req;
 +    bool found_dirty = false;
      /*
       * block_copy() user is responsible for keeping source and target in same
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
      assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
      assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
 -    block_copy_wait_inflight_reqs(s, offset, bytes);
 -    block_copy_inflight_req_begin(s, &req, offset, bytes);
 -
      while (bytes) {
 +        BlockCopyInFlightReq req;
          int64_t next_zero, cur_bytes, status_bytes;
          if (!bdrv_dirty_bitmap_get(s->copy_bitmap, offset)) {
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
              continue; /* already copied */
          }
 +        found_dirty = true;
 +
          cur_bytes = MIN(bytes, s->copy_size);
          next_zero = bdrv_dirty_bitmap_next_zero(s->copy_bitmap, offset,
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
              assert(next_zero < offset + cur_bytes); /* no need to do MIN() */
              cur_bytes = next_zero - offset;
          }
 +        block_copy_inflight_req_begin(s, &req, offset, cur_bytes);
          ret = block_copy_block_status(s, offset, cur_bytes, &status_bytes);
 +        assert(ret >= 0); /* never fail */
 +        cur_bytes = MIN(cur_bytes, status_bytes);
 +        block_copy_inflight_req_shrink(s, &req, cur_bytes);
          if (s->skip_unallocated && !(ret & BDRV_BLOCK_ALLOCATED)) {
 -            bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, status_bytes);
 +            block_copy_inflight_req_end(s, &req, 0);
              progress_set_remaining(s->progress,
                                     bdrv_get_dirty_count(s->copy_bitmap) +
                                     s->in_flight_bytes);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
              continue;
          }
 -        cur_bytes = MIN(cur_bytes, status_bytes);
 -
          trace_block_copy_process(s, offset);
 -        bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, cur_bytes);
 -        s->in_flight_bytes += cur_bytes;
 -
          co_get_from_shres(s->mem, cur_bytes);
          ret = block_copy_do_copy(s, offset, cur_bytes, ret & BDRV_BLOCK_ZERO,
                                   error_is_read);
          co_put_to_shres(s->mem, cur_bytes);
 -        s->in_flight_bytes -= cur_bytes;
 +        block_copy_inflight_req_end(s, &req, ret);
          if (ret < 0) {
 -            bdrv_set_dirty_bitmap(s->copy_bitmap, offset, cur_bytes);
 -            break;
 +            return ret;
          }
          progress_work_done(s->progress, cur_bytes);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
          bytes -= cur_bytes;
      }
 -    block_copy_inflight_req_end(&req);
 +    return found_dirty;
 +}
 +
 +/*
 + * block_copy
 + *
 + * Copy requested region, accordingly to dirty bitmap.
 + * Collaborate with parallel block_copy requests: if they succeed it will help
 + * us. If they fail, we will retry not-copied regions. So, if we return error,
 + * it means that some I/O operation failed in context of _this_ block_copy call,
 + * not some parallel operation.
 + */
 +int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes,
 +                            bool *error_is_read)
 +{
 +    int ret;
 +
 +    do {
 +        ret = block_copy_dirty_clusters(s, offset, bytes, error_is_read);
 +
 +        if (ret == 0) {
 +            ret = block_copy_wait_one(s, offset, bytes);
 +        }
 +
 +        /*
 +         * We retry in two cases:
 +         * 1. Some progress done
 +         *    Something was copied, which means that there were yield points
 +         *    and some new dirty bits may have appeared (due to failed parallel
 +         *    block-copy requests).
 +         * 2. We have waited for some intersecting block-copy request
 +         *    It may have failed and produced new dirty bits.
 +         */
 +    } while (ret > 0);
      return ret;
  }
 --
 .24.1

-New patch
+[PULL 19/19] block/block-copy: hide structure definitions
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Hide structure definitions and add explicit API instead, to keep an
 eye on the scope of the shared fields.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200311103004.7649-10-vsementsov@virtuozzo.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block/backup-top.c         |  6 ++--
  block/backup.c             | 25 ++++++++--------
  block/block-copy.c         | 59 ++++++++++++++++++++++++++++++++++++++
  include/block/block-copy.h | 52 +++------------------------------
 files changed, 80 insertions(+), 62 deletions(-)
 diff --git a/block/backup-top.c b/block/backup-top.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/backup-top.c
 +++ b/block/backup-top.c
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVBackupTopState {
      BlockCopyState *bcs;
      BdrvChild *target;
      bool active;
 +    int64_t cluster_size;
  } BDRVBackupTopState;
  static coroutine_fn int backup_top_co_preadv(
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int backup_top_cbw(BlockDriverState *bs, uint64_t offset,
          return 0;
      }
 -    off = QEMU_ALIGN_DOWN(offset, s->bcs->cluster_size);
 -    end = QEMU_ALIGN_UP(offset + bytes, s->bcs->cluster_size);
 +    off = QEMU_ALIGN_DOWN(offset, s->cluster_size);
 +    end = QEMU_ALIGN_UP(offset + bytes, s->cluster_size);
      return block_copy(s->bcs, off, end - off, NULL);
  }
@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_backup_top_append(BlockDriverState *source,
          goto fail;
      }
 +    state->cluster_size = cluster_size;
      state->bcs = block_copy_state_new(top->backing, state->target,
                                        cluster_size, write_flags, &local_err);
      if (local_err) {
 diff --git a/block/backup.c b/block/backup.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/backup.c
 +++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)
      if (ret < 0 && job->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS) {
          /* If we failed and synced, merge in the bits we didn't copy: */
 -        bdrv_dirty_bitmap_merge_internal(bm, job->bcs->copy_bitmap,
 +        bdrv_dirty_bitmap_merge_internal(bm, block_copy_dirty_bitmap(job->bcs),
                                           NULL, true);
      }
  }
@@ -XXX,XX +XXX,XX @@ void backup_do_checkpoint(BlockJob *job, Error **errp)
          return;
      }
 -    bdrv_set_dirty_bitmap(backup_job->bcs->copy_bitmap, 0, backup_job->len);
 +    bdrv_set_dirty_bitmap(block_copy_dirty_bitmap(backup_job->bcs), 0,
 +                          backup_job->len);
  }
  static BlockErrorAction backup_error_action(BackupBlockJob *job,
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_loop(BackupBlockJob *job)
      BdrvDirtyBitmapIter *bdbi;
      int ret = 0;
 -    bdbi = bdrv_dirty_iter_new(job->bcs->copy_bitmap);
 +    bdbi = bdrv_dirty_iter_new(block_copy_dirty_bitmap(job->bcs));
      while ((offset = bdrv_dirty_iter_next(bdbi)) != -1) {
          do {
              if (yield_and_check(job)) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_loop(BackupBlockJob *job)
      return ret;
  }
 -static void backup_init_copy_bitmap(BackupBlockJob *job)
 +static void backup_init_bcs_bitmap(BackupBlockJob *job)
  {
      bool ret;
      uint64_t estimate;
 +    BdrvDirtyBitmap *bcs_bitmap = block_copy_dirty_bitmap(job->bcs);
      if (job->sync_mode == MIRROR_SYNC_MODE_BITMAP) {
 -        ret = bdrv_dirty_bitmap_merge_internal(job->bcs->copy_bitmap,
 -                                               job->sync_bitmap,
 +        ret = bdrv_dirty_bitmap_merge_internal(bcs_bitmap, job->sync_bitmap,
                                                 NULL, true);
          assert(ret);
      } else {
@@ -XXX,XX +XXX,XX @@ static void backup_init_copy_bitmap(BackupBlockJob *job)
               * We can't hog the coroutine to initialize this thoroughly.
               * Set a flag and resume work when we are able to yield safely.
               */
 -            job->bcs->skip_unallocated = true;
 +            block_copy_set_skip_unallocated(job->bcs, true);
          }
 -        bdrv_set_dirty_bitmap(job->bcs->copy_bitmap, 0, job->len);
 +        bdrv_set_dirty_bitmap(bcs_bitmap, 0, job->len);
      }
 -    estimate = bdrv_get_dirty_count(job->bcs->copy_bitmap);
 +    estimate = bdrv_get_dirty_count(bcs_bitmap);
      job_progress_set_remaining(&job->common.job, estimate);
  }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_run(Job *job, Error **errp)
      BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
      int ret = 0;
 -    backup_init_copy_bitmap(s);
 +    backup_init_bcs_bitmap(s);
      if (s->sync_mode == MIRROR_SYNC_MODE_TOP) {
          int64_t offset = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_run(Job *job, Error **errp)
              offset += count;
          }
 -        s->bcs->skip_unallocated = false;
 +        block_copy_set_skip_unallocated(s->bcs, false);
      }
      if (s->sync_mode == MIRROR_SYNC_MODE_NONE) {
          /*
 -         * All bits are set in copy_bitmap to allow any cluster to be copied.
 +         * All bits are set in bcs bitmap to allow any cluster to be copied.
           * This does not actually require them to be copied.
           */
          while (!job_is_cancelled(job)) {
 diff --git a/block/block-copy.c b/block/block-copy.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-copy.c
 +++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@
  #define BLOCK_COPY_MAX_BUFFER (1 * MiB)
  #define BLOCK_COPY_MAX_MEM (128 * MiB)
 +typedef struct BlockCopyInFlightReq {
 +    int64_t offset;
 +    int64_t bytes;
 +    QLIST_ENTRY(BlockCopyInFlightReq) list;
 +    CoQueue wait_queue; /* coroutines blocked on this request */
 +} BlockCopyInFlightReq;
 +
 +typedef struct BlockCopyState {
 +    /*
 +     * BdrvChild objects are not owned or managed by block-copy. They are
 +     * provided by block-copy user and user is responsible for appropriate
 +     * permissions on these children.
 +     */
 +    BdrvChild *source;
 +    BdrvChild *target;
 +    BdrvDirtyBitmap *copy_bitmap;
 +    int64_t in_flight_bytes;
 +    int64_t cluster_size;
 +    bool use_copy_range;
 +    int64_t copy_size;
 +    uint64_t len;
 +    QLIST_HEAD(, BlockCopyInFlightReq) inflight_reqs;
 +
 +    BdrvRequestFlags write_flags;
 +
 +    /*
 +     * skip_unallocated:
 +     *
 +     * Used by sync=top jobs, which first scan the source node for unallocated
 +     * areas and clear them in the copy_bitmap.  During this process, the bitmap
 +     * is thus not fully initialized: It may still have bits set for areas that
 +     * are unallocated and should actually not be copied.
 +     *
 +     * This is indicated by skip_unallocated.
 +     *
 +     * In this case, block_copy() will query the source’s allocation status,
 +     * skip unallocated regions, clear them in the copy_bitmap, and invoke
 +     * block_copy_reset_unallocated() every time it does.
 +     */
 +    bool skip_unallocated;
 +
 +    ProgressMeter *progress;
 +    /* progress_bytes_callback: called when some copying progress is done. */
 +    ProgressBytesCallbackFunc progress_bytes_callback;
 +    void *progress_opaque;
 +
 +    SharedResource *mem;
 +} BlockCopyState;
 +
  static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
                                                             int64_t offset,
                                                             int64_t bytes)
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes,
      return ret;
  }
 +
 +BdrvDirtyBitmap *block_copy_dirty_bitmap(BlockCopyState *s)
 +{
 +    return s->copy_bitmap;
 +}
 +
 +void block_copy_set_skip_unallocated(BlockCopyState *s, bool skip)
 +{
 +    s->skip_unallocated = skip;
 +}
 diff --git a/include/block/block-copy.h b/include/block/block-copy.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block-copy.h
 +++ b/include/block/block-copy.h
@@ -XXX,XX +XXX,XX @@
  #include "block/block.h"
  #include "qemu/co-shared-resource.h"
 -typedef struct BlockCopyInFlightReq {
 -    int64_t offset;
 -    int64_t bytes;
 -    QLIST_ENTRY(BlockCopyInFlightReq) list;
 -    CoQueue wait_queue; /* coroutines blocked on this request */
 -} BlockCopyInFlightReq;
 -
  typedef void (*ProgressBytesCallbackFunc)(int64_t bytes, void *opaque);
 -typedef struct BlockCopyState {
 -    /*
 -     * BdrvChild objects are not owned or managed by block-copy. They are
 -     * provided by block-copy user and user is responsible for appropriate
 -     * permissions on these children.
 -     */
 -    BdrvChild *source;
 -    BdrvChild *target;
 -    BdrvDirtyBitmap *copy_bitmap;
 -    int64_t in_flight_bytes;
 -    int64_t cluster_size;
 -    bool use_copy_range;
 -    int64_t copy_size;
 -    uint64_t len;
 -    QLIST_HEAD(, BlockCopyInFlightReq) inflight_reqs;
 -
 -    BdrvRequestFlags write_flags;
 -
 -    /*
 -     * skip_unallocated:
 -     *
 -     * Used by sync=top jobs, which first scan the source node for unallocated
 -     * areas and clear them in the copy_bitmap.  During this process, the bitmap
 -     * is thus not fully initialized: It may still have bits set for areas that
 -     * are unallocated and should actually not be copied.
 -     *
 -     * This is indicated by skip_unallocated.
 -     *
 -     * In this case, block_copy() will query the source’s allocation status,
 -     * skip unallocated regions, clear them in the copy_bitmap, and invoke
 -     * block_copy_reset_unallocated() every time it does.
 -     */
 -    bool skip_unallocated;
 -
 -    ProgressMeter *progress;
 -    /* progress_bytes_callback: called when some copying progress is done. */
 -    ProgressBytesCallbackFunc progress_bytes_callback;
 -    void *progress_opaque;
 -
 -    SharedResource *mem;
 -} BlockCopyState;
 +typedef struct BlockCopyState BlockCopyState;
  BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
                                       int64_t cluster_size,
@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
  int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes,
                              bool *error_is_read);
 +BdrvDirtyBitmap *block_copy_dirty_bitmap(BlockCopyState *s);
 +void block_copy_set_skip_unallocated(BlockCopyState *s, bool skip);
 +
  #endif /* BLOCK_COPY_H */
 --
 .24.1

The following changes since commit bfec359afba088aaacc7d316f43302f28c6e642a:

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

are available in the git repository at:

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

for you to fetch changes up to 1507631e438930bc07f776f303af127a9cdb4d41:

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

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

Block patches for 2.10

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

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

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

-- 
2.9.3

From: Ashish Mittal <ashmit602@gmail.com>

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

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

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

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

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

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

From: Ashish Mittal <ashmit602@gmail.com>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Move bdrv_is_read_only() up with its friends.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

The following changes since commit ba29883206d92a29ad5a466e679ccfc2ee6132ef:

Merge remote-tracking branch 'remotes/borntraeger/tags/s390x-20200310' into staging (2020-03-10 16:50:28 +0000)

are available in the Git repository at:

https://github.com/XanClic/qemu.git tags/pull-block-2020-03-11

for you to fetch changes up to 397f4e9d83e9c0000905f0a988ba1aeda162571c:

block/block-copy: hide structure definitions (2020-03-11 12:42:30 +0100)

----------------------------------------------------------------
Block patches for the 5.0 softfreeze:
- qemu-img measure for LUKS
- Improve block-copy's performance by reducing inter-request
  dependencies
- Make curl's detection of accept-ranges more robust
- Memleak fixes
- iotest fix

----------------------------------------------------------------
David Edmondson (2):
  block/curl: HTTP header fields allow whitespace around values
  block/curl: HTTP header field names are case insensitive

Eric Blake (1):
  iotests: Fix nonportable use of od --endian

Pan Nengyuan (2):
  block/qcow2: do free crypto_opts in qcow2_close()
  qemu-img: free memory before re-assign

Stefan Hajnoczi (4):
  luks: extract qcrypto_block_calculate_payload_offset()
  luks: implement .bdrv_measure()
  qemu-img: allow qemu-img measure --object without a filename
  iotests: add 288 luks qemu-img measure test

Vladimir Sementsov-Ogievskiy (10):
  block/qcow2-threads: fix qcow2_decompress
  job: refactor progress to separate object
  block/block-copy: fix progress calculation
  block/block-copy: specialcase first copy_range request
  block/block-copy: use block_status
  block/block-copy: factor out find_conflicting_inflight_req
  block/block-copy: refactor interfaces to use bytes instead of end
  block/block-copy: rename start to offset in interfaces
  block/block-copy: reduce intersecting request lock
  block/block-copy: hide structure definitions

-- 
2.24.1

From: Stefan Hajnoczi <stefanha@redhat.com>

The qcow2 .bdrv_measure() code calculates the crypto payload offset.
This logic really belongs in crypto/block.c where it can be reused by
other image formats.

The "luks" block driver will need this same logic in order to implement
.bdrv_measure(), so extract the qcrypto_block_calculate_payload_offset()
function now.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200221112522.1497712-2-stefanha@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/qcow2.c          | 74 +++++++++++-------------------------------
 crypto/block.c         | 36 ++++++++++++++++++++
 include/crypto/block.h | 22 +++++++++++++
 3 files changed, 77 insertions(+), 55 deletions(-)

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_flush_to_os(BlockDriverState *bs)
     return ret;
 }
 
-static ssize_t qcow2_measure_crypto_hdr_init_func(QCryptoBlock *block,
-        size_t headerlen, void *opaque, Error **errp)
-{
-    size_t *headerlenp = opaque;
-
-    /* Stash away the payload size */
-    *headerlenp = headerlen;
-    return 0;
-}
-
-static ssize_t qcow2_measure_crypto_hdr_write_func(QCryptoBlock *block,
-        size_t offset, const uint8_t *buf, size_t buflen,
-        void *opaque, Error **errp)
-{
-    /* Discard the bytes, we're not actually writing to an image */
-    return buflen;
-}
-
-/* Determine the number of bytes for the LUKS payload */
-static bool qcow2_measure_luks_headerlen(QemuOpts *opts, size_t *len,
-                                         Error **errp)
-{
-    QDict *opts_qdict;
-    QDict *cryptoopts_qdict;
-    QCryptoBlockCreateOptions *cryptoopts;
-    QCryptoBlock *crypto;
-
-    /* Extract "encrypt." options into a qdict */
-    opts_qdict = qemu_opts_to_qdict(opts, NULL);
-    qdict_extract_subqdict(opts_qdict, &cryptoopts_qdict, "encrypt.");
-    qobject_unref(opts_qdict);
-
-    /* Build QCryptoBlockCreateOptions object from qdict */
-    qdict_put_str(cryptoopts_qdict, "format", "luks");
-    cryptoopts = block_crypto_create_opts_init(cryptoopts_qdict, errp);
-    qobject_unref(cryptoopts_qdict);
-    if (!cryptoopts) {
-        return false;
-    }
-
-    /* Fake LUKS creation in order to determine the payload size */
-    crypto = qcrypto_block_create(cryptoopts, "encrypt.",
-                                  qcow2_measure_crypto_hdr_init_func,
-                                  qcow2_measure_crypto_hdr_write_func,
-                                  len, errp);
-    qapi_free_QCryptoBlockCreateOptions(cryptoopts);
-    if (!crypto) {
-        return false;
-    }
-
-    qcrypto_block_free(crypto);
-    return true;
-}
-
 static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,
                                        Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ static BlockMeasureInfo *qcow2_measure(QemuOpts *opts, BlockDriverState *in_bs,
     g_free(optstr);
 
     if (has_luks) {
+        g_autoptr(QCryptoBlockCreateOptions) create_opts = NULL;
+        QDict *opts_qdict;
+        QDict *cryptoopts;
         size_t headerlen;
 
-        if (!qcow2_measure_luks_headerlen(opts, &headerlen, &local_err)) {
+        opts_qdict = qemu_opts_to_qdict(opts, NULL);
+        qdict_extract_subqdict(opts_qdict, &cryptoopts, "encrypt.");
+        qobject_unref(opts_qdict);
+
+        qdict_put_str(cryptoopts, "format", "luks");
+
+        create_opts = block_crypto_create_opts_init(cryptoopts, errp);
+        qobject_unref(cryptoopts);
+        if (!create_opts) {
+            goto err;
+        }
+
+        if (!qcrypto_block_calculate_payload_offset(create_opts,
+                                                    "encrypt.",
+                                                    &headerlen,
+                                                    &local_err)) {
             goto err;
         }
 
diff --git a/crypto/block.c b/crypto/block.c
index XXXXXXX..XXXXXXX 100644
--- a/crypto/block.c
+++ b/crypto/block.c
@@ -XXX,XX +XXX,XX @@ QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
 }
 
 
+static ssize_t qcrypto_block_headerlen_hdr_init_func(QCryptoBlock *block,
+        size_t headerlen, void *opaque, Error **errp)
+{
+    size_t *headerlenp = opaque;
+
+    /* Stash away the payload size */
+    *headerlenp = headerlen;
+    return 0;
+}
+
+
+static ssize_t qcrypto_block_headerlen_hdr_write_func(QCryptoBlock *block,
+        size_t offset, const uint8_t *buf, size_t buflen,
+        void *opaque, Error **errp)
+{
+    /* Discard the bytes, we're not actually writing to an image */
+    return buflen;
+}
+
+
+bool
+qcrypto_block_calculate_payload_offset(QCryptoBlockCreateOptions *create_opts,
+                                       const char *optprefix,
+                                       size_t *len,
+                                       Error **errp)
+{
+    /* Fake LUKS creation in order to determine the payload size */
+    g_autoptr(QCryptoBlock) crypto =
+        qcrypto_block_create(create_opts, optprefix,
+                             qcrypto_block_headerlen_hdr_init_func,
+                             qcrypto_block_headerlen_hdr_write_func,
+                             len, errp);
+    return crypto != NULL;
+}
+
+
 QCryptoBlockInfo *qcrypto_block_get_info(QCryptoBlock *block,
                                          Error **errp)
 {
diff --git a/include/crypto/block.h b/include/crypto/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/crypto/block.h
+++ b/include/crypto/block.h
@@ -XXX,XX +XXX,XX @@ QCryptoBlock *qcrypto_block_create(QCryptoBlockCreateOptions *options,
                                    Error **errp);
 
 
+/**
+ * qcrypto_block_calculate_payload_offset:
+ * @create_opts: the encryption options
+ * @optprefix: name prefix for options
+ * @len: output for number of header bytes before payload
+ * @errp: pointer to a NULL-initialized error object
+ *
+ * Calculate the number of header bytes before the payload in an encrypted
+ * storage volume.  The header is an area before the payload that is reserved
+ * for encryption metadata.
+ *
+ * Returns: true on success, false on error
+ */
+bool
+qcrypto_block_calculate_payload_offset(QCryptoBlockCreateOptions *create_opts,
+                                       const char *optprefix,
+                                       size_t *len,
+                                       Error **errp);
+
+
 /**
  * qcrypto_block_get_info:
  * @block: the block encryption object
@@ -XXX,XX +XXX,XX @@ uint64_t qcrypto_block_get_sector_size(QCryptoBlock *block);
 void qcrypto_block_free(QCryptoBlock *block);
 
 G_DEFINE_AUTOPTR_CLEANUP_FUNC(QCryptoBlock, qcrypto_block_free)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(QCryptoBlockCreateOptions,
+                              qapi_free_QCryptoBlockCreateOptions)
 
 #endif /* QCRYPTO_BLOCK_H */
-- 
2.24.1

From: Stefan Hajnoczi <stefanha@redhat.com>

Add qemu-img measure support in the "luks" block driver.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200221112522.1497712-3-stefanha@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/crypto.c | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static int64_t block_crypto_getlength(BlockDriverState *bs)
 }
 
 
+static BlockMeasureInfo *block_crypto_measure(QemuOpts *opts,
+                                              BlockDriverState *in_bs,
+                                              Error **errp)
+{
+    g_autoptr(QCryptoBlockCreateOptions) create_opts = NULL;
+    Error *local_err = NULL;
+    BlockMeasureInfo *info;
+    uint64_t size;
+    size_t luks_payload_size;
+    QDict *cryptoopts;
+
+    /*
+     * Preallocation mode doesn't affect size requirements but we must consume
+     * the option.
+     */
+    g_free(qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC));
+
+    size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
+
+    if (in_bs) {
+        int64_t ssize = bdrv_getlength(in_bs);
+
+        if (ssize < 0) {
+            error_setg_errno(&local_err, -ssize,
+                             "Unable to get image virtual_size");
+            goto err;
+        }
+
+        size = ssize;
+    }
+
+    cryptoopts = qemu_opts_to_qdict_filtered(opts, NULL,
+            &block_crypto_create_opts_luks, true);
+    qdict_put_str(cryptoopts, "format", "luks");
+    create_opts = block_crypto_create_opts_init(cryptoopts, &local_err);
+    qobject_unref(cryptoopts);
+    if (!create_opts) {
+        goto err;
+    }
+
+    if (!qcrypto_block_calculate_payload_offset(create_opts, NULL,
+                                                &luks_payload_size,
+                                                &local_err)) {
+        goto err;
+    }
+
+    /*
+     * Unallocated blocks are still encrypted so allocation status makes no
+     * difference to the file size.
+     */
+    info = g_new(BlockMeasureInfo, 1);
+    info->fully_allocated = luks_payload_size + size;
+    info->required = luks_payload_size + size;
+    return info;
+
+err:
+    error_propagate(errp, local_err);
+    return NULL;
+}
+
+
 static int block_crypto_probe_luks(const uint8_t *buf,
                                    int buf_size,
                                    const char *filename) {
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_crypto_luks = {
     .bdrv_co_preadv     = block_crypto_co_preadv,
     .bdrv_co_pwritev    = block_crypto_co_pwritev,
     .bdrv_getlength     = block_crypto_getlength,
+    .bdrv_measure       = block_crypto_measure,
     .bdrv_get_info      = block_crypto_get_info_luks,
     .bdrv_get_specific_info = block_crypto_get_specific_info_luks,
 
-- 
2.24.1

From: Stefan Hajnoczi <stefanha@redhat.com>

In most qemu-img sub-commands the --object option only makes sense when
there is a filename.  qemu-img measure is an exception because objects
may be referenced from the image creation options instead of an existing
image file.  Allow --object without a filename.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200221112522.1497712-4-stefanha@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qemu-img.c                       | 6 ++----
 tests/qemu-iotests/178           | 2 +-
 tests/qemu-iotests/178.out.qcow2 | 8 ++++----
 tests/qemu-iotests/178.out.raw   | 8 ++++----
 4 files changed, 11 insertions(+), 13 deletions(-)

diff --git a/qemu-img.c b/qemu-img.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -XXX,XX +XXX,XX @@ static int img_measure(int argc, char **argv)
         filename = argv[optind];
     }
 
-    if (!filename &&
-        (object_opts || image_opts || fmt || snapshot_name || sn_opts)) {
-        error_report("--object, --image-opts, -f, and -l "
-                     "require a filename argument.");
+    if (!filename && (image_opts || fmt || snapshot_name || sn_opts)) {
+        error_report("--image-opts, -f, and -l require a filename argument.");
         goto out;
     }
     if (filename && img_size != UINT64_MAX) {
diff --git a/tests/qemu-iotests/178 b/tests/qemu-iotests/178
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/178
+++ b/tests/qemu-iotests/178
@@ -XXX,XX +XXX,XX @@ _make_test_img 1G
 $QEMU_IMG measure # missing arguments
 $QEMU_IMG measure --size 2G "$TEST_IMG" # only one allowed
 $QEMU_IMG measure "$TEST_IMG" a # only one filename allowed
-$QEMU_IMG measure --object secret,id=sec0,data=MTIzNDU2,format=base64 # missing filename
+$QEMU_IMG measure --object secret,id=sec0,data=MTIzNDU2,format=base64 # size or filename needed
 $QEMU_IMG measure --image-opts # missing filename
 $QEMU_IMG measure -f qcow2 # missing filename
 $QEMU_IMG measure -l snap1 # missing filename
diff --git a/tests/qemu-iotests/178.out.qcow2 b/tests/qemu-iotests/178.out.qcow2
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/178.out.qcow2
+++ b/tests/qemu-iotests/178.out.qcow2
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
 qemu-img: Either --size N or one filename must be specified.
 qemu-img: --size N cannot be used together with a filename.
 qemu-img: At most one filename argument is allowed.
-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
+qemu-img: Either --size N or one filename must be specified.
+qemu-img: --image-opts, -f, and -l require a filename argument.
+qemu-img: --image-opts, -f, and -l require a filename argument.
+qemu-img: --image-opts, -f, and -l require a filename argument.
 qemu-img: Invalid option list: ,
 qemu-img: Invalid parameter 'snapshot.foo'
 qemu-img: Failed in parsing snapshot param 'snapshot.foo'
diff --git a/tests/qemu-iotests/178.out.raw b/tests/qemu-iotests/178.out.raw
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/178.out.raw
+++ b/tests/qemu-iotests/178.out.raw
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
 qemu-img: Either --size N or one filename must be specified.
 qemu-img: --size N cannot be used together with a filename.
 qemu-img: At most one filename argument is allowed.
-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
-qemu-img: --object, --image-opts, -f, and -l require a filename argument.
+qemu-img: Either --size N or one filename must be specified.
+qemu-img: --image-opts, -f, and -l require a filename argument.
+qemu-img: --image-opts, -f, and -l require a filename argument.
+qemu-img: --image-opts, -f, and -l require a filename argument.
 qemu-img: Invalid option list: ,
 qemu-img: Invalid parameter 'snapshot.foo'
 qemu-img: Failed in parsing snapshot param 'snapshot.foo'
-- 
2.24.1

From: Stefan Hajnoczi <stefanha@redhat.com>

This test exercises the block/crypto.c "luks" block driver
.bdrv_measure() code.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200221112522.1497712-5-stefanha@redhat.com>
[mreitz: Renamed test from 282 to 288]
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/288     | 93 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/288.out | 30 ++++++++++++
 tests/qemu-iotests/group   |  1 +
 3 files changed, 124 insertions(+)
 create mode 100755 tests/qemu-iotests/288
 create mode 100644 tests/qemu-iotests/288.out

diff --git a/tests/qemu-iotests/288 b/tests/qemu-iotests/288
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/288
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env bash
+#
+# qemu-img measure tests for LUKS images
+#
+# Copyright (C) 2020 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# creator
+owner=stefanha@redhat.com
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+status=1    # failure is the default!
+
+_cleanup()
+{
+    _cleanup_test_img
+    rm -f "$TEST_IMG.converted"
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+. ./common.pattern
+
+_supported_fmt luks
+_supported_proto file
+_supported_os Linux
+
+SECRET=secret,id=sec0,data=passphrase
+
+echo "== measure 1G image file =="
+echo
+
+$QEMU_IMG measure --object "$SECRET" \
+	          -O "$IMGFMT" \
+		  -o key-secret=sec0,iter-time=10 \
+		  --size 1G
+
+echo
+echo "== create 1G image file (size should be no greater than measured) =="
+echo
+
+_make_test_img 1G
+stat -c "image file size in bytes: %s" "$TEST_IMG_FILE"
+
+echo
+echo "== modified 1G image file (size should be no greater than measured) =="
+echo
+
+$QEMU_IO --object "$SECRET" --image-opts "$TEST_IMG" -c "write -P 0x51 0x10000 0x400" | _filter_qemu_io | _filter_testdir
+stat -c "image file size in bytes: %s" "$TEST_IMG_FILE"
+
+echo
+echo "== measure preallocation=falloc 1G image file =="
+echo
+
+$QEMU_IMG measure --object "$SECRET" \
+	          -O "$IMGFMT" \
+		  -o key-secret=sec0,iter-time=10,preallocation=falloc \
+		  --size 1G
+
+echo
+echo "== measure with input image file =="
+echo
+
+IMGFMT=raw IMGKEYSECRET= IMGOPTS= _make_test_img 1G | _filter_imgfmt
+QEMU_IO_OPTIONS= IMGOPTSSYNTAX= $QEMU_IO -f raw -c "write -P 0x51 0x10000 0x400" "$TEST_IMG_FILE" | _filter_qemu_io | _filter_testdir
+$QEMU_IMG measure --object "$SECRET" \
+	          -O "$IMGFMT" \
+		  -o key-secret=sec0,iter-time=10 \
+		  -f raw \
+		  "$TEST_IMG_FILE"
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/288.out b/tests/qemu-iotests/288.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/288.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 288
+== measure 1G image file ==
+
+required size: 1075810304
+fully allocated size: 1075810304
+
+== create 1G image file (size should be no greater than measured) ==
+
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
+image file size in bytes: 1075810304
+
+== modified 1G image file (size should be no greater than measured) ==
+
+wrote 1024/1024 bytes at offset 65536
+1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+image file size in bytes: 1075810304
+
+== measure preallocation=falloc 1G image file ==
+
+required size: 1075810304
+fully allocated size: 1075810304
+
+== measure with input image file ==
+
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824
+wrote 1024/1024 bytes at offset 65536
+1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+required size: 1075810304
+fully allocated size: 1075810304
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 283 auto quick
 284 rw
 286 rw quick
+288 quick
-- 
2.24.1

From: David Edmondson <david.edmondson@oracle.com>

RFC 7230 section 3.2 indicates that whitespace is permitted between
the field name and field value and after the field value.

Signed-off-by: David Edmondson <david.edmondson@oracle.com>
Message-Id: <20200224101310.101169-2-david.edmondson@oracle.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/curl.c | 31 +++++++++++++++++++++++++++----
 1 file changed, 27 insertions(+), 4 deletions(-)

diff --git a/block/curl.c b/block/curl.c
index XXXXXXX..XXXXXXX 100644
--- a/block/curl.c
+++ b/block/curl.c
@@ -XXX,XX +XXX,XX @@ static size_t curl_header_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
 {
     BDRVCURLState *s = opaque;
     size_t realsize = size * nmemb;
-    const char *accept_line = "Accept-Ranges: bytes";
+    const char *header = (char *)ptr;
+    const char *end = header + realsize;
+    const char *accept_ranges = "Accept-Ranges:";
+    const char *bytes = "bytes";
 
-    if (realsize >= strlen(accept_line)
-        && strncmp((char *)ptr, accept_line, strlen(accept_line)) == 0) {
-        s->accept_range = true;
+    if (realsize >= strlen(accept_ranges)
+        && strncmp(header, accept_ranges, strlen(accept_ranges)) == 0) {
+
+        char *p = strchr(header, ':') + 1;
+
+        /* Skip whitespace between the header name and value. */
+        while (p < end && *p && g_ascii_isspace(*p)) {
+            p++;
+        }
+
+        if (end - p >= strlen(bytes)
+            && strncmp(p, bytes, strlen(bytes)) == 0) {
+
+            /* Check that there is nothing but whitespace after the value. */
+            p += strlen(bytes);
+            while (p < end && *p && g_ascii_isspace(*p)) {
+                p++;
+            }
+
+            if (p == end || !*p) {
+                s->accept_range = true;
+            }
+        }
     }
 
     return realsize;
-- 
2.24.1

From: David Edmondson <david.edmondson@oracle.com>

RFC 7230 section 3.2 indicates that HTTP header field names are case
insensitive.

Signed-off-by: David Edmondson <david.edmondson@oracle.com>
Message-Id: <20200224101310.101169-3-david.edmondson@oracle.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/curl.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/block/curl.c b/block/curl.c
index XXXXXXX..XXXXXXX 100644
--- a/block/curl.c
+++ b/block/curl.c
@@ -XXX,XX +XXX,XX @@ static size_t curl_header_cb(void *ptr, size_t size, size_t nmemb, void *opaque)
     size_t realsize = size * nmemb;
     const char *header = (char *)ptr;
     const char *end = header + realsize;
-    const char *accept_ranges = "Accept-Ranges:";
+    const char *accept_ranges = "accept-ranges:";
     const char *bytes = "bytes";
 
     if (realsize >= strlen(accept_ranges)
-        && strncmp(header, accept_ranges, strlen(accept_ranges)) == 0) {
+        && g_ascii_strncasecmp(header, accept_ranges,
+                               strlen(accept_ranges)) == 0) {
 
         char *p = strchr(header, ':') + 1;
 
-- 
2.24.1

From: Eric Blake <eblake@redhat.com>

Tests 261 and 272 fail on RHEL 7 with coreutils 8.22, since od
--endian was not added until coreutils 8.23.  Fix this by manually
constructing the final value one byte at a time.

Fixes: fc8ba423
Reported-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200226125424.481840-1-eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/common.rc | 22 +++++++++++++++++-----
 1 file changed, 17 insertions(+), 5 deletions(-)

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 @@ poke_file()
 # peek_file_le 'test.img' 512 2 => 65534
 peek_file_le()
 {
-    # Wrap in echo $() to strip spaces
-    echo $(od -j"$2" -N"$3" --endian=little -An -vtu"$3" "$1")
+    local val=0 shift=0 byte
+
+    # coreutils' od --endian is not portable, so manually assemble bytes.
+    for byte in $(od -j"$2" -N"$3" -An -v -tu1 "$1"); do
+        val=$(( val | (byte << shift) ))
+        shift=$((shift + 8))
+    done
+    printf %llu $val
 }
 
 # peek_file_be 'test.img' 512 2 => 65279
 peek_file_be()
 {
-    # Wrap in echo $() to strip spaces
-    echo $(od -j"$2" -N"$3" --endian=big -An -vtu"$3" "$1")
+    local val=0 byte
+
+    # coreutils' od --endian is not portable, so manually assemble bytes.
+    for byte in $(od -j"$2" -N"$3" -An -v -tu1 "$1"); do
+        val=$(( (val << 8) | byte ))
+    done
+    printf %llu $val
 }
 
-# peek_file_raw 'test.img' 512 2 => '\xff\xfe'
+# peek_file_raw 'test.img' 512 2 => '\xff\xfe'. Do not use if the raw data
+# is likely to contain \0 or trailing \n.
 peek_file_raw()
 {
     dd if="$1" bs=1 skip="$2" count="$3" status=none
-- 
2.24.1

From: Pan Nengyuan <pannengyuan@huawei.com>

'crypto_opts' forgot to free in qcow2_close(), this patch fix the bellow leak stack:

Direct leak of 24 byte(s) in 1 object(s) allocated from:
    #0 0x7f0edd81f970 in __interceptor_calloc (/lib64/libasan.so.5+0xef970)
    #1 0x7f0edc6d149d in g_malloc0 (/lib64/libglib-2.0.so.0+0x5249d)
    #2 0x55d7eaede63d in qobject_input_start_struct /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qobject-input-visitor.c:295
    #3 0x55d7eaed78b8 in visit_start_struct /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qapi-visit-core.c:49
    #4 0x55d7eaf5140b in visit_type_QCryptoBlockOpenOptions qapi/qapi-visit-crypto.c:290
    #5 0x55d7eae43af3 in block_crypto_open_opts_init /mnt/sdb/qemu-new/qemu_test/qemu/block/crypto.c:163
    #6 0x55d7eacd2924 in qcow2_update_options_prepare /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:1148
    #7 0x55d7eacd33f7 in qcow2_update_options /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:1232
    #8 0x55d7eacd9680 in qcow2_do_open /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:1512
    #9 0x55d7eacdc55e in qcow2_open_entry /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:1792
    #10 0x55d7eacdc8fe in qcow2_open /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:1819
    #11 0x55d7eac3742d in bdrv_open_driver /mnt/sdb/qemu-new/qemu_test/qemu/block.c:1317
    #12 0x55d7eac3e990 in bdrv_open_common /mnt/sdb/qemu-new/qemu_test/qemu/block.c:1575
    #13 0x55d7eac4442c in bdrv_open_inherit /mnt/sdb/qemu-new/qemu_test/qemu/block.c:3126
    #14 0x55d7eac45c3f in bdrv_open /mnt/sdb/qemu-new/qemu_test/qemu/block.c:3219
    #15 0x55d7ead8e8a4 in blk_new_open /mnt/sdb/qemu-new/qemu_test/qemu/block/block-backend.c:397
    #16 0x55d7eacde74c in qcow2_co_create /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:3534
    #17 0x55d7eacdfa6d in qcow2_co_create_opts /mnt/sdb/qemu-new/qemu_test/qemu/block/qcow2.c:3668
    #18 0x55d7eac1c678 in bdrv_create_co_entry /mnt/sdb/qemu-new/qemu_test/qemu/block.c:485
    #19 0x55d7eb0024d2 in coroutine_trampoline /mnt/sdb/qemu-new/qemu_test/qemu/util/coroutine-ucontext.c:115

Reported-by: Euler Robot <euler.robot@huawei.com>
Signed-off-by: Pan Nengyuan <pannengyuan@huawei.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200227012950.12256-2-pannengyuan@huawei.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/qcow2.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static void qcow2_close(BlockDriverState *bs)
 
     qcrypto_block_free(s->crypto);
     s->crypto = NULL;
+    qapi_free_QCryptoBlockOpenOptions(s->crypto_opts);
 
     g_free(s->unknown_header_fields);
     cleanup_unknown_header_ext(bs);
-- 
2.24.1

From: Pan Nengyuan <pannengyuan@huawei.com>

collect_image_check() is called twice in img_check(), the filename/format will be alloced without free the original memory.
It is not a big deal since the process will exit anyway, but seems like a clean code and it will remove the warning spotted by asan.

Reported-by: Euler Robot <euler.robot@huawei.com>
Signed-off-by: Pan Nengyuan <pannengyuan@huawei.com>
Message-Id: <20200227012950.12256-3-pannengyuan@huawei.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qemu-img.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/qemu-img.c b/qemu-img.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -XXX,XX +XXX,XX @@ static int img_check(int argc, char **argv)
                     check->corruptions_fixed);
         }
 
+        qapi_free_ImageCheck(check);
+        check = g_new0(ImageCheck, 1);
         ret = collect_image_check(bs, check, filename, fmt, 0);
 
         check->leaks_fixed          = leaks_fixed;
-- 
2.24.1

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

On success path we return what inflate() returns instead of 0. And it
most probably works for Z_STREAM_END as it is positive, but is
definitely broken for Z_BUF_ERROR.

While being here, switch to errno return code, to be closer to
qcow2_compress API (and usual expectations).

Revert condition in if to be more positive. Drop dead initialization of
ret.

Cc: qemu-stable@nongnu.org # v4.0
Fixes: 341926ab83e2b
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200302150930.16218-1-vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Ján Tomko <jtomko@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/qcow2-threads.c | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/block/qcow2-threads.c b/block/qcow2-threads.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-threads.c
+++ b/block/qcow2-threads.c
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_compress(void *dest, size_t dest_size,
  * @src - source buffer, @src_size bytes
  *
  * Returns: 0 on success
- *          -1 on fail
+ *          -EIO on fail
  */
 static ssize_t qcow2_decompress(void *dest, size_t dest_size,
                                 const void *src, size_t src_size)
 {
-    int ret = 0;
+    int ret;
     z_stream strm;
 
     memset(&strm, 0, sizeof(strm));
@@ -XXX,XX +XXX,XX @@ static ssize_t qcow2_decompress(void *dest, size_t dest_size,
 
     ret = inflateInit2(&strm, -12);
     if (ret != Z_OK) {
-        return -1;
+        return -EIO;
     }
 
     ret = inflate(&strm, Z_FINISH);
-    if ((ret != Z_STREAM_END && ret != Z_BUF_ERROR) || strm.avail_out != 0) {
+    if ((ret == Z_STREAM_END || ret == Z_BUF_ERROR) && strm.avail_out == 0) {
         /*
          * We approve Z_BUF_ERROR because we need @dest buffer to be filled, but
          * @src buffer may be processed partly (because in qcow2 we know size of
          * compressed data with precision of one sector)
          */
-        ret = -1;
+        ret = 0;
+    } else {
+        ret = -EIO;
     }
 
     inflateEnd(&strm);
-- 
2.24.1

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

We need it in separate to pass to the block-copy object in the next
commit.

Cc: qemu-stable@nongnu.org
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200311103004.7649-2-vsementsov@virtuozzo.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 blockjob.c                    | 16 +++++-----
 include/qemu/job.h            | 11 ++-----
 include/qemu/progress_meter.h | 58 +++++++++++++++++++++++++++++++++++
 job-qmp.c                     |  4 +--
 job.c                         |  6 ++--
 qemu-img.c                    |  6 ++--
 6 files changed, 76 insertions(+), 25 deletions(-)
 create mode 100644 include/qemu/progress_meter.h

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ BlockJobInfo *block_job_query(BlockJob *job, Error **errp)
     info->device    = g_strdup(job->job.id);
     info->busy      = atomic_read(&job->job.busy);
     info->paused    = job->job.pause_count > 0;
-    info->offset    = job->job.progress_current;
-    info->len       = job->job.progress_total;
+    info->offset    = job->job.progress.current;
+    info->len       = job->job.progress.total;
     info->speed     = job->speed;
     info->io_status = job->iostatus;
     info->ready     = job_is_ready(&job->job),
@@ -XXX,XX +XXX,XX @@ static void block_job_event_cancelled(Notifier *n, void *opaque)
 
     qapi_event_send_block_job_cancelled(job_type(&job->job),
                                         job->job.id,
-                                        job->job.progress_total,
-                                        job->job.progress_current,
+                                        job->job.progress.total,
+                                        job->job.progress.current,
                                         job->speed);
 }
 
@@ -XXX,XX +XXX,XX @@ static void block_job_event_completed(Notifier *n, void *opaque)
 
     qapi_event_send_block_job_completed(job_type(&job->job),
                                         job->job.id,
-                                        job->job.progress_total,
-                                        job->job.progress_current,
+                                        job->job.progress.total,
+                                        job->job.progress.current,
                                         job->speed,
                                         !!msg,
                                         msg);
@@ -XXX,XX +XXX,XX @@ static void block_job_event_ready(Notifier *n, void *opaque)
 
     qapi_event_send_block_job_ready(job_type(&job->job),
                                     job->job.id,
-                                    job->job.progress_total,
-                                    job->job.progress_current,
+                                    job->job.progress.total,
+                                    job->job.progress.current,
                                     job->speed);
 }
 
diff --git a/include/qemu/job.h b/include/qemu/job.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/job.h
+++ b/include/qemu/job.h
@@ -XXX,XX +XXX,XX @@
 
 #include "qapi/qapi-types-job.h"
 #include "qemu/queue.h"
+#include "qemu/progress_meter.h"
 #include "qemu/coroutine.h"
 #include "block/aio.h"
 
@@ -XXX,XX +XXX,XX @@ typedef struct Job {
     /** True if this job should automatically dismiss itself */
     bool auto_dismiss;
 
-    /**
-     * Current progress. The unit is arbitrary as long as the ratio between
-     * progress_current and progress_total represents the estimated percentage
-     * of work already done.
-     */
-    int64_t progress_current;
-
-    /** Estimated progress_current value at the completion of the job */
-    int64_t progress_total;
+    ProgressMeter progress;
 
     /**
      * Return code from @run and/or @prepare callback(s).
diff --git a/include/qemu/progress_meter.h b/include/qemu/progress_meter.h
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/include/qemu/progress_meter.h
@@ -XXX,XX +XXX,XX @@
+/*
+ * Helper functionality for some process progress tracking.
+ *
+ * Copyright (c) 2011 IBM Corp.
+ * Copyright (c) 2012, 2018 Red Hat, Inc.
+ * Copyright (c) 2020 Virtuozzo International GmbH
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#ifndef QEMU_PROGRESS_METER_H
+#define QEMU_PROGRESS_METER_H
+
+typedef struct ProgressMeter {
+    /**
+     * Current progress. The unit is arbitrary as long as the ratio between
+     * current and total represents the estimated percentage
+     * of work already done.
+     */
+    uint64_t current;
+
+    /** Estimated current value at the completion of the process */
+    uint64_t total;
+} ProgressMeter;
+
+static inline void progress_work_done(ProgressMeter *pm, uint64_t done)
+{
+    pm->current += done;
+}
+
+static inline void progress_set_remaining(ProgressMeter *pm, uint64_t remaining)
+{
+    pm->total = pm->current + remaining;
+}
+
+static inline void progress_increase_remaining(ProgressMeter *pm,
+                                               uint64_t delta)
+{
+    pm->total += delta;
+}
+
+#endif /* QEMU_PROGRESS_METER_H */
diff --git a/job-qmp.c b/job-qmp.c
index XXXXXXX..XXXXXXX 100644
--- a/job-qmp.c
+++ b/job-qmp.c
@@ -XXX,XX +XXX,XX @@ static JobInfo *job_query_single(Job *job, Error **errp)
         .id                 = g_strdup(job->id),
         .type               = job_type(job),
         .status             = job->status,
-        .current_progress   = job->progress_current,
-        .total_progress     = job->progress_total,
+        .current_progress   = job->progress.current,
+        .total_progress     = job->progress.total,
         .has_error          = !!job->err,
         .error              = job->err ? \
                               g_strdup(error_get_pretty(job->err)) : NULL,
diff --git a/job.c b/job.c
index XXXXXXX..XXXXXXX 100644
--- a/job.c
+++ b/job.c
@@ -XXX,XX +XXX,XX @@ void job_unref(Job *job)
 
 void job_progress_update(Job *job, uint64_t done)
 {
-    job->progress_current += done;
+    progress_work_done(&job->progress, done);
 }
 
 void job_progress_set_remaining(Job *job, uint64_t remaining)
 {
-    job->progress_total = job->progress_current + remaining;
+    progress_set_remaining(&job->progress, remaining);
 }
 
 void job_progress_increase_remaining(Job *job, uint64_t delta)
 {
-    job->progress_total += delta;
+    progress_increase_remaining(&job->progress, delta);
 }
 
 void job_event_cancelled(Job *job)
diff --git a/qemu-img.c b/qemu-img.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -XXX,XX +XXX,XX @@ static void run_block_job(BlockJob *job, Error **errp)
     do {
         float progress = 0.0f;
         aio_poll(aio_context, true);
-        if (job->job.progress_total) {
-            progress = (float)job->job.progress_current /
-                       job->job.progress_total * 100.f;
+        if (job->job.progress.total) {
+            progress = (float)job->job.progress.current /
+                       job->job.progress.total * 100.f;
         }
         qemu_progress_print(progress, 0);
     } while (!job_is_ready(&job->job) && !job_is_completed(&job->job));
-- 
2.24.1

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

Assume we have two regions, A and B, and region B is in-flight now,
region A is not yet touched, but it is unallocated and should be
skipped.

Correspondingly, as progress we have

total = A + B
  current = 0

If we reset unallocated region A and call progress_reset_callback,
it will calculate 0 bytes dirty in the bitmap and call
job_progress_set_remaining, which will set

total = current + 0 = 0 + 0 = 0

So, B bytes are actually removed from total accounting. When job
finishes we'll have

total = 0
   current = B

, which doesn't sound good.

This is because we didn't considered in-flight bytes, actually when
calculating remaining, we should have set (in_flight + dirty_bytes)
as remaining, not only dirty_bytes.

To fix it, let's refactor progress calculation, moving it to block-copy
itself instead of fixing callback. And, of course, track in_flight
bytes count.

We still have to keep one callback, to maintain backup job bytes_read
calculation, but it will go on soon, when we turn the whole backup
process into one block_copy call.

Cc: qemu-stable@nongnu.org
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Message-Id: <20200311103004.7649-3-vsementsov@virtuozzo.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/backup.c             | 13 ++-----------
 block/block-copy.c         | 16 ++++++++++++----
 include/block/block-copy.h | 15 +++++----------
 3 files changed, 19 insertions(+), 25 deletions(-)

diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ static void backup_progress_bytes_callback(int64_t bytes, void *opaque)
     BackupBlockJob *s = opaque;
 
     s->bytes_read += bytes;
-    job_progress_update(&s->common.job, bytes);
-}
-
-static void backup_progress_reset_callback(void *opaque)
-{
-    BackupBlockJob *s = opaque;
-    uint64_t estimate = bdrv_get_dirty_count(s->bcs->copy_bitmap);
-
-    job_progress_set_remaining(&s->common.job, estimate);
 }
 
 static int coroutine_fn backup_do_cow(BackupBlockJob *job,
@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
     job->cluster_size = cluster_size;
     job->len = len;
 
-    block_copy_set_callbacks(bcs, backup_progress_bytes_callback,
-                             backup_progress_reset_callback, job);
+    block_copy_set_progress_callback(bcs, backup_progress_bytes_callback, job);
+    block_copy_set_progress_meter(bcs, &job->common.job.progress);
 
     /* Required permissions are already taken by backup-top target */
     block_job_add_bdrv(&job->common, "target", target, 0, BLK_PERM_ALL,
diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
     return s;
 }
 
-void block_copy_set_callbacks(
+void block_copy_set_progress_callback(
         BlockCopyState *s,
         ProgressBytesCallbackFunc progress_bytes_callback,
-        ProgressResetCallbackFunc progress_reset_callback,
         void *progress_opaque)
 {
     s->progress_bytes_callback = progress_bytes_callback;
-    s->progress_reset_callback = progress_reset_callback;
     s->progress_opaque = progress_opaque;
 }
 
+void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm)
+{
+    s->progress = pm;
+}
+
 /*
  * block_copy_do_copy
  *
@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
 
     if (!ret) {
         bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
-        s->progress_reset_callback(s->progress_opaque);
+        progress_set_remaining(s->progress,
+                               bdrv_get_dirty_count(s->copy_bitmap) +
+                               s->in_flight_bytes);
     }
 
     *count = bytes;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
         trace_block_copy_process(s, start);
 
         bdrv_reset_dirty_bitmap(s->copy_bitmap, start, chunk_end - start);
+        s->in_flight_bytes += chunk_end - start;
 
         co_get_from_shres(s->mem, chunk_end - start);
         ret = block_copy_do_copy(s, start, chunk_end, error_is_read);
         co_put_to_shres(s->mem, chunk_end - start);
+        s->in_flight_bytes -= chunk_end - start;
         if (ret < 0) {
             bdrv_set_dirty_bitmap(s->copy_bitmap, start, chunk_end - start);
             break;
         }
 
+        progress_work_done(s->progress, chunk_end - start);
         s->progress_bytes_callback(chunk_end - start, s->progress_opaque);
         start = chunk_end;
         ret = 0;
diff --git a/include/block/block-copy.h b/include/block/block-copy.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-copy.h
+++ b/include/block/block-copy.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyInFlightReq {
 } BlockCopyInFlightReq;
 
 typedef void (*ProgressBytesCallbackFunc)(int64_t bytes, void *opaque);
-typedef void (*ProgressResetCallbackFunc)(void *opaque);
 typedef struct BlockCopyState {
     /*
      * BdrvChild objects are not owned or managed by block-copy. They are
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState {
     BdrvChild *source;
     BdrvChild *target;
     BdrvDirtyBitmap *copy_bitmap;
+    int64_t in_flight_bytes;
     int64_t cluster_size;
     bool use_copy_range;
     int64_t copy_size;
@@ -XXX,XX +XXX,XX @@ typedef struct BlockCopyState {
      */
     bool skip_unallocated;
 
+    ProgressMeter *progress;
     /* progress_bytes_callback: called when some copying progress is done. */
     ProgressBytesCallbackFunc progress_bytes_callback;
-
-    /*
-     * progress_reset_callback: called when some bytes reset from copy_bitmap
-     * (see @skip_unallocated above). The callee is assumed to recalculate how
-     * many bytes remain based on the dirty bit count of copy_bitmap.
-     */
-    ProgressResetCallbackFunc progress_reset_callback;
     void *progress_opaque;
 
     SharedResource *mem;
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
                                      BdrvRequestFlags write_flags,
                                      Error **errp);
 
-void block_copy_set_callbacks(
+void block_copy_set_progress_callback(
         BlockCopyState *s,
         ProgressBytesCallbackFunc progress_bytes_callback,
-        ProgressResetCallbackFunc progress_reset_callback,
         void *progress_opaque);
 
+void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm);
+
 void block_copy_state_free(BlockCopyState *s);
 
 int64_t block_copy_reset_unallocated(BlockCopyState *s,
-- 
2.24.1

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

In block_copy_do_copy we fallback to read+write if copy_range failed.
In this case copy_size is larger than defined for buffered IO, and
there is corresponding commit. Still, backup copies data cluster by
cluster, and most of requests are limited to one cluster anyway, so the
only source of this one bad-limited request is copy-before-write
operation.

Further patch will move backup to use block_copy directly, than for
cases where copy_range is not supported, first request will be
oversized in each backup. It's not good, let's change it now.

Fix is simple: just limit first copy_range request like buffer-based
request. If it succeed, set larger copy_range limit.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200311103004.7649-4-vsementsov@virtuozzo.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/block-copy.c | 41 +++++++++++++++++++++++++++++++----------
 1 file changed, 31 insertions(+), 10 deletions(-)

diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ void block_copy_state_free(BlockCopyState *s)
     g_free(s);
 }
 
+static uint32_t block_copy_max_transfer(BdrvChild *source, BdrvChild *target)
+{
+    return MIN_NON_ZERO(INT_MAX,
+                        MIN_NON_ZERO(source->bs->bl.max_transfer,
+                                     target->bs->bl.max_transfer));
+}
+
 BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
                                      int64_t cluster_size,
                                      BdrvRequestFlags write_flags, Error **errp)
 {
     BlockCopyState *s;
     BdrvDirtyBitmap *copy_bitmap;
-    uint32_t max_transfer =
-            MIN_NON_ZERO(INT_MAX,
-                         MIN_NON_ZERO(source->bs->bl.max_transfer,
-                                      target->bs->bl.max_transfer));
 
     copy_bitmap = bdrv_create_dirty_bitmap(source->bs, cluster_size, NULL,
                                            errp);
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
         .mem = shres_create(BLOCK_COPY_MAX_MEM),
     };
 
-    if (max_transfer < cluster_size) {
+    if (block_copy_max_transfer(source, target) < cluster_size) {
         /*
          * copy_range does not respect max_transfer. We don't want to bother
          * with requests smaller than block-copy cluster size, so fallback to
@@ -XXX,XX +XXX,XX @@ BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
         s->copy_size = cluster_size;
     } else {
         /*
-         * copy_range does not respect max_transfer (it's a TODO), so we factor
-         * that in here.
+         * We enable copy-range, but keep small copy_size, until first
+         * successful copy_range (look at block_copy_do_copy).
          */
         s->use_copy_range = true;
-        s->copy_size = MIN(MAX(cluster_size, BLOCK_COPY_MAX_COPY_RANGE),
-                           QEMU_ALIGN_DOWN(max_transfer, cluster_size));
+        s->copy_size = MAX(s->cluster_size, BLOCK_COPY_MAX_BUFFER);
     }
 
     QLIST_INIT(&s->inflight_reqs);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
             s->copy_size = MAX(s->cluster_size, BLOCK_COPY_MAX_BUFFER);
             /* Fallback to read+write with allocated buffer */
         } else {
+            if (s->use_copy_range) {
+                /*
+                 * Successful copy-range. Now increase copy_size.  copy_range
+                 * does not respect max_transfer (it's a TODO), so we factor
+                 * that in here.
+                 *
+                 * Note: we double-check s->use_copy_range for the case when
+                 * parallel block-copy request unsets it during previous
+                 * bdrv_co_copy_range call.
+                 */
+                s->copy_size =
+                        MIN(MAX(s->cluster_size, BLOCK_COPY_MAX_COPY_RANGE),
+                            QEMU_ALIGN_DOWN(block_copy_max_transfer(s->source,
+                                                                    s->target),
+                                            s->cluster_size));
+            }
             goto out;
         }
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
     /*
      * In case of failed copy_range request above, we may proceed with buffered
      * request larger than BLOCK_COPY_MAX_BUFFER. Still, further requests will
-     * be properly limited, so don't care too much.
+     * be properly limited, so don't care too much. Moreover the most likely
+     * case (copy_range is unsupported for the configuration, so the very first
+     * copy_range request fails) is handled by setting large copy_size only
+     * after first successful copy_range.
      */
 
     bounce_buffer = qemu_blockalign(s->source->bs, nbytes);
-- 
2.24.1

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

Use bdrv_block_status_above to chose effective chunk size and to handle
zeroes effectively.

This substitutes checking for just being allocated or not, and drops
old code path for it. Assistance by backup job is dropped too, as
caching block-status information is more difficult than just caching
is-allocated information in our dirty bitmap, and backup job is not
good place for this caching anyway.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200311103004.7649-5-vsementsov@virtuozzo.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/block-copy.c | 73 +++++++++++++++++++++++++++++++++++++---------
 block/trace-events |  1 +
 2 files changed, 61 insertions(+), 13 deletions(-)

diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm)
  */
 static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
                                            int64_t start, int64_t end,
-                                           bool *error_is_read)
+                                           bool zeroes, bool *error_is_read)
 {
     int ret;
     int nbytes = MIN(end, s->len) - start;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
     assert(QEMU_IS_ALIGNED(end, s->cluster_size));
     assert(end < s->len || end == QEMU_ALIGN_UP(s->len, s->cluster_size));
 
+    if (zeroes) {
+        ret = bdrv_co_pwrite_zeroes(s->target, start, nbytes, s->write_flags &
+                                    ~BDRV_REQ_WRITE_COMPRESSED);
+        if (ret < 0) {
+            trace_block_copy_write_zeroes_fail(s, start, ret);
+            if (error_is_read) {
+                *error_is_read = false;
+            }
+        }
+        return ret;
+    }
+
     if (s->use_copy_range) {
         ret = bdrv_co_copy_range(s->source, start, s->target, start, nbytes,
                                  0, s->write_flags);
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
+static int block_copy_block_status(BlockCopyState *s, int64_t offset,
+                                   int64_t bytes, int64_t *pnum)
+{
+    int64_t num;
+    BlockDriverState *base;
+    int ret;
+
+    if (s->skip_unallocated && s->source->bs->backing) {
+        base = s->source->bs->backing->bs;
+    } else {
+        base = NULL;
+    }
+
+    ret = bdrv_block_status_above(s->source->bs, base, offset, bytes, &num,
+                                  NULL, NULL);
+    if (ret < 0 || num < s->cluster_size) {
+        /*
+         * On error or if failed to obtain large enough chunk just fallback to
+         * copy one cluster.
+         */
+        num = s->cluster_size;
+        ret = BDRV_BLOCK_ALLOCATED | BDRV_BLOCK_DATA;
+    } else if (offset + num == s->len) {
+        num = QEMU_ALIGN_UP(num, s->cluster_size);
+    } else {
+        num = QEMU_ALIGN_DOWN(num, s->cluster_size);
+    }
+
+    *pnum = num;
+    return ret;
+}
+
 /*
  * Check if the cluster starting at offset is allocated or not.
  * return via pnum the number of contiguous clusters sharing this allocation.
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
 {
     int ret = 0;
     int64_t end = bytes + start; /* bytes */
-    int64_t status_bytes;
     BlockCopyInFlightReq req;
 
     /*
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
     block_copy_inflight_req_begin(s, &req, start, end);
 
     while (start < end) {
-        int64_t next_zero, chunk_end;
+        int64_t next_zero, chunk_end, status_bytes;
 
         if (!bdrv_dirty_bitmap_get(s->copy_bitmap, start)) {
             trace_block_copy_skip(s, start);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
             chunk_end = next_zero;
         }
 
-        if (s->skip_unallocated) {
-            ret = block_copy_reset_unallocated(s, start, &status_bytes);
-            if (ret == 0) {
-                trace_block_copy_skip_range(s, start, status_bytes);
-                start += status_bytes;
-                continue;
-            }
-            /* Clamp to known allocated region */
-            chunk_end = MIN(chunk_end, start + status_bytes);
+        ret = block_copy_block_status(s, start, chunk_end - start,
+                                      &status_bytes);
+        if (s->skip_unallocated && !(ret & BDRV_BLOCK_ALLOCATED)) {
+            bdrv_reset_dirty_bitmap(s->copy_bitmap, start, status_bytes);
+            progress_set_remaining(s->progress,
+                                   bdrv_get_dirty_count(s->copy_bitmap) +
+                                   s->in_flight_bytes);
+            trace_block_copy_skip_range(s, start, status_bytes);
+            start += status_bytes;
+            continue;
         }
 
+        chunk_end = MIN(chunk_end, start + status_bytes);
+
         trace_block_copy_process(s, start);
 
         bdrv_reset_dirty_bitmap(s->copy_bitmap, start, chunk_end - start);
         s->in_flight_bytes += chunk_end - start;
 
         co_get_from_shres(s->mem, chunk_end - start);
-        ret = block_copy_do_copy(s, start, chunk_end, error_is_read);
+        ret = block_copy_do_copy(s, start, chunk_end, ret & BDRV_BLOCK_ZERO,
+                                 error_is_read);
         co_put_to_shres(s->mem, chunk_end - start);
         s->in_flight_bytes -= chunk_end - start;
         if (ret < 0) {
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 @@ block_copy_process(void *bcs, int64_t start) "bcs %p start %"PRId64
 block_copy_copy_range_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d"
 block_copy_read_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d"
 block_copy_write_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d"
+block_copy_write_zeroes_fail(void *bcs, int64_t start, int ret) "bcs %p start %"PRId64" ret %d"
 
 # ../blockdev.c
 qmp_block_job_cancel(void *job) "job %p"
-- 
2.24.1

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

Split find_conflicting_inflight_req to be used separately.

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

We have a lot of "chunk_end - start" invocations, let's switch to
bytes/cur_bytes scheme instead.

While being here, improve check on block_copy_do_copy parameters to not
overflow when calculating nbytes and use int64_t for bytes in
block_copy for consistency.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200311103004.7649-7-vsementsov@virtuozzo.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/block-copy.c         | 78 ++++++++++++++++++++------------------
 include/block/block-copy.h |  6 +--
 2 files changed, 44 insertions(+), 40 deletions(-)

diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@
 
 static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
                                                            int64_t start,
-                                                           int64_t end)
+                                                           int64_t bytes)
 {
     BlockCopyInFlightReq *req;
 
     QLIST_FOREACH(req, &s->inflight_reqs, list) {
-        if (end > req->start_byte && start < req->end_byte) {
+        if (start + bytes > req->start && start < req->start + req->bytes) {
             return req;
         }
     }
@@ -XXX,XX +XXX,XX @@ static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
 
 static void coroutine_fn block_copy_wait_inflight_reqs(BlockCopyState *s,
                                                        int64_t start,
-                                                       int64_t end)
+                                                       int64_t bytes)
 {
     BlockCopyInFlightReq *req;
 
-    while ((req = find_conflicting_inflight_req(s, start, end))) {
+    while ((req = find_conflicting_inflight_req(s, start, bytes))) {
         qemu_co_queue_wait(&req->wait_queue, NULL);
     }
 }
 
 static void block_copy_inflight_req_begin(BlockCopyState *s,
                                           BlockCopyInFlightReq *req,
-                                          int64_t start, int64_t end)
+                                          int64_t start, int64_t bytes)
 {
-    req->start_byte = start;
-    req->end_byte = end;
+    req->start = start;
+    req->bytes = bytes;
     qemu_co_queue_init(&req->wait_queue);
     QLIST_INSERT_HEAD(&s->inflight_reqs, req, list);
 }
@@ -XXX,XX +XXX,XX @@ void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm)
 /*
  * block_copy_do_copy
  *
- * Do copy of cluser-aligned chunk. @end is allowed to exceed s->len only to
- * cover last cluster when s->len is not aligned to clusters.
+ * Do copy of cluster-aligned chunk. Requested region is allowed to exceed
+ * s->len only to cover last cluster when s->len is not aligned to clusters.
  *
  * No sync here: nor bitmap neighter intersecting requests handling, only copy.
  *
  * Returns 0 on success.
  */
 static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
-                                           int64_t start, int64_t end,
+                                           int64_t start, int64_t bytes,
                                            bool zeroes, bool *error_is_read)
 {
     int ret;
-    int nbytes = MIN(end, s->len) - start;
+    int64_t nbytes = MIN(start + bytes, s->len) - start;
     void *bounce_buffer = NULL;
 
+    assert(start >= 0 && bytes > 0 && INT64_MAX - start >= bytes);
     assert(QEMU_IS_ALIGNED(start, s->cluster_size));
-    assert(QEMU_IS_ALIGNED(end, s->cluster_size));
-    assert(end < s->len || end == QEMU_ALIGN_UP(s->len, s->cluster_size));
+    assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
+    assert(start < s->len);
+    assert(start + bytes <= s->len ||
+           start + bytes == QEMU_ALIGN_UP(s->len, s->cluster_size));
+    assert(nbytes < INT_MAX);
 
     if (zeroes) {
         ret = bdrv_co_pwrite_zeroes(s->target, start, nbytes, s->write_flags &
@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
 }
 
 int coroutine_fn block_copy(BlockCopyState *s,
-                            int64_t start, uint64_t bytes,
+                            int64_t start, int64_t bytes,
                             bool *error_is_read)
 {
     int ret = 0;
-    int64_t end = bytes + start; /* bytes */
     BlockCopyInFlightReq req;
 
     /*
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
            bdrv_get_aio_context(s->target->bs));
 
     assert(QEMU_IS_ALIGNED(start, s->cluster_size));
-    assert(QEMU_IS_ALIGNED(end, s->cluster_size));
+    assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
 
     block_copy_wait_inflight_reqs(s, start, bytes);
-    block_copy_inflight_req_begin(s, &req, start, end);
+    block_copy_inflight_req_begin(s, &req, start, bytes);
 
-    while (start < end) {
-        int64_t next_zero, chunk_end, status_bytes;
+    while (bytes) {
+        int64_t next_zero, cur_bytes, status_bytes;
 
         if (!bdrv_dirty_bitmap_get(s->copy_bitmap, start)) {
             trace_block_copy_skip(s, start);
             start += s->cluster_size;
+            bytes -= s->cluster_size;
             continue; /* already copied */
         }
 
-        chunk_end = MIN(end, start + s->copy_size);
+        cur_bytes = MIN(bytes, s->copy_size);
 
         next_zero = bdrv_dirty_bitmap_next_zero(s->copy_bitmap, start,
-                                                chunk_end - start);
+                                                cur_bytes);
         if (next_zero >= 0) {
             assert(next_zero > start); /* start is dirty */
-            assert(next_zero < chunk_end); /* no need to do MIN() */
-            chunk_end = next_zero;
+            assert(next_zero < start + cur_bytes); /* no need to do MIN() */
+            cur_bytes = next_zero - start;
         }
 
-        ret = block_copy_block_status(s, start, chunk_end - start,
-                                      &status_bytes);
+        ret = block_copy_block_status(s, start, cur_bytes, &status_bytes);
         if (s->skip_unallocated && !(ret & BDRV_BLOCK_ALLOCATED)) {
             bdrv_reset_dirty_bitmap(s->copy_bitmap, start, status_bytes);
             progress_set_remaining(s->progress,
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
                                    s->in_flight_bytes);
             trace_block_copy_skip_range(s, start, status_bytes);
             start += status_bytes;
+            bytes -= status_bytes;
             continue;
         }
 
-        chunk_end = MIN(chunk_end, start + status_bytes);
+        cur_bytes = MIN(cur_bytes, status_bytes);
 
         trace_block_copy_process(s, start);
 
-        bdrv_reset_dirty_bitmap(s->copy_bitmap, start, chunk_end - start);
-        s->in_flight_bytes += chunk_end - start;
+        bdrv_reset_dirty_bitmap(s->copy_bitmap, start, cur_bytes);
+        s->in_flight_bytes += cur_bytes;
 
-        co_get_from_shres(s->mem, chunk_end - start);
-        ret = block_copy_do_copy(s, start, chunk_end, ret & BDRV_BLOCK_ZERO,
+        co_get_from_shres(s->mem, cur_bytes);
+        ret = block_copy_do_copy(s, start, cur_bytes, ret & BDRV_BLOCK_ZERO,
                                  error_is_read);
-        co_put_to_shres(s->mem, chunk_end - start);
-        s->in_flight_bytes -= chunk_end - start;
+        co_put_to_shres(s->mem, cur_bytes);
+        s->in_flight_bytes -= cur_bytes;
         if (ret < 0) {
-            bdrv_set_dirty_bitmap(s->copy_bitmap, start, chunk_end - start);
+            bdrv_set_dirty_bitmap(s->copy_bitmap, start, cur_bytes);
             break;
         }
 
-        progress_work_done(s->progress, chunk_end - start);
-        s->progress_bytes_callback(chunk_end - start, s->progress_opaque);
-        start = chunk_end;
-        ret = 0;
+        progress_work_done(s->progress, cur_bytes);
+        s->progress_bytes_callback(cur_bytes, s->progress_opaque);
+        start += cur_bytes;
+        bytes -= cur_bytes;
     }
 
     block_copy_inflight_req_end(&req);
diff --git a/include/block/block-copy.h b/include/block/block-copy.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-copy.h
+++ b/include/block/block-copy.h
@@ -XXX,XX +XXX,XX @@
 #include "qemu/co-shared-resource.h"
 
 typedef struct BlockCopyInFlightReq {
-    int64_t start_byte;
-    int64_t end_byte;
+    int64_t start;
+    int64_t bytes;
     QLIST_ENTRY(BlockCopyInFlightReq) list;
     CoQueue wait_queue; /* coroutines blocked on this request */
 } BlockCopyInFlightReq;
@@ -XXX,XX +XXX,XX @@ void block_copy_state_free(BlockCopyState *s);
 int64_t block_copy_reset_unallocated(BlockCopyState *s,
                                      int64_t offset, int64_t *count);
 
-int coroutine_fn block_copy(BlockCopyState *s, int64_t start, uint64_t bytes,
+int coroutine_fn block_copy(BlockCopyState *s, int64_t start, int64_t bytes,
                             bool *error_is_read);
 
 #endif /* BLOCK_COPY_H */
-- 
2.24.1

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

offset/bytes pair is more usual naming in block layer, let's use it.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200311103004.7649-8-vsementsov@virtuozzo.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/block-copy.c         | 82 +++++++++++++++++++-------------------
 include/block/block-copy.h |  4 +-
 2 files changed, 43 insertions(+), 43 deletions(-)

diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@
 #define BLOCK_COPY_MAX_MEM (128 * MiB)
 
 static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
-                                                           int64_t start,
+                                                           int64_t offset,
                                                            int64_t bytes)
 {
     BlockCopyInFlightReq *req;
 
     QLIST_FOREACH(req, &s->inflight_reqs, list) {
-        if (start + bytes > req->start && start < req->start + req->bytes) {
+        if (offset + bytes > req->offset && offset < req->offset + req->bytes) {
             return req;
         }
     }
@@ -XXX,XX +XXX,XX @@ static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
 }
 
 static void coroutine_fn block_copy_wait_inflight_reqs(BlockCopyState *s,
-                                                       int64_t start,
+                                                       int64_t offset,
                                                        int64_t bytes)
 {
     BlockCopyInFlightReq *req;
 
-    while ((req = find_conflicting_inflight_req(s, start, bytes))) {
+    while ((req = find_conflicting_inflight_req(s, offset, bytes))) {
         qemu_co_queue_wait(&req->wait_queue, NULL);
     }
 }
 
 static void block_copy_inflight_req_begin(BlockCopyState *s,
                                           BlockCopyInFlightReq *req,
-                                          int64_t start, int64_t bytes)
+                                          int64_t offset, int64_t bytes)
 {
-    req->start = start;
+    req->offset = offset;
     req->bytes = bytes;
     qemu_co_queue_init(&req->wait_queue);
     QLIST_INSERT_HEAD(&s->inflight_reqs, req, list);
@@ -XXX,XX +XXX,XX @@ void block_copy_set_progress_meter(BlockCopyState *s, ProgressMeter *pm)
  * Returns 0 on success.
  */
 static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
-                                           int64_t start, int64_t bytes,
+                                           int64_t offset, int64_t bytes,
                                            bool zeroes, bool *error_is_read)
 {
     int ret;
-    int64_t nbytes = MIN(start + bytes, s->len) - start;
+    int64_t nbytes = MIN(offset + bytes, s->len) - offset;
     void *bounce_buffer = NULL;
 
-    assert(start >= 0 && bytes > 0 && INT64_MAX - start >= bytes);
-    assert(QEMU_IS_ALIGNED(start, s->cluster_size));
+    assert(offset >= 0 && bytes > 0 && INT64_MAX - offset >= bytes);
+    assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
     assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
-    assert(start < s->len);
-    assert(start + bytes <= s->len ||
-           start + bytes == QEMU_ALIGN_UP(s->len, s->cluster_size));
+    assert(offset < s->len);
+    assert(offset + bytes <= s->len ||
+           offset + bytes == QEMU_ALIGN_UP(s->len, s->cluster_size));
     assert(nbytes < INT_MAX);
 
     if (zeroes) {
-        ret = bdrv_co_pwrite_zeroes(s->target, start, nbytes, s->write_flags &
+        ret = bdrv_co_pwrite_zeroes(s->target, offset, nbytes, s->write_flags &
                                     ~BDRV_REQ_WRITE_COMPRESSED);
         if (ret < 0) {
-            trace_block_copy_write_zeroes_fail(s, start, ret);
+            trace_block_copy_write_zeroes_fail(s, offset, ret);
             if (error_is_read) {
                 *error_is_read = false;
             }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
     }
 
     if (s->use_copy_range) {
-        ret = bdrv_co_copy_range(s->source, start, s->target, start, nbytes,
+        ret = bdrv_co_copy_range(s->source, offset, s->target, offset, nbytes,
                                  0, s->write_flags);
         if (ret < 0) {
-            trace_block_copy_copy_range_fail(s, start, ret);
+            trace_block_copy_copy_range_fail(s, offset, ret);
             s->use_copy_range = false;
             s->copy_size = MAX(s->cluster_size, BLOCK_COPY_MAX_BUFFER);
             /* Fallback to read+write with allocated buffer */
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_copy_do_copy(BlockCopyState *s,
 
     bounce_buffer = qemu_blockalign(s->source->bs, nbytes);
 
-    ret = bdrv_co_pread(s->source, start, nbytes, bounce_buffer, 0);
+    ret = bdrv_co_pread(s->source, offset, nbytes, bounce_buffer, 0);
     if (ret < 0) {
-        trace_block_copy_read_fail(s, start, ret);
+        trace_block_copy_read_fail(s, offset, ret);
         if (error_is_read) {
             *error_is_read = true;
         }
         goto out;
     }
 
-    ret = bdrv_co_pwrite(s->target, start, nbytes, bounce_buffer,
+    ret = bdrv_co_pwrite(s->target, offset, nbytes, bounce_buffer,
                          s->write_flags);
     if (ret < 0) {
-        trace_block_copy_write_fail(s, start, ret);
+        trace_block_copy_write_fail(s, offset, ret);
         if (error_is_read) {
             *error_is_read = false;
         }
@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
 }
 
 int coroutine_fn block_copy(BlockCopyState *s,
-                            int64_t start, int64_t bytes,
+                            int64_t offset, int64_t bytes,
                             bool *error_is_read)
 {
     int ret = 0;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
     assert(bdrv_get_aio_context(s->source->bs) ==
            bdrv_get_aio_context(s->target->bs));
 
-    assert(QEMU_IS_ALIGNED(start, s->cluster_size));
+    assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
     assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
 
-    block_copy_wait_inflight_reqs(s, start, bytes);
-    block_copy_inflight_req_begin(s, &req, start, bytes);
+    block_copy_wait_inflight_reqs(s, offset, bytes);
+    block_copy_inflight_req_begin(s, &req, offset, bytes);
 
     while (bytes) {
         int64_t next_zero, cur_bytes, status_bytes;
 
-        if (!bdrv_dirty_bitmap_get(s->copy_bitmap, start)) {
-            trace_block_copy_skip(s, start);
-            start += s->cluster_size;
+        if (!bdrv_dirty_bitmap_get(s->copy_bitmap, offset)) {
+            trace_block_copy_skip(s, offset);
+            offset += s->cluster_size;
             bytes -= s->cluster_size;
             continue; /* already copied */
         }
 
         cur_bytes = MIN(bytes, s->copy_size);
 
-        next_zero = bdrv_dirty_bitmap_next_zero(s->copy_bitmap, start,
+        next_zero = bdrv_dirty_bitmap_next_zero(s->copy_bitmap, offset,
                                                 cur_bytes);
         if (next_zero >= 0) {
-            assert(next_zero > start); /* start is dirty */
-            assert(next_zero < start + cur_bytes); /* no need to do MIN() */
-            cur_bytes = next_zero - start;
+            assert(next_zero > offset); /* offset is dirty */
+            assert(next_zero < offset + cur_bytes); /* no need to do MIN() */
+            cur_bytes = next_zero - offset;
         }
 
-        ret = block_copy_block_status(s, start, cur_bytes, &status_bytes);
+        ret = block_copy_block_status(s, offset, cur_bytes, &status_bytes);
         if (s->skip_unallocated && !(ret & BDRV_BLOCK_ALLOCATED)) {
-            bdrv_reset_dirty_bitmap(s->copy_bitmap, start, status_bytes);
+            bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, status_bytes);
             progress_set_remaining(s->progress,
                                    bdrv_get_dirty_count(s->copy_bitmap) +
                                    s->in_flight_bytes);
-            trace_block_copy_skip_range(s, start, status_bytes);
-            start += status_bytes;
+            trace_block_copy_skip_range(s, offset, status_bytes);
+            offset += status_bytes;
             bytes -= status_bytes;
             continue;
         }
 
         cur_bytes = MIN(cur_bytes, status_bytes);
 
-        trace_block_copy_process(s, start);
+        trace_block_copy_process(s, offset);
 
-        bdrv_reset_dirty_bitmap(s->copy_bitmap, start, cur_bytes);
+        bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, cur_bytes);
         s->in_flight_bytes += cur_bytes;
 
         co_get_from_shres(s->mem, cur_bytes);
-        ret = block_copy_do_copy(s, start, cur_bytes, ret & BDRV_BLOCK_ZERO,
+        ret = block_copy_do_copy(s, offset, cur_bytes, ret & BDRV_BLOCK_ZERO,
                                  error_is_read);
         co_put_to_shres(s->mem, cur_bytes);
         s->in_flight_bytes -= cur_bytes;
         if (ret < 0) {
-            bdrv_set_dirty_bitmap(s->copy_bitmap, start, cur_bytes);
+            bdrv_set_dirty_bitmap(s->copy_bitmap, offset, cur_bytes);
             break;
         }
 
         progress_work_done(s->progress, cur_bytes);
         s->progress_bytes_callback(cur_bytes, s->progress_opaque);
-        start += cur_bytes;
+        offset += cur_bytes;
         bytes -= cur_bytes;
     }
 
diff --git a/include/block/block-copy.h b/include/block/block-copy.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-copy.h
+++ b/include/block/block-copy.h
@@ -XXX,XX +XXX,XX @@
 #include "qemu/co-shared-resource.h"
 
 typedef struct BlockCopyInFlightReq {
-    int64_t start;
+    int64_t offset;
     int64_t bytes;
     QLIST_ENTRY(BlockCopyInFlightReq) list;
     CoQueue wait_queue; /* coroutines blocked on this request */
@@ -XXX,XX +XXX,XX @@ void block_copy_state_free(BlockCopyState *s);
 int64_t block_copy_reset_unallocated(BlockCopyState *s,
                                      int64_t offset, int64_t *count);
 
-int coroutine_fn block_copy(BlockCopyState *s, int64_t start, int64_t bytes,
+int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes,
                             bool *error_is_read);
 
 #endif /* BLOCK_COPY_H */
-- 
2.24.1

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

Currently, block_copy operation lock the whole requested region. But
there is no reason to lock clusters, which are already copied, it will
disturb other parallel block_copy requests for no reason.

Let's instead do the following:

Lock only sub-region, which we are going to operate on. Then, after
copying all dirty sub-regions, we should wait for intersecting
requests block-copy, if they failed, we should retry these new dirty
clusters.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Message-Id: <20200311103004.7649-9-vsementsov@virtuozzo.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/block-copy.c | 129 ++++++++++++++++++++++++++++++++++++---------
 1 file changed, 105 insertions(+), 24 deletions(-)

diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@ static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
     return NULL;
 }
 
-static void coroutine_fn block_copy_wait_inflight_reqs(BlockCopyState *s,
-                                                       int64_t offset,
-                                                       int64_t bytes)
+/*
+ * If there are no intersecting requests return false. Otherwise, wait for the
+ * first found intersecting request to finish and return true.
+ */
+static bool coroutine_fn block_copy_wait_one(BlockCopyState *s, int64_t offset,
+                                             int64_t bytes)
 {
-    BlockCopyInFlightReq *req;
+    BlockCopyInFlightReq *req = find_conflicting_inflight_req(s, offset, bytes);
 
-    while ((req = find_conflicting_inflight_req(s, offset, bytes))) {
-        qemu_co_queue_wait(&req->wait_queue, NULL);
+    if (!req) {
+        return false;
     }
+
+    qemu_co_queue_wait(&req->wait_queue, NULL);
+
+    return true;
 }
 
+/* Called only on full-dirty region */
 static void block_copy_inflight_req_begin(BlockCopyState *s,
                                           BlockCopyInFlightReq *req,
                                           int64_t offset, int64_t bytes)
 {
+    assert(!find_conflicting_inflight_req(s, offset, bytes));
+
+    bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, bytes);
+    s->in_flight_bytes += bytes;
+
     req->offset = offset;
     req->bytes = bytes;
     qemu_co_queue_init(&req->wait_queue);
     QLIST_INSERT_HEAD(&s->inflight_reqs, req, list);
 }
 
-static void coroutine_fn block_copy_inflight_req_end(BlockCopyInFlightReq *req)
+/*
+ * block_copy_inflight_req_shrink
+ *
+ * Drop the tail of the request to be handled later. Set dirty bits back and
+ * wake up all requests waiting for us (may be some of them are not intersecting
+ * with shrunk request)
+ */
+static void coroutine_fn block_copy_inflight_req_shrink(BlockCopyState *s,
+        BlockCopyInFlightReq *req, int64_t new_bytes)
 {
+    if (new_bytes == req->bytes) {
+        return;
+    }
+
+    assert(new_bytes > 0 && new_bytes < req->bytes);
+
+    s->in_flight_bytes -= req->bytes - new_bytes;
+    bdrv_set_dirty_bitmap(s->copy_bitmap,
+                          req->offset + new_bytes, req->bytes - new_bytes);
+
+    req->bytes = new_bytes;
+    qemu_co_queue_restart_all(&req->wait_queue);
+}
+
+static void coroutine_fn block_copy_inflight_req_end(BlockCopyState *s,
+                                                     BlockCopyInFlightReq *req,
+                                                     int ret)
+{
+    s->in_flight_bytes -= req->bytes;
+    if (ret < 0) {
+        bdrv_set_dirty_bitmap(s->copy_bitmap, req->offset, req->bytes);
+    }
     QLIST_REMOVE(req, list);
     qemu_co_queue_restart_all(&req->wait_queue);
 }
@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
     return ret;
 }
 
-int coroutine_fn block_copy(BlockCopyState *s,
-                            int64_t offset, int64_t bytes,
-                            bool *error_is_read)
+/*
+ * block_copy_dirty_clusters
+ *
+ * Copy dirty clusters in @offset/@bytes range.
+ * Returns 1 if dirty clusters found and successfully copied, 0 if no dirty
+ * clusters found and -errno on failure.
+ */
+static int coroutine_fn block_copy_dirty_clusters(BlockCopyState *s,
+                                                  int64_t offset, int64_t bytes,
+                                                  bool *error_is_read)
 {
     int ret = 0;
-    BlockCopyInFlightReq req;
+    bool found_dirty = false;
 
     /*
      * block_copy() user is responsible for keeping source and target in same
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
     assert(QEMU_IS_ALIGNED(bytes, s->cluster_size));
 
-    block_copy_wait_inflight_reqs(s, offset, bytes);
-    block_copy_inflight_req_begin(s, &req, offset, bytes);
-
     while (bytes) {
+        BlockCopyInFlightReq req;
         int64_t next_zero, cur_bytes, status_bytes;
 
         if (!bdrv_dirty_bitmap_get(s->copy_bitmap, offset)) {
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
             continue; /* already copied */
         }
 
+        found_dirty = true;
+
         cur_bytes = MIN(bytes, s->copy_size);
 
         next_zero = bdrv_dirty_bitmap_next_zero(s->copy_bitmap, offset,
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
             assert(next_zero < offset + cur_bytes); /* no need to do MIN() */
             cur_bytes = next_zero - offset;
         }
+        block_copy_inflight_req_begin(s, &req, offset, cur_bytes);
 
         ret = block_copy_block_status(s, offset, cur_bytes, &status_bytes);
+        assert(ret >= 0); /* never fail */
+        cur_bytes = MIN(cur_bytes, status_bytes);
+        block_copy_inflight_req_shrink(s, &req, cur_bytes);
         if (s->skip_unallocated && !(ret & BDRV_BLOCK_ALLOCATED)) {
-            bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, status_bytes);
+            block_copy_inflight_req_end(s, &req, 0);
             progress_set_remaining(s->progress,
                                    bdrv_get_dirty_count(s->copy_bitmap) +
                                    s->in_flight_bytes);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
             continue;
         }
 
-        cur_bytes = MIN(cur_bytes, status_bytes);
-
         trace_block_copy_process(s, offset);
 
-        bdrv_reset_dirty_bitmap(s->copy_bitmap, offset, cur_bytes);
-        s->in_flight_bytes += cur_bytes;
-
         co_get_from_shres(s->mem, cur_bytes);
         ret = block_copy_do_copy(s, offset, cur_bytes, ret & BDRV_BLOCK_ZERO,
                                  error_is_read);
         co_put_to_shres(s->mem, cur_bytes);
-        s->in_flight_bytes -= cur_bytes;
+        block_copy_inflight_req_end(s, &req, ret);
         if (ret < 0) {
-            bdrv_set_dirty_bitmap(s->copy_bitmap, offset, cur_bytes);
-            break;
+            return ret;
         }
 
         progress_work_done(s->progress, cur_bytes);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s,
         bytes -= cur_bytes;
     }
 
-    block_copy_inflight_req_end(&req);
+    return found_dirty;
+}
+
+/*
+ * block_copy
+ *
+ * Copy requested region, accordingly to dirty bitmap.
+ * Collaborate with parallel block_copy requests: if they succeed it will help
+ * us. If they fail, we will retry not-copied regions. So, if we return error,
+ * it means that some I/O operation failed in context of _this_ block_copy call,
+ * not some parallel operation.
+ */
+int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes,
+                            bool *error_is_read)
+{
+    int ret;
+
+    do {
+        ret = block_copy_dirty_clusters(s, offset, bytes, error_is_read);
+
+        if (ret == 0) {
+            ret = block_copy_wait_one(s, offset, bytes);
+        }
+
+        /*
+         * We retry in two cases:
+         * 1. Some progress done
+         *    Something was copied, which means that there were yield points
+         *    and some new dirty bits may have appeared (due to failed parallel
+         *    block-copy requests).
+         * 2. We have waited for some intersecting block-copy request
+         *    It may have failed and produced new dirty bits.
+         */
+    } while (ret > 0);
 
     return ret;
 }
-- 
2.24.1

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

Hide structure definitions and add explicit API instead, to keep an
eye on the scope of the shared fields.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200311103004.7649-10-vsementsov@virtuozzo.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/backup-top.c         |  6 ++--
 block/backup.c             | 25 ++++++++--------
 block/block-copy.c         | 59 ++++++++++++++++++++++++++++++++++++++
 include/block/block-copy.h | 52 +++------------------------------
 4 files changed, 80 insertions(+), 62 deletions(-)

diff --git a/block/backup-top.c b/block/backup-top.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup-top.c
+++ b/block/backup-top.c
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVBackupTopState {
     BlockCopyState *bcs;
     BdrvChild *target;
     bool active;
+    int64_t cluster_size;
 } BDRVBackupTopState;
 
 static coroutine_fn int backup_top_co_preadv(
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int backup_top_cbw(BlockDriverState *bs, uint64_t offset,
         return 0;
     }
 
-    off = QEMU_ALIGN_DOWN(offset, s->bcs->cluster_size);
-    end = QEMU_ALIGN_UP(offset + bytes, s->bcs->cluster_size);
+    off = QEMU_ALIGN_DOWN(offset, s->cluster_size);
+    end = QEMU_ALIGN_UP(offset + bytes, s->cluster_size);
 
     return block_copy(s->bcs, off, end - off, NULL);
 }
@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_backup_top_append(BlockDriverState *source,
         goto fail;
     }
 
+    state->cluster_size = cluster_size;
     state->bcs = block_copy_state_new(top->backing, state->target,
                                       cluster_size, write_flags, &local_err);
     if (local_err) {
diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ static void backup_cleanup_sync_bitmap(BackupBlockJob *job, int ret)
 
     if (ret < 0 && job->bitmap_mode == BITMAP_SYNC_MODE_ALWAYS) {
         /* If we failed and synced, merge in the bits we didn't copy: */
-        bdrv_dirty_bitmap_merge_internal(bm, job->bcs->copy_bitmap,
+        bdrv_dirty_bitmap_merge_internal(bm, block_copy_dirty_bitmap(job->bcs),
                                          NULL, true);
     }
 }
@@ -XXX,XX +XXX,XX @@ void backup_do_checkpoint(BlockJob *job, Error **errp)
         return;
     }
 
-    bdrv_set_dirty_bitmap(backup_job->bcs->copy_bitmap, 0, backup_job->len);
+    bdrv_set_dirty_bitmap(block_copy_dirty_bitmap(backup_job->bcs), 0,
+                          backup_job->len);
 }
 
 static BlockErrorAction backup_error_action(BackupBlockJob *job,
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_loop(BackupBlockJob *job)
     BdrvDirtyBitmapIter *bdbi;
     int ret = 0;
 
-    bdbi = bdrv_dirty_iter_new(job->bcs->copy_bitmap);
+    bdbi = bdrv_dirty_iter_new(block_copy_dirty_bitmap(job->bcs));
     while ((offset = bdrv_dirty_iter_next(bdbi)) != -1) {
         do {
             if (yield_and_check(job)) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_loop(BackupBlockJob *job)
     return ret;
 }
 
-static void backup_init_copy_bitmap(BackupBlockJob *job)
+static void backup_init_bcs_bitmap(BackupBlockJob *job)
 {
     bool ret;
     uint64_t estimate;
+    BdrvDirtyBitmap *bcs_bitmap = block_copy_dirty_bitmap(job->bcs);
 
     if (job->sync_mode == MIRROR_SYNC_MODE_BITMAP) {
-        ret = bdrv_dirty_bitmap_merge_internal(job->bcs->copy_bitmap,
-                                               job->sync_bitmap,
+        ret = bdrv_dirty_bitmap_merge_internal(bcs_bitmap, job->sync_bitmap,
                                                NULL, true);
         assert(ret);
     } else {
@@ -XXX,XX +XXX,XX @@ static void backup_init_copy_bitmap(BackupBlockJob *job)
              * We can't hog the coroutine to initialize this thoroughly.
              * Set a flag and resume work when we are able to yield safely.
              */
-            job->bcs->skip_unallocated = true;
+            block_copy_set_skip_unallocated(job->bcs, true);
         }
-        bdrv_set_dirty_bitmap(job->bcs->copy_bitmap, 0, job->len);
+        bdrv_set_dirty_bitmap(bcs_bitmap, 0, job->len);
     }
 
-    estimate = bdrv_get_dirty_count(job->bcs->copy_bitmap);
+    estimate = bdrv_get_dirty_count(bcs_bitmap);
     job_progress_set_remaining(&job->common.job, estimate);
 }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_run(Job *job, Error **errp)
     BackupBlockJob *s = container_of(job, BackupBlockJob, common.job);
     int ret = 0;
 
-    backup_init_copy_bitmap(s);
+    backup_init_bcs_bitmap(s);
 
     if (s->sync_mode == MIRROR_SYNC_MODE_TOP) {
         int64_t offset = 0;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_run(Job *job, Error **errp)
 
             offset += count;
         }
-        s->bcs->skip_unallocated = false;
+        block_copy_set_skip_unallocated(s->bcs, false);
     }
 
     if (s->sync_mode == MIRROR_SYNC_MODE_NONE) {
         /*
-         * All bits are set in copy_bitmap to allow any cluster to be copied.
+         * All bits are set in bcs bitmap to allow any cluster to be copied.
          * This does not actually require them to be copied.
          */
         while (!job_is_cancelled(job)) {
diff --git a/block/block-copy.c b/block/block-copy.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-copy.c
+++ b/block/block-copy.c
@@ -XXX,XX +XXX,XX @@
 #define BLOCK_COPY_MAX_BUFFER (1 * MiB)
 #define BLOCK_COPY_MAX_MEM (128 * MiB)
 
+typedef struct BlockCopyInFlightReq {
+    int64_t offset;
+    int64_t bytes;
+    QLIST_ENTRY(BlockCopyInFlightReq) list;
+    CoQueue wait_queue; /* coroutines blocked on this request */
+} BlockCopyInFlightReq;
+
+typedef struct BlockCopyState {
+    /*
+     * BdrvChild objects are not owned or managed by block-copy. They are
+     * provided by block-copy user and user is responsible for appropriate
+     * permissions on these children.
+     */
+    BdrvChild *source;
+    BdrvChild *target;
+    BdrvDirtyBitmap *copy_bitmap;
+    int64_t in_flight_bytes;
+    int64_t cluster_size;
+    bool use_copy_range;
+    int64_t copy_size;
+    uint64_t len;
+    QLIST_HEAD(, BlockCopyInFlightReq) inflight_reqs;
+
+    BdrvRequestFlags write_flags;
+
+    /*
+     * skip_unallocated:
+     *
+     * Used by sync=top jobs, which first scan the source node for unallocated
+     * areas and clear them in the copy_bitmap.  During this process, the bitmap
+     * is thus not fully initialized: It may still have bits set for areas that
+     * are unallocated and should actually not be copied.
+     *
+     * This is indicated by skip_unallocated.
+     *
+     * In this case, block_copy() will query the source’s allocation status,
+     * skip unallocated regions, clear them in the copy_bitmap, and invoke
+     * block_copy_reset_unallocated() every time it does.
+     */
+    bool skip_unallocated;
+
+    ProgressMeter *progress;
+    /* progress_bytes_callback: called when some copying progress is done. */
+    ProgressBytesCallbackFunc progress_bytes_callback;
+    void *progress_opaque;
+
+    SharedResource *mem;
+} BlockCopyState;
+
 static BlockCopyInFlightReq *find_conflicting_inflight_req(BlockCopyState *s,
                                                            int64_t offset,
                                                            int64_t bytes)
@@ -XXX,XX +XXX,XX @@ int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes,
 
     return ret;
 }
+
+BdrvDirtyBitmap *block_copy_dirty_bitmap(BlockCopyState *s)
+{
+    return s->copy_bitmap;
+}
+
+void block_copy_set_skip_unallocated(BlockCopyState *s, bool skip)
+{
+    s->skip_unallocated = skip;
+}
diff --git a/include/block/block-copy.h b/include/block/block-copy.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-copy.h
+++ b/include/block/block-copy.h
@@ -XXX,XX +XXX,XX @@
 #include "block/block.h"
 #include "qemu/co-shared-resource.h"
 
-typedef struct BlockCopyInFlightReq {
-    int64_t offset;
-    int64_t bytes;
-    QLIST_ENTRY(BlockCopyInFlightReq) list;
-    CoQueue wait_queue; /* coroutines blocked on this request */
-} BlockCopyInFlightReq;
-
 typedef void (*ProgressBytesCallbackFunc)(int64_t bytes, void *opaque);
-typedef struct BlockCopyState {
-    /*
-     * BdrvChild objects are not owned or managed by block-copy. They are
-     * provided by block-copy user and user is responsible for appropriate
-     * permissions on these children.
-     */
-    BdrvChild *source;
-    BdrvChild *target;
-    BdrvDirtyBitmap *copy_bitmap;
-    int64_t in_flight_bytes;
-    int64_t cluster_size;
-    bool use_copy_range;
-    int64_t copy_size;
-    uint64_t len;
-    QLIST_HEAD(, BlockCopyInFlightReq) inflight_reqs;
-
-    BdrvRequestFlags write_flags;
-
-    /*
-     * skip_unallocated:
-     *
-     * Used by sync=top jobs, which first scan the source node for unallocated
-     * areas and clear them in the copy_bitmap.  During this process, the bitmap
-     * is thus not fully initialized: It may still have bits set for areas that
-     * are unallocated and should actually not be copied.
-     *
-     * This is indicated by skip_unallocated.
-     *
-     * In this case, block_copy() will query the source’s allocation status,
-     * skip unallocated regions, clear them in the copy_bitmap, and invoke
-     * block_copy_reset_unallocated() every time it does.
-     */
-    bool skip_unallocated;
-
-    ProgressMeter *progress;
-    /* progress_bytes_callback: called when some copying progress is done. */
-    ProgressBytesCallbackFunc progress_bytes_callback;
-    void *progress_opaque;
-
-    SharedResource *mem;
-} BlockCopyState;
+typedef struct BlockCopyState BlockCopyState;
 
 BlockCopyState *block_copy_state_new(BdrvChild *source, BdrvChild *target,
                                      int64_t cluster_size,
@@ -XXX,XX +XXX,XX @@ int64_t block_copy_reset_unallocated(BlockCopyState *s,
 int coroutine_fn block_copy(BlockCopyState *s, int64_t offset, int64_t bytes,
                             bool *error_is_read);
 
+BdrvDirtyBitmap *block_copy_dirty_bitmap(BlockCopyState *s);
+void block_copy_set_skip_unallocated(BlockCopyState *s, bool skip);
+
 #endif /* BLOCK_COPY_H */
-- 
2.24.1