Series comparison

-[PULL 00/18] Block patches
+[PULL 00/11] Block patches
-The following changes since commit 672f9d0df10a68a5c5f2b32cbc8284abf9f5ee18:
+The following changes since commit 88afdc92b644120e0182c8567e1b1d236e471b12:
-  Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging (2020-02-18 14:23:43 +0000)
+  Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging (2021-09-05 15:48:42 +0100)
 are available in the Git repository at:
-  https://github.com/XanClic/qemu.git tags/pull-block-2020-02-20
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to dff8d44c96f128480430b0c59ed8760917dbd427:
+for you to fetch changes up to 9bd2788f49c331b02372cc257b11e4c984d39708:
-  iotests: Test snapshot -l field separation (2020-02-20 16:43:42 +0100)
+  block/nvme: Only report VFIO error on failed retry (2021-09-07 09:08:24 +0100)
 ----------------------------------------------------------------
-Block patches:
+Pull request
-- qemu-img convert: New --target-is-zero parameter
-- qcow2: Specify non-default compression type flag
+Userspace NVMe driver patches.
 - optionally flat output for query-named-block-nodes
 - some fixes
 - pseudo-creation of images on block devices is now done by a generic
   block layer function
 ----------------------------------------------------------------
-Daniel P. Berrangé (1):
-  block: always fill entire LUKS header space with zeros
-David Edmondson (1):
+Philippe Mathieu-Daudé (11):
-  qemu-img: Add --target-is-zero to convert
+  block/nvme: Use safer trace format string
   util/vfio-helpers: Let qemu_vfio_verify_mappings() use error_report()
   util/vfio-helpers: Replace qemu_mutex_lock() calls with
     QEMU_LOCK_GUARD
   util/vfio-helpers: Remove unreachable code in qemu_vfio_dma_map()
   block/nvme: Have nvme_create_queue_pair() report errors consistently
   util/vfio-helpers: Pass Error handle to qemu_vfio_dma_map()
   util/vfio-helpers: Extract qemu_vfio_water_mark_reached()
   util/vfio-helpers: Use error_setg in qemu_vfio_find_[fixed/temp]_iova
   util/vfio-helpers: Simplify qemu_vfio_dma_map() returning directly
   util/vfio-helpers: Let qemu_vfio_do_mapping() propagate Error
   block/nvme: Only report VFIO error on failed retry
-Max Reitz (11):
+ include/qemu/vfio-helpers.h |  2 +-
-  iotests/147: Fix drive parameters
+ block/nvme.c                | 29 +++++++----
-  iotests/279: Fix for non-qcow2 formats
+ util/vfio-helpers.c         | 99 ++++++++++++++++++++-----------------
-  block/nbd: Fix hang in .bdrv_close()
+ block/trace-events          |  2 +-
-  block: Generic file creation fallback
+files changed, 76 insertions(+), 56 deletions(-)
   file-posix: Drop hdev_co_create_opts()
   iscsi: Drop iscsi_co_create_opts()
   iotests: Add test for image creation fallback
   qemu-img: Fix convert -n -B for backing-less targets
   iotests: Test convert -n -B to backing-less target
   block: Fix VM size field width in snapshot dump
   iotests: Test snapshot -l field separation
 Peter Krempa (1):
   qapi: Allow getting flat output from 'query-named-block-nodes'
 Thomas Huth (1):
   iotests: Remove the superfluous 2nd check for the availability of
     quorum
 Vladimir Sementsov-Ogievskiy (3):
   docs: improve qcow2 spec about extending image header
   docs: qcow2: introduce compression type feature
   block/backup-top: fix flags handling
  block.c                    | 164 +++++++++++++++++++++++++++++++++----
  block/backup-top.c         |  31 ++++---
  block/file-posix.c         |  67 ---------------
  block/iscsi.c              |  56 -------------
  block/nbd.c                |  14 +++-
  block/qapi.c               |  15 +++-
  block/qcow2.c              |  11 ++-
  blockdev.c                 |   8 +-
  docs/interop/qcow2.txt     |  64 ++++++++++++++-
  docs/interop/qemu-img.rst  |   9 +-
  include/block/block.h      |   2 +-
  include/block/qapi.h       |   4 +-
  monitor/hmp-cmds.c         |   2 +-
  qapi/block-core.json       |   7 +-
  qemu-img-cmds.hx           |   4 +-
  qemu-img.c                 |  28 ++++++-
  tests/qemu-iotests/122     |  14 ++++
  tests/qemu-iotests/122.out |   5 ++
  tests/qemu-iotests/139     |   3 -
  tests/qemu-iotests/147     |   2 +-
  tests/qemu-iotests/259     |  62 ++++++++++++++
  tests/qemu-iotests/259.out |  14 ++++
  tests/qemu-iotests/279     |   7 +-
  tests/qemu-iotests/284     |  97 ++++++++++++++++++++++
  tests/qemu-iotests/284.out |  62 ++++++++++++++
  tests/qemu-iotests/286     |  76 +++++++++++++++++
  tests/qemu-iotests/286.out |   8 ++
  tests/qemu-iotests/group   |   3 +
 files changed, 659 insertions(+), 180 deletions(-)
  create mode 100755 tests/qemu-iotests/259
  create mode 100644 tests/qemu-iotests/259.out
  create mode 100755 tests/qemu-iotests/284
  create mode 100644 tests/qemu-iotests/284.out
  create mode 100755 tests/qemu-iotests/286
  create mode 100644 tests/qemu-iotests/286.out
 --
-.24.1
+.31.1

-[PULL 01/18] docs: improve qcow2 spec about extending image header
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Make it more obvious how to add new fields to the version 3 header and
-how to interpret them.
-The specification is adjusted so that for new defined optional fields:
-. Software may support some of these optional fields and ignore the
-   others, which means that features may be backported to downstream
-   Qemu independently.
-. If we want to add incompatible field (or a field, for which some of
-   its values would be incompatible), it must be accompanied by
-   incompatible feature bit.
-Also the concept of "default is zero" is clarified, as it's strange to
-say that the value of the field is assumed to be zero for the software
-version which don't know about the field at all and don't know how to
-treat it be it zero or not.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Message-Id: <20200131142219.3264-2-vsementsov@virtuozzo.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
-[mreitz: s/some its/some of its/]
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- docs/interop/qcow2.txt | 45 +++++++++++++++++++++++++++++++++++++++---
-file changed, 42 insertions(+), 3 deletions(-)
-diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
-index XXXXXXX..XXXXXXX 100644
---- a/docs/interop/qcow2.txt
-+++ b/docs/interop/qcow2.txt
-@@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header:
-                     Offset into the image file at which the snapshot table
-                     starts. Must be aligned to a cluster boundary.
--If the version is 3 or higher, the header has the following additional fields.
--For version 2, the values are assumed to be zero, unless specified otherwise
--in the description of a field.
-+For version 2, the header is exactly 72 bytes in length, and finishes here.
-+For version 3 or higher, the header length is at least 104 bytes, including
-+the next fields through header_length.
--  79:  incompatible_features
-                     Bitmask of incompatible features. An implementation must
-@@ -XXX,XX +XXX,XX @@ in the description of a field.
-- 103:  header_length
-                     Length of the header structure in bytes. For version 2
-                     images, the length is always assumed to be 72 bytes.
-+                    For version 3 it's at least 104 bytes and must be a multiple
-+                    of 8.
-+
-+
-+=== Additional fields (version 3 and higher) ===
-+
-+In general, these fields are optional and may be safely ignored by the software,
-+as well as filled by zeros (which is equal to field absence), if software needs
-+to set field B, but does not care about field A which precedes B. More
-+formally, additional fields have the following compatibility rules:
-+
-+1. If the value of the additional field must not be ignored for correct
-+handling of the file, it will be accompanied by a corresponding incompatible
-+feature bit.
-+
-+2. If there are no unrecognized incompatible feature bits set, an unknown
-+additional field may be safely ignored other than preserving its value when
-+rewriting the image header.
-+
-+3. An explicit value of 0 will have the same behavior as when the field is not
-+present*, if not altered by a specific incompatible bit.
-+
-+*. A field is considered not present when header_length is less than or equal
-+to the field's offset. Also, all additional fields are not present for
-+version 2.
-+
-+        < ... No additional fields in the header currently ... >
-+
-+
-+=== Header padding ===
-+
-+@header_length must be a multiple of 8, which means that if the end of the last
-+additional field is not aligned, some padding is needed. This padding must be
-+zeroed, so that if some existing (or future) additional field will fall into
-+the padding, it will be interpreted accordingly to point [3.] of the previous
-+paragraph, i.e.  in the same manner as when this field is not present.
-+
-+
-+=== Header extensions ===
- Directly after the image header, optional sections called header extensions can
- be stored. Each extension has a structure like the following:
---
-.24.1

-[PULL 02/18] docs: qcow2: introduce compression type feature
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-The patch adds a new additional field to the qcow2 header: compression_type,
-which specifies compression type. If field is absent or zero, default
-compression type is set: ZLIB, which corresponds to current behavior.
-New compression type (ZSTD) is to be added in further commit.
-Suggested-by: Denis Plotnikov <dplotnikov@virtuozzo.com>
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Message-Id: <20200131142219.3264-3-vsementsov@virtuozzo.com>
-[mreitz: s/Bits 3-63:  Reserved/Bits 4-63:  Reserved/]
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- docs/interop/qcow2.txt | 21 +++++++++++++++++++--
-file changed, 19 insertions(+), 2 deletions(-)
-diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
-index XXXXXXX..XXXXXXX 100644
---- a/docs/interop/qcow2.txt
-+++ b/docs/interop/qcow2.txt
-@@ -XXX,XX +XXX,XX @@ the next fields through header_length.
-                                 An External Data File Name header extension may
-                                 be present if this bit is set.
--                    Bits 3-63:  Reserved (set to 0)
-+                    Bit 3:      Compression type bit.  If this bit is set,
-+                                a non-default compression is used for compressed
-+                                clusters. The compression_type field must be
-+                                present and not zero.
-+
-+                    Bits 4-63:  Reserved (set to 0)
--  87:  compatible_features
-                     Bitmask of compatible features. An implementation can
-@@ -XXX,XX +XXX,XX @@ present*, if not altered by a specific incompatible bit.
- to the field's offset. Also, all additional fields are not present for
- version 2.
--        < ... No additional fields in the header currently ... >
-+              104:  compression_type
-+
-+                    Defines the compression method used for compressed clusters.
-+                    All compressed clusters in an image use the same compression
-+                    type.
-+
-+                    If the incompatible bit "Compression type" is set: the field
-+                    must be present and non-zero (which means non-zlib
-+                    compression type). Otherwise, this field must not be present
-+                    or must be zero (which means zlib).
-+
-+                    Available compression type values:
-+                        0: zlib <https://www.zlib.net/>
- === Header padding ===
---
-.24.1

-[PULL 03/18] iotests: Remove the superfluous 2nd check for the availability of quorum
+Deleted patch
-From: Thomas Huth <thuth@redhat.com>
-Commit d9df28e7b07 ("iotests: check whitelisted formats") added the
-modern @iotests.skip_if_unsupported() to the functions in this test,
-so we don't need the old explicit test here anymore.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
-Message-Id: <20200129141751.32652-1-thuth@redhat.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
-Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
-Tested-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/139 | 3 ---
-file changed, 3 deletions(-)
-diff --git a/tests/qemu-iotests/139 b/tests/qemu-iotests/139
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/139
-+++ b/tests/qemu-iotests/139
-@@ -XXX,XX +XXX,XX @@ class TestBlockdevDel(iotests.QMPTestCase):
-     @iotests.skip_if_unsupported(['quorum'])
-     def testQuorum(self):
--        if not iotests.supports_quorum():
--            return
--
-         self.addQuorum('quorum0', 'node0', 'node1')
-         # We cannot remove the children of a Quorum device
-         self.delBlockDriverState('node0', expect_error = True)
---
-.24.1

-[PULL 15/18] qemu-img: Fix convert -n -B for backing-less targets
+[PULL 01/11] block/nvme: Use safer trace format string
-s.target_has_backing does not reflect whether the target BDS has a
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
 backing file; it only tells whether we should use a backing file during
 conversion (specified by -B).
-As such, if you use convert -n, the target does not necessarily actually
+Fix when building with -Wshorten-64-to-32:
 have a backing file, and then dereferencing out_bs->backing fails here.
-When converting to an existing file, we should set
+  warning: implicit conversion loses integer precision: 'unsigned long' to 'int' [-Wshorten-64-to-32]
 target_backing_sectors to a negative value, because first, as the
 comment explains, this value is only used for optimization, so it is
 always fine to do that.
-Second, we use this value to determine where the target must be
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
-initialized to zeroes (overlays are initialized to zero after the end of
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-their backing file).  When converting to an existing file, we cannot
+Message-id: 20210902070025.197072-2-philmd@redhat.com
-assume that to be true.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Cc: qemu-stable@nongnu.org
 Fixes: 351c8efff9ad809c822d55620df54d575d536f68
        ("qemu-img: Special post-backing convert handling")
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200121155915.98232-2-mreitz@redhat.com>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- qemu-img.c | 2 +-
+ block/trace-events | 2 +-
 file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/qemu-img.c b/qemu-img.c
+diff --git a/block/trace-events b/block/trace-events
 index XXXXXXX..XXXXXXX 100644
---- a/qemu-img.c
+--- a/block/trace-events
-+++ b/qemu-img.c
++++ b/block/trace-events
-@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
+@@ -XXX,XX +XXX,XX @@ nvme_dsm(void *s, uint64_t offset, uint64_t bytes) "s %p offset 0x%"PRIx64" byte
-         }
+ nvme_dsm_done(void *s, uint64_t offset, uint64_t bytes, int ret) "s %p offset 0x%"PRIx64" bytes %"PRId64" ret %d"
-     }
+ nvme_dma_map_flush(void *s) "s %p"
+ nvme_free_req_queue_wait(void *s, unsigned q_index) "s %p q #%u"
--    if (s.target_has_backing) {
+-nvme_create_queue_pair(unsigned q_index, void *q, unsigned size, void *aio_context, int fd) "index %u q %p size %u aioctx %p fd %d"
-+    if (s.target_has_backing && s.target_is_new) {
++nvme_create_queue_pair(unsigned q_index, void *q, size_t size, void *aio_context, int fd) "index %u q %p size %zu aioctx %p fd %d"
-         /* Errors are treated as "backing length unknown" (which means
+ nvme_free_queue_pair(unsigned q_index, void *q) "index %u q %p"
-          * s.target_backing_sectors has to be negative, which it will
+ nvme_cmd_map_qiov(void *s, void *cmd, void *req, void *qiov, int entries) "s %p cmd %p req %p qiov %p entries %d"
-          * be automatically).  The backing file length is used only
+ nvme_cmd_map_qiov_pages(void *s, int i, uint64_t page) "s %p page[%d] 0x%"PRIx64
 --
-.24.1
+.31.1

-[PULL 17/18] block: Fix VM size field width in snapshot dump
+[PULL 02/11] util/vfio-helpers: Let qemu_vfio_verify_mappings() use error_report()
-When printing the snapshot list (e.g. with qemu-img snapshot -l), the VM
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
 size field is only seven characters wide.  As of de38b5005e9, this is
 not necessarily sufficient: We generally print three digits, and this
 may require a decimal point.  Also, the unit field grew from something
 as plain as "M" to " MiB".  This means that number and unit may take up
 eight characters in total; but we also want spaces in front.
-Considering previously the maximum width was four characters and the
+Instead of displaying the error on stderr, use error_report()
-field width was chosen to be three characters wider, let us adjust the
+which also report to the monitor.
 field width to be eleven now.
-Fixes: de38b5005e946aa3714963ea4c501e279e7d3666
+Reviewed-by: Fam Zheng <fam@euphon.net>
-Buglink: https://bugs.launchpad.net/qemu/+bug/1859989
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
-Message-Id: <20200117105859.241818-2-mreitz@redhat.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Message-id: 20210902070025.197072-3-philmd@redhat.com
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/qapi.c | 4 ++--
+ util/vfio-helpers.c | 4 ++--
 file changed, 2 insertions(+), 2 deletions(-)
-diff --git a/block/qapi.c b/block/qapi.c
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/qapi.c
+--- a/util/vfio-helpers.c
-+++ b/block/qapi.c
++++ b/util/vfio-helpers.c
-@@ -XXX,XX +XXX,XX @@ void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)
+@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_verify_mappings(QEMUVFIOState *s)
-     char *sizing = NULL;
+     if (QEMU_VFIO_DEBUG) {
+         for (i = 0; i < s->nr_mappings - 1; ++i) {
-     if (!sn) {
+             if (!(s->mappings[i].host < s->mappings[i + 1].host)) {
--        qemu_printf("%-10s%-20s%7s%20s%15s",
+-                fprintf(stderr, "item %d not sorted!\n", i);
-+        qemu_printf("%-10s%-20s%11s%20s%15s",
++                error_report("item %d not sorted!", i);
-                     "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
+                 qemu_vfio_dump_mappings(s);
-     } else {
+                 return false;
-         ti = sn->date_sec;
+             }
-@@ -XXX,XX +XXX,XX @@ void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)
+             if (!(s->mappings[i].host + s->mappings[i].size <=
-                  (int)(secs % 60),
+                   s->mappings[i + 1].host)) {
-                  (int)((sn->vm_clock_nsec / 1000000) % 1000));
+-                fprintf(stderr, "item %d overlap with next!\n", i);
-         sizing = size_to_str(sn->vm_state_size);
++                error_report("item %d overlap with next!", i);
--        qemu_printf("%-10s%-20s%7s%20s%15s",
+                 qemu_vfio_dump_mappings(s);
-+        qemu_printf("%-10s%-20s%11s%20s%15s",
+                 return false;
-                     sn->id_str, sn->name,
+             }
                      sizing,
                      date_buf,
 --
-.24.1
+.31.1

-[PULL 11/18] block: Generic file creation fallback
+[PULL 03/11] util/vfio-helpers: Replace qemu_mutex_lock() calls with QEMU_LOCK_GUARD
-If a protocol driver does not support image creation, we can see whether
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
 maybe the file exists already.  If so, just truncating it will be
 sufficient.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Simplify qemu_vfio_dma_[un]map() handlers by replacing a pair of
-Message-Id: <20200122164532.178040-3-mreitz@redhat.com>
+qemu_mutex_lock/qemu_mutex_unlock calls by the WITH_QEMU_LOCK_GUARD
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+macro.
 Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Message-id: 20210902070025.197072-4-philmd@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block.c | 159 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
+ util/vfio-helpers.c | 9 +++------
-file changed, 147 insertions(+), 12 deletions(-)
+file changed, 3 insertions(+), 6 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/util/vfio-helpers.c
-+++ b/block.c
++++ b/util/vfio-helpers.c
-@@ -XXX,XX +XXX,XX @@ out:
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
      assert(QEMU_PTR_IS_ALIGNED(host, qemu_real_host_page_size));
      assert(QEMU_IS_ALIGNED(size, qemu_real_host_page_size));
      trace_qemu_vfio_dma_map(s, host, size, temporary, iova);
 -    qemu_mutex_lock(&s->lock);
 +    QEMU_LOCK_GUARD(&s->lock);
      mapping = qemu_vfio_find_mapping(s, host, &index);
      if (mapping) {
          iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
          *iova = iova0;
      }
  out:
 -    qemu_mutex_unlock(&s->lock);
      return ret;
  }
--int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
+@@ -XXX,XX +XXX,XX @@ void qemu_vfio_dma_unmap(QEMUVFIOState *s, void *host)
 +/**
 + * Helper function for bdrv_create_file_fallback(): Resize @blk to at
 + * least the given @minimum_size.
 + *
 + * On success, return @blk's actual length.
 + * Otherwise, return -errno.
 + */
 +static int64_t create_file_fallback_truncate(BlockBackend *blk,
 +                                             int64_t minimum_size, Error **errp)
  {
 -    BlockDriver *drv;
 +    Error *local_err = NULL;
 +    int64_t size;
 +    int ret;
 +
 +    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);
 +    if (ret < 0 && ret != -ENOTSUP) {
 +        error_propagate(errp, local_err);
 +        return ret;
 +    }
 +
 +    size = blk_getlength(blk);
 +    if (size < 0) {
 +        error_free(local_err);
 +        error_setg_errno(errp, -size,
 +                         "Failed to inquire the new image file's length");
 +        return size;
 +    }
 +
 +    if (size < minimum_size) {
 +        /* Need to grow the image, but we failed to do that */
 +        error_propagate(errp, local_err);
 +        return -ENOTSUP;
 +    }
 +
 +    error_free(local_err);
 +    local_err = NULL;
 +
 +    return size;
 +}
 +
 +/**
 + * Helper function for bdrv_create_file_fallback(): Zero the first
 + * sector to remove any potentially pre-existing image header.
 + */
 +static int create_file_fallback_zero_first_sector(BlockBackend *blk,
 +                                                  int64_t current_size,
 +                                                  Error **errp)
 +{
 +    int64_t bytes_to_clear;
 +    int ret;
 +
 +    bytes_to_clear = MIN(current_size, BDRV_SECTOR_SIZE);
 +    if (bytes_to_clear) {
 +        ret = blk_pwrite_zeroes(blk, 0, bytes_to_clear, BDRV_REQ_MAY_UNMAP);
 +        if (ret < 0) {
 +            error_setg_errno(errp, -ret,
 +                             "Failed to clear the new image's first sector");
 +            return ret;
 +        }
 +    }
 +
 +    return 0;
 +}
 +
 +static int bdrv_create_file_fallback(const char *filename, BlockDriver *drv,
 +                                     QemuOpts *opts, Error **errp)
 +{
 +    BlockBackend *blk;
 +    QDict *options = qdict_new();
 +    int64_t size = 0;
 +    char *buf = NULL;
 +    PreallocMode prealloc;
      Error *local_err = NULL;
      int ret;
 +    size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
 +    buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
 +    prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
 +                               PREALLOC_MODE_OFF, &local_err);
 +    g_free(buf);
 +    if (local_err) {
 +        error_propagate(errp, local_err);
 +        return -EINVAL;
 +    }
 +
 +    if (prealloc != PREALLOC_MODE_OFF) {
 +        error_setg(errp, "Unsupported preallocation mode '%s'",
 +                   PreallocMode_str(prealloc));
 +        return -ENOTSUP;
 +    }
 +
 +    qdict_put_str(options, "driver", drv->format_name);
 +
 +    blk = blk_new_open(filename, NULL, options,
 +                       BDRV_O_RDWR | BDRV_O_RESIZE, errp);
 +    if (!blk) {
 +        error_prepend(errp, "Protocol driver '%s' does not support image "
 +                      "creation, and opening the image failed: ",
 +                      drv->format_name);
 +        return -EINVAL;
 +    }
 +
 +    size = create_file_fallback_truncate(blk, size, errp);
 +    if (size < 0) {
 +        ret = size;
 +        goto out;
 +    }
 +
 +    ret = create_file_fallback_zero_first_sector(blk, size, errp);
 +    if (ret < 0) {
 +        goto out;
 +    }
 +
 +    ret = 0;
 +out:
 +    blk_unref(blk);
 +    return ret;
 +}
 +
 +int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
 +{
 +    BlockDriver *drv;
 +
      drv = bdrv_find_protocol(filename, true, errp);
      if (drv == NULL) {
          return -ENOENT;
      }
--    ret = bdrv_create(drv, filename, opts, &local_err);
+     trace_qemu_vfio_dma_unmap(s, host);
--    error_propagate(errp, local_err);
+-    qemu_mutex_lock(&s->lock);
--    return ret;
++    QEMU_LOCK_GUARD(&s->lock);
-+    if (drv->bdrv_co_create_opts) {
+     m = qemu_vfio_find_mapping(s, host, &index);
-+        return bdrv_create(drv, filename, opts, errp);
+     if (!m) {
-+    } else {
+-        goto out;
-+        return bdrv_create_file_fallback(filename, drv, opts, errp);
++        return;
-+    }
+     }
      qemu_vfio_undo_mapping(s, m, NULL);
 -out:
 -    qemu_mutex_unlock(&s->lock);
  }
- /**
+ static void qemu_vfio_reset(QEMUVFIOState *s)
@@ -XXX,XX +XXX,XX @@ QemuOptsList bdrv_runtime_opts = {
      },
  };
 +static QemuOptsList fallback_create_opts = {
 +    .name = "fallback-create-opts",
 +    .head = QTAILQ_HEAD_INITIALIZER(fallback_create_opts.head),
 +    .desc = {
 +        {
 +            .name = BLOCK_OPT_SIZE,
 +            .type = QEMU_OPT_SIZE,
 +            .help = "Virtual disk size"
 +        },
 +        {
 +            .name = BLOCK_OPT_PREALLOC,
 +            .type = QEMU_OPT_STRING,
 +            .help = "Preallocation mode (allowed values: off)"
 +        },
 +        { /* end of list */ }
 +    }
 +};
 +
  /*
   * Common part for opening disk images and files
   *
@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,
          return;
      }
 -    if (!proto_drv->create_opts) {
 -        error_setg(errp, "Protocol driver '%s' does not support image creation",
 -                   proto_drv->format_name);
 -        return;
 -    }
 -
      /* Create parameter list */
      create_opts = qemu_opts_append(create_opts, drv->create_opts);
 -    create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
 +    if (proto_drv->create_opts) {
 +        create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
 +    } else {
 +        create_opts = qemu_opts_append(create_opts, &fallback_create_opts);
 +    }
      opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
 --
-.24.1
+.31.1

-[PULL 18/18] iotests: Test snapshot -l field separation
+[PULL 04/11] util/vfio-helpers: Remove unreachable code in qemu_vfio_dma_map()
-Add a test that all fields in "qemu-img snapshot -l"s output are
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
 separated by spaces.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+qemu_vfio_add_mapping() returns a pointer to an indexed entry
-Message-Id: <20200117105859.241818-3-mreitz@redhat.com>
+in pre-allocated QEMUVFIOState::mappings[], thus can not be NULL.
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Remove the pointless check.
-[mreitz: Renamed test from 284 to 286]
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Message-id: 20210902070025.197072-5-philmd@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/286     | 76 ++++++++++++++++++++++++++++++++++++++
+ util/vfio-helpers.c | 4 ----
- tests/qemu-iotests/286.out |  8 ++++
+file changed, 4 deletions(-)
  tests/qemu-iotests/group   |  1 +
 files changed, 85 insertions(+)
  create mode 100755 tests/qemu-iotests/286
  create mode 100644 tests/qemu-iotests/286.out
-diff --git a/tests/qemu-iotests/286 b/tests/qemu-iotests/286
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/286
@@ -XXX,XX +XXX,XX @@
 +#!/usr/bin/env bash
 +#
 +# Test qemu-img snapshot -l
 +#
 +# Copyright (C) 2019 Red Hat, Inc.
 +#
 +# This program is free software; you can redistribute it and/or modify
 +# it under the terms of the GNU General Public License as published by
 +# the Free Software Foundation; either version 2 of the License, or
 +# (at your option) any later version.
 +#
 +# This program is distributed in the hope that it will be useful,
 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +# GNU General Public License for more details.
 +#
 +# You should have received a copy of the GNU General Public License
 +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 +#
 +
 +seq=$(basename "$0")
 +echo "QA output created by $seq"
 +
 +status=1    # failure is the default!
 +
 +_cleanup()
 +{
 +    _cleanup_test_img
 +}
 +trap "_cleanup; exit \$status" 0 1 2 3 15
 +
 +# get standard environment, filters and checks
 +. ./common.rc
 +. ./common.filter
 +. ./common.qemu
 +
 +_supported_fmt qcow2
 +_supported_proto file
 +# Internal snapshots are (currently) impossible with refcount_bits=1,
 +# and generally impossible with external data files
 +_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file
 +
 +_make_test_img 64M
 +
 +# Should be so long as to take up the whole field width
 +sn_name=abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
 +
 +# More memory will give us a larger VM state, i.e. one above 1 MB.
 +# This way, we get a number with a decimal point.
 +qemu_comm_method=monitor _launch_qemu -m 512 "$TEST_IMG"
 +
 +_send_qemu_cmd $QEMU_HANDLE "savevm $sn_name" '(qemu)'
 +_send_qemu_cmd $QEMU_HANDLE 'quit' '(qemu)'
 +wait=yes _cleanup_qemu
 +
 +# Check that all fields are separated by spaces.
 +# We first collapse all space sequences into one space each;
 +# then we turn every space-separated field into a '.';
 +# and finally, we name the '.'s so the output is not just a confusing
 +# sequence of dots.
 +
 +echo 'Output structure:'
 +$QEMU_IMG snapshot -l "$TEST_IMG" | tail -n 1 | tr -s ' ' \
 +    | sed -e 's/\S\+/./g' \
 +    | sed -e 's/\./(snapshot ID)/' \
 +          -e 's/\./(snapshot name)/' \
 +          -e 's/\./(VM state size value)/' \
 +          -e 's/\./(VM state size unit)/' \
 +          -e 's/\./(snapshot date)/' \
 +          -e 's/\./(snapshot time)/' \
 +          -e 's/\./(VM clock)/'
 +
 +# success, all done
 +echo "*** done"
 +rm -f $seq.full
 +status=0
 diff --git a/tests/qemu-iotests/286.out b/tests/qemu-iotests/286.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/286.out
@@ -XXX,XX +XXX,XX @@
 +QA output created by 286
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
 +QEMU X.Y.Z monitor - type 'help' for more information
 +(qemu) savevm abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
 +(qemu) quit
 +Output structure:
 +(snapshot ID) (snapshot name) (VM state size value) (VM state size unit) (snapshot date) (snapshot time) (VM clock)
 +*** done
 diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/group
+--- a/util/vfio-helpers.c
-+++ b/tests/qemu-iotests/group
++++ b/util/vfio-helpers.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
-rw quick
+             }
-auto quick
-rw
+             mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
-+286 rw quick
+-            if (!mapping) {
 -                ret = -ENOMEM;
 -                goto out;
 -            }
              assert(qemu_vfio_verify_mappings(s));
              ret = qemu_vfio_do_mapping(s, host, size, iova0);
              if (ret) {
 --
-.24.1
+.31.1

-[PULL 08/18] block/backup-top: fix flags handling
+[PULL 05/11] block/nvme: Have nvme_create_queue_pair() report errors consistently
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
-backup-top "supports" write-unchanged, by skipping CBW operation in
+nvme_create_queue_pair() does not return a boolean value (indicating
-backup_top_co_pwritev. But it forgets to do the same in
+eventual error) but a pointer, and is inconsistent in how it fills the
-backup_top_co_pwrite_zeroes, as well as declare support for
+error handler. To fulfill callers expectations, always set an error
-BDRV_REQ_WRITE_UNCHANGED.
+message on failure.
-Fix this, and, while being here, declare also support for flags
+Reported-by: Auger Eric <eric.auger@redhat.com>
-supported by source child.
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Message-id: 20210902070025.197072-6-philmd@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  block/nvme.c | 3 +++
 file changed, 3 insertions(+)
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+diff --git a/block/nvme.c b/block/nvme.c
 Message-Id: <20200207161231.32707-1-vsementsov@virtuozzo.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block/backup-top.c | 31 ++++++++++++++++++++-----------
 file changed, 20 insertions(+), 11 deletions(-)
 diff --git a/block/backup-top.c b/block/backup-top.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/backup-top.c
+--- a/block/nvme.c
-+++ b/block/backup-top.c
++++ b/block/nvme.c
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int backup_top_co_preadv(
+@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
- }
+     q = g_try_new0(NVMeQueuePair, 1);
- static coroutine_fn int backup_top_cbw(BlockDriverState *bs, uint64_t offset,
+     if (!q) {
--                                       uint64_t bytes)
++        error_setg(errp, "Cannot allocate queue pair");
 +                                       uint64_t bytes, BdrvRequestFlags flags)
  {
      BDRVBackupTopState *s = bs->opaque;
 -    uint64_t end = QEMU_ALIGN_UP(offset + bytes, s->bcs->cluster_size);
 -    uint64_t off = QEMU_ALIGN_DOWN(offset, s->bcs->cluster_size);
 +    uint64_t off, end;
 +
 +    if (flags & BDRV_REQ_WRITE_UNCHANGED) {
 +        return 0;
 +    }
 +
 +    off = QEMU_ALIGN_DOWN(offset, s->bcs->cluster_size);
 +    end = QEMU_ALIGN_UP(offset + bytes, s->bcs->cluster_size);
      return block_copy(s->bcs, off, end - off, NULL);
  }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int backup_top_cbw(BlockDriverState *bs, uint64_t offset,
  static int coroutine_fn backup_top_co_pdiscard(BlockDriverState *bs,
                                                 int64_t offset, int bytes)
  {
 -    int ret = backup_top_cbw(bs, offset, bytes);
 +    int ret = backup_top_cbw(bs, offset, bytes, 0);
      if (ret < 0) {
          return ret;
      }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_top_co_pdiscard(BlockDriverState *bs,
  static int coroutine_fn backup_top_co_pwrite_zeroes(BlockDriverState *bs,
          int64_t offset, int bytes, BdrvRequestFlags flags)
  {
 -    int ret = backup_top_cbw(bs, offset, bytes);
 +    int ret = backup_top_cbw(bs, offset, bytes, flags);
      if (ret < 0) {
          return ret;
      }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int backup_top_co_pwritev(BlockDriverState *bs,
                                                uint64_t bytes,
                                                QEMUIOVector *qiov, int flags)
  {
 -    if (!(flags & BDRV_REQ_WRITE_UNCHANGED)) {
 -        int ret = backup_top_cbw(bs, offset, bytes);
 -        if (ret < 0) {
 -            return ret;
 -        }
 +    int ret = backup_top_cbw(bs, offset, bytes, flags);
 +    if (ret < 0) {
 +        return ret;
      }
      return bdrv_co_pwritev(bs->backing, offset, bytes, qiov, flags);
@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_backup_top_append(BlockDriverState *source,
          return NULL;
      }
+     trace_nvme_create_queue_pair(idx, q, size, aio_context,
--    top->total_sectors = source->total_sectors;
+@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
-     state = top->opaque;
+                           qemu_real_host_page_size);
-+    top->total_sectors = source->total_sectors;
+     q->prp_list_pages = qemu_try_memalign(qemu_real_host_page_size, bytes);
-+    top->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |
+     if (!q->prp_list_pages) {
-+            (BDRV_REQ_FUA & source->supported_write_flags);
++        error_setg(errp, "Cannot allocate PRP page list");
-+    top->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
+         goto fail;
-+            ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
+     }
-+             source->supported_zero_flags);
+     memset(q->prp_list_pages, 0, bytes);
+@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
-     bdrv_ref(target);
+     r = qemu_vfio_dma_map(s->vfio, q->prp_list_pages, bytes,
-     state->target = bdrv_attach_child(top, target, "target", &child_file, errp);
+                           false, &prp_list_iova);
      if (r) {
 +        error_setg_errno(errp, -r, "Cannot map buffer for DMA");
          goto fail;
      }
      q->free_req_head = -1;
 --
-.24.1
+.31.1

-[PULL 05/18] qapi: Allow getting flat output from 'query-named-block-nodes'
+[PULL 06/11] util/vfio-helpers: Pass Error handle to qemu_vfio_dma_map()
-From: Peter Krempa <pkrempa@redhat.com>
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
-When a management application manages node names there's no reason to
+Currently qemu_vfio_dma_map() displays errors on stderr.
-recurse into backing images in the output of query-named-block-nodes.
+When using management interface, this information is simply
 lost. Pass qemu_vfio_dma_map() an Error** handle so it can
 propagate the error to callers.
-Add a parameter to the command which will return just the top level
+Reviewed-by: Fam Zheng <fam@euphon.net>
-structs.
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Message-id: 20210902070025.197072-7-philmd@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
  include/qemu/vfio-helpers.h |  2 +-
  block/nvme.c                | 22 +++++++++++-----------
  util/vfio-helpers.c         | 10 ++++++----
 files changed, 18 insertions(+), 16 deletions(-)
-Signed-off-by: Peter Krempa <pkrempa@redhat.com>
+diff --git a/include/qemu/vfio-helpers.h b/include/qemu/vfio-helpers.h
 Message-Id: <4470f8c779abc404dcf65e375db195cd91a80651.1579509782.git.pkrempa@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 [mreitz: Fixed coding style]
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
  block.c               |  5 +++--
  block/qapi.c          | 11 +++++++++--
  blockdev.c            |  8 ++++++--
  include/block/block.h |  2 +-
  include/block/qapi.h  |  4 +++-
  monitor/hmp-cmds.c    |  2 +-
  qapi/block-core.json  |  7 ++++++-
 files changed, 29 insertions(+), 10 deletions(-)
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/include/qemu/vfio-helpers.h
-+++ b/block.c
++++ b/include/qemu/vfio-helpers.h
-@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_find_node(const char *node_name)
+@@ -XXX,XX +XXX,XX @@ typedef struct QEMUVFIOState QEMUVFIOState;
  QEMUVFIOState *qemu_vfio_open_pci(const char *device, Error **errp);
  void qemu_vfio_close(QEMUVFIOState *s);
  int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
 -                      bool temporary, uint64_t *iova_list);
 +                      bool temporary, uint64_t *iova_list, Error **errp);
  int qemu_vfio_dma_reset_temporary(QEMUVFIOState *s);
  void qemu_vfio_dma_unmap(QEMUVFIOState *s, void *host);
  void *qemu_vfio_pci_map_bar(QEMUVFIOState *s, int index,
 diff --git a/block/nvme.c b/block/nvme.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/nvme.c
 +++ b/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static bool nvme_init_queue(BDRVNVMeState *s, NVMeQueue *q,
          return false;
      }
      memset(q->queue, 0, bytes);
 -    r = qemu_vfio_dma_map(s->vfio, q->queue, bytes, false, &q->iova);
 +    r = qemu_vfio_dma_map(s->vfio, q->queue, bytes, false, &q->iova, errp);
      if (r) {
 -        error_setg(errp, "Cannot map queue");
 -        return false;
 +        error_prepend(errp, "Cannot map queue: ");
      }
 -    return true;
 +    return r == 0;
  }
- /* Put this QMP function here so it can access the static graph_bdrv_states. */
+ static void nvme_free_queue_pair(NVMeQueuePair *q)
--BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
+@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
-+BlockDeviceInfoList *bdrv_named_nodes_list(bool flat,
+     qemu_co_queue_init(&q->free_req_queue);
-+                                           Error **errp)
+     q->completion_bh = aio_bh_new(aio_context, nvme_process_completion_bh, q);
      r = qemu_vfio_dma_map(s->vfio, q->prp_list_pages, bytes,
 -                          false, &prp_list_iova);
 +                          false, &prp_list_iova, errp);
      if (r) {
 -        error_setg_errno(errp, -r, "Cannot map buffer for DMA");
 +        error_prepend(errp, "Cannot map buffer for DMA: ");
          goto fail;
      }
      q->free_req_head = -1;
@@ -XXX,XX +XXX,XX @@ static bool nvme_identify(BlockDriverState *bs, int namespace, Error **errp)
          error_setg(errp, "Cannot allocate buffer for identify response");
          goto out;
      }
 -    r = qemu_vfio_dma_map(s->vfio, id, id_size, true, &iova);
 +    r = qemu_vfio_dma_map(s->vfio, id, id_size, true, &iova, errp);
      if (r) {
 -        error_setg(errp, "Cannot map buffer for DMA");
 +        error_prepend(errp, "Cannot map buffer for DMA: ");
          goto out;
      }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
  try_map:
          r = qemu_vfio_dma_map(s->vfio,
                                qiov->iov[i].iov_base,
 -                              len, true, &iova);
 +                              len, true, &iova, NULL);
          if (r == -ENOSPC) {
              /*
               * In addition to the -ENOMEM error, the VFIO_IOMMU_MAP_DMA
@@ -XXX,XX +XXX,XX @@ static void nvme_aio_unplug(BlockDriverState *bs)
  static void nvme_register_buf(BlockDriverState *bs, void *host, size_t size)
  {
-     BlockDeviceInfoList *list, *entry;
+     int ret;
-     BlockDriverState *bs;
++    Error *local_err = NULL;
+     BDRVNVMeState *s = bs->opaque;
-     list = NULL;
-     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
+-    ret = qemu_vfio_dma_map(s->vfio, host, size, false, NULL);
--        BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
++    ret = qemu_vfio_dma_map(s->vfio, host, size, false, NULL, &local_err);
-+        BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, flat, errp);
+     if (ret) {
-         if (!info) {
+         /* FIXME: we may run out of IOVA addresses after repeated
-             qapi_free_BlockDeviceInfoList(list);
+          * bdrv_register_buf/bdrv_unregister_buf, because nvme_vfio_dma_unmap
-             return NULL;
+          * doesn't reclaim addresses for fixed mappings. */
-diff --git a/block/qapi.c b/block/qapi.c
+-        error_report("nvme_register_buf failed: %s", strerror(-ret));
 +        error_reportf_err(local_err, "nvme_register_buf failed: ");
      }
  }
 diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/qapi.c
+--- a/util/vfio-helpers.c
-+++ b/block/qapi.c
++++ b/util/vfio-helpers.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static void qemu_vfio_ram_block_added(RAMBlockNotifier *n, void *host,
- #include "qemu/cutils.h"
+                                       size_t size, size_t max_size)
  BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
 -                                        BlockDriverState *bs, Error **errp)
 +                                        BlockDriverState *bs,
 +                                        bool flat,
 +                                        Error **errp)
  {
-     ImageInfo **p_image_info;
+     QEMUVFIOState *s = container_of(n, QEMUVFIOState, ram_notifier);
-     BlockDriverState *bs0;
++    Error *local_err = NULL;
-@@ -XXX,XX +XXX,XX @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
+     int ret;
-             return NULL;
-         }
+     trace_qemu_vfio_ram_block_added(s, host, max_size);
+-    ret = qemu_vfio_dma_map(s, host, max_size, false, NULL);
-+        /* stop gathering data for flat output */
++    ret = qemu_vfio_dma_map(s, host, max_size, false, NULL, &local_err);
-+        if (flat) {
+     if (ret) {
-+            break;
+-        error_report("qemu_vfio_dma_map(%p, %zu) failed: %s", host, max_size,
-+        }
+-                     strerror(-ret));
-+
++        error_reportf_err(local_err,
-         if (bs0->drv && bs0->backing) {
++                          "qemu_vfio_dma_map(%p, %zu) failed: ",
-             info->backing_file_depth++;
++                          host, max_size);
-             bs0 = bs0->backing->bs;
+     }
@@ -XXX,XX +XXX,XX @@ static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info,
      if (bs && bs->drv) {
          info->has_inserted = true;
 -        info->inserted = bdrv_block_device_info(blk, bs, errp);
 +        info->inserted = bdrv_block_device_info(blk, bs, false, errp);
          if (info->inserted == NULL) {
              goto err;
          }
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_drive_backup(DriveBackup *backup, Error **errp)
      blockdev_do_action(&action, errp);
  }
--BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)
+@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
-+BlockDeviceInfoList *qmp_query_named_block_nodes(bool has_flat,
+  * mapping status within this area is not allowed).
-+                                                 bool flat,
+  */
-+                                                 Error **errp)
+ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
 -                      bool temporary, uint64_t *iova)
 +                      bool temporary, uint64_t *iova, Error **errp)
  {
--    return bdrv_named_nodes_list(errp);
+     int ret = 0;
-+    bool return_flat = has_flat && flat;
+     int index;
 +
 +    return bdrv_named_nodes_list(return_flat, errp);
  }
  XDbgBlockGraph *qmp_x_debug_query_block_graph(Error **errp)
 diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block.h
 +++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ void bdrv_lock_medium(BlockDriverState *bs, bool locked);
  void bdrv_eject(BlockDriverState *bs, bool eject_flag);
  const char *bdrv_get_format_name(BlockDriverState *bs);
  BlockDriverState *bdrv_find_node(const char *node_name);
 -BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp);
 +BlockDeviceInfoList *bdrv_named_nodes_list(bool flat, Error **errp);
  XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp);
  BlockDriverState *bdrv_lookup_bs(const char *device,
                                   const char *node_name,
 diff --git a/include/block/qapi.h b/include/block/qapi.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/qapi.h
 +++ b/include/block/qapi.h
@@ -XXX,XX +XXX,XX @@
  #include "block/snapshot.h"
  BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
 -                                        BlockDriverState *bs, Error **errp);
 +                                        BlockDriverState *bs,
 +                                        bool flat,
 +                                        Error **errp);
  int bdrv_query_snapshot_info_list(BlockDriverState *bs,
                                    SnapshotInfoList **p_list,
                                    Error **errp);
 diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
 index XXXXXXX..XXXXXXX 100644
 --- a/monitor/hmp-cmds.c
 +++ b/monitor/hmp-cmds.c
@@ -XXX,XX +XXX,XX @@ void hmp_info_block(Monitor *mon, const QDict *qdict)
      }
      /* Print node information */
 -    blockdev_list = qmp_query_named_block_nodes(NULL);
 +    blockdev_list = qmp_query_named_block_nodes(false, false, NULL);
      for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) {
          assert(blockdev->value->has_node_name);
          if (device && strcmp(device, blockdev->value->node_name)) {
 diff --git a/qapi/block-core.json b/qapi/block-core.json
 index XXXXXXX..XXXXXXX 100644
 --- a/qapi/block-core.json
 +++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
  #
  # Get the named block driver list
  #
 +# @flat: Omit the nested data about backing image ("backing-image" key) if true.
 +#        Default is false (Since 5.0)
 +#
  # Returns: the list of BlockDeviceInfo
  #
  # Since: 2.0
@@ -XXX,XX +XXX,XX @@
  #                    } } ] }
  #
  ##
 -{ 'command': 'query-named-block-nodes', 'returns': [ 'BlockDeviceInfo' ] }
 +{ 'command': 'query-named-block-nodes',
 +  'returns': [ 'BlockDeviceInfo' ],
 +  'data': { '*flat': 'bool' } }
  ##
  # @XDbgBlockGraphNodeType:
 --
-.24.1
+.31.1

-[PULL 13/18] iscsi: Drop iscsi_co_create_opts()
+[PULL 07/11] util/vfio-helpers: Extract qemu_vfio_water_mark_reached()
-The generic fallback implementation effectively does the same.
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
+Extract qemu_vfio_water_mark_reached() for readability,
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+and have it provide an error hint it its Error* handle.
-Message-Id: <20200122164532.178040-5-mreitz@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Suggested-by: Klaus Jensen <k.jensen@samsung.com>
 Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Message-id: 20210902070025.197072-8-philmd@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/iscsi.c | 56 ---------------------------------------------------
+ util/vfio-helpers.c | 17 ++++++++++++++++-
-file changed, 56 deletions(-)
+file changed, 16 insertions(+), 1 deletion(-)
-diff --git a/block/iscsi.c b/block/iscsi.c
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/iscsi.c
+--- a/util/vfio-helpers.c
-+++ b/block/iscsi.c
++++ b/util/vfio-helpers.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,
+@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
-     return 0;
+     return -ENOMEM;
  }
--static int coroutine_fn iscsi_co_create_opts(const char *filename, QemuOpts *opts,
++/**
--                                             Error **errp)
++ * qemu_vfio_water_mark_reached:
--{
++ *
--    int ret = 0;
++ * Returns %true if high watermark has been reached, %false otherwise.
--    int64_t total_size = 0;
++ */
--    BlockDriverState *bs;
++static bool qemu_vfio_water_mark_reached(QEMUVFIOState *s, size_t size,
--    IscsiLun *iscsilun = NULL;
++                                         Error **errp)
--    QDict *bs_options;
++{
--    Error *local_err = NULL;
++    if (s->high_water_mark - s->low_water_mark + 1 < size) {
--
++        error_setg(errp, "iova exhausted (water mark reached)");
--    bs = bdrv_new();
++        return true;
--
++    }
--    /* Read out options */
++    return false;
--    total_size = DIV_ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
++}
--                              BDRV_SECTOR_SIZE);
++
--    bs->opaque = g_new0(struct IscsiLun, 1);
+ /* Map [host, host + size) area into a contiguous IOVA address space, and store
--    iscsilun = bs->opaque;
+  * the result in @iova if not NULL. The caller need to make sure the area is
--
+  * aligned to page size, and mustn't overlap with existing mapping areas (split
--    bs_options = qdict_new();
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
--    iscsi_parse_filename(filename, bs_options, &local_err);
+     if (mapping) {
--    if (local_err) {
+         iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
--        error_propagate(errp, local_err);
+     } else {
--        ret = -EINVAL;
+-        if (s->high_water_mark - s->low_water_mark + 1 < size) {
--    } else {
++        if (qemu_vfio_water_mark_reached(s, size, errp)) {
--        ret = iscsi_open(bs, bs_options, 0, NULL);
+             ret = -ENOMEM;
--    }
+             goto out;
--    qobject_unref(bs_options);
+         }
 -
 -    if (ret != 0) {
 -        goto out;
 -    }
 -    iscsi_detach_aio_context(bs);
 -    if (iscsilun->type != TYPE_DISK) {
 -        ret = -ENODEV;
 -        goto out;
 -    }
 -    if (bs->total_sectors < total_size) {
 -        ret = -ENOSPC;
 -        goto out;
 -    }
 -
 -    ret = 0;
 -out:
 -    if (iscsilun->iscsi != NULL) {
 -        iscsi_destroy_context(iscsilun->iscsi);
 -    }
 -    g_free(bs->opaque);
 -    bs->opaque = NULL;
 -    bdrv_unref(bs);
 -    return ret;
 -}
 -
  static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
  {
      IscsiLun *iscsilun = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iscsi = {
      .bdrv_parse_filename    = iscsi_parse_filename,
      .bdrv_file_open         = iscsi_open,
      .bdrv_close             = iscsi_close,
 -    .bdrv_co_create_opts    = iscsi_co_create_opts,
 -    .create_opts            = &iscsi_create_opts,
      .bdrv_reopen_prepare    = iscsi_reopen_prepare,
      .bdrv_reopen_commit     = iscsi_reopen_commit,
      .bdrv_co_invalidate_cache = iscsi_co_invalidate_cache,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iser = {
      .bdrv_parse_filename    = iscsi_parse_filename,
      .bdrv_file_open         = iscsi_open,
      .bdrv_close             = iscsi_close,
 -    .bdrv_co_create_opts    = iscsi_co_create_opts,
 -    .create_opts            = &iscsi_create_opts,
      .bdrv_reopen_prepare    = iscsi_reopen_prepare,
      .bdrv_reopen_commit     = iscsi_reopen_commit,
      .bdrv_co_invalidate_cache  = iscsi_co_invalidate_cache,
 --
-.24.1
+.31.1

-[PULL 10/18] block/nbd: Fix hang in .bdrv_close()
+[PULL 08/11] util/vfio-helpers: Use error_setg in qemu_vfio_find_[fixed/temp]_iova
-When nbd_close() is called from a coroutine, the connection_co never
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
 gets to run, and thus nbd_teardown_connection() hangs.
-This is because aio_co_enter() only puts the connection_co into the main
+Both qemu_vfio_find_fixed_iova() and qemu_vfio_find_temp_iova()
-coroutine's wake-up queue, so this main coroutine needs to yield and
+return an errno which is unused (or overwritten). Have them propagate
-wait for connection_co to terminate.
+eventual errors to callers, returning a boolean (which is what the
 Error API recommends, see commit e3fe3988d78 "error: Document Error
 API usage rules" for rationale).
-Suggested-by: Kevin Wolf <kwolf@redhat.com>
+Suggested-by: Klaus Jensen <k.jensen@samsung.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
-Message-Id: <20200122164532.178040-2-mreitz@redhat.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Message-id: 20210902070025.197072-9-philmd@redhat.com
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- block/nbd.c | 14 +++++++++++++-
+ util/vfio-helpers.c | 24 ++++++++++++++----------
-file changed, 13 insertions(+), 1 deletion(-)
+file changed, 14 insertions(+), 10 deletions(-)
-diff --git a/block/nbd.c b/block/nbd.c
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/nbd.c
+--- a/util/vfio-helpers.c
-+++ b/block/nbd.c
++++ b/util/vfio-helpers.c
-@@ -XXX,XX +XXX,XX @@ typedef struct BDRVNBDState {
+@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_verify_mappings(QEMUVFIOState *s)
-     CoMutex send_mutex;
+     return true;
-     CoQueue free_sema;
+ }
-     Coroutine *connection_co;
-+    Coroutine *teardown_co;
+-static int
-     QemuCoSleepState *connection_co_sleep_ns_state;
+-qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
-     bool drained;
++static bool qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size,
-     bool wait_drained_end;
++                                      uint64_t *iova, Error **errp)
-@@ -XXX,XX +XXX,XX @@ static void nbd_teardown_connection(BlockDriverState *bs)
+ {
-             qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
+     int i;
@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
              s->usable_iova_ranges[i].end - s->low_water_mark + 1 == 0) {
              *iova = s->low_water_mark;
              s->low_water_mark += size;
 -            return 0;
 +            return true;
          }
      }
--    BDRV_POLL_WHILE(bs, s->connection_co);
+-    return -ENOMEM;
-+    if (qemu_in_coroutine()) {
++    error_setg(errp, "fixed iova range not found");
-+        s->teardown_co = qemu_coroutine_self();
++
-+        /* connection_co resumes us when it terminates */
++    return false;
 +        qemu_coroutine_yield();
 +        s->teardown_co = NULL;
 +    } else {
 +        BDRV_POLL_WHILE(bs, s->connection_co);
 +    }
 +    assert(!s->connection_co);
  }
- static bool nbd_client_connecting(BDRVNBDState *s)
+-static int
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn void nbd_connection_entry(void *opaque)
+-qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
-         s->ioc = NULL;
++static bool qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size,
 +                                     uint64_t *iova, Error **errp)
  {
      int i;
@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
              s->high_water_mark - s->usable_iova_ranges[i].start + 1 == 0) {
              *iova = s->high_water_mark - size;
              s->high_water_mark = *iova;
 -            return 0;
 +            return true;
          }
      }
+-    return -ENOMEM;
-+    if (s->teardown_co) {
++    error_setg(errp, "temporary iova range not found");
-+        aio_co_wake(s->teardown_co);
++
-+    }
++    return false;
      aio_wait_kick();
  }
+ /**
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+             goto out;
+         }
+         if (!temporary) {
+-            if (qemu_vfio_find_fixed_iova(s, size, &iova0)) {
++            if (!qemu_vfio_find_fixed_iova(s, size, &iova0, errp)) {
+                 ret = -ENOMEM;
+                 goto out;
+             }
+@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
+             }
+             qemu_vfio_dump_mappings(s);
+         } else {
+-            if (qemu_vfio_find_temp_iova(s, size, &iova0)) {
++            if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
+                 ret = -ENOMEM;
+                 goto out;
+             }
 --
-.24.1
+.31.1

-[PULL 12/18] file-posix: Drop hdev_co_create_opts()
+[PULL 09/11] util/vfio-helpers: Simplify qemu_vfio_dma_map() returning directly
-The generic fallback implementation effectively does the same.
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
+To simplify qemu_vfio_dma_map():
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+- reduce 'ret' (returned value) scope by returning errno directly,
-Message-Id: <20200122164532.178040-4-mreitz@redhat.com>
+- remove the goto 'out' label.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
 Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Message-id: 20210902070025.197072-10-philmd@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/file-posix.c | 67 ----------------------------------------------
+ util/vfio-helpers.c | 23 ++++++++++-------------
-file changed, 67 deletions(-)
+file changed, 10 insertions(+), 13 deletions(-)
-diff --git a/block/file-posix.c b/block/file-posix.c
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/file-posix.c
+--- a/util/vfio-helpers.c
-+++ b/block/file-posix.c
++++ b/util/vfio-helpers.c
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_water_mark_reached(QEMUVFIOState *s, size_t size,
-     return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
+ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
                        bool temporary, uint64_t *iova, Error **errp)
  {
 -    int ret = 0;
      int index;
      IOVAMapping *mapping;
      uint64_t iova0;
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
      if (mapping) {
          iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
      } else {
 +        int ret;
 +
          if (qemu_vfio_water_mark_reached(s, size, errp)) {
 -            ret = -ENOMEM;
 -            goto out;
 +            return -ENOMEM;
          }
          if (!temporary) {
              if (!qemu_vfio_find_fixed_iova(s, size, &iova0, errp)) {
 -                ret = -ENOMEM;
 -                goto out;
 +                return -ENOMEM;
              }
              mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
              assert(qemu_vfio_verify_mappings(s));
              ret = qemu_vfio_do_mapping(s, host, size, iova0);
 -            if (ret) {
 +            if (ret < 0) {
                  qemu_vfio_undo_mapping(s, mapping, NULL);
 -                goto out;
 +                return ret;
              }
              qemu_vfio_dump_mappings(s);
          } else {
              if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
 -                ret = -ENOMEM;
 -                goto out;
 +                return -ENOMEM;
              }
              ret = qemu_vfio_do_mapping(s, host, size, iova0);
 -            if (ret) {
 -                goto out;
 +            if (ret < 0) {
 +                return ret;
              }
          }
      }
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
      if (iova) {
          *iova = iova0;
      }
 -out:
 -    return ret;
 +    return 0;
  }
--static int coroutine_fn hdev_co_create_opts(const char *filename, QemuOpts *opts,
+ /* Reset the high watermark and free all "temporary" mappings. */
 -                                            Error **errp)
 -{
 -    int fd;
 -    int ret = 0;
 -    struct stat stat_buf;
 -    int64_t total_size = 0;
 -    bool has_prefix;
 -
 -    /* This function is used by both protocol block drivers and therefore either
 -     * of these prefixes may be given.
 -     * The return value has to be stored somewhere, otherwise this is an error
 -     * due to -Werror=unused-value. */
 -    has_prefix =
 -        strstart(filename, "host_device:", &filename) ||
 -        strstart(filename, "host_cdrom:" , &filename);
 -
 -    (void)has_prefix;
 -
 -    ret = raw_normalize_devicepath(&filename, errp);
 -    if (ret < 0) {
 -        return ret;
 -    }
 -
 -    /* Read out options */
 -    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
 -                          BDRV_SECTOR_SIZE);
 -
 -    fd = qemu_open(filename, O_WRONLY | O_BINARY);
 -    if (fd < 0) {
 -        ret = -errno;
 -        error_setg_errno(errp, -ret, "Could not open device");
 -        return ret;
 -    }
 -
 -    if (fstat(fd, &stat_buf) < 0) {
 -        ret = -errno;
 -        error_setg_errno(errp, -ret, "Could not stat device");
 -    } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
 -        error_setg(errp,
 -                   "The given file is neither a block nor a character device");
 -        ret = -ENODEV;
 -    } else if (lseek(fd, 0, SEEK_END) < total_size) {
 -        error_setg(errp, "Device is too small");
 -        ret = -ENOSPC;
 -    }
 -
 -    if (!ret && total_size) {
 -        uint8_t buf[BDRV_SECTOR_SIZE] = { 0 };
 -        int64_t zero_size = MIN(BDRV_SECTOR_SIZE, total_size);
 -        if (lseek(fd, 0, SEEK_SET) == -1) {
 -            ret = -errno;
 -        } else {
 -            ret = qemu_write_full(fd, buf, zero_size);
 -            ret = ret == zero_size ? 0 : -errno;
 -        }
 -    }
 -    qemu_close(fd);
 -    return ret;
 -}
 -
  static BlockDriver bdrv_host_device = {
      .format_name        = "host_device",
      .protocol_name        = "host_device",
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_device = {
      .bdrv_reopen_prepare = raw_reopen_prepare,
      .bdrv_reopen_commit  = raw_reopen_commit,
      .bdrv_reopen_abort   = raw_reopen_abort,
 -    .bdrv_co_create_opts = hdev_co_create_opts,
 -    .create_opts         = &raw_create_opts,
      .mutable_opts        = mutable_opts,
      .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
      .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_cdrom = {
      .bdrv_reopen_prepare = raw_reopen_prepare,
      .bdrv_reopen_commit  = raw_reopen_commit,
      .bdrv_reopen_abort   = raw_reopen_abort,
 -    .bdrv_co_create_opts = hdev_co_create_opts,
 -    .create_opts         = &raw_create_opts,
      .mutable_opts        = mutable_opts,
      .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_cdrom = {
      .bdrv_reopen_prepare = raw_reopen_prepare,
      .bdrv_reopen_commit  = raw_reopen_commit,
      .bdrv_reopen_abort   = raw_reopen_abort,
 -    .bdrv_co_create_opts = hdev_co_create_opts,
 -    .create_opts        = &raw_create_opts,
      .mutable_opts       = mutable_opts,
      .bdrv_co_preadv         = raw_co_preadv,
 --
-.24.1
+.31.1

-[PULL 16/18] iotests: Test convert -n -B to backing-less target
+[PULL 10/11] util/vfio-helpers: Let qemu_vfio_do_mapping() propagate Error
-This must not crash.
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Pass qemu_vfio_do_mapping() an Error* argument so it can propagate
-Message-Id: <20200121155915.98232-3-mreitz@redhat.com>
+any error to callers. Replace error_report() which only report
-Reviewed-by: John Snow <jsnow@redhat.com>
+to the monitor by the more generic error_setg_errno().
-Signed-off-by: Max Reitz <mreitz@redhat.com>
 Reviewed-by: Fam Zheng <fam@euphon.net>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Message-id: 20210902070025.197072-11-philmd@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/122     | 14 ++++++++++++++
+ util/vfio-helpers.c | 8 ++++----
- tests/qemu-iotests/122.out |  5 +++++
+file changed, 4 insertions(+), 4 deletions(-)
 files changed, 19 insertions(+)
-diff --git a/tests/qemu-iotests/122 b/tests/qemu-iotests/122
+diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/122
 +++ b/tests/qemu-iotests/122
@@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -O $IMGFMT -n "$TEST_IMG" "$TEST_IMG".orig
  $QEMU_IMG compare "$TEST_IMG" "$TEST_IMG".orig
 +echo
 +echo '=== -n -B to an image without a backing file ==='
 +echo
 +
 +# Base for the output
 +TEST_IMG="$TEST_IMG".base _make_test_img 64M
 +
 +# Output that does have $TEST_IMG.base set as its (implicit) backing file
 +TEST_IMG="$TEST_IMG".orig _make_test_img 64M
 +
 +# Convert with -n, which should not confuse -B with "target BDS has a
 +# backing file"
 +$QEMU_IMG convert -O $IMGFMT -B "$TEST_IMG".base -n "$TEST_IMG" "$TEST_IMG".orig
 +
  # success, all done
  echo '*** done'
  rm -f $seq.full
 diff --git a/tests/qemu-iotests/122.out b/tests/qemu-iotests/122.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/122.out
+--- a/util/vfio-helpers.c
-+++ b/tests/qemu-iotests/122.out
++++ b/util/vfio-helpers.c
-@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT.orig', fmt=IMGFMT size=67108864
+@@ -XXX,XX +XXX,XX @@ static IOVAMapping *qemu_vfio_add_mapping(QEMUVFIOState *s,
- wrote 65536/65536 bytes at offset 0
-KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+ /* Do the DMA mapping with VFIO. */
- Images are identical.
+ static int qemu_vfio_do_mapping(QEMUVFIOState *s, void *host, size_t size,
-+
+-                                uint64_t iova)
-+=== -n -B to an image without a backing file ===
++                                uint64_t iova, Error **errp)
-+
+ {
-+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864
+     struct vfio_iommu_type1_dma_map dma_map = {
-+Formatting 'TEST_DIR/t.IMGFMT.orig', fmt=IMGFMT size=67108864
+         .argsz = sizeof(dma_map),
- *** done
+@@ -XXX,XX +XXX,XX @@ static int qemu_vfio_do_mapping(QEMUVFIOState *s, void *host, size_t size,
      trace_qemu_vfio_do_mapping(s, host, iova, size);
      if (ioctl(s->container, VFIO_IOMMU_MAP_DMA, &dma_map)) {
 -        error_report("VFIO_MAP_DMA failed: %s", strerror(errno));
 +        error_setg_errno(errp, errno, "VFIO_MAP_DMA failed");
          return -errno;
      }
      return 0;
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
              mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
              assert(qemu_vfio_verify_mappings(s));
 -            ret = qemu_vfio_do_mapping(s, host, size, iova0);
 +            ret = qemu_vfio_do_mapping(s, host, size, iova0, errp);
              if (ret < 0) {
                  qemu_vfio_undo_mapping(s, mapping, NULL);
                  return ret;
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
              if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
                  return -ENOMEM;
              }
 -            ret = qemu_vfio_do_mapping(s, host, size, iova0);
 +            ret = qemu_vfio_do_mapping(s, host, size, iova0, errp);
              if (ret < 0) {
                  return ret;
              }
 --
-.24.1
+.31.1

-[PULL 04/18] iotests/147: Fix drive parameters
+[PULL 11/11] block/nvme: Only report VFIO error on failed retry
-dff69b94 added an aio parameter to the drive parameter but forgot to
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
 add a comma before, thus breaking the test.  Fix it again.
-Fixes: 8dff69b9415b4287e900358744b732195e1ab2e2
+We expect the first qemu_vfio_dma_map() to fail (indicating
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+DMA mappings exhaustion, see commit 15a730e7a3a). Do not
-Message-Id: <20200206130812.612960-1-mreitz@redhat.com>
+report the first failure as error, since we are going to
-Reviewed-by: Eric Blake <eblake@redhat.com>
+flush the mappings and retry.
-Tested-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+This removes spurious error message displayed on the monitor:
   (qemu) c
   (qemu) qemu-kvm: VFIO_MAP_DMA failed: No space left on device
   (qemu) info status
   VM status: running
 Reported-by: Tingting Mao <timao@redhat.com>
 Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Message-id: 20210902070025.197072-12-philmd@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/147 | 2 +-
+ block/nvme.c | 8 +++++++-
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 7 insertions(+), 1 deletion(-)
-diff --git a/tests/qemu-iotests/147 b/tests/qemu-iotests/147
+diff --git a/block/nvme.c b/block/nvme.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/147
+--- a/block/nvme.c
-+++ b/tests/qemu-iotests/147
++++ b/block/nvme.c
-@@ -XXX,XX +XXX,XX @@ class BuiltinNBD(NBDBlockdevAddBase):
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
-         self.server.add_drive_raw('if=none,id=nbd-export,' +
+     uint64_t *pagelist = req->prp_list_page;
-                                   'file=%s,' % test_img +
+     int i, j, r;
-                                   'format=%s,' % imgfmt +
+     int entries = 0;
--                                  'cache=%s' % cachemode +
++    Error *local_err = NULL, **errp = NULL;
-+                                  'cache=%s,' % cachemode +
-                                   'aio=%s' % aiomode)
+     assert(qiov->size);
-         self.server.launch()
+     assert(QEMU_IS_ALIGNED(qiov->size, s->page_size));
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
  try_map:
          r = qemu_vfio_dma_map(s->vfio,
                                qiov->iov[i].iov_base,
 -                              len, true, &iova, NULL);
 +                              len, true, &iova, errp);
          if (r == -ENOSPC) {
              /*
               * In addition to the -ENOMEM error, the VFIO_IOMMU_MAP_DMA
@@ -XXX,XX +XXX,XX @@ try_map:
                      goto fail;
                  }
              }
 +            errp = &local_err;
 +
              goto try_map;
          }
          if (r) {
@@ -XXX,XX +XXX,XX @@ fail:
       * because they are already mapped before calling this function; for
       * temporary mappings, a later nvme_cmd_(un)map_qiov will reclaim by
       * calling qemu_vfio_dma_reset_temporary when necessary. */
 +    if (local_err) {
 +        error_reportf_err(local_err, "Cannot map buffer for DMA: ");
 +    }
      return r;
  }
 --
-.24.1
+.31.1

-[PULL 06/18] qemu-img: Add --target-is-zero to convert
+Deleted patch
-From: David Edmondson <david.edmondson@oracle.com>
-In many cases the target of a convert operation is a newly provisioned
-target that the user knows is blank (reads as zero). In this situation
-there is no requirement for qemu-img to wastefully zero out the entire
-device.
-Add a new option, --target-is-zero, allowing the user to indicate that
-an existing target device will return zeros for all reads.
-Signed-off-by: David Edmondson <david.edmondson@oracle.com>
-Message-Id: <20200205110248.2009589-2-david.edmondson@oracle.com>
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- docs/interop/qemu-img.rst |  9 ++++++++-
- qemu-img-cmds.hx          |  4 ++--
- qemu-img.c                | 26 +++++++++++++++++++++++---
-files changed, 33 insertions(+), 6 deletions(-)
-diff --git a/docs/interop/qemu-img.rst b/docs/interop/qemu-img.rst
-index XXXXXXX..XXXXXXX 100644
---- a/docs/interop/qemu-img.rst
-+++ b/docs/interop/qemu-img.rst
-@@ -XXX,XX +XXX,XX @@ Parameters to convert subcommand:
-   will still be printed.  Areas that cannot be read from the source will be
-   treated as containing only zeroes.
-+.. option:: --target-is-zero
-+
-+  Assume that reading the destination image will always return
-+  zeros. This parameter is mutually exclusive with a destination image
-+  that has a backing file. It is required to also use the ``-n``
-+  parameter to skip image creation.
-+
- Parameters to dd subcommand:
- .. program:: qemu-img-dd
-@@ -XXX,XX +XXX,XX @@ Command description:
-     Error on reading data
--.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME
-+.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [--target-is-zero] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME
-   Convert the disk image *FILENAME* or a snapshot *SNAPSHOT_PARAM*
-   to disk image *OUTPUT_FILENAME* using format *OUTPUT_FMT*. It can
-diff --git a/qemu-img-cmds.hx b/qemu-img-cmds.hx
-index XXXXXXX..XXXXXXX 100644
---- a/qemu-img-cmds.hx
-+++ b/qemu-img-cmds.hx
-@@ -XXX,XX +XXX,XX @@ SRST
- ERST
- DEF("convert", img_convert,
--    "convert [--object objectdef] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f fmt] [-t cache] [-T src_cache] [-O output_fmt] [-B backing_file] [-o options] [-l snapshot_param] [-S sparse_size] [-m num_coroutines] [-W] [--salvage] filename [filename2 [...]] output_filename")
-+    "convert [--object objectdef] [--image-opts] [--target-image-opts] [--target-is-zero] [-U] [-C] [-c] [-p] [-q] [-n] [-f fmt] [-t cache] [-T src_cache] [-O output_fmt] [-B backing_file] [-o options] [-l snapshot_param] [-S sparse_size] [-m num_coroutines] [-W] [--salvage] filename [filename2 [...]] output_filename")
- SRST
--.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] [--salvage] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME
-+.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [--target-is-zero] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] [--salvage] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME
- ERST
- DEF("create", img_create,
-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 @@ enum {
-     OPTION_PREALLOCATION = 265,
-     OPTION_SHRINK = 266,
-     OPTION_SALVAGE = 267,
-+    OPTION_TARGET_IS_ZERO = 268,
- };
- typedef enum OutputFormat {
-@@ -XXX,XX +XXX,XX @@ static int convert_do_copy(ImgConvertState *s)
-     int64_t sector_num = 0;
-     /* Check whether we have zero initialisation or can get it efficiently */
--    if (s->target_is_new && s->min_sparse && !s->target_has_backing) {
-+    if (!s->has_zero_init && s->target_is_new && s->min_sparse &&
-+        !s->target_has_backing) {
-         s->has_zero_init = bdrv_has_zero_init(blk_bs(s->target));
--    } else {
--        s->has_zero_init = false;
-     }
-     if (!s->has_zero_init && !s->target_has_backing &&
-@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
-             {"force-share", no_argument, 0, 'U'},
-             {"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},
-             {"salvage", no_argument, 0, OPTION_SALVAGE},
-+            {"target-is-zero", no_argument, 0, OPTION_TARGET_IS_ZERO},
-             {0, 0, 0, 0}
-         };
-         c = getopt_long(argc, argv, ":hf:O:B:Cco:l:S:pt:T:qnm:WU",
-@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
-         case OPTION_TARGET_IMAGE_OPTS:
-             tgt_image_opts = true;
-             break;
-+        case OPTION_TARGET_IS_ZERO:
-+            /*
-+             * The user asserting that the target is blank has the
-+             * same effect as the target driver supporting zero
-+             * initialisation.
-+             */
-+            s.has_zero_init = true;
-+            break;
-         }
-     }
-@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
-         warn_report("This will become an error in future QEMU versions.");
-     }
-+    if (s.has_zero_init && !skip_create) {
-+        error_report("--target-is-zero requires use of -n flag");
-+        goto fail_getopt;
-+    }
-+
-     s.src_num = argc - optind - 1;
-     out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL;
-@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
-     }
-     s.target_has_backing = (bool) out_baseimg;
-+    if (s.has_zero_init && s.target_has_backing) {
-+        error_report("Cannot use --target-is-zero when the destination "
-+                     "image has a backing file");
-+        goto out;
-+    }
-+
-     if (s.src_num > 1 && out_baseimg) {
-         error_report("Having a backing file for the target makes no sense when "
-                      "concatenating multiple input images");
---
-.24.1

-[PULL 07/18] block: always fill entire LUKS header space with zeros
+Deleted patch
-From: Daniel P. Berrangé <berrange@redhat.com>
-When initializing the LUKS header the size with default encryption
-parameters will currently be 2068480 bytes. This is rounded up to
-a multiple of the cluster size, 2081792, with 64k sectors. If the
-end of the header is not the same as the end of the cluster we fill
-the extra space with zeros. This was forgetting that not even the
-space allocated for the header will be fully initialized, as we
-only write key material for the first key slot. The space left
-for the other 7 slots is never written to.
-An optimization to the ref count checking code:
-  commit a5fff8d4b4d928311a5005efa12d0991fe3b66f9 (refs/bisect/bad)
-  Author: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-  Date:   Wed Feb 27 16:14:30 2019 +0300
-    qcow2-refcount: avoid eating RAM
-made the assumption that every cluster which was allocated would
-have at least some data written to it. This was violated by way
-the LUKS header is only partially written, with much space simply
-reserved for future use.
-Depending on the cluster size this problem was masked by the
-logic which wrote zeros between the end of the LUKS header and
-the end of the cluster.
-$ qemu-img create --object secret,id=cluster_encrypt0,data=123456 \
-   -f qcow2 -o cluster_size=2k,encrypt.iter-time=1,\
-               encrypt.format=luks,encrypt.key-secret=cluster_encrypt0 \
-               cluster_size_check.qcow2 100M
-  Formatting 'cluster_size_check.qcow2', fmt=qcow2 size=104857600
-    encrypt.format=luks encrypt.key-secret=cluster_encrypt0
-    encrypt.iter-time=1 cluster_size=2048 lazy_refcounts=off refcount_bits=16
-$ qemu-img check --object secret,id=cluster_encrypt0,data=redhat \
-    'json:{"driver": "qcow2", "encrypt.format": "luks", \
-           "encrypt.key-secret": "cluster_encrypt0", \
-           "file.driver": "file", "file.filename": "cluster_size_check.qcow2"}'
-ERROR: counting reference for region exceeding the end of the file by one cluster or more: offset 0x2000 size 0x1f9000
-Leaked cluster 4 refcount=1 reference=0
-...snip...
-Leaked cluster 130 refcount=1 reference=0
-errors were found on the image.
-Data may be corrupted, or further writes to the image may corrupt it.
-leaked clusters were found on the image.
-This means waste of disk space, but no harm to data.
-Image end offset: 268288
-The problem only exists when the disk image is entirely empty. Writing
-data to the disk image payload will solve the problem by causing the
-end of the file to be extended further.
-The change fixes it by ensuring that the entire allocated LUKS header
-region is fully initialized with zeros. The qemu-img check will still
-fail for any pre-existing disk images created prior to this change,
-unless at least 1 byte of the payload is written to.
-Fully writing zeros to the entire LUKS header is a good idea regardless
-as it ensures that space has been allocated on the host filesystem (or
-whatever block storage backend is used).
-Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
-Message-Id: <20200207135520.2669430-1-berrange@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- block/qcow2.c              | 11 +++--
- tests/qemu-iotests/284     | 97 ++++++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/284.out | 62 ++++++++++++++++++++++++
- tests/qemu-iotests/group   |  1 +
-files changed, 167 insertions(+), 4 deletions(-)
- create mode 100755 tests/qemu-iotests/284
- create mode 100644 tests/qemu-iotests/284.out
-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 ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
-     s->crypto_header.length = headerlen;
-     s->crypto_header.offset = ret;
--    /* Zero fill remaining space in cluster so it has predictable
--     * content in case of future spec changes */
-+    /*
-+     * Zero fill all space in cluster so it has predictable
-+     * content, as we may not initialize some regions of the
-+     * header (eg only 1 out of 8 key slots will be initialized)
-+     */
-     clusterlen = size_to_clusters(s, headerlen) * s->cluster_size;
-     assert(qcow2_pre_write_overlap_check(bs, 0, ret, clusterlen, false) == 0);
-     ret = bdrv_pwrite_zeroes(bs->file,
--                             ret + headerlen,
--                             clusterlen - headerlen, 0);
-+                             ret,
-+                             clusterlen, 0);
-     if (ret < 0) {
-         error_setg_errno(errp, -ret, "Could not zero fill encryption header");
-         return -1;
-diff --git a/tests/qemu-iotests/284 b/tests/qemu-iotests/284
-new file mode 100755
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/tests/qemu-iotests/284
-@@ -XXX,XX +XXX,XX @@
-+#!/usr/bin/env bash
-+#
-+# Test ref count checks on encrypted images
-+#
-+# Copyright (C) 2019 Red Hat, Inc.
-+#
-+# This program is free software; you can redistribute it and/or modify
-+# it under the terms of the GNU General Public License as published by
-+# the Free Software Foundation; either version 2 of the License, or
-+# (at your option) any later version.
-+#
-+# This program is distributed in the hope that it will be useful,
-+# but WITHOUT ANY WARRANTY; without even the implied warranty of
-+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+# GNU General Public License for more details.
-+#
-+# You should have received a copy of the GNU General Public License
-+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-+#
-+
-+# creator
-+owner=berrange@redhat.com
-+
-+seq=`basename $0`
-+echo "QA output created by $seq"
-+
-+status=1        # failure is the default!
-+
-+_cleanup()
-+{
-+        _cleanup_test_img
-+}
-+trap "_cleanup; exit \$status" 0 1 2 3 15
-+
-+# get standard environment, filters and checks
-+. ./common.rc
-+. ./common.filter
-+
-+_supported_fmt qcow2
-+_supported_proto generic
-+_supported_os Linux
-+
-+
-+size=1M
-+
-+SECRET="secret,id=sec0,data=astrochicken"
-+
-+IMGSPEC="driver=$IMGFMT,file.filename=$TEST_IMG,encrypt.key-secret=sec0"
-+QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT
-+
-+_run_test()
-+{
-+        IMGOPTSSYNTAX=true
-+        OLD_TEST_IMG="$TEST_IMG"
-+        TEST_IMG="driver=$IMGFMT,file.filename=$TEST_IMG,encrypt.key-secret=sec0"
-+        QEMU_IMG_EXTRA_ARGS="--image-opts --object $SECRET"
-+
-+        echo
-+        echo "== cluster size $csize"
-+        echo "== checking image refcounts =="
-+        _check_test_img
-+
-+        echo
-+        echo "== writing some data =="
-+        $QEMU_IO -c "write -P 0x9 0 1"  $QEMU_IMG_EXTRA_ARGS $TEST_IMG | _filter_qemu_io | _filter_testdir
-+        echo
-+        echo "== rechecking image refcounts =="
-+        _check_test_img
-+
-+        echo
-+        echo "== writing some more data =="
-+        $QEMU_IO -c "write -P 0x9 $csize 1" $QEMU_IMG_EXTRA_ARGS $TEST_IMG | _filter_qemu_io | _filter_testdir
-+        echo
-+        echo "== rechecking image refcounts =="
-+        _check_test_img
-+
-+        TEST_IMG="$OLD_TEST_IMG"
-+        QEMU_IMG_EXTRA_ARGS=
-+        IMGOPTSSYNTAX=
-+}
-+
-+
-+echo
-+echo "testing LUKS qcow2 encryption"
-+echo
-+
-+for csize in 512 2048 32768
-+do
-+  _make_test_img --object $SECRET -o "encrypt.format=luks,encrypt.key-secret=sec0,encrypt.iter-time=10,cluster_size=$csize" $size
-+  _run_test
-+  _cleanup_test_img
-+done
-+
-+# success, all done
-+echo "*** done"
-+rm -f $seq.full
-+status=0
-diff --git a/tests/qemu-iotests/284.out b/tests/qemu-iotests/284.out
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/tests/qemu-iotests/284.out
-@@ -XXX,XX +XXX,XX @@
-+QA output created by 284
-+
-+testing LUKS qcow2 encryption
-+
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10
-+
-+== cluster size 512
-+== checking image refcounts ==
-+No errors were found on the image.
-+
-+== writing some data ==
-+wrote 1/1 bytes at offset 0
-+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+
-+== rechecking image refcounts ==
-+No errors were found on the image.
-+
-+== writing some more data ==
-+wrote 1/1 bytes at offset 512
-+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+
-+== rechecking image refcounts ==
-+No errors were found on the image.
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10
-+
-+== cluster size 2048
-+== checking image refcounts ==
-+No errors were found on the image.
-+
-+== writing some data ==
-+wrote 1/1 bytes at offset 0
-+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+
-+== rechecking image refcounts ==
-+No errors were found on the image.
-+
-+== writing some more data ==
-+wrote 1/1 bytes at offset 2048
-+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+
-+== rechecking image refcounts ==
-+No errors were found on the image.
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10
-+
-+== cluster size 32768
-+== checking image refcounts ==
-+No errors were found on the image.
-+
-+== writing some data ==
-+wrote 1/1 bytes at offset 0
-+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+
-+== rechecking image refcounts ==
-+No errors were found on the image.
-+
-+== writing some more data ==
-+wrote 1/1 bytes at offset 32768
-+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+
-+== rechecking image refcounts ==
-+No errors were found on the image.
-+*** done
-diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/group
-+++ b/tests/qemu-iotests/group
-@@ -XXX,XX +XXX,XX @@
-rw migration quick
-rw quick
-auto quick
-+284 rw
---
-.24.1

-[PULL 09/18] iotests/279: Fix for non-qcow2 formats
+Deleted patch
-First, driver=qcow2 will not work so well with non-qcow2 formats (and
-this test claims to support qcow, qed, and vmdk).
-Second, vmdk will always report the backing file format to be vmdk.
-Filter that out so the output looks like for all other formats.
-Third, the flat vmdk subformats do not support backing files, so they
-will not work with this test.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-Id: <20191219144243.1763246-1-mreitz@redhat.com>
-Tested-by: Thomas Huth <thuth@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/279 | 7 +++++--
-file changed, 5 insertions(+), 2 deletions(-)
-diff --git a/tests/qemu-iotests/279 b/tests/qemu-iotests/279
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/279
-+++ b/tests/qemu-iotests/279
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow qcow2 vmdk qed
- _supported_proto file
- _supported_os Linux
-+_unsupported_imgopts "subformat=monolithicFlat" \
-+                     "subformat=twoGbMaxExtentFlat" \
- TEST_IMG="$TEST_IMG.base" _make_test_img 64M
- TEST_IMG="$TEST_IMG.mid" _make_test_img -b "$TEST_IMG.base"
-@@ -XXX,XX +XXX,XX @@ _make_test_img -b "$TEST_IMG.mid"
- echo
- echo '== qemu-img info --backing-chain =='
--_img_info --backing-chain | _filter_img_info
-+_img_info --backing-chain | _filter_img_info | grep -v 'backing file format'
- echo
- echo '== qemu-img info --backing-chain --image-opts =='
--TEST_IMG="driver=qcow2,file.driver=file,file.filename=$TEST_IMG" _img_info --backing-chain --image-opts | _filter_img_info
-+TEST_IMG="driver=$IMGFMT,file.driver=file,file.filename=$TEST_IMG" _img_info --backing-chain --image-opts \
-+    | _filter_img_info | grep -v 'backing file format'
- # success, all done
- echo "*** done"
---
-.24.1

-[PULL 14/18] iotests: Add test for image creation fallback
+Deleted patch
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-Id: <20200122164532.178040-6-mreitz@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
-[mreitz: Added a note that NBD does not support resizing, which is why
-         the second case is expected to fail]
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/259     | 62 ++++++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/259.out | 14 +++++++++
- tests/qemu-iotests/group   |  1 +
-files changed, 77 insertions(+)
- create mode 100755 tests/qemu-iotests/259
- create mode 100644 tests/qemu-iotests/259.out
-diff --git a/tests/qemu-iotests/259 b/tests/qemu-iotests/259
-new file mode 100755
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/tests/qemu-iotests/259
-@@ -XXX,XX +XXX,XX @@
-+#!/usr/bin/env bash
-+#
-+# Test generic image creation fallback (by using NBD)
-+#
-+# Copyright (C) 2019 Red Hat, Inc.
-+#
-+# This program is free software; you can redistribute it and/or modify
-+# it under the terms of the GNU General Public License as published by
-+# the Free Software Foundation; either version 2 of the License, or
-+# (at your option) any later version.
-+#
-+# This program is distributed in the hope that it will be useful,
-+# but WITHOUT ANY WARRANTY; without even the implied warranty of
-+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-+# GNU General Public License for more details.
-+#
-+# You should have received a copy of the GNU General Public License
-+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
-+#
-+
-+# creator
-+owner=mreitz@redhat.com
-+
-+seq=$(basename $0)
-+echo "QA output created by $seq"
-+
-+status=1    # failure is the default!
-+
-+_cleanup()
-+{
-+    _cleanup_test_img
-+}
-+trap "_cleanup; exit \$status" 0 1 2 3 15
-+
-+# get standard environment, filters and checks
-+. ./common.rc
-+. ./common.filter
-+
-+_supported_fmt raw
-+_supported_proto nbd
-+_supported_os Linux
-+
-+
-+_make_test_img 64M
-+
-+echo
-+echo '--- Testing creation ---'
-+
-+$QEMU_IMG create -f qcow2 "$TEST_IMG" 64M | _filter_img_create
-+$QEMU_IMG info "$TEST_IMG" | _filter_img_info
-+
-+echo
-+echo '--- Testing creation for which the node would need to grow ---'
-+
-+# NBD does not support resizing, so this will fail
-+$QEMU_IMG create -f qcow2 -o preallocation=metadata "$TEST_IMG" 64M 2>&1 \
-+    | _filter_img_create
-+
-+# success, all done
-+echo "*** done"
-+rm -f $seq.full
-+status=0
-diff --git a/tests/qemu-iotests/259.out b/tests/qemu-iotests/259.out
-new file mode 100644
-index XXXXXXX..XXXXXXX
---- /dev/null
-+++ b/tests/qemu-iotests/259.out
-@@ -XXX,XX +XXX,XX @@
-+QA output created by 259
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
-+
-+--- Testing creation ---
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=qcow2 size=67108864
-+image: TEST_DIR/t.IMGFMT
-+file format: qcow2
-+virtual size: 64 MiB (67108864 bytes)
-+disk size: unavailable
-+
-+--- Testing creation for which the node would need to grow ---
-+qemu-img: TEST_DIR/t.IMGFMT: Could not resize image: Image format driver does not support resize
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=qcow2 size=67108864 preallocation=metadata
-+*** done
-diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/group
-+++ b/tests/qemu-iotests/group
-@@ -XXX,XX +XXX,XX @@
-rw auto quick
-rw
-rw quick
-+259 rw auto quick
-rw quick
-rw
-rw quick migration
---
-.24.1

The following changes since commit 672f9d0df10a68a5c5f2b32cbc8284abf9f5ee18:

Merge remote-tracking branch 'remotes/kevin/tags/for-upstream' into staging (2020-02-18 14:23:43 +0000)

are available in the Git repository at:

https://github.com/XanClic/qemu.git tags/pull-block-2020-02-20

for you to fetch changes up to dff8d44c96f128480430b0c59ed8760917dbd427:

iotests: Test snapshot -l field separation (2020-02-20 16:43:42 +0100)

----------------------------------------------------------------
Block patches:
- qemu-img convert: New --target-is-zero parameter
- qcow2: Specify non-default compression type flag
- optionally flat output for query-named-block-nodes
- some fixes
- pseudo-creation of images on block devices is now done by a generic
  block layer function

----------------------------------------------------------------
Daniel P. Berrangé (1):
  block: always fill entire LUKS header space with zeros

David Edmondson (1):
  qemu-img: Add --target-is-zero to convert

Max Reitz (11):
  iotests/147: Fix drive parameters
  iotests/279: Fix for non-qcow2 formats
  block/nbd: Fix hang in .bdrv_close()
  block: Generic file creation fallback
  file-posix: Drop hdev_co_create_opts()
  iscsi: Drop iscsi_co_create_opts()
  iotests: Add test for image creation fallback
  qemu-img: Fix convert -n -B for backing-less targets
  iotests: Test convert -n -B to backing-less target
  block: Fix VM size field width in snapshot dump
  iotests: Test snapshot -l field separation

Peter Krempa (1):
  qapi: Allow getting flat output from 'query-named-block-nodes'

Thomas Huth (1):
  iotests: Remove the superfluous 2nd check for the availability of
    quorum

Vladimir Sementsov-Ogievskiy (3):
  docs: improve qcow2 spec about extending image header
  docs: qcow2: introduce compression type feature
  block/backup-top: fix flags handling

block.c                    | 164 +++++++++++++++++++++++++++++++++----
 block/backup-top.c         |  31 ++++---
 block/file-posix.c         |  67 ---------------
 block/iscsi.c              |  56 -------------
 block/nbd.c                |  14 +++-
 block/qapi.c               |  15 +++-
 block/qcow2.c              |  11 ++-
 blockdev.c                 |   8 +-
 docs/interop/qcow2.txt     |  64 ++++++++++++++-
 docs/interop/qemu-img.rst  |   9 +-
 include/block/block.h      |   2 +-
 include/block/qapi.h       |   4 +-
 monitor/hmp-cmds.c         |   2 +-
 qapi/block-core.json       |   7 +-
 qemu-img-cmds.hx           |   4 +-
 qemu-img.c                 |  28 ++++++-
 tests/qemu-iotests/122     |  14 ++++
 tests/qemu-iotests/122.out |   5 ++
 tests/qemu-iotests/139     |   3 -
 tests/qemu-iotests/147     |   2 +-
 tests/qemu-iotests/259     |  62 ++++++++++++++
 tests/qemu-iotests/259.out |  14 ++++
 tests/qemu-iotests/279     |   7 +-
 tests/qemu-iotests/284     |  97 ++++++++++++++++++++++
 tests/qemu-iotests/284.out |  62 ++++++++++++++
 tests/qemu-iotests/286     |  76 +++++++++++++++++
 tests/qemu-iotests/286.out |   8 ++
 tests/qemu-iotests/group   |   3 +
 28 files changed, 659 insertions(+), 180 deletions(-)
 create mode 100755 tests/qemu-iotests/259
 create mode 100644 tests/qemu-iotests/259.out
 create mode 100755 tests/qemu-iotests/284
 create mode 100644 tests/qemu-iotests/284.out
 create mode 100755 tests/qemu-iotests/286
 create mode 100644 tests/qemu-iotests/286.out

-- 
2.24.1

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

Make it more obvious how to add new fields to the version 3 header and
how to interpret them.

The specification is adjusted so that for new defined optional fields:

1. Software may support some of these optional fields and ignore the
   others, which means that features may be backported to downstream
   Qemu independently.
2. If we want to add incompatible field (or a field, for which some of
   its values would be incompatible), it must be accompanied by
   incompatible feature bit.

Also the concept of "default is zero" is clarified, as it's strange to
say that the value of the field is assumed to be zero for the software
version which don't know about the field at all and don't know how to
treat it be it zero or not.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20200131142219.3264-2-vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
[mreitz: s/some its/some of its/]
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 docs/interop/qcow2.txt | 45 +++++++++++++++++++++++++++++++++++++++---
 1 file changed, 42 insertions(+), 3 deletions(-)

diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
index XXXXXXX..XXXXXXX 100644
--- a/docs/interop/qcow2.txt
+++ b/docs/interop/qcow2.txt
@@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header:
                     Offset into the image file at which the snapshot table
                     starts. Must be aligned to a cluster boundary.
 
-If the version is 3 or higher, the header has the following additional fields.
-For version 2, the values are assumed to be zero, unless specified otherwise
-in the description of a field.
+For version 2, the header is exactly 72 bytes in length, and finishes here.
+For version 3 or higher, the header length is at least 104 bytes, including
+the next fields through header_length.
 
          72 -  79:  incompatible_features
                     Bitmask of incompatible features. An implementation must
@@ -XXX,XX +XXX,XX @@ in the description of a field.
         100 - 103:  header_length
                     Length of the header structure in bytes. For version 2
                     images, the length is always assumed to be 72 bytes.
+                    For version 3 it's at least 104 bytes and must be a multiple
+                    of 8.
+
+
+=== Additional fields (version 3 and higher) ===
+
+In general, these fields are optional and may be safely ignored by the software,
+as well as filled by zeros (which is equal to field absence), if software needs
+to set field B, but does not care about field A which precedes B. More
+formally, additional fields have the following compatibility rules:
+
+1. If the value of the additional field must not be ignored for correct
+handling of the file, it will be accompanied by a corresponding incompatible
+feature bit.
+
+2. If there are no unrecognized incompatible feature bits set, an unknown
+additional field may be safely ignored other than preserving its value when
+rewriting the image header.
+
+3. An explicit value of 0 will have the same behavior as when the field is not
+present*, if not altered by a specific incompatible bit.
+
+*. A field is considered not present when header_length is less than or equal
+to the field's offset. Also, all additional fields are not present for
+version 2.
+
+        < ... No additional fields in the header currently ... >
+
+
+=== Header padding ===
+
+@header_length must be a multiple of 8, which means that if the end of the last
+additional field is not aligned, some padding is needed. This padding must be
+zeroed, so that if some existing (or future) additional field will fall into
+the padding, it will be interpreted accordingly to point [3.] of the previous
+paragraph, i.e.  in the same manner as when this field is not present.
+
+
+=== Header extensions ===
 
 Directly after the image header, optional sections called header extensions can
 be stored. Each extension has a structure like the following:
-- 
2.24.1

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

The patch adds a new additional field to the qcow2 header: compression_type,
which specifies compression type. If field is absent or zero, default
compression type is set: ZLIB, which corresponds to current behavior.

New compression type (ZSTD) is to be added in further commit.

Suggested-by: Denis Plotnikov <dplotnikov@virtuozzo.com>
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200131142219.3264-3-vsementsov@virtuozzo.com>
[mreitz: s/Bits 3-63:  Reserved/Bits 4-63:  Reserved/]
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 docs/interop/qcow2.txt | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
index XXXXXXX..XXXXXXX 100644
--- a/docs/interop/qcow2.txt
+++ b/docs/interop/qcow2.txt
@@ -XXX,XX +XXX,XX @@ the next fields through header_length.
                                 An External Data File Name header extension may
                                 be present if this bit is set.
 
-                    Bits 3-63:  Reserved (set to 0)
+                    Bit 3:      Compression type bit.  If this bit is set,
+                                a non-default compression is used for compressed
+                                clusters. The compression_type field must be
+                                present and not zero.
+
+                    Bits 4-63:  Reserved (set to 0)
 
          80 -  87:  compatible_features
                     Bitmask of compatible features. An implementation can
@@ -XXX,XX +XXX,XX @@ present*, if not altered by a specific incompatible bit.
 to the field's offset. Also, all additional fields are not present for
 version 2.
 
-        < ... No additional fields in the header currently ... >
+              104:  compression_type
+
+                    Defines the compression method used for compressed clusters.
+                    All compressed clusters in an image use the same compression
+                    type.
+
+                    If the incompatible bit "Compression type" is set: the field
+                    must be present and non-zero (which means non-zlib
+                    compression type). Otherwise, this field must not be present
+                    or must be zero (which means zlib).
+
+                    Available compression type values:
+                        0: zlib <https://www.zlib.net/>
 
 
 === Header padding ===
-- 
2.24.1

From: Thomas Huth <thuth@redhat.com>

Commit d9df28e7b07 ("iotests: check whitelisted formats") added the
modern @iotests.skip_if_unsupported() to the functions in this test,
so we don't need the old explicit test here anymore.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Message-Id: <20200129141751.32652-1-thuth@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Tested-by: Andrey Shinkevich <andrey.shinkevich@virtuozzo.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/139 | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tests/qemu-iotests/139 b/tests/qemu-iotests/139
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/139
+++ b/tests/qemu-iotests/139
@@ -XXX,XX +XXX,XX @@ class TestBlockdevDel(iotests.QMPTestCase):
 
     @iotests.skip_if_unsupported(['quorum'])
     def testQuorum(self):
-        if not iotests.supports_quorum():
-            return
-
         self.addQuorum('quorum0', 'node0', 'node1')
         # We cannot remove the children of a Quorum device
         self.delBlockDriverState('node0', expect_error = True)
-- 
2.24.1

8dff69b94 added an aio parameter to the drive parameter but forgot to
add a comma before, thus breaking the test.  Fix it again.

Fixes: 8dff69b9415b4287e900358744b732195e1ab2e2
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200206130812.612960-1-mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Tested-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/147 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/147 b/tests/qemu-iotests/147
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/147
+++ b/tests/qemu-iotests/147
@@ -XXX,XX +XXX,XX @@ class BuiltinNBD(NBDBlockdevAddBase):
         self.server.add_drive_raw('if=none,id=nbd-export,' +
                                   'file=%s,' % test_img +
                                   'format=%s,' % imgfmt +
-                                  'cache=%s' % cachemode +
+                                  'cache=%s,' % cachemode +
                                   'aio=%s' % aiomode)
         self.server.launch()
 
-- 
2.24.1

From: Peter Krempa <pkrempa@redhat.com>

When a management application manages node names there's no reason to
recurse into backing images in the output of query-named-block-nodes.

Add a parameter to the command which will return just the top level
structs.

Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Message-Id: <4470f8c779abc404dcf65e375db195cd91a80651.1579509782.git.pkrempa@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
[mreitz: Fixed coding style]
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block.c               |  5 +++--
 block/qapi.c          | 11 +++++++++--
 blockdev.c            |  8 ++++++--
 include/block/block.h |  2 +-
 include/block/qapi.h  |  4 +++-
 monitor/hmp-cmds.c    |  2 +-
 qapi/block-core.json  |  7 ++++++-
 7 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_find_node(const char *node_name)
 }
 
 /* Put this QMP function here so it can access the static graph_bdrv_states. */
-BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp)
+BlockDeviceInfoList *bdrv_named_nodes_list(bool flat,
+                                           Error **errp)
 {
     BlockDeviceInfoList *list, *entry;
     BlockDriverState *bs;
 
     list = NULL;
     QTAILQ_FOREACH(bs, &graph_bdrv_states, node_list) {
-        BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, errp);
+        BlockDeviceInfo *info = bdrv_block_device_info(NULL, bs, flat, errp);
         if (!info) {
             qapi_free_BlockDeviceInfoList(list);
             return NULL;
diff --git a/block/qapi.c b/block/qapi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qapi.c
+++ b/block/qapi.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/cutils.h"
 
 BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
-                                        BlockDriverState *bs, Error **errp)
+                                        BlockDriverState *bs,
+                                        bool flat,
+                                        Error **errp)
 {
     ImageInfo **p_image_info;
     BlockDriverState *bs0;
@@ -XXX,XX +XXX,XX @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
             return NULL;
         }
 
+        /* stop gathering data for flat output */
+        if (flat) {
+            break;
+        }
+
         if (bs0->drv && bs0->backing) {
             info->backing_file_depth++;
             bs0 = bs0->backing->bs;
@@ -XXX,XX +XXX,XX @@ static void bdrv_query_info(BlockBackend *blk, BlockInfo **p_info,
 
     if (bs && bs->drv) {
         info->has_inserted = true;
-        info->inserted = bdrv_block_device_info(blk, bs, errp);
+        info->inserted = bdrv_block_device_info(blk, bs, false, errp);
         if (info->inserted == NULL) {
             goto err;
         }
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_drive_backup(DriveBackup *backup, Error **errp)
     blockdev_do_action(&action, errp);
 }
 
-BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)
+BlockDeviceInfoList *qmp_query_named_block_nodes(bool has_flat,
+                                                 bool flat,
+                                                 Error **errp)
 {
-    return bdrv_named_nodes_list(errp);
+    bool return_flat = has_flat && flat;
+
+    return bdrv_named_nodes_list(return_flat, errp);
 }
 
 XDbgBlockGraph *qmp_x_debug_query_block_graph(Error **errp)
diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ void bdrv_lock_medium(BlockDriverState *bs, bool locked);
 void bdrv_eject(BlockDriverState *bs, bool eject_flag);
 const char *bdrv_get_format_name(BlockDriverState *bs);
 BlockDriverState *bdrv_find_node(const char *node_name);
-BlockDeviceInfoList *bdrv_named_nodes_list(Error **errp);
+BlockDeviceInfoList *bdrv_named_nodes_list(bool flat, Error **errp);
 XDbgBlockGraph *bdrv_get_xdbg_block_graph(Error **errp);
 BlockDriverState *bdrv_lookup_bs(const char *device,
                                  const char *node_name,
diff --git a/include/block/qapi.h b/include/block/qapi.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/qapi.h
+++ b/include/block/qapi.h
@@ -XXX,XX +XXX,XX @@
 #include "block/snapshot.h"
 
 BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
-                                        BlockDriverState *bs, Error **errp);
+                                        BlockDriverState *bs,
+                                        bool flat,
+                                        Error **errp);
 int bdrv_query_snapshot_info_list(BlockDriverState *bs,
                                   SnapshotInfoList **p_list,
                                   Error **errp);
diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/monitor/hmp-cmds.c
+++ b/monitor/hmp-cmds.c
@@ -XXX,XX +XXX,XX @@ void hmp_info_block(Monitor *mon, const QDict *qdict)
     }
 
     /* Print node information */
-    blockdev_list = qmp_query_named_block_nodes(NULL);
+    blockdev_list = qmp_query_named_block_nodes(false, false, NULL);
     for (blockdev = blockdev_list; blockdev; blockdev = blockdev->next) {
         assert(blockdev->value->has_node_name);
         if (device && strcmp(device, blockdev->value->node_name)) {
diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #
 # Get the named block driver list
 #
+# @flat: Omit the nested data about backing image ("backing-image" key) if true.
+#        Default is false (Since 5.0)
+#
 # Returns: the list of BlockDeviceInfo
 #
 # Since: 2.0
@@ -XXX,XX +XXX,XX @@
 #                    } } ] }
 #
 ##
-{ 'command': 'query-named-block-nodes', 'returns': [ 'BlockDeviceInfo' ] }
+{ 'command': 'query-named-block-nodes',
+  'returns': [ 'BlockDeviceInfo' ],
+  'data': { '*flat': 'bool' } }
 
 ##
 # @XDbgBlockGraphNodeType:
-- 
2.24.1

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

In many cases the target of a convert operation is a newly provisioned
target that the user knows is blank (reads as zero). In this situation
there is no requirement for qemu-img to wastefully zero out the entire
device.

Add a new option, --target-is-zero, allowing the user to indicate that
an existing target device will return zeros for all reads.

Signed-off-by: David Edmondson <david.edmondson@oracle.com>
Message-Id: <20200205110248.2009589-2-david.edmondson@oracle.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 docs/interop/qemu-img.rst |  9 ++++++++-
 qemu-img-cmds.hx          |  4 ++--
 qemu-img.c                | 26 +++++++++++++++++++++++---
 3 files changed, 33 insertions(+), 6 deletions(-)

diff --git a/docs/interop/qemu-img.rst b/docs/interop/qemu-img.rst
index XXXXXXX..XXXXXXX 100644
--- a/docs/interop/qemu-img.rst
+++ b/docs/interop/qemu-img.rst
@@ -XXX,XX +XXX,XX @@ Parameters to convert subcommand:
   will still be printed.  Areas that cannot be read from the source will be
   treated as containing only zeroes.
 
+.. option:: --target-is-zero
+
+  Assume that reading the destination image will always return
+  zeros. This parameter is mutually exclusive with a destination image
+  that has a backing file. It is required to also use the ``-n``
+  parameter to skip image creation.
+
 Parameters to dd subcommand:
 
 .. program:: qemu-img-dd
@@ -XXX,XX +XXX,XX @@ Command description:
   4
     Error on reading data
 
-.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME
+.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [--target-is-zero] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME
 
   Convert the disk image *FILENAME* or a snapshot *SNAPSHOT_PARAM*
   to disk image *OUTPUT_FILENAME* using format *OUTPUT_FMT*. It can
diff --git a/qemu-img-cmds.hx b/qemu-img-cmds.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img-cmds.hx
+++ b/qemu-img-cmds.hx
@@ -XXX,XX +XXX,XX @@ SRST
 ERST
 
 DEF("convert", img_convert,
-    "convert [--object objectdef] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f fmt] [-t cache] [-T src_cache] [-O output_fmt] [-B backing_file] [-o options] [-l snapshot_param] [-S sparse_size] [-m num_coroutines] [-W] [--salvage] filename [filename2 [...]] output_filename")
+    "convert [--object objectdef] [--image-opts] [--target-image-opts] [--target-is-zero] [-U] [-C] [-c] [-p] [-q] [-n] [-f fmt] [-t cache] [-T src_cache] [-O output_fmt] [-B backing_file] [-o options] [-l snapshot_param] [-S sparse_size] [-m num_coroutines] [-W] [--salvage] filename [filename2 [...]] output_filename")
 SRST
-.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] [--salvage] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME
+.. option:: convert [--object OBJECTDEF] [--image-opts] [--target-image-opts] [--target-is-zero] [-U] [-C] [-c] [-p] [-q] [-n] [-f FMT] [-t CACHE] [-T SRC_CACHE] [-O OUTPUT_FMT] [-B BACKING_FILE] [-o OPTIONS] [-l SNAPSHOT_PARAM] [-S SPARSE_SIZE] [-m NUM_COROUTINES] [-W] [--salvage] FILENAME [FILENAME2 [...]] OUTPUT_FILENAME
 ERST
 
 DEF("create", img_create,
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 @@ enum {
     OPTION_PREALLOCATION = 265,
     OPTION_SHRINK = 266,
     OPTION_SALVAGE = 267,
+    OPTION_TARGET_IS_ZERO = 268,
 };
 
 typedef enum OutputFormat {
@@ -XXX,XX +XXX,XX @@ static int convert_do_copy(ImgConvertState *s)
     int64_t sector_num = 0;
 
     /* Check whether we have zero initialisation or can get it efficiently */
-    if (s->target_is_new && s->min_sparse && !s->target_has_backing) {
+    if (!s->has_zero_init && s->target_is_new && s->min_sparse &&
+        !s->target_has_backing) {
         s->has_zero_init = bdrv_has_zero_init(blk_bs(s->target));
-    } else {
-        s->has_zero_init = false;
     }
 
     if (!s->has_zero_init && !s->target_has_backing &&
@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
             {"force-share", no_argument, 0, 'U'},
             {"target-image-opts", no_argument, 0, OPTION_TARGET_IMAGE_OPTS},
             {"salvage", no_argument, 0, OPTION_SALVAGE},
+            {"target-is-zero", no_argument, 0, OPTION_TARGET_IS_ZERO},
             {0, 0, 0, 0}
         };
         c = getopt_long(argc, argv, ":hf:O:B:Cco:l:S:pt:T:qnm:WU",
@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
         case OPTION_TARGET_IMAGE_OPTS:
             tgt_image_opts = true;
             break;
+        case OPTION_TARGET_IS_ZERO:
+            /*
+             * The user asserting that the target is blank has the
+             * same effect as the target driver supporting zero
+             * initialisation.
+             */
+            s.has_zero_init = true;
+            break;
         }
     }
 
@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
         warn_report("This will become an error in future QEMU versions.");
     }
 
+    if (s.has_zero_init && !skip_create) {
+        error_report("--target-is-zero requires use of -n flag");
+        goto fail_getopt;
+    }
+
     s.src_num = argc - optind - 1;
     out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL;
 
@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
     }
     s.target_has_backing = (bool) out_baseimg;
 
+    if (s.has_zero_init && s.target_has_backing) {
+        error_report("Cannot use --target-is-zero when the destination "
+                     "image has a backing file");
+        goto out;
+    }
+
     if (s.src_num > 1 && out_baseimg) {
         error_report("Having a backing file for the target makes no sense when "
                      "concatenating multiple input images");
-- 
2.24.1

From: Daniel P. Berrangé <berrange@redhat.com>

When initializing the LUKS header the size with default encryption
parameters will currently be 2068480 bytes. This is rounded up to
a multiple of the cluster size, 2081792, with 64k sectors. If the
end of the header is not the same as the end of the cluster we fill
the extra space with zeros. This was forgetting that not even the
space allocated for the header will be fully initialized, as we
only write key material for the first key slot. The space left
for the other 7 slots is never written to.

An optimization to the ref count checking code:

commit a5fff8d4b4d928311a5005efa12d0991fe3b66f9 (refs/bisect/bad)
  Author: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
  Date:   Wed Feb 27 16:14:30 2019 +0300

qcow2-refcount: avoid eating RAM

made the assumption that every cluster which was allocated would
have at least some data written to it. This was violated by way
the LUKS header is only partially written, with much space simply
reserved for future use.

Depending on the cluster size this problem was masked by the
logic which wrote zeros between the end of the LUKS header and
the end of the cluster.

$ qemu-img create --object secret,id=cluster_encrypt0,data=123456 \
   -f qcow2 -o cluster_size=2k,encrypt.iter-time=1,\
               encrypt.format=luks,encrypt.key-secret=cluster_encrypt0 \
               cluster_size_check.qcow2 100M
  Formatting 'cluster_size_check.qcow2', fmt=qcow2 size=104857600
    encrypt.format=luks encrypt.key-secret=cluster_encrypt0
    encrypt.iter-time=1 cluster_size=2048 lazy_refcounts=off refcount_bits=16

$ qemu-img check --object secret,id=cluster_encrypt0,data=redhat \
    'json:{"driver": "qcow2", "encrypt.format": "luks", \
           "encrypt.key-secret": "cluster_encrypt0", \
           "file.driver": "file", "file.filename": "cluster_size_check.qcow2"}'
ERROR: counting reference for region exceeding the end of the file by one cluster or more: offset 0x2000 size 0x1f9000
Leaked cluster 4 refcount=1 reference=0
...snip...
Leaked cluster 130 refcount=1 reference=0

1 errors were found on the image.
Data may be corrupted, or further writes to the image may corrupt it.

127 leaked clusters were found on the image.
This means waste of disk space, but no harm to data.
Image end offset: 268288

The problem only exists when the disk image is entirely empty. Writing
data to the disk image payload will solve the problem by causing the
end of the file to be extended further.

The change fixes it by ensuring that the entire allocated LUKS header
region is fully initialized with zeros. The qemu-img check will still
fail for any pre-existing disk images created prior to this change,
unless at least 1 byte of the payload is written to.

Fully writing zeros to the entire LUKS header is a good idea regardless
as it ensures that space has been allocated on the host filesystem (or
whatever block storage backend is used).

Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20200207135520.2669430-1-berrange@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/qcow2.c              | 11 +++--
 tests/qemu-iotests/284     | 97 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/284.out | 62 ++++++++++++++++++++++++
 tests/qemu-iotests/group   |  1 +
 4 files changed, 167 insertions(+), 4 deletions(-)
 create mode 100755 tests/qemu-iotests/284
 create mode 100644 tests/qemu-iotests/284.out

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 ssize_t qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
     s->crypto_header.length = headerlen;
     s->crypto_header.offset = ret;
 
-    /* Zero fill remaining space in cluster so it has predictable
-     * content in case of future spec changes */
+    /*
+     * Zero fill all space in cluster so it has predictable
+     * content, as we may not initialize some regions of the
+     * header (eg only 1 out of 8 key slots will be initialized)
+     */
     clusterlen = size_to_clusters(s, headerlen) * s->cluster_size;
     assert(qcow2_pre_write_overlap_check(bs, 0, ret, clusterlen, false) == 0);
     ret = bdrv_pwrite_zeroes(bs->file,
-                             ret + headerlen,
-                             clusterlen - headerlen, 0);
+                             ret,
+                             clusterlen, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not zero fill encryption header");
         return -1;
diff --git a/tests/qemu-iotests/284 b/tests/qemu-iotests/284
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/284
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env bash
+#
+# Test ref count checks on encrypted images
+#
+# Copyright (C) 2019 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# creator
+owner=berrange@redhat.com
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+status=1        # failure is the default!
+
+_cleanup()
+{
+        _cleanup_test_img
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+
+_supported_fmt qcow2
+_supported_proto generic
+_supported_os Linux
+
+
+size=1M
+
+SECRET="secret,id=sec0,data=astrochicken"
+
+IMGSPEC="driver=$IMGFMT,file.filename=$TEST_IMG,encrypt.key-secret=sec0"
+QEMU_IO_OPTIONS=$QEMU_IO_OPTIONS_NO_FMT
+
+_run_test()
+{
+        IMGOPTSSYNTAX=true
+        OLD_TEST_IMG="$TEST_IMG"
+        TEST_IMG="driver=$IMGFMT,file.filename=$TEST_IMG,encrypt.key-secret=sec0"
+        QEMU_IMG_EXTRA_ARGS="--image-opts --object $SECRET"
+
+        echo
+        echo "== cluster size $csize"
+        echo "== checking image refcounts =="
+        _check_test_img
+
+        echo
+        echo "== writing some data =="
+        $QEMU_IO -c "write -P 0x9 0 1"  $QEMU_IMG_EXTRA_ARGS $TEST_IMG | _filter_qemu_io | _filter_testdir
+        echo
+        echo "== rechecking image refcounts =="
+        _check_test_img
+
+        echo
+        echo "== writing some more data =="
+        $QEMU_IO -c "write -P 0x9 $csize 1" $QEMU_IMG_EXTRA_ARGS $TEST_IMG | _filter_qemu_io | _filter_testdir
+        echo
+        echo "== rechecking image refcounts =="
+        _check_test_img
+
+        TEST_IMG="$OLD_TEST_IMG"
+        QEMU_IMG_EXTRA_ARGS=
+        IMGOPTSSYNTAX=
+}
+
+
+echo
+echo "testing LUKS qcow2 encryption"
+echo
+
+for csize in 512 2048 32768
+do
+  _make_test_img --object $SECRET -o "encrypt.format=luks,encrypt.key-secret=sec0,encrypt.iter-time=10,cluster_size=$csize" $size
+  _run_test
+  _cleanup_test_img
+done
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/284.out b/tests/qemu-iotests/284.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/284.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 284
+
+testing LUKS qcow2 encryption
+
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10
+
+== cluster size 512
+== checking image refcounts ==
+No errors were found on the image.
+
+== writing some data ==
+wrote 1/1 bytes at offset 0
+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== rechecking image refcounts ==
+No errors were found on the image.
+
+== writing some more data ==
+wrote 1/1 bytes at offset 512
+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== rechecking image refcounts ==
+No errors were found on the image.
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10
+
+== cluster size 2048
+== checking image refcounts ==
+No errors were found on the image.
+
+== writing some data ==
+wrote 1/1 bytes at offset 0
+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== rechecking image refcounts ==
+No errors were found on the image.
+
+== writing some more data ==
+wrote 1/1 bytes at offset 2048
+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== rechecking image refcounts ==
+No errors were found on the image.
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 encrypt.format=luks encrypt.key-secret=sec0 encrypt.iter-time=10
+
+== cluster size 32768
+== checking image refcounts ==
+No errors were found on the image.
+
+== writing some data ==
+wrote 1/1 bytes at offset 0
+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== rechecking image refcounts ==
+No errors were found on the image.
+
+== writing some more data ==
+wrote 1/1 bytes at offset 32768
+1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== rechecking image refcounts ==
+No errors were found on the image.
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 280 rw migration quick
 281 rw quick
 283 auto quick
+284 rw
-- 
2.24.1

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

backup-top "supports" write-unchanged, by skipping CBW operation in
backup_top_co_pwritev. But it forgets to do the same in
backup_top_co_pwrite_zeroes, as well as declare support for
BDRV_REQ_WRITE_UNCHANGED.

Fix this, and, while being here, declare also support for flags
supported by source child.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200207161231.32707-1-vsementsov@virtuozzo.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/backup-top.c | 31 ++++++++++++++++++++-----------
 1 file changed, 20 insertions(+), 11 deletions(-)

diff --git a/block/backup-top.c b/block/backup-top.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup-top.c
+++ b/block/backup-top.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int backup_top_co_preadv(
 }
 
 static coroutine_fn int backup_top_cbw(BlockDriverState *bs, uint64_t offset,
-                                       uint64_t bytes)
+                                       uint64_t bytes, BdrvRequestFlags flags)
 {
     BDRVBackupTopState *s = bs->opaque;
-    uint64_t end = QEMU_ALIGN_UP(offset + bytes, s->bcs->cluster_size);
-    uint64_t off = QEMU_ALIGN_DOWN(offset, s->bcs->cluster_size);
+    uint64_t off, end;
+
+    if (flags & BDRV_REQ_WRITE_UNCHANGED) {
+        return 0;
+    }
+
+    off = QEMU_ALIGN_DOWN(offset, s->bcs->cluster_size);
+    end = QEMU_ALIGN_UP(offset + bytes, s->bcs->cluster_size);
 
     return block_copy(s->bcs, off, end - off, NULL);
 }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int backup_top_cbw(BlockDriverState *bs, uint64_t offset,
 static int coroutine_fn backup_top_co_pdiscard(BlockDriverState *bs,
                                                int64_t offset, int bytes)
 {
-    int ret = backup_top_cbw(bs, offset, bytes);
+    int ret = backup_top_cbw(bs, offset, bytes, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn backup_top_co_pdiscard(BlockDriverState *bs,
 static int coroutine_fn backup_top_co_pwrite_zeroes(BlockDriverState *bs,
         int64_t offset, int bytes, BdrvRequestFlags flags)
 {
-    int ret = backup_top_cbw(bs, offset, bytes);
+    int ret = backup_top_cbw(bs, offset, bytes, flags);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int backup_top_co_pwritev(BlockDriverState *bs,
                                               uint64_t bytes,
                                               QEMUIOVector *qiov, int flags)
 {
-    if (!(flags & BDRV_REQ_WRITE_UNCHANGED)) {
-        int ret = backup_top_cbw(bs, offset, bytes);
-        if (ret < 0) {
-            return ret;
-        }
+    int ret = backup_top_cbw(bs, offset, bytes, flags);
+    if (ret < 0) {
+        return ret;
     }
 
     return bdrv_co_pwritev(bs->backing, offset, bytes, qiov, flags);
@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_backup_top_append(BlockDriverState *source,
         return NULL;
     }
 
-    top->total_sectors = source->total_sectors;
     state = top->opaque;
+    top->total_sectors = source->total_sectors;
+    top->supported_write_flags = BDRV_REQ_WRITE_UNCHANGED |
+            (BDRV_REQ_FUA & source->supported_write_flags);
+    top->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
+            ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
+             source->supported_zero_flags);
 
     bdrv_ref(target);
     state->target = bdrv_attach_child(top, target, "target", &child_file, errp);
-- 
2.24.1

First, driver=qcow2 will not work so well with non-qcow2 formats (and
this test claims to support qcow, qed, and vmdk).

Second, vmdk will always report the backing file format to be vmdk.
Filter that out so the output looks like for all other formats.

Third, the flat vmdk subformats do not support backing files, so they
will not work with this test.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20191219144243.1763246-1-mreitz@redhat.com>
Tested-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/279 | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/279 b/tests/qemu-iotests/279
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/279
+++ b/tests/qemu-iotests/279
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow qcow2 vmdk qed
 _supported_proto file
 _supported_os Linux
+_unsupported_imgopts "subformat=monolithicFlat" \
+                     "subformat=twoGbMaxExtentFlat" \
 
 TEST_IMG="$TEST_IMG.base" _make_test_img 64M
 TEST_IMG="$TEST_IMG.mid" _make_test_img -b "$TEST_IMG.base"
@@ -XXX,XX +XXX,XX @@ _make_test_img -b "$TEST_IMG.mid"
 
 echo
 echo '== qemu-img info --backing-chain =='
-_img_info --backing-chain | _filter_img_info
+_img_info --backing-chain | _filter_img_info | grep -v 'backing file format'
 
 echo
 echo '== qemu-img info --backing-chain --image-opts =='
-TEST_IMG="driver=qcow2,file.driver=file,file.filename=$TEST_IMG" _img_info --backing-chain --image-opts | _filter_img_info
+TEST_IMG="driver=$IMGFMT,file.driver=file,file.filename=$TEST_IMG" _img_info --backing-chain --image-opts \
+    | _filter_img_info | grep -v 'backing file format'
 
 # success, all done
 echo "*** done"
-- 
2.24.1

When nbd_close() is called from a coroutine, the connection_co never
gets to run, and thus nbd_teardown_connection() hangs.

This is because aio_co_enter() only puts the connection_co into the main
coroutine's wake-up queue, so this main coroutine needs to yield and
wait for connection_co to terminate.

Suggested-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200122164532.178040-2-mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/nbd.c | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/block/nbd.c b/block/nbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nbd.c
+++ b/block/nbd.c
@@ -XXX,XX +XXX,XX @@ typedef struct BDRVNBDState {
     CoMutex send_mutex;
     CoQueue free_sema;
     Coroutine *connection_co;
+    Coroutine *teardown_co;
     QemuCoSleepState *connection_co_sleep_ns_state;
     bool drained;
     bool wait_drained_end;
@@ -XXX,XX +XXX,XX @@ static void nbd_teardown_connection(BlockDriverState *bs)
             qemu_co_sleep_wake(s->connection_co_sleep_ns_state);
         }
     }
-    BDRV_POLL_WHILE(bs, s->connection_co);
+    if (qemu_in_coroutine()) {
+        s->teardown_co = qemu_coroutine_self();
+        /* connection_co resumes us when it terminates */
+        qemu_coroutine_yield();
+        s->teardown_co = NULL;
+    } else {
+        BDRV_POLL_WHILE(bs, s->connection_co);
+    }
+    assert(!s->connection_co);
 }
 
 static bool nbd_client_connecting(BDRVNBDState *s)
@@ -XXX,XX +XXX,XX @@ static coroutine_fn void nbd_connection_entry(void *opaque)
         s->ioc = NULL;
     }
 
+    if (s->teardown_co) {
+        aio_co_wake(s->teardown_co);
+    }
     aio_wait_kick();
 }
 
-- 
2.24.1

If a protocol driver does not support image creation, we can see whether
maybe the file exists already.  If so, just truncating it will be
sufficient.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200122164532.178040-3-mreitz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block.c | 159 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 147 insertions(+), 12 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
-int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
+/**
+ * Helper function for bdrv_create_file_fallback(): Resize @blk to at
+ * least the given @minimum_size.
+ *
+ * On success, return @blk's actual length.
+ * Otherwise, return -errno.
+ */
+static int64_t create_file_fallback_truncate(BlockBackend *blk,
+                                             int64_t minimum_size, Error **errp)
 {
-    BlockDriver *drv;
+    Error *local_err = NULL;
+    int64_t size;
+    int ret;
+
+    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);
+    if (ret < 0 && ret != -ENOTSUP) {
+        error_propagate(errp, local_err);
+        return ret;
+    }
+
+    size = blk_getlength(blk);
+    if (size < 0) {
+        error_free(local_err);
+        error_setg_errno(errp, -size,
+                         "Failed to inquire the new image file's length");
+        return size;
+    }
+
+    if (size < minimum_size) {
+        /* Need to grow the image, but we failed to do that */
+        error_propagate(errp, local_err);
+        return -ENOTSUP;
+    }
+
+    error_free(local_err);
+    local_err = NULL;
+
+    return size;
+}
+
+/**
+ * Helper function for bdrv_create_file_fallback(): Zero the first
+ * sector to remove any potentially pre-existing image header.
+ */
+static int create_file_fallback_zero_first_sector(BlockBackend *blk,
+                                                  int64_t current_size,
+                                                  Error **errp)
+{
+    int64_t bytes_to_clear;
+    int ret;
+
+    bytes_to_clear = MIN(current_size, BDRV_SECTOR_SIZE);
+    if (bytes_to_clear) {
+        ret = blk_pwrite_zeroes(blk, 0, bytes_to_clear, BDRV_REQ_MAY_UNMAP);
+        if (ret < 0) {
+            error_setg_errno(errp, -ret,
+                             "Failed to clear the new image's first sector");
+            return ret;
+        }
+    }
+
+    return 0;
+}
+
+static int bdrv_create_file_fallback(const char *filename, BlockDriver *drv,
+                                     QemuOpts *opts, Error **errp)
+{
+    BlockBackend *blk;
+    QDict *options = qdict_new();
+    int64_t size = 0;
+    char *buf = NULL;
+    PreallocMode prealloc;
     Error *local_err = NULL;
     int ret;
 
+    size = qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0);
+    buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);
+    prealloc = qapi_enum_parse(&PreallocMode_lookup, buf,
+                               PREALLOC_MODE_OFF, &local_err);
+    g_free(buf);
+    if (local_err) {
+        error_propagate(errp, local_err);
+        return -EINVAL;
+    }
+
+    if (prealloc != PREALLOC_MODE_OFF) {
+        error_setg(errp, "Unsupported preallocation mode '%s'",
+                   PreallocMode_str(prealloc));
+        return -ENOTSUP;
+    }
+
+    qdict_put_str(options, "driver", drv->format_name);
+
+    blk = blk_new_open(filename, NULL, options,
+                       BDRV_O_RDWR | BDRV_O_RESIZE, errp);
+    if (!blk) {
+        error_prepend(errp, "Protocol driver '%s' does not support image "
+                      "creation, and opening the image failed: ",
+                      drv->format_name);
+        return -EINVAL;
+    }
+
+    size = create_file_fallback_truncate(blk, size, errp);
+    if (size < 0) {
+        ret = size;
+        goto out;
+    }
+
+    ret = create_file_fallback_zero_first_sector(blk, size, errp);
+    if (ret < 0) {
+        goto out;
+    }
+
+    ret = 0;
+out:
+    blk_unref(blk);
+    return ret;
+}
+
+int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
+{
+    BlockDriver *drv;
+
     drv = bdrv_find_protocol(filename, true, errp);
     if (drv == NULL) {
         return -ENOENT;
     }
 
-    ret = bdrv_create(drv, filename, opts, &local_err);
-    error_propagate(errp, local_err);
-    return ret;
+    if (drv->bdrv_co_create_opts) {
+        return bdrv_create(drv, filename, opts, errp);
+    } else {
+        return bdrv_create_file_fallback(filename, drv, opts, errp);
+    }
 }
 
 /**
@@ -XXX,XX +XXX,XX @@ QemuOptsList bdrv_runtime_opts = {
     },
 };
 
+static QemuOptsList fallback_create_opts = {
+    .name = "fallback-create-opts",
+    .head = QTAILQ_HEAD_INITIALIZER(fallback_create_opts.head),
+    .desc = {
+        {
+            .name = BLOCK_OPT_SIZE,
+            .type = QEMU_OPT_SIZE,
+            .help = "Virtual disk size"
+        },
+        {
+            .name = BLOCK_OPT_PREALLOC,
+            .type = QEMU_OPT_STRING,
+            .help = "Preallocation mode (allowed values: off)"
+        },
+        { /* end of list */ }
+    }
+};
+
 /*
  * Common part for opening disk images and files
  *
@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,
         return;
     }
 
-    if (!proto_drv->create_opts) {
-        error_setg(errp, "Protocol driver '%s' does not support image creation",
-                   proto_drv->format_name);
-        return;
-    }
-
     /* Create parameter list */
     create_opts = qemu_opts_append(create_opts, drv->create_opts);
-    create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
+    if (proto_drv->create_opts) {
+        create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
+    } else {
+        create_opts = qemu_opts_append(create_opts, &fallback_create_opts);
+    }
 
     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
 
-- 
2.24.1

The generic fallback implementation effectively does the same.

Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200122164532.178040-4-mreitz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/file-posix.c | 67 ----------------------------------------------
 1 file changed, 67 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 @@ static coroutine_fn int hdev_co_pwrite_zeroes(BlockDriverState *bs,
     return raw_do_pwrite_zeroes(bs, offset, bytes, flags, true);
 }
 
-static int coroutine_fn hdev_co_create_opts(const char *filename, QemuOpts *opts,
-                                            Error **errp)
-{
-    int fd;
-    int ret = 0;
-    struct stat stat_buf;
-    int64_t total_size = 0;
-    bool has_prefix;
-
-    /* This function is used by both protocol block drivers and therefore either
-     * of these prefixes may be given.
-     * The return value has to be stored somewhere, otherwise this is an error
-     * due to -Werror=unused-value. */
-    has_prefix =
-        strstart(filename, "host_device:", &filename) ||
-        strstart(filename, "host_cdrom:" , &filename);
-
-    (void)has_prefix;
-
-    ret = raw_normalize_devicepath(&filename, errp);
-    if (ret < 0) {
-        return ret;
-    }
-
-    /* Read out options */
-    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
-                          BDRV_SECTOR_SIZE);
-
-    fd = qemu_open(filename, O_WRONLY | O_BINARY);
-    if (fd < 0) {
-        ret = -errno;
-        error_setg_errno(errp, -ret, "Could not open device");
-        return ret;
-    }
-
-    if (fstat(fd, &stat_buf) < 0) {
-        ret = -errno;
-        error_setg_errno(errp, -ret, "Could not stat device");
-    } else if (!S_ISBLK(stat_buf.st_mode) && !S_ISCHR(stat_buf.st_mode)) {
-        error_setg(errp,
-                   "The given file is neither a block nor a character device");
-        ret = -ENODEV;
-    } else if (lseek(fd, 0, SEEK_END) < total_size) {
-        error_setg(errp, "Device is too small");
-        ret = -ENOSPC;
-    }
-
-    if (!ret && total_size) {
-        uint8_t buf[BDRV_SECTOR_SIZE] = { 0 };
-        int64_t zero_size = MIN(BDRV_SECTOR_SIZE, total_size);
-        if (lseek(fd, 0, SEEK_SET) == -1) {
-            ret = -errno;
-        } else {
-            ret = qemu_write_full(fd, buf, zero_size);
-            ret = ret == zero_size ? 0 : -errno;
-        }
-    }
-    qemu_close(fd);
-    return ret;
-}
-
 static BlockDriver bdrv_host_device = {
     .format_name        = "host_device",
     .protocol_name        = "host_device",
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_device = {
     .bdrv_reopen_prepare = raw_reopen_prepare,
     .bdrv_reopen_commit  = raw_reopen_commit,
     .bdrv_reopen_abort   = raw_reopen_abort,
-    .bdrv_co_create_opts = hdev_co_create_opts,
-    .create_opts         = &raw_create_opts,
     .mutable_opts        = mutable_opts,
     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
     .bdrv_co_pwrite_zeroes = hdev_co_pwrite_zeroes,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_cdrom = {
     .bdrv_reopen_prepare = raw_reopen_prepare,
     .bdrv_reopen_commit  = raw_reopen_commit,
     .bdrv_reopen_abort   = raw_reopen_abort,
-    .bdrv_co_create_opts = hdev_co_create_opts,
-    .create_opts         = &raw_create_opts,
     .mutable_opts        = mutable_opts,
     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
 
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_host_cdrom = {
     .bdrv_reopen_prepare = raw_reopen_prepare,
     .bdrv_reopen_commit  = raw_reopen_commit,
     .bdrv_reopen_abort   = raw_reopen_abort,
-    .bdrv_co_create_opts = hdev_co_create_opts,
-    .create_opts        = &raw_create_opts,
     .mutable_opts       = mutable_opts,
 
     .bdrv_co_preadv         = raw_co_preadv,
-- 
2.24.1

The generic fallback implementation effectively does the same.

Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200122164532.178040-5-mreitz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/iscsi.c | 56 ---------------------------------------------------
 1 file changed, 56 deletions(-)

diff --git a/block/iscsi.c b/block/iscsi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/iscsi.c
+++ b/block/iscsi.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,
     return 0;
 }
 
-static int coroutine_fn iscsi_co_create_opts(const char *filename, QemuOpts *opts,
-                                             Error **errp)
-{
-    int ret = 0;
-    int64_t total_size = 0;
-    BlockDriverState *bs;
-    IscsiLun *iscsilun = NULL;
-    QDict *bs_options;
-    Error *local_err = NULL;
-
-    bs = bdrv_new();
-
-    /* Read out options */
-    total_size = DIV_ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
-                              BDRV_SECTOR_SIZE);
-    bs->opaque = g_new0(struct IscsiLun, 1);
-    iscsilun = bs->opaque;
-
-    bs_options = qdict_new();
-    iscsi_parse_filename(filename, bs_options, &local_err);
-    if (local_err) {
-        error_propagate(errp, local_err);
-        ret = -EINVAL;
-    } else {
-        ret = iscsi_open(bs, bs_options, 0, NULL);
-    }
-    qobject_unref(bs_options);
-
-    if (ret != 0) {
-        goto out;
-    }
-    iscsi_detach_aio_context(bs);
-    if (iscsilun->type != TYPE_DISK) {
-        ret = -ENODEV;
-        goto out;
-    }
-    if (bs->total_sectors < total_size) {
-        ret = -ENOSPC;
-        goto out;
-    }
-
-    ret = 0;
-out:
-    if (iscsilun->iscsi != NULL) {
-        iscsi_destroy_context(iscsilun->iscsi);
-    }
-    g_free(bs->opaque);
-    bs->opaque = NULL;
-    bdrv_unref(bs);
-    return ret;
-}
-
 static int iscsi_get_info(BlockDriverState *bs, BlockDriverInfo *bdi)
 {
     IscsiLun *iscsilun = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iscsi = {
     .bdrv_parse_filename    = iscsi_parse_filename,
     .bdrv_file_open         = iscsi_open,
     .bdrv_close             = iscsi_close,
-    .bdrv_co_create_opts    = iscsi_co_create_opts,
-    .create_opts            = &iscsi_create_opts,
     .bdrv_reopen_prepare    = iscsi_reopen_prepare,
     .bdrv_reopen_commit     = iscsi_reopen_commit,
     .bdrv_co_invalidate_cache = iscsi_co_invalidate_cache,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_iser = {
     .bdrv_parse_filename    = iscsi_parse_filename,
     .bdrv_file_open         = iscsi_open,
     .bdrv_close             = iscsi_close,
-    .bdrv_co_create_opts    = iscsi_co_create_opts,
-    .create_opts            = &iscsi_create_opts,
     .bdrv_reopen_prepare    = iscsi_reopen_prepare,
     .bdrv_reopen_commit     = iscsi_reopen_commit,
     .bdrv_co_invalidate_cache  = iscsi_co_invalidate_cache,
-- 
2.24.1

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200122164532.178040-6-mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Maxim Levitsky <mlevitsk@redhat.com>
[mreitz: Added a note that NBD does not support resizing, which is why
         the second case is expected to fail]
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/259     | 62 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/259.out | 14 +++++++++
 tests/qemu-iotests/group   |  1 +
 3 files changed, 77 insertions(+)
 create mode 100755 tests/qemu-iotests/259
 create mode 100644 tests/qemu-iotests/259.out

diff --git a/tests/qemu-iotests/259 b/tests/qemu-iotests/259
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/259
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env bash
+#
+# Test generic image creation fallback (by using NBD)
+#
+# Copyright (C) 2019 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# creator
+owner=mreitz@redhat.com
+
+seq=$(basename $0)
+echo "QA output created by $seq"
+
+status=1	# failure is the default!
+
+_cleanup()
+{
+    _cleanup_test_img
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+
+_supported_fmt raw
+_supported_proto nbd
+_supported_os Linux
+
+
+_make_test_img 64M
+
+echo
+echo '--- Testing creation ---'
+
+$QEMU_IMG create -f qcow2 "$TEST_IMG" 64M | _filter_img_create
+$QEMU_IMG info "$TEST_IMG" | _filter_img_info
+
+echo
+echo '--- Testing creation for which the node would need to grow ---'
+
+# NBD does not support resizing, so this will fail
+$QEMU_IMG create -f qcow2 -o preallocation=metadata "$TEST_IMG" 64M 2>&1 \
+    | _filter_img_create
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/259.out b/tests/qemu-iotests/259.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/259.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 259
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
+
+--- Testing creation ---
+Formatting 'TEST_DIR/t.IMGFMT', fmt=qcow2 size=67108864
+image: TEST_DIR/t.IMGFMT
+file format: qcow2
+virtual size: 64 MiB (67108864 bytes)
+disk size: unavailable
+
+--- Testing creation for which the node would need to grow ---
+qemu-img: TEST_DIR/t.IMGFMT: Could not resize image: Image format driver does not support resize
+Formatting 'TEST_DIR/t.IMGFMT', fmt=qcow2 size=67108864 preallocation=metadata
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 256 rw auto quick
 257 rw
 258 rw quick
+259 rw auto quick
 260 rw quick
 261 rw
 262 rw quick migration
-- 
2.24.1

s.target_has_backing does not reflect whether the target BDS has a
backing file; it only tells whether we should use a backing file during
conversion (specified by -B).

As such, if you use convert -n, the target does not necessarily actually
have a backing file, and then dereferencing out_bs->backing fails here.

When converting to an existing file, we should set
target_backing_sectors to a negative value, because first, as the
comment explains, this value is only used for optimization, so it is
always fine to do that.

Second, we use this value to determine where the target must be
initialized to zeroes (overlays are initialized to zero after the end of
their backing file).  When converting to an existing file, we cannot
assume that to be true.

Cc: qemu-stable@nongnu.org
Fixes: 351c8efff9ad809c822d55620df54d575d536f68
       ("qemu-img: Special post-backing convert handling")
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200121155915.98232-2-mreitz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qemu-img.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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)
         }
     }
 
-    if (s.target_has_backing) {
+    if (s.target_has_backing && s.target_is_new) {
         /* Errors are treated as "backing length unknown" (which means
          * s.target_backing_sectors has to be negative, which it will
          * be automatically).  The backing file length is used only
-- 
2.24.1

This must not crash.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200121155915.98232-3-mreitz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/122     | 14 ++++++++++++++
 tests/qemu-iotests/122.out |  5 +++++
 2 files changed, 19 insertions(+)

diff --git a/tests/qemu-iotests/122 b/tests/qemu-iotests/122
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/122
+++ b/tests/qemu-iotests/122
@@ -XXX,XX +XXX,XX @@ $QEMU_IMG convert -O $IMGFMT -n "$TEST_IMG" "$TEST_IMG".orig
 
 $QEMU_IMG compare "$TEST_IMG" "$TEST_IMG".orig
 
+echo
+echo '=== -n -B to an image without a backing file ==='
+echo
+
+# Base for the output
+TEST_IMG="$TEST_IMG".base _make_test_img 64M
+
+# Output that does have $TEST_IMG.base set as its (implicit) backing file
+TEST_IMG="$TEST_IMG".orig _make_test_img 64M
+
+# Convert with -n, which should not confuse -B with "target BDS has a
+# backing file"
+$QEMU_IMG convert -O $IMGFMT -B "$TEST_IMG".base -n "$TEST_IMG" "$TEST_IMG".orig
+
 # success, all done
 echo '*** done'
 rm -f $seq.full
diff --git a/tests/qemu-iotests/122.out b/tests/qemu-iotests/122.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/122.out
+++ b/tests/qemu-iotests/122.out
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT.orig', fmt=IMGFMT size=67108864
 wrote 65536/65536 bytes at offset 0
 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 Images are identical.
+
+=== -n -B to an image without a backing file ===
+
+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864
+Formatting 'TEST_DIR/t.IMGFMT.orig', fmt=IMGFMT size=67108864
 *** done
-- 
2.24.1

When printing the snapshot list (e.g. with qemu-img snapshot -l), the VM
size field is only seven characters wide.  As of de38b5005e9, this is
not necessarily sufficient: We generally print three digits, and this
may require a decimal point.  Also, the unit field grew from something
as plain as "M" to " MiB".  This means that number and unit may take up
eight characters in total; but we also want spaces in front.

Considering previously the maximum width was four characters and the
field width was chosen to be three characters wider, let us adjust the
field width to be eleven now.

Fixes: de38b5005e946aa3714963ea4c501e279e7d3666
Buglink: https://bugs.launchpad.net/qemu/+bug/1859989
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200117105859.241818-2-mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/qapi.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/block/qapi.c b/block/qapi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qapi.c
+++ b/block/qapi.c
@@ -XXX,XX +XXX,XX @@ void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)
     char *sizing = NULL;
 
     if (!sn) {
-        qemu_printf("%-10s%-20s%7s%20s%15s",
+        qemu_printf("%-10s%-20s%11s%20s%15s",
                     "ID", "TAG", "VM SIZE", "DATE", "VM CLOCK");
     } else {
         ti = sn->date_sec;
@@ -XXX,XX +XXX,XX @@ void bdrv_snapshot_dump(QEMUSnapshotInfo *sn)
                  (int)(secs % 60),
                  (int)((sn->vm_clock_nsec / 1000000) % 1000));
         sizing = size_to_str(sn->vm_state_size);
-        qemu_printf("%-10s%-20s%7s%20s%15s",
+        qemu_printf("%-10s%-20s%11s%20s%15s",
                     sn->id_str, sn->name,
                     sizing,
                     date_buf,
-- 
2.24.1

Add a test that all fields in "qemu-img snapshot -l"s output are
separated by spaces.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200117105859.241818-3-mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
[mreitz: Renamed test from 284 to 286]
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/286     | 76 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/286.out |  8 ++++
 tests/qemu-iotests/group   |  1 +
 3 files changed, 85 insertions(+)
 create mode 100755 tests/qemu-iotests/286
 create mode 100644 tests/qemu-iotests/286.out

diff --git a/tests/qemu-iotests/286 b/tests/qemu-iotests/286
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/286
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env bash
+#
+# Test qemu-img snapshot -l
+#
+# Copyright (C) 2019 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+seq=$(basename "$0")
+echo "QA output created by $seq"
+
+status=1	# failure is the default!
+
+_cleanup()
+{
+    _cleanup_test_img
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+. ./common.qemu
+
+_supported_fmt qcow2
+_supported_proto file
+# Internal snapshots are (currently) impossible with refcount_bits=1,
+# and generally impossible with external data files
+_unsupported_imgopts 'refcount_bits=1[^0-9]' data_file
+
+_make_test_img 64M
+
+# Should be so long as to take up the whole field width
+sn_name=abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
+
+# More memory will give us a larger VM state, i.e. one above 1 MB.
+# This way, we get a number with a decimal point.
+qemu_comm_method=monitor _launch_qemu -m 512 "$TEST_IMG"
+
+_send_qemu_cmd $QEMU_HANDLE "savevm $sn_name" '(qemu)'
+_send_qemu_cmd $QEMU_HANDLE 'quit' '(qemu)'
+wait=yes _cleanup_qemu
+
+# Check that all fields are separated by spaces.
+# We first collapse all space sequences into one space each;
+# then we turn every space-separated field into a '.';
+# and finally, we name the '.'s so the output is not just a confusing
+# sequence of dots.
+
+echo 'Output structure:'
+$QEMU_IMG snapshot -l "$TEST_IMG" | tail -n 1 | tr -s ' ' \
+    | sed -e 's/\S\+/./g' \
+    | sed -e 's/\./(snapshot ID)/' \
+          -e 's/\./(snapshot name)/' \
+          -e 's/\./(VM state size value)/' \
+          -e 's/\./(VM state size unit)/' \
+          -e 's/\./(snapshot date)/' \
+          -e 's/\./(snapshot time)/' \
+          -e 's/\./(VM clock)/'
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/286.out b/tests/qemu-iotests/286.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/286.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 286
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
+QEMU X.Y.Z monitor - type 'help' for more information
+(qemu) savevm abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz
+(qemu) quit
+Output structure:
+(snapshot ID) (snapshot name) (VM state size value) (VM state size unit) (snapshot date) (snapshot time) (VM clock)
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 281 rw quick
 283 auto quick
 284 rw
+286 rw quick
-- 
2.24.1

The following changes since commit 88afdc92b644120e0182c8567e1b1d236e471b12:

Merge remote-tracking branch 'remotes/mst/tags/for_upstream' into staging (2021-09-05 15:48:42 +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 9bd2788f49c331b02372cc257b11e4c984d39708:

block/nvme: Only report VFIO error on failed retry (2021-09-07 09:08:24 +0100)

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

Userspace NVMe driver patches.

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

Philippe Mathieu-Daudé (11):
  block/nvme: Use safer trace format string
  util/vfio-helpers: Let qemu_vfio_verify_mappings() use error_report()
  util/vfio-helpers: Replace qemu_mutex_lock() calls with
    QEMU_LOCK_GUARD
  util/vfio-helpers: Remove unreachable code in qemu_vfio_dma_map()
  block/nvme: Have nvme_create_queue_pair() report errors consistently
  util/vfio-helpers: Pass Error handle to qemu_vfio_dma_map()
  util/vfio-helpers: Extract qemu_vfio_water_mark_reached()
  util/vfio-helpers: Use error_setg in qemu_vfio_find_[fixed/temp]_iova
  util/vfio-helpers: Simplify qemu_vfio_dma_map() returning directly
  util/vfio-helpers: Let qemu_vfio_do_mapping() propagate Error
  block/nvme: Only report VFIO error on failed retry

include/qemu/vfio-helpers.h |  2 +-
 block/nvme.c                | 29 +++++++----
 util/vfio-helpers.c         | 99 ++++++++++++++++++++-----------------
 block/trace-events          |  2 +-
 4 files changed, 76 insertions(+), 56 deletions(-)

-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Fix when building with -Wshorten-64-to-32:

warning: implicit conversion loses integer precision: 'unsigned long' to 'int' [-Wshorten-64-to-32]

Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-2-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/trace-events | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/block/trace-events b/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/block/trace-events
+++ b/block/trace-events
@@ -XXX,XX +XXX,XX @@ nvme_dsm(void *s, uint64_t offset, uint64_t bytes) "s %p offset 0x%"PRIx64" byte
 nvme_dsm_done(void *s, uint64_t offset, uint64_t bytes, int ret) "s %p offset 0x%"PRIx64" bytes %"PRId64" ret %d"
 nvme_dma_map_flush(void *s) "s %p"
 nvme_free_req_queue_wait(void *s, unsigned q_index) "s %p q #%u"
-nvme_create_queue_pair(unsigned q_index, void *q, unsigned size, void *aio_context, int fd) "index %u q %p size %u aioctx %p fd %d"
+nvme_create_queue_pair(unsigned q_index, void *q, size_t size, void *aio_context, int fd) "index %u q %p size %zu aioctx %p fd %d"
 nvme_free_queue_pair(unsigned q_index, void *q) "index %u q %p"
 nvme_cmd_map_qiov(void *s, void *cmd, void *req, void *qiov, int entries) "s %p cmd %p req %p qiov %p entries %d"
 nvme_cmd_map_qiov_pages(void *s, int i, uint64_t page) "s %p page[%d] 0x%"PRIx64
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Instead of displaying the error on stderr, use error_report()
which also report to the monitor.

Reviewed-by: Fam Zheng <fam@euphon.net>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-3-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_verify_mappings(QEMUVFIOState *s)
     if (QEMU_VFIO_DEBUG) {
         for (i = 0; i < s->nr_mappings - 1; ++i) {
             if (!(s->mappings[i].host < s->mappings[i + 1].host)) {
-                fprintf(stderr, "item %d not sorted!\n", i);
+                error_report("item %d not sorted!", i);
                 qemu_vfio_dump_mappings(s);
                 return false;
             }
             if (!(s->mappings[i].host + s->mappings[i].size <=
                   s->mappings[i + 1].host)) {
-                fprintf(stderr, "item %d overlap with next!\n", i);
+                error_report("item %d overlap with next!", i);
                 qemu_vfio_dump_mappings(s);
                 return false;
             }
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Simplify qemu_vfio_dma_[un]map() handlers by replacing a pair of
qemu_mutex_lock/qemu_mutex_unlock calls by the WITH_QEMU_LOCK_GUARD
macro.

Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-4-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
     assert(QEMU_PTR_IS_ALIGNED(host, qemu_real_host_page_size));
     assert(QEMU_IS_ALIGNED(size, qemu_real_host_page_size));
     trace_qemu_vfio_dma_map(s, host, size, temporary, iova);
-    qemu_mutex_lock(&s->lock);
+    QEMU_LOCK_GUARD(&s->lock);
     mapping = qemu_vfio_find_mapping(s, host, &index);
     if (mapping) {
         iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
         *iova = iova0;
     }
 out:
-    qemu_mutex_unlock(&s->lock);
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ void qemu_vfio_dma_unmap(QEMUVFIOState *s, void *host)
     }
 
     trace_qemu_vfio_dma_unmap(s, host);
-    qemu_mutex_lock(&s->lock);
+    QEMU_LOCK_GUARD(&s->lock);
     m = qemu_vfio_find_mapping(s, host, &index);
     if (!m) {
-        goto out;
+        return;
     }
     qemu_vfio_undo_mapping(s, m, NULL);
-out:
-    qemu_mutex_unlock(&s->lock);
 }
 
 static void qemu_vfio_reset(QEMUVFIOState *s)
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

qemu_vfio_add_mapping() returns a pointer to an indexed entry
in pre-allocated QEMUVFIOState::mappings[], thus can not be NULL.
Remove the pointless check.

Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-5-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
             }
 
             mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
-            if (!mapping) {
-                ret = -ENOMEM;
-                goto out;
-            }
             assert(qemu_vfio_verify_mappings(s));
             ret = qemu_vfio_do_mapping(s, host, size, iova0);
             if (ret) {
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

nvme_create_queue_pair() does not return a boolean value (indicating
eventual error) but a pointer, and is inconsistent in how it fills the
error handler. To fulfill callers expectations, always set an error
message on failure.

Reported-by: Auger Eric <eric.auger@redhat.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-6-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/nvme.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/block/nvme.c b/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nvme.c
+++ b/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
 
     q = g_try_new0(NVMeQueuePair, 1);
     if (!q) {
+        error_setg(errp, "Cannot allocate queue pair");
         return NULL;
     }
     trace_nvme_create_queue_pair(idx, q, size, aio_context,
@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
                           qemu_real_host_page_size);
     q->prp_list_pages = qemu_try_memalign(qemu_real_host_page_size, bytes);
     if (!q->prp_list_pages) {
+        error_setg(errp, "Cannot allocate PRP page list");
         goto fail;
     }
     memset(q->prp_list_pages, 0, bytes);
@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
     r = qemu_vfio_dma_map(s->vfio, q->prp_list_pages, bytes,
                           false, &prp_list_iova);
     if (r) {
+        error_setg_errno(errp, -r, "Cannot map buffer for DMA");
         goto fail;
     }
     q->free_req_head = -1;
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Currently qemu_vfio_dma_map() displays errors on stderr.
When using management interface, this information is simply
lost. Pass qemu_vfio_dma_map() an Error** handle so it can
propagate the error to callers.

Reviewed-by: Fam Zheng <fam@euphon.net>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-7-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/qemu/vfio-helpers.h |  2 +-
 block/nvme.c                | 22 +++++++++++-----------
 util/vfio-helpers.c         | 10 ++++++----
 3 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/include/qemu/vfio-helpers.h b/include/qemu/vfio-helpers.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/vfio-helpers.h
+++ b/include/qemu/vfio-helpers.h
@@ -XXX,XX +XXX,XX @@ typedef struct QEMUVFIOState QEMUVFIOState;
 QEMUVFIOState *qemu_vfio_open_pci(const char *device, Error **errp);
 void qemu_vfio_close(QEMUVFIOState *s);
 int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
-                      bool temporary, uint64_t *iova_list);
+                      bool temporary, uint64_t *iova_list, Error **errp);
 int qemu_vfio_dma_reset_temporary(QEMUVFIOState *s);
 void qemu_vfio_dma_unmap(QEMUVFIOState *s, void *host);
 void *qemu_vfio_pci_map_bar(QEMUVFIOState *s, int index,
diff --git a/block/nvme.c b/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nvme.c
+++ b/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static bool nvme_init_queue(BDRVNVMeState *s, NVMeQueue *q,
         return false;
     }
     memset(q->queue, 0, bytes);
-    r = qemu_vfio_dma_map(s->vfio, q->queue, bytes, false, &q->iova);
+    r = qemu_vfio_dma_map(s->vfio, q->queue, bytes, false, &q->iova, errp);
     if (r) {
-        error_setg(errp, "Cannot map queue");
-        return false;
+        error_prepend(errp, "Cannot map queue: ");
     }
-    return true;
+    return r == 0;
 }
 
 static void nvme_free_queue_pair(NVMeQueuePair *q)
@@ -XXX,XX +XXX,XX @@ static NVMeQueuePair *nvme_create_queue_pair(BDRVNVMeState *s,
     qemu_co_queue_init(&q->free_req_queue);
     q->completion_bh = aio_bh_new(aio_context, nvme_process_completion_bh, q);
     r = qemu_vfio_dma_map(s->vfio, q->prp_list_pages, bytes,
-                          false, &prp_list_iova);
+                          false, &prp_list_iova, errp);
     if (r) {
-        error_setg_errno(errp, -r, "Cannot map buffer for DMA");
+        error_prepend(errp, "Cannot map buffer for DMA: ");
         goto fail;
     }
     q->free_req_head = -1;
@@ -XXX,XX +XXX,XX @@ static bool nvme_identify(BlockDriverState *bs, int namespace, Error **errp)
         error_setg(errp, "Cannot allocate buffer for identify response");
         goto out;
     }
-    r = qemu_vfio_dma_map(s->vfio, id, id_size, true, &iova);
+    r = qemu_vfio_dma_map(s->vfio, id, id_size, true, &iova, errp);
     if (r) {
-        error_setg(errp, "Cannot map buffer for DMA");
+        error_prepend(errp, "Cannot map buffer for DMA: ");
         goto out;
     }
 
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
 try_map:
         r = qemu_vfio_dma_map(s->vfio,
                               qiov->iov[i].iov_base,
-                              len, true, &iova);
+                              len, true, &iova, NULL);
         if (r == -ENOSPC) {
             /*
              * In addition to the -ENOMEM error, the VFIO_IOMMU_MAP_DMA
@@ -XXX,XX +XXX,XX @@ static void nvme_aio_unplug(BlockDriverState *bs)
 static void nvme_register_buf(BlockDriverState *bs, void *host, size_t size)
 {
     int ret;
+    Error *local_err = NULL;
     BDRVNVMeState *s = bs->opaque;
 
-    ret = qemu_vfio_dma_map(s->vfio, host, size, false, NULL);
+    ret = qemu_vfio_dma_map(s->vfio, host, size, false, NULL, &local_err);
     if (ret) {
         /* FIXME: we may run out of IOVA addresses after repeated
          * bdrv_register_buf/bdrv_unregister_buf, because nvme_vfio_dma_unmap
          * doesn't reclaim addresses for fixed mappings. */
-        error_report("nvme_register_buf failed: %s", strerror(-ret));
+        error_reportf_err(local_err, "nvme_register_buf failed: ");
     }
 }
 
diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ static void qemu_vfio_ram_block_added(RAMBlockNotifier *n, void *host,
                                       size_t size, size_t max_size)
 {
     QEMUVFIOState *s = container_of(n, QEMUVFIOState, ram_notifier);
+    Error *local_err = NULL;
     int ret;
 
     trace_qemu_vfio_ram_block_added(s, host, max_size);
-    ret = qemu_vfio_dma_map(s, host, max_size, false, NULL);
+    ret = qemu_vfio_dma_map(s, host, max_size, false, NULL, &local_err);
     if (ret) {
-        error_report("qemu_vfio_dma_map(%p, %zu) failed: %s", host, max_size,
-                     strerror(-ret));
+        error_reportf_err(local_err,
+                          "qemu_vfio_dma_map(%p, %zu) failed: ",
+                          host, max_size);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
  * mapping status within this area is not allowed).
  */
 int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
-                      bool temporary, uint64_t *iova)
+                      bool temporary, uint64_t *iova, Error **errp)
 {
     int ret = 0;
     int index;
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Extract qemu_vfio_water_mark_reached() for readability,
and have it provide an error hint it its Error* handle.

Suggested-by: Klaus Jensen <k.jensen@samsung.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-8-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
     return -ENOMEM;
 }
 
+/**
+ * qemu_vfio_water_mark_reached:
+ *
+ * Returns %true if high watermark has been reached, %false otherwise.
+ */
+static bool qemu_vfio_water_mark_reached(QEMUVFIOState *s, size_t size,
+                                         Error **errp)
+{
+    if (s->high_water_mark - s->low_water_mark + 1 < size) {
+        error_setg(errp, "iova exhausted (water mark reached)");
+        return true;
+    }
+    return false;
+}
+
 /* Map [host, host + size) area into a contiguous IOVA address space, and store
  * the result in @iova if not NULL. The caller need to make sure the area is
  * aligned to page size, and mustn't overlap with existing mapping areas (split
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
     if (mapping) {
         iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
     } else {
-        if (s->high_water_mark - s->low_water_mark + 1 < size) {
+        if (qemu_vfio_water_mark_reached(s, size, errp)) {
             ret = -ENOMEM;
             goto out;
         }
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Both qemu_vfio_find_fixed_iova() and qemu_vfio_find_temp_iova()
return an errno which is unused (or overwritten). Have them propagate
eventual errors to callers, returning a boolean (which is what the
Error API recommends, see commit e3fe3988d78 "error: Document Error
API usage rules" for rationale).

Suggested-by: Klaus Jensen <k.jensen@samsung.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-9-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 24 ++++++++++++++----------
 1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_verify_mappings(QEMUVFIOState *s)
     return true;
 }
 
-static int
-qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
+static bool qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size,
+                                      uint64_t *iova, Error **errp)
 {
     int i;
 
@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_fixed_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
             s->usable_iova_ranges[i].end - s->low_water_mark + 1 == 0) {
             *iova = s->low_water_mark;
             s->low_water_mark += size;
-            return 0;
+            return true;
         }
     }
-    return -ENOMEM;
+    error_setg(errp, "fixed iova range not found");
+
+    return false;
 }
 
-static int
-qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
+static bool qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size,
+                                     uint64_t *iova, Error **errp)
 {
     int i;
 
@@ -XXX,XX +XXX,XX @@ qemu_vfio_find_temp_iova(QEMUVFIOState *s, size_t size, uint64_t *iova)
             s->high_water_mark - s->usable_iova_ranges[i].start + 1 == 0) {
             *iova = s->high_water_mark - size;
             s->high_water_mark = *iova;
-            return 0;
+            return true;
         }
     }
-    return -ENOMEM;
+    error_setg(errp, "temporary iova range not found");
+
+    return false;
 }
 
 /**
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
             goto out;
         }
         if (!temporary) {
-            if (qemu_vfio_find_fixed_iova(s, size, &iova0)) {
+            if (!qemu_vfio_find_fixed_iova(s, size, &iova0, errp)) {
                 ret = -ENOMEM;
                 goto out;
             }
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
             }
             qemu_vfio_dump_mappings(s);
         } else {
-            if (qemu_vfio_find_temp_iova(s, size, &iova0)) {
+            if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
                 ret = -ENOMEM;
                 goto out;
             }
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

To simplify qemu_vfio_dma_map():
- reduce 'ret' (returned value) scope by returning errno directly,
- remove the goto 'out' label.

Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-10-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ static bool qemu_vfio_water_mark_reached(QEMUVFIOState *s, size_t size,
 int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
                       bool temporary, uint64_t *iova, Error **errp)
 {
-    int ret = 0;
     int index;
     IOVAMapping *mapping;
     uint64_t iova0;
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
     if (mapping) {
         iova0 = mapping->iova + ((uint8_t *)host - (uint8_t *)mapping->host);
     } else {
+        int ret;
+
         if (qemu_vfio_water_mark_reached(s, size, errp)) {
-            ret = -ENOMEM;
-            goto out;
+            return -ENOMEM;
         }
         if (!temporary) {
             if (!qemu_vfio_find_fixed_iova(s, size, &iova0, errp)) {
-                ret = -ENOMEM;
-                goto out;
+                return -ENOMEM;
             }
 
             mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
             assert(qemu_vfio_verify_mappings(s));
             ret = qemu_vfio_do_mapping(s, host, size, iova0);
-            if (ret) {
+            if (ret < 0) {
                 qemu_vfio_undo_mapping(s, mapping, NULL);
-                goto out;
+                return ret;
             }
             qemu_vfio_dump_mappings(s);
         } else {
             if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
-                ret = -ENOMEM;
-                goto out;
+                return -ENOMEM;
             }
             ret = qemu_vfio_do_mapping(s, host, size, iova0);
-            if (ret) {
-                goto out;
+            if (ret < 0) {
+                return ret;
             }
         }
     }
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
     if (iova) {
         *iova = iova0;
     }
-out:
-    return ret;
+    return 0;
 }
 
 /* Reset the high watermark and free all "temporary" mappings. */
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

Pass qemu_vfio_do_mapping() an Error* argument so it can propagate
any error to callers. Replace error_report() which only report
to the monitor by the more generic error_setg_errno().

Reviewed-by: Fam Zheng <fam@euphon.net>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-11-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 util/vfio-helpers.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/util/vfio-helpers.c b/util/vfio-helpers.c
index XXXXXXX..XXXXXXX 100644
--- a/util/vfio-helpers.c
+++ b/util/vfio-helpers.c
@@ -XXX,XX +XXX,XX @@ static IOVAMapping *qemu_vfio_add_mapping(QEMUVFIOState *s,
 
 /* Do the DMA mapping with VFIO. */
 static int qemu_vfio_do_mapping(QEMUVFIOState *s, void *host, size_t size,
-                                uint64_t iova)
+                                uint64_t iova, Error **errp)
 {
     struct vfio_iommu_type1_dma_map dma_map = {
         .argsz = sizeof(dma_map),
@@ -XXX,XX +XXX,XX @@ static int qemu_vfio_do_mapping(QEMUVFIOState *s, void *host, size_t size,
     trace_qemu_vfio_do_mapping(s, host, iova, size);
 
     if (ioctl(s->container, VFIO_IOMMU_MAP_DMA, &dma_map)) {
-        error_report("VFIO_MAP_DMA failed: %s", strerror(errno));
+        error_setg_errno(errp, errno, "VFIO_MAP_DMA failed");
         return -errno;
     }
     return 0;
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
 
             mapping = qemu_vfio_add_mapping(s, host, size, index + 1, iova0);
             assert(qemu_vfio_verify_mappings(s));
-            ret = qemu_vfio_do_mapping(s, host, size, iova0);
+            ret = qemu_vfio_do_mapping(s, host, size, iova0, errp);
             if (ret < 0) {
                 qemu_vfio_undo_mapping(s, mapping, NULL);
                 return ret;
@@ -XXX,XX +XXX,XX @@ int qemu_vfio_dma_map(QEMUVFIOState *s, void *host, size_t size,
             if (!qemu_vfio_find_temp_iova(s, size, &iova0, errp)) {
                 return -ENOMEM;
             }
-            ret = qemu_vfio_do_mapping(s, host, size, iova0);
+            ret = qemu_vfio_do_mapping(s, host, size, iova0, errp);
             if (ret < 0) {
                 return ret;
             }
-- 
2.31.1

From: Philippe Mathieu-Daudé <philmd@redhat.com>

We expect the first qemu_vfio_dma_map() to fail (indicating
DMA mappings exhaustion, see commit 15a730e7a3a). Do not
report the first failure as error, since we are going to
flush the mappings and retry.

This removes spurious error message displayed on the monitor:

(qemu) c
  (qemu) qemu-kvm: VFIO_MAP_DMA failed: No space left on device
  (qemu) info status
  VM status: running

Reported-by: Tingting Mao <timao@redhat.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20210902070025.197072-12-philmd@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/nvme.c | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/block/nvme.c b/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nvme.c
+++ b/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
     uint64_t *pagelist = req->prp_list_page;
     int i, j, r;
     int entries = 0;
+    Error *local_err = NULL, **errp = NULL;
 
     assert(qiov->size);
     assert(QEMU_IS_ALIGNED(qiov->size, s->page_size));
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nvme_cmd_map_qiov(BlockDriverState *bs, NvmeCmd *cmd,
 try_map:
         r = qemu_vfio_dma_map(s->vfio,
                               qiov->iov[i].iov_base,
-                              len, true, &iova, NULL);
+                              len, true, &iova, errp);
         if (r == -ENOSPC) {
             /*
              * In addition to the -ENOMEM error, the VFIO_IOMMU_MAP_DMA
@@ -XXX,XX +XXX,XX @@ try_map:
                     goto fail;
                 }
             }
+            errp = &local_err;
+
             goto try_map;
         }
         if (r) {
@@ -XXX,XX +XXX,XX @@ fail:
      * because they are already mapped before calling this function; for
      * temporary mappings, a later nvme_cmd_(un)map_qiov will reclaim by
      * calling qemu_vfio_dma_reset_temporary when necessary. */
+    if (local_err) {
+        error_reportf_err(local_err, "Cannot map buffer for DMA: ");
+    }
     return r;
 }
 
-- 
2.31.1