Series comparison

-[Qemu-devel] [PULL 00/16] Block layer patches
+[PULL 00/15] Block layer patches
-The following changes since commit 9e06029aea3b2eca1d5261352e695edc1e7d7b8b:
+The following changes since commit 16aaacb307ed607b9780c12702c44f0fe52edc7e:
-  Update version for v4.1.0 release (2019-08-15 13:03:37 +0100)
+  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 a6b257a08e3d72219f03e461a52152672fec0612:
+for you to fetch changes up to eaae29ef89d498d0eac553c77b554f310a47f809:
-  file-posix: Handle undetectable alignment (2019-08-16 11:29:11 +0200)
+  qemu-storage-daemon: Fix non-string --object properties (2020-04-30 17:51:07 +0200)
 ----------------------------------------------------------------
 Block layer patches:
-- file-posix: Fix O_DIRECT alignment detection
+- Fix resize (extending) of short overlays
-- Fixes for concurrent block jobs
+- nvme: introduce PMR support from NVMe 1.4 spec
-- block-backend: Queue requests while drained (fix IDE vs. job crashes)
+- qemu-storage-daemon: Fix non-string --object properties
 - qemu-img convert: Deprecate using -n and -o together
 - iotests: Migration tests with filter nodes
 - iotests: More media change tests
 ----------------------------------------------------------------
-Kevin Wolf (10):
+Alberto Garcia (1):
-      iotests/118: Test media change for scsi-cd
+      qcow2: Add incompatibility note between backing files and raw external data files
       iotests/118: Create test classes dynamically
       iotests/118: Add -blockdev based tests
       iotests: Move migration helpers to iotests.py
       iotests: Test migration with all kinds of filter nodes
       block: Simplify bdrv_filter_default_perms()
       block: Remove blk_pread_unthrottled()
       mirror: Keep mirror_top_bs drained after dropping permissions
       block-backend: Queue requests while drained
       qemu-img convert: Deprecate using -n and -o together
-Max Reitz (5):
+Andrzej Jakowski (1):
-      block: Keep subtree drained in drop_intermediate
+      nvme: introduce PMR support from NVMe 1.4 spec
       block: Reduce (un)drains when replacing a child
       tests: Test polling in bdrv_drop_intermediate()
       tests: Test mid-drain bdrv_replace_child_noperm()
       iotests: Add test for concurrent stream/commit
-Nir Soffer (1):
+Kevin Wolf (12):
-      file-posix: Handle undetectable alignment
+      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
- include/sysemu/block-backend.h |   3 +-
+Paolo Bonzini (1):
- block.c                        |  63 +++---
+      qemu-iotests: allow qcow2 external discarded clusters to contain stale data
  block/backup.c                 |   1 +
  block/block-backend.c          |  69 ++++--
  block/commit.c                 |   2 +
  block/file-posix.c             |  36 +++-
  block/mirror.c                 |   7 +-
  blockjob.c                     |   3 +
  hw/block/hd-geometry.c         |   7 +-
  qemu-img.c                     |   5 +
  tests/test-bdrv-drain.c        | 476 +++++++++++++++++++++++++++++++++++++++++
  qemu-deprecated.texi           |   7 +
  tests/qemu-iotests/118         |  84 ++++----
  tests/qemu-iotests/118.out     |   4 +-
  tests/qemu-iotests/234         |  30 +--
  tests/qemu-iotests/258         | 163 ++++++++++++++
  tests/qemu-iotests/258.out     |  33 +++
  tests/qemu-iotests/262         |  82 +++++++
  tests/qemu-iotests/262.out     |  17 ++
  tests/qemu-iotests/group       |   2 +
  tests/qemu-iotests/iotests.py  |  16 ++
 files changed, 983 insertions(+), 127 deletions(-)
  create mode 100755 tests/qemu-iotests/258
  create mode 100644 tests/qemu-iotests/258.out
  create mode 100755 tests/qemu-iotests/262
  create mode 100644 tests/qemu-iotests/262.out
+ docs/interop/qcow2.txt          |   3 +
+ hw/block/nvme.h                 |   2 +
+ include/block/block.h           |   5 +-
+ include/block/block_int.h       |  10 +-
+ include/block/nvme.h            | 172 ++++++++++++++++++++++++++
+ include/qom/object_interfaces.h |  16 +++
+ include/sysemu/block-backend.h  |   2 +-
+ block.c                         |   3 +-
+ block/block-backend.c           |   4 +-
+ block/commit.c                  |   4 +-
+ block/crypto.c                  |   7 +-
+ block/file-posix.c              |   6 +-
+ block/file-win32.c              |   2 +-
+ block/gluster.c                 |   1 +
+ block/io.c                      |  43 ++++++-
+ block/iscsi.c                   |   2 +-
+ block/mirror.c                  |   2 +-
+ block/nfs.c                     |   3 +-
+ block/parallels.c               |   6 +-
+ block/qcow.c                    |   4 +-
+ block/qcow2-cluster.c           |   2 +-
+ block/qcow2-refcount.c          |   2 +-
+ block/qcow2.c                   |  73 +++++++++--
+ block/qed.c                     |   3 +-
+ block/raw-format.c              |   6 +-
+ block/rbd.c                     |   1 +
+ block/sheepdog.c                |   4 +-
+ block/ssh.c                     |   2 +-
+ block/vdi.c                     |   2 +-
+ block/vhdx-log.c                |   2 +-
+ block/vhdx.c                    |   6 +-
+ block/vmdk.c                    |   8 +-
+ block/vpc.c                     |   2 +-
+ blockdev.c                      |   2 +-
+ hw/block/nvme.c                 | 109 ++++++++++++++++
+ qemu-img.c                      |   2 +-
+ qemu-io-cmds.c                  |   2 +-
+ qemu-storage-daemon.c           |   4 +-
+ qom/object_interfaces.c         |  31 +++++
+ qom/qom-qmp-cmds.c              |  24 +---
+ tests/test-block-iothread.c     |   9 +-
+ tests/qemu-iotests/iotests.py   |   5 +-
+ hw/block/Makefile.objs          |   2 +-
+ hw/block/trace-events           |   4 +
+ tests/qemu-iotests/244          |  10 +-
+ tests/qemu-iotests/244.out      |   9 +-
+ tests/qemu-iotests/274          | 155 +++++++++++++++++++++++
+ tests/qemu-iotests/274.out      | 268 ++++++++++++++++++++++++++++++++++++++++
+ tests/qemu-iotests/group        |   1 +
+files changed, 951 insertions(+), 96 deletions(-)
+ create mode 100755 tests/qemu-iotests/274
+ create mode 100644 tests/qemu-iotests/274.out

-[Qemu-devel] [PULL 01/16] iotests/118: Test media change for scsi-cd
+Deleted patch
-The test covered only floppy and ide-cd. Add scsi-cd as well.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/118     | 20 ++++++++++++++++++++
- tests/qemu-iotests/118.out |  4 ++--
-files changed, 22 insertions(+), 2 deletions(-)
-diff --git a/tests/qemu-iotests/118 b/tests/qemu-iotests/118
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/118
-+++ b/tests/qemu-iotests/118
-@@ -XXX,XX +XXX,XX @@ def interface_to_device_name(interface):
-         return 'ide-cd'
-     elif interface == 'floppy':
-         return 'floppy'
-+    elif interface == 'scsi':
-+        return 'scsi-cd'
-     else:
-         return None
-@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):
-         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
-         self.vm = iotests.VM()
-         self.vm.add_drive(old_img, 'media=%s' % media, 'none')
-+        if interface == 'scsi':
-+            self.vm.add_device('virtio-scsi-pci')
-         self.vm.add_device('%s,drive=drive0,id=%s' %
-                            (interface_to_device_name(interface),
-                             self.device_name))
-@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
-     def setUp(self, media, interface):
-         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
-         self.vm = iotests.VM().add_drive(None, 'media=%s' % media, 'none')
-+        if interface == 'scsi':
-+            self.vm.add_device('virtio-scsi-pci')
-         self.vm.add_device('%s,drive=drive0,id=%s' %
-                            (interface_to_device_name(interface),
-                             self.device_name))
-@@ -XXX,XX +XXX,XX @@ class TestCDInitiallyEmpty(TestInitiallyEmpty):
-     def setUp(self):
-         self.TestInitiallyEmpty.setUp(self, 'cdrom', 'ide')
-+class TestSCSICDInitiallyFilled(TestInitiallyFilled):
-+    TestInitiallyFilled = TestInitiallyFilled
-+    has_real_tray = True
-+
-+    def setUp(self):
-+        self.TestInitiallyFilled.setUp(self, 'cdrom', 'scsi')
-+
-+class TestSCSICDInitiallyEmpty(TestInitiallyEmpty):
-+    TestInitiallyEmpty = TestInitiallyEmpty
-+    has_real_tray = True
-+
-+    def setUp(self):
-+        self.TestInitiallyEmpty.setUp(self, 'cdrom', 'scsi')
-+
- class TestFloppyInitiallyFilled(TestInitiallyFilled):
-     TestInitiallyFilled = TestInitiallyFilled
-     has_real_tray = False
-diff --git a/tests/qemu-iotests/118.out b/tests/qemu-iotests/118.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/118.out
-+++ b/tests/qemu-iotests/118.out
-@@ -XXX,XX +XXX,XX @@
--...............................................................
-+.........................................................................................
- ----------------------------------------------------------------------
--Ran 63 tests
-+Ran 89 tests
- OK
---
-.20.1

-[Qemu-devel] [PULL 13/16] mirror: Keep mirror_top_bs drained after dropping permissions
+[PULL 01/15] qcow2: Add incompatibility note between backing files and raw external data files
-mirror_top_bs is currently implicitly drained through its connection to
+From: Alberto Garcia <berto@igalia.com>
 the source or the target node. However, the drain section for target_bs
 ends early after moving mirror_top_bs from src to target_bs, so that
 requests can already be restarted while mirror_top_bs is still present
 in the chain, but has dropped all permissions and therefore runs into an
 assertion failure like this:
-    qemu-system-x86_64: block/io.c:1634: bdrv_co_write_req_prepare:
+Backing files and raw external data files are mutually exclusive.
-    Assertion `child->perm & BLK_PERM_WRITE' failed.
+The documentation of the raw external data bit (in autoclear_features)
 already indicates that, but we should also mention it on the other
 side.
-Keep mirror_top_bs drained until all graph changes have completed.
+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 +++
 file changed, 3 insertions(+)
-Cc: qemu-stable@nongnu.org
+diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
  block/mirror.c | 6 +++++-
 file changed, 5 insertions(+), 1 deletion(-)
 diff --git a/block/mirror.c b/block/mirror.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/mirror.c
+--- a/docs/interop/qcow2.txt
-+++ b/block/mirror.c
++++ b/docs/interop/qcow2.txt
-@@ -XXX,XX +XXX,XX @@ static int mirror_exit_common(Job *job)
+@@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header:
-     s->target = NULL;
+                     is stored (NB: The string is not null terminated). 0 if the
+                     image doesn't have a backing file.
-     /* We don't access the source any more. Dropping any WRITE/RESIZE is
--     * required before it could become a backing file of target_bs. */
++                    Note: backing files are incompatible with raw external data
-+     * required before it could become a backing file of target_bs. Not having
++                    files (auto-clear feature bit 1).
-+     * these permissions any more means that we can't allow any new requests on
++
-+     * mirror_top_bs from now on, so keep it drained. */
+- 19:   backing_file_size
-+    bdrv_drained_begin(mirror_top_bs);
+                     Length of the backing file name in bytes. Must not be
-     bs_opaque->stop = true;
+                     longer than 1023 bytes. Undefined if the image doesn't have
      bdrv_child_refresh_perms(mirror_top_bs, mirror_top_bs->backing,
                               &error_abort);
@@ -XXX,XX +XXX,XX @@ static int mirror_exit_common(Job *job)
      bs_opaque->job = NULL;
      bdrv_drained_end(src);
 +    bdrv_drained_end(mirror_top_bs);
      s->in_drain = false;
      bdrv_unref(mirror_top_bs);
      bdrv_unref(src);
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 07/16] block: Keep subtree drained in drop_intermediate
+[PULL 02/15] qemu-iotests: allow qcow2 external discarded clusters to contain stale data
-From: Max Reitz <mreitz@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-bdrv_drop_intermediate() calls BdrvChildRole.update_filename().  That
+Test 244 checks the expected behavior of qcow2 external data files
-may poll, thus changing the graph, which potentially breaks the
+with respect to zero and discarded clusters.  Filesystems however
-QLIST_FOREACH_SAFE() loop.
+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.
-Just keep the whole subtree drained.  This is probably the right thing
+This fixes docker tests on RHEL8.
 to do anyway (dropping nodes while the subtree is not drained seems
 wrong).
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Cc: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: 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>
 ---
- block.c | 2 ++
+ tests/qemu-iotests/244     | 10 ++++++++--
-file changed, 2 insertions(+)
+ tests/qemu-iotests/244.out |  9 ++++++---
 files changed, 14 insertions(+), 5 deletions(-)
-diff --git a/block.c b/block.c
+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/block.c
+--- a/tests/qemu-iotests/244.out
-+++ b/block.c
++++ b/tests/qemu-iotests/244.out
-@@ -XXX,XX +XXX,XX @@ int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
+@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 0
-     int ret = -EIO;
+MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+ read 1048576/1048576 bytes at offset 1048576
-     bdrv_ref(top);
+MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+    bdrv_subtree_drained_begin(top);
+-read 2097152/2097152 bytes at offset 2097152
+-2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-     if (!top->drv || !base->drv) {
+ read 1048576/1048576 bytes at offset 4194304
-         goto exit;
+MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-@@ -XXX,XX +XXX,XX @@ int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
+ read 1048576/1048576 bytes at offset 5242880
+@@ -XXX,XX +XXX,XX @@ read 1048576/1048576 bytes at offset 1048576
-     ret = 0;
+ read 4194304/4194304 bytes at offset 2097152
- exit:
+MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+    bdrv_subtree_drained_end(top);
-     bdrv_unref(top);
+-Images are identical.
-     return ret;
++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

-[Qemu-devel] [PULL 15/16] qemu-img convert: Deprecate using -n and -o together
+[PULL 03/15] block: Add flags to BlockDriver.bdrv_co_truncate()
-bdrv_create options specified with -o have no effect when skipping image
+This adds a new BdrvRequestFlags parameter to the .bdrv_co_truncate()
-creation with -n, so this doesn't make sense. Warn against the misuse
+driver callbacks, and a supported_truncate_flags field in
-and deprecate the combination so we can make it a hard error later.
+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>
-Reviewed-by: John Snow <jsnow@redhat.com>
+Message-Id: <20200424125448.63318-2-kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qemu-img.c           | 5 +++++
+ include/block/block_int.h   | 10 +++++++++-
- qemu-deprecated.texi | 7 +++++++
+ block/crypto.c              |  3 ++-
-files changed, 12 insertions(+)
+ block/file-posix.c          |  2 +-
+ block/file-win32.c          |  2 +-
-diff --git a/qemu-img.c b/qemu-img.c
+ block/gluster.c             |  1 +
-index XXXXXXX..XXXXXXX 100644
+ block/io.c                  |  8 +++++++-
---- a/qemu-img.c
+ block/iscsi.c               |  2 +-
-+++ b/qemu-img.c
+ block/nfs.c                 |  3 ++-
-@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
+ block/qcow2.c               |  2 +-
-         goto fail_getopt;
+ 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 (skip_create && options) {
+     if (drv->bdrv_co_truncate) {
-+        warn_report("-o has no effect when skipping image creation");
+-        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, errp);
-+        warn_report("This will become an error in future QEMU versions.");
++        if (flags & ~bs->supported_truncate_flags) {
-+    }
++            error_setg(errp, "Block driver does not support requested flags");
-+
++            ret = -ENOTSUP;
-     s.src_num = argc - optind - 1;
++            goto out;
-     out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL;
++        }
++        ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
-diff --git a/qemu-deprecated.texi b/qemu-deprecated.texi
+     } else if (bs->file && drv->is_filter) {
-index XXXXXXX..XXXXXXX 100644
+         ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
---- a/qemu-deprecated.texi
+     } else {
-+++ b/qemu-deprecated.texi
+diff --git a/block/iscsi.c b/block/iscsi.c
-@@ -XXX,XX +XXX,XX @@ to just export the entire image and then mount only /dev/nbd0p1 than
+index XXXXXXX..XXXXXXX 100644
- it is to reinvoke @command{qemu-nbd -c /dev/nbd0} limited to just a
+--- a/block/iscsi.c
- subset of the image.
++++ b/block/iscsi.c
+@@ -XXX,XX +XXX,XX @@ static void iscsi_reopen_commit(BDRVReopenState *reopen_state)
-+@subsection qemu-img convert -n -o (since 4.2.0)
-+
+ static int coroutine_fn iscsi_co_truncate(BlockDriverState *bs, int64_t offset,
-+All options specified in @option{-o} are image creation options, so
+                                           bool exact, PreallocMode prealloc,
-+they have no effect when used with @option{-n} to skip image creation.
+-                                          Error **errp)
-+Silently ignored options can be confusing, so this combination of
++                                          BdrvRequestFlags flags, Error **errp)
-+options will be made an error in future versions.
+ {
-+
+     IscsiLun *iscsilun = bs->opaque;
- @section Build system
+     int64_t cur_length;
+diff --git a/block/nfs.c b/block/nfs.c
- @subsection Python 2 support (since 4.1.0)
+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;
  }
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 12/16] block: Remove blk_pread_unthrottled()
+[PULL 04/15] block: Add flags to bdrv(_co)_truncate()
-The functionality offered by blk_pread_unthrottled() goes back to commit
+Now that block drivers can support flags for .bdrv_co_truncate, expose
-e386c584. Then, we couldn't perform I/O throttling with synchronous
+the parameter in the node level interfaces bdrv_co_truncate() and
-requests because timers wouldn't be executed in polling loops. So the
+bdrv_truncate().
 commit automatically disabled I/O throttling as soon as a synchronous
 request was issued.
 However, for geometry detection during disk initialisation, we always
 used (and still use) synchronous requests even if guest requests use AIO
 later. Geometry detection was not wanted to disable I/O throttling, so
 bdrv_pread_unthrottled() was introduced which disabled throttling only
 temporarily.
 All of this isn't necessary any more because we do run timers in polling
 loop and even synchronous requests are now using coroutine
 infrastructure internally. For this reason, commit 90c78624f already
 removed the automatic disabling of I/O throttling.
 It's time to get rid of the workaround for the removed code, and its
 abuse of blk_root_drained_begin()/end(), as well.
 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/sysemu/block-backend.h |  2 --
+ include/block/block.h       |  5 +++--
- block/block-backend.c          | 16 ----------------
+ block/block-backend.c       |  2 +-
- hw/block/hd-geometry.c         |  7 +------
+ block/crypto.c              |  2 +-
-files changed, 1 insertion(+), 24 deletions(-)
+ 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/include/sysemu/block-backend.h b/include/sysemu/block-backend.h
+diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
---- a/include/sysemu/block-backend.h
+--- a/include/block/block.h
-+++ b/include/sysemu/block-backend.h
++++ b/include/block/block.h
-@@ -XXX,XX +XXX,XX @@ char *blk_get_attached_dev_id(BlockBackend *blk);
+@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_find_backing_image(BlockDriverState *bs,
- BlockBackend *blk_by_dev(void *dev);
+ void bdrv_refresh_filename(BlockDriverState *bs);
- BlockBackend *blk_by_qdev_id(const char *id, Error **errp);
- void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops, void *opaque);
+ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
--int blk_pread_unthrottled(BlockBackend *blk, int64_t offset, uint8_t *buf,
+-                                  PreallocMode prealloc, Error **errp);
--                          int bytes);
++                                  PreallocMode prealloc, BdrvRequestFlags flags,
- int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
++                                  Error **errp);
-                                unsigned int bytes, QEMUIOVector *qiov,
+ int bdrv_truncate(BdrvChild *child, int64_t offset, bool exact,
-                                BdrvRequestFlags flags);
+-                  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 @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
+@@ -XXX,XX +XXX,XX @@ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
-     return rwco.ret;
+         return -ENOMEDIUM;
- }
+     }
--int blk_pread_unthrottled(BlockBackend *blk, int64_t offset, uint8_t *buf,
+-    return bdrv_truncate(blk->root, offset, exact, prealloc, errp);
--                          int count)
++    return bdrv_truncate(blk->root, offset, exact, prealloc, 0, errp);
--{
+ }
--    int ret;
--
+ int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
--    ret = blk_check_byte_request(blk, offset, count);
+diff --git a/block/crypto.c b/block/crypto.c
--    if (ret < 0) {
+index XXXXXXX..XXXXXXX 100644
--        return ret;
+--- a/block/crypto.c
--    }
++++ b/block/crypto.c
--
+@@ -XXX,XX +XXX,XX @@ block_crypto_co_truncate(BlockDriverState *bs, int64_t offset, bool exact,
--    blk_root_drained_begin(blk->root);
--    ret = blk_pread(blk, offset, buf, count);
+     offset += payload_offset;
--    blk_root_drained_end(blk->root, NULL);
--    return ret;
+-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
--}
++    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
--
+ }
- int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
-                       int bytes, BdrvRequestFlags flags)
+ 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)
  {
-diff --git a/hw/block/hd-geometry.c b/hw/block/hd-geometry.c
+     BlockDriverState *bs = child->bs;
-index XXXXXXX..XXXXXXX 100644
+     BlockDriver *drv = bs->drv;
---- a/hw/block/hd-geometry.c
+     BdrvTrackedRequest req;
-+++ b/hw/block/hd-geometry.c
+-    BdrvRequestFlags flags = 0;
-@@ -XXX,XX +XXX,XX @@ static int guess_disk_lchs(BlockBackend *blk,
+     int64_t old_size, new_bytes;
+     int ret;
-     blk_get_geometry(blk, &nb_sectors);
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
--    /**
+         }
--     * The function will be invoked during startup not only in sync I/O mode,
+         ret = drv->bdrv_co_truncate(bs, offset, exact, prealloc, flags, errp);
--     * but also in async I/O mode. So the I/O throttling function has to
+     } else if (bs->file && drv->is_filter) {
--     * be disabled temporarily here, not permanently.
+-        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, errp);
--     */
++        ret = bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
--    if (blk_pread_unthrottled(blk, 0, buf, BDRV_SECTOR_SIZE) < 0) {
+     } else {
-+    if (blk_pread(blk, 0, buf, BDRV_SECTOR_SIZE) < 0) {
+         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,
-     /* test msdos magic */
+-                        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;
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 14/16] block-backend: Queue requests while drained
+[PULL 05/15] block-backend: Add flags to blk_truncate()
-This fixes devices like IDE that can still start new requests from I/O
+Now that node level interface bdrv_truncate() supports passing request
-handlers in the CPU thread while the block backend is drained.
+flags to the block driver, expose this on the BlockBackend level, too.
 The basic assumption is that in a drain section, no new requests should
 be allowed through a BlockBackend (blk_drained_begin/end don't exist,
 we get drain sections only on the node level). However, there are two
 special cases where requests should not be queued:
 . Block jobs: We already make sure that block jobs are paused in a
    drain section, so they won't start new requests. However, if the
    drain_begin is called on the job's BlockBackend first, it can happen
    that we deadlock because the job stays busy until it reaches a pause
    point - which it can't if its requests aren't processed any more.
    The proper solution here would be to make all requests through the
    job's filter node instead of using a BlockBackend. For now, just
    disabling request queuing on the job BlockBackend is simpler.
 . In test cases where making requests through bdrv_* would be
    cumbersome because we'd need a BdrvChild. As we already got the
    functionality to disable request queuing from 1., use it in tests,
    too, for convenience.
 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 |  1 +
+ include/sysemu/block-backend.h | 2 +-
- block/backup.c                 |  1 +
+ block.c                        | 3 ++-
- block/block-backend.c          | 53 ++++++++++++++++++++++++++++++++--
+ block/block-backend.c          | 4 ++--
- block/commit.c                 |  2 ++
+ block/commit.c                 | 4 ++--
- block/mirror.c                 |  1 +
+ block/crypto.c                 | 2 +-
- blockjob.c                     |  3 ++
+ block/mirror.c                 | 2 +-
- tests/test-bdrv-drain.c        |  1 +
+ block/qcow2.c                  | 4 ++--
-files changed, 59 insertions(+), 3 deletions(-)
+ 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 @@ void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm);
+@@ -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,
- void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow);
+                           int bytes);
- void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow);
+ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
-+void blk_set_disable_request_queuing(BlockBackend *blk, bool disable);
+-                 PreallocMode prealloc, Error **errp);
- void blk_iostatus_enable(BlockBackend *blk);
++                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp);
- bool blk_iostatus_is_enabled(const BlockBackend *blk);
+ int blk_pdiscard(BlockBackend *blk, int64_t offset, int bytes);
- BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk);
+ int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
-diff --git a/block/backup.c b/block/backup.c
+                      int64_t pos, int size);
-index XXXXXXX..XXXXXXX 100644
+diff --git a/block.c b/block.c
---- a/block/backup.c
+index XXXXXXX..XXXXXXX 100644
-+++ b/block/backup.c
+--- a/block.c
-@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
++++ b/block.c
-     if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,
-         goto error;
+     int64_t size;
-     }
+     int ret;
-+    blk_set_disable_request_queuing(job->target, true);
+-    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, &local_err);
-     job->on_source_error = on_source_error;
++    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
-     job->on_target_error = on_target_error;
++                       &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 @@ struct BlockBackend {
+@@ -XXX,XX +XXX,XX @@ int blk_pwrite_compressed(BlockBackend *blk, int64_t offset, const void *buf,
      QLIST_HEAD(, BlockBackendAioNotifier) aio_notifiers;
      int quiesce_counter;
 +    CoQueue queued_requests;
 +    bool disable_request_queuing;
 +
      VMChangeStateEntry *vmsh;
      bool force_allow_inactivate;
@@ -XXX,XX +XXX,XX @@ BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm)
      block_acct_init(&blk->stats);
 +    qemu_co_queue_init(&blk->queued_requests);
      notifier_list_init(&blk->remove_bs_notifiers);
      notifier_list_init(&blk->insert_bs_notifiers);
      QLIST_INIT(&blk->aio_notifiers);
@@ -XXX,XX +XXX,XX @@ void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow)
      blk->allow_aio_context_change = allow;
  }
-+void blk_set_disable_request_queuing(BlockBackend *blk, bool disable)
+ int blk_truncate(BlockBackend *blk, int64_t offset, bool exact,
-+{
+-                 PreallocMode prealloc, Error **errp)
-+    blk->disable_request_queuing = disable;
++                 PreallocMode prealloc, BdrvRequestFlags flags, Error **errp)
 +}
 +
  static int blk_check_byte_request(BlockBackend *blk, int64_t offset,
                                    size_t size)
  {
-@@ -XXX,XX +XXX,XX @@ static int blk_check_byte_request(BlockBackend *blk, int64_t offset,
+     if (!blk_is_available(blk)) {
-     return 0;
+         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);
  }
-+static void coroutine_fn blk_wait_while_drained(BlockBackend *blk)
+ int blk_save_vmstate(BlockBackend *blk, const uint8_t *buf,
 +{
 +    if (blk->quiesce_counter && !blk->disable_request_queuing) {
 +        qemu_co_queue_wait(&blk->queued_requests, NULL);
 +    }
 +}
 +
  int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
                                 unsigned int bytes, QEMUIOVector *qiov,
                                 BdrvRequestFlags flags)
  {
      int ret;
 -    BlockDriverState *bs = blk_bs(blk);
 +    BlockDriverState *bs;
 +    blk_wait_while_drained(blk);
 +
 +    /* Call blk_bs() only after waiting, the graph may have changed */
 +    bs = blk_bs(blk);
      trace_blk_co_preadv(blk, bs, offset, bytes, flags);
      ret = blk_check_byte_request(blk, offset, bytes);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
                                  BdrvRequestFlags flags)
  {
      int ret;
 -    BlockDriverState *bs = blk_bs(blk);
 +    BlockDriverState *bs;
 +    blk_wait_while_drained(blk);
 +
 +    /* Call blk_bs() only after waiting, the graph may have changed */
 +    bs = blk_bs(blk);
      trace_blk_co_pwritev(blk, bs, offset, bytes, flags);
      ret = blk_check_byte_request(blk, offset, bytes);
@@ -XXX,XX +XXX,XX @@ static void blk_aio_read_entry(void *opaque)
      BlkRwCo *rwco = &acb->rwco;
      QEMUIOVector *qiov = rwco->iobuf;
 +    if (rwco->blk->quiesce_counter) {
 +        blk_dec_in_flight(rwco->blk);
 +        blk_wait_while_drained(rwco->blk);
 +        blk_inc_in_flight(rwco->blk);
 +    }
 +
      assert(qiov->size == acb->bytes);
      rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, acb->bytes,
                                qiov, rwco->flags);
@@ -XXX,XX +XXX,XX @@ static void blk_aio_write_entry(void *opaque)
      BlkRwCo *rwco = &acb->rwco;
      QEMUIOVector *qiov = rwco->iobuf;
 +    if (rwco->blk->quiesce_counter) {
 +        blk_dec_in_flight(rwco->blk);
 +        blk_wait_while_drained(rwco->blk);
 +        blk_inc_in_flight(rwco->blk);
 +    }
 +
      assert(!qiov || qiov->size == acb->bytes);
      rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, acb->bytes,
                                 qiov, rwco->flags);
@@ -XXX,XX +XXX,XX @@ void blk_aio_cancel_async(BlockAIOCB *acb)
  int blk_co_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
  {
 +    blk_wait_while_drained(blk);
 +
      if (!blk_is_available(blk)) {
          return -ENOMEDIUM;
      }
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
  int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
  {
 -    int ret = blk_check_byte_request(blk, offset, bytes);
 +    int ret;
 +
 +    blk_wait_while_drained(blk);
 +
 +    ret = blk_check_byte_request(blk, offset, bytes);
      if (ret < 0) {
          return ret;
      }
@@ -XXX,XX +XXX,XX @@ int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
  int blk_co_flush(BlockBackend *blk)
  {
 +    blk_wait_while_drained(blk);
 +
      if (!blk_is_available(blk)) {
          return -ENOMEDIUM;
      }
@@ -XXX,XX +XXX,XX @@ static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter)
          if (blk->dev_ops && blk->dev_ops->drained_end) {
              blk->dev_ops->drained_end(blk->dev_opaque);
          }
 +        while (qemu_co_enter_next(&blk->queued_requests, NULL)) {
 +            /* Resume all queued requests */
 +        }
      }
  }
 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 @@ void commit_start(const char *job_id, BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
-     if (ret < 0) {
+     }
-         goto fail;
-     }
+     if (base_len < len) {
-+    blk_set_disable_request_queuing(s->base, true);
+-        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, NULL);
-     s->base_bs = base;
++        ret = blk_truncate(s->base, len, false, PREALLOC_MODE_OFF, 0, NULL);
+         if (ret) {
-     /* Required permissions are already taken with block_job_add_bdrv() */
+             goto out;
-@@ -XXX,XX +XXX,XX @@ void commit_start(const char *job_id, BlockDriverState *bs,
+         }
-     if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ int bdrv_commit(BlockDriverState *bs)
-         goto fail;
+      * grow the backing file image if possible.  If not possible,
-     }
+      * we must return an error */
-+    blk_set_disable_request_queuing(s->top, true);
+     if (length > backing_length) {
+-        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF,
-     s->backing_file_str = g_strdup(backing_file_str);
++        ret = blk_truncate(backing, length, false, PREALLOC_MODE_OFF, 0,
-     s->on_error = on_error;
+                            &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 BlockJob *mirror_start_job(
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
-         blk_set_force_allow_inactivate(s->target);
-     }
+         if (s->bdev_length > base_length) {
-     blk_set_allow_aio_context_change(s->target, true);
+             ret = blk_truncate(s->target, s->bdev_length, false,
-+    blk_set_disable_request_queuing(s->target, true);
+-                               PREALLOC_MODE_OFF, NULL);
++                               PREALLOC_MODE_OFF, 0, NULL);
-     s->replaces = g_strdup(replaces);
+             if (ret < 0) {
-     s->on_source_error = on_source_error;
+                 goto immediate_exit;
-diff --git a/blockjob.c b/blockjob.c
+             }
-index XXXXXXX..XXXXXXX 100644
+diff --git a/block/qcow2.c b/block/qcow2.c
---- a/blockjob.c
+index XXXXXXX..XXXXXXX 100644
-+++ b/blockjob.c
+--- a/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
++++ b/block/qcow2.c
+@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
-     bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
+     /* Okay, now that we have a valid image, let's give it the right size */
-+    /* Disable request queuing in the BlockBackend to avoid deadlocks on drain:
+     ret = blk_truncate(blk, qcow2_opts->size, false, qcow2_opts->preallocation,
-+     * The job reports that it's busy until it reaches a pause point. */
+-                       errp);
-+    blk_set_disable_request_queuing(blk, true);
++                       0, errp);
-     blk_set_allow_aio_context_change(blk, true);
+     if (ret < 0) {
+         error_prepend(errp, "Could not resize image: ");
-     /* Only set speed when necessary to avoid NotSupported error */
+         goto out;
-diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
+@@ -XXX,XX +XXX,XX @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts,
-index XXXXXXX..XXXXXXX 100644
+          * Amending image options should ensure that the image has
---- a/tests/test-bdrv-drain.c
+          * exactly the given new values, so pass exact=true here.
-+++ b/tests/test-bdrv-drain.c
+          */
-@@ -XXX,XX +XXX,XX @@ static void test_iothread_common(enum drain_type drain_type, int drain_thread)
+-        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, errp);
-                               &error_abort);
++        ret = blk_truncate(blk, new_size, true, PREALLOC_MODE_OFF, 0, errp);
-     s = bs->opaque;
+         blk_unref(blk);
-     blk_insert_bs(blk, bs, &error_abort);
+         if (ret < 0) {
-+    blk_set_disable_request_queuing(blk, true);
+             return ret;
+diff --git a/block/qed.c b/block/qed.c
-     blk_set_aio_context(blk, ctx_a, &error_abort);
+index XXXXXXX..XXXXXXX 100644
-     aio_context_acquire(ctx_a);
+--- 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;
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 11/16] iotests: Add test for concurrent stream/commit
+[PULL 06/15] qcow2: Support BDRV_REQ_ZERO_WRITE for truncate
-From: Max Reitz <mreitz@redhat.com>
+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.
-We already have 030 for that in general, but this tests very specific
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-cases of both jobs finishing concurrently.
+Message-Id: <20200424125448.63318-5-kwolf@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/258     | 163 +++++++++++++++++++++++++++++++++++++
+ block/qcow2-cluster.c |  2 +-
- tests/qemu-iotests/258.out |  33 ++++++++
+ block/qcow2.c         | 34 ++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/group   |   1 +
+files changed, 35 insertions(+), 1 deletion(-)
 files changed, 197 insertions(+)
  create mode 100755 tests/qemu-iotests/258
  create mode 100644 tests/qemu-iotests/258.out
-diff --git a/tests/qemu-iotests/258 b/tests/qemu-iotests/258
+diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
-new file mode 100755
+index XXXXXXX..XXXXXXX 100644
-index XXXXXXX..XXXXXXX
+--- a/block/qcow2-cluster.c
---- /dev/null
++++ b/block/qcow2-cluster.c
-+++ b/tests/qemu-iotests/258
+@@ -XXX,XX +XXX,XX @@ int qcow2_cluster_zeroize(BlockDriverState *bs, uint64_t offset,
-@@ -XXX,XX +XXX,XX @@
+     /* Caller must pass aligned values, except at image end */
-+#!/usr/bin/env python
+     assert(QEMU_IS_ALIGNED(offset, s->cluster_size));
-+#
+     assert(QEMU_IS_ALIGNED(end_offset, s->cluster_size) ||
-+# Very specific tests for adjacent commit/stream block jobs
+-           end_offset == bs->total_sectors << BDRV_SECTOR_BITS);
-+#
++           end_offset >= bs->total_sectors << BDRV_SECTOR_BITS);
-+# Copyright (C) 2019 Red Hat, Inc.
-+#
+     /* The zero flag is only supported by version 3 and newer */
-+# This program is free software; you can redistribute it and/or modify
+     if (s->qcow_version < 3) {
-+# it under the terms of the GNU General Public License as published by
+diff --git a/block/qcow2.c b/block/qcow2.c
-+# the Free Software Foundation; either version 2 of the License, or
+index XXXXXXX..XXXXXXX 100644
-+# (at your option) any later version.
+--- a/block/qcow2.c
-+#
++++ b/block/qcow2.c
-+# This program is distributed in the hope that it will be useful,
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
-+# but WITHOUT ANY WARRANTY; without even the implied warranty of
-+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+     bs->supported_zero_flags = header.version >= 3 ?
-+# GNU General Public License for more details.
+                                BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
-+#
++    bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
-+# You should have received a copy of the GNU General Public License
-+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+     /* Repair image if dirty */
-+#
+     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
-+# Creator/Owner: Max Reitz <mreitz@redhat.com>
+@@ -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);
 +
-+import iotests
++        /*
-+from iotests import log, qemu_img, qemu_io_silent, \
++         * Use zero clusters as much as we can. qcow2_cluster_zeroize()
-+        filter_qmp_testfiles, filter_qmp_imgfmt
++         * 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;
 +        }
 +
-+# Need backing file and change-backing-file support
++        /* Write explicit zeros for the unaligned head */
-+iotests.verify_image_format(supported_fmts=['qcow2', 'qed'])
++        if (zero_start > old_length) {
-+iotests.verify_platform(['linux'])
++            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);
 +
-+# Returns a node for blockdev-add
++            qemu_vfree(buf);
-+def node(node_name, path, backing=None, fmt=None, throttle=None):
++            if (ret < 0) {
-+    if fmt is None:
++                error_setg_errno(errp, -ret, "Failed to zero out the new area");
-+        fmt = iotests.imgfmt
++                goto fail;
-+
++            }
 +    res = {
 +        'node-name': node_name,
 +        'driver': fmt,
 +        'file': {
 +            'driver': 'file',
 +            'filename': path
 +        }
 +    }
 +
-+    if backing is not None:
+     if (prealloc != PREALLOC_MODE_OFF) {
-+        res['backing'] = backing
+         /* Flush metadata before actually changing the image size */
-+
+         ret = qcow2_write_caches(bs);
 +    if throttle:
 +        res['file'] = {
 +            'driver': 'throttle',
 +            'throttle-group': throttle,
 +            'file': res['file']
 +        }
 +
 +    return res
 +
 +# Finds a node in the debug block graph
 +def find_graph_node(graph, node_id):
 +    return next(node for node in graph['nodes'] if node['id'] == node_id)
 +
 +
 +def test_concurrent_finish(write_to_stream_node):
 +    log('')
 +    log('=== Commit and stream finish concurrently (letting %s write) ===' % \
 +        ('stream' if write_to_stream_node else 'commit'))
 +    log('')
 +
 +    # All chosen in such a way that when the commit job wants to
 +    # finish, it polls and thus makes stream finish concurrently --
 +    # and the other way around, depending on whether the commit job
 +    # is finalized before stream completes or not.
 +
 +    with iotests.FilePath('node4.img') as node4_path, \
 +         iotests.FilePath('node3.img') as node3_path, \
 +         iotests.FilePath('node2.img') as node2_path, \
 +         iotests.FilePath('node1.img') as node1_path, \
 +         iotests.FilePath('node0.img') as node0_path, \
 +         iotests.VM() as vm:
 +
 +        # It is important to use raw for the base layer (so that
 +        # permissions are just handed through to the protocol layer)
 +        assert qemu_img('create', '-f', 'raw', node0_path, '64M') == 0
 +
 +        stream_throttle=None
 +        commit_throttle=None
 +
 +        for path in [node1_path, node2_path, node3_path, node4_path]:
 +            assert qemu_img('create', '-f', iotests.imgfmt, path, '64M') == 0
 +
 +        if write_to_stream_node:
 +            # This is what (most of the time) makes commit finish
 +            # earlier and then pull in stream
 +            assert qemu_io_silent(node2_path,
 +                                  '-c', 'write %iK 64K' % (65536 - 192),
 +                                  '-c', 'write %iK 64K' % (65536 -  64)) == 0
 +
 +            stream_throttle='tg'
 +        else:
 +            # And this makes stream finish earlier
 +            assert qemu_io_silent(node1_path,
 +                                  '-c', 'write %iK 64K' % (65536 - 64)) == 0
 +
 +            commit_throttle='tg'
 +
 +        vm.launch()
 +
 +        vm.qmp_log('object-add',
 +                   qom_type='throttle-group',
 +                   id='tg',
 +                   props={
 +                       'x-iops-write': 1,
 +                       'x-iops-write-max': 1
 +                   })
 +
 +        vm.qmp_log('blockdev-add',
 +                   filters=[filter_qmp_testfiles, filter_qmp_imgfmt],
 +                   **node('node4', node4_path, throttle=stream_throttle,
 +                     backing=node('node3', node3_path,
 +                     backing=node('node2', node2_path,
 +                     backing=node('node1', node1_path,
 +                     backing=node('node0', node0_path, throttle=commit_throttle,
 +                                  fmt='raw'))))))
 +
 +        vm.qmp_log('block-commit',
 +                   job_id='commit',
 +                   device='node4',
 +                   filter_node_name='commit-filter',
 +                   top_node='node1',
 +                   base_node='node0',
 +                   auto_finalize=False)
 +
 +        vm.qmp_log('block-stream',
 +                   job_id='stream',
 +                   device='node3',
 +                   base_node='commit-filter')
 +
 +        if write_to_stream_node:
 +            vm.run_job('commit', auto_finalize=False, auto_dismiss=True)
 +            vm.run_job('stream', auto_finalize=True, auto_dismiss=True)
 +        else:
 +            # No, the jobs do not really finish concurrently here,
 +            # the stream job does complete strictly before commit.
 +            # But still, this is close enough for what we want to
 +            # test.
 +            vm.run_job('stream', auto_finalize=True, auto_dismiss=True)
 +            vm.run_job('commit', auto_finalize=False, auto_dismiss=True)
 +
 +        # Assert that the backing node of node3 is node 0 now
 +        graph = vm.qmp('x-debug-query-block-graph')['return']
 +        for edge in graph['edges']:
 +            if edge['name'] == 'backing' and \
 +               find_graph_node(graph, edge['parent'])['name'] == 'node3':
 +                assert find_graph_node(graph, edge['child'])['name'] == 'node0'
 +                break
 +
 +
 +def main():
 +    log('Running tests:')
 +    test_concurrent_finish(True)
 +    test_concurrent_finish(False)
 +
 +if __name__ == '__main__':
 +    main()
 diff --git a/tests/qemu-iotests/258.out b/tests/qemu-iotests/258.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/258.out
@@ -XXX,XX +XXX,XX @@
 +Running tests:
 +
 +=== Commit and stream finish concurrently (letting stream write) ===
 +
 +{"execute": "object-add", "arguments": {"id": "tg", "props": {"x-iops-write": 1, "x-iops-write-max": 1}, "qom-type": "throttle-group"}}
 +{"return": {}}
 +{"execute": "blockdev-add", "arguments": {"backing": {"backing": {"backing": {"backing": {"driver": "raw", "file": {"driver": "file", "filename": "TEST_DIR/PID-node0.img"}, "node-name": "node0"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node1.img"}, "node-name": "node1"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node2.img"}, "node-name": "node2"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node3.img"}, "node-name": "node3"}, "driver": "IMGFMT", "file": {"driver": "throttle", "file": {"driver": "file", "filename": "TEST_DIR/PID-node4.img"}, "throttle-group": "tg"}, "node-name": "node4"}}
 +{"return": {}}
 +{"execute": "block-commit", "arguments": {"auto-finalize": false, "base-node": "node0", "device": "node4", "filter-node-name": "commit-filter", "job-id": "commit", "top-node": "node1"}}
 +{"return": {}}
 +{"execute": "block-stream", "arguments": {"base-node": "commit-filter", "device": "node3", "job-id": "stream"}}
 +{"return": {}}
 +{"execute": "job-finalize", "arguments": {"id": "commit"}}
 +{"return": {}}
 +{"data": {"id": "commit", "type": "commit"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"data": {"device": "commit", "len": 67108864, "offset": 67108864, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"data": {"device": "stream", "len": 67108864, "offset": 67108864, "speed": 0, "type": "stream"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +
 +=== Commit and stream finish concurrently (letting commit write) ===
 +
 +{"execute": "object-add", "arguments": {"id": "tg", "props": {"x-iops-write": 1, "x-iops-write-max": 1}, "qom-type": "throttle-group"}}
 +{"return": {}}
 +{"execute": "blockdev-add", "arguments": {"backing": {"backing": {"backing": {"backing": {"driver": "raw", "file": {"driver": "throttle", "file": {"driver": "file", "filename": "TEST_DIR/PID-node0.img"}, "throttle-group": "tg"}, "node-name": "node0"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node1.img"}, "node-name": "node1"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node2.img"}, "node-name": "node2"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node3.img"}, "node-name": "node3"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node4.img"}, "node-name": "node4"}}
 +{"return": {}}
 +{"execute": "block-commit", "arguments": {"auto-finalize": false, "base-node": "node0", "device": "node4", "filter-node-name": "commit-filter", "job-id": "commit", "top-node": "node1"}}
 +{"return": {}}
 +{"execute": "block-stream", "arguments": {"base-node": "commit-filter", "device": "node3", "job-id": "stream"}}
 +{"return": {}}
 +{"data": {"device": "stream", "len": 67108864, "offset": 67108864, "speed": 0, "type": "stream"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"execute": "job-finalize", "arguments": {"id": "commit"}}
 +{"return": {}}
 +{"data": {"id": "commit", "type": "commit"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"data": {"device": "commit", "len": 67108864, "offset": 67108864, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 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
 rw quick
 +258 rw quick
 rw quick migration
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 03/16] iotests/118: Add -blockdev based tests
+[PULL 07/15] raw-format: Support BDRV_REQ_ZERO_WRITE for truncate
-The code path for -device drive=<node-name> or without a drive=...
+The raw format driver can simply forward the flag and let its bs->file
-option for empty drives, which is supposed to be used with -blockdev
+child take care of actually providing the zeros.
 differs enough from the -drive based path with a user-owned
 BlockBackend, so we want to test both paths at least for the basic tests
 implemented by TestInitiallyFilled and TestInitiallyEmpty.
 This would have caught the bug recently fixed for inserting read-only
 nodes into a scsi-cd created without a drive=... option.
 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>
 ---
- tests/qemu-iotests/118     | 43 ++++++++++++++++++++++++++------------
+ block/raw-format.c | 4 +++-
- tests/qemu-iotests/118.out |  4 ++--
+file changed, 3 insertions(+), 1 deletion(-)
 files changed, 32 insertions(+), 15 deletions(-)
-diff --git a/tests/qemu-iotests/118 b/tests/qemu-iotests/118
+diff --git a/block/raw-format.c b/block/raw-format.c
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/118
 +++ b/tests/qemu-iotests/118
@@ -XXX,XX +XXX,XX @@ class ChangeBaseClass(iotests.QMPTestCase):
      has_opened = False
      has_closed = False
 +    device_name = 'qdev0'
 +    use_drive = False
 +
      def process_events(self):
          for event in self.vm.get_qmp_events(wait=False):
              if (event['event'] == 'DEVICE_TRAY_MOVED' and
 -                event['data']['device'] == 'drive0'):
 +                (event['data']['device'] == 'drive0' or
 +                 event['data']['id'] == self.device_name)):
                  if event['data']['tray-open'] == False:
                      self.has_closed = True
                  else:
@@ -XXX,XX +XXX,XX @@ class ChangeBaseClass(iotests.QMPTestCase):
  class GeneralChangeTestsBaseClass(ChangeBaseClass):
 -    device_name = 'qdev0'
 -
      def test_change(self):
 +        # 'change' requires a drive name, so skip the test for blockdev
 +        if not self.use_drive:
 +            return
 +
          result = self.vm.qmp('change', device='drive0', target=new_img,
                                         arg=iotests.imgfmt)
          self.assert_qmp(result, 'return', {})
@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):
          qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k')
          qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
          self.vm = iotests.VM()
 -        self.vm.add_drive(old_img, 'media=%s' % self.media, 'none')
 +        if self.use_drive:
 +            self.vm.add_drive(old_img, 'media=%s' % self.media, 'none')
 +        else:
 +            self.vm.add_blockdev([ 'node-name=drive0',
 +                                   'driver=%s' % iotests.imgfmt,
 +                                   'file.driver=file',
 +                                   'file.filename=%s' % old_img ])
          if self.interface == 'scsi':
              self.vm.add_device('virtio-scsi-pci')
          self.vm.add_device('%s,drive=drive0,id=%s' %
@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
      def setUp(self):
          qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
 -        self.vm = iotests.VM().add_drive(None, 'media=%s' % self.media, 'none')
 +        self.vm = iotests.VM()
 +        if self.use_drive:
 +            self.vm.add_drive(None, 'media=%s' % self.media, 'none')
          if self.interface == 'scsi':
              self.vm.add_device('virtio-scsi-pci')
 -        self.vm.add_device('%s,drive=drive0,id=%s' %
 +        self.vm.add_device('%s,%sid=%s' %
                             (interface_to_device_name(self.interface),
 +                            'drive=drive0,' if self.use_drive else '',
                              self.device_name))
          self.vm.launch()
@@ -XXX,XX +XXX,XX @@ def create_basic_test_classes():
                                                 ('disk', 'floppy', False) ]:
          for case in [ TestInitiallyFilled, TestInitiallyEmpty ]:
 -
 -            attr = { 'media': media,
 -                     'interface': interface,
 -                     'has_real_tray': has_real_tray }
 -
 -            name = '%s_%s_%s' % (case.__name__, media, interface)
 -            globals()[name] = type(name, (case, ), attr)
 +            for use_drive in [ True, False ]:
 +                attr = { 'media': media,
 +                         'interface': interface,
 +                         'has_real_tray': has_real_tray,
 +                         'use_drive': use_drive }
 +
 +                name = '%s_%s_%s_%s' % (case.__name__, media, interface,
 +                                        'drive' if use_drive else 'blockdev')
 +                globals()[name] = type(name, (case, ), attr)
  create_basic_test_classes()
 diff --git a/tests/qemu-iotests/118.out b/tests/qemu-iotests/118.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/118.out
+--- a/block/raw-format.c
-+++ b/tests/qemu-iotests/118.out
++++ b/block/raw-format.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
--.........................................................................................
-+.......................................................................................................................................................................
+     s->size = offset;
- ----------------------------------------------------------------------
+     offset += s->offset;
--Ran 89 tests
+-    return bdrv_co_truncate(bs->file, offset, exact, prealloc, 0, errp);
-+Ran 167 tests
++    return bdrv_co_truncate(bs->file, offset, exact, prealloc, flags, errp);
+ }
- OK
  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);
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 16/16] file-posix: Handle undetectable alignment
+[PULL 08/15] file-posix: Support BDRV_REQ_ZERO_WRITE for truncate
-From: Nir Soffer <nirsof@gmail.com>
+For regular files, we always get BDRV_REQ_ZERO_WRITE behaviour from the
 OS, so we can advertise the flag and just ignore it.
-In some cases buf_align or request_alignment cannot be detected:
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-. With Gluster, buf_align cannot be detected since the actual I/O is
+Reviewed-by: Alberto Garcia <berto@igalia.com>
-   done on Gluster server, and qemu buffer alignment does not matter.
+Reviewed-by: Max Reitz <mreitz@redhat.com>
-   Since we don't have alignment requirement, buf_align=1 is the best
+Message-Id: <20200424125448.63318-7-kwolf@redhat.com>
    value.
 . With local XFS filesystem, buf_align cannot be detected if reading
    from unallocated area. In this we must align the buffer, but we don't
    know what is the correct size. Using the wrong alignment results in
    I/O error.
 . With Gluster backed by XFS, request_alignment cannot be detected if
    reading from unallocated area. In this case we need to use the
    correct alignment, and failing to do so results in I/O errors.
 . With NFS, the server does not use direct I/O, so both buf_align cannot
    be detected. In this case we don't need any alignment so we can use
    buf_align=1 and request_alignment=1.
 These cases seems to work when storage sector size is 512 bytes, because
 the current code starts checking align=512. If the check succeeds
 because alignment cannot be detected we use 512. But this does not work
 for storage with 4k sector size.
 To determine if we can detect the alignment, we probe first with
 align=1. If probing succeeds, maybe there are no alignment requirement
 (cases 1, 4) or we are probing unallocated area (cases 2, 3). Since we
 don't have any way to tell, we treat this as undetectable alignment. If
 probing with align=1 fails with EINVAL, but probing with one of the
 expected alignments succeeds, we know that we found a working alignment.
 Practically the alignment requirements are the same for buffer
 alignment, buffer length, and offset in file. So in case we cannot
 detect buf_align, we can use request alignment. If we cannot detect
 request alignment, we can fallback to a safe value. To use this logic,
 we probe first request alignment instead of buf_align.
 Here is a table showing the behaviour with current code (the value in
 parenthesis is the optimal value).
 Case    Sector    buf_align (opt)   request_alignment (opt)     result
 ======================================================================
 512       512   (1)          512   (512)                 OK
 4096      512   (1)          4096  (4096)                FAIL
 ----------------------------------------------------------------------
 512       512   (512)        512   (512)                 OK
 4096      512   (4096)       4096  (4096)                FAIL
 ----------------------------------------------------------------------
 512       512   (1)          512   (512)                 OK
 4096      512   (1)          512   (4096)                FAIL
 ----------------------------------------------------------------------
 512       512   (1)          512   (1)                   OK
 4096      512   (1)          512   (1)                   OK
 Same cases with this change:
 Case    Sector    buf_align (opt)   request_alignment (opt)     result
 ======================================================================
 512       512   (1)          512   (512)                 OK
 4096      4096  (1)          4096  (4096)                OK
 ----------------------------------------------------------------------
 512       512   (512)        512   (512)                 OK
 4096      4096  (4096)       4096  (4096)                OK
 ----------------------------------------------------------------------
 512       4096  (1)          4096  (512)                 OK
 4096      4096  (1)          4096  (4096)                OK
 ----------------------------------------------------------------------
 512       4096  (1)          4096  (1)                   OK
 4096      4096  (1)          4096  (1)                   OK
 I tested that provisioning VMs and copying disks on local XFS and
 Gluster with 4k bytes sector size work now, resolving bugs [1],[2].
 I tested also on XFS, NFS, Gluster with 512 bytes sector size.
 [1] https://bugzilla.redhat.com/1737256
 [2] https://bugzilla.redhat.com/1738657
 Signed-off-by: Nir Soffer <nsoffer@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/file-posix.c | 36 +++++++++++++++++++++++++-----------
+ block/file-posix.c | 4 ++++
-file changed, 25 insertions(+), 11 deletions(-)
+file changed, 4 insertions(+)
 diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/file-posix.c
 +++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static int raw_open_common(BlockDriverState *bs, QDict *options,
      BDRVRawState *s = bs->opaque;
      char *buf;
      size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
 +    size_t alignments[] = {1, 512, 1024, 2048, 4096};
      /* For SCSI generic devices the alignment is not really used.
         With buffered I/O, we don't have any restrictions. */
@@ -XXX,XX +XXX,XX @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
      }
  #endif
--    /* If we could not get the sizes so far, we can only guess them */
+     bs->supported_zero_flags = BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK;
--    if (!s->buf_align) {
++    if (S_ISREG(st.st_mode)) {
-+    /*
++        /* When extending regular files, we get zeros from the OS */
-+     * If we could not get the sizes so far, we can only guess them. First try
++        bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
-+     * to detect request alignment, since it is more likely to succeed. Then
++    }
-+     * try to detect buf_align, which cannot be detected in some cases (e.g.
+     ret = 0;
-+     * Gluster). If buf_align cannot be detected, we fallback to the value of
+ fail:
-+     * request_alignment.
+     if (filename && (bdrv_flags & BDRV_O_TEMPORARY)) {
 +     */
 +
 +    if (!bs->bl.request_alignment) {
 +        int i;
          size_t align;
 -        buf = qemu_memalign(max_align, 2 * max_align);
 -        for (align = 512; align <= max_align; align <<= 1) {
 -            if (raw_is_io_aligned(fd, buf + align, max_align)) {
 -                s->buf_align = align;
 +        buf = qemu_memalign(max_align, max_align);
 +        for (i = 0; i < ARRAY_SIZE(alignments); i++) {
 +            align = alignments[i];
 +            if (raw_is_io_aligned(fd, buf, align)) {
 +                /* Fallback to safe value. */
 +                bs->bl.request_alignment = (align != 1) ? align : max_align;
                  break;
              }
          }
          qemu_vfree(buf);
      }
 -    if (!bs->bl.request_alignment) {
 +    if (!s->buf_align) {
 +        int i;
          size_t align;
 -        buf = qemu_memalign(s->buf_align, max_align);
 -        for (align = 512; align <= max_align; align <<= 1) {
 -            if (raw_is_io_aligned(fd, buf, align)) {
 -                bs->bl.request_alignment = align;
 +        buf = qemu_memalign(max_align, 2 * max_align);
 +        for (i = 0; i < ARRAY_SIZE(alignments); i++) {
 +            align = alignments[i];
 +            if (raw_is_io_aligned(fd, buf + align, max_align)) {
 +                /* Fallback to request_aligment. */
 +                s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
                  break;
              }
          }
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 10/16] tests: Test mid-drain bdrv_replace_child_noperm()
+[PULL 09/15] block: truncate: Don't make backing file data visible
-From: Max Reitz <mreitz@redhat.com>
+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.
-Add a test for what happens when you call bdrv_replace_child_noperm()
+Consider the following scenario where the overlay is shorter than its
-for various drain situations ({old,new} child {drained,not drained}).
+backing file:
-Most importantly, if both the old and the new child are drained, the
+    base.qcow2:     AAAAAAAA
-parent must not be undrained at any point.
+    overlay.qcow2:  BBBB
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+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>
 ---
- tests/test-bdrv-drain.c | 308 ++++++++++++++++++++++++++++++++++++++++
+ block/io.c | 25 +++++++++++++++++++++++++
-file changed, 308 insertions(+)
+file changed, 25 insertions(+)
-diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/test-bdrv-drain.c
+--- a/block/io.c
-+++ b/tests/test-bdrv-drain.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static void test_drop_intermediate_poll(void)
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
-     bdrv_unref(chain[2]);
+         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;
 +
-+typedef struct BDRVReplaceTestState {
++        backing_len = bdrv_getlength(backing_bs(bs));
-+    bool was_drained;
++        if (backing_len < 0) {
-+    bool was_undrained;
++            ret = backing_len;
-+    bool has_read;
++            error_setg_errno(errp, -ret, "Could not get backing file size");
-+
++            goto out;
 +    int drain_count;
 +
 +    bool yield_before_read;
 +    Coroutine *io_co;
 +    Coroutine *drain_co;
 +} BDRVReplaceTestState;
 +
 +static void bdrv_replace_test_close(BlockDriverState *bs)
 +{
 +}
 +
 +/**
 + * If @bs has a backing file:
 + *   Yield if .yield_before_read is true (and wait for drain_begin to
 + *   wake us up).
 + *   Forward the read to bs->backing.  Set .has_read to true.
 + *   If drain_begin has woken us, wake it in turn.
 + *
 + * Otherwise:
 + *   Set .has_read to true and return success.
 + */
 +static int coroutine_fn bdrv_replace_test_co_preadv(BlockDriverState *bs,
 +                                                    uint64_t offset,
 +                                                    uint64_t bytes,
 +                                                    QEMUIOVector *qiov,
 +                                                    int flags)
 +{
 +    BDRVReplaceTestState *s = bs->opaque;
 +
 +    if (bs->backing) {
 +        int ret;
 +
 +        g_assert(!s->drain_count);
 +
 +        s->io_co = qemu_coroutine_self();
 +        if (s->yield_before_read) {
 +            s->yield_before_read = false;
 +            qemu_coroutine_yield();
 +        }
 +        s->io_co = NULL;
 +
 +        ret = bdrv_preadv(bs->backing, offset, qiov);
 +        s->has_read = true;
 +
 +        /* Wake up drain_co if it runs */
 +        if (s->drain_co) {
 +            aio_co_wake(s->drain_co);
 +        }
 +
-+        return ret;
++        if (backing_len > old_size) {
 +            flags |= BDRV_REQ_ZERO_WRITE;
 +        }
 +    }
 +
-+    s->has_read = true;
+     if (drv->bdrv_co_truncate) {
-+    return 0;
+         if (flags & ~bs->supported_truncate_flags) {
-+}
+             error_setg(errp, "Block driver does not support requested flags");
 +
 +/**
 + * If .drain_count is 0, wake up .io_co if there is one; and set
 + * .was_drained.
 + * Increment .drain_count.
 + */
 +static void coroutine_fn bdrv_replace_test_co_drain_begin(BlockDriverState *bs)
 +{
 +    BDRVReplaceTestState *s = bs->opaque;
 +
 +    if (!s->drain_count) {
 +        /* Keep waking io_co up until it is done */
 +        s->drain_co = qemu_coroutine_self();
 +        while (s->io_co) {
 +            aio_co_wake(s->io_co);
 +            s->io_co = NULL;
 +            qemu_coroutine_yield();
 +        }
 +        s->drain_co = NULL;
 +
 +        s->was_drained = true;
 +    }
 +    s->drain_count++;
 +}
 +
 +/**
 + * Reduce .drain_count, set .was_undrained once it reaches 0.
 + * If .drain_count reaches 0 and the node has a backing file, issue a
 + * read request.
 + */
 +static void coroutine_fn bdrv_replace_test_co_drain_end(BlockDriverState *bs)
 +{
 +    BDRVReplaceTestState *s = bs->opaque;
 +
 +    g_assert(s->drain_count > 0);
 +    if (!--s->drain_count) {
 +        int ret;
 +
 +        s->was_undrained = true;
 +
 +        if (bs->backing) {
 +            char data;
 +            QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, &data, 1);
 +
 +            /* Queue a read request post-drain */
 +            ret = bdrv_replace_test_co_preadv(bs, 0, 1, &qiov, 0);
 +            g_assert(ret >= 0);
 +        }
 +    }
 +}
 +
 +static BlockDriver bdrv_replace_test = {
 +    .format_name            = "replace_test",
 +    .instance_size          = sizeof(BDRVReplaceTestState),
 +
 +    .bdrv_close             = bdrv_replace_test_close,
 +    .bdrv_co_preadv         = bdrv_replace_test_co_preadv,
 +
 +    .bdrv_co_drain_begin    = bdrv_replace_test_co_drain_begin,
 +    .bdrv_co_drain_end      = bdrv_replace_test_co_drain_end,
 +
 +    .bdrv_child_perm        = bdrv_format_default_perms,
 +};
 +
 +static void coroutine_fn test_replace_child_mid_drain_read_co(void *opaque)
 +{
 +    int ret;
 +    char data;
 +
 +    ret = blk_co_pread(opaque, 0, 1, &data, 0);
 +    g_assert(ret >= 0);
 +}
 +
 +/**
 + * We test two things:
 + * (1) bdrv_replace_child_noperm() must not undrain the parent if both
 + *     children are drained.
 + * (2) bdrv_replace_child_noperm() must never flush I/O requests to a
 + *     drained child.  If the old child is drained, it must flush I/O
 + *     requests after the new one has been attached.  If the new child
 + *     is drained, it must flush I/O requests before the old one is
 + *     detached.
 + *
 + * To do so, we create one parent node and two child nodes; then
 + * attach one of the children (old_child_bs) to the parent, then
 + * drain both old_child_bs and new_child_bs according to
 + * old_drain_count and new_drain_count, respectively, and finally
 + * we invoke bdrv_replace_node() to replace old_child_bs by
 + * new_child_bs.
 + *
 + * The test block driver we use here (bdrv_replace_test) has a read
 + * function that:
 + * - For the parent node, can optionally yield, and then forwards the
 + *   read to bdrv_preadv(),
 + * - For the child node, just returns immediately.
 + *
 + * If the read yields, the drain_begin function will wake it up.
 + *
 + * The drain_end function issues a read on the parent once it is fully
 + * undrained (which simulates requests starting to come in again).
 + */
 +static void do_test_replace_child_mid_drain(int old_drain_count,
 +                                            int new_drain_count)
 +{
 +    BlockBackend *parent_blk;
 +    BlockDriverState *parent_bs;
 +    BlockDriverState *old_child_bs, *new_child_bs;
 +    BDRVReplaceTestState *parent_s;
 +    BDRVReplaceTestState *old_child_s, *new_child_s;
 +    Coroutine *io_co;
 +    int i;
 +
 +    parent_bs = bdrv_new_open_driver(&bdrv_replace_test, "parent", 0,
 +                                     &error_abort);
 +    parent_s = parent_bs->opaque;
 +
 +    parent_blk = blk_new(qemu_get_aio_context(),
 +                         BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL);
 +    blk_insert_bs(parent_blk, parent_bs, &error_abort);
 +
 +    old_child_bs = bdrv_new_open_driver(&bdrv_replace_test, "old-child", 0,
 +                                        &error_abort);
 +    new_child_bs = bdrv_new_open_driver(&bdrv_replace_test, "new-child", 0,
 +                                        &error_abort);
 +    old_child_s = old_child_bs->opaque;
 +    new_child_s = new_child_bs->opaque;
 +
 +    /* So that we can read something */
 +    parent_bs->total_sectors = 1;
 +    old_child_bs->total_sectors = 1;
 +    new_child_bs->total_sectors = 1;
 +
 +    bdrv_ref(old_child_bs);
 +    parent_bs->backing = bdrv_attach_child(parent_bs, old_child_bs, "child",
 +                                           &child_backing, &error_abort);
 +
 +    for (i = 0; i < old_drain_count; i++) {
 +        bdrv_drained_begin(old_child_bs);
 +    }
 +    for (i = 0; i < new_drain_count; i++) {
 +        bdrv_drained_begin(new_child_bs);
 +    }
 +
 +    if (!old_drain_count) {
 +        /*
 +         * Start a read operation that will yield, so it will not
 +         * complete before the node is drained.
 +         */
 +        parent_s->yield_before_read = true;
 +        io_co = qemu_coroutine_create(test_replace_child_mid_drain_read_co,
 +                                      parent_blk);
 +        qemu_coroutine_enter(io_co);
 +    }
 +
 +    /* If we have started a read operation, it should have yielded */
 +    g_assert(!parent_s->has_read);
 +
 +    /* Reset drained status so we can see what bdrv_replace_node() does */
 +    parent_s->was_drained = false;
 +    parent_s->was_undrained = false;
 +
 +    g_assert(parent_bs->quiesce_counter == old_drain_count);
 +    bdrv_replace_node(old_child_bs, new_child_bs, &error_abort);
 +    g_assert(parent_bs->quiesce_counter == new_drain_count);
 +
 +    if (!old_drain_count && !new_drain_count) {
 +        /*
 +         * From undrained to undrained drains and undrains the parent,
 +         * because bdrv_replace_node() contains a drained section for
 +         * @old_child_bs.
 +         */
 +        g_assert(parent_s->was_drained && parent_s->was_undrained);
 +    } else if (!old_drain_count && new_drain_count) {
 +        /*
 +         * From undrained to drained should drain the parent and keep
 +         * it that way.
 +         */
 +        g_assert(parent_s->was_drained && !parent_s->was_undrained);
 +    } else if (old_drain_count && !new_drain_count) {
 +        /*
 +         * From drained to undrained should undrain the parent and
 +         * keep it that way.
 +         */
 +        g_assert(!parent_s->was_drained && parent_s->was_undrained);
 +    } else /* if (old_drain_count && new_drain_count) */ {
 +        /*
 +         * From drained to drained must not undrain the parent at any
 +         * point
 +         */
 +        g_assert(!parent_s->was_drained && !parent_s->was_undrained);
 +    }
 +
 +    if (!old_drain_count || !new_drain_count) {
 +        /*
 +         * If !old_drain_count, we have started a read request before
 +         * bdrv_replace_node().  If !new_drain_count, the parent must
 +         * have been undrained at some point, and
 +         * bdrv_replace_test_co_drain_end() starts a read request
 +         * then.
 +         */
 +        g_assert(parent_s->has_read);
 +    } else {
 +        /*
 +         * If the parent was never undrained, there is no way to start
 +         * a read request.
 +         */
 +        g_assert(!parent_s->has_read);
 +    }
 +
 +    /* A drained child must have not received any request */
 +    g_assert(!(old_drain_count && old_child_s->has_read));
 +    g_assert(!(new_drain_count && new_child_s->has_read));
 +
 +    for (i = 0; i < new_drain_count; i++) {
 +        bdrv_drained_end(new_child_bs);
 +    }
 +    for (i = 0; i < old_drain_count; i++) {
 +        bdrv_drained_end(old_child_bs);
 +    }
 +
 +    /*
 +     * By now, bdrv_replace_test_co_drain_end() must have been called
 +     * at some point while the new child was attached to the parent.
 +     */
 +    g_assert(parent_s->has_read);
 +    g_assert(new_child_s->has_read);
 +
 +    blk_unref(parent_blk);
 +    bdrv_unref(parent_bs);
 +    bdrv_unref(old_child_bs);
 +    bdrv_unref(new_child_bs);
 +}
 +
 +static void test_replace_child_mid_drain(void)
 +{
 +    int old_drain_count, new_drain_count;
 +
 +    for (old_drain_count = 0; old_drain_count < 2; old_drain_count++) {
 +        for (new_drain_count = 0; new_drain_count < 2; new_drain_count++) {
 +            do_test_replace_child_mid_drain(old_drain_count, new_drain_count);
 +        }
 +    }
 +}
 +
  int main(int argc, char **argv)
  {
      int ret;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
      g_test_add_func("/bdrv-drain/bdrv_drop_intermediate/poll",
                      test_drop_intermediate_poll);
 +    g_test_add_func("/bdrv-drain/replace_child/mid-drain",
 +                    test_replace_child_mid_drain);
 +
      ret = g_test_run();
      qemu_event_destroy(&done_event);
      return ret;
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 04/16] iotests: Move migration helpers to iotests.py
+[PULL 10/15] iotests: Filter testfiles out in filter_img_info()
-implements functions that are useful for doing migration between two
+We want to keep TEST_IMG for the full path of the main test image, but
-VMs. Move them to iotests.py so that other test cases can use them, too.
+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/234        | 30 +++++++-----------------------
+ tests/qemu-iotests/iotests.py | 5 +++--
- tests/qemu-iotests/iotests.py | 16 ++++++++++++++++
+file changed, 3 insertions(+), 2 deletions(-)
 files changed, 23 insertions(+), 23 deletions(-)
-diff --git a/tests/qemu-iotests/234 b/tests/qemu-iotests/234
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/234
-+++ b/tests/qemu-iotests/234
-@@ -XXX,XX +XXX,XX @@ import os
- iotests.verify_image_format(supported_fmts=['qcow2'])
- iotests.verify_platform(['linux'])
--def enable_migration_events(vm, name):
--    iotests.log('Enabling migration QMP events on %s...' % name)
--    iotests.log(vm.qmp('migrate-set-capabilities', capabilities=[
--        {
--            'capability': 'events',
--            'state': True
--        }
--    ]))
--
--def wait_migration(vm):
--    while True:
--        event = vm.event_wait('MIGRATION')
--        iotests.log(event, filters=[iotests.filter_qmp_event])
--        if event['data']['status'] == 'completed':
--            break
--
- with iotests.FilePath('img') as img_path, \
-      iotests.FilePath('backing') as backing_path, \
-      iotests.FilePath('mig_fifo_a') as fifo_a, \
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('img') as img_path, \
-          .add_blockdev('%s,file=drive0-backing-file,node-name=drive0-backing' % (iotests.imgfmt))
-          .launch())
--    enable_migration_events(vm_a, 'A')
-+    vm_a.enable_migration_events('A')
-     iotests.log('Launching destination VM...')
-     (vm_b.add_blockdev('file,filename=%s,node-name=drive0-file' % (img_path))
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('img') as img_path, \
-          .add_incoming("exec: cat '%s'" % (fifo_a))
-          .launch())
--    enable_migration_events(vm_b, 'B')
-+    vm_b.enable_migration_events('B')
-     # Add a child node that was created after the parent node. The reverse case
-     # is covered by the -blockdev options above.
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('img') as img_path, \
-     iotests.log(vm_a.qmp('migrate', uri='exec:cat >%s' % (fifo_a)))
-     with iotests.Timeout(3, 'Migration does not complete'):
-         # Wait for the source first (which includes setup=setup)
--        wait_migration(vm_a)
-+        vm_a.wait_migration()
-         # Wait for the destination second (which does not)
--        wait_migration(vm_b)
-+        vm_b.wait_migration()
-     iotests.log(vm_a.qmp('query-migrate')['return']['status'])
-     iotests.log(vm_b.qmp('query-migrate')['return']['status'])
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('img') as img_path, \
-          .add_incoming("exec: cat '%s'" % (fifo_b))
-          .launch())
--    enable_migration_events(vm_a, 'A')
-+    vm_a.enable_migration_events('A')
-     iotests.log(vm_a.qmp('blockdev-snapshot', node='drive0-backing',
-                          overlay='drive0'))
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('img') as img_path, \
-     iotests.log(vm_b.qmp('migrate', uri='exec:cat >%s' % (fifo_b)))
-     with iotests.Timeout(3, 'Migration does not complete'):
-         # Wait for the source first (which includes setup=setup)
--        wait_migration(vm_b)
-+        vm_b.wait_migration()
-         # Wait for the destination second (which does not)
--        wait_migration(vm_a)
-+        vm_a.wait_migration()
-     iotests.log(vm_a.qmp('query-migrate')['return']['status'])
-     iotests.log(vm_b.qmp('query-migrate')['return']['status'])
 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
-+    def enable_migration_events(self, name):
+-        line = line.replace(filename, 'TEST_IMG') \
-+        log('Enabling migration QMP events on %s...' % name)
+-                   .replace(imgfmt, 'IMGFMT')
-+        log(self.qmp('migrate-set-capabilities', capabilities=[
++        line = line.replace(filename, 'TEST_IMG')
-+            {
++        line = filter_testfiles(line)
-+                'capability': 'events',
++        line = line.replace(imgfmt, 'IMGFMT')
-+                'state': True
+         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)
 +
 +    def wait_migration(self):
 +        while True:
 +            event = self.event_wait('MIGRATION')
 +            log(event, filters=[filter_qmp_event])
 +            if event['data']['status'] == 'completed':
 +                break
 +
      def node_info(self, node_name):
          nodes = self.qmp('query-named-block-nodes')
          for x in nodes['return']:
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 05/16] iotests: Test migration with all kinds of filter nodes
+[PULL 11/15] iotests: Test committing to short backing file
-This test case is motivated by commit 2b23f28639 ('block/copy-on-read:
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Fix permissions for inactive node'). Instead of just testing
+Message-Id: <20200424125448.63318-10-kwolf@redhat.com>
-copy-on-read on migration, let's stack all sorts of filter nodes on top
+Reviewed-by: Max Reitz <mreitz@redhat.com>
-of each other and try if the resulting VM can still migrate
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-successfully. For good measure, put everything into an iothread, because
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-why not?
+---
  tests/qemu-iotests/274     | 155 +++++++++++++++++++++
  tests/qemu-iotests/274.out | 268 +++++++++++++++++++++++++++++++++++++
  tests/qemu-iotests/group   |   1 +
 files changed, 424 insertions(+)
  create mode 100755 tests/qemu-iotests/274
  create mode 100644 tests/qemu-iotests/274.out
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+diff --git a/tests/qemu-iotests/274 b/tests/qemu-iotests/274
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
  tests/qemu-iotests/262     | 82 ++++++++++++++++++++++++++++++++++++++
  tests/qemu-iotests/262.out | 17 ++++++++
  tests/qemu-iotests/group   |  1 +
 files changed, 100 insertions(+)
  create mode 100755 tests/qemu-iotests/262
  create mode 100644 tests/qemu-iotests/262.out
 diff --git a/tests/qemu-iotests/262 b/tests/qemu-iotests/262
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/262
++++ 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 with filter drivers present. Keep everything in an
++# Some tests for short backing files and short overlays
 +# iothread just for fun.
 +
 +import iotests
-+import os
 +
 +iotests.verify_image_format(supported_fmts=['qcow2'])
 +iotests.verify_platform(['linux'])
 +
-+with iotests.FilePath('img') as img_path, \
++size_short = 1 * 1024 * 1024
-+     iotests.FilePath('mig_fifo') as fifo, \
++size_long = 2 * 1024 * 1024
-+     iotests.VM(path_suffix='a') as vm_a, \
++size_diff = size_long - size_short
-+     iotests.VM(path_suffix='b') as vm_b:
++
-+
++def create_chain() -> None:
-+    def add_opts(vm):
++    iotests.qemu_img_log('create', '-f', iotests.imgfmt, base,
-+        vm.add_object('iothread,id=iothread0')
++                         str(size_long))
-+        vm.add_object('throttle-group,id=tg0,x-bps-total=65536')
++    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', base, mid,
-+        vm.add_blockdev('file,filename=%s,node-name=drive0-file' % (img_path))
++                         str(size_short))
-+        vm.add_blockdev('%s,file=drive0-file,node-name=drive0-fmt' % (iotests.imgfmt))
++    iotests.qemu_img_log('create', '-f', iotests.imgfmt, '-b', mid, top,
-+        vm.add_blockdev('copy-on-read,file=drive0-fmt,node-name=drive0-cor')
++                         str(size_long))
-+        vm.add_blockdev('throttle,file=drive0-cor,node-name=drive0-throttle,throttle-group=tg0')
++
-+        vm.add_blockdev('blkdebug,image=drive0-throttle,node-name=drive0-dbg')
++    iotests.qemu_io_log('-c', 'write -P 1 0 %d' % size_long, base)
-+        vm.add_blockdev('null-co,node-name=null,read-zeroes=on')
++
-+        vm.add_blockdev('blkverify,test=drive0-dbg,raw=null,node-name=drive0-verify')
++def create_vm() -> iotests.VM:
-+
++    vm = iotests.VM()
-+        if iotests.supports_quorum():
++    vm.add_blockdev('file,filename=%s,node-name=base-file' % base)
-+            vm.add_blockdev('quorum,children.0=drive0-verify,vote-threshold=1,node-name=drive0-quorum')
++    vm.add_blockdev('%s,file=base-file,node-name=base' % iotests.imgfmt)
-+            root = "drive0-quorum"
++    vm.add_blockdev('file,filename=%s,node-name=mid-file' % mid)
-+        else:
++    vm.add_blockdev('%s,file=mid-file,node-name=mid,backing=base'
-+            root = "drive0-verify"
++                    % iotests.imgfmt)
-+
++    vm.add_drive(top, 'backing=mid,node-name=top')
-+        vm.add_device('virtio-blk,drive=%s,iothread=iothread0' % root)
++    return vm
 +
-+    iotests.qemu_img_pipe('create', '-f', iotests.imgfmt, img_path, '64M')
++with iotests.FilePath('base') as base, \
-+
++     iotests.FilePath('mid') as mid, \
-+    os.mkfifo(fifo)
++     iotests.FilePath('top') as top:
 +
-+    iotests.log('Launching source VM...')
++    iotests.log('== Commit tests ==')
-+    add_opts(vm_a)
++
-+    vm_a.launch()
++    create_chain()
 +
-+    vm_a.enable_migration_events('A')
++    iotests.log('=== Check visible data ===')
 +
-+    iotests.log('Launching destination VM...')
++    iotests.qemu_io_log('-c', 'read -P 1 0 %d' % size_short, top)
-+    add_opts(vm_b)
++    iotests.qemu_io_log('-c', 'read -P 0 %d %d' % (size_short, size_diff), top)
-+    vm_b.add_incoming("exec: cat '%s'" % (fifo))
++
-+    vm_b.launch()
++    iotests.log('=== Checking allocation status ===')
 +
-+    vm_b.enable_migration_events('B')
++    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
-+
++                        '-c', 'alloc %d %d' % (size_short, size_diff),
-+    iotests.log('Starting migration to B...')
++                        base)
-+    iotests.log(vm_a.qmp('migrate', uri='exec:cat >%s' % (fifo)))
++
-+    with iotests.Timeout(3, 'Migration does not complete'):
++    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
-+        # Wait for the source first (which includes setup=setup)
++                        '-c', 'alloc %d %d' % (size_short, size_diff),
-+        vm_a.wait_migration()
++                        mid)
-+        # Wait for the destination second (which does not)
++
-+        vm_b.wait_migration()
++    iotests.qemu_io_log('-c', 'alloc 0 %d' % size_short,
-+
++                        '-c', 'alloc %d %d' % (size_short, size_diff),
-+    iotests.log(vm_a.qmp('query-migrate')['return']['status'])
++                        top)
-+    iotests.log(vm_b.qmp('query-migrate')['return']['status'])
++
-+
++    iotests.log('=== Checking map ===')
-+    iotests.log(vm_a.qmp('query-status'))
++
-+    iotests.log(vm_b.qmp('query-status'))
++    iotests.qemu_img_log('map', '--output=json', base)
-diff --git a/tests/qemu-iotests/262.out b/tests/qemu-iotests/262.out
++    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/262.out
++++ b/tests/qemu-iotests/274.out
 @@ -XXX,XX +XXX,XX @@
-+Launching source VM...
++== Commit tests ==
-+Enabling migration QMP events on A...
++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": {}}
-+Launching destination VM...
++{"execute": "job-complete", "arguments": {"id": "job0"}}
 +Enabling migration QMP events on B...
 +{"return": {}}
-+Starting migration to B...
++{"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": {}}
-+{"data": {"status": "setup"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++image: TEST_IMG
-+{"data": {"status": "active"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++file format: IMGFMT
-+{"data": {"status": "completed"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++virtual size: 2 MiB (2097152 bytes)
-+{"data": {"status": "active"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++cluster_size: 65536
-+{"data": {"status": "completed"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++backing file: TEST_DIR/PID-base
-+completed
++Format specific information:
-+completed
++    compat: 1.1
-+{"return": {"running": false, "singlestep": false, "status": "postmigrate"}}
++    lazy refcounts: false
-+{"return": {"running": true, "singlestep": false, "status": "running"}}
++    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 quick
+rw
-rw quick
+backing quick
-+262 rw quick migration
++274 rw backing
 rw quick
 rw backing quick
 rw migration quick
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 02/16] iotests/118: Create test classes dynamically
+[PULL 12/15] qcow2: Forward ZERO_WRITE flag for full preallocation
-We're getting a ridiculous number of child classes of
+The BDRV_REQ_ZERO_WRITE is currently implemented in a way that first the
-TestInitiallyFilled and TestInitiallyEmpty that differ only in a few
+image is possibly preallocated and then the zero flag is added to all
-attributes that we want to test in all combinations.
+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 of explicitly writing down every combination, let's use a loop
+Instead, try to forward the BDRV_REQ_ZERO_WRITE to the protocol driver,
-and create those classes dynamically.
+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>
 ---
- tests/qemu-iotests/118 | 69 +++++++++++++-----------------------------
+ block/qcow2.c              | 22 +++++++++++++++++++---
-file changed, 21 insertions(+), 48 deletions(-)
+ tests/qemu-iotests/274.out |  4 ++--
 files changed, 21 insertions(+), 5 deletions(-)
-diff --git a/tests/qemu-iotests/118 b/tests/qemu-iotests/118
+diff --git a/block/qcow2.c b/block/qcow2.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/118
+--- a/block/qcow2.c
-+++ b/tests/qemu-iotests/118
++++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
- class TestInitiallyFilled(GeneralChangeTestsBaseClass):
+         /* Allocate the data area */
-     was_empty = False
+         new_file_size = allocation_start +
+                         nb_new_data_clusters * s->cluster_size;
--    def setUp(self, media, interface):
+-        /* Image file grows, so @exact does not matter */
-+    def setUp(self):
+-        ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
-         qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k')
+-                               errp);
-         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
++        /*
-         self.vm = iotests.VM()
++         * Image file grows, so @exact does not matter.
--        self.vm.add_drive(old_img, 'media=%s' % media, 'none')
++         *
--        if interface == 'scsi':
++         * If we need to zero out the new area, try first whether the protocol
-+        self.vm.add_drive(old_img, 'media=%s' % self.media, 'none')
++         * driver can already take care of this.
-+        if self.interface == 'scsi':
++         */
-             self.vm.add_device('virtio-scsi-pci')
++        if (flags & BDRV_REQ_ZERO_WRITE) {
-         self.vm.add_device('%s,drive=drive0,id=%s' %
++            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc,
--                           (interface_to_device_name(interface),
++                                   BDRV_REQ_ZERO_WRITE, NULL);
-+                           (interface_to_device_name(self.interface),
++            if (ret >= 0) {
-                             self.device_name))
++                flags &= ~BDRV_REQ_ZERO_WRITE;
-         self.vm.launch()
++            }
++        } else {
-@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):
++            ret = -1;
- class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
++        }
-     was_empty = True
++        if (ret < 0) {
++            ret = bdrv_co_truncate(bs->file, new_file_size, false, prealloc, 0,
--    def setUp(self, media, interface):
++                                   errp);
-+    def setUp(self):
++        }
-         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
+         if (ret < 0) {
--        self.vm = iotests.VM().add_drive(None, 'media=%s' % media, 'none')
+             error_prepend(errp, "Failed to resize underlying file: ");
--        if interface == 'scsi':
+             qcow2_free_clusters(bs, allocation_start,
-+        self.vm = iotests.VM().add_drive(None, 'media=%s' % self.media, 'none')
+diff --git a/tests/qemu-iotests/274.out b/tests/qemu-iotests/274.out
-+        if self.interface == 'scsi':
+index XXXXXXX..XXXXXXX 100644
-             self.vm.add_device('virtio-scsi-pci')
+--- a/tests/qemu-iotests/274.out
-         self.vm.add_device('%s,drive=drive0,id=%s' %
++++ b/tests/qemu-iotests/274.out
--                           (interface_to_device_name(interface),
+@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 9437184
-+                           (interface_to_device_name(self.interface),
+MiB (0xa00000) bytes     allocated at offset 5 MiB (0x500000)
-                             self.device_name))
-         self.vm.launch()
+ [{ "start": 0, "length": 5242880, "depth": 1, "zero": true, "data": false},
+-{ "start": 5242880, "length": 10485760, "depth": 0, "zero": true, "data": false, "offset": 327680}]
-@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
++{ "start": 5242880, "length": 10485760, "depth": 0, "zero": false, "data": true, "offset": 327680}]
-         # Should be a no-op
-         self.assert_qmp(result, 'return', {})
+ === preallocation=full ===
+ Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=16777216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
--class TestCDInitiallyFilled(TestInitiallyFilled):
+@@ -XXX,XX +XXX,XX @@ read 65536/65536 bytes at offset 11534336
--    TestInitiallyFilled = TestInitiallyFilled
+MiB (0x400000) bytes     allocated at offset 8 MiB (0x800000)
--    has_real_tray = True
--
+ [{ "start": 0, "length": 8388608, "depth": 1, "zero": true, "data": false},
--    def setUp(self):
+-{ "start": 8388608, "length": 4194304, "depth": 0, "zero": true, "data": false, "offset": 327680}]
--        self.TestInitiallyFilled.setUp(self, 'cdrom', 'ide')
++{ "start": 8388608, "length": 4194304, "depth": 0, "zero": false, "data": true, "offset": 327680}]
--
--class TestCDInitiallyEmpty(TestInitiallyEmpty):
+ === preallocation=off ===
--    TestInitiallyEmpty = TestInitiallyEmpty
+ Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=393216 cluster_size=65536 lazy_refcounts=off refcount_bits=16
 -    has_real_tray = True
 -
 -    def setUp(self):
 -        self.TestInitiallyEmpty.setUp(self, 'cdrom', 'ide')
 +# Do this in a function to avoid leaking variables like case into the global
 +# name space (otherwise tests would be run for the abstract base classes)
 +def create_basic_test_classes():
 +    for (media, interface, has_real_tray) in [ ('cdrom', 'ide', True),
 +                                               ('cdrom', 'scsi', True),
 +                                               ('disk', 'floppy', False) ]:
 -class TestSCSICDInitiallyFilled(TestInitiallyFilled):
 -    TestInitiallyFilled = TestInitiallyFilled
 -    has_real_tray = True
 +        for case in [ TestInitiallyFilled, TestInitiallyEmpty ]:
 -    def setUp(self):
 -        self.TestInitiallyFilled.setUp(self, 'cdrom', 'scsi')
 +            attr = { 'media': media,
 +                     'interface': interface,
 +                     'has_real_tray': has_real_tray }
 -class TestSCSICDInitiallyEmpty(TestInitiallyEmpty):
 -    TestInitiallyEmpty = TestInitiallyEmpty
 -    has_real_tray = True
 +            name = '%s_%s_%s' % (case.__name__, media, interface)
 +            globals()[name] = type(name, (case, ), attr)
 -    def setUp(self):
 -        self.TestInitiallyEmpty.setUp(self, 'cdrom', 'scsi')
 -
 -class TestFloppyInitiallyFilled(TestInitiallyFilled):
 -    TestInitiallyFilled = TestInitiallyFilled
 -    has_real_tray = False
 -
 -    def setUp(self):
 -        self.TestInitiallyFilled.setUp(self, 'disk', 'floppy')
 -
 -class TestFloppyInitiallyEmpty(TestInitiallyEmpty):
 -    TestInitiallyEmpty = TestInitiallyEmpty
 -    has_real_tray = False
 -
 -    def setUp(self):
 -        self.TestInitiallyEmpty.setUp(self, 'disk', 'floppy')
 -        # FDDs not having a real tray and there not being a medium inside the
 -        # tray at startup means the tray will be considered open
 -        self.has_opened = True
 +create_basic_test_classes()
  class TestChangeReadOnly(ChangeBaseClass):
      device_name = 'qdev0'
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 08/16] block: Reduce (un)drains when replacing a child
+[PULL 13/15] nvme: introduce PMR support from NVMe 1.4 spec
-From: Max Reitz <mreitz@redhat.com>
+From: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>
-Currently, bdrv_replace_child_noperm() undrains the parent until it is
+This patch introduces support for PMR that has been defined as part of NVMe 1.4
-completely undrained, then re-drains it after attaching the new child
+spec. User can now specify a pmrdev option that should point to HostMemoryBackend.
-node.
+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.
-This is a problem with bdrv_drop_intermediate(): We want to keep the
+Signed-off-by: Andrzej Jakowski <andrzej.jakowski@linux.intel.com>
-whole subtree drained, including parents, while the operation is
+Reviewed-by: Klaus Jensen <k.jensen@samsung.com>
-under way.  bdrv_replace_child_noperm() breaks this by allowing every
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-parent to become unquiesced briefly, and then redraining it.
+Message-Id: <20200330164656.9348-1-andrzej.jakowski@linux.intel.com>
+Reviewed-by: Keith Busch <kbusch@kernel.org>
 In fact, there is no reason why the parent should become unquiesced and
 be allowed to submit requests to the new child node if that new node is
 supposed to be kept drained.  So if anything, we have to drain the
 parent before detaching the old child node.  Conversely, we have to
 undrain it only after attaching the new child node.
 Thus, change the whole drain algorithm here: Calculate the number of
 times we have to drain/undrain the parent before replacing the child
 node then drain it (if necessary), replace the child node, and then
 undrain it.
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block.c | 49 +++++++++++++++++++++++++++++++++----------------
+ hw/block/nvme.h        |   2 +
-file changed, 33 insertions(+), 16 deletions(-)
+ 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(-)
-diff --git a/block.c b/block.c
+diff --git a/hw/block/nvme.h b/hw/block/nvme.h
 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 bdrv_replace_child_noperm(BdrvChild *child,
+@@ -XXX,XX +XXX,XX @@ typedef struct NvmeCtrl {
-                                       BlockDriverState *new_bs)
+     uint64_t    timestamp_set_qemu_clock_ms;    /* QEMU clock time */
- {
-     BlockDriverState *old_bs = child->bs;
+     char            *serial;
--    int i;
++    HostMemoryBackend *pmrdev;
-+    int new_bs_quiesce_counter;
++
-+    int drain_saldo;
+     NvmeNamespace   *namespaces;
+     NvmeSQueue      **sq;
-     assert(!child->frozen);
+     NvmeCQueue      **cq;
+diff --git a/include/block/nvme.h b/include/block/nvme.h
-     if (old_bs && new_bs) {
+index XXXXXXX..XXXXXXX 100644
-         assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
+--- 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)
      }
-+
-+    new_bs_quiesce_counter = (new_bs ? new_bs->quiesce_counter : 0);
+     if (addr < sizeof(n->bar)) {
-+    drain_saldo = new_bs_quiesce_counter - child->parent_quiesce_counter;
++        /*
-+
++         * When PMRWBM bit 1 is set then read from
-+    /*
++         * from PMRSTS should ensure prior writes
-+     * If the new child node is drained but the old one was not, flush
++         * made it to persistent media
-+     * all outstanding requests to the old child node.
++         */
-+     */
++        if (addr == 0xE08 &&
-+    while (drain_saldo > 0 && child->role->drained_begin) {
++            (NVME_PMRCAP_PMRWBM(n->bar.pmrcap) & 0x02)) {
-+        bdrv_parent_drained_begin_single(child, true);
++            qemu_ram_writeback(n->pmrdev->mr.ram_block,
-+        drain_saldo--;
++                               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);
 +    }
 +
-     if (old_bs) {
+     blkconf_blocksizes(&n->conf);
-         /* Detach first so that the recursive drain sections coming from @child
+     if (!blkconf_apply_backend_options(&n->conf, blk_is_read_only(n->conf.blk),
-          * are already gone and we only end the drain sections that came from
+                                        false, errp)) {
-@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
+@@ -XXX,XX +XXX,XX @@ static void nvme_realize(PCIDevice *pci_dev, Error **errp)
-         if (child->role->detach) {
+             PCI_BASE_ADDRESS_SPACE_MEMORY | PCI_BASE_ADDRESS_MEM_TYPE_64 |
-             child->role->detach(child);
+             PCI_BASE_ADDRESS_MEM_PREFETCH, &n->ctrl_mem);
-         }
--        while (child->parent_quiesce_counter) {
++    } else if (n->pmrdev) {
--            bdrv_parent_drained_end_single(child);
++        /* Controller Capabilities register */
--        }
++        NVME_CAP_SET_PMRS(n->bar.cap, 1);
-         QLIST_REMOVE(child, next_parent);
++
--    } else {
++        /* PMR Capabities register */
--        assert(child->parent_quiesce_counter == 0);
++        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);
      }
-     child->bs = new_bs;
+     for (i = 0; i < n->num_namespaces; i++) {
+@@ -XXX,XX +XXX,XX @@ static void nvme_exit(PCIDevice *pci_dev)
-     if (new_bs) {
+     if (n->cmb_size_mb) {
-         QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
+         g_free(n->cmbuf);
 -        if (new_bs->quiesce_counter) {
 -            int num = new_bs->quiesce_counter;
 -            if (child->role->parent_is_bds) {
 -                num -= bdrv_drain_all_count;
 -            }
 -            assert(num >= 0);
 -            for (i = 0; i < num; i++) {
 -                bdrv_parent_drained_begin_single(child, true);
 -            }
 -        }
 +
 +        /*
 +         * Detaching the old node may have led to the new node's
 +         * quiesce_counter having been decreased.  Not a problem, we
 +         * just need to recognize this here and then invoke
 +         * drained_end appropriately more often.
 +         */
 +        assert(new_bs->quiesce_counter <= new_bs_quiesce_counter);
 +        drain_saldo += new_bs->quiesce_counter - new_bs_quiesce_counter;
          /* Attach only after starting new drained sections, so that recursive
           * drain sections coming from @child don't get an extra .drained_begin
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
              child->role->attach(child);
          }
      }
 +
-+    /*
++    if (n->pmrdev) {
-+     * If the old child node was drained but the new one is not, allow
++        host_memory_backend_set_mapped(n->pmrdev, false);
 +     * requests to come in only after the new node has been attached.
 +     */
 +    while (drain_saldo < 0 && child->role->drained_end) {
 +        bdrv_parent_drained_end_single(child);
 +        drain_saldo++;
 +    }
+     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

-[Qemu-devel] [PULL 06/16] block: Simplify bdrv_filter_default_perms()
+[PULL 14/15] qom: Factor out user_creatable_add_dict()
-The same change as commit 2b23f28639 ('block/copy-on-read: Fix
+The QMP handler qmp_object_add() and the implementation of --object in
-permissions for inactive node') made for the copy-on-read driver can be
+qemu-storage-daemon can share most of the code. Currently,
-made for bdrv_filter_default_perms(): Retaining the old permissions from
+qemu-storage-daemon calls qmp_object_add(), but this is not correct
-the BdrvChild if it is given complicates things unnecessarily when in
+because different visitors need to be used.
-the end this only means that the options set in the c == NULL case (i.e.
-during child creation) are retained.
+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>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- block.c | 12 ++----------
+ include/qom/object_interfaces.h | 12 ++++++++++++
-file changed, 2 insertions(+), 10 deletions(-)
+ qom/object_interfaces.c         | 27 +++++++++++++++++++++++++++
  qom/qom-qmp-cmds.c              | 24 +-----------------------
 files changed, 40 insertions(+), 23 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/include/qom/object_interfaces.h
-+++ b/block.c
++++ b/include/qom/object_interfaces.h
-@@ -XXX,XX +XXX,XX @@ void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
+@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
-                                uint64_t perm, uint64_t shared,
+                                 const QDict *qdict,
-                                uint64_t *nperm, uint64_t *nshared)
+                                 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)
  {
--    if (c == NULL) {
+diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
--        *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
+index XXXXXXX..XXXXXXX 100644
--        *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
+--- 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");
 -
--    *nperm = (perm & DEFAULT_PERM_PASSTHROUGH) |
+-    id = g_strdup(qdict_get_try_str(qdict, "id"));
--             (c->perm & DEFAULT_PERM_UNCHANGED);
+-    if (!id) {
--    *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) |
+-        error_setg(errp, QERR_MISSING_PARAMETER, "id");
--               (c->shared_perm & DEFAULT_PERM_UNCHANGED);
+-        return;
-+    *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
+-    }
-+    *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
+-    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 bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
+ void qmp_object_del(const char *id, Error **errp)
 --
-.20.1
+.25.3

-[Qemu-devel] [PULL 09/16] tests: Test polling in bdrv_drop_intermediate()
+[PULL 15/15] qemu-storage-daemon: Fix non-string --object properties
-From: Max Reitz <mreitz@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.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+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>
 ---
- tests/test-bdrv-drain.c | 167 ++++++++++++++++++++++++++++++++++++++++
+ include/qom/object_interfaces.h | 6 +++++-
-file changed, 167 insertions(+)
+ qemu-storage-daemon.c           | 4 +---
  qom/object_interfaces.c         | 8 ++++++--
  qom/qom-qmp-cmds.c              | 2 +-
 files changed, 13 insertions(+), 7 deletions(-)
-diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
+diff --git a/include/qom/object_interfaces.h b/include/qom/object_interfaces.h
 index XXXXXXX..XXXXXXX 100644
---- a/tests/test-bdrv-drain.c
+--- a/include/qom/object_interfaces.h
-+++ b/tests/test-bdrv-drain.c
++++ b/include/qom/object_interfaces.h
-@@ -XXX,XX +XXX,XX @@ static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c,
+@@ -XXX,XX +XXX,XX @@ Object *user_creatable_add_type(const char *type, const char *id,
-                               nperm, nshared);
+ /**
   * 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;
  }
-+static int bdrv_test_change_backing_file(BlockDriverState *bs,
+-void user_creatable_add_dict(QDict *qdict, Error **errp)
-+                                         const char *backing_file,
++void user_creatable_add_dict(QDict *qdict, bool keyval, Error **errp)
-+                                         const char *backing_fmt)
+ {
-+{
+     Visitor *v;
-+    return 0;
+     Object *obj;
-+}
+@@ -XXX,XX +XXX,XX @@ void user_creatable_add_dict(QDict *qdict, Error **errp)
-+
+     }
- static BlockDriver bdrv_test = {
+     qdict_del(qdict, "id");
-     .format_name            = "test",
-     .instance_size          = sizeof(BDRVTestState),
+-    v = qobject_input_visitor_new(QOBJECT(qdict));
-@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_test = {
++    if (keyval) {
-     .bdrv_co_drain_end      = bdrv_test_co_drain_end,
++        v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
++    } else {
-     .bdrv_child_perm        = bdrv_test_child_perm,
++        v = qobject_input_visitor_new(QOBJECT(qdict));
-+
++    }
-+    .bdrv_change_backing_file = bdrv_test_change_backing_file,
+     obj = user_creatable_add_type(type, id, qdict, v, errp);
- };
+     visit_free(v);
+     object_unref(obj);
- static void aio_ret_cb(void *opaque, int ret)
+diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
-@@ -XXX,XX +XXX,XX @@ static void test_blockjob_commit_by_drained_end(void)
+index XXXXXXX..XXXXXXX 100644
-     bdrv_unref(bs_child);
+--- 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)
 +typedef struct TestSimpleBlockJob {
 +    BlockJob common;
 +    bool should_complete;
 +    bool *did_complete;
 +} TestSimpleBlockJob;
 +
 +static int coroutine_fn test_simple_job_run(Job *job, Error **errp)
 +{
 +    TestSimpleBlockJob *s = container_of(job, TestSimpleBlockJob, common.job);
 +
 +    while (!s->should_complete) {
 +        job_sleep_ns(job, 0);
 +    }
 +
 +    return 0;
 +}
 +
 +static void test_simple_job_clean(Job *job)
 +{
 +    TestSimpleBlockJob *s = container_of(job, TestSimpleBlockJob, common.job);
 +    *s->did_complete = true;
 +}
 +
 +static const BlockJobDriver test_simple_job_driver = {
 +    .job_driver = {
 +        .instance_size  = sizeof(TestSimpleBlockJob),
 +        .free           = block_job_free,
 +        .user_resume    = block_job_user_resume,
 +        .drain          = block_job_drain,
 +        .run            = test_simple_job_run,
 +        .clean          = test_simple_job_clean,
 +    },
 +};
 +
 +static int drop_intermediate_poll_update_filename(BdrvChild *child,
 +                                                  BlockDriverState *new_base,
 +                                                  const char *filename,
 +                                                  Error **errp)
 +{
 +    /*
 +     * We are free to poll here, which may change the block graph, if
 +     * it is not drained.
 +     */
 +
 +    /* If the job is not drained: Complete it, schedule job_exit() */
 +    aio_poll(qemu_get_current_aio_context(), false);
 +    /* If the job is not drained: Run job_exit(), finish the job */
 +    aio_poll(qemu_get_current_aio_context(), false);
 +
 +    return 0;
 +}
 +
 +/**
 + * Test a poll in the midst of bdrv_drop_intermediate().
 + *
 + * bdrv_drop_intermediate() calls BdrvChildRole.update_filename(),
 + * which can yield or poll.  This may lead to graph changes, unless
 + * the whole subtree in question is drained.
 + *
 + * We test this on the following graph:
 + *
 + *                    Job
 + *
 + *                     |
 + *                  job-node
 + *                     |
 + *                     v
 + *
 + *                  job-node
 + *
 + *                     |
 + *                  backing
 + *                     |
 + *                     v
 + *
 + * node-2 --chain--> node-1 --chain--> node-0
 + *
 + * We drop node-1 with bdrv_drop_intermediate(top=node-1, base=node-0).
 + *
 + * This first updates node-2's backing filename by invoking
 + * drop_intermediate_poll_update_filename(), which polls twice.  This
 + * causes the job to finish, which in turns causes the job-node to be
 + * deleted.
 + *
 + * bdrv_drop_intermediate() uses a QLIST_FOREACH_SAFE() loop, so it
 + * already has a pointer to the BdrvChild edge between job-node and
 + * node-1.  When it tries to handle that edge, we probably get a
 + * segmentation fault because the object no longer exists.
 + *
 + *
 + * The solution is for bdrv_drop_intermediate() to drain top's
 + * subtree.  This prevents graph changes from happening just because
 + * BdrvChildRole.update_filename() yields or polls.  Thus, the block
 + * job is paused during that drained section and must finish before or
 + * after.
 + *
 + * (In addition, bdrv_replace_child() must keep the job paused.)
 + */
 +static void test_drop_intermediate_poll(void)
 +{
 +    static BdrvChildRole chain_child_role;
 +    BlockDriverState *chain[3];
 +    TestSimpleBlockJob *job;
 +    BlockDriverState *job_node;
 +    bool job_has_completed = false;
 +    int i;
 +    int ret;
 +
 +    chain_child_role = child_backing;
 +    chain_child_role.update_filename = drop_intermediate_poll_update_filename;
 +
 +    for (i = 0; i < 3; i++) {
 +        char name[32];
 +        snprintf(name, 32, "node-%i", i);
 +
 +        chain[i] = bdrv_new_open_driver(&bdrv_test, name, 0, &error_abort);
 +    }
 +
 +    job_node = bdrv_new_open_driver(&bdrv_test, "job-node", BDRV_O_RDWR,
 +                                    &error_abort);
 +    bdrv_set_backing_hd(job_node, chain[1], &error_abort);
 +
 +    /*
 +     * Establish the chain last, so the chain links are the first
 +     * elements in the BDS.parents lists
 +     */
 +    for (i = 0; i < 3; i++) {
 +        if (i) {
 +            /* Takes the reference to chain[i - 1] */
 +            chain[i]->backing = bdrv_attach_child(chain[i], chain[i - 1],
 +                                                  "chain", &chain_child_role,
 +                                                  &error_abort);
 +        }
 +    }
 +
 +    job = block_job_create("job", &test_simple_job_driver, NULL, job_node,
 +                           0, BLK_PERM_ALL, 0, 0, NULL, NULL, &error_abort);
 +
 +    /* The job has a reference now */
 +    bdrv_unref(job_node);
 +
 +    job->did_complete = &job_has_completed;
 +
 +    job_start(&job->common.job);
 +    job->should_complete = true;
 +
 +    g_assert(!job_has_completed);
 +    ret = bdrv_drop_intermediate(chain[1], chain[0], NULL);
 +    g_assert(ret == 0);
 +    g_assert(job_has_completed);
 +
 +    bdrv_unref(chain[2]);
 +}
 +
  int main(int argc, char **argv)
  {
      int ret;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
      g_test_add_func("/bdrv-drain/blockjob/commit_by_drained_end",
                      test_blockjob_commit_by_drained_end);
 +    g_test_add_func("/bdrv-drain/bdrv_drop_intermediate/poll",
 +                    test_drop_intermediate_poll);
 +
      ret = g_test_run();
      qemu_event_destroy(&done_event);
      return ret;
 --
-.20.1
+.25.3

The following changes since commit 9e06029aea3b2eca1d5261352e695edc1e7d7b8b:

Update version for v4.1.0 release (2019-08-15 13:03:37 +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 a6b257a08e3d72219f03e461a52152672fec0612:

file-posix: Handle undetectable alignment (2019-08-16 11:29:11 +0200)

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

- file-posix: Fix O_DIRECT alignment detection
- Fixes for concurrent block jobs
- block-backend: Queue requests while drained (fix IDE vs. job crashes)
- qemu-img convert: Deprecate using -n and -o together
- iotests: Migration tests with filter nodes
- iotests: More media change tests

----------------------------------------------------------------
Kevin Wolf (10):
      iotests/118: Test media change for scsi-cd
      iotests/118: Create test classes dynamically
      iotests/118: Add -blockdev based tests
      iotests: Move migration helpers to iotests.py
      iotests: Test migration with all kinds of filter nodes
      block: Simplify bdrv_filter_default_perms()
      block: Remove blk_pread_unthrottled()
      mirror: Keep mirror_top_bs drained after dropping permissions
      block-backend: Queue requests while drained
      qemu-img convert: Deprecate using -n and -o together

Max Reitz (5):
      block: Keep subtree drained in drop_intermediate
      block: Reduce (un)drains when replacing a child
      tests: Test polling in bdrv_drop_intermediate()
      tests: Test mid-drain bdrv_replace_child_noperm()
      iotests: Add test for concurrent stream/commit

Nir Soffer (1):
      file-posix: Handle undetectable alignment

The test covered only floppy and ide-cd. Add scsi-cd as well.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/118     | 20 ++++++++++++++++++++
 tests/qemu-iotests/118.out |  4 ++--
 2 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/118 b/tests/qemu-iotests/118
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/118
+++ b/tests/qemu-iotests/118
@@ -XXX,XX +XXX,XX @@ def interface_to_device_name(interface):
         return 'ide-cd'
     elif interface == 'floppy':
         return 'floppy'
+    elif interface == 'scsi':
+        return 'scsi-cd'
     else:
         return None
 
@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):
         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
         self.vm = iotests.VM()
         self.vm.add_drive(old_img, 'media=%s' % media, 'none')
+        if interface == 'scsi':
+            self.vm.add_device('virtio-scsi-pci')
         self.vm.add_device('%s,drive=drive0,id=%s' %
                            (interface_to_device_name(interface),
                             self.device_name))
@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
     def setUp(self, media, interface):
         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
         self.vm = iotests.VM().add_drive(None, 'media=%s' % media, 'none')
+        if interface == 'scsi':
+            self.vm.add_device('virtio-scsi-pci')
         self.vm.add_device('%s,drive=drive0,id=%s' %
                            (interface_to_device_name(interface),
                             self.device_name))
@@ -XXX,XX +XXX,XX @@ class TestCDInitiallyEmpty(TestInitiallyEmpty):
     def setUp(self):
         self.TestInitiallyEmpty.setUp(self, 'cdrom', 'ide')
 
+class TestSCSICDInitiallyFilled(TestInitiallyFilled):
+    TestInitiallyFilled = TestInitiallyFilled
+    has_real_tray = True
+
+    def setUp(self):
+        self.TestInitiallyFilled.setUp(self, 'cdrom', 'scsi')
+
+class TestSCSICDInitiallyEmpty(TestInitiallyEmpty):
+    TestInitiallyEmpty = TestInitiallyEmpty
+    has_real_tray = True
+
+    def setUp(self):
+        self.TestInitiallyEmpty.setUp(self, 'cdrom', 'scsi')
+
 class TestFloppyInitiallyFilled(TestInitiallyFilled):
     TestInitiallyFilled = TestInitiallyFilled
     has_real_tray = False
diff --git a/tests/qemu-iotests/118.out b/tests/qemu-iotests/118.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/118.out
+++ b/tests/qemu-iotests/118.out
@@ -XXX,XX +XXX,XX @@
-...............................................................
+.........................................................................................
 ----------------------------------------------------------------------
-Ran 63 tests
+Ran 89 tests
 
 OK
-- 
2.20.1

We're getting a ridiculous number of child classes of
TestInitiallyFilled and TestInitiallyEmpty that differ only in a few
attributes that we want to test in all combinations.

Instead of explicitly writing down every combination, let's use a loop
and create those classes dynamically.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/118 | 69 +++++++++++++-----------------------------
 1 file changed, 21 insertions(+), 48 deletions(-)

diff --git a/tests/qemu-iotests/118 b/tests/qemu-iotests/118
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/118
+++ b/tests/qemu-iotests/118
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
 class TestInitiallyFilled(GeneralChangeTestsBaseClass):
     was_empty = False
 
-    def setUp(self, media, interface):
+    def setUp(self):
         qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k')
         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
         self.vm = iotests.VM()
-        self.vm.add_drive(old_img, 'media=%s' % media, 'none')
-        if interface == 'scsi':
+        self.vm.add_drive(old_img, 'media=%s' % self.media, 'none')
+        if self.interface == 'scsi':
             self.vm.add_device('virtio-scsi-pci')
         self.vm.add_device('%s,drive=drive0,id=%s' %
-                           (interface_to_device_name(interface),
+                           (interface_to_device_name(self.interface),
                             self.device_name))
         self.vm.launch()
 
@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):
 class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
     was_empty = True
 
-    def setUp(self, media, interface):
+    def setUp(self):
         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
-        self.vm = iotests.VM().add_drive(None, 'media=%s' % media, 'none')
-        if interface == 'scsi':
+        self.vm = iotests.VM().add_drive(None, 'media=%s' % self.media, 'none')
+        if self.interface == 'scsi':
             self.vm.add_device('virtio-scsi-pci')
         self.vm.add_device('%s,drive=drive0,id=%s' %
-                           (interface_to_device_name(interface),
+                           (interface_to_device_name(self.interface),
                             self.device_name))
         self.vm.launch()
 
@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
         # Should be a no-op
         self.assert_qmp(result, 'return', {})
 
-class TestCDInitiallyFilled(TestInitiallyFilled):
-    TestInitiallyFilled = TestInitiallyFilled
-    has_real_tray = True
-
-    def setUp(self):
-        self.TestInitiallyFilled.setUp(self, 'cdrom', 'ide')
-
-class TestCDInitiallyEmpty(TestInitiallyEmpty):
-    TestInitiallyEmpty = TestInitiallyEmpty
-    has_real_tray = True
-
-    def setUp(self):
-        self.TestInitiallyEmpty.setUp(self, 'cdrom', 'ide')
+# Do this in a function to avoid leaking variables like case into the global
+# name space (otherwise tests would be run for the abstract base classes)
+def create_basic_test_classes():
+    for (media, interface, has_real_tray) in [ ('cdrom', 'ide', True),
+                                               ('cdrom', 'scsi', True),
+                                               ('disk', 'floppy', False) ]:
 
-class TestSCSICDInitiallyFilled(TestInitiallyFilled):
-    TestInitiallyFilled = TestInitiallyFilled
-    has_real_tray = True
+        for case in [ TestInitiallyFilled, TestInitiallyEmpty ]:
 
-    def setUp(self):
-        self.TestInitiallyFilled.setUp(self, 'cdrom', 'scsi')
+            attr = { 'media': media,
+                     'interface': interface,
+                     'has_real_tray': has_real_tray }
 
-class TestSCSICDInitiallyEmpty(TestInitiallyEmpty):
-    TestInitiallyEmpty = TestInitiallyEmpty
-    has_real_tray = True
+            name = '%s_%s_%s' % (case.__name__, media, interface)
+            globals()[name] = type(name, (case, ), attr)
 
-    def setUp(self):
-        self.TestInitiallyEmpty.setUp(self, 'cdrom', 'scsi')
-
-class TestFloppyInitiallyFilled(TestInitiallyFilled):
-    TestInitiallyFilled = TestInitiallyFilled
-    has_real_tray = False
-
-    def setUp(self):
-        self.TestInitiallyFilled.setUp(self, 'disk', 'floppy')
-
-class TestFloppyInitiallyEmpty(TestInitiallyEmpty):
-    TestInitiallyEmpty = TestInitiallyEmpty
-    has_real_tray = False
-
-    def setUp(self):
-        self.TestInitiallyEmpty.setUp(self, 'disk', 'floppy')
-        # FDDs not having a real tray and there not being a medium inside the
-        # tray at startup means the tray will be considered open
-        self.has_opened = True
+create_basic_test_classes()
 
 class TestChangeReadOnly(ChangeBaseClass):
     device_name = 'qdev0'
-- 
2.20.1

The code path for -device drive=<node-name> or without a drive=...
option for empty drives, which is supposed to be used with -blockdev
differs enough from the -drive based path with a user-owned
BlockBackend, so we want to test both paths at least for the basic tests
implemented by TestInitiallyFilled and TestInitiallyEmpty.

This would have caught the bug recently fixed for inserting read-only
nodes into a scsi-cd created without a drive=... option.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/118     | 43 ++++++++++++++++++++++++++------------
 tests/qemu-iotests/118.out |  4 ++--
 2 files changed, 32 insertions(+), 15 deletions(-)

diff --git a/tests/qemu-iotests/118 b/tests/qemu-iotests/118
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/118
+++ b/tests/qemu-iotests/118
@@ -XXX,XX +XXX,XX @@ class ChangeBaseClass(iotests.QMPTestCase):
     has_opened = False
     has_closed = False
 
+    device_name = 'qdev0'
+    use_drive = False
+
     def process_events(self):
         for event in self.vm.get_qmp_events(wait=False):
             if (event['event'] == 'DEVICE_TRAY_MOVED' and
-                event['data']['device'] == 'drive0'):
+                (event['data']['device'] == 'drive0' or
+                 event['data']['id'] == self.device_name)):
                 if event['data']['tray-open'] == False:
                     self.has_closed = True
                 else:
@@ -XXX,XX +XXX,XX @@ class ChangeBaseClass(iotests.QMPTestCase):
 
 class GeneralChangeTestsBaseClass(ChangeBaseClass):
 
-    device_name = 'qdev0'
-
     def test_change(self):
+        # 'change' requires a drive name, so skip the test for blockdev
+        if not self.use_drive:
+            return
+
         result = self.vm.qmp('change', device='drive0', target=new_img,
                                        arg=iotests.imgfmt)
         self.assert_qmp(result, 'return', {})
@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):
         qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k')
         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
         self.vm = iotests.VM()
-        self.vm.add_drive(old_img, 'media=%s' % self.media, 'none')
+        if self.use_drive:
+            self.vm.add_drive(old_img, 'media=%s' % self.media, 'none')
+        else:
+            self.vm.add_blockdev([ 'node-name=drive0',
+                                   'driver=%s' % iotests.imgfmt,
+                                   'file.driver=file',
+                                   'file.filename=%s' % old_img ])
         if self.interface == 'scsi':
             self.vm.add_device('virtio-scsi-pci')
         self.vm.add_device('%s,drive=drive0,id=%s' %
@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
 
     def setUp(self):
         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
-        self.vm = iotests.VM().add_drive(None, 'media=%s' % self.media, 'none')
+        self.vm = iotests.VM()
+        if self.use_drive:
+            self.vm.add_drive(None, 'media=%s' % self.media, 'none')
         if self.interface == 'scsi':
             self.vm.add_device('virtio-scsi-pci')
-        self.vm.add_device('%s,drive=drive0,id=%s' %
+        self.vm.add_device('%s,%sid=%s' %
                            (interface_to_device_name(self.interface),
+                            'drive=drive0,' if self.use_drive else '',
                             self.device_name))
         self.vm.launch()
 
@@ -XXX,XX +XXX,XX @@ def create_basic_test_classes():
                                                ('disk', 'floppy', False) ]:
 
         for case in [ TestInitiallyFilled, TestInitiallyEmpty ]:
-
-            attr = { 'media': media,
-                     'interface': interface,
-                     'has_real_tray': has_real_tray }
-
-            name = '%s_%s_%s' % (case.__name__, media, interface)
-            globals()[name] = type(name, (case, ), attr)
+            for use_drive in [ True, False ]:
+                attr = { 'media': media,
+                         'interface': interface,
+                         'has_real_tray': has_real_tray,
+                         'use_drive': use_drive }
+
+                name = '%s_%s_%s_%s' % (case.__name__, media, interface,
+                                        'drive' if use_drive else 'blockdev')
+                globals()[name] = type(name, (case, ), attr)
 
 create_basic_test_classes()
 
diff --git a/tests/qemu-iotests/118.out b/tests/qemu-iotests/118.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/118.out
+++ b/tests/qemu-iotests/118.out
@@ -XXX,XX +XXX,XX @@
-.........................................................................................
+.......................................................................................................................................................................
 ----------------------------------------------------------------------
-Ran 89 tests
+Ran 167 tests
 
 OK
-- 
2.20.1

234 implements functions that are useful for doing migration between two
VMs. Move them to iotests.py so that other test cases can use them, too.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/234        | 30 +++++++-----------------------
 tests/qemu-iotests/iotests.py | 16 ++++++++++++++++
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/tests/qemu-iotests/234 b/tests/qemu-iotests/234
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/234
+++ b/tests/qemu-iotests/234
@@ -XXX,XX +XXX,XX @@ import os
 iotests.verify_image_format(supported_fmts=['qcow2'])
 iotests.verify_platform(['linux'])
 
-def enable_migration_events(vm, name):
-    iotests.log('Enabling migration QMP events on %s...' % name)
-    iotests.log(vm.qmp('migrate-set-capabilities', capabilities=[
-        {
-            'capability': 'events',
-            'state': True
-        }
-    ]))
-
-def wait_migration(vm):
-    while True:
-        event = vm.event_wait('MIGRATION')
-        iotests.log(event, filters=[iotests.filter_qmp_event])
-        if event['data']['status'] == 'completed':
-            break
-
 with iotests.FilePath('img') as img_path, \
      iotests.FilePath('backing') as backing_path, \
      iotests.FilePath('mig_fifo_a') as fifo_a, \
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('img') as img_path, \
          .add_blockdev('%s,file=drive0-backing-file,node-name=drive0-backing' % (iotests.imgfmt))
          .launch())
 
-    enable_migration_events(vm_a, 'A')
+    vm_a.enable_migration_events('A')
 
     iotests.log('Launching destination VM...')
     (vm_b.add_blockdev('file,filename=%s,node-name=drive0-file' % (img_path))
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('img') as img_path, \
          .add_incoming("exec: cat '%s'" % (fifo_a))
          .launch())
 
-    enable_migration_events(vm_b, 'B')
+    vm_b.enable_migration_events('B')
 
     # Add a child node that was created after the parent node. The reverse case
     # is covered by the -blockdev options above.
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('img') as img_path, \
     iotests.log(vm_a.qmp('migrate', uri='exec:cat >%s' % (fifo_a)))
     with iotests.Timeout(3, 'Migration does not complete'):
         # Wait for the source first (which includes setup=setup)
-        wait_migration(vm_a)
+        vm_a.wait_migration()
         # Wait for the destination second (which does not)
-        wait_migration(vm_b)
+        vm_b.wait_migration()
 
     iotests.log(vm_a.qmp('query-migrate')['return']['status'])
     iotests.log(vm_b.qmp('query-migrate')['return']['status'])
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('img') as img_path, \
          .add_incoming("exec: cat '%s'" % (fifo_b))
          .launch())
 
-    enable_migration_events(vm_a, 'A')
+    vm_a.enable_migration_events('A')
 
     iotests.log(vm_a.qmp('blockdev-snapshot', node='drive0-backing',
                          overlay='drive0'))
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('img') as img_path, \
     iotests.log(vm_b.qmp('migrate', uri='exec:cat >%s' % (fifo_b)))
     with iotests.Timeout(3, 'Migration does not complete'):
         # Wait for the source first (which includes setup=setup)
-        wait_migration(vm_b)
+        vm_b.wait_migration()
         # Wait for the destination second (which does not)
-        wait_migration(vm_a)
+        vm_a.wait_migration()
 
     iotests.log(vm_a.qmp('query-migrate')['return']['status'])
     iotests.log(vm_b.qmp('query-migrate')['return']['status'])
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
 
+    def enable_migration_events(self, name):
+        log('Enabling migration QMP events on %s...' % name)
+        log(self.qmp('migrate-set-capabilities', capabilities=[
+            {
+                'capability': 'events',
+                'state': True
+            }
+        ]))
+
+    def wait_migration(self):
+        while True:
+            event = self.event_wait('MIGRATION')
+            log(event, filters=[filter_qmp_event])
+            if event['data']['status'] == 'completed':
+                break
+
     def node_info(self, node_name):
         nodes = self.qmp('query-named-block-nodes')
         for x in nodes['return']:
-- 
2.20.1

This test case is motivated by commit 2b23f28639 ('block/copy-on-read:
Fix permissions for inactive node'). Instead of just testing
copy-on-read on migration, let's stack all sorts of filter nodes on top
of each other and try if the resulting VM can still migrate
successfully. For good measure, put everything into an iothread, because
why not?

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/262     | 82 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/262.out | 17 ++++++++
 tests/qemu-iotests/group   |  1 +
 3 files changed, 100 insertions(+)
 create mode 100755 tests/qemu-iotests/262
 create mode 100644 tests/qemu-iotests/262.out

diff --git a/tests/qemu-iotests/262 b/tests/qemu-iotests/262
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/262
@@ -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 with filter drivers present. Keep everything in an
+# iothread just for fun.
+
+import iotests
+import os
+
+iotests.verify_image_format(supported_fmts=['qcow2'])
+iotests.verify_platform(['linux'])
+
+with iotests.FilePath('img') as img_path, \
+     iotests.FilePath('mig_fifo') as fifo, \
+     iotests.VM(path_suffix='a') as vm_a, \
+     iotests.VM(path_suffix='b') as vm_b:
+
+    def add_opts(vm):
+        vm.add_object('iothread,id=iothread0')
+        vm.add_object('throttle-group,id=tg0,x-bps-total=65536')
+        vm.add_blockdev('file,filename=%s,node-name=drive0-file' % (img_path))
+        vm.add_blockdev('%s,file=drive0-file,node-name=drive0-fmt' % (iotests.imgfmt))
+        vm.add_blockdev('copy-on-read,file=drive0-fmt,node-name=drive0-cor')
+        vm.add_blockdev('throttle,file=drive0-cor,node-name=drive0-throttle,throttle-group=tg0')
+        vm.add_blockdev('blkdebug,image=drive0-throttle,node-name=drive0-dbg')
+        vm.add_blockdev('null-co,node-name=null,read-zeroes=on')
+        vm.add_blockdev('blkverify,test=drive0-dbg,raw=null,node-name=drive0-verify')
+
+        if iotests.supports_quorum():
+            vm.add_blockdev('quorum,children.0=drive0-verify,vote-threshold=1,node-name=drive0-quorum')
+            root = "drive0-quorum"
+        else:
+            root = "drive0-verify"
+
+        vm.add_device('virtio-blk,drive=%s,iothread=iothread0' % root)
+
+    iotests.qemu_img_pipe('create', '-f', iotests.imgfmt, img_path, '64M')
+
+    os.mkfifo(fifo)
+
+    iotests.log('Launching source VM...')
+    add_opts(vm_a)
+    vm_a.launch()
+
+    vm_a.enable_migration_events('A')
+
+    iotests.log('Launching destination VM...')
+    add_opts(vm_b)
+    vm_b.add_incoming("exec: cat '%s'" % (fifo))
+    vm_b.launch()
+
+    vm_b.enable_migration_events('B')
+
+    iotests.log('Starting migration to B...')
+    iotests.log(vm_a.qmp('migrate', uri='exec:cat >%s' % (fifo)))
+    with iotests.Timeout(3, 'Migration does not complete'):
+        # Wait for the source first (which includes setup=setup)
+        vm_a.wait_migration()
+        # Wait for the destination second (which does not)
+        vm_b.wait_migration()
+
+    iotests.log(vm_a.qmp('query-migrate')['return']['status'])
+    iotests.log(vm_b.qmp('query-migrate')['return']['status'])
+
+    iotests.log(vm_a.qmp('query-status'))
+    iotests.log(vm_b.qmp('query-status'))
diff --git a/tests/qemu-iotests/262.out b/tests/qemu-iotests/262.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/262.out
@@ -XXX,XX +XXX,XX @@
+Launching source VM...
+Enabling migration QMP events on A...
+{"return": {}}
+Launching destination VM...
+Enabling migration QMP events on B...
+{"return": {}}
+Starting migration to B...
+{"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"}}
+{"data": {"status": "active"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"status": "completed"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+completed
+completed
+{"return": {"running": false, "singlestep": false, "status": "postmigrate"}}
+{"return": {"running": true, "singlestep": false, "status": "running"}}
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 @@
 254 rw backing quick
 255 rw quick
 256 rw quick
+262 rw quick migration
-- 
2.20.1

The same change as commit 2b23f28639 ('block/copy-on-read: Fix
permissions for inactive node') made for the copy-on-read driver can be
made for bdrv_filter_default_perms(): Retaining the old permissions from
the BdrvChild if it is given complicates things unnecessarily when in
the end this only means that the options set in the c == NULL case (i.e.
during child creation) are retained.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 block.c | 12 ++----------
 1 file changed, 2 insertions(+), 10 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void bdrv_filter_default_perms(BlockDriverState *bs, BdrvChild *c,
                                uint64_t perm, uint64_t shared,
                                uint64_t *nperm, uint64_t *nshared)
 {
-    if (c == NULL) {
-        *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
-        *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
-        return;
-    }
-
-    *nperm = (perm & DEFAULT_PERM_PASSTHROUGH) |
-             (c->perm & DEFAULT_PERM_UNCHANGED);
-    *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) |
-               (c->shared_perm & DEFAULT_PERM_UNCHANGED);
+    *nperm = perm & DEFAULT_PERM_PASSTHROUGH;
+    *nshared = (shared & DEFAULT_PERM_PASSTHROUGH) | DEFAULT_PERM_UNCHANGED;
 }
 
 void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
-- 
2.20.1

From: Max Reitz <mreitz@redhat.com>

bdrv_drop_intermediate() calls BdrvChildRole.update_filename().  That
may poll, thus changing the graph, which potentially breaks the
QLIST_FOREACH_SAFE() loop.

Just keep the whole subtree drained.  This is probably the right thing
to do anyway (dropping nodes while the subtree is not drained seems
wrong).

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
     int ret = -EIO;
 
     bdrv_ref(top);
+    bdrv_subtree_drained_begin(top);
 
     if (!top->drv || !base->drv) {
         goto exit;
@@ -XXX,XX +XXX,XX @@ int bdrv_drop_intermediate(BlockDriverState *top, BlockDriverState *base,
 
     ret = 0;
 exit:
+    bdrv_subtree_drained_end(top);
     bdrv_unref(top);
     return ret;
 }
-- 
2.20.1

From: Max Reitz <mreitz@redhat.com>

Currently, bdrv_replace_child_noperm() undrains the parent until it is
completely undrained, then re-drains it after attaching the new child
node.

This is a problem with bdrv_drop_intermediate(): We want to keep the
whole subtree drained, including parents, while the operation is
under way.  bdrv_replace_child_noperm() breaks this by allowing every
parent to become unquiesced briefly, and then redraining it.

In fact, there is no reason why the parent should become unquiesced and
be allowed to submit requests to the new child node if that new node is
supposed to be kept drained.  So if anything, we have to drain the
parent before detaching the old child node.  Conversely, we have to
undrain it only after attaching the new child node.

Thus, change the whole drain algorithm here: Calculate the number of
times we have to drain/undrain the parent before replacing the child
node then drain it (if necessary), replace the child node, and then
undrain it.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 49 +++++++++++++++++++++++++++++++++----------------
 1 file changed, 33 insertions(+), 16 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 bdrv_replace_child_noperm(BdrvChild *child,
                                       BlockDriverState *new_bs)
 {
     BlockDriverState *old_bs = child->bs;
-    int i;
+    int new_bs_quiesce_counter;
+    int drain_saldo;
 
     assert(!child->frozen);
 
     if (old_bs && new_bs) {
         assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
     }
+
+    new_bs_quiesce_counter = (new_bs ? new_bs->quiesce_counter : 0);
+    drain_saldo = new_bs_quiesce_counter - child->parent_quiesce_counter;
+
+    /*
+     * If the new child node is drained but the old one was not, flush
+     * all outstanding requests to the old child node.
+     */
+    while (drain_saldo > 0 && child->role->drained_begin) {
+        bdrv_parent_drained_begin_single(child, true);
+        drain_saldo--;
+    }
+
     if (old_bs) {
         /* Detach first so that the recursive drain sections coming from @child
          * are already gone and we only end the drain sections that came from
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
         if (child->role->detach) {
             child->role->detach(child);
         }
-        while (child->parent_quiesce_counter) {
-            bdrv_parent_drained_end_single(child);
-        }
         QLIST_REMOVE(child, next_parent);
-    } else {
-        assert(child->parent_quiesce_counter == 0);
     }
 
     child->bs = new_bs;
 
     if (new_bs) {
         QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
-        if (new_bs->quiesce_counter) {
-            int num = new_bs->quiesce_counter;
-            if (child->role->parent_is_bds) {
-                num -= bdrv_drain_all_count;
-            }
-            assert(num >= 0);
-            for (i = 0; i < num; i++) {
-                bdrv_parent_drained_begin_single(child, true);
-            }
-        }
+
+        /*
+         * Detaching the old node may have led to the new node's
+         * quiesce_counter having been decreased.  Not a problem, we
+         * just need to recognize this here and then invoke
+         * drained_end appropriately more often.
+         */
+        assert(new_bs->quiesce_counter <= new_bs_quiesce_counter);
+        drain_saldo += new_bs->quiesce_counter - new_bs_quiesce_counter;
 
         /* Attach only after starting new drained sections, so that recursive
          * drain sections coming from @child don't get an extra .drained_begin
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
             child->role->attach(child);
         }
     }
+
+    /*
+     * If the old child node was drained but the new one is not, allow
+     * requests to come in only after the new node has been attached.
+     */
+    while (drain_saldo < 0 && child->role->drained_end) {
+        bdrv_parent_drained_end_single(child);
+        drain_saldo++;
+    }
 }
 
 /*
-- 
2.20.1

From: Max Reitz <mreitz@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/test-bdrv-drain.c | 167 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_test_child_perm(BlockDriverState *bs, BdrvChild *c,
                               nperm, nshared);
 }
 
+static int bdrv_test_change_backing_file(BlockDriverState *bs,
+                                         const char *backing_file,
+                                         const char *backing_fmt)
+{
+    return 0;
+}
+
 static BlockDriver bdrv_test = {
     .format_name            = "test",
     .instance_size          = sizeof(BDRVTestState),
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_test = {
     .bdrv_co_drain_end      = bdrv_test_co_drain_end,
 
     .bdrv_child_perm        = bdrv_test_child_perm,
+
+    .bdrv_change_backing_file = bdrv_test_change_backing_file,
 };
 
 static void aio_ret_cb(void *opaque, int ret)
@@ -XXX,XX +XXX,XX @@ static void test_blockjob_commit_by_drained_end(void)
     bdrv_unref(bs_child);
 }
 
+
+typedef struct TestSimpleBlockJob {
+    BlockJob common;
+    bool should_complete;
+    bool *did_complete;
+} TestSimpleBlockJob;
+
+static int coroutine_fn test_simple_job_run(Job *job, Error **errp)
+{
+    TestSimpleBlockJob *s = container_of(job, TestSimpleBlockJob, common.job);
+
+    while (!s->should_complete) {
+        job_sleep_ns(job, 0);
+    }
+
+    return 0;
+}
+
+static void test_simple_job_clean(Job *job)
+{
+    TestSimpleBlockJob *s = container_of(job, TestSimpleBlockJob, common.job);
+    *s->did_complete = true;
+}
+
+static const BlockJobDriver test_simple_job_driver = {
+    .job_driver = {
+        .instance_size  = sizeof(TestSimpleBlockJob),
+        .free           = block_job_free,
+        .user_resume    = block_job_user_resume,
+        .drain          = block_job_drain,
+        .run            = test_simple_job_run,
+        .clean          = test_simple_job_clean,
+    },
+};
+
+static int drop_intermediate_poll_update_filename(BdrvChild *child,
+                                                  BlockDriverState *new_base,
+                                                  const char *filename,
+                                                  Error **errp)
+{
+    /*
+     * We are free to poll here, which may change the block graph, if
+     * it is not drained.
+     */
+
+    /* If the job is not drained: Complete it, schedule job_exit() */
+    aio_poll(qemu_get_current_aio_context(), false);
+    /* If the job is not drained: Run job_exit(), finish the job */
+    aio_poll(qemu_get_current_aio_context(), false);
+
+    return 0;
+}
+
+/**
+ * Test a poll in the midst of bdrv_drop_intermediate().
+ *
+ * bdrv_drop_intermediate() calls BdrvChildRole.update_filename(),
+ * which can yield or poll.  This may lead to graph changes, unless
+ * the whole subtree in question is drained.
+ *
+ * We test this on the following graph:
+ *
+ *                    Job
+ *
+ *                     |
+ *                  job-node
+ *                     |
+ *                     v
+ *
+ *                  job-node
+ *
+ *                     |
+ *                  backing
+ *                     |
+ *                     v
+ *
+ * node-2 --chain--> node-1 --chain--> node-0
+ *
+ * We drop node-1 with bdrv_drop_intermediate(top=node-1, base=node-0).
+ *
+ * This first updates node-2's backing filename by invoking
+ * drop_intermediate_poll_update_filename(), which polls twice.  This
+ * causes the job to finish, which in turns causes the job-node to be
+ * deleted.
+ *
+ * bdrv_drop_intermediate() uses a QLIST_FOREACH_SAFE() loop, so it
+ * already has a pointer to the BdrvChild edge between job-node and
+ * node-1.  When it tries to handle that edge, we probably get a
+ * segmentation fault because the object no longer exists.
+ *
+ *
+ * The solution is for bdrv_drop_intermediate() to drain top's
+ * subtree.  This prevents graph changes from happening just because
+ * BdrvChildRole.update_filename() yields or polls.  Thus, the block
+ * job is paused during that drained section and must finish before or
+ * after.
+ *
+ * (In addition, bdrv_replace_child() must keep the job paused.)
+ */
+static void test_drop_intermediate_poll(void)
+{
+    static BdrvChildRole chain_child_role;
+    BlockDriverState *chain[3];
+    TestSimpleBlockJob *job;
+    BlockDriverState *job_node;
+    bool job_has_completed = false;
+    int i;
+    int ret;
+
+    chain_child_role = child_backing;
+    chain_child_role.update_filename = drop_intermediate_poll_update_filename;
+
+    for (i = 0; i < 3; i++) {
+        char name[32];
+        snprintf(name, 32, "node-%i", i);
+
+        chain[i] = bdrv_new_open_driver(&bdrv_test, name, 0, &error_abort);
+    }
+
+    job_node = bdrv_new_open_driver(&bdrv_test, "job-node", BDRV_O_RDWR,
+                                    &error_abort);
+    bdrv_set_backing_hd(job_node, chain[1], &error_abort);
+
+    /*
+     * Establish the chain last, so the chain links are the first
+     * elements in the BDS.parents lists
+     */
+    for (i = 0; i < 3; i++) {
+        if (i) {
+            /* Takes the reference to chain[i - 1] */
+            chain[i]->backing = bdrv_attach_child(chain[i], chain[i - 1],
+                                                  "chain", &chain_child_role,
+                                                  &error_abort);
+        }
+    }
+
+    job = block_job_create("job", &test_simple_job_driver, NULL, job_node,
+                           0, BLK_PERM_ALL, 0, 0, NULL, NULL, &error_abort);
+
+    /* The job has a reference now */
+    bdrv_unref(job_node);
+
+    job->did_complete = &job_has_completed;
+
+    job_start(&job->common.job);
+    job->should_complete = true;
+
+    g_assert(!job_has_completed);
+    ret = bdrv_drop_intermediate(chain[1], chain[0], NULL);
+    g_assert(ret == 0);
+    g_assert(job_has_completed);
+
+    bdrv_unref(chain[2]);
+}
+
 int main(int argc, char **argv)
 {
     int ret;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/bdrv-drain/blockjob/commit_by_drained_end",
                     test_blockjob_commit_by_drained_end);
 
+    g_test_add_func("/bdrv-drain/bdrv_drop_intermediate/poll",
+                    test_drop_intermediate_poll);
+
     ret = g_test_run();
     qemu_event_destroy(&done_event);
     return ret;
-- 
2.20.1

From: Max Reitz <mreitz@redhat.com>

Add a test for what happens when you call bdrv_replace_child_noperm()
for various drain situations ({old,new} child {drained,not drained}).

Most importantly, if both the old and the new child are drained, the
parent must not be undrained at any point.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/test-bdrv-drain.c | 308 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 308 insertions(+)

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void test_drop_intermediate_poll(void)
     bdrv_unref(chain[2]);
 }
 
+
+typedef struct BDRVReplaceTestState {
+    bool was_drained;
+    bool was_undrained;
+    bool has_read;
+
+    int drain_count;
+
+    bool yield_before_read;
+    Coroutine *io_co;
+    Coroutine *drain_co;
+} BDRVReplaceTestState;
+
+static void bdrv_replace_test_close(BlockDriverState *bs)
+{
+}
+
+/**
+ * If @bs has a backing file:
+ *   Yield if .yield_before_read is true (and wait for drain_begin to
+ *   wake us up).
+ *   Forward the read to bs->backing.  Set .has_read to true.
+ *   If drain_begin has woken us, wake it in turn.
+ *
+ * Otherwise:
+ *   Set .has_read to true and return success.
+ */
+static int coroutine_fn bdrv_replace_test_co_preadv(BlockDriverState *bs,
+                                                    uint64_t offset,
+                                                    uint64_t bytes,
+                                                    QEMUIOVector *qiov,
+                                                    int flags)
+{
+    BDRVReplaceTestState *s = bs->opaque;
+
+    if (bs->backing) {
+        int ret;
+
+        g_assert(!s->drain_count);
+
+        s->io_co = qemu_coroutine_self();
+        if (s->yield_before_read) {
+            s->yield_before_read = false;
+            qemu_coroutine_yield();
+        }
+        s->io_co = NULL;
+
+        ret = bdrv_preadv(bs->backing, offset, qiov);
+        s->has_read = true;
+
+        /* Wake up drain_co if it runs */
+        if (s->drain_co) {
+            aio_co_wake(s->drain_co);
+        }
+
+        return ret;
+    }
+
+    s->has_read = true;
+    return 0;
+}
+
+/**
+ * If .drain_count is 0, wake up .io_co if there is one; and set
+ * .was_drained.
+ * Increment .drain_count.
+ */
+static void coroutine_fn bdrv_replace_test_co_drain_begin(BlockDriverState *bs)
+{
+    BDRVReplaceTestState *s = bs->opaque;
+
+    if (!s->drain_count) {
+        /* Keep waking io_co up until it is done */
+        s->drain_co = qemu_coroutine_self();
+        while (s->io_co) {
+            aio_co_wake(s->io_co);
+            s->io_co = NULL;
+            qemu_coroutine_yield();
+        }
+        s->drain_co = NULL;
+
+        s->was_drained = true;
+    }
+    s->drain_count++;
+}
+
+/**
+ * Reduce .drain_count, set .was_undrained once it reaches 0.
+ * If .drain_count reaches 0 and the node has a backing file, issue a
+ * read request.
+ */
+static void coroutine_fn bdrv_replace_test_co_drain_end(BlockDriverState *bs)
+{
+    BDRVReplaceTestState *s = bs->opaque;
+
+    g_assert(s->drain_count > 0);
+    if (!--s->drain_count) {
+        int ret;
+
+        s->was_undrained = true;
+
+        if (bs->backing) {
+            char data;
+            QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, &data, 1);
+
+            /* Queue a read request post-drain */
+            ret = bdrv_replace_test_co_preadv(bs, 0, 1, &qiov, 0);
+            g_assert(ret >= 0);
+        }
+    }
+}
+
+static BlockDriver bdrv_replace_test = {
+    .format_name            = "replace_test",
+    .instance_size          = sizeof(BDRVReplaceTestState),
+
+    .bdrv_close             = bdrv_replace_test_close,
+    .bdrv_co_preadv         = bdrv_replace_test_co_preadv,
+
+    .bdrv_co_drain_begin    = bdrv_replace_test_co_drain_begin,
+    .bdrv_co_drain_end      = bdrv_replace_test_co_drain_end,
+
+    .bdrv_child_perm        = bdrv_format_default_perms,
+};
+
+static void coroutine_fn test_replace_child_mid_drain_read_co(void *opaque)
+{
+    int ret;
+    char data;
+
+    ret = blk_co_pread(opaque, 0, 1, &data, 0);
+    g_assert(ret >= 0);
+}
+
+/**
+ * We test two things:
+ * (1) bdrv_replace_child_noperm() must not undrain the parent if both
+ *     children are drained.
+ * (2) bdrv_replace_child_noperm() must never flush I/O requests to a
+ *     drained child.  If the old child is drained, it must flush I/O
+ *     requests after the new one has been attached.  If the new child
+ *     is drained, it must flush I/O requests before the old one is
+ *     detached.
+ *
+ * To do so, we create one parent node and two child nodes; then
+ * attach one of the children (old_child_bs) to the parent, then
+ * drain both old_child_bs and new_child_bs according to
+ * old_drain_count and new_drain_count, respectively, and finally
+ * we invoke bdrv_replace_node() to replace old_child_bs by
+ * new_child_bs.
+ *
+ * The test block driver we use here (bdrv_replace_test) has a read
+ * function that:
+ * - For the parent node, can optionally yield, and then forwards the
+ *   read to bdrv_preadv(),
+ * - For the child node, just returns immediately.
+ *
+ * If the read yields, the drain_begin function will wake it up.
+ *
+ * The drain_end function issues a read on the parent once it is fully
+ * undrained (which simulates requests starting to come in again).
+ */
+static void do_test_replace_child_mid_drain(int old_drain_count,
+                                            int new_drain_count)
+{
+    BlockBackend *parent_blk;
+    BlockDriverState *parent_bs;
+    BlockDriverState *old_child_bs, *new_child_bs;
+    BDRVReplaceTestState *parent_s;
+    BDRVReplaceTestState *old_child_s, *new_child_s;
+    Coroutine *io_co;
+    int i;
+
+    parent_bs = bdrv_new_open_driver(&bdrv_replace_test, "parent", 0,
+                                     &error_abort);
+    parent_s = parent_bs->opaque;
+
+    parent_blk = blk_new(qemu_get_aio_context(),
+                         BLK_PERM_CONSISTENT_READ, BLK_PERM_ALL);
+    blk_insert_bs(parent_blk, parent_bs, &error_abort);
+
+    old_child_bs = bdrv_new_open_driver(&bdrv_replace_test, "old-child", 0,
+                                        &error_abort);
+    new_child_bs = bdrv_new_open_driver(&bdrv_replace_test, "new-child", 0,
+                                        &error_abort);
+    old_child_s = old_child_bs->opaque;
+    new_child_s = new_child_bs->opaque;
+
+    /* So that we can read something */
+    parent_bs->total_sectors = 1;
+    old_child_bs->total_sectors = 1;
+    new_child_bs->total_sectors = 1;
+
+    bdrv_ref(old_child_bs);
+    parent_bs->backing = bdrv_attach_child(parent_bs, old_child_bs, "child",
+                                           &child_backing, &error_abort);
+
+    for (i = 0; i < old_drain_count; i++) {
+        bdrv_drained_begin(old_child_bs);
+    }
+    for (i = 0; i < new_drain_count; i++) {
+        bdrv_drained_begin(new_child_bs);
+    }
+
+    if (!old_drain_count) {
+        /*
+         * Start a read operation that will yield, so it will not
+         * complete before the node is drained.
+         */
+        parent_s->yield_before_read = true;
+        io_co = qemu_coroutine_create(test_replace_child_mid_drain_read_co,
+                                      parent_blk);
+        qemu_coroutine_enter(io_co);
+    }
+
+    /* If we have started a read operation, it should have yielded */
+    g_assert(!parent_s->has_read);
+
+    /* Reset drained status so we can see what bdrv_replace_node() does */
+    parent_s->was_drained = false;
+    parent_s->was_undrained = false;
+
+    g_assert(parent_bs->quiesce_counter == old_drain_count);
+    bdrv_replace_node(old_child_bs, new_child_bs, &error_abort);
+    g_assert(parent_bs->quiesce_counter == new_drain_count);
+
+    if (!old_drain_count && !new_drain_count) {
+        /*
+         * From undrained to undrained drains and undrains the parent,
+         * because bdrv_replace_node() contains a drained section for
+         * @old_child_bs.
+         */
+        g_assert(parent_s->was_drained && parent_s->was_undrained);
+    } else if (!old_drain_count && new_drain_count) {
+        /*
+         * From undrained to drained should drain the parent and keep
+         * it that way.
+         */
+        g_assert(parent_s->was_drained && !parent_s->was_undrained);
+    } else if (old_drain_count && !new_drain_count) {
+        /*
+         * From drained to undrained should undrain the parent and
+         * keep it that way.
+         */
+        g_assert(!parent_s->was_drained && parent_s->was_undrained);
+    } else /* if (old_drain_count && new_drain_count) */ {
+        /*
+         * From drained to drained must not undrain the parent at any
+         * point
+         */
+        g_assert(!parent_s->was_drained && !parent_s->was_undrained);
+    }
+
+    if (!old_drain_count || !new_drain_count) {
+        /*
+         * If !old_drain_count, we have started a read request before
+         * bdrv_replace_node().  If !new_drain_count, the parent must
+         * have been undrained at some point, and
+         * bdrv_replace_test_co_drain_end() starts a read request
+         * then.
+         */
+        g_assert(parent_s->has_read);
+    } else {
+        /*
+         * If the parent was never undrained, there is no way to start
+         * a read request.
+         */
+        g_assert(!parent_s->has_read);
+    }
+
+    /* A drained child must have not received any request */
+    g_assert(!(old_drain_count && old_child_s->has_read));
+    g_assert(!(new_drain_count && new_child_s->has_read));
+
+    for (i = 0; i < new_drain_count; i++) {
+        bdrv_drained_end(new_child_bs);
+    }
+    for (i = 0; i < old_drain_count; i++) {
+        bdrv_drained_end(old_child_bs);
+    }
+
+    /*
+     * By now, bdrv_replace_test_co_drain_end() must have been called
+     * at some point while the new child was attached to the parent.
+     */
+    g_assert(parent_s->has_read);
+    g_assert(new_child_s->has_read);
+
+    blk_unref(parent_blk);
+    bdrv_unref(parent_bs);
+    bdrv_unref(old_child_bs);
+    bdrv_unref(new_child_bs);
+}
+
+static void test_replace_child_mid_drain(void)
+{
+    int old_drain_count, new_drain_count;
+
+    for (old_drain_count = 0; old_drain_count < 2; old_drain_count++) {
+        for (new_drain_count = 0; new_drain_count < 2; new_drain_count++) {
+            do_test_replace_child_mid_drain(old_drain_count, new_drain_count);
+        }
+    }
+}
+
 int main(int argc, char **argv)
 {
     int ret;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/bdrv-drain/bdrv_drop_intermediate/poll",
                     test_drop_intermediate_poll);
 
+    g_test_add_func("/bdrv-drain/replace_child/mid-drain",
+                    test_replace_child_mid_drain);
+
     ret = g_test_run();
     qemu_event_destroy(&done_event);
     return ret;
-- 
2.20.1

From: Max Reitz <mreitz@redhat.com>

We already have 030 for that in general, but this tests very specific
cases of both jobs finishing concurrently.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/258     | 163 +++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/258.out |  33 ++++++++
 tests/qemu-iotests/group   |   1 +
 3 files changed, 197 insertions(+)
 create mode 100755 tests/qemu-iotests/258
 create mode 100644 tests/qemu-iotests/258.out

diff --git a/tests/qemu-iotests/258 b/tests/qemu-iotests/258
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/258
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python
+#
+# Very specific tests for adjacent commit/stream block jobs
+#
+# 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: Max Reitz <mreitz@redhat.com>
+
+import iotests
+from iotests import log, qemu_img, qemu_io_silent, \
+        filter_qmp_testfiles, filter_qmp_imgfmt
+
+# Need backing file and change-backing-file support
+iotests.verify_image_format(supported_fmts=['qcow2', 'qed'])
+iotests.verify_platform(['linux'])
+
+
+# Returns a node for blockdev-add
+def node(node_name, path, backing=None, fmt=None, throttle=None):
+    if fmt is None:
+        fmt = iotests.imgfmt
+
+    res = {
+        'node-name': node_name,
+        'driver': fmt,
+        'file': {
+            'driver': 'file',
+            'filename': path
+        }
+    }
+
+    if backing is not None:
+        res['backing'] = backing
+
+    if throttle:
+        res['file'] = {
+            'driver': 'throttle',
+            'throttle-group': throttle,
+            'file': res['file']
+        }
+
+    return res
+
+# Finds a node in the debug block graph
+def find_graph_node(graph, node_id):
+    return next(node for node in graph['nodes'] if node['id'] == node_id)
+
+
+def test_concurrent_finish(write_to_stream_node):
+    log('')
+    log('=== Commit and stream finish concurrently (letting %s write) ===' % \
+        ('stream' if write_to_stream_node else 'commit'))
+    log('')
+
+    # All chosen in such a way that when the commit job wants to
+    # finish, it polls and thus makes stream finish concurrently --
+    # and the other way around, depending on whether the commit job
+    # is finalized before stream completes or not.
+
+    with iotests.FilePath('node4.img') as node4_path, \
+         iotests.FilePath('node3.img') as node3_path, \
+         iotests.FilePath('node2.img') as node2_path, \
+         iotests.FilePath('node1.img') as node1_path, \
+         iotests.FilePath('node0.img') as node0_path, \
+         iotests.VM() as vm:
+
+        # It is important to use raw for the base layer (so that
+        # permissions are just handed through to the protocol layer)
+        assert qemu_img('create', '-f', 'raw', node0_path, '64M') == 0
+
+        stream_throttle=None
+        commit_throttle=None
+
+        for path in [node1_path, node2_path, node3_path, node4_path]:
+            assert qemu_img('create', '-f', iotests.imgfmt, path, '64M') == 0
+
+        if write_to_stream_node:
+            # This is what (most of the time) makes commit finish
+            # earlier and then pull in stream
+            assert qemu_io_silent(node2_path,
+                                  '-c', 'write %iK 64K' % (65536 - 192),
+                                  '-c', 'write %iK 64K' % (65536 -  64)) == 0
+
+            stream_throttle='tg'
+        else:
+            # And this makes stream finish earlier
+            assert qemu_io_silent(node1_path,
+                                  '-c', 'write %iK 64K' % (65536 - 64)) == 0
+
+            commit_throttle='tg'
+
+        vm.launch()
+
+        vm.qmp_log('object-add',
+                   qom_type='throttle-group',
+                   id='tg',
+                   props={
+                       'x-iops-write': 1,
+                       'x-iops-write-max': 1
+                   })
+
+        vm.qmp_log('blockdev-add',
+                   filters=[filter_qmp_testfiles, filter_qmp_imgfmt],
+                   **node('node4', node4_path, throttle=stream_throttle,
+                     backing=node('node3', node3_path,
+                     backing=node('node2', node2_path,
+                     backing=node('node1', node1_path,
+                     backing=node('node0', node0_path, throttle=commit_throttle,
+                                  fmt='raw'))))))
+
+        vm.qmp_log('block-commit',
+                   job_id='commit',
+                   device='node4',
+                   filter_node_name='commit-filter',
+                   top_node='node1',
+                   base_node='node0',
+                   auto_finalize=False)
+
+        vm.qmp_log('block-stream',
+                   job_id='stream',
+                   device='node3',
+                   base_node='commit-filter')
+
+        if write_to_stream_node:
+            vm.run_job('commit', auto_finalize=False, auto_dismiss=True)
+            vm.run_job('stream', auto_finalize=True, auto_dismiss=True)
+        else:
+            # No, the jobs do not really finish concurrently here,
+            # the stream job does complete strictly before commit.
+            # But still, this is close enough for what we want to
+            # test.
+            vm.run_job('stream', auto_finalize=True, auto_dismiss=True)
+            vm.run_job('commit', auto_finalize=False, auto_dismiss=True)
+
+        # Assert that the backing node of node3 is node 0 now
+        graph = vm.qmp('x-debug-query-block-graph')['return']
+        for edge in graph['edges']:
+            if edge['name'] == 'backing' and \
+               find_graph_node(graph, edge['parent'])['name'] == 'node3':
+                assert find_graph_node(graph, edge['child'])['name'] == 'node0'
+                break
+
+
+def main():
+    log('Running tests:')
+    test_concurrent_finish(True)
+    test_concurrent_finish(False)
+
+if __name__ == '__main__':
+    main()
diff --git a/tests/qemu-iotests/258.out b/tests/qemu-iotests/258.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/258.out
@@ -XXX,XX +XXX,XX @@
+Running tests:
+
+=== Commit and stream finish concurrently (letting stream write) ===
+
+{"execute": "object-add", "arguments": {"id": "tg", "props": {"x-iops-write": 1, "x-iops-write-max": 1}, "qom-type": "throttle-group"}}
+{"return": {}}
+{"execute": "blockdev-add", "arguments": {"backing": {"backing": {"backing": {"backing": {"driver": "raw", "file": {"driver": "file", "filename": "TEST_DIR/PID-node0.img"}, "node-name": "node0"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node1.img"}, "node-name": "node1"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node2.img"}, "node-name": "node2"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node3.img"}, "node-name": "node3"}, "driver": "IMGFMT", "file": {"driver": "throttle", "file": {"driver": "file", "filename": "TEST_DIR/PID-node4.img"}, "throttle-group": "tg"}, "node-name": "node4"}}
+{"return": {}}
+{"execute": "block-commit", "arguments": {"auto-finalize": false, "base-node": "node0", "device": "node4", "filter-node-name": "commit-filter", "job-id": "commit", "top-node": "node1"}}
+{"return": {}}
+{"execute": "block-stream", "arguments": {"base-node": "commit-filter", "device": "node3", "job-id": "stream"}}
+{"return": {}}
+{"execute": "job-finalize", "arguments": {"id": "commit"}}
+{"return": {}}
+{"data": {"id": "commit", "type": "commit"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"device": "commit", "len": 67108864, "offset": 67108864, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"device": "stream", "len": 67108864, "offset": 67108864, "speed": 0, "type": "stream"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+
+=== Commit and stream finish concurrently (letting commit write) ===
+
+{"execute": "object-add", "arguments": {"id": "tg", "props": {"x-iops-write": 1, "x-iops-write-max": 1}, "qom-type": "throttle-group"}}
+{"return": {}}
+{"execute": "blockdev-add", "arguments": {"backing": {"backing": {"backing": {"backing": {"driver": "raw", "file": {"driver": "throttle", "file": {"driver": "file", "filename": "TEST_DIR/PID-node0.img"}, "throttle-group": "tg"}, "node-name": "node0"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node1.img"}, "node-name": "node1"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node2.img"}, "node-name": "node2"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node3.img"}, "node-name": "node3"}, "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/PID-node4.img"}, "node-name": "node4"}}
+{"return": {}}
+{"execute": "block-commit", "arguments": {"auto-finalize": false, "base-node": "node0", "device": "node4", "filter-node-name": "commit-filter", "job-id": "commit", "top-node": "node1"}}
+{"return": {}}
+{"execute": "block-stream", "arguments": {"base-node": "commit-filter", "device": "node3", "job-id": "stream"}}
+{"return": {}}
+{"data": {"device": "stream", "len": 67108864, "offset": 67108864, "speed": 0, "type": "stream"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"execute": "job-finalize", "arguments": {"id": "commit"}}
+{"return": {}}
+{"data": {"id": "commit", "type": "commit"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"device": "commit", "len": 67108864, "offset": 67108864, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
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 @@
 254 rw backing quick
 255 rw quick
 256 rw quick
+258 rw quick
 262 rw quick migration
-- 
2.20.1

The functionality offered by blk_pread_unthrottled() goes back to commit
498e386c584. Then, we couldn't perform I/O throttling with synchronous
requests because timers wouldn't be executed in polling loops. So the
commit automatically disabled I/O throttling as soon as a synchronous
request was issued.

However, for geometry detection during disk initialisation, we always
used (and still use) synchronous requests even if guest requests use AIO
later. Geometry detection was not wanted to disable I/O throttling, so
bdrv_pread_unthrottled() was introduced which disabled throttling only
temporarily.

All of this isn't necessary any more because we do run timers in polling
loop and even synchronous requests are now using coroutine
infrastructure internally. For this reason, commit 90c78624f already
removed the automatic disabling of I/O throttling.

It's time to get rid of the workaround for the removed code, and its
abuse of blk_root_drained_begin()/end(), as well.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 include/sysemu/block-backend.h |  2 --
 block/block-backend.c          | 16 ----------------
 hw/block/hd-geometry.c         |  7 +------
 3 files changed, 1 insertion(+), 24 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 @@ char *blk_get_attached_dev_id(BlockBackend *blk);
 BlockBackend *blk_by_dev(void *dev);
 BlockBackend *blk_by_qdev_id(const char *id, Error **errp);
 void blk_set_dev_ops(BlockBackend *blk, const BlockDevOps *ops, void *opaque);
-int blk_pread_unthrottled(BlockBackend *blk, int64_t offset, uint8_t *buf,
-                          int bytes);
 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
                                unsigned int bytes, QEMUIOVector *qiov,
                                BdrvRequestFlags flags);
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 @@ static int blk_prw(BlockBackend *blk, int64_t offset, uint8_t *buf,
     return rwco.ret;
 }
 
-int blk_pread_unthrottled(BlockBackend *blk, int64_t offset, uint8_t *buf,
-                          int count)
-{
-    int ret;
-
-    ret = blk_check_byte_request(blk, offset, count);
-    if (ret < 0) {
-        return ret;
-    }
-
-    blk_root_drained_begin(blk->root);
-    ret = blk_pread(blk, offset, buf, count);
-    blk_root_drained_end(blk->root, NULL);
-    return ret;
-}
-
 int blk_pwrite_zeroes(BlockBackend *blk, int64_t offset,
                       int bytes, BdrvRequestFlags flags)
 {
diff --git a/hw/block/hd-geometry.c b/hw/block/hd-geometry.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/hd-geometry.c
+++ b/hw/block/hd-geometry.c
@@ -XXX,XX +XXX,XX @@ static int guess_disk_lchs(BlockBackend *blk,
 
     blk_get_geometry(blk, &nb_sectors);
 
-    /**
-     * The function will be invoked during startup not only in sync I/O mode,
-     * but also in async I/O mode. So the I/O throttling function has to
-     * be disabled temporarily here, not permanently.
-     */
-    if (blk_pread_unthrottled(blk, 0, buf, BDRV_SECTOR_SIZE) < 0) {
+    if (blk_pread(blk, 0, buf, BDRV_SECTOR_SIZE) < 0) {
         return -1;
     }
     /* test msdos magic */
-- 
2.20.1

mirror_top_bs is currently implicitly drained through its connection to
the source or the target node. However, the drain section for target_bs
ends early after moving mirror_top_bs from src to target_bs, so that
requests can already be restarted while mirror_top_bs is still present
in the chain, but has dropped all permissions and therefore runs into an
assertion failure like this:

qemu-system-x86_64: block/io.c:1634: bdrv_co_write_req_prepare:
    Assertion `child->perm & BLK_PERM_WRITE' failed.

Keep mirror_top_bs drained until all graph changes have completed.

Cc: qemu-stable@nongnu.org
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 block/mirror.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

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 mirror_exit_common(Job *job)
     s->target = NULL;
 
     /* We don't access the source any more. Dropping any WRITE/RESIZE is
-     * required before it could become a backing file of target_bs. */
+     * required before it could become a backing file of target_bs. Not having
+     * these permissions any more means that we can't allow any new requests on
+     * mirror_top_bs from now on, so keep it drained. */
+    bdrv_drained_begin(mirror_top_bs);
     bs_opaque->stop = true;
     bdrv_child_refresh_perms(mirror_top_bs, mirror_top_bs->backing,
                              &error_abort);
@@ -XXX,XX +XXX,XX @@ static int mirror_exit_common(Job *job)
     bs_opaque->job = NULL;
 
     bdrv_drained_end(src);
+    bdrv_drained_end(mirror_top_bs);
     s->in_drain = false;
     bdrv_unref(mirror_top_bs);
     bdrv_unref(src);
-- 
2.20.1

This fixes devices like IDE that can still start new requests from I/O
handlers in the CPU thread while the block backend is drained.

The basic assumption is that in a drain section, no new requests should
be allowed through a BlockBackend (blk_drained_begin/end don't exist,
we get drain sections only on the node level). However, there are two
special cases where requests should not be queued:

1. Block jobs: We already make sure that block jobs are paused in a
   drain section, so they won't start new requests. However, if the
   drain_begin is called on the job's BlockBackend first, it can happen
   that we deadlock because the job stays busy until it reaches a pause
   point - which it can't if its requests aren't processed any more.

The proper solution here would be to make all requests through the
   job's filter node instead of using a BlockBackend. For now, just
   disabling request queuing on the job BlockBackend is simpler.

2. In test cases where making requests through bdrv_* would be
   cumbersome because we'd need a BdrvChild. As we already got the
   functionality to disable request queuing from 1., use it in tests,
   too, for convenience.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
---
 include/sysemu/block-backend.h |  1 +
 block/backup.c                 |  1 +
 block/block-backend.c          | 53 ++++++++++++++++++++++++++++++++--
 block/commit.c                 |  2 ++
 block/mirror.c                 |  1 +
 blockjob.c                     |  3 ++
 tests/test-bdrv-drain.c        |  1 +
 7 files changed, 59 insertions(+), 3 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 @@ void blk_get_perm(BlockBackend *blk, uint64_t *perm, uint64_t *shared_perm);
 
 void blk_set_allow_write_beyond_eof(BlockBackend *blk, bool allow);
 void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow);
+void blk_set_disable_request_queuing(BlockBackend *blk, bool disable);
 void blk_iostatus_enable(BlockBackend *blk);
 bool blk_iostatus_is_enabled(const BlockBackend *blk);
 BlockDeviceIoStatus blk_iostatus(const BlockBackend *blk);
diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
     if (ret < 0) {
         goto error;
     }
+    blk_set_disable_request_queuing(job->target, true);
 
     job->on_source_error = on_source_error;
     job->on_target_error = on_target_error;
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 @@ struct BlockBackend {
     QLIST_HEAD(, BlockBackendAioNotifier) aio_notifiers;
 
     int quiesce_counter;
+    CoQueue queued_requests;
+    bool disable_request_queuing;
+
     VMChangeStateEntry *vmsh;
     bool force_allow_inactivate;
 
@@ -XXX,XX +XXX,XX @@ BlockBackend *blk_new(AioContext *ctx, uint64_t perm, uint64_t shared_perm)
 
     block_acct_init(&blk->stats);
 
+    qemu_co_queue_init(&blk->queued_requests);
     notifier_list_init(&blk->remove_bs_notifiers);
     notifier_list_init(&blk->insert_bs_notifiers);
     QLIST_INIT(&blk->aio_notifiers);
@@ -XXX,XX +XXX,XX @@ void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow)
     blk->allow_aio_context_change = allow;
 }
 
+void blk_set_disable_request_queuing(BlockBackend *blk, bool disable)
+{
+    blk->disable_request_queuing = disable;
+}
+
 static int blk_check_byte_request(BlockBackend *blk, int64_t offset,
                                   size_t size)
 {
@@ -XXX,XX +XXX,XX @@ static int blk_check_byte_request(BlockBackend *blk, int64_t offset,
     return 0;
 }
 
+static void coroutine_fn blk_wait_while_drained(BlockBackend *blk)
+{
+    if (blk->quiesce_counter && !blk->disable_request_queuing) {
+        qemu_co_queue_wait(&blk->queued_requests, NULL);
+    }
+}
+
 int coroutine_fn blk_co_preadv(BlockBackend *blk, int64_t offset,
                                unsigned int bytes, QEMUIOVector *qiov,
                                BdrvRequestFlags flags)
 {
     int ret;
-    BlockDriverState *bs = blk_bs(blk);
+    BlockDriverState *bs;
 
+    blk_wait_while_drained(blk);
+
+    /* Call blk_bs() only after waiting, the graph may have changed */
+    bs = blk_bs(blk);
     trace_blk_co_preadv(blk, bs, offset, bytes, flags);
 
     ret = blk_check_byte_request(blk, offset, bytes);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn blk_co_pwritev(BlockBackend *blk, int64_t offset,
                                 BdrvRequestFlags flags)
 {
     int ret;
-    BlockDriverState *bs = blk_bs(blk);
+    BlockDriverState *bs;
 
+    blk_wait_while_drained(blk);
+
+    /* Call blk_bs() only after waiting, the graph may have changed */
+    bs = blk_bs(blk);
     trace_blk_co_pwritev(blk, bs, offset, bytes, flags);
 
     ret = blk_check_byte_request(blk, offset, bytes);
@@ -XXX,XX +XXX,XX @@ static void blk_aio_read_entry(void *opaque)
     BlkRwCo *rwco = &acb->rwco;
     QEMUIOVector *qiov = rwco->iobuf;
 
+    if (rwco->blk->quiesce_counter) {
+        blk_dec_in_flight(rwco->blk);
+        blk_wait_while_drained(rwco->blk);
+        blk_inc_in_flight(rwco->blk);
+    }
+
     assert(qiov->size == acb->bytes);
     rwco->ret = blk_co_preadv(rwco->blk, rwco->offset, acb->bytes,
                               qiov, rwco->flags);
@@ -XXX,XX +XXX,XX @@ static void blk_aio_write_entry(void *opaque)
     BlkRwCo *rwco = &acb->rwco;
     QEMUIOVector *qiov = rwco->iobuf;
 
+    if (rwco->blk->quiesce_counter) {
+        blk_dec_in_flight(rwco->blk);
+        blk_wait_while_drained(rwco->blk);
+        blk_inc_in_flight(rwco->blk);
+    }
+
     assert(!qiov || qiov->size == acb->bytes);
     rwco->ret = blk_co_pwritev(rwco->blk, rwco->offset, acb->bytes,
                                qiov, rwco->flags);
@@ -XXX,XX +XXX,XX @@ void blk_aio_cancel_async(BlockAIOCB *acb)
 
 int blk_co_ioctl(BlockBackend *blk, unsigned long int req, void *buf)
 {
+    blk_wait_while_drained(blk);
+
     if (!blk_is_available(blk)) {
         return -ENOMEDIUM;
     }
@@ -XXX,XX +XXX,XX @@ BlockAIOCB *blk_aio_ioctl(BlockBackend *blk, unsigned long int req, void *buf,
 
 int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
 {
-    int ret = blk_check_byte_request(blk, offset, bytes);
+    int ret;
+
+    blk_wait_while_drained(blk);
+
+    ret = blk_check_byte_request(blk, offset, bytes);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ int blk_co_pdiscard(BlockBackend *blk, int64_t offset, int bytes)
 
 int blk_co_flush(BlockBackend *blk)
 {
+    blk_wait_while_drained(blk);
+
     if (!blk_is_available(blk)) {
         return -ENOMEDIUM;
     }
@@ -XXX,XX +XXX,XX @@ static void blk_root_drained_end(BdrvChild *child, int *drained_end_counter)
         if (blk->dev_ops && blk->dev_ops->drained_end) {
             blk->dev_ops->drained_end(blk->dev_opaque);
         }
+        while (qemu_co_enter_next(&blk->queued_requests, NULL)) {
+            /* Resume all queued requests */
+        }
     }
 }
 
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 @@ void commit_start(const char *job_id, BlockDriverState *bs,
     if (ret < 0) {
         goto fail;
     }
+    blk_set_disable_request_queuing(s->base, true);
     s->base_bs = base;
 
     /* Required permissions are already taken with block_job_add_bdrv() */
@@ -XXX,XX +XXX,XX @@ void commit_start(const char *job_id, BlockDriverState *bs,
     if (ret < 0) {
         goto fail;
     }
+    blk_set_disable_request_queuing(s->top, true);
 
     s->backing_file_str = g_strdup(backing_file_str);
     s->on_error = on_error;
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 BlockJob *mirror_start_job(
         blk_set_force_allow_inactivate(s->target);
     }
     blk_set_allow_aio_context_change(s->target, true);
+    blk_set_disable_request_queuing(s->target, true);
 
     s->replaces = g_strdup(replaces);
     s->on_source_error = on_source_error;
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_create(const char *job_id, const BlockJobDriver *driver,
 
     bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
 
+    /* Disable request queuing in the BlockBackend to avoid deadlocks on drain:
+     * The job reports that it's busy until it reaches a pause point. */
+    blk_set_disable_request_queuing(blk, true);
     blk_set_allow_aio_context_change(blk, true);
 
     /* Only set speed when necessary to avoid NotSupported error */
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void test_iothread_common(enum drain_type drain_type, int drain_thread)
                               &error_abort);
     s = bs->opaque;
     blk_insert_bs(blk, bs, &error_abort);
+    blk_set_disable_request_queuing(blk, true);
 
     blk_set_aio_context(blk, ctx_a, &error_abort);
     aio_context_acquire(ctx_a);
-- 
2.20.1

bdrv_create options specified with -o have no effect when skipping image
creation with -n, so this doesn't make sense. Warn against the misuse
and deprecate the combination so we can make it a hard error later.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 qemu-img.c           | 5 +++++
 qemu-deprecated.texi | 7 +++++++
 2 files changed, 12 insertions(+)

diff --git a/qemu-img.c b/qemu-img.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -XXX,XX +XXX,XX @@ static int img_convert(int argc, char **argv)
         goto fail_getopt;
     }
 
+    if (skip_create && options) {
+        warn_report("-o has no effect when skipping image creation");
+        warn_report("This will become an error in future QEMU versions.");
+    }
+
     s.src_num = argc - optind - 1;
     out_filename = s.src_num >= 1 ? argv[argc - 1] : NULL;
 
diff --git a/qemu-deprecated.texi b/qemu-deprecated.texi
index XXXXXXX..XXXXXXX 100644
--- a/qemu-deprecated.texi
+++ b/qemu-deprecated.texi
@@ -XXX,XX +XXX,XX @@ to just export the entire image and then mount only /dev/nbd0p1 than
 it is to reinvoke @command{qemu-nbd -c /dev/nbd0} limited to just a
 subset of the image.
 
+@subsection qemu-img convert -n -o (since 4.2.0)
+
+All options specified in @option{-o} are image creation options, so
+they have no effect when used with @option{-n} to skip image creation.
+Silently ignored options can be confusing, so this combination of
+options will be made an error in future versions.
+
 @section Build system
 
 @subsection Python 2 support (since 4.1.0)
-- 
2.20.1

From: Nir Soffer <nirsof@gmail.com>

In some cases buf_align or request_alignment cannot be detected:

1. With Gluster, buf_align cannot be detected since the actual I/O is
   done on Gluster server, and qemu buffer alignment does not matter.
   Since we don't have alignment requirement, buf_align=1 is the best
   value.

2. With local XFS filesystem, buf_align cannot be detected if reading
   from unallocated area. In this we must align the buffer, but we don't
   know what is the correct size. Using the wrong alignment results in
   I/O error.

3. With Gluster backed by XFS, request_alignment cannot be detected if
   reading from unallocated area. In this case we need to use the
   correct alignment, and failing to do so results in I/O errors.

4. With NFS, the server does not use direct I/O, so both buf_align cannot
   be detected. In this case we don't need any alignment so we can use
   buf_align=1 and request_alignment=1.

These cases seems to work when storage sector size is 512 bytes, because
the current code starts checking align=512. If the check succeeds
because alignment cannot be detected we use 512. But this does not work
for storage with 4k sector size.

To determine if we can detect the alignment, we probe first with
align=1. If probing succeeds, maybe there are no alignment requirement
(cases 1, 4) or we are probing unallocated area (cases 2, 3). Since we
don't have any way to tell, we treat this as undetectable alignment. If
probing with align=1 fails with EINVAL, but probing with one of the
expected alignments succeeds, we know that we found a working alignment.

Practically the alignment requirements are the same for buffer
alignment, buffer length, and offset in file. So in case we cannot
detect buf_align, we can use request alignment. If we cannot detect
request alignment, we can fallback to a safe value. To use this logic,
we probe first request alignment instead of buf_align.

Here is a table showing the behaviour with current code (the value in
parenthesis is the optimal value).

Case    Sector    buf_align (opt)   request_alignment (opt)     result
======================================================================
1       512       512   (1)          512   (512)                 OK
1       4096      512   (1)          4096  (4096)                FAIL
----------------------------------------------------------------------
2       512       512   (512)        512   (512)                 OK
2       4096      512   (4096)       4096  (4096)                FAIL
----------------------------------------------------------------------
3       512       512   (1)          512   (512)                 OK
3       4096      512   (1)          512   (4096)                FAIL
----------------------------------------------------------------------
4       512       512   (1)          512   (1)                   OK
4       4096      512   (1)          512   (1)                   OK

Same cases with this change:

Case    Sector    buf_align (opt)   request_alignment (opt)     result
======================================================================
1       512       512   (1)          512   (512)                 OK
1       4096      4096  (1)          4096  (4096)                OK
----------------------------------------------------------------------
2       512       512   (512)        512   (512)                 OK
2       4096      4096  (4096)       4096  (4096)                OK
----------------------------------------------------------------------
3       512       4096  (1)          4096  (512)                 OK
3       4096      4096  (1)          4096  (4096)                OK
----------------------------------------------------------------------
4       512       4096  (1)          4096  (1)                   OK
4       4096      4096  (1)          4096  (1)                   OK

I tested that provisioning VMs and copying disks on local XFS and
Gluster with 4k bytes sector size work now, resolving bugs [1],[2].
I tested also on XFS, NFS, Gluster with 512 bytes sector size.

[1] https://bugzilla.redhat.com/1737256
[2] https://bugzilla.redhat.com/1738657

Signed-off-by: Nir Soffer <nsoffer@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/file-posix.c | 36 +++++++++++++++++++++++++-----------
 1 file changed, 25 insertions(+), 11 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
     BDRVRawState *s = bs->opaque;
     char *buf;
     size_t max_align = MAX(MAX_BLOCKSIZE, getpagesize());
+    size_t alignments[] = {1, 512, 1024, 2048, 4096};
 
     /* For SCSI generic devices the alignment is not really used.
        With buffered I/O, we don't have any restrictions. */
@@ -XXX,XX +XXX,XX @@ static void raw_probe_alignment(BlockDriverState *bs, int fd, Error **errp)
     }
 #endif
 
-    /* If we could not get the sizes so far, we can only guess them */
-    if (!s->buf_align) {
+    /*
+     * If we could not get the sizes so far, we can only guess them. First try
+     * to detect request alignment, since it is more likely to succeed. Then
+     * try to detect buf_align, which cannot be detected in some cases (e.g.
+     * Gluster). If buf_align cannot be detected, we fallback to the value of
+     * request_alignment.
+     */
+
+    if (!bs->bl.request_alignment) {
+        int i;
         size_t align;
-        buf = qemu_memalign(max_align, 2 * max_align);
-        for (align = 512; align <= max_align; align <<= 1) {
-            if (raw_is_io_aligned(fd, buf + align, max_align)) {
-                s->buf_align = align;
+        buf = qemu_memalign(max_align, max_align);
+        for (i = 0; i < ARRAY_SIZE(alignments); i++) {
+            align = alignments[i];
+            if (raw_is_io_aligned(fd, buf, align)) {
+                /* Fallback to safe value. */
+                bs->bl.request_alignment = (align != 1) ? align : max_align;
                 break;
             }
         }
         qemu_vfree(buf);
     }
 
-    if (!bs->bl.request_alignment) {
+    if (!s->buf_align) {
+        int i;
         size_t align;
-        buf = qemu_memalign(s->buf_align, max_align);
-        for (align = 512; align <= max_align; align <<= 1) {
-            if (raw_is_io_aligned(fd, buf, align)) {
-                bs->bl.request_alignment = align;
+        buf = qemu_memalign(max_align, 2 * max_align);
+        for (i = 0; i < ARRAY_SIZE(alignments); i++) {
+            align = alignments[i];
+            if (raw_is_io_aligned(fd, buf + align, max_align)) {
+                /* Fallback to request_aligment. */
+                s->buf_align = (align != 1) ? align : bs->bl.request_alignment;
                 break;
             }
         }
-- 
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