Series comparison

-[Qemu-devel] [PULL 00/12] Block patches
+[PULL 0/5] Block patches
-The following changes since commit dac03af5d5482ec7ee9c23db467bb7230b33c0d9:
+The following changes since commit 711c0418c8c1ce3a24346f058b001c4c5a2f0f81:
-  Merge remote-tracking branch 'remotes/rth/tags/pull-axp-20190825' into staging (2019-08-27 10:00:51 +0100)
+  Merge remote-tracking branch 'remotes/philmd/tags/mips-20210702' into staging (2021-07-04 14:04:12 +0100)
 are available in the Git repository at:
-  https://github.com/stefanha/qemu.git tags/block-pull-request
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 5396234b96a2ac743f48644529771498e036e698:
+for you to fetch changes up to 9f460c64e13897117f35ffb61f6f5e0102cabc70:
-  block/qcow2: implement .bdrv_co_pwritev(_compressed)_part (2019-08-27 14:58:42 +0100)
+  block/io: Merge discard request alignments (2021-07-06 14:28:55 +0100)
 ----------------------------------------------------------------
 Pull request
 ----------------------------------------------------------------
-Vladimir Sementsov-Ogievskiy (12):
+Akihiko Odaki (3):
-  util/iov: introduce qemu_iovec_init_extended
+  block/file-posix: Optimize for macOS
-  util/iov: improve qemu_iovec_is_zero
+  block: Add backend_defaults property
-  block/io: refactor padding
+  block/io: Merge discard request alignments
   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
- block/qcow2.h             |   1 +
+Stefan Hajnoczi (2):
- include/block/block_int.h |  21 ++
+  util/async: add a human-readable name to BHs for debugging
- include/qemu/iov.h        |  10 +-
+  util/async: print leaked BH name when AioContext finalizes
- block/backup.c            |   2 +-
- block/io.c                | 541 +++++++++++++++++++++++---------------
+ include/block/aio.h            | 31 ++++++++++++++++++++++---
- block/qcow2-cluster.c     |  14 +-
+ include/hw/block/block.h       |  3 +++
- block/qcow2.c             | 131 +++++----
+ include/qemu/main-loop.h       |  4 +++-
- qemu-img.c                |   4 +-
+ block/file-posix.c             | 27 ++++++++++++++++++++--
- util/iov.c                | 153 +++++++++--
+ block/io.c                     |  2 ++
-files changed, 568 insertions(+), 309 deletions(-)
+ hw/block/block.c               | 42 ++++++++++++++++++++++++++++++----
  tests/unit/ptimer-test-stubs.c |  2 +-
  util/async.c                   | 25 ++++++++++++++++----
  util/main-loop.c               |  4 ++--
  tests/qemu-iotests/172.out     | 38 ++++++++++++++++++++++++++++++
 files changed, 161 insertions(+), 17 deletions(-)
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 01/12] util/iov: introduce qemu_iovec_init_extended
+Deleted patch
-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 +++++++++++++++++++++++++++++++++++++++++++--
-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)
---
-.21.0

-[Qemu-devel] [PULL 02/12] util/iov: improve qemu_iovec_is_zero
+Deleted patch
-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:
-. It is strange: it aligns length of the buffer, but where is a
-   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>
----
- include/qemu/iov.h |  2 +-
- block/io.c         |  2 +-
- util/iov.c         | 31 +++++++++++++++++++------------
-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;
- }
---
-.21.0

-[Qemu-devel] [PULL 12/12] block/qcow2: implement .bdrv_co_pwritev(_compressed)_part
+[PULL 1/5] util/async: add a human-readable name to BHs for debugging
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+It can be difficult to debug issues with BHs in production environments.
 Although BHs can usually be identified by looking up their ->cb()
 function pointer, this requires debug information for the program. It is
 also not possible to print human-readable diagnostics about BHs because
 they have no identifier.
-Implement and use new interface to get rid of hd_qiov.
+This patch adds a name to each BH. The name is not unique per instance
 but differentiates between cb() functions, which is usually enough. It's
 done by changing aio_bh_new() and friends to macros that stringify cb.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+The next patch will use the name field when reporting leaked BHs.
-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>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-Id: <20210414200247.917496-2-stefanha@redhat.com>
 ---
- block/qcow2.h         |  1 +
+ include/block/aio.h            | 31 ++++++++++++++++++++++++++++---
- include/qemu/iov.h    |  1 +
+ include/qemu/main-loop.h       |  4 +++-
- block/qcow2-cluster.c |  9 ++++---
+ tests/unit/ptimer-test-stubs.c |  2 +-
- block/qcow2.c         | 60 +++++++++++++++++++++----------------------
+ util/async.c                   |  9 +++++++--
- util/iov.c            | 10 ++++++++
+ util/main-loop.c               |  4 ++--
-files changed, 48 insertions(+), 33 deletions(-)
+files changed, 41 insertions(+), 9 deletions(-)
-diff --git a/block/qcow2.h b/block/qcow2.h
+diff --git a/include/block/aio.h b/include/block/aio.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2.h
+--- a/include/block/aio.h
-+++ b/block/qcow2.h
++++ b/include/block/aio.h
-@@ -XXX,XX +XXX,XX @@ typedef struct QCowL2Meta
+@@ -XXX,XX +XXX,XX @@ void aio_context_acquire(AioContext *ctx);
-      * from @cow_start and @cow_end into one single write operation.
+ /* Relinquish ownership of the AioContext. */
-      */
+ void aio_context_release(AioContext *ctx);
-     QEMUIOVector *data_qiov;
-+    size_t data_qiov_offset;
++/**
++ * aio_bh_schedule_oneshot_full: Allocate a new bottom half structure that will
-     /** Pointer to next L2Meta of the same write request */
++ * run only once and as soon as possible.
-     struct QCowL2Meta *next;
++ *
-diff --git a/include/qemu/iov.h b/include/qemu/iov.h
++ * @name: A human-readable identifier for debugging purposes.
 + */
 +void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
 +                                  const char *name);
 +
  /**
   * aio_bh_schedule_oneshot: Allocate a new bottom half structure that will run
   * only once and as soon as possible.
 + *
 + * A convenience wrapper for aio_bh_schedule_oneshot_full() that uses cb as the
 + * name string.
   */
 -void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
 +#define aio_bh_schedule_oneshot(ctx, cb, opaque) \
 +    aio_bh_schedule_oneshot_full((ctx), (cb), (opaque), (stringify(cb)))
  /**
 - * aio_bh_new: Allocate a new bottom half structure.
 + * aio_bh_new_full: Allocate a new bottom half structure.
   *
   * Bottom halves are lightweight callbacks whose invocation is guaranteed
   * to be wait-free, thread-safe and signal-safe.  The #QEMUBH structure
   * is opaque and must be allocated prior to its use.
 + *
 + * @name: A human-readable identifier for debugging purposes.
   */
 -QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
 +QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
 +                        const char *name);
 +
 +/**
 + * aio_bh_new: Allocate a new bottom half structure
 + *
 + * A convenience wrapper for aio_bh_new_full() that uses the cb as the name
 + * string.
 + */
 +#define aio_bh_new(ctx, cb, opaque) \
 +    aio_bh_new_full((ctx), (cb), (opaque), (stringify(cb)))
  /**
   * aio_notify: Force processing of pending events.
 diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/qemu/iov.h
+--- a/include/qemu/main-loop.h
-+++ b/include/qemu/iov.h
++++ b/include/qemu/main-loop.h
-@@ -XXX,XX +XXX,XX @@ void qemu_iovec_init_extended(
+@@ -XXX,XX +XXX,XX @@ void qemu_cond_timedwait_iothread(QemuCond *cond, int ms);
-         void *tail_buf, size_t tail_len);
- void qemu_iovec_init_slice(QEMUIOVector *qiov, QEMUIOVector *source,
+ void qemu_fd_register(int fd);
-                            size_t offset, size_t len);
-+int qemu_iovec_subvec_niov(QEMUIOVector *qiov, size_t offset, size_t len);
+-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
- void qemu_iovec_add(QEMUIOVector *qiov, void *base, size_t len);
++#define qemu_bh_new(cb, opaque) \
- void qemu_iovec_concat(QEMUIOVector *dst,
++    qemu_bh_new_full((cb), (opaque), (stringify(cb)))
-                        QEMUIOVector *src, size_t soffset, size_t sbytes);
++QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name);
-diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
+ void qemu_bh_schedule_idle(QEMUBH *bh);
  enum {
 diff --git a/tests/unit/ptimer-test-stubs.c b/tests/unit/ptimer-test-stubs.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2-cluster.c
+--- a/tests/unit/ptimer-test-stubs.c
-+++ b/block/qcow2-cluster.c
++++ b/tests/unit/ptimer-test-stubs.c
-@@ -XXX,XX +XXX,XX @@ static int perform_cow(BlockDriverState *bs, QCowL2Meta *m)
+@@ -XXX,XX +XXX,XX @@ int64_t qemu_clock_deadline_ns_all(QEMUClockType type, int attr_mask)
-     assert(start->nb_bytes <= UINT_MAX - end->nb_bytes);
+     return deadline;
-     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);
+-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
++QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
-     if ((start->nb_bytes == 0 && end->nb_bytes == 0) || m->skip_cow) {
+ {
-         return 0;
+     QEMUBH *bh = g_new(QEMUBH, 1);
-@@ -XXX,XX +XXX,XX @@ static int perform_cow(BlockDriverState *bs, QCowL2Meta *m)
-     /* The part of the buffer where the end region is located */
+diff --git a/util/async.c b/util/async.c
      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
+--- a/util/async.c
-+++ b/block/qcow2.c
++++ b/util/async.c
-@@ -XXX,XX +XXX,XX @@ fail:
+@@ -XXX,XX +XXX,XX @@ enum {
- /* Check if it's possible to merge a write request with the writing of
-  * the data from the COW regions */
+ struct QEMUBH {
- static bool merge_cow(uint64_t offset, unsigned bytes,
+     AioContext *ctx;
--                      QEMUIOVector *hd_qiov, QCowL2Meta *l2meta)
++    const char *name;
-+                      QEMUIOVector *qiov, size_t qiov_offset,
+     QEMUBHFunc *cb;
-+                      QCowL2Meta *l2meta)
+     void *opaque;
      QSLIST_ENTRY(QEMUBH) next;
@@ -XXX,XX +XXX,XX @@ static QEMUBH *aio_bh_dequeue(BHList *head, unsigned *flags)
      return bh;
  }
 -void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
 +void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb,
 +                                  void *opaque, const char *name)
  {
-     QCowL2Meta *m;
+     QEMUBH *bh;
+     bh = g_new(QEMUBH, 1);
-@@ -XXX,XX +XXX,XX @@ static bool merge_cow(uint64_t offset, unsigned bytes,
+@@ -XXX,XX +XXX,XX @@ void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
+         .ctx = ctx,
-         /* Make sure that adding both COW regions to the QEMUIOVector
+         .cb = cb,
-          * does not exceed IOV_MAX */
+         .opaque = opaque,
--        if (hd_qiov->niov > IOV_MAX - 2) {
++        .name = name,
-+        if (qemu_iovec_subvec_niov(qiov, qiov_offset, bytes) > IOV_MAX - 2) {
+     };
-             continue;
+     aio_bh_enqueue(bh, BH_SCHEDULED | BH_ONESHOT);
          }
 -        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,
+-QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
--                                         uint64_t bytes, QEMUIOVector *qiov,
++QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
--                                         int flags)
++                        const char *name)
 +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;
+     QEMUBH *bh;
-     int offset_in_cluster;
+     bh = g_new(QEMUBH, 1);
-     int ret;
+@@ -XXX,XX +XXX,XX @@ QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
-     unsigned int cur_bytes; /* number of sectors in current iteration */
+         .ctx = ctx,
-     uint64_t cluster_offset;
+         .cb = cb,
--    QEMUIOVector hd_qiov;
+         .opaque = opaque,
-+    QEMUIOVector encrypted_qiov;
++        .name = name,
-     uint64_t bytes_done = 0;
+     };
-     uint8_t *cluster_data = NULL;
+     return bh;
-     QCowL2Meta *l2meta = NULL;
+ }
+diff --git a/util/main-loop.c b/util/main-loop.c
-     trace_qcow2_writev_start_req(qemu_coroutine_self(), offset, bytes);
+index XXXXXXX..XXXXXXX 100644
+--- a/util/main-loop.c
--    qemu_iovec_init(&hd_qiov, qiov->niov);
++++ b/util/main-loop.c
--
+@@ -XXX,XX +XXX,XX @@ void main_loop_wait(int nonblocking)
-     qemu_co_mutex_lock(&s->lock);
+ /* Functions to operate on the main QEMU AioContext.  */
-     while (bytes != 0) {
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_pwritev(BlockDriverState *bs, uint64_t offset,
+-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
++QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
          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;
+-    return aio_bh_new(qemu_aio_context, cb, opaque);
-     int ret;
++    return aio_bh_new_full(qemu_aio_context, cb, opaque, name);
@@ -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.
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 11/12] block/qcow2: implement .bdrv_co_preadv_part
+[PULL 2/5] util/async: print leaked BH name when AioContext finalizes
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+BHs must be deleted before the AioContext is finalized. If not, it's a
 bug and probably indicates that some part of the program still expects
 the BH to run in the future. That can lead to memory leaks, inconsistent
 state, or just hangs.
-Implement and use new interface to get rid of hd_qiov.
+Unfortunately the assert(flags & BH_DELETED) call in aio_ctx_finalize()
 is difficult to debug because the assertion failure contains no
 information about the BH!
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Use the QEMUBH name field added in the previous patch to show a useful
-Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
+error when a leaked BH is detected.
-Message-id: 20190604161514.262241-12-vsementsov@virtuozzo.com
-Message-Id: <20190604161514.262241-12-vsementsov@virtuozzo.com>
+Suggested-by: Eric Ernst <eric.g.ernst@gmail.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20210414200247.917496-3-stefanha@redhat.com>
 ---
- block/qcow2-cluster.c |  5 +++--
+ util/async.c | 16 ++++++++++++++--
- block/qcow2.c         | 49 +++++++++++++++++++------------------------
+file changed, 14 insertions(+), 2 deletions(-)
 files changed, 25 insertions(+), 29 deletions(-)
-diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
+diff --git a/util/async.c b/util/async.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2-cluster.c
+--- a/util/async.c
-+++ b/block/qcow2-cluster.c
++++ b/util/async.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn do_perform_cow_read(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ aio_ctx_finalize(GSource     *source)
-      * interface.  This avoids double I/O throttling and request tracking,
+     assert(QSIMPLEQ_EMPTY(&ctx->bh_slice_list));
-      * which can lead to deadlock when block layer copy-on-read is enabled.
-      */
+     while ((bh = aio_bh_dequeue(&ctx->bh_list, &flags))) {
--    ret = bs->drv->bdrv_co_preadv(bs, src_cluster_offset + offset_in_cluster,
+-        /* qemu_bh_delete() must have been called on BHs in this AioContext */
--                                  qiov->size, qiov, 0);
+-        assert(flags & BH_DELETED);
-+    ret = bs->drv->bdrv_co_preadv_part(bs,
++        /*
-+                                       src_cluster_offset + offset_in_cluster,
++         * qemu_bh_delete() must have been called on BHs in this AioContext. In
-+                                       qiov->size, qiov, 0, 0);
++         * many cases memory leaks, hangs, or inconsistent state occur when a
-     if (ret < 0) {
++         * BH is leaked because something still expects it to run.
-         return ret;
++         *
 +         * If you hit this, fix the lifecycle of the BH so that
 +         * qemu_bh_delete() and any associated cleanup is called before the
 +         * AioContext is finalized.
 +         */
 +        if (unlikely(!(flags & BH_DELETED))) {
 +            fprintf(stderr, "%s: BH '%s' leaked, aborting...\n",
 +                    __func__, bh->name);
 +            abort();
 +        }
          g_free(bh);
      }
-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,
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 09/12] block/io: introduce bdrv_co_p{read, write}v_part
+[PULL 3/5] block/file-posix: Optimize for macOS
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+From: Akihiko Odaki <akihiko.odaki@gmail.com>
-Introduce extended variants of bdrv_co_preadv and bdrv_co_pwritev
+This commit introduces "punch hole" operation and optimizes transfer
-with qiov_offset parameter.
+block size for macOS.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Thanks to Konstantin Nazarov for detailed analysis of a flaw in an
-Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
+old version of this change:
-Message-id: 20190604161514.262241-10-vsementsov@virtuozzo.com
+https://gist.github.com/akihikodaki/87df4149e7ca87f18dc56807ec5a1bc5#gistcomment-3654667
-Message-Id: <20190604161514.262241-10-vsementsov@virtuozzo.com>
 Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
 Message-id: 20210705130458.97642-1-akihiko.odaki@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- include/block/block_int.h |  6 ++++++
+ block/file-posix.c | 27 +++++++++++++++++++++++++--
- block/io.c                | 29 +++++++++++++++++++++++------
+file changed, 25 insertions(+), 2 deletions(-)
 files changed, 29 insertions(+), 6 deletions(-)
-diff --git a/include/block/block_int.h b/include/block/block_int.h
+diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/block_int.h
+--- a/block/file-posix.c
-+++ b/include/block/block_int.h
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ extern BlockDriver bdrv_qcow2;
+@@ -XXX,XX +XXX,XX @@
- int coroutine_fn bdrv_co_preadv(BdrvChild *child,
+ #if defined(HAVE_HOST_BLOCK_DEVICE)
-     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
+ #include <paths.h>
-     BdrvRequestFlags flags);
+ #include <sys/param.h>
-+int coroutine_fn bdrv_co_preadv_part(BdrvChild *child,
++#include <sys/mount.h>
-+    int64_t offset, unsigned int bytes,
+ #include <IOKit/IOKitLib.h>
-+    QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags);
+ #include <IOKit/IOBSD.h>
- int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
+ #include <IOKit/storage/IOMediaBSDClient.h>
-     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
+@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
-     BdrvRequestFlags flags);
+         return;
-+int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
+     }
-+    int64_t offset, unsigned int bytes,
-+    QEMUIOVector *qiov, size_t qiov_offset, BdrvRequestFlags flags);
++#if defined(__APPLE__) && (__MACH__)
++    struct statfs buf;
- static inline int coroutine_fn bdrv_co_pread(BdrvChild *child,
++
-     int64_t offset, unsigned int bytes, void *buf, BdrvRequestFlags flags)
++    if (!fstatfs(s->fd, &buf)) {
-diff --git a/block/io.c b/block/io.c
++        bs->bl.opt_transfer = buf.f_iosize;
-index XXXXXXX..XXXXXXX 100644
++        bs->bl.pdiscard_alignment = buf.f_bsize;
---- a/block/io.c
++    }
-+++ b/block/io.c
++#endif
-@@ -XXX,XX +XXX,XX @@ static void bdrv_padding_destroy(BdrvRequestPadding *pad)
++
-  *
+     if (bs->sg || S_ISBLK(st.st_mode)) {
-  * Function always succeeds.
+         int ret = hdev_get_max_hw_transfer(s->fd, &st);
-  */
--static bool bdrv_pad_request(BlockDriverState *bs, QEMUIOVector **qiov,
+@@ -XXX,XX +XXX,XX @@ out:
-+static bool bdrv_pad_request(BlockDriverState *bs,
+     }
-+                             QEMUIOVector **qiov, size_t *qiov_offset,
+ }
-                              int64_t *offset, unsigned int *bytes,
-                              BdrvRequestPadding *pad)
++#if defined(CONFIG_FALLOCATE) || defined(BLKZEROOUT) || defined(BLKDISCARD)
  static int translate_err(int err)
  {
-@@ -XXX,XX +XXX,XX @@ static bool bdrv_pad_request(BlockDriverState *bs, QEMUIOVector **qiov,
+     if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
@@ -XXX,XX +XXX,XX @@ static int translate_err(int err)
      }
+     return err;
      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,
++#endif
- int coroutine_fn bdrv_co_preadv(BdrvChild *child,
-     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
+ #ifdef CONFIG_FALLOCATE
-     BdrvRequestFlags flags)
+ static int do_fallocate(int fd, int mode, off_t offset, off_t len)
-+{
+@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_discard(void *opaque)
-+    return bdrv_co_preadv_part(child, offset, bytes, qiov, 0, flags);
+             }
-+}
+         } while (errno == EINTR);
-+
-+int coroutine_fn bdrv_co_preadv_part(BdrvChild *child,
+-        ret = -errno;
-+    int64_t offset, unsigned int bytes,
++        ret = translate_err(-errno);
-+    QEMUIOVector *qiov, size_t qiov_offset,
+ #endif
-+    BdrvRequestFlags flags)
+     } else {
- {
+ #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
-     BlockDriverState *bs = child->bs;
+         ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
-     BdrvTrackedRequest req;
+                            aiocb->aio_offset, aiocb->aio_nbytes);
-@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_preadv(BdrvChild *child,
++        ret = translate_err(-errno);
-         flags |= BDRV_REQ_COPY_ON_READ;
++#elif defined(__APPLE__) && (__MACH__)
 +        fpunchhole_t fpunchhole;
 +        fpunchhole.fp_flags = 0;
 +        fpunchhole.reserved = 0;
 +        fpunchhole.fp_offset = aiocb->aio_offset;
 +        fpunchhole.fp_length = aiocb->aio_nbytes;
 +        if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) {
 +            ret = errno == ENODEV ? -ENOTSUP : -errno;
 +        } else {
 +            ret = 0;
 +        }
  #endif
      }
--    bdrv_pad_request(bs, &qiov, &offset, &bytes, &pad);
+-    ret = translate_err(ret);
-+    bdrv_pad_request(bs, &qiov, &qiov_offset, &offset, &bytes, &pad);
+     if (ret == -ENOTSUP) {
+         s->has_discard = false;
      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);
 +}
 +
 +int coroutine_fn bdrv_co_pwritev_part(BdrvChild *child,
 +    int64_t offset, unsigned int bytes, QEMUIOVector *qiov, size_t qiov_offset,
 +    BdrvRequestFlags flags)
  {
      BlockDriverState *bs = child->bs;
      BdrvTrackedRequest req;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
          goto out;
      }
--    if (bdrv_pad_request(bs, &qiov, &offset, &bytes, &pad)) {
-+    if (bdrv_pad_request(bs, &qiov, &qiov_offset, &offset, &bytes, &pad)) {
-         mark_request_serialising(&req, align);
-         wait_serialising_requests(&req);
-         bdrv_padding_rmw_read(child, &req, &pad, false);
-     }
-     ret = bdrv_aligned_pwritev(child, &req, offset, bytes, align,
--                               qiov, 0, flags);
-+                               qiov, qiov_offset, flags);
-     bdrv_padding_destroy(&pad);
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 03/12] block/io: refactor padding
+[PULL 4/5] block: Add backend_defaults property
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+From: Akihiko Odaki <akihiko.odaki@gmail.com>
-We have similar padding code in bdrv_co_pwritev,
+backend_defaults property allow users to control if default block
-bdrv_co_do_pwrite_zeroes and bdrv_co_preadv. Let's combine and unify
+properties should be decided with backend information.
-it.
+If it is off, any backend information will be discarded, which is
-[Squashed in Vladimir's qemu-iotests 077 fix
+suitable if you plan to perform live migration to a different disk backend.
---Stefan]
+If it is on, a block device may utilize backend information more
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+aggressively.
-Acked-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-id: 20190604161514.262241-4-vsementsov@virtuozzo.com
+By default, it is auto, which uses backend information for block
-Message-Id: <20190604161514.262241-4-vsementsov@virtuozzo.com>
+sizes and ignores the others, which is consistent with the older
 versions.
 Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
 Message-id: 20210705130458.97642-2-akihiko.odaki@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/io.c | 365 +++++++++++++++++++++++++++++------------------------
+ include/hw/block/block.h   |  3 +++
-file changed, 200 insertions(+), 165 deletions(-)
+ hw/block/block.c           | 42 ++++++++++++++++++++++++++++++++++----
+ tests/qemu-iotests/172.out | 38 ++++++++++++++++++++++++++++++++++
-diff --git a/block/io.c b/block/io.c
+files changed, 79 insertions(+), 4 deletions(-)
 diff --git a/include/hw/block/block.h b/include/hw/block/block.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/io.c
+--- a/include/hw/block/block.h
-+++ b/block/io.c
++++ b/include/hw/block/block.h
-@@ -XXX,XX +XXX,XX @@ out:
+@@ -XXX,XX +XXX,XX @@
  typedef struct BlockConf {
      BlockBackend *blk;
 +    OnOffAuto backend_defaults;
      uint32_t physical_block_size;
      uint32_t logical_block_size;
      uint32_t min_io_size;
@@ -XXX,XX +XXX,XX @@ static inline unsigned int get_physical_block_exp(BlockConf *conf)
  }
- /*
+ #define DEFINE_BLOCK_PROPERTIES_BASE(_state, _conf)                     \
-- * Handle a read request in coroutine context
++    DEFINE_PROP_ON_OFF_AUTO("backend_defaults", _state,                 \
-+ * Request padding
++                            _conf.backend_defaults, ON_OFF_AUTO_AUTO),  \
-+ *
+     DEFINE_PROP_BLOCKSIZE("logical_block_size", _state,                 \
-+ *  |<---- align ----->|                     |<----- align ---->|
+                           _conf.logical_block_size),                    \
-+ *  |<- head ->|<------------- bytes ------------->|<-- tail -->|
+     DEFINE_PROP_BLOCKSIZE("physical_block_size", _state,                \
-+ *  |          |       |                     |     |            |
+diff --git a/hw/block/block.c b/hw/block/block.c
-+ * -*----------$-------*-------- ... --------*-----$------------*---
+index XXXXXXX..XXXXXXX 100644
-+ *  |          |       |                     |     |            |
+--- a/hw/block/block.c
-+ *  |          offset  |                     |     end          |
++++ b/hw/block/block.c
-+ *  ALIGN_DOWN(offset) ALIGN_UP(offset)      ALIGN_DOWN(end)   ALIGN_UP(end)
+@@ -XXX,XX +XXX,XX @@ bool blkconf_blocksizes(BlockConf *conf, Error **errp)
-+ *  [buf   ... )                             [tail_buf          )
+ {
-+ *
+     BlockBackend *blk = conf->blk;
-+ * @buf is an aligned allocation needed to store @head and @tail paddings. @head
+     BlockSizes blocksizes;
-+ * is placed at the beginning of @buf and @tail at the @end.
+-    int backend_ret;
-+ *
++    BlockDriverState *bs;
-+ * @tail_buf is a pointer to sub-buffer, corresponding to align-sized chunk
++    bool use_blocksizes;
-+ * around tail, if tail exists.
++    bool use_bs;
 + *
 + * @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,
++    switch (conf->backend_defaults) {
-+                              int64_t offset, int64_t bytes,
++    case ON_OFF_AUTO_AUTO:
-+                              BdrvRequestPadding *pad)
++        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
-+{
++        use_bs = false;
-+    uint64_t align = bs->bl.request_alignment;
++        break;
 +    size_t sum;
 +
-+    memset(pad, 0, sizeof(*pad));
++    case ON_OFF_AUTO_ON:
 +        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
 +        bs = blk_bs(blk);
 +        use_bs = bs;
 +        break;
 +
-+    pad->head = offset & (align - 1);
++    case ON_OFF_AUTO_OFF:
-+    pad->tail = ((offset + bytes) & (align - 1));
++        use_blocksizes = false;
-+    if (pad->tail) {
++        use_bs = false;
-+        pad->tail = align - pad->tail;
++        break;
 +
 +    default:
 +        abort();
 +    }
-+
-+    if ((!pad->head && !pad->tail) || !bytes) {
+-    backend_ret = blk_probe_blocksizes(blk, &blocksizes);
-+        return false;
+     /* fill in detected values if they are not defined via qemu command line */
-+    }
+     if (!conf->physical_block_size) {
-+
+-        if (!backend_ret) {
-+    sum = pad->head + bytes + pad->tail;
++        if (use_blocksizes) {
-+    pad->buf_len = (sum > align && pad->head && pad->tail) ? 2 * align : align;
+            conf->physical_block_size = blocksizes.phys;
-+    pad->buf = qemu_blockalign(bs, pad->buf_len);
+         } else {
-+    pad->merge_reads = sum == pad->buf_len;
+             conf->physical_block_size = BDRV_SECTOR_SIZE;
-+    if (pad->tail) {
+         }
-+        pad->tail_buf = pad->buf + pad->buf_len - align;
+     }
-+    }
+     if (!conf->logical_block_size) {
-+
+-        if (!backend_ret) {
-+    return true;
++        if (use_blocksizes) {
-+}
+             conf->logical_block_size = blocksizes.log;
-+
+         } else {
-+static int bdrv_padding_rmw_read(BdrvChild *child,
+             conf->logical_block_size = BDRV_SECTOR_SIZE;
-+                                 BdrvTrackedRequest *req,
+         }
-+                                 BdrvRequestPadding *pad,
+     }
-+                                 bool zero_middle)
++    if (use_bs) {
-+{
++        if (!conf->opt_io_size) {
-+    QEMUIOVector local_qiov;
++            conf->opt_io_size = bs->bl.opt_transfer;
 +    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) {
++        if (conf->discard_granularity == -1) {
-+            bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
++            if (bs->bl.pdiscard_alignment) {
-+        }
++                conf->discard_granularity = bs->bl.pdiscard_alignment;
-+        ret = bdrv_aligned_preadv(child, req, req->overlap_offset, bytes,
++            } else if (bs->bl.request_alignment != 1) {
-+                                  align, &local_qiov, 0);
++                conf->discard_granularity = bs->bl.request_alignment;
-+        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) {
+     if (conf->logical_block_size > conf->physical_block_size) {
-+        qemu_iovec_init_buf(&local_qiov, pad->tail_buf, align);
+         error_setg(errp,
-+
+diff --git a/tests/qemu-iotests/172.out b/tests/qemu-iotests/172.out
-+        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
+index XXXXXXX..XXXXXXX 100644
-+        ret = bdrv_aligned_preadv(
+--- a/tests/qemu-iotests/172.out
-+                child, req,
++++ b/tests/qemu-iotests/172.out
-+                req->overlap_offset + req->overlap_bytes - align,
+@@ -XXX,XX +XXX,XX @@ Testing:
-+                align, align, &local_qiov, 0);
+               dev: floppy, id ""
-+        if (ret < 0) {
+                 unit = 0 (0x0)
-+            return ret;
+                 drive = "floppy0"
-+        }
++                backend_defaults = "auto"
-+        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
+                 logical_block_size = 512 (512 B)
-+    }
+                 physical_block_size = 512 (512 B)
-+
+                 min_io_size = 0 (0 B)
-+zero_mem:
+@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2
-+    if (zero_middle) {
+               dev: floppy, id ""
-+        memset(pad->buf + pad->head, 0, pad->buf_len - pad->head - pad->tail);
+                 unit = 0 (0x0)
-+    }
+                 drive = "floppy0"
-+
++                backend_defaults = "auto"
-+    return 0;
+                 logical_block_size = 512 (512 B)
-+}
+                 physical_block_size = 512 (512 B)
-+
+                 min_io_size = 0 (0 B)
-+static void bdrv_padding_destroy(BdrvRequestPadding *pad)
+@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
-+{
+               dev: floppy, id ""
-+    if (pad->buf) {
+                 unit = 1 (0x1)
-+        qemu_vfree(pad->buf);
+                 drive = "floppy1"
-+        qemu_iovec_destroy(&pad->local_qiov);
++                backend_defaults = "auto"
-+    }
+                 logical_block_size = 512 (512 B)
-+}
+                 physical_block_size = 512 (512 B)
-+
+                 min_io_size = 0 (0 B)
-+/*
+@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
-+ * bdrv_pad_request
+               dev: floppy, id ""
-+ *
+                 unit = 0 (0x0)
-+ * Exchange request parameters with padded request if needed. Don't include RMW
+                 drive = "floppy0"
-+ * read of padding, bdrv_padding_rmw_read() should be called separately if
++                backend_defaults = "auto"
-+ * needed.
+                 logical_block_size = 512 (512 B)
-+ *
+                 physical_block_size = 512 (512 B)
-+ * All parameters except @bs are in-out: they represent original request at
+                 min_io_size = 0 (0 B)
-+ * function call and padded (if padding needed) at function finish.
+@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
-+ *
+               dev: floppy, id ""
-+ * Function always succeeds.
+                 unit = 1 (0x1)
-+ */
+                 drive = "floppy1"
-+static bool bdrv_pad_request(BlockDriverState *bs, QEMUIOVector **qiov,
++                backend_defaults = "auto"
-+                             int64_t *offset, unsigned int *bytes,
+                 logical_block_size = 512 (512 B)
-+                             BdrvRequestPadding *pad)
+                 physical_block_size = 512 (512 B)
-+{
+                 min_io_size = 0 (0 B)
-+    if (!bdrv_init_padding(bs, *offset, *bytes, pad)) {
+@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
-+        return false;
+               dev: floppy, id ""
-+    }
+                 unit = 0 (0x0)
-+
+                 drive = "floppy0"
-+    qemu_iovec_init_extended(&pad->local_qiov, pad->buf, pad->head,
++                backend_defaults = "auto"
-+                             *qiov, 0, *bytes,
+                 logical_block_size = 512 (512 B)
-+                             pad->buf + pad->buf_len - pad->tail, pad->tail);
+                 physical_block_size = 512 (512 B)
-+    *bytes += pad->head + pad->tail;
+                 min_io_size = 0 (0 B)
-+    *offset -= pad->head;
+@@ -XXX,XX +XXX,XX @@ Testing: -fdb
-+    *qiov = &pad->local_qiov;
+               dev: floppy, id ""
-+
+                 unit = 1 (0x1)
-+    return true;
+                 drive = "floppy1"
-+}
++                backend_defaults = "auto"
-+
+                 logical_block_size = 512 (512 B)
- int coroutine_fn bdrv_co_preadv(BdrvChild *child,
+                 physical_block_size = 512 (512 B)
-     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
+                 min_io_size = 0 (0 B)
-     BdrvRequestFlags flags)
+@@ -XXX,XX +XXX,XX @@ Testing: -fdb
- {
+               dev: floppy, id ""
-     BlockDriverState *bs = child->bs;
+                 unit = 0 (0x0)
--    BlockDriver *drv = bs->drv;
+                 drive = "floppy0"
-     BdrvTrackedRequest req;
++                backend_defaults = "auto"
--
+                 logical_block_size = 512 (512 B)
--    uint64_t align = bs->bl.request_alignment;
+                 physical_block_size = 512 (512 B)
--    uint8_t *head_buf = NULL;
+                 min_io_size = 0 (0 B)
--    uint8_t *tail_buf = NULL;
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2
--    QEMUIOVector local_qiov;
+               dev: floppy, id ""
--    bool use_local_qiov = false;
+                 unit = 0 (0x0)
-+    BdrvRequestPadding pad;
+                 drive = "floppy0"
-     int ret;
++                backend_defaults = "auto"
+                 logical_block_size = 512 (512 B)
--    trace_bdrv_co_preadv(child->bs, offset, bytes, flags);
+                 physical_block_size = 512 (512 B)
--
+                 min_io_size = 0 (0 B)
--    if (!drv) {
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
--        return -ENOMEDIUM;
+               dev: floppy, id ""
--    }
+                 unit = 1 (0x1)
-+    trace_bdrv_co_preadv(bs, offset, bytes, flags);
+                 drive = "floppy1"
++                backend_defaults = "auto"
-     ret = bdrv_check_byte_request(bs, offset, bytes);
+                 logical_block_size = 512 (512 B)
-     if (ret < 0) {
+                 physical_block_size = 512 (512 B)
-@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_preadv(BdrvChild *child,
+                 min_io_size = 0 (0 B)
-         flags |= BDRV_REQ_COPY_ON_READ;
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
-     }
+               dev: floppy, id ""
+                 unit = 0 (0x0)
--    /* Align read if necessary by padding qiov */
+                 drive = "floppy0"
--    if (offset & (align - 1)) {
++                backend_defaults = "auto"
--        head_buf = qemu_blockalign(bs, align);
+                 logical_block_size = 512 (512 B)
--        qemu_iovec_init(&local_qiov, qiov->niov + 2);
+                 physical_block_size = 512 (512 B)
--        qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
+                 min_io_size = 0 (0 B)
--        qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
--        use_local_qiov = true;
+               dev: floppy, id ""
--
+                 unit = 1 (0x1)
--        bytes += offset & (align - 1);
+                 drive = "floppy1"
--        offset = offset & ~(align - 1);
++                backend_defaults = "auto"
--    }
+                 logical_block_size = 512 (512 B)
--
+                 physical_block_size = 512 (512 B)
--    if ((offset + bytes) & (align - 1)) {
+                 min_io_size = 0 (0 B)
--        if (!use_local_qiov) {
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
--            qemu_iovec_init(&local_qiov, qiov->niov + 1);
+               dev: floppy, id ""
--            qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
+                 unit = 0 (0x0)
--            use_local_qiov = true;
+                 drive = "floppy0"
--        }
++                backend_defaults = "auto"
--        tail_buf = qemu_blockalign(bs, align);
+                 logical_block_size = 512 (512 B)
--        qemu_iovec_add(&local_qiov, tail_buf,
+                 physical_block_size = 512 (512 B)
--                       align - ((offset + bytes) & (align - 1)));
+                 min_io_size = 0 (0 B)
--
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0
--        bytes = ROUND_UP(bytes, align);
+               dev: floppy, id ""
--    }
+                 unit = 0 (0x0)
-+    bdrv_pad_request(bs, &qiov, &offset, &bytes, &pad);
+                 drive = "none0"
++                backend_defaults = "auto"
-     tracked_request_begin(&req, bs, offset, bytes, BDRV_TRACKED_READ);
+                 logical_block_size = 512 (512 B)
--    ret = bdrv_aligned_preadv(child, &req, offset, bytes, align,
+                 physical_block_size = 512 (512 B)
--                              use_local_qiov ? &local_qiov : qiov,
+                 min_io_size = 0 (0 B)
--                              flags);
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,unit=1
-+    ret = bdrv_aligned_preadv(child, &req, offset, bytes,
+               dev: floppy, id ""
-+                              bs->bl.request_alignment,
+                 unit = 1 (0x1)
-+                              qiov, flags);
+                 drive = "none0"
-     tracked_request_end(&req);
++                backend_defaults = "auto"
-     bdrv_dec_in_flight(bs);
+                 logical_block_size = 512 (512 B)
+                 physical_block_size = 512 (512 B)
--    if (use_local_qiov) {
+                 min_io_size = 0 (0 B)
--        qemu_iovec_destroy(&local_qiov);
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
--        qemu_vfree(head_buf);
+               dev: floppy, id ""
--        qemu_vfree(tail_buf);
+                 unit = 1 (0x1)
--    }
+                 drive = "none1"
-+    bdrv_padding_destroy(&pad);
++                backend_defaults = "auto"
+                 logical_block_size = 512 (512 B)
-     return ret;
+                 physical_block_size = 512 (512 B)
- }
+                 min_io_size = 0 (0 B)
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
-                                                 BdrvTrackedRequest *req)
+               dev: floppy, id ""
- {
+                 unit = 0 (0x0)
-     BlockDriverState *bs = child->bs;
+                 drive = "none0"
--    uint8_t *buf = NULL;
++                backend_defaults = "auto"
-     QEMUIOVector local_qiov;
+                 logical_block_size = 512 (512 B)
-     uint64_t align = bs->bl.request_alignment;
+                 physical_block_size = 512 (512 B)
--    unsigned int head_padding_bytes, tail_padding_bytes;
+                 min_io_size = 0 (0 B)
-     int ret = 0;
+@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
-+    bool padding;
+               dev: floppy, id ""
-+    BdrvRequestPadding pad;
+                 unit = 1 (0x1)
+                 drive = "none0"
--    head_padding_bytes = offset & (align - 1);
++                backend_defaults = "auto"
--    tail_padding_bytes = (align - (offset + bytes)) & (align - 1);
+                 logical_block_size = 512 (512 B)
--
+                 physical_block_size = 512 (512 B)
--
+                 min_io_size = 0 (0 B)
--    assert(flags & BDRV_REQ_ZERO_WRITE);
+@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
--    if (head_padding_bytes || tail_padding_bytes) {
+               dev: floppy, id ""
--        buf = qemu_blockalign(bs, align);
+                 unit = 0 (0x0)
--        qemu_iovec_init_buf(&local_qiov, buf, align);
+                 drive = "floppy0"
--    }
++                backend_defaults = "auto"
--    if (head_padding_bytes) {
+                 logical_block_size = 512 (512 B)
--        uint64_t zero_bytes = MIN(bytes, align - head_padding_bytes);
+                 physical_block_size = 512 (512 B)
--
+                 min_io_size = 0 (0 B)
--        /* RMW the unaligned part before head. */
+@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
-+    padding = bdrv_init_padding(bs, offset, bytes, &pad);
+               dev: floppy, id ""
-+    if (padding) {
+                 unit = 1 (0x1)
-         mark_request_serialising(req, align);
+                 drive = "none0"
-         wait_serialising_requests(req);
++                backend_defaults = "auto"
--        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
+                 logical_block_size = 512 (512 B)
--        ret = bdrv_aligned_preadv(child, req, offset & ~(align - 1), align,
+                 physical_block_size = 512 (512 B)
--                                  align, &local_qiov, 0);
+                 min_io_size = 0 (0 B)
--        if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
--            goto fail;
+               dev: floppy, id ""
--        }
+                 unit = 0 (0x0)
--        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
+                 drive = "floppy0"
++                backend_defaults = "auto"
--        memset(buf + head_padding_bytes, 0, zero_bytes);
+                 logical_block_size = 512 (512 B)
--        ret = bdrv_aligned_pwritev(child, req, offset & ~(align - 1), align,
+                 physical_block_size = 512 (512 B)
--                                   align, &local_qiov,
+                 min_io_size = 0 (0 B)
--                                   flags & ~BDRV_REQ_ZERO_WRITE);
+@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
--        if (ret < 0) {
+               dev: floppy, id ""
--            goto fail;
+                 unit = 0 (0x0)
-+        bdrv_padding_rmw_read(child, req, &pad, true);
+                 drive = "none0"
-+
++                backend_defaults = "auto"
-+        if (pad.head || pad.merge_reads) {
+                 logical_block_size = 512 (512 B)
-+            int64_t aligned_offset = offset & ~(align - 1);
+                 physical_block_size = 512 (512 B)
-+            int64_t write_bytes = pad.merge_reads ? pad.buf_len : align;
+                 min_io_size = 0 (0 B)
-+
+@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
-+            qemu_iovec_init_buf(&local_qiov, pad.buf, write_bytes);
+               dev: floppy, id ""
-+            ret = bdrv_aligned_pwritev(child, req, aligned_offset, write_bytes,
+                 unit = 1 (0x1)
-+                                       align, &local_qiov,
+                 drive = "floppy1"
-+                                       flags & ~BDRV_REQ_ZERO_WRITE);
++                backend_defaults = "auto"
-+            if (ret < 0 || pad.merge_reads) {
+                 logical_block_size = 512 (512 B)
-+                /* Error or all work is done */
+                 physical_block_size = 512 (512 B)
-+                goto out;
+                 min_io_size = 0 (0 B)
-+            }
+@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
-+            offset += write_bytes - pad.head;
+               dev: floppy, id ""
-+            bytes -= write_bytes - pad.head;
+                 unit = 0 (0x0)
-         }
+                 drive = "none0"
--        offset += zero_bytes;
++                backend_defaults = "auto"
--        bytes -= zero_bytes;
+                 logical_block_size = 512 (512 B)
-     }
+                 physical_block_size = 512 (512 B)
+                 min_io_size = 0 (0 B)
-     assert(!bytes || (offset & (align - 1)) == 0);
+@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
+               dev: floppy, id ""
-         ret = bdrv_aligned_pwritev(child, req, offset, aligned_bytes, align,
+                 unit = 1 (0x1)
-                                    NULL, flags);
+                 drive = "floppy1"
-         if (ret < 0) {
++                backend_defaults = "auto"
--            goto fail;
+                 logical_block_size = 512 (512 B)
-+            goto out;
+                 physical_block_size = 512 (512 B)
-         }
+                 min_io_size = 0 (0 B)
-         bytes -= aligned_bytes;
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
-         offset += aligned_bytes;
+               dev: floppy, id ""
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_co_do_zero_pwritev(BdrvChild *child,
+                 unit = 1 (0x1)
+                 drive = "none0"
-     assert(!bytes || (offset & (align - 1)) == 0);
++                backend_defaults = "auto"
-     if (bytes) {
+                 logical_block_size = 512 (512 B)
--        assert(align == tail_padding_bytes + bytes);
+                 physical_block_size = 512 (512 B)
--        /* RMW the unaligned part after tail. */
+                 min_io_size = 0 (0 B)
--        mark_request_serialising(req, align);
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
--        wait_serialising_requests(req);
+               dev: floppy, id ""
--        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
+                 unit = 0 (0x0)
--        ret = bdrv_aligned_preadv(child, req, offset, align,
+                 drive = "floppy0"
--                                  align, &local_qiov, 0);
++                backend_defaults = "auto"
--        if (ret < 0) {
+                 logical_block_size = 512 (512 B)
--            goto fail;
+                 physical_block_size = 512 (512 B)
--        }
+                 min_io_size = 0 (0 B)
--        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_TAIL);
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
-+        assert(align == pad.tail + bytes);
+               dev: floppy, id ""
+                 unit = 1 (0x1)
--        memset(buf, 0, bytes);
+                 drive = "none0"
-+        qemu_iovec_init_buf(&local_qiov, pad.tail_buf, align);
++                backend_defaults = "auto"
-         ret = bdrv_aligned_pwritev(child, req, offset, align, align,
+                 logical_block_size = 512 (512 B)
-                                    &local_qiov, flags & ~BDRV_REQ_ZERO_WRITE);
+                 physical_block_size = 512 (512 B)
-     }
+                 min_io_size = 0 (0 B)
--fail:
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
--    qemu_vfree(buf);
+               dev: floppy, id ""
-+
+                 unit = 0 (0x0)
-+out:
+                 drive = "floppy0"
-+    bdrv_padding_destroy(&pad);
++                backend_defaults = "auto"
-+
+                 logical_block_size = 512 (512 B)
-     return ret;
+                 physical_block_size = 512 (512 B)
--
+                 min_io_size = 0 (0 B)
- }
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -global floppy.drive=none0 -device
+               dev: floppy, id ""
- /*
+                 unit = 0 (0x0)
-@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
+                 drive = "none0"
-     BlockDriverState *bs = child->bs;
++                backend_defaults = "auto"
-     BdrvTrackedRequest req;
+                 logical_block_size = 512 (512 B)
-     uint64_t align = bs->bl.request_alignment;
+                 physical_block_size = 512 (512 B)
--    uint8_t *head_buf = NULL;
+                 min_io_size = 0 (0 B)
--    uint8_t *tail_buf = NULL;
+@@ -XXX,XX +XXX,XX @@ Testing: -device floppy
--    QEMUIOVector local_qiov;
+               dev: floppy, id ""
--    bool use_local_qiov = false;
+                 unit = 0 (0x0)
-+    BdrvRequestPadding pad;
+                 drive = ""
-     int ret;
++                backend_defaults = "auto"
+                 logical_block_size = 512 (512 B)
-     trace_bdrv_co_pwritev(child->bs, offset, bytes, flags);
+                 physical_block_size = 512 (512 B)
-@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
+                 min_io_size = 0 (0 B)
-         goto out;
+@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=120
-     }
+               dev: floppy, id ""
+                 unit = 0 (0x0)
--    if (offset & (align - 1)) {
+                 drive = ""
--        QEMUIOVector head_qiov;
++                backend_defaults = "auto"
--
+                 logical_block_size = 512 (512 B)
-+    if (bdrv_pad_request(bs, &qiov, &offset, &bytes, &pad)) {
+                 physical_block_size = 512 (512 B)
-         mark_request_serialising(&req, align);
+                 min_io_size = 0 (0 B)
-         wait_serialising_requests(&req);
+@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=144
--
+               dev: floppy, id ""
--        head_buf = qemu_blockalign(bs, align);
+                 unit = 0 (0x0)
--        qemu_iovec_init_buf(&head_qiov, head_buf, align);
+                 drive = ""
--
++                backend_defaults = "auto"
--        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_HEAD);
+                 logical_block_size = 512 (512 B)
--        ret = bdrv_aligned_preadv(child, &req, offset & ~(align - 1), align,
+                 physical_block_size = 512 (512 B)
--                                  align, &head_qiov, 0);
+                 min_io_size = 0 (0 B)
--        if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=288
--            goto fail;
+               dev: floppy, id ""
--        }
+                 unit = 0 (0x0)
--        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_AFTER_HEAD);
+                 drive = ""
--
++                backend_defaults = "auto"
--        qemu_iovec_init(&local_qiov, qiov->niov + 2);
+                 logical_block_size = 512 (512 B)
--        qemu_iovec_add(&local_qiov, head_buf, offset & (align - 1));
+                 physical_block_size = 512 (512 B)
--        qemu_iovec_concat(&local_qiov, qiov, 0, qiov->size);
+                 min_io_size = 0 (0 B)
--        use_local_qiov = true;
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
--
+               dev: floppy, id ""
--        bytes += offset & (align - 1);
+                 unit = 0 (0x0)
--        offset = offset & ~(align - 1);
+                 drive = "none0"
--
++                backend_defaults = "auto"
--        /* We have read the tail already if the request is smaller
+                 logical_block_size = 512 (512 B)
--         * than one aligned block.
+                 physical_block_size = 512 (512 B)
--         */
+                 min_io_size = 0 (0 B)
--        if (bytes < align) {
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
--            qemu_iovec_add(&local_qiov, head_buf + bytes, align - bytes);
+               dev: floppy, id ""
--            bytes = align;
+                 unit = 0 (0x0)
--        }
+                 drive = "none0"
--    }
++                backend_defaults = "auto"
--
+                 logical_block_size = 512 (512 B)
--    if ((offset + bytes) & (align - 1)) {
+                 physical_block_size = 512 (512 B)
--        QEMUIOVector tail_qiov;
+                 min_io_size = 0 (0 B)
--        size_t tail_bytes;
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,logical
--        bool waited;
+               dev: floppy, id ""
--
+                 unit = 0 (0x0)
--        mark_request_serialising(&req, align);
+                 drive = "none0"
--        waited = wait_serialising_requests(&req);
++                backend_defaults = "auto"
--        assert(!waited || !use_local_qiov);
+                 logical_block_size = 512 (512 B)
--
+                 physical_block_size = 512 (512 B)
--        tail_buf = qemu_blockalign(bs, align);
+                 min_io_size = 0 (0 B)
--        qemu_iovec_init_buf(&tail_qiov, tail_buf, align);
+@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,physica
--
+               dev: floppy, id ""
--        bdrv_debug_event(bs, BLKDBG_PWRITEV_RMW_TAIL);
+                 unit = 0 (0x0)
--        ret = bdrv_aligned_preadv(child, &req, (offset + bytes) & ~(align - 1),
+                 drive = "none0"
--                                  align, align, &tail_qiov, 0);
++                backend_defaults = "auto"
--        if (ret < 0) {
+                 logical_block_size = 512 (512 B)
--            goto fail;
+                 physical_block_size = 512 (512 B)
--        }
+                 min_io_size = 0 (0 B)
 -        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;
  }
 --
-.21.0
+.31.1

-[Qemu-devel] [PULL 04/12] block: define .*_part io handlers in BlockDriver
+Deleted patch
-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 +-
-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;
---
-.21.0

-[Qemu-devel] [PULL 05/12] block/io: bdrv_co_do_copy_on_readv: use and support qiov_offset
+Deleted patch
-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 +++++++++---------
-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;
---
-.21.0

-[Qemu-devel] [PULL 06/12] block/io: bdrv_co_do_copy_on_readv: lazy allocation
+Deleted patch
-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 ++++++++++++---------
-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,
---
-.21.0

-[Qemu-devel] [PULL 07/12] block/io: bdrv_aligned_preadv: use and support qiov_offset
+Deleted patch
-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 ++++++++-------------
-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);
---
-.21.0

-[Qemu-devel] [PULL 08/12] block/io: bdrv_aligned_pwritev: use and support qiov_offset
+[PULL 5/5] block/io: Merge discard request alignments
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+From: Akihiko Odaki <akihiko.odaki@gmail.com>
-Use and support new API in bdrv_aligned_pwritev.
+Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
+Message-id: 20210705130458.97642-3-akihiko.odaki@gmail.com
 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 +++++++++++++--------------
+ block/io.c | 2 ++
-file changed, 13 insertions(+), 14 deletions(-)
+file changed, 2 insertions(+)
 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,
+@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_begin_single(BdrvChild *c, bool poll)
-  */
- static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
+ static void bdrv_merge_limits(BlockLimits *dst, const BlockLimits *src)
      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;
++    dst->pdiscard_alignment = MAX(dst->pdiscard_alignment,
-     BlockDriver *drv = bs->drv;
++                                  src->pdiscard_alignment);
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_aligned_pwritev(BdrvChild *child,
+     dst->opt_transfer = MAX(dst->opt_transfer, src->opt_transfer);
-     assert(is_power_of_2(align));
+     dst->max_transfer = MIN_NON_ZERO(dst->max_transfer, src->max_transfer);
-     assert((offset & (align - 1)) == 0);
+     dst->max_hw_transfer = MIN_NON_ZERO(dst->max_hw_transfer,
      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
+.31.1

-[Qemu-devel] [PULL 10/12] block/qcow2: refactor qcow2_co_preadv to use buffer-based io
+Deleted patch
-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 ++++++++++++++++------------
-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;
---
-.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

The following changes since commit 711c0418c8c1ce3a24346f058b001c4c5a2f0f81:

Merge remote-tracking branch 'remotes/philmd/tags/mips-20210702' into staging (2021-07-04 14:04:12 +0100)

are available in the Git repository at:

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

for you to fetch changes up to 9f460c64e13897117f35ffb61f6f5e0102cabc70:

block/io: Merge discard request alignments (2021-07-06 14:28:55 +0100)

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

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

Akihiko Odaki (3):
  block/file-posix: Optimize for macOS
  block: Add backend_defaults property
  block/io: Merge discard request alignments

Stefan Hajnoczi (2):
  util/async: add a human-readable name to BHs for debugging
  util/async: print leaked BH name when AioContext finalizes

-- 
2.31.1

It can be difficult to debug issues with BHs in production environments.
Although BHs can usually be identified by looking up their ->cb()
function pointer, this requires debug information for the program. It is
also not possible to print human-readable diagnostics about BHs because
they have no identifier.

This patch adds a name to each BH. The name is not unique per instance
but differentiates between cb() functions, which is usually enough. It's
done by changing aio_bh_new() and friends to macros that stringify cb.

The next patch will use the name field when reporting leaked BHs.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-Id: <20210414200247.917496-2-stefanha@redhat.com>
---
 include/block/aio.h            | 31 ++++++++++++++++++++++++++++---
 include/qemu/main-loop.h       |  4 +++-
 tests/unit/ptimer-test-stubs.c |  2 +-
 util/async.c                   |  9 +++++++--
 util/main-loop.c               |  4 ++--
 5 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/include/block/aio.h b/include/block/aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ void aio_context_acquire(AioContext *ctx);
 /* Relinquish ownership of the AioContext. */
 void aio_context_release(AioContext *ctx);
 
+/**
+ * aio_bh_schedule_oneshot_full: Allocate a new bottom half structure that will
+ * run only once and as soon as possible.
+ *
+ * @name: A human-readable identifier for debugging purposes.
+ */
+void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
+                                  const char *name);
+
 /**
  * aio_bh_schedule_oneshot: Allocate a new bottom half structure that will run
  * only once and as soon as possible.
+ *
+ * A convenience wrapper for aio_bh_schedule_oneshot_full() that uses cb as the
+ * name string.
  */
-void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
+#define aio_bh_schedule_oneshot(ctx, cb, opaque) \
+    aio_bh_schedule_oneshot_full((ctx), (cb), (opaque), (stringify(cb)))
 
 /**
- * aio_bh_new: Allocate a new bottom half structure.
+ * aio_bh_new_full: Allocate a new bottom half structure.
  *
  * Bottom halves are lightweight callbacks whose invocation is guaranteed
  * to be wait-free, thread-safe and signal-safe.  The #QEMUBH structure
  * is opaque and must be allocated prior to its use.
+ *
+ * @name: A human-readable identifier for debugging purposes.
  */
-QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
+QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
+                        const char *name);
+
+/**
+ * aio_bh_new: Allocate a new bottom half structure
+ *
+ * A convenience wrapper for aio_bh_new_full() that uses the cb as the name
+ * string.
+ */
+#define aio_bh_new(ctx, cb, opaque) \
+    aio_bh_new_full((ctx), (cb), (opaque), (stringify(cb)))
 
 /**
  * aio_notify: Force processing of pending events.
diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/main-loop.h
+++ b/include/qemu/main-loop.h
@@ -XXX,XX +XXX,XX @@ void qemu_cond_timedwait_iothread(QemuCond *cond, int ms);
 
 void qemu_fd_register(int fd);
 
-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
+#define qemu_bh_new(cb, opaque) \
+    qemu_bh_new_full((cb), (opaque), (stringify(cb)))
+QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name);
 void qemu_bh_schedule_idle(QEMUBH *bh);
 
 enum {
diff --git a/tests/unit/ptimer-test-stubs.c b/tests/unit/ptimer-test-stubs.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/ptimer-test-stubs.c
+++ b/tests/unit/ptimer-test-stubs.c
@@ -XXX,XX +XXX,XX @@ int64_t qemu_clock_deadline_ns_all(QEMUClockType type, int attr_mask)
     return deadline;
 }
 
-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
+QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
 {
     QEMUBH *bh = g_new(QEMUBH, 1);
 
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ enum {
 
 struct QEMUBH {
     AioContext *ctx;
+    const char *name;
     QEMUBHFunc *cb;
     void *opaque;
     QSLIST_ENTRY(QEMUBH) next;
@@ -XXX,XX +XXX,XX @@ static QEMUBH *aio_bh_dequeue(BHList *head, unsigned *flags)
     return bh;
 }
 
-void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
+void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb,
+                                  void *opaque, const char *name)
 {
     QEMUBH *bh;
     bh = g_new(QEMUBH, 1);
@@ -XXX,XX +XXX,XX @@ void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
         .ctx = ctx,
         .cb = cb,
         .opaque = opaque,
+        .name = name,
     };
     aio_bh_enqueue(bh, BH_SCHEDULED | BH_ONESHOT);
 }
 
-QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
+QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
+                        const char *name)
 {
     QEMUBH *bh;
     bh = g_new(QEMUBH, 1);
@@ -XXX,XX +XXX,XX @@ QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
         .ctx = ctx,
         .cb = cb,
         .opaque = opaque,
+        .name = name,
     };
     return bh;
 }
diff --git a/util/main-loop.c b/util/main-loop.c
index XXXXXXX..XXXXXXX 100644
--- a/util/main-loop.c
+++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@ void main_loop_wait(int nonblocking)
 
 /* Functions to operate on the main QEMU AioContext.  */
 
-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
+QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
 {
-    return aio_bh_new(qemu_aio_context, cb, opaque);
+    return aio_bh_new_full(qemu_aio_context, cb, opaque, name);
 }
 
 /*
-- 
2.31.1

BHs must be deleted before the AioContext is finalized. If not, it's a
bug and probably indicates that some part of the program still expects
the BH to run in the future. That can lead to memory leaks, inconsistent
state, or just hangs.

Unfortunately the assert(flags & BH_DELETED) call in aio_ctx_finalize()
is difficult to debug because the assertion failure contains no
information about the BH!

Use the QEMUBH name field added in the previous patch to show a useful
error when a leaked BH is detected.

Suggested-by: Eric Ernst <eric.g.ernst@gmail.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20210414200247.917496-3-stefanha@redhat.com>
---
 util/async.c | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ aio_ctx_finalize(GSource     *source)
     assert(QSIMPLEQ_EMPTY(&ctx->bh_slice_list));
 
     while ((bh = aio_bh_dequeue(&ctx->bh_list, &flags))) {
-        /* qemu_bh_delete() must have been called on BHs in this AioContext */
-        assert(flags & BH_DELETED);
+        /*
+         * qemu_bh_delete() must have been called on BHs in this AioContext. In
+         * many cases memory leaks, hangs, or inconsistent state occur when a
+         * BH is leaked because something still expects it to run.
+         *
+         * If you hit this, fix the lifecycle of the BH so that
+         * qemu_bh_delete() and any associated cleanup is called before the
+         * AioContext is finalized.
+         */
+        if (unlikely(!(flags & BH_DELETED))) {
+            fprintf(stderr, "%s: BH '%s' leaked, aborting...\n",
+                    __func__, bh->name);
+            abort();
+        }
 
         g_free(bh);
     }
-- 
2.31.1

From: Akihiko Odaki <akihiko.odaki@gmail.com>

This commit introduces "punch hole" operation and optimizes transfer
block size for macOS.

Thanks to Konstantin Nazarov for detailed analysis of a flaw in an
old version of this change:
https://gist.github.com/akihikodaki/87df4149e7ca87f18dc56807ec5a1bc5#gistcomment-3654667

Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Message-id: 20210705130458.97642-1-akihiko.odaki@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/file-posix.c | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

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 @@
 #if defined(HAVE_HOST_BLOCK_DEVICE)
 #include <paths.h>
 #include <sys/param.h>
+#include <sys/mount.h>
 #include <IOKit/IOKitLib.h>
 #include <IOKit/IOBSD.h>
 #include <IOKit/storage/IOMediaBSDClient.h>
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
         return;
     }
 
+#if defined(__APPLE__) && (__MACH__)
+    struct statfs buf;
+
+    if (!fstatfs(s->fd, &buf)) {
+        bs->bl.opt_transfer = buf.f_iosize;
+        bs->bl.pdiscard_alignment = buf.f_bsize;
+    }
+#endif
+
     if (bs->sg || S_ISBLK(st.st_mode)) {
         int ret = hdev_get_max_hw_transfer(s->fd, &st);
 
@@ -XXX,XX +XXX,XX @@ out:
     }
 }
 
+#if defined(CONFIG_FALLOCATE) || defined(BLKZEROOUT) || defined(BLKDISCARD)
 static int translate_err(int err)
 {
     if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
@@ -XXX,XX +XXX,XX @@ static int translate_err(int err)
     }
     return err;
 }
+#endif
 
 #ifdef CONFIG_FALLOCATE
 static int do_fallocate(int fd, int mode, off_t offset, off_t len)
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_discard(void *opaque)
             }
         } while (errno == EINTR);
 
-        ret = -errno;
+        ret = translate_err(-errno);
 #endif
     } else {
 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
         ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
                            aiocb->aio_offset, aiocb->aio_nbytes);
+        ret = translate_err(-errno);
+#elif defined(__APPLE__) && (__MACH__)
+        fpunchhole_t fpunchhole;
+        fpunchhole.fp_flags = 0;
+        fpunchhole.reserved = 0;
+        fpunchhole.fp_offset = aiocb->aio_offset;
+        fpunchhole.fp_length = aiocb->aio_nbytes;
+        if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) {
+            ret = errno == ENODEV ? -ENOTSUP : -errno;
+        } else {
+            ret = 0;
+        }
 #endif
     }
 
-    ret = translate_err(ret);
     if (ret == -ENOTSUP) {
         s->has_discard = false;
     }
-- 
2.31.1

From: Akihiko Odaki <akihiko.odaki@gmail.com>

backend_defaults property allow users to control if default block
properties should be decided with backend information.

If it is off, any backend information will be discarded, which is
suitable if you plan to perform live migration to a different disk backend.

If it is on, a block device may utilize backend information more
aggressively.

By default, it is auto, which uses backend information for block
sizes and ignores the others, which is consistent with the older
versions.

Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Message-id: 20210705130458.97642-2-akihiko.odaki@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/block/block.h   |  3 +++
 hw/block/block.c           | 42 ++++++++++++++++++++++++++++++++++----
 tests/qemu-iotests/172.out | 38 ++++++++++++++++++++++++++++++++++
 3 files changed, 79 insertions(+), 4 deletions(-)

diff --git a/include/hw/block/block.h b/include/hw/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/block/block.h
+++ b/include/hw/block/block.h
@@ -XXX,XX +XXX,XX @@
 
 typedef struct BlockConf {
     BlockBackend *blk;
+    OnOffAuto backend_defaults;
     uint32_t physical_block_size;
     uint32_t logical_block_size;
     uint32_t min_io_size;
@@ -XXX,XX +XXX,XX @@ static inline unsigned int get_physical_block_exp(BlockConf *conf)
 }
 
 #define DEFINE_BLOCK_PROPERTIES_BASE(_state, _conf)                     \
+    DEFINE_PROP_ON_OFF_AUTO("backend_defaults", _state,                 \
+                            _conf.backend_defaults, ON_OFF_AUTO_AUTO),  \
     DEFINE_PROP_BLOCKSIZE("logical_block_size", _state,                 \
                           _conf.logical_block_size),                    \
     DEFINE_PROP_BLOCKSIZE("physical_block_size", _state,                \
diff --git a/hw/block/block.c b/hw/block/block.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/block.c
+++ b/hw/block/block.c
@@ -XXX,XX +XXX,XX @@ bool blkconf_blocksizes(BlockConf *conf, Error **errp)
 {
     BlockBackend *blk = conf->blk;
     BlockSizes blocksizes;
-    int backend_ret;
+    BlockDriverState *bs;
+    bool use_blocksizes;
+    bool use_bs;
+
+    switch (conf->backend_defaults) {
+    case ON_OFF_AUTO_AUTO:
+        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
+        use_bs = false;
+        break;
+
+    case ON_OFF_AUTO_ON:
+        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
+        bs = blk_bs(blk);
+        use_bs = bs;
+        break;
+
+    case ON_OFF_AUTO_OFF:
+        use_blocksizes = false;
+        use_bs = false;
+        break;
+
+    default:
+        abort();
+    }
 
-    backend_ret = blk_probe_blocksizes(blk, &blocksizes);
     /* fill in detected values if they are not defined via qemu command line */
     if (!conf->physical_block_size) {
-        if (!backend_ret) {
+        if (use_blocksizes) {
            conf->physical_block_size = blocksizes.phys;
         } else {
             conf->physical_block_size = BDRV_SECTOR_SIZE;
         }
     }
     if (!conf->logical_block_size) {
-        if (!backend_ret) {
+        if (use_blocksizes) {
             conf->logical_block_size = blocksizes.log;
         } else {
             conf->logical_block_size = BDRV_SECTOR_SIZE;
         }
     }
+    if (use_bs) {
+        if (!conf->opt_io_size) {
+            conf->opt_io_size = bs->bl.opt_transfer;
+        }
+        if (conf->discard_granularity == -1) {
+            if (bs->bl.pdiscard_alignment) {
+                conf->discard_granularity = bs->bl.pdiscard_alignment;
+            } else if (bs->bl.request_alignment != 1) {
+                conf->discard_granularity = bs->bl.request_alignment;
+            }
+        }
+    }
 
     if (conf->logical_block_size > conf->physical_block_size) {
         error_setg(errp,
diff --git a/tests/qemu-iotests/172.out b/tests/qemu-iotests/172.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/172.out
+++ b/tests/qemu-iotests/172.out
@@ -XXX,XX +XXX,XX @@ Testing:
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,unit=1
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -global floppy.drive=none0 -device
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=120
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=144
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=288
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,logical
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,physica
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
-- 
2.31.1