Series comparison

-[Qemu-devel] [PULL 00/15] Block patches
+[Qemu-devel] [PULL 00/12] Block patches
-The following changes since commit 23919ddfd56135cad3cb468a8f54d5a595f024f4:
+The following changes since commit dac03af5d5482ec7ee9c23db467bb7230b33c0d9:
-  Merge remote-tracking branch 'remotes/aperard/tags/pull-xen-20190827' into staging (2019-08-27 15:52:36 +0100)
+  Merge remote-tracking branch 'remotes/rth/tags/pull-axp-20190825' into staging (2019-08-27 10:00:51 +0100)
 are available in the Git repository at:
-  https://github.com/XanClic/qemu.git tags/pull-block-2019-08-27
+  https://github.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to bb043c056cffcc2f3ce88bfdaf2e76e455c09e2c:
+for you to fetch changes up to 5396234b96a2ac743f48644529771498e036e698:
-  iotests: Unify cache mode quoting (2019-08-27 19:48:44 +0200)
+  block/qcow2: implement .bdrv_co_pwritev(_compressed)_part (2019-08-27 14:58:42 +0100)
 ----------------------------------------------------------------
-Block patches:
+Pull request
 - qemu-io now accepts a file to read a write pattern from
 - Ensure that raw files have their first block allocated so we can probe
   the O_DIRECT alignment if necessary
 - Various fixes
 ----------------------------------------------------------------
-Denis Plotnikov (1):
-  qemu-io: add pattern file for write command
-Max Reitz (7):
+Vladimir Sementsov-Ogievskiy (12):
-  iotests: Fix _filter_img_create()
+  util/iov: introduce qemu_iovec_init_extended
-  vmdk: Use bdrv_dirname() for relative extent paths
+  util/iov: improve qemu_iovec_is_zero
-  iotests: Keep testing broken relative extent paths
+  block/io: refactor padding
-  vmdk: Reject invalid compressed writes
+  block: define .*_part io handlers in BlockDriver
-  iotests: Disable broken streamOptimized tests
+  block/io: bdrv_co_do_copy_on_readv: use and support qiov_offset
-  iotests: Disable 110 for vmdk.twoGbMaxExtentSparse
+  block/io: bdrv_co_do_copy_on_readv: lazy allocation
-  iotests: Disable 126 for flat vmdk subformats
+  block/io: bdrv_aligned_preadv: use and support qiov_offset
   block/io: bdrv_aligned_pwritev: use and support qiov_offset
   block/io: introduce bdrv_co_p{read, write}v_part
   block/qcow2: refactor qcow2_co_preadv to use buffer-based io
   block/qcow2: implement .bdrv_co_preadv_part
   block/qcow2: implement .bdrv_co_pwritev(_compressed)_part
-Nir Soffer (3):
+ block/qcow2.h             |   1 +
-  block: posix: Always allocate the first block
+ include/block/block_int.h |  21 ++
-  iotests: Test allocate_first_block() with O_DIRECT
+ include/qemu/iov.h        |  10 +-
-  iotests: Unify cache mode quoting
+ block/backup.c            |   2 +-
+ block/io.c                | 541 +++++++++++++++++++++++---------------
-Stefan Hajnoczi (1):
+ block/qcow2-cluster.c     |  14 +-
-  file-posix: fix request_alignment typo
+ block/qcow2.c             | 131 +++++----
+ qemu-img.c                |   4 +-
-Thomas Huth (2):
+ util/iov.c                | 153 +++++++++--
-  iotests: Check for enabled drivers before testing them
+files changed, 568 insertions(+), 309 deletions(-)
   tests/check-block: Skip iotests when sanitizers are enabled
 Vladimir Sementsov-Ogievskiy (1):
   block: fix permission update in bdrv_replace_node
  block.c                                       |  5 +-
  block/file-posix.c                            | 53 +++++++++-
  block/vmdk.c                                  | 64 ++++++++----
  qemu-io-cmds.c                                | 99 +++++++++++++++++--
  tests/check-block.sh                          |  5 +
  tests/qemu-iotests/002                        |  1 +
  tests/qemu-iotests/003                        |  1 +
  tests/qemu-iotests/005                        |  3 +-
  tests/qemu-iotests/009                        |  1 +
  tests/qemu-iotests/010                        |  1 +
  tests/qemu-iotests/011                        |  1 +
  tests/qemu-iotests/017                        |  3 +-
  tests/qemu-iotests/018                        |  3 +-
  tests/qemu-iotests/019                        |  3 +-
  tests/qemu-iotests/020                        |  3 +-
  tests/qemu-iotests/026                        |  4 +-
  tests/qemu-iotests/027                        |  1 +
  tests/qemu-iotests/032                        |  1 +
  tests/qemu-iotests/033                        |  1 +
  tests/qemu-iotests/034                        |  3 +-
  tests/qemu-iotests/037                        |  3 +-
  tests/qemu-iotests/039                        |  4 +-
  tests/qemu-iotests/052                        |  2 +-
  tests/qemu-iotests/059                        | 34 ++++++-
  tests/qemu-iotests/059.out                    | 26 +++--
  tests/qemu-iotests/063                        |  3 +-
  tests/qemu-iotests/071                        |  1 +
  tests/qemu-iotests/072                        |  1 +
  tests/qemu-iotests/081                        |  4 +-
  tests/qemu-iotests/091                        |  4 +-
  tests/qemu-iotests/099                        |  1 +
  tests/qemu-iotests/105                        |  3 +-
  tests/qemu-iotests/110                        |  3 +-
  tests/qemu-iotests/120                        |  1 +
  tests/qemu-iotests/126                        |  2 +
  tests/qemu-iotests/{150.out => 150.out.qcow2} |  0
  tests/qemu-iotests/150.out.raw                | 12 +++
  tests/qemu-iotests/162                        |  4 +-
  tests/qemu-iotests/175                        | 47 +++++++--
  tests/qemu-iotests/175.out                    | 16 ++-
  tests/qemu-iotests/178.out.qcow2              |  4 +-
  tests/qemu-iotests/184                        |  1 +
  tests/qemu-iotests/186                        |  1 +
  tests/qemu-iotests/197                        |  1 +
  tests/qemu-iotests/215                        |  1 +
  tests/qemu-iotests/221.out                    | 12 ++-
  tests/qemu-iotests/251                        |  1 +
  tests/qemu-iotests/253.out                    | 12 ++-
  tests/qemu-iotests/common.filter              |  4 +-
  tests/qemu-iotests/common.rc                  | 14 +++
 files changed, 391 insertions(+), 87 deletions(-)
  rename tests/qemu-iotests/{150.out => 150.out.qcow2} (100%)
  create mode 100644 tests/qemu-iotests/150.out.raw
 --
 .21.0

-[Qemu-devel] [PULL 01/15] qemu-io: add pattern file for write command
+[Qemu-devel] [PULL 01/12] util/iov: introduce qemu_iovec_init_extended
-From: Denis Plotnikov <dplotnikov@virtuozzo.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-The patch allows to provide a pattern file for write
+Introduce new initialization API, to create requests with padding. Will
-command. There was no similar ability before.
+be used in the following patch. New API uses qemu_iovec_init_buf if
 resulting io vector has only one element, to avoid extra allocations.
 So, we need to update qemu_iovec_destroy to support destroying such
 QIOVs.
-Signed-off-by: Denis Plotnikov <dplotnikov@virtuozzo.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-id: 20190820164616.4072-1-dplotnikov@virtuozzo.com
+Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Message-id: 20190604161514.262241-2-vsementsov@virtuozzo.com
-[mreitz: Keep optstring in alphabetical order]
+Message-Id: <20190604161514.262241-2-vsementsov@virtuozzo.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- qemu-io-cmds.c | 99 +++++++++++++++++++++++++++++++++++++++++++++++---
+ include/qemu/iov.h |   7 +++
-file changed, 93 insertions(+), 6 deletions(-)
+ util/iov.c         | 112 +++++++++++++++++++++++++++++++++++++++++++--
 files changed, 114 insertions(+), 5 deletions(-)
-diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
+diff --git a/include/qemu/iov.h b/include/qemu/iov.h
 index XXXXXXX..XXXXXXX 100644
---- a/qemu-io-cmds.c
+--- a/include/qemu/iov.h
-+++ b/qemu-io-cmds.c
++++ b/include/qemu/iov.h
-@@ -XXX,XX +XXX,XX @@ static void qemu_io_free(void *p)
+@@ -XXX,XX +XXX,XX @@ static inline void *qemu_iovec_buf(QEMUIOVector *qiov)
-     qemu_vfree(p);
  void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
  void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov);
 +void qemu_iovec_init_extended(
 +        QEMUIOVector *qiov,
 +        void *head_buf, size_t head_len,
 +        QEMUIOVector *mid_qiov, size_t mid_offset, size_t mid_len,
 +        void *tail_buf, size_t tail_len);
 +void qemu_iovec_init_slice(QEMUIOVector *qiov, QEMUIOVector *source,
 +                           size_t offset, size_t len);
  void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
  void qemu_iovec_concat(QEMUIOVector *dst,
                         QEMUIOVector *src, size_t soffset, size_t sbytes);
 diff --git a/util/iov.c b/util/iov.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/iov.c
 +++ b/util/iov.c
@@ -XXX,XX +XXX,XX @@ void qemu_iovec_concat(QEMUIOVector *dst,
      qemu_iovec_concat_iov(dst, src->iov, src->niov, soffset, sbytes);
  }
 +/*
-+ * qemu_io_alloc_from_file()
++ * qiov_find_iov
 + *
-+ * Allocates the buffer and populates it with the content of the given file
++ * Return pointer to iovec structure, where byte at @offset in original vector
-+ * up to @len bytes. If the file length is less than @len, then the buffer
++ * @iov exactly is.
-+ * is populated with the file content cyclically.
++ * Set @remaining_offset to be offset inside that iovec to the same byte.
 + */
 +static struct iovec *iov_skip_offset(struct iovec *iov, size_t offset,
 +                                     size_t *remaining_offset)
 +{
 +    while (offset > 0 && offset >= iov->iov_len) {
 +        offset -= iov->iov_len;
 +        iov++;
 +    }
 +    *remaining_offset = offset;
 +
 +    return iov;
 +}
 +
 +/*
 + * qiov_slice
 + *
-+ * @blk - the block backend where the buffer content is going to be written to
++ * Find subarray of iovec's, containing requested range. @head would
-+ * @len - the buffer length
++ * be offset in first iov (returned by the function), @tail would be
-+ * @file_name - the file to read the content from
++ * count of extra bytes in last iovec (returned iov + @niov - 1).
 + *
 + * Returns: the buffer pointer on success
 + *          NULL on error
 + */
-+static void *qemu_io_alloc_from_file(BlockBackend *blk, size_t len,
++static struct iovec *qiov_slice(QEMUIOVector *qiov,
-+                                     const char *file_name)
++                                size_t offset, size_t len,
 +                                size_t *head, size_t *tail, int *niov)
 +{
-+    char *buf, *buf_origin;
++    struct iovec *iov, *end_iov;
 +    FILE *f = fopen(file_name, "r");
 +    int pattern_len;
 +
-+    if (!f) {
++    assert(offset + len <= qiov->size);
-+        perror(file_name);
++
-+        return NULL;
++    iov = iov_skip_offset(qiov->iov, offset, head);
 +    end_iov = iov_skip_offset(iov, *head + len, tail);
 +
 +    if (*tail > 0) {
 +        assert(*tail < end_iov->iov_len);
 +        *tail = end_iov->iov_len - *tail;
 +        end_iov++;
 +    }
 +
-+    if (qemuio_misalign) {
++    *niov = end_iov - iov;
-+        len += MISALIGN_OFFSET;
++
 +    return iov;
 +}
 +
 +/*
 + * Compile new iovec, combining @head_buf buffer, sub-qiov of @mid_qiov,
 + * and @tail_buf buffer into new qiov.
 + */
 +void qemu_iovec_init_extended(
 +        QEMUIOVector *qiov,
 +        void *head_buf, size_t head_len,
 +        QEMUIOVector *mid_qiov, size_t mid_offset, size_t mid_len,
 +        void *tail_buf, size_t tail_len)
 +{
 +    size_t mid_head, mid_tail;
 +    int total_niov, mid_niov = 0;
 +    struct iovec *p, *mid_iov;
 +
 +    if (mid_len) {
 +        mid_iov = qiov_slice(mid_qiov, mid_offset, mid_len,
 +                             &mid_head, &mid_tail, &mid_niov);
 +    }
 +
-+    buf_origin = buf = blk_blockalign(blk, len);
++    total_niov = !!head_len + mid_niov + !!tail_len;
-+
++    if (total_niov == 1) {
-+    if (qemuio_misalign) {
++        qemu_iovec_init_buf(qiov, NULL, 0);
-+        buf_origin += MISALIGN_OFFSET;
++        p = &qiov->local_iov;
-+        buf += MISALIGN_OFFSET;
++    } else {
-+        len -= MISALIGN_OFFSET;
++        qiov->niov = qiov->nalloc = total_niov;
 +        qiov->size = head_len + mid_len + tail_len;
 +        p = qiov->iov = g_new(struct iovec, qiov->niov);
 +    }
 +
-+    pattern_len = fread(buf_origin, 1, len, f);
++    if (head_len) {
-+
++        p->iov_base = head_buf;
-+    if (ferror(f)) {
++        p->iov_len = head_len;
-+        perror(file_name);
++        p++;
 +        goto error;
 +    }
 +
-+    if (pattern_len == 0) {
++    if (mid_len) {
-+        fprintf(stderr, "%s: file is empty\n", file_name);
++        memcpy(p, mid_iov, mid_niov * sizeof(*p));
-+        goto error;
++        p[0].iov_base = (uint8_t *)p[0].iov_base + mid_head;
 +        p[0].iov_len -= mid_head;
 +        p[mid_niov - 1].iov_len -= mid_tail;
 +        p += mid_niov;
 +    }
 +
-+    fclose(f);
++    if (tail_len) {
-+
++        p->iov_base = tail_buf;
-+    if (len > pattern_len) {
++        p->iov_len = tail_len;
 +        len -= pattern_len;
 +        buf += pattern_len;
 +
 +        while (len > 0) {
 +            size_t len_to_copy = MIN(pattern_len, len);
 +
 +            memcpy(buf, buf_origin, len_to_copy);
 +
 +            len -= len_to_copy;
 +            buf += len_to_copy;
 +        }
 +    }
-+
-+    return buf_origin;
-+
-+error:
-+    qemu_io_free(buf_origin);
-+    return NULL;
 +}
 +
- static void dump_buffer(const void *buffer, int64_t offset, int64_t len)
+ /*
   * Check if the contents of the iovecs are all zero
   */
@@ -XXX,XX +XXX,XX @@ bool qemu_iovec_is_zero(QEMUIOVector *qiov)
      return true;
  }
 +void qemu_iovec_init_slice(QEMUIOVector *qiov, QEMUIOVector *source,
 +                           size_t offset, size_t len)
 +{
 +    qemu_iovec_init_extended(qiov, NULL, 0, source, offset, len, NULL, 0);
 +}
 +
  void qemu_iovec_destroy(QEMUIOVector *qiov)
  {
-     uint64_t i;
+-    assert(qiov->nalloc != -1);
-@@ -XXX,XX +XXX,XX @@ static void write_help(void)
++    if (qiov->nalloc != -1) {
- " -n, -- with -z, don't allow slow fallback\n"
++        g_free(qiov->iov);
- " -p, -- ignored for backwards compatibility\n"
++    }
- " -P, -- use different pattern to fill file\n"
-+" -s, -- use a pattern file to fill the write buffer\n"
+-    qemu_iovec_reset(qiov);
- " -C, -- report statistics in a machine parsable format\n"
+-    g_free(qiov->iov);
- " -q, -- quiet mode, do not show I/O statistics\n"
+-    qiov->nalloc = 0;
- " -u, -- with -z, allow unmapping\n"
+-    qiov->iov = NULL;
-@@ -XXX,XX +XXX,XX @@ static const cmdinfo_t write_cmd = {
++    memset(qiov, 0, sizeof(*qiov));
-     .perm       = BLK_PERM_WRITE,
+ }
-     .argmin     = 2,
-     .argmax     = -1,
+ void qemu_iovec_reset(QEMUIOVector *qiov)
 -    .args       = "[-bcCfnquz] [-P pattern] off len",
 +    .args       = "[-bcCfnquz] [-P pattern | -s source_file] off len",
      .oneline    = "writes a number of bytes at a specified offset",
      .help       = write_help,
  };
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
  {
      struct timespec t1, t2;
      bool Cflag = false, qflag = false, bflag = false;
 -    bool Pflag = false, zflag = false, cflag = false;
 +    bool Pflag = false, zflag = false, cflag = false, sflag = false;
      int flags = 0;
      int c, cnt, ret;
      char *buf = NULL;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
      /* Some compilers get confused and warn if this is not initialized.  */
      int64_t total = 0;
      int pattern = 0xcd;
 +    const char *file_name = NULL;
 -    while ((c = getopt(argc, argv, "bcCfnpP:quz")) != -1) {
 +    while ((c = getopt(argc, argv, "bcCfnpP:qs:uz")) != -1) {
          switch (c) {
          case 'b':
              bflag = true;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
          case 'q':
              qflag = true;
              break;
 +        case 's':
 +            sflag = true;
 +            file_name = optarg;
 +            break;
          case 'u':
              flags |= BDRV_REQ_MAY_UNMAP;
              break;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
          return -EINVAL;
      }
 -    if (zflag && Pflag) {
 -        printf("-z and -P cannot be specified at the same time\n");
 +    if (zflag + Pflag + sflag > 1) {
 +        printf("Only one of -z, -P, and -s "
 +               "can be specified at the same time\n");
          return -EINVAL;
      }
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
      }
      if (!zflag) {
 -        buf = qemu_io_alloc(blk, count, pattern);
 +        if (sflag) {
 +            buf = qemu_io_alloc_from_file(blk, count, file_name);
 +            if (!buf) {
 +                return -EINVAL;
 +            }
 +        } else {
 +            buf = qemu_io_alloc(blk, count, pattern);
 +        }
      }
      clock_gettime(CLOCK_MONOTONIC, &t1);
 --
 .21.0

-[Qemu-devel] [PULL 14/15] tests/check-block: Skip iotests when sanitizers are enabled
+[Qemu-devel] [PULL 02/12] util/iov: improve qemu_iovec_is_zero
-From: Thomas Huth <thuth@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-The sanitizers (especially the address sanitizer from Clang) are
+We'll need to check a part of qiov soon, so implement it now.
 sometimes printing out warnings or false positives - this spoils
 the output of the iotests, causing some of the tests to fail.
 Thus let's skip the automatic iotests during "make check" when the
 user configured QEMU with --enable-sanitizers.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
+Optimization with align down to 4 * sizeof(long) is dropped due to:
-Message-id: 20190823084203.29734-1-thuth@redhat.com
+. It is strange: it aligns length of the buffer, but where is a
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+   guarantee that buffer pointer is aligned itself?
 . buffer_is_zero() is a better place for optimizations and it has
    them.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: 20190604161514.262241-3-vsementsov@virtuozzo.com
 Message-Id: <20190604161514.262241-3-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/check-block.sh | 5 +++++
+ include/qemu/iov.h |  2 +-
-file changed, 5 insertions(+)
+ block/io.c         |  2 +-
  util/iov.c         | 31 +++++++++++++++++++------------
 files changed, 21 insertions(+), 14 deletions(-)
-diff --git a/tests/check-block.sh b/tests/check-block.sh
+diff --git a/include/qemu/iov.h b/include/qemu/iov.h
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/check-block.sh
+--- a/include/qemu/iov.h
-+++ b/tests/check-block.sh
++++ b/include/qemu/iov.h
-@@ -XXX,XX +XXX,XX @@ if grep -q "TARGET_GPROF=y" *-softmmu/config-target.mak 2>/dev/null ; then
+@@ -XXX,XX +XXX,XX @@ void qemu_iovec_concat(QEMUIOVector *dst,
-     exit 0
+ size_t qemu_iovec_concat_iov(QEMUIOVector *dst,
- fi
+                              struct iovec *src_iov, unsigned int src_cnt,
+                              size_t soffset, size_t sbytes);
-+if grep -q "CFLAGS.*-fsanitize" config-host.mak 2>/dev/null ; then
+-bool qemu_iovec_is_zero(QEMUIOVector *qiov);
-+    echo "Sanitizers are enabled ==> Not running the qemu-iotests."
++bool qemu_iovec_is_zero(QEMUIOVector *qiov, size_t qiov_offeset, size_t bytes);
-+    exit 0
+ void qemu_iovec_destroy(QEMUIOVector *qiov);
-+fi
+ void qemu_iovec_reset(QEMUIOVector *qiov);
  size_t qemu_iovec_to_buf(QEMUIOVector *qiov, size_t offset,
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
      if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
          !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_pwrite_zeroes &&
 -        qemu_iovec_is_zero(qiov)) {
 +        qemu_iovec_is_zero(qiov, 0, qiov->size)) {
          flags |= BDRV_REQ_ZERO_WRITE;
          if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
              flags |= BDRV_REQ_MAY_UNMAP;
 diff --git a/util/iov.c b/util/iov.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/iov.c
 +++ b/util/iov.c
@@ -XXX,XX +XXX,XX @@ void qemu_iovec_init_extended(
  }
  /*
 - * Check if the contents of the iovecs are all zero
 + * Check if the contents of subrange of qiov data is all zeroes.
   */
 -bool qemu_iovec_is_zero(QEMUIOVector *qiov)
 +bool qemu_iovec_is_zero(QEMUIOVector *qiov, size_t offset, size_t bytes)
  {
 -    int i;
 -    for (i = 0; i < qiov->niov; i++) {
 -        size_t offs = QEMU_ALIGN_DOWN(qiov->iov[i].iov_len, 4 * sizeof(long));
 -        uint8_t *ptr = qiov->iov[i].iov_base;
 -        if (offs && !buffer_is_zero(qiov->iov[i].iov_base, offs)) {
 +    struct iovec *iov;
 +    size_t current_offset;
 +
- if [ -z "$(find . -name 'qemu-system-*' -print)" ]; then
++    assert(offset + bytes <= qiov->size);
-     echo "No qemu-system binary available ==> Not running the qemu-iotests."
++
-     exit 0
++    iov = iov_skip_offset(qiov->iov, offset, &current_offset);
 +
 +    while (bytes) {
 +        uint8_t *base = (uint8_t *)iov->iov_base + current_offset;
 +        size_t len = MIN(iov->iov_len - current_offset, bytes);
 +
 +        if (!buffer_is_zero(base, len)) {
              return false;
          }
 -        for (; offs < qiov->iov[i].iov_len; offs++) {
 -            if (ptr[offs]) {
 -                return false;
 -            }
 -        }
 +
 +        current_offset = 0;
 +        bytes -= len;
 +        iov++;
      }
 +
      return true;
  }
 --
 .21.0

-[Qemu-devel] [PULL 02/15] block: fix permission update in bdrv_replace_node
+[Qemu-devel] [PULL 03/12] block/io: refactor padding
 From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-It's wrong to OR shared permissions. It may lead to crash on further
+We have similar padding code in bdrv_co_pwritev,
-permission updates.
+bdrv_co_do_pwrite_zeroes and bdrv_co_preadv. Let's combine and unify
-Also, no needs to consider previously calculated permissions, as at
+it.
-this point we already bind all new parents and bdrv_get_cumulative_perm
-result is enough. So fix the bug by just set permissions by
+[Squashed in Vladimir's qemu-iotests 077 fix
-bdrv_get_cumulative_perm result.
+--Stefan]
 Bug was introduced in long ago 234ac1a9025, in 2.9.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-id: 20190824100740.61635-1-vsementsov@virtuozzo.com
+Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Message-id: 20190604161514.262241-4-vsementsov@virtuozzo.com
 Message-Id: <20190604161514.262241-4-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block.c | 5 ++---
+ block/io.c | 365 +++++++++++++++++++++++++++++------------------------
-file changed, 2 insertions(+), 3 deletions(-)
+file changed, 200 insertions(+), 165 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/block/io.c
-+++ b/block.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
+@@ -XXX,XX +XXX,XX @@ out:
  }
  /*
 - * Handle a read request in coroutine context
 + * Request padding
 + *
 + *  |<---- align ----->|                     |<----- align ---->|
 + *  |<- head ->|<------------- bytes ------------->|<-- tail -->|
 + *  |          |       |                     |     |            |
 + * -*----------$-------*-------- ... --------*-----$------------*---
 + *  |          |       |                     |     |            |
 + *  |          offset  |                     |     end          |
 + *  ALIGN_DOWN(offset) ALIGN_UP(offset)      ALIGN_DOWN(end)   ALIGN_UP(end)
 + *  [buf   ... )                             [tail_buf          )
 + *
 + * @buf is an aligned allocation needed to store @head and @tail paddings. @head
 + * is placed at the beginning of @buf and @tail at the @end.
 + *
 + * @tail_buf is a pointer to sub-buffer, corresponding to align-sized chunk
 + * around tail, if tail exists.
 + *
 + * @merge_reads is true for small requests,
 + * if @buf_len == @head + bytes + @tail. In this case it is possible that both
 + * head and tail exist but @buf_len == align and @tail_buf == @buf.
   */
 +typedef struct BdrvRequestPadding {
 +    uint8_t *buf;
 +    size_t buf_len;
 +    uint8_t *tail_buf;
 +    size_t head;
 +    size_t tail;
 +    bool merge_reads;
 +    QEMUIOVector local_qiov;
 +} BdrvRequestPadding;
 +
 +static bool bdrv_init_padding(BlockDriverState *bs,
 +                              int64_t offset, int64_t bytes,
 +                              BdrvRequestPadding *pad)
 +{
 +    uint64_t align = bs->bl.request_alignment;
 +    size_t sum;
 +
 +    memset(pad, 0, sizeof(*pad));
 +
 +    pad->head = offset & (align - 1);
 +    pad->tail = ((offset + bytes) & (align - 1));
 +    if (pad->tail) {
 +        pad->tail = align - pad->tail;
 +    }
 +
 +    if ((!pad->head && !pad->tail) || !bytes) {
 +        return false;
 +    }
 +
 +    sum = pad->head + bytes + pad->tail;
 +    pad->buf_len = (sum > align && pad->head && pad->tail) ? 2 * align : align;
 +    pad->buf = qemu_blockalign(bs, pad->buf_len);
 +    pad->merge_reads = sum == pad->buf_len;
 +    if (pad->tail) {
 +        pad->tail_buf = pad->buf + pad->buf_len - align;
 +    }
 +
 +    return true;
 +}
 +
 +static int bdrv_padding_rmw_read(BdrvChild *child,
 +                                 BdrvTrackedRequest *req,
 +                                 BdrvRequestPadding *pad,
 +                                 bool zero_middle)
 +{
 +    QEMUIOVector local_qiov;
 +    BlockDriverState *bs = child->bs;
 +    uint64_t align = bs->bl.request_alignment;
 +    int ret;
 +
 +    assert(req->serialising && pad->buf);
 +
 +    if (pad->head || pad->merge_reads) {
 +        uint64_t bytes = pad->merge_reads ? pad->buf_len : align;
 +
 +        qemu_iovec_init_buf(&local_qiov, pad->buf, bytes);
 +
 +        if (pad->head) {
 +            bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
 +        }
 +        if (pad->merge_reads && pad->tail) {
 +            bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
 +        }
 +        ret = bdrv_aligned_preadv(child, req, req->overlap_offset, bytes,
 +                                  align, &local_qiov, 0);
 +        if (ret < 0) {
 +            return ret;
 +        }
 +        if (pad->head) {
 +            bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
 +        }
 +        if (pad->merge_reads && pad->tail) {
 +            bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
 +        }
 +
 +        if (pad->merge_reads) {
 +            goto zero_mem;
 +        }
 +    }
 +
 +    if (pad->tail) {
 +        qemu_iovec_init_buf(&local_qiov, pad->tail_buf, align);
 +
 +        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
 +        ret = bdrv_aligned_preadv(
 +                child, req,
 +                req->overlap_offset + req->overlap_bytes - align,
 +                align, align, &local_qiov, 0);
 +        if (ret < 0) {
 +            return ret;
 +        }
 +        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
 +    }
 +
 +zero_mem:
 +    if (zero_middle) {
 +        memset(pad->buf + pad->head, 0, pad->buf_len - pad->head - pad->tail);
 +    }
 +
 +    return 0;
 +}
 +
 +static void bdrv_padding_destroy(BdrvRequestPadding *pad)
 +{
 +    if (pad->buf) {
 +        qemu_vfree(pad->buf);
 +        qemu_iovec_destroy(&pad->local_qiov);
 +    }
 +}
 +
 +/*
 + * bdrv_pad_request
 + *
 + * Exchange request parameters with padded request if needed. Don't include RMW
 + * read of padding, bdrv_padding_rmw_read() should be called separately if
 + * needed.
 + *
 + * All parameters except @bs are in-out: they represent original request at
 + * function call and padded (if padding needed) at function finish.
 + *
 + * Function always succeeds.
 + */
 +static bool bdrv_pad_request(BlockDriverState *bs, QEMUIOVector **qiov,
 +                             int64_t *offset, unsigned int *bytes,
 +                             BdrvRequestPadding *pad)
 +{
 +    if (!bdrv_init_padding(bs, *offset, *bytes, pad)) {
 +        return false;
 +    }
 +
 +    qemu_iovec_init_extended(&pad->local_qiov, pad->buf, pad->head,
 +                             *qiov, 0, *bytes,
 +                             pad->buf + pad->buf_len - pad->tail, pad->tail);
 +    *bytes += pad->head + pad->tail;
 +    *offset -= pad->head;
 +    *qiov = &pad->local_qiov;
 +
 +    return true;
 +}
 +
  int coroutine_fn bdrv_co_preadv(BdrvChild *child,
      int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
      BdrvRequestFlags flags)
  {
-     BdrvChild *c, *next;
+     BlockDriverState *bs = child->bs;
-     GSList *list = NULL, *p;
+-    BlockDriver *drv = bs->drv;
--    uint64_t old_perm, old_shared;
+     BdrvTrackedRequest req;
-     uint64_t perm = 0, shared = BLK_PERM_ALL;
+-
 -    uint64_t align = bs->bl.request_alignment;
 -    uint8_t *head_buf = NULL;
 -    uint8_t *tail_buf = NULL;
 -    QEMUIOVector local_qiov;
 -    bool use_local_qiov = false;
 +    BdrvRequestPadding pad;
      int ret;
-@@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
+-    trace_bdrv_co_preadv(child->bs, offset, bytes, flags);
-         bdrv_unref(from);
+-
 -    if (!drv) {
 -        return -ENOMEDIUM;
 -    }
 +    trace_bdrv_co_preadv(bs, offset, bytes, flags);
      ret = bdrv_check_byte_request(bs, offset, bytes);
      if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_preadv(BdrvChild *child,
          flags |= BDRV_REQ_COPY_ON_READ;
      }
--    bdrv_get_cumulative_perm(to, &old_perm, &old_shared);
+-    /* Align read if necessary by padding qiov */
--    bdrv_set_perm(to, old_perm | perm, old_shared | shared);
+-    if (offset & (align - 1)) {
-+    bdrv_get_cumulative_perm(to, &perm, &shared);
+-        head_buf = qemu_blockalign(bs, align);
-+    bdrv_set_perm(to, perm, shared);
+-        qemu_iovec_init(&local_qiov, qiov->niov + 2);
+-        qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
 -        qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
 -        use_local_qiov = true;
 -
 -        bytes += offset & (align - 1);
 -        offset = offset & ~(align - 1);
 -    }
 -
 -    if ((offset + bytes) & (align - 1)) {
 -        if (!use_local_qiov) {
 -            qemu_iovec_init(&local_qiov, qiov->niov + 1);
 -            qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
 -            use_local_qiov = true;
 -        }
 -        tail_buf = qemu_blockalign(bs, align);
 -        qemu_iovec_add(&local_qiov, tail_buf,
 -                       align - ((offset + bytes) & (align - 1)));
 -
 -        bytes = ROUND_UP(bytes, align);
 -    }
 +    bdrv_pad_request(bs, &qiov, &offset, &bytes, &pad);
      tracked_request_begin(&req, bs, offset, bytes, BDRV_TRACKED_READ);
 -    ret = bdrv_aligned_preadv(child, &req, offset, bytes, align,
 -                              use_local_qiov ? &local_qiov : qiov,
 -                              flags);
 +    ret = bdrv_aligned_preadv(child, &req, offset, bytes,
 +                              bs->bl.request_alignment,
 +                              qiov, flags);
      tracked_request_end(&req);
      bdrv_dec_in_flight(bs);
 -    if (use_local_qiov) {
 -        qemu_iovec_destroy(&local_qiov);
 -        qemu_vfree(head_buf);
 -        qemu_vfree(tail_buf);
 -    }
 +    bdrv_padding_destroy(&pad);
      return ret;
  }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
                                                  BdrvTrackedRequest *req)
  {
      BlockDriverState *bs = child->bs;
 -    uint8_t *buf = NULL;
      QEMUIOVector local_qiov;
      uint64_t align = bs->bl.request_alignment;
 -    unsigned int head_padding_bytes, tail_padding_bytes;
      int ret = 0;
 +    bool padding;
 +    BdrvRequestPadding pad;
 -    head_padding_bytes = offset & (align - 1);
 -    tail_padding_bytes = (align - (offset + bytes)) & (align - 1);
 -
 -
 -    assert(flags & BDRV_REQ_ZERO_WRITE);
 -    if (head_padding_bytes || tail_padding_bytes) {
 -        buf = qemu_blockalign(bs, align);
 -        qemu_iovec_init_buf(&local_qiov, buf, align);
 -    }
 -    if (head_padding_bytes) {
 -        uint64_t zero_bytes = MIN(bytes, align - head_padding_bytes);
 -
 -        /* RMW the unaligned part before head. */
 +    padding = bdrv_init_padding(bs, offset, bytes, &pad);
 +    if (padding) {
          mark_request_serialising(req, align);
          wait_serialising_requests(req);
 -        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
 -        ret = bdrv_aligned_preadv(child, req, offset & ~(align - 1), align,
 -                                  align, &local_qiov, 0);
 -        if (ret < 0) {
 -            goto fail;
 -        }
 -        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
 -        memset(buf + head_padding_bytes, 0, zero_bytes);
 -        ret = bdrv_aligned_pwritev(child, req, offset & ~(align - 1), align,
 -                                   align, &local_qiov,
 -                                   flags & ~BDRV_REQ_ZERO_WRITE);
 -        if (ret < 0) {
 -            goto fail;
 +        bdrv_padding_rmw_read(child, req, &pad, true);
 +
 +        if (pad.head || pad.merge_reads) {
 +            int64_t aligned_offset = offset & ~(align - 1);
 +            int64_t write_bytes = pad.merge_reads ? pad.buf_len : align;
 +
 +            qemu_iovec_init_buf(&local_qiov, pad.buf, write_bytes);
 +            ret = bdrv_aligned_pwritev(child, req, aligned_offset, write_bytes,
 +                                       align, &local_qiov,
 +                                       flags & ~BDRV_REQ_ZERO_WRITE);
 +            if (ret < 0 || pad.merge_reads) {
 +                /* Error or all work is done */
 +                goto out;
 +            }
 +            offset += write_bytes - pad.head;
 +            bytes -= write_bytes - pad.head;
          }
 -        offset += zero_bytes;
 -        bytes -= zero_bytes;
      }
      assert(!bytes || (offset & (align - 1)) == 0);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
          ret = bdrv_aligned_pwritev(child, req, offset, aligned_bytes, align,
                                     NULL, flags);
          if (ret < 0) {
 -            goto fail;
 +            goto out;
          }
          bytes -= aligned_bytes;
          offset += aligned_bytes;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
      assert(!bytes || (offset & (align - 1)) == 0);
      if (bytes) {
 -        assert(align == tail_padding_bytes + bytes);
 -        /* RMW the unaligned part after tail. */
 -        mark_request_serialising(req, align);
 -        wait_serialising_requests(req);
 -        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
 -        ret = bdrv_aligned_preadv(child, req, offset, align,
 -                                  align, &local_qiov, 0);
 -        if (ret < 0) {
 -            goto fail;
 -        }
 -        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
 +        assert(align == pad.tail + bytes);
 -        memset(buf, 0, bytes);
 +        qemu_iovec_init_buf(&local_qiov, pad.tail_buf, align);
          ret = bdrv_aligned_pwritev(child, req, offset, align, align,
                                     &local_qiov, flags & ~BDRV_REQ_ZERO_WRITE);
      }
 -fail:
 -    qemu_vfree(buf);
 +
 +out:
 +    bdrv_padding_destroy(&pad);
 +
      return ret;
 -
  }
  /*
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
      BlockDriverState *bs = child->bs;
      BdrvTrackedRequest req;
      uint64_t align = bs->bl.request_alignment;
 -    uint8_t *head_buf = NULL;
 -    uint8_t *tail_buf = NULL;
 -    QEMUIOVector local_qiov;
 -    bool use_local_qiov = false;
 +    BdrvRequestPadding pad;
      int ret;
      trace_bdrv_co_pwritev(child->bs, offset, bytes, flags);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
          goto out;
      }
 -    if (offset & (align - 1)) {
 -        QEMUIOVector head_qiov;
 -
 +    if (bdrv_pad_request(bs, &qiov, &offset, &bytes, &pad)) {
          mark_request_serialising(&req, align);
          wait_serialising_requests(&req);
 -
 -        head_buf = qemu_blockalign(bs, align);
 -        qemu_iovec_init_buf(&head_qiov, head_buf, align);
 -
 -        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
 -        ret = bdrv_aligned_preadv(child, &req, offset & ~(align - 1), align,
 -                                  align, &head_qiov, 0);
 -        if (ret < 0) {
 -            goto fail;
 -        }
 -        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
 -
 -        qemu_iovec_init(&local_qiov, qiov->niov + 2);
 -        qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
 -        qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
 -        use_local_qiov = true;
 -
 -        bytes += offset & (align - 1);
 -        offset = offset & ~(align - 1);
 -
 -        /* We have read the tail already if the request is smaller
 -         * than one aligned block.
 -         */
 -        if (bytes < align) {
 -            qemu_iovec_add(&local_qiov, head_buf + bytes, align - bytes);
 -            bytes = align;
 -        }
 -    }
 -
 -    if ((offset + bytes) & (align - 1)) {
 -        QEMUIOVector tail_qiov;
 -        size_t tail_bytes;
 -        bool waited;
 -
 -        mark_request_serialising(&req, align);
 -        waited = wait_serialising_requests(&req);
 -        assert(!waited || !use_local_qiov);
 -
 -        tail_buf = qemu_blockalign(bs, align);
 -        qemu_iovec_init_buf(&tail_qiov, tail_buf, align);
 -
 -        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
 -        ret = bdrv_aligned_preadv(child, &req, (offset + bytes) & ~(align - 1),
 -                                  align, align, &tail_qiov, 0);
 -        if (ret < 0) {
 -            goto fail;
 -        }
 -        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
 -
 -        if (!use_local_qiov) {
 -            qemu_iovec_init(&local_qiov, qiov->niov + 1);
 -            qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
 -            use_local_qiov = true;
 -        }
 -
 -        tail_bytes = (offset + bytes) & (align - 1);
 -        qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
 -
 -        bytes = ROUND_UP(bytes, align);
 +        bdrv_padding_rmw_read(child, &req, &pad, false);
      }
      ret = bdrv_aligned_pwritev(child, &req, offset, bytes, align,
 -                               use_local_qiov ? &local_qiov : qiov,
 -                               flags);
 +                               qiov, flags);
 -fail:
 +    bdrv_padding_destroy(&pad);
 -    if (use_local_qiov) {
 -        qemu_iovec_destroy(&local_qiov);
 -    }
 -    qemu_vfree(head_buf);
 -    qemu_vfree(tail_buf);
  out:
-     g_slist_free(list);
+     tracked_request_end(&req);
      bdrv_dec_in_flight(bs);
 +
      return ret;
  }
 --
 .21.0

-[Qemu-devel] [PULL 06/15] vmdk: Use bdrv_dirname() for relative extent paths
+[Qemu-devel] [PULL 04/12] block: define .*_part io handlers in BlockDriver
-This makes iotest 033 pass with e.g. subformat=monolithicFlat.  It also
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-turns a former error in 059 into success.
+Add handlers supporting qiov_offset parameter:
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+    bdrv_co_preadv_part
-Message-id: 20190815153638.4600-3-mreitz@redhat.com
+    bdrv_co_pwritev_part
-Reviewed-by: John Snow <jsnow@redhat.com>
+    bdrv_co_pwritev_compressed_part
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+This is used to reduce need of defining local_qiovs and hd_qiovs in all
 corners of block layer code. The following patches will increase usage
 of this new API part by part.
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: 20190604161514.262241-5-vsementsov@virtuozzo.com
 Message-Id: <20190604161514.262241-5-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/vmdk.c               | 54 ++++++++++++++++++++++++--------------
+ include/block/block_int.h | 15 ++++++
- tests/qemu-iotests/059     |  7 +++--
+ block/backup.c            |  2 +-
- tests/qemu-iotests/059.out |  4 ++-
+ block/io.c                | 96 +++++++++++++++++++++++++++++++--------
-files changed, 42 insertions(+), 23 deletions(-)
+ qemu-img.c                |  4 +-
+files changed, 95 insertions(+), 22 deletions(-)
-diff --git a/block/vmdk.c b/block/vmdk.c
 diff --git a/include/block/block_int.h b/include/block/block_int.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/vmdk.c
+--- a/include/block/block_int.h
-+++ b/block/vmdk.c
++++ b/include/block/block_int.h
-@@ -XXX,XX +XXX,XX @@ static const char *next_line(const char *s)
+@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
- }
+      */
+     int coroutine_fn (*bdrv_co_preadv)(BlockDriverState *bs,
- static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
+         uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags);
--                              const char *desc_file_path, QDict *options,
++    int coroutine_fn (*bdrv_co_preadv_part)(BlockDriverState *bs,
--                              Error **errp)
++        uint64_t offset, uint64_t bytes,
-+                              QDict *options, Error **errp)
++        QEMUIOVector *qiov, size_t qiov_offset, int flags);
      int coroutine_fn (*bdrv_co_writev)(BlockDriverState *bs,
          int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, int flags);
      /**
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
       */
      int coroutine_fn (*bdrv_co_pwritev)(BlockDriverState *bs,
          uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags);
 +    int coroutine_fn (*bdrv_co_pwritev_part)(BlockDriverState *bs,
 +        uint64_t offset, uint64_t bytes,
 +        QEMUIOVector *qiov, size_t qiov_offset, int flags);
      /*
       * Efficiently zero a region of the disk image.  Typically an image format
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
      int coroutine_fn (*bdrv_co_pwritev_compressed)(BlockDriverState *bs,
          uint64_t offset, uint64_t bytes, QEMUIOVector *qiov);
 +    int coroutine_fn (*bdrv_co_pwritev_compressed_part)(BlockDriverState *bs,
 +        uint64_t offset, uint64_t bytes, QEMUIOVector *qiov,
 +        size_t qiov_offset);
      int (*bdrv_snapshot_create)(BlockDriverState *bs,
                                  QEMUSnapshotInfo *sn_info);
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
      const char *const *strong_runtime_opts;
  };
 +static inline bool block_driver_can_compress(BlockDriver *drv)
 +{
 +    return drv->bdrv_co_pwritev_compressed ||
 +           drv->bdrv_co_pwritev_compressed_part;
 +}
 +
  typedef struct BlockLimits {
      /* Alignment requirement, in bytes, for offset/length of I/O
       * requests. Must be a power of 2 less than INT_MAX; defaults to
 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 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
          return NULL;
      }
 -    if (compress && target->drv->bdrv_co_pwritev_compressed == NULL) {
 +    if (compress && !block_driver_can_compress(target->drv)) {
          error_setg(errp, "Compression is not supported for this drive %s",
                     bdrv_get_device_name(target));
          return NULL;
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)
      /* Default alignment based on whether driver has byte interface */
      bs->bl.request_alignment = (drv->bdrv_co_preadv ||
 -                                drv->bdrv_aio_preadv) ? 1 : 512;
 +                                drv->bdrv_aio_preadv ||
 +                                drv->bdrv_co_preadv_part) ? 1 : 512;
      /* Take some limits from the children as a default */
      if (bs->file) {
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_io_em_complete(void *opaque, int ret)
  static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
                                             uint64_t offset, uint64_t bytes,
 -                                           QEMUIOVector *qiov, int flags)
 +                                           QEMUIOVector *qiov,
 +                                           size_t qiov_offset, int flags)
  {
-     int ret;
+     BlockDriver *drv = bs->drv;
-     int matches;
+     int64_t sector_num;
-@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
+     unsigned int nb_sectors;
-     const char *p, *np;
++    QEMUIOVector local_qiov;
-     int64_t sectors = 0;
++    int ret;
-     int64_t flat_offset;
-+    char *desc_file_dir = NULL;
+     assert(!(flags & ~BDRV_REQ_MASK));
-     char *extent_path;
+     assert(!(flags & BDRV_REQ_NO_FALLBACK));
-     BdrvChild *extent_file;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
-     BDRVVmdkState *s = bs->opaque;
+         return -ENOMEDIUM;
-@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
+     }
-             continue;
-         }
++    if (drv->bdrv_co_preadv_part) {
++        return drv->bdrv_co_preadv_part(bs, offset, bytes, qiov, qiov_offset,
--        if (!path_is_absolute(fname) && !path_has_protocol(fname) &&
++                                        flags);
--            !desc_file_path[0])
++    }
--        {
++
--            bdrv_refresh_filename(bs->file->bs);
++    if (qiov_offset > 0 || bytes != qiov->size) {
--            error_setg(errp, "Cannot use relative extent paths with VMDK "
++        qemu_iovec_init_slice(&local_qiov, qiov, qiov_offset, bytes);
--                       "descriptor file '%s'", bs->file->bs->filename);
++        qiov = &local_qiov;
--            return -EINVAL;
++    }
--        }
++
-+        if (path_is_absolute(fname)) {
+     if (drv->bdrv_co_preadv) {
-+            extent_path = g_strdup(fname);
+-        return drv->bdrv_co_preadv(bs, offset, bytes, qiov, flags);
-+        } else {
++        ret = drv->bdrv_co_preadv(bs, offset, bytes, qiov, flags);
-+            if (!desc_file_dir) {
++        goto out;
-+                desc_file_dir = bdrv_dirname(bs->file->bs, errp);
+     }
-+                if (!desc_file_dir) {
-+                    bdrv_refresh_filename(bs->file->bs);
+     if (drv->bdrv_aio_preadv) {
-+                    error_prepend(errp, "Cannot use relative paths with VMDK "
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
-+                                  "descriptor file '%s': ",
+         acb = drv->bdrv_aio_preadv(bs, offset, bytes, qiov, flags,
-+                                  bs->file->bs->filename);
+                                    bdrv_co_io_em_complete, &co);
-+                    ret = -EINVAL;
+         if (acb == NULL) {
-+                    goto out;
+-            return -EIO;
-+                }
++            ret = -EIO;
-+            }
++            goto out;
+         } else {
--        extent_path = path_combine(desc_file_path, fname);
+             qemu_coroutine_yield();
-+            extent_path = g_strconcat(desc_file_dir, fname, NULL);
+-            return co.ret;
-+        }
++            ret = co.ret;
          ret = snprintf(extent_opt_prefix, 32, "extents.%d", s->num_extents);
          assert(ret < 32);
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
          g_free(extent_path);
          if (local_err) {
              error_propagate(errp, local_err);
 -            return -EINVAL;
 +            ret = -EINVAL;
 +            goto out;
          }
+     }
-         /* save to extents array */
-@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
-, 0, 0, 0, 0, &extent, errp);
+     assert(bytes <= BDRV_REQUEST_MAX_BYTES);
-             if (ret < 0) {
+     assert(drv->bdrv_co_readv);
-                 bdrv_unref_child(bs, extent_file);
--                return ret;
+-    return drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
-+                goto out;
++    ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
              }
              extent->flat_start_offset = flat_offset << 9;
          } else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) {
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
              g_free(buf);
              if (ret) {
                  bdrv_unref_child(bs, extent_file);
 -                return ret;
 +                goto out;
              }
              extent = &s->extents[s->num_extents - 1];
          } else if (!strcmp(type, "SESPARSE")) {
              ret = vmdk_open_se_sparse(bs, extent_file, bs->open_flags, errp);
              if (ret) {
                  bdrv_unref_child(bs, extent_file);
 -                return ret;
 +                goto out;
              }
              extent = &s->extents[s->num_extents - 1];
          } else {
              error_setg(errp, "Unsupported extent type '%s'", type);
              bdrv_unref_child(bs, extent_file);
 -            return -ENOTSUP;
 +            ret = -ENOTSUP;
 +            goto out;
          }
          extent->type = g_strdup(type);
      }
 -    return 0;
 +
 +    ret = 0;
 +    goto out;
  invalid:
      np = next_line(p);
@@ -XXX,XX +XXX,XX @@ invalid:
          np--;
      }
      error_setg(errp, "Invalid extent line: %.*s", (int)(np - p), p);
 -    return -EINVAL;
 +    ret = -EINVAL;
 +
 +out:
-+    g_free(desc_file_dir);
++    if (qiov == &local_qiov) {
 +        qemu_iovec_destroy(&local_qiov);
 +    }
 +
 +    return ret;
  }
- static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf,
+ static int coroutine_fn bdrv_driver_pwritev(BlockDriverState *bs,
-@@ -XXX,XX +XXX,XX @@ static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf,
+                                             uint64_t offset, uint64_t bytes,
-     }
+-                                            QEMUIOVector *qiov, int flags)
-     s->create_type = g_strdup(ct);
++                                            QEMUIOVector *qiov,
-     s->desc_offset = 0;
++                                            size_t qiov_offset, int flags)
--    ret = vmdk_parse_extents(buf, bs, bs->file->bs->exact_filename, options,
+ {
--                             errp);
+     BlockDriver *drv = bs->drv;
-+    ret = vmdk_parse_extents(buf, bs, options, errp);
+     int64_t sector_num;
- exit:
+     unsigned int nb_sectors;
 +    QEMUIOVector local_qiov;
      int ret;
      assert(!(flags & ~BDRV_REQ_MASK));
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_driver_pwritev(BlockDriverState *bs,
          return -ENOMEDIUM;
      }
 +    if (drv->bdrv_co_pwritev_part) {
 +        ret = drv->bdrv_co_pwritev_part(bs, offset, bytes, qiov, qiov_offset,
 +                                        flags & bs->supported_write_flags);
 +        flags &= ~bs->supported_write_flags;
 +        goto emulate_flags;
 +    }
 +
 +    if (qiov_offset > 0 || bytes != qiov->size) {
 +        qemu_iovec_init_slice(&local_qiov, qiov, qiov_offset, bytes);
 +        qiov = &local_qiov;
 +    }
 +
      if (drv->bdrv_co_pwritev) {
          ret = drv->bdrv_co_pwritev(bs, offset, bytes, qiov,
                                     flags & bs->supported_write_flags);
@@ -XXX,XX +XXX,XX @@ emulate_flags:
          ret = bdrv_co_flush(bs);
      }
 +    if (qiov == &local_qiov) {
 +        qemu_iovec_destroy(&local_qiov);
 +    }
 +
      return ret;
  }
-diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059
-index XXXXXXX..XXXXXXX 100755
+ static int coroutine_fn
---- a/tests/qemu-iotests/059
+ bdrv_driver_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
-+++ b/tests/qemu-iotests/059
+-                               uint64_t bytes, QEMUIOVector *qiov)
-@@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -f qcow2 -O vmdk -o subformat=streamOptimized "$TEST_IMG.qcow2
++                               uint64_t bytes, QEMUIOVector *qiov,
++                               size_t qiov_offset)
- echo
+ {
- echo "=== Testing monolithicFlat with internally generated JSON file name ==="
+     BlockDriver *drv = bs->drv;
-+# Should work, because bdrv_dirname() works fine with blkdebug
++    QEMUIOVector local_qiov;
- IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
++    int ret;
--$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" 2>&1 \
--    | _filter_testdir | _filter_imgfmt
+     if (!drv) {
-+$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" \
+         return -ENOMEDIUM;
-+         -c info \
+     }
-+    2>&1 \
-+    | _filter_testdir | _filter_imgfmt | _filter_img_info
+-    if (!drv->bdrv_co_pwritev_compressed) {
- _cleanup_test_img
++    if (!block_driver_can_compress(drv)) {
+         return -ENOTSUP;
- echo
+     }
-diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
 -    return drv->bdrv_co_pwritev_compressed(bs, offset, bytes, qiov);
 +    if (drv->bdrv_co_pwritev_compressed_part) {
 +        return drv->bdrv_co_pwritev_compressed_part(bs, offset, bytes,
 +                                                    qiov, qiov_offset);
 +    }
 +
 +    if (qiov_offset == 0) {
 +        return drv->bdrv_co_pwritev_compressed(bs, offset, bytes, qiov);
 +    }
 +
 +    qemu_iovec_init_slice(&local_qiov, qiov, qiov_offset, bytes);
 +    ret = drv->bdrv_co_pwritev_compressed(bs, offset, bytes, &local_qiov);
 +    qemu_iovec_destroy(&local_qiov);
 +
 +    return ret;
  }
  static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
              qemu_iovec_init_buf(&local_qiov, bounce_buffer, pnum);
              ret = bdrv_driver_preadv(bs, cluster_offset, pnum,
 -                                     &local_qiov, 0);
 +                                     &local_qiov, 0, 0);
              if (ret < 0) {
                  goto err;
              }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
                   * necessary to flush even in cache=writethrough mode.
                   */
                  ret = bdrv_driver_pwritev(bs, cluster_offset, pnum,
 -                                          &local_qiov,
 +                                          &local_qiov, 0,
                                            BDRV_REQ_WRITE_UNCHANGED);
              }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
              qemu_iovec_init(&local_qiov, qiov->niov);
              qemu_iovec_concat(&local_qiov, qiov, progress, pnum - skip_bytes);
              ret = bdrv_driver_preadv(bs, offset + progress, local_qiov.size,
 -                                     &local_qiov, 0);
 +                                     &local_qiov, 0, 0);
              qemu_iovec_destroy(&local_qiov);
              if (ret < 0) {
                  goto err;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
      max_bytes = ROUND_UP(MAX(0, total_bytes - offset), align);
      if (bytes <= max_bytes && bytes <= max_transfer) {
 -        ret = bdrv_driver_preadv(bs, offset, bytes, qiov, 0);
 +        ret = bdrv_driver_preadv(bs, offset, bytes, qiov, 0, 0);
          goto out;
      }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
              qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);
              ret = bdrv_driver_preadv(bs, offset + bytes - bytes_remaining,
 -                                     num, &local_qiov, 0);
 +                                     num, &local_qiov, 0, 0);
              max_bytes -= num;
              qemu_iovec_destroy(&local_qiov);
          } else {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
              }
              qemu_iovec_init_buf(&qiov, buf, num);
 -            ret = bdrv_driver_pwritev(bs, offset, num, &qiov, write_flags);
 +            ret = bdrv_driver_pwritev(bs, offset, num, &qiov, 0, write_flags);
              /* Keep bounce buffer around if it is big enough for all
               * all future requests.
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
          bdrv_debug_event(bs, BLKDBG_PWRITEV_ZERO);
          ret = bdrv_co_do_pwrite_zeroes(bs, offset, bytes, flags);
      } else if (flags & BDRV_REQ_WRITE_COMPRESSED) {
 -        ret = bdrv_driver_pwritev_compressed(bs, offset, bytes, qiov);
 +        ret = bdrv_driver_pwritev_compressed(bs, offset, bytes, qiov, 0);
      } else if (bytes <= max_transfer) {
          bdrv_debug_event(bs, BLKDBG_PWRITEV);
 -        ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, flags);
 +        ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, 0, flags);
      } else {
          bdrv_debug_event(bs, BLKDBG_PWRITEV);
          while (bytes_remaining) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
              qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);
              ret = bdrv_driver_pwritev(bs, offset + bytes - bytes_remaining,
 -                                      num, &local_qiov, local_flags);
 +                                      num, &local_qiov, 0, local_flags);
              qemu_iovec_destroy(&local_qiov);
              if (ret < 0) {
                  break;
 diff --git a/qemu-img.c b/qemu-img.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/059.out
+--- a/qemu-img.c
-+++ b/tests/qemu-iotests/059.out
++++ b/qemu-img.c
-@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
+@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
+         const char *preallocation =
- === Testing monolithicFlat with internally generated JSON file name ===
+             qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
- Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
--qemu-io: can't open: Cannot use relative extent paths with VMDK descriptor file 'json:{"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "read_aio"}'
+-        if (drv && !drv->bdrv_co_pwritev_compressed) {
-+format name: IMGFMT
++        if (drv && !block_driver_can_compress(drv)) {
-+cluster size: 0 bytes
+             error_report("Compression not supported for this file format");
-+vm state offset: 0 bytes
+             ret = -1;
+             goto out;
- === Testing version 3 ===
+@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
- image: TEST_DIR/iotest-version3.IMGFMT
+     }
      out_bs = blk_bs(s.target);
 -    if (s.compressed && !out_bs->drv->bdrv_co_pwritev_compressed) {
 +    if (s.compressed && !block_driver_can_compress(out_bs->drv)) {
          error_report("Compression not supported for this file format");
          ret = -1;
          goto out;
 --
 .21.0

-[Qemu-devel] [PULL 08/15] vmdk: Reject invalid compressed writes
+[Qemu-devel] [PULL 05/12] block/io: bdrv_co_do_copy_on_readv: use and support qiov_offset
-Compressed writes generally have to write full clusters, not just in
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 theory but also in practice when it comes to vmdk's streamOptimized
 subformat.  It currently is just silently broken for writes with
 non-zero in-cluster offsets:
-$ qemu-img create -f vmdk -o subformat=streamOptimized foo.vmdk 1M
+Use and support new API in bdrv_co_do_copy_on_readv. Note that in case
-$ qemu-io -c 'write 4k 4k' -c 'read 4k 4k' foo.vmdk
+of allocated-in-top we need to shrink read size to MIN(..) by hand, as
-wrote 4096/4096 bytes at offset 4096
+pre-patch this was actually done implicitly by qemu_iovec_concat (and
-KiB, 1 ops; 00.01 sec (443.724 KiB/sec and 110.9309 ops/sec)
+we used local_qiov.size).
 read failed: Invalid argument
-(The technical reason is that vmdk_write_extent() just writes the
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-incomplete compressed data actually to offset 4k.  When reading the
+Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
-data, vmdk_read_extent() looks at offset 0 and finds the compressed data
+Message-id: 20190604161514.262241-6-vsementsov@virtuozzo.com
-size to be 0, because that is what it reads from there.  This yields an
+Message-Id: <20190604161514.262241-6-vsementsov@virtuozzo.com>
-error.)
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  block/io.c | 18 +++++++++---------
 file changed, 9 insertions(+), 9 deletions(-)
-For incomplete writes with zero in-cluster offsets, the error path when
+diff --git a/block/io.c b/block/io.c
 reading the rest of the cluster is a bit different, but the result is
 the same:
 $ qemu-img create -f vmdk -o subformat=streamOptimized foo.vmdk 1M
 $ qemu-io -c 'write 0k 4k' -c 'read 4k 4k' foo.vmdk
 wrote 4096/4096 bytes at offset 0
 KiB, 1 ops; 00.01 sec (362.641 KiB/sec and 90.6603 ops/sec)
 read failed: Invalid argument
 (Here, vmdk_read_extent() finds the data and then sees that the
 uncompressed data is short.)
 It is better to reject invalid writes than to make the user believe they
 might have succeeded and then fail when trying to read it back.
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Message-id: 20190815153638.4600-5-mreitz@redhat.com
 Reviewed-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block/vmdk.c | 10 ++++++++++
 file changed, 10 insertions(+)
 diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/vmdk.c
+--- a/block/io.c
-+++ b/block/vmdk.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
+@@ -XXX,XX +XXX,XX @@ bdrv_driver_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
-     if (extent->compressed) {
-         void *compressed_data;
+ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
+         int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
-+        /* Only whole clusters */
+-        int flags)
-+        if (offset_in_cluster ||
++        size_t qiov_offset, int flags)
-+            n_bytes > (extent->cluster_sectors * SECTOR_SIZE) ||
+ {
-+            (n_bytes < (extent->cluster_sectors * SECTOR_SIZE) &&
+     BlockDriverState *bs = child->bs;
-+             offset + n_bytes != extent->end_sector * SECTOR_SIZE))
-+        {
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
-+            ret = -EINVAL;
+     void *bounce_buffer;
-+            goto out;
-+        }
+     BlockDriver *drv = bs->drv;
 -    QEMUIOVector local_qiov;
      int64_t cluster_offset;
      int64_t cluster_bytes;
      size_t skip_bytes;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
          assert(skip_bytes < pnum);
          if (ret <= 0) {
 +            QEMUIOVector local_qiov;
 +
-         if (!extent->has_marker) {
+             /* Must copy-on-read; use the bounce buffer */
-             ret = -EINVAL;
+             pnum = MIN(pnum, MAX_BOUNCE_BUFFER);
              qemu_iovec_init_buf(&local_qiov, bounce_buffer, pnum);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
              }
              if (!(flags & BDRV_REQ_PREFETCH)) {
 -                qemu_iovec_from_buf(qiov, progress, bounce_buffer + skip_bytes,
 +                qemu_iovec_from_buf(qiov, qiov_offset + progress,
 +                                    bounce_buffer + skip_bytes,
                                      pnum - skip_bytes);
              }
          } else if (!(flags & BDRV_REQ_PREFETCH)) {
              /* Read directly into the destination */
 -            qemu_iovec_init(&local_qiov, qiov->niov);
 -            qemu_iovec_concat(&local_qiov, qiov, progress, pnum - skip_bytes);
 -            ret = bdrv_driver_preadv(bs, offset + progress, local_qiov.size,
 -                                     &local_qiov, 0, 0);
 -            qemu_iovec_destroy(&local_qiov);
 +            ret = bdrv_driver_preadv(bs, offset + progress,
 +                                     MIN(pnum - skip_bytes, bytes - progress),
 +                                     qiov, qiov_offset + progress, 0);
              if (ret < 0) {
                  goto err;
              }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
          }
          if (!ret || pnum != bytes) {
 -            ret = bdrv_co_do_copy_on_readv(child, offset, bytes, qiov, flags);
 +            ret = bdrv_co_do_copy_on_readv(child, offset, bytes, qiov, 0, flags);
              goto out;
          } else if (flags & BDRV_REQ_PREFETCH) {
              goto out;
 --
 .21.0

-[Qemu-devel] [PULL 11/15] iotests: Disable 126 for flat vmdk subformats
+[Qemu-devel] [PULL 06/12] block/io: bdrv_co_do_copy_on_readv: lazy allocation
-iotest 126 requires backing file support, which flat vmdks cannot offer.
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Skip this test for such subformats.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Allocate bounce_buffer only if it is really needed. Also, sub-optimize
-Message-id: 20190815153638.4600-8-mreitz@redhat.com
+allocation size (why not?).
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: 20190604161514.262241-7-vsementsov@virtuozzo.com
 Message-Id: <20190604161514.262241-7-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/126 | 2 ++
+ block/io.c | 21 ++++++++++++---------
-file changed, 2 insertions(+)
+file changed, 12 insertions(+), 9 deletions(-)
-diff --git a/tests/qemu-iotests/126 b/tests/qemu-iotests/126
+diff --git a/block/io.c b/block/io.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/126
+--- a/block/io.c
-+++ b/tests/qemu-iotests/126
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
+      * modifying the image file.  This is critical for zero-copy guest I/O
- # Needs backing file support
+      * where anything might happen inside guest memory.
- _supported_fmt qcow qcow2 qed vmdk
+      */
-+_unsupported_imgopts "subformat=monolithicFlat" \
+-    void *bounce_buffer;
-+                     "subformat=twoGbMaxExtentFlat"
++    void *bounce_buffer = NULL;
- # This is the default protocol (and we want to test the difference between
- # colons which separate a protocol prefix from the rest and colons which are
+     BlockDriver *drv = bs->drv;
- # just part of the filename, so we cannot test protocols which require a prefix)
+     int64_t cluster_offset;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
      trace_bdrv_co_do_copy_on_readv(bs, offset, bytes,
                                     cluster_offset, cluster_bytes);
 -    bounce_buffer = qemu_try_blockalign(bs,
 -                                        MIN(MIN(max_transfer, cluster_bytes),
 -                                            MAX_BOUNCE_BUFFER));
 -    if (bounce_buffer == NULL) {
 -        ret = -ENOMEM;
 -        goto err;
 -    }
 -
      while (cluster_bytes) {
          int64_t pnum;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
              /* Must copy-on-read; use the bounce buffer */
              pnum = MIN(pnum, MAX_BOUNCE_BUFFER);
 +            if (!bounce_buffer) {
 +                int64_t max_we_need = MAX(pnum, cluster_bytes - pnum);
 +                int64_t max_allowed = MIN(max_transfer, MAX_BOUNCE_BUFFER);
 +                int64_t bounce_buffer_len = MIN(max_we_need, max_allowed);
 +
 +                bounce_buffer = qemu_try_blockalign(bs, bounce_buffer_len);
 +                if (!bounce_buffer) {
 +                    ret = -ENOMEM;
 +                    goto err;
 +                }
 +            }
              qemu_iovec_init_buf(&local_qiov, bounce_buffer, pnum);
              ret = bdrv_driver_preadv(bs, cluster_offset, pnum,
 --
 .21.0

-[Qemu-devel] [PULL 15/15] iotests: Unify cache mode quoting
+[Qemu-devel] [PULL 07/12] block/io: bdrv_aligned_preadv: use and support qiov_offset
-From: Nir Soffer <nirsof@gmail.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Quoting cache mode is not needed, and most tests use unquoted values.
+Use and support new API in bdrv_co_do_copy_on_readv.
 Unify all test to use the same style.
-Message-id: 20190827173432.7656-1-nsoffer@redhat.com
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Signed-off-by: Nir Soffer <nsoffer@redhat.com>
+Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Message-id: 20190604161514.262241-8-vsementsov@virtuozzo.com
 Message-Id: <20190604161514.262241-8-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/026 | 4 ++--
+ block/io.c | 21 ++++++++-------------
- tests/qemu-iotests/039 | 4 ++--
+file changed, 8 insertions(+), 13 deletions(-)
  tests/qemu-iotests/052 | 2 +-
  tests/qemu-iotests/091 | 4 ++--
 files changed, 7 insertions(+), 7 deletions(-)
-diff --git a/tests/qemu-iotests/026 b/tests/qemu-iotests/026
+diff --git a/block/io.c b/block/io.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/026
+--- a/block/io.c
-+++ b/tests/qemu-iotests/026
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+@@ -XXX,XX +XXX,XX @@ err:
- # Currently only qcow2 supports rebasing
+  */
- _supported_fmt qcow2
+ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
- _supported_proto file
+     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
--_default_cache_mode "writethrough"
+-    int64_t align, QEMUIOVector *qiov, int flags)
--_supported_cache_modes "writethrough" "none"
++    int64_t align, QEMUIOVector *qiov, size_t qiov_offset, int flags)
-+_default_cache_mode writethrough
+ {
-+_supported_cache_modes writethrough none
+     BlockDriverState *bs = child->bs;
- # The refcount table tests expect a certain minimum width for refcount entries
+     int64_t total_bytes, max_bytes;
- # (so that the refcount table actually needs to grow); that minimum is 16 bits,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
- # being the default refcount entry width.
+     assert(is_power_of_2(align));
-diff --git a/tests/qemu-iotests/039 b/tests/qemu-iotests/039
+     assert((offset & (align - 1)) == 0);
-index XXXXXXX..XXXXXXX 100755
+     assert((bytes & (align - 1)) == 0);
---- a/tests/qemu-iotests/039
+-    assert(!qiov || bytes == qiov->size);
-+++ b/tests/qemu-iotests/039
+     assert((bs->open_flags & BDRV_O_NO_IO) == 0);
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+     max_transfer = QEMU_ALIGN_DOWN(MIN_NON_ZERO(bs->bl.max_transfer, INT_MAX),
- _supported_fmt qcow2
+                                    align);
- _supported_proto file
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
- _supported_os Linux
+         }
--_default_cache_mode "writethrough"
--_supported_cache_modes "writethrough"
+         if (!ret || pnum != bytes) {
-+_default_cache_mode writethrough
+-            ret = bdrv_co_do_copy_on_readv(child, offset, bytes, qiov, 0, flags);
-+_supported_cache_modes writethrough
++            ret = bdrv_co_do_copy_on_readv(child, offset, bytes,
++                                           qiov, qiov_offset, flags);
- size=128M
+             goto out;
+         } else if (flags & BDRV_REQ_PREFETCH) {
-diff --git a/tests/qemu-iotests/052 b/tests/qemu-iotests/052
+             goto out;
-index XXXXXXX..XXXXXXX 100755
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
---- a/tests/qemu-iotests/052
-+++ b/tests/qemu-iotests/052
+     max_bytes = ROUND_UP(MAX(0, total_bytes - offset), align);
-@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
+     if (bytes <= max_bytes && bytes <= max_transfer) {
- _supported_proto file
+-        ret = bdrv_driver_preadv(bs, offset, bytes, qiov, 0, 0);
++        ret = bdrv_driver_preadv(bs, offset, bytes, qiov, qiov_offset, 0);
- # Don't do O_DIRECT on tmpfs
+         goto out;
--_supported_cache_modes "writeback" "writethrough" "unsafe"
+     }
-+_supported_cache_modes writeback writethrough unsafe
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
- size=128M
+         int num;
- _make_test_img $size
-diff --git a/tests/qemu-iotests/091 b/tests/qemu-iotests/091
+         if (max_bytes) {
-index XXXXXXX..XXXXXXX 100755
+-            QEMUIOVector local_qiov;
---- a/tests/qemu-iotests/091
+-
-+++ b/tests/qemu-iotests/091
+             num = MIN(bytes_remaining, MIN(max_bytes, max_transfer));
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+             assert(num);
- _supported_fmt qcow2
+-            qemu_iovec_init(&local_qiov, qiov->niov);
- _supported_proto file
+-            qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);
- _supported_os Linux
--_default_cache_mode "none"
+             ret = bdrv_driver_preadv(bs, offset + bytes - bytes_remaining,
--_supported_cache_modes "writethrough" "none" "writeback"
+-                                     num, &local_qiov, 0, 0);
-+_default_cache_mode none
++                                     num, qiov, bytes - bytes_remaining, 0);
-+_supported_cache_modes writethrough none writeback
+             max_bytes -= num;
+-            qemu_iovec_destroy(&local_qiov);
- size=1G
+         } else {
              num = bytes_remaining;
              ret = qemu_iovec_memset(qiov, bytes - bytes_remaining, 0,
@@ -XXX,XX +XXX,XX @@ static int bdrv_padding_rmw_read(BdrvChild *child,
              bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
          }
          ret = bdrv_aligned_preadv(child, req, req->overlap_offset, bytes,
 -                                  align, &local_qiov, 0);
 +                                  align, &local_qiov, 0, 0);
          if (ret < 0) {
              return ret;
          }
@@ -XXX,XX +XXX,XX @@ static int bdrv_padding_rmw_read(BdrvChild *child,
          ret = bdrv_aligned_preadv(
                  child, req,
                  req->overlap_offset + req->overlap_bytes - align,
 -                align, align, &local_qiov, 0);
 +                align, align, &local_qiov, 0, 0);
          if (ret < 0) {
              return ret;
          }
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_preadv(BdrvChild *child,
      tracked_request_begin(&req, bs, offset, bytes, BDRV_TRACKED_READ);
      ret = bdrv_aligned_preadv(child, &req, offset, bytes,
                                bs->bl.request_alignment,
 -                              qiov, flags);
 +                              qiov, 0, flags);
      tracked_request_end(&req);
      bdrv_dec_in_flight(bs);
 --
 .21.0

-[Qemu-devel] [PULL 12/15] file-posix: fix request_alignment typo
+[Qemu-devel] [PULL 08/12] block/io: bdrv_aligned_pwritev: use and support qiov_offset
-From: Stefan Hajnoczi <stefanha@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Fixes: a6b257a08e3d72219f03e461a52152672fec0612
+Use and support new API in bdrv_aligned_pwritev.
-       ("file-posix: Handle undetectable alignment")
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-id: 20190604161514.262241-9-vsementsov@virtuozzo.com
 Message-Id: <20190604161514.262241-9-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-id: 20190827101328.4062-1-stefanha@redhat.com
-Reviewed-by: Thomas Huth <thuth@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block/file-posix.c | 2 +-
+ block/io.c | 27 +++++++++++++--------------
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 13 insertions(+), 14 deletions(-)
-diff --git a/block/file-posix.c b/block/file-posix.c
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/file-posix.c
+--- a/block/io.c
-+++ b/block/file-posix.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
+@@ -XXX,XX +XXX,XX @@ bdrv_co_write_req_finish(BdrvChild *child, int64_t offset, uint64_t bytes,
-         for (i = 0; i < ARRAY_SIZE(alignments); i++) {
+  */
-             align = alignments[i];
+ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
-             if (raw_is_io_aligned(fd, buf + align, max_align)) {
+     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
--                /* Fallback to request_aligment. */
+-    int64_t align, QEMUIOVector *qiov, int flags)
-+                /* Fallback to request_alignment. */
++    int64_t align, QEMUIOVector *qiov, size_t qiov_offset, int flags)
-                 s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
+ {
      BlockDriverState *bs = child->bs;
      BlockDriver *drv = bs->drv;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
      assert(is_power_of_2(align));
      assert((offset & (align - 1)) == 0);
      assert((bytes & (align - 1)) == 0);
 -    assert(!qiov || bytes == qiov->size);
 +    assert(!qiov || qiov_offset + bytes <= qiov->size);
      max_transfer = QEMU_ALIGN_DOWN(MIN_NON_ZERO(bs->bl.max_transfer, INT_MAX),
                                     align);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
      if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
          !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_pwrite_zeroes &&
 -        qemu_iovec_is_zero(qiov, 0, qiov->size)) {
 +        qemu_iovec_is_zero(qiov, qiov_offset, bytes)) {
          flags |= BDRV_REQ_ZERO_WRITE;
          if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
              flags |= BDRV_REQ_MAY_UNMAP;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
          bdrv_debug_event(bs, BLKDBG_PWRITEV_ZERO);
          ret = bdrv_co_do_pwrite_zeroes(bs, offset, bytes, flags);
      } else if (flags & BDRV_REQ_WRITE_COMPRESSED) {
 -        ret = bdrv_driver_pwritev_compressed(bs, offset, bytes, qiov, 0);
 +        ret = bdrv_driver_pwritev_compressed(bs, offset, bytes,
 +                                             qiov, qiov_offset);
      } else if (bytes <= max_transfer) {
          bdrv_debug_event(bs, BLKDBG_PWRITEV);
 -        ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, 0, flags);
 +        ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, qiov_offset, flags);
      } else {
          bdrv_debug_event(bs, BLKDBG_PWRITEV);
          while (bytes_remaining) {
              int num = MIN(bytes_remaining, max_transfer);
 -            QEMUIOVector local_qiov;
              int local_flags = flags;
              assert(num);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
                   * need to flush on the last iteration */
                  local_flags &= ~BDRV_REQ_FUA;
              }
 -            qemu_iovec_init(&local_qiov, qiov->niov);
 -            qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);
              ret = bdrv_driver_pwritev(bs, offset + bytes - bytes_remaining,
 -                                      num, &local_qiov, 0, local_flags);
 -            qemu_iovec_destroy(&local_qiov);
 +                                      num, qiov, bytes - bytes_remaining,
 +                                      local_flags);
              if (ret < 0) {
                  break;
              }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
+             qemu_iovec_init_buf(&local_qiov, pad.buf, write_bytes);
+             ret = bdrv_aligned_pwritev(child, req, aligned_offset, write_bytes,
+-                                       align, &local_qiov,
++                                       align, &local_qiov, 0,
+                                        flags & ~BDRV_REQ_ZERO_WRITE);
+             if (ret < 0 || pad.merge_reads) {
+                 /* Error or all work is done */
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
+         /* Write the aligned part in the middle. */
+         uint64_t aligned_bytes = bytes & ~(align - 1);
+         ret = bdrv_aligned_pwritev(child, req, offset, aligned_bytes, align,
+-                                   NULL, flags);
++                                   NULL, 0, flags);
+         if (ret < 0) {
+             goto out;
+         }
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
+         qemu_iovec_init_buf(&local_qiov, pad.tail_buf, align);
+         ret = bdrv_aligned_pwritev(child, req, offset, align, align,
+-                                   &local_qiov, flags & ~BDRV_REQ_ZERO_WRITE);
++                                   &local_qiov, 0,
++                                   flags & ~BDRV_REQ_ZERO_WRITE);
+     }
+ out:
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
+     }
+     ret = bdrv_aligned_pwritev(child, &req, offset, bytes, align,
+-                               qiov, flags);
++                               qiov, 0, flags);
+     bdrv_padding_destroy(&pad);
 --
 .21.0

-[Qemu-devel] [PULL 04/15] iotests: Test allocate_first_block() with O_DIRECT
+[Qemu-devel] [PULL 09/12] block/io: introduce bdrv_co_p{read, write}v_part
-From: Nir Soffer <nirsof@gmail.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Using block_resize we can test allocate_first_block() with file
+Introduce extended variants of bdrv_co_preadv and bdrv_co_pwritev
-descriptor opened with O_DIRECT, ensuring that it works for any size
+with qiov_offset parameter.
 larger than 4096 bytes.
-Testing smaller sizes is tricky as the result depends on the filesystem
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-used for testing. For example on NFS any size will work since O_DIRECT
+Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
-does not require any alignment.
+Message-id: 20190604161514.262241-10-vsementsov@virtuozzo.com
 Message-Id: <20190604161514.262241-10-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  include/block/block_int.h |  6 ++++++
  block/io.c                | 29 +++++++++++++++++++++++------
 files changed, 29 insertions(+), 6 deletions(-)
-Signed-off-by: Nir Soffer <nsoffer@redhat.com>
+diff --git a/include/block/block_int.h b/include/block/block_int.h
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+index XXXXXXX..XXXXXXX 100644
-Message-id: 20190827010528.8818-3-nsoffer@redhat.com
+--- a/include/block/block_int.h
-Signed-off-by: Max Reitz <mreitz@redhat.com>
++++ b/include/block/block_int.h
----
+@@ -XXX,XX +XXX,XX @@ extern BlockDriver bdrv_qcow2;
- tests/qemu-iotests/175     | 28 ++++++++++++++++++++++++++++
+ int coroutine_fn bdrv_co_preadv(BdrvChild *child,
- tests/qemu-iotests/175.out |  8 ++++++++
+     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
-files changed, 36 insertions(+)
+     BdrvRequestFlags flags);
++int coroutine_fn bdrv_co_preadv_part(BdrvChild *child,
-diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175
++    int64_t offset, unsigned int bytes,
-index XXXXXXX..XXXXXXX 100755
++    QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags);
---- a/tests/qemu-iotests/175
+ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
-+++ b/tests/qemu-iotests/175
+     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
-@@ -XXX,XX +XXX,XX @@ _filter_blocks()
+     BdrvRequestFlags flags);
-         -e "s/blocks=$((extra_blocks + img_size / 512))\\(\$\\|[^0-9]\\)/max allocation/"
++int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
 +    int64_t offset, unsigned int bytes,
 +    QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags);
  static inline int coroutine_fn bdrv_co_pread(BdrvChild *child,
      int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags)
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_padding_destroy(BdrvRequestPadding *pad)
   *
   * Function always succeeds.
   */
 -static bool bdrv_pad_request(BlockDriverState *bs, QEMUIOVector **qiov,
 +static bool bdrv_pad_request(BlockDriverState *bs,
 +                             QEMUIOVector **qiov, size_t *qiov_offset,
                               int64_t *offset, unsigned int *bytes,
                               BdrvRequestPadding *pad)
  {
@@ -XXX,XX +XXX,XX @@ static bool bdrv_pad_request(BlockDriverState *bs, QEMUIOVector **qiov,
      }
      qemu_iovec_init_extended(&pad->local_qiov, pad->buf, pad->head,
 -                             *qiov, 0, *bytes,
 +                             *qiov, *qiov_offset, *bytes,
                               pad->buf + pad->buf_len - pad->tail, pad->tail);
      *bytes += pad->head + pad->tail;
      *offset -= pad->head;
      *qiov = &pad->local_qiov;
 +    *qiov_offset = 0;
      return true;
  }
+@@ -XXX,XX +XXX,XX @@ static bool bdrv_pad_request(BlockDriverState *bs, QEMUIOVector **qiov,
-+# Resize image using block_resize.
+ int coroutine_fn bdrv_co_preadv(BdrvChild *child,
-+# Parameter 1: image path
+     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
-+# Parameter 2: new size
+     BdrvRequestFlags flags)
 +_block_resize()
 +{
-+    local path=$1
++    return bdrv_co_preadv_part(child, offset, bytes, qiov, 0, flags);
 +    local size=$2
 +
 +    $QEMU -qmp stdio -nographic -nodefaults \
 +        -blockdev file,node-name=file,filename=$path,cache.direct=on \
 +        <<EOF
 +{'execute': 'qmp_capabilities'}
 +{'execute': 'block_resize', 'arguments': {'node-name': 'file', 'size': $size}}
 +{'execute': 'quit'}
 +EOF
 +}
 +
- # get standard environment, filters and checks
++int coroutine_fn bdrv_co_preadv_part(BdrvChild *child,
- . ./common.rc
++    int64_t offset, unsigned int bytes,
- . ./common.filter
++    QEMUIOVector *qiov, size_t qiov_offset,
-@@ -XXX,XX +XXX,XX @@ _supported_fmt raw
++    BdrvRequestFlags flags)
- _supported_proto file
+ {
- _supported_os Linux
+     BlockDriverState *bs = child->bs;
+     BdrvTrackedRequest req;
-+_default_cache_mode none
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_preadv(BdrvChild *child,
-+_supported_cache_modes none directsync
+         flags |= BDRV_REQ_COPY_ON_READ;
      }
 -    bdrv_pad_request(bs, &qiov, &offset, &bytes, &pad);
 +    bdrv_pad_request(bs, &qiov, &qiov_offset, &offset, &bytes, &pad);
      tracked_request_begin(&req, bs, offset, bytes, BDRV_TRACKED_READ);
      ret = bdrv_aligned_preadv(child, &req, offset, bytes,
                                bs->bl.request_alignment,
 -                              qiov, 0, flags);
 +                              qiov, qiov_offset, flags);
      tracked_request_end(&req);
      bdrv_dec_in_flight(bs);
@@ -XXX,XX +XXX,XX @@ out:
  int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
      int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
      BdrvRequestFlags flags)
 +{
 +    return bdrv_co_pwritev_part(child, offset, bytes, qiov, 0, flags);
 +}
 +
- size=$((1 * 1024 * 1024))
++int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
++    int64_t offset, unsigned int bytes, QEMUIOVector *qiov, size_t qiov_offset,
- touch "$TEST_DIR/empty"
++    BdrvRequestFlags flags)
-@@ -XXX,XX +XXX,XX @@ for mode in off full falloc; do
+ {
-     stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
+     BlockDriverState *bs = child->bs;
- done
+     BdrvTrackedRequest req;
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
-+for new_size in 4096 1048576; do
+         goto out;
-+    echo
+     }
-+    echo "== resize empty image with block_resize =="
-+    _make_test_img 0 | _filter_imgfmt
+-    if (bdrv_pad_request(bs, &qiov, &offset, &bytes, &pad)) {
-+    _block_resize $TEST_IMG $new_size >/dev/null
++    if (bdrv_pad_request(bs, &qiov, &qiov_offset, &offset, &bytes, &pad)) {
-+    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $new_size
+         mark_request_serialising(&req, align);
-+done
+         wait_serialising_requests(&req);
-+
+         bdrv_padding_rmw_read(child, &req, &pad, false);
- # success, all done
+     }
- echo "*** done"
- rm -f $seq.full
+     ret = bdrv_aligned_pwritev(child, &req, offset, bytes, align,
-diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out
+-                               qiov, 0, flags);
-index XXXXXXX..XXXXXXX 100644
++                               qiov, qiov_offset, flags);
---- a/tests/qemu-iotests/175.out
-+++ b/tests/qemu-iotests/175.out
+     bdrv_padding_destroy(&pad);
-@@ -XXX,XX +XXX,XX @@ size=1048576, max allocation
  == creating image with preallocation falloc ==
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc
  size=1048576, max allocation
 +
 +== resize empty image with block_resize ==
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=0
 +size=4096, min allocation
 +
 +== resize empty image with block_resize ==
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=0
 +size=1048576, min allocation
   *** done
 --
 .21.0

-[Qemu-devel] [PULL 10/15] iotests: Disable 110 for vmdk.twoGbMaxExtentSparse
+[Qemu-devel] [PULL 10/12] block/qcow2: refactor qcow2_co_preadv to use buffer-based io
-The error message for the test case where we have a quorum node for
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 which no directory name can be generated is different: For
 twoGbMaxExtentSparse, it complains that it cannot open the extent file.
 For other (sub)formats, it just notes that it cannot determine the
 backing file path.  Both are fine, but just disable twoGbMaxExtentSparse
 for simplicity's sake.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Use buffer based io in encrypted case.
-Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: 20190815153638.4600-7-mreitz@redhat.com
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
+Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Message-id: 20190604161514.262241-11-vsementsov@virtuozzo.com
 Message-Id: <20190604161514.262241-11-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/110 | 3 ++-
+ block/qcow2.c | 28 ++++++++++++++++------------
-file changed, 2 insertions(+), 1 deletion(-)
+file changed, 16 insertions(+), 12 deletions(-)
-diff --git a/tests/qemu-iotests/110 b/tests/qemu-iotests/110
+diff --git a/block/qcow2.c b/block/qcow2.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/110
+--- a/block/qcow2.c
-+++ b/tests/qemu-iotests/110
++++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
- # Any format supporting backing files
+                 }
- _supported_fmt qed qcow qcow2 vmdk
- _supported_proto file
+                 assert(cur_bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
--_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
+-                qemu_iovec_reset(&hd_qiov);
-+_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
+-                qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes);
-+                     "subformat=twoGbMaxExtentSparse"
+-            }
- TEST_IMG_REL=$(basename "$TEST_IMG")
+-            BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
 -            ret = bdrv_co_preadv(s->data_file,
 -                                 cluster_offset + offset_in_cluster,
 -                                 cur_bytes, &hd_qiov, 0);
 -            if (ret < 0) {
 -                goto fail;
 -            }
 -            if (bs->encrypted) {
 -                assert(s->crypto);
 +                BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
 +                ret = bdrv_co_pread(s->data_file,
 +                                    cluster_offset + offset_in_cluster,
 +                                    cur_bytes, cluster_data, 0);
 +                if (ret < 0) {
 +                    goto fail;
 +                }
 +
                  assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
                  assert((cur_bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
                  if (qcow2_co_decrypt(bs, cluster_offset, offset,
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
                      goto fail;
                  }
                  qemu_iovec_from_buf(qiov, bytes_done, cluster_data, cur_bytes);
 +            } else {
 +                BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
 +                ret = bdrv_co_preadv(s->data_file,
 +                                     cluster_offset + offset_in_cluster,
 +                                     cur_bytes, &hd_qiov, 0);
 +                if (ret < 0) {
 +                    goto fail;
 +                }
              }
              break;
 --
 .21.0

-[Qemu-devel] [PULL 03/15] block: posix: Always allocate the first block
+[Qemu-devel] [PULL 11/12] block/qcow2: implement .bdrv_co_preadv_part
-From: Nir Soffer <nirsof@gmail.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-When creating an image with preallocation "off" or "falloc", the first
+Implement and use new interface to get rid of hd_qiov.
 block of the image is typically not allocated. When using Gluster
 storage backed by XFS filesystem, reading this block using direct I/O
 succeeds regardless of request length, fooling alignment detection.
-In this case we fallback to a safe value (4096) instead of the optimal
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-value (512), which may lead to unneeded data copying when aligning
+Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
-requests.  Allocating the first block avoids the fallback.
+Message-id: 20190604161514.262241-12-vsementsov@virtuozzo.com
 Message-Id: <20190604161514.262241-12-vsementsov@virtuozzo.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  block/qcow2-cluster.c |  5 +++--
  block/qcow2.c         | 49 +++++++++++++++++++------------------------
 files changed, 25 insertions(+), 29 deletions(-)
-Since we allocate the first block even with preallocation=off, we no
+diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
 longer create images with zero disk size:
     $ ./qemu-img create -f raw test.raw 1g
     Formatting 'test.raw', fmt=raw size=1073741824
     $ ls -lhs test.raw
 .0K -rw-r--r--. 1 nsoffer nsoffer 1.0G Aug 16 23:48 test.raw
 And converting the image requires additional cluster:
     $ ./qemu-img measure -f raw -O qcow2 test.raw
     required size: 458752
     fully allocated size: 1074135040
 When using format like vmdk with multiple files per image, we allocate
 one block per file:
     $ ./qemu-img create -f vmdk -o subformat=twoGbMaxExtentFlat test.vmdk 4g
     Formatting 'test.vmdk', fmt=vmdk size=4294967296 compat6=off hwversion=undefined subformat=twoGbMaxExtentFlat
     $ ls -lhs test*.vmdk
 .0K -rw-r--r--. 1 nsoffer nsoffer 2.0G Aug 27 03:23 test-f001.vmdk
 .0K -rw-r--r--. 1 nsoffer nsoffer 2.0G Aug 27 03:23 test-f002.vmdk
 .0K -rw-r--r--. 1 nsoffer nsoffer  353 Aug 27 03:23 test.vmdk
 I did quick performance test for copying disks with qemu-img convert to
 new raw target image to Gluster storage with sector size of 512 bytes:
     for i in $(seq 10); do
         rm -f dst.raw
         sleep 10
         time ./qemu-img convert -f raw -O raw -t none -T none src.raw dst.raw
     done
 Here is a table comparing the total time spent:
 Type    Before(s)   After(s)    Diff(%)
 ---------------------------------------
 real      530.028    469.123      -11.4
 user       17.204     10.768      -37.4
 sys        17.881      7.011      -60.7
 We can see very clear improvement in CPU usage.
 Signed-off-by: Nir Soffer <nsoffer@redhat.com>
 Message-id: 20190827010528.8818-2-nsoffer@redhat.com
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block/file-posix.c                            | 51 +++++++++++++++++++
  tests/qemu-iotests/059.out                    |  2 +-
  tests/qemu-iotests/{150.out => 150.out.qcow2} |  0
  tests/qemu-iotests/150.out.raw                | 12 +++++
  tests/qemu-iotests/175                        | 19 ++++---
  tests/qemu-iotests/175.out                    |  8 +--
  tests/qemu-iotests/178.out.qcow2              |  4 +-
  tests/qemu-iotests/221.out                    | 12 +++--
  tests/qemu-iotests/253.out                    | 12 +++--
 files changed, 99 insertions(+), 21 deletions(-)
  rename tests/qemu-iotests/{150.out => 150.out.qcow2} (100%)
  create mode 100644 tests/qemu-iotests/150.out.raw
 diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/file-posix.c
+--- a/block/qcow2-cluster.c
-+++ b/block/file-posix.c
++++ b/block/qcow2-cluster.c
-@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_discard(void *opaque)
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn do_perform_cow_read(BlockDriverState *bs,
       * interface.  This avoids double I/O throttling and request tracking,
       * which can lead to deadlock when block layer copy-on-read is enabled.
       */
 -    ret = bs->drv->bdrv_co_preadv(bs, src_cluster_offset + offset_in_cluster,
 -                                  qiov->size, qiov, 0);
 +    ret = bs->drv->bdrv_co_preadv_part(bs,
 +                                       src_cluster_offset + offset_in_cluster,
 +                                       qiov->size, qiov, 0, 0);
      if (ret < 0) {
          return ret;
      }
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
                             uint64_t file_cluster_offset,
                             uint64_t offset,
                             uint64_t bytes,
 -                           QEMUIOVector *qiov);
 +                           QEMUIOVector *qiov,
 +                           size_t qiov_offset);
  static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
  {
@@ -XXX,XX +XXX,XX @@ out:
      return ret;
  }
-+/*
+-static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
-+ * Help alignment probing by allocating the first block.
+-                                        uint64_t bytes, QEMUIOVector *qiov,
-+ *
+-                                        int flags)
-+ * When reading with direct I/O from unallocated area on Gluster backed by XFS,
++static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs,
-+ * reading succeeds regardless of request length. In this case we fallback to
++                                             uint64_t offset, uint64_t bytes,
-+ * safe alignment which is not optimal. Allocating the first block avoids this
++                                             QEMUIOVector *qiov,
-+ * fallback.
++                                             size_t qiov_offset, int flags)
 + *
 + * fd may be opened with O_DIRECT, but we don't know the buffer alignment or
 + * request alignment, so we use safe values.
 + *
 + * Returns: 0 on success, -errno on failure. Since this is an optimization,
 + * caller may ignore failures.
 + */
 +static int allocate_first_block(int fd, size_t max_size)
 +{
 +    size_t write_size = (max_size < MAX_BLOCKSIZE)
 +        ? BDRV_SECTOR_SIZE
 +        : MAX_BLOCKSIZE;
 +    size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
 +    void *buf;
 +    ssize_t n;
 +    int ret;
 +
 +    buf = qemu_memalign(max_align, write_size);
 +    memset(buf, 0, write_size);
 +
 +    do {
 +        n = pwrite(fd, buf, write_size, 0);
 +    } while (n == -1 && errno == EINTR);
 +
 +    ret = (n == -1) ? -errno : 0;
 +
 +    qemu_vfree(buf);
 +    return ret;
 +}
 +
  static int handle_aiocb_truncate(void *opaque)
  {
-     RawPosixAIOData *aiocb = opaque;
+     BDRVQcow2State *s = bs->opaque;
-@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_truncate(void *opaque)
+     int offset_in_cluster;
-                 /* posix_fallocate() doesn't set errno. */
+     int ret;
-                 error_setg_errno(errp, -result,
+     unsigned int cur_bytes; /* number of bytes in current iteration */
-                                  "Could not preallocate new data");
+     uint64_t cluster_offset = 0;
-+            } else if (current_length == 0) {
+-    uint64_t bytes_done = 0;
-+                /*
+-    QEMUIOVector hd_qiov;
-+                 * posix_fallocate() uses fallocate() if the filesystem
+     uint8_t *cluster_data = NULL;
-+                 * supports it, or fallback to manually writing zeroes. If
-+                 * fallocate() was used, unaligned reads from the fallocated
+-    qemu_iovec_init(&hd_qiov, qiov->niov);
-+                 * area in raw_probe_alignment() will succeed, hence we need to
+-
-+                 * allocate the first block.
+     while (bytes != 0) {
-+                 *
-+                 * Optimize future alignment probing; ignore failures.
+         /* prepare next request */
-+                 */
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
-+                allocate_first_block(fd, offset);
          offset_in_cluster = offset_into_cluster(s, offset);
 -        qemu_iovec_reset(&hd_qiov);
 -        qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
 -
          switch (ret) {
          case QCOW2_CLUSTER_UNALLOCATED:
              if (bs->backing) {
                  BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
 -                ret = bdrv_co_preadv(bs->backing, offset, cur_bytes,
 -                                     &hd_qiov, 0);
 +                ret = bdrv_co_preadv_part(bs->backing, offset, cur_bytes,
 +                                          qiov, qiov_offset, 0);
                  if (ret < 0) {
                      goto fail;
                  }
              } else {
                  /* Note: in this case, no need to wait */
 -                qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes);
 +                qemu_iovec_memset(qiov, qiov_offset, 0, cur_bytes);
              }
-         } else {
+             break;
-             result = 0;
-@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_truncate(void *opaque)
+         case QCOW2_CLUSTER_ZERO_PLAIN:
-         if (ftruncate(fd, offset) != 0) {
+         case QCOW2_CLUSTER_ZERO_ALLOC:
-             result = -errno;
+-            qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes);
-             error_setg_errno(errp, -result, "Could not resize file");
++            qemu_iovec_memset(qiov, qiov_offset, 0, cur_bytes);
-+        } else if (current_length == 0 && offset > current_length) {
+             break;
-+            /* Optimize future alignment probing; ignore failures. */
-+            allocate_first_block(fd, offset);
+         case QCOW2_CLUSTER_COMPRESSED:
-         }
+             ret = qcow2_co_preadv_compressed(bs, cluster_offset,
-         return result;
+                                              offset, cur_bytes,
-     default:
+-                                             &hd_qiov);
-diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
++                                             qiov, qiov_offset);
-index XXXXXXX..XXXXXXX 100644
+             if (ret < 0) {
---- a/tests/qemu-iotests/059.out
+                 goto fail;
-+++ b/tests/qemu-iotests/059.out
+             }
-@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMax
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
- image: TEST_DIR/t.vmdk
+                     ret = -EIO;
- file format: vmdk
+                     goto fail;
- virtual size: 0.977 TiB (1073741824000 bytes)
+                 }
--disk size: 16 KiB
+-                qemu_iovec_from_buf(qiov, bytes_done, cluster_data, cur_bytes);
-+disk size: 1.97 MiB
++                qemu_iovec_from_buf(qiov, qiov_offset, cluster_data, cur_bytes);
- Format specific information:
+             } else {
-     cid: XXXXXXXX
+                 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
-     parent cid: XXXXXXXX
+-                ret = bdrv_co_preadv(s->data_file,
-diff --git a/tests/qemu-iotests/150.out b/tests/qemu-iotests/150.out.qcow2
+-                                     cluster_offset + offset_in_cluster,
-similarity index 100%
+-                                     cur_bytes, &hd_qiov, 0);
-rename from tests/qemu-iotests/150.out
++                ret = bdrv_co_preadv_part(s->data_file,
-rename to tests/qemu-iotests/150.out.qcow2
++                                          cluster_offset + offset_in_cluster,
-diff --git a/tests/qemu-iotests/150.out.raw b/tests/qemu-iotests/150.out.raw
++                                          cur_bytes, qiov, qiov_offset, 0);
-new file mode 100644
+                 if (ret < 0) {
-index XXXXXXX..XXXXXXX
+                     goto fail;
---- /dev/null
+                 }
-+++ b/tests/qemu-iotests/150.out.raw
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
-@@ -XXX,XX +XXX,XX @@
-+QA output created by 150
+         bytes -= cur_bytes;
-+
+         offset += cur_bytes;
-+=== Mapping sparse conversion ===
+-        bytes_done += cur_bytes;
-+
++        qiov_offset += cur_bytes;
-+Offset          Length          File
+     }
-+0               0x1000          TEST_DIR/t.IMGFMT
+     ret = 0;
-+
-+=== Mapping non-sparse conversion ===
+ fail:
-+
+-    qemu_iovec_destroy(&hd_qiov);
-+Offset          Length          File
+     qemu_vfree(cluster_data);
-+0               0x100000        TEST_DIR/t.IMGFMT
-+*** done
+     return ret;
-diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175
+@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
-index XXXXXXX..XXXXXXX 100755
+                            uint64_t file_cluster_offset,
---- a/tests/qemu-iotests/175
+                            uint64_t offset,
-+++ b/tests/qemu-iotests/175
+                            uint64_t bytes,
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+-                           QEMUIOVector *qiov)
- # the file size.  This function hides the resulting difference in the
++                           QEMUIOVector *qiov,
- # stat -c '%b' output.
++                           size_t qiov_offset)
  # Parameter 1: Number of blocks an empty file occupies
 -# Parameter 2: Image size in bytes
 +# Parameter 2: Minimal number of blocks in an image
 +# Parameter 3: Image size in bytes
  _filter_blocks()
  {
-     extra_blocks=$1
+     BDRVQcow2State *s = bs->opaque;
--    img_size=$2
+     int ret = 0, csize, nb_csectors;
-+    min_blocks=$2
+@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
-+    img_size=$3
+         goto fail;
+     }
--    sed -e "s/blocks=$extra_blocks\\(\$\\|[^0-9]\\)/nothing allocated/" \
--        -e "s/blocks=$((extra_blocks + img_size / 512))\\(\$\\|[^0-9]\\)/everything allocated/"
+-    qemu_iovec_from_buf(qiov, 0, out_buf + offset_in_cluster, bytes);
-+    sed -e "s/blocks=$min_blocks\\(\$\\|[^0-9]\\)/min allocation/" \
++    qemu_iovec_from_buf(qiov, qiov_offset, out_buf + offset_in_cluster, bytes);
-+        -e "s/blocks=$((extra_blocks + img_size / 512))\\(\$\\|[^0-9]\\)/max allocation/"
  fail:
      qemu_vfree(out_buf);
@@ -XXX,XX +XXX,XX @@ static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
      BDRVQcow2State *s = bs->opaque;
      BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
 -    return bs->drv->bdrv_co_preadv(bs, qcow2_vm_state_offset(s) + pos,
 -                                   qiov->size, qiov, 0);
 +    return bs->drv->bdrv_co_preadv_part(bs, qcow2_vm_state_offset(s) + pos,
 +                                        qiov->size, qiov, 0, 0);
  }
- # get standard environment, filters and checks
+ /*
-@@ -XXX,XX +XXX,XX @@ size=$((1 * 1024 * 1024))
+@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {
- touch "$TEST_DIR/empty"
+     .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
- extra_blocks=$(stat -c '%b' "$TEST_DIR/empty")
+     .bdrv_co_block_status = qcow2_co_block_status,
-+# We always write the first byte; check how many blocks this filesystem
+-    .bdrv_co_preadv         = qcow2_co_preadv,
-+# allocates to match empty image alloation.
++    .bdrv_co_preadv_part    = qcow2_co_preadv_part,
-+printf "\0" > "$TEST_DIR/empty"
+     .bdrv_co_pwritev        = qcow2_co_pwritev,
-+min_blocks=$(stat -c '%b' "$TEST_DIR/empty")
+     .bdrv_co_flush_to_os    = qcow2_co_flush_to_os,
-+
  echo
  echo "== creating image with default preallocation =="
  _make_test_img $size | _filter_imgfmt
 -stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size
 +stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
  for mode in off full falloc; do
      echo
      echo "== creating image with preallocation $mode =="
      IMGOPTS=preallocation=$mode _make_test_img $size | _filter_imgfmt
 -    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size
 +    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
  done
  # success, all done
 diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/175.out
 +++ b/tests/qemu-iotests/175.out
@@ -XXX,XX +XXX,XX @@ QA output created by 175
  == creating image with default preallocation ==
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576
 -size=1048576, nothing allocated
 +size=1048576, min allocation
  == creating image with preallocation off ==
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=off
 -size=1048576, nothing allocated
 +size=1048576, min allocation
  == creating image with preallocation full ==
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=full
 -size=1048576, everything allocated
 +size=1048576, max allocation
  == creating image with preallocation falloc ==
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc
 -size=1048576, everything allocated
 +size=1048576, max allocation
   *** done
 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 @@ converted image file size in bytes: 196608
  == raw input image with data (human) ==
  Formatting 'TEST_DIR/t.qcow2', fmt=IMGFMT size=1073741824
 -required size: 393216
 +required size: 458752
  fully allocated size: 1074135040
  wrote 512/512 bytes at offset 512
 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
@@ -XXX,XX +XXX,XX @@ converted image file size in bytes: 196608
  Formatting 'TEST_DIR/t.qcow2', fmt=IMGFMT size=1073741824
  {
 -    "required": 393216,
 +    "required": 458752,
      "fully-allocated": 1074135040
  }
  wrote 512/512 bytes at offset 512
 diff --git a/tests/qemu-iotests/221.out b/tests/qemu-iotests/221.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/221.out
 +++ b/tests/qemu-iotests/221.out
@@ -XXX,XX +XXX,XX @@ QA output created by 221
  === Check mapping of unaligned raw image ===
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=65537
 -[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 -[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
  wrote 1/1 bytes at offset 65536
 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 -[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
  { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
  { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 -[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
  { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
  { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
  *** done
 diff --git a/tests/qemu-iotests/253.out b/tests/qemu-iotests/253.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/253.out
 +++ b/tests/qemu-iotests/253.out
@@ -XXX,XX +XXX,XX @@ QA output created by 253
  === Check mapping of unaligned raw image ===
  Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048575
 -[{ "start": 0, "length": 1048576, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 -[{ "start": 0, "length": 1048576, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 1044480, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 1044480, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
  wrote 65535/65535 bytes at offset 983040
 .999 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 -[{ "start": 0, "length": 983040, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 978944, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
  { "start": 983040, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]
 -[{ "start": 0, "length": 983040, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 +[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 +{ "start": 4096, "length": 978944, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
  { "start": 983040, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]
  *** done
 --
 .21.0

-[Qemu-devel] [PULL 05/15] iotests: Fix _filter_img_create()
+Deleted patch
-fe646693acc changed qemu-img create's output so that it no longer prints
-single quotes around parameter values.  The subformat and adapter_type
-filters in _filter_img_create() have never been adapted to that change.
-Fixes: fe646693acc13ac48b98435d14149ab04dc597bc
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: 20190815153638.4600-2-mreitz@redhat.com
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/059.out       | 16 ++++++++--------
- tests/qemu-iotests/common.filter |  4 ++--
-files changed, 10 insertions(+), 10 deletions(-)
-diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/059.out
-+++ b/tests/qemu-iotests/059.out
-@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
- qemu-io: can't open device TEST_DIR/t.vmdk: L1 size too big
- === Testing monolithicFlat creation and opening ===
--Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648
- image: TEST_DIR/t.IMGFMT
- file format: IMGFMT
- virtual size: 2 GiB (2147483648 bytes)
- === Testing monolithicFlat with zeroed_grain ===
- qemu-img: TEST_DIR/t.IMGFMT: Flat image can't enable zeroed grain
--Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648
- === Testing big twoGbMaxExtentFlat ===
--Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMaxExtentFlat
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000
- image: TEST_DIR/t.vmdk
- file format: vmdk
- virtual size: 0.977 TiB (1073741824000 bytes)
-@@ -XXX,XX +XXX,XX @@ Format specific information:
- qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Invalid extent line: RW 12582912 VMFS "dummy.IMGFMT" 1
- === Testing truncated sparse ===
--Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=107374182400 subformat=monolithicSparse
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=107374182400
- qemu-img: Could not open 'TEST_DIR/t.IMGFMT': File truncated, expecting at least 13172736 bytes
- === Converting to streamOptimized from image with small cluster size===
-@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
-bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- === Testing monolithicFlat with internally generated JSON file name ===
--Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 subformat=monolithicFlat
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
- qemu-io: can't open: Cannot use relative extent paths with VMDK descriptor file 'json:{"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "read_aio"}'
- === Testing version 3 ===
-@@ -XXX,XX +XXX,XX @@ read 512/512 bytes at offset 64931328
-bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- === Testing 4TB monolithicFlat creation and IO ===
--Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104 subformat=monolithicFlat
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104
- image: TEST_DIR/t.IMGFMT
- file format: IMGFMT
- virtual size: 4 TiB (4398046511104 bytes)
-@@ -XXX,XX +XXX,XX @@ read 1024/1024 bytes at offset 966367641600
-KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- === Testing qemu-img map on extents ===
--Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 subformat=monolithicSparse
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544
- wrote 1024/1024 bytes at offset 65024
-KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- wrote 1024/1024 bytes at offset 2147483136
-@@ -XXX,XX +XXX,XX @@ Offset          Length          Mapped to       File
-0x20000         0x3f0000        TEST_DIR/t.vmdk
-x7fff0000      0x20000         0x410000        TEST_DIR/t.vmdk
-x140000000     0x10000         0x430000        TEST_DIR/t.vmdk
--Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 subformat=twoGbMaxExtentSparse
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544
- wrote 1024/1024 bytes at offset 65024
-KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- wrote 1024/1024 bytes at offset 2147483136
-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_create()
-         -e "s# compat6=\\(on\\|off\\)##g" \
-         -e "s# static=\\(on\\|off\\)##g" \
-         -e "s# zeroed_grain=\\(on\\|off\\)##g" \
--        -e "s# subformat='[^']*'##g" \
--        -e "s# adapter_type='[^']*'##g" \
-+        -e "s# subformat=[^ ]*##g" \
-+        -e "s# adapter_type=[^ ]*##g" \
-         -e "s# hwversion=[^ ]*##g" \
-         -e "s# lazy_refcounts=\\(on\\|off\\)##g" \
-         -e "s# block_size=[0-9]\\+##g" \
---
-.21.0

-[Qemu-devel] [PULL 07/15] iotests: Keep testing broken relative extent paths
+Deleted patch
-We had a test for a case where relative extent paths did not work, but
-unfortunately we just fixed the underlying problem, so it works now.
-This patch adds a new test case that still fails.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Message-id: 20190815153638.4600-4-mreitz@redhat.com
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/059     | 27 +++++++++++++++++++++++++++
- tests/qemu-iotests/059.out |  4 ++++
-files changed, 31 insertions(+)
-diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/059
-+++ b/tests/qemu-iotests/059
-@@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -f qcow2 -O vmdk -o subformat=streamOptimized "$TEST_IMG.qcow2
- echo
- echo "=== Testing monolithicFlat with internally generated JSON file name ==="
-+
-+echo '--- blkdebug ---'
- # Should work, because bdrv_dirname() works fine with blkdebug
- IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
- $QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" \
-@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TE
-     | _filter_testdir | _filter_imgfmt | _filter_img_info
- _cleanup_test_img
-+echo '--- quorum ---'
-+# Should not work, because bdrv_dirname() does not work with quorum
-+IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
-+cp "$TEST_IMG" "$TEST_IMG.orig"
-+
-+filename="json:{
-+    \"driver\": \"$IMGFMT\",
-+    \"file\": {
-+        \"driver\": \"quorum\",
-+        \"children\": [ {
-+            \"driver\": \"file\",
-+            \"filename\": \"$TEST_IMG\"
-+        }, {
-+            \"driver\": \"file\",
-+            \"filename\": \"$TEST_IMG.orig\"
-+        } ],
-+        \"vote-threshold\": 1
-+    } }"
-+
-+filename=$(echo "$filename" | tr '\n' ' ' | sed -e 's/\s\+/ /g')
-+$QEMU_IMG info "$filename" 2>&1 \
-+    | sed -e "s/'json:[^']*'/\$QUORUM_FILE/g" \
-+    | _filter_testdir | _filter_imgfmt | _filter_img_info
-+
-+
- echo
- echo "=== Testing version 3 ==="
- _use_sample_img iotest-version3.vmdk.bz2
-diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/059.out
-+++ b/tests/qemu-iotests/059.out
-@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
-bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
- === Testing monolithicFlat with internally generated JSON file name ===
-+--- blkdebug ---
- Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
- format name: IMGFMT
- cluster size: 0 bytes
- vm state offset: 0 bytes
-+--- quorum ---
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
-+qemu-img: Could not open $QUORUM_FILE: Cannot use relative paths with VMDK descriptor file $QUORUM_FILE: Cannot generate a base directory for quorum nodes
- === Testing version 3 ===
- image: TEST_DIR/iotest-version3.IMGFMT
---
-.21.0

-[Qemu-devel] [PULL 09/15] iotests: Disable broken streamOptimized tests
+Deleted patch
-streamOptimized does not support writes that do not span exactly one
-cluster.  Furthermore, it cannot rewrite already allocated clusters.
-As such, many iotests do not work with it.  Disable them.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20190815153638.4600-6-mreitz@redhat.com
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/002 | 1 +
- tests/qemu-iotests/003 | 1 +
- tests/qemu-iotests/005 | 3 ++-
- tests/qemu-iotests/009 | 1 +
- tests/qemu-iotests/010 | 1 +
- tests/qemu-iotests/011 | 1 +
- tests/qemu-iotests/017 | 3 ++-
- tests/qemu-iotests/018 | 3 ++-
- tests/qemu-iotests/019 | 3 ++-
- tests/qemu-iotests/020 | 3 ++-
- tests/qemu-iotests/027 | 1 +
- tests/qemu-iotests/032 | 1 +
- tests/qemu-iotests/033 | 1 +
- tests/qemu-iotests/034 | 3 ++-
- tests/qemu-iotests/037 | 3 ++-
- tests/qemu-iotests/063 | 3 ++-
- tests/qemu-iotests/072 | 1 +
- tests/qemu-iotests/105 | 3 ++-
- tests/qemu-iotests/197 | 1 +
- tests/qemu-iotests/215 | 1 +
- tests/qemu-iotests/251 | 1 +
-files changed, 30 insertions(+), 9 deletions(-)
-diff --git a/tests/qemu-iotests/002 b/tests/qemu-iotests/002
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/002
-+++ b/tests/qemu-iotests/002
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt generic
- _supported_proto generic
-+_unsupported_imgopts "subformat=streamOptimized"
- size=128M
-diff --git a/tests/qemu-iotests/003 b/tests/qemu-iotests/003
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/003
-+++ b/tests/qemu-iotests/003
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt generic
- _supported_proto generic
-+_unsupported_imgopts "subformat=streamOptimized"
- size=128M
- offset=67M
-diff --git a/tests/qemu-iotests/005 b/tests/qemu-iotests/005
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/005
-+++ b/tests/qemu-iotests/005
-@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
- _supported_proto generic
- _supported_os Linux
- _unsupported_imgopts "subformat=twoGbMaxExtentFlat" \
--                     "subformat=twoGbMaxExtentSparse"
-+                     "subformat=twoGbMaxExtentSparse" \
-+                     "subformat=streamOptimized"
- # vpc is limited to 127GB, so we can't test it here
- if [ "$IMGFMT" = "vpc" ]; then
-diff --git a/tests/qemu-iotests/009 b/tests/qemu-iotests/009
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/009
-+++ b/tests/qemu-iotests/009
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt generic
- _supported_proto generic
-+_unsupported_imgopts "subformat=streamOptimized"
- size=6G
-diff --git a/tests/qemu-iotests/010 b/tests/qemu-iotests/010
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/010
-+++ b/tests/qemu-iotests/010
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt generic
- _supported_proto generic
-+_unsupported_imgopts "subformat=streamOptimized"
- size=6G
-diff --git a/tests/qemu-iotests/011 b/tests/qemu-iotests/011
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/011
-+++ b/tests/qemu-iotests/011
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt generic
- _supported_proto generic
-+_unsupported_imgopts "subformat=streamOptimized"
- size=6G
-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
- _supported_fmt qcow qcow2 vmdk qed
- _supported_proto generic
- _unsupported_proto vxhs
--_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
-+_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
-+                     "subformat=streamOptimized"
- TEST_OFFSETS="0 4294967296"
-diff --git a/tests/qemu-iotests/018 b/tests/qemu-iotests/018
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/018
-+++ b/tests/qemu-iotests/018
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow qcow2 vmdk qed
- _supported_proto file
- _supported_os Linux
--_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
-+_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
-+                     "streamOptimized"
- TEST_OFFSETS="0 4294967296"
-diff --git a/tests/qemu-iotests/019 b/tests/qemu-iotests/019
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/019
-+++ b/tests/qemu-iotests/019
-@@ -XXX,XX +XXX,XX @@ _supported_proto file
- _supported_os Linux
- _unsupported_imgopts "subformat=monolithicFlat" \
-                      "subformat=twoGbMaxExtentFlat" \
--                     "subformat=twoGbMaxExtentSparse"
-+                     "subformat=twoGbMaxExtentSparse" \
-+                     "subformat=streamOptimized"
- TEST_OFFSETS="0 4294967296"
- CLUSTER_SIZE=65536
-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 @@ _supported_fmt qcow qcow2 vmdk qed
- _supported_proto file
- _unsupported_imgopts "subformat=monolithicFlat" \
-                      "subformat=twoGbMaxExtentFlat" \
--                     "subformat=twoGbMaxExtentSparse"
-+                     "subformat=twoGbMaxExtentSparse" \
-+                     "subformat=streamOptimized"
- TEST_OFFSETS="0 4294967296"
-diff --git a/tests/qemu-iotests/027 b/tests/qemu-iotests/027
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/027
-+++ b/tests/qemu-iotests/027
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt vmdk qcow qcow2 qed
- _supported_proto generic
-+_unsupported_imgopts "subformat=streamOptimized"
- size=128M
-diff --git a/tests/qemu-iotests/032 b/tests/qemu-iotests/032
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/032
-+++ b/tests/qemu-iotests/032
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- # This works for any image format (though unlikely to segfault for raw)
- _supported_fmt generic
- _supported_proto generic
-+_unsupported_imgopts "subformat=streamOptimized"
- echo
- echo === Prepare image ===
-diff --git a/tests/qemu-iotests/033 b/tests/qemu-iotests/033
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/033
-+++ b/tests/qemu-iotests/033
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt generic
- _supported_proto generic
-+_unsupported_imgopts "subformat=streamOptimized"
- size=128M
-diff --git a/tests/qemu-iotests/034 b/tests/qemu-iotests/034
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/034
-+++ b/tests/qemu-iotests/034
-@@ -XXX,XX +XXX,XX @@ _supported_proto file
- _supported_os Linux
- _unsupported_imgopts "subformat=monolithicFlat" \
-                      "subformat=twoGbMaxExtentFlat" \
--                     "subformat=twoGbMaxExtentSparse"
-+                     "subformat=twoGbMaxExtentSparse" \
-+                     "subformat=streamOptimized"
- CLUSTER_SIZE=4k
- size=128M
-diff --git a/tests/qemu-iotests/037 b/tests/qemu-iotests/037
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/037
-+++ b/tests/qemu-iotests/037
-@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed
- _supported_proto file
- _unsupported_imgopts "subformat=monolithicFlat" \
-                      "subformat=twoGbMaxExtentFlat" \
--                     "subformat=twoGbMaxExtentSparse"
-+                     "subformat=twoGbMaxExtentSparse" \
-+                     "subformat=streamOptimized"
- CLUSTER_SIZE=4k
- size=128M
-diff --git a/tests/qemu-iotests/063 b/tests/qemu-iotests/063
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/063
-+++ b/tests/qemu-iotests/063
-@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed raw
- _supported_proto file
- _unsupported_imgopts "subformat=monolithicFlat" \
-                      "subformat=twoGbMaxExtentFlat" \
--                     "subformat=twoGbMaxExtentSparse"
-+                     "subformat=twoGbMaxExtentSparse" \
-+                     "subformat=streamOptimized"
- _make_test_img 4M
-diff --git a/tests/qemu-iotests/072 b/tests/qemu-iotests/072
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/072
-+++ b/tests/qemu-iotests/072
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt vpc vmdk vhdx vdi qed qcow2 qcow
- _supported_proto file
-+_unsupported_imgopts "subformat=streamOptimized"
- IMG_SIZE=64M
-diff --git a/tests/qemu-iotests/105 b/tests/qemu-iotests/105
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/105
-+++ b/tests/qemu-iotests/105
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow2 vmdk vhdx qed
- _supported_proto generic
- _unsupported_imgopts "subformat=twoGbMaxExtentFlat" \
--                     "subformat=twoGbMaxExtentSparse"
-+                     "subformat=twoGbMaxExtentSparse" \
-+                     "subformat=streamOptimized"
- echo
- echo "creating large image"
-diff --git a/tests/qemu-iotests/197 b/tests/qemu-iotests/197
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/197
-+++ b/tests/qemu-iotests/197
-@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
- _supported_proto generic
- # LUKS support may be possible, but it complicates things.
- _unsupported_fmt luks
-+_unsupported_imgopts "subformat=streamOptimized"
- echo
- echo '=== Copy-on-read ==='
-diff --git a/tests/qemu-iotests/215 b/tests/qemu-iotests/215
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/215
-+++ b/tests/qemu-iotests/215
-@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
- _supported_proto generic
- # LUKS support may be possible, but it complicates things.
- _unsupported_fmt luks
-+_unsupported_imgopts "subformat=streamOptimized"
- echo
- echo '=== Copy-on-read ==='
-diff --git a/tests/qemu-iotests/251 b/tests/qemu-iotests/251
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/251
-+++ b/tests/qemu-iotests/251
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt generic
- _supported_proto file
- _supported_os Linux
-+_unsupported_imgopts "subformat=streamOptimized"
- if [ "$IMGOPTSSYNTAX" = "true" ]; then
-     # We use json:{} filenames here, so we cannot work with additional options.
---
-.21.0

-[Qemu-devel] [PULL 13/15] iotests: Check for enabled drivers before testing them
+[Qemu-devel] [PULL 12/12] block/qcow2: implement .bdrv_co_pwritev(_compressed)_part
-From: Thomas Huth <thuth@redhat.com>
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-It is possible to enable only a subset of the block drivers with the
+Implement and use new interface to get rid of hd_qiov.
-"--block-drv-rw-whitelist" option of the "configure" script. All other
-drivers are marked as unusable (or only included as read-only with the
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-"--block-drv-ro-whitelist" option). If an iotest is now using such a
+Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
-disabled block driver, it is failing - which is bad, since at least the
+Message-id: 20190604161514.262241-13-vsementsov@virtuozzo.com
-tests in the "auto" group should be able to deal with this situation.
+Message-Id: <20190604161514.262241-13-vsementsov@virtuozzo.com>
-Thus let's introduce a "_require_drivers" function that can be used by
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 the shell tests to check for the availability of certain drivers first,
 and marks the test as "not run" if one of the drivers is missing.
 This patch mainly targets the test in the "auto" group which should
 never fail in such a case, but also improves some of the other tests
 along the way. Note that we also assume that the "qcow2" and "file"
 drivers are always available - otherwise it does not make sense to
 run "make check-block" at all (which only tests with qcow2 by default).
 Signed-off-by: Thomas Huth <thuth@redhat.com>
 Message-id: 20190823133552.11680-1-thuth@redhat.com
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- tests/qemu-iotests/071       |  1 +
+ block/qcow2.h         |  1 +
- tests/qemu-iotests/081       |  4 +---
+ include/qemu/iov.h    |  1 +
- tests/qemu-iotests/099       |  1 +
+ block/qcow2-cluster.c |  9 ++++---
- tests/qemu-iotests/120       |  1 +
+ block/qcow2.c         | 60 +++++++++++++++++++++----------------------
- tests/qemu-iotests/162       |  4 +---
+ util/iov.c            | 10 ++++++++
- tests/qemu-iotests/184       |  1 +
+files changed, 48 insertions(+), 33 deletions(-)
- tests/qemu-iotests/186       |  1 +
- tests/qemu-iotests/common.rc | 14 ++++++++++++++
+diff --git a/block/qcow2.h b/block/qcow2.h
-files changed, 21 insertions(+), 6 deletions(-)
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2.h
-diff --git a/tests/qemu-iotests/071 b/tests/qemu-iotests/071
++++ b/block/qcow2.h
-index XXXXXXX..XXXXXXX 100755
+@@ -XXX,XX +XXX,XX @@ typedef struct QCowL2Meta
---- a/tests/qemu-iotests/071
+      * from @cow_start and @cow_end into one single write operation.
-+++ b/tests/qemu-iotests/071
+      */
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+     QEMUIOVector *data_qiov;
++    size_t data_qiov_offset;
- _supported_fmt qcow2
- _supported_proto file
+     /** Pointer to next L2Meta of the same write request */
-+_require_drivers blkdebug blkverify
+     struct QCowL2Meta *next;
+diff --git a/include/qemu/iov.h b/include/qemu/iov.h
- do_run_qemu()
+index XXXXXXX..XXXXXXX 100644
 --- a/include/qemu/iov.h
 +++ b/include/qemu/iov.h
@@ -XXX,XX +XXX,XX @@ void qemu_iovec_init_extended(
          void *tail_buf, size_t tail_len);
  void qemu_iovec_init_slice(QEMUIOVector *qiov, QEMUIOVector *source,
                             size_t offset, size_t len);
 +int qemu_iovec_subvec_niov(QEMUIOVector *qiov, size_t offset, size_t len);
  void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
  void qemu_iovec_concat(QEMUIOVector *dst,
                         QEMUIOVector *src, size_t soffset, size_t sbytes);
 diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2-cluster.c
 +++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ static int perform_cow(BlockDriverState *bs, QCowL2Meta *m)
      assert(start->nb_bytes <= UINT_MAX - end->nb_bytes);
      assert(start->nb_bytes + end->nb_bytes <= UINT_MAX - data_bytes);
      assert(start->offset + start->nb_bytes <= end->offset);
 -    assert(!m->data_qiov || m->data_qiov->size == data_bytes);
      if ((start->nb_bytes == 0 && end->nb_bytes == 0) || m->skip_cow) {
          return 0;
@@ -XXX,XX +XXX,XX @@ static int perform_cow(BlockDriverState *bs, QCowL2Meta *m)
      /* The part of the buffer where the end region is located */
      end_buffer = start_buffer + buffer_size - end->nb_bytes;
 -    qemu_iovec_init(&qiov, 2 + (m->data_qiov ? m->data_qiov->niov : 0));
 +    qemu_iovec_init(&qiov, 2 + (m->data_qiov ?
 +                                qemu_iovec_subvec_niov(m->data_qiov,
 +                                                       m->data_qiov_offset,
 +                                                       data_bytes)
 +                                : 0));
      qemu_co_mutex_unlock(&s->lock);
      /* First we read the existing data from both COW regions. We
@@ -XXX,XX +XXX,XX @@ static int perform_cow(BlockDriverState *bs, QCowL2Meta *m)
          if (start->nb_bytes) {
              qemu_iovec_add(&qiov, start_buffer, start->nb_bytes);
          }
 -        qemu_iovec_concat(&qiov, m->data_qiov, 0, data_bytes);
 +        qemu_iovec_concat(&qiov, m->data_qiov, m->data_qiov_offset, data_bytes);
          if (end->nb_bytes) {
              qemu_iovec_add(&qiov, end_buffer, end->nb_bytes);
          }
 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 @@ fail:
  /* Check if it's possible to merge a write request with the writing of
   * the data from the COW regions */
  static bool merge_cow(uint64_t offset, unsigned bytes,
 -                      QEMUIOVector *hd_qiov, QCowL2Meta *l2meta)
 +                      QEMUIOVector *qiov, size_t qiov_offset,
 +                      QCowL2Meta *l2meta)
  {
-diff --git a/tests/qemu-iotests/081 b/tests/qemu-iotests/081
+     QCowL2Meta *m;
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/081
+@@ -XXX,XX +XXX,XX @@ static bool merge_cow(uint64_t offset, unsigned bytes,
-+++ b/tests/qemu-iotests/081
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+         /* Make sure that adding both COW regions to the QEMUIOVector
- _supported_fmt raw
+          * does not exceed IOV_MAX */
- _supported_proto file
+-        if (hd_qiov->niov > IOV_MAX - 2) {
- _supported_os Linux
++        if (qemu_iovec_subvec_niov(qiov, qiov_offset, bytes) > IOV_MAX - 2) {
-+_require_drivers quorum
+             continue;
+         }
- do_run_qemu()
 -        m->data_qiov = hd_qiov;
 +        m->data_qiov = qiov;
 +        m->data_qiov_offset = qiov_offset;
          return true;
      }
@@ -XXX,XX +XXX,XX @@ static int handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)
      return 0;
  }
 -static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
 -                                         uint64_t bytes, QEMUIOVector *qiov,
 -                                         int flags)
 +static coroutine_fn int qcow2_co_pwritev_part(
 +        BlockDriverState *bs, uint64_t offset, uint64_t bytes,
 +        QEMUIOVector *qiov, size_t qiov_offset, int flags)
  {
-@@ -XXX,XX +XXX,XX @@ run_qemu()
+     BDRVQcow2State *s = bs->opaque;
-                           | _filter_qemu_io | _filter_generated_node_ids
+     int offset_in_cluster;
      int ret;
      unsigned int cur_bytes; /* number of sectors in current iteration */
      uint64_t cluster_offset;
 -    QEMUIOVector hd_qiov;
 +    QEMUIOVector encrypted_qiov;
      uint64_t bytes_done = 0;
      uint8_t *cluster_data = NULL;
      QCowL2Meta *l2meta = NULL;
      trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes);
 -    qemu_iovec_init(&hd_qiov, qiov->niov);
 -
      qemu_co_mutex_lock(&s->lock);
      while (bytes != 0) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
          qemu_co_mutex_unlock(&s->lock);
 -        qemu_iovec_reset(&hd_qiov);
 -        qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
 -
          if (bs->encrypted) {
              assert(s->crypto);
              if (!cluster_data) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
                  }
              }
 -            assert(hd_qiov.size <=
 -                   QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
 -            qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size);
 +            assert(cur_bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
 +            qemu_iovec_to_buf(qiov, qiov_offset + bytes_done,
 +                              cluster_data, cur_bytes);
              if (qcow2_co_encrypt(bs, cluster_offset, offset,
                                   cluster_data, cur_bytes) < 0) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
                  goto out_unlocked;
              }
 -            qemu_iovec_reset(&hd_qiov);
 -            qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes);
 +            qemu_iovec_init_buf(&encrypted_qiov, cluster_data, cur_bytes);
          }
          /* Try to efficiently initialize the physical space with zeroes */
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
           * writing of the guest data together with that of the COW regions.
           * If it's not possible (or not necessary) then write the
           * guest data now. */
 -        if (!merge_cow(offset, cur_bytes, &hd_qiov, l2meta)) {
 +        if (!merge_cow(offset, cur_bytes,
 +                       bs->encrypted ? &encrypted_qiov : qiov,
 +                       bs->encrypted ? 0 : qiov_offset + bytes_done, l2meta))
 +        {
              BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
              trace_qcow2_writev_data(qemu_coroutine_self(),
                                      cluster_offset + offset_in_cluster);
 -            ret = bdrv_co_pwritev(s->data_file,
 -                                  cluster_offset + offset_in_cluster,
 -                                  cur_bytes, &hd_qiov, 0);
 +            ret = bdrv_co_pwritev_part(
 +                    s->data_file, cluster_offset + offset_in_cluster, cur_bytes,
 +                    bs->encrypted ? &encrypted_qiov : qiov,
 +                    bs->encrypted ? 0 : qiov_offset + bytes_done, 0);
              if (ret < 0) {
                  goto out_unlocked;
              }
@@ -XXX,XX +XXX,XX @@ out_locked:
      qemu_co_mutex_unlock(&s->lock);
 -    qemu_iovec_destroy(&hd_qiov);
      qemu_vfree(cluster_data);
      trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
@@ -XXX,XX +XXX,XX @@ fail:
  /* XXX: put compressed sectors first, then all the cluster aligned
     tables to avoid losing bytes in alignment */
  static coroutine_fn int
 -qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
 -                            uint64_t bytes, QEMUIOVector *qiov)
 +qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
 +                                 uint64_t offset, uint64_t bytes,
 +                                 QEMUIOVector *qiov, size_t qiov_offset)
  {
      BDRVQcow2State *s = bs->opaque;
      int ret;
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
          /* Zero-pad last write if image size is not cluster aligned */
          memset(buf + bytes, 0, s->cluster_size - bytes);
      }
 -    qemu_iovec_to_buf(qiov, 0, buf, bytes);
 +    qemu_iovec_to_buf(qiov, qiov_offset, buf, bytes);
      out_buf = g_malloc(s->cluster_size);
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
                                  buf, s->cluster_size);
      if (out_len == -ENOMEM) {
          /* could not compress: write normal cluster */
 -        ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0);
 +        ret = qcow2_co_pwritev_part(bs, offset, bytes, qiov, qiov_offset, 0);
          if (ret < 0) {
              goto fail;
          }
@@ -XXX,XX +XXX,XX @@ static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
      BDRVQcow2State *s = bs->opaque;
      BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
 -    return bs->drv->bdrv_co_pwritev(bs, qcow2_vm_state_offset(s) + pos,
 -                                    qiov->size, qiov, 0);
 +    return bs->drv->bdrv_co_pwritev_part(bs, qcow2_vm_state_offset(s) + pos,
 +                                         qiov->size, qiov, 0, 0);
  }
--test_quorum=$($QEMU_IMG --help|grep quorum)
+ static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
--[ "$test_quorum" = "" ] && _supported_fmt quorum
+@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {
--
+     .bdrv_co_block_status = qcow2_co_block_status,
- quorum="driver=raw,file.driver=quorum,file.vote-threshold=2"
- quorum="$quorum,file.children.0.file.filename=$TEST_DIR/1.raw"
+     .bdrv_co_preadv_part    = qcow2_co_preadv_part,
- quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw"
+-    .bdrv_co_pwritev        = qcow2_co_pwritev,
-diff --git a/tests/qemu-iotests/099 b/tests/qemu-iotests/099
++    .bdrv_co_pwritev_part   = qcow2_co_pwritev_part,
-index XXXXXXX..XXXXXXX 100755
+     .bdrv_co_flush_to_os    = qcow2_co_flush_to_os,
---- a/tests/qemu-iotests/099
-+++ b/tests/qemu-iotests/099
+     .bdrv_co_pwrite_zeroes  = qcow2_co_pwrite_zeroes,
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {
- _supported_fmt qcow qcow2 qed vdi vhdx vmdk vpc
+     .bdrv_co_copy_range_from = qcow2_co_copy_range_from,
- _supported_proto file
+     .bdrv_co_copy_range_to  = qcow2_co_copy_range_to,
- _supported_os Linux
+     .bdrv_co_truncate       = qcow2_co_truncate,
-+_require_drivers blkdebug blkverify
+-    .bdrv_co_pwritev_compressed = qcow2_co_pwritev_compressed,
- _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
++    .bdrv_co_pwritev_compressed_part = qcow2_co_pwritev_compressed_part,
-     "subformat=twoGbMaxExtentSparse"
+     .bdrv_make_empty        = qcow2_make_empty,
-diff --git a/tests/qemu-iotests/120 b/tests/qemu-iotests/120
+     .bdrv_snapshot_create   = qcow2_snapshot_create,
-index XXXXXXX..XXXXXXX 100755
+diff --git a/util/iov.c b/util/iov.c
---- a/tests/qemu-iotests/120
+index XXXXXXX..XXXXXXX 100644
-+++ b/tests/qemu-iotests/120
+--- a/util/iov.c
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
++++ b/util/iov.c
- _supported_fmt generic
+@@ -XXX,XX +XXX,XX @@ static struct iovec *qiov_slice(QEMUIOVector *qiov,
- _supported_proto file
+     return iov;
  _unsupported_fmt luks
 +_require_drivers raw
  _make_test_img 64M
 diff --git a/tests/qemu-iotests/162 b/tests/qemu-iotests/162
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/162
 +++ b/tests/qemu-iotests/162
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  . ./common.filter
  _supported_fmt generic
 -
 -test_ssh=$($QEMU_IMG --help | grep '^Supported formats:.* ssh\( \|$\)')
 -[ "$test_ssh" = "" ] && _notrun "ssh support required"
 +_require_drivers ssh
  echo
  echo '=== NBD ==='
 diff --git a/tests/qemu-iotests/184 b/tests/qemu-iotests/184
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/184
 +++ b/tests/qemu-iotests/184
@@ -XXX,XX +XXX,XX @@ trap "exit \$status" 0 1 2 3 15
  . ./common.filter
  _supported_os Linux
 +_require_drivers throttle
  do_run_qemu()
  {
 diff --git a/tests/qemu-iotests/186 b/tests/qemu-iotests/186
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/186
 +++ b/tests/qemu-iotests/186
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2
  _supported_proto file
 +_require_drivers null-co
  if [ "$QEMU_DEFAULT_MACHINE" != "pc" ]; then
      _notrun "Requires a PC machine"
 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 @@ _require_command()
      [ -x "$c" ] || _notrun "$1 utility required, skipped this test"
  }
-+# Check that a set of drivers has been whitelisted in the QEMU binary
++int qemu_iovec_subvec_niov(QEMUIOVector *qiov, size_t offset, size_t len)
 +#
 +_require_drivers()
 +{
-+    available=$($QEMU -drive format=help | \
++    size_t head, tail;
-+                sed -e '/Supported formats:/!d' -e 's/Supported formats://')
++    int niov;
-+    for driver
++
-+    do
++    qiov_slice(qiov, offset, len, &head, &tail, &niov);
-+        if ! echo "$available" | grep -q " $driver\( \|$\)"; then
++
-+            _notrun "$driver not available"
++    return niov;
 +        fi
 +    done
 +}
 +
- # make sure this script returns success
+ /*
- true
+  * Compile new iovec, combining @head_buf buffer, sub-qiov of @mid_qiov,
   * and @tail_buf buffer into new qiov.
 --
 .21.0

The following changes since commit 23919ddfd56135cad3cb468a8f54d5a595f024f4:

Merge remote-tracking branch 'remotes/aperard/tags/pull-xen-20190827' into staging (2019-08-27 15:52:36 +0100)

are available in the Git repository at:

https://github.com/XanClic/qemu.git tags/pull-block-2019-08-27

for you to fetch changes up to bb043c056cffcc2f3ce88bfdaf2e76e455c09e2c:

iotests: Unify cache mode quoting (2019-08-27 19:48:44 +0200)

----------------------------------------------------------------
Block patches:
- qemu-io now accepts a file to read a write pattern from
- Ensure that raw files have their first block allocated so we can probe
  the O_DIRECT alignment if necessary
- Various fixes

----------------------------------------------------------------
Denis Plotnikov (1):
  qemu-io: add pattern file for write command

Max Reitz (7):
  iotests: Fix _filter_img_create()
  vmdk: Use bdrv_dirname() for relative extent paths
  iotests: Keep testing broken relative extent paths
  vmdk: Reject invalid compressed writes
  iotests: Disable broken streamOptimized tests
  iotests: Disable 110 for vmdk.twoGbMaxExtentSparse
  iotests: Disable 126 for flat vmdk subformats

Nir Soffer (3):
  block: posix: Always allocate the first block
  iotests: Test allocate_first_block() with O_DIRECT
  iotests: Unify cache mode quoting

Stefan Hajnoczi (1):
  file-posix: fix request_alignment typo

Thomas Huth (2):
  iotests: Check for enabled drivers before testing them
  tests/check-block: Skip iotests when sanitizers are enabled

Vladimir Sementsov-Ogievskiy (1):
  block: fix permission update in bdrv_replace_node

block.c                                       |  5 +-
 block/file-posix.c                            | 53 +++++++++-
 block/vmdk.c                                  | 64 ++++++++----
 qemu-io-cmds.c                                | 99 +++++++++++++++++--
 tests/check-block.sh                          |  5 +
 tests/qemu-iotests/002                        |  1 +
 tests/qemu-iotests/003                        |  1 +
 tests/qemu-iotests/005                        |  3 +-
 tests/qemu-iotests/009                        |  1 +
 tests/qemu-iotests/010                        |  1 +
 tests/qemu-iotests/011                        |  1 +
 tests/qemu-iotests/017                        |  3 +-
 tests/qemu-iotests/018                        |  3 +-
 tests/qemu-iotests/019                        |  3 +-
 tests/qemu-iotests/020                        |  3 +-
 tests/qemu-iotests/026                        |  4 +-
 tests/qemu-iotests/027                        |  1 +
 tests/qemu-iotests/032                        |  1 +
 tests/qemu-iotests/033                        |  1 +
 tests/qemu-iotests/034                        |  3 +-
 tests/qemu-iotests/037                        |  3 +-
 tests/qemu-iotests/039                        |  4 +-
 tests/qemu-iotests/052                        |  2 +-
 tests/qemu-iotests/059                        | 34 ++++++-
 tests/qemu-iotests/059.out                    | 26 +++--
 tests/qemu-iotests/063                        |  3 +-
 tests/qemu-iotests/071                        |  1 +
 tests/qemu-iotests/072                        |  1 +
 tests/qemu-iotests/081                        |  4 +-
 tests/qemu-iotests/091                        |  4 +-
 tests/qemu-iotests/099                        |  1 +
 tests/qemu-iotests/105                        |  3 +-
 tests/qemu-iotests/110                        |  3 +-
 tests/qemu-iotests/120                        |  1 +
 tests/qemu-iotests/126                        |  2 +
 tests/qemu-iotests/{150.out => 150.out.qcow2} |  0
 tests/qemu-iotests/150.out.raw                | 12 +++
 tests/qemu-iotests/162                        |  4 +-
 tests/qemu-iotests/175                        | 47 +++++++--
 tests/qemu-iotests/175.out                    | 16 ++-
 tests/qemu-iotests/178.out.qcow2              |  4 +-
 tests/qemu-iotests/184                        |  1 +
 tests/qemu-iotests/186                        |  1 +
 tests/qemu-iotests/197                        |  1 +
 tests/qemu-iotests/215                        |  1 +
 tests/qemu-iotests/221.out                    | 12 ++-
 tests/qemu-iotests/251                        |  1 +
 tests/qemu-iotests/253.out                    | 12 ++-
 tests/qemu-iotests/common.filter              |  4 +-
 tests/qemu-iotests/common.rc                  | 14 +++
 50 files changed, 391 insertions(+), 87 deletions(-)
 rename tests/qemu-iotests/{150.out => 150.out.qcow2} (100%)
 create mode 100644 tests/qemu-iotests/150.out.raw

-- 
2.21.0

From: Denis Plotnikov <dplotnikov@virtuozzo.com>

The patch allows to provide a pattern file for write
command. There was no similar ability before.

Signed-off-by: Denis Plotnikov <dplotnikov@virtuozzo.com>
Message-id: 20190820164616.4072-1-dplotnikov@virtuozzo.com
Reviewed-by: Eric Blake <eblake@redhat.com>
[mreitz: Keep optstring in alphabetical order]
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qemu-io-cmds.c | 99 +++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 93 insertions(+), 6 deletions(-)

diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -XXX,XX +XXX,XX @@ static void qemu_io_free(void *p)
     qemu_vfree(p);
 }
 
+/*
+ * qemu_io_alloc_from_file()
+ *
+ * Allocates the buffer and populates it with the content of the given file
+ * up to @len bytes. If the file length is less than @len, then the buffer
+ * is populated with the file content cyclically.
+ *
+ * @blk - the block backend where the buffer content is going to be written to
+ * @len - the buffer length
+ * @file_name - the file to read the content from
+ *
+ * Returns: the buffer pointer on success
+ *          NULL on error
+ */
+static void *qemu_io_alloc_from_file(BlockBackend *blk, size_t len,
+                                     const char *file_name)
+{
+    char *buf, *buf_origin;
+    FILE *f = fopen(file_name, "r");
+    int pattern_len;
+
+    if (!f) {
+        perror(file_name);
+        return NULL;
+    }
+
+    if (qemuio_misalign) {
+        len += MISALIGN_OFFSET;
+    }
+
+    buf_origin = buf = blk_blockalign(blk, len);
+
+    if (qemuio_misalign) {
+        buf_origin += MISALIGN_OFFSET;
+        buf += MISALIGN_OFFSET;
+        len -= MISALIGN_OFFSET;
+    }
+
+    pattern_len = fread(buf_origin, 1, len, f);
+
+    if (ferror(f)) {
+        perror(file_name);
+        goto error;
+    }
+
+    if (pattern_len == 0) {
+        fprintf(stderr, "%s: file is empty\n", file_name);
+        goto error;
+    }
+
+    fclose(f);
+
+    if (len > pattern_len) {
+        len -= pattern_len;
+        buf += pattern_len;
+
+        while (len > 0) {
+            size_t len_to_copy = MIN(pattern_len, len);
+
+            memcpy(buf, buf_origin, len_to_copy);
+
+            len -= len_to_copy;
+            buf += len_to_copy;
+        }
+    }
+
+    return buf_origin;
+
+error:
+    qemu_io_free(buf_origin);
+    return NULL;
+}
+
 static void dump_buffer(const void *buffer, int64_t offset, int64_t len)
 {
     uint64_t i;
@@ -XXX,XX +XXX,XX @@ static void write_help(void)
 " -n, -- with -z, don't allow slow fallback\n"
 " -p, -- ignored for backwards compatibility\n"
 " -P, -- use different pattern to fill file\n"
+" -s, -- use a pattern file to fill the write buffer\n"
 " -C, -- report statistics in a machine parsable format\n"
 " -q, -- quiet mode, do not show I/O statistics\n"
 " -u, -- with -z, allow unmapping\n"
@@ -XXX,XX +XXX,XX @@ static const cmdinfo_t write_cmd = {
     .perm       = BLK_PERM_WRITE,
     .argmin     = 2,
     .argmax     = -1,
-    .args       = "[-bcCfnquz] [-P pattern] off len",
+    .args       = "[-bcCfnquz] [-P pattern | -s source_file] off len",
     .oneline    = "writes a number of bytes at a specified offset",
     .help       = write_help,
 };
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
 {
     struct timespec t1, t2;
     bool Cflag = false, qflag = false, bflag = false;
-    bool Pflag = false, zflag = false, cflag = false;
+    bool Pflag = false, zflag = false, cflag = false, sflag = false;
     int flags = 0;
     int c, cnt, ret;
     char *buf = NULL;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
     /* Some compilers get confused and warn if this is not initialized.  */
     int64_t total = 0;
     int pattern = 0xcd;
+    const char *file_name = NULL;
 
-    while ((c = getopt(argc, argv, "bcCfnpP:quz")) != -1) {
+    while ((c = getopt(argc, argv, "bcCfnpP:qs:uz")) != -1) {
         switch (c) {
         case 'b':
             bflag = true;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
         case 'q':
             qflag = true;
             break;
+        case 's':
+            sflag = true;
+            file_name = optarg;
+            break;
         case 'u':
             flags |= BDRV_REQ_MAY_UNMAP;
             break;
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
         return -EINVAL;
     }
 
-    if (zflag && Pflag) {
-        printf("-z and -P cannot be specified at the same time\n");
+    if (zflag + Pflag + sflag > 1) {
+        printf("Only one of -z, -P, and -s "
+               "can be specified at the same time\n");
         return -EINVAL;
     }
 
@@ -XXX,XX +XXX,XX @@ static int write_f(BlockBackend *blk, int argc, char **argv)
     }
 
     if (!zflag) {
-        buf = qemu_io_alloc(blk, count, pattern);
+        if (sflag) {
+            buf = qemu_io_alloc_from_file(blk, count, file_name);
+            if (!buf) {
+                return -EINVAL;
+            }
+        } else {
+            buf = qemu_io_alloc(blk, count, pattern);
+        }
     }
 
     clock_gettime(CLOCK_MONOTONIC, &t1);
-- 
2.21.0

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

It's wrong to OR shared permissions. It may lead to crash on further
permission updates.
Also, no needs to consider previously calculated permissions, as at
this point we already bind all new parents and bdrv_get_cumulative_perm
result is enough. So fix the bug by just set permissions by
bdrv_get_cumulative_perm result.

Bug was introduced in long ago 234ac1a9025, in 2.9.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-id: 20190824100740.61635-1-vsementsov@virtuozzo.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
 {
     BdrvChild *c, *next;
     GSList *list = NULL, *p;
-    uint64_t old_perm, old_shared;
     uint64_t perm = 0, shared = BLK_PERM_ALL;
     int ret;
 
@@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
         bdrv_unref(from);
     }
 
-    bdrv_get_cumulative_perm(to, &old_perm, &old_shared);
-    bdrv_set_perm(to, old_perm | perm, old_shared | shared);
+    bdrv_get_cumulative_perm(to, &perm, &shared);
+    bdrv_set_perm(to, perm, shared);
 
 out:
     g_slist_free(list);
-- 
2.21.0

From: Nir Soffer <nirsof@gmail.com>

When creating an image with preallocation "off" or "falloc", the first
block of the image is typically not allocated. When using Gluster
storage backed by XFS filesystem, reading this block using direct I/O
succeeds regardless of request length, fooling alignment detection.

In this case we fallback to a safe value (4096) instead of the optimal
value (512), which may lead to unneeded data copying when aligning
requests.  Allocating the first block avoids the fallback.

Since we allocate the first block even with preallocation=off, we no
longer create images with zero disk size:

$ ./qemu-img create -f raw test.raw 1g
    Formatting 'test.raw', fmt=raw size=1073741824

$ ls -lhs test.raw
    4.0K -rw-r--r--. 1 nsoffer nsoffer 1.0G Aug 16 23:48 test.raw

And converting the image requires additional cluster:

$ ./qemu-img measure -f raw -O qcow2 test.raw
    required size: 458752
    fully allocated size: 1074135040

When using format like vmdk with multiple files per image, we allocate
one block per file:

$ ./qemu-img create -f vmdk -o subformat=twoGbMaxExtentFlat test.vmdk 4g
    Formatting 'test.vmdk', fmt=vmdk size=4294967296 compat6=off hwversion=undefined subformat=twoGbMaxExtentFlat

$ ls -lhs test*.vmdk
    4.0K -rw-r--r--. 1 nsoffer nsoffer 2.0G Aug 27 03:23 test-f001.vmdk
    4.0K -rw-r--r--. 1 nsoffer nsoffer 2.0G Aug 27 03:23 test-f002.vmdk
    4.0K -rw-r--r--. 1 nsoffer nsoffer  353 Aug 27 03:23 test.vmdk

I did quick performance test for copying disks with qemu-img convert to
new raw target image to Gluster storage with sector size of 512 bytes:

for i in $(seq 10); do
        rm -f dst.raw
        sleep 10
        time ./qemu-img convert -f raw -O raw -t none -T none src.raw dst.raw
    done

Here is a table comparing the total time spent:

Type    Before(s)   After(s)    Diff(%)
---------------------------------------
real      530.028    469.123      -11.4
user       17.204     10.768      -37.4
sys        17.881      7.011      -60.7

We can see very clear improvement in CPU usage.

Signed-off-by: Nir Soffer <nsoffer@redhat.com>
Message-id: 20190827010528.8818-2-nsoffer@redhat.com
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/file-posix.c                            | 51 +++++++++++++++++++
 tests/qemu-iotests/059.out                    |  2 +-
 tests/qemu-iotests/{150.out => 150.out.qcow2} |  0
 tests/qemu-iotests/150.out.raw                | 12 +++++
 tests/qemu-iotests/175                        | 19 ++++---
 tests/qemu-iotests/175.out                    |  8 +--
 tests/qemu-iotests/178.out.qcow2              |  4 +-
 tests/qemu-iotests/221.out                    | 12 +++--
 tests/qemu-iotests/253.out                    | 12 +++--
 9 files changed, 99 insertions(+), 21 deletions(-)
 rename tests/qemu-iotests/{150.out => 150.out.qcow2} (100%)
 create mode 100644 tests/qemu-iotests/150.out.raw

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_discard(void *opaque)
     return ret;
 }
 
+/*
+ * Help alignment probing by allocating the first block.
+ *
+ * When reading with direct I/O from unallocated area on Gluster backed by XFS,
+ * reading succeeds regardless of request length. In this case we fallback to
+ * safe alignment which is not optimal. Allocating the first block avoids this
+ * fallback.
+ *
+ * fd may be opened with O_DIRECT, but we don't know the buffer alignment or
+ * request alignment, so we use safe values.
+ *
+ * Returns: 0 on success, -errno on failure. Since this is an optimization,
+ * caller may ignore failures.
+ */
+static int allocate_first_block(int fd, size_t max_size)
+{
+    size_t write_size = (max_size < MAX_BLOCKSIZE)
+        ? BDRV_SECTOR_SIZE
+        : MAX_BLOCKSIZE;
+    size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
+    void *buf;
+    ssize_t n;
+    int ret;
+
+    buf = qemu_memalign(max_align, write_size);
+    memset(buf, 0, write_size);
+
+    do {
+        n = pwrite(fd, buf, write_size, 0);
+    } while (n == -1 && errno == EINTR);
+
+    ret = (n == -1) ? -errno : 0;
+
+    qemu_vfree(buf);
+    return ret;
+}
+
 static int handle_aiocb_truncate(void *opaque)
 {
     RawPosixAIOData *aiocb = opaque;
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_truncate(void *opaque)
                 /* posix_fallocate() doesn't set errno. */
                 error_setg_errno(errp, -result,
                                  "Could not preallocate new data");
+            } else if (current_length == 0) {
+                /*
+                 * posix_fallocate() uses fallocate() if the filesystem
+                 * supports it, or fallback to manually writing zeroes. If
+                 * fallocate() was used, unaligned reads from the fallocated
+                 * area in raw_probe_alignment() will succeed, hence we need to
+                 * allocate the first block.
+                 *
+                 * Optimize future alignment probing; ignore failures.
+                 */
+                allocate_first_block(fd, offset);
             }
         } else {
             result = 0;
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_truncate(void *opaque)
         if (ftruncate(fd, offset) != 0) {
             result = -errno;
             error_setg_errno(errp, -result, "Could not resize file");
+        } else if (current_length == 0 && offset > current_length) {
+            /* Optimize future alignment probing; ignore failures. */
+            allocate_first_block(fd, offset);
         }
         return result;
     default:
diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/059.out
+++ b/tests/qemu-iotests/059.out
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMax
 image: TEST_DIR/t.vmdk
 file format: vmdk
 virtual size: 0.977 TiB (1073741824000 bytes)
-disk size: 16 KiB
+disk size: 1.97 MiB
 Format specific information:
     cid: XXXXXXXX
     parent cid: XXXXXXXX
diff --git a/tests/qemu-iotests/150.out b/tests/qemu-iotests/150.out.qcow2
similarity index 100%
rename from tests/qemu-iotests/150.out
rename to tests/qemu-iotests/150.out.qcow2
diff --git a/tests/qemu-iotests/150.out.raw b/tests/qemu-iotests/150.out.raw
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/150.out.raw
@@ -XXX,XX +XXX,XX @@
+QA output created by 150
+
+=== Mapping sparse conversion ===
+
+Offset          Length          File
+0               0x1000          TEST_DIR/t.IMGFMT
+
+=== Mapping non-sparse conversion ===
+
+Offset          Length          File
+0               0x100000        TEST_DIR/t.IMGFMT
+*** done
diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/175
+++ b/tests/qemu-iotests/175
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # the file size.  This function hides the resulting difference in the
 # stat -c '%b' output.
 # Parameter 1: Number of blocks an empty file occupies
-# Parameter 2: Image size in bytes
+# Parameter 2: Minimal number of blocks in an image
+# Parameter 3: Image size in bytes
 _filter_blocks()
 {
     extra_blocks=$1
-    img_size=$2
+    min_blocks=$2
+    img_size=$3
 
-    sed -e "s/blocks=$extra_blocks\$\$\\|[^0-9]\$/nothing allocated/" \
-        -e "s/blocks=$((extra_blocks + img_size / 512))\$\$\\|[^0-9]\$/everything allocated/"
+    sed -e "s/blocks=$min_blocks\$\$\\|[^0-9]\$/min allocation/" \
+        -e "s/blocks=$((extra_blocks + img_size / 512))\$\$\\|[^0-9]\$/max allocation/"
 }
 
 # get standard environment, filters and checks
@@ -XXX,XX +XXX,XX @@ size=$((1 * 1024 * 1024))
 touch "$TEST_DIR/empty"
 extra_blocks=$(stat -c '%b' "$TEST_DIR/empty")
 
+# We always write the first byte; check how many blocks this filesystem
+# allocates to match empty image alloation.
+printf "\0" > "$TEST_DIR/empty"
+min_blocks=$(stat -c '%b' "$TEST_DIR/empty")
+
 echo
 echo "== creating image with default preallocation =="
 _make_test_img $size | _filter_imgfmt
-stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size
+stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
 
 for mode in off full falloc; do
     echo
     echo "== creating image with preallocation $mode =="
     IMGOPTS=preallocation=$mode _make_test_img $size | _filter_imgfmt
-    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $size
+    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
 done
 
 # success, all done
diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/175.out
+++ b/tests/qemu-iotests/175.out
@@ -XXX,XX +XXX,XX @@ QA output created by 175
 
 == creating image with default preallocation ==
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576
-size=1048576, nothing allocated
+size=1048576, min allocation
 
 == creating image with preallocation off ==
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=off
-size=1048576, nothing allocated
+size=1048576, min allocation
 
 == creating image with preallocation full ==
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=full
-size=1048576, everything allocated
+size=1048576, max allocation
 
 == creating image with preallocation falloc ==
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc
-size=1048576, everything allocated
+size=1048576, max allocation
  *** done
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 @@ converted image file size in bytes: 196608
 == raw input image with data (human) ==
 
 Formatting 'TEST_DIR/t.qcow2', fmt=IMGFMT size=1073741824
-required size: 393216
+required size: 458752
 fully allocated size: 1074135040
 wrote 512/512 bytes at offset 512
 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
@@ -XXX,XX +XXX,XX @@ converted image file size in bytes: 196608
 
 Formatting 'TEST_DIR/t.qcow2', fmt=IMGFMT size=1073741824
 {
-    "required": 393216,
+    "required": 458752,
     "fully-allocated": 1074135040
 }
 wrote 512/512 bytes at offset 512
diff --git a/tests/qemu-iotests/221.out b/tests/qemu-iotests/221.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/221.out
+++ b/tests/qemu-iotests/221.out
@@ -XXX,XX +XXX,XX @@ QA output created by 221
 === Check mapping of unaligned raw image ===
 
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=65537
-[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
-[{ "start": 0, "length": 66048, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 61952, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 wrote 1/1 bytes at offset 65536
 1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
-[{ "start": 0, "length": 65536, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 61440, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 { "start": 65536, "length": 1, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
 { "start": 65537, "length": 511, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 *** done
diff --git a/tests/qemu-iotests/253.out b/tests/qemu-iotests/253.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/253.out
+++ b/tests/qemu-iotests/253.out
@@ -XXX,XX +XXX,XX @@ QA output created by 253
 === Check mapping of unaligned raw image ===
 
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048575
-[{ "start": 0, "length": 1048576, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
-[{ "start": 0, "length": 1048576, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 1044480, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 1044480, "depth": 0, "zero": true, "data": false, "offset": OFFSET}]
 wrote 65535/65535 bytes at offset 983040
 63.999 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-[{ "start": 0, "length": 983040, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 978944, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 { "start": 983040, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]
-[{ "start": 0, "length": 983040, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
+[{ "start": 0, "length": 4096, "depth": 0, "zero": false, "data": true, "offset": OFFSET},
+{ "start": 4096, "length": 978944, "depth": 0, "zero": true, "data": false, "offset": OFFSET},
 { "start": 983040, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": OFFSET}]
 *** done
-- 
2.21.0

From: Nir Soffer <nirsof@gmail.com>

Using block_resize we can test allocate_first_block() with file
descriptor opened with O_DIRECT, ensuring that it works for any size
larger than 4096 bytes.

Testing smaller sizes is tricky as the result depends on the filesystem
used for testing. For example on NFS any size will work since O_DIRECT
does not require any alignment.

Signed-off-by: Nir Soffer <nsoffer@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190827010528.8818-3-nsoffer@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/175     | 28 ++++++++++++++++++++++++++++
 tests/qemu-iotests/175.out |  8 ++++++++
 2 files changed, 36 insertions(+)

diff --git a/tests/qemu-iotests/175 b/tests/qemu-iotests/175
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/175
+++ b/tests/qemu-iotests/175
@@ -XXX,XX +XXX,XX @@ _filter_blocks()
         -e "s/blocks=$((extra_blocks + img_size / 512))\$\$\\|[^0-9]\$/max allocation/"
 }
 
+# Resize image using block_resize.
+# Parameter 1: image path
+# Parameter 2: new size
+_block_resize()
+{
+    local path=$1
+    local size=$2
+
+    $QEMU -qmp stdio -nographic -nodefaults \
+        -blockdev file,node-name=file,filename=$path,cache.direct=on \
+        <<EOF
+{'execute': 'qmp_capabilities'}
+{'execute': 'block_resize', 'arguments': {'node-name': 'file', 'size': $size}}
+{'execute': 'quit'}
+EOF
+}
+
 # get standard environment, filters and checks
 . ./common.rc
 . ./common.filter
@@ -XXX,XX +XXX,XX @@ _supported_fmt raw
 _supported_proto file
 _supported_os Linux
 
+_default_cache_mode none
+_supported_cache_modes none directsync
+
 size=$((1 * 1024 * 1024))
 
 touch "$TEST_DIR/empty"
@@ -XXX,XX +XXX,XX @@ for mode in off full falloc; do
     stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $size
 done
 
+for new_size in 4096 1048576; do
+    echo
+    echo "== resize empty image with block_resize =="
+    _make_test_img 0 | _filter_imgfmt
+    _block_resize $TEST_IMG $new_size >/dev/null
+    stat -c "size=%s, blocks=%b" $TEST_IMG | _filter_blocks $extra_blocks $min_blocks $new_size
+done
+
 # success, all done
 echo "*** done"
 rm -f $seq.full
diff --git a/tests/qemu-iotests/175.out b/tests/qemu-iotests/175.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/175.out
+++ b/tests/qemu-iotests/175.out
@@ -XXX,XX +XXX,XX @@ size=1048576, max allocation
 == creating image with preallocation falloc ==
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 preallocation=falloc
 size=1048576, max allocation
+
+== resize empty image with block_resize ==
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=0
+size=4096, min allocation
+
+== resize empty image with block_resize ==
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=0
+size=1048576, min allocation
  *** done
-- 
2.21.0

fe646693acc changed qemu-img create's output so that it no longer prints
single quotes around parameter values.  The subformat and adapter_type
filters in _filter_img_create() have never been adapted to that change.

Fixes: fe646693acc13ac48b98435d14149ab04dc597bc
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 20190815153638.4600-2-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/059.out       | 16 ++++++++--------
 tests/qemu-iotests/common.filter |  4 ++--
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/059.out
+++ b/tests/qemu-iotests/059.out
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
 qemu-io: can't open device TEST_DIR/t.vmdk: L1 size too big
 
 === Testing monolithicFlat creation and opening ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648
 image: TEST_DIR/t.IMGFMT
 file format: IMGFMT
 virtual size: 2 GiB (2147483648 bytes)
 
 === Testing monolithicFlat with zeroed_grain ===
 qemu-img: TEST_DIR/t.IMGFMT: Flat image can't enable zeroed grain
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648 subformat=monolithicFlat
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=2147483648
 
 === Testing big twoGbMaxExtentFlat ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000 subformat=twoGbMaxExtentFlat
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824000
 image: TEST_DIR/t.vmdk
 file format: vmdk
 virtual size: 0.977 TiB (1073741824000 bytes)
@@ -XXX,XX +XXX,XX @@ Format specific information:
 qemu-img: Could not open 'TEST_DIR/t.IMGFMT': Invalid extent line: RW 12582912 VMFS "dummy.IMGFMT" 1
 
 === Testing truncated sparse ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=107374182400 subformat=monolithicSparse
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=107374182400
 qemu-img: Could not open 'TEST_DIR/t.IMGFMT': File truncated, expecting at least 13172736 bytes
 
 === Converting to streamOptimized from image with small cluster size===
@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
 === Testing monolithicFlat with internally generated JSON file name ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 subformat=monolithicFlat
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
 qemu-io: can't open: Cannot use relative extent paths with VMDK descriptor file 'json:{"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "read_aio"}'
 
 === Testing version 3 ===
@@ -XXX,XX +XXX,XX @@ read 512/512 bytes at offset 64931328
 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
 === Testing 4TB monolithicFlat creation and IO ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104 subformat=monolithicFlat
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=4398046511104
 image: TEST_DIR/t.IMGFMT
 file format: IMGFMT
 virtual size: 4 TiB (4398046511104 bytes)
@@ -XXX,XX +XXX,XX @@ read 1024/1024 bytes at offset 966367641600
 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
 === Testing qemu-img map on extents ===
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 subformat=monolithicSparse
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544
 wrote 1024/1024 bytes at offset 65024
 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 wrote 1024/1024 bytes at offset 2147483136
@@ -XXX,XX +XXX,XX @@ Offset          Length          Mapped to       File
 0               0x20000         0x3f0000        TEST_DIR/t.vmdk
 0x7fff0000      0x20000         0x410000        TEST_DIR/t.vmdk
 0x140000000     0x10000         0x430000        TEST_DIR/t.vmdk
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544 subformat=twoGbMaxExtentSparse
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=33285996544
 wrote 1024/1024 bytes at offset 65024
 1 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 wrote 1024/1024 bytes at offset 2147483136
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_create()
         -e "s# compat6=\$on\\|off\$##g" \
         -e "s# static=\$on\\|off\$##g" \
         -e "s# zeroed_grain=\$on\\|off\$##g" \
-        -e "s# subformat='[^']*'##g" \
-        -e "s# adapter_type='[^']*'##g" \
+        -e "s# subformat=[^ ]*##g" \
+        -e "s# adapter_type=[^ ]*##g" \
         -e "s# hwversion=[^ ]*##g" \
         -e "s# lazy_refcounts=\$on\\|off\$##g" \
         -e "s# block_size=[0-9]\\+##g" \
-- 
2.21.0

This makes iotest 033 pass with e.g. subformat=monolithicFlat.  It also
turns a former error in 059 into success.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20190815153638.4600-3-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/vmdk.c               | 54 ++++++++++++++++++++++++--------------
 tests/qemu-iotests/059     |  7 +++--
 tests/qemu-iotests/059.out |  4 ++-
 3 files changed, 42 insertions(+), 23 deletions(-)

diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static const char *next_line(const char *s)
 }
 
 static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
-                              const char *desc_file_path, QDict *options,
-                              Error **errp)
+                              QDict *options, Error **errp)
 {
     int ret;
     int matches;
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
     const char *p, *np;
     int64_t sectors = 0;
     int64_t flat_offset;
+    char *desc_file_dir = NULL;
     char *extent_path;
     BdrvChild *extent_file;
     BDRVVmdkState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
             continue;
         }
 
-        if (!path_is_absolute(fname) && !path_has_protocol(fname) &&
-            !desc_file_path[0])
-        {
-            bdrv_refresh_filename(bs->file->bs);
-            error_setg(errp, "Cannot use relative extent paths with VMDK "
-                       "descriptor file '%s'", bs->file->bs->filename);
-            return -EINVAL;
-        }
+        if (path_is_absolute(fname)) {
+            extent_path = g_strdup(fname);
+        } else {
+            if (!desc_file_dir) {
+                desc_file_dir = bdrv_dirname(bs->file->bs, errp);
+                if (!desc_file_dir) {
+                    bdrv_refresh_filename(bs->file->bs);
+                    error_prepend(errp, "Cannot use relative paths with VMDK "
+                                  "descriptor file '%s': ",
+                                  bs->file->bs->filename);
+                    ret = -EINVAL;
+                    goto out;
+                }
+            }
 
-        extent_path = path_combine(desc_file_path, fname);
+            extent_path = g_strconcat(desc_file_dir, fname, NULL);
+        }
 
         ret = snprintf(extent_opt_prefix, 32, "extents.%d", s->num_extents);
         assert(ret < 32);
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
         g_free(extent_path);
         if (local_err) {
             error_propagate(errp, local_err);
-            return -EINVAL;
+            ret = -EINVAL;
+            goto out;
         }
 
         /* save to extents array */
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
                             0, 0, 0, 0, 0, &extent, errp);
             if (ret < 0) {
                 bdrv_unref_child(bs, extent_file);
-                return ret;
+                goto out;
             }
             extent->flat_start_offset = flat_offset << 9;
         } else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) {
@@ -XXX,XX +XXX,XX @@ static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
             g_free(buf);
             if (ret) {
                 bdrv_unref_child(bs, extent_file);
-                return ret;
+                goto out;
             }
             extent = &s->extents[s->num_extents - 1];
         } else if (!strcmp(type, "SESPARSE")) {
             ret = vmdk_open_se_sparse(bs, extent_file, bs->open_flags, errp);
             if (ret) {
                 bdrv_unref_child(bs, extent_file);
-                return ret;
+                goto out;
             }
             extent = &s->extents[s->num_extents - 1];
         } else {
             error_setg(errp, "Unsupported extent type '%s'", type);
             bdrv_unref_child(bs, extent_file);
-            return -ENOTSUP;
+            ret = -ENOTSUP;
+            goto out;
         }
         extent->type = g_strdup(type);
     }
-    return 0;
+
+    ret = 0;
+    goto out;
 
 invalid:
     np = next_line(p);
@@ -XXX,XX +XXX,XX @@ invalid:
         np--;
     }
     error_setg(errp, "Invalid extent line: %.*s", (int)(np - p), p);
-    return -EINVAL;
+    ret = -EINVAL;
+
+out:
+    g_free(desc_file_dir);
+    return ret;
 }
 
 static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf,
@@ -XXX,XX +XXX,XX @@ static int vmdk_open_desc_file(BlockDriverState *bs, int flags, char *buf,
     }
     s->create_type = g_strdup(ct);
     s->desc_offset = 0;
-    ret = vmdk_parse_extents(buf, bs, bs->file->bs->exact_filename, options,
-                             errp);
+    ret = vmdk_parse_extents(buf, bs, options, errp);
 exit:
     return ret;
 }
diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/059
+++ b/tests/qemu-iotests/059
@@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -f qcow2 -O vmdk -o subformat=streamOptimized "$TEST_IMG.qcow2
 
 echo
 echo "=== Testing monolithicFlat with internally generated JSON file name ==="
+# Should work, because bdrv_dirname() works fine with blkdebug
 IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
-$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" 2>&1 \
-    | _filter_testdir | _filter_imgfmt
+$QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" \
+         -c info \
+    2>&1 \
+    | _filter_testdir | _filter_imgfmt | _filter_img_info
 _cleanup_test_img
 
 echo
diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/059.out
+++ b/tests/qemu-iotests/059.out
@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
 
 === Testing monolithicFlat with internally generated JSON file name ===
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
-qemu-io: can't open: Cannot use relative extent paths with VMDK descriptor file 'json:{"image": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}, "driver": "blkdebug", "inject-error.0.event": "read_aio"}'
+format name: IMGFMT
+cluster size: 0 bytes
+vm state offset: 0 bytes
 
 === Testing version 3 ===
 image: TEST_DIR/iotest-version3.IMGFMT
-- 
2.21.0

We had a test for a case where relative extent paths did not work, but
unfortunately we just fixed the underlying problem, so it works now.
This patch adds a new test case that still fails.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 20190815153638.4600-4-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/059     | 27 +++++++++++++++++++++++++++
 tests/qemu-iotests/059.out |  4 ++++
 2 files changed, 31 insertions(+)

diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/059
+++ b/tests/qemu-iotests/059
@@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -f qcow2 -O vmdk -o subformat=streamOptimized "$TEST_IMG.qcow2
 
 echo
 echo "=== Testing monolithicFlat with internally generated JSON file name ==="
+
+echo '--- blkdebug ---'
 # Should work, because bdrv_dirname() works fine with blkdebug
 IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
 $QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TEST_IMG,file.inject-error.0.event=read_aio" \
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "open -o driver=$IMGFMT,file.driver=blkdebug,file.image.filename=$TE
     | _filter_testdir | _filter_imgfmt | _filter_img_info
 _cleanup_test_img
 
+echo '--- quorum ---'
+# Should not work, because bdrv_dirname() does not work with quorum
+IMGOPTS="subformat=monolithicFlat" _make_test_img 64M
+cp "$TEST_IMG" "$TEST_IMG.orig"
+
+filename="json:{
+    \"driver\": \"$IMGFMT\",
+    \"file\": {
+        \"driver\": \"quorum\",
+        \"children\": [ {
+            \"driver\": \"file\",
+            \"filename\": \"$TEST_IMG\"
+        }, {
+            \"driver\": \"file\",
+            \"filename\": \"$TEST_IMG.orig\"
+        } ],
+        \"vote-threshold\": 1
+    } }"
+
+filename=$(echo "$filename" | tr '\n' ' ' | sed -e 's/\s\+/ /g')
+$QEMU_IMG info "$filename" 2>&1 \
+    | sed -e "s/'json:[^']*'/\$QUORUM_FILE/g" \
+    | _filter_testdir | _filter_imgfmt | _filter_img_info
+
+
 echo
 echo "=== Testing version 3 ==="
 _use_sample_img iotest-version3.vmdk.bz2
diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/059.out
+++ b/tests/qemu-iotests/059.out
@@ -XXX,XX +XXX,XX @@ wrote 512/512 bytes at offset 10240
 512 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
 === Testing monolithicFlat with internally generated JSON file name ===
+--- blkdebug ---
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
 format name: IMGFMT
 cluster size: 0 bytes
 vm state offset: 0 bytes
+--- quorum ---
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
+qemu-img: Could not open $QUORUM_FILE: Cannot use relative paths with VMDK descriptor file $QUORUM_FILE: Cannot generate a base directory for quorum nodes
 
 === Testing version 3 ===
 image: TEST_DIR/iotest-version3.IMGFMT
-- 
2.21.0

Compressed writes generally have to write full clusters, not just in
theory but also in practice when it comes to vmdk's streamOptimized
subformat.  It currently is just silently broken for writes with
non-zero in-cluster offsets:

$ qemu-img create -f vmdk -o subformat=streamOptimized foo.vmdk 1M
$ qemu-io -c 'write 4k 4k' -c 'read 4k 4k' foo.vmdk
wrote 4096/4096 bytes at offset 4096
4 KiB, 1 ops; 00.01 sec (443.724 KiB/sec and 110.9309 ops/sec)
read failed: Invalid argument

(The technical reason is that vmdk_write_extent() just writes the
incomplete compressed data actually to offset 4k.  When reading the
data, vmdk_read_extent() looks at offset 0 and finds the compressed data
size to be 0, because that is what it reads from there.  This yields an
error.)

For incomplete writes with zero in-cluster offsets, the error path when
reading the rest of the cluster is a bit different, but the result is
the same:

$ qemu-img create -f vmdk -o subformat=streamOptimized foo.vmdk 1M
$ qemu-io -c 'write 0k 4k' -c 'read 4k 4k' foo.vmdk
wrote 4096/4096 bytes at offset 0
4 KiB, 1 ops; 00.01 sec (362.641 KiB/sec and 90.6603 ops/sec)
read failed: Invalid argument

(Here, vmdk_read_extent() finds the data and then sees that the
uncompressed data is short.)

It is better to reject invalid writes than to make the user believe they
might have succeeded and then fail when trying to read it back.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 20190815153638.4600-5-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/vmdk.c | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
     if (extent->compressed) {
         void *compressed_data;
 
+        /* Only whole clusters */
+        if (offset_in_cluster ||
+            n_bytes > (extent->cluster_sectors * SECTOR_SIZE) ||
+            (n_bytes < (extent->cluster_sectors * SECTOR_SIZE) &&
+             offset + n_bytes != extent->end_sector * SECTOR_SIZE))
+        {
+            ret = -EINVAL;
+            goto out;
+        }
+
         if (!extent->has_marker) {
             ret = -EINVAL;
             goto out;
-- 
2.21.0

streamOptimized does not support writes that do not span exactly one
cluster.  Furthermore, it cannot rewrite already allocated clusters.
As such, many iotests do not work with it.  Disable them.

diff --git a/tests/qemu-iotests/002 b/tests/qemu-iotests/002
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/002
+++ b/tests/qemu-iotests/002
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=128M
diff --git a/tests/qemu-iotests/003 b/tests/qemu-iotests/003
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/003
+++ b/tests/qemu-iotests/003
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 size=128M
 offset=67M
diff --git a/tests/qemu-iotests/005 b/tests/qemu-iotests/005
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/005
+++ b/tests/qemu-iotests/005
@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
 _supported_proto generic
 _supported_os Linux
 _unsupported_imgopts "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 # vpc is limited to 127GB, so we can't test it here
 if [ "$IMGFMT" = "vpc" ]; then
diff --git a/tests/qemu-iotests/009 b/tests/qemu-iotests/009
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/009
+++ b/tests/qemu-iotests/009
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=6G
diff --git a/tests/qemu-iotests/010 b/tests/qemu-iotests/010
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/010
+++ b/tests/qemu-iotests/010
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=6G
diff --git a/tests/qemu-iotests/011 b/tests/qemu-iotests/011
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/011
+++ b/tests/qemu-iotests/011
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=6G
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
 _supported_fmt qcow qcow2 vmdk qed
 _supported_proto generic
 _unsupported_proto vxhs
-_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
+_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
+                     "subformat=streamOptimized"
 
 TEST_OFFSETS="0 4294967296"
 
diff --git a/tests/qemu-iotests/018 b/tests/qemu-iotests/018
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/018
+++ b/tests/qemu-iotests/018
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow qcow2 vmdk qed
 _supported_proto file
 _supported_os Linux
-_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
+_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
+                     "streamOptimized"
 
 TEST_OFFSETS="0 4294967296"
 
diff --git a/tests/qemu-iotests/019 b/tests/qemu-iotests/019
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/019
+++ b/tests/qemu-iotests/019
@@ -XXX,XX +XXX,XX @@ _supported_proto file
 _supported_os Linux
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 TEST_OFFSETS="0 4294967296"
 CLUSTER_SIZE=65536
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 @@ _supported_fmt qcow qcow2 vmdk qed
 _supported_proto file
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 TEST_OFFSETS="0 4294967296"
 
diff --git a/tests/qemu-iotests/027 b/tests/qemu-iotests/027
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/027
+++ b/tests/qemu-iotests/027
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt vmdk qcow qcow2 qed
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=128M
diff --git a/tests/qemu-iotests/032 b/tests/qemu-iotests/032
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/032
+++ b/tests/qemu-iotests/032
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # This works for any image format (though unlikely to segfault for raw)
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 echo
 echo === Prepare image ===
diff --git a/tests/qemu-iotests/033 b/tests/qemu-iotests/033
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/033
+++ b/tests/qemu-iotests/033
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt generic
 _supported_proto generic
+_unsupported_imgopts "subformat=streamOptimized"
 
 
 size=128M
diff --git a/tests/qemu-iotests/034 b/tests/qemu-iotests/034
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/034
+++ b/tests/qemu-iotests/034
@@ -XXX,XX +XXX,XX @@ _supported_proto file
 _supported_os Linux
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 CLUSTER_SIZE=4k
 size=128M
diff --git a/tests/qemu-iotests/037 b/tests/qemu-iotests/037
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/037
+++ b/tests/qemu-iotests/037
@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed
 _supported_proto file
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 CLUSTER_SIZE=4k
 size=128M
diff --git a/tests/qemu-iotests/063 b/tests/qemu-iotests/063
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/063
+++ b/tests/qemu-iotests/063
@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow qcow2 vmdk qed raw
 _supported_proto file
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 _make_test_img 4M
 
diff --git a/tests/qemu-iotests/072 b/tests/qemu-iotests/072
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/072
+++ b/tests/qemu-iotests/072
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt vpc vmdk vhdx vdi qed qcow2 qcow
 _supported_proto file
+_unsupported_imgopts "subformat=streamOptimized"
 
 IMG_SIZE=64M
 
diff --git a/tests/qemu-iotests/105 b/tests/qemu-iotests/105
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/105
+++ b/tests/qemu-iotests/105
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2 vmdk vhdx qed
 _supported_proto generic
 _unsupported_imgopts "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+                     "subformat=twoGbMaxExtentSparse" \
+                     "subformat=streamOptimized"
 
 echo
 echo "creating large image"
diff --git a/tests/qemu-iotests/197 b/tests/qemu-iotests/197
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/197
+++ b/tests/qemu-iotests/197
@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
 _supported_proto generic
 # LUKS support may be possible, but it complicates things.
 _unsupported_fmt luks
+_unsupported_imgopts "subformat=streamOptimized"
 
 echo
 echo '=== Copy-on-read ==='
diff --git a/tests/qemu-iotests/215 b/tests/qemu-iotests/215
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/215
+++ b/tests/qemu-iotests/215
@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
 _supported_proto generic
 # LUKS support may be possible, but it complicates things.
 _unsupported_fmt luks
+_unsupported_imgopts "subformat=streamOptimized"
 
 echo
 echo '=== Copy-on-read ==='
diff --git a/tests/qemu-iotests/251 b/tests/qemu-iotests/251
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/251
+++ b/tests/qemu-iotests/251
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt generic
 _supported_proto file
 _supported_os Linux
+_unsupported_imgopts "subformat=streamOptimized"
 
 if [ "$IMGOPTSSYNTAX" = "true" ]; then
     # We use json:{} filenames here, so we cannot work with additional options.
-- 
2.21.0

The error message for the test case where we have a quorum node for
which no directory name can be generated is different: For
twoGbMaxExtentSparse, it complains that it cannot open the extent file.
For other (sub)formats, it just notes that it cannot determine the
backing file path.  Both are fine, but just disable twoGbMaxExtentSparse
for simplicity's sake.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 20190815153638.4600-7-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/110 | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/110 b/tests/qemu-iotests/110
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/110
+++ b/tests/qemu-iotests/110
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # Any format supporting backing files
 _supported_fmt qed qcow qcow2 vmdk
 _supported_proto file
-_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat"
+_unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
+                     "subformat=twoGbMaxExtentSparse"
 
 TEST_IMG_REL=$(basename "$TEST_IMG")
 
-- 
2.21.0

From: Stefan Hajnoczi <stefanha@redhat.com>

Fixes: a6b257a08e3d72219f03e461a52152672fec0612
       ("file-posix: Handle undetectable alignment")
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190827101328.4062-1-stefanha@redhat.com
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/file-posix.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
         for (i = 0; i < ARRAY_SIZE(alignments); i++) {
             align = alignments[i];
             if (raw_is_io_aligned(fd, buf + align, max_align)) {
-                /* Fallback to request_aligment. */
+                /* Fallback to request_alignment. */
                 s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
                 break;
             }
-- 
2.21.0

From: Thomas Huth <thuth@redhat.com>

It is possible to enable only a subset of the block drivers with the
"--block-drv-rw-whitelist" option of the "configure" script. All other
drivers are marked as unusable (or only included as read-only with the
"--block-drv-ro-whitelist" option). If an iotest is now using such a
disabled block driver, it is failing - which is bad, since at least the
tests in the "auto" group should be able to deal with this situation.
Thus let's introduce a "_require_drivers" function that can be used by
the shell tests to check for the availability of certain drivers first,
and marks the test as "not run" if one of the drivers is missing.

This patch mainly targets the test in the "auto" group which should
never fail in such a case, but also improves some of the other tests
along the way. Note that we also assume that the "qcow2" and "file"
drivers are always available - otherwise it does not make sense to
run "make check-block" at all (which only tests with qcow2 by default).

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-id: 20190823133552.11680-1-thuth@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/071       |  1 +
 tests/qemu-iotests/081       |  4 +---
 tests/qemu-iotests/099       |  1 +
 tests/qemu-iotests/120       |  1 +
 tests/qemu-iotests/162       |  4 +---
 tests/qemu-iotests/184       |  1 +
 tests/qemu-iotests/186       |  1 +
 tests/qemu-iotests/common.rc | 14 ++++++++++++++
 8 files changed, 21 insertions(+), 6 deletions(-)

diff --git a/tests/qemu-iotests/071 b/tests/qemu-iotests/071
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/071
+++ b/tests/qemu-iotests/071
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto file
+_require_drivers blkdebug blkverify
 
 do_run_qemu()
 {
diff --git a/tests/qemu-iotests/081 b/tests/qemu-iotests/081
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/081
+++ b/tests/qemu-iotests/081
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt raw
 _supported_proto file
 _supported_os Linux
+_require_drivers quorum
 
 do_run_qemu()
 {
@@ -XXX,XX +XXX,XX @@ run_qemu()
                           | _filter_qemu_io | _filter_generated_node_ids
 }
 
-test_quorum=$($QEMU_IMG --help|grep quorum)
-[ "$test_quorum" = "" ] && _supported_fmt quorum
-
 quorum="driver=raw,file.driver=quorum,file.vote-threshold=2"
 quorum="$quorum,file.children.0.file.filename=$TEST_DIR/1.raw"
 quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw"
diff --git a/tests/qemu-iotests/099 b/tests/qemu-iotests/099
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/099
+++ b/tests/qemu-iotests/099
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow qcow2 qed vdi vhdx vmdk vpc
 _supported_proto file
 _supported_os Linux
+_require_drivers blkdebug blkverify
 _unsupported_imgopts "subformat=monolithicFlat" "subformat=twoGbMaxExtentFlat" \
     "subformat=twoGbMaxExtentSparse"
 
diff --git a/tests/qemu-iotests/120 b/tests/qemu-iotests/120
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/120
+++ b/tests/qemu-iotests/120
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt generic
 _supported_proto file
 _unsupported_fmt luks
+_require_drivers raw
 
 _make_test_img 64M
 
diff --git a/tests/qemu-iotests/162 b/tests/qemu-iotests/162
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/162
+++ b/tests/qemu-iotests/162
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 . ./common.filter
 
 _supported_fmt generic
-
-test_ssh=$($QEMU_IMG --help | grep '^Supported formats:.* ssh$ \|$$')
-[ "$test_ssh" = "" ] && _notrun "ssh support required"
+_require_drivers ssh
 
 echo
 echo '=== NBD ==='
diff --git a/tests/qemu-iotests/184 b/tests/qemu-iotests/184
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/184
+++ b/tests/qemu-iotests/184
@@ -XXX,XX +XXX,XX @@ trap "exit \$status" 0 1 2 3 15
 . ./common.filter
 
 _supported_os Linux
+_require_drivers throttle
 
 do_run_qemu()
 {
diff --git a/tests/qemu-iotests/186 b/tests/qemu-iotests/186
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/186
+++ b/tests/qemu-iotests/186
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 _supported_fmt qcow2
 _supported_proto file
+_require_drivers null-co
 
 if [ "$QEMU_DEFAULT_MACHINE" != "pc" ]; then
     _notrun "Requires a PC machine"
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 @@ _require_command()
     [ -x "$c" ] || _notrun "$1 utility required, skipped this test"
 }
 
+# Check that a set of drivers has been whitelisted in the QEMU binary
+#
+_require_drivers()
+{
+    available=$($QEMU -drive format=help | \
+                sed -e '/Supported formats:/!d' -e 's/Supported formats://')
+    for driver
+    do
+        if ! echo "$available" | grep -q " $driver$ \|$$"; then
+            _notrun "$driver not available"
+        fi
+    done
+}
+
 # make sure this script returns success
 true
-- 
2.21.0

From: Thomas Huth <thuth@redhat.com>

The sanitizers (especially the address sanitizer from Clang) are
sometimes printing out warnings or false positives - this spoils
the output of the iotests, causing some of the tests to fail.
Thus let's skip the automatic iotests during "make check" when the
user configured QEMU with --enable-sanitizers.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-id: 20190823084203.29734-1-thuth@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/check-block.sh | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/check-block.sh b/tests/check-block.sh
index XXXXXXX..XXXXXXX 100755
--- a/tests/check-block.sh
+++ b/tests/check-block.sh
@@ -XXX,XX +XXX,XX @@ if grep -q "TARGET_GPROF=y" *-softmmu/config-target.mak 2>/dev/null ; then
     exit 0
 fi
 
+if grep -q "CFLAGS.*-fsanitize" config-host.mak 2>/dev/null ; then
+    echo "Sanitizers are enabled ==> Not running the qemu-iotests."
+    exit 0
+fi
+
 if [ -z "$(find . -name 'qemu-system-*' -print)" ]; then
     echo "No qemu-system binary available ==> Not running the qemu-iotests."
     exit 0
-- 
2.21.0

From: Nir Soffer <nirsof@gmail.com>

Quoting cache mode is not needed, and most tests use unquoted values.
Unify all test to use the same style.

Message-id: 20190827173432.7656-1-nsoffer@redhat.com
Signed-off-by: Nir Soffer <nsoffer@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/026 | 4 ++--
 tests/qemu-iotests/039 | 4 ++--
 tests/qemu-iotests/052 | 2 +-
 tests/qemu-iotests/091 | 4 ++--
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/qemu-iotests/026 b/tests/qemu-iotests/026
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/026
+++ b/tests/qemu-iotests/026
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 # Currently only qcow2 supports rebasing
 _supported_fmt qcow2
 _supported_proto file
-_default_cache_mode "writethrough"
-_supported_cache_modes "writethrough" "none"
+_default_cache_mode writethrough
+_supported_cache_modes writethrough none
 # The refcount table tests expect a certain minimum width for refcount entries
 # (so that the refcount table actually needs to grow); that minimum is 16 bits,
 # being the default refcount entry width.
diff --git a/tests/qemu-iotests/039 b/tests/qemu-iotests/039
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/039
+++ b/tests/qemu-iotests/039
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2
 _supported_proto file
 _supported_os Linux
-_default_cache_mode "writethrough"
-_supported_cache_modes "writethrough"
+_default_cache_mode writethrough
+_supported_cache_modes writethrough
 
 size=128M
 
diff --git a/tests/qemu-iotests/052 b/tests/qemu-iotests/052
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/052
+++ b/tests/qemu-iotests/052
@@ -XXX,XX +XXX,XX @@ _supported_fmt generic
 _supported_proto file
 
 # Don't do O_DIRECT on tmpfs
-_supported_cache_modes "writeback" "writethrough" "unsafe"
+_supported_cache_modes writeback writethrough unsafe
 
 size=128M
 _make_test_img $size
diff --git a/tests/qemu-iotests/091 b/tests/qemu-iotests/091
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/091
+++ b/tests/qemu-iotests/091
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2
 _supported_proto file
 _supported_os Linux
-_default_cache_mode "none"
-_supported_cache_modes "writethrough" "none" "writeback"
+_default_cache_mode none
+_supported_cache_modes writethrough none writeback
 
 size=1G
 
-- 
2.21.0

The following changes since commit dac03af5d5482ec7ee9c23db467bb7230b33c0d9:

Merge remote-tracking branch 'remotes/rth/tags/pull-axp-20190825' into staging (2019-08-27 10:00:51 +0100)

are available in the Git repository at:

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

for you to fetch changes up to 5396234b96a2ac743f48644529771498e036e698:

block/qcow2: implement .bdrv_co_pwritev(_compressed)_part (2019-08-27 14:58:42 +0100)

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

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

Vladimir Sementsov-Ogievskiy (12):
  util/iov: introduce qemu_iovec_init_extended
  util/iov: improve qemu_iovec_is_zero
  block/io: refactor padding
  block: define .*_part io handlers in BlockDriver
  block/io: bdrv_co_do_copy_on_readv: use and support qiov_offset
  block/io: bdrv_co_do_copy_on_readv: lazy allocation
  block/io: bdrv_aligned_preadv: use and support qiov_offset
  block/io: bdrv_aligned_pwritev: use and support qiov_offset
  block/io: introduce bdrv_co_p{read, write}v_part
  block/qcow2: refactor qcow2_co_preadv to use buffer-based io
  block/qcow2: implement .bdrv_co_preadv_part
  block/qcow2: implement .bdrv_co_pwritev(_compressed)_part

-- 
2.21.0

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

Introduce new initialization API, to create requests with padding. Will
be used in the following patch. New API uses qemu_iovec_init_buf if
resulting io vector has only one element, to avoid extra allocations.
So, we need to update qemu_iovec_destroy to support destroying such
QIOVs.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-2-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-2-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/iov.h |   7 +++
 util/iov.c         | 112 +++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 114 insertions(+), 5 deletions(-)

diff --git a/include/qemu/iov.h b/include/qemu/iov.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/iov.h
+++ b/include/qemu/iov.h
@@ -XXX,XX +XXX,XX @@ static inline void *qemu_iovec_buf(QEMUIOVector *qiov)
 
 void qemu_iovec_init(QEMUIOVector *qiov, int alloc_hint);
 void qemu_iovec_init_external(QEMUIOVector *qiov, struct iovec *iov, int niov);
+void qemu_iovec_init_extended(
+        QEMUIOVector *qiov,
+        void *head_buf, size_t head_len,
+        QEMUIOVector *mid_qiov, size_t mid_offset, size_t mid_len,
+        void *tail_buf, size_t tail_len);
+void qemu_iovec_init_slice(QEMUIOVector *qiov, QEMUIOVector *source,
+                           size_t offset, size_t len);
 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
 void qemu_iovec_concat(QEMUIOVector *dst,
                        QEMUIOVector *src, size_t soffset, size_t sbytes);
diff --git a/util/iov.c b/util/iov.c
index XXXXXXX..XXXXXXX 100644
--- a/util/iov.c
+++ b/util/iov.c
@@ -XXX,XX +XXX,XX @@ void qemu_iovec_concat(QEMUIOVector *dst,
     qemu_iovec_concat_iov(dst, src->iov, src->niov, soffset, sbytes);
 }
 
+/*
+ * qiov_find_iov
+ *
+ * Return pointer to iovec structure, where byte at @offset in original vector
+ * @iov exactly is.
+ * Set @remaining_offset to be offset inside that iovec to the same byte.
+ */
+static struct iovec *iov_skip_offset(struct iovec *iov, size_t offset,
+                                     size_t *remaining_offset)
+{
+    while (offset > 0 && offset >= iov->iov_len) {
+        offset -= iov->iov_len;
+        iov++;
+    }
+    *remaining_offset = offset;
+
+    return iov;
+}
+
+/*
+ * qiov_slice
+ *
+ * Find subarray of iovec's, containing requested range. @head would
+ * be offset in first iov (returned by the function), @tail would be
+ * count of extra bytes in last iovec (returned iov + @niov - 1).
+ */
+static struct iovec *qiov_slice(QEMUIOVector *qiov,
+                                size_t offset, size_t len,
+                                size_t *head, size_t *tail, int *niov)
+{
+    struct iovec *iov, *end_iov;
+
+    assert(offset + len <= qiov->size);
+
+    iov = iov_skip_offset(qiov->iov, offset, head);
+    end_iov = iov_skip_offset(iov, *head + len, tail);
+
+    if (*tail > 0) {
+        assert(*tail < end_iov->iov_len);
+        *tail = end_iov->iov_len - *tail;
+        end_iov++;
+    }
+
+    *niov = end_iov - iov;
+
+    return iov;
+}
+
+/*
+ * Compile new iovec, combining @head_buf buffer, sub-qiov of @mid_qiov,
+ * and @tail_buf buffer into new qiov.
+ */
+void qemu_iovec_init_extended(
+        QEMUIOVector *qiov,
+        void *head_buf, size_t head_len,
+        QEMUIOVector *mid_qiov, size_t mid_offset, size_t mid_len,
+        void *tail_buf, size_t tail_len)
+{
+    size_t mid_head, mid_tail;
+    int total_niov, mid_niov = 0;
+    struct iovec *p, *mid_iov;
+
+    if (mid_len) {
+        mid_iov = qiov_slice(mid_qiov, mid_offset, mid_len,
+                             &mid_head, &mid_tail, &mid_niov);
+    }
+
+    total_niov = !!head_len + mid_niov + !!tail_len;
+    if (total_niov == 1) {
+        qemu_iovec_init_buf(qiov, NULL, 0);
+        p = &qiov->local_iov;
+    } else {
+        qiov->niov = qiov->nalloc = total_niov;
+        qiov->size = head_len + mid_len + tail_len;
+        p = qiov->iov = g_new(struct iovec, qiov->niov);
+    }
+
+    if (head_len) {
+        p->iov_base = head_buf;
+        p->iov_len = head_len;
+        p++;
+    }
+
+    if (mid_len) {
+        memcpy(p, mid_iov, mid_niov * sizeof(*p));
+        p[0].iov_base = (uint8_t *)p[0].iov_base + mid_head;
+        p[0].iov_len -= mid_head;
+        p[mid_niov - 1].iov_len -= mid_tail;
+        p += mid_niov;
+    }
+
+    if (tail_len) {
+        p->iov_base = tail_buf;
+        p->iov_len = tail_len;
+    }
+}
+
 /*
  * Check if the contents of the iovecs are all zero
  */
@@ -XXX,XX +XXX,XX @@ bool qemu_iovec_is_zero(QEMUIOVector *qiov)
     return true;
 }
 
+void qemu_iovec_init_slice(QEMUIOVector *qiov, QEMUIOVector *source,
+                           size_t offset, size_t len)
+{
+    qemu_iovec_init_extended(qiov, NULL, 0, source, offset, len, NULL, 0);
+}
+
 void qemu_iovec_destroy(QEMUIOVector *qiov)
 {
-    assert(qiov->nalloc != -1);
+    if (qiov->nalloc != -1) {
+        g_free(qiov->iov);
+    }
 
-    qemu_iovec_reset(qiov);
-    g_free(qiov->iov);
-    qiov->nalloc = 0;
-    qiov->iov = NULL;
+    memset(qiov, 0, sizeof(*qiov));
 }
 
 void qemu_iovec_reset(QEMUIOVector *qiov)
-- 
2.21.0

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

We'll need to check a part of qiov soon, so implement it now.

Optimization with align down to 4 * sizeof(long) is dropped due to:
1. It is strange: it aligns length of the buffer, but where is a
   guarantee that buffer pointer is aligned itself?
2. buffer_is_zero() is a better place for optimizations and it has
   them.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-3-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-3-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/iov.h |  2 +-
 block/io.c         |  2 +-
 util/iov.c         | 31 +++++++++++++++++++------------
 3 files changed, 21 insertions(+), 14 deletions(-)

diff --git a/include/qemu/iov.h b/include/qemu/iov.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/iov.h
+++ b/include/qemu/iov.h
@@ -XXX,XX +XXX,XX @@ void qemu_iovec_concat(QEMUIOVector *dst,
 size_t qemu_iovec_concat_iov(QEMUIOVector *dst,
                              struct iovec *src_iov, unsigned int src_cnt,
                              size_t soffset, size_t sbytes);
-bool qemu_iovec_is_zero(QEMUIOVector *qiov);
+bool qemu_iovec_is_zero(QEMUIOVector *qiov, size_t qiov_offeset, size_t bytes);
 void qemu_iovec_destroy(QEMUIOVector *qiov);
 void qemu_iovec_reset(QEMUIOVector *qiov);
 size_t qemu_iovec_to_buf(QEMUIOVector *qiov, size_t offset,
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
 
     if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
         !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_pwrite_zeroes &&
-        qemu_iovec_is_zero(qiov)) {
+        qemu_iovec_is_zero(qiov, 0, qiov->size)) {
         flags |= BDRV_REQ_ZERO_WRITE;
         if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
             flags |= BDRV_REQ_MAY_UNMAP;
diff --git a/util/iov.c b/util/iov.c
index XXXXXXX..XXXXXXX 100644
--- a/util/iov.c
+++ b/util/iov.c
@@ -XXX,XX +XXX,XX @@ void qemu_iovec_init_extended(
 }
 
 /*
- * Check if the contents of the iovecs are all zero
+ * Check if the contents of subrange of qiov data is all zeroes.
  */
-bool qemu_iovec_is_zero(QEMUIOVector *qiov)
+bool qemu_iovec_is_zero(QEMUIOVector *qiov, size_t offset, size_t bytes)
 {
-    int i;
-    for (i = 0; i < qiov->niov; i++) {
-        size_t offs = QEMU_ALIGN_DOWN(qiov->iov[i].iov_len, 4 * sizeof(long));
-        uint8_t *ptr = qiov->iov[i].iov_base;
-        if (offs && !buffer_is_zero(qiov->iov[i].iov_base, offs)) {
+    struct iovec *iov;
+    size_t current_offset;
+
+    assert(offset + bytes <= qiov->size);
+
+    iov = iov_skip_offset(qiov->iov, offset, &current_offset);
+
+    while (bytes) {
+        uint8_t *base = (uint8_t *)iov->iov_base + current_offset;
+        size_t len = MIN(iov->iov_len - current_offset, bytes);
+
+        if (!buffer_is_zero(base, len)) {
             return false;
         }
-        for (; offs < qiov->iov[i].iov_len; offs++) {
-            if (ptr[offs]) {
-                return false;
-            }
-        }
+
+        current_offset = 0;
+        bytes -= len;
+        iov++;
     }
+
     return true;
 }
 
-- 
2.21.0

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

We have similar padding code in bdrv_co_pwritev,
bdrv_co_do_pwrite_zeroes and bdrv_co_preadv. Let's combine and unify
it.

[Squashed in Vladimir's qemu-iotests 077 fix
--Stefan]

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-4-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-4-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 365 +++++++++++++++++++++++++++++------------------------
 1 file changed, 200 insertions(+), 165 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ out:
 }
 
 /*
- * Handle a read request in coroutine context
+ * Request padding
+ *
+ *  |<---- align ----->|                     |<----- align ---->|
+ *  |<- head ->|<------------- bytes ------------->|<-- tail -->|
+ *  |          |       |                     |     |            |
+ * -*----------$-------*-------- ... --------*-----$------------*---
+ *  |          |       |                     |     |            |
+ *  |          offset  |                     |     end          |
+ *  ALIGN_DOWN(offset) ALIGN_UP(offset)      ALIGN_DOWN(end)   ALIGN_UP(end)
+ *  [buf   ... )                             [tail_buf          )
+ *
+ * @buf is an aligned allocation needed to store @head and @tail paddings. @head
+ * is placed at the beginning of @buf and @tail at the @end.
+ *
+ * @tail_buf is a pointer to sub-buffer, corresponding to align-sized chunk
+ * around tail, if tail exists.
+ *
+ * @merge_reads is true for small requests,
+ * if @buf_len == @head + bytes + @tail. In this case it is possible that both
+ * head and tail exist but @buf_len == align and @tail_buf == @buf.
  */
+typedef struct BdrvRequestPadding {
+    uint8_t *buf;
+    size_t buf_len;
+    uint8_t *tail_buf;
+    size_t head;
+    size_t tail;
+    bool merge_reads;
+    QEMUIOVector local_qiov;
+} BdrvRequestPadding;
+
+static bool bdrv_init_padding(BlockDriverState *bs,
+                              int64_t offset, int64_t bytes,
+                              BdrvRequestPadding *pad)
+{
+    uint64_t align = bs->bl.request_alignment;
+    size_t sum;
+
+    memset(pad, 0, sizeof(*pad));
+
+    pad->head = offset & (align - 1);
+    pad->tail = ((offset + bytes) & (align - 1));
+    if (pad->tail) {
+        pad->tail = align - pad->tail;
+    }
+
+    if ((!pad->head && !pad->tail) || !bytes) {
+        return false;
+    }
+
+    sum = pad->head + bytes + pad->tail;
+    pad->buf_len = (sum > align && pad->head && pad->tail) ? 2 * align : align;
+    pad->buf = qemu_blockalign(bs, pad->buf_len);
+    pad->merge_reads = sum == pad->buf_len;
+    if (pad->tail) {
+        pad->tail_buf = pad->buf + pad->buf_len - align;
+    }
+
+    return true;
+}
+
+static int bdrv_padding_rmw_read(BdrvChild *child,
+                                 BdrvTrackedRequest *req,
+                                 BdrvRequestPadding *pad,
+                                 bool zero_middle)
+{
+    QEMUIOVector local_qiov;
+    BlockDriverState *bs = child->bs;
+    uint64_t align = bs->bl.request_alignment;
+    int ret;
+
+    assert(req->serialising && pad->buf);
+
+    if (pad->head || pad->merge_reads) {
+        uint64_t bytes = pad->merge_reads ? pad->buf_len : align;
+
+        qemu_iovec_init_buf(&local_qiov, pad->buf, bytes);
+
+        if (pad->head) {
+            bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
+        }
+        if (pad->merge_reads && pad->tail) {
+            bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
+        }
+        ret = bdrv_aligned_preadv(child, req, req->overlap_offset, bytes,
+                                  align, &local_qiov, 0);
+        if (ret < 0) {
+            return ret;
+        }
+        if (pad->head) {
+            bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
+        }
+        if (pad->merge_reads && pad->tail) {
+            bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
+        }
+
+        if (pad->merge_reads) {
+            goto zero_mem;
+        }
+    }
+
+    if (pad->tail) {
+        qemu_iovec_init_buf(&local_qiov, pad->tail_buf, align);
+
+        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
+        ret = bdrv_aligned_preadv(
+                child, req,
+                req->overlap_offset + req->overlap_bytes - align,
+                align, align, &local_qiov, 0);
+        if (ret < 0) {
+            return ret;
+        }
+        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
+    }
+
+zero_mem:
+    if (zero_middle) {
+        memset(pad->buf + pad->head, 0, pad->buf_len - pad->head - pad->tail);
+    }
+
+    return 0;
+}
+
+static void bdrv_padding_destroy(BdrvRequestPadding *pad)
+{
+    if (pad->buf) {
+        qemu_vfree(pad->buf);
+        qemu_iovec_destroy(&pad->local_qiov);
+    }
+}
+
+/*
+ * bdrv_pad_request
+ *
+ * Exchange request parameters with padded request if needed. Don't include RMW
+ * read of padding, bdrv_padding_rmw_read() should be called separately if
+ * needed.
+ *
+ * All parameters except @bs are in-out: they represent original request at
+ * function call and padded (if padding needed) at function finish.
+ *
+ * Function always succeeds.
+ */
+static bool bdrv_pad_request(BlockDriverState *bs, QEMUIOVector **qiov,
+                             int64_t *offset, unsigned int *bytes,
+                             BdrvRequestPadding *pad)
+{
+    if (!bdrv_init_padding(bs, *offset, *bytes, pad)) {
+        return false;
+    }
+
+    qemu_iovec_init_extended(&pad->local_qiov, pad->buf, pad->head,
+                             *qiov, 0, *bytes,
+                             pad->buf + pad->buf_len - pad->tail, pad->tail);
+    *bytes += pad->head + pad->tail;
+    *offset -= pad->head;
+    *qiov = &pad->local_qiov;
+
+    return true;
+}
+
 int coroutine_fn bdrv_co_preadv(BdrvChild *child,
     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
     BdrvRequestFlags flags)
 {
     BlockDriverState *bs = child->bs;
-    BlockDriver *drv = bs->drv;
     BdrvTrackedRequest req;
-
-    uint64_t align = bs->bl.request_alignment;
-    uint8_t *head_buf = NULL;
-    uint8_t *tail_buf = NULL;
-    QEMUIOVector local_qiov;
-    bool use_local_qiov = false;
+    BdrvRequestPadding pad;
     int ret;
 
-    trace_bdrv_co_preadv(child->bs, offset, bytes, flags);
-
-    if (!drv) {
-        return -ENOMEDIUM;
-    }
+    trace_bdrv_co_preadv(bs, offset, bytes, flags);
 
     ret = bdrv_check_byte_request(bs, offset, bytes);
     if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_preadv(BdrvChild *child,
         flags |= BDRV_REQ_COPY_ON_READ;
     }
 
-    /* Align read if necessary by padding qiov */
-    if (offset & (align - 1)) {
-        head_buf = qemu_blockalign(bs, align);
-        qemu_iovec_init(&local_qiov, qiov->niov + 2);
-        qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
-        qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
-        use_local_qiov = true;
-
-        bytes += offset & (align - 1);
-        offset = offset & ~(align - 1);
-    }
-
-    if ((offset + bytes) & (align - 1)) {
-        if (!use_local_qiov) {
-            qemu_iovec_init(&local_qiov, qiov->niov + 1);
-            qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
-            use_local_qiov = true;
-        }
-        tail_buf = qemu_blockalign(bs, align);
-        qemu_iovec_add(&local_qiov, tail_buf,
-                       align - ((offset + bytes) & (align - 1)));
-
-        bytes = ROUND_UP(bytes, align);
-    }
+    bdrv_pad_request(bs, &qiov, &offset, &bytes, &pad);
 
     tracked_request_begin(&req, bs, offset, bytes, BDRV_TRACKED_READ);
-    ret = bdrv_aligned_preadv(child, &req, offset, bytes, align,
-                              use_local_qiov ? &local_qiov : qiov,
-                              flags);
+    ret = bdrv_aligned_preadv(child, &req, offset, bytes,
+                              bs->bl.request_alignment,
+                              qiov, flags);
     tracked_request_end(&req);
     bdrv_dec_in_flight(bs);
 
-    if (use_local_qiov) {
-        qemu_iovec_destroy(&local_qiov);
-        qemu_vfree(head_buf);
-        qemu_vfree(tail_buf);
-    }
+    bdrv_padding_destroy(&pad);
 
     return ret;
 }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
                                                 BdrvTrackedRequest *req)
 {
     BlockDriverState *bs = child->bs;
-    uint8_t *buf = NULL;
     QEMUIOVector local_qiov;
     uint64_t align = bs->bl.request_alignment;
-    unsigned int head_padding_bytes, tail_padding_bytes;
     int ret = 0;
+    bool padding;
+    BdrvRequestPadding pad;
 
-    head_padding_bytes = offset & (align - 1);
-    tail_padding_bytes = (align - (offset + bytes)) & (align - 1);
-
-
-    assert(flags & BDRV_REQ_ZERO_WRITE);
-    if (head_padding_bytes || tail_padding_bytes) {
-        buf = qemu_blockalign(bs, align);
-        qemu_iovec_init_buf(&local_qiov, buf, align);
-    }
-    if (head_padding_bytes) {
-        uint64_t zero_bytes = MIN(bytes, align - head_padding_bytes);
-
-        /* RMW the unaligned part before head. */
+    padding = bdrv_init_padding(bs, offset, bytes, &pad);
+    if (padding) {
         mark_request_serialising(req, align);
         wait_serialising_requests(req);
-        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
-        ret = bdrv_aligned_preadv(child, req, offset & ~(align - 1), align,
-                                  align, &local_qiov, 0);
-        if (ret < 0) {
-            goto fail;
-        }
-        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
 
-        memset(buf + head_padding_bytes, 0, zero_bytes);
-        ret = bdrv_aligned_pwritev(child, req, offset & ~(align - 1), align,
-                                   align, &local_qiov,
-                                   flags & ~BDRV_REQ_ZERO_WRITE);
-        if (ret < 0) {
-            goto fail;
+        bdrv_padding_rmw_read(child, req, &pad, true);
+
+        if (pad.head || pad.merge_reads) {
+            int64_t aligned_offset = offset & ~(align - 1);
+            int64_t write_bytes = pad.merge_reads ? pad.buf_len : align;
+
+            qemu_iovec_init_buf(&local_qiov, pad.buf, write_bytes);
+            ret = bdrv_aligned_pwritev(child, req, aligned_offset, write_bytes,
+                                       align, &local_qiov,
+                                       flags & ~BDRV_REQ_ZERO_WRITE);
+            if (ret < 0 || pad.merge_reads) {
+                /* Error or all work is done */
+                goto out;
+            }
+            offset += write_bytes - pad.head;
+            bytes -= write_bytes - pad.head;
         }
-        offset += zero_bytes;
-        bytes -= zero_bytes;
     }
 
     assert(!bytes || (offset & (align - 1)) == 0);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
         ret = bdrv_aligned_pwritev(child, req, offset, aligned_bytes, align,
                                    NULL, flags);
         if (ret < 0) {
-            goto fail;
+            goto out;
         }
         bytes -= aligned_bytes;
         offset += aligned_bytes;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
 
     assert(!bytes || (offset & (align - 1)) == 0);
     if (bytes) {
-        assert(align == tail_padding_bytes + bytes);
-        /* RMW the unaligned part after tail. */
-        mark_request_serialising(req, align);
-        wait_serialising_requests(req);
-        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
-        ret = bdrv_aligned_preadv(child, req, offset, align,
-                                  align, &local_qiov, 0);
-        if (ret < 0) {
-            goto fail;
-        }
-        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
+        assert(align == pad.tail + bytes);
 
-        memset(buf, 0, bytes);
+        qemu_iovec_init_buf(&local_qiov, pad.tail_buf, align);
         ret = bdrv_aligned_pwritev(child, req, offset, align, align,
                                    &local_qiov, flags & ~BDRV_REQ_ZERO_WRITE);
     }
-fail:
-    qemu_vfree(buf);
+
+out:
+    bdrv_padding_destroy(&pad);
+
     return ret;
-
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
     BlockDriverState *bs = child->bs;
     BdrvTrackedRequest req;
     uint64_t align = bs->bl.request_alignment;
-    uint8_t *head_buf = NULL;
-    uint8_t *tail_buf = NULL;
-    QEMUIOVector local_qiov;
-    bool use_local_qiov = false;
+    BdrvRequestPadding pad;
     int ret;
 
     trace_bdrv_co_pwritev(child->bs, offset, bytes, flags);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
         goto out;
     }
 
-    if (offset & (align - 1)) {
-        QEMUIOVector head_qiov;
-
+    if (bdrv_pad_request(bs, &qiov, &offset, &bytes, &pad)) {
         mark_request_serialising(&req, align);
         wait_serialising_requests(&req);
-
-        head_buf = qemu_blockalign(bs, align);
-        qemu_iovec_init_buf(&head_qiov, head_buf, align);
-
-        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
-        ret = bdrv_aligned_preadv(child, &req, offset & ~(align - 1), align,
-                                  align, &head_qiov, 0);
-        if (ret < 0) {
-            goto fail;
-        }
-        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
-
-        qemu_iovec_init(&local_qiov, qiov->niov + 2);
-        qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
-        qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
-        use_local_qiov = true;
-
-        bytes += offset & (align - 1);
-        offset = offset & ~(align - 1);
-
-        /* We have read the tail already if the request is smaller
-         * than one aligned block.
-         */
-        if (bytes < align) {
-            qemu_iovec_add(&local_qiov, head_buf + bytes, align - bytes);
-            bytes = align;
-        }
-    }
-
-    if ((offset + bytes) & (align - 1)) {
-        QEMUIOVector tail_qiov;
-        size_t tail_bytes;
-        bool waited;
-
-        mark_request_serialising(&req, align);
-        waited = wait_serialising_requests(&req);
-        assert(!waited || !use_local_qiov);
-
-        tail_buf = qemu_blockalign(bs, align);
-        qemu_iovec_init_buf(&tail_qiov, tail_buf, align);
-
-        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
-        ret = bdrv_aligned_preadv(child, &req, (offset + bytes) & ~(align - 1),
-                                  align, align, &tail_qiov, 0);
-        if (ret < 0) {
-            goto fail;
-        }
-        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
-
-        if (!use_local_qiov) {
-            qemu_iovec_init(&local_qiov, qiov->niov + 1);
-            qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
-            use_local_qiov = true;
-        }
-
-        tail_bytes = (offset + bytes) & (align - 1);
-        qemu_iovec_add(&local_qiov, tail_buf + tail_bytes, align - tail_bytes);
-
-        bytes = ROUND_UP(bytes, align);
+        bdrv_padding_rmw_read(child, &req, &pad, false);
     }
 
     ret = bdrv_aligned_pwritev(child, &req, offset, bytes, align,
-                               use_local_qiov ? &local_qiov : qiov,
-                               flags);
+                               qiov, flags);
 
-fail:
+    bdrv_padding_destroy(&pad);
 
-    if (use_local_qiov) {
-        qemu_iovec_destroy(&local_qiov);
-    }
-    qemu_vfree(head_buf);
-    qemu_vfree(tail_buf);
 out:
     tracked_request_end(&req);
     bdrv_dec_in_flight(bs);
+
     return ret;
 }
 
-- 
2.21.0

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

Add handlers supporting qiov_offset parameter:
    bdrv_co_preadv_part
    bdrv_co_pwritev_part
    bdrv_co_pwritev_compressed_part
This is used to reduce need of defining local_qiovs and hd_qiovs in all
corners of block layer code. The following patches will increase usage
of this new API part by part.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-5-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-5-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/block/block_int.h | 15 ++++++
 block/backup.c            |  2 +-
 block/io.c                | 96 +++++++++++++++++++++++++++++++--------
 qemu-img.c                |  4 +-
 4 files changed, 95 insertions(+), 22 deletions(-)

diff --git a/include/block/block_int.h b/include/block/block_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
      */
     int coroutine_fn (*bdrv_co_preadv)(BlockDriverState *bs,
         uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags);
+    int coroutine_fn (*bdrv_co_preadv_part)(BlockDriverState *bs,
+        uint64_t offset, uint64_t bytes,
+        QEMUIOVector *qiov, size_t qiov_offset, int flags);
     int coroutine_fn (*bdrv_co_writev)(BlockDriverState *bs,
         int64_t sector_num, int nb_sectors, QEMUIOVector *qiov, int flags);
     /**
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
      */
     int coroutine_fn (*bdrv_co_pwritev)(BlockDriverState *bs,
         uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags);
+    int coroutine_fn (*bdrv_co_pwritev_part)(BlockDriverState *bs,
+        uint64_t offset, uint64_t bytes,
+        QEMUIOVector *qiov, size_t qiov_offset, int flags);
 
     /*
      * Efficiently zero a region of the disk image.  Typically an image format
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
 
     int coroutine_fn (*bdrv_co_pwritev_compressed)(BlockDriverState *bs,
         uint64_t offset, uint64_t bytes, QEMUIOVector *qiov);
+    int coroutine_fn (*bdrv_co_pwritev_compressed_part)(BlockDriverState *bs,
+        uint64_t offset, uint64_t bytes, QEMUIOVector *qiov,
+        size_t qiov_offset);
 
     int (*bdrv_snapshot_create)(BlockDriverState *bs,
                                 QEMUSnapshotInfo *sn_info);
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
     const char *const *strong_runtime_opts;
 };
 
+static inline bool block_driver_can_compress(BlockDriver *drv)
+{
+    return drv->bdrv_co_pwritev_compressed ||
+           drv->bdrv_co_pwritev_compressed_part;
+}
+
 typedef struct BlockLimits {
     /* Alignment requirement, in bytes, for offset/length of I/O
      * requests. Must be a power of 2 less than INT_MAX; defaults to
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 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
         return NULL;
     }
 
-    if (compress && target->drv->bdrv_co_pwritev_compressed == NULL) {
+    if (compress && !block_driver_can_compress(target->drv)) {
         error_setg(errp, "Compression is not supported for this drive %s",
                    bdrv_get_device_name(target));
         return NULL;
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ void bdrv_refresh_limits(BlockDriverState *bs, Error **errp)
 
     /* Default alignment based on whether driver has byte interface */
     bs->bl.request_alignment = (drv->bdrv_co_preadv ||
-                                drv->bdrv_aio_preadv) ? 1 : 512;
+                                drv->bdrv_aio_preadv ||
+                                drv->bdrv_co_preadv_part) ? 1 : 512;
 
     /* Take some limits from the children as a default */
     if (bs->file) {
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_io_em_complete(void *opaque, int ret)
 
 static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
                                            uint64_t offset, uint64_t bytes,
-                                           QEMUIOVector *qiov, int flags)
+                                           QEMUIOVector *qiov,
+                                           size_t qiov_offset, int flags)
 {
     BlockDriver *drv = bs->drv;
     int64_t sector_num;
     unsigned int nb_sectors;
+    QEMUIOVector local_qiov;
+    int ret;
 
     assert(!(flags & ~BDRV_REQ_MASK));
     assert(!(flags & BDRV_REQ_NO_FALLBACK));
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
         return -ENOMEDIUM;
     }
 
+    if (drv->bdrv_co_preadv_part) {
+        return drv->bdrv_co_preadv_part(bs, offset, bytes, qiov, qiov_offset,
+                                        flags);
+    }
+
+    if (qiov_offset > 0 || bytes != qiov->size) {
+        qemu_iovec_init_slice(&local_qiov, qiov, qiov_offset, bytes);
+        qiov = &local_qiov;
+    }
+
     if (drv->bdrv_co_preadv) {
-        return drv->bdrv_co_preadv(bs, offset, bytes, qiov, flags);
+        ret = drv->bdrv_co_preadv(bs, offset, bytes, qiov, flags);
+        goto out;
     }
 
     if (drv->bdrv_aio_preadv) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
         acb = drv->bdrv_aio_preadv(bs, offset, bytes, qiov, flags,
                                    bdrv_co_io_em_complete, &co);
         if (acb == NULL) {
-            return -EIO;
+            ret = -EIO;
+            goto out;
         } else {
             qemu_coroutine_yield();
-            return co.ret;
+            ret = co.ret;
+            goto out;
         }
     }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
     assert(bytes <= BDRV_REQUEST_MAX_BYTES);
     assert(drv->bdrv_co_readv);
 
-    return drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
+    ret = drv->bdrv_co_readv(bs, sector_num, nb_sectors, qiov);
+
+out:
+    if (qiov == &local_qiov) {
+        qemu_iovec_destroy(&local_qiov);
+    }
+
+    return ret;
 }
 
 static int coroutine_fn bdrv_driver_pwritev(BlockDriverState *bs,
                                             uint64_t offset, uint64_t bytes,
-                                            QEMUIOVector *qiov, int flags)
+                                            QEMUIOVector *qiov,
+                                            size_t qiov_offset, int flags)
 {
     BlockDriver *drv = bs->drv;
     int64_t sector_num;
     unsigned int nb_sectors;
+    QEMUIOVector local_qiov;
     int ret;
 
     assert(!(flags & ~BDRV_REQ_MASK));
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_driver_pwritev(BlockDriverState *bs,
         return -ENOMEDIUM;
     }
 
+    if (drv->bdrv_co_pwritev_part) {
+        ret = drv->bdrv_co_pwritev_part(bs, offset, bytes, qiov, qiov_offset,
+                                        flags & bs->supported_write_flags);
+        flags &= ~bs->supported_write_flags;
+        goto emulate_flags;
+    }
+
+    if (qiov_offset > 0 || bytes != qiov->size) {
+        qemu_iovec_init_slice(&local_qiov, qiov, qiov_offset, bytes);
+        qiov = &local_qiov;
+    }
+
     if (drv->bdrv_co_pwritev) {
         ret = drv->bdrv_co_pwritev(bs, offset, bytes, qiov,
                                    flags & bs->supported_write_flags);
@@ -XXX,XX +XXX,XX @@ emulate_flags:
         ret = bdrv_co_flush(bs);
     }
 
+    if (qiov == &local_qiov) {
+        qemu_iovec_destroy(&local_qiov);
+    }
+
     return ret;
 }
 
 static int coroutine_fn
 bdrv_driver_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
-                               uint64_t bytes, QEMUIOVector *qiov)
+                               uint64_t bytes, QEMUIOVector *qiov,
+                               size_t qiov_offset)
 {
     BlockDriver *drv = bs->drv;
+    QEMUIOVector local_qiov;
+    int ret;
 
     if (!drv) {
         return -ENOMEDIUM;
     }
 
-    if (!drv->bdrv_co_pwritev_compressed) {
+    if (!block_driver_can_compress(drv)) {
         return -ENOTSUP;
     }
 
-    return drv->bdrv_co_pwritev_compressed(bs, offset, bytes, qiov);
+    if (drv->bdrv_co_pwritev_compressed_part) {
+        return drv->bdrv_co_pwritev_compressed_part(bs, offset, bytes,
+                                                    qiov, qiov_offset);
+    }
+
+    if (qiov_offset == 0) {
+        return drv->bdrv_co_pwritev_compressed(bs, offset, bytes, qiov);
+    }
+
+    qemu_iovec_init_slice(&local_qiov, qiov, qiov_offset, bytes);
+    ret = drv->bdrv_co_pwritev_compressed(bs, offset, bytes, &local_qiov);
+    qemu_iovec_destroy(&local_qiov);
+
+    return ret;
 }
 
 static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
             qemu_iovec_init_buf(&local_qiov, bounce_buffer, pnum);
 
             ret = bdrv_driver_preadv(bs, cluster_offset, pnum,
-                                     &local_qiov, 0);
+                                     &local_qiov, 0, 0);
             if (ret < 0) {
                 goto err;
             }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
                  * necessary to flush even in cache=writethrough mode.
                  */
                 ret = bdrv_driver_pwritev(bs, cluster_offset, pnum,
-                                          &local_qiov,
+                                          &local_qiov, 0,
                                           BDRV_REQ_WRITE_UNCHANGED);
             }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
             qemu_iovec_init(&local_qiov, qiov->niov);
             qemu_iovec_concat(&local_qiov, qiov, progress, pnum - skip_bytes);
             ret = bdrv_driver_preadv(bs, offset + progress, local_qiov.size,
-                                     &local_qiov, 0);
+                                     &local_qiov, 0, 0);
             qemu_iovec_destroy(&local_qiov);
             if (ret < 0) {
                 goto err;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
 
     max_bytes = ROUND_UP(MAX(0, total_bytes - offset), align);
     if (bytes <= max_bytes && bytes <= max_transfer) {
-        ret = bdrv_driver_preadv(bs, offset, bytes, qiov, 0);
+        ret = bdrv_driver_preadv(bs, offset, bytes, qiov, 0, 0);
         goto out;
     }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
             qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);
 
             ret = bdrv_driver_preadv(bs, offset + bytes - bytes_remaining,
-                                     num, &local_qiov, 0);
+                                     num, &local_qiov, 0, 0);
             max_bytes -= num;
             qemu_iovec_destroy(&local_qiov);
         } else {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
             }
             qemu_iovec_init_buf(&qiov, buf, num);
 
-            ret = bdrv_driver_pwritev(bs, offset, num, &qiov, write_flags);
+            ret = bdrv_driver_pwritev(bs, offset, num, &qiov, 0, write_flags);
 
             /* Keep bounce buffer around if it is big enough for all
              * all future requests.
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
         bdrv_debug_event(bs, BLKDBG_PWRITEV_ZERO);
         ret = bdrv_co_do_pwrite_zeroes(bs, offset, bytes, flags);
     } else if (flags & BDRV_REQ_WRITE_COMPRESSED) {
-        ret = bdrv_driver_pwritev_compressed(bs, offset, bytes, qiov);
+        ret = bdrv_driver_pwritev_compressed(bs, offset, bytes, qiov, 0);
     } else if (bytes <= max_transfer) {
         bdrv_debug_event(bs, BLKDBG_PWRITEV);
-        ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, flags);
+        ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, 0, flags);
     } else {
         bdrv_debug_event(bs, BLKDBG_PWRITEV);
         while (bytes_remaining) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
             qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);
 
             ret = bdrv_driver_pwritev(bs, offset + bytes - bytes_remaining,
-                                      num, &local_qiov, local_flags);
+                                      num, &local_qiov, 0, local_flags);
             qemu_iovec_destroy(&local_qiov);
             if (ret < 0) {
                 break;
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_convert(int argc, char **argv)
         const char *preallocation =
             qemu_opt_get(opts, BLOCK_OPT_PREALLOC);
 
-        if (drv && !drv->bdrv_co_pwritev_compressed) {
+        if (drv && !block_driver_can_compress(drv)) {
             error_report("Compression not supported for this file format");
             ret = -1;
             goto out;
@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
     }
     out_bs = blk_bs(s.target);
 
-    if (s.compressed && !out_bs->drv->bdrv_co_pwritev_compressed) {
+    if (s.compressed && !block_driver_can_compress(out_bs->drv)) {
         error_report("Compression not supported for this file format");
         ret = -1;
         goto out;
-- 
2.21.0

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

Use and support new API in bdrv_co_do_copy_on_readv. Note that in case
of allocated-in-top we need to shrink read size to MIN(..) by hand, as
pre-patch this was actually done implicitly by qemu_iovec_concat (and
we used local_qiov.size).

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-6-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-6-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ bdrv_driver_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
 
 static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
         int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
-        int flags)
+        size_t qiov_offset, int flags)
 {
     BlockDriverState *bs = child->bs;
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
     void *bounce_buffer;
 
     BlockDriver *drv = bs->drv;
-    QEMUIOVector local_qiov;
     int64_t cluster_offset;
     int64_t cluster_bytes;
     size_t skip_bytes;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
         assert(skip_bytes < pnum);
 
         if (ret <= 0) {
+            QEMUIOVector local_qiov;
+
             /* Must copy-on-read; use the bounce buffer */
             pnum = MIN(pnum, MAX_BOUNCE_BUFFER);
             qemu_iovec_init_buf(&local_qiov, bounce_buffer, pnum);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
             }
 
             if (!(flags & BDRV_REQ_PREFETCH)) {
-                qemu_iovec_from_buf(qiov, progress, bounce_buffer + skip_bytes,
+                qemu_iovec_from_buf(qiov, qiov_offset + progress,
+                                    bounce_buffer + skip_bytes,
                                     pnum - skip_bytes);
             }
         } else if (!(flags & BDRV_REQ_PREFETCH)) {
             /* Read directly into the destination */
-            qemu_iovec_init(&local_qiov, qiov->niov);
-            qemu_iovec_concat(&local_qiov, qiov, progress, pnum - skip_bytes);
-            ret = bdrv_driver_preadv(bs, offset + progress, local_qiov.size,
-                                     &local_qiov, 0, 0);
-            qemu_iovec_destroy(&local_qiov);
+            ret = bdrv_driver_preadv(bs, offset + progress,
+                                     MIN(pnum - skip_bytes, bytes - progress),
+                                     qiov, qiov_offset + progress, 0);
             if (ret < 0) {
                 goto err;
             }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
         }
 
         if (!ret || pnum != bytes) {
-            ret = bdrv_co_do_copy_on_readv(child, offset, bytes, qiov, flags);
+            ret = bdrv_co_do_copy_on_readv(child, offset, bytes, qiov, 0, flags);
             goto out;
         } else if (flags & BDRV_REQ_PREFETCH) {
             goto out;
-- 
2.21.0

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

Allocate bounce_buffer only if it is really needed. Also, sub-optimize
allocation size (why not?).

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-7-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-7-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 21 ++++++++++++---------
 1 file changed, 12 insertions(+), 9 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
      * modifying the image file.  This is critical for zero-copy guest I/O
      * where anything might happen inside guest memory.
      */
-    void *bounce_buffer;
+    void *bounce_buffer = NULL;
 
     BlockDriver *drv = bs->drv;
     int64_t cluster_offset;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
     trace_bdrv_co_do_copy_on_readv(bs, offset, bytes,
                                    cluster_offset, cluster_bytes);
 
-    bounce_buffer = qemu_try_blockalign(bs,
-                                        MIN(MIN(max_transfer, cluster_bytes),
-                                            MAX_BOUNCE_BUFFER));
-    if (bounce_buffer == NULL) {
-        ret = -ENOMEM;
-        goto err;
-    }
-
     while (cluster_bytes) {
         int64_t pnum;
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_copy_on_readv(BdrvChild *child,
 
             /* Must copy-on-read; use the bounce buffer */
             pnum = MIN(pnum, MAX_BOUNCE_BUFFER);
+            if (!bounce_buffer) {
+                int64_t max_we_need = MAX(pnum, cluster_bytes - pnum);
+                int64_t max_allowed = MIN(max_transfer, MAX_BOUNCE_BUFFER);
+                int64_t bounce_buffer_len = MIN(max_we_need, max_allowed);
+
+                bounce_buffer = qemu_try_blockalign(bs, bounce_buffer_len);
+                if (!bounce_buffer) {
+                    ret = -ENOMEM;
+                    goto err;
+                }
+            }
             qemu_iovec_init_buf(&local_qiov, bounce_buffer, pnum);
 
             ret = bdrv_driver_preadv(bs, cluster_offset, pnum,
-- 
2.21.0

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

Use and support new API in bdrv_co_do_copy_on_readv.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-8-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-8-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ err:
  */
 static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
-    int64_t align, QEMUIOVector *qiov, int flags)
+    int64_t align, QEMUIOVector *qiov, size_t qiov_offset, int flags)
 {
     BlockDriverState *bs = child->bs;
     int64_t total_bytes, max_bytes;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
     assert(is_power_of_2(align));
     assert((offset & (align - 1)) == 0);
     assert((bytes & (align - 1)) == 0);
-    assert(!qiov || bytes == qiov->size);
     assert((bs->open_flags & BDRV_O_NO_IO) == 0);
     max_transfer = QEMU_ALIGN_DOWN(MIN_NON_ZERO(bs->bl.max_transfer, INT_MAX),
                                    align);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
         }
 
         if (!ret || pnum != bytes) {
-            ret = bdrv_co_do_copy_on_readv(child, offset, bytes, qiov, 0, flags);
+            ret = bdrv_co_do_copy_on_readv(child, offset, bytes,
+                                           qiov, qiov_offset, flags);
             goto out;
         } else if (flags & BDRV_REQ_PREFETCH) {
             goto out;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
 
     max_bytes = ROUND_UP(MAX(0, total_bytes - offset), align);
     if (bytes <= max_bytes && bytes <= max_transfer) {
-        ret = bdrv_driver_preadv(bs, offset, bytes, qiov, 0, 0);
+        ret = bdrv_driver_preadv(bs, offset, bytes, qiov, qiov_offset, 0);
         goto out;
     }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_preadv(BdrvChild *child,
         int num;
 
         if (max_bytes) {
-            QEMUIOVector local_qiov;
-
             num = MIN(bytes_remaining, MIN(max_bytes, max_transfer));
             assert(num);
-            qemu_iovec_init(&local_qiov, qiov->niov);
-            qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);
 
             ret = bdrv_driver_preadv(bs, offset + bytes - bytes_remaining,
-                                     num, &local_qiov, 0, 0);
+                                     num, qiov, bytes - bytes_remaining, 0);
             max_bytes -= num;
-            qemu_iovec_destroy(&local_qiov);
         } else {
             num = bytes_remaining;
             ret = qemu_iovec_memset(qiov, bytes - bytes_remaining, 0,
@@ -XXX,XX +XXX,XX @@ static int bdrv_padding_rmw_read(BdrvChild *child,
             bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
         }
         ret = bdrv_aligned_preadv(child, req, req->overlap_offset, bytes,
-                                  align, &local_qiov, 0);
+                                  align, &local_qiov, 0, 0);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ static int bdrv_padding_rmw_read(BdrvChild *child,
         ret = bdrv_aligned_preadv(
                 child, req,
                 req->overlap_offset + req->overlap_bytes - align,
-                align, align, &local_qiov, 0);
+                align, align, &local_qiov, 0, 0);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_preadv(BdrvChild *child,
     tracked_request_begin(&req, bs, offset, bytes, BDRV_TRACKED_READ);
     ret = bdrv_aligned_preadv(child, &req, offset, bytes,
                               bs->bl.request_alignment,
-                              qiov, flags);
+                              qiov, 0, flags);
     tracked_request_end(&req);
     bdrv_dec_in_flight(bs);
 
-- 
2.21.0

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

Use and support new API in bdrv_aligned_pwritev.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-9-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-9-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ bdrv_co_write_req_finish(BdrvChild *child, int64_t offset, uint64_t bytes,
  */
 static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
     BdrvTrackedRequest *req, int64_t offset, unsigned int bytes,
-    int64_t align, QEMUIOVector *qiov, int flags)
+    int64_t align, QEMUIOVector *qiov, size_t qiov_offset, int flags)
 {
     BlockDriverState *bs = child->bs;
     BlockDriver *drv = bs->drv;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
     assert(is_power_of_2(align));
     assert((offset & (align - 1)) == 0);
     assert((bytes & (align - 1)) == 0);
-    assert(!qiov || bytes == qiov->size);
+    assert(!qiov || qiov_offset + bytes <= qiov->size);
     max_transfer = QEMU_ALIGN_DOWN(MIN_NON_ZERO(bs->bl.max_transfer, INT_MAX),
                                    align);
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
 
     if (!ret && bs->detect_zeroes != BLOCKDEV_DETECT_ZEROES_OPTIONS_OFF &&
         !(flags & BDRV_REQ_ZERO_WRITE) && drv->bdrv_co_pwrite_zeroes &&
-        qemu_iovec_is_zero(qiov, 0, qiov->size)) {
+        qemu_iovec_is_zero(qiov, qiov_offset, bytes)) {
         flags |= BDRV_REQ_ZERO_WRITE;
         if (bs->detect_zeroes == BLOCKDEV_DETECT_ZEROES_OPTIONS_UNMAP) {
             flags |= BDRV_REQ_MAY_UNMAP;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
         bdrv_debug_event(bs, BLKDBG_PWRITEV_ZERO);
         ret = bdrv_co_do_pwrite_zeroes(bs, offset, bytes, flags);
     } else if (flags & BDRV_REQ_WRITE_COMPRESSED) {
-        ret = bdrv_driver_pwritev_compressed(bs, offset, bytes, qiov, 0);
+        ret = bdrv_driver_pwritev_compressed(bs, offset, bytes,
+                                             qiov, qiov_offset);
     } else if (bytes <= max_transfer) {
         bdrv_debug_event(bs, BLKDBG_PWRITEV);
-        ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, 0, flags);
+        ret = bdrv_driver_pwritev(bs, offset, bytes, qiov, qiov_offset, flags);
     } else {
         bdrv_debug_event(bs, BLKDBG_PWRITEV);
         while (bytes_remaining) {
             int num = MIN(bytes_remaining, max_transfer);
-            QEMUIOVector local_qiov;
             int local_flags = flags;
 
             assert(num);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
                  * need to flush on the last iteration */
                 local_flags &= ~BDRV_REQ_FUA;
             }
-            qemu_iovec_init(&local_qiov, qiov->niov);
-            qemu_iovec_concat(&local_qiov, qiov, bytes - bytes_remaining, num);
 
             ret = bdrv_driver_pwritev(bs, offset + bytes - bytes_remaining,
-                                      num, &local_qiov, 0, local_flags);
-            qemu_iovec_destroy(&local_qiov);
+                                      num, qiov, bytes - bytes_remaining,
+                                      local_flags);
             if (ret < 0) {
                 break;
             }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
 
             qemu_iovec_init_buf(&local_qiov, pad.buf, write_bytes);
             ret = bdrv_aligned_pwritev(child, req, aligned_offset, write_bytes,
-                                       align, &local_qiov,
+                                       align, &local_qiov, 0,
                                        flags & ~BDRV_REQ_ZERO_WRITE);
             if (ret < 0 || pad.merge_reads) {
                 /* Error or all work is done */
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
         /* Write the aligned part in the middle. */
         uint64_t aligned_bytes = bytes & ~(align - 1);
         ret = bdrv_aligned_pwritev(child, req, offset, aligned_bytes, align,
-                                   NULL, flags);
+                                   NULL, 0, flags);
         if (ret < 0) {
             goto out;
         }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
 
         qemu_iovec_init_buf(&local_qiov, pad.tail_buf, align);
         ret = bdrv_aligned_pwritev(child, req, offset, align, align,
-                                   &local_qiov, flags & ~BDRV_REQ_ZERO_WRITE);
+                                   &local_qiov, 0,
+                                   flags & ~BDRV_REQ_ZERO_WRITE);
     }
 
 out:
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
     }
 
     ret = bdrv_aligned_pwritev(child, &req, offset, bytes, align,
-                               qiov, flags);
+                               qiov, 0, flags);
 
     bdrv_padding_destroy(&pad);
 
-- 
2.21.0

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

Introduce extended variants of bdrv_co_preadv and bdrv_co_pwritev
with qiov_offset parameter.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-10-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-10-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/block/block_int.h |  6 ++++++
 block/io.c                | 29 +++++++++++++++++++++++------
 2 files changed, 29 insertions(+), 6 deletions(-)

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

Use buffer based io in encrypted case.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-11-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-11-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/qcow2.c | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 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_preadv(BlockDriverState *bs, uint64_t offset,
                 }
 
                 assert(cur_bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
-                qemu_iovec_reset(&hd_qiov);
-                qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes);
-            }
 
-            BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
-            ret = bdrv_co_preadv(s->data_file,
-                                 cluster_offset + offset_in_cluster,
-                                 cur_bytes, &hd_qiov, 0);
-            if (ret < 0) {
-                goto fail;
-            }
-            if (bs->encrypted) {
-                assert(s->crypto);
+                BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
+                ret = bdrv_co_pread(s->data_file,
+                                    cluster_offset + offset_in_cluster,
+                                    cur_bytes, cluster_data, 0);
+                if (ret < 0) {
+                    goto fail;
+                }
+
                 assert((offset & (BDRV_SECTOR_SIZE - 1)) == 0);
                 assert((cur_bytes & (BDRV_SECTOR_SIZE - 1)) == 0);
                 if (qcow2_co_decrypt(bs, cluster_offset, offset,
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
                     goto fail;
                 }
                 qemu_iovec_from_buf(qiov, bytes_done, cluster_data, cur_bytes);
+            } else {
+                BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
+                ret = bdrv_co_preadv(s->data_file,
+                                     cluster_offset + offset_in_cluster,
+                                     cur_bytes, &hd_qiov, 0);
+                if (ret < 0) {
+                    goto fail;
+                }
             }
             break;
 
-- 
2.21.0

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

Implement and use new interface to get rid of hd_qiov.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-12-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-12-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/qcow2-cluster.c |  5 +++--
 block/qcow2.c         | 49 +++++++++++++++++++------------------------
 2 files changed, 25 insertions(+), 29 deletions(-)

diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn do_perform_cow_read(BlockDriverState *bs,
      * interface.  This avoids double I/O throttling and request tracking,
      * which can lead to deadlock when block layer copy-on-read is enabled.
      */
-    ret = bs->drv->bdrv_co_preadv(bs, src_cluster_offset + offset_in_cluster,
-                                  qiov->size, qiov, 0);
+    ret = bs->drv->bdrv_co_preadv_part(bs,
+                                       src_cluster_offset + offset_in_cluster,
+                                       qiov->size, qiov, 0, 0);
     if (ret < 0) {
         return ret;
     }
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
                            uint64_t file_cluster_offset,
                            uint64_t offset,
                            uint64_t bytes,
-                           QEMUIOVector *qiov);
+                           QEMUIOVector *qiov,
+                           size_t qiov_offset);
 
 static int qcow2_probe(const uint8_t *buf, int buf_size, const char *filename)
 {
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
-static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
-                                        uint64_t bytes, QEMUIOVector *qiov,
-                                        int flags)
+static coroutine_fn int qcow2_co_preadv_part(BlockDriverState *bs,
+                                             uint64_t offset, uint64_t bytes,
+                                             QEMUIOVector *qiov,
+                                             size_t qiov_offset, int flags)
 {
     BDRVQcow2State *s = bs->opaque;
     int offset_in_cluster;
     int ret;
     unsigned int cur_bytes; /* number of bytes in current iteration */
     uint64_t cluster_offset = 0;
-    uint64_t bytes_done = 0;
-    QEMUIOVector hd_qiov;
     uint8_t *cluster_data = NULL;
 
-    qemu_iovec_init(&hd_qiov, qiov->niov);
-
     while (bytes != 0) {
 
         /* prepare next request */
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
 
         offset_in_cluster = offset_into_cluster(s, offset);
 
-        qemu_iovec_reset(&hd_qiov);
-        qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
-
         switch (ret) {
         case QCOW2_CLUSTER_UNALLOCATED:
 
             if (bs->backing) {
                 BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
-                ret = bdrv_co_preadv(bs->backing, offset, cur_bytes,
-                                     &hd_qiov, 0);
+                ret = bdrv_co_preadv_part(bs->backing, offset, cur_bytes,
+                                          qiov, qiov_offset, 0);
                 if (ret < 0) {
                     goto fail;
                 }
             } else {
                 /* Note: in this case, no need to wait */
-                qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes);
+                qemu_iovec_memset(qiov, qiov_offset, 0, cur_bytes);
             }
             break;
 
         case QCOW2_CLUSTER_ZERO_PLAIN:
         case QCOW2_CLUSTER_ZERO_ALLOC:
-            qemu_iovec_memset(&hd_qiov, 0, 0, cur_bytes);
+            qemu_iovec_memset(qiov, qiov_offset, 0, cur_bytes);
             break;
 
         case QCOW2_CLUSTER_COMPRESSED:
             ret = qcow2_co_preadv_compressed(bs, cluster_offset,
                                              offset, cur_bytes,
-                                             &hd_qiov);
+                                             qiov, qiov_offset);
             if (ret < 0) {
                 goto fail;
             }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
                     ret = -EIO;
                     goto fail;
                 }
-                qemu_iovec_from_buf(qiov, bytes_done, cluster_data, cur_bytes);
+                qemu_iovec_from_buf(qiov, qiov_offset, cluster_data, cur_bytes);
             } else {
                 BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
-                ret = bdrv_co_preadv(s->data_file,
-                                     cluster_offset + offset_in_cluster,
-                                     cur_bytes, &hd_qiov, 0);
+                ret = bdrv_co_preadv_part(s->data_file,
+                                          cluster_offset + offset_in_cluster,
+                                          cur_bytes, qiov, qiov_offset, 0);
                 if (ret < 0) {
                     goto fail;
                 }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
 
         bytes -= cur_bytes;
         offset += cur_bytes;
-        bytes_done += cur_bytes;
+        qiov_offset += cur_bytes;
     }
     ret = 0;
 
 fail:
-    qemu_iovec_destroy(&hd_qiov);
     qemu_vfree(cluster_data);
 
     return ret;
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
                            uint64_t file_cluster_offset,
                            uint64_t offset,
                            uint64_t bytes,
-                           QEMUIOVector *qiov)
+                           QEMUIOVector *qiov,
+                           size_t qiov_offset)
 {
     BDRVQcow2State *s = bs->opaque;
     int ret = 0, csize, nb_csectors;
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
         goto fail;
     }
 
-    qemu_iovec_from_buf(qiov, 0, out_buf + offset_in_cluster, bytes);
+    qemu_iovec_from_buf(qiov, qiov_offset, out_buf + offset_in_cluster, bytes);
 
 fail:
     qemu_vfree(out_buf);
@@ -XXX,XX +XXX,XX @@ static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
     BDRVQcow2State *s = bs->opaque;
 
     BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
-    return bs->drv->bdrv_co_preadv(bs, qcow2_vm_state_offset(s) + pos,
-                                   qiov->size, qiov, 0);
+    return bs->drv->bdrv_co_preadv_part(bs, qcow2_vm_state_offset(s) + pos,
+                                        qiov->size, qiov, 0, 0);
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {
     .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
     .bdrv_co_block_status = qcow2_co_block_status,
 
-    .bdrv_co_preadv         = qcow2_co_preadv,
+    .bdrv_co_preadv_part    = qcow2_co_preadv_part,
     .bdrv_co_pwritev        = qcow2_co_pwritev,
     .bdrv_co_flush_to_os    = qcow2_co_flush_to_os,
 
-- 
2.21.0

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

Implement and use new interface to get rid of hd_qiov.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-id: 20190604161514.262241-13-vsementsov@virtuozzo.com
Message-Id: <20190604161514.262241-13-vsementsov@virtuozzo.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/qcow2.h         |  1 +
 include/qemu/iov.h    |  1 +
 block/qcow2-cluster.c |  9 ++++---
 block/qcow2.c         | 60 +++++++++++++++++++++----------------------
 util/iov.c            | 10 ++++++++
 5 files changed, 48 insertions(+), 33 deletions(-)

diff --git a/block/qcow2.h b/block/qcow2.h
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -XXX,XX +XXX,XX @@ typedef struct QCowL2Meta
      * from @cow_start and @cow_end into one single write operation.
      */
     QEMUIOVector *data_qiov;
+    size_t data_qiov_offset;
 
     /** Pointer to next L2Meta of the same write request */
     struct QCowL2Meta *next;
diff --git a/include/qemu/iov.h b/include/qemu/iov.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/iov.h
+++ b/include/qemu/iov.h
@@ -XXX,XX +XXX,XX @@ void qemu_iovec_init_extended(
         void *tail_buf, size_t tail_len);
 void qemu_iovec_init_slice(QEMUIOVector *qiov, QEMUIOVector *source,
                            size_t offset, size_t len);
+int qemu_iovec_subvec_niov(QEMUIOVector *qiov, size_t offset, size_t len);
 void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
 void qemu_iovec_concat(QEMUIOVector *dst,
                        QEMUIOVector *src, size_t soffset, size_t sbytes);
diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ static int perform_cow(BlockDriverState *bs, QCowL2Meta *m)
     assert(start->nb_bytes <= UINT_MAX - end->nb_bytes);
     assert(start->nb_bytes + end->nb_bytes <= UINT_MAX - data_bytes);
     assert(start->offset + start->nb_bytes <= end->offset);
-    assert(!m->data_qiov || m->data_qiov->size == data_bytes);
 
     if ((start->nb_bytes == 0 && end->nb_bytes == 0) || m->skip_cow) {
         return 0;
@@ -XXX,XX +XXX,XX @@ static int perform_cow(BlockDriverState *bs, QCowL2Meta *m)
     /* The part of the buffer where the end region is located */
     end_buffer = start_buffer + buffer_size - end->nb_bytes;
 
-    qemu_iovec_init(&qiov, 2 + (m->data_qiov ? m->data_qiov->niov : 0));
+    qemu_iovec_init(&qiov, 2 + (m->data_qiov ?
+                                qemu_iovec_subvec_niov(m->data_qiov,
+                                                       m->data_qiov_offset,
+                                                       data_bytes)
+                                : 0));
 
     qemu_co_mutex_unlock(&s->lock);
     /* First we read the existing data from both COW regions. We
@@ -XXX,XX +XXX,XX @@ static int perform_cow(BlockDriverState *bs, QCowL2Meta *m)
         if (start->nb_bytes) {
             qemu_iovec_add(&qiov, start_buffer, start->nb_bytes);
         }
-        qemu_iovec_concat(&qiov, m->data_qiov, 0, data_bytes);
+        qemu_iovec_concat(&qiov, m->data_qiov, m->data_qiov_offset, data_bytes);
         if (end->nb_bytes) {
             qemu_iovec_add(&qiov, end_buffer, end->nb_bytes);
         }
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 @@ fail:
 /* Check if it's possible to merge a write request with the writing of
  * the data from the COW regions */
 static bool merge_cow(uint64_t offset, unsigned bytes,
-                      QEMUIOVector *hd_qiov, QCowL2Meta *l2meta)
+                      QEMUIOVector *qiov, size_t qiov_offset,
+                      QCowL2Meta *l2meta)
 {
     QCowL2Meta *m;
 
@@ -XXX,XX +XXX,XX @@ static bool merge_cow(uint64_t offset, unsigned bytes,
 
         /* Make sure that adding both COW regions to the QEMUIOVector
          * does not exceed IOV_MAX */
-        if (hd_qiov->niov > IOV_MAX - 2) {
+        if (qemu_iovec_subvec_niov(qiov, qiov_offset, bytes) > IOV_MAX - 2) {
             continue;
         }
 
-        m->data_qiov = hd_qiov;
+        m->data_qiov = qiov;
+        m->data_qiov_offset = qiov_offset;
         return true;
     }
 
@@ -XXX,XX +XXX,XX @@ static int handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)
     return 0;
 }
 
-static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
-                                         uint64_t bytes, QEMUIOVector *qiov,
-                                         int flags)
+static coroutine_fn int qcow2_co_pwritev_part(
+        BlockDriverState *bs, uint64_t offset, uint64_t bytes,
+        QEMUIOVector *qiov, size_t qiov_offset, int flags)
 {
     BDRVQcow2State *s = bs->opaque;
     int offset_in_cluster;
     int ret;
     unsigned int cur_bytes; /* number of sectors in current iteration */
     uint64_t cluster_offset;
-    QEMUIOVector hd_qiov;
+    QEMUIOVector encrypted_qiov;
     uint64_t bytes_done = 0;
     uint8_t *cluster_data = NULL;
     QCowL2Meta *l2meta = NULL;
 
     trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes);
 
-    qemu_iovec_init(&hd_qiov, qiov->niov);
-
     qemu_co_mutex_lock(&s->lock);
 
     while (bytes != 0) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
 
         qemu_co_mutex_unlock(&s->lock);
 
-        qemu_iovec_reset(&hd_qiov);
-        qemu_iovec_concat(&hd_qiov, qiov, bytes_done, cur_bytes);
-
         if (bs->encrypted) {
             assert(s->crypto);
             if (!cluster_data) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
                 }
             }
 
-            assert(hd_qiov.size <=
-                   QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
-            qemu_iovec_to_buf(&hd_qiov, 0, cluster_data, hd_qiov.size);
+            assert(cur_bytes <= QCOW_MAX_CRYPT_CLUSTERS * s->cluster_size);
+            qemu_iovec_to_buf(qiov, qiov_offset + bytes_done,
+                              cluster_data, cur_bytes);
 
             if (qcow2_co_encrypt(bs, cluster_offset, offset,
                                  cluster_data, cur_bytes) < 0) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
                 goto out_unlocked;
             }
 
-            qemu_iovec_reset(&hd_qiov);
-            qemu_iovec_add(&hd_qiov, cluster_data, cur_bytes);
+            qemu_iovec_init_buf(&encrypted_qiov, cluster_data, cur_bytes);
         }
 
         /* Try to efficiently initialize the physical space with zeroes */
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
          * writing of the guest data together with that of the COW regions.
          * If it's not possible (or not necessary) then write the
          * guest data now. */
-        if (!merge_cow(offset, cur_bytes, &hd_qiov, l2meta)) {
+        if (!merge_cow(offset, cur_bytes,
+                       bs->encrypted ? &encrypted_qiov : qiov,
+                       bs->encrypted ? 0 : qiov_offset + bytes_done, l2meta))
+        {
             BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
             trace_qcow2_writev_data(qemu_coroutine_self(),
                                     cluster_offset + offset_in_cluster);
-            ret = bdrv_co_pwritev(s->data_file,
-                                  cluster_offset + offset_in_cluster,
-                                  cur_bytes, &hd_qiov, 0);
+            ret = bdrv_co_pwritev_part(
+                    s->data_file, cluster_offset + offset_in_cluster, cur_bytes,
+                    bs->encrypted ? &encrypted_qiov : qiov,
+                    bs->encrypted ? 0 : qiov_offset + bytes_done, 0);
             if (ret < 0) {
                 goto out_unlocked;
             }
@@ -XXX,XX +XXX,XX @@ out_locked:
 
     qemu_co_mutex_unlock(&s->lock);
 
-    qemu_iovec_destroy(&hd_qiov);
     qemu_vfree(cluster_data);
     trace_qcow2_writev_done_req(qemu_coroutine_self(), ret);
 
@@ -XXX,XX +XXX,XX @@ fail:
 /* XXX: put compressed sectors first, then all the cluster aligned
    tables to avoid losing bytes in alignment */
 static coroutine_fn int
-qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
-                            uint64_t bytes, QEMUIOVector *qiov)
+qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
+                                 uint64_t offset, uint64_t bytes,
+                                 QEMUIOVector *qiov, size_t qiov_offset)
 {
     BDRVQcow2State *s = bs->opaque;
     int ret;
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
         /* Zero-pad last write if image size is not cluster aligned */
         memset(buf + bytes, 0, s->cluster_size - bytes);
     }
-    qemu_iovec_to_buf(qiov, 0, buf, bytes);
+    qemu_iovec_to_buf(qiov, qiov_offset, buf, bytes);
 
     out_buf = g_malloc(s->cluster_size);
 
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
                                 buf, s->cluster_size);
     if (out_len == -ENOMEM) {
         /* could not compress: write normal cluster */
-        ret = qcow2_co_pwritev(bs, offset, bytes, qiov, 0);
+        ret = qcow2_co_pwritev_part(bs, offset, bytes, qiov, qiov_offset, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ static int qcow2_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
     BDRVQcow2State *s = bs->opaque;
 
     BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
-    return bs->drv->bdrv_co_pwritev(bs, qcow2_vm_state_offset(s) + pos,
-                                    qiov->size, qiov, 0);
+    return bs->drv->bdrv_co_pwritev_part(bs, qcow2_vm_state_offset(s) + pos,
+                                         qiov->size, qiov, 0, 0);
 }
 
 static int qcow2_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov,
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {
     .bdrv_co_block_status = qcow2_co_block_status,
 
     .bdrv_co_preadv_part    = qcow2_co_preadv_part,
-    .bdrv_co_pwritev        = qcow2_co_pwritev,
+    .bdrv_co_pwritev_part   = qcow2_co_pwritev_part,
     .bdrv_co_flush_to_os    = qcow2_co_flush_to_os,
 
     .bdrv_co_pwrite_zeroes  = qcow2_co_pwrite_zeroes,
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {
     .bdrv_co_copy_range_from = qcow2_co_copy_range_from,
     .bdrv_co_copy_range_to  = qcow2_co_copy_range_to,
     .bdrv_co_truncate       = qcow2_co_truncate,
-    .bdrv_co_pwritev_compressed = qcow2_co_pwritev_compressed,
+    .bdrv_co_pwritev_compressed_part = qcow2_co_pwritev_compressed_part,
     .bdrv_make_empty        = qcow2_make_empty,
 
     .bdrv_snapshot_create   = qcow2_snapshot_create,
diff --git a/util/iov.c b/util/iov.c
index XXXXXXX..XXXXXXX 100644
--- a/util/iov.c
+++ b/util/iov.c
@@ -XXX,XX +XXX,XX @@ static struct iovec *qiov_slice(QEMUIOVector *qiov,
     return iov;
 }
 
+int qemu_iovec_subvec_niov(QEMUIOVector *qiov, size_t offset, size_t len)
+{
+    size_t head, tail;
+    int niov;
+
+    qiov_slice(qiov, offset, len, &head, &tail, &niov);
+
+    return niov;
+}
+
 /*
  * Compile new iovec, combining @head_buf buffer, sub-qiov of @mid_qiov,
  * and @tail_buf buffer into new qiov.
-- 
2.21.0