Series comparison

-[PULL 00/30] Block layer patches
+[PULL 00/15] Block layer patches
-The following changes since commit aceeaa69d28e6f08a24395d0aa6915b687d0a681:
+The following changes since commit 16aaacb307ed607b9780c12702c44f0fe52edc7e:
-  Merge remote-tracking branch 'remotes/huth-gitlab/tags/pull-request-2019-12-17' into staging (2019-12-17 15:55:20 +0000)
+  Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20200430' into staging (2020-04-30 14:00:36 +0100)
 are available in the Git repository at:
   git://repo.or.cz/qemu/kevin.git tags/for-upstream
-for you to fetch changes up to f62f08ab7a9d902da70078992248ec5c98f652ad:
+for you to fetch changes up to eaae29ef89d498d0eac553c77b554f310a47f809:
-  iotests: Test external snapshot with VM state (2019-12-19 18:04:25 +0100)
+  qemu-storage-daemon: Fix non-string --object properties (2020-04-30 17:51:07 +0200)
 ----------------------------------------------------------------
 Block layer patches:
-- qemu-img: fix info --backing-chain --image-opts
+- Fix resize (extending) of short overlays
-- Error out on image creation with conflicting size options
+- nvme: introduce PMR support from NVMe 1.4 spec
-- Fix external snapshot with VM state
+- qemu-storage-daemon: Fix non-string --object properties
 - hmp: Allow using qdev ID for qemu-io command
 - Misc code cleanup
 - Many iotests improvements
 ----------------------------------------------------------------
 Alberto Garcia (1):
-      qcow2: Use offset_into_cluster()
+      qcow2: Add incompatibility note between backing files and raw external data files
-Daniel P. Berrangé (1):
+Andrzej Jakowski (1):
-      qapi: better document NVMe blockdev @device parameter
+      nvme: introduce PMR support from NVMe 1.4 spec
-Kevin Wolf (19):
+Kevin Wolf (12):
-      block: Error out on image creation with conflicting size options
+      block: Add flags to BlockDriver.bdrv_co_truncate()
-      blockjob: Fix error message for negative speed
+      block: Add flags to bdrv(_co)_truncate()
-      qcow2: Declare BDRV_REQ_NO_FALLBACK supported
+      block-backend: Add flags to blk_truncate()
-      iotests: Add qemu_io_log()
+      qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
-      iotests: Fix timeout in run_job()
+      raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
-      iotests: Support job-complete in run_job()
+      file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
-      iotests: Create VM.blockdev_create()
+      block: truncate: Don't make backing file data visible
-      iotests: 255: Drop blockdev_create()
+      iotests: Filter testfiles out in filter_img_info()
-      iotests: 206: Convert to VM.blockdev_create()
+      iotests: Test committing to short backing file
-      iotests: 210: Convert to VM.blockdev_create()
+      qcow2: Forward ZERO_WRITE flag for full preallocation
-      iotests: 212: Convert to VM.blockdev_create()
+      qom: Factor out user_creatable_add_dict()
-      iotests: 213: Convert to VM.blockdev_create()
+      qemu-storage-daemon: Fix non-string --object properties
       iotests: 237: Convert to VM.blockdev_create()
       iotests: 266: Convert to VM.blockdev_create()
       iotests: 207: Remove duplication with VM.blockdev_create()
       iotests: 211: Remove duplication with VM.blockdev_create()
       block: Activate recursively even for already active nodes
       hmp: Allow using qdev ID for qemu-io command
       iotests: Test external snapshot with VM state
-Max Reitz (2):
+Paolo Bonzini (1):
-      iotests/273: Filter format-specific information
+      qemu-iotests: allow qcow2 external discarded clusters to contain stale data
       iotests: Fix IMGOPTSSYNTAX for nbd
-Stefan Hajnoczi (1):
+ docs/interop/qcow2.txt          |   3 +
-      qemu-img: fix info --backing-chain --image-opts
+ hw/block/nvme.h                 |   2 +
+ include/block/block.h           |   5 +-
-Thomas Huth (4):
+ include/block/block_int.h       |  10 +-
-      iotests: Provide a function for checking the creation of huge files
+ include/block/nvme.h            | 172 ++++++++++++++++++++++++++
-      iotests: Skip test 060 if it is not possible to create large files
+ include/qom/object_interfaces.h |  16 +++
-      iotests: Skip test 079 if it is not possible to create large files
+ include/sysemu/block-backend.h  |   2 +-
-      iotests: Add more "_require_drivers" checks to the shell-based tests
+ block.c                         |   3 +-
+ block/block-backend.c           |   4 +-
-Tuguoyi (1):
+ block/commit.c                  |   4 +-
-      qcow2: Move error check of local_err near its assignment
+ block/crypto.c                  |   7 +-
+ block/file-posix.c              |   6 +-
-Vladimir Sementsov-Ogievskiy (1):
+ block/file-win32.c              |   2 +-
-      MAINTAINERS: fix qcow2-bitmap.c under Dirty Bitmaps header
+ block/gluster.c                 |   1 +
+ block/io.c                      |  43 ++++++-
- qapi/block-core.json          |   6 +-
+ block/iscsi.c                   |   2 +-
- block.c                       |  60 ++++++-----
+ block/mirror.c                  |   2 +-
- block/qcow2.c                 |  21 ++--
+ block/nfs.c                     |   3 +-
- blockjob.c                    |   3 +-
+ block/parallels.c               |   6 +-
- monitor/hmp-cmds.c            |  28 +++--
+ block/qcow.c                    |   4 +-
- qemu-img.c                    |   3 +
+ block/qcow2-cluster.c           |   2 +-
- MAINTAINERS                   |   6 +-
+ block/qcow2-refcount.c          |   2 +-
- hmp-commands.hx               |   8 +-
+ block/qcow2.c                   |  73 +++++++++--
- tests/qemu-iotests/005        |   5 +-
+ block/qed.c                     |   3 +-
- tests/qemu-iotests/030        |   4 +-
+ block/raw-format.c              |   6 +-
- tests/qemu-iotests/049        |   5 +
+ block/rbd.c                     |   1 +
- tests/qemu-iotests/049.out    |   5 +
+ block/sheepdog.c                |   4 +-
- tests/qemu-iotests/051        |   1 +
+ block/ssh.c                     |   2 +-
- tests/qemu-iotests/060        |   3 +
+ block/vdi.c                     |   2 +-
- tests/qemu-iotests/079        |   3 +
+ block/vhdx-log.c                |   2 +-
- tests/qemu-iotests/206        | 232 ++++++++++++++++++++----------------------
+ block/vhdx.c                    |   6 +-
- tests/qemu-iotests/207        |   8 +-
+ block/vmdk.c                    |   8 +-
- tests/qemu-iotests/210        |  81 +++++++--------
+ block/vpc.c                     |   2 +-
- tests/qemu-iotests/211        |  12 +--
+ blockdev.c                      |   2 +-
- tests/qemu-iotests/212        | 101 +++++++++---------
+ hw/block/nvme.c                 | 109 ++++++++++++++++
- tests/qemu-iotests/213        | 113 ++++++++++----------
+ qemu-img.c                      |   2 +-
- tests/qemu-iotests/220        |   6 +-
+ qemu-io-cmds.c                  |   2 +-
- tests/qemu-iotests/237        | 139 ++++++++++++-------------
+ qemu-storage-daemon.c           |   4 +-
- tests/qemu-iotests/255        |  10 --
+ qom/object_interfaces.c         |  31 +++++
- tests/qemu-iotests/266        |  69 ++++++-------
+ qom/qom-qmp-cmds.c              |  24 +---
- tests/qemu-iotests/266.out    |  14 +++
+ tests/test-block-iothread.c     |   9 +-
- tests/qemu-iotests/267        |   1 +
+ tests/qemu-iotests/iotests.py   |   5 +-
- tests/qemu-iotests/273        |   3 +-
+ hw/block/Makefile.objs          |   2 +-
- tests/qemu-iotests/273.out    |  27 -----
+ hw/block/trace-events           |   4 +
- tests/qemu-iotests/279        |  57 +++++++++++
+ tests/qemu-iotests/244          |  10 +-
- tests/qemu-iotests/279.out    |  35 +++++++
+ tests/qemu-iotests/244.out      |   9 +-
- tests/qemu-iotests/280        |  83 +++++++++++++++
+ tests/qemu-iotests/274          | 155 +++++++++++++++++++++++
- tests/qemu-iotests/280.out    |  50 +++++++++
+ tests/qemu-iotests/274.out      | 268 ++++++++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/common.rc  |  13 ++-
+ tests/qemu-iotests/group        |   1 +
- tests/qemu-iotests/group      |   2 +
+files changed, 951 insertions(+), 96 deletions(-)
- tests/qemu-iotests/iotests.py |  25 ++++-
+ create mode 100755 tests/qemu-iotests/274
-files changed, 724 insertions(+), 518 deletions(-)
+ create mode 100644 tests/qemu-iotests/274.out
  create mode 100755 tests/qemu-iotests/279
  create mode 100644 tests/qemu-iotests/279.out
  create mode 100755 tests/qemu-iotests/280
  create mode 100644 tests/qemu-iotests/280.out

-[PULL 04/30] qapi: better document NVMe blockdev @device parameter
+[PULL 01/15] qcow2: Add incompatibility note between backing files and raw external data files
-From: Daniel P. Berrangé <berrange@redhat.com>
+From: Alberto Garcia <berto@igalia.com>
-Mention that this is a PCI device address & give the format it is
+Backing files and raw external data files are mutually exclusive.
-expected in. Also mention that it must be first unbound from any
+The documentation of the raw external data bit (in autoclear_features)
-host kernel driver.
+already indicates that, but we should also mention it on the other
 side.
-Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
+Suggested-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Alberto Garcia <berto@igalia.com>
 Message-Id: <20200410121816.8334-1-berto@igalia.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json | 6 +++++-
+ docs/interop/qcow2.txt | 3 +++
-file changed, 5 insertions(+), 1 deletion(-)
+file changed, 3 insertions(+)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/docs/interop/qcow2.txt
-+++ b/qapi/block-core.json
++++ b/docs/interop/qcow2.txt
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header:
- #
+                     is stored (NB: The string is not null terminated). 0 if the
- # Driver specific block device options for the NVMe backend.
+                     image doesn't have a backing file.
- #
--# @device:    controller address of the NVMe device.
++                    Note: backing files are incompatible with raw external data
-+# @device:    PCI controller address of the NVMe device in
++                    files (auto-clear feature bit 1).
-+#             format hhhh:bb:ss.f (host:bus:slot.function)
++
- # @namespace: namespace number of the device, starting from 1.
+- 19:   backing_file_size
- #
+                     Length of the backing file name in bytes. Must not be
-+# Note that the PCI @device must have been unbound from any host
+                     longer than 1023 bytes. Undefined if the image doesn't have
 +# kernel driver before instructing QEMU to add the blockdev.
 +#
  # Since: 2.12
  ##
  { 'struct': 'BlockdevOptionsNVMe',
 --
-.20.1
+.25.3

-[PULL 27/30] iotests: 211: Remove duplication with VM.blockdev_create()
+[PULL 02/15] qemu-iotests: allow qcow2 external discarded clusters to contain stale data
-The blockdev_create() function in this test case adds an error check
+From: Paolo Bonzini <pbonzini@redhat.com>
 that skips the test in case of failure because of memory shortage, but
 provides otherwise the same functionality as VM.blockdev_create() from
 iotests.py. Make it a thin wrapper around the iotests.py function.
+Test 244 checks the expected behavior of qcow2 external data files
+with respect to zero and discarded clusters.  Filesystems however
+are free to ignore discard requests, and this seems to be the
+case for overlayfs.  Relax the tests to skip checks on the
+external data file for discarded areas, which implies not using
+qemu-img compare in the data_file_raw=on case.
+This fixes docker tests on RHEL8.
+Cc: Kevin Wolf <kwolf@redhat.com>
+Cc: qemu-block@nongnu.org
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Message-Id: <20200409191006.24429-1-pbonzini@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/211 | 12 +++---------
+ tests/qemu-iotests/244     | 10 ++++++++--
-file changed, 3 insertions(+), 9 deletions(-)
+ tests/qemu-iotests/244.out |  9 ++++++---
 files changed, 14 insertions(+), 5 deletions(-)
-diff --git a/tests/qemu-iotests/211 b/tests/qemu-iotests/211
+diff --git a/tests/qemu-iotests/244 b/tests/qemu-iotests/244
 index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/211
+--- a/tests/qemu-iotests/244
-+++ b/tests/qemu-iotests/211
++++ b/tests/qemu-iotests/244
-@@ -XXX,XX +XXX,XX @@ iotests.verify_image_format(supported_fmts=['vdi'])
+@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
- iotests.verify_protocol(supported=['file'])
+ echo
+ $QEMU_IO -c 'read -P 0 0 1M' \
- def blockdev_create(vm, options):
+          -c 'read -P 0x11 1M 1M' \
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
+-         -c 'read -P 0 2M 2M' \
--                        filters=[iotests.filter_qmp_testfiles])
+          -c 'read -P 0x11 4M 1M' \
--
+          -c 'read -P 0 5M 1M' \
--    if 'return' in result:
+          -f raw "$TEST_IMG.data" |
--        assert result['return'] == {}
+@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
--        error = vm.run_job('job0')
+          -f $IMGFMT "$TEST_IMG" |
--        if error and 'Could not allocate bmap' in error:
+          _filter_qemu_io
--            iotests.notrun('Insufficient memory')
--    iotests.log("")
++# Discarded clusters are only marked as such in the qcow2 metadata, but
-+    error = vm.blockdev_create(options)
++# they can contain stale data in the external data file.  Instead, zero
-+    if error and 'Could not allocate bmap' in error:
++# clusters must be zeroed in the external data file too.
-+        iotests.notrun('Insufficient memory')
+ echo
+-$QEMU_IMG compare "$TEST_IMG" "$TEST_IMG.data"
- with iotests.FilePath('t.vdi') as disk_path, \
++$QEMU_IO -c 'read -P 0 0 1M' \
-      iotests.VM() as vm:
++         -c 'read -P 0x11 1M 1M' \
 +         -c 'read -P 0 3M 3M' \
 +         -f raw "$TEST_IMG".data |
 +         _filter_qemu_io
  echo -n "qcow2 file size after I/O: "
  du -b $TEST_IMG | cut -f1
 diff --git a/tests/qemu-iotests/244.out b/tests/qemu-iotests/244.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/244.out
 +++ b/tests/qemu-iotests/244.out
@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0
 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  read 1048576/1048576 bytes at offset 1048576
 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 -read 2097152/2097152 bytes at offset 2097152
 -2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  read 1048576/1048576 bytes at offset 4194304
 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  read 1048576/1048576 bytes at offset 5242880
@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 1048576
  read 4194304/4194304 bytes at offset 2097152
 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 -Images are identical.
 +read 1048576/1048576 bytes at offset 0
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 1048576/1048576 bytes at offset 1048576
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 3145728/3145728 bytes at offset 3145728
 +3 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  qcow2 file size after I/O: 327680
  === bdrv_co_block_status test for file and offset=0 ===
 --
-.20.1
+.25.3

-[PULL 12/30] qcow2: Use offset_into_cluster()
+[PULL 03/15] block: Add flags to BlockDriver.bdrv_co_truncate()
-From: Alberto Garcia <berto@igalia.com>
+This adds a new BdrvRequestFlags parameter to the .bdrv_co_truncate()
+driver callbacks, and a supported_truncate_flags field in
-There's a couple of places left in the qcow2 code that still do the
+BlockDriverState that allows drivers to advertise support for request
-calculation manually, so let's replace them.
+flags in the context of truncate.
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+For now, we always pass 0 and no drivers declare support for any flag.
-Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200424125448.63318-2-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2.c | 8 +++-----
+ include/block/block_int.h   | 10 +++++++++-
-file changed, 3 insertions(+), 5 deletions(-)
+ block/crypto.c              |  3 ++-
+ block/file-posix.c          |  2 +-
  block/file-win32.c          |  2 +-
  block/gluster.c             |  1 +
  block/io.c                  |  8 +++++++-
  block/iscsi.c               |  2 +-
  block/nfs.c                 |  3 ++-
  block/qcow2.c               |  2 +-
  block/qed.c                 |  1 +
  block/raw-format.c          |  2 +-
  block/rbd.c                 |  1 +
  block/sheepdog.c            |  4 ++--
  block/ssh.c                 |  2 +-
  tests/test-block-iothread.c |  3 ++-
 files changed, 33 insertions(+), 13 deletions(-)
 diff --git a/include/block/block_int.h b/include/block/block_int.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block_int.h
 +++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
       */
      int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,
                                           bool exact, PreallocMode prealloc,
 -                                         Error **errp);
 +                                         BdrvRequestFlags flags, Error **errp);
      int64_t (*bdrv_getlength)(BlockDriverState *bs);
      bool has_variable_length;
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
      /* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA,
       * BDRV_REQ_MAY_UNMAP, BDRV_REQ_WRITE_UNCHANGED) */
      unsigned int supported_zero_flags;
 +    /*
 +     * Flags honoured during truncate (so far: BDRV_REQ_ZERO_WRITE).
 +     *
 +     * If BDRV_REQ_ZERO_WRITE is given, the truncate operation must make sure
 +     * that any added space reads as all zeros. If this can't be guaranteed,
 +     * the operation must fail.
 +     */
 +    unsigned int supported_truncate_flags;
      /* the following member gives a name to every node on the bs graph. */
      char node_name[32];
 diff --git a/block/crypto.c b/block/crypto.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/crypto.c
 +++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static int block_crypto_co_create_generic(BlockDriverState *bs,
  static int coroutine_fn
  block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
 -                         PreallocMode prealloc, Error **errp)
 +                         PreallocMode prealloc, BdrvRequestFlags flags,
 +                         Error **errp)
  {
      BlockCrypto *crypto = bs->opaque;
      uint64_t payload_offset =
 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 @@ raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
  static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                          bool exact, PreallocMode prealloc,
 -                                        Error **errp)
 +                                        BdrvRequestFlags flags, Error **errp)
  {
      BDRVRawState *s = bs->opaque;
      struct stat st;
 diff --git a/block/file-win32.c b/block/file-win32.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/file-win32.c
 +++ b/block/file-win32.c
@@ -XXX,XX +XXX,XX @@ static void raw_close(BlockDriverState *bs)
  static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                          bool exact, PreallocMode prealloc,
 -                                        Error **errp)
 +                                        BdrvRequestFlags flags, Error **errp)
  {
      BDRVRawState *s = bs->opaque;
      LONG low, high;
 diff --git a/block/gluster.c b/block/gluster.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/gluster.c
 +++ b/block/gluster.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qemu_gluster_co_truncate(BlockDriverState *bs,
                                                   int64_t offset,
                                                   bool exact,
                                                   PreallocMode prealloc,
 +                                                 BdrvRequestFlags flags,
                                                   Error **errp)
  {
      BDRVGlusterState *s = bs->opaque;
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
      BlockDriverState *bs = child->bs;
      BlockDriver *drv = bs->drv;
      BdrvTrackedRequest req;
 +    BdrvRequestFlags flags = 0;
      int64_t old_size, new_bytes;
      int ret;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
      }
      if (drv->bdrv_co_truncate) {
 -        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, errp);
 +        if (flags & ~bs->supported_truncate_flags) {
 +            error_setg(errp, "Block driver does not support requested flags");
 +            ret = -ENOTSUP;
 +            goto out;
 +        }
 +        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
      } else if (bs->file && drv->is_filter) {
          ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
      } else {
 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 void iscsi_reopen_commit(BDRVReopenState *reopen_state)
  static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,
                                            bool exact, PreallocMode prealloc,
 -                                          Error **errp)
 +                                          BdrvRequestFlags flags, Error **errp)
  {
      IscsiLun *iscsilun = bs->opaque;
      int64_t cur_length;
 diff --git a/block/nfs.c b/block/nfs.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/nfs.c
 +++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static int64_t nfs_get_allocated_file_size(BlockDriverState *bs)
  static int coroutine_fn
  nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
 -                     PreallocMode prealloc, Error **errp)
 +                     PreallocMode prealloc, BdrvRequestFlags flags,
 +                     Error **errp)
  {
      NFSClient *client = bs->opaque;
      int ret;
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+@@ -XXX,XX +XXX,XX @@ fail:
-                 return -EINVAL;
-             }
+ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
+                                           bool exact, PreallocMode prealloc,
--            if (bitmaps_ext.bitmap_directory_offset & (s->cluster_size - 1)) {
+-                                          Error **errp)
-+            if (offset_into_cluster(s, bitmaps_ext.bitmap_directory_offset)) {
++                                          BdrvRequestFlags flags, Error **errp)
                  error_setg(errp, "bitmaps_ext: "
                                   "invalid bitmap directory offset");
                  return -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
  {
      BDRVQcow2State *s = bs->opaque;
-     uint64_t cluster_offset;
+     uint64_t old_length;
--    int index_in_cluster, ret;
+diff --git a/block/qed.c b/block/qed.c
-     unsigned int bytes;
+index XXXXXXX..XXXXXXX 100644
--    int status = 0;
+--- a/block/qed.c
-+    int ret, status = 0;
++++ b/block/qed.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_truncate(BlockDriverState *bs,
-     qemu_co_mutex_lock(&s->lock);
+                                              int64_t offset,
+                                              bool exact,
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
+                                              PreallocMode prealloc,
++                                             BdrvRequestFlags flags,
-     if ((ret == QCOW2_CLUSTER_NORMAL || ret == QCOW2_CLUSTER_ZERO_ALLOC) &&
+                                              Error **errp)
-         !s->crypto) {
+ {
--        index_in_cluster = offset & (s->cluster_size - 1);
+     BDRVQEDState *s = bs->opaque;
--        *map = cluster_offset | index_in_cluster;
+diff --git a/block/raw-format.c b/block/raw-format.c
-+        *map = cluster_offset | offset_into_cluster(s, offset);
+index XXXXXXX..XXXXXXX 100644
-         *file = s->data_file->bs;
+--- a/block/raw-format.c
-         status |= BDRV_BLOCK_OFFSET_VALID;
++++ b/block/raw-format.c
-     }
+@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
  static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                          bool exact, PreallocMode prealloc,
 -                                        Error **errp)
 +                                        BdrvRequestFlags flags, Error **errp)
  {
      BDRVRawState *s = bs->opaque;
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs,
                                               int64_t offset,
                                               bool exact,
                                               PreallocMode prealloc,
 +                                             BdrvRequestFlags flags,
                                               Error **errp)
  {
      int r;
 diff --git a/block/sheepdog.c b/block/sheepdog.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/sheepdog.c
 +++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static int64_t sd_getlength(BlockDriverState *bs)
  static int coroutine_fn sd_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
 -                                       Error **errp)
 +                                       BdrvRequestFlags flags, Error **errp)
  {
      BDRVSheepdogState *s = bs->opaque;
      int ret, fd;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,
      assert(!flags);
      if (offset > s->inode.vdi_size) {
 -        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, NULL);
 +        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, 0, NULL);
          if (ret < 0) {
              return ret;
          }
 diff --git a/block/ssh.c b/block/ssh.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/ssh.c
 +++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static int64_t ssh_getlength(BlockDriverState *bs)
  static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,
                                          bool exact, PreallocMode prealloc,
 -                                        Error **errp)
 +                                        BdrvRequestFlags flags, Error **errp)
  {
      BDRVSSHState *s = bs->opaque;
 diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-block-iothread.c
 +++ b/tests/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs,
  static int coroutine_fn
  bdrv_test_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
 -                      PreallocMode prealloc, Error **errp)
 +                      PreallocMode prealloc, BdrvRequestFlags flags,
 +                      Error **errp)
  {
      return 0;
  }
 --
-.20.1
+.25.3

-[PULL 29/30] hmp: Allow using qdev ID for qemu-io command
+[PULL 04/15] block: Add flags to bdrv(_co)_truncate()
-In order to issue requests on an existing BlockBackend with the
+Now that block drivers can support flags for .bdrv_co_truncate, expose
-'qemu-io' HMP command, allow specifying the BlockBackend not only with a
+the parameter in the node level interfaces bdrv_co_truncate() and
-BlockBackend name, but also with a qdev ID/QOM path for a device that
+bdrv_truncate().
 owns the (possibly anonymous) BlockBackend.
 Because qdev names could be conflicting with BlockBackend and node
 names, introduce a -d option to explicitly address a device. If the
 option is not given, a BlockBackend or a node is addressed.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
+Reviewed-by: Max Reitz <mreitz@redhat.com>
+Message-Id: <20200424125448.63318-3-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- monitor/hmp-cmds.c | 28 ++++++++++++++++++----------
+ include/block/block.h       |  5 +++--
- hmp-commands.hx    |  8 +++++---
+ block/block-backend.c       |  2 +-
-files changed, 23 insertions(+), 13 deletions(-)
+ block/crypto.c              |  2 +-
  block/io.c                  | 12 +++++++-----
  block/parallels.c           |  6 +++---
  block/qcow.c                |  4 ++--
  block/qcow2-refcount.c      |  2 +-
  block/qcow2.c               | 15 +++++++++------
  block/raw-format.c          |  2 +-
  block/vhdx-log.c            |  2 +-
  block/vhdx.c                |  2 +-
  block/vmdk.c                |  2 +-
  tests/test-block-iothread.c |  6 +++---
 files changed, 34 insertions(+), 28 deletions(-)
-diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
+diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
---- a/monitor/hmp-cmds.c
+--- a/include/block/block.h
-+++ b/monitor/hmp-cmds.c
++++ b/include/block/block.h
-@@ -XXX,XX +XXX,XX @@ void hmp_qemu_io(Monitor *mon, const QDict *qdict)
+@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
  void bdrv_refresh_filename(BlockDriverState *bs);
  int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
 -                                  PreallocMode prealloc, Error **errp);
 +                                  PreallocMode prealloc, BdrvRequestFlags flags,
 +                                  Error **errp);
  int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
 -                  PreallocMode prealloc, Error **errp);
 +                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
  int64_t bdrv_nb_sectors(BlockDriverState *bs);
  int64_t bdrv_getlength(BlockDriverState *bs);
 diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-backend.c
 +++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
          return -ENOMEDIUM;
      }
 -    return bdrv_truncate(blk->root, offset, exact, prealloc, errp);
 +    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
  }
  int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
 diff --git a/block/crypto.c b/block/crypto.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/crypto.c
 +++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
      offset += payload_offset;
 -    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
 +    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
  }
  static void block_crypto_close(BlockDriverState *bs)
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_parent_cb_resize(BlockDriverState *bs)
   * 'offset' bytes in length.
   */
  int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
 -                                  PreallocMode prealloc, Error **errp)
 +                                  PreallocMode prealloc, BdrvRequestFlags flags,
 +                                  Error **errp)
  {
-     BlockBackend *blk;
+     BlockDriverState *bs = child->bs;
-     BlockBackend *local_blk = NULL;
+     BlockDriver *drv = bs->drv;
-+    bool qdev = qdict_get_try_bool(qdict, "qdev", false);
+     BdrvTrackedRequest req;
-     const char* device = qdict_get_str(qdict, "device");
+-    BdrvRequestFlags flags = 0;
-     const char* command = qdict_get_str(qdict, "command");
+     int64_t old_size, new_bytes;
      Error *err = NULL;
      int ret;
--    blk = blk_by_name(device);
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
--    if (!blk) {
+         }
--        BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err);
+         ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
--        if (bs) {
+     } else if (bs->file && drv->is_filter) {
--            blk = local_blk = blk_new(bdrv_get_aio_context(bs),
+-        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
--                                      0, BLK_PERM_ALL);
++        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
--            ret = blk_insert_bs(blk, bs, &err);
+     } else {
--            if (ret < 0) {
+         error_setg(errp, "Image format driver does not support resize");
-+    if (qdev) {
+         ret = -ENOTSUP;
-+        blk = blk_by_qdev_id(device, &err);
+@@ -XXX,XX +XXX,XX @@ typedef struct TruncateCo {
-+        if (!blk) {
+     int64_t offset;
-+            goto fail;
+     bool exact;
-+        }
+     PreallocMode prealloc;
-+    } else {
++    BdrvRequestFlags flags;
-+        blk = blk_by_name(device);
+     Error **errp;
-+        if (!blk) {
+     int ret;
-+            BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err);
+ } TruncateCo;
-+            if (bs) {
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_truncate_co_entry(void *opaque)
-+                blk = local_blk = blk_new(bdrv_get_aio_context(bs),
+ {
-+                                          0, BLK_PERM_ALL);
+     TruncateCo *tco = opaque;
-+                ret = blk_insert_bs(blk, bs, &err);
+     tco->ret = bdrv_co_truncate(tco->child, tco->offset, tco->exact,
-+                if (ret < 0) {
+-                                tco->prealloc, tco->errp);
-+                    goto fail;
++                                tco->prealloc, tco->flags, tco->errp);
-+                }
+     aio_wait_kick();
-+            } else {
+ }
  int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
 -                  PreallocMode prealloc, Error **errp)
 +                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
  {
      Coroutine *co;
      TruncateCo tco = {
@@ -XXX,XX +XXX,XX @@ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
          .offset     = offset,
          .exact      = exact,
          .prealloc   = prealloc,
 +        .flags      = flags,
          .errp       = errp,
          .ret        = NOT_DONE,
      };
 diff --git a/block/parallels.c b/block/parallels.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/parallels.c
 +++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
          } else {
              ret = bdrv_truncate(bs->file,
                                  (s->data_end + space) << BDRV_SECTOR_BITS,
 -                                false, PREALLOC_MODE_OFF, NULL);
 +                                false, PREALLOC_MODE_OFF, 0, NULL);
          }
          if (ret < 0) {
              return ret;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
               * That means we have to pass exact=true.
               */
              ret = bdrv_truncate(bs->file, res->image_end_offset, true,
 -                                PREALLOC_MODE_OFF, &local_err);
 +                                PREALLOC_MODE_OFF, 0, &local_err);
              if (ret < 0) {
                  error_report_err(local_err);
                  res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static void parallels_close(BlockDriverState *bs)
          /* errors are ignored, so we might as well pass exact=true */
          bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS, true,
 -                      PREALLOC_MODE_OFF, NULL);
 +                      PREALLOC_MODE_OFF, 0, NULL);
      }
      g_free(s->bat_dirty_bmap);
 diff --git a/block/qcow.c b/block/qcow.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow.c
 +++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
                      return -E2BIG;
                  }
                  ret = bdrv_truncate(bs->file, cluster_offset + s->cluster_size,
 -                                    false, PREALLOC_MODE_OFF, NULL);
 +                                    false, PREALLOC_MODE_OFF, 0, NULL);
                  if (ret < 0) {
                      return ret;
                  }
@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
              l1_length) < 0)
          return -1;
      ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length, false,
 -                        PREALLOC_MODE_OFF, NULL);
 +                        PREALLOC_MODE_OFF, 0, NULL);
      if (ret < 0)
          return ret;
 diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2-refcount.c
 +++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
                  }
                  ret = bdrv_truncate(bs->file, offset + s->cluster_size, false,
 -                                    PREALLOC_MODE_OFF, &local_err);
 +                                    PREALLOC_MODE_OFF, 0, &local_err);
                  if (ret < 0) {
                      error_report_err(local_err);
                      goto resize_fail;
 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 int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
              mode = PREALLOC_MODE_OFF;
          }
          ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false,
 -                               mode, errp);
 +                               mode, 0, errp);
          if (ret < 0) {
              return ret;
          }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
               * always fulfilled, so there is no need to pass it on.)
               */
              bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size,
 -                             false, PREALLOC_MODE_OFF, &local_err);
 +                             false, PREALLOC_MODE_OFF, 0, &local_err);
              if (local_err) {
                  warn_reportf_err(local_err,
                                   "Failed to truncate the tail of the image: ");
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
               * file should be resized to the exact target size, too,
               * so we pass @exact here.
               */
 -            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, errp);
 +            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0,
 +                                   errp);
              if (ret < 0) {
                  goto fail;
              }
--        } else {
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
--            goto fail;
+         new_file_size = allocation_start +
-         }
+                         nb_new_data_clusters * s->cluster_size;
-     }
+         /* Image file grows, so @exact does not matter */
+-        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, errp);
-diff --git a/hmp-commands.hx b/hmp-commands.hx
++        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
-index XXXXXXX..XXXXXXX 100644
++                               errp);
---- a/hmp-commands.hx
+         if (ret < 0) {
-+++ b/hmp-commands.hx
+             error_prepend(errp, "Failed to resize underlying file: ");
-@@ -XXX,XX +XXX,XX @@ ETEXI
+             qcow2_free_clusters(bs, allocation_start,
+@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
-     {
+         if (len < 0) {
-         .name       = "qemu-io",
+             return len;
--        .args_type  = "device:B,command:s",
+         }
--        .params     = "[device] \"[command]\"",
+-        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, NULL);
--        .help       = "run a qemu-io command on a block device",
++        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0,
-+        .args_type  = "qdev:-d,device:B,command:s",
++                                NULL);
-+        .params     = "[-d] [device] \"[command]\"",
+     }
-+        .help       = "run a qemu-io command on a block device\n\t\t\t"
-+                      "-d: [device] is a device ID rather than a "
+     if (offset_into_cluster(s, offset)) {
-+                      "drive ID or node name",
+@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
-         .cmd        = hmp_qemu_io,
+     }
-     },
+     ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false,
 -                        PREALLOC_MODE_OFF, &local_err);
 +                        PREALLOC_MODE_OFF, 0, &local_err);
      if (ret < 0) {
          error_report_err(local_err);
          goto fail;
 diff --git a/block/raw-format.c b/block/raw-format.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/raw-format.c
 +++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
      s->size = offset;
      offset += s->offset;
 -    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
 +    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
  }
  static void raw_eject(BlockDriverState *bs, bool eject_flag)
 diff --git a/block/vhdx-log.c b/block/vhdx-log.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vhdx-log.c
 +++ b/block/vhdx-log.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_flush(BlockDriverState *bs, BDRVVHDXState *s,
                      goto exit;
                  }
                  ret = bdrv_truncate(bs->file, new_file_size, false,
 -                                    PREALLOC_MODE_OFF, NULL);
 +                                    PREALLOC_MODE_OFF, 0, NULL);
                  if (ret < 0) {
                      goto exit;
                  }
 diff --git a/block/vhdx.c b/block/vhdx.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vhdx.c
 +++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
      }
      return bdrv_truncate(bs->file, *new_offset + s->block_size, false,
 -                         PREALLOC_MODE_OFF, NULL);
 +                         PREALLOC_MODE_OFF, 0, NULL);
  }
  /*
 diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vmdk.c
 +++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
              }
              length = QEMU_ALIGN_UP(length, BDRV_SECTOR_SIZE);
              ret = bdrv_truncate(s->extents[i].file, length, false,
 -                                PREALLOC_MODE_OFF, NULL);
 +                                PREALLOC_MODE_OFF, 0, NULL);
              if (ret < 0) {
                  return ret;
              }
 diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/test-block-iothread.c
 +++ b/tests/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_truncate(BdrvChild *c)
      int ret;
      /* Normal success path */
 -    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
 +    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
      g_assert_cmpint(ret, ==, 0);
      /* Early error: Negative offset */
 -    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, NULL);
 +    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, 0, NULL);
      g_assert_cmpint(ret, ==, -EINVAL);
      /* Error: Read-only image */
      c->bs->read_only = true;
      c->bs->open_flags &= ~BDRV_O_RDWR;
 -    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
 +    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
      g_assert_cmpint(ret, ==, -EACCES);
      c->bs->read_only = false;
 --
-.20.1
+.25.3

-[PULL 05/30] qemu-img: fix info --backing-chain --image-opts
+[PULL 05/15] block-backend: Add flags to blk_truncate()
-From: Stefan Hajnoczi <stefanha@redhat.com>
+Now that node level interface bdrv_truncate() supports passing request
+flags to the block driver, expose this on the BlockBackend level, too.
-Only apply --image-opts to the topmost image when listing an entire
-backing chain.  It is incorrect to treat backing filenames as image
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-options.  Assuming we have the backing chain t.IMGFMT.base <-
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 t.IMGFMT.mid <- t.IMGFMT, qemu-img info fails as follows:
   $ qemu-img info --backing-chain --image-opts \
       driver=qcow2,file.driver=file,file.filename=t.IMGFMT
   qemu-img: Could not open 'TEST_DIR/t.IMGFMT.mid': Cannot find device=TEST_DIR/t.IMGFMT.mid nor node_name=TEST_DIR/t.IMGFMT.mid
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
+Reviewed-by: Max Reitz <mreitz@redhat.com>
+Message-Id: <20200424125448.63318-4-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qemu-img.c                 |  3 ++
+ include/sysemu/block-backend.h | 2 +-
- tests/qemu-iotests/279     | 57 ++++++++++++++++++++++++++++++++++++++
+ block.c                        | 3 ++-
- tests/qemu-iotests/279.out | 35 +++++++++++++++++++++++
+ block/block-backend.c          | 4 ++--
- tests/qemu-iotests/group   |  1 +
+ block/commit.c                 | 4 ++--
-files changed, 96 insertions(+)
+ block/crypto.c                 | 2 +-
- create mode 100755 tests/qemu-iotests/279
+ block/mirror.c                 | 2 +-
- create mode 100644 tests/qemu-iotests/279.out
+ block/qcow2.c                  | 4 ++--
+ block/qed.c                    | 2 +-
  block/vdi.c                    | 2 +-
  block/vhdx.c                   | 4 ++--
  block/vmdk.c                   | 6 +++---
  block/vpc.c                    | 2 +-
  blockdev.c                     | 2 +-
  qemu-img.c                     | 2 +-
  qemu-io-cmds.c                 | 2 +-
 files changed, 22 insertions(+), 21 deletions(-)
 diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/sysemu/block-backend.h
 +++ b/include/sysemu/block-backend.h
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
  int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
                            int bytes);
  int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
 -                 PreallocMode prealloc, Error **errp);
 +                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
  int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes);
  int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
                       int64_t pos, int size);
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
@@ -XXX,XX +XXX,XX @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,
      int64_t size;
      int ret;
 -    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);
 +    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
 +                       &local_err);
      if (ret < 0 && ret != -ENOTSUP) {
          error_propagate(errp, local_err);
          return ret;
 diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-backend.c
 +++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
  }
  int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
 -                 PreallocMode prealloc, Error **errp)
 +                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
  {
      if (!blk_is_available(blk)) {
          error_setg(errp, "No medium inserted");
          return -ENOMEDIUM;
      }
 -    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
 +    return bdrv_truncate(blk->root, offset, exact, prealloc, flags, errp);
  }
  int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
 diff --git a/block/commit.c b/block/commit.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/commit.c
 +++ b/block/commit.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
      }
      if (base_len < len) {
 -        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, NULL);
 +        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, 0, NULL);
          if (ret) {
              goto out;
          }
@@ -XXX,XX +XXX,XX @@ int bdrv_commit(BlockDriverState *bs)
       * grow the backing file image if possible.  If not possible,
       * we must return an error */
      if (length > backing_length) {
 -        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF,
 +        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF, 0,
                             &local_err);
          if (ret < 0) {
              error_report_err(local_err);
 diff --git a/block/crypto.c b/block/crypto.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/crypto.c
 +++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_init_func(QCryptoBlock *block,
       * which will be used by the crypto header
       */
      return blk_truncate(data->blk, data->size + headerlen, false,
 -                        data->prealloc, errp);
 +                        data->prealloc, 0, errp);
  }
 diff --git a/block/mirror.c b/block/mirror.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/mirror.c
 +++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
          if (s->bdev_length > base_length) {
              ret = blk_truncate(s->target, s->bdev_length, false,
 -                               PREALLOC_MODE_OFF, NULL);
 +                               PREALLOC_MODE_OFF, 0, NULL);
              if (ret < 0) {
                  goto immediate_exit;
              }
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
      /* Okay, now that we have a valid image, let's give it the right size */
      ret = blk_truncate(blk, qcow2_opts->size, false, qcow2_opts->preallocation,
 -                       errp);
 +                       0, errp);
      if (ret < 0) {
          error_prepend(errp, "Could not resize image: ");
          goto out;
@@ -XXX,XX +XXX,XX @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
           * Amending image options should ensure that the image has
           * exactly the given new values, so pass exact=true here.
           */
 -        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, errp);
 +        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, 0, errp);
          blk_unref(blk);
          if (ret < 0) {
              return ret;
 diff --git a/block/qed.c b/block/qed.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qed.c
 +++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
       * The QED format associates file length with allocation status,
       * so a new file (which is empty) must have a length of 0.
       */
 -    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, errp);
 +    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, 0, errp);
      if (ret < 0) {
          goto out;
      }
 diff --git a/block/vdi.c b/block/vdi.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vdi.c
 +++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
      if (image_type == VDI_TYPE_STATIC) {
          ret = blk_truncate(blk, offset + blocks * block_size, false,
 -                           PREALLOC_MODE_OFF, errp);
 +                           PREALLOC_MODE_OFF, 0, errp);
          if (ret < 0) {
              error_prepend(errp, "Failed to statically allocate file");
              goto exit;
 diff --git a/block/vhdx.c b/block/vhdx.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vhdx.c
 +++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
          /* All zeroes, so we can just extend the file - the end of the BAT
           * is the furthest thing we have written yet */
          ret = blk_truncate(blk, data_file_offset, false, PREALLOC_MODE_OFF,
 -                           errp);
 +                           0, errp);
          if (ret < 0) {
              goto exit;
          }
      } else if (type == VHDX_TYPE_FIXED) {
          ret = blk_truncate(blk, data_file_offset + image_size, false,
 -                           PREALLOC_MODE_OFF, errp);
 +                           PREALLOC_MODE_OFF, 0, errp);
          if (ret < 0) {
              goto exit;
          }
 diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vmdk.c
 +++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
      int gd_buf_size;
      if (flat) {
 -        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, errp);
 +        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, 0, errp);
          goto exit;
      }
      magic = cpu_to_be32(VMDK4_MAGIC);
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
      }
      ret = blk_truncate(blk, le64_to_cpu(header.grain_offset) << 9, false,
 -                       PREALLOC_MODE_OFF, errp);
 +                       PREALLOC_MODE_OFF, 0, errp);
      if (ret < 0) {
          goto exit;
      }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vmdk_co_do_create(int64_t size,
      /* bdrv_pwrite write padding zeros to align to sector, we don't need that
       * for description file */
      if (desc_offset == 0) {
 -        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, errp);
 +        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, 0, errp);
          if (ret < 0) {
              goto exit;
          }
 diff --git a/block/vpc.c b/block/vpc.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vpc.c
 +++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
      /* Add footer to total size */
      total_size += HEADER_SIZE;
 -    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, errp);
 +    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
      if (ret < 0) {
          return ret;
      }
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_block_resize(bool has_device, const char *device,
      }
      bdrv_drained_begin(bs);
 -    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, errp);
 +    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, 0, errp);
      bdrv_drained_end(bs);
  out:
 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 ImageInfoList *collect_image_info_list(bool image_opts,
+@@ -XXX,XX +XXX,XX @@ static int img_resize(int argc, char **argv)
+      * resizing, so pass @exact=true.  It is of no use to report
-         blk_unref(blk);
+      * success when the image has not actually been resized.
+      */
-+        /* Clear parameters that only apply to the topmost image */
+-    ret = blk_truncate(blk, total_size, true, prealloc, &err);
-         filename = fmt = NULL;
++    ret = blk_truncate(blk, total_size, true, prealloc, 0, &err);
-+        image_opts = false;
+     if (!ret) {
-+
+         qprintf(quiet, "Image resized.\n");
-         if (chain) {
+     } else {
-             if (info->has_full_backing_filename) {
+diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
-                 filename = info->full_backing_filename;
+index XXXXXXX..XXXXXXX 100644
-diff --git a/tests/qemu-iotests/279 b/tests/qemu-iotests/279
+--- a/qemu-io-cmds.c
-new file mode 100755
++++ b/qemu-io-cmds.c
-index XXXXXXX..XXXXXXX
+@@ -XXX,XX +XXX,XX @@ static int truncate_f(BlockBackend *blk, int argc, char **argv)
---- /dev/null
+      * exact=true.  It is better to err on the "emit more errors" side
-+++ b/tests/qemu-iotests/279
+      * than to be overly permissive.
-@@ -XXX,XX +XXX,XX @@
+      */
-+#!/usr/bin/env bash
+-    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, &local_err);
-+#
++    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, 0, &local_err);
-+# Test qemu-img --backing-chain --image-opts
+     if (ret < 0) {
-+#
+         error_report_err(local_err);
-+# Copyright (C) 2019 Red Hat, Inc.
+         return ret;
 +#
 +# 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
 +    rm -f "$TEST_IMG.mid"
 +}
 +trap "_cleanup; exit \$status" 0 1 2 3 15
 +
 +# get standard environment, filters and checks
 +. ./common.rc
 +. ./common.filter
 +
 +# Backing files are required...
 +_supported_fmt qcow qcow2 vmdk qed
 +_supported_proto file
 +_supported_os Linux
 +
 +TEST_IMG="$TEST_IMG.base" _make_test_img 64M
 +TEST_IMG="$TEST_IMG.mid" _make_test_img -b "$TEST_IMG.base"
 +_make_test_img -b "$TEST_IMG.mid"
 +
 +echo
 +echo '== qemu-img info --backing-chain =='
 +_img_info --backing-chain | _filter_img_info
 +
 +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
 +
 +# success, all done
 +echo "*** done"
 +rm -f $seq.full
 +status=0
 diff --git a/tests/qemu-iotests/279.out b/tests/qemu-iotests/279.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/279.out
@@ -XXX,XX +XXX,XX @@
 +QA output created by 279
 +Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864
 +Formatting 'TEST_DIR/t.IMGFMT.mid', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.base
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.mid
 +
 +== qemu-img info --backing-chain ==
 +image: TEST_DIR/t.IMGFMT
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +backing file: TEST_DIR/t.IMGFMT.mid
 +
 +image: TEST_DIR/t.IMGFMT.mid
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +backing file: TEST_DIR/t.IMGFMT.base
 +
 +image: TEST_DIR/t.IMGFMT.base
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +
 +== qemu-img info --backing-chain --image-opts ==
 +image: TEST_DIR/t.IMGFMT
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +backing file: TEST_DIR/t.IMGFMT.mid
 +
 +image: TEST_DIR/t.IMGFMT.mid
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +backing file: TEST_DIR/t.IMGFMT.base
 +
 +image: TEST_DIR/t.IMGFMT.base
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +*** 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
 backing quick
 rw quick
 +279 rw backing quick
 --
-.20.1
+.25.3

-[PULL 08/30] qcow2: Declare BDRV_REQ_NO_FALLBACK supported
+[PULL 06/15] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
-In the common case, qcow2_co_pwrite_zeroes() already only modifies
+If BDRV_REQ_ZERO_WRITE is set and we're extending the image, calling
-metadata case, so we're fine with or without BDRV_REQ_NO_FALLBACK set.
+qcow2_cluster_zeroize() with flags=0 does the right thing: It doesn't
+undo any previous preallocation, but just adds the zero flag to all
-The only exception is when using an external data file, where the
+relevant L2 entries. If an external data file is in use, a write_zeroes
-request is passed down to the block driver of the external data file. We
+request to the data file is made instead.
 are forwarding the BDRV_REQ_NO_FALLBACK flag there, though, so this is
 fine, too.
 Declare the flag supported therefore.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-Id: <20200424125448.63318-5-kwolf@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2.c | 3 ++-
+ block/qcow2-cluster.c |  2 +-
-file changed, 2 insertions(+), 1 deletion(-)
+ block/qcow2.c         | 34 ++++++++++++++++++++++++++++++++++
 files changed, 35 insertions(+), 1 deletion(-)
+diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2-cluster.c
++++ b/block/qcow2-cluster.c
+@@ -XXX,XX +XXX,XX @@ int qcow2_cluster_zeroize(BlockDriverState *bs, uint64_t offset,
+     /* Caller must pass aligned values, except at image end */
+     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
+     assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) ||
+-           end_offset == bs->total_sectors << BDRV_SECTOR_BITS);
++           end_offset >= bs->total_sectors << BDRV_SECTOR_BITS);
+     /* The zero flag is only supported by version 3 and newer */
+     if (s->qcow_version < 3) {
 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 int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
-         }
-     }
+     bs->supported_zero_flags = header.version >= 3 ?
+                                BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
--    bs->supported_zero_flags = header.version >= 3 ? BDRV_REQ_MAY_UNMAP : 0;
++    bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
 +    bs->supported_zero_flags = header.version >= 3 ?
 +                               BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
      /* Repair image if dirty */
      if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
+         g_assert_not_reached();
+     }
++    if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
++        uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->cluster_size);
++
++        /*
++         * Use zero clusters as much as we can. qcow2_cluster_zeroize()
++         * requires a cluster-aligned start. The end may be unaligned if it is
++         * at the end of the image (which it is here).
++         */
++        ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
++        if (ret < 0) {
++            error_setg_errno(errp, -ret, "Failed to zero out new clusters");
++            goto fail;
++        }
++
++        /* Write explicit zeros for the unaligned head */
++        if (zero_start > old_length) {
++            uint64_t len = zero_start - old_length;
++            uint8_t *buf = qemu_blockalign0(bs, len);
++            QEMUIOVector qiov;
++            qemu_iovec_init_buf(&qiov, buf, len);
++
++            qemu_co_mutex_unlock(&s->lock);
++            ret = qcow2_co_pwritev_part(bs, old_length, len, &qiov, 0, 0);
++            qemu_co_mutex_lock(&s->lock);
++
++            qemu_vfree(buf);
++            if (ret < 0) {
++                error_setg_errno(errp, -ret, "Failed to zero out the new area");
++                goto fail;
++            }
++        }
++    }
++
+     if (prealloc != PREALLOC_MODE_OFF) {
+         /* Flush metadata before actually changing the image size */
+         ret = qcow2_write_caches(bs);
 --
-.20.1
+.25.3

-[PULL 09/30] iotests: Add qemu_io_log()
+[PULL 07/15] raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
-Add a function that runs qemu-io and logs the output with the
+The raw format driver can simply forward the flag and let its bs->file
-appropriate filters applied.
+child take care of actually providing the zeros.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Max Reitz <mreitz@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
+Message-Id: <20200424125448.63318-6-kwolf@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/iotests.py | 5 +++++
+ block/raw-format.c | 4 +++-
-file changed, 5 insertions(+)
+file changed, 3 insertions(+), 1 deletion(-)
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
+diff --git a/block/raw-format.c b/block/raw-format.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
+--- a/block/raw-format.c
-+++ b/tests/qemu-iotests/iotests.py
++++ b/block/raw-format.c
-@@ -XXX,XX +XXX,XX @@ def qemu_io(*args):
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
-         sys.stderr.write('qemu-io received signal %i: %s\n' % (-exitcode, ' '.join(args)))
-     return subp.communicate()[0]
+     s->size = offset;
+     offset += s->offset;
-+def qemu_io_log(*args):
+-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
-+    result = qemu_io(*args)
++    return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
-+    log(result, filters=[filter_testfiles, filter_qemu_io])
+ }
-+    return result
-+
+ static void raw_eject(BlockDriverState *bs, bool eject_flag)
- def qemu_io_silent(*args):
+@@ -XXX,XX +XXX,XX @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
-     '''Run qemu-io and return the exit code, suppressing stdout'''
+     bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
-     args = qemu_io_args + list(args)
+         ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
              bs->file->bs->supported_zero_flags);
 +    bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags &
 +                                   BDRV_REQ_ZERO_WRITE;
      if (bs->probed && !bdrv_is_read_only(bs)) {
          bdrv_refresh_filename(bs->file->bs);
 --
-.20.1
+.25.3

-[PULL 07/30] blockjob: Fix error message for negative speed
+[PULL 08/15] file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
-The error message for a negative speed uses QERR_INVALID_PARAMETER,
+For regular files, we always get BDRV_REQ_ZERO_WRITE behaviour from the
-which implies that the 'speed' option doesn't even exist:
+OS, so we can advertise the flag and just ignore it.
     {"error": {"class": "GenericError", "desc": "Invalid parameter 'speed'"}}
 Make it use QERR_INVALID_PARAMETER_VALUE instead:
     {"error": {"class": "GenericError", "desc": "Parameter 'speed' expects a non-negative value"}}
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
+Message-Id: <20200424125448.63318-7-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- blockjob.c             | 3 ++-
+ block/file-posix.c | 4 ++++
- tests/qemu-iotests/030 | 4 ++--
+file changed, 4 insertions(+)
 files changed, 4 insertions(+), 3 deletions(-)
-diff --git a/blockjob.c b/blockjob.c
+diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockjob.c
+--- a/block/file-posix.c
-+++ b/blockjob.c
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
-         return;
+ #endif
-     }
-     if (speed < 0) {
+     bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
--        error_setg(errp, QERR_INVALID_PARAMETER, "speed");
++    if (S_ISREG(st.st_mode)) {
-+        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "speed",
++        /* When extending regular files, we get zeros from the OS */
-+                   "a non-negative value");
++        bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
-         return;
++    }
-     }
+     ret = 0;
+ fail:
-diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
+     if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/030
 +++ b/tests/qemu-iotests/030
@@ -XXX,XX +XXX,XX @@ class TestSetSpeed(iotests.QMPTestCase):
          self.assert_no_active_block_jobs()
          result = self.vm.qmp('block-stream', device='drive0', speed=-1)
 -        self.assert_qmp(result, 'error/desc', "Invalid parameter 'speed'")
 +        self.assert_qmp(result, 'error/desc', "Parameter 'speed' expects a non-negative value")
          self.assert_no_active_block_jobs()
@@ -XXX,XX +XXX,XX @@ class TestSetSpeed(iotests.QMPTestCase):
          self.assert_qmp(result, 'return', {})
          result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1)
 -        self.assert_qmp(result, 'error/desc', "Invalid parameter 'speed'")
 +        self.assert_qmp(result, 'error/desc', "Parameter 'speed' expects a non-negative value")
          self.cancel_and_wait(resume=True)
 --
-.20.1
+.25.3

-[PULL 06/30] block: Error out on image creation with conflicting size options
+[PULL 09/15] block: truncate: Don't make backing file data visible
-If both the create options (qemu-img create -o ...) and the size
+When extending the size of an image that has a backing file larger than
-parameter were given, the size parameter was silently ignored. Instead,
+its old size, make sure that the backing file data doesn't become
-make specifying two sizes an error.
+visible in the guest, but the added area is properly zeroed out.
 Consider the following scenario where the overlay is shorter than its
 backing file:
     base.qcow2:     AAAAAAAA
     overlay.qcow2:  BBBB
 When resizing (extending) overlay.qcow2, the new blocks should not stay
 unallocated and make the additional As from base.qcow2 visible like
 before this patch, but zeros should be read.
 A similar case happens with the various variants of a commit job when an
 intermediate file is short (- for unallocated):
     base.qcow2:     A-A-AAAA
     mid.qcow2:      BB-B
     top.qcow2:      C--C--C-
 After commit top.qcow2 to mid.qcow2, the following happens:
     mid.qcow2:      CB-C00C0 (correct result)
     mid.qcow2:      CB-C--C- (before this fix)
 Without the fix, blocks that previously read as zeros on top.qcow2
 suddenly turn into A.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Message-Id: <20200424125448.63318-8-kwolf@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block.c                    | 10 ++++++++--
+ block/io.c | 25 +++++++++++++++++++++++++
- tests/qemu-iotests/049     |  5 +++++
+file changed, 25 insertions(+)
  tests/qemu-iotests/049.out |  5 +++++
 files changed, 18 insertions(+), 2 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/block/io.c
-+++ b/block.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
-         return;
+         goto out;
      }
-+    /* Create parameter list */
++    /*
-     create_opts = qemu_opts_append(create_opts, drv->create_opts);
++     * If the image has a backing file that is large enough that it would
-     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
++     * provide data for the new area, we cannot leave it unallocated because
++     * then the backing file content would become visible. Instead, zero-fill
--    /* Create parameter list with default values */
++     * the new area.
-     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
++     *
--    qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
++     * Note that if the image has a backing file, but was opened without the
++     * backing file, taking care of keeping things consistent with that backing
-     /* Parse -o options */
++     * file is the user's responsibility.
-     if (options) {
++     */
-@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,
++    if (new_bytes && bs->backing) {
-         }
++        int64_t backing_len;
-     }
++
++        backing_len = bdrv_getlength(backing_bs(bs));
-+    if (!qemu_opt_get(opts, BLOCK_OPT_SIZE)) {
++        if (backing_len < 0) {
-+        qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
++            ret = backing_len;
-+    } else if (img_size != UINT64_C(-1)) {
++            error_setg_errno(errp, -ret, "Could not get backing file size");
-+        error_setg(errp, "The image size must be specified only once");
++            goto out;
-+        goto out;
++        }
 +
 +        if (backing_len > old_size) {
 +            flags |= BDRV_REQ_ZERO_WRITE;
 +        }
 +    }
 +
-     if (base_filename) {
+     if (drv->bdrv_co_truncate) {
-         qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
+         if (flags & ~bs->supported_truncate_flags) {
-         if (local_err) {
+             error_setg(errp, "Block driver does not support requested flags");
 diff --git a/tests/qemu-iotests/049 b/tests/qemu-iotests/049
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/049
 +++ b/tests/qemu-iotests/049
@@ -XXX,XX +XXX,XX @@ for s in $sizes; do
      test_qemu_img create -f $IMGFMT -o size=$s "$TEST_IMG"
  done
 +echo "== 4. Specify size twice (-o and traditional parameter) =="
 +echo
 +
 +test_qemu_img create -f $IMGFMT -o size=10M "$TEST_IMG" 20M
 +
  echo "== Check correct interpretation of suffixes for cluster size =="
  echo
  sizes="1024 1024b 1k 1K 1M "
 diff --git a/tests/qemu-iotests/049.out b/tests/qemu-iotests/049.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/049.out
 +++ b/tests/qemu-iotests/049.out
@@ -XXX,XX +XXX,XX @@ qemu-img: TEST_DIR/t.qcow2: Parameter 'size' expects a non-negative number below
  Optional suffix k, M, G, T, P or E means kilo-, mega-, giga-, tera-, peta-
  and exabytes, respectively.
 +== 4. Specify size twice (-o and traditional parameter) ==
 +
 +qemu-img create -f qcow2 -o size=10M TEST_DIR/t.qcow2 20M
 +qemu-img: TEST_DIR/t.qcow2: The image size must be specified only once
 +
  == Check correct interpretation of suffixes for cluster size ==
  qemu-img create -f qcow2 -o cluster_size=1024 TEST_DIR/t.qcow2 64M
 --
-.20.1
+.25.3

-[PULL 18/30] iotests: Create VM.blockdev_create()
+[PULL 10/15] iotests: Filter testfiles out in filter_img_info()
-We have several almost identical copies of a blockdev_create() function
+We want to keep TEST_IMG for the full path of the main test image, but
-in different test cases. Time to create one unified function in
+filter_testfiles() must be called for other test images before replacing
-iotests.py.
+other things like the image format because the test directory path could
 contain the format as a substring.
-To keep the diff managable, this patch only creates the function and
+Insert a filter_testfiles() call between both.
 follow-up patches will convert the individual test cases.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20200424125448.63318-9-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/iotests.py | 16 ++++++++++++++++
+ tests/qemu-iotests/iotests.py | 5 +++--
-file changed, 16 insertions(+)
+file changed, 3 insertions(+), 2 deletions(-)
 diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/iotests.py
 +++ b/tests/qemu-iotests/iotests.py
-@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
+@@ -XXX,XX +XXX,XX @@ def filter_img_info(output, filename):
-             elif status == 'null':
+     for line in output.split('\n'):
-                 return error
+         if 'disk size' in line or 'actual-size' in line:
+             continue
-+    # Returns None on success, and an error string on failure
+-        line = line.replace(filename, 'TEST_IMG') \
-+    def blockdev_create(self, options, job_id='job0', filters=None):
+-                   .replace(imgfmt, 'IMGFMT')
-+        if filters is None:
++        line = line.replace(filename, 'TEST_IMG')
-+            filters = [filter_qmp_testfiles]
++        line = filter_testfiles(line)
-+        result = self.qmp_log('blockdev-create', filters=filters,
++        line = line.replace(imgfmt, 'IMGFMT')
-+                              job_id=job_id, options=options)
+         line = re.sub('iters: [0-9]+', 'iters: XXX', line)
-+
+         line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line)
-+        if 'return' in result:
+         line = re.sub('cid: [0-9]+', 'cid: XXXXXXXXXX', line)
 +            assert result['return'] == {}
 +            job_result = self.run_job(job_id)
 +        else:
 +            job_result = result['error']
 +
 +        log("")
 +        return job_result
 +
      def enable_migration_events(self, name):
          log('Enabling migration QMP events on %s...' % name)
          log(self.qmp('migrate-set-capabilities', capabilities=[
 --
-.20.1
+.25.3

-[PULL 30/30] iotests: Test external snapshot with VM state
+[PULL 11/15] iotests: Test committing to short backing file
-This tests creating an external snapshot with VM state (which results in
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-an active overlay over an inactive backing file, which is also the root
+Message-Id: <20200424125448.63318-10-kwolf@redhat.com>
-node of an inactive BlockBackend), re-activating the images and
+Reviewed-by: Max Reitz <mreitz@redhat.com>
-performing some operations to test that the re-activation worked as
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 intended.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/280     | 83 ++++++++++++++++++++++++++++++++++++++
+ tests/qemu-iotests/274     | 155 +++++++++++++++++++++
- tests/qemu-iotests/280.out | 50 +++++++++++++++++++++++
+ tests/qemu-iotests/274.out | 268 +++++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/group   |  1 +
+ tests/qemu-iotests/group   |   1 +
-files changed, 134 insertions(+)
+files changed, 424 insertions(+)
- create mode 100755 tests/qemu-iotests/280
+ create mode 100755 tests/qemu-iotests/274
- create mode 100644 tests/qemu-iotests/280.out
+ create mode 100644 tests/qemu-iotests/274.out
-diff --git a/tests/qemu-iotests/280 b/tests/qemu-iotests/280
+diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/280
++++ b/tests/qemu-iotests/274
 @@ -XXX,XX +XXX,XX @@
-+#!/usr/bin/env python
++#!/usr/bin/env python3
 +#
 +# 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
 ...
 +# 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: Kevin Wolf <kwolf@redhat.com>
 +#
-+# Test migration to file for taking an external snapshot with VM state.
++# Some tests for short backing files and short overlays
 +
 +import iotests
-+import os
 +
 +iotests.verify_image_format(supported_fmts=['qcow2'])
-+iotests.verify_protocol(supported=['file'])
 +iotests.verify_platform(['linux'])
 +
-+with iotests.FilePath('base') as base_path , \
++size_short = 1 * 1024 * 1024
-+     iotests.FilePath('top') as top_path, \
++size_long = 2 * 1024 * 1024
-+     iotests.VM() as vm:
++size_diff = size_long - size_short
 +
-+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, base_path, '64M')
++def create_chain() -> None:
-+
++    iotests.qemu_img_log('create', '-f', iotests.imgfmt, base,
-+    iotests.log('=== Launch VM ===')
++                         str(size_long))
-+    vm.add_object('iothread,id=iothread0')
++    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, mid,
-+    vm.add_blockdev('file,filename=%s,node-name=base-file' % (base_path))
++                         str(size_short))
-+    vm.add_blockdev('%s,file=base-file,node-name=base-fmt' % (iotests.imgfmt))
++    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', mid, top,
-+    vm.add_device('virtio-blk,drive=base-fmt,iothread=iothread0,id=vda')
++                         str(size_long))
-+    vm.launch()
++
-+
++    iotests.qemu_io_log('-c', 'write -P 1 0 %d' % size_long, base)
-+    vm.enable_migration_events('VM')
++
-+
++def create_vm() -> iotests.VM:
-+    iotests.log('\n=== Migrate to file ===')
++    vm = iotests.VM()
-+    vm.qmp_log('migrate', uri='exec:cat > /dev/null')
++    vm.add_blockdev('file,filename=%s,node-name=base-file' % base)
-+
++    vm.add_blockdev('%s,file=base-file,node-name=base' % iotests.imgfmt)
-+    with iotests.Timeout(3, 'Migration does not complete'):
++    vm.add_blockdev('file,filename=%s,node-name=mid-file' % mid)
-+        vm.wait_migration()
++    vm.add_blockdev('%s,file=mid-file,node-name=mid,backing=base'
-+
++                    % iotests.imgfmt)
-+    iotests.log('\nVM is now stopped:')
++    vm.add_drive(top, 'backing=mid,node-name=top')
-+    iotests.log(vm.qmp('query-migrate')['return']['status'])
++    return vm
-+    vm.qmp_log('query-status')
++
-+
++with iotests.FilePath('base') as base, \
-+    iotests.log('\n=== Create a snapshot of the disk image ===')
++     iotests.FilePath('mid') as mid, \
-+    vm.blockdev_create({
++     iotests.FilePath('top') as top:
-+        'driver': 'file',
++
-+        'filename': top_path,
++    iotests.log('== Commit tests ==')
-+        'size': 0,
++
-+    })
++    create_chain()
-+    vm.qmp_log('blockdev-add', node_name='top-file',
++
-+               driver='file', filename=top_path,
++    iotests.log('=== Check visible data ===')
-+               filters=[iotests.filter_qmp_testfiles])
++
-+
++    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, top)
-+    vm.blockdev_create({
++    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), top)
-+        'driver': iotests.imgfmt,
++
-+        'file': 'top-file',
++    iotests.log('=== Checking allocation status ===')
-+        'size': 1024 * 1024,
++
-+    })
++    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
-+    vm.qmp_log('blockdev-add', node_name='top-fmt',
++                        '-c', 'alloc %d %d' % (size_short, size_diff),
-+               driver=iotests.imgfmt, file='top-file')
++                        base)
 +
-+    vm.qmp_log('blockdev-snapshot', node='base-fmt', overlay='top-fmt')
++    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
-+
++                        '-c', 'alloc %d %d' % (size_short, size_diff),
-+    iotests.log('\n=== Resume the VM and simulate a write request ===')
++                        mid)
-+    vm.qmp_log('cont')
++
-+    iotests.log(vm.hmp_qemu_io('-d vda/virtio-backend', 'write 4k 4k'))
++    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
-+
++                        '-c', 'alloc %d %d' % (size_short, size_diff),
-+    iotests.log('\n=== Commit it to the backing file ===')
++                        top)
-+    result = vm.qmp_log('block-commit', job_id='job0', auto_dismiss=False,
++
-+                        device='top-fmt', top_node='top-fmt',
++    iotests.log('=== Checking map ===')
-+                        filters=[iotests.filter_qmp_testfiles])
++
-+    if 'return' in result:
++    iotests.qemu_img_log('map', '--output=json', base)
-+        vm.run_job('job0')
++    iotests.qemu_img_log('map', '--output=human', base)
-diff --git a/tests/qemu-iotests/280.out b/tests/qemu-iotests/280.out
++    iotests.qemu_img_log('map', '--output=json', mid)
 +    iotests.qemu_img_log('map', '--output=human', mid)
 +    iotests.qemu_img_log('map', '--output=json', top)
 +    iotests.qemu_img_log('map', '--output=human', top)
 +
 +    iotests.log('=== Testing qemu-img commit (top -> mid) ===')
 +
 +    iotests.qemu_img_log('commit', top)
 +    iotests.img_info_log(mid)
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
 +
 +    iotests.log('=== Testing HMP commit (top -> mid) ===')
 +
 +    create_chain()
 +    with create_vm() as vm:
 +        vm.launch()
 +        vm.qmp_log('human-monitor-command', command_line='commit drive0')
 +
 +    iotests.img_info_log(mid)
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
 +
 +    iotests.log('=== Testing QMP active commit (top -> mid) ===')
 +
 +    create_chain()
 +    with create_vm() as vm:
 +        vm.launch()
 +        vm.qmp_log('block-commit', device='top', base_node='mid',
 +                   job_id='job0', auto_dismiss=False)
 +        vm.run_job('job0', wait=5)
 +
 +    iotests.img_info_log(mid)
 +    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
 +    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
 +
 +
 +    iotests.log('== Resize tests ==')
 +
 +    # Use different sizes for different allocation modes:
 +    #
 +    # We want to have at least one test where 32 bit truncation in the size of
 +    # the overlapping area becomes visible. This is covered by the
 +    # prealloc='off' case (1G to 6G is an overlap of 5G).
 +    #
 +    # However, we can only do this for modes that don't preallocate data
 +    # because otherwise we might run out of space on the test host.
 +    #
 +    # We also want to test some unaligned combinations.
 +    for (prealloc, base_size, top_size_old, top_size_new, off) in [
 +            ('off',       '6G',    '1G',   '8G',   '5G'),
 +            ('metadata', '32G',   '30G',  '33G',  '31G'),
 +            ('falloc',   '10M',    '5M',  '15M',   '9M'),
 +            ('full',     '16M',    '8M',  '12M',  '11M'),
 +            ('off',      '384k', '253k', '512k', '253k'),
 +            ('off',      '400k', '256k', '512k', '336k'),
 +            ('off',      '512k', '256k', '500k', '436k')]:
 +
 +        iotests.log('=== preallocation=%s ===' % prealloc)
 +        iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, base_size)
 +        iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, top,
 +                             top_size_old)
 +        iotests.qemu_io_log('-c', 'write -P 1 %s 64k' % off, base)
 +
 +        # After this, top_size_old to base_size should be allocated/zeroed.
 +        #
 +        # In theory, leaving base_size to top_size_new unallocated would be
 +        # correct, but in practice, if we zero out anything, we zero out
 +        # everything up to top_size_new.
 +        iotests.qemu_img_log('resize', '-f', iotests.imgfmt,
 +                             '--preallocation', prealloc, top, top_size_new)
 +        iotests.qemu_io_log('-c', 'read -P 0 %s 64k' % off, top)
 +        iotests.qemu_io_log('-c', 'map', top)
 +        iotests.qemu_img_log('map', '--output=json', top)
 diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/280.out
++++ b/tests/qemu-iotests/274.out
 @@ -XXX,XX +XXX,XX @@
-+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=67108864 cluster_size=65536 lazy_refcounts=off refcount_bits=16
++== Commit tests ==
-+
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
-+=== Launch VM ===
++
-+Enabling migration QMP events on VM...
++Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
-+{"return": {}}
++
-+
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
-+=== Migrate to file ===
++
-+{"execute": "migrate", "arguments": {"uri": "exec:cat > /dev/null"}}
++wrote 2097152/2097152 bytes at offset 0
-+{"return": {}}
++2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+{"data": {"status": "setup"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
-+{"data": {"status": "active"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++=== Check visible data ===
-+{"data": {"status": "completed"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++read 1048576/1048576 bytes at offset 0
-+
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+VM is now stopped:
++
-+completed
++read 1048576/1048576 bytes at offset 1048576
-+{"execute": "query-status", "arguments": {}}
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+{"return": {"running": false, "singlestep": false, "status": "postmigrate"}}
++
-+
++=== Checking allocation status ===
-+=== Create a snapshot of the disk image ===
++1048576/1048576 bytes allocated at offset 0 bytes
-+{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "file", "filename": "TEST_DIR/PID-top", "size": 0}}}
++1048576/1048576 bytes allocated at offset 1 MiB
-+{"return": {}}
++
-+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
++0/1048576 bytes allocated at offset 0 bytes
-+{"return": {}}
++0/0 bytes allocated at offset 1 MiB
 +
-+{"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-top", "node-name": "top-file"}}
++0/1048576 bytes allocated at offset 0 bytes
-+{"return": {}}
++0/1048576 bytes allocated at offset 1 MiB
-+{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "qcow2", "file": "top-file", "size": 1048576}}}
++
-+{"return": {}}
++=== Checking map ===
-+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
++[{ "start": 0, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": 327680}]
-+{"return": {}}
++
-+
++Offset          Length          Mapped to       File
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": "top-file", "node-name": "top-fmt"}}
++0               0x200000        0x50000         TEST_DIR/PID-base
-+{"return": {}}
++
-+{"execute": "blockdev-snapshot", "arguments": {"node": "base-fmt", "overlay": "top-fmt"}}
++[{ "start": 0, "length": 1048576, "depth": 1, "zero": false, "data": true, "offset": 327680}]
-+{"return": {}}
++
-+
++Offset          Length          Mapped to       File
-+=== Resume the VM and simulate a write request ===
++0               0x100000        0x50000         TEST_DIR/PID-base
-+{"execute": "cont", "arguments": {}}
++
-+{"return": {}}
++[{ "start": 0, "length": 1048576, "depth": 2, "zero": false, "data": true, "offset": 327680},
 +{ "start": 1048576, "length": 1048576, "depth": 0, "zero": true, "data": false}]
 +
 +Offset          Length          Mapped to       File
 +0               0x100000        0x50000         TEST_DIR/PID-base
 +
 +=== Testing qemu-img commit (top -> mid) ===
 +Image committed.
 +
 +image: TEST_IMG
 +file format: IMGFMT
 +virtual size: 2 MiB (2097152 bytes)
 +cluster_size: 65536
 +backing file: TEST_DIR/PID-base
 +Format specific information:
 +    compat: 1.1
 +    lazy refcounts: false
 +    refcount bits: 16
 +    corrupt: false
 +
 +read 1048576/1048576 bytes at offset 0
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +read 1048576/1048576 bytes at offset 1048576
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +=== Testing HMP commit (top -> mid) ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 2097152/2097152 bytes at offset 0
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +{"execute": "human-monitor-command", "arguments": {"command-line": "commit drive0"}}
 +{"return": ""}
-+
++image: TEST_IMG
-+=== Commit it to the backing file ===
++file format: IMGFMT
-+{"execute": "block-commit", "arguments": {"auto-dismiss": false, "device": "top-fmt", "job-id": "job0", "top-node": "top-fmt"}}
++virtual size: 2 MiB (2097152 bytes)
 +cluster_size: 65536
 +backing file: TEST_DIR/PID-base
 +Format specific information:
 +    compat: 1.1
 +    lazy refcounts: false
 +    refcount bits: 16
 +    corrupt: false
 +
 +read 1048576/1048576 bytes at offset 0
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +read 1048576/1048576 bytes at offset 1048576
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +=== Testing QMP active commit (top -> mid) ===
 +Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +
 +wrote 2097152/2097152 bytes at offset 0
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +{"execute": "block-commit", "arguments": {"auto-dismiss": false, "base-node": "mid", "device": "top", "job-id": "job0"}}
 +{"return": {}}
 +{"execute": "job-complete", "arguments": {"id": "job0"}}
 +{"return": {}}
-+{"data": {"device": "job0", "len": 65536, "offset": 65536, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-+{"data": {"device": "job0", "len": 65536, "offset": 65536, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"execute": "job-dismiss", "arguments": {"id": "job0"}}
 +{"return": {}}
++image: TEST_IMG
++file format: IMGFMT
++virtual size: 2 MiB (2097152 bytes)
++cluster_size: 65536
++backing file: TEST_DIR/PID-base
++Format specific information:
++    compat: 1.1
++    lazy refcounts: false
++    refcount bits: 16
++    corrupt: false
++
++read 1048576/1048576 bytes at offset 0
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++read 1048576/1048576 bytes at offset 1048576
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++== Resize tests ==
++=== preallocation=off ===
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=6442450944 cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=1073741824 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++wrote 65536/65536 bytes at offset 5368709120
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++Image resized.
++
++read 65536/65536 bytes at offset 5368709120
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++1 GiB (0x40000000) bytes not allocated at offset 0 bytes (0x0)
++7 GiB (0x1c0000000) bytes     allocated at offset 1 GiB (0x40000000)
++
++[{ "start": 0, "length": 1073741824, "depth": 1, "zero": true, "data": false},
++{ "start": 1073741824, "length": 7516192768, "depth": 0, "zero": true, "data": false}]
++
++=== preallocation=metadata ===
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=34359738368 cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=32212254720 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++wrote 65536/65536 bytes at offset 33285996544
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++Image resized.
++
++read 65536/65536 bytes at offset 33285996544
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++30 GiB (0x780000000) bytes not allocated at offset 0 bytes (0x0)
++3 GiB (0xc0000000) bytes     allocated at offset 30 GiB (0x780000000)
++
++[{ "start": 0, "length": 32212254720, "depth": 1, "zero": true, "data": false},
++{ "start": 32212254720, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 327680},
++{ "start": 32749125632, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 537264128},
++{ "start": 33285996544, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1074200576},
++{ "start": 33822867456, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1611137024},
++{ "start": 34359738368, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2148139008},
++{ "start": 34896609280, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2685075456}]
++
++=== preallocation=falloc ===
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=10485760 cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=5242880 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++wrote 65536/65536 bytes at offset 9437184
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++Image resized.
++
++read 65536/65536 bytes at offset 9437184
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++5 MiB (0x500000) bytes not allocated at offset 0 bytes (0x0)
++10 MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
++
++[{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
++{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
++
++=== preallocation=full ===
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=8388608 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++wrote 65536/65536 bytes at offset 11534336
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++Image resized.
++
++read 65536/65536 bytes at offset 11534336
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++8 MiB (0x800000) bytes not allocated at offset 0 bytes (0x0)
++4 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
++
++[{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
++{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
++
++=== preallocation=off ===
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=259072 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++wrote 65536/65536 bytes at offset 259072
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++Image resized.
++
++read 65536/65536 bytes at offset 259072
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++192 KiB (0x30000) bytes not allocated at offset 0 bytes (0x0)
++320 KiB (0x50000) bytes     allocated at offset 192 KiB (0x30000)
++
++[{ "start": 0, "length": 196608, "depth": 1, "zero": true, "data": false},
++{ "start": 196608, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": 327680},
++{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
++
++=== preallocation=off ===
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=409600 cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++wrote 65536/65536 bytes at offset 344064
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++Image resized.
++
++read 65536/65536 bytes at offset 344064
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
++256 KiB (0x40000) bytes     allocated at offset 256 KiB (0x40000)
++
++[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
++{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
++
++=== preallocation=off ===
++Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=524288 cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
++
++wrote 65536/65536 bytes at offset 446464
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++Image resized.
++
++read 65536/65536 bytes at offset 446464
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++
++256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
++244 KiB (0x3d000) bytes     allocated at offset 256 KiB (0x40000)
++
++[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
++{ "start": 262144, "length": 249856, "depth": 0, "zero": true, "data": false}]
++
 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 backing quick
+rw
 backing quick
++274 rw backing
 rw quick
 rw backing quick
-+280 rw migration quick
+rw migration quick
 --
-.20.1
+.25.3

-[PULL 17/30] qcow2: Move error check of local_err near its assignment
+[PULL 12/15] qcow2: Forward ZERO_WRITE flag for full preallocation
-From: Tuguoyi <tu.guoyi@h3c.com>
+The BDRV_REQ_ZERO_WRITE is currently implemented in a way that first the
 image is possibly preallocated and then the zero flag is added to all
 clusters. This means that a copy-on-write operation may be needed when
 writing to these clusters, despite having used preallocation, negating
 one of the major benefits of preallocation.
-The local_err check outside of the if block was necessary
+Instead, try to forward the BDRV_REQ_ZERO_WRITE to the protocol driver,
-when it was introduced in commit d1258dd0c87 because it needed to be
+and if the protocol driver can ensure that the new area reads as zeros,
-executed even if qcow2_load_autoloading_dirty_bitmaps() returned false.
+we can skip setting the zero flag in the qcow2 layer.
-After some modifications that all required the error check to remain
+Unfortunately, the same approach doesn't work for metadata
-where it is, commit 9c98f145dfb finally moved the
+preallocation, so we'll still set the zero flag there.
 qcow2_load_dirty_bitmaps() call into the if block, so now the error
 check should be there, too.
-Signed-off-by: Guoyi Tu <tu.guoyi@h3c.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-Id: <20200424142701.67053-1-kwolf@redhat.com>
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2.c | 10 +++++-----
+ block/qcow2.c              | 22 +++++++++++++++++++---
-file changed, 5 insertions(+), 5 deletions(-)
+ tests/qemu-iotests/274.out |  4 ++--
 files changed, 21 insertions(+), 5 deletions(-)
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
-     if (!(bdrv_get_flags(bs) & BDRV_O_INACTIVE)) {
+         /* Allocate the data area */
-         /* It's case 1, 2 or 3.2. Or 3.1 which is BUG in management layer. */
+         new_file_size = allocation_start +
-         bool header_updated = qcow2_load_dirty_bitmaps(bs, &local_err);
+                         nb_new_data_clusters * s->cluster_size;
-+        if (local_err != NULL) {
+-        /* Image file grows, so @exact does not matter */
-+            error_propagate(errp, local_err);
+-        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
-+            ret = -EINVAL;
+-                               errp);
-+            goto fail;
++        /*
 +         * Image file grows, so @exact does not matter.
 +         *
 +         * If we need to zero out the new area, try first whether the protocol
 +         * driver can already take care of this.
 +         */
 +        if (flags & BDRV_REQ_ZERO_WRITE) {
 +            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc,
 +                                   BDRV_REQ_ZERO_WRITE, NULL);
 +            if (ret >= 0) {
 +                flags &= ~BDRV_REQ_ZERO_WRITE;
 +            }
 +        } else {
 +            ret = -1;
 +        }
++        if (ret < 0) {
-         update_header = update_header && !header_updated;
++            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
-     }
++                                   errp);
--    if (local_err != NULL) {
++        }
--        error_propagate(errp, local_err);
+         if (ret < 0) {
--        ret = -EINVAL;
+             error_prepend(errp, "Failed to resize underlying file: ");
--        goto fail;
+             qcow2_free_clusters(bs, allocation_start,
--    }
+diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
+index XXXXXXX..XXXXXXX 100644
-     if (update_header) {
+--- a/tests/qemu-iotests/274.out
-         ret = qcow2_update_header(bs);
++++ b/tests/qemu-iotests/274.out
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 9437184
 MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
  [{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
 -{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
 +{ "start": 5242880, "length": 10485760, "depth": 0, "zero": false, "data": true, "offset": 327680}]
  === preallocation=full ===
  Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 11534336
 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
  [{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
 -{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
 +{ "start": 8388608, "length": 4194304, "depth": 0, "zero": false, "data": true, "offset": 327680}]
  === preallocation=off ===
  Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 --
-.20.1
+.25.3

-[PULL 28/30] block: Activate recursively even for already active nodes
+[PULL 13/15] nvme: introduce PMR support from NVMe 1.4 spec
-bdrv_invalidate_cache_all() assumes that all nodes in a given subtree
+From: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>
 are either active or inactive when it starts. Therefore, as soon as it
 arrives at an already active node, it stops.
-However, this assumption is wrong. For example, it's possible to take a
+This patch introduces support for PMR that has been defined as part of NVMe 1.4
-snapshot of an inactive node, which results in an active overlay over an
+spec. User can now specify a pmrdev option that should point to HostMemoryBackend.
-inactive backing file. The active overlay is probably also the root node
+pmrdev memory region will subsequently be exposed as PCI BAR 2 in emulated NVMe
-of an inactive BlockBackend (blk->disable_perm == true).
+device. Guest OS can perform mmio read and writes to the PMR region that will stay
 persistent across system reboot.
-In this case, bdrv_invalidate_cache_all() does not need to do anything
+Signed-off-by: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>
-to activate the overlay node, but it still needs to recurse into the
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
-children and the parents to make sure that after returning success,
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-really everything is activated.
+Message-Id: <20200330164656.9348-1-andrzej.jakowski@linux.intel.com>
 Reviewed-by: Keith Busch <kbusch@kernel.org>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
  hw/block/nvme.h        |   2 +
  include/block/nvme.h   | 172 +++++++++++++++++++++++++++++++++++++++++
  hw/block/nvme.c        | 109 ++++++++++++++++++++++++++
  hw/block/Makefile.objs |   2 +-
  hw/block/trace-events  |   4 +
 files changed, 288 insertions(+), 1 deletion(-)
-Cc: qemu-stable@nongnu.org
+diff --git a/hw/block/nvme.h b/hw/block/nvme.h
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
  block.c | 50 ++++++++++++++++++++++++--------------------------
 file changed, 24 insertions(+), 26 deletions(-)
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/hw/block/nvme.h
-+++ b/block.c
++++ b/hw/block/nvme.h
-@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ typedef struct NvmeCtrl {
      uint64_t    timestamp_set_qemu_clock_ms;    /* QEMU clock time */
      char            *serial;
 +    HostMemoryBackend *pmrdev;
 +
      NvmeNamespace   *namespaces;
      NvmeSQueue      **sq;
      NvmeCQueue      **cq;
 diff --git a/include/block/nvme.h b/include/block/nvme.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/nvme.h
 +++ b/include/block/nvme.h
@@ -XXX,XX +XXX,XX @@ typedef struct NvmeBar {
      uint64_t    acq;
      uint32_t    cmbloc;
      uint32_t    cmbsz;
 +    uint8_t     padding[3520]; /* not used by QEMU */
 +    uint32_t    pmrcap;
 +    uint32_t    pmrctl;
 +    uint32_t    pmrsts;
 +    uint32_t    pmrebs;
 +    uint32_t    pmrswtp;
 +    uint32_t    pmrmsc;
  } NvmeBar;
  enum NvmeCapShift {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapShift {
      CAP_CSS_SHIFT      = 37,
      CAP_MPSMIN_SHIFT   = 48,
      CAP_MPSMAX_SHIFT   = 52,
 +    CAP_PMR_SHIFT      = 56,
  };
  enum NvmeCapMask {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
      CAP_CSS_MASK       = 0xff,
      CAP_MPSMIN_MASK    = 0xf,
      CAP_MPSMAX_MASK    = 0xf,
 +    CAP_PMR_MASK       = 0x1,
  };
  #define NVME_CAP_MQES(cap)  (((cap) >> CAP_MQES_SHIFT)   & CAP_MQES_MASK)
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
                                                             << CAP_MPSMIN_SHIFT)
  #define NVME_CAP_SET_MPSMAX(cap, val) (cap |= (uint64_t)(val & CAP_MPSMAX_MASK)\
                                                              << CAP_MPSMAX_SHIFT)
 +#define NVME_CAP_SET_PMRS(cap, val) (cap |= (uint64_t)(val & CAP_PMR_MASK)\
 +                                                            << CAP_PMR_SHIFT)
  enum NvmeCcShift {
      CC_EN_SHIFT     = 0,
@@ -XXX,XX +XXX,XX @@ enum NvmeCmbszMask {
  #define NVME_CMBSZ_GETSIZE(cmbsz) \
      (NVME_CMBSZ_SZ(cmbsz) * (1 << (12 + 4 * NVME_CMBSZ_SZU(cmbsz))))
 +enum NvmePmrcapShift {
 +    PMRCAP_RDS_SHIFT      = 3,
 +    PMRCAP_WDS_SHIFT      = 4,
 +    PMRCAP_BIR_SHIFT      = 5,
 +    PMRCAP_PMRTU_SHIFT    = 8,
 +    PMRCAP_PMRWBM_SHIFT   = 10,
 +    PMRCAP_PMRTO_SHIFT    = 16,
 +    PMRCAP_CMSS_SHIFT     = 24,
 +};
 +
 +enum NvmePmrcapMask {
 +    PMRCAP_RDS_MASK      = 0x1,
 +    PMRCAP_WDS_MASK      = 0x1,
 +    PMRCAP_BIR_MASK      = 0x7,
 +    PMRCAP_PMRTU_MASK    = 0x3,
 +    PMRCAP_PMRWBM_MASK   = 0xf,
 +    PMRCAP_PMRTO_MASK    = 0xff,
 +    PMRCAP_CMSS_MASK     = 0x1,
 +};
 +
 +#define NVME_PMRCAP_RDS(pmrcap)    \
 +    ((pmrcap >> PMRCAP_RDS_SHIFT)   & PMRCAP_RDS_MASK)
 +#define NVME_PMRCAP_WDS(pmrcap)    \
 +    ((pmrcap >> PMRCAP_WDS_SHIFT)   & PMRCAP_WDS_MASK)
 +#define NVME_PMRCAP_BIR(pmrcap)    \
 +    ((pmrcap >> PMRCAP_BIR_SHIFT)   & PMRCAP_BIR_MASK)
 +#define NVME_PMRCAP_PMRTU(pmrcap)    \
 +    ((pmrcap >> PMRCAP_PMRTU_SHIFT)   & PMRCAP_PMRTU_MASK)
 +#define NVME_PMRCAP_PMRWBM(pmrcap)    \
 +    ((pmrcap >> PMRCAP_PMRWBM_SHIFT)   & PMRCAP_PMRWBM_MASK)
 +#define NVME_PMRCAP_PMRTO(pmrcap)    \
 +    ((pmrcap >> PMRCAP_PMRTO_SHIFT)   & PMRCAP_PMRTO_MASK)
 +#define NVME_PMRCAP_CMSS(pmrcap)    \
 +    ((pmrcap >> PMRCAP_CMSS_SHIFT)   & PMRCAP_CMSS_MASK)
 +
 +#define NVME_PMRCAP_SET_RDS(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_RDS_MASK) << PMRCAP_RDS_SHIFT)
 +#define NVME_PMRCAP_SET_WDS(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_WDS_MASK) << PMRCAP_WDS_SHIFT)
 +#define NVME_PMRCAP_SET_BIR(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_BIR_MASK) << PMRCAP_BIR_SHIFT)
 +#define NVME_PMRCAP_SET_PMRTU(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTU_MASK) << PMRCAP_PMRTU_SHIFT)
 +#define NVME_PMRCAP_SET_PMRWBM(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_PMRWBM_MASK) << PMRCAP_PMRWBM_SHIFT)
 +#define NVME_PMRCAP_SET_PMRTO(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTO_MASK) << PMRCAP_PMRTO_SHIFT)
 +#define NVME_PMRCAP_SET_CMSS(pmrcap, val)   \
 +    (pmrcap |= (uint64_t)(val & PMRCAP_CMSS_MASK) << PMRCAP_CMSS_SHIFT)
 +
 +enum NvmePmrctlShift {
 +    PMRCTL_EN_SHIFT   = 0,
 +};
 +
 +enum NvmePmrctlMask {
 +    PMRCTL_EN_MASK   = 0x1,
 +};
 +
 +#define NVME_PMRCTL_EN(pmrctl)  ((pmrctl >> PMRCTL_EN_SHIFT)   & PMRCTL_EN_MASK)
 +
 +#define NVME_PMRCTL_SET_EN(pmrctl, val)   \
 +    (pmrctl |= (uint64_t)(val & PMRCTL_EN_MASK) << PMRCTL_EN_SHIFT)
 +
 +enum NvmePmrstsShift {
 +    PMRSTS_ERR_SHIFT    = 0,
 +    PMRSTS_NRDY_SHIFT   = 8,
 +    PMRSTS_HSTS_SHIFT   = 9,
 +    PMRSTS_CBAI_SHIFT   = 12,
 +};
 +
 +enum NvmePmrstsMask {
 +    PMRSTS_ERR_MASK    = 0xff,
 +    PMRSTS_NRDY_MASK   = 0x1,
 +    PMRSTS_HSTS_MASK   = 0x7,
 +    PMRSTS_CBAI_MASK   = 0x1,
 +};
 +
 +#define NVME_PMRSTS_ERR(pmrsts)     \
 +    ((pmrsts >> PMRSTS_ERR_SHIFT)   & PMRSTS_ERR_MASK)
 +#define NVME_PMRSTS_NRDY(pmrsts)    \
 +    ((pmrsts >> PMRSTS_NRDY_SHIFT)   & PMRSTS_NRDY_MASK)
 +#define NVME_PMRSTS_HSTS(pmrsts)    \
 +    ((pmrsts >> PMRSTS_HSTS_SHIFT)   & PMRSTS_HSTS_MASK)
 +#define NVME_PMRSTS_CBAI(pmrsts)    \
 +    ((pmrsts >> PMRSTS_CBAI_SHIFT)   & PMRSTS_CBAI_MASK)
 +
 +#define NVME_PMRSTS_SET_ERR(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_ERR_MASK) << PMRSTS_ERR_SHIFT)
 +#define NVME_PMRSTS_SET_NRDY(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_NRDY_MASK) << PMRSTS_NRDY_SHIFT)
 +#define NVME_PMRSTS_SET_HSTS(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_HSTS_MASK) << PMRSTS_HSTS_SHIFT)
 +#define NVME_PMRSTS_SET_CBAI(pmrsts, val)   \
 +    (pmrsts |= (uint64_t)(val & PMRSTS_CBAI_MASK) << PMRSTS_CBAI_SHIFT)
 +
 +enum NvmePmrebsShift {
 +    PMREBS_PMRSZU_SHIFT   = 0,
 +    PMREBS_RBB_SHIFT      = 4,
 +    PMREBS_PMRWBZ_SHIFT   = 8,
 +};
 +
 +enum NvmePmrebsMask {
 +    PMREBS_PMRSZU_MASK   = 0xf,
 +    PMREBS_RBB_MASK      = 0x1,
 +    PMREBS_PMRWBZ_MASK   = 0xffffff,
 +};
 +
 +#define NVME_PMREBS_PMRSZU(pmrebs)  \
 +    ((pmrebs >> PMREBS_PMRSZU_SHIFT)   & PMREBS_PMRSZU_MASK)
 +#define NVME_PMREBS_RBB(pmrebs)     \
 +    ((pmrebs >> PMREBS_RBB_SHIFT)   & PMREBS_RBB_MASK)
 +#define NVME_PMREBS_PMRWBZ(pmrebs)  \
 +    ((pmrebs >> PMREBS_PMRWBZ_SHIFT)   & PMREBS_PMRWBZ_MASK)
 +
 +#define NVME_PMREBS_SET_PMRSZU(pmrebs, val)   \
 +    (pmrebs |= (uint64_t)(val & PMREBS_PMRSZU_MASK) << PMREBS_PMRSZU_SHIFT)
 +#define NVME_PMREBS_SET_RBB(pmrebs, val)   \
 +    (pmrebs |= (uint64_t)(val & PMREBS_RBB_MASK) << PMREBS_RBB_SHIFT)
 +#define NVME_PMREBS_SET_PMRWBZ(pmrebs, val)   \
 +    (pmrebs |= (uint64_t)(val & PMREBS_PMRWBZ_MASK) << PMREBS_PMRWBZ_SHIFT)
 +
 +enum NvmePmrswtpShift {
 +    PMRSWTP_PMRSWTU_SHIFT   = 0,
 +    PMRSWTP_PMRSWTV_SHIFT   = 8,
 +};
 +
 +enum NvmePmrswtpMask {
 +    PMRSWTP_PMRSWTU_MASK   = 0xf,
 +    PMRSWTP_PMRSWTV_MASK   = 0xffffff,
 +};
 +
 +#define NVME_PMRSWTP_PMRSWTU(pmrswtp)   \
 +    ((pmrswtp >> PMRSWTP_PMRSWTU_SHIFT)   & PMRSWTP_PMRSWTU_MASK)
 +#define NVME_PMRSWTP_PMRSWTV(pmrswtp)   \
 +    ((pmrswtp >> PMRSWTP_PMRSWTV_SHIFT)   & PMRSWTP_PMRSWTV_MASK)
 +
 +#define NVME_PMRSWTP_SET_PMRSWTU(pmrswtp, val)   \
 +    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTU_MASK) << PMRSWTP_PMRSWTU_SHIFT)
 +#define NVME_PMRSWTP_SET_PMRSWTV(pmrswtp, val)   \
 +    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTV_MASK) << PMRSWTP_PMRSWTV_SHIFT)
 +
 +enum NvmePmrmscShift {
 +    PMRMSC_CMSE_SHIFT   = 1,
 +    PMRMSC_CBA_SHIFT    = 12,
 +};
 +
 +enum NvmePmrmscMask {
 +    PMRMSC_CMSE_MASK   = 0x1,
 +    PMRMSC_CBA_MASK    = 0xfffffffffffff,
 +};
 +
 +#define NVME_PMRMSC_CMSE(pmrmsc)    \
 +    ((pmrmsc >> PMRMSC_CMSE_SHIFT)   & PMRMSC_CMSE_MASK)
 +#define NVME_PMRMSC_CBA(pmrmsc)     \
 +    ((pmrmsc >> PMRMSC_CBA_SHIFT)   & PMRMSC_CBA_MASK)
 +
 +#define NVME_PMRMSC_SET_CMSE(pmrmsc, val)   \
 +    (pmrmsc |= (uint64_t)(val & PMRMSC_CMSE_MASK) << PMRMSC_CMSE_SHIFT)
 +#define NVME_PMRMSC_SET_CBA(pmrmsc, val)   \
 +    (pmrmsc |= (uint64_t)(val & PMRMSC_CBA_MASK) << PMRMSC_CBA_SHIFT)
 +
  typedef struct NvmeCmd {
      uint8_t     opcode;
      uint8_t     fuse;
 diff --git a/hw/block/nvme.c b/hw/block/nvme.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/nvme.c
 +++ b/hw/block/nvme.c
@@ -XXX,XX +XXX,XX @@
   *      -drive file=<file>,if=none,id=<drive_id>
   *      -device nvme,drive=<drive_id>,serial=<serial>,id=<id[optional]>, \
   *              cmb_size_mb=<cmb_size_mb[optional]>, \
 + *              [pmrdev=<mem_backend_file_id>,] \
   *              num_queues=<N[optional]>
   *
   * Note cmb_size_mb denotes size of CMB in MB. CMB is assumed to be at
   * offset 0 in BAR2 and supports only WDS, RDS and SQS for now.
 + *
 + * cmb_size_mb= and pmrdev= options are mutually exclusive due to limitation
 + * in available BAR's. cmb_size_mb= will take precedence over pmrdev= when
 + * both provided.
 + * Enabling pmr emulation can be achieved by pointing to memory-backend-file.
 + * For example:
 + * -object memory-backend-file,id=<mem_id>,share=on,mem-path=<file_path>, \
 + *  size=<size> .... -device nvme,...,pmrdev=<mem_id>
   */
  #include "qemu/osdep.h"
@@ -XXX,XX +XXX,XX @@
  #include "sysemu/sysemu.h"
  #include "qapi/error.h"
  #include "qapi/visitor.h"
 +#include "sysemu/hostmem.h"
  #include "sysemu/block-backend.h"
 +#include "exec/ram_addr.h"
  #include "qemu/log.h"
  #include "qemu/module.h"
@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
          NVME_GUEST_ERR(nvme_ub_mmiowr_cmbsz_readonly,
                         "invalid write to read only CMBSZ, ignored");
          return;
 +    case 0xE00: /* PMRCAP */
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrcap_readonly,
 +                       "invalid write to PMRCAP register, ignored");
 +        return;
 +    case 0xE04: /* TODO PMRCTL */
 +        break;
 +    case 0xE08: /* PMRSTS */
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrsts_readonly,
 +                       "invalid write to PMRSTS register, ignored");
 +        return;
 +    case 0xE0C: /* PMREBS */
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrebs_readonly,
 +                       "invalid write to PMREBS register, ignored");
 +        return;
 +    case 0xE10: /* PMRSWTP */
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrswtp_readonly,
 +                       "invalid write to PMRSWTP register, ignored");
 +        return;
 +    case 0xE14: /* TODO PMRMSC */
 +         break;
      default:
          NVME_GUEST_ERR(nvme_ub_mmiowr_invalid,
                         "invalid MMIO write,"
@@ -XXX,XX +XXX,XX @@ static uint64_t nvme_mmio_read(void *opaque, hwaddr addr, unsigned size)
      }
      if (addr < sizeof(n->bar)) {
 +        /*
 +         * When PMRWBM bit 1 is set then read from
 +         * from PMRSTS should ensure prior writes
 +         * made it to persistent media
 +         */
 +        if (addr == 0xE08 &&
 +            (NVME_PMRCAP_PMRWBM(n->bar.pmrcap) & 0x02)) {
 +            qemu_ram_writeback(n->pmrdev->mr.ram_block,
 +                               0, n->pmrdev->size);
 +        }
          memcpy(&val, ptr + addr, size);
      } else {
          NVME_GUEST_ERR(nvme_ub_mmiord_invalid_ofs,
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
          error_setg(errp, "serial property not set");
          return;
      }
++
--    if (!(bs->open_flags & BDRV_O_INACTIVE)) {
++    if (!n->cmb_size_mb && n->pmrdev) {
--        return;
++        if (host_memory_backend_is_mapped(n->pmrdev)) {
--    }
++            char *path = object_get_canonical_path_component(OBJECT(n->pmrdev));
--
++            error_setg(errp, "can't use already busy memdev: %s", path);
-     QLIST_FOREACH(child, &bs->children, next) {
++            g_free(path);
          bdrv_co_invalidate_cache(child->bs, &local_err);
          if (local_err) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
       * just keep the extended permissions for the next time that an activation
       * of the image is tried.
       */
 -    bs->open_flags &= ~BDRV_O_INACTIVE;
 -    bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
 -    ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, NULL, &local_err);
 -    if (ret < 0) {
 -        bs->open_flags |= BDRV_O_INACTIVE;
 -        error_propagate(errp, local_err);
 -        return;
 -    }
 -    bdrv_set_perm(bs, perm, shared_perm);
 -
 -    if (bs->drv->bdrv_co_invalidate_cache) {
 -        bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
 -        if (local_err) {
 +    if (bs->open_flags & BDRV_O_INACTIVE) {
 +        bs->open_flags &= ~BDRV_O_INACTIVE;
 +        bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
 +        ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, NULL, &local_err);
 +        if (ret < 0) {
              bs->open_flags |= BDRV_O_INACTIVE;
              error_propagate(errp, local_err);
              return;
          }
 -    }
 +        bdrv_set_perm(bs, perm, shared_perm);
 -    FOR_EACH_DIRTY_BITMAP(bs, bm) {
 -        bdrv_dirty_bitmap_skip_store(bm, false);
 -    }
 +        if (bs->drv->bdrv_co_invalidate_cache) {
 +            bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
 +            if (local_err) {
 +                bs->open_flags |= BDRV_O_INACTIVE;
 +                error_propagate(errp, local_err);
 +                return;
 +            }
 +        }
 -    ret = refresh_total_sectors(bs, bs->total_sectors);
 -    if (ret < 0) {
 -        bs->open_flags |= BDRV_O_INACTIVE;
 -        error_setg_errno(errp, -ret, "Could not refresh total sector count");
 -        return;
 +        FOR_EACH_DIRTY_BITMAP(bs, bm) {
 +            bdrv_dirty_bitmap_skip_store(bm, false);
 +        }
 +
 +        ret = refresh_total_sectors(bs, bs->total_sectors);
 +        if (ret < 0) {
 +            bs->open_flags |= BDRV_O_INACTIVE;
 +            error_setg_errno(errp, -ret, "Could not refresh total sector count");
 +            return;
 +        }
++
++        if (!is_power_of_2(n->pmrdev->size)) {
++            error_setg(errp, "pmr backend size needs to be power of 2 in size");
++            return;
++        }
++
++        host_memory_backend_set_mapped(n->pmrdev, true);
++    }
++
+     blkconf_blocksizes(&n->conf);
+     if (!blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk),
+                                        false, errp)) {
+@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
+             PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
+             PCI_BASE_ADDRESS_MEM_PREFETCH, &n->ctrl_mem);
++    } else if (n->pmrdev) {
++        /* Controller Capabilities register */
++        NVME_CAP_SET_PMRS(n->bar.cap, 1);
++
++        /* PMR Capabities register */
++        n->bar.pmrcap = 0;
++        NVME_PMRCAP_SET_RDS(n->bar.pmrcap, 0);
++        NVME_PMRCAP_SET_WDS(n->bar.pmrcap, 0);
++        NVME_PMRCAP_SET_BIR(n->bar.pmrcap, 2);
++        NVME_PMRCAP_SET_PMRTU(n->bar.pmrcap, 0);
++        /* Turn on bit 1 support */
++        NVME_PMRCAP_SET_PMRWBM(n->bar.pmrcap, 0x02);
++        NVME_PMRCAP_SET_PMRTO(n->bar.pmrcap, 0);
++        NVME_PMRCAP_SET_CMSS(n->bar.pmrcap, 0);
++
++        /* PMR Control register */
++        n->bar.pmrctl = 0;
++        NVME_PMRCTL_SET_EN(n->bar.pmrctl, 0);
++
++        /* PMR Status register */
++        n->bar.pmrsts = 0;
++        NVME_PMRSTS_SET_ERR(n->bar.pmrsts, 0);
++        NVME_PMRSTS_SET_NRDY(n->bar.pmrsts, 0);
++        NVME_PMRSTS_SET_HSTS(n->bar.pmrsts, 0);
++        NVME_PMRSTS_SET_CBAI(n->bar.pmrsts, 0);
++
++        /* PMR Elasticity Buffer Size register */
++        n->bar.pmrebs = 0;
++        NVME_PMREBS_SET_PMRSZU(n->bar.pmrebs, 0);
++        NVME_PMREBS_SET_RBB(n->bar.pmrebs, 0);
++        NVME_PMREBS_SET_PMRWBZ(n->bar.pmrebs, 0);
++
++        /* PMR Sustained Write Throughput register */
++        n->bar.pmrswtp = 0;
++        NVME_PMRSWTP_SET_PMRSWTU(n->bar.pmrswtp, 0);
++        NVME_PMRSWTP_SET_PMRSWTV(n->bar.pmrswtp, 0);
++
++        /* PMR Memory Space Control register */
++        n->bar.pmrmsc = 0;
++        NVME_PMRMSC_SET_CMSE(n->bar.pmrmsc, 0);
++        NVME_PMRMSC_SET_CBA(n->bar.pmrmsc, 0);
++
++        pci_register_bar(pci_dev, NVME_PMRCAP_BIR(n->bar.pmrcap),
++            PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
++            PCI_BASE_ADDRESS_MEM_PREFETCH, &n->pmrdev->mr);
      }
-     QLIST_FOREACH(parent, &bs->parents, next_parent) {
+     for (i = 0; i < n->num_namespaces; i++) {
@@ -XXX,XX +XXX,XX @@ static void nvme_exit(PCIDevice *pci_dev)
      if (n->cmb_size_mb) {
          g_free(n->cmbuf);
      }
 +
 +    if (n->pmrdev) {
 +        host_memory_backend_set_mapped(n->pmrdev, false);
 +    }
      msix_uninit_exclusive_bar(pci_dev);
  }
  static Property nvme_props[] = {
      DEFINE_BLOCK_PROPERTIES(NvmeCtrl, conf),
 +    DEFINE_PROP_LINK("pmrdev", NvmeCtrl, pmrdev, TYPE_MEMORY_BACKEND,
 +                     HostMemoryBackend *),
      DEFINE_PROP_STRING("serial", NvmeCtrl, serial),
      DEFINE_PROP_UINT32("cmb_size_mb", NvmeCtrl, cmb_size_mb, 0),
      DEFINE_PROP_UINT32("num_queues", NvmeCtrl, num_queues, 64),
 diff --git a/hw/block/Makefile.objs b/hw/block/Makefile.objs
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/Makefile.objs
 +++ b/hw/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ common-obj-$(CONFIG_PFLASH_CFI02) += pflash_cfi02.o
  common-obj-$(CONFIG_XEN) += xen-block.o
  common-obj-$(CONFIG_ECC) += ecc.o
  common-obj-$(CONFIG_ONENAND) += onenand.o
 -common-obj-$(CONFIG_NVME_PCI) += nvme.o
  common-obj-$(CONFIG_SWIM) += swim.o
  common-obj-$(CONFIG_SH4) += tc58128.o
  obj-$(CONFIG_VIRTIO_BLK) += virtio-blk.o
  obj-$(CONFIG_VHOST_USER_BLK) += vhost-user-blk.o
 +obj-$(CONFIG_NVME_PCI) += nvme.o
  obj-y += dataplane/
 diff --git a/hw/block/trace-events b/hw/block/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/trace-events
 +++ b/hw/block/trace-events
@@ -XXX,XX +XXX,XX @@ nvme_ub_mmiowr_ssreset_w1c_unsupported(void) "attempted to W1C CSTS.NSSRO but CA
  nvme_ub_mmiowr_ssreset_unsupported(void) "attempted NVM subsystem reset but CAP.NSSRS is zero (not supported)"
  nvme_ub_mmiowr_cmbloc_reserved(void) "invalid write to reserved CMBLOC when CMBSZ is zero, ignored"
  nvme_ub_mmiowr_cmbsz_readonly(void) "invalid write to read only CMBSZ, ignored"
 +nvme_ub_mmiowr_pmrcap_readonly(void) "invalid write to read only PMRCAP, ignored"
 +nvme_ub_mmiowr_pmrsts_readonly(void) "invalid write to read only PMRSTS, ignored"
 +nvme_ub_mmiowr_pmrebs_readonly(void) "invalid write to read only PMREBS, ignored"
 +nvme_ub_mmiowr_pmrswtp_readonly(void) "invalid write to read only PMRSWTP, ignored"
  nvme_ub_mmiowr_invalid(uint64_t offset, uint64_t data) "invalid MMIO write, offset=0x%"PRIx64", data=0x%"PRIx64""
  nvme_ub_mmiord_misaligned32(uint64_t offset) "MMIO read not 32-bit aligned, offset=0x%"PRIx64""
  nvme_ub_mmiord_toosmall(uint64_t offset) "MMIO read smaller than 32-bits, offset=0x%"PRIx64""
 --
-.20.1
+.25.3

-[PULL 26/30] iotests: 207: Remove duplication with VM.blockdev_create()
+[PULL 14/15] qom: Factor out user_creatable_add_dict()
-The blockdev_create() function in this test case adds another filter to
+The QMP handler qmp_object_add() and the implementation of --object in
-the logging, but provides otherwise the same functionality as
+qemu-storage-daemon can share most of the code. Currently,
-VM.blockdev_create() from iotests.py. Make it a thin wrapper around the
+qemu-storage-daemon calls qmp_object_add(), but this is not correct
-iotests.py function.
+because different visitors need to be used.
 As a first step towards a fix, make qmp_object_add() a wrapper around a
 new function user_creatable_add_dict() that can get an additional
 parameter. The handling of "props" is only required for compatibility
 and not required for the qemu-storage-daemon command line, so it stays
 in qmp_object_add().
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/207 | 8 +-------
+ include/qom/object_interfaces.h | 12 ++++++++++++
-file changed, 1 insertion(+), 7 deletions(-)
+ qom/object_interfaces.c         | 27 +++++++++++++++++++++++++++
  qom/qom-qmp-cmds.c              | 24 +-----------------------
 files changed, 40 insertions(+), 23 deletions(-)
-diff --git a/tests/qemu-iotests/207 b/tests/qemu-iotests/207
+diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/207
+--- a/include/qom/object_interfaces.h
-+++ b/tests/qemu-iotests/207
++++ b/include/qom/object_interfaces.h
-@@ -XXX,XX +XXX,XX @@ def filter_hash(qmsg):
+@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
-     return iotests.filter_qmp(qmsg, _filter)
+                                 const QDict *qdict,
+                                 Visitor *v, Error **errp);
- def blockdev_create(vm, options):
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
++/**
--                        filters=[iotests.filter_qmp_testfiles, filter_hash])
++ * user_creatable_add_dict:
 + * @qdict: the object definition
 + * @errp: if an error occurs, a pointer to an area to store the error
 + *
 + * Create an instance of the user creatable object that is defined by
 + * @qdict.  The object type is taken from the QDict key 'qom-type', its
 + * ID from the key 'id'. The remaining entries in @qdict are used to
 + * initialize the object properties.
 + */
 +void user_creatable_add_dict(QDict *qdict, Error **errp);
 +
  /**
   * user_creatable_add_opts:
   * @opts: the object definition
 diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qom/object_interfaces.c
 +++ b/qom/object_interfaces.c
@@ -XXX,XX +XXX,XX @@
  #include "qapi/qmp/qerror.h"
  #include "qapi/qmp/qjson.h"
  #include "qapi/qmp/qstring.h"
 +#include "qapi/qobject-input-visitor.h"
  #include "qom/object_interfaces.h"
  #include "qemu/help_option.h"
  #include "qemu/module.h"
@@ -XXX,XX +XXX,XX @@ out:
      return obj;
  }
 +void user_creatable_add_dict(QDict *qdict, Error **errp)
 +{
 +    Visitor *v;
 +    Object *obj;
 +    g_autofree char *type = NULL;
 +    g_autofree char *id = NULL;
 +
 +    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
 +    if (!type) {
 +        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
 +        return;
 +    }
 +    qdict_del(qdict, "qom-type");
 +
 +    id = g_strdup(qdict_get_try_str(qdict, "id"));
 +    if (!id) {
 +        error_setg(errp, QERR_MISSING_PARAMETER, "id");
 +        return;
 +    }
 +    qdict_del(qdict, "id");
 +
 +    v = qobject_input_visitor_new(QOBJECT(qdict));
 +    obj = user_creatable_add_type(type, id, qdict, v, errp);
 +    visit_free(v);
 +    object_unref(obj);
 +}
  Object *user_creatable_add_opts(QemuOpts *opts, Error **errp)
  {
 diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qom/qom-qmp-cmds.c
 +++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@
  #include "qapi/qapi-commands-qom.h"
  #include "qapi/qmp/qdict.h"
  #include "qapi/qmp/qerror.h"
 -#include "qapi/qobject-input-visitor.h"
  #include "qemu/cutils.h"
  #include "qom/object_interfaces.h"
  #include "qom/qom-qobject.h"
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
  {
      QObject *props;
      QDict *pdict;
 -    Visitor *v;
 -    Object *obj;
 -    g_autofree char *type = NULL;
 -    g_autofree char *id = NULL;
 -
--    if 'return' in result:
+-    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
--        assert result['return'] == {}
+-    if (!type) {
--        vm.run_job('job0')
+-        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
--    iotests.log("")
+-        return;
-+    vm.blockdev_create(options, filters=[iotests.filter_qmp_testfiles, filter_hash])
+-    }
+-    qdict_del(qdict, "qom-type");
- with iotests.FilePath('t.img') as disk_path, \
+-
-      iotests.VM() as vm:
+-    id = g_strdup(qdict_get_try_str(qdict, "id"));
 -    if (!id) {
 -        error_setg(errp, QERR_MISSING_PARAMETER, "id");
 -        return;
 -    }
 -    qdict_del(qdict, "id");
      props = qdict_get(qdict, "props");
      if (props) {
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
          qobject_unref(pdict);
      }
 -    v = qobject_input_visitor_new(QOBJECT(qdict));
 -    obj = user_creatable_add_type(type, id, qdict, v, errp);
 -    visit_free(v);
 -    object_unref(obj);
 +    user_creatable_add_dict(qdict, errp);
  }
  void qmp_object_del(const char *id, Error **errp)
 --
-.20.1
+.25.3

-[PULL 01/30] iotests: Provide a function for checking the creation of huge files
+[PULL 15/15] qemu-storage-daemon: Fix non-string --object properties
-From: Thomas Huth <thuth@redhat.com>
+After processing the option string with the keyval parser, we get a
 QDict that contains only strings. This QDict must be fed to a keyval
 visitor which converts the strings into the right data types.
-Some tests create huge (but sparse) files, and to be able to run those
+qmp_object_add(), however, uses the normal QObject input visitor, which
-tests in certain limited environments (like CI containers), we have to
+expects a QDict where all properties already have the QType that matches
-check for the possibility to create such files first. Thus let's introduce
+the data type required by the QOM object type.
 a common function to check for large files, and replace the already
 existing checks in the iotests 005 and 220 with this function.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
+Change the --object implementation in qemu-storage-daemon so that it
-Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
+doesn't call qmp_object_add(), but calls user_creatable_add_dict()
 directly instead and pass it a new keyval boolean that decides which
 visitor must be used.
 Reported-by: Coiby Xu <coiby.xu@gmail.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/005       |  5 +----
+ include/qom/object_interfaces.h | 6 +++++-
- tests/qemu-iotests/220       |  6 ++----
+ qemu-storage-daemon.c           | 4 +---
- tests/qemu-iotests/common.rc | 10 ++++++++++
+ qom/object_interfaces.c         | 8 ++++++--
-files changed, 13 insertions(+), 8 deletions(-)
+ qom/qom-qmp-cmds.c              | 2 +-
 files changed, 13 insertions(+), 7 deletions(-)
-diff --git a/tests/qemu-iotests/005 b/tests/qemu-iotests/005
+diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/005
 +++ b/tests/qemu-iotests/005
@@ -XXX,XX +XXX,XX @@ fi
  # Sanity check: For raw, we require a file system that permits the creation
  # of a HUGE (but very sparse) file. Check we can create it before continuing.
  if [ "$IMGFMT" = "raw" ]; then
 -    if ! truncate --size=5T "$TEST_IMG"; then
 -        _notrun "file system on $TEST_DIR does not support large enough files"
 -    fi
 -    rm "$TEST_IMG"
 +    _require_large_file 5T
  fi
  echo
 diff --git a/tests/qemu-iotests/220 b/tests/qemu-iotests/220
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/220
 +++ b/tests/qemu-iotests/220
@@ -XXX,XX +XXX,XX @@ echo "== Creating huge file =="
  # Sanity check: We require a file system that permits the creation
  # of a HUGE (but very sparse) file.  tmpfs works, ext4 does not.
 -if ! truncate --size=513T "$TEST_IMG"; then
 -    _notrun "file system on $TEST_DIR does not support large enough files"
 -fi
 -rm "$TEST_IMG"
 +_require_large_file 513T
 +
  IMGOPTS='cluster_size=2M,refcount_bits=1' _make_test_img 513T
  echo "== Populating refcounts =="
 diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.rc
+--- a/include/qom/object_interfaces.h
-+++ b/tests/qemu-iotests/common.rc
++++ b/include/qom/object_interfaces.h
-@@ -XXX,XX +XXX,XX @@ _require_drivers()
+@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
-     done
+ /**
   * user_creatable_add_dict:
   * @qdict: the object definition
 + * @keyval: if true, use a keyval visitor for processing @qdict (i.e.
 + *          assume that all @qdict values are strings); otherwise, use
 + *          the normal QObject visitor (i.e. assume all @qdict values
 + *          have the QType expected by the QOM object type)
   * @errp: if an error occurs, a pointer to an area to store the error
   *
   * Create an instance of the user creatable object that is defined by
@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
   * ID from the key 'id'. The remaining entries in @qdict are used to
   * initialize the object properties.
   */
 -void user_creatable_add_dict(QDict *qdict, Error **errp);
 +void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp);
  /**
   * user_creatable_add_opts:
 diff --git a/qemu-storage-daemon.c b/qemu-storage-daemon.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-storage-daemon.c
 +++ b/qemu-storage-daemon.c
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
                  QemuOpts *opts;
                  const char *type;
                  QDict *args;
 -                QObject *ret_data = NULL;
                  /* FIXME The keyval parser rejects 'help' arguments, so we must
                   * unconditionall try QemuOpts first. */
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
                  qemu_opts_del(opts);
                  args = keyval_parse(optarg, "qom-type", &error_fatal);
 -                qmp_object_add(args, &ret_data, &error_fatal);
 +                user_creatable_add_dict(args, true, &error_fatal);
                  qobject_unref(args);
 -                qobject_unref(ret_data);
                  break;
              }
          default:
 diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qom/object_interfaces.c
 +++ b/qom/object_interfaces.c
@@ -XXX,XX +XXX,XX @@ out:
      return obj;
  }
-+# Check that we have a file system that allows huge (but very sparse) files
+-void user_creatable_add_dict(QDict *qdict, Error **errp)
-+#
++void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp)
-+_require_large_file()
+ {
-+{
+     Visitor *v;
-+    if ! truncate --size="$1" "$TEST_IMG"; then
+     Object *obj;
-+        _notrun "file system on $TEST_DIR does not support large enough files"
+@@ -XXX,XX +XXX,XX @@ void user_creatable_add_dict(QDict *qdict, Error **errp)
-+    fi
+     }
-+    rm "$TEST_IMG"
+     qdict_del(qdict, "id");
-+}
-+
+-    v = qobject_input_visitor_new(QOBJECT(qdict));
- # make sure this script returns success
++    if (keyval) {
- true
++        v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 +    } else {
 +        v = qobject_input_visitor_new(QOBJECT(qdict));
 +    }
      obj = user_creatable_add_type(type, id, qdict, v, errp);
      visit_free(v);
      object_unref(obj);
 diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
 index XXXXXXX..XXXXXXX 100644
 --- a/qom/qom-qmp-cmds.c
 +++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
          qobject_unref(pdict);
      }
 -    user_creatable_add_dict(qdict, errp);
 +    user_creatable_add_dict(qdict, false, errp);
  }
  void qmp_object_del(const char *id, Error **errp)
 --
-.20.1
+.25.3

-[PULL 02/30] iotests: Skip test 060 if it is not possible to create large files
+Deleted patch
-From: Thomas Huth <thuth@redhat.com>
-Test 060 fails in the arm64, s390x and ppc64le LXD containers on Travis
-(which we will hopefully enable in our CI soon). These containers
-apparently do not allow large files to be created. The repair process
-in test 060 creates a file of 64 GiB, so test first whether such large
-files are possible and skip the test if that's not the case.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/060 | 3 +++
-file changed, 3 insertions(+)
-diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/060
-+++ b/tests/qemu-iotests/060
-@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow2
- _supported_proto file
- _supported_os Linux
-+# The repair process will create a large file - so check for availability first
-+_require_large_file 64G
-+
- rt_offset=65536  # 0x10000 (XXX: just an assumption)
- rb_offset=131072 # 0x20000 (XXX: just an assumption)
- l1_offset=196608 # 0x30000 (XXX: just an assumption)
---
-.20.1

-[PULL 03/30] iotests: Skip test 079 if it is not possible to create large files
+Deleted patch
-From: Thomas Huth <thuth@redhat.com>
-Test 079 fails in the arm64, s390x and ppc64le LXD containers on Travis
-(which we will hopefully enable in our CI soon). These containers
-apparently do not allow large files to be created. Test 079 tries to
-create a 4G sparse file, which is apparently already too big for these
-containers, so check first whether we can really create such files before
-executing the test.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/079 | 3 +++
-file changed, 3 insertions(+)
-diff --git a/tests/qemu-iotests/079 b/tests/qemu-iotests/079
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/079
-+++ b/tests/qemu-iotests/079
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow2
- _supported_proto file nfs
-+# Some containers (e.g. non-x86 on Travis) do not allow large files
-+_require_large_file 4G
-+
- echo "=== Check option preallocation and cluster_size ==="
- echo
- cluster_sizes="16384 32768 65536 131072 262144 524288 1048576 2097152 4194304"
---
-.20.1

-[PULL 10/30] iotests: Fix timeout in run_job()
+Deleted patch
-run_job() accepts a wait parameter for a timeout, but it doesn't
-actually use it. The only thing that is missing is passing it to
-events_wait(), so do that now.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/qemu-iotests/iotests.py | 2 +-
-file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
-+++ b/tests/qemu-iotests/iotests.py
-@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
-         ]
-         error = None
-         while True:
--            ev = filter_qmp_event(self.events_wait(events))
-+            ev = filter_qmp_event(self.events_wait(events, timeout=wait))
-             if ev['event'] != 'JOB_STATUS_CHANGE':
-                 if use_log:
-                     log(ev)
---
-.20.1

-[PULL 11/30] iotests: Support job-complete in run_job()
+Deleted patch
-Automatically complete jobs that have a 'ready' state and need an
-explicit job-complete. Without this, run_job() would hang for such
-jobs.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/qemu-iotests/iotests.py | 2 ++
-file changed, 2 insertions(+)
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
-+++ b/tests/qemu-iotests/iotests.py
-@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
-                         error = j['error']
-                         if use_log:
-                             log('Job failed: %s' % (j['error']))
-+            elif status == 'ready':
-+                self.qmp_log('job-complete', id=job)
-             elif status == 'pending' and not auto_finalize:
-                 if pre_finalize:
-                     pre_finalize()
---
-.20.1

-[PULL 13/30] MAINTAINERS: fix qcow2-bitmap.c under Dirty Bitmaps header
+Deleted patch
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Somehow I wrote not full path to the file. Fix that.
-Also, while being here, rearrange entries, so that includes go first,
-then block, than migration, than util.
-Fixes: 052db8e71444d
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- MAINTAINERS | 6 +++---
-file changed, 3 insertions(+), 3 deletions(-)
-diff --git a/MAINTAINERS b/MAINTAINERS
-index XXXXXXX..XXXXXXX 100644
---- a/MAINTAINERS
-+++ b/MAINTAINERS
-@@ -XXX,XX +XXX,XX @@ M: John Snow <jsnow@redhat.com>
- R: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
- L: qemu-block@nongnu.org
- S: Supported
--F: util/hbitmap.c
--F: block/dirty-bitmap.c
- F: include/qemu/hbitmap.h
- F: include/block/dirty-bitmap.h
--F: qcow2-bitmap.c
-+F: block/dirty-bitmap.c
-+F: block/qcow2-bitmap.c
- F: migration/block-dirty-bitmap.c
-+F: util/hbitmap.c
- F: tests/test-hbitmap.c
- F: docs/interop/bitmaps.rst
- T: git https://github.com/jnsnow/qemu.git bitmaps
---
-.20.1

-[PULL 14/30] iotests: Add more "_require_drivers" checks to the shell-based tests
+Deleted patch
-From: Thomas Huth <thuth@redhat.com>
-Test 051 should be skipped if nbd is not available, and 267 should
-be skipped if copy-on-read is not enabled.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/051 | 1 +
- tests/qemu-iotests/267 | 1 +
-files changed, 2 insertions(+)
-diff --git a/tests/qemu-iotests/051 b/tests/qemu-iotests/051
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/051
-+++ b/tests/qemu-iotests/051
-@@ -XXX,XX +XXX,XX @@ _supported_proto file
- # A compat=0.10 image is created in this test which does not support anything
- # other than refcount_bits=16
- _unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)'
-+_require_drivers nbd
- do_run_qemu()
- {
-diff --git a/tests/qemu-iotests/267 b/tests/qemu-iotests/267
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/267
-+++ b/tests/qemu-iotests/267
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow2
- _supported_proto file
- _supported_os Linux
-+_require_drivers copy-on-read
- # Internal snapshots are (currently) impossible with refcount_bits=1
- _unsupported_imgopts 'refcount_bits=1[^0-9]'
---
-.20.1

-[PULL 15/30] iotests/273: Filter format-specific information
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-Doing this allows running this test with e.g. -o compat=0.10 or
--o compat=refcount_bits=1.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/273     |  3 ++-
- tests/qemu-iotests/273.out | 27 ---------------------------
-files changed, 2 insertions(+), 28 deletions(-)
-diff --git a/tests/qemu-iotests/273 b/tests/qemu-iotests/273
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/273
-+++ b/tests/qemu-iotests/273
-@@ -XXX,XX +XXX,XX @@ do_run_qemu()
- run_qemu()
- {
-     do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qemu | _filter_qmp |
--        _filter_generated_node_ids | _filter_imgfmt | _filter_actual_image_size
-+        _filter_generated_node_ids | _filter_imgfmt |
-+        _filter_actual_image_size | _filter_img_info
- }
- TEST_IMG="$TEST_IMG.base" _make_test_img 64M
-diff --git a/tests/qemu-iotests/273.out b/tests/qemu-iotests/273.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/273.out
-+++ b/tests/qemu-iotests/273.out
-@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
-                     "cluster-size": 65536,
-                     "format": "IMGFMT",
-                     "actual-size": SIZE,
--                    "format-specific": {
--                        "type": "IMGFMT",
--                        "data": {
--                            "compat": "1.1",
--                            "lazy-refcounts": false,
--                            "refcount-bits": 16,
--                            "corrupt": false
--                        }
--                    },
-                     "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
-                     "backing-filename": "TEST_DIR/t.IMGFMT.base",
-                     "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
-                 "cluster-size": 65536,
-                 "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "IMGFMT",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
-                 "full-backing-filename": "TEST_DIR/t.IMGFMT.mid",
-                 "backing-filename": "TEST_DIR/t.IMGFMT.mid",
-                 "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
-                 "cluster-size": 65536,
-                 "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "IMGFMT",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
-                 "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
-                 "backing-filename": "TEST_DIR/t.IMGFMT.base",
-                 "dirty-flag": false
---
-.20.1

-[PULL 16/30] iotests: Fix IMGOPTSSYNTAX for nbd
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-There is no $SOCKDIR, only $SOCK_DIR.
-Fixes: f3923a72f199b2c63747a7032db74730546f55c6
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/common.rc | 3 ++-
-file changed, 2 insertions(+), 1 deletion(-)
-diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.rc
-+++ b/tests/qemu-iotests/common.rc
-@@ -XXX,XX +XXX,XX @@ if [ "$IMGOPTSSYNTAX" = "true" ]; then
-         TEST_IMG="$DRIVER,file.filename=$TEST_DIR/t.$IMGFMT"
-     elif [ "$IMGPROTO" = "nbd" ]; then
-         TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
--        TEST_IMG="$DRIVER,file.driver=nbd,file.type=unix,file.path=$SOCKDIR/nbd"
-+        TEST_IMG="$DRIVER,file.driver=nbd,file.type=unix"
-+        TEST_IMG="$TEST_IMG,file.path=$SOCK_DIR/nbd"
-     elif [ "$IMGPROTO" = "ssh" ]; then
-         TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
-         TEST_IMG="$DRIVER,file.driver=ssh,file.host=127.0.0.1,file.path=$TEST_IMG_FILE"
---
-.20.1

-[PULL 19/30] iotests: 255: Drop blockdev_create()
+Deleted patch
-blockdev_create() is completely unused in this test case, so we can just
-drop it.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/255 | 10 ----------
-file changed, 10 deletions(-)
-diff --git a/tests/qemu-iotests/255 b/tests/qemu-iotests/255
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/255
-+++ b/tests/qemu-iotests/255
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
- iotests.verify_image_format(supported_fmts=['qcow2'])
--def blockdev_create(vm, options):
--    result = vm.qmp_log('blockdev-create',
--                        filters=[iotests.filter_qmp_testfiles],
--                        job_id='job0', options=options)
--
--    if 'return' in result:
--        assert result['return'] == {}
--        vm.run_job('job0')
--    iotests.log("")
--
- iotests.log('Finishing a commit job with background reads')
- iotests.log('============================================')
- iotests.log('')
---
-.20.1

-[PULL 20/30] iotests: 206: Convert to VM.blockdev_create()
+Deleted patch
-Instead of having a separate blockdev_create() function, make use of the
-VM.blockdev_create() offered by iotests.py.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/206 | 232 ++++++++++++++++++++---------------------
-file changed, 111 insertions(+), 121 deletions(-)
-diff --git a/tests/qemu-iotests/206 b/tests/qemu-iotests/206
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/206
-+++ b/tests/qemu-iotests/206
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
- iotests.verify_image_format(supported_fmts=['qcow2'])
--def blockdev_create(vm, options):
--    result = vm.qmp_log('blockdev-create',
--                        filters=[iotests.filter_qmp_testfiles],
--                        job_id='job0', options=options)
--
--    if 'return' in result:
--        assert result['return'] == {}
--        vm.run_job('job0')
--    iotests.log("")
--
- with iotests.FilePath('t.qcow2') as disk_path, \
-      iotests.FilePath('t.qcow2.base') as backing_path, \
-      iotests.VM() as vm:
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
-     size = 128 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-     vm.qmp_log('blockdev-add',
-                filters=[iotests.filter_qmp_testfiles],
-                driver='file', filename=disk_path,
-                node_name='imgfile')
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'imgfile',
--                          'size': size })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'imgfile',
-+                         'size': size })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
-     size = 64 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0,
--                          'preallocation': 'off',
--                          'nocow': False })
--
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': {
--                              'driver': 'file',
--                              'filename': disk_path,
--                          },
--                          'size': size,
--                          'version': 'v3',
--                          'cluster-size': 65536,
--                          'preallocation': 'off',
--                          'lazy-refcounts': False,
--                          'refcount-bits': 16 })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0,
-+                         'preallocation': 'off',
-+                         'nocow': False })
-+
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': {
-+                             'driver': 'file',
-+                             'filename': disk_path,
-+                         },
-+                         'size': size,
-+                         'version': 'v3',
-+                         'cluster-size': 65536,
-+                         'preallocation': 'off',
-+                         'lazy-refcounts': False,
-+                         'refcount-bits': 16 })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
-     size = 32 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0,
--                          'preallocation': 'falloc',
--                          'nocow': True })
--
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': {
--                              'driver': 'file',
--                              'filename': disk_path,
--                          },
--                          'size': size,
--                          'version': 'v3',
--                          'cluster-size': 2097152,
--                          'preallocation': 'metadata',
--                          'lazy-refcounts': True,
--                          'refcount-bits': 1 })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0,
-+                         'preallocation': 'falloc',
-+                         'nocow': True })
-+
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': {
-+                             'driver': 'file',
-+                             'filename': disk_path,
-+                         },
-+                         'size': size,
-+                         'version': 'v3',
-+                         'cluster-size': 2097152,
-+                         'preallocation': 'metadata',
-+                         'lazy-refcounts': True,
-+                         'refcount-bits': 1 })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
-     iotests.log("")
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
--
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': {
--                              'driver': 'file',
--                              'filename': disk_path,
--                          },
--                          'size': size,
--                          'backing-file': backing_path,
--                          'backing-fmt': 'qcow2',
--                          'version': 'v2',
--                          'cluster-size': 512 })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-+
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': {
-+                             'driver': 'file',
-+                             'filename': disk_path,
-+                         },
-+                         'size': size,
-+                         'backing-file': backing_path,
-+                         'backing-fmt': 'qcow2',
-+                         'version': 'v2',
-+                         'cluster-size': 512 })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
-     iotests.log("")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': {
--                              'driver': 'file',
--                              'filename': disk_path,
--                          },
--                          'size': size,
--                          'encrypt': {
--                              'format': 'luks',
--                              'key-secret': 'keysec0',
--                              'cipher-alg': 'twofish-128',
--                              'cipher-mode': 'ctr',
--                              'ivgen-alg': 'plain64',
--                              'ivgen-hash-alg': 'md5',
--                              'hash-alg': 'sha1',
--                              'iter-time': 10,
--                          }})
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': {
-+                             'driver': 'file',
-+                             'filename': disk_path,
-+                         },
-+                         'size': size,
-+                         'encrypt': {
-+                             'format': 'luks',
-+                             'key-secret': 'keysec0',
-+                             'cipher-alg': 'twofish-128',
-+                             'cipher-mode': 'ctr',
-+                             'ivgen-alg': 'plain64',
-+                             'ivgen-hash-alg': 'md5',
-+                             'hash-alg': 'sha1',
-+                             'iter-time': 10,
-+                         }})
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
-     iotests.log("")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': "this doesn't exist",
--                          'size': size })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': "this doesn't exist",
-+                         'size': size })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
-     vm.launch()
-     for size in [ 1234, 18446744073709551104, 9223372036854775808,
-                   9223372036854775296 ]:
--        blockdev_create(vm, { 'driver': imgfmt,
--                              'file': 'node0',
--                              'size': size })
-+        vm.blockdev_create({ 'driver': imgfmt,
-+                             'file': 'node0',
-+                             'size': size })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
-     iotests.log("=== Invalid version ===")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 67108864,
--                          'version': 'v1' })
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 67108864,
--                          'version': 'v2',
--                          'lazy-refcounts': True })
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 67108864,
--                          'version': 'v2',
--                          'refcount-bits': 8 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 67108864,
-+                         'version': 'v1' })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 67108864,
-+                         'version': 'v2',
-+                         'lazy-refcounts': True })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 67108864,
-+                         'version': 'v2',
-+                         'refcount-bits': 8 })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
-     iotests.log("=== Invalid backing file options ===")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 67108864,
--                          'backing-file': '/dev/null',
--                          'preallocation': 'full' })
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 67108864,
--                          'backing-fmt': imgfmt })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 67108864,
-+                         'backing-file': '/dev/null',
-+                         'preallocation': 'full' })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 67108864,
-+                         'backing-fmt': imgfmt })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
-     vm.launch()
-     for csize in [ 1234, 128, 4194304, 0 ]:
--        blockdev_create(vm, { 'driver': imgfmt,
--                              'file': 'node0',
--                              'size': 67108864,
--                              'cluster-size': csize })
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 281474976710656,
--                          'cluster-size': 512 })
-+        vm.blockdev_create({ 'driver': imgfmt,
-+                             'file': 'node0',
-+                             'size': 67108864,
-+                             'cluster-size': csize })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 281474976710656,
-+                         'cluster-size': 512 })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
-     vm.launch()
-     for refcount_bits in [ 128, 0, 7 ]:
--        blockdev_create(vm, { 'driver': imgfmt,
--                              'file': 'node0',
--                              'size': 67108864,
--                              'refcount-bits': refcount_bits })
-+        vm.blockdev_create({ 'driver': imgfmt,
-+                             'file': 'node0',
-+                             'size': 67108864,
-+                             'refcount-bits': refcount_bits })
-     vm.shutdown()
---
-.20.1

-[PULL 21/30] iotests: 210: Convert to VM.blockdev_create()
+Deleted patch
-Instead of having a separate blockdev_create() function, make use of the
-VM.blockdev_create() offered by iotests.py.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/210 | 81 +++++++++++++++++++-----------------------
-file changed, 36 insertions(+), 45 deletions(-)
-diff --git a/tests/qemu-iotests/210 b/tests/qemu-iotests/210
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/210
-+++ b/tests/qemu-iotests/210
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
- iotests.verify_image_format(supported_fmts=['luks'])
- iotests.verify_protocol(supported=['file'])
--def blockdev_create(vm, options):
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
--                        filters=[iotests.filter_qmp_testfiles])
--
--    if 'return' in result:
--        assert result['return'] == {}
--        vm.run_job('job0')
--    iotests.log("")
--
- with iotests.FilePath('t.luks') as disk_path, \
-      iotests.VM() as vm:
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
-     size = 128 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-     vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
-                node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'imgfile',
--                          'key-secret': 'keysec0',
--                          'size': size,
--                          'iter-time': 10 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'imgfile',
-+                         'key-secret': 'keysec0',
-+                         'size': size,
-+                         'iter-time': 10 })
-     vm.shutdown()
-     # TODO Proper support for images to be used with imgopts and/or protocols
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
-     size = 64 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': {
--                              'driver': 'file',
--                              'filename': disk_path,
--                          },
--                          'size': size,
--                          'key-secret': 'keysec0',
--                          'cipher-alg': 'twofish-128',
--                          'cipher-mode': 'ctr',
--                          'ivgen-alg': 'plain64',
--                          'ivgen-hash-alg': 'md5',
--                          'hash-alg': 'sha1',
--                          'iter-time': 10 })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': {
-+                             'driver': 'file',
-+                             'filename': disk_path,
-+                         },
-+                         'size': size,
-+                         'key-secret': 'keysec0',
-+                         'cipher-alg': 'twofish-128',
-+                         'cipher-mode': 'ctr',
-+                         'ivgen-alg': 'plain64',
-+                         'ivgen-hash-alg': 'md5',
-+                         'hash-alg': 'sha1',
-+                         'iter-time': 10 })
-     vm.shutdown()
-     # TODO Proper support for images to be used with imgopts and/or protocols
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
-     size = 64 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': "this doesn't exist",
--                          'size': size })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': "this doesn't exist",
-+                         'size': size })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
-     vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'key-secret': 'keysec0',
--                          'size': 0,
--                          'iter-time': 10 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'key-secret': 'keysec0',
-+                         'size': 0,
-+                         'iter-time': 10 })
-     vm.shutdown()
-     # TODO Proper support for images to be used with imgopts and/or protocols
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
-     vm.launch()
-     for size in [ 18446744073709551104, 9223372036854775808, 9223372036854775296 ]:
--        blockdev_create(vm, { 'driver': imgfmt,
--                              'file': 'node0',
--                              'key-secret': 'keysec0',
--                              'size': size })
-+        vm.blockdev_create({ 'driver': imgfmt,
-+                             'file': 'node0',
-+                             'key-secret': 'keysec0',
-+                             'size': size })
-     vm.shutdown()
-     #
---
-.20.1

-[PULL 22/30] iotests: 212: Convert to VM.blockdev_create()
+Deleted patch
-Instead of having a separate blockdev_create() function, make use of the
-VM.blockdev_create() offered by iotests.py.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/212 | 101 +++++++++++++++++++----------------------
-file changed, 46 insertions(+), 55 deletions(-)
-diff --git a/tests/qemu-iotests/212 b/tests/qemu-iotests/212
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/212
-+++ b/tests/qemu-iotests/212
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
- iotests.verify_image_format(supported_fmts=['parallels'])
- iotests.verify_protocol(supported=['file'])
--def blockdev_create(vm, options):
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
--                        filters=[iotests.filter_qmp_testfiles])
--
--    if 'return' in result:
--        assert result['return'] == {}
--        vm.run_job('job0')
--    iotests.log("")
--
- with iotests.FilePath('t.parallels') as disk_path, \
-      iotests.VM() as vm:
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
-     size = 128 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-     vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
-                node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'imgfile',
--                          'size': size })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'imgfile',
-+                         'size': size })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
-     size = 64 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': {
--                              'driver': 'file',
--                              'filename': disk_path,
--                          },
--                          'size': size,
--                          'cluster-size': 1048576 })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': {
-+                             'driver': 'file',
-+                             'filename': disk_path,
-+                         },
-+                         'size': size,
-+                         'cluster-size': 1048576 })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
-     size = 32 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': {
--                              'driver': 'file',
--                              'filename': disk_path,
--                          },
--                          'size': size,
--                          'cluster-size': 65536 })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': {
-+                             'driver': 'file',
-+                             'filename': disk_path,
-+                         },
-+                         'size': size,
-+                         'cluster-size': 65536 })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
-     iotests.log("")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': "this doesn't exist",
--                          'size': size })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': "this doesn't exist",
-+                         'size': size })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
-     vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 0 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 0 })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
-     iotests.log("")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 4503599627369984})
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 4503599627369984})
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
-     vm.launch()
-     for size in [ 1234, 18446744073709551104, 9223372036854775808,
-                   9223372036854775296, 4503599627370497 ]:
--        blockdev_create(vm, { 'driver': imgfmt,
--                              'file': 'node0',
--                              'size': size })
-+        vm.blockdev_create({ 'driver': imgfmt,
-+                             'file': 'node0',
-+                             'size': size })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
-     vm.launch()
-     for csize in [ 1234, 128, 4294967296, 9223372036854775808,
-                    18446744073709551104, 0 ]:
--        blockdev_create(vm, { 'driver': imgfmt,
--                              'file': 'node0',
--                              'size': 67108864,
--                              'cluster-size': csize })
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 281474976710656,
--                          'cluster-size': 512 })
-+        vm.blockdev_create({ 'driver': imgfmt,
-+                             'file': 'node0',
-+                             'size': 67108864,
-+                             'cluster-size': csize })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 281474976710656,
-+                         'cluster-size': 512 })
-     vm.shutdown()
---
-.20.1

-[PULL 23/30] iotests: 213: Convert to VM.blockdev_create()
+Deleted patch
-Instead of having a separate blockdev_create() function, make use of the
-VM.blockdev_create() offered by iotests.py.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/213 | 113 +++++++++++++++++++----------------------
-file changed, 52 insertions(+), 61 deletions(-)
-diff --git a/tests/qemu-iotests/213 b/tests/qemu-iotests/213
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/213
-+++ b/tests/qemu-iotests/213
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
- iotests.verify_image_format(supported_fmts=['vhdx'])
- iotests.verify_protocol(supported=['file'])
--def blockdev_create(vm, options):
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
--                        filters=[iotests.filter_qmp_testfiles])
--
--    if 'return' in result:
--        assert result['return'] == {}
--        vm.run_job('job0')
--    iotests.log("")
--
- with iotests.FilePath('t.vhdx') as disk_path, \
-      iotests.VM() as vm:
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
-     size = 128 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-     vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
-                node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'imgfile',
--                          'size': size })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'imgfile',
-+                         'size': size })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
-     size = 64 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': {
--                              'driver': 'file',
--                              'filename': disk_path,
--                          },
--                          'size': size,
--                          'log-size': 1048576,
--                          'block-size': 8388608,
--                          'subformat': 'dynamic',
--                          'block-state-zero': True })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': {
-+                             'driver': 'file',
-+                             'filename': disk_path,
-+                         },
-+                         'size': size,
-+                         'log-size': 1048576,
-+                         'block-size': 8388608,
-+                         'subformat': 'dynamic',
-+                         'block-state-zero': True })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
-     size = 32 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': {
--                              'driver': 'file',
--                              'filename': disk_path,
--                          },
--                          'size': size,
--                          'log-size': 8388608,
--                          'block-size': 268435456,
--                          'subformat': 'fixed',
--                          'block-state-zero': False })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': {
-+                             'driver': 'file',
-+                             'filename': disk_path,
-+                         },
-+                         'size': size,
-+                         'log-size': 8388608,
-+                         'block-size': 268435456,
-+                         'subformat': 'fixed',
-+                         'block-state-zero': False })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
-     iotests.log("")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': "this doesn't exist",
--                          'size': size })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': "this doesn't exist",
-+                         'size': size })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
-     vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 0 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 0 })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
-     iotests.log("")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 70368744177664 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 70368744177664 })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
-     vm.launch()
-     for size in [ 18446744073709551104, 9223372036854775808,
-                   9223372036854775296, 70368744177665 ]:
--        blockdev_create(vm, { 'driver': imgfmt,
--                              'file': 'node0',
--                              'size': size })
-+        vm.blockdev_create({ 'driver': imgfmt,
-+                             'file': 'node0',
-+                             'size': size })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
-     vm.launch()
-     for bsize in [ 1234567, 128, 3145728, 536870912, 0 ]:
--        blockdev_create(vm, { 'driver': imgfmt,
--                              'file': 'node0',
--                              'size': 67108864,
--                              'block-size': bsize })
-+        vm.blockdev_create({ 'driver': imgfmt,
-+                             'file': 'node0',
-+                             'size': 67108864,
-+                             'block-size': bsize })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
-     vm.launch()
-     for lsize in [ 1234567, 128, 4294967296, 0 ]:
--        blockdev_create(vm, { 'driver': imgfmt,
--                              'file': 'node0',
--                              'size': 67108864,
--                              'log-size': lsize })
-+        vm.blockdev_create({ 'driver': imgfmt,
-+                             'file': 'node0',
-+                             'size': 67108864,
-+                             'log-size': lsize })
-     vm.shutdown()
---
-.20.1

-[PULL 24/30] iotests: 237: Convert to VM.blockdev_create()
+Deleted patch
-Instead of having a separate blockdev_create() function, make use of the
-VM.blockdev_create() offered by iotests.py.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/237 | 139 +++++++++++++++++++----------------------
-file changed, 65 insertions(+), 74 deletions(-)
-diff --git a/tests/qemu-iotests/237 b/tests/qemu-iotests/237
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/237
-+++ b/tests/qemu-iotests/237
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
- iotests.verify_image_format(supported_fmts=['vmdk'])
--def blockdev_create(vm, options):
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
--                        filters=[iotests.filter_qmp_testfiles])
--
--    if 'return' in result:
--        assert result['return'] == {}
--        vm.run_job('job0')
--    iotests.log("")
--
- with iotests.FilePath('t.vmdk') as disk_path, \
-      iotests.FilePath('t.vmdk.1') as extent1_path, \
-      iotests.FilePath('t.vmdk.2') as extent2_path, \
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
-     size = 5 * 1024 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-     vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
-                node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'imgfile',
--                          'size': size })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'imgfile',
-+                         'size': size })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
-     size = 64 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
--
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': {
--                              'driver': 'file',
--                              'filename': disk_path,
--                          },
--                          'size': size,
--                          'extents': [],
--                          'subformat': 'monolithicSparse',
--                          'adapter-type': 'ide',
--                          'hwversion': '4',
--                          'zeroed-grain': False })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-+
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': {
-+                             'driver': 'file',
-+                             'filename': disk_path,
-+                         },
-+                         'size': size,
-+                         'extents': [],
-+                         'subformat': 'monolithicSparse',
-+                         'adapter-type': 'ide',
-+                         'hwversion': '4',
-+                         'zeroed-grain': False })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
-     size = 32 * 1024 * 1024
-     vm.launch()
--    blockdev_create(vm, { 'driver': 'file',
--                          'filename': disk_path,
--                          'size': 0 })
--
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': {
--                              'driver': 'file',
--                              'filename': disk_path,
--                          },
--                          'size': size,
--                          'extents': [],
--                          'subformat': 'monolithicSparse',
--                          'adapter-type': 'buslogic',
--                          'zeroed-grain': True })
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
-+                         'size': 0 })
-+
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': {
-+                             'driver': 'file',
-+                             'filename': disk_path,
-+                         },
-+                         'size': size,
-+                         'extents': [],
-+                         'subformat': 'monolithicSparse',
-+                         'adapter-type': 'buslogic',
-+                         'zeroed-grain': True })
-     vm.shutdown()
-     iotests.img_info_log(disk_path)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
-     iotests.log("")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': "this doesn't exist",
--                          'size': size })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': "this doesn't exist",
-+                         'size': size })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
-     vm.launch()
-     for adapter_type in [ 'ide', 'buslogic', 'lsilogic', 'legacyESX' ]:
--        blockdev_create(vm, { 'driver': imgfmt,
--                              'file': 'node0',
--                              'size': size,
--                              'adapter-type': adapter_type })
-+        vm.blockdev_create({ 'driver': imgfmt,
-+                             'file': 'node0',
-+                             'size': size,
-+                             'adapter-type': adapter_type })
-     vm.shutdown()
-     # Invalid
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
-     vm.launch()
-     for adapter_type in [ 'foo', 'IDE', 'legacyesx', 1 ]:
--        blockdev_create(vm, { 'driver': imgfmt,
--                              'file': 'node0',
--                              'size': size,
--                              'adapter-type': adapter_type })
-+        vm.blockdev_create({ 'driver': imgfmt,
-+                             'file': 'node0',
-+                             'size': size,
-+                             'adapter-type': adapter_type })
-     vm.shutdown()
-     #
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
-     iotests.log("")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': size,
--                          'subformat': 'monolithicFlat' })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': size,
-+                         'subformat': 'monolithicFlat' })
-     vm.shutdown()
-     # Correct extent
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
-     iotests.log("")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': size,
--                          'subformat': 'monolithicFlat',
--                          'extents': ['ext1'] })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': size,
-+                         'subformat': 'monolithicFlat',
-+                         'extents': ['ext1'] })
-     vm.shutdown()
-     # Extra extent
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
-     iotests.log("")
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
--                          'size': 512,
--                          'subformat': 'monolithicFlat',
--                          'extents': ['ext1', 'ext2', 'ext3'] })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'node0',
-+                         'size': 512,
-+                         'subformat': 'monolithicFlat',
-+                         'extents': ['ext1', 'ext2', 'ext3'] })
-     vm.shutdown()
-     # Split formats
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
-             extents = [ "ext%d" % (i) for i in range(1, num_extents + 1) ]
-             vm.launch()
--            blockdev_create(vm, { 'driver': imgfmt,
--                                  'file': 'node0',
--                                  'size': size,
--                                  'subformat': subfmt,
--                                  'extents': extents })
-+            vm.blockdev_create({ 'driver': imgfmt,
-+                                 'file': 'node0',
-+                                 'size': size,
-+                                 'subformat': subfmt,
-+                                 'extents': extents })
-             vm.shutdown()
-             iotests.img_info_log(disk_path)
---
-.20.1

-[PULL 25/30] iotests: 266: Convert to VM.blockdev_create()
+Deleted patch
-Instead of having a separate blockdev_create() function, make use of the
-VM.blockdev_create() offered by iotests.py.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
----
- tests/qemu-iotests/266     | 69 +++++++++++++++++---------------------
- tests/qemu-iotests/266.out | 14 ++++++++
-files changed, 44 insertions(+), 39 deletions(-)
-diff --git a/tests/qemu-iotests/266 b/tests/qemu-iotests/266
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/266
-+++ b/tests/qemu-iotests/266
-@@ -XXX,XX +XXX,XX @@ import iotests
- from iotests import imgfmt
--def blockdev_create(vm, options):
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
--                        filters=[iotests.filter_qmp_testfiles])
--
--    if 'return' in result:
--        assert result['return'] == {}
--        vm.run_job('job0')
--
--
- # Successful image creation (defaults)
- def implicit_defaults(vm, file_path):
-     iotests.log("=== Successful image creation (defaults) ===")
-@@ -XXX,XX +XXX,XX @@ def implicit_defaults(vm, file_path):
-     # (Close to 64 MB)
-     size = 8 * 964 * 17 * 512
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'protocol-node',
--                          'size': size })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'protocol-node',
-+                         'size': size })
- # Successful image creation (explicit defaults)
-@@ -XXX,XX +XXX,XX @@ def explicit_defaults(vm, file_path):
-     # (Close to 128 MB)
-     size = 16 * 964 * 17 * 512
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'protocol-node',
--                          'size': size,
--                          'subformat': 'dynamic',
--                          'force-size': False })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'protocol-node',
-+                         'size': size,
-+                         'subformat': 'dynamic',
-+                         'force-size': False })
- # Successful image creation (non-default options)
-@@ -XXX,XX +XXX,XX @@ def non_defaults(vm, file_path):
-     # Not representable in CHS (fine with force-size=True)
-     size = 1048576
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'protocol-node',
--                          'size': size,
--                          'subformat': 'fixed',
--                          'force-size': True })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'protocol-node',
-+                         'size': size,
-+                         'subformat': 'fixed',
-+                         'force-size': True })
- # Size not representable in CHS with force-size=False
-@@ -XXX,XX +XXX,XX @@ def non_chs_size_without_force(vm, file_path):
-     # Not representable in CHS (will not work with force-size=False)
-     size = 1048576
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'protocol-node',
--                          'size': size,
--                          'force-size': False })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'protocol-node',
-+                         'size': size,
-+                         'force-size': False })
- # Zero size
-@@ -XXX,XX +XXX,XX @@ def zero_size(vm, file_path):
-     iotests.log("=== Zero size===")
-     iotests.log("")
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'protocol-node',
--                          'size': 0 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'protocol-node',
-+                         'size': 0 })
- # Maximum CHS size
-@@ -XXX,XX +XXX,XX @@ def maximum_chs_size(vm, file_path):
-     iotests.log("=== Maximum CHS size===")
-     iotests.log("")
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'protocol-node',
--                          'size': 16 * 65535 * 255 * 512 })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'protocol-node',
-+                         'size': 16 * 65535 * 255 * 512 })
- # Actual maximum size
-@@ -XXX,XX +XXX,XX @@ def maximum_size(vm, file_path):
-     iotests.log("=== Actual maximum size===")
-     iotests.log("")
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'protocol-node',
--                          'size': 0xff000000 * 512,
--                          'force-size': True })
-+    vm.blockdev_create({ 'driver': imgfmt,
-+                         'file': 'protocol-node',
-+                         'size': 0xff000000 * 512,
-+                         'force-size': True })
- def main():
-@@ -XXX,XX +XXX,XX @@ def main():
-             vm.launch()
-             iotests.log('--- Creating empty file ---')
--            blockdev_create(vm, { 'driver': 'file',
--                                  'filename': file_path,
--                                  'size': 0 })
-+            vm.blockdev_create({ 'driver': 'file',
-+                                 'filename': file_path,
-+                                 'size': 0 })
-             vm.qmp_log('blockdev-add', driver='file', filename=file_path,
-                        node_name='protocol-node',
-diff --git a/tests/qemu-iotests/266.out b/tests/qemu-iotests/266.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/266.out
-+++ b/tests/qemu-iotests/266.out
-@@ -XXX,XX +XXX,XX @@
- {"return": {}}
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
- {"return": {}}
-@@ -XXX,XX +XXX,XX @@
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- image: TEST_IMG
- file format: IMGFMT
- virtual size: 64 MiB (67125248 bytes)
-@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
- {"return": {}}
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
- {"return": {}}
-@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- image: TEST_IMG
- file format: IMGFMT
- virtual size: 128 MiB (134250496 bytes)
-@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
- {"return": {}}
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
- {"return": {}}
-@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- image: TEST_IMG
- file format: IMGFMT
- virtual size: 1 MiB (1048576 bytes)
-@@ -XXX,XX +XXX,XX @@ virtual size: 1 MiB (1048576 bytes)
- {"return": {}}
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
- {"return": {}}
-@@ -XXX,XX +XXX,XX @@ Job failed: The requested image size cannot be represented in CHS geometry
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- qemu-img: Could not open 'TEST_IMG': File too small for a VHD header
- --- Creating empty file ---
-@@ -XXX,XX +XXX,XX @@ qemu-img: Could not open 'TEST_IMG': File too small for a VHD header
- {"return": {}}
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
- {"return": {}}
-@@ -XXX,XX +XXX,XX @@ qemu-img: Could not open 'TEST_IMG': File too small for a VHD header
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- image: TEST_IMG
- file format: IMGFMT
- virtual size: 0 B (0 bytes)
-@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
- {"return": {}}
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
- {"return": {}}
-@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- image: TEST_IMG
- file format: IMGFMT
- virtual size: 127 GiB (136899993600 bytes)
-@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
- {"return": {}}
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
- {"return": {}}
-@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
-+
- image: TEST_IMG
- file format: IMGFMT
- virtual size: 1.99 TiB (2190433320960 bytes)
---
-.20.1

The following changes since commit aceeaa69d28e6f08a24395d0aa6915b687d0a681:

Merge remote-tracking branch 'remotes/huth-gitlab/tags/pull-request-2019-12-17' into staging (2019-12-17 15:55:20 +0000)

are available in the Git repository at:

git://repo.or.cz/qemu/kevin.git tags/for-upstream

for you to fetch changes up to f62f08ab7a9d902da70078992248ec5c98f652ad:

iotests: Test external snapshot with VM state (2019-12-19 18:04:25 +0100)

----------------------------------------------------------------
Block layer patches:

- qemu-img: fix info --backing-chain --image-opts
- Error out on image creation with conflicting size options
- Fix external snapshot with VM state
- hmp: Allow using qdev ID for qemu-io command
- Misc code cleanup
- Many iotests improvements

----------------------------------------------------------------
Alberto Garcia (1):
      qcow2: Use offset_into_cluster()

Daniel P. Berrangé (1):
      qapi: better document NVMe blockdev @device parameter

Kevin Wolf (19):
      block: Error out on image creation with conflicting size options
      blockjob: Fix error message for negative speed
      qcow2: Declare BDRV_REQ_NO_FALLBACK supported
      iotests: Add qemu_io_log()
      iotests: Fix timeout in run_job()
      iotests: Support job-complete in run_job()
      iotests: Create VM.blockdev_create()
      iotests: 255: Drop blockdev_create()
      iotests: 206: Convert to VM.blockdev_create()
      iotests: 210: Convert to VM.blockdev_create()
      iotests: 212: Convert to VM.blockdev_create()
      iotests: 213: Convert to VM.blockdev_create()
      iotests: 237: Convert to VM.blockdev_create()
      iotests: 266: Convert to VM.blockdev_create()
      iotests: 207: Remove duplication with VM.blockdev_create()
      iotests: 211: Remove duplication with VM.blockdev_create()
      block: Activate recursively even for already active nodes
      hmp: Allow using qdev ID for qemu-io command
      iotests: Test external snapshot with VM state

Max Reitz (2):
      iotests/273: Filter format-specific information
      iotests: Fix IMGOPTSSYNTAX for nbd

Stefan Hajnoczi (1):
      qemu-img: fix info --backing-chain --image-opts

Thomas Huth (4):
      iotests: Provide a function for checking the creation of huge files
      iotests: Skip test 060 if it is not possible to create large files
      iotests: Skip test 079 if it is not possible to create large files
      iotests: Add more "_require_drivers" checks to the shell-based tests

Tuguoyi (1):
      qcow2: Move error check of local_err near its assignment

Vladimir Sementsov-Ogievskiy (1):
      MAINTAINERS: fix qcow2-bitmap.c under Dirty Bitmaps header

From: Thomas Huth <thuth@redhat.com>

Some tests create huge (but sparse) files, and to be able to run those
tests in certain limited environments (like CI containers), we have to
check for the possibility to create such files first. Thus let's introduce
a common function to check for large files, and replace the already
existing checks in the iotests 005 and 220 with this function.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/005       |  5 +----
 tests/qemu-iotests/220       |  6 ++----
 tests/qemu-iotests/common.rc | 10 ++++++++++
 3 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/tests/qemu-iotests/005 b/tests/qemu-iotests/005
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/005
+++ b/tests/qemu-iotests/005
@@ -XXX,XX +XXX,XX @@ fi
 # Sanity check: For raw, we require a file system that permits the creation
 # of a HUGE (but very sparse) file. Check we can create it before continuing.
 if [ "$IMGFMT" = "raw" ]; then
-    if ! truncate --size=5T "$TEST_IMG"; then
-        _notrun "file system on $TEST_DIR does not support large enough files"
-    fi
-    rm "$TEST_IMG"
+    _require_large_file 5T
 fi
 
 echo
diff --git a/tests/qemu-iotests/220 b/tests/qemu-iotests/220
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/220
+++ b/tests/qemu-iotests/220
@@ -XXX,XX +XXX,XX @@ echo "== Creating huge file =="
 
 # Sanity check: We require a file system that permits the creation
 # of a HUGE (but very sparse) file.  tmpfs works, ext4 does not.
-if ! truncate --size=513T "$TEST_IMG"; then
-    _notrun "file system on $TEST_DIR does not support large enough files"
-fi
-rm "$TEST_IMG"
+_require_large_file 513T
+
 IMGOPTS='cluster_size=2M,refcount_bits=1' _make_test_img 513T
 
 echo "== Populating refcounts =="
diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@ _require_drivers()
     done
 }
 
+# Check that we have a file system that allows huge (but very sparse) files
+#
+_require_large_file()
+{
+    if ! truncate --size="$1" "$TEST_IMG"; then
+        _notrun "file system on $TEST_DIR does not support large enough files"
+    fi
+    rm "$TEST_IMG"
+}
+
 # make sure this script returns success
 true
-- 
2.20.1

From: Thomas Huth <thuth@redhat.com>

Test 060 fails in the arm64, s390x and ppc64le LXD containers on Travis
(which we will hopefully enable in our CI soon). These containers
apparently do not allow large files to be created. The repair process
in test 060 creates a file of 64 GiB, so test first whether such large
files are possible and skip the test if that's not the case.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/060 | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/060
+++ b/tests/qemu-iotests/060
@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow2
 _supported_proto file
 _supported_os Linux
 
+# The repair process will create a large file - so check for availability first
+_require_large_file 64G
+
 rt_offset=65536  # 0x10000 (XXX: just an assumption)
 rb_offset=131072 # 0x20000 (XXX: just an assumption)
 l1_offset=196608 # 0x30000 (XXX: just an assumption)
-- 
2.20.1

From: Thomas Huth <thuth@redhat.com>

Test 079 fails in the arm64, s390x and ppc64le LXD containers on Travis
(which we will hopefully enable in our CI soon). These containers
apparently do not allow large files to be created. Test 079 tries to
create a 4G sparse file, which is apparently already too big for these
containers, so check first whether we can really create such files before
executing the test.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/079 | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/qemu-iotests/079 b/tests/qemu-iotests/079
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/079
+++ b/tests/qemu-iotests/079
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2
 _supported_proto file nfs
 
+# Some containers (e.g. non-x86 on Travis) do not allow large files
+_require_large_file 4G
+
 echo "=== Check option preallocation and cluster_size ==="
 echo
 cluster_sizes="16384 32768 65536 131072 262144 524288 1048576 2097152 4194304"
-- 
2.20.1

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

Mention that this is a PCI device address & give the format it is
expected in. Also mention that it must be first unbound from any
host kernel driver.

Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

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 @@
 #
 # Driver specific block device options for the NVMe backend.
 #
-# @device:    controller address of the NVMe device.
+# @device:    PCI controller address of the NVMe device in
+#             format hhhh:bb:ss.f (host:bus:slot.function)
 # @namespace: namespace number of the device, starting from 1.
 #
+# Note that the PCI @device must have been unbound from any host
+# kernel driver before instructing QEMU to add the blockdev.
+#
 # Since: 2.12
 ##
 { 'struct': 'BlockdevOptionsNVMe',
-- 
2.20.1

From: Stefan Hajnoczi <stefanha@redhat.com>

Only apply --image-opts to the topmost image when listing an entire
backing chain.  It is incorrect to treat backing filenames as image
options.  Assuming we have the backing chain t.IMGFMT.base <-
t.IMGFMT.mid <- t.IMGFMT, qemu-img info fails as follows:

$ qemu-img info --backing-chain --image-opts \
      driver=qcow2,file.driver=file,file.filename=t.IMGFMT
  qemu-img: Could not open 'TEST_DIR/t.IMGFMT.mid': Cannot find device=TEST_DIR/t.IMGFMT.mid nor node_name=TEST_DIR/t.IMGFMT.mid

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qemu-img.c                 |  3 ++
 tests/qemu-iotests/279     | 57 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/279.out | 35 +++++++++++++++++++++++
 tests/qemu-iotests/group   |  1 +
 4 files changed, 96 insertions(+)
 create mode 100755 tests/qemu-iotests/279
 create mode 100644 tests/qemu-iotests/279.out

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 ImageInfoList *collect_image_info_list(bool image_opts,
 
         blk_unref(blk);
 
+        /* Clear parameters that only apply to the topmost image */
         filename = fmt = NULL;
+        image_opts = false;
+
         if (chain) {
             if (info->has_full_backing_filename) {
                 filename = info->full_backing_filename;
diff --git a/tests/qemu-iotests/279 b/tests/qemu-iotests/279
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/279
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env bash
+#
+# Test qemu-img --backing-chain --image-opts
+#
+# 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
+    rm -f "$TEST_IMG.mid"
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+
+# Backing files are required...
+_supported_fmt qcow qcow2 vmdk qed
+_supported_proto file
+_supported_os Linux
+
+TEST_IMG="$TEST_IMG.base" _make_test_img 64M
+TEST_IMG="$TEST_IMG.mid" _make_test_img -b "$TEST_IMG.base"
+_make_test_img -b "$TEST_IMG.mid"
+
+echo
+echo '== qemu-img info --backing-chain =='
+_img_info --backing-chain | _filter_img_info
+
+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
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/279.out b/tests/qemu-iotests/279.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/279.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 279
+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864
+Formatting 'TEST_DIR/t.IMGFMT.mid', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.base
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.mid
+
+== qemu-img info --backing-chain ==
+image: TEST_DIR/t.IMGFMT
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+backing file: TEST_DIR/t.IMGFMT.mid
+
+image: TEST_DIR/t.IMGFMT.mid
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+backing file: TEST_DIR/t.IMGFMT.base
+
+image: TEST_DIR/t.IMGFMT.base
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+
+== qemu-img info --backing-chain --image-opts ==
+image: TEST_DIR/t.IMGFMT
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+backing file: TEST_DIR/t.IMGFMT.mid
+
+image: TEST_DIR/t.IMGFMT.mid
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+backing file: TEST_DIR/t.IMGFMT.base
+
+image: TEST_DIR/t.IMGFMT.base
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+*** 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 @@
 272 rw
 273 backing quick
 277 rw quick
+279 rw backing quick
-- 
2.20.1

If both the create options (qemu-img create -o ...) and the size
parameter were given, the size parameter was silently ignored. Instead,
make specifying two sizes an error.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 block.c                    | 10 ++++++++--
 tests/qemu-iotests/049     |  5 +++++
 tests/qemu-iotests/049.out |  5 +++++
 3 files changed, 18 insertions(+), 2 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,
         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);
 
-    /* Create parameter list with default values */
     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
-    qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
 
     /* Parse -o options */
     if (options) {
@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,
         }
     }
 
+    if (!qemu_opt_get(opts, BLOCK_OPT_SIZE)) {
+        qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
+    } else if (img_size != UINT64_C(-1)) {
+        error_setg(errp, "The image size must be specified only once");
+        goto out;
+    }
+
     if (base_filename) {
         qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
         if (local_err) {
diff --git a/tests/qemu-iotests/049 b/tests/qemu-iotests/049
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/049
+++ b/tests/qemu-iotests/049
@@ -XXX,XX +XXX,XX @@ for s in $sizes; do
     test_qemu_img create -f $IMGFMT -o size=$s "$TEST_IMG"
 done
 
+echo "== 4. Specify size twice (-o and traditional parameter) =="
+echo
+
+test_qemu_img create -f $IMGFMT -o size=10M "$TEST_IMG" 20M
+
 echo "== Check correct interpretation of suffixes for cluster size =="
 echo
 sizes="1024 1024b 1k 1K 1M "
diff --git a/tests/qemu-iotests/049.out b/tests/qemu-iotests/049.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/049.out
+++ b/tests/qemu-iotests/049.out
@@ -XXX,XX +XXX,XX @@ qemu-img: TEST_DIR/t.qcow2: Parameter 'size' expects a non-negative number below
 Optional suffix k, M, G, T, P or E means kilo-, mega-, giga-, tera-, peta-
 and exabytes, respectively.
 
+== 4. Specify size twice (-o and traditional parameter) ==
+
+qemu-img create -f qcow2 -o size=10M TEST_DIR/t.qcow2 20M
+qemu-img: TEST_DIR/t.qcow2: The image size must be specified only once
+
 == Check correct interpretation of suffixes for cluster size ==
 
 qemu-img create -f qcow2 -o cluster_size=1024 TEST_DIR/t.qcow2 64M
-- 
2.20.1

The error message for a negative speed uses QERR_INVALID_PARAMETER,
which implies that the 'speed' option doesn't even exist:

{"error": {"class": "GenericError", "desc": "Invalid parameter 'speed'"}}

Make it use QERR_INVALID_PARAMETER_VALUE instead:

{"error": {"class": "GenericError", "desc": "Parameter 'speed' expects a non-negative value"}}

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 blockjob.c             | 3 ++-
 tests/qemu-iotests/030 | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
         return;
     }
     if (speed < 0) {
-        error_setg(errp, QERR_INVALID_PARAMETER, "speed");
+        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "speed",
+                   "a non-negative value");
         return;
     }
 
diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/030
+++ b/tests/qemu-iotests/030
@@ -XXX,XX +XXX,XX @@ class TestSetSpeed(iotests.QMPTestCase):
         self.assert_no_active_block_jobs()
 
         result = self.vm.qmp('block-stream', device='drive0', speed=-1)
-        self.assert_qmp(result, 'error/desc', "Invalid parameter 'speed'")
+        self.assert_qmp(result, 'error/desc', "Parameter 'speed' expects a non-negative value")
 
         self.assert_no_active_block_jobs()
 
@@ -XXX,XX +XXX,XX @@ class TestSetSpeed(iotests.QMPTestCase):
         self.assert_qmp(result, 'return', {})
 
         result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1)
-        self.assert_qmp(result, 'error/desc', "Invalid parameter 'speed'")
+        self.assert_qmp(result, 'error/desc', "Parameter 'speed' expects a non-negative value")
 
         self.cancel_and_wait(resume=True)
 
-- 
2.20.1

In the common case, qcow2_co_pwrite_zeroes() already only modifies
metadata case, so we're fine with or without BDRV_REQ_NO_FALLBACK set.

The only exception is when using an external data file, where the
request is passed down to the block driver of the external data file. We
are forwarding the BDRV_REQ_NO_FALLBACK flag there, though, so this is
fine, too.

Declare the flag supported therefore.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
---
 block/qcow2.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

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 int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
         }
     }
 
-    bs->supported_zero_flags = header.version >= 3 ? BDRV_REQ_MAY_UNMAP : 0;
+    bs->supported_zero_flags = header.version >= 3 ?
+                               BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
 
     /* Repair image if dirty */
     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
-- 
2.20.1

Add a function that runs qemu-io and logs the output with the
appropriate filters applied.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/qemu-iotests/iotests.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/iotests.py
+++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@ def qemu_io(*args):
         sys.stderr.write('qemu-io received signal %i: %s\n' % (-exitcode, ' '.join(args)))
     return subp.communicate()[0]
 
+def qemu_io_log(*args):
+    result = qemu_io(*args)
+    log(result, filters=[filter_testfiles, filter_qemu_io])
+    return result
+
 def qemu_io_silent(*args):
     '''Run qemu-io and return the exit code, suppressing stdout'''
     args = qemu_io_args + list(args)
-- 
2.20.1

run_job() accepts a wait parameter for a timeout, but it doesn't
actually use it. The only thing that is missing is passing it to
events_wait(), so do that now.

Automatically complete jobs that have a 'ready' state and need an
explicit job-complete. Without this, run_job() would hang for such
jobs.

From: Alberto Garcia <berto@igalia.com>

There's a couple of places left in the qcow2 code that still do the
calculation manually, so let's replace them.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
                 return -EINVAL;
             }
 
-            if (bitmaps_ext.bitmap_directory_offset & (s->cluster_size - 1)) {
+            if (offset_into_cluster(s, bitmaps_ext.bitmap_directory_offset)) {
                 error_setg(errp, "bitmaps_ext: "
                                  "invalid bitmap directory offset");
                 return -EINVAL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t cluster_offset;
-    int index_in_cluster, ret;
     unsigned int bytes;
-    int status = 0;
+    int ret, status = 0;
 
     qemu_co_mutex_lock(&s->lock);
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
 
     if ((ret == QCOW2_CLUSTER_NORMAL || ret == QCOW2_CLUSTER_ZERO_ALLOC) &&
         !s->crypto) {
-        index_in_cluster = offset & (s->cluster_size - 1);
-        *map = cluster_offset | index_in_cluster;
+        *map = cluster_offset | offset_into_cluster(s, offset);
         *file = s->data_file->bs;
         status |= BDRV_BLOCK_OFFSET_VALID;
     }
-- 
2.20.1

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

Somehow I wrote not full path to the file. Fix that.

Also, while being here, rearrange entries, so that includes go first,
then block, than migration, than util.

Fixes: 052db8e71444d
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 MAINTAINERS | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ M: John Snow <jsnow@redhat.com>
 R: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 L: qemu-block@nongnu.org
 S: Supported
-F: util/hbitmap.c
-F: block/dirty-bitmap.c
 F: include/qemu/hbitmap.h
 F: include/block/dirty-bitmap.h
-F: qcow2-bitmap.c
+F: block/dirty-bitmap.c
+F: block/qcow2-bitmap.c
 F: migration/block-dirty-bitmap.c
+F: util/hbitmap.c
 F: tests/test-hbitmap.c
 F: docs/interop/bitmaps.rst
 T: git https://github.com/jnsnow/qemu.git bitmaps
-- 
2.20.1

From: Thomas Huth <thuth@redhat.com>

Test 051 should be skipped if nbd is not available, and 267 should
be skipped if copy-on-read is not enabled.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/051 | 1 +
 tests/qemu-iotests/267 | 1 +
 2 files changed, 2 insertions(+)

diff --git a/tests/qemu-iotests/051 b/tests/qemu-iotests/051
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/051
+++ b/tests/qemu-iotests/051
@@ -XXX,XX +XXX,XX @@ _supported_proto file
 # A compat=0.10 image is created in this test which does not support anything
 # other than refcount_bits=16
 _unsupported_imgopts 'refcount_bits=$[^1]\|.\([^6]\|$$\)'
+_require_drivers nbd
 
 do_run_qemu()
 {
diff --git a/tests/qemu-iotests/267 b/tests/qemu-iotests/267
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/267
+++ b/tests/qemu-iotests/267
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2
 _supported_proto file
 _supported_os Linux
+_require_drivers copy-on-read
 
 # Internal snapshots are (currently) impossible with refcount_bits=1
 _unsupported_imgopts 'refcount_bits=1[^0-9]'
-- 
2.20.1

From: Max Reitz <mreitz@redhat.com>

Doing this allows running this test with e.g. -o compat=0.10 or
-o compat=refcount_bits=1.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/273     |  3 ++-
 tests/qemu-iotests/273.out | 27 ---------------------------
 2 files changed, 2 insertions(+), 28 deletions(-)

diff --git a/tests/qemu-iotests/273 b/tests/qemu-iotests/273
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/273
+++ b/tests/qemu-iotests/273
@@ -XXX,XX +XXX,XX @@ do_run_qemu()
 run_qemu()
 {
     do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qemu | _filter_qmp |
-        _filter_generated_node_ids | _filter_imgfmt | _filter_actual_image_size
+        _filter_generated_node_ids | _filter_imgfmt |
+        _filter_actual_image_size | _filter_img_info
 }
 
 TEST_IMG="$TEST_IMG.base" _make_test_img 64M
diff --git a/tests/qemu-iotests/273.out b/tests/qemu-iotests/273.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/273.out
+++ b/tests/qemu-iotests/273.out
@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
                     "cluster-size": 65536,
                     "format": "IMGFMT",
                     "actual-size": SIZE,
-                    "format-specific": {
-                        "type": "IMGFMT",
-                        "data": {
-                            "compat": "1.1",
-                            "lazy-refcounts": false,
-                            "refcount-bits": 16,
-                            "corrupt": false
-                        }
-                    },
                     "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
                     "backing-filename": "TEST_DIR/t.IMGFMT.base",
                     "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
                 "cluster-size": 65536,
                 "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "IMGFMT",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
                 "full-backing-filename": "TEST_DIR/t.IMGFMT.mid",
                 "backing-filename": "TEST_DIR/t.IMGFMT.mid",
                 "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
                 "cluster-size": 65536,
                 "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "IMGFMT",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
                 "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
                 "backing-filename": "TEST_DIR/t.IMGFMT.base",
                 "dirty-flag": false
-- 
2.20.1

From: Max Reitz <mreitz@redhat.com>

There is no $SOCKDIR, only $SOCK_DIR.

Fixes: f3923a72f199b2c63747a7032db74730546f55c6
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/common.rc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@ if [ "$IMGOPTSSYNTAX" = "true" ]; then
         TEST_IMG="$DRIVER,file.filename=$TEST_DIR/t.$IMGFMT"
     elif [ "$IMGPROTO" = "nbd" ]; then
         TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
-        TEST_IMG="$DRIVER,file.driver=nbd,file.type=unix,file.path=$SOCKDIR/nbd"
+        TEST_IMG="$DRIVER,file.driver=nbd,file.type=unix"
+        TEST_IMG="$TEST_IMG,file.path=$SOCK_DIR/nbd"
     elif [ "$IMGPROTO" = "ssh" ]; then
         TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
         TEST_IMG="$DRIVER,file.driver=ssh,file.host=127.0.0.1,file.path=$TEST_IMG_FILE"
-- 
2.20.1

From: Tuguoyi <tu.guoyi@h3c.com>

The local_err check outside of the if block was necessary
when it was introduced in commit d1258dd0c87 because it needed to be
executed even if qcow2_load_autoloading_dirty_bitmaps() returned false.

After some modifications that all required the error check to remain
where it is, commit 9c98f145dfb finally moved the
qcow2_load_dirty_bitmaps() call into the if block, so now the error
check should be there, too.

Signed-off-by: Guoyi Tu <tu.guoyi@h3c.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
     if (!(bdrv_get_flags(bs) & BDRV_O_INACTIVE)) {
         /* It's case 1, 2 or 3.2. Or 3.1 which is BUG in management layer. */
         bool header_updated = qcow2_load_dirty_bitmaps(bs, &local_err);
+        if (local_err != NULL) {
+            error_propagate(errp, local_err);
+            ret = -EINVAL;
+            goto fail;
+        }
 
         update_header = update_header && !header_updated;
     }
-    if (local_err != NULL) {
-        error_propagate(errp, local_err);
-        ret = -EINVAL;
-        goto fail;
-    }
 
     if (update_header) {
         ret = qcow2_update_header(bs);
-- 
2.20.1

We have several almost identical copies of a blockdev_create() function
in different test cases. Time to create one unified function in
iotests.py.

To keep the diff managable, this patch only creates the function and
follow-up patches will convert the individual test cases.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/iotests.py | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/iotests.py
+++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
             elif status == 'null':
                 return error
 
+    # Returns None on success, and an error string on failure
+    def blockdev_create(self, options, job_id='job0', filters=None):
+        if filters is None:
+            filters = [filter_qmp_testfiles]
+        result = self.qmp_log('blockdev-create', filters=filters,
+                              job_id=job_id, options=options)
+
+        if 'return' in result:
+            assert result['return'] == {}
+            job_result = self.run_job(job_id)
+        else:
+            job_result = result['error']
+
+        log("")
+        return job_result
+
     def enable_migration_events(self, name):
         log('Enabling migration QMP events on %s...' % name)
         log(self.qmp('migrate-set-capabilities', capabilities=[
-- 
2.20.1

Instead of having a separate blockdev_create() function, make use of the
VM.blockdev_create() offered by iotests.py.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/206 | 232 ++++++++++++++++++++---------------------
 1 file changed, 111 insertions(+), 121 deletions(-)

diff --git a/tests/qemu-iotests/206 b/tests/qemu-iotests/206
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/206
+++ b/tests/qemu-iotests/206
@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
 
 iotests.verify_image_format(supported_fmts=['qcow2'])
 
-def blockdev_create(vm, options):
-    result = vm.qmp_log('blockdev-create',
-                        filters=[iotests.filter_qmp_testfiles],
-                        job_id='job0', options=options)
-
-    if 'return' in result:
-        assert result['return'] == {}
-        vm.run_job('job0')
-    iotests.log("")
-
 with iotests.FilePath('t.qcow2') as disk_path, \
      iotests.FilePath('t.qcow2.base') as backing_path, \
      iotests.VM() as vm:
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
     size = 128 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
 
     vm.qmp_log('blockdev-add',
                filters=[iotests.filter_qmp_testfiles],
                driver='file', filename=disk_path,
                node_name='imgfile')
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'imgfile',
-                          'size': size })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'imgfile',
+                         'size': size })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
     size = 64 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0,
-                          'preallocation': 'off',
-                          'nocow': False })
-
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': {
-                              'driver': 'file',
-                              'filename': disk_path,
-                          },
-                          'size': size,
-                          'version': 'v3',
-                          'cluster-size': 65536,
-                          'preallocation': 'off',
-                          'lazy-refcounts': False,
-                          'refcount-bits': 16 })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0,
+                         'preallocation': 'off',
+                         'nocow': False })
+
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': {
+                             'driver': 'file',
+                             'filename': disk_path,
+                         },
+                         'size': size,
+                         'version': 'v3',
+                         'cluster-size': 65536,
+                         'preallocation': 'off',
+                         'lazy-refcounts': False,
+                         'refcount-bits': 16 })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
     size = 32 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0,
-                          'preallocation': 'falloc',
-                          'nocow': True })
-
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': {
-                              'driver': 'file',
-                              'filename': disk_path,
-                          },
-                          'size': size,
-                          'version': 'v3',
-                          'cluster-size': 2097152,
-                          'preallocation': 'metadata',
-                          'lazy-refcounts': True,
-                          'refcount-bits': 1 })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0,
+                         'preallocation': 'falloc',
+                         'nocow': True })
+
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': {
+                             'driver': 'file',
+                             'filename': disk_path,
+                         },
+                         'size': size,
+                         'version': 'v3',
+                         'cluster-size': 2097152,
+                         'preallocation': 'metadata',
+                         'lazy-refcounts': True,
+                         'refcount-bits': 1 })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
     iotests.log("")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
-
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': {
-                              'driver': 'file',
-                              'filename': disk_path,
-                          },
-                          'size': size,
-                          'backing-file': backing_path,
-                          'backing-fmt': 'qcow2',
-                          'version': 'v2',
-                          'cluster-size': 512 })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
+
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': {
+                             'driver': 'file',
+                             'filename': disk_path,
+                         },
+                         'size': size,
+                         'backing-file': backing_path,
+                         'backing-fmt': 'qcow2',
+                         'version': 'v2',
+                         'cluster-size': 512 })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
     iotests.log("")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': {
-                              'driver': 'file',
-                              'filename': disk_path,
-                          },
-                          'size': size,
-                          'encrypt': {
-                              'format': 'luks',
-                              'key-secret': 'keysec0',
-                              'cipher-alg': 'twofish-128',
-                              'cipher-mode': 'ctr',
-                              'ivgen-alg': 'plain64',
-                              'ivgen-hash-alg': 'md5',
-                              'hash-alg': 'sha1',
-                              'iter-time': 10,
-                          }})
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': {
+                             'driver': 'file',
+                             'filename': disk_path,
+                         },
+                         'size': size,
+                         'encrypt': {
+                             'format': 'luks',
+                             'key-secret': 'keysec0',
+                             'cipher-alg': 'twofish-128',
+                             'cipher-mode': 'ctr',
+                             'ivgen-alg': 'plain64',
+                             'ivgen-hash-alg': 'md5',
+                             'hash-alg': 'sha1',
+                             'iter-time': 10,
+                         }})
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
     iotests.log("")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': "this doesn't exist",
-                          'size': size })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': "this doesn't exist",
+                         'size': size })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
     vm.launch()
     for size in [ 1234, 18446744073709551104, 9223372036854775808,
                   9223372036854775296 ]:
-        blockdev_create(vm, { 'driver': imgfmt,
-                              'file': 'node0',
-                              'size': size })
+        vm.blockdev_create({ 'driver': imgfmt,
+                             'file': 'node0',
+                             'size': size })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
     iotests.log("=== Invalid version ===")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 67108864,
-                          'version': 'v1' })
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 67108864,
-                          'version': 'v2',
-                          'lazy-refcounts': True })
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 67108864,
-                          'version': 'v2',
-                          'refcount-bits': 8 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 67108864,
+                         'version': 'v1' })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 67108864,
+                         'version': 'v2',
+                         'lazy-refcounts': True })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 67108864,
+                         'version': 'v2',
+                         'refcount-bits': 8 })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
     iotests.log("=== Invalid backing file options ===")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 67108864,
-                          'backing-file': '/dev/null',
-                          'preallocation': 'full' })
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 67108864,
-                          'backing-fmt': imgfmt })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 67108864,
+                         'backing-file': '/dev/null',
+                         'preallocation': 'full' })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 67108864,
+                         'backing-fmt': imgfmt })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
 
     vm.launch()
     for csize in [ 1234, 128, 4194304, 0 ]:
-        blockdev_create(vm, { 'driver': imgfmt,
-                              'file': 'node0',
-                              'size': 67108864,
-                              'cluster-size': csize })
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 281474976710656,
-                          'cluster-size': 512 })
+        vm.blockdev_create({ 'driver': imgfmt,
+                             'file': 'node0',
+                             'size': 67108864,
+                             'cluster-size': csize })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 281474976710656,
+                         'cluster-size': 512 })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
 
     vm.launch()
     for refcount_bits in [ 128, 0, 7 ]:
-        blockdev_create(vm, { 'driver': imgfmt,
-                              'file': 'node0',
-                              'size': 67108864,
-                              'refcount-bits': refcount_bits })
+        vm.blockdev_create({ 'driver': imgfmt,
+                             'file': 'node0',
+                             'size': 67108864,
+                             'refcount-bits': refcount_bits })
     vm.shutdown()
-- 
2.20.1

Instead of having a separate blockdev_create() function, make use of the
VM.blockdev_create() offered by iotests.py.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/210 | 81 +++++++++++++++++++-----------------------
 1 file changed, 36 insertions(+), 45 deletions(-)

diff --git a/tests/qemu-iotests/210 b/tests/qemu-iotests/210
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/210
+++ b/tests/qemu-iotests/210
@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
 iotests.verify_image_format(supported_fmts=['luks'])
 iotests.verify_protocol(supported=['file'])
 
-def blockdev_create(vm, options):
-    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
-                        filters=[iotests.filter_qmp_testfiles])
-
-    if 'return' in result:
-        assert result['return'] == {}
-        vm.run_job('job0')
-    iotests.log("")
-
 with iotests.FilePath('t.luks') as disk_path, \
      iotests.VM() as vm:
 
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
     size = 128 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
 
     vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
                node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'imgfile',
-                          'key-secret': 'keysec0',
-                          'size': size,
-                          'iter-time': 10 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'imgfile',
+                         'key-secret': 'keysec0',
+                         'size': size,
+                         'iter-time': 10 })
     vm.shutdown()
 
     # TODO Proper support for images to be used with imgopts and/or protocols
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
     size = 64 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': {
-                              'driver': 'file',
-                              'filename': disk_path,
-                          },
-                          'size': size,
-                          'key-secret': 'keysec0',
-                          'cipher-alg': 'twofish-128',
-                          'cipher-mode': 'ctr',
-                          'ivgen-alg': 'plain64',
-                          'ivgen-hash-alg': 'md5',
-                          'hash-alg': 'sha1',
-                          'iter-time': 10 })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': {
+                             'driver': 'file',
+                             'filename': disk_path,
+                         },
+                         'size': size,
+                         'key-secret': 'keysec0',
+                         'cipher-alg': 'twofish-128',
+                         'cipher-mode': 'ctr',
+                         'ivgen-alg': 'plain64',
+                         'ivgen-hash-alg': 'md5',
+                         'hash-alg': 'sha1',
+                         'iter-time': 10 })
     vm.shutdown()
 
     # TODO Proper support for images to be used with imgopts and/or protocols
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
     size = 64 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': "this doesn't exist",
-                          'size': size })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': "this doesn't exist",
+                         'size': size })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
 
     vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'key-secret': 'keysec0',
-                          'size': 0,
-                          'iter-time': 10 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'key-secret': 'keysec0',
+                         'size': 0,
+                         'iter-time': 10 })
     vm.shutdown()
 
     # TODO Proper support for images to be used with imgopts and/or protocols
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
 
     vm.launch()
     for size in [ 18446744073709551104, 9223372036854775808, 9223372036854775296 ]:
-        blockdev_create(vm, { 'driver': imgfmt,
-                              'file': 'node0',
-                              'key-secret': 'keysec0',
-                              'size': size })
+        vm.blockdev_create({ 'driver': imgfmt,
+                             'file': 'node0',
+                             'key-secret': 'keysec0',
+                             'size': size })
     vm.shutdown()
 
     #
-- 
2.20.1

Instead of having a separate blockdev_create() function, make use of the
VM.blockdev_create() offered by iotests.py.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/212 | 101 +++++++++++++++++++----------------------
 1 file changed, 46 insertions(+), 55 deletions(-)

diff --git a/tests/qemu-iotests/212 b/tests/qemu-iotests/212
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/212
+++ b/tests/qemu-iotests/212
@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
 iotests.verify_image_format(supported_fmts=['parallels'])
 iotests.verify_protocol(supported=['file'])
 
-def blockdev_create(vm, options):
-    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
-                        filters=[iotests.filter_qmp_testfiles])
-
-    if 'return' in result:
-        assert result['return'] == {}
-        vm.run_job('job0')
-    iotests.log("")
-
 with iotests.FilePath('t.parallels') as disk_path, \
      iotests.VM() as vm:
 
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
     size = 128 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
 
     vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
                node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'imgfile',
-                          'size': size })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'imgfile',
+                         'size': size })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
     size = 64 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': {
-                              'driver': 'file',
-                              'filename': disk_path,
-                          },
-                          'size': size,
-                          'cluster-size': 1048576 })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': {
+                             'driver': 'file',
+                             'filename': disk_path,
+                         },
+                         'size': size,
+                         'cluster-size': 1048576 })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
     size = 32 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': {
-                              'driver': 'file',
-                              'filename': disk_path,
-                          },
-                          'size': size,
-                          'cluster-size': 65536 })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': {
+                             'driver': 'file',
+                             'filename': disk_path,
+                         },
+                         'size': size,
+                         'cluster-size': 65536 })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
     iotests.log("")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': "this doesn't exist",
-                          'size': size })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': "this doesn't exist",
+                         'size': size })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
 
     vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 0 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 0 })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
     iotests.log("")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 4503599627369984})
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 4503599627369984})
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
     vm.launch()
     for size in [ 1234, 18446744073709551104, 9223372036854775808,
                   9223372036854775296, 4503599627370497 ]:
-        blockdev_create(vm, { 'driver': imgfmt,
-                              'file': 'node0',
-                              'size': size })
+        vm.blockdev_create({ 'driver': imgfmt,
+                             'file': 'node0',
+                             'size': size })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
     vm.launch()
     for csize in [ 1234, 128, 4294967296, 9223372036854775808,
                    18446744073709551104, 0 ]:
-        blockdev_create(vm, { 'driver': imgfmt,
-                              'file': 'node0',
-                              'size': 67108864,
-                              'cluster-size': csize })
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 281474976710656,
-                          'cluster-size': 512 })
+        vm.blockdev_create({ 'driver': imgfmt,
+                             'file': 'node0',
+                             'size': 67108864,
+                             'cluster-size': csize })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 281474976710656,
+                         'cluster-size': 512 })
     vm.shutdown()
-- 
2.20.1

Instead of having a separate blockdev_create() function, make use of the
VM.blockdev_create() offered by iotests.py.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/213 | 113 +++++++++++++++++++----------------------
 1 file changed, 52 insertions(+), 61 deletions(-)

diff --git a/tests/qemu-iotests/213 b/tests/qemu-iotests/213
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/213
+++ b/tests/qemu-iotests/213
@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
 iotests.verify_image_format(supported_fmts=['vhdx'])
 iotests.verify_protocol(supported=['file'])
 
-def blockdev_create(vm, options):
-    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
-                        filters=[iotests.filter_qmp_testfiles])
-
-    if 'return' in result:
-        assert result['return'] == {}
-        vm.run_job('job0')
-    iotests.log("")
-
 with iotests.FilePath('t.vhdx') as disk_path, \
      iotests.VM() as vm:
 
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
     size = 128 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
 
     vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
                node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'imgfile',
-                          'size': size })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'imgfile',
+                         'size': size })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
     size = 64 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': {
-                              'driver': 'file',
-                              'filename': disk_path,
-                          },
-                          'size': size,
-                          'log-size': 1048576,
-                          'block-size': 8388608,
-                          'subformat': 'dynamic',
-                          'block-state-zero': True })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': {
+                             'driver': 'file',
+                             'filename': disk_path,
+                         },
+                         'size': size,
+                         'log-size': 1048576,
+                         'block-size': 8388608,
+                         'subformat': 'dynamic',
+                         'block-state-zero': True })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
     size = 32 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': {
-                              'driver': 'file',
-                              'filename': disk_path,
-                          },
-                          'size': size,
-                          'log-size': 8388608,
-                          'block-size': 268435456,
-                          'subformat': 'fixed',
-                          'block-state-zero': False })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': {
+                             'driver': 'file',
+                             'filename': disk_path,
+                         },
+                         'size': size,
+                         'log-size': 8388608,
+                         'block-size': 268435456,
+                         'subformat': 'fixed',
+                         'block-state-zero': False })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
     iotests.log("")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': "this doesn't exist",
-                          'size': size })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': "this doesn't exist",
+                         'size': size })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
 
     vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 0 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 0 })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
     iotests.log("")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 70368744177664 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 70368744177664 })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
     vm.launch()
     for size in [ 18446744073709551104, 9223372036854775808,
                   9223372036854775296, 70368744177665 ]:
-        blockdev_create(vm, { 'driver': imgfmt,
-                              'file': 'node0',
-                              'size': size })
+        vm.blockdev_create({ 'driver': imgfmt,
+                             'file': 'node0',
+                             'size': size })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
 
     vm.launch()
     for bsize in [ 1234567, 128, 3145728, 536870912, 0 ]:
-        blockdev_create(vm, { 'driver': imgfmt,
-                              'file': 'node0',
-                              'size': 67108864,
-                              'block-size': bsize })
+        vm.blockdev_create({ 'driver': imgfmt,
+                             'file': 'node0',
+                             'size': 67108864,
+                             'block-size': bsize })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
 
     vm.launch()
     for lsize in [ 1234567, 128, 4294967296, 0 ]:
-        blockdev_create(vm, { 'driver': imgfmt,
-                              'file': 'node0',
-                              'size': 67108864,
-                              'log-size': lsize })
+        vm.blockdev_create({ 'driver': imgfmt,
+                             'file': 'node0',
+                             'size': 67108864,
+                             'log-size': lsize })
     vm.shutdown()
-- 
2.20.1

Instead of having a separate blockdev_create() function, make use of the
VM.blockdev_create() offered by iotests.py.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/237 | 139 +++++++++++++++++++----------------------
 1 file changed, 65 insertions(+), 74 deletions(-)

diff --git a/tests/qemu-iotests/237 b/tests/qemu-iotests/237
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/237
+++ b/tests/qemu-iotests/237
@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
 
 iotests.verify_image_format(supported_fmts=['vmdk'])
 
-def blockdev_create(vm, options):
-    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
-                        filters=[iotests.filter_qmp_testfiles])
-
-    if 'return' in result:
-        assert result['return'] == {}
-        vm.run_job('job0')
-    iotests.log("")
-
 with iotests.FilePath('t.vmdk') as disk_path, \
      iotests.FilePath('t.vmdk.1') as extent1_path, \
      iotests.FilePath('t.vmdk.2') as extent2_path, \
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
     size = 5 * 1024 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
 
     vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
                node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'imgfile',
-                          'size': size })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'imgfile',
+                         'size': size })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
     size = 64 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
-
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': {
-                              'driver': 'file',
-                              'filename': disk_path,
-                          },
-                          'size': size,
-                          'extents': [],
-                          'subformat': 'monolithicSparse',
-                          'adapter-type': 'ide',
-                          'hwversion': '4',
-                          'zeroed-grain': False })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
+
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': {
+                             'driver': 'file',
+                             'filename': disk_path,
+                         },
+                         'size': size,
+                         'extents': [],
+                         'subformat': 'monolithicSparse',
+                         'adapter-type': 'ide',
+                         'hwversion': '4',
+                         'zeroed-grain': False })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
     size = 32 * 1024 * 1024
 
     vm.launch()
-    blockdev_create(vm, { 'driver': 'file',
-                          'filename': disk_path,
-                          'size': 0 })
-
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': {
-                              'driver': 'file',
-                              'filename': disk_path,
-                          },
-                          'size': size,
-                          'extents': [],
-                          'subformat': 'monolithicSparse',
-                          'adapter-type': 'buslogic',
-                          'zeroed-grain': True })
+    vm.blockdev_create({ 'driver': 'file',
+                         'filename': disk_path,
+                         'size': 0 })
+
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': {
+                             'driver': 'file',
+                             'filename': disk_path,
+                         },
+                         'size': size,
+                         'extents': [],
+                         'subformat': 'monolithicSparse',
+                         'adapter-type': 'buslogic',
+                         'zeroed-grain': True })
     vm.shutdown()
 
     iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
     iotests.log("")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': "this doesn't exist",
-                          'size': size })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': "this doesn't exist",
+                         'size': size })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
 
     vm.launch()
     for adapter_type in [ 'ide', 'buslogic', 'lsilogic', 'legacyESX' ]:
-        blockdev_create(vm, { 'driver': imgfmt,
-                              'file': 'node0',
-                              'size': size,
-                              'adapter-type': adapter_type })
+        vm.blockdev_create({ 'driver': imgfmt,
+                             'file': 'node0',
+                             'size': size,
+                             'adapter-type': adapter_type })
     vm.shutdown()
 
     # Invalid
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
 
     vm.launch()
     for adapter_type in [ 'foo', 'IDE', 'legacyesx', 1 ]:
-        blockdev_create(vm, { 'driver': imgfmt,
-                              'file': 'node0',
-                              'size': size,
-                              'adapter-type': adapter_type })
+        vm.blockdev_create({ 'driver': imgfmt,
+                             'file': 'node0',
+                             'size': size,
+                             'adapter-type': adapter_type })
     vm.shutdown()
 
     #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
     iotests.log("")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': size,
-                          'subformat': 'monolithicFlat' })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': size,
+                         'subformat': 'monolithicFlat' })
     vm.shutdown()
 
     # Correct extent
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
     iotests.log("")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': size,
-                          'subformat': 'monolithicFlat',
-                          'extents': ['ext1'] })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': size,
+                         'subformat': 'monolithicFlat',
+                         'extents': ['ext1'] })
     vm.shutdown()
 
     # Extra extent
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
     iotests.log("")
 
     vm.launch()
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'node0',
-                          'size': 512,
-                          'subformat': 'monolithicFlat',
-                          'extents': ['ext1', 'ext2', 'ext3'] })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'node0',
+                         'size': 512,
+                         'subformat': 'monolithicFlat',
+                         'extents': ['ext1', 'ext2', 'ext3'] })
     vm.shutdown()
 
     # Split formats
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
             extents = [ "ext%d" % (i) for i in range(1, num_extents + 1) ]
 
             vm.launch()
-            blockdev_create(vm, { 'driver': imgfmt,
-                                  'file': 'node0',
-                                  'size': size,
-                                  'subformat': subfmt,
-                                  'extents': extents })
+            vm.blockdev_create({ 'driver': imgfmt,
+                                 'file': 'node0',
+                                 'size': size,
+                                 'subformat': subfmt,
+                                 'extents': extents })
             vm.shutdown()
 
             iotests.img_info_log(disk_path)
-- 
2.20.1

Instead of having a separate blockdev_create() function, make use of the
VM.blockdev_create() offered by iotests.py.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/266     | 69 +++++++++++++++++---------------------
 tests/qemu-iotests/266.out | 14 ++++++++
 2 files changed, 44 insertions(+), 39 deletions(-)

diff --git a/tests/qemu-iotests/266 b/tests/qemu-iotests/266
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/266
+++ b/tests/qemu-iotests/266
@@ -XXX,XX +XXX,XX @@ import iotests
 from iotests import imgfmt
 
 
-def blockdev_create(vm, options):
-    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
-                        filters=[iotests.filter_qmp_testfiles])
-
-    if 'return' in result:
-        assert result['return'] == {}
-        vm.run_job('job0')
-
-
 # Successful image creation (defaults)
 def implicit_defaults(vm, file_path):
     iotests.log("=== Successful image creation (defaults) ===")
@@ -XXX,XX +XXX,XX @@ def implicit_defaults(vm, file_path):
     # (Close to 64 MB)
     size = 8 * 964 * 17 * 512
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'protocol-node',
-                          'size': size })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'protocol-node',
+                         'size': size })
 
 
 # Successful image creation (explicit defaults)
@@ -XXX,XX +XXX,XX @@ def explicit_defaults(vm, file_path):
     # (Close to 128 MB)
     size = 16 * 964 * 17 * 512
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'protocol-node',
-                          'size': size,
-                          'subformat': 'dynamic',
-                          'force-size': False })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'protocol-node',
+                         'size': size,
+                         'subformat': 'dynamic',
+                         'force-size': False })
 
 
 # Successful image creation (non-default options)
@@ -XXX,XX +XXX,XX @@ def non_defaults(vm, file_path):
     # Not representable in CHS (fine with force-size=True)
     size = 1048576
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'protocol-node',
-                          'size': size,
-                          'subformat': 'fixed',
-                          'force-size': True })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'protocol-node',
+                         'size': size,
+                         'subformat': 'fixed',
+                         'force-size': True })
 
 
 # Size not representable in CHS with force-size=False
@@ -XXX,XX +XXX,XX @@ def non_chs_size_without_force(vm, file_path):
     # Not representable in CHS (will not work with force-size=False)
     size = 1048576
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'protocol-node',
-                          'size': size,
-                          'force-size': False })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'protocol-node',
+                         'size': size,
+                         'force-size': False })
 
 
 # Zero size
@@ -XXX,XX +XXX,XX @@ def zero_size(vm, file_path):
     iotests.log("=== Zero size===")
     iotests.log("")
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'protocol-node',
-                          'size': 0 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'protocol-node',
+                         'size': 0 })
 
 
 # Maximum CHS size
@@ -XXX,XX +XXX,XX @@ def maximum_chs_size(vm, file_path):
     iotests.log("=== Maximum CHS size===")
     iotests.log("")
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'protocol-node',
-                          'size': 16 * 65535 * 255 * 512 })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'protocol-node',
+                         'size': 16 * 65535 * 255 * 512 })
 
 
 # Actual maximum size
@@ -XXX,XX +XXX,XX @@ def maximum_size(vm, file_path):
     iotests.log("=== Actual maximum size===")
     iotests.log("")
 
-    blockdev_create(vm, { 'driver': imgfmt,
-                          'file': 'protocol-node',
-                          'size': 0xff000000 * 512,
-                          'force-size': True })
+    vm.blockdev_create({ 'driver': imgfmt,
+                         'file': 'protocol-node',
+                         'size': 0xff000000 * 512,
+                         'force-size': True })
 
 
 def main():
@@ -XXX,XX +XXX,XX @@ def main():
             vm.launch()
 
             iotests.log('--- Creating empty file ---')
-            blockdev_create(vm, { 'driver': 'file',
-                                  'filename': file_path,
-                                  'size': 0 })
+            vm.blockdev_create({ 'driver': 'file',
+                                 'filename': file_path,
+                                 'size': 0 })
 
             vm.qmp_log('blockdev-add', driver='file', filename=file_path,
                        node_name='protocol-node',
diff --git a/tests/qemu-iotests/266.out b/tests/qemu-iotests/266.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/266.out
+++ b/tests/qemu-iotests/266.out
@@ -XXX,XX +XXX,XX @@
 {"return": {}}
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
+
 {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
 {"return": {}}
 
@@ -XXX,XX +XXX,XX @@
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
 
+
 image: TEST_IMG
 file format: IMGFMT
 virtual size: 64 MiB (67125248 bytes)
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
 {"return": {}}
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
+
 {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
 {"return": {}}
 
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
 
+
 image: TEST_IMG
 file format: IMGFMT
 virtual size: 128 MiB (134250496 bytes)
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
 {"return": {}}
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
+
 {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
 {"return": {}}
 
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
 
+
 image: TEST_IMG
 file format: IMGFMT
 virtual size: 1 MiB (1048576 bytes)
@@ -XXX,XX +XXX,XX @@ virtual size: 1 MiB (1048576 bytes)
 {"return": {}}
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
+
 {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
 {"return": {}}
 
@@ -XXX,XX +XXX,XX @@ Job failed: The requested image size cannot be represented in CHS geometry
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
 
+
 qemu-img: Could not open 'TEST_IMG': File too small for a VHD header
 
 --- Creating empty file ---
@@ -XXX,XX +XXX,XX @@ qemu-img: Could not open 'TEST_IMG': File too small for a VHD header
 {"return": {}}
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
+
 {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
 {"return": {}}
 
@@ -XXX,XX +XXX,XX @@ qemu-img: Could not open 'TEST_IMG': File too small for a VHD header
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
 
+
 image: TEST_IMG
 file format: IMGFMT
 virtual size: 0 B (0 bytes)
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
 {"return": {}}
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
+
 {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
 {"return": {}}
 
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
 
+
 image: TEST_IMG
 file format: IMGFMT
 virtual size: 127 GiB (136899993600 bytes)
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
 {"return": {}}
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
+
 {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
 {"return": {}}
 
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
 {"execute": "job-dismiss", "arguments": {"id": "job0"}}
 {"return": {}}
 
+
 image: TEST_IMG
 file format: IMGFMT
 virtual size: 1.99 TiB (2190433320960 bytes)
-- 
2.20.1

The blockdev_create() function in this test case adds another filter to
the logging, but provides otherwise the same functionality as
VM.blockdev_create() from iotests.py. Make it a thin wrapper around the
iotests.py function.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/207 | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/tests/qemu-iotests/207 b/tests/qemu-iotests/207
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/207
+++ b/tests/qemu-iotests/207
@@ -XXX,XX +XXX,XX @@ def filter_hash(qmsg):
     return iotests.filter_qmp(qmsg, _filter)
 
 def blockdev_create(vm, options):
-    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
-                        filters=[iotests.filter_qmp_testfiles, filter_hash])
-
-    if 'return' in result:
-        assert result['return'] == {}
-        vm.run_job('job0')
-    iotests.log("")
+    vm.blockdev_create(options, filters=[iotests.filter_qmp_testfiles, filter_hash])
 
 with iotests.FilePath('t.img') as disk_path, \
      iotests.VM() as vm:
-- 
2.20.1

The blockdev_create() function in this test case adds an error check
that skips the test in case of failure because of memory shortage, but
provides otherwise the same functionality as VM.blockdev_create() from
iotests.py. Make it a thin wrapper around the iotests.py function.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/211 | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/tests/qemu-iotests/211 b/tests/qemu-iotests/211
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/211
+++ b/tests/qemu-iotests/211
@@ -XXX,XX +XXX,XX @@ iotests.verify_image_format(supported_fmts=['vdi'])
 iotests.verify_protocol(supported=['file'])
 
 def blockdev_create(vm, options):
-    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
-                        filters=[iotests.filter_qmp_testfiles])
-
-    if 'return' in result:
-        assert result['return'] == {}
-        error = vm.run_job('job0')
-        if error and 'Could not allocate bmap' in error:
-            iotests.notrun('Insufficient memory')
-    iotests.log("")
+    error = vm.blockdev_create(options)
+    if error and 'Could not allocate bmap' in error:
+        iotests.notrun('Insufficient memory')
 
 with iotests.FilePath('t.vdi') as disk_path, \
      iotests.VM() as vm:
-- 
2.20.1

bdrv_invalidate_cache_all() assumes that all nodes in a given subtree
are either active or inactive when it starts. Therefore, as soon as it
arrives at an already active node, it stops.

However, this assumption is wrong. For example, it's possible to take a
snapshot of an inactive node, which results in an active overlay over an
inactive backing file. The active overlay is probably also the root node
of an inactive BlockBackend (blk->disable_perm == true).

In this case, bdrv_invalidate_cache_all() does not need to do anything
to activate the overlay node, but it still needs to recurse into the
children and the parents to make sure that after returning success,
really everything is activated.

Cc: qemu-stable@nongnu.org
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 block.c | 50 ++++++++++++++++++++++++--------------------------
 1 file changed, 24 insertions(+), 26 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
         return;
     }
 
-    if (!(bs->open_flags & BDRV_O_INACTIVE)) {
-        return;
-    }
-
     QLIST_FOREACH(child, &bs->children, next) {
         bdrv_co_invalidate_cache(child->bs, &local_err);
         if (local_err) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
      * just keep the extended permissions for the next time that an activation
      * of the image is tried.
      */
-    bs->open_flags &= ~BDRV_O_INACTIVE;
-    bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
-    ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, NULL, &local_err);
-    if (ret < 0) {
-        bs->open_flags |= BDRV_O_INACTIVE;
-        error_propagate(errp, local_err);
-        return;
-    }
-    bdrv_set_perm(bs, perm, shared_perm);
-
-    if (bs->drv->bdrv_co_invalidate_cache) {
-        bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
-        if (local_err) {
+    if (bs->open_flags & BDRV_O_INACTIVE) {
+        bs->open_flags &= ~BDRV_O_INACTIVE;
+        bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
+        ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, NULL, &local_err);
+        if (ret < 0) {
             bs->open_flags |= BDRV_O_INACTIVE;
             error_propagate(errp, local_err);
             return;
         }
-    }
+        bdrv_set_perm(bs, perm, shared_perm);
 
-    FOR_EACH_DIRTY_BITMAP(bs, bm) {
-        bdrv_dirty_bitmap_skip_store(bm, false);
-    }
+        if (bs->drv->bdrv_co_invalidate_cache) {
+            bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
+            if (local_err) {
+                bs->open_flags |= BDRV_O_INACTIVE;
+                error_propagate(errp, local_err);
+                return;
+            }
+        }
 
-    ret = refresh_total_sectors(bs, bs->total_sectors);
-    if (ret < 0) {
-        bs->open_flags |= BDRV_O_INACTIVE;
-        error_setg_errno(errp, -ret, "Could not refresh total sector count");
-        return;
+        FOR_EACH_DIRTY_BITMAP(bs, bm) {
+            bdrv_dirty_bitmap_skip_store(bm, false);
+        }
+
+        ret = refresh_total_sectors(bs, bs->total_sectors);
+        if (ret < 0) {
+            bs->open_flags |= BDRV_O_INACTIVE;
+            error_setg_errno(errp, -ret, "Could not refresh total sector count");
+            return;
+        }
     }
 
     QLIST_FOREACH(parent, &bs->parents, next_parent) {
-- 
2.20.1

In order to issue requests on an existing BlockBackend with the
'qemu-io' HMP command, allow specifying the BlockBackend not only with a
BlockBackend name, but also with a qdev ID/QOM path for a device that
owns the (possibly anonymous) BlockBackend.

Because qdev names could be conflicting with BlockBackend and node
names, introduce a -d option to explicitly address a device. If the
option is not given, a BlockBackend or a node is addressed.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 monitor/hmp-cmds.c | 28 ++++++++++++++++++----------
 hmp-commands.hx    |  8 +++++---
 2 files changed, 23 insertions(+), 13 deletions(-)

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_qemu_io(Monitor *mon, const QDict *qdict)
 {
     BlockBackend *blk;
     BlockBackend *local_blk = NULL;
+    bool qdev = qdict_get_try_bool(qdict, "qdev", false);
     const char* device = qdict_get_str(qdict, "device");
     const char* command = qdict_get_str(qdict, "command");
     Error *err = NULL;
     int ret;
 
-    blk = blk_by_name(device);
-    if (!blk) {
-        BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err);
-        if (bs) {
-            blk = local_blk = blk_new(bdrv_get_aio_context(bs),
-                                      0, BLK_PERM_ALL);
-            ret = blk_insert_bs(blk, bs, &err);
-            if (ret < 0) {
+    if (qdev) {
+        blk = blk_by_qdev_id(device, &err);
+        if (!blk) {
+            goto fail;
+        }
+    } else {
+        blk = blk_by_name(device);
+        if (!blk) {
+            BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err);
+            if (bs) {
+                blk = local_blk = blk_new(bdrv_get_aio_context(bs),
+                                          0, BLK_PERM_ALL);
+                ret = blk_insert_bs(blk, bs, &err);
+                if (ret < 0) {
+                    goto fail;
+                }
+            } else {
                 goto fail;
             }
-        } else {
-            goto fail;
         }
     }
 
diff --git a/hmp-commands.hx b/hmp-commands.hx
index XXXXXXX..XXXXXXX 100644
--- a/hmp-commands.hx
+++ b/hmp-commands.hx
@@ -XXX,XX +XXX,XX @@ ETEXI
 
     {
         .name       = "qemu-io",
-        .args_type  = "device:B,command:s",
-        .params     = "[device] \"[command]\"",
-        .help       = "run a qemu-io command on a block device",
+        .args_type  = "qdev:-d,device:B,command:s",
+        .params     = "[-d] [device] \"[command]\"",
+        .help       = "run a qemu-io command on a block device\n\t\t\t"
+                      "-d: [device] is a device ID rather than a "
+                      "drive ID or node name",
         .cmd        = hmp_qemu_io,
     },
 
-- 
2.20.1

This tests creating an external snapshot with VM state (which results in
an active overlay over an inactive backing file, which is also the root
node of an inactive BlockBackend), re-activating the images and
performing some operations to test that the re-activation worked as
intended.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/280     | 83 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/280.out | 50 +++++++++++++++++++++++
 tests/qemu-iotests/group   |  1 +
 3 files changed, 134 insertions(+)
 create mode 100755 tests/qemu-iotests/280
 create mode 100644 tests/qemu-iotests/280.out

diff --git a/tests/qemu-iotests/280 b/tests/qemu-iotests/280
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/280
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python
+#
+# 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: Kevin Wolf <kwolf@redhat.com>
+#
+# Test migration to file for taking an external snapshot with VM state.
+
+import iotests
+import os
+
+iotests.verify_image_format(supported_fmts=['qcow2'])
+iotests.verify_protocol(supported=['file'])
+iotests.verify_platform(['linux'])
+
+with iotests.FilePath('base') as base_path , \
+     iotests.FilePath('top') as top_path, \
+     iotests.VM() as vm:
+
+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, base_path, '64M')
+
+    iotests.log('=== Launch VM ===')
+    vm.add_object('iothread,id=iothread0')
+    vm.add_blockdev('file,filename=%s,node-name=base-file' % (base_path))
+    vm.add_blockdev('%s,file=base-file,node-name=base-fmt' % (iotests.imgfmt))
+    vm.add_device('virtio-blk,drive=base-fmt,iothread=iothread0,id=vda')
+    vm.launch()
+
+    vm.enable_migration_events('VM')
+
+    iotests.log('\n=== Migrate to file ===')
+    vm.qmp_log('migrate', uri='exec:cat > /dev/null')
+
+    with iotests.Timeout(3, 'Migration does not complete'):
+        vm.wait_migration()
+
+    iotests.log('\nVM is now stopped:')
+    iotests.log(vm.qmp('query-migrate')['return']['status'])
+    vm.qmp_log('query-status')
+
+    iotests.log('\n=== Create a snapshot of the disk image ===')
+    vm.blockdev_create({
+        'driver': 'file',
+        'filename': top_path,
+        'size': 0,
+    })
+    vm.qmp_log('blockdev-add', node_name='top-file',
+               driver='file', filename=top_path,
+               filters=[iotests.filter_qmp_testfiles])
+
+    vm.blockdev_create({
+        'driver': iotests.imgfmt,
+        'file': 'top-file',
+        'size': 1024 * 1024,
+    })
+    vm.qmp_log('blockdev-add', node_name='top-fmt',
+               driver=iotests.imgfmt, file='top-file')
+
+    vm.qmp_log('blockdev-snapshot', node='base-fmt', overlay='top-fmt')
+
+    iotests.log('\n=== Resume the VM and simulate a write request ===')
+    vm.qmp_log('cont')
+    iotests.log(vm.hmp_qemu_io('-d vda/virtio-backend', 'write 4k 4k'))
+
+    iotests.log('\n=== Commit it to the backing file ===')
+    result = vm.qmp_log('block-commit', job_id='job0', auto_dismiss=False,
+                        device='top-fmt', top_node='top-fmt',
+                        filters=[iotests.filter_qmp_testfiles])
+    if 'return' in result:
+        vm.run_job('job0')
diff --git a/tests/qemu-iotests/280.out b/tests/qemu-iotests/280.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/280.out
@@ -XXX,XX +XXX,XX @@
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=67108864 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+=== Launch VM ===
+Enabling migration QMP events on VM...
+{"return": {}}
+
+=== Migrate to file ===
+{"execute": "migrate", "arguments": {"uri": "exec:cat > /dev/null"}}
+{"return": {}}
+{"data": {"status": "setup"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"status": "active"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"status": "completed"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+
+VM is now stopped:
+completed
+{"execute": "query-status", "arguments": {}}
+{"return": {"running": false, "singlestep": false, "status": "postmigrate"}}
+
+=== Create a snapshot of the disk image ===
+{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "file", "filename": "TEST_DIR/PID-top", "size": 0}}}
+{"return": {}}
+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
+{"return": {}}
+
+{"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-top", "node-name": "top-file"}}
+{"return": {}}
+{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "qcow2", "file": "top-file", "size": 1048576}}}
+{"return": {}}
+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
+{"return": {}}
+
+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": "top-file", "node-name": "top-fmt"}}
+{"return": {}}
+{"execute": "blockdev-snapshot", "arguments": {"node": "base-fmt", "overlay": "top-fmt"}}
+{"return": {}}
+
+=== Resume the VM and simulate a write request ===
+{"execute": "cont", "arguments": {}}
+{"return": {}}
+{"return": ""}
+
+=== Commit it to the backing file ===
+{"execute": "block-commit", "arguments": {"auto-dismiss": false, "device": "top-fmt", "job-id": "job0", "top-node": "top-fmt"}}
+{"return": {}}
+{"execute": "job-complete", "arguments": {"id": "job0"}}
+{"return": {}}
+{"data": {"device": "job0", "len": 65536, "offset": 65536, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"device": "job0", "len": 65536, "offset": 65536, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
+{"return": {}}
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 @@
 273 backing quick
 277 rw quick
 279 rw backing quick
+280 rw migration quick
-- 
2.20.1

The following changes since commit 16aaacb307ed607b9780c12702c44f0fe52edc7e:

Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20200430' into staging (2020-04-30 14:00:36 +0100)

are available in the Git repository at:

git://repo.or.cz/qemu/kevin.git tags/for-upstream

for you to fetch changes up to eaae29ef89d498d0eac553c77b554f310a47f809:

qemu-storage-daemon: Fix non-string --object properties (2020-04-30 17:51:07 +0200)

----------------------------------------------------------------
Block layer patches:

- Fix resize (extending) of short overlays
- nvme: introduce PMR support from NVMe 1.4 spec
- qemu-storage-daemon: Fix non-string --object properties

----------------------------------------------------------------
Alberto Garcia (1):
      qcow2: Add incompatibility note between backing files and raw external data files

Andrzej Jakowski (1):
      nvme: introduce PMR support from NVMe 1.4 spec

Kevin Wolf (12):
      block: Add flags to BlockDriver.bdrv_co_truncate()
      block: Add flags to bdrv(_co)_truncate()
      block-backend: Add flags to blk_truncate()
      qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
      raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
      file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
      block: truncate: Don't make backing file data visible
      iotests: Filter testfiles out in filter_img_info()
      iotests: Test committing to short backing file
      qcow2: Forward ZERO_WRITE flag for full preallocation
      qom: Factor out user_creatable_add_dict()
      qemu-storage-daemon: Fix non-string --object properties

Paolo Bonzini (1):
      qemu-iotests: allow qcow2 external discarded clusters to contain stale data

From: Alberto Garcia <berto@igalia.com>

Backing files and raw external data files are mutually exclusive.
The documentation of the raw external data bit (in autoclear_features)
already indicates that, but we should also mention it on the other
side.

Suggested-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-Id: <20200410121816.8334-1-berto@igalia.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 docs/interop/qcow2.txt | 3 +++
 1 file changed, 3 insertions(+)

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:
                     is stored (NB: The string is not null terminated). 0 if the
                     image doesn't have a backing file.
 
+                    Note: backing files are incompatible with raw external data
+                    files (auto-clear feature bit 1).
+
          16 - 19:   backing_file_size
                     Length of the backing file name in bytes. Must not be
                     longer than 1023 bytes. Undefined if the image doesn't have
-- 
2.25.3

From: Paolo Bonzini <pbonzini@redhat.com>

Test 244 checks the expected behavior of qcow2 external data files
with respect to zero and discarded clusters.  Filesystems however
are free to ignore discard requests, and this seems to be the
case for overlayfs.  Relax the tests to skip checks on the
external data file for discarded areas, which implies not using
qemu-img compare in the data_file_raw=on case.

This fixes docker tests on RHEL8.

Cc: Kevin Wolf <kwolf@redhat.com>
Cc: qemu-block@nongnu.org
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20200409191006.24429-1-pbonzini@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/244     | 10 ++++++++--
 tests/qemu-iotests/244.out |  9 ++++++---
 2 files changed, 14 insertions(+), 5 deletions(-)

diff --git a/tests/qemu-iotests/244 b/tests/qemu-iotests/244
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/244
+++ b/tests/qemu-iotests/244
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
 echo
 $QEMU_IO -c 'read -P 0 0 1M' \
          -c 'read -P 0x11 1M 1M' \
-         -c 'read -P 0 2M 2M' \
          -c 'read -P 0x11 4M 1M' \
          -c 'read -P 0 5M 1M' \
          -f raw "$TEST_IMG.data" |
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'read -P 0 0 1M' \
          -f $IMGFMT "$TEST_IMG" |
          _filter_qemu_io
 
+# Discarded clusters are only marked as such in the qcow2 metadata, but
+# they can contain stale data in the external data file.  Instead, zero
+# clusters must be zeroed in the external data file too.
 echo
-$QEMU_IMG compare "$TEST_IMG" "$TEST_IMG.data"
+$QEMU_IO -c 'read -P 0 0 1M' \
+         -c 'read -P 0x11 1M 1M' \
+         -c 'read -P 0 3M 3M' \
+         -f raw "$TEST_IMG".data |
+         _filter_qemu_io
 
 echo -n "qcow2 file size after I/O: "
 du -b $TEST_IMG | cut -f1
diff --git a/tests/qemu-iotests/244.out b/tests/qemu-iotests/244.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/244.out
+++ b/tests/qemu-iotests/244.out
@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0
 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 read 1048576/1048576 bytes at offset 1048576
 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-read 2097152/2097152 bytes at offset 2097152
-2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 read 1048576/1048576 bytes at offset 4194304
 1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 read 1048576/1048576 bytes at offset 5242880
@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 1048576
 read 4194304/4194304 bytes at offset 2097152
 4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
-Images are identical.
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 3145728/3145728 bytes at offset 3145728
+3 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 qcow2 file size after I/O: 327680
 
 === bdrv_co_block_status test for file and offset=0 ===
-- 
2.25.3

This adds a new BdrvRequestFlags parameter to the .bdrv_co_truncate()
driver callbacks, and a supported_truncate_flags field in
BlockDriverState that allows drivers to advertise support for request
flags in the context of truncate.

For now, we always pass 0 and no drivers declare support for any flag.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424125448.63318-2-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block_int.h   | 10 +++++++++-
 block/crypto.c              |  3 ++-
 block/file-posix.c          |  2 +-
 block/file-win32.c          |  2 +-
 block/gluster.c             |  1 +
 block/io.c                  |  8 +++++++-
 block/iscsi.c               |  2 +-
 block/nfs.c                 |  3 ++-
 block/qcow2.c               |  2 +-
 block/qed.c                 |  1 +
 block/raw-format.c          |  2 +-
 block/rbd.c                 |  1 +
 block/sheepdog.c            |  4 ++--
 block/ssh.c                 |  2 +-
 tests/test-block-iothread.c |  3 ++-
 15 files changed, 33 insertions(+), 13 deletions(-)

diff --git a/include/block/block_int.h b/include/block/block_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
      */
     int coroutine_fn (*bdrv_co_truncate)(BlockDriverState *bs, int64_t offset,
                                          bool exact, PreallocMode prealloc,
-                                         Error **errp);
+                                         BdrvRequestFlags flags, Error **errp);
 
     int64_t (*bdrv_getlength)(BlockDriverState *bs);
     bool has_variable_length;
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
     /* Flags honored during pwrite_zeroes (so far: BDRV_REQ_FUA,
      * BDRV_REQ_MAY_UNMAP, BDRV_REQ_WRITE_UNCHANGED) */
     unsigned int supported_zero_flags;
+    /*
+     * Flags honoured during truncate (so far: BDRV_REQ_ZERO_WRITE).
+     *
+     * If BDRV_REQ_ZERO_WRITE is given, the truncate operation must make sure
+     * that any added space reads as all zeros. If this can't be guaranteed,
+     * the operation must fail.
+     */
+    unsigned int supported_truncate_flags;
 
     /* the following member gives a name to every node on the bs graph. */
     char node_name[32];
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static int block_crypto_co_create_generic(BlockDriverState *bs,
 
 static int coroutine_fn
 block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                         PreallocMode prealloc, Error **errp)
+                         PreallocMode prealloc, BdrvRequestFlags flags,
+                         Error **errp)
 {
     BlockCrypto *crypto = bs->opaque;
     uint64_t payload_offset =
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 @@ raw_regular_truncate(BlockDriverState *bs, int fd, int64_t offset,
 
 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVRawState *s = bs->opaque;
     struct stat st;
diff --git a/block/file-win32.c b/block/file-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-win32.c
+++ b/block/file-win32.c
@@ -XXX,XX +XXX,XX @@ static void raw_close(BlockDriverState *bs)
 
 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVRawState *s = bs->opaque;
     LONG low, high;
diff --git a/block/gluster.c b/block/gluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/gluster.c
+++ b/block/gluster.c
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qemu_gluster_co_truncate(BlockDriverState *bs,
                                                  int64_t offset,
                                                  bool exact,
                                                  PreallocMode prealloc,
+                                                 BdrvRequestFlags flags,
                                                  Error **errp)
 {
     BDRVGlusterState *s = bs->opaque;
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
     BlockDriverState *bs = child->bs;
     BlockDriver *drv = bs->drv;
     BdrvTrackedRequest req;
+    BdrvRequestFlags flags = 0;
     int64_t old_size, new_bytes;
     int ret;
 
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
     }
 
     if (drv->bdrv_co_truncate) {
-        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, errp);
+        if (flags & ~bs->supported_truncate_flags) {
+            error_setg(errp, "Block driver does not support requested flags");
+            ret = -ENOTSUP;
+            goto out;
+        }
+        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
     } else if (bs->file && drv->is_filter) {
         ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
     } else {
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 void iscsi_reopen_commit(BDRVReopenState *reopen_state)
 
 static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,
                                           bool exact, PreallocMode prealloc,
-                                          Error **errp)
+                                          BdrvRequestFlags flags, Error **errp)
 {
     IscsiLun *iscsilun = bs->opaque;
     int64_t cur_length;
diff --git a/block/nfs.c b/block/nfs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static int64_t nfs_get_allocated_file_size(BlockDriverState *bs)
 
 static int coroutine_fn
 nfs_file_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                     PreallocMode prealloc, Error **errp)
+                     PreallocMode prealloc, BdrvRequestFlags flags,
+                     Error **errp)
 {
     NFSClient *client = bs->opaque;
     int ret;
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ fail:
 
 static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
                                           bool exact, PreallocMode prealloc,
-                                          Error **errp)
+                                          BdrvRequestFlags flags, Error **errp)
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t old_length;
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_truncate(BlockDriverState *bs,
                                              int64_t offset,
                                              bool exact,
                                              PreallocMode prealloc,
+                                             BdrvRequestFlags flags,
                                              Error **errp)
 {
     BDRVQEDState *s = bs->opaque;
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
 
 static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVRawState *s = bs->opaque;
 
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qemu_rbd_co_truncate(BlockDriverState *bs,
                                              int64_t offset,
                                              bool exact,
                                              PreallocMode prealloc,
+                                             BdrvRequestFlags flags,
                                              Error **errp)
 {
     int r;
diff --git a/block/sheepdog.c b/block/sheepdog.c
index XXXXXXX..XXXXXXX 100644
--- a/block/sheepdog.c
+++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static int64_t sd_getlength(BlockDriverState *bs)
 
 static int coroutine_fn sd_co_truncate(BlockDriverState *bs, int64_t offset,
                                        bool exact, PreallocMode prealloc,
-                                       Error **errp)
+                                       BdrvRequestFlags flags, Error **errp)
 {
     BDRVSheepdogState *s = bs->opaque;
     int ret, fd;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int sd_co_writev(BlockDriverState *bs, int64_t sector_num,
 
     assert(!flags);
     if (offset > s->inode.vdi_size) {
-        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, NULL);
+        ret = sd_co_truncate(bs, offset, false, PREALLOC_MODE_OFF, 0, NULL);
         if (ret < 0) {
             return ret;
         }
diff --git a/block/ssh.c b/block/ssh.c
index XXXXXXX..XXXXXXX 100644
--- a/block/ssh.c
+++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static int64_t ssh_getlength(BlockDriverState *bs)
 
 static int coroutine_fn ssh_co_truncate(BlockDriverState *bs, int64_t offset,
                                         bool exact, PreallocMode prealloc,
-                                        Error **errp)
+                                        BdrvRequestFlags flags, Error **errp)
 {
     BDRVSSHState *s = bs->opaque;
 
diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-block-iothread.c
+++ b/tests/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_test_co_pdiscard(BlockDriverState *bs,
 
 static int coroutine_fn
 bdrv_test_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
-                      PreallocMode prealloc, Error **errp)
+                      PreallocMode prealloc, BdrvRequestFlags flags,
+                      Error **errp)
 {
     return 0;
 }
-- 
2.25.3

Now that block drivers can support flags for .bdrv_co_truncate, expose
the parameter in the node level interfaces bdrv_co_truncate() and
bdrv_truncate().

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424125448.63318-3-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block.h       |  5 +++--
 block/block-backend.c       |  2 +-
 block/crypto.c              |  2 +-
 block/io.c                  | 12 +++++++-----
 block/parallels.c           |  6 +++---
 block/qcow.c                |  4 ++--
 block/qcow2-refcount.c      |  2 +-
 block/qcow2.c               | 15 +++++++++------
 block/raw-format.c          |  2 +-
 block/vhdx-log.c            |  2 +-
 block/vhdx.c                |  2 +-
 block/vmdk.c                |  2 +-
 tests/test-block-iothread.c |  6 +++---
 13 files changed, 34 insertions(+), 28 deletions(-)

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 @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
 void bdrv_refresh_filename(BlockDriverState *bs);
 
 int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
-                                  PreallocMode prealloc, Error **errp);
+                                  PreallocMode prealloc, BdrvRequestFlags flags,
+                                  Error **errp);
 int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
-                  PreallocMode prealloc, Error **errp);
+                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
 
 int64_t bdrv_nb_sectors(BlockDriverState *bs);
 int64_t bdrv_getlength(BlockDriverState *bs);
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
         return -ENOMEDIUM;
     }
 
-    return bdrv_truncate(blk->root, offset, exact, prealloc, errp);
+    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
 }
 
 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
 
     offset += payload_offset;
 
-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
+    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
 }
 
 static void block_crypto_close(BlockDriverState *bs)
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_parent_cb_resize(BlockDriverState *bs)
  * 'offset' bytes in length.
  */
 int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
-                                  PreallocMode prealloc, Error **errp)
+                                  PreallocMode prealloc, BdrvRequestFlags flags,
+                                  Error **errp)
 {
     BlockDriverState *bs = child->bs;
     BlockDriver *drv = bs->drv;
     BdrvTrackedRequest req;
-    BdrvRequestFlags flags = 0;
     int64_t old_size, new_bytes;
     int ret;
 
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
         }
         ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
     } else if (bs->file && drv->is_filter) {
-        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
+        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
     } else {
         error_setg(errp, "Image format driver does not support resize");
         ret = -ENOTSUP;
@@ -XXX,XX +XXX,XX @@ typedef struct TruncateCo {
     int64_t offset;
     bool exact;
     PreallocMode prealloc;
+    BdrvRequestFlags flags;
     Error **errp;
     int ret;
 } TruncateCo;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_truncate_co_entry(void *opaque)
 {
     TruncateCo *tco = opaque;
     tco->ret = bdrv_co_truncate(tco->child, tco->offset, tco->exact,
-                                tco->prealloc, tco->errp);
+                                tco->prealloc, tco->flags, tco->errp);
     aio_wait_kick();
 }
 
 int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
-                  PreallocMode prealloc, Error **errp)
+                  PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
 {
     Coroutine *co;
     TruncateCo tco = {
@@ -XXX,XX +XXX,XX @@ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
         .offset     = offset,
         .exact      = exact,
         .prealloc   = prealloc,
+        .flags      = flags,
         .errp       = errp,
         .ret        = NOT_DONE,
     };
diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
         } else {
             ret = bdrv_truncate(bs->file,
                                 (s->data_end + space) << BDRV_SECTOR_BITS,
-                                false, PREALLOC_MODE_OFF, NULL);
+                                false, PREALLOC_MODE_OFF, 0, NULL);
         }
         if (ret < 0) {
             return ret;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn parallels_co_check(BlockDriverState *bs,
              * That means we have to pass exact=true.
              */
             ret = bdrv_truncate(bs->file, res->image_end_offset, true,
-                                PREALLOC_MODE_OFF, &local_err);
+                                PREALLOC_MODE_OFF, 0, &local_err);
             if (ret < 0) {
                 error_report_err(local_err);
                 res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static void parallels_close(BlockDriverState *bs)
 
         /* errors are ignored, so we might as well pass exact=true */
         bdrv_truncate(bs->file, s->data_end << BDRV_SECTOR_BITS, true,
-                      PREALLOC_MODE_OFF, NULL);
+                      PREALLOC_MODE_OFF, 0, NULL);
     }
 
     g_free(s->bat_dirty_bmap);
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
                     return -E2BIG;
                 }
                 ret = bdrv_truncate(bs->file, cluster_offset + s->cluster_size,
-                                    false, PREALLOC_MODE_OFF, NULL);
+                                    false, PREALLOC_MODE_OFF, 0, NULL);
                 if (ret < 0) {
                     return ret;
                 }
@@ -XXX,XX +XXX,XX @@ static int qcow_make_empty(BlockDriverState *bs)
             l1_length) < 0)
         return -1;
     ret = bdrv_truncate(bs->file, s->l1_table_offset + l1_length, false,
-                        PREALLOC_MODE_OFF, NULL);
+                        PREALLOC_MODE_OFF, 0, NULL);
     if (ret < 0)
         return ret;
 
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
                 }
 
                 ret = bdrv_truncate(bs->file, offset + s->cluster_size, false,
-                                    PREALLOC_MODE_OFF, &local_err);
+                                    PREALLOC_MODE_OFF, 0, &local_err);
                 if (ret < 0) {
                     error_report_err(local_err);
                     goto resize_fail;
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 int coroutine_fn preallocate_co(BlockDriverState *bs, uint64_t offset,
             mode = PREALLOC_MODE_OFF;
         }
         ret = bdrv_co_truncate(s->data_file, host_offset + cur_bytes, false,
-                               mode, errp);
+                               mode, 0, errp);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
              * always fulfilled, so there is no need to pass it on.)
              */
             bdrv_co_truncate(bs->file, (last_cluster + 1) * s->cluster_size,
-                             false, PREALLOC_MODE_OFF, &local_err);
+                             false, PREALLOC_MODE_OFF, 0, &local_err);
             if (local_err) {
                 warn_reportf_err(local_err,
                                  "Failed to truncate the tail of the image: ");
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
              * file should be resized to the exact target size, too,
              * so we pass @exact here.
              */
-            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, errp);
+            ret = bdrv_co_truncate(s->data_file, offset, exact, prealloc, 0,
+                                   errp);
             if (ret < 0) {
                 goto fail;
             }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
         new_file_size = allocation_start +
                         nb_new_data_clusters * s->cluster_size;
         /* Image file grows, so @exact does not matter */
-        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, errp);
+        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
+                               errp);
         if (ret < 0) {
             error_prepend(errp, "Failed to resize underlying file: ");
             qcow2_free_clusters(bs, allocation_start,
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed_part(BlockDriverState *bs,
         if (len < 0) {
             return len;
         }
-        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, NULL);
+        return bdrv_co_truncate(bs->file, len, false, PREALLOC_MODE_OFF, 0,
+                                NULL);
     }
 
     if (offset_into_cluster(s, offset)) {
@@ -XXX,XX +XXX,XX @@ static int make_completely_empty(BlockDriverState *bs)
     }
 
     ret = bdrv_truncate(bs->file, (3 + l1_clusters) * s->cluster_size, false,
-                        PREALLOC_MODE_OFF, &local_err);
+                        PREALLOC_MODE_OFF, 0, &local_err);
     if (ret < 0) {
         error_report_err(local_err);
         goto fail;
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
 
     s->size = offset;
     offset += s->offset;
-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
+    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
 }
 
 static void raw_eject(BlockDriverState *bs, bool eject_flag)
diff --git a/block/vhdx-log.c b/block/vhdx-log.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx-log.c
+++ b/block/vhdx-log.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_flush(BlockDriverState *bs, BDRVVHDXState *s,
                     goto exit;
                 }
                 ret = bdrv_truncate(bs->file, new_file_size, false,
-                                    PREALLOC_MODE_OFF, NULL);
+                                    PREALLOC_MODE_OFF, 0, NULL);
                 if (ret < 0) {
                     goto exit;
                 }
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
     }
 
     return bdrv_truncate(bs->file, *new_offset + s->block_size, false,
-                         PREALLOC_MODE_OFF, NULL);
+                         PREALLOC_MODE_OFF, 0, NULL);
 }
 
 /*
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
             }
             length = QEMU_ALIGN_UP(length, BDRV_SECTOR_SIZE);
             ret = bdrv_truncate(s->extents[i].file, length, false,
-                                PREALLOC_MODE_OFF, NULL);
+                                PREALLOC_MODE_OFF, 0, NULL);
             if (ret < 0) {
                 return ret;
             }
diff --git a/tests/test-block-iothread.c b/tests/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-block-iothread.c
+++ b/tests/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_sync_op_truncate(BdrvChild *c)
     int ret;
 
     /* Normal success path */
-    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
+    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, 0);
 
     /* Early error: Negative offset */
-    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, NULL);
+    ret = bdrv_truncate(c, -2, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, -EINVAL);
 
     /* Error: Read-only image */
     c->bs->read_only = true;
     c->bs->open_flags &= ~BDRV_O_RDWR;
 
-    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, NULL);
+    ret = bdrv_truncate(c, 65536, false, PREALLOC_MODE_OFF, 0, NULL);
     g_assert_cmpint(ret, ==, -EACCES);
 
     c->bs->read_only = false;
-- 
2.25.3

Now that node level interface bdrv_truncate() supports passing request
flags to the block driver, expose this on the BlockBackend level, too.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424125448.63318-4-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/sysemu/block-backend.h | 2 +-
 block.c                        | 3 ++-
 block/block-backend.c          | 4 ++--
 block/commit.c                 | 4 ++--
 block/crypto.c                 | 2 +-
 block/mirror.c                 | 2 +-
 block/qcow2.c                  | 4 ++--
 block/qed.c                    | 2 +-
 block/vdi.c                    | 2 +-
 block/vhdx.c                   | 4 ++--
 block/vmdk.c                   | 6 +++---
 block/vpc.c                    | 2 +-
 blockdev.c                     | 2 +-
 qemu-img.c                     | 2 +-
 qemu-io-cmds.c                 | 2 +-
 15 files changed, 22 insertions(+), 21 deletions(-)

diff --git a/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
index XXXXXXX..XXXXXXX 100644
--- a/include/sysemu/block-backend.h
+++ b/include/sysemu/block-backend.h
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwrite_zeroes(BlockBackend *blk, int64_t offset,
 int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
                           int bytes);
 int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
-                 PreallocMode prealloc, Error **errp);
+                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
 int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes);
 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
                      int64_t pos, int size);
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,
     int64_t size;
     int ret;
 
-    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);
+    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
+                       &local_err);
     if (ret < 0 && ret != -ENOTSUP) {
         error_propagate(errp, local_err);
         return ret;
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
 }
 
 int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
-                 PreallocMode prealloc, Error **errp)
+                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
 {
     if (!blk_is_available(blk)) {
         error_setg(errp, "No medium inserted");
         return -ENOMEDIUM;
     }
 
-    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
+    return bdrv_truncate(blk->root, offset, exact, prealloc, flags, errp);
 }
 
 int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
diff --git a/block/commit.c b/block/commit.c
index XXXXXXX..XXXXXXX 100644
--- a/block/commit.c
+++ b/block/commit.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
     }
 
     if (base_len < len) {
-        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, NULL);
+        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, 0, NULL);
         if (ret) {
             goto out;
         }
@@ -XXX,XX +XXX,XX @@ int bdrv_commit(BlockDriverState *bs)
      * grow the backing file image if possible.  If not possible,
      * we must return an error */
     if (length > backing_length) {
-        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF,
+        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF, 0,
                            &local_err);
         if (ret < 0) {
             error_report_err(local_err);
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ static ssize_t block_crypto_init_func(QCryptoBlock *block,
      * which will be used by the crypto header
      */
     return blk_truncate(data->blk, data->size + headerlen, false,
-                        data->prealloc, errp);
+                        data->prealloc, 0, errp);
 }
 
 
diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
 
         if (s->bdev_length > base_length) {
             ret = blk_truncate(s->target, s->bdev_length, false,
-                               PREALLOC_MODE_OFF, NULL);
+                               PREALLOC_MODE_OFF, 0, NULL);
             if (ret < 0) {
                 goto immediate_exit;
             }
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
 
     /* Okay, now that we have a valid image, let's give it the right size */
     ret = blk_truncate(blk, qcow2_opts->size, false, qcow2_opts->preallocation,
-                       errp);
+                       0, errp);
     if (ret < 0) {
         error_prepend(errp, "Could not resize image: ");
         goto out;
@@ -XXX,XX +XXX,XX @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
          * Amending image options should ensure that the image has
          * exactly the given new values, so pass exact=true here.
          */
-        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, errp);
+        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, 0, errp);
         blk_unref(blk);
         if (ret < 0) {
             return ret;
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
      * The QED format associates file length with allocation status,
      * so a new file (which is empty) must have a length of 0.
      */
-    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, errp);
+    ret = blk_truncate(blk, 0, true, PREALLOC_MODE_OFF, 0, errp);
     if (ret < 0) {
         goto out;
     }
diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
 
     if (image_type == VDI_TYPE_STATIC) {
         ret = blk_truncate(blk, offset + blocks * block_size, false,
-                           PREALLOC_MODE_OFF, errp);
+                           PREALLOC_MODE_OFF, 0, errp);
         if (ret < 0) {
             error_prepend(errp, "Failed to statically allocate file");
             goto exit;
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
         /* All zeroes, so we can just extend the file - the end of the BAT
          * is the furthest thing we have written yet */
         ret = blk_truncate(blk, data_file_offset, false, PREALLOC_MODE_OFF,
-                           errp);
+                           0, errp);
         if (ret < 0) {
             goto exit;
         }
     } else if (type == VHDX_TYPE_FIXED) {
         ret = blk_truncate(blk, data_file_offset + image_size, false,
-                           PREALLOC_MODE_OFF, errp);
+                           PREALLOC_MODE_OFF, 0, errp);
         if (ret < 0) {
             goto exit;
         }
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
     int gd_buf_size;
 
     if (flat) {
-        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, errp);
+        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, 0, errp);
         goto exit;
     }
     magic = cpu_to_be32(VMDK4_MAGIC);
@@ -XXX,XX +XXX,XX @@ static int vmdk_init_extent(BlockBackend *blk,
     }
 
     ret = blk_truncate(blk, le64_to_cpu(header.grain_offset) << 9, false,
-                       PREALLOC_MODE_OFF, errp);
+                       PREALLOC_MODE_OFF, 0, errp);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn vmdk_co_do_create(int64_t size,
     /* bdrv_pwrite write padding zeros to align to sector, we don't need that
      * for description file */
     if (desc_offset == 0) {
-        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, errp);
+        ret = blk_truncate(blk, desc_len, false, PREALLOC_MODE_OFF, 0, errp);
         if (ret < 0) {
             goto exit;
         }
diff --git a/block/vpc.c b/block/vpc.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int create_fixed_disk(BlockBackend *blk, uint8_t *buf,
     /* Add footer to total size */
     total_size += HEADER_SIZE;
 
-    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, errp);
+    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
     if (ret < 0) {
         return ret;
     }
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_block_resize(bool has_device, const char *device,
     }
 
     bdrv_drained_begin(bs);
-    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, errp);
+    ret = blk_truncate(blk, size, false, PREALLOC_MODE_OFF, 0, errp);
     bdrv_drained_end(bs);
 
 out:
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_resize(int argc, char **argv)
      * resizing, so pass @exact=true.  It is of no use to report
      * success when the image has not actually been resized.
      */
-    ret = blk_truncate(blk, total_size, true, prealloc, &err);
+    ret = blk_truncate(blk, total_size, true, prealloc, 0, &err);
     if (!ret) {
         qprintf(quiet, "Image resized.\n");
     } else {
diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -XXX,XX +XXX,XX @@ static int truncate_f(BlockBackend *blk, int argc, char **argv)
      * exact=true.  It is better to err on the "emit more errors" side
      * than to be overly permissive.
      */
-    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, &local_err);
+    ret = blk_truncate(blk, offset, true, PREALLOC_MODE_OFF, 0, &local_err);
     if (ret < 0) {
         error_report_err(local_err);
         return ret;
-- 
2.25.3

If BDRV_REQ_ZERO_WRITE is set and we're extending the image, calling
qcow2_cluster_zeroize() with flags=0 does the right thing: It doesn't
undo any previous preallocation, but just adds the zero flag to all
relevant L2 entries. If an external data file is in use, a write_zeroes
request to the data file is made instead.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200424125448.63318-5-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2-cluster.c |  2 +-
 block/qcow2.c         | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 35 insertions(+), 1 deletion(-)

diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ int qcow2_cluster_zeroize(BlockDriverState *bs, uint64_t offset,
     /* Caller must pass aligned values, except at image end */
     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
     assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) ||
-           end_offset == bs->total_sectors << BDRV_SECTOR_BITS);
+           end_offset >= bs->total_sectors << BDRV_SECTOR_BITS);
 
     /* The zero flag is only supported by version 3 and newer */
     if (s->qcow_version < 3) {
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 int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
 
     bs->supported_zero_flags = header.version >= 3 ?
                                BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
+    bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
 
     /* Repair image if dirty */
     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
         g_assert_not_reached();
     }
 
+    if ((flags & BDRV_REQ_ZERO_WRITE) && offset > old_length) {
+        uint64_t zero_start = QEMU_ALIGN_UP(old_length, s->cluster_size);
+
+        /*
+         * Use zero clusters as much as we can. qcow2_cluster_zeroize()
+         * requires a cluster-aligned start. The end may be unaligned if it is
+         * at the end of the image (which it is here).
+         */
+        ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
+        if (ret < 0) {
+            error_setg_errno(errp, -ret, "Failed to zero out new clusters");
+            goto fail;
+        }
+
+        /* Write explicit zeros for the unaligned head */
+        if (zero_start > old_length) {
+            uint64_t len = zero_start - old_length;
+            uint8_t *buf = qemu_blockalign0(bs, len);
+            QEMUIOVector qiov;
+            qemu_iovec_init_buf(&qiov, buf, len);
+
+            qemu_co_mutex_unlock(&s->lock);
+            ret = qcow2_co_pwritev_part(bs, old_length, len, &qiov, 0, 0);
+            qemu_co_mutex_lock(&s->lock);
+
+            qemu_vfree(buf);
+            if (ret < 0) {
+                error_setg_errno(errp, -ret, "Failed to zero out the new area");
+                goto fail;
+            }
+        }
+    }
+
     if (prealloc != PREALLOC_MODE_OFF) {
         /* Flush metadata before actually changing the image size */
         ret = qcow2_write_caches(bs);
-- 
2.25.3

The raw format driver can simply forward the flag and let its bs->file
child take care of actually providing the zeros.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200424125448.63318-6-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/raw-format.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
 
     s->size = offset;
     offset += s->offset;
-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
+    return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
 }
 
 static void raw_eject(BlockDriverState *bs, bool eject_flag)
@@ -XXX,XX +XXX,XX @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
     bs->supported_zero_flags = BDRV_REQ_WRITE_UNCHANGED |
         ((BDRV_REQ_FUA | BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK) &
             bs->file->bs->supported_zero_flags);
+    bs->supported_truncate_flags = bs->file->bs->supported_truncate_flags &
+                                   BDRV_REQ_ZERO_WRITE;
 
     if (bs->probed && !bdrv_is_read_only(bs)) {
         bdrv_refresh_filename(bs->file->bs);
-- 
2.25.3

For regular files, we always get BDRV_REQ_ZERO_WRITE behaviour from the
OS, so we can advertise the flag and just ignore it.

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
 #endif
 
     bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
+    if (S_ISREG(st.st_mode)) {
+        /* When extending regular files, we get zeros from the OS */
+        bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
+    }
     ret = 0;
 fail:
     if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
-- 
2.25.3

When extending the size of an image that has a backing file larger than
its old size, make sure that the backing file data doesn't become
visible in the guest, but the added area is properly zeroed out.

Consider the following scenario where the overlay is shorter than its
backing file:

base.qcow2:     AAAAAAAA
    overlay.qcow2:  BBBB

When resizing (extending) overlay.qcow2, the new blocks should not stay
unallocated and make the additional As from base.qcow2 visible like
before this patch, but zeros should be read.

A similar case happens with the various variants of a commit job when an
intermediate file is short (- for unallocated):

base.qcow2:     A-A-AAAA
    mid.qcow2:      BB-B
    top.qcow2:      C--C--C-

After commit top.qcow2 to mid.qcow2, the following happens:

mid.qcow2:      CB-C00C0 (correct result)
    mid.qcow2:      CB-C--C- (before this fix)

Without the fix, blocks that previously read as zeros on top.qcow2
suddenly turn into A.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200424125448.63318-8-kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/io.c | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
         goto out;
     }
 
+    /*
+     * If the image has a backing file that is large enough that it would
+     * provide data for the new area, we cannot leave it unallocated because
+     * then the backing file content would become visible. Instead, zero-fill
+     * the new area.
+     *
+     * Note that if the image has a backing file, but was opened without the
+     * backing file, taking care of keeping things consistent with that backing
+     * file is the user's responsibility.
+     */
+    if (new_bytes && bs->backing) {
+        int64_t backing_len;
+
+        backing_len = bdrv_getlength(backing_bs(bs));
+        if (backing_len < 0) {
+            ret = backing_len;
+            error_setg_errno(errp, -ret, "Could not get backing file size");
+            goto out;
+        }
+
+        if (backing_len > old_size) {
+            flags |= BDRV_REQ_ZERO_WRITE;
+        }
+    }
+
     if (drv->bdrv_co_truncate) {
         if (flags & ~bs->supported_truncate_flags) {
             error_setg(errp, "Block driver does not support requested flags");
-- 
2.25.3

We want to keep TEST_IMG for the full path of the main test image, but
filter_testfiles() must be called for other test images before replacing
other things like the image format because the test directory path could
contain the format as a substring.

Insert a filter_testfiles() call between both.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200424125448.63318-9-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/iotests.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/iotests.py
+++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@ def filter_img_info(output, filename):
     for line in output.split('\n'):
         if 'disk size' in line or 'actual-size' in line:
             continue
-        line = line.replace(filename, 'TEST_IMG') \
-                   .replace(imgfmt, 'IMGFMT')
+        line = line.replace(filename, 'TEST_IMG')
+        line = filter_testfiles(line)
+        line = line.replace(imgfmt, 'IMGFMT')
         line = re.sub('iters: [0-9]+', 'iters: XXX', line)
         line = re.sub('uuid: [-a-f0-9]+', 'uuid: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX', line)
         line = re.sub('cid: [0-9]+', 'cid: XXXXXXXXXX', line)
-- 
2.25.3

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200424125448.63318-10-kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/274     | 155 +++++++++++++++++++++
 tests/qemu-iotests/274.out | 268 +++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/group   |   1 +
 3 files changed, 424 insertions(+)
 create mode 100755 tests/qemu-iotests/274
 create mode 100644 tests/qemu-iotests/274.out

diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/274
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python3
+#
+# 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: Kevin Wolf <kwolf@redhat.com>
+#
+# Some tests for short backing files and short overlays
+
+import iotests
+
+iotests.verify_image_format(supported_fmts=['qcow2'])
+iotests.verify_platform(['linux'])
+
+size_short = 1 * 1024 * 1024
+size_long = 2 * 1024 * 1024
+size_diff = size_long - size_short
+
+def create_chain() -> None:
+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, base,
+                         str(size_long))
+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, mid,
+                         str(size_short))
+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', mid, top,
+                         str(size_long))
+
+    iotests.qemu_io_log('-c', 'write -P 1 0 %d' % size_long, base)
+
+def create_vm() -> iotests.VM:
+    vm = iotests.VM()
+    vm.add_blockdev('file,filename=%s,node-name=base-file' % base)
+    vm.add_blockdev('%s,file=base-file,node-name=base' % iotests.imgfmt)
+    vm.add_blockdev('file,filename=%s,node-name=mid-file' % mid)
+    vm.add_blockdev('%s,file=mid-file,node-name=mid,backing=base'
+                    % iotests.imgfmt)
+    vm.add_drive(top, 'backing=mid,node-name=top')
+    return vm
+
+with iotests.FilePath('base') as base, \
+     iotests.FilePath('mid') as mid, \
+     iotests.FilePath('top') as top:
+
+    iotests.log('== Commit tests ==')
+
+    create_chain()
+
+    iotests.log('=== Check visible data ===')
+
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, top)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), top)
+
+    iotests.log('=== Checking allocation status ===')
+
+    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
+                        '-c', 'alloc %d %d' % (size_short, size_diff),
+                        base)
+
+    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
+                        '-c', 'alloc %d %d' % (size_short, size_diff),
+                        mid)
+
+    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
+                        '-c', 'alloc %d %d' % (size_short, size_diff),
+                        top)
+
+    iotests.log('=== Checking map ===')
+
+    iotests.qemu_img_log('map', '--output=json', base)
+    iotests.qemu_img_log('map', '--output=human', base)
+    iotests.qemu_img_log('map', '--output=json', mid)
+    iotests.qemu_img_log('map', '--output=human', mid)
+    iotests.qemu_img_log('map', '--output=json', top)
+    iotests.qemu_img_log('map', '--output=human', top)
+
+    iotests.log('=== Testing qemu-img commit (top -> mid) ===')
+
+    iotests.qemu_img_log('commit', top)
+    iotests.img_info_log(mid)
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
+
+    iotests.log('=== Testing HMP commit (top -> mid) ===')
+
+    create_chain()
+    with create_vm() as vm:
+        vm.launch()
+        vm.qmp_log('human-monitor-command', command_line='commit drive0')
+
+    iotests.img_info_log(mid)
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
+
+    iotests.log('=== Testing QMP active commit (top -> mid) ===')
+
+    create_chain()
+    with create_vm() as vm:
+        vm.launch()
+        vm.qmp_log('block-commit', device='top', base_node='mid',
+                   job_id='job0', auto_dismiss=False)
+        vm.run_job('job0', wait=5)
+
+    iotests.img_info_log(mid)
+    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, mid)
+    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), mid)
+
+
+    iotests.log('== Resize tests ==')
+
+    # Use different sizes for different allocation modes:
+    #
+    # We want to have at least one test where 32 bit truncation in the size of
+    # the overlapping area becomes visible. This is covered by the
+    # prealloc='off' case (1G to 6G is an overlap of 5G).
+    #
+    # However, we can only do this for modes that don't preallocate data
+    # because otherwise we might run out of space on the test host.
+    #
+    # We also want to test some unaligned combinations.
+    for (prealloc, base_size, top_size_old, top_size_new, off) in [
+            ('off',       '6G',    '1G',   '8G',   '5G'),
+            ('metadata', '32G',   '30G',  '33G',  '31G'),
+            ('falloc',   '10M',    '5M',  '15M',   '9M'),
+            ('full',     '16M',    '8M',  '12M',  '11M'),
+            ('off',      '384k', '253k', '512k', '253k'),
+            ('off',      '400k', '256k', '512k', '336k'),
+            ('off',      '512k', '256k', '500k', '436k')]:
+
+        iotests.log('=== preallocation=%s ===' % prealloc)
+        iotests.qemu_img_log('create', '-f', iotests.imgfmt, base, base_size)
+        iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, top,
+                             top_size_old)
+        iotests.qemu_io_log('-c', 'write -P 1 %s 64k' % off, base)
+
+        # After this, top_size_old to base_size should be allocated/zeroed.
+        #
+        # In theory, leaving base_size to top_size_new unallocated would be
+        # correct, but in practice, if we zero out anything, we zero out
+        # everything up to top_size_new.
+        iotests.qemu_img_log('resize', '-f', iotests.imgfmt,
+                             '--preallocation', prealloc, top, top_size_new)
+        iotests.qemu_io_log('-c', 'read -P 0 %s 64k' % off, top)
+        iotests.qemu_io_log('-c', 'map', top)
+        iotests.qemu_img_log('map', '--output=json', top)
diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/274.out
@@ -XXX,XX +XXX,XX @@
+== Commit tests ==
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Check visible data ===
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Checking allocation status ===
+1048576/1048576 bytes allocated at offset 0 bytes
+1048576/1048576 bytes allocated at offset 1 MiB
+
+0/1048576 bytes allocated at offset 0 bytes
+0/0 bytes allocated at offset 1 MiB
+
+0/1048576 bytes allocated at offset 0 bytes
+0/1048576 bytes allocated at offset 1 MiB
+
+=== Checking map ===
+[{ "start": 0, "length": 2097152, "depth": 0, "zero": false, "data": true, "offset": 327680}]
+
+Offset          Length          Mapped to       File
+0               0x200000        0x50000         TEST_DIR/PID-base
+
+[{ "start": 0, "length": 1048576, "depth": 1, "zero": false, "data": true, "offset": 327680}]
+
+Offset          Length          Mapped to       File
+0               0x100000        0x50000         TEST_DIR/PID-base
+
+[{ "start": 0, "length": 1048576, "depth": 2, "zero": false, "data": true, "offset": 327680},
+{ "start": 1048576, "length": 1048576, "depth": 0, "zero": true, "data": false}]
+
+Offset          Length          Mapped to       File
+0               0x100000        0x50000         TEST_DIR/PID-base
+
+=== Testing qemu-img commit (top -> mid) ===
+Image committed.
+
+image: TEST_IMG
+file format: IMGFMT
+virtual size: 2 MiB (2097152 bytes)
+cluster_size: 65536
+backing file: TEST_DIR/PID-base
+Format specific information:
+    compat: 1.1
+    lazy refcounts: false
+    refcount bits: 16
+    corrupt: false
+
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Testing HMP commit (top -> mid) ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+{"execute": "human-monitor-command", "arguments": {"command-line": "commit drive0"}}
+{"return": ""}
+image: TEST_IMG
+file format: IMGFMT
+virtual size: 2 MiB (2097152 bytes)
+cluster_size: 65536
+backing file: TEST_DIR/PID-base
+Format specific information:
+    compat: 1.1
+    lazy refcounts: false
+    refcount bits: 16
+    corrupt: false
+
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+=== Testing QMP active commit (top -> mid) ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=2097152 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-mid', fmt=qcow2 size=1048576 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=2097152 backing_file=TEST_DIR/PID-mid cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+{"execute": "block-commit", "arguments": {"auto-dismiss": false, "base-node": "mid", "device": "top", "job-id": "job0"}}
+{"return": {}}
+{"execute": "job-complete", "arguments": {"id": "job0"}}
+{"return": {}}
+{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"device": "job0", "len": 0, "offset": 0, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
+{"return": {}}
+image: TEST_IMG
+file format: IMGFMT
+virtual size: 2 MiB (2097152 bytes)
+cluster_size: 65536
+backing file: TEST_DIR/PID-base
+Format specific information:
+    compat: 1.1
+    lazy refcounts: false
+    refcount bits: 16
+    corrupt: false
+
+read 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+read 1048576/1048576 bytes at offset 1048576
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== Resize tests ==
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=6442450944 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=1073741824 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 5368709120
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 5368709120
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+1 GiB (0x40000000) bytes not allocated at offset 0 bytes (0x0)
+7 GiB (0x1c0000000) bytes     allocated at offset 1 GiB (0x40000000)
+
+[{ "start": 0, "length": 1073741824, "depth": 1, "zero": true, "data": false},
+{ "start": 1073741824, "length": 7516192768, "depth": 0, "zero": true, "data": false}]
+
+=== preallocation=metadata ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=34359738368 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=32212254720 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 33285996544
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 33285996544
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+30 GiB (0x780000000) bytes not allocated at offset 0 bytes (0x0)
+3 GiB (0xc0000000) bytes     allocated at offset 30 GiB (0x780000000)
+
+[{ "start": 0, "length": 32212254720, "depth": 1, "zero": true, "data": false},
+{ "start": 32212254720, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 327680},
+{ "start": 32749125632, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 537264128},
+{ "start": 33285996544, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1074200576},
+{ "start": 33822867456, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 1611137024},
+{ "start": 34359738368, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2148139008},
+{ "start": 34896609280, "length": 536870912, "depth": 0, "zero": true, "data": false, "offset": 2685075456}]
+
+=== preallocation=falloc ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=10485760 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=5242880 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 9437184
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 9437184
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+5 MiB (0x500000) bytes not allocated at offset 0 bytes (0x0)
+10 MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
+
+[{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
+{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+
+=== preallocation=full ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=8388608 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 11534336
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 11534336
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+8 MiB (0x800000) bytes not allocated at offset 0 bytes (0x0)
+4 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
+
+[{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
+{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=259072 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 259072
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 259072
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+192 KiB (0x30000) bytes not allocated at offset 0 bytes (0x0)
+320 KiB (0x50000) bytes     allocated at offset 192 KiB (0x30000)
+
+[{ "start": 0, "length": 196608, "depth": 1, "zero": true, "data": false},
+{ "start": 196608, "length": 65536, "depth": 0, "zero": false, "data": true, "offset": 327680},
+{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
+
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=409600 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 344064
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 344064
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
+256 KiB (0x40000) bytes     allocated at offset 256 KiB (0x40000)
+
+[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
+{ "start": 262144, "length": 262144, "depth": 0, "zero": true, "data": false}]
+
+=== preallocation=off ===
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=524288 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+Formatting 'TEST_DIR/PID-top', fmt=qcow2 size=262144 backing_file=TEST_DIR/PID-base cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+wrote 65536/65536 bytes at offset 446464
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Image resized.
+
+read 65536/65536 bytes at offset 446464
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+256 KiB (0x40000) bytes not allocated at offset 0 bytes (0x0)
+244 KiB (0x3d000) bytes     allocated at offset 256 KiB (0x40000)
+
+[{ "start": 0, "length": 262144, "depth": 1, "zero": true, "data": false},
+{ "start": 262144, "length": 249856, "depth": 0, "zero": true, "data": false}]
+
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 @@
 270 rw backing quick
 272 rw
 273 backing quick
+274 rw backing
 277 rw quick
 279 rw backing quick
 280 rw migration quick
-- 
2.25.3

The BDRV_REQ_ZERO_WRITE is currently implemented in a way that first the
image is possibly preallocated and then the zero flag is added to all
clusters. This means that a copy-on-write operation may be needed when
writing to these clusters, despite having used preallocation, negating
one of the major benefits of preallocation.

Instead, try to forward the BDRV_REQ_ZERO_WRITE to the protocol driver,
and if the protocol driver can ensure that the new area reads as zeros,
we can skip setting the zero flag in the qcow2 layer.

Unfortunately, the same approach doesn't work for metadata
preallocation, so we'll still set the zero flag there.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200424142701.67053-1-kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c              | 22 +++++++++++++++++++---
 tests/qemu-iotests/274.out |  4 ++--
 2 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
         /* Allocate the data area */
         new_file_size = allocation_start +
                         nb_new_data_clusters * s->cluster_size;
-        /* Image file grows, so @exact does not matter */
-        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
-                               errp);
+        /*
+         * Image file grows, so @exact does not matter.
+         *
+         * If we need to zero out the new area, try first whether the protocol
+         * driver can already take care of this.
+         */
+        if (flags & BDRV_REQ_ZERO_WRITE) {
+            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc,
+                                   BDRV_REQ_ZERO_WRITE, NULL);
+            if (ret >= 0) {
+                flags &= ~BDRV_REQ_ZERO_WRITE;
+            }
+        } else {
+            ret = -1;
+        }
+        if (ret < 0) {
+            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
+                                   errp);
+        }
         if (ret < 0) {
             error_prepend(errp, "Failed to resize underlying file: ");
             qcow2_free_clusters(bs, allocation_start,
diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/274.out
+++ b/tests/qemu-iotests/274.out
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 9437184
 10 MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
 
 [{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
-{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+{ "start": 5242880, "length": 10485760, "depth": 0, "zero": false, "data": true, "offset": 327680}]
 
 === preallocation=full ===
 Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 11534336
 4 MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
 
 [{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
-{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
+{ "start": 8388608, "length": 4194304, "depth": 0, "zero": false, "data": true, "offset": 327680}]
 
 === preallocation=off ===
 Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
-- 
2.25.3

From: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>

This patch introduces support for PMR that has been defined as part of NVMe 1.4
spec. User can now specify a pmrdev option that should point to HostMemoryBackend.
pmrdev memory region will subsequently be exposed as PCI BAR 2 in emulated NVMe
device. Guest OS can perform mmio read and writes to the PMR region that will stay
persistent across system reboot.

Signed-off-by: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>
Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20200330164656.9348-1-andrzej.jakowski@linux.intel.com>
Reviewed-by: Keith Busch <kbusch@kernel.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 hw/block/nvme.h        |   2 +
 include/block/nvme.h   | 172 +++++++++++++++++++++++++++++++++++++++++
 hw/block/nvme.c        | 109 ++++++++++++++++++++++++++
 hw/block/Makefile.objs |   2 +-
 hw/block/trace-events  |   4 +
 5 files changed, 288 insertions(+), 1 deletion(-)

diff --git a/hw/block/nvme.h b/hw/block/nvme.h
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/nvme.h
+++ b/hw/block/nvme.h
@@ -XXX,XX +XXX,XX @@ typedef struct NvmeCtrl {
     uint64_t    timestamp_set_qemu_clock_ms;    /* QEMU clock time */
 
     char            *serial;
+    HostMemoryBackend *pmrdev;
+
     NvmeNamespace   *namespaces;
     NvmeSQueue      **sq;
     NvmeCQueue      **cq;
diff --git a/include/block/nvme.h b/include/block/nvme.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/nvme.h
+++ b/include/block/nvme.h
@@ -XXX,XX +XXX,XX @@ typedef struct NvmeBar {
     uint64_t    acq;
     uint32_t    cmbloc;
     uint32_t    cmbsz;
+    uint8_t     padding[3520]; /* not used by QEMU */
+    uint32_t    pmrcap;
+    uint32_t    pmrctl;
+    uint32_t    pmrsts;
+    uint32_t    pmrebs;
+    uint32_t    pmrswtp;
+    uint32_t    pmrmsc;
 } NvmeBar;
 
 enum NvmeCapShift {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapShift {
     CAP_CSS_SHIFT      = 37,
     CAP_MPSMIN_SHIFT   = 48,
     CAP_MPSMAX_SHIFT   = 52,
+    CAP_PMR_SHIFT      = 56,
 };
 
 enum NvmeCapMask {
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
     CAP_CSS_MASK       = 0xff,
     CAP_MPSMIN_MASK    = 0xf,
     CAP_MPSMAX_MASK    = 0xf,
+    CAP_PMR_MASK       = 0x1,
 };
 
 #define NVME_CAP_MQES(cap)  (((cap) >> CAP_MQES_SHIFT)   & CAP_MQES_MASK)
@@ -XXX,XX +XXX,XX @@ enum NvmeCapMask {
                                                            << CAP_MPSMIN_SHIFT)
 #define NVME_CAP_SET_MPSMAX(cap, val) (cap |= (uint64_t)(val & CAP_MPSMAX_MASK)\
                                                             << CAP_MPSMAX_SHIFT)
+#define NVME_CAP_SET_PMRS(cap, val) (cap |= (uint64_t)(val & CAP_PMR_MASK)\
+                                                            << CAP_PMR_SHIFT)
 
 enum NvmeCcShift {
     CC_EN_SHIFT     = 0,
@@ -XXX,XX +XXX,XX @@ enum NvmeCmbszMask {
 #define NVME_CMBSZ_GETSIZE(cmbsz) \
     (NVME_CMBSZ_SZ(cmbsz) * (1 << (12 + 4 * NVME_CMBSZ_SZU(cmbsz))))
 
+enum NvmePmrcapShift {
+    PMRCAP_RDS_SHIFT      = 3,
+    PMRCAP_WDS_SHIFT      = 4,
+    PMRCAP_BIR_SHIFT      = 5,
+    PMRCAP_PMRTU_SHIFT    = 8,
+    PMRCAP_PMRWBM_SHIFT   = 10,
+    PMRCAP_PMRTO_SHIFT    = 16,
+    PMRCAP_CMSS_SHIFT     = 24,
+};
+
+enum NvmePmrcapMask {
+    PMRCAP_RDS_MASK      = 0x1,
+    PMRCAP_WDS_MASK      = 0x1,
+    PMRCAP_BIR_MASK      = 0x7,
+    PMRCAP_PMRTU_MASK    = 0x3,
+    PMRCAP_PMRWBM_MASK   = 0xf,
+    PMRCAP_PMRTO_MASK    = 0xff,
+    PMRCAP_CMSS_MASK     = 0x1,
+};
+
+#define NVME_PMRCAP_RDS(pmrcap)    \
+    ((pmrcap >> PMRCAP_RDS_SHIFT)   & PMRCAP_RDS_MASK)
+#define NVME_PMRCAP_WDS(pmrcap)    \
+    ((pmrcap >> PMRCAP_WDS_SHIFT)   & PMRCAP_WDS_MASK)
+#define NVME_PMRCAP_BIR(pmrcap)    \
+    ((pmrcap >> PMRCAP_BIR_SHIFT)   & PMRCAP_BIR_MASK)
+#define NVME_PMRCAP_PMRTU(pmrcap)    \
+    ((pmrcap >> PMRCAP_PMRTU_SHIFT)   & PMRCAP_PMRTU_MASK)
+#define NVME_PMRCAP_PMRWBM(pmrcap)    \
+    ((pmrcap >> PMRCAP_PMRWBM_SHIFT)   & PMRCAP_PMRWBM_MASK)
+#define NVME_PMRCAP_PMRTO(pmrcap)    \
+    ((pmrcap >> PMRCAP_PMRTO_SHIFT)   & PMRCAP_PMRTO_MASK)
+#define NVME_PMRCAP_CMSS(pmrcap)    \
+    ((pmrcap >> PMRCAP_CMSS_SHIFT)   & PMRCAP_CMSS_MASK)
+
+#define NVME_PMRCAP_SET_RDS(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_RDS_MASK) << PMRCAP_RDS_SHIFT)
+#define NVME_PMRCAP_SET_WDS(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_WDS_MASK) << PMRCAP_WDS_SHIFT)
+#define NVME_PMRCAP_SET_BIR(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_BIR_MASK) << PMRCAP_BIR_SHIFT)
+#define NVME_PMRCAP_SET_PMRTU(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTU_MASK) << PMRCAP_PMRTU_SHIFT)
+#define NVME_PMRCAP_SET_PMRWBM(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_PMRWBM_MASK) << PMRCAP_PMRWBM_SHIFT)
+#define NVME_PMRCAP_SET_PMRTO(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_PMRTO_MASK) << PMRCAP_PMRTO_SHIFT)
+#define NVME_PMRCAP_SET_CMSS(pmrcap, val)   \
+    (pmrcap |= (uint64_t)(val & PMRCAP_CMSS_MASK) << PMRCAP_CMSS_SHIFT)
+
+enum NvmePmrctlShift {
+    PMRCTL_EN_SHIFT   = 0,
+};
+
+enum NvmePmrctlMask {
+    PMRCTL_EN_MASK   = 0x1,
+};
+
+#define NVME_PMRCTL_EN(pmrctl)  ((pmrctl >> PMRCTL_EN_SHIFT)   & PMRCTL_EN_MASK)
+
+#define NVME_PMRCTL_SET_EN(pmrctl, val)   \
+    (pmrctl |= (uint64_t)(val & PMRCTL_EN_MASK) << PMRCTL_EN_SHIFT)
+
+enum NvmePmrstsShift {
+    PMRSTS_ERR_SHIFT    = 0,
+    PMRSTS_NRDY_SHIFT   = 8,
+    PMRSTS_HSTS_SHIFT   = 9,
+    PMRSTS_CBAI_SHIFT   = 12,
+};
+
+enum NvmePmrstsMask {
+    PMRSTS_ERR_MASK    = 0xff,
+    PMRSTS_NRDY_MASK   = 0x1,
+    PMRSTS_HSTS_MASK   = 0x7,
+    PMRSTS_CBAI_MASK   = 0x1,
+};
+
+#define NVME_PMRSTS_ERR(pmrsts)     \
+    ((pmrsts >> PMRSTS_ERR_SHIFT)   & PMRSTS_ERR_MASK)
+#define NVME_PMRSTS_NRDY(pmrsts)    \
+    ((pmrsts >> PMRSTS_NRDY_SHIFT)   & PMRSTS_NRDY_MASK)
+#define NVME_PMRSTS_HSTS(pmrsts)    \
+    ((pmrsts >> PMRSTS_HSTS_SHIFT)   & PMRSTS_HSTS_MASK)
+#define NVME_PMRSTS_CBAI(pmrsts)    \
+    ((pmrsts >> PMRSTS_CBAI_SHIFT)   & PMRSTS_CBAI_MASK)
+
+#define NVME_PMRSTS_SET_ERR(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_ERR_MASK) << PMRSTS_ERR_SHIFT)
+#define NVME_PMRSTS_SET_NRDY(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_NRDY_MASK) << PMRSTS_NRDY_SHIFT)
+#define NVME_PMRSTS_SET_HSTS(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_HSTS_MASK) << PMRSTS_HSTS_SHIFT)
+#define NVME_PMRSTS_SET_CBAI(pmrsts, val)   \
+    (pmrsts |= (uint64_t)(val & PMRSTS_CBAI_MASK) << PMRSTS_CBAI_SHIFT)
+
+enum NvmePmrebsShift {
+    PMREBS_PMRSZU_SHIFT   = 0,
+    PMREBS_RBB_SHIFT      = 4,
+    PMREBS_PMRWBZ_SHIFT   = 8,
+};
+
+enum NvmePmrebsMask {
+    PMREBS_PMRSZU_MASK   = 0xf,
+    PMREBS_RBB_MASK      = 0x1,
+    PMREBS_PMRWBZ_MASK   = 0xffffff,
+};
+
+#define NVME_PMREBS_PMRSZU(pmrebs)  \
+    ((pmrebs >> PMREBS_PMRSZU_SHIFT)   & PMREBS_PMRSZU_MASK)
+#define NVME_PMREBS_RBB(pmrebs)     \
+    ((pmrebs >> PMREBS_RBB_SHIFT)   & PMREBS_RBB_MASK)
+#define NVME_PMREBS_PMRWBZ(pmrebs)  \
+    ((pmrebs >> PMREBS_PMRWBZ_SHIFT)   & PMREBS_PMRWBZ_MASK)
+
+#define NVME_PMREBS_SET_PMRSZU(pmrebs, val)   \
+    (pmrebs |= (uint64_t)(val & PMREBS_PMRSZU_MASK) << PMREBS_PMRSZU_SHIFT)
+#define NVME_PMREBS_SET_RBB(pmrebs, val)   \
+    (pmrebs |= (uint64_t)(val & PMREBS_RBB_MASK) << PMREBS_RBB_SHIFT)
+#define NVME_PMREBS_SET_PMRWBZ(pmrebs, val)   \
+    (pmrebs |= (uint64_t)(val & PMREBS_PMRWBZ_MASK) << PMREBS_PMRWBZ_SHIFT)
+
+enum NvmePmrswtpShift {
+    PMRSWTP_PMRSWTU_SHIFT   = 0,
+    PMRSWTP_PMRSWTV_SHIFT   = 8,
+};
+
+enum NvmePmrswtpMask {
+    PMRSWTP_PMRSWTU_MASK   = 0xf,
+    PMRSWTP_PMRSWTV_MASK   = 0xffffff,
+};
+
+#define NVME_PMRSWTP_PMRSWTU(pmrswtp)   \
+    ((pmrswtp >> PMRSWTP_PMRSWTU_SHIFT)   & PMRSWTP_PMRSWTU_MASK)
+#define NVME_PMRSWTP_PMRSWTV(pmrswtp)   \
+    ((pmrswtp >> PMRSWTP_PMRSWTV_SHIFT)   & PMRSWTP_PMRSWTV_MASK)
+
+#define NVME_PMRSWTP_SET_PMRSWTU(pmrswtp, val)   \
+    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTU_MASK) << PMRSWTP_PMRSWTU_SHIFT)
+#define NVME_PMRSWTP_SET_PMRSWTV(pmrswtp, val)   \
+    (pmrswtp |= (uint64_t)(val & PMRSWTP_PMRSWTV_MASK) << PMRSWTP_PMRSWTV_SHIFT)
+
+enum NvmePmrmscShift {
+    PMRMSC_CMSE_SHIFT   = 1,
+    PMRMSC_CBA_SHIFT    = 12,
+};
+
+enum NvmePmrmscMask {
+    PMRMSC_CMSE_MASK   = 0x1,
+    PMRMSC_CBA_MASK    = 0xfffffffffffff,
+};
+
+#define NVME_PMRMSC_CMSE(pmrmsc)    \
+    ((pmrmsc >> PMRMSC_CMSE_SHIFT)   & PMRMSC_CMSE_MASK)
+#define NVME_PMRMSC_CBA(pmrmsc)     \
+    ((pmrmsc >> PMRMSC_CBA_SHIFT)   & PMRMSC_CBA_MASK)
+
+#define NVME_PMRMSC_SET_CMSE(pmrmsc, val)   \
+    (pmrmsc |= (uint64_t)(val & PMRMSC_CMSE_MASK) << PMRMSC_CMSE_SHIFT)
+#define NVME_PMRMSC_SET_CBA(pmrmsc, val)   \
+    (pmrmsc |= (uint64_t)(val & PMRMSC_CBA_MASK) << PMRMSC_CBA_SHIFT)
+
 typedef struct NvmeCmd {
     uint8_t     opcode;
     uint8_t     fuse;
diff --git a/hw/block/nvme.c b/hw/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/nvme.c
+++ b/hw/block/nvme.c
@@ -XXX,XX +XXX,XX @@
  *      -drive file=<file>,if=none,id=<drive_id>
  *      -device nvme,drive=<drive_id>,serial=<serial>,id=<id[optional]>, \
  *              cmb_size_mb=<cmb_size_mb[optional]>, \
+ *              [pmrdev=<mem_backend_file_id>,] \
  *              num_queues=<N[optional]>
  *
  * Note cmb_size_mb denotes size of CMB in MB. CMB is assumed to be at
  * offset 0 in BAR2 and supports only WDS, RDS and SQS for now.
+ *
+ * cmb_size_mb= and pmrdev= options are mutually exclusive due to limitation
+ * in available BAR's. cmb_size_mb= will take precedence over pmrdev= when
+ * both provided.
+ * Enabling pmr emulation can be achieved by pointing to memory-backend-file.
+ * For example:
+ * -object memory-backend-file,id=<mem_id>,share=on,mem-path=<file_path>, \
+ *  size=<size> .... -device nvme,...,pmrdev=<mem_id>
  */
 
 #include "qemu/osdep.h"
@@ -XXX,XX +XXX,XX @@
 #include "sysemu/sysemu.h"
 #include "qapi/error.h"
 #include "qapi/visitor.h"
+#include "sysemu/hostmem.h"
 #include "sysemu/block-backend.h"
+#include "exec/ram_addr.h"
 
 #include "qemu/log.h"
 #include "qemu/module.h"
@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
         NVME_GUEST_ERR(nvme_ub_mmiowr_cmbsz_readonly,
                        "invalid write to read only CMBSZ, ignored");
         return;
+    case 0xE00: /* PMRCAP */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrcap_readonly,
+                       "invalid write to PMRCAP register, ignored");
+        return;
+    case 0xE04: /* TODO PMRCTL */
+        break;
+    case 0xE08: /* PMRSTS */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrsts_readonly,
+                       "invalid write to PMRSTS register, ignored");
+        return;
+    case 0xE0C: /* PMREBS */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrebs_readonly,
+                       "invalid write to PMREBS register, ignored");
+        return;
+    case 0xE10: /* PMRSWTP */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_pmrswtp_readonly,
+                       "invalid write to PMRSWTP register, ignored");
+        return;
+    case 0xE14: /* TODO PMRMSC */
+         break;
     default:
         NVME_GUEST_ERR(nvme_ub_mmiowr_invalid,
                        "invalid MMIO write,"
@@ -XXX,XX +XXX,XX @@ static uint64_t nvme_mmio_read(void *opaque, hwaddr addr, unsigned size)
     }
 
     if (addr < sizeof(n->bar)) {
+        /*
+         * When PMRWBM bit 1 is set then read from
+         * from PMRSTS should ensure prior writes
+         * made it to persistent media
+         */
+        if (addr == 0xE08 &&
+            (NVME_PMRCAP_PMRWBM(n->bar.pmrcap) & 0x02)) {
+            qemu_ram_writeback(n->pmrdev->mr.ram_block,
+                               0, n->pmrdev->size);
+        }
         memcpy(&val, ptr + addr, size);
     } else {
         NVME_GUEST_ERR(nvme_ub_mmiord_invalid_ofs,
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
         error_setg(errp, "serial property not set");
         return;
     }
+
+    if (!n->cmb_size_mb && n->pmrdev) {
+        if (host_memory_backend_is_mapped(n->pmrdev)) {
+            char *path = object_get_canonical_path_component(OBJECT(n->pmrdev));
+            error_setg(errp, "can't use already busy memdev: %s", path);
+            g_free(path);
+            return;
+        }
+
+        if (!is_power_of_2(n->pmrdev->size)) {
+            error_setg(errp, "pmr backend size needs to be power of 2 in size");
+            return;
+        }
+
+        host_memory_backend_set_mapped(n->pmrdev, true);
+    }
+
     blkconf_blocksizes(&n->conf);
     if (!blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk),
                                        false, errp)) {
@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
             PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
             PCI_BASE_ADDRESS_MEM_PREFETCH, &n->ctrl_mem);
 
+    } else if (n->pmrdev) {
+        /* Controller Capabilities register */
+        NVME_CAP_SET_PMRS(n->bar.cap, 1);
+
+        /* PMR Capabities register */
+        n->bar.pmrcap = 0;
+        NVME_PMRCAP_SET_RDS(n->bar.pmrcap, 0);
+        NVME_PMRCAP_SET_WDS(n->bar.pmrcap, 0);
+        NVME_PMRCAP_SET_BIR(n->bar.pmrcap, 2);
+        NVME_PMRCAP_SET_PMRTU(n->bar.pmrcap, 0);
+        /* Turn on bit 1 support */
+        NVME_PMRCAP_SET_PMRWBM(n->bar.pmrcap, 0x02);
+        NVME_PMRCAP_SET_PMRTO(n->bar.pmrcap, 0);
+        NVME_PMRCAP_SET_CMSS(n->bar.pmrcap, 0);
+
+        /* PMR Control register */
+        n->bar.pmrctl = 0;
+        NVME_PMRCTL_SET_EN(n->bar.pmrctl, 0);
+
+        /* PMR Status register */
+        n->bar.pmrsts = 0;
+        NVME_PMRSTS_SET_ERR(n->bar.pmrsts, 0);
+        NVME_PMRSTS_SET_NRDY(n->bar.pmrsts, 0);
+        NVME_PMRSTS_SET_HSTS(n->bar.pmrsts, 0);
+        NVME_PMRSTS_SET_CBAI(n->bar.pmrsts, 0);
+
+        /* PMR Elasticity Buffer Size register */
+        n->bar.pmrebs = 0;
+        NVME_PMREBS_SET_PMRSZU(n->bar.pmrebs, 0);
+        NVME_PMREBS_SET_RBB(n->bar.pmrebs, 0);
+        NVME_PMREBS_SET_PMRWBZ(n->bar.pmrebs, 0);
+
+        /* PMR Sustained Write Throughput register */
+        n->bar.pmrswtp = 0;
+        NVME_PMRSWTP_SET_PMRSWTU(n->bar.pmrswtp, 0);
+        NVME_PMRSWTP_SET_PMRSWTV(n->bar.pmrswtp, 0);
+
+        /* PMR Memory Space Control register */
+        n->bar.pmrmsc = 0;
+        NVME_PMRMSC_SET_CMSE(n->bar.pmrmsc, 0);
+        NVME_PMRMSC_SET_CBA(n->bar.pmrmsc, 0);
+
+        pci_register_bar(pci_dev, NVME_PMRCAP_BIR(n->bar.pmrcap),
+            PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
+            PCI_BASE_ADDRESS_MEM_PREFETCH, &n->pmrdev->mr);
     }
 
     for (i = 0; i < n->num_namespaces; i++) {
@@ -XXX,XX +XXX,XX @@ static void nvme_exit(PCIDevice *pci_dev)
     if (n->cmb_size_mb) {
         g_free(n->cmbuf);
     }
+
+    if (n->pmrdev) {
+        host_memory_backend_set_mapped(n->pmrdev, false);
+    }
     msix_uninit_exclusive_bar(pci_dev);
 }
 
 static Property nvme_props[] = {
     DEFINE_BLOCK_PROPERTIES(NvmeCtrl, conf),
+    DEFINE_PROP_LINK("pmrdev", NvmeCtrl, pmrdev, TYPE_MEMORY_BACKEND,
+                     HostMemoryBackend *),
     DEFINE_PROP_STRING("serial", NvmeCtrl, serial),
     DEFINE_PROP_UINT32("cmb_size_mb", NvmeCtrl, cmb_size_mb, 0),
     DEFINE_PROP_UINT32("num_queues", NvmeCtrl, num_queues, 64),
diff --git a/hw/block/Makefile.objs b/hw/block/Makefile.objs
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/Makefile.objs
+++ b/hw/block/Makefile.objs
@@ -XXX,XX +XXX,XX @@ common-obj-$(CONFIG_PFLASH_CFI02) += pflash_cfi02.o
 common-obj-$(CONFIG_XEN) += xen-block.o
 common-obj-$(CONFIG_ECC) += ecc.o
 common-obj-$(CONFIG_ONENAND) += onenand.o
-common-obj-$(CONFIG_NVME_PCI) += nvme.o
 common-obj-$(CONFIG_SWIM) += swim.o
 
 common-obj-$(CONFIG_SH4) += tc58128.o
 
 obj-$(CONFIG_VIRTIO_BLK) += virtio-blk.o
 obj-$(CONFIG_VHOST_USER_BLK) += vhost-user-blk.o
+obj-$(CONFIG_NVME_PCI) += nvme.o
 
 obj-y += dataplane/
diff --git a/hw/block/trace-events b/hw/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/trace-events
+++ b/hw/block/trace-events
@@ -XXX,XX +XXX,XX @@ nvme_ub_mmiowr_ssreset_w1c_unsupported(void) "attempted to W1C CSTS.NSSRO but CA
 nvme_ub_mmiowr_ssreset_unsupported(void) "attempted NVM subsystem reset but CAP.NSSRS is zero (not supported)"
 nvme_ub_mmiowr_cmbloc_reserved(void) "invalid write to reserved CMBLOC when CMBSZ is zero, ignored"
 nvme_ub_mmiowr_cmbsz_readonly(void) "invalid write to read only CMBSZ, ignored"
+nvme_ub_mmiowr_pmrcap_readonly(void) "invalid write to read only PMRCAP, ignored"
+nvme_ub_mmiowr_pmrsts_readonly(void) "invalid write to read only PMRSTS, ignored"
+nvme_ub_mmiowr_pmrebs_readonly(void) "invalid write to read only PMREBS, ignored"
+nvme_ub_mmiowr_pmrswtp_readonly(void) "invalid write to read only PMRSWTP, ignored"
 nvme_ub_mmiowr_invalid(uint64_t offset, uint64_t data) "invalid MMIO write, offset=0x%"PRIx64", data=0x%"PRIx64""
 nvme_ub_mmiord_misaligned32(uint64_t offset) "MMIO read not 32-bit aligned, offset=0x%"PRIx64""
 nvme_ub_mmiord_toosmall(uint64_t offset) "MMIO read smaller than 32-bits, offset=0x%"PRIx64""
-- 
2.25.3

The QMP handler qmp_object_add() and the implementation of --object in
qemu-storage-daemon can share most of the code. Currently,
qemu-storage-daemon calls qmp_object_add(), but this is not correct
because different visitors need to be used.

As a first step towards a fix, make qmp_object_add() a wrapper around a
new function user_creatable_add_dict() that can get an additional
parameter. The handling of "props" is only required for compatibility
and not required for the qemu-storage-daemon command line, so it stays
in qmp_object_add().

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/qom/object_interfaces.h | 12 ++++++++++++
 qom/object_interfaces.c         | 27 +++++++++++++++++++++++++++
 qom/qom-qmp-cmds.c              | 24 +-----------------------
 3 files changed, 40 insertions(+), 23 deletions(-)

diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qom/object_interfaces.h
+++ b/include/qom/object_interfaces.h
@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
                                 const QDict *qdict,
                                 Visitor *v, Error **errp);
 
+/**
+ * user_creatable_add_dict:
+ * @qdict: the object definition
+ * @errp: if an error occurs, a pointer to an area to store the error
+ *
+ * Create an instance of the user creatable object that is defined by
+ * @qdict.  The object type is taken from the QDict key 'qom-type', its
+ * ID from the key 'id'. The remaining entries in @qdict are used to
+ * initialize the object properties.
+ */
+void user_creatable_add_dict(QDict *qdict, Error **errp);
+
 /**
  * user_creatable_add_opts:
  * @opts: the object definition
diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/object_interfaces.c
+++ b/qom/object_interfaces.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/qmp/qerror.h"
 #include "qapi/qmp/qjson.h"
 #include "qapi/qmp/qstring.h"
+#include "qapi/qobject-input-visitor.h"
 #include "qom/object_interfaces.h"
 #include "qemu/help_option.h"
 #include "qemu/module.h"
@@ -XXX,XX +XXX,XX @@ out:
     return obj;
 }
 
+void user_creatable_add_dict(QDict *qdict, Error **errp)
+{
+    Visitor *v;
+    Object *obj;
+    g_autofree char *type = NULL;
+    g_autofree char *id = NULL;
+
+    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
+    if (!type) {
+        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
+        return;
+    }
+    qdict_del(qdict, "qom-type");
+
+    id = g_strdup(qdict_get_try_str(qdict, "id"));
+    if (!id) {
+        error_setg(errp, QERR_MISSING_PARAMETER, "id");
+        return;
+    }
+    qdict_del(qdict, "id");
+
+    v = qobject_input_visitor_new(QOBJECT(qdict));
+    obj = user_creatable_add_type(type, id, qdict, v, errp);
+    visit_free(v);
+    object_unref(obj);
+}
 
 Object *user_creatable_add_opts(QemuOpts *opts, Error **errp)
 {
diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/qom-qmp-cmds.c
+++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@
 #include "qapi/qapi-commands-qom.h"
 #include "qapi/qmp/qdict.h"
 #include "qapi/qmp/qerror.h"
-#include "qapi/qobject-input-visitor.h"
 #include "qemu/cutils.h"
 #include "qom/object_interfaces.h"
 #include "qom/qom-qobject.h"
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
 {
     QObject *props;
     QDict *pdict;
-    Visitor *v;
-    Object *obj;
-    g_autofree char *type = NULL;
-    g_autofree char *id = NULL;
-
-    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
-    if (!type) {
-        error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
-        return;
-    }
-    qdict_del(qdict, "qom-type");
-
-    id = g_strdup(qdict_get_try_str(qdict, "id"));
-    if (!id) {
-        error_setg(errp, QERR_MISSING_PARAMETER, "id");
-        return;
-    }
-    qdict_del(qdict, "id");
 
     props = qdict_get(qdict, "props");
     if (props) {
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
         qobject_unref(pdict);
     }
 
-    v = qobject_input_visitor_new(QOBJECT(qdict));
-    obj = user_creatable_add_type(type, id, qdict, v, errp);
-    visit_free(v);
-    object_unref(obj);
+    user_creatable_add_dict(qdict, errp);
 }
 
 void qmp_object_del(const char *id, Error **errp)
-- 
2.25.3

After processing the option string with the keyval parser, we get a
QDict that contains only strings. This QDict must be fed to a keyval
visitor which converts the strings into the right data types.

qmp_object_add(), however, uses the normal QObject input visitor, which
expects a QDict where all properties already have the QType that matches
the data type required by the QOM object type.

Change the --object implementation in qemu-storage-daemon so that it
doesn't call qmp_object_add(), but calls user_creatable_add_dict()
directly instead and pass it a new keyval boolean that decides which
visitor must be used.

Reported-by: Coiby Xu <coiby.xu@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/qom/object_interfaces.h | 6 +++++-
 qemu-storage-daemon.c           | 4 +---
 qom/object_interfaces.c         | 8 ++++++--
 qom/qom-qmp-cmds.c              | 2 +-
 4 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qom/object_interfaces.h
+++ b/include/qom/object_interfaces.h
@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
 /**
  * user_creatable_add_dict:
  * @qdict: the object definition
+ * @keyval: if true, use a keyval visitor for processing @qdict (i.e.
+ *          assume that all @qdict values are strings); otherwise, use
+ *          the normal QObject visitor (i.e. assume all @qdict values
+ *          have the QType expected by the QOM object type)
  * @errp: if an error occurs, a pointer to an area to store the error
  *
  * Create an instance of the user creatable object that is defined by
@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
  * ID from the key 'id'. The remaining entries in @qdict are used to
  * initialize the object properties.
  */
-void user_creatable_add_dict(QDict *qdict, Error **errp);
+void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp);
 
 /**
  * user_creatable_add_opts:
diff --git a/qemu-storage-daemon.c b/qemu-storage-daemon.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-storage-daemon.c
+++ b/qemu-storage-daemon.c
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
                 QemuOpts *opts;
                 const char *type;
                 QDict *args;
-                QObject *ret_data = NULL;
 
                 /* FIXME The keyval parser rejects 'help' arguments, so we must
                  * unconditionall try QemuOpts first. */
@@ -XXX,XX +XXX,XX @@ static void process_options(int argc, char *argv[])
                 qemu_opts_del(opts);
 
                 args = keyval_parse(optarg, "qom-type", &error_fatal);
-                qmp_object_add(args, &ret_data, &error_fatal);
+                user_creatable_add_dict(args, true, &error_fatal);
                 qobject_unref(args);
-                qobject_unref(ret_data);
                 break;
             }
         default:
diff --git a/qom/object_interfaces.c b/qom/object_interfaces.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/object_interfaces.c
+++ b/qom/object_interfaces.c
@@ -XXX,XX +XXX,XX @@ out:
     return obj;
 }
 
-void user_creatable_add_dict(QDict *qdict, Error **errp)
+void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp)
 {
     Visitor *v;
     Object *obj;
@@ -XXX,XX +XXX,XX @@ void user_creatable_add_dict(QDict *qdict, Error **errp)
     }
     qdict_del(qdict, "id");
 
-    v = qobject_input_visitor_new(QOBJECT(qdict));
+    if (keyval) {
+        v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
+    } else {
+        v = qobject_input_visitor_new(QOBJECT(qdict));
+    }
     obj = user_creatable_add_type(type, id, qdict, v, errp);
     visit_free(v);
     object_unref(obj);
diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/qom-qmp-cmds.c
+++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
         qobject_unref(pdict);
     }
 
-    user_creatable_add_dict(qdict, errp);
+    user_creatable_add_dict(qdict, false, errp);
 }
 
 void qmp_object_del(const char *id, Error **errp)
-- 
2.25.3