Series comparison

-[Qemu-devel] [PULL 00/29] Block layer patches
+[PULL 00/10] Block layer patches
-The following changes since commit ee86981bda9ecd40c8daf81b7307b1d2aff68174:
+The following changes since commit ec11dc41eec5142b4776db1296972c6323ba5847:
-  migration: Revert postcopy-blocktime commit set (2018-01-23 10:08:05 +0000)
+  Merge tag 'pull-misc-2022-05-11' of git://repo.or.cz/qemu/armbru into staging (2022-05-11 09:00:26 -0700)
-are available in the git repository at:
+are available in the Git repository at:
   git://repo.or.cz/qemu/kevin.git tags/for-upstream
-for you to fetch changes up to 8c0c5e636e6b11eaf0556be31fceb68e0baff310:
+for you to fetch changes up to f70625299ecc9ba577c87f3d1d75012c747c7d88:
-  Merge remote-tracking branch 'mreitz/tags/pull-block-2018-01-23' into queue-block (2018-01-23 12:40:46 +0100)
+  qemu-iotests: inline common.config into common.rc (2022-05-12 15:42:49 +0200)
 ----------------------------------------------------------------
 Block layer patches
+- coroutine: Fix crashes due to too large pool batch size
+- fdc: Prevent end-of-track overrun
+- nbd: MULTI_CONN for shared writable exports
+- iotests test runner improvements
 ----------------------------------------------------------------
-Daniel Henrique Barboza (1):
+Daniel P. Berrangé (2):
-      tests/qemu-iotests: adding savevm/loadvm with postcopy flag test
+      tests/qemu-iotests: print intent to run a test in TAP mode
       .gitlab-ci.d: export meson testlog.txt as an artifact
-Eric Blake (1):
+Eric Blake (2):
-      iotests: Split 177 into two parts for compat=0.10
+      qemu-nbd: Pass max connections to blockdev layer
       nbd/server: Allow MULTI_CONN for shared writable exports
-Fam Zheng (1):
+Hanna Reitz (1):
-      osdep: Retry SETLK upon EINTR
+      iotests/testrunner: Flush after run_test()
 Hikaru Nishida (1):
       hw/block: Fix pin-based interrupt behaviour of NVMe
 Kevin Wolf (2):
-      tests/.gitignore: Add test-bdrv-drain
+      coroutine: Rename qemu_coroutine_inc/dec_pool_size()
-      Merge remote-tracking branch 'mreitz/tags/pull-block-2018-01-23' into queue-block
+      coroutine: Revert to constant batch size
-Max Reitz (24):
+Paolo Bonzini (1):
-      qcow2: Repair unaligned preallocated zero clusters
+      qemu-iotests: inline common.config into common.rc
       iotests: Make BD-{remove,insert}-medium use @id
       tests/ahci: Switch tray and medium commands to @id
       blockdev: Drop BD-{remove,insert}-medium's @device
       blockdev: Mark BD-{remove,insert}-medium stable
       qemu-iotests: Fix locking issue in 102
       block/vmdk: Fix , instead of ; at end of line
       qcow2: No persistent dirty bitmaps for compat=0.10
       block/qcow: Add blkdebug events
       block/vmdk: Add blkdebug events
       iotests: Fix _img_info for backslashes
       iotests: Drop format-specific in _filter_img_info
       iotests: Forbid 020 for non-file protocols
       iotests: Skip 103 for refcount_bits=1
       iotests: Fix 020 for vmdk
       iotests: Fix 051 for compat=0.10
       iotests: Fix 059's reference output
       iotests: Fix 067 for compat=0.10
       iotests: Make 089 compatible with compat=0.10
       iotests: Make 184 image-less
       iotests: Make 191 work with qcow2 options
       iotests: Filter compat-dependent info in 198
       iotests: Make 059 pass on machines with little RAM
       iotests: Disable some tests for compat=0.10
- qapi/block-core.json             |  42 ++----
+Philippe Mathieu-Daudé (2):
- hw/block/nvme.h                  |   1 +
+      hw/block/fdc: Prevent end-of-track overrun (CVE-2021-3507)
- block/qcow.c                     |  16 ++
+      tests/qtest/fdc-test: Add a regression test for CVE-2021-3507
  block/qcow2-bitmap.c             |  10 ++
  block/qcow2-refcount.c           |  70 +++++++--
  block/qcow2.c                    |  14 +-
  block/vmdk.c                     |  18 ++-
  blockdev.c                       |  30 +++-
  hw/block/nvme.c                  |  39 ++++-
  tests/ahci-test.c                |  16 +-
  util/osdep.c                     |   4 +-
  tests/.gitignore                 |   1 +
  tests/qemu-iotests/020           |  17 +--
  tests/qemu-iotests/020.out       |   6 +-
  tests/qemu-iotests/051           |   2 +
  tests/qemu-iotests/051.out       |   1 +
  tests/qemu-iotests/051.pc.out    |   1 +
  tests/qemu-iotests/059           |   4 +-
  tests/qemu-iotests/059.out       |   2 +-
  tests/qemu-iotests/060           |   3 +-
  tests/qemu-iotests/060.out       |   9 ++
  tests/qemu-iotests/067           |   3 +-
  tests/qemu-iotests/067.out       |  97 ++++--------
  tests/qemu-iotests/080           |   5 +-
  tests/qemu-iotests/089           |   4 +-
  tests/qemu-iotests/089.out       |  10 --
  tests/qemu-iotests/093           |   6 +-
  tests/qemu-iotests/102           |   7 +-
  tests/qemu-iotests/102.out       |   3 +-
  tests/qemu-iotests/103           |   2 +
  tests/qemu-iotests/118           | 184 +++++++++++------------
  tests/qemu-iotests/130           |   2 +
  tests/qemu-iotests/137           |   2 +
  tests/qemu-iotests/139           |   2 +-
  tests/qemu-iotests/155           |  60 ++++----
  tests/qemu-iotests/176           |   2 +
  tests/qemu-iotests/177           |  20 +--
  tests/qemu-iotests/177.out       |  22 +--
  tests/qemu-iotests/184           |  25 +---
  tests/qemu-iotests/184.out       |  63 ++------
  tests/qemu-iotests/191           |   5 +-
  tests/qemu-iotests/191.out       | 313 +++++++++++----------------------------
  tests/qemu-iotests/198           |   8 +-
  tests/qemu-iotests/198.out       |   8 -
  tests/qemu-iotests/201           | 120 +++++++++++++++
  tests/qemu-iotests/201.out       |  23 +++
  tests/qemu-iotests/204           | 119 +++++++++++++++
  tests/qemu-iotests/204.out       |  63 ++++++++
  tests/qemu-iotests/common.filter |  29 +++-
  tests/qemu-iotests/common.rc     |   2 +-
  tests/qemu-iotests/group         |   2 +
 files changed, 870 insertions(+), 647 deletions(-)
  create mode 100755 tests/qemu-iotests/201
  create mode 100644 tests/qemu-iotests/201.out
  create mode 100755 tests/qemu-iotests/204
  create mode 100644 tests/qemu-iotests/204.out
+ qapi/block-export.json                           |   8 +-
+ docs/interop/nbd.txt                             |   1 +
+ docs/tools/qemu-nbd.rst                          |   3 +-
+ include/block/nbd.h                              |   5 +-
+ include/qemu/coroutine.h                         |   6 +-
+ blockdev-nbd.c                                   |  13 +-
+ hw/block/fdc.c                                   |   8 ++
+ hw/block/virtio-blk.c                            |   6 +-
+ nbd/server.c                                     |  10 +-
+ qemu-nbd.c                                       |   2 +-
+ tests/qtest/fdc-test.c                           |  21 ++++
+ util/qemu-coroutine.c                            |  26 ++--
+ tests/qemu-iotests/testrunner.py                 |   4 +
+ .gitlab-ci.d/buildtest-template.yml              |  12 +-
+ MAINTAINERS                                      |   1 +
+ tests/qemu-iotests/common.config                 |  41 -------
+ tests/qemu-iotests/common.rc                     |  31 +++--
+ tests/qemu-iotests/tests/nbd-multiconn           | 145 +++++++++++++++++++++++
+ tests/qemu-iotests/tests/nbd-multiconn.out       |   5 +
+ tests/qemu-iotests/tests/nbd-qemu-allocation.out |   2 +-
+files changed, 261 insertions(+), 89 deletions(-)
+ delete mode 100644 tests/qemu-iotests/common.config
+ create mode 100755 tests/qemu-iotests/tests/nbd-multiconn
+ create mode 100644 tests/qemu-iotests/tests/nbd-multiconn.out

-[Qemu-devel] [PULL 08/29] blockdev: Drop BD-{remove, insert}-medium's @device
+[PULL 01/10] coroutine: Rename qemu_coroutine_inc/dec_pool_size()
-From: Max Reitz <mreitz@redhat.com>
+It's true that these functions currently affect the batch size in which
 coroutines are reused (i.e. moved from the global release pool to the
 allocation pool of a specific thread), but this is a bug and will be
 fixed in a separate patch.
-This is an incompatible change, which is fine as the commands are
+In fact, the comment in the header file already just promises that it
-experimental.
+influences the pool size, so reflect this in the name of the functions.
 As a nice side effect, the shorter function name makes some line
 wrapping unnecessary.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Cc: qemu-stable@nongnu.org
-Message-id: 20171110224302.14424-4-mreitz@redhat.com
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
+Message-Id: <20220510151020.105528-2-kwolf@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json | 10 ++--------
+ include/qemu/coroutine.h | 6 +++---
- blockdev.c           | 30 +++++++++++++++++++++++-------
+ hw/block/virtio-blk.c    | 6 ++----
-files changed, 25 insertions(+), 15 deletions(-)
+ util/qemu-coroutine.c    | 4 ++--
 files changed, 7 insertions(+), 9 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/include/qemu/coroutine.h
-+++ b/qapi/block-core.json
++++ b/include/qemu/coroutine.h
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ void coroutine_fn yield_until_fd_readable(int fd);
- #
+ /**
- # If the tray is open and there is no medium inserted, this will be a no-op.
+  * Increase coroutine pool size
- #
+  */
--# @device: Block device name (deprecated, use @id instead)
+-void qemu_coroutine_increase_pool_batch_size(unsigned int additional_pool_size);
--#
++void qemu_coroutine_inc_pool_size(unsigned int additional_pool_size);
- # @id:     The name or QOM path of the guest device (since: 2.8)
- #
+ /**
- # Note: This command is still a work in progress and is considered experimental.
+- * Devcrease coroutine pool size
-@@ -XXX,XX +XXX,XX @@
++ * Decrease coroutine pool size
- #
+  */
- ##
+-void qemu_coroutine_decrease_pool_batch_size(unsigned int additional_pool_size);
- { 'command': 'x-blockdev-remove-medium',
++void qemu_coroutine_dec_pool_size(unsigned int additional_pool_size);
--  'data': { '*device': 'str',
--            '*id': 'str' } }
+ #include "qemu/lockable.h"
-+  'data': { 'id': 'str' } }
+diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
  ##
  # @x-blockdev-insert-medium:
@@ -XXX,XX +XXX,XX @@
  # device's tray must currently be open (unless there is no attached guest
  # device) and there must be no medium inserted already.
  #
 -# @device:    Block device name (deprecated, use @id instead)
 -#
  # @id:        The name or QOM path of the guest device (since: 2.8)
  #
  # @node-name: name of a node in the block driver state graph
@@ -XXX,XX +XXX,XX @@
  #
  ##
  { 'command': 'x-blockdev-insert-medium',
 -  'data': { '*device': 'str',
 -            '*id': 'str',
 +  'data': { 'id': 'str',
              'node-name': 'str'} }
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockdev.c
+--- a/hw/block/virtio-blk.c
-+++ b/blockdev.c
++++ b/hw/block/virtio-blk.c
-@@ -XXX,XX +XXX,XX @@ static QTAILQ_HEAD(, BlockDriverState) monitor_bdrv_states =
+@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
+     for (i = 0; i < conf->num_queues; i++) {
- static int do_open_tray(const char *blk_name, const char *qdev_id,
+         virtio_add_queue(vdev, conf->queue_size, virtio_blk_handle_output);
                          bool force, Error **errp);
 +static void blockdev_remove_medium(bool has_device, const char *device,
 +                                   bool has_id, const char *id, Error **errp);
 +static void blockdev_insert_medium(bool has_device, const char *device,
 +                                   bool has_id, const char *id,
 +                                   const char *node_name, Error **errp);
  static const char *const if_name[IF_COUNT] = {
      [IF_NONE] = "none",
@@ -XXX,XX +XXX,XX @@ void qmp_eject(bool has_device, const char *device,
      }
-     error_free(local_err);
+-    qemu_coroutine_increase_pool_batch_size(conf->num_queues * conf->queue_size
+-                                            / 2);
--    qmp_x_blockdev_remove_medium(has_device, device, has_id, id, errp);
++    qemu_coroutine_inc_pool_size(conf->num_queues * conf->queue_size / 2);
-+    blockdev_remove_medium(has_device, device, has_id, id, errp);
+     virtio_blk_data_plane_create(vdev, conf, &s->dataplane, &err);
      if (err != NULL) {
          error_propagate(errp, err);
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_unrealize(DeviceState *dev)
      for (i = 0; i < conf->num_queues; i++) {
          virtio_del_queue(vdev, i);
      }
 -    qemu_coroutine_decrease_pool_batch_size(conf->num_queues * conf->queue_size
 -                                            / 2);
 +    qemu_coroutine_dec_pool_size(conf->num_queues * conf->queue_size / 2);
      qemu_del_vm_change_state_handler(s->change);
      blockdev_mark_auto_del(s->blk);
      virtio_cleanup(vdev);
 diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/qemu-coroutine.c
 +++ b/util/qemu-coroutine.c
@@ -XXX,XX +XXX,XX @@ AioContext *coroutine_fn qemu_coroutine_get_aio_context(Coroutine *co)
      return co->ctx;
  }
- void qmp_block_passwd(bool has_device, const char *device,
+-void qemu_coroutine_increase_pool_batch_size(unsigned int additional_pool_size)
-@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_close_tray(bool has_device, const char *device,
++void qemu_coroutine_inc_pool_size(unsigned int additional_pool_size)
-     }
+ {
      qatomic_add(&pool_batch_size, additional_pool_size);
  }
--void qmp_x_blockdev_remove_medium(bool has_device, const char *device,
+-void qemu_coroutine_decrease_pool_batch_size(unsigned int removing_pool_size)
--                                  bool has_id, const char *id, Error **errp)
++void qemu_coroutine_dec_pool_size(unsigned int removing_pool_size)
 +static void blockdev_remove_medium(bool has_device, const char *device,
 +                                   bool has_id, const char *id, Error **errp)
  {
-     BlockBackend *blk;
+     qatomic_sub(&pool_batch_size, removing_pool_size);
      BlockDriverState *bs;
@@ -XXX,XX +XXX,XX @@ out:
      aio_context_release(aio_context);
  }
-+void qmp_x_blockdev_remove_medium(const char *id, Error **errp)
-+{
-+    blockdev_remove_medium(false, NULL, true, id, errp);
-+}
-+
- static void qmp_blockdev_insert_anon_medium(BlockBackend *blk,
-                                             BlockDriverState *bs, Error **errp)
- {
-@@ -XXX,XX +XXX,XX @@ static void qmp_blockdev_insert_anon_medium(BlockBackend *blk,
-     }
- }
--void qmp_x_blockdev_insert_medium(bool has_device, const char *device,
--                                  bool has_id, const char *id,
--                                  const char *node_name, Error **errp)
-+static void blockdev_insert_medium(bool has_device, const char *device,
-+                                   bool has_id, const char *id,
-+                                   const char *node_name, Error **errp)
- {
-     BlockBackend *blk;
-     BlockDriverState *bs;
-@@ -XXX,XX +XXX,XX @@ void qmp_x_blockdev_insert_medium(bool has_device, const char *device,
-     qmp_blockdev_insert_anon_medium(blk, bs, errp);
- }
-+void qmp_x_blockdev_insert_medium(const char *id, const char *node_name,
-+                                  Error **errp)
-+{
-+    blockdev_insert_medium(false, NULL, true, id, node_name, errp);
-+}
-+
- void qmp_blockdev_change_medium(bool has_device, const char *device,
-                                 bool has_id, const char *id,
-                                 const char *filename,
-@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_change_medium(bool has_device, const char *device,
-     error_free(err);
-     err = NULL;
--    qmp_x_blockdev_remove_medium(has_device, device, has_id, id, &err);
-+    blockdev_remove_medium(has_device, device, has_id, id, &err);
-     if (err) {
-         error_propagate(errp, err);
-         goto fail;
 --
-.13.6
+.35.3

-[Qemu-devel] [PULL 01/29] osdep: Retry SETLK upon EINTR
+[PULL 02/10] coroutine: Revert to constant batch size
-From: Fam Zheng <famz@redhat.com>
+Commit 4c41c69e changed the way the coroutine pool is sized because for
 virtio-blk devices with a large queue size and heavy I/O, it was just
 too small and caused coroutines to be deleted and reallocated soon
 afterwards. The change made the size dynamic based on the number of
 queues and the queue size of virtio-blk devices.
-We could hit lock failure if there is a signal that makes fcntl return
+There are two important numbers here: Slightly simplified, when a
--1 and errno set to EINTR. In this case we should retry.
+coroutine terminates, it is generally stored in the global release pool
 up to a certain pool size, and if the pool is full, it is freed.
 Conversely, when allocating a new coroutine, the coroutines in the
 release pool are reused if the pool already has reached a certain
 minimum size (the batch size), otherwise we allocate new coroutines.
 The problem after commit 4c41c69e is that it not only increases the
 maximum pool size (which is the intended effect), but also the batch
 size for reusing coroutines (which is a bug). It means that in cases
 with many devices and/or a large queue size (which defaults to the
 number of vcpus for virtio-blk-pci), many thousand coroutines could be
 sitting in the release pool without being reused.
 This is not only a waste of memory and allocations, but it actually
 makes the QEMU process likely to hit the vm.max_map_count limit on Linux
 because each coroutine requires two mappings (its stack and the guard
 page for the stack), causing it to abort() in qemu_alloc_stack() because
 when the limit is hit, mprotect() starts to fail with ENOMEM.
 In order to fix the problem, change the batch size back to 64 to avoid
 uselessly accumulating coroutines in the release pool, but keep the
 dynamic maximum pool size so that coroutines aren't freed too early
 in heavy I/O scenarios.
 Note that this fix doesn't strictly make it impossible to hit the limit,
 but this would only happen if most of the coroutines are actually in use
 at the same time, not just sitting in a pool. This is the same behaviour
 as we already had before commit 4c41c69e. Fully preventing this would
 require allowing qemu_coroutine_create() to return an error, but it
 doesn't seem to be a scenario that people hit in practice.
 Cc: qemu-stable@nongnu.org
-Signed-off-by: Fam Zheng <famz@redhat.com>
+Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=2079938
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Fixes: 4c41c69e05fe28c0f95f8abd2ebf407e95a4f04b
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Message-Id: <20220510151020.105528-3-kwolf@redhat.com>
 Tested-by: Hiroki Narukawa <hnarukaw@yahoo-corp.jp>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- util/osdep.c | 4 +++-
+ util/qemu-coroutine.c | 22 ++++++++++++++--------
-file changed, 3 insertions(+), 1 deletion(-)
+file changed, 14 insertions(+), 8 deletions(-)
-diff --git a/util/osdep.c b/util/osdep.c
+diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/osdep.c
+--- a/util/qemu-coroutine.c
-+++ b/util/osdep.c
++++ b/util/qemu-coroutine.c
-@@ -XXX,XX +XXX,XX @@ static int qemu_lock_fcntl(int fd, int64_t start, int64_t len, int fl_type)
+@@ -XXX,XX +XXX,XX @@
-         .l_type   = fl_type,
+ #include "qemu/coroutine-tls.h"
-     };
+ #include "block/aio.h"
-     qemu_probe_lock_ops();
--    ret = fcntl(fd, fcntl_op_setlk, &fl);
+-/** Initial batch size is 64, and is increased on demand */
-+    do {
++/**
-+        ret = fcntl(fd, fcntl_op_setlk, &fl);
++ * The minimal batch size is always 64, coroutines from the release_pool are
-+    } while (ret == -1 && errno == EINTR);
++ * reused as soon as there are 64 coroutines in it. The maximum pool size starts
-     return ret == -1 ? -errno : 0;
++ * with 64 and is increased on demand so that coroutines are not deleted even if
 + * they are not immediately reused.
 + */
  enum {
 -    POOL_INITIAL_BATCH_SIZE = 64,
 +    POOL_MIN_BATCH_SIZE = 64,
 +    POOL_INITIAL_MAX_SIZE = 64,
  };
  /** Free list to speed up creation */
  static QSLIST_HEAD(, Coroutine) release_pool = QSLIST_HEAD_INITIALIZER(pool);
 -static unsigned int pool_batch_size = POOL_INITIAL_BATCH_SIZE;
 +static unsigned int pool_max_size = POOL_INITIAL_MAX_SIZE;
  static unsigned int release_pool_size;
  typedef QSLIST_HEAD(, Coroutine) CoroutineQSList;
@@ -XXX,XX +XXX,XX @@ Coroutine *qemu_coroutine_create(CoroutineEntry *entry, void *opaque)
          co = QSLIST_FIRST(alloc_pool);
          if (!co) {
 -            if (release_pool_size > qatomic_read(&pool_batch_size)) {
 +            if (release_pool_size > POOL_MIN_BATCH_SIZE) {
                  /* Slow path; a good place to register the destructor, too.  */
                  Notifier *notifier = get_ptr_coroutine_pool_cleanup_notifier();
                  if (!notifier->notify) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_delete(Coroutine *co)
      co->caller = NULL;
      if (CONFIG_COROUTINE_POOL) {
 -        if (release_pool_size < qatomic_read(&pool_batch_size) * 2) {
 +        if (release_pool_size < qatomic_read(&pool_max_size) * 2) {
              QSLIST_INSERT_HEAD_ATOMIC(&release_pool, co, pool_next);
              qatomic_inc(&release_pool_size);
              return;
          }
 -        if (get_alloc_pool_size() < qatomic_read(&pool_batch_size)) {
 +        if (get_alloc_pool_size() < qatomic_read(&pool_max_size)) {
              QSLIST_INSERT_HEAD(get_ptr_alloc_pool(), co, pool_next);
              set_alloc_pool_size(get_alloc_pool_size() + 1);
              return;
@@ -XXX,XX +XXX,XX @@ AioContext *coroutine_fn qemu_coroutine_get_aio_context(Coroutine *co)
  void qemu_coroutine_inc_pool_size(unsigned int additional_pool_size)
  {
 -    qatomic_add(&pool_batch_size, additional_pool_size);
 +    qatomic_add(&pool_max_size, additional_pool_size);
  }
+ void qemu_coroutine_dec_pool_size(unsigned int removing_pool_size)
+ {
+-    qatomic_sub(&pool_batch_size, removing_pool_size);
++    qatomic_sub(&pool_max_size, removing_pool_size);
+ }
 --
-.13.6
+.35.3

-[Qemu-devel] [PULL 03/29] tests/.gitignore: Add test-bdrv-drain
+[PULL 03/10] iotests/testrunner: Flush after run_test()
-Commit 881cfd17 added a new test binary, include it in .gitignore.
+From: Hanna Reitz <hreitz@redhat.com>
-Reported-by: Eric Blake <eblake@redhat.com>
+When stdout is not a terminal, the buffer may not be flushed at each end
 of line, so we should flush after each test is done.  This is especially
 apparent when run by check-block, in two ways:
 First, when running make check-block -jX with X > 1, progress indication
 was missing, even though testrunner.py does theoretically print each
 test's status once it has been run, even in multi-processing mode.
 Flushing after each test restores this progress indication.
 Second, sometimes make check-block failed altogether, with an error
 message that "too few tests [were] run".  I presume that's because one
 worker process in the job pool did not get to flush its stdout before
 the main process exited, and so meson did not get to see that worker's
 test results.  In any case, by flushing at the end of run_test(), the
 problem has disappeared for me.
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 Message-Id: <20220506134215.10086-1-hreitz@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
 ---
- tests/.gitignore | 1 +
+ tests/qemu-iotests/testrunner.py | 1 +
 file changed, 1 insertion(+)
-diff --git a/tests/.gitignore b/tests/.gitignore
+diff --git a/tests/qemu-iotests/testrunner.py b/tests/qemu-iotests/testrunner.py
 index XXXXXXX..XXXXXXX 100644
---- a/tests/.gitignore
+--- a/tests/qemu-iotests/testrunner.py
-+++ b/tests/.gitignore
++++ b/tests/qemu-iotests/testrunner.py
-@@ -XXX,XX +XXX,XX @@ test-aio
+@@ -XXX,XX +XXX,XX @@ def run_test(self, test: str,
- test-aio-multithread
+             else:
- test-arm-mptimer
+                 print(res.casenotrun)
- test-base64
-+test-bdrv-drain
++        sys.stdout.flush()
- test-bitops
+         return res
- test-bitcnt
- test-blockjob
+     def run_tests(self, tests: List[str], jobs: int = 1) -> bool:
 --
-.13.6
+.35.3

-[Qemu-devel] [PULL 05/29] qcow2: Repair unaligned preallocated zero clusters
+[PULL 04/10] tests/qemu-iotests: print intent to run a test in TAP mode
-From: Max Reitz <mreitz@redhat.com>
+From: Daniel P. Berrangé <berrange@redhat.com>
-We can easily repair unaligned preallocated zero clusters by discarding
+When running I/O tests using TAP output mode, we get a single TAP test
-them, so why not do it?
+with a sub-test reported for each I/O test that is run. The output looks
 something like this:
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+..123
-Message-id: 20171110203759.14018-2-mreitz@redhat.com
+ ok qcow2 011
-Reviewed-by: Eric Blake <eblake@redhat.com>
+ ok qcow2 012
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+ ok qcow2 013
  ok qcow2 217
  ...
 If everything runs or fails normally this is fine, but periodically we
 have been seeing the test harness abort early before all 123 tests have
 been run, just leaving a fairly useless message like
   TAP parsing error: Too few tests run (expected 123, got 107)
 we have no idea which tests were running at the time the test harness
 abruptly exited. This change causes us to print a message about our
 intent to run each test, so we have a record of what is active at the
 time the harness exits abnormally.
 ..123
  # running qcow2 011
  ok qcow2 011
  # running qcow2 012
  ok qcow2 012
  # running qcow2 013
  ok qcow2 013
  # running qcow2 217
  ok qcow2 217
  ...
 Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
 Message-Id: <20220509124134.867431-2-berrange@redhat.com>
 Reviewed-by: Thomas Huth <thuth@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2-refcount.c     | 70 ++++++++++++++++++++++++++++++++++++++--------
+ tests/qemu-iotests/testrunner.py | 3 +++
- tests/qemu-iotests/060     |  3 +-
+file changed, 3 insertions(+)
  tests/qemu-iotests/060.out |  9 ++++++
 files changed, 69 insertions(+), 13 deletions(-)
-diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
+diff --git a/tests/qemu-iotests/testrunner.py b/tests/qemu-iotests/testrunner.py
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2-refcount.c
+--- a/tests/qemu-iotests/testrunner.py
-+++ b/block/qcow2-refcount.c
++++ b/tests/qemu-iotests/testrunner.py
-@@ -XXX,XX +XXX,XX @@ enum {
+@@ -XXX,XX +XXX,XX @@ def run_test(self, test: str,
- static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
+                                      starttime=start,
-                               void **refcount_table,
+                                      lasttime=last_el,
-                               int64_t *refcount_table_size, int64_t l2_offset,
+                                      end = '\n' if mp else '\r')
--                              int flags)
++        else:
-+                              int flags, BdrvCheckMode fix)
++            testname = os.path.basename(test)
- {
++            print(f'# running {self.env.imgfmt} {testname}')
-     BDRVQcow2State *s = bs->opaque;
-     uint64_t *l2_table, l2_entry;
+         res = self.do_run_test(test, mp)
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
                  next_contiguous_offset = offset + s->cluster_size;
              }
 +            /* Correct offsets are cluster aligned */
 +            if (offset_into_cluster(s, offset)) {
 +                if (qcow2_get_cluster_type(l2_entry) ==
 +                    QCOW2_CLUSTER_ZERO_ALLOC)
 +                {
 +                    fprintf(stderr, "%s offset=%" PRIx64 ": Preallocated zero "
 +                            "cluster is not properly aligned; L2 entry "
 +                            "corrupted.\n",
 +                            fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR",
 +                            offset);
 +                    if (fix & BDRV_FIX_ERRORS) {
 +                        uint64_t l2e_offset =
 +                            l2_offset + (uint64_t)i * sizeof(uint64_t);
 +
 +                        l2_entry = QCOW_OFLAG_ZERO;
 +                        l2_table[i] = cpu_to_be64(l2_entry);
 +                        ret = qcow2_pre_write_overlap_check(bs,
 +                                QCOW2_OL_ACTIVE_L2 | QCOW2_OL_INACTIVE_L2,
 +                                l2e_offset, sizeof(uint64_t));
 +                        if (ret < 0) {
 +                            fprintf(stderr, "ERROR: Overlap check failed\n");
 +                            res->check_errors++;
 +                            /* Something is seriously wrong, so abort checking
 +                             * this L2 table */
 +                            goto fail;
 +                        }
 +
 +                        ret = bdrv_pwrite_sync(bs->file, l2e_offset,
 +                                               &l2_table[i], sizeof(uint64_t));
 +                        if (ret < 0) {
 +                            fprintf(stderr, "ERROR: Failed to overwrite L2 "
 +                                    "table entry: %s\n", strerror(-ret));
 +                            res->check_errors++;
 +                            /* Do not abort, continue checking the rest of this
 +                             * L2 table's entries */
 +                        } else {
 +                            res->corruptions_fixed++;
 +                            /* Skip marking the cluster as used
 +                             * (it is unused now) */
 +                            continue;
 +                        }
 +                    } else {
 +                        res->corruptions++;
 +                    }
 +                } else {
 +                    fprintf(stderr, "ERROR offset=%" PRIx64 ": Data cluster is "
 +                        "not properly aligned; L2 entry corrupted.\n", offset);
 +                    res->corruptions++;
 +                }
 +            }
 +
              /* Mark cluster as used */
              ret = qcow2_inc_refcounts_imrt(bs, res,
                                             refcount_table, refcount_table_size,
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
              if (ret < 0) {
                  goto fail;
              }
 -
 -            /* Correct offsets are cluster aligned */
 -            if (offset_into_cluster(s, offset)) {
 -                fprintf(stderr, "ERROR offset=%" PRIx64 ": Cluster is not "
 -                    "properly aligned; L2 entry corrupted.\n", offset);
 -                res->corruptions++;
 -            }
              break;
          }
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
                                void **refcount_table,
                                int64_t *refcount_table_size,
                                int64_t l1_table_offset, int l1_size,
 -                              int flags)
 +                              int flags, BdrvCheckMode fix)
  {
      BDRVQcow2State *s = bs->opaque;
      uint64_t *l1_table = NULL, l2_offset, l1_size2;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
              /* Process and check L2 entries */
              ret = check_refcounts_l2(bs, res, refcount_table,
 -                                     refcount_table_size, l2_offset, flags);
 +                                     refcount_table_size, l2_offset, flags,
 +                                     fix);
              if (ret < 0) {
                  goto fail;
              }
@@ -XXX,XX +XXX,XX @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
      /* current L1 table */
      ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
 -                             s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO);
 +                             s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO,
 +                             fix);
      if (ret < 0) {
          return ret;
      }
@@ -XXX,XX +XXX,XX @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
      for (i = 0; i < s->nb_snapshots; i++) {
          sn = s->snapshots + i;
          ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
 -                                 sn->l1_table_offset, sn->l1_size, 0);
 +                                 sn->l1_table_offset, sn->l1_size, 0, fix);
          if (ret < 0) {
              return ret;
          }
 diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/060
 +++ b/tests/qemu-iotests/060
@@ -XXX,XX +XXX,XX @@ poke_file "$TEST_IMG" "$l2_offset" "\x80\x00\x00\x00\x00\x00\x2a\x01"
  # Let's write to it!
  $QEMU_IO -c "write 0 64k" "$TEST_IMG" | _filter_qemu_io
 -# Can't repair this yet (TODO: We can just deallocate the cluster)
 +echo '--- Repairing ---'
 +_check_test_img -r all
  echo
  echo '=== Discarding with an unaligned refblock ==='
 diff --git a/tests/qemu-iotests/060.out b/tests/qemu-iotests/060.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/060.out
 +++ b/tests/qemu-iotests/060.out
@@ -XXX,XX +XXX,XX @@ discard 65536/65536 bytes at offset 0
 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  qcow2: Marking image as corrupt: Preallocated zero cluster offset 0x2a00 unaligned (guest offset: 0); further corruption events will be suppressed
  write failed: Input/output error
 +--- Repairing ---
 +Repairing offset=2a00: Preallocated zero cluster is not properly aligned; L2 entry corrupted.
 +The following inconsistencies were found and repaired:
 +
 +    0 leaked clusters
 +    1 corruptions
 +
 +Double checking the fixed image now...
 +No errors were found on the image.
  === Discarding with an unaligned refblock ===
 --
-.13.6
+.35.3

-[Qemu-devel] [PULL 29/29] iotests: Disable some tests for compat=0.10
+[PULL 05/10] .gitlab-ci.d: export meson testlog.txt as an artifact
-From: Max Reitz <mreitz@redhat.com>
+From: Daniel P. Berrangé <berrange@redhat.com>
-Tests 080, 130, 137, and 176 simply do not work with compat=0.10 for the
+When running 'make check' we only get a summary of progress on the
-reasons stated there.
+console. Fortunately meson/ninja have saved the raw test output to a
 logfile. Exposing this log will make it easier to debug failures that
 happen in CI.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
-Message-Id: <20171123020832.8165-10-mreitz@redhat.com>
+Message-Id: <20220509124134.867431-3-berrange@redhat.com>
-[eblake: fix 177 in a separate commit]
+Reviewed-by: Thomas Huth <thuth@redhat.com>
-Signed-off-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
-Message-id: 20180117165420.15946-3-eblake@redhat.com
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- tests/qemu-iotests/080 | 5 +++--
+ .gitlab-ci.d/buildtest-template.yml | 12 ++++++++++--
- tests/qemu-iotests/130 | 2 ++
+file changed, 10 insertions(+), 2 deletions(-)
  tests/qemu-iotests/137 | 2 ++
  tests/qemu-iotests/176 | 2 ++
 files changed, 9 insertions(+), 2 deletions(-)
-diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080
+diff --git a/.gitlab-ci.d/buildtest-template.yml b/.gitlab-ci.d/buildtest-template.yml
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/080
+--- a/.gitlab-ci.d/buildtest-template.yml
-+++ b/tests/qemu-iotests/080
++++ b/.gitlab-ci.d/buildtest-template.yml
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+@@ -XXX,XX +XXX,XX @@
- _supported_fmt qcow2
+         make -j"$JOBS" $MAKE_CHECK_ARGS ;
- _supported_proto file
+       fi
- _supported_os Linux
--# Internal snapshots are (currently) impossible with refcount_bits=1
+-.native_test_job_template:
--_unsupported_imgopts 'refcount_bits=1[^0-9]'
++.common_test_job_template:
-+# - Internal snapshots are (currently) impossible with refcount_bits=1
+   stage: test
-+# - This is generally a test for compat=1.1 images
+   image: $CI_REGISTRY_IMAGE/qemu/$IMAGE:latest
-+_unsupported_imgopts 'refcount_bits=1[^0-9]' 'compat=0.10'
+   script:
+@@ -XXX,XX +XXX,XX @@
- header_size=104
+     # Avoid recompiling by hiding ninja with NINJA=":"
+     - make NINJA=":" $MAKE_CHECK_ARGS
-diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
-index XXXXXXX..XXXXXXX 100755
++.native_test_job_template:
---- a/tests/qemu-iotests/130
++  extends: .common_test_job_template
-+++ b/tests/qemu-iotests/130
++  artifacts:
-@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow2
++    name: "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG"
- _supported_proto generic
++    expire_in: 7 days
- _unsupported_proto vxhs
++    paths:
- _supported_os Linux
++      - build/meson-logs/testlog.txt
-+# We are going to use lazy-refcounts
++
-+_unsupported_imgopts 'compat=0.10'
+ .avocado_test_job_template:
+-  extends: .native_test_job_template
- qemu_comm_method="monitor"
++  extends: .common_test_job_template
+   cache:
-diff --git a/tests/qemu-iotests/137 b/tests/qemu-iotests/137
+     key: "${CI_JOB_NAME}-cache"
-index XXXXXXX..XXXXXXX 100755
+     paths:
 --- a/tests/qemu-iotests/137
 +++ b/tests/qemu-iotests/137
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2
  _supported_proto file
  _supported_os Linux
 +# We are going to use lazy-refcounts
 +_unsupported_imgopts 'compat=0.10'
  _make_test_img 64M
 diff --git a/tests/qemu-iotests/176 b/tests/qemu-iotests/176
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/176
 +++ b/tests/qemu-iotests/176
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
  _supported_fmt qcow2
  _supported_proto file
  _supported_os Linux
 +# Persistent dirty bitmaps require compat=1.1
 +_unsupported_imgopts 'compat=0.10'
  function run_qemu()
  {
 --
-.13.6
+.35.3

-[Qemu-devel] [PULL 27/29] iotests: Make 059 pass on machines with little RAM
+[PULL 06/10] hw/block/fdc: Prevent end-of-track overrun (CVE-2021-3507)
-From: Max Reitz <mreitz@redhat.com>
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Per the 82078 datasheet, if the end-of-track (EOT byte in
-Message-id: 20171129192411.6637-1-mreitz@redhat.com
+the FIFO) is more than the number of sectors per side, the
-Reviewed-by: John Snow <jsnow@redhat.com>
+command is terminated unsuccessfully:
-Signed-off-by: Max Reitz <mreitz@redhat.com>
 * 5.2.5 DATA TRANSFER TERMINATION
   The 82078 supports terminal count explicitly through
   the TC pin and implicitly through the underrun/over-
   run and end-of-track (EOT) functions. For full sector
   transfers, the EOT parameter can define the last
   sector to be transferred in a single or multisector
   transfer. If the last sector to be transferred is a par-
   tial sector, the host can stop transferring the data in
   mid-sector, and the 82078 will continue to complete
   the sector as if a hardware TC was received. The
   only difference between these implicit functions and
   TC is that they return "abnormal termination" result
   status. Such status indications can be ignored if they
   were expected.
 * 6.1.3 READ TRACK
   This command terminates when the EOT specified
   number of sectors have been read. If the 82078
   does not find an I D Address Mark on the diskette
   after the second· occurrence of a pulse on the
   INDX# pin, then it sets the IC code in Status Regis-
   ter 0 to "01" (Abnormal termination), sets the MA bit
   in Status Register 1 to "1", and terminates the com-
   mand.
 * 6.1.6 VERIFY
   Refer to Table 6-6 and Table 6-7 for information
   concerning the values of MT and EC versus SC and
   EOT value.
 * Table 6·6. Result Phase Table
 * Table 6-7. Verify Command Result Phase Table
 Fix by aborting the transfer when EOT > # Sectors Per Side.
 Cc: qemu-stable@nongnu.org
 Cc: Hervé Poussineau <hpoussin@reactos.org>
 Fixes: baca51faff0 ("floppy driver: disk geometry auto detect")
 Reported-by: Alexander Bulekov <alxndr@bu.edu>
 Resolves: https://gitlab.com/qemu-project/qemu/-/issues/339
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Message-Id: <20211118115733.4038610-2-philmd@redhat.com>
 Reviewed-by: Hanna Reitz <hreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/059 | 4 +++-
+ hw/block/fdc.c | 8 ++++++++
-file changed, 3 insertions(+), 1 deletion(-)
+file changed, 8 insertions(+)
-diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059
+diff --git a/hw/block/fdc.c b/hw/block/fdc.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/059
+--- a/hw/block/fdc.c
-+++ b/tests/qemu-iotests/059
++++ b/hw/block/fdc.c
-@@ -XXX,XX +XXX,XX @@ done
+@@ -XXX,XX +XXX,XX @@ static void fdctrl_start_transfer(FDCtrl *fdctrl, int direction)
- echo
+         int tmp;
- echo "=== Testing afl image with a very large capacity ==="
+         fdctrl->data_len = 128 << (fdctrl->fifo[5] > 7 ? 7 : fdctrl->fifo[5]);
- _use_sample_img afl9.vmdk.bz2
+         tmp = (fdctrl->fifo[6] - ks + 1);
--_img_info
++        if (tmp < 0) {
-+# The sed makes this test pass on machines with little RAM
++            FLOPPY_DPRINTF("invalid EOT: %d\n", tmp);
-+# (and also with 32 bit builds)
++            fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM, FD_SR1_MA, 0x00);
-+_img_info | sed -e 's/Cannot allocate memory/Invalid argument/'
++            fdctrl->fifo[3] = kt;
- _cleanup_test_img
++            fdctrl->fifo[4] = kh;
++            fdctrl->fifo[5] = ks;
- # success, all done
++            return;
 +        }
          if (fdctrl->fifo[0] & 0x80)
              tmp += fdctrl->fifo[6];
          fdctrl->data_len *= tmp;
 --
-.13.6
+.35.3

-[Qemu-devel] [PULL 02/29] hw/block: Fix pin-based interrupt behaviour of NVMe
+[PULL 07/10] tests/qtest/fdc-test: Add a regression test for CVE-2021-3507
-From: Hikaru Nishida <hikarupsp@gmail.com>
+From: Philippe Mathieu-Daudé <philmd@redhat.com>
-Pin-based interrupt of NVMe controller did not work properly
+Add the reproducer from https://gitlab.com/qemu-project/qemu/-/issues/339
 because using an obsolated function pci_irq_pulse().
 To fix this, change to use pci_irq_assert() / pci_irq_deassert()
 instead of pci_irq_pulse().
-Signed-off-by: Hikaru Nishida <hikarupsp@gmail.com>
+Without the previous commit, when running 'make check-qtest-i386'
-Reviewed-by: Keith Busch <keith.busch@intel.com>
+with QEMU configured with '--enable-sanitizers' we get:
   ==4028352==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x619000062a00 at pc 0x5626d03c491a bp 0x7ffdb4199410 sp 0x7ffdb4198bc0
   READ of size 786432 at 0x619000062a00 thread T0
       #0 0x5626d03c4919 in __asan_memcpy (qemu-system-i386+0x1e65919)
       #1 0x5626d1c023cc in flatview_write_continue softmmu/physmem.c:2787:13
       #2 0x5626d1bf0c0f in flatview_write softmmu/physmem.c:2822:14
       #3 0x5626d1bf0798 in address_space_write softmmu/physmem.c:2914:18
       #4 0x5626d1bf0f37 in address_space_rw softmmu/physmem.c:2924:16
       #5 0x5626d1bf14c8 in cpu_physical_memory_rw softmmu/physmem.c:2933:5
       #6 0x5626d0bd5649 in cpu_physical_memory_write include/exec/cpu-common.h:82:5
       #7 0x5626d0bd0a07 in i8257_dma_write_memory hw/dma/i8257.c:452:9
       #8 0x5626d09f825d in fdctrl_transfer_handler hw/block/fdc.c:1616:13
       #9 0x5626d0a048b4 in fdctrl_start_transfer hw/block/fdc.c:1539:13
       #10 0x5626d09f4c3e in fdctrl_write_data hw/block/fdc.c:2266:13
       #11 0x5626d09f22f7 in fdctrl_write hw/block/fdc.c:829:9
       #12 0x5626d1c20bc5 in portio_write softmmu/ioport.c:207:17
 x619000062a00 is located 0 bytes to the right of 512-byte region [0x619000062800,0x619000062a00)
   allocated by thread T0 here:
       #0 0x5626d03c66ec in posix_memalign (qemu-system-i386+0x1e676ec)
       #1 0x5626d2b988d4 in qemu_try_memalign util/oslib-posix.c:210:11
       #2 0x5626d2b98b0c in qemu_memalign util/oslib-posix.c:226:27
       #3 0x5626d09fbaf0 in fdctrl_realize_common hw/block/fdc.c:2341:20
       #4 0x5626d0a150ed in isabus_fdc_realize hw/block/fdc-isa.c:113:5
       #5 0x5626d2367935 in device_set_realized hw/core/qdev.c:531:13
   SUMMARY: AddressSanitizer: heap-buffer-overflow (qemu-system-i386+0x1e65919) in __asan_memcpy
   Shadow bytes around the buggy address:
 x0c32800044f0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
 x0c3280004500: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 x0c3280004510: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 x0c3280004520: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 x0c3280004530: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
   =>0x0c3280004540:[fa]fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
 x0c3280004550: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
 x0c3280004560: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
 x0c3280004570: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
 x0c3280004580: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
 x0c3280004590: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd
   Shadow byte legend (one shadow byte represents 8 application bytes):
     Addressable:           00
     Heap left redzone:       fa
     Freed heap region:       fd
   ==4028352==ABORTING
 [ kwolf: Added snapshot=on to prevent write file lock failure ]
 Reported-by: Alexander Bulekov <alxndr@bu.edu>
 Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Reviewed-by: Alexander Bulekov <alxndr@bu.edu>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- hw/block/nvme.h |  1 +
+ tests/qtest/fdc-test.c | 21 +++++++++++++++++++++
- hw/block/nvme.c | 39 ++++++++++++++++++++++++++++++++++-----
+file changed, 21 insertions(+)
 files changed, 35 insertions(+), 5 deletions(-)
-diff --git a/hw/block/nvme.h b/hw/block/nvme.h
+diff --git a/tests/qtest/fdc-test.c b/tests/qtest/fdc-test.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/nvme.h
+--- a/tests/qtest/fdc-test.c
-+++ b/hw/block/nvme.h
++++ b/tests/qtest/fdc-test.c
-@@ -XXX,XX +XXX,XX @@ typedef struct NvmeCtrl {
+@@ -XXX,XX +XXX,XX @@ static void test_cve_2021_20196(void)
-     uint32_t    cmbsz;
+     qtest_quit(s);
      uint32_t    cmbloc;
      uint8_t     *cmbuf;
 +    uint64_t    irq_status;
      char            *serial;
      NvmeNamespace   *namespaces;
 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 @@ static uint8_t nvme_sq_empty(NvmeSQueue *sq)
      return sq->head == sq->tail;
  }
--static void nvme_isr_notify(NvmeCtrl *n, NvmeCQueue *cq)
++static void test_cve_2021_3507(void)
 +static void nvme_irq_check(NvmeCtrl *n)
 +{
-+    if (msix_enabled(&(n->parent_obj))) {
++    QTestState *s;
-+        return;
++
-+    }
++    s = qtest_initf("-nographic -m 32M -nodefaults "
-+    if (~n->bar.intms & n->irq_status) {
++                    "-drive file=%s,format=raw,if=floppy,snapshot=on",
-+        pci_irq_assert(&n->parent_obj);
++                    test_image);
-+    } else {
++    qtest_outl(s, 0x9, 0x0a0206);
-+        pci_irq_deassert(&n->parent_obj);
++    qtest_outw(s, 0x3f4, 0x1600);
-+    }
++    qtest_outw(s, 0x3f4, 0x0000);
 +    qtest_outw(s, 0x3f4, 0x0000);
 +    qtest_outw(s, 0x3f4, 0x0000);
 +    qtest_outw(s, 0x3f4, 0x0200);
 +    qtest_outw(s, 0x3f4, 0x0200);
 +    qtest_outw(s, 0x3f4, 0x0000);
 +    qtest_outw(s, 0x3f4, 0x0000);
 +    qtest_outw(s, 0x3f4, 0x0000);
 +    qtest_quit(s);
 +}
 +
-+static void nvme_irq_assert(NvmeCtrl *n, NvmeCQueue *cq)
+ int main(int argc, char **argv)
  {
-     if (cq->irq_enabled) {
+     int fd;
-         if (msix_enabled(&(n->parent_obj))) {
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
-@@ -XXX,XX +XXX,XX @@ static void nvme_isr_notify(NvmeCtrl *n, NvmeCQueue *cq)
+     qtest_add_func("/fdc/read_no_dma_19", test_read_no_dma_19);
-             msix_notify(&(n->parent_obj), cq->vector);
+     qtest_add_func("/fdc/fuzz-registers", fuzz_registers);
-         } else {
+     qtest_add_func("/fdc/fuzz/cve_2021_20196", test_cve_2021_20196);
-             trace_nvme_irq_pin();
++    qtest_add_func("/fdc/fuzz/cve_2021_3507", test_cve_2021_3507);
--            pci_irq_pulse(&n->parent_obj);
-+            assert(cq->cqid < 64);
+     ret = g_test_run();
-+            n->irq_status |= 1 << cq->cqid;
 +            nvme_irq_check(n);
          }
      } else {
          trace_nvme_irq_masked();
      }
  }
 +static void nvme_irq_deassert(NvmeCtrl *n, NvmeCQueue *cq)
 +{
 +    if (cq->irq_enabled) {
 +        if (msix_enabled(&(n->parent_obj))) {
 +            return;
 +        } else {
 +            assert(cq->cqid < 64);
 +            n->irq_status &= ~(1 << cq->cqid);
 +            nvme_irq_check(n);
 +        }
 +    }
 +}
 +
  static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
                               uint64_t prp2, uint32_t len, NvmeCtrl *n)
  {
@@ -XXX,XX +XXX,XX @@ static void nvme_post_cqes(void *opaque)
              sizeof(req->cqe));
          QTAILQ_INSERT_TAIL(&sq->req_list, req, entry);
      }
 -    nvme_isr_notify(n, cq);
 +    nvme_irq_assert(n, cq);
  }
  static void nvme_enqueue_req_completion(NvmeCQueue *cq, NvmeRequest *req)
@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
          n->bar.intmc = n->bar.intms;
          trace_nvme_mmio_intm_set(data & 0xffffffff,
                                   n->bar.intmc);
 +        nvme_irq_check(n);
          break;
      case 0x10:  /* INTMC */
          if (unlikely(msix_enabled(&(n->parent_obj)))) {
@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
          n->bar.intmc = n->bar.intms;
          trace_nvme_mmio_intm_clr(data & 0xffffffff,
                                   n->bar.intmc);
 +        nvme_irq_check(n);
          break;
      case 0x14:  /* CC */
          trace_nvme_mmio_cfg(data & 0xffffffff);
@@ -XXX,XX +XXX,XX @@ static void nvme_process_db(NvmeCtrl *n, hwaddr addr, int val)
              timer_mod(cq->timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 500);
          }
 -        if (cq->tail != cq->head) {
 -            nvme_isr_notify(n, cq);
 +        if (cq->tail == cq->head) {
 +            nvme_irq_deassert(n, cq);
          }
      } else {
          /* Submission queue doorbell write */
 --
-.13.6
+.35.3

-[Qemu-devel] [PULL 28/29] iotests: Split 177 into two parts for compat=0.10
+[PULL 08/10] qemu-nbd: Pass max connections to blockdev layer
 From: Eric Blake <eblake@redhat.com>
-When originally written, test 177 explicitly took care to run
+The next patch wants to adjust whether the NBD server code advertises
-with compat=0.10.  Then I botched my own test in commit
+MULTI_CONN based on whether it is known if the server limits to
-c219ac and f0a9c18f, by adding additional actions that require
+exactly one client.  For a server started by QMP, this information is
-v3 images.  Split out the new code into a new v3-only test, 204,
+obtained through nbd_server_start (which can support more than one
-and revert 177 back to its original state other than a new comment.
+export); but for qemu-nbd (which supports exactly one export), it is
 controlled only by the command-line option -e/--shared.  Since we
 already have a hook function used by qemu-nbd, it's easiest to just
 alter its signature to fit our needs.
-Reported-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Eric Blake <eblake@redhat.com>
-Message-id: 20180117165420.15946-2-eblake@redhat.com
+Message-Id: <20220512004924.417153-2-eblake@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/177     |  20 +++-----
+ include/block/nbd.h | 2 +-
- tests/qemu-iotests/177.out |  22 ++-------
+ blockdev-nbd.c      | 8 ++++----
- tests/qemu-iotests/204     | 119 +++++++++++++++++++++++++++++++++++++++++++++
+ qemu-nbd.c          | 2 +-
- tests/qemu-iotests/204.out |  63 ++++++++++++++++++++++++
+files changed, 6 insertions(+), 6 deletions(-)
  tests/qemu-iotests/group   |   1 +
 files changed, 193 insertions(+), 32 deletions(-)
  create mode 100755 tests/qemu-iotests/204
  create mode 100644 tests/qemu-iotests/204.out
-diff --git a/tests/qemu-iotests/177 b/tests/qemu-iotests/177
+diff --git a/include/block/nbd.h b/include/block/nbd.h
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/177
+--- a/include/block/nbd.h
-+++ b/tests/qemu-iotests/177
++++ b/include/block/nbd.h
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ void nbd_client_new(QIOChannelSocket *sioc,
- #
+ void nbd_client_get(NBDClient *client);
- # Test corner cases with unusual block geometries
+ void nbd_client_put(NBDClient *client);
- #
--# Copyright (C) 2016-2017 Red Hat, Inc.
+-void nbd_server_is_qemu_nbd(bool value);
-+# Copyright (C) 2016-2018 Red Hat, Inc.
++void nbd_server_is_qemu_nbd(int max_connections);
- #
+ bool nbd_server_is_running(void);
- # This program is free software; you can redistribute it and/or modify
+ void nbd_server_start(SocketAddress *addr, const char *tls_creds,
- # it under the terms of the GNU General Public License as published by
+                       const char *tls_authz, uint32_t max_connections,
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+diff --git a/blockdev-nbd.c b/blockdev-nbd.c
- . ./common.rc
+index XXXXXXX..XXXXXXX 100644
- . ./common.filter
+--- a/blockdev-nbd.c
++++ b/blockdev-nbd.c
-+# This test is runnable under compat=0.10; see test 204 for additional
+@@ -XXX,XX +XXX,XX @@ typedef struct NBDServerData {
-+# tests specific to compat=1.1.
+ } NBDServerData;
-+
- _supported_fmt qcow2
+ static NBDServerData *nbd_server;
- _supported_proto file
+-static bool is_qemu_nbd;
++static int qemu_nbd_connections = -1; /* Non-negative if this is qemu-nbd */
- CLUSTER_SIZE=1M
- size=128M
+ static void nbd_update_server_watch(NBDServerData *s);
- options=driver=blkdebug,image.driver=qcow2
--nested_opts=image.file.driver=file,image.file.filename=$TEST_IMG
+-void nbd_server_is_qemu_nbd(bool value)
++void nbd_server_is_qemu_nbd(int max_connections)
- echo
+ {
- echo "== setting up files =="
+-    is_qemu_nbd = value;
-@@ -XXX,XX +XXX,XX @@ echo "== setting up files =="
++    qemu_nbd_connections = max_connections;
  TEST_IMG="$TEST_IMG.base" _make_test_img $size
  $QEMU_IO -c "write -P 11 0 $size" "$TEST_IMG.base" | _filter_qemu_io
  _make_test_img -b "$TEST_IMG.base"
 -$QEMU_IO -c "write -P 22 0 110M" "$TEST_IMG" | _filter_qemu_io
 +$QEMU_IO -c "write -P 22 0 $size" "$TEST_IMG" | _filter_qemu_io
  # Limited to 64k max-transfer
  echo
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
           -c "discard 80000001 30M" | _filter_qemu_io
  echo
 -echo "== block status smaller than alignment =="
 -limits=align=4k
 -$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
 -     -c "alloc 1 1" -c "alloc 0x6dffff0 1000" -c "alloc 127m 5P" \
 -     -c map | _filter_qemu_io
 -
 -echo
  echo "== verify image content =="
  function verify_io()
@@ -XXX,XX +XXX,XX @@ function verify_io()
      echo read -P 0 32M 32M
      echo read -P 22 64M 13M
      echo read -P $discarded 77M 29M
 -    echo read -P 22 106M 4M
 -    echo read -P 11 110M 18M
 +    echo read -P 22 106M 22M
  }
- verify_io | $QEMU_IO -r "$TEST_IMG" | _filter_qemu_io
+ bool nbd_server_is_running(void)
--$QEMU_IMG map --image-opts "$options,$nested_opts,align=4k" \
+ {
--    | _filter_qemu_img_map
+-    return nbd_server || is_qemu_nbd;
++    return nbd_server || qemu_nbd_connections >= 0;
- _check_test_img
+ }
-diff --git a/tests/qemu-iotests/177.out b/tests/qemu-iotests/177.out
+ static void nbd_blockdev_client_closed(NBDClient *client, bool ignored)
 diff --git a/qemu-nbd.c b/qemu-nbd.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/177.out
+--- a/qemu-nbd.c
-+++ b/tests/qemu-iotests/177.out
++++ b/qemu-nbd.c
-@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=134217728
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
- wrote 134217728/134217728 bytes at offset 0
-MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+     bs->detect_zeroes = detect_zeroes;
- Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/t.IMGFMT.base
--wrote 115343360/115343360 bytes at offset 0
+-    nbd_server_is_qemu_nbd(true);
--110 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++    nbd_server_is_qemu_nbd(shared);
-+wrote 134217728/134217728 bytes at offset 0
-+128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+     export_opts = g_new(BlockExportOptions, 1);
+     *export_opts = (BlockExportOptions) {
  == constrained alignment and max-transfer ==
  wrote 131072/131072 bytes at offset 1000
@@ -XXX,XX +XXX,XX @@ wrote 33554432/33554432 bytes at offset 33554432
  discard 31457280/31457280 bytes at offset 80000001
 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 -== block status smaller than alignment ==
 -1/1 bytes allocated at offset 1 bytes
 -16/1000 bytes allocated at offset 110 MiB
 -0/1048576 bytes allocated at offset 127 MiB
 -110 MiB (0x6e00000) bytes     allocated at offset 0 bytes (0x0)
 -18 MiB (0x1200000) bytes not allocated at offset 110 MiB (0x6e00000)
 -
  == verify image content ==
  read 1000/1000 bytes at offset 0
 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
@@ -XXX,XX +XXX,XX @@ read 13631488/13631488 bytes at offset 67108864
 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  read 30408704/30408704 bytes at offset 80740352
 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 -read 4194304/4194304 bytes at offset 111149056
 -4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 -read 18874368/18874368 bytes at offset 115343360
 -18 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 -Offset          Length          File
 -0               0x800000        TEST_DIR/t.IMGFMT
 -0x900000        0x2400000       TEST_DIR/t.IMGFMT
 -0x3c00000       0x1100000       TEST_DIR/t.IMGFMT
 -0x6a00000       0x400000        TEST_DIR/t.IMGFMT
 +read 23068672/23068672 bytes at offset 111149056
 +22 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
  No errors were found on the image.
  *** done
 diff --git a/tests/qemu-iotests/204 b/tests/qemu-iotests/204
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/204
@@ -XXX,XX +XXX,XX @@
 +#!/bin/bash
 +#
 +# Test corner cases with unusual block geometries
 +#
 +# Copyright (C) 2016-2018 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=eblake@redhat.com
 +
 +seq=`basename $0`
 +echo "QA output created by $seq"
 +
 +here=`pwd`
 +status=1    # failure is the default!
 +
 +_cleanup()
 +{
 +    _cleanup_test_img
 +}
 +trap "_cleanup; exit \$status" 0 1 2 3 15
 +
 +# get standard environment, filters and checks
 +. ./common.rc
 +. ./common.filter
 +
 +_supported_fmt qcow2
 +_supported_proto file
 +# This test assumes that discard leaves zero clusters; see test 177 for
 +# other tests that also work in older images
 +_unsupported_imgopts 'compat=0.10'
 +
 +CLUSTER_SIZE=1M
 +size=128M
 +options=driver=blkdebug,image.driver=qcow2
 +nested_opts=image.file.driver=file,image.file.filename=$TEST_IMG
 +
 +echo
 +echo "== setting up files =="
 +
 +TEST_IMG="$TEST_IMG.base" _make_test_img $size
 +$QEMU_IO -c "write -P 11 0 $size" "$TEST_IMG.base" | _filter_qemu_io
 +_make_test_img -b "$TEST_IMG.base"
 +$QEMU_IO -c "write -P 22 0 110M" "$TEST_IMG" | _filter_qemu_io
 +
 +# Limited to 64k max-transfer
 +echo
 +echo "== constrained alignment and max-transfer =="
 +limits=align=4k,max-transfer=64k
 +$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
 +         -c "write -P 33 1000 128k" -c "read -P 33 1000 128k" | _filter_qemu_io
 +
 +echo
 +echo "== write zero with constrained max-transfer =="
 +limits=align=512,max-transfer=64k,opt-write-zero=$CLUSTER_SIZE
 +$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
 +         -c "write -z 8003584 2093056" | _filter_qemu_io
 +
 +# non-power-of-2 write-zero/discard alignments
 +echo
 +echo "== non-power-of-2 write zeroes limits =="
 +
 +limits=align=512,opt-write-zero=15M,max-write-zero=15M,opt-discard=15M,max-discard=15M
 +$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
 +         -c "write -z 32M 32M" | _filter_qemu_io
 +
 +echo
 +echo "== non-power-of-2 discard limits =="
 +
 +limits=align=512,opt-write-zero=15M,max-write-zero=15M,opt-discard=15M,max-discard=15M
 +$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
 +         -c "discard 80000001 30M" | _filter_qemu_io
 +
 +echo
 +echo "== block status smaller than alignment =="
 +limits=align=4k
 +$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
 +     -c "alloc 1 1" -c "alloc 0x6dffff0 1000" -c "alloc 127m 5P" \
 +     -c map | _filter_qemu_io
 +
 +echo
 +echo "== verify image content =="
 +
 +function verify_io()
 +{
 +    echo read -P 22 0 1000
 +    echo read -P 33 1000 128k
 +    echo read -P 22 132072 7871512
 +    echo read -P 0 8003584 2093056
 +    echo read -P 22 10096640 23457792
 +    echo read -P 0 32M 32M
 +    echo read -P 22 64M 13M
 +    echo read -P 0 77M 29M
 +    echo read -P 22 106M 4M
 +    echo read -P 11 110M 18M
 +}
 +
 +verify_io | $QEMU_IO -r "$TEST_IMG" | _filter_qemu_io
 +$QEMU_IMG map --image-opts "$options,$nested_opts,align=4k" \
 +    | _filter_qemu_img_map
 +
 +_check_test_img
 +
 +# success, all done
 +echo "*** done"
 +status=0
 diff --git a/tests/qemu-iotests/204.out b/tests/qemu-iotests/204.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/204.out
@@ -XXX,XX +XXX,XX @@
 +QA output created by 204
 +
 +== setting up files ==
 +Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=134217728
 +wrote 134217728/134217728 bytes at offset 0
 +128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/t.IMGFMT.base
 +wrote 115343360/115343360 bytes at offset 0
 +110 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +== constrained alignment and max-transfer ==
 +wrote 131072/131072 bytes at offset 1000
 +128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 131072/131072 bytes at offset 1000
 +128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +== write zero with constrained max-transfer ==
 +wrote 2093056/2093056 bytes at offset 8003584
 +1.996 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +== non-power-of-2 write zeroes limits ==
 +wrote 33554432/33554432 bytes at offset 33554432
 +32 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +== non-power-of-2 discard limits ==
 +discard 31457280/31457280 bytes at offset 80000001
 +30 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +== block status smaller than alignment ==
 +1/1 bytes allocated at offset 1 bytes
 +16/1000 bytes allocated at offset 110 MiB
 +0/1048576 bytes allocated at offset 127 MiB
 +110 MiB (0x6e00000) bytes     allocated at offset 0 bytes (0x0)
 +18 MiB (0x1200000) bytes not allocated at offset 110 MiB (0x6e00000)
 +
 +== verify image content ==
 +read 1000/1000 bytes at offset 0
 +1000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 131072/131072 bytes at offset 1000
 +128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 7871512/7871512 bytes at offset 132072
 +7.507 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 2093056/2093056 bytes at offset 8003584
 +1.996 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 23457792/23457792 bytes at offset 10096640
 +22.371 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 33554432/33554432 bytes at offset 33554432
 +32 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 13631488/13631488 bytes at offset 67108864
 +13 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 30408704/30408704 bytes at offset 80740352
 +29 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 4194304/4194304 bytes at offset 111149056
 +4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 18874368/18874368 bytes at offset 115343360
 +18 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +Offset          Length          File
 +0               0x800000        TEST_DIR/t.IMGFMT
 +0x900000        0x2400000       TEST_DIR/t.IMGFMT
 +0x3c00000       0x1100000       TEST_DIR/t.IMGFMT
 +0x6a00000       0x400000        TEST_DIR/t.IMGFMT
 +No errors were found on the image.
 +*** done
 diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/group
 +++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 rw auto migration
 rw auto quick
 rw auto
 +204 rw auto quick
 --
-.13.6
+.35.3

-[Qemu-devel] [PULL 04/29] tests/qemu-iotests: adding savevm/loadvm with postcopy flag test
+[PULL 09/10] nbd/server: Allow MULTI_CONN for shared writable exports
-From: Daniel Henrique Barboza <danielhb@linux.vnet.ibm.com>
+From: Eric Blake <eblake@redhat.com>
-This patch implements a test case for the scenario that was failing
+According to the NBD spec, a server that advertises
-prior to the patch "migration/ram.c: do not set 'postcopy_running' in
+NBD_FLAG_CAN_MULTI_CONN promises that multiple client connections will
-POSTCOPY_INCOMING_END", commit acab30b85d.
+not see any cache inconsistencies: when properly separated by a single
+flush, actions performed by one client will be visible to another
-This new test file 201 was derived from the test file 181 authored
+client, regardless of which client did the flush.
-by Kevin Wolf.
+We always satisfy these conditions in qemu - even when we support
-CC: Kevin Wolf <kwolf@redhat.com>
+multiple clients, ALL clients go through a single point of reference
-CC: Max Reitz <mreitz@redhat.com>
+into the block layer, with no local caching.  The effect of one client
-CC: Cleber Rosa <crosa@redhat.com>
+is instantly visible to the next client.  Even if our backend were a
-Signed-off-by: Daniel Henrique Barboza <danielhb@linux.vnet.ibm.com>
+network device, we argue that any multi-path caching effects that
 would cause inconsistencies in back-to-back actions not seeing the
 effect of previous actions would be a bug in that backend, and not the
 fault of caching in qemu.  As such, it is safe to unconditionally
 advertise CAN_MULTI_CONN for any qemu NBD server situation that
 supports parallel clients.
 Note, however, that we don't want to advertise CAN_MULTI_CONN when we
 know that a second client cannot connect (for historical reasons,
 qemu-nbd defaults to a single connection while nbd-server-add and QMP
 commands default to unlimited connections; but we already have
 existing means to let either style of NBD server creation alter those
 defaults).  This is visible by no longer advertising MULTI_CONN for
 'qemu-nbd -r' without -e, as in the iotest nbd-qemu-allocation.
 The harder part of this patch is setting up an iotest to demonstrate
 behavior of multiple NBD clients to a single server.  It might be
 possible with parallel qemu-io processes, but I found it easier to do
 in python with the help of libnbd, and help from Nir and Vladimir in
 writing the test.
 Signed-off-by: Eric Blake <eblake@redhat.com>
 Suggested-by: Nir Soffer <nsoffer@redhat.com>
 Suggested-by: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
 Message-Id: <20220512004924.417153-3-eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/201     | 120 +++++++++++++++++++++++++++++++++++++++++++++
+ qapi/block-export.json                        |   8 +-
- tests/qemu-iotests/201.out |  23 +++++++++
+ docs/interop/nbd.txt                          |   1 +
- tests/qemu-iotests/group   |   1 +
+ docs/tools/qemu-nbd.rst                       |   3 +-
-files changed, 144 insertions(+)
+ include/block/nbd.h                           |   3 +-
- create mode 100755 tests/qemu-iotests/201
+ blockdev-nbd.c                                |   5 +
- create mode 100644 tests/qemu-iotests/201.out
+ nbd/server.c                                  |  10 +-
+ MAINTAINERS                                   |   1 +
-diff --git a/tests/qemu-iotests/201 b/tests/qemu-iotests/201
+ tests/qemu-iotests/tests/nbd-multiconn        | 145 ++++++++++++++++++
  tests/qemu-iotests/tests/nbd-multiconn.out    |   5 +
  .../tests/nbd-qemu-allocation.out             |   2 +-
 files changed, 172 insertions(+), 11 deletions(-)
  create mode 100755 tests/qemu-iotests/tests/nbd-multiconn
  create mode 100644 tests/qemu-iotests/tests/nbd-multiconn.out
 diff --git a/qapi/block-export.json b/qapi/block-export.json
 index XXXXXXX..XXXXXXX 100644
 --- a/qapi/block-export.json
 +++ b/qapi/block-export.json
@@ -XXX,XX +XXX,XX @@
  #             recreated on the fly while the NBD server is active.
  #             If missing, it will default to denying access (since 4.0).
  # @max-connections: The maximum number of connections to allow at the same
 -#                   time, 0 for unlimited. (since 5.2; default: 0)
 +#                   time, 0 for unlimited. Setting this to 1 also stops
 +#                   the server from advertising multiple client support
 +#                   (since 5.2; default: 0)
  #
  # Since: 4.2
  ##
@@ -XXX,XX +XXX,XX @@
  #             recreated on the fly while the NBD server is active.
  #             If missing, it will default to denying access (since 4.0).
  # @max-connections: The maximum number of connections to allow at the same
 -#                   time, 0 for unlimited. (since 5.2; default: 0)
 +#                   time, 0 for unlimited. Setting this to 1 also stops
 +#                   the server from advertising multiple client support
 +#                   (since 5.2; default: 0).
  #
  # Returns: error if the server is already running.
  #
 diff --git a/docs/interop/nbd.txt b/docs/interop/nbd.txt
 index XXXXXXX..XXXXXXX 100644
 --- a/docs/interop/nbd.txt
 +++ b/docs/interop/nbd.txt
@@ -XXX,XX +XXX,XX @@ NBD_CMD_BLOCK_STATUS for "qemu:dirty-bitmap:", NBD_CMD_CACHE
  * 4.2: NBD_FLAG_CAN_MULTI_CONN for shareable read-only exports,
  NBD_CMD_FLAG_FAST_ZERO
  * 5.2: NBD_CMD_BLOCK_STATUS for "qemu:allocation-depth"
 +* 7.1: NBD_FLAG_CAN_MULTI_CONN for shareable writable exports
 diff --git a/docs/tools/qemu-nbd.rst b/docs/tools/qemu-nbd.rst
 index XXXXXXX..XXXXXXX 100644
 --- a/docs/tools/qemu-nbd.rst
 +++ b/docs/tools/qemu-nbd.rst
@@ -XXX,XX +XXX,XX @@ driver options if :option:`--image-opts` is specified.
  .. option:: -e, --shared=NUM
    Allow up to *NUM* clients to share the device (default
 -  ``1``), 0 for unlimited. Safe for readers, but for now,
 -  consistency is not guaranteed between multiple writers.
 +  ``1``), 0 for unlimited.
  .. option:: -t, --persistent
 diff --git a/include/block/nbd.h b/include/block/nbd.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/nbd.h
 +++ b/include/block/nbd.h
@@ -XXX,XX +XXX,XX @@
  /*
 - *  Copyright (C) 2016-2020 Red Hat, Inc.
 + *  Copyright (C) 2016-2022 Red Hat, Inc.
   *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
   *
   *  Network Block Device
@@ -XXX,XX +XXX,XX @@ void nbd_client_put(NBDClient *client);
  void nbd_server_is_qemu_nbd(int max_connections);
  bool nbd_server_is_running(void);
 +int nbd_server_max_connections(void);
  void nbd_server_start(SocketAddress *addr, const char *tls_creds,
                        const char *tls_authz, uint32_t max_connections,
                        Error **errp);
 diff --git a/blockdev-nbd.c b/blockdev-nbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev-nbd.c
 +++ b/blockdev-nbd.c
@@ -XXX,XX +XXX,XX @@ bool nbd_server_is_running(void)
      return nbd_server || qemu_nbd_connections >= 0;
  }
 +int nbd_server_max_connections(void)
 +{
 +    return nbd_server ? nbd_server->max_connections : qemu_nbd_connections;
 +}
 +
  static void nbd_blockdev_client_closed(NBDClient *client, bool ignored)
  {
      nbd_client_put(client);
 diff --git a/nbd/server.c b/nbd/server.c
 index XXXXXXX..XXXXXXX 100644
 --- a/nbd/server.c
 +++ b/nbd/server.c
@@ -XXX,XX +XXX,XX @@
  /*
 - *  Copyright (C) 2016-2021 Red Hat, Inc.
 + *  Copyright (C) 2016-2022 Red Hat, Inc.
   *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
   *
   *  Network Block Device Server Side
@@ -XXX,XX +XXX,XX @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
      int64_t size;
      uint64_t perm, shared_perm;
      bool readonly = !exp_args->writable;
 -    bool shared = !exp_args->writable;
      BlockDirtyBitmapOrStrList *bitmaps;
      size_t i;
      int ret;
@@ -XXX,XX +XXX,XX @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
      exp->description = g_strdup(arg->description);
      exp->nbdflags = (NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_FLUSH |
                       NBD_FLAG_SEND_FUA | NBD_FLAG_SEND_CACHE);
 +
 +    if (nbd_server_max_connections() != 1) {
 +        exp->nbdflags |= NBD_FLAG_CAN_MULTI_CONN;
 +    }
      if (readonly) {
          exp->nbdflags |= NBD_FLAG_READ_ONLY;
 -        if (shared) {
 -            exp->nbdflags |= NBD_FLAG_CAN_MULTI_CONN;
 -        }
      } else {
          exp->nbdflags |= (NBD_FLAG_SEND_TRIM | NBD_FLAG_SEND_WRITE_ZEROES |
                            NBD_FLAG_SEND_FAST_ZERO);
 diff --git a/MAINTAINERS b/MAINTAINERS
 index XXXXXXX..XXXXXXX 100644
 --- a/MAINTAINERS
 +++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: qemu-nbd.*
  F: blockdev-nbd.c
  F: docs/interop/nbd.txt
  F: docs/tools/qemu-nbd.rst
 +F: tests/qemu-iotests/tests/*nbd*
  T: git https://repo.or.cz/qemu/ericb.git nbd
  T: git https://src.openvz.org/scm/~vsementsov/qemu.git nbd
 diff --git a/tests/qemu-iotests/tests/nbd-multiconn b/tests/qemu-iotests/tests/nbd-multiconn
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/201
++++ b/tests/qemu-iotests/tests/nbd-multiconn
 @@ -XXX,XX +XXX,XX @@
-+#!/bin/bash
++#!/usr/bin/env python3
-+#
++# group: rw auto quick
-+# Test savevm and loadvm after live migration with postcopy flag
++#
-+#
++# Test cases for NBD multi-conn advertisement
-+# Copyright (C) 2017, IBM Corporation.
++#
-+#
++# Copyright (C) 2022 Red Hat, Inc.
 +# This file is derived from tests/qemu-iotests/181 by Kevin Wolf
 +#
 +# 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.
 ...
 +# GNU General Public License for more details.
 +#
 +# You should have received a copy of the GNU General Public License
 +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 +
-+seq=`basename $0`
++import os
-+echo "QA output created by $seq"
++from contextlib import contextmanager
-+
++import iotests
-+status=1    # failure is the default!
++from iotests import qemu_img_create, qemu_io
 +
-+MIG_SOCKET="${TEST_DIR}/migrate"
++
-+
++disk = os.path.join(iotests.test_dir, 'disk')
-+# get standard environment, filters and checks
++size = '4M'
-+. ./common.rc
++nbd_sock = os.path.join(iotests.sock_dir, 'nbd_sock')
-+. ./common.filter
++nbd_uri = 'nbd+unix:///{}?socket=' + nbd_sock
-+. ./common.qemu
++
 +
-+_cleanup()
++@contextmanager
-+{
++def open_nbd(export_name):
-+    rm -f "${MIG_SOCKET}"
++    h = nbd.NBD()
-+    _cleanup_test_img
++    try:
-+    _cleanup_qemu
++        h.connect_uri(nbd_uri.format(export_name))
-+}
++        yield h
-+trap "_cleanup; exit \$status" 0 1 2 3 15
++    finally:
-+
++        h.shutdown()
-+_supported_fmt qcow2
++
-+_supported_proto generic
++class TestNbdMulticonn(iotests.QMPTestCase):
-+_supported_os Linux
++    def setUp(self):
-+
++        qemu_img_create('-f', iotests.imgfmt, disk, size)
-+# Internal snapshots are (currently) impossible with refcount_bits=1
++        qemu_io('-c', 'w -P 1 0 2M', '-c', 'w -P 2 2M 2M', disk)
-+# This was taken from test 080
++
-+_unsupported_imgopts 'refcount_bits=1[^0-9]'
++        self.vm = iotests.VM()
-+
++        self.vm.launch()
-+size=64M
++        result = self.vm.qmp('blockdev-add', {
-+_make_test_img $size
++            'driver': 'qcow2',
-+
++            'node-name': 'n',
-+echo
++            'file': {'driver': 'file', 'filename': disk}
-+echo === Starting VMs ===
++        })
-+echo
++        self.assert_qmp(result, 'return', {})
 +
-+qemu_comm_method="monitor"
++    def tearDown(self):
-+
++        self.vm.shutdown()
-+if [ "$IMGOPTSSYNTAX" = "true" ]; then
++        os.remove(disk)
-+    _launch_qemu \
++        try:
-+        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk
++            os.remove(nbd_sock)
-+else
++        except OSError:
-+    _launch_qemu \
++            pass
-+        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk
++
-+fi
++    @contextmanager
-+src=$QEMU_HANDLE
++    def run_server(self, max_connections=None):
-+
++        args = {
-+if [ "$IMGOPTSSYNTAX" = "true" ]; then
++            'addr': {
-+    _launch_qemu \
++                'type': 'unix',
-+        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk \
++                'data': {'path': nbd_sock}
-+        -incoming "unix:${MIG_SOCKET}"
++            }
-+else
++        }
-+    _launch_qemu \
++        if max_connections is not None:
-+        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk \
++            args['max-connections'] = max_connections
-+        -incoming "unix:${MIG_SOCKET}"
++
-+fi
++        result = self.vm.qmp('nbd-server-start', args)
-+dest=$QEMU_HANDLE
++        self.assert_qmp(result, 'return', {})
-+
++        yield
-+echo
++
-+echo === Set \'migrate_set_capability postcopy-ram on\' and migrate ===
++        result = self.vm.qmp('nbd-server-stop')
-+echo
++        self.assert_qmp(result, 'return', {})
 +
-+silent=yes
++    def add_export(self, name, writable=None):
-+_send_qemu_cmd $dest 'migrate_set_capability postcopy-ram on' "(qemu)"
++        args = {
-+_send_qemu_cmd $src 'migrate_set_capability postcopy-ram on' "(qemu)"
++            'type': 'nbd',
-+_send_qemu_cmd $src "migrate -d unix:${MIG_SOCKET}" "(qemu)"
++            'id': name,
-+
++            'node-name': 'n',
-+QEMU_COMM_TIMEOUT=1 qemu_cmd_repeat=10 silent=yes \
++            'name': name,
-+    _send_qemu_cmd $src "info migrate" "completed\|failed"
++        }
-+silent=yes _send_qemu_cmd $src "" "(qemu)"
++        if writable is not None:
-+
++            args['writable'] = writable
-+echo
++
-+echo === Check if migration was successful ===
++        result = self.vm.qmp('block-export-add', args)
-+echo
++        self.assert_qmp(result, 'return', {})
 +
-+QEMU_COMM_TIMEOUT=1 silent=yes \
++    def test_default_settings(self):
-+    _send_qemu_cmd $src "info migrate" "completed"
++        with self.run_server():
-+silent=yes _send_qemu_cmd $src "" "(qemu)"
++            self.add_export('r')
-+
++            self.add_export('w', writable=True)
-+echo
++            with open_nbd('r') as h:
-+echo === On destination, execute savevm and loadvm ===
++                self.assertTrue(h.can_multi_conn())
-+echo
++            with open_nbd('w') as h:
-+
++                self.assertTrue(h.can_multi_conn())
-+silent=
++
-+_send_qemu_cmd $dest 'savevm state1' "(qemu)"
++    def test_limited_connections(self):
-+_send_qemu_cmd $dest 'loadvm state1' "(qemu)"
++        with self.run_server(max_connections=1):
-+
++            self.add_export('r')
-+echo
++            self.add_export('w', writable=True)
-+echo === Shut down and check image ===
++            with open_nbd('r') as h:
-+echo
++                self.assertFalse(h.can_multi_conn())
-+
++            with open_nbd('w') as h:
-+_send_qemu_cmd $src 'quit' ""
++                self.assertFalse(h.can_multi_conn())
-+_send_qemu_cmd $dest 'quit' ""
++
-+wait=1 _cleanup_qemu
++    def test_parallel_writes(self):
-+
++        with self.run_server():
-+_check_test_img
++            self.add_export('w', writable=True)
 +
-+# success, all done
++            clients = [nbd.NBD() for _ in range(3)]
-+echo "*** done"
++            for c in clients:
-+status=0
++                c.connect_uri(nbd_uri.format('w'))
-diff --git a/tests/qemu-iotests/201.out b/tests/qemu-iotests/201.out
++                self.assertTrue(c.can_multi_conn())
 +
 +            initial_data = clients[0].pread(1024 * 1024, 0)
 +            self.assertEqual(initial_data, b'\x01' * 1024 * 1024)
 +
 +            updated_data = b'\x03' * 1024 * 1024
 +            clients[1].pwrite(updated_data, 0)
 +            clients[2].flush()
 +            current_data = clients[0].pread(1024 * 1024, 0)
 +
 +            self.assertEqual(updated_data, current_data)
 +
 +            for i in range(3):
 +                clients[i].shutdown()
 +
 +
 +if __name__ == '__main__':
 +    try:
 +        # Easier to use libnbd than to try and set up parallel
 +        # 'qemu-nbd --list' or 'qemu-io' processes, but not all systems
 +        # have libnbd installed.
 +        import nbd  # type: ignore
 +
 +        iotests.main(supported_fmts=['qcow2'])
 +    except ImportError:
 +        iotests.notrun('libnbd not installed')
 diff --git a/tests/qemu-iotests/tests/nbd-multiconn.out b/tests/qemu-iotests/tests/nbd-multiconn.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/201.out
++++ b/tests/qemu-iotests/tests/nbd-multiconn.out
 @@ -XXX,XX +XXX,XX @@
-+QA output created by 201
++...
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
++----------------------------------------------------------------------
-+
++Ran 3 tests
-+=== Starting VMs ===
++
-+
++OK
-+
+diff --git a/tests/qemu-iotests/tests/nbd-qemu-allocation.out b/tests/qemu-iotests/tests/nbd-qemu-allocation.out
-+=== Set 'migrate_set_capability postcopy-ram on' and migrate ===
+index XXXXXXX..XXXXXXX 100644
-+
+--- a/tests/qemu-iotests/tests/nbd-qemu-allocation.out
-+
++++ b/tests/qemu-iotests/tests/nbd-qemu-allocation.out
-+=== Check if migration was successful ===
+@@ -XXX,XX +XXX,XX @@ wrote 2097152/2097152 bytes at offset 1048576
-+
+ exports available: 1
-+
+  export: ''
-+=== On destination, execute savevm and loadvm ===
+   size:  4194304
-+
+-  flags: 0x58f ( readonly flush fua df multi cache )
-+(qemu) savevm state1
++  flags: 0x48f ( readonly flush fua df cache )
-+(qemu) loadvm state1
+   min block: 1
-+
+   opt block: 4096
-+=== Shut down and check image ===
+   max block: 33554432
 +
 +(qemu) quit
 +(qemu) quit
 +No errors were found on the image.
 +*** done
 diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/group
 +++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 rw auto quick
 rw auto
 rw auto
 +201 rw auto migration
 rw auto quick
 rw auto
 --
-.13.6
+.35.3

-[Qemu-devel] [PULL 06/29] iotests: Make BD-{remove, insert}-medium use @id
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-In some cases, these commands still use the deprecated @device
-parameter.  Fix that so we can later drop that parameter from their
-interface.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171110224302.14424-2-mreitz@redhat.com
-Reviewed-by: Alberto Garcia <berto@igalia.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/118 | 184 +++++++++++++++++++++++--------------------------
- tests/qemu-iotests/155 |  60 ++++++++--------
-files changed, 113 insertions(+), 131 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 @@ from iotests import qemu_img
- old_img = os.path.join(iotests.test_dir, 'test0.img')
- new_img = os.path.join(iotests.test_dir, 'test1.img')
-+def interface_to_device_name(interface):
-+    if interface == 'ide':
-+        return 'ide-cd'
-+    elif interface == 'floppy':
-+        return 'floppy'
-+    else:
-+        return None
-+
- class ChangeBaseClass(iotests.QMPTestCase):
-     has_opened = False
-     has_closed = False
-@@ -XXX,XX +XXX,XX @@ class ChangeBaseClass(iotests.QMPTestCase):
- class GeneralChangeTestsBaseClass(ChangeBaseClass):
--    device_name = None
-+    device_name = 'qdev0'
-     def test_change(self):
-         result = self.vm.qmp('change', device='drive0', target=new_img,
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
-     def test_blockdev_change_medium(self):
--        if self.device_name is not None:
--            result = self.vm.qmp('blockdev-change-medium',
--                                 id=self.device_name, filename=new_img,
--                                 format=iotests.imgfmt)
--        else:
--            result = self.vm.qmp('blockdev-change-medium',
--                                 device='drive0', filename=new_img,
--                                 format=iotests.imgfmt)
-+        result = self.vm.qmp('blockdev-change-medium',
-+                             id=self.device_name, filename=new_img,
-+                             format=iotests.imgfmt)
-         self.assert_qmp(result, 'return', {})
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
-     def test_eject(self):
--        if self.device_name is not None:
--            result = self.vm.qmp('eject', id=self.device_name, force=True)
--        else:
--            result = self.vm.qmp('eject', device='drive0', force=True)
-+        result = self.vm.qmp('eject', id=self.device_name, force=True)
-         self.assert_qmp(result, 'return', {})
-         self.wait_for_open()
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-         self.assert_qmp_absent(result, 'return[0]/inserted')
-     def test_tray_eject_change(self):
--        if self.device_name is not None:
--            result = self.vm.qmp('eject', id=self.device_name, force=True)
--        else:
--            result = self.vm.qmp('eject', device='drive0', force=True)
-+        result = self.vm.qmp('eject', id=self.device_name, force=True)
-         self.assert_qmp(result, 'return', {})
-         self.wait_for_open()
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-             self.assert_qmp(result, 'return[0]/tray_open', True)
-         self.assert_qmp_absent(result, 'return[0]/inserted')
--        if self.device_name is not None:
--            result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
--                                 filename=new_img, format=iotests.imgfmt)
--        else:
--            result = self.vm.qmp('blockdev-change-medium', device='drive0',
--                                 filename=new_img, format=iotests.imgfmt)
-+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
-+                             filename=new_img, format=iotests.imgfmt)
-         self.assert_qmp(result, 'return', {})
-         self.wait_for_close()
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
-     def test_tray_open_close(self):
--        if self.device_name is not None:
--            result = self.vm.qmp('blockdev-open-tray',
--                                 id=self.device_name, force=True)
--        else:
--            result = self.vm.qmp('blockdev-open-tray',
--                                 device='drive0', force=True)
-+        result = self.vm.qmp('blockdev-open-tray',
-+                             id=self.device_name, force=True)
-         self.assert_qmp(result, 'return', {})
-         self.wait_for_open()
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-         else:
-             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
--        if self.device_name is not None:
--            result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
--        else:
--            result = self.vm.qmp('blockdev-close-tray', device='drive0')
-+        result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
-         self.assert_qmp(result, 'return', {})
-         if self.has_real_tray or not self.was_empty:
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
-     def test_tray_eject_close(self):
--        result = self.vm.qmp('eject', device='drive0', force=True)
-+        result = self.vm.qmp('eject', id=self.device_name, force=True)
-         self.assert_qmp(result, 'return', {})
-         self.wait_for_open()
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-             self.assert_qmp(result, 'return[0]/tray_open', True)
-         self.assert_qmp_absent(result, 'return[0]/inserted')
--        if self.device_name is not None:
--            result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
--        else:
--            result = self.vm.qmp('blockdev-close-tray', device='drive0')
-+        result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
-         self.assert_qmp(result, 'return', {})
-         self.wait_for_close()
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-         self.assert_qmp_absent(result, 'return[0]/inserted')
-     def test_tray_open_change(self):
--        result = self.vm.qmp('blockdev-open-tray', device='drive0', force=True)
-+        result = self.vm.qmp('blockdev-open-tray', id=self.device_name,
-+                                                   force=True)
-         self.assert_qmp(result, 'return', {})
-         self.wait_for_open()
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-         else:
-             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
--        result = self.vm.qmp('blockdev-change-medium', device='drive0',
-+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
-                                                        filename=new_img,
-                                                        format=iotests.imgfmt)
-         self.assert_qmp(result, 'return', {})
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-                                     'driver': 'file'})
-         self.assert_qmp(result, 'return', {})
--        if self.device_name is not None:
--            result = self.vm.qmp('blockdev-open-tray',
--                                 id=self.device_name, force=True)
--        else:
--            result = self.vm.qmp('blockdev-open-tray',
--                                 device='drive0', force=True)
-+        result = self.vm.qmp('blockdev-open-tray',
-+                             id=self.device_name, force=True)
-         self.assert_qmp(result, 'return', {})
-         self.wait_for_open()
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-         else:
-             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
--        if self.device_name is not None:
--            result = self.vm.qmp('x-blockdev-remove-medium',
--                                 id=self.device_name)
--        else:
--            result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
-+        result = self.vm.qmp('x-blockdev-remove-medium',
-+                             id=self.device_name)
-         self.assert_qmp(result, 'return', {})
-         result = self.vm.qmp('query-block')
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-             self.assert_qmp(result, 'return[0]/tray_open', True)
-         self.assert_qmp_absent(result, 'return[0]/inserted')
--        if self.device_name is not None:
--            result = self.vm.qmp('x-blockdev-insert-medium',
--                                 id=self.device_name, node_name='new')
--        else:
--            result = self.vm.qmp('x-blockdev-insert-medium',
--                                 device='drive0', node_name='new')
-+        result = self.vm.qmp('x-blockdev-insert-medium',
-+                             id=self.device_name, node_name='new')
-         self.assert_qmp(result, 'return', {})
-         result = self.vm.qmp('query-block')
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-             self.assert_qmp(result, 'return[0]/tray_open', True)
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
--        if self.device_name is not None:
--            result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
--        else:
--            result = self.vm.qmp('blockdev-close-tray', device='drive0')
-+        result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
-         self.assert_qmp(result, 'return', {})
-         self.wait_for_close()
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
-     def test_close_on_closed(self):
--        result = self.vm.qmp('blockdev-close-tray', device='drive0')
-+        result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
-         # Should be a no-op
-         self.assert_qmp(result, 'return', {})
-         self.assertEquals(self.vm.get_qmp_events(wait=False), [])
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-         if not self.has_real_tray:
-             return
--        result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
-+        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
-         self.assert_qmp(result, 'error/class', 'GenericError')
-     def test_insert_on_closed(self):
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-                                    'driver': 'file'})
-         self.assert_qmp(result, 'return', {})
--        result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
-+        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
-                                                        node_name='new')
-         self.assert_qmp(result, 'error/class', 'GenericError')
-@@ -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()
--        if interface == 'ide':
--            self.device_name = 'qdev0'
--            self.vm.add_drive(old_img, 'media=%s' % media, 'none')
--            self.vm.add_device('ide-cd,drive=drive0,id=%s' % self.device_name)
--        else:
--            self.vm.add_drive(old_img, 'media=%s' % media, interface)
-+        self.vm.add_drive(old_img, 'media=%s' % media, 'none')
-+        self.vm.add_device('%s,drive=drive0,id=%s' %
-+                           (interface_to_device_name(interface),
-+                            self.device_name))
-         self.vm.launch()
-     def tearDown(self):
-@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):
-                                    'driver': 'file'})
-         self.assert_qmp(result, 'return', {})
--        result = self.vm.qmp('blockdev-open-tray', device='drive0')
-+        result = self.vm.qmp('blockdev-open-tray', id=self.device_name)
-         self.assert_qmp(result, 'return', {})
-         self.wait_for_open()
--        result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
-+        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
-                                                        node_name='new')
-         self.assert_qmp(result, 'error/class', 'GenericError')
-@@ -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, interface)
-+        self.vm = iotests.VM().add_drive(None, 'media=%s' % media, 'none')
-+        self.vm.add_device('%s,drive=drive0,id=%s' %
-+                           (interface_to_device_name(interface),
-+                            self.device_name))
-         self.vm.launch()
-     def tearDown(self):
-@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
-         os.remove(new_img)
-     def test_remove_on_empty(self):
--        result = self.vm.qmp('blockdev-open-tray', device='drive0')
-+        result = self.vm.qmp('blockdev-open-tray', id=self.device_name)
-         self.assert_qmp(result, 'return', {})
-         self.wait_for_open()
--        result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
-+        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
-         # Should be a no-op
-         self.assert_qmp(result, 'return', {})
-@@ -XXX,XX +XXX,XX @@ class TestFloppyInitiallyEmpty(TestInitiallyEmpty):
-         self.has_opened = True
- class TestChangeReadOnly(ChangeBaseClass):
-+    device_name = 'qdev0'
-+
-     def setUp(self):
-         qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k')
-         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-     def test_ro_ro_retain(self):
-         os.chmod(old_img, 0444)
-         os.chmod(new_img, 0444)
--        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
-+        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')
-+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
-         self.vm.launch()
-         result = self.vm.qmp('query-block')
-         self.assert_qmp(result, 'return[0]/inserted/ro', True)
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
--        result = self.vm.qmp('blockdev-change-medium', device='drive0',
-+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
-                                                        filename=new_img,
-                                                        format=iotests.imgfmt,
-                                                        read_only_mode='retain')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-     def test_ro_rw_retain(self):
-         os.chmod(old_img, 0444)
--        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
-+        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')
-+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
-         self.vm.launch()
-         result = self.vm.qmp('query-block')
-         self.assert_qmp(result, 'return[0]/inserted/ro', True)
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
--        result = self.vm.qmp('blockdev-change-medium', device='drive0',
-+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
-                                                        filename=new_img,
-                                                        format=iotests.imgfmt,
-                                                        read_only_mode='retain')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-     def test_rw_ro_retain(self):
-         os.chmod(new_img, 0444)
--        self.vm.add_drive(old_img, 'media=disk', 'floppy')
-+        self.vm.add_drive(old_img, 'media=disk', 'none')
-+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
-         self.vm.launch()
-         result = self.vm.qmp('query-block')
-         self.assert_qmp(result, 'return[0]/inserted/ro', False)
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
--        result = self.vm.qmp('blockdev-change-medium', device='drive0',
-+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
-                                                        filename=new_img,
-                                                        format=iotests.imgfmt,
-                                                        read_only_mode='retain')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-     def test_ro_rw(self):
-         os.chmod(old_img, 0444)
--        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
-+        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')
-+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
-         self.vm.launch()
-         result = self.vm.qmp('query-block')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
-         result = self.vm.qmp('blockdev-change-medium',
--                             device='drive0',
-+                             id=self.device_name,
-                              filename=new_img,
-                              format=iotests.imgfmt,
-                              read_only_mode='read-write')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-     def test_rw_ro(self):
-         os.chmod(new_img, 0444)
--        self.vm.add_drive(old_img, 'media=disk', 'floppy')
-+        self.vm.add_drive(old_img, 'media=disk', 'none')
-+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
-         self.vm.launch()
-         result = self.vm.qmp('query-block')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
-         result = self.vm.qmp('blockdev-change-medium',
--                             device='drive0',
-+                             id=self.device_name,
-                              filename=new_img,
-                              format=iotests.imgfmt,
-                              read_only_mode='read-only')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
-     def test_make_rw_ro(self):
--        self.vm.add_drive(old_img, 'media=disk', 'floppy')
-+        self.vm.add_drive(old_img, 'media=disk', 'none')
-+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
-         self.vm.launch()
-         result = self.vm.qmp('query-block')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
-         result = self.vm.qmp('blockdev-change-medium',
--                             device='drive0',
-+                             id=self.device_name,
-                              filename=new_img,
-                              format=iotests.imgfmt,
-                              read_only_mode='read-only')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-     def test_make_ro_rw(self):
-         os.chmod(new_img, 0444)
--        self.vm.add_drive(old_img, 'media=disk', 'floppy')
-+        self.vm.add_drive(old_img, 'media=disk', 'none')
-+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
-         self.vm.launch()
-         result = self.vm.qmp('query-block')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
-         result = self.vm.qmp('blockdev-change-medium',
--                             device='drive0',
-+                             id=self.device_name,
-                              filename=new_img,
-                              format=iotests.imgfmt,
-                              read_only_mode='read-write')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-     def test_make_rw_ro_by_retain(self):
-         os.chmod(old_img, 0444)
--        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
-+        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')
-+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
-         self.vm.launch()
-         result = self.vm.qmp('query-block')
-         self.assert_qmp(result, 'return[0]/inserted/ro', True)
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
--        result = self.vm.qmp('blockdev-change-medium', device='drive0',
-+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
-                                                        filename=new_img,
-                                                        format=iotests.imgfmt,
-                                                        read_only_mode='retain')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-     def test_make_ro_rw_by_retain(self):
-         os.chmod(new_img, 0444)
--        self.vm.add_drive(old_img, 'media=disk', 'floppy')
-+        self.vm.add_drive(old_img, 'media=disk', 'none')
-+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
-         self.vm.launch()
-         result = self.vm.qmp('query-block')
-         self.assert_qmp(result, 'return[0]/inserted/ro', False)
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
--        result = self.vm.qmp('blockdev-change-medium', device='drive0',
-+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
-                                                        filename=new_img,
-                                                        format=iotests.imgfmt,
-                                                        read_only_mode='retain')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-     def test_rw_ro_cycle(self):
-         os.chmod(new_img, 0444)
--        self.vm.add_drive(old_img, 'media=disk', 'floppy')
-+        self.vm.add_drive(old_img, 'media=disk', 'none')
-+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
-         self.vm.launch()
-         result = self.vm.qmp('query-block')
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-         self.assert_qmp(result, 'return[0]/inserted/ro', False)
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
--        result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
-+        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
-         self.assert_qmp(result, 'return', {})
-         result = self.vm.qmp('query-block')
-         self.assert_qmp_absent(result, 'return[0]/inserted')
--        result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
-+        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
-                                                        node_name='new')
-         self.assert_qmp(result, 'return', {})
-@@ -XXX,XX +XXX,XX @@ TestInitiallyEmpty = None
- class TestBlockJobsAfterCycle(ChangeBaseClass):
-+    device_name = 'qdev0'
-+
-     def setUp(self):
--        qemu_img('create', '-f', iotests.imgfmt, old_img, '1M')
-+        qemu_img('create', '-f', iotests.imgfmt, old_img, '1440K')
-         self.vm = iotests.VM()
-         self.vm.add_drive_raw("id=drive0,driver=null-co,if=none")
-+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
-         self.vm.launch()
-         result = self.vm.qmp('query-block')
-@@ -XXX,XX +XXX,XX @@ class TestBlockJobsAfterCycle(ChangeBaseClass):
-         # For device-less BBs, calling blockdev-open-tray or blockdev-close-tray
-         # is not necessary
--        result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
-+        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
-         self.assert_qmp(result, 'return', {})
-         result = self.vm.qmp('query-block')
-@@ -XXX,XX +XXX,XX @@ class TestBlockJobsAfterCycle(ChangeBaseClass):
-                                    'driver': 'file'})
-         self.assert_qmp(result, 'return', {})
--        result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
-+        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
-                                                        node_name='node0')
-         self.assert_qmp(result, 'return', {})
-diff --git a/tests/qemu-iotests/155 b/tests/qemu-iotests/155
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/155
-+++ b/tests/qemu-iotests/155
-@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
-     target_real_backing = None
-     def setUp(self):
--        qemu_img('create', '-f', iotests.imgfmt, back0_img, '1M')
-+        qemu_img('create', '-f', iotests.imgfmt, back0_img, '1440K')
-         qemu_img('create', '-f', iotests.imgfmt, '-b', back0_img, back1_img)
-         qemu_img('create', '-f', iotests.imgfmt, '-b', back1_img, back2_img)
-         qemu_img('create', '-f', iotests.imgfmt, '-b', back2_img, source_img)
-         self.vm = iotests.VM()
--        self.vm.add_drive(None, '', 'none')
--        self.vm.launch()
--
-         # Add the BDS via blockdev-add so it stays around after the mirror block
-         # job has been completed
--        result = self.vm.qmp('blockdev-add',
--                             node_name='source',
--                             driver=iotests.imgfmt,
--                             file={'driver': 'file',
--                                   'filename': source_img})
--        self.assert_qmp(result, 'return', {})
--
--        result = self.vm.qmp('x-blockdev-insert-medium',
--                             device='drive0', node_name='source')
--        self.assert_qmp(result, 'return', {})
-+        blockdev = {'node-name': 'source',
-+                    'driver': iotests.imgfmt,
-+                    'file': {'driver': 'file',
-+                             'filename': source_img}}
-+        self.vm.add_blockdev(self.qmp_to_opts(blockdev))
-+        self.vm.add_device('floppy,id=qdev0,drive=source')
-+        self.vm.launch()
-         self.assertIntactSourceBackingChain()
-         if self.existing:
-             if self.target_backing:
-                 qemu_img('create', '-f', iotests.imgfmt,
--                         '-b', self.target_backing, target_img, '1M')
-+                         '-b', self.target_backing, target_img, '1440K')
-             else:
--                qemu_img('create', '-f', iotests.imgfmt, target_img, '1M')
-+                qemu_img('create', '-f', iotests.imgfmt, target_img, '1440K')
-             if self.cmd == 'blockdev-mirror':
-                 options = { 'node-name': 'target',
-@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
-         except OSError:
-             pass
--    def findBlockNode(self, node_name, id=None):
--        if id:
-+    def findBlockNode(self, node_name, qdev=None):
-+        if qdev:
-             result = self.vm.qmp('query-block')
-             for device in result['return']:
--                if device['device'] == id:
-+                if device['qdev'] == qdev:
-                     if node_name:
-                         self.assert_qmp(device, 'inserted/node-name', node_name)
-                     return device['inserted']
-@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
-                 if node['node-name'] == node_name:
-                     return node
--        self.fail('Cannot find node %s/%s' % (id, node_name))
-+        self.fail('Cannot find node %s/%s' % (qdev, node_name))
-     def assertIntactSourceBackingChain(self):
-         node = self.findBlockNode('source')
-@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
- class MirrorBaseClass(BaseClass):
-     def runMirror(self, sync):
-         if self.cmd == 'blockdev-mirror':
--            result = self.vm.qmp(self.cmd, device='drive0', sync=sync,
--                                 target='target')
-+            result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source',
-+                                 sync=sync, target='target')
-         else:
-             if self.existing:
-                 mode = 'existing'
-             else:
-                 mode = 'absolute-paths'
--            result = self.vm.qmp(self.cmd, device='drive0', sync=sync,
--                                 target=target_img, format=iotests.imgfmt,
--                                 mode=mode, node_name='target')
-+            result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source',
-+                                 sync=sync, target=target_img,
-+                                 format=iotests.imgfmt, mode=mode,
-+                                 node_name='target')
-         self.assert_qmp(result, 'return', {})
-         self.vm.event_wait('BLOCK_JOB_READY')
--        result = self.vm.qmp('block-job-complete', device='drive0')
-+        result = self.vm.qmp('block-job-complete', device='mirror-job')
-         self.assert_qmp(result, 'return', {})
-         self.vm.event_wait('BLOCK_JOB_COMPLETED')
-@@ -XXX,XX +XXX,XX @@ class MirrorBaseClass(BaseClass):
-     def testFull(self):
-         self.runMirror('full')
--        node = self.findBlockNode('target', 'drive0')
-+        node = self.findBlockNode('target', 'qdev0')
-         self.assertCorrectBackingImage(node, None)
-         self.assertIntactSourceBackingChain()
-     def testTop(self):
-         self.runMirror('top')
--        node = self.findBlockNode('target', 'drive0')
-+        node = self.findBlockNode('target', 'qdev0')
-         self.assertCorrectBackingImage(node, back2_img)
-         self.assertIntactSourceBackingChain()
-     def testNone(self):
-         self.runMirror('none')
--        node = self.findBlockNode('target', 'drive0')
-+        node = self.findBlockNode('target', 'qdev0')
-         self.assertCorrectBackingImage(node, source_img)
-         self.assertIntactSourceBackingChain()
-@@ -XXX,XX +XXX,XX @@ class TestCommit(BaseClass):
-     existing = False
-     def testCommit(self):
--        result = self.vm.qmp('block-commit', device='drive0', base=back1_img)
-+        result = self.vm.qmp('block-commit', job_id='commit-job',
-+                             device='source', base=back1_img)
-         self.assert_qmp(result, 'return', {})
-         self.vm.event_wait('BLOCK_JOB_READY')
--        result = self.vm.qmp('block-job-complete', device='drive0')
-+        result = self.vm.qmp('block-job-complete', device='commit-job')
-         self.assert_qmp(result, 'return', {})
-         self.vm.event_wait('BLOCK_JOB_COMPLETED')
--        node = self.findBlockNode(None, 'drive0')
-+        node = self.findBlockNode(None, 'qdev0')
-         self.assert_qmp(node, 'image' + '/backing-image' * 0 + '/filename',
-                         back1_img)
-         self.assert_qmp(node, 'image' + '/backing-image' * 1 + '/filename',
---
-.13.6

-[Qemu-devel] [PULL 07/29] tests/ahci: Switch tray and medium commands to @id
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-Currently, the tray and medium commands in the AHCI test use the
-deprecated @device parameter.  This patch switches all invocations over
-to use @id.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171110224302.14424-3-mreitz@redhat.com
-Reviewed-by: Alberto Garcia <berto@igalia.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/ahci-test.c | 12 ++++++------
-file changed, 6 insertions(+), 6 deletions(-)
-diff --git a/tests/ahci-test.c b/tests/ahci-test.c
-index XXXXXXX..XXXXXXX 100644
---- a/tests/ahci-test.c
-+++ b/tests/ahci-test.c
-@@ -XXX,XX +XXX,XX @@ static void test_atapi_tray(void)
-     QDict *rsp;
-     fd = prepare_iso(iso_size, &tx, &iso);
--    ahci = ahci_boot_and_enable("-drive if=none,id=drive0,file=%s,format=raw "
-+    ahci = ahci_boot_and_enable("-blockdev node-name=drive0,driver=file,filename=%s "
-                                 "-M q35 "
--                                "-device ide-cd,drive=drive0 ", iso);
-+                                "-device ide-cd,id=cd0,drive=drive0 ", iso);
-     port = ahci_port_select(ahci);
-     ahci_atapi_eject(ahci, port);
-@@ -XXX,XX +XXX,XX @@ static void test_atapi_tray(void)
-     /* Remove media */
-     qmp_async("{'execute': 'blockdev-open-tray', "
--               "'arguments': {'device': 'drive0'}}");
-+               "'arguments': {'id': 'cd0'}}");
-     atapi_wait_tray(true);
-     rsp = qmp_receive();
-     QDECREF(rsp);
-     qmp_discard_response("{'execute': 'x-blockdev-remove-medium', "
--                         "'arguments': {'device': 'drive0'}}");
-+                         "'arguments': {'id': 'cd0'}}");
-     /* Test the tray without a medium */
-     ahci_atapi_load(ahci, port);
-@@ -XXX,XX +XXX,XX @@ static void test_atapi_tray(void)
-                                         "'file': { 'driver': 'file', "
-                                                   "'filename': %s }}}", iso);
-     qmp_discard_response("{'execute': 'x-blockdev-insert-medium',"
--                          "'arguments': { 'device': 'drive0', "
-+                          "'arguments': { 'id': 'cd0', "
-                                          "'node-name': 'node0' }}");
-     /* Again, the event shows up first */
-     qmp_async("{'execute': 'blockdev-close-tray', "
--               "'arguments': {'device': 'drive0'}}");
-+               "'arguments': {'id': 'cd0'}}");
-     atapi_wait_tray(false);
-     rsp = qmp_receive();
-     QDECREF(rsp);
---
-.13.6

-[Qemu-devel] [PULL 09/29] blockdev: Mark BD-{remove, insert}-medium stable
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-Now that iotest 093 test proves that the throttling configuration
-survives a blockdev-remove-medium/blockdev-insert-medium pair, the
-original reason for declaring these commands experimental is gone
-(see commit 6e0abc251dd4f8eba1f53656dfede12e5840e83b).
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171110224302.14424-5-mreitz@redhat.com
-Reviewed-by: Alberto Garcia <berto@igalia.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- qapi/block-core.json   | 32 +++++++++++++-------------------
- blockdev.c             |  6 +++---
- tests/ahci-test.c      |  4 ++--
- tests/qemu-iotests/093 |  6 +++---
- tests/qemu-iotests/118 | 20 ++++++++++----------
- tests/qemu-iotests/139 |  2 +-
-files changed, 32 insertions(+), 38 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
-index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
-+++ b/qapi/block-core.json
-@@ -XXX,XX +XXX,XX @@
-             '*id': 'str' } }
- ##
--# @x-blockdev-remove-medium:
-+# @blockdev-remove-medium:
- #
- # Removes a medium (a block driver state tree) from a block device. That block
- # device's tray must currently be open (unless there is no attached guest
-@@ -XXX,XX +XXX,XX @@
- #
- # If the tray is open and there is no medium inserted, this will be a no-op.
- #
--# @id:     The name or QOM path of the guest device (since: 2.8)
--#
--# Note: This command is still a work in progress and is considered experimental.
--# Stay away from it unless you want to help with its development.
-+# @id:     The name or QOM path of the guest device
- #
--# Since: 2.5
-+# Since: 2.12
- #
- # Example:
- #
--# -> { "execute": "x-blockdev-remove-medium",
-+# -> { "execute": "blockdev-remove-medium",
- #      "arguments": { "id": "ide0-1-0" } }
- #
- # <- { "error": { "class": "GenericError",
-@@ -XXX,XX +XXX,XX @@
- #
- # <- { "return": {} }
- #
--# -> { "execute": "x-blockdev-remove-medium",
-+# -> { "execute": "blockdev-remove-medium",
- #      "arguments": { "id": "ide0-1-0" } }
- #
- # <- { "return": {} }
- #
- ##
--{ 'command': 'x-blockdev-remove-medium',
-+{ 'command': 'blockdev-remove-medium',
-   'data': { 'id': 'str' } }
- ##
--# @x-blockdev-insert-medium:
-+# @blockdev-insert-medium:
- #
- # Inserts a medium (a block driver state tree) into a block device. That block
- # device's tray must currently be open (unless there is no attached guest
- # device) and there must be no medium inserted already.
- #
--# @id:        The name or QOM path of the guest device (since: 2.8)
-+# @id:        The name or QOM path of the guest device
- #
- # @node-name: name of a node in the block driver state graph
- #
--# Note: This command is still a work in progress and is considered experimental.
--# Stay away from it unless you want to help with its development.
--#
--# Since: 2.5
-+# Since: 2.12
- #
- # Example:
- #
-@@ -XXX,XX +XXX,XX @@
- #                    "filename": "fedora.iso" } } }
- # <- { "return": {} }
- #
--# -> { "execute": "x-blockdev-insert-medium",
-+# -> { "execute": "blockdev-insert-medium",
- #      "arguments": { "id": "ide0-1-0",
- #                     "node-name": "node0" } }
- #
- # <- { "return": {} }
- #
- ##
--{ 'command': 'x-blockdev-insert-medium',
-+{ 'command': 'blockdev-insert-medium',
-   'data': { 'id': 'str',
-             'node-name': 'str'} }
-@@ -XXX,XX +XXX,XX @@
- #
- # Changes the medium inserted into a block device by ejecting the current medium
- # and loading a new image file which is inserted as the new medium (this command
--# combines blockdev-open-tray, x-blockdev-remove-medium,
--# x-blockdev-insert-medium and blockdev-close-tray).
-+# combines blockdev-open-tray, blockdev-remove-medium, blockdev-insert-medium
-+# and blockdev-close-tray).
- #
- # @device:          Block device name (deprecated, use @id instead)
- #
-diff --git a/blockdev.c b/blockdev.c
-index XXXXXXX..XXXXXXX 100644
---- a/blockdev.c
-+++ b/blockdev.c
-@@ -XXX,XX +XXX,XX @@ out:
-     aio_context_release(aio_context);
- }
--void qmp_x_blockdev_remove_medium(const char *id, Error **errp)
-+void qmp_blockdev_remove_medium(const char *id, Error **errp)
- {
-     blockdev_remove_medium(false, NULL, true, id, errp);
- }
-@@ -XXX,XX +XXX,XX @@ static void blockdev_insert_medium(bool has_device, const char *device,
-     qmp_blockdev_insert_anon_medium(blk, bs, errp);
- }
--void qmp_x_blockdev_insert_medium(const char *id, const char *node_name,
--                                  Error **errp)
-+void qmp_blockdev_insert_medium(const char *id, const char *node_name,
-+                                Error **errp)
- {
-     blockdev_insert_medium(false, NULL, true, id, node_name, errp);
- }
-diff --git a/tests/ahci-test.c b/tests/ahci-test.c
-index XXXXXXX..XXXXXXX 100644
---- a/tests/ahci-test.c
-+++ b/tests/ahci-test.c
-@@ -XXX,XX +XXX,XX @@ static void test_atapi_tray(void)
-     rsp = qmp_receive();
-     QDECREF(rsp);
--    qmp_discard_response("{'execute': 'x-blockdev-remove-medium', "
-+    qmp_discard_response("{'execute': 'blockdev-remove-medium', "
-                          "'arguments': {'id': 'cd0'}}");
-     /* Test the tray without a medium */
-@@ -XXX,XX +XXX,XX @@ static void test_atapi_tray(void)
-                                         "'driver': 'raw', "
-                                         "'file': { 'driver': 'file', "
-                                                   "'filename': %s }}}", iso);
--    qmp_discard_response("{'execute': 'x-blockdev-insert-medium',"
-+    qmp_discard_response("{'execute': 'blockdev-insert-medium',"
-                           "'arguments': { 'id': 'cd0', "
-                                          "'node-name': 'node0' }}");
-diff --git a/tests/qemu-iotests/093 b/tests/qemu-iotests/093
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/093
-+++ b/tests/qemu-iotests/093
-@@ -XXX,XX +XXX,XX @@ class ThrottleTestRemovableMedia(iotests.QMPTestCase):
-         # Now eject cd0 and insert cd1
-         result = self.vm.qmp("blockdev-open-tray", id='dev0')
-         self.assert_qmp(result, 'return', {})
--        result = self.vm.qmp("x-blockdev-remove-medium", id='dev0')
-+        result = self.vm.qmp("blockdev-remove-medium", id='dev0')
-         self.assert_qmp(result, 'return', {})
--        result = self.vm.qmp("x-blockdev-insert-medium", id='dev0', node_name='cd1')
-+        result = self.vm.qmp("blockdev-insert-medium", id='dev0', node_name='cd1')
-         self.assert_qmp(result, 'return', {})
-         # Check that the I/O limits are still the same
-@@ -XXX,XX +XXX,XX @@ class ThrottleTestRemovableMedia(iotests.QMPTestCase):
-         self.assert_qmp(result, 'return[0]/inserted/bps',   50)
-         # Eject cd1
--        result = self.vm.qmp("x-blockdev-remove-medium", id='dev0')
-+        result = self.vm.qmp("blockdev-remove-medium", id='dev0')
-         self.assert_qmp(result, 'return', {})
-         # Check that we can't set limits if the device has no medium
-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):
-         else:
-             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
--        result = self.vm.qmp('x-blockdev-remove-medium',
-+        result = self.vm.qmp('blockdev-remove-medium',
-                              id=self.device_name)
-         self.assert_qmp(result, 'return', {})
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-             self.assert_qmp(result, 'return[0]/tray_open', True)
-         self.assert_qmp_absent(result, 'return[0]/inserted')
--        result = self.vm.qmp('x-blockdev-insert-medium',
-+        result = self.vm.qmp('blockdev-insert-medium',
-                              id=self.device_name, node_name='new')
-         self.assert_qmp(result, 'return', {})
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-         if not self.has_real_tray:
-             return
--        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
-+        result = self.vm.qmp('blockdev-remove-medium', id=self.device_name)
-         self.assert_qmp(result, 'error/class', 'GenericError')
-     def test_insert_on_closed(self):
-@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
-                                    'driver': 'file'})
-         self.assert_qmp(result, 'return', {})
--        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
-+        result = self.vm.qmp('blockdev-insert-medium', id=self.device_name,
-                                                        node_name='new')
-         self.assert_qmp(result, 'error/class', 'GenericError')
-@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):
-         self.wait_for_open()
--        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
-+        result = self.vm.qmp('blockdev-insert-medium', id=self.device_name,
-                                                        node_name='new')
-         self.assert_qmp(result, 'error/class', 'GenericError')
-@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
-         self.wait_for_open()
--        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
-+        result = self.vm.qmp('blockdev-remove-medium', id=self.device_name)
-         # Should be a no-op
-         self.assert_qmp(result, 'return', {})
-@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
-         self.assert_qmp(result, 'return[0]/inserted/ro', False)
-         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
--        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
-+        result = self.vm.qmp('blockdev-remove-medium', id=self.device_name)
-         self.assert_qmp(result, 'return', {})
-         result = self.vm.qmp('query-block')
-         self.assert_qmp_absent(result, 'return[0]/inserted')
--        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
-+        result = self.vm.qmp('blockdev-insert-medium', id=self.device_name,
-                                                        node_name='new')
-         self.assert_qmp(result, 'return', {})
-@@ -XXX,XX +XXX,XX @@ class TestBlockJobsAfterCycle(ChangeBaseClass):
-         # For device-less BBs, calling blockdev-open-tray or blockdev-close-tray
-         # is not necessary
--        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
-+        result = self.vm.qmp('blockdev-remove-medium', id=self.device_name)
-         self.assert_qmp(result, 'return', {})
-         result = self.vm.qmp('query-block')
-@@ -XXX,XX +XXX,XX @@ class TestBlockJobsAfterCycle(ChangeBaseClass):
-                                    'driver': 'file'})
-         self.assert_qmp(result, 'return', {})
--        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
-+        result = self.vm.qmp('blockdev-insert-medium', id=self.device_name,
-                                                        node_name='node0')
-         self.assert_qmp(result, 'return', {})
-diff --git a/tests/qemu-iotests/139 b/tests/qemu-iotests/139
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/139
-+++ b/tests/qemu-iotests/139
-@@ -XXX,XX +XXX,XX @@ class TestBlockdevDel(iotests.QMPTestCase):
-     # Insert a BlockDriverState
-     def insertDrive(self, device, node):
-         self.checkBlockDriverState(node)
--        result = self.vm.qmp('x-blockdev-insert-medium',
-+        result = self.vm.qmp('blockdev-insert-medium',
-                              id = device, node_name = node)
-         self.assert_qmp(result, 'return', {})
-         self.checkBlockDriverState(node)
---
-.13.6

-[Qemu-devel] [PULL 10/29] qemu-iotests: Fix locking issue in 102
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-truncates a qcow2 file (the raw file) on purpose while a VM is
-running.  However, image locking will usually prevent exactly this.
-The fact that most people have not noticed until now (I suppose you may
-have seen sporadic failures, but not taken them too seriously, like me)
-further shows that this truncation is actually not really done
-concurrently, but that the VM is still starting up by this point and has
-not yet opened the image.  Remedy this by waiting for the monitor shell
-to appear before the qemu-img invocation so we know the VM is up.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171129185102.29390-1-mreitz@redhat.com
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/102     | 7 ++++++-
- tests/qemu-iotests/102.out | 3 ++-
-files changed, 8 insertions(+), 2 deletions(-)
-diff --git a/tests/qemu-iotests/102 b/tests/qemu-iotests/102
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/102
-+++ b/tests/qemu-iotests/102
-@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'write 0 64k' "$TEST_IMG" | _filter_qemu_io
- qemu_comm_method=monitor _launch_qemu -drive if=none,file="$TEST_IMG",id=drv0
--$QEMU_IMG resize -f raw --shrink "$TEST_IMG" $((5 * 64 * 1024))
-+# Wait for a prompt to appear (so we know qemu has opened the image)
-+_send_qemu_cmd '' '(qemu)'
-+
-+$QEMU_IMG resize --shrink --image-opts \
-+    "driver=raw,file.driver=file,file.filename=$TEST_IMG,file.locking=off" \
-+    $((5 * 64 * 1024))
- _send_qemu_cmd $QEMU_HANDLE 'qemu-io drv0 map' 'allocated' \
-     | sed -e 's/^(qemu).*qemu-io drv0 map...$/(qemu) qemu-io drv0 map/'
-diff --git a/tests/qemu-iotests/102.out b/tests/qemu-iotests/102.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/102.out
-+++ b/tests/qemu-iotests/102.out
-@@ -XXX,XX +XXX,XX @@ Offset          Length          Mapped to       File
- Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=65536
- wrote 65536/65536 bytes at offset 0
-KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--Image resized.
- QEMU X.Y.Z monitor - type 'help' for more information
-+Image resized.
-+(qemu)
- (qemu) qemu-io drv0 map
-KiB (0x10000) bytes     allocated at offset 0 bytes (0x0)
- *** done
---
-.13.6

-[Qemu-devel] [PULL 11/29] block/vmdk: Fix , instead of ; at end of line
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-2-mreitz@redhat.com
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- block/vmdk.c | 2 +-
-file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/block/vmdk.c b/block/vmdk.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/vmdk.c
-+++ b/block/vmdk.c
-@@ -XXX,XX +XXX,XX @@ static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
-         qemu_iovec_concat(&local_qiov, qiov, qiov_offset, n_bytes);
-     }
--    write_offset = cluster_offset + offset_in_cluster,
-+    write_offset = cluster_offset + offset_in_cluster;
-     ret = bdrv_co_pwritev(extent->file, write_offset, n_bytes,
-                           &local_qiov, 0);
---
-.13.6

-[Qemu-devel] [PULL 12/29] qcow2: No persistent dirty bitmaps for compat=0.10
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-Persistent dirty bitmaps require a properly functioning
-autoclear_features field, or we cannot track when an unsupporting
-program might overwrite them.  Therefore, we cannot support them for
-compat=0.10 images.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-3-mreitz@redhat.com
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- block/qcow2-bitmap.c | 10 ++++++++++
- block/qcow2.c        | 14 +++++++++++---
-files changed, 21 insertions(+), 3 deletions(-)
-diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2-bitmap.c
-+++ b/block/qcow2-bitmap.c
-@@ -XXX,XX +XXX,XX @@ bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs,
-     bool found;
-     Qcow2BitmapList *bm_list;
-+    if (s->qcow_version < 3) {
-+        /* Without autoclear_features, we would always have to assume
-+         * that a program without persistent dirty bitmap support has
-+         * accessed this qcow2 file when opening it, and would thus
-+         * have to drop all dirty bitmaps (defeating their purpose).
-+         */
-+        error_setg(errp, "Cannot store dirty bitmaps in qcow2 v2 files");
-+        goto fail;
-+    }
-+
-     if (check_constraints_on_bitmap(bs, name, granularity, errp) != 0) {
-         goto 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 qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
-             }
-             if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) {
--                warn_report("a program lacking bitmap support "
--                            "modified this file, so all bitmaps are now "
--                            "considered inconsistent");
-+                if (s->qcow_version < 3) {
-+                    /* Let's be a bit more specific */
-+                    warn_report("This qcow2 v2 image contains bitmaps, but "
-+                                "they may have been modified by a program "
-+                                "without persistent bitmap support; so now "
-+                                "they must all be considered inconsistent");
-+                } else {
-+                    warn_report("a program lacking bitmap support "
-+                                "modified this file, so all bitmaps are now "
-+                                "considered inconsistent");
-+                }
-                 error_printf("Some clusters may be leaked, "
-                              "run 'qemu-img check -r' on the image "
-                              "file to fix.");
---
-.13.6

-[Qemu-devel] [PULL 13/29] block/qcow: Add blkdebug events
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-This is not necessarily complete, but it should include the most
-important places.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-4-mreitz@redhat.com
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- block/qcow.c | 16 ++++++++++++++++
-file changed, 16 insertions(+)
-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,
-         /* update the L1 entry */
-         s->l1_table[l1_index] = l2_offset;
-         tmp = cpu_to_be64(l2_offset);
-+        BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
-         ret = bdrv_pwrite_sync(bs->file,
-                                s->l1_table_offset + l1_index * sizeof(tmp),
-                                &tmp, sizeof(tmp));
-@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
-         }
-     }
-     l2_table = s->l2_cache + (min_index << s->l2_bits);
-+    BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
-     if (new_l2_table) {
-         memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
-         ret = bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
-@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
-         ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1)) {
-         if (!allocate)
-             return 0;
-+        BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
-         /* allocate a new cluster */
-         if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
-             (n_end - n_start) < s->cluster_sectors) {
-@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
-             }
-             cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size);
-             /* write the cluster content */
-+            BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
-             ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache,
-                               s->cluster_size);
-             if (ret < 0) {
-@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
-                                                       NULL) < 0) {
-                                 return -EIO;
-                             }
-+                            BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
-                             ret = bdrv_pwrite(bs->file,
-                                               cluster_offset + i * 512,
-                                               s->cluster_data, 512);
-@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
-         /* update L2 table */
-         tmp = cpu_to_be64(cluster_offset);
-         l2_table[l2_index] = tmp;
-+        if (allocate == 2) {
-+            BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
-+        } else {
-+            BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
-+        }
-         ret = bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
-                                &tmp, sizeof(tmp));
-         if (ret < 0) {
-@@ -XXX,XX +XXX,XX @@ static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
-     if (s->cluster_cache_offset != coffset) {
-         csize = cluster_offset >> (63 - s->cluster_bits);
-         csize &= (s->cluster_size - 1);
-+        BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
-         ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize);
-         if (ret != csize)
-             return -1;
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
-                 hd_iov.iov_len = n * 512;
-                 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
-                 qemu_co_mutex_unlock(&s->lock);
-+                /* qcow2 emits this on bs->file instead of bs->backing */
-+                BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
-                 ret = bdrv_co_readv(bs->backing, sector_num, n, &hd_qiov);
-                 qemu_co_mutex_lock(&s->lock);
-                 if (ret < 0) {
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
-             hd_iov.iov_len = n * 512;
-             qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
-             qemu_co_mutex_unlock(&s->lock);
-+            BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
-             ret = bdrv_co_readv(bs->file,
-                                 (cluster_offset >> 9) + index_in_cluster,
-                                 n, &hd_qiov);
-@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
-         hd_iov.iov_len = n * 512;
-         qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
-         qemu_co_mutex_unlock(&s->lock);
-+        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
-         ret = bdrv_co_writev(bs->file,
-                              (cluster_offset >> 9) + index_in_cluster,
-                              n, &hd_qiov);
-@@ -XXX,XX +XXX,XX @@ qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
-         .iov_len    = out_len,
-     };
-     qemu_iovec_init_external(&hd_qiov, &iov, 1);
-+    BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
-     ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0);
-     if (ret < 0) {
-         goto fail;
---
-.13.6

-[Qemu-devel] [PULL 14/29] block/vmdk: Add blkdebug events
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-This is certainly not complete, but it includes at least write_aio and
-read_aio.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-5-mreitz@redhat.com
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- block/vmdk.c | 16 ++++++++++++++++
-file changed, 16 insertions(+)
-diff --git a/block/vmdk.c b/block/vmdk.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/vmdk.c
-+++ b/block/vmdk.c
-@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
-     /* Read backing data before skip range */
-     if (skip_start_bytes > 0) {
-         if (bs->backing) {
-+            /* qcow2 emits this on bs->file instead of bs->backing */
-+            BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
-             ret = bdrv_pread(bs->backing, offset, whole_grain,
-                              skip_start_bytes);
-             if (ret < 0) {
-@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
-                 goto exit;
-             }
-         }
-+        BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
-         ret = bdrv_pwrite(extent->file, cluster_offset, whole_grain,
-                           skip_start_bytes);
-         if (ret < 0) {
-@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
-     /* Read backing data after skip range */
-     if (skip_end_bytes < cluster_bytes) {
-         if (bs->backing) {
-+            /* qcow2 emits this on bs->file instead of bs->backing */
-+            BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
-             ret = bdrv_pread(bs->backing, offset + skip_end_bytes,
-                              whole_grain + skip_end_bytes,
-                              cluster_bytes - skip_end_bytes);
-@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
-                 goto exit;
-             }
-         }
-+        BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
-         ret = bdrv_pwrite(extent->file, cluster_offset + skip_end_bytes,
-                           whole_grain + skip_end_bytes,
-                           cluster_bytes - skip_end_bytes);
-@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
- {
-     offset = cpu_to_le32(offset);
-     /* update L2 table */
-+    BLKDBG_EVENT(extent->file, BLKDBG_L2_UPDATE);
-     if (bdrv_pwrite_sync(extent->file,
-                 ((int64_t)m_data->l2_offset * 512)
-                     + (m_data->l2_index * sizeof(offset)),
-@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
-         }
-     }
-     l2_table = extent->l2_cache + (min_index * extent->l2_size);
-+    BLKDBG_EVENT(extent->file, BLKDBG_L2_LOAD);
-     if (bdrv_pread(extent->file,
-                 (int64_t)l2_offset * 512,
-                 l2_table,
-@@ -XXX,XX +XXX,XX @@ static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
-             .iov_len    = n_bytes,
-         };
-         qemu_iovec_init_external(&local_qiov, &iov, 1);
-+
-+        BLKDBG_EVENT(extent->file, BLKDBG_WRITE_COMPRESSED);
-     } else {
-         qemu_iovec_init(&local_qiov, qiov->niov);
-         qemu_iovec_concat(&local_qiov, qiov, qiov_offset, n_bytes);
-+
-+        BLKDBG_EVENT(extent->file, BLKDBG_WRITE_AIO);
-     }
-     write_offset = cluster_offset + offset_in_cluster;
-@@ -XXX,XX +XXX,XX @@ static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
-     if (!extent->compressed) {
-+        BLKDBG_EVENT(extent->file, BLKDBG_READ_AIO);
-         ret = bdrv_co_preadv(extent->file,
-                              cluster_offset + offset_in_cluster, bytes,
-                              qiov, 0);
-@@ -XXX,XX +XXX,XX @@ static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
-     buf_bytes = cluster_bytes * 2;
-     cluster_buf = g_malloc(buf_bytes);
-     uncomp_buf = g_malloc(cluster_bytes);
-+    BLKDBG_EVENT(extent->file, BLKDBG_READ_COMPRESSED);
-     ret = bdrv_pread(extent->file,
-                 cluster_offset,
-                 cluster_buf, buf_bytes);
-@@ -XXX,XX +XXX,XX @@ vmdk_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
-                 qemu_iovec_reset(&local_qiov);
-                 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
-+                /* qcow2 emits this on bs->file instead of bs->backing */
-+                BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
-                 ret = bdrv_co_preadv(bs->backing, offset, n_bytes,
-                                      &local_qiov, 0);
-                 if (ret < 0) {
---
-.13.6

-[Qemu-devel] [PULL 15/29] iotests: Fix _img_info for backslashes
+[PULL 10/10] qemu-iotests: inline common.config into common.rc
-From: Max Reitz <mreitz@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-read without -r eats backslashes.
+common.rc has some complicated logic to find the common.config that
 dates back to xfstests and is completely unnecessary now.  Just include
 the contents of the file.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Message-id: 20171123020832.8165-6-mreitz@redhat.com
+Message-Id: <20220505094723.732116-1-pbonzini@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 ---
- tests/qemu-iotests/common.rc | 2 +-
+ tests/qemu-iotests/common.config | 41 --------------------------------
-file changed, 1 insertion(+), 1 deletion(-)
+ tests/qemu-iotests/common.rc     | 31 ++++++++++++++----------
 files changed, 19 insertions(+), 53 deletions(-)
  delete mode 100644 tests/qemu-iotests/common.config
+diff --git a/tests/qemu-iotests/common.config b/tests/qemu-iotests/common.config
+deleted file mode 100644
+index XXXXXXX..XXXXXXX
+--- a/tests/qemu-iotests/common.config
++++ /dev/null
+@@ -XXX,XX +XXX,XX @@
+-#!/usr/bin/env bash
+-#
+-# Copyright (C) 2009 Red Hat, Inc.
+-# Copyright (c) 2000-2003,2006 Silicon Graphics, Inc.  All Rights Reserved.
+-#
+-# 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.
+-#
+-# This program is distributed in the hope that it would 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/>.
+-#
+-# all tests should use a common language setting to prevent golden
+-# output mismatches.
+-export LANG=C
+-
+-PATH=".:$PATH"
+-
+-HOSTOS=$(uname -s)
+-arch=$(uname -m)
+-[[ "$arch" =~ "ppc64" ]] && qemu_arch=ppc64 || qemu_arch="$arch"
+-
+-# make sure we have a standard umask
+-umask 022
+-
+-_optstr_add()
+-{
+-    if [ -n "$1" ]; then
+-        echo "$1,$2"
+-    else
+-        echo "$2"
+-    fi
+-}
+-
+-# make sure this script returns success
+-true
 diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/common.rc
 +++ b/tests/qemu-iotests/common.rc
-@@ -XXX,XX +XXX,XX @@ _img_info()
+@@ -XXX,XX +XXX,XX @@
-             -e "s#$IMGFMT#IMGFMT#g" \
+ # along with this program.  If not, see <http://www.gnu.org/licenses/>.
-             -e "/^disk size:/ D" \
+ #
-             -e "/actual-size/ D" | \
--        while IFS='' read line; do
++export LANG=C
-+        while IFS='' read -r line; do
++
-             if [[ $format_specific == 1 ]]; then
++PATH=".:$PATH"
-                 discard=0
++
-             elif [[ $line == "Format specific information:" ]]; then
++HOSTOS=$(uname -s)
 +arch=$(uname -m)
 +[[ "$arch" =~ "ppc64" ]] && qemu_arch=ppc64 || qemu_arch="$arch"
 +
 +# make sure we have a standard umask
 +umask 022
 +
  # bail out, setting up .notrun file
  _notrun()
  {
@@ -XXX,XX +XXX,XX @@ peek_file_raw()
      dd if="$1" bs=1 skip="$2" count="$3" status=none
  }
 -config=common.config
 -test -f $config || config=../common.config
 -if ! test -f $config
 -then
 -    echo "$0: failed to find common.config"
 -    exit 1
 -fi
 -if ! . $config
 -    then
 -    echo "$0: failed to source common.config"
 -    exit 1
 -fi
 +_optstr_add()
 +{
 +    if [ -n "$1" ]; then
 +        echo "$1,$2"
 +    else
 +        echo "$2"
 +    fi
 +}
  # Set the variables to the empty string to turn Valgrind off
  # for specific processes, e.g.
 --
-.13.6
+.35.3

-[Qemu-devel] [PULL 16/29] iotests: Drop format-specific in _filter_img_info
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-_filter_img_info should remove format-specific information, too.  We
-already have such a filter in _img_info, and it is very useful for
-query-block-named-block-nodes (etc.), too.
-However, in 198 we need that information (but we still want the rest of
-the filter), so make that filtering optional.  Note that "the rest of
-the filter" includes filtering of the test directory, so we can drop the
-_filter_testdir from 198 at the same time.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-7-mreitz@redhat.com
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/198           |  6 ++++--
- tests/qemu-iotests/common.filter | 29 ++++++++++++++++++++++++++++-
-files changed, 32 insertions(+), 3 deletions(-)
-diff --git a/tests/qemu-iotests/198 b/tests/qemu-iotests/198
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/198
-+++ b/tests/qemu-iotests/198
-@@ -XXX,XX +XXX,XX @@ $QEMU_IO --object $SECRET0 --object $SECRET1 -c "read -P 0x9 0 $size" --image-op
- echo
- echo "== checking image base =="
--$QEMU_IMG info --image-opts $IMGSPECBASE | _filter_img_info | _filter_testdir | sed -e "/^disk size:/ D"
-+$QEMU_IMG info --image-opts $IMGSPECBASE | _filter_img_info --format-specific \
-+    | sed -e "/^disk size:/ D"
- echo
- echo "== checking image layer =="
--$QEMU_IMG info --image-opts $IMGSPECLAYER | _filter_img_info | _filter_testdir | sed -e "/^disk size:/ D"
-+$QEMU_IMG info --image-opts $IMGSPECLAYER | _filter_img_info --format-specific \
-+    | sed -e "/^disk size:/ D"
- # success, all done
-diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.filter
-+++ b/tests/qemu-iotests/common.filter
-@@ -XXX,XX +XXX,XX @@ _filter_img_create()
- _filter_img_info()
- {
-+    if [[ "$1" == "--format-specific" ]]; then
-+        local format_specific=1
-+        shift
-+    else
-+        local format_specific=0
-+    fi
-+
-+    discard=0
-+    regex_json_spec_start='^ *"format-specific": \{'
-     sed -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
-         -e "s#$TEST_DIR#TEST_DIR#g" \
-         -e "s#$IMGFMT#IMGFMT#g" \
-@@ -XXX,XX +XXX,XX @@ _filter_img_info()
-         -e "/block_state_zero: \\(on\\|off\\)/d" \
-         -e "/log_size: [0-9]\\+/d" \
-         -e "s/iters: [0-9]\\+/iters: 1024/" \
--        -e "s/uuid: [-a-f0-9]\\+/uuid: 00000000-0000-0000-0000-000000000000/"
-+        -e "s/uuid: [-a-f0-9]\\+/uuid: 00000000-0000-0000-0000-000000000000/" | \
-+    while IFS='' read -r line; do
-+        if [[ $format_specific == 1 ]]; then
-+            discard=0
-+        elif [[ $line == "Format specific information:" ]]; then
-+            discard=1
-+        elif [[ $line =~ $regex_json_spec_start ]]; then
-+            discard=2
-+            regex_json_spec_end="^${line%%[^ ]*}\\},? *$"
-+        fi
-+        if [[ $discard == 0 ]]; then
-+            echo "$line"
-+        elif [[ $discard == 1 && ! $line ]]; then
-+            echo
-+            discard=0
-+        elif [[ $discard == 2 && $line =~ $regex_json_spec_end ]]; then
-+            discard=0
-+        fi
-+    done
- }
- # filter out offsets and file names from qemu-img map; good for both
---
-.13.6

-[Qemu-devel] [PULL 17/29] iotests: Forbid 020 for non-file protocols
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-This test does funny things like TEST_IMG="TEST_IMG.base" _make_test_img
-that usually only work with the file protocol.  More specifically, they
-do not work with the most interesting non-file protocols, so we might as
-well skip this for anything but file.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-8-mreitz@redhat.com
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/020 | 8 +-------
-file changed, 1 insertion(+), 7 deletions(-)
-diff --git a/tests/qemu-iotests/020 b/tests/qemu-iotests/020
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/020
-+++ b/tests/qemu-iotests/020
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- # Any format supporting backing files
- _supported_fmt qcow qcow2 vmdk qed
--_supported_proto generic
--_unsupported_proto vxhs
-+_supported_proto file
- _supported_os Linux
- _unsupported_imgopts "subformat=monolithicFlat" \
-                      "subformat=twoGbMaxExtentFlat" \
-                      "subformat=twoGbMaxExtentSparse"
--# NFS does not support bdrv_reopen_prepare thus qemu-img commit fails.
--if [ "$IMGPROTO" = "nfs" ]; then
--    _notrun "image protocol $IMGPROTO does not support bdrv_commit"
--fi
--
- TEST_OFFSETS="0 4294967296"
- TEST_IMG_SAVE="$TEST_IMG"
---
-.13.6

-[Qemu-devel] [PULL 18/29] iotests: Skip 103 for refcount_bits=1
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-9-mreitz@redhat.com
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/103 | 2 ++
-file changed, 2 insertions(+)
-diff --git a/tests/qemu-iotests/103 b/tests/qemu-iotests/103
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/103
-+++ b/tests/qemu-iotests/103
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- _supported_fmt qcow2
- _supported_proto file nfs
- _supported_os Linux
-+# Internal snapshots are (currently) impossible with refcount_bits=1
-+_unsupported_imgopts 'refcount_bits=1[^0-9]'
- IMG_SIZE=64K
---
-.13.6

-[Qemu-devel] [PULL 19/29] iotests: Fix 020 for vmdk
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-vmdk cannot work with anything but vmdk backing files, so make the
-backing file be the same format as the overlay.
-Reported-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-11-mreitz@redhat.com
-Reviewed-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/020     | 9 ++++++---
- tests/qemu-iotests/020.out | 6 ++++--
-files changed, 10 insertions(+), 5 deletions(-)
-diff --git a/tests/qemu-iotests/020 b/tests/qemu-iotests/020
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/020
-+++ b/tests/qemu-iotests/020
-@@ -XXX,XX +XXX,XX @@ echo
- echo 'Testing failing commit'
- echo
-+TEST_IMG="$TEST_IMG.base" _make_test_img 1M
-+
- # Create an image with a null backing file to which committing will fail (with
- # ENOSPC so we can distinguish the result from some generic EIO which may be
- # generated anywhere in the block layer)
--_make_test_img -b "json:{'driver': 'raw',
-+_make_test_img -b "json:{'driver': '$IMGFMT',
-                          'file': {
-                              'driver': 'blkdebug',
-                              'inject-error': [{
-@@ -XXX,XX +XXX,XX @@ _make_test_img -b "json:{'driver': 'raw',
-                                  'once': true
-                              }],
-                              'image': {
--                                 'driver': 'null-co'
-+                                 'driver': 'file',
-+                                 'filename': '$TEST_IMG.base'
-                              }}}"
- # Just write anything so committing will not be a no-op
- $QEMU_IO -c 'writev 0 64k' "$TEST_IMG" | _filter_qemu_io
- $QEMU_IMG commit "$TEST_IMG"
--_cleanup_test_img
-+_cleanup
- # success, all done
- echo "*** done"
-diff --git a/tests/qemu-iotests/020.out b/tests/qemu-iotests/020.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/020.out
-+++ b/tests/qemu-iotests/020.out
-@@ -XXX,XX +XXX,XX @@ No errors were found on the image.
- Testing failing commit
--Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 backing_file=json:{'driver': 'raw',,
-+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=1048576
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=json:{'driver': 'IMGFMT',,
-                          'file': {
-                              'driver': 'blkdebug',,
-                              'inject-error': [{
-@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 backing_file=json:{'d
-                                  'once': true
-                              }],,
-                              'image': {
--                                 'driver': 'null-co'
-+                                 'driver': 'file',,
-+                                 'filename': 'TEST_DIR/t.IMGFMT.base'
-                              }}}
- wrote 65536/65536 bytes at offset 0
-KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
---
-.13.6

-[Qemu-devel] [PULL 20/29] iotests: Fix 051 for compat=0.10
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-has both compat=1.1 and compat=0.10 tests (once it uses
-lazy_refcounts, once it tests that setting them does not work).
-For the compat=0.10 tests, it already explicitly creates a suitable
-image.  So let's just ignore the user-specified compat level for the
-lazy_refcounts test and explicitly create a compat=1.1 image there, too.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-12-mreitz@redhat.com
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/051        | 2 ++
- tests/qemu-iotests/051.out    | 1 +
- tests/qemu-iotests/051.pc.out | 1 +
-files changed, 4 insertions(+)
-diff --git a/tests/qemu-iotests/051 b/tests/qemu-iotests/051
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/051
-+++ b/tests/qemu-iotests/051
-@@ -XXX,XX +XXX,XX @@ echo
- echo === Enable and disable lazy refcounting on the command line, plus some invalid values ===
- echo
-+_make_test_img -o compat=1.1 "$size"
-+
- run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=on
- run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=off
- run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=
-diff --git a/tests/qemu-iotests/051.out b/tests/qemu-iotests/051.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/051.out
-+++ b/tests/qemu-iotests/051.out
-@@ -XXX,XX +XXX,XX @@ QEMU_PROG: -drive file=TEST_DIR/t.qcow2,file.backing.driver=qcow2,file.backing.f
- === Enable and disable lazy refcounting on the command line, plus some invalid values ===
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
- Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=on
- QEMU X.Y.Z monitor - type 'help' for more information
- (qemu) quit
-diff --git a/tests/qemu-iotests/051.pc.out b/tests/qemu-iotests/051.pc.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/051.pc.out
-+++ b/tests/qemu-iotests/051.pc.out
-@@ -XXX,XX +XXX,XX @@ QEMU_PROG: -drive file=TEST_DIR/t.qcow2,file.backing.driver=qcow2,file.backing.f
- === Enable and disable lazy refcounting on the command line, plus some invalid values ===
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
- Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=on
- QEMU X.Y.Z monitor - type 'help' for more information
- (qemu) quit
---
-.13.6

-[Qemu-devel] [PULL 21/29] iotests: Fix 059's reference output
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-As of commit 9877860e7bd1e26ee70ab9bb5ebc34c92bf23bf5, vmdk fails
-differently when opening the sample image.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-13-mreitz@redhat.com
-Reviewed-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Fam Zheng <famz@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/059.out | 2 +-
-file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/059.out
-+++ b/tests/qemu-iotests/059.out
-@@ -XXX,XX +XXX,XX @@ Offset          Length          Mapped to       File
-x140000000     0x10000         0x50000         TEST_DIR/t-s003.vmdk
- === Testing afl image with a very large capacity ===
--qemu-img: Can't get image size 'TEST_DIR/afl9.IMGFMT': File too large
-+qemu-img: Could not open 'TEST_DIR/afl9.IMGFMT': Could not open 'TEST_DIR/afl9.IMGFMT': Invalid argument
- *** done
---
-.13.6

-[Qemu-devel] [PULL 22/29] iotests: Fix 067 for compat=0.10
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-works very well with compat=0.10 once you remove format-specific
-information from the QMP output.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-14-mreitz@redhat.com
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/067     |  3 +-
- tests/qemu-iotests/067.out | 97 +++++++++++++---------------------------------
-files changed, 28 insertions(+), 72 deletions(-)
-diff --git a/tests/qemu-iotests/067 b/tests/qemu-iotests/067
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/067
-+++ b/tests/qemu-iotests/067
-@@ -XXX,XX +XXX,XX @@ function run_qemu()
- {
-     do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qmp | _filter_qemu \
-                           | _filter_actual_image_size \
--                          | _filter_generated_node_ids | _filter_qmp_events
-+                          | _filter_generated_node_ids | _filter_qmp_events \
-+                          | _filter_img_info
- }
- size=128M
-diff --git a/tests/qemu-iotests/067.out b/tests/qemu-iotests/067.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/067.out
-+++ b/tests/qemu-iotests/067.out
-@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
- === -drive/-device and device_del ===
--Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk -device virtio-blk,drive=disk,id=virtio0
-+Testing: -drive file=TEST_DIR/t.IMGFMT,format=IMGFMT,if=none,id=disk -device virtio-blk,drive=disk,id=virtio0
- {
-     QMP_VERSION
- }
-@@ -XXX,XX +XXX,XX @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk -device virti
-                 "detect_zeroes": "off",
-                 "image": {
-                     "virtual-size": 134217728,
--                    "filename": "TEST_DIR/t.qcow2",
-+                    "filename": "TEST_DIR/t.IMGFMT",
-                     "cluster-size": 65536,
--                    "format": "qcow2",
-+                    "format": "IMGFMT",
-                     "actual-size": SIZE,
--                    "format-specific": {
--                        "type": "qcow2",
--                        "data": {
--                            "compat": "1.1",
--                            "lazy-refcounts": false,
--                            "refcount-bits": 16,
--                            "corrupt": false
--                        }
--                    },
-                     "dirty-flag": false
-                 },
-                 "iops_wr": 0,
-                 "ro": false,
-                 "node-name": "NODE_NAME",
-                 "backing_file_depth": 0,
--                "drv": "qcow2",
-+                "drv": "IMGFMT",
-                 "iops": 0,
-                 "bps_wr": 0,
-                 "write_threshold": 0,
-@@ -XXX,XX +XXX,XX @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk -device virti
-                     "direct": false,
-                     "writeback": true
-                 },
--                "file": "TEST_DIR/t.qcow2",
-+                "file": "TEST_DIR/t.IMGFMT",
-                 "encryption_key_missing": false
-             },
-             "qdev": "/machine/peripheral/virtio0/virtio-backend",
-@@ -XXX,XX +XXX,XX @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk -device virti
- === -drive/device_add and device_del ===
--Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk
-+Testing: -drive file=TEST_DIR/t.IMGFMT,format=IMGFMT,if=none,id=disk
- {
-     QMP_VERSION
- }
-@@ -XXX,XX +XXX,XX @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk
-                 "detect_zeroes": "off",
-                 "image": {
-                     "virtual-size": 134217728,
--                    "filename": "TEST_DIR/t.qcow2",
-+                    "filename": "TEST_DIR/t.IMGFMT",
-                     "cluster-size": 65536,
--                    "format": "qcow2",
-+                    "format": "IMGFMT",
-                     "actual-size": SIZE,
--                    "format-specific": {
--                        "type": "qcow2",
--                        "data": {
--                            "compat": "1.1",
--                            "lazy-refcounts": false,
--                            "refcount-bits": 16,
--                            "corrupt": false
--                        }
--                    },
-                     "dirty-flag": false
-                 },
-                 "iops_wr": 0,
-                 "ro": false,
-                 "node-name": "NODE_NAME",
-                 "backing_file_depth": 0,
--                "drv": "qcow2",
-+                "drv": "IMGFMT",
-                 "iops": 0,
-                 "bps_wr": 0,
-                 "write_threshold": 0,
-@@ -XXX,XX +XXX,XX @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk
-                     "direct": false,
-                     "writeback": true
-                 },
--                "file": "TEST_DIR/t.qcow2",
-+                "file": "TEST_DIR/t.IMGFMT",
-                 "encryption_key_missing": false
-             },
-             "type": "unknown"
-@@ -XXX,XX +XXX,XX @@ Testing:
-                 "detect_zeroes": "off",
-                 "image": {
-                     "virtual-size": 134217728,
--                    "filename": "TEST_DIR/t.qcow2",
-+                    "filename": "TEST_DIR/t.IMGFMT",
-                     "cluster-size": 65536,
--                    "format": "qcow2",
-+                    "format": "IMGFMT",
-                     "actual-size": SIZE,
--                    "format-specific": {
--                        "type": "qcow2",
--                        "data": {
--                            "compat": "1.1",
--                            "lazy-refcounts": false,
--                            "refcount-bits": 16,
--                            "corrupt": false
--                        }
--                    },
-                     "dirty-flag": false
-                 },
-                 "iops_wr": 0,
-                 "ro": false,
-                 "node-name": "NODE_NAME",
-                 "backing_file_depth": 0,
--                "drv": "qcow2",
-+                "drv": "IMGFMT",
-                 "iops": 0,
-                 "bps_wr": 0,
-                 "write_threshold": 0,
-@@ -XXX,XX +XXX,XX @@ Testing:
-                     "direct": false,
-                     "writeback": true
-                 },
--                "file": "TEST_DIR/t.qcow2",
-+                "file": "TEST_DIR/t.IMGFMT",
-                 "encryption_key_missing": false
-             },
-             "type": "unknown"
-@@ -XXX,XX +XXX,XX @@ Testing:
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 134217728,
--                "filename": "TEST_DIR/t.qcow2",
-+                "filename": "TEST_DIR/t.IMGFMT",
-                 "cluster-size": 65536,
--                "format": "qcow2",
-+                "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "qcow2",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
-                 "dirty-flag": false
-             },
-             "iops_wr": 0,
-             "ro": false,
-             "node-name": "disk",
-             "backing_file_depth": 0,
--            "drv": "qcow2",
-+            "drv": "IMGFMT",
-             "iops": 0,
-             "bps_wr": 0,
-             "write_threshold": 0,
-@@ -XXX,XX +XXX,XX @@ Testing:
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2",
-+            "file": "TEST_DIR/t.IMGFMT",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ Testing:
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 197120,
--                "filename": "TEST_DIR/t.qcow2",
-+                "filename": "TEST_DIR/t.IMGFMT",
-                 "format": "file",
-                 "actual-size": SIZE,
-                 "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ Testing:
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2",
-+            "file": "TEST_DIR/t.IMGFMT",
-             "encryption_key_missing": false
-         }
-     ]
-@@ -XXX,XX +XXX,XX @@ Testing:
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 134217728,
--                "filename": "TEST_DIR/t.qcow2",
-+                "filename": "TEST_DIR/t.IMGFMT",
-                 "cluster-size": 65536,
--                "format": "qcow2",
-+                "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "qcow2",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
-                 "dirty-flag": false
-             },
-             "iops_wr": 0,
-             "ro": false,
-             "node-name": "disk",
-             "backing_file_depth": 0,
--            "drv": "qcow2",
-+            "drv": "IMGFMT",
-             "iops": 0,
-             "bps_wr": 0,
-             "write_threshold": 0,
-@@ -XXX,XX +XXX,XX @@ Testing:
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2",
-+            "file": "TEST_DIR/t.IMGFMT",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ Testing:
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 197120,
--                "filename": "TEST_DIR/t.qcow2",
-+                "filename": "TEST_DIR/t.IMGFMT",
-                 "format": "file",
-                 "actual-size": SIZE,
-                 "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ Testing:
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2",
-+            "file": "TEST_DIR/t.IMGFMT",
-             "encryption_key_missing": false
-         }
-     ]
---
-.13.6

-[Qemu-devel] [PULL 23/29] iotests: Make 089 compatible with compat=0.10
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-The only thing that is missing is a _filter_img_info after the
-"$QEMU_IO -c info" invocations.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-15-mreitz@redhat.com
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/089     |  4 ++--
- tests/qemu-iotests/089.out | 10 ----------
-files changed, 2 insertions(+), 12 deletions(-)
-diff --git a/tests/qemu-iotests/089 b/tests/qemu-iotests/089
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/089
-+++ b/tests/qemu-iotests/089
-@@ -XXX,XX +XXX,XX @@ echo
- # Both options given directly and those given in the filename should be used
- $QEMU_IO -c "open -o driver=qcow2 json:{\"file.filename\":\"$TEST_IMG\"}" \
--         -c "info" 2>&1 | _filter_testdir | _filter_imgfmt
-+         -c "info" 2>&1 | _filter_img_info
- # Options given directly should be prioritized over those given in the filename
- $QEMU_IO -c "open -o driver=qcow2 json:{\"driver\":\"raw\",\"file.filename\":\"$TEST_IMG\"}" \
--         -c "info" 2>&1 | _filter_testdir | _filter_imgfmt
-+         -c "info" 2>&1 | _filter_img_info
- # success, all done
-diff --git a/tests/qemu-iotests/089.out b/tests/qemu-iotests/089.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/089.out
-+++ b/tests/qemu-iotests/089.out
-@@ -XXX,XX +XXX,XX @@ cluster_size: 65536
- format name: IMGFMT
- cluster size: 64 KiB
- vm state offset: 512 MiB
--Format specific information:
--    compat: 1.1
--    lazy refcounts: false
--    refcount bits: 16
--    corrupt: false
- format name: IMGFMT
- cluster size: 64 KiB
- vm state offset: 512 MiB
--Format specific information:
--    compat: 1.1
--    lazy refcounts: false
--    refcount bits: 16
--    corrupt: false
- *** done
---
-.13.6

-[Qemu-devel] [PULL 24/29] iotests: Make 184 image-less
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-does not need an image, so don't use one.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-16-mreitz@redhat.com
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/184     | 25 ++++--------------
- tests/qemu-iotests/184.out | 63 +++++++---------------------------------------
-files changed, 14 insertions(+), 74 deletions(-)
-diff --git a/tests/qemu-iotests/184 b/tests/qemu-iotests/184
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/184
-+++ b/tests/qemu-iotests/184
-@@ -XXX,XX +XXX,XX @@ echo "QA output created by $seq"
- here=`pwd`
- status=1    # failure is the default!
--_cleanup()
--{
--    _cleanup_test_img
--}
--trap "_cleanup; exit \$status" 0 1 2 3 15
-+trap "exit \$status" 0 1 2 3 15
- # get standard environment, filters and checks
- . ./common.rc
- . ./common.filter
--_supported_fmt qcow2
--_supported_proto file
- _supported_os Linux
- function do_run_qemu()
-@@ -XXX,XX +XXX,XX @@ function run_qemu()
-                           | _filter_actual_image_size
- }
--_make_test_img 64M
- test_throttle=$($QEMU_IMG --help|grep throttle)
- [ "$test_throttle" = "" ] && _supported_fmt throttle
-@@ -XXX,XX +XXX,XX @@ run_qemu <<EOF
- { "execute": "qmp_capabilities" }
- { "execute": "blockdev-add",
-   "arguments": {
--    "driver": "$IMGFMT",
--    "node-name": "disk0",
--    "file": {
--      "driver": "file",
--      "filename": "$TEST_IMG"
--    }
-+    "driver": "null-co",
-+    "node-name": "disk0"
-   }
- }
- { "execute": "object-add",
-@@ -XXX,XX +XXX,XX @@ run_qemu <<EOF
- { "execute": "qmp_capabilities" }
- { "execute": "blockdev-add",
-   "arguments": {
--    "driver": "$IMGFMT",
--    "node-name": "disk0",
--    "file": {
--      "driver": "file",
--      "filename": "$TEST_IMG"
--    }
-+    "driver": "null-co",
-+    "node-name": "disk0"
-   }
- }
- { "execute": "blockdev-add",
-diff --git a/tests/qemu-iotests/184.out b/tests/qemu-iotests/184.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/184.out
-+++ b/tests/qemu-iotests/184.out
-@@ -XXX,XX +XXX,XX @@
- QA output created by 184
--Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
- == checking interface ==
- Testing:
-@@ -XXX,XX +XXX,XX @@ Testing:
-             "iops_rd": 0,
-             "detect_zeroes": "off",
-             "image": {
--                "virtual-size": 67108864,
--                "filename": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"qcow2\", \"file\": {\"driver\": \"file\", \"filename\": \"TEST_DIR/t.qcow2\"}}}",
--                "cluster-size": 65536,
--                "format": "throttle",
--                "actual-size": SIZE,
--                "dirty-flag": false
-+                "virtual-size": 1073741824,
-+                "filename": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"null-co\"}}",
-+                "format": "throttle"
-             },
-             "iops_wr": 0,
-             "ro": false,
-@@ -XXX,XX +XXX,XX @@ Testing:
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"qcow2\", \"file\": {\"driver\": \"file\", \"filename\": \"TEST_DIR/t.qcow2\"}}}",
-+            "file": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"null-co\"}}",
-             "encryption_key_missing": false
-         },
-         {
-             "iops_rd": 0,
-             "detect_zeroes": "off",
-             "image": {
--                "virtual-size": 67108864,
--                "filename": "TEST_DIR/t.qcow2",
--                "cluster-size": 65536,
--                "format": "qcow2",
--                "actual-size": SIZE,
--                "format-specific": {
--                    "type": "qcow2",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
--                "dirty-flag": false
-+                "virtual-size": 1073741824,
-+                "filename": "null-co://",
-+                "format": "null-co"
-             },
-             "iops_wr": 0,
-             "ro": false,
-             "node-name": "disk0",
-             "backing_file_depth": 0,
--            "drv": "qcow2",
-+            "drv": "null-co",
-             "iops": 0,
-             "bps_wr": 0,
-             "write_threshold": 0,
-@@ -XXX,XX +XXX,XX @@ Testing:
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2",
--            "encryption_key_missing": false
--        },
--        {
--            "iops_rd": 0,
--            "detect_zeroes": "off",
--            "image": {
--                "virtual-size": 197120,
--                "filename": "TEST_DIR/t.qcow2",
--                "format": "file",
--                "actual-size": SIZE,
--                "dirty-flag": false
--            },
--            "iops_wr": 0,
--            "ro": false,
--            "node-name": "NODE_NAME",
--            "backing_file_depth": 0,
--            "drv": "file",
--            "iops": 0,
--            "bps_wr": 0,
--            "write_threshold": 0,
--            "encrypted": false,
--            "bps": 0,
--            "bps_rd": 0,
--            "cache": {
--                "no-flush": false,
--                "direct": false,
--                "writeback": true
--            },
--            "file": "TEST_DIR/t.qcow2",
-+            "file": "null-co://",
-             "encryption_key_missing": false
-         }
-     ]
---
-.13.6

-[Qemu-devel] [PULL 25/29] iotests: Make 191 work with qcow2 options
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-In order for 191 to work with an explicit refcount_bits or compat=0.10,
-we should strip format-specific information from the output--and we can
-do so by using _filter_img_info.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-17-mreitz@redhat.com
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/191     |   5 +-
- tests/qemu-iotests/191.out | 313 +++++++++++++--------------------------------
-files changed, 91 insertions(+), 227 deletions(-)
-diff --git a/tests/qemu-iotests/191 b/tests/qemu-iotests/191
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/191
-+++ b/tests/qemu-iotests/191
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
- . ./common.qemu
- _supported_fmt qcow2
--_unsupported_imgopts compat=0.10
- _supported_proto file
- _supported_os Linux
-@@ -XXX,XX +XXX,XX @@ echo === Check that both top and top2 point to base now ===
- echo
- _send_qemu_cmd $h "{ 'execute': 'query-named-block-nodes' }" "^}" |
--    _filter_generated_node_ids | _filter_actual_image_size
-+    _filter_generated_node_ids | _filter_actual_image_size | _filter_img_info
- _send_qemu_cmd $h "{ 'execute': 'quit' }" "^}"
- wait=1 _cleanup_qemu
-@@ -XXX,XX +XXX,XX @@ echo === Check that both top and top2 point to base now ===
- echo
- _send_qemu_cmd $h "{ 'execute': 'query-named-block-nodes' }" "^}" |
--    _filter_generated_node_ids | _filter_actual_image_size
-+    _filter_generated_node_ids | _filter_actual_image_size | _filter_img_info
- _send_qemu_cmd $h "{ 'execute': 'quit' }" "^}"
- wait=1 _cleanup_qemu
-diff --git a/tests/qemu-iotests/191.out b/tests/qemu-iotests/191.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/191.out
-+++ b/tests/qemu-iotests/191.out
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "image": {
-                 "backing-image": {
-                     "virtual-size": 67108864,
--                    "filename": "TEST_DIR/t.qcow2.base",
-+                    "filename": "TEST_DIR/t.IMGFMT.base",
-                     "cluster-size": 65536,
--                    "format": "qcow2",
-+                    "format": "IMGFMT",
-                     "actual-size": SIZE,
--                    "format-specific": {
--                        "type": "qcow2",
--                        "data": {
--                            "compat": "1.1",
--                            "lazy-refcounts": false,
--                            "refcount-bits": 16,
--                            "corrupt": false
--                        }
--                    },
-                     "dirty-flag": false
-                 },
--                "backing-filename-format": "qcow2",
-+                "backing-filename-format": "IMGFMT",
-                 "virtual-size": 67108864,
--                "filename": "TEST_DIR/t.qcow2.ovl2",
-+                "filename": "TEST_DIR/t.IMGFMT.ovl2",
-                 "cluster-size": 65536,
--                "format": "qcow2",
-+                "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "qcow2",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
--                "full-backing-filename": "TEST_DIR/t.qcow2.base",
--                "backing-filename": "TEST_DIR/t.qcow2.base",
-+                "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
-+                "backing-filename": "TEST_DIR/t.IMGFMT.base",
-                 "dirty-flag": false
-             },
-             "iops_wr": 0,
-             "ro": false,
-             "node-name": "top2",
-             "backing_file_depth": 1,
--            "drv": "qcow2",
-+            "drv": "IMGFMT",
-             "iops": 0,
-             "bps_wr": 0,
-             "write_threshold": 0,
--            "backing_file": "TEST_DIR/t.qcow2.base",
-+            "backing_file": "TEST_DIR/t.IMGFMT.base",
-             "encrypted": false,
-             "bps": 0,
-             "bps_rd": 0,
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.ovl2",
-+            "file": "TEST_DIR/t.IMGFMT.ovl2",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 197120,
--                "filename": "TEST_DIR/t.qcow2.ovl2",
-+                "filename": "TEST_DIR/t.IMGFMT.ovl2",
-                 "format": "file",
-                 "actual-size": SIZE,
-                 "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.ovl2",
-+            "file": "TEST_DIR/t.IMGFMT.ovl2",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "image": {
-                 "backing-image": {
-                     "virtual-size": 67108864,
--                    "filename": "TEST_DIR/t.qcow2.base",
-+                    "filename": "TEST_DIR/t.IMGFMT.base",
-                     "cluster-size": 65536,
--                    "format": "qcow2",
-+                    "format": "IMGFMT",
-                     "actual-size": SIZE,
--                    "format-specific": {
--                        "type": "qcow2",
--                        "data": {
--                            "compat": "1.1",
--                            "lazy-refcounts": false,
--                            "refcount-bits": 16,
--                            "corrupt": false
--                        }
--                    },
-                     "dirty-flag": false
-                 },
--                "backing-filename-format": "qcow2",
-+                "backing-filename-format": "IMGFMT",
-                 "virtual-size": 67108864,
--                "filename": "TEST_DIR/t.qcow2",
-+                "filename": "TEST_DIR/t.IMGFMT",
-                 "cluster-size": 65536,
--                "format": "qcow2",
-+                "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "qcow2",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
--                "full-backing-filename": "TEST_DIR/t.qcow2.base",
--                "backing-filename": "TEST_DIR/t.qcow2.base",
-+                "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
-+                "backing-filename": "TEST_DIR/t.IMGFMT.base",
-                 "dirty-flag": false
-             },
-             "iops_wr": 0,
-             "ro": false,
-             "node-name": "top",
-             "backing_file_depth": 1,
--            "drv": "qcow2",
-+            "drv": "IMGFMT",
-             "iops": 0,
-             "bps_wr": 0,
-             "write_threshold": 0,
--            "backing_file": "TEST_DIR/t.qcow2.base",
-+            "backing_file": "TEST_DIR/t.IMGFMT.base",
-             "encrypted": false,
-             "bps": 0,
-             "bps_rd": 0,
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2",
-+            "file": "TEST_DIR/t.IMGFMT",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 197120,
--                "filename": "TEST_DIR/t.qcow2",
-+                "filename": "TEST_DIR/t.IMGFMT",
-                 "format": "file",
-                 "actual-size": SIZE,
-                 "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2",
-+            "file": "TEST_DIR/t.IMGFMT",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "image": {
-                 "backing-image": {
-                     "virtual-size": 67108864,
--                    "filename": "TEST_DIR/t.qcow2.base",
-+                    "filename": "TEST_DIR/t.IMGFMT.base",
-                     "cluster-size": 65536,
--                    "format": "qcow2",
-+                    "format": "IMGFMT",
-                     "actual-size": SIZE,
--                    "format-specific": {
--                        "type": "qcow2",
--                        "data": {
--                            "compat": "1.1",
--                            "lazy-refcounts": false,
--                            "refcount-bits": 16,
--                            "corrupt": false
--                        }
--                    },
-                     "dirty-flag": false
-                 },
--                "backing-filename-format": "qcow2",
-+                "backing-filename-format": "IMGFMT",
-                 "virtual-size": 67108864,
--                "filename": "TEST_DIR/t.qcow2.mid",
-+                "filename": "TEST_DIR/t.IMGFMT.mid",
-                 "cluster-size": 65536,
--                "format": "qcow2",
-+                "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "qcow2",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
--                "full-backing-filename": "TEST_DIR/t.qcow2.base",
--                "backing-filename": "TEST_DIR/t.qcow2.base",
-+                "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
-+                "backing-filename": "TEST_DIR/t.IMGFMT.base",
-                 "dirty-flag": false
-             },
-             "iops_wr": 0,
-             "ro": false,
-             "node-name": "mid",
-             "backing_file_depth": 1,
--            "drv": "qcow2",
-+            "drv": "IMGFMT",
-             "iops": 0,
-             "bps_wr": 0,
-             "write_threshold": 0,
--            "backing_file": "TEST_DIR/t.qcow2.base",
-+            "backing_file": "TEST_DIR/t.IMGFMT.base",
-             "encrypted": false,
-             "bps": 0,
-             "bps_rd": 0,
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.mid",
-+            "file": "TEST_DIR/t.IMGFMT.mid",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 393216,
--                "filename": "TEST_DIR/t.qcow2.mid",
-+                "filename": "TEST_DIR/t.IMGFMT.mid",
-                 "format": "file",
-                 "actual-size": SIZE,
-                 "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.mid",
-+            "file": "TEST_DIR/t.IMGFMT.mid",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 67108864,
--                "filename": "TEST_DIR/t.qcow2.base",
-+                "filename": "TEST_DIR/t.IMGFMT.base",
-                 "cluster-size": 65536,
--                "format": "qcow2",
-+                "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "qcow2",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
-                 "dirty-flag": false
-             },
-             "iops_wr": 0,
-             "ro": false,
-             "node-name": "base",
-             "backing_file_depth": 0,
--            "drv": "qcow2",
-+            "drv": "IMGFMT",
-             "iops": 0,
-             "bps_wr": 0,
-             "write_threshold": 0,
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.base",
-+            "file": "TEST_DIR/t.IMGFMT.base",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 393216,
--                "filename": "TEST_DIR/t.qcow2.base",
-+                "filename": "TEST_DIR/t.IMGFMT.base",
-                 "format": "file",
-                 "actual-size": SIZE,
-                 "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.base",
-+            "file": "TEST_DIR/t.IMGFMT.base",
-             "encryption_key_missing": false
-         }
-     ]
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "image": {
-                 "backing-image": {
-                     "virtual-size": 67108864,
--                    "filename": "TEST_DIR/t.qcow2.base",
-+                    "filename": "TEST_DIR/t.IMGFMT.base",
-                     "cluster-size": 65536,
--                    "format": "qcow2",
-+                    "format": "IMGFMT",
-                     "actual-size": SIZE,
--                    "format-specific": {
--                        "type": "qcow2",
--                        "data": {
--                            "compat": "1.1",
--                            "lazy-refcounts": false,
--                            "refcount-bits": 16,
--                            "corrupt": false
--                        }
--                    },
-                     "dirty-flag": false
-                 },
--                "backing-filename-format": "qcow2",
-+                "backing-filename-format": "IMGFMT",
-                 "virtual-size": 67108864,
--                "filename": "TEST_DIR/t.qcow2.ovl2",
-+                "filename": "TEST_DIR/t.IMGFMT.ovl2",
-                 "cluster-size": 65536,
--                "format": "qcow2",
-+                "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "qcow2",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
--                "full-backing-filename": "TEST_DIR/t.qcow2.base",
--                "backing-filename": "TEST_DIR/t.qcow2.base",
-+                "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
-+                "backing-filename": "TEST_DIR/t.IMGFMT.base",
-                 "dirty-flag": false
-             },
-             "iops_wr": 0,
-             "ro": true,
-             "node-name": "NODE_NAME",
-             "backing_file_depth": 1,
--            "drv": "qcow2",
-+            "drv": "IMGFMT",
-             "iops": 0,
-             "bps_wr": 0,
-             "write_threshold": 0,
--            "backing_file": "TEST_DIR/t.qcow2.base",
-+            "backing_file": "TEST_DIR/t.IMGFMT.base",
-             "encrypted": false,
-             "bps": 0,
-             "bps_rd": 0,
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.ovl2",
-+            "file": "TEST_DIR/t.IMGFMT.ovl2",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 197120,
--                "filename": "TEST_DIR/t.qcow2.ovl2",
-+                "filename": "TEST_DIR/t.IMGFMT.ovl2",
-                 "format": "file",
-                 "actual-size": SIZE,
-                 "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.ovl2",
-+            "file": "TEST_DIR/t.IMGFMT.ovl2",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "backing-image": {
-                     "backing-image": {
-                         "virtual-size": 67108864,
--                        "filename": "TEST_DIR/t.qcow2.base",
-+                        "filename": "TEST_DIR/t.IMGFMT.base",
-                         "cluster-size": 65536,
--                        "format": "qcow2",
-+                        "format": "IMGFMT",
-                         "actual-size": SIZE,
--                        "format-specific": {
--                            "type": "qcow2",
--                            "data": {
--                                "compat": "1.1",
--                                "lazy-refcounts": false,
--                                "refcount-bits": 16,
--                                "corrupt": false
--                            }
--                        },
-                         "dirty-flag": false
-                     },
--                    "backing-filename-format": "qcow2",
-+                    "backing-filename-format": "IMGFMT",
-                     "virtual-size": 67108864,
--                    "filename": "TEST_DIR/t.qcow2.ovl2",
-+                    "filename": "TEST_DIR/t.IMGFMT.ovl2",
-                     "cluster-size": 65536,
--                    "format": "qcow2",
-+                    "format": "IMGFMT",
-                     "actual-size": SIZE,
--                    "format-specific": {
--                        "type": "qcow2",
--                        "data": {
--                            "compat": "1.1",
--                            "lazy-refcounts": false,
--                            "refcount-bits": 16,
--                            "corrupt": false
--                        }
--                    },
--                    "full-backing-filename": "TEST_DIR/t.qcow2.base",
--                    "backing-filename": "TEST_DIR/t.qcow2.base",
-+                    "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
-+                    "backing-filename": "TEST_DIR/t.IMGFMT.base",
-                     "dirty-flag": false
-                 },
--                "backing-filename-format": "qcow2",
-+                "backing-filename-format": "IMGFMT",
-                 "virtual-size": 67108864,
--                "filename": "TEST_DIR/t.qcow2.ovl3",
-+                "filename": "TEST_DIR/t.IMGFMT.ovl3",
-                 "cluster-size": 65536,
--                "format": "qcow2",
-+                "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "qcow2",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
--                "full-backing-filename": "TEST_DIR/t.qcow2.ovl2",
--                "backing-filename": "TEST_DIR/t.qcow2.ovl2",
-+                "full-backing-filename": "TEST_DIR/t.IMGFMT.ovl2",
-+                "backing-filename": "TEST_DIR/t.IMGFMT.ovl2",
-                 "dirty-flag": false
-             },
-             "iops_wr": 0,
-             "ro": false,
-             "node-name": "top2",
-             "backing_file_depth": 2,
--            "drv": "qcow2",
-+            "drv": "IMGFMT",
-             "iops": 0,
-             "bps_wr": 0,
-             "write_threshold": 0,
--            "backing_file": "TEST_DIR/t.qcow2.ovl2",
-+            "backing_file": "TEST_DIR/t.IMGFMT.ovl2",
-             "encrypted": false,
-             "bps": 0,
-             "bps_rd": 0,
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.ovl3",
-+            "file": "TEST_DIR/t.IMGFMT.ovl3",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 197120,
--                "filename": "TEST_DIR/t.qcow2.ovl3",
-+                "filename": "TEST_DIR/t.IMGFMT.ovl3",
-                 "format": "file",
-                 "actual-size": SIZE,
-                 "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.ovl3",
-+            "file": "TEST_DIR/t.IMGFMT.ovl3",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 67108864,
--                "filename": "TEST_DIR/t.qcow2.base",
-+                "filename": "TEST_DIR/t.IMGFMT.base",
-                 "cluster-size": 65536,
--                "format": "qcow2",
-+                "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "qcow2",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
-                 "dirty-flag": false
-             },
-             "iops_wr": 0,
-             "ro": true,
-             "node-name": "NODE_NAME",
-             "backing_file_depth": 0,
--            "drv": "qcow2",
-+            "drv": "IMGFMT",
-             "iops": 0,
-             "bps_wr": 0,
-             "write_threshold": 0,
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.base",
-+            "file": "TEST_DIR/t.IMGFMT.base",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 393216,
--                "filename": "TEST_DIR/t.qcow2.base",
-+                "filename": "TEST_DIR/t.IMGFMT.base",
-                 "format": "file",
-                 "actual-size": SIZE,
-                 "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2.base",
-+            "file": "TEST_DIR/t.IMGFMT.base",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "image": {
-                 "backing-image": {
-                     "virtual-size": 67108864,
--                    "filename": "TEST_DIR/t.qcow2.base",
-+                    "filename": "TEST_DIR/t.IMGFMT.base",
-                     "cluster-size": 65536,
--                    "format": "qcow2",
-+                    "format": "IMGFMT",
-                     "actual-size": SIZE,
--                    "format-specific": {
--                        "type": "qcow2",
--                        "data": {
--                            "compat": "1.1",
--                            "lazy-refcounts": false,
--                            "refcount-bits": 16,
--                            "corrupt": false
--                        }
--                    },
-                     "dirty-flag": false
-                 },
--                "backing-filename-format": "qcow2",
-+                "backing-filename-format": "IMGFMT",
-                 "virtual-size": 67108864,
--                "filename": "TEST_DIR/t.qcow2",
-+                "filename": "TEST_DIR/t.IMGFMT",
-                 "cluster-size": 65536,
--                "format": "qcow2",
-+                "format": "IMGFMT",
-                 "actual-size": SIZE,
--                "format-specific": {
--                    "type": "qcow2",
--                    "data": {
--                        "compat": "1.1",
--                        "lazy-refcounts": false,
--                        "refcount-bits": 16,
--                        "corrupt": false
--                    }
--                },
--                "full-backing-filename": "TEST_DIR/t.qcow2.base",
--                "backing-filename": "TEST_DIR/t.qcow2.base",
-+                "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
-+                "backing-filename": "TEST_DIR/t.IMGFMT.base",
-                 "dirty-flag": false
-             },
-             "iops_wr": 0,
-             "ro": false,
-             "node-name": "top",
-             "backing_file_depth": 1,
--            "drv": "qcow2",
-+            "drv": "IMGFMT",
-             "iops": 0,
-             "bps_wr": 0,
-             "write_threshold": 0,
--            "backing_file": "TEST_DIR/t.qcow2.base",
-+            "backing_file": "TEST_DIR/t.IMGFMT.base",
-             "encrypted": false,
-             "bps": 0,
-             "bps_rd": 0,
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2",
-+            "file": "TEST_DIR/t.IMGFMT",
-             "encryption_key_missing": false
-         },
-         {
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-             "detect_zeroes": "off",
-             "image": {
-                 "virtual-size": 197120,
--                "filename": "TEST_DIR/t.qcow2",
-+                "filename": "TEST_DIR/t.IMGFMT",
-                 "format": "file",
-                 "actual-size": SIZE,
-                 "dirty-flag": false
-@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
-                 "direct": false,
-                 "writeback": true
-             },
--            "file": "TEST_DIR/t.qcow2",
-+            "file": "TEST_DIR/t.IMGFMT",
-             "encryption_key_missing": false
-         }
-     ]
---
-.13.6

-[Qemu-devel] [PULL 26/29] iotests: Filter compat-dependent info in 198
+Deleted patch
-From: Max Reitz <mreitz@redhat.com>
-There is a bit of image-specific information which depends on the qcow2
-compat level.  Filter it so that 198 works with compat=0.10 (and any
-refcount_bits value).
-Note that we cannot simply drop the --format-specific switch because we
-do need the "encrypt" information.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Message-id: 20171123020832.8165-18-mreitz@redhat.com
-Reviewed-by: John Snow <jsnow@redhat.com>
-Signed-off-by: Max Reitz <mreitz@redhat.com>
----
- tests/qemu-iotests/198     | 6 ++++--
- tests/qemu-iotests/198.out | 8 --------
-files changed, 4 insertions(+), 10 deletions(-)
-diff --git a/tests/qemu-iotests/198 b/tests/qemu-iotests/198
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/198
-+++ b/tests/qemu-iotests/198
-@@ -XXX,XX +XXX,XX @@ $QEMU_IO --object $SECRET0 --object $SECRET1 -c "read -P 0x9 0 $size" --image-op
- echo
- echo "== checking image base =="
- $QEMU_IMG info --image-opts $IMGSPECBASE | _filter_img_info --format-specific \
--    | sed -e "/^disk size:/ D"
-+    | sed -e "/^disk size:/ D" -e '/refcount bits:/ D' -e '/compat:/ D' \
-+          -e '/lazy refcounts:/ D' -e '/corrupt:/ D'
- echo
- echo "== checking image layer =="
- $QEMU_IMG info --image-opts $IMGSPECLAYER | _filter_img_info --format-specific \
--    | sed -e "/^disk size:/ D"
-+    | sed -e "/^disk size:/ D" -e '/refcount bits:/ D' -e '/compat:/ D' \
-+          -e '/lazy refcounts:/ D' -e '/corrupt:/ D'
- # success, all done
-diff --git a/tests/qemu-iotests/198.out b/tests/qemu-iotests/198.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/198.out
-+++ b/tests/qemu-iotests/198.out
-@@ -XXX,XX +XXX,XX @@ image: json:{"encrypt.key-secret": "sec0", "driver": "IMGFMT", "file": {"driver"
- file format: IMGFMT
- virtual size: 16M (16777216 bytes)
- Format specific information:
--    compat: 1.1
--    lazy refcounts: false
--    refcount bits: 16
-     encrypt:
-         ivgen alg: plain64
-         hash alg: sha256
-@@ -XXX,XX +XXX,XX @@ Format specific information:
-                 key offset: 1810432
-         payload offset: 2068480
-         master key iters: 1024
--    corrupt: false
- == checking image layer ==
- image: json:{"encrypt.key-secret": "sec1", "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}}
-@@ -XXX,XX +XXX,XX @@ file format: IMGFMT
- virtual size: 16M (16777216 bytes)
- backing file: TEST_DIR/t.IMGFMT.base
- Format specific information:
--    compat: 1.1
--    lazy refcounts: false
--    refcount bits: 16
-     encrypt:
-         ivgen alg: plain64
-         hash alg: sha256
-@@ -XXX,XX +XXX,XX @@ Format specific information:
-                 key offset: 1810432
-         payload offset: 2068480
-         master key iters: 1024
--    corrupt: false
- *** done
---
-.13.6

The following changes since commit ee86981bda9ecd40c8daf81b7307b1d2aff68174:

migration: Revert postcopy-blocktime commit set (2018-01-23 10:08:05 +0000)

are available in the git repository at:

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

for you to fetch changes up to 8c0c5e636e6b11eaf0556be31fceb68e0baff310:

Merge remote-tracking branch 'mreitz/tags/pull-block-2018-01-23' into queue-block (2018-01-23 12:40:46 +0100)

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

----------------------------------------------------------------
Daniel Henrique Barboza (1):
      tests/qemu-iotests: adding savevm/loadvm with postcopy flag test

Eric Blake (1):
      iotests: Split 177 into two parts for compat=0.10

Fam Zheng (1):
      osdep: Retry SETLK upon EINTR

Hikaru Nishida (1):
      hw/block: Fix pin-based interrupt behaviour of NVMe

Kevin Wolf (2):
      tests/.gitignore: Add test-bdrv-drain
      Merge remote-tracking branch 'mreitz/tags/pull-block-2018-01-23' into queue-block

Max Reitz (24):
      qcow2: Repair unaligned preallocated zero clusters
      iotests: Make BD-{remove,insert}-medium use @id
      tests/ahci: Switch tray and medium commands to @id
      blockdev: Drop BD-{remove,insert}-medium's @device
      blockdev: Mark BD-{remove,insert}-medium stable
      qemu-iotests: Fix locking issue in 102
      block/vmdk: Fix , instead of ; at end of line
      qcow2: No persistent dirty bitmaps for compat=0.10
      block/qcow: Add blkdebug events
      block/vmdk: Add blkdebug events
      iotests: Fix _img_info for backslashes
      iotests: Drop format-specific in _filter_img_info
      iotests: Forbid 020 for non-file protocols
      iotests: Skip 103 for refcount_bits=1
      iotests: Fix 020 for vmdk
      iotests: Fix 051 for compat=0.10
      iotests: Fix 059's reference output
      iotests: Fix 067 for compat=0.10
      iotests: Make 089 compatible with compat=0.10
      iotests: Make 184 image-less
      iotests: Make 191 work with qcow2 options
      iotests: Filter compat-dependent info in 198
      iotests: Make 059 pass on machines with little RAM
      iotests: Disable some tests for compat=0.10

From: Hikaru Nishida <hikarupsp@gmail.com>

Pin-based interrupt of NVMe controller did not work properly
because using an obsolated function pci_irq_pulse().
To fix this, change to use pci_irq_assert() / pci_irq_deassert()
instead of pci_irq_pulse().

Signed-off-by: Hikaru Nishida <hikarupsp@gmail.com>
Reviewed-by: Keith Busch <keith.busch@intel.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 hw/block/nvme.h |  1 +
 hw/block/nvme.c | 39 ++++++++++++++++++++++++++++++++++-----
 2 files changed, 35 insertions(+), 5 deletions(-)

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 {
     uint32_t    cmbsz;
     uint32_t    cmbloc;
     uint8_t     *cmbuf;
+    uint64_t    irq_status;
 
     char            *serial;
     NvmeNamespace   *namespaces;
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 @@ static uint8_t nvme_sq_empty(NvmeSQueue *sq)
     return sq->head == sq->tail;
 }
 
-static void nvme_isr_notify(NvmeCtrl *n, NvmeCQueue *cq)
+static void nvme_irq_check(NvmeCtrl *n)
+{
+    if (msix_enabled(&(n->parent_obj))) {
+        return;
+    }
+    if (~n->bar.intms & n->irq_status) {
+        pci_irq_assert(&n->parent_obj);
+    } else {
+        pci_irq_deassert(&n->parent_obj);
+    }
+}
+
+static void nvme_irq_assert(NvmeCtrl *n, NvmeCQueue *cq)
 {
     if (cq->irq_enabled) {
         if (msix_enabled(&(n->parent_obj))) {
@@ -XXX,XX +XXX,XX @@ static void nvme_isr_notify(NvmeCtrl *n, NvmeCQueue *cq)
             msix_notify(&(n->parent_obj), cq->vector);
         } else {
             trace_nvme_irq_pin();
-            pci_irq_pulse(&n->parent_obj);
+            assert(cq->cqid < 64);
+            n->irq_status |= 1 << cq->cqid;
+            nvme_irq_check(n);
         }
     } else {
         trace_nvme_irq_masked();
     }
 }
 
+static void nvme_irq_deassert(NvmeCtrl *n, NvmeCQueue *cq)
+{
+    if (cq->irq_enabled) {
+        if (msix_enabled(&(n->parent_obj))) {
+            return;
+        } else {
+            assert(cq->cqid < 64);
+            n->irq_status &= ~(1 << cq->cqid);
+            nvme_irq_check(n);
+        }
+    }
+}
+
 static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
                              uint64_t prp2, uint32_t len, NvmeCtrl *n)
 {
@@ -XXX,XX +XXX,XX @@ static void nvme_post_cqes(void *opaque)
             sizeof(req->cqe));
         QTAILQ_INSERT_TAIL(&sq->req_list, req, entry);
     }
-    nvme_isr_notify(n, cq);
+    nvme_irq_assert(n, cq);
 }
 
 static void nvme_enqueue_req_completion(NvmeCQueue *cq, NvmeRequest *req)
@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
         n->bar.intmc = n->bar.intms;
         trace_nvme_mmio_intm_set(data & 0xffffffff,
                                  n->bar.intmc);
+        nvme_irq_check(n);
         break;
     case 0x10:  /* INTMC */
         if (unlikely(msix_enabled(&(n->parent_obj)))) {
@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
         n->bar.intmc = n->bar.intms;
         trace_nvme_mmio_intm_clr(data & 0xffffffff,
                                  n->bar.intmc);
+        nvme_irq_check(n);
         break;
     case 0x14:  /* CC */
         trace_nvme_mmio_cfg(data & 0xffffffff);
@@ -XXX,XX +XXX,XX @@ static void nvme_process_db(NvmeCtrl *n, hwaddr addr, int val)
             timer_mod(cq->timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + 500);
         }
 
-        if (cq->tail != cq->head) {
-            nvme_isr_notify(n, cq);
+        if (cq->tail == cq->head) {
+            nvme_irq_deassert(n, cq);
         }
     } else {
         /* Submission queue doorbell write */
-- 
2.13.6

From: Daniel Henrique Barboza <danielhb@linux.vnet.ibm.com>

This patch implements a test case for the scenario that was failing
prior to the patch "migration/ram.c: do not set 'postcopy_running' in
POSTCOPY_INCOMING_END", commit acab30b85d.

This new test file 201 was derived from the test file 181 authored
by Kevin Wolf.

CC: Kevin Wolf <kwolf@redhat.com>
CC: Max Reitz <mreitz@redhat.com>
CC: Cleber Rosa <crosa@redhat.com>
Signed-off-by: Daniel Henrique Barboza <danielhb@linux.vnet.ibm.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/201     | 120 +++++++++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/201.out |  23 +++++++++
 tests/qemu-iotests/group   |   1 +
 3 files changed, 144 insertions(+)
 create mode 100755 tests/qemu-iotests/201
 create mode 100644 tests/qemu-iotests/201.out

diff --git a/tests/qemu-iotests/201 b/tests/qemu-iotests/201
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/201
@@ -XXX,XX +XXX,XX @@
+#!/bin/bash
+#
+# Test savevm and loadvm after live migration with postcopy flag
+#
+# Copyright (C) 2017, IBM Corporation.
+#
+# This file is derived from tests/qemu-iotests/181 by Kevin Wolf
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+status=1	# failure is the default!
+
+MIG_SOCKET="${TEST_DIR}/migrate"
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+. ./common.qemu
+
+_cleanup()
+{
+    rm -f "${MIG_SOCKET}"
+    _cleanup_test_img
+    _cleanup_qemu
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+_supported_fmt qcow2
+_supported_proto generic
+_supported_os Linux
+
+# Internal snapshots are (currently) impossible with refcount_bits=1
+# This was taken from test 080
+_unsupported_imgopts 'refcount_bits=1[^0-9]'
+
+size=64M
+_make_test_img $size
+
+echo
+echo === Starting VMs ===
+echo
+
+qemu_comm_method="monitor"
+
+if [ "$IMGOPTSSYNTAX" = "true" ]; then
+    _launch_qemu \
+        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk
+else
+    _launch_qemu \
+        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk
+fi
+src=$QEMU_HANDLE
+
+if [ "$IMGOPTSSYNTAX" = "true" ]; then
+    _launch_qemu \
+        -drive "${TEST_IMG}",cache=${CACHEMODE},id=disk \
+        -incoming "unix:${MIG_SOCKET}"
+else
+    _launch_qemu \
+        -drive file="${TEST_IMG}",cache=${CACHEMODE},driver=$IMGFMT,id=disk \
+        -incoming "unix:${MIG_SOCKET}"
+fi
+dest=$QEMU_HANDLE
+
+echo
+echo === Set \'migrate_set_capability postcopy-ram on\' and migrate ===
+echo
+
+silent=yes
+_send_qemu_cmd $dest 'migrate_set_capability postcopy-ram on' "(qemu)"
+_send_qemu_cmd $src 'migrate_set_capability postcopy-ram on' "(qemu)"
+_send_qemu_cmd $src "migrate -d unix:${MIG_SOCKET}" "(qemu)"
+
+QEMU_COMM_TIMEOUT=1 qemu_cmd_repeat=10 silent=yes \
+    _send_qemu_cmd $src "info migrate" "completed\|failed"
+silent=yes _send_qemu_cmd $src "" "(qemu)"
+
+echo
+echo === Check if migration was successful ===
+echo
+
+QEMU_COMM_TIMEOUT=1 silent=yes \
+    _send_qemu_cmd $src "info migrate" "completed"
+silent=yes _send_qemu_cmd $src "" "(qemu)"
+
+echo
+echo === On destination, execute savevm and loadvm ===
+echo
+
+silent=
+_send_qemu_cmd $dest 'savevm state1' "(qemu)"
+_send_qemu_cmd $dest 'loadvm state1' "(qemu)"
+
+echo
+echo === Shut down and check image ===
+echo
+
+_send_qemu_cmd $src 'quit' ""
+_send_qemu_cmd $dest 'quit' ""
+wait=1 _cleanup_qemu
+
+_check_test_img
+
+# success, all done
+echo "*** done"
+status=0
diff --git a/tests/qemu-iotests/201.out b/tests/qemu-iotests/201.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/201.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 201
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
+
+=== Starting VMs ===
+
+
+=== Set 'migrate_set_capability postcopy-ram on' and migrate ===
+
+
+=== Check if migration was successful ===
+
+
+=== On destination, execute savevm and loadvm ===
+
+(qemu) savevm state1
+(qemu) loadvm state1
+
+=== Shut down and check image ===
+
+(qemu) quit
+(qemu) quit
+No errors were found on the image.
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 197 rw auto quick
 198 rw auto
 200 rw auto
+201 rw auto migration
 202 rw auto quick
 203 rw auto
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

We can easily repair unaligned preallocated zero clusters by discarding
them, so why not do it?

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171110203759.14018-2-mreitz@redhat.com
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/qcow2-refcount.c     | 70 ++++++++++++++++++++++++++++++++++++++--------
 tests/qemu-iotests/060     |  3 +-
 tests/qemu-iotests/060.out |  9 ++++++
 3 files changed, 69 insertions(+), 13 deletions(-)

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 @@ enum {
 static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
                               void **refcount_table,
                               int64_t *refcount_table_size, int64_t l2_offset,
-                              int flags)
+                              int flags, BdrvCheckMode fix)
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t *l2_table, l2_entry;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
                 next_contiguous_offset = offset + s->cluster_size;
             }
 
+            /* Correct offsets are cluster aligned */
+            if (offset_into_cluster(s, offset)) {
+                if (qcow2_get_cluster_type(l2_entry) ==
+                    QCOW2_CLUSTER_ZERO_ALLOC)
+                {
+                    fprintf(stderr, "%s offset=%" PRIx64 ": Preallocated zero "
+                            "cluster is not properly aligned; L2 entry "
+                            "corrupted.\n",
+                            fix & BDRV_FIX_ERRORS ? "Repairing" : "ERROR",
+                            offset);
+                    if (fix & BDRV_FIX_ERRORS) {
+                        uint64_t l2e_offset =
+                            l2_offset + (uint64_t)i * sizeof(uint64_t);
+
+                        l2_entry = QCOW_OFLAG_ZERO;
+                        l2_table[i] = cpu_to_be64(l2_entry);
+                        ret = qcow2_pre_write_overlap_check(bs,
+                                QCOW2_OL_ACTIVE_L2 | QCOW2_OL_INACTIVE_L2,
+                                l2e_offset, sizeof(uint64_t));
+                        if (ret < 0) {
+                            fprintf(stderr, "ERROR: Overlap check failed\n");
+                            res->check_errors++;
+                            /* Something is seriously wrong, so abort checking
+                             * this L2 table */
+                            goto fail;
+                        }
+
+                        ret = bdrv_pwrite_sync(bs->file, l2e_offset,
+                                               &l2_table[i], sizeof(uint64_t));
+                        if (ret < 0) {
+                            fprintf(stderr, "ERROR: Failed to overwrite L2 "
+                                    "table entry: %s\n", strerror(-ret));
+                            res->check_errors++;
+                            /* Do not abort, continue checking the rest of this
+                             * L2 table's entries */
+                        } else {
+                            res->corruptions_fixed++;
+                            /* Skip marking the cluster as used
+                             * (it is unused now) */
+                            continue;
+                        }
+                    } else {
+                        res->corruptions++;
+                    }
+                } else {
+                    fprintf(stderr, "ERROR offset=%" PRIx64 ": Data cluster is "
+                        "not properly aligned; L2 entry corrupted.\n", offset);
+                    res->corruptions++;
+                }
+            }
+
             /* Mark cluster as used */
             ret = qcow2_inc_refcounts_imrt(bs, res,
                                            refcount_table, refcount_table_size,
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
             if (ret < 0) {
                 goto fail;
             }
-
-            /* Correct offsets are cluster aligned */
-            if (offset_into_cluster(s, offset)) {
-                fprintf(stderr, "ERROR offset=%" PRIx64 ": Cluster is not "
-                    "properly aligned; L2 entry corrupted.\n", offset);
-                res->corruptions++;
-            }
             break;
         }
 
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
                               void **refcount_table,
                               int64_t *refcount_table_size,
                               int64_t l1_table_offset, int l1_size,
-                              int flags)
+                              int flags, BdrvCheckMode fix)
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t *l1_table = NULL, l2_offset, l1_size2;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
 
             /* Process and check L2 entries */
             ret = check_refcounts_l2(bs, res, refcount_table,
-                                     refcount_table_size, l2_offset, flags);
+                                     refcount_table_size, l2_offset, flags,
+                                     fix);
             if (ret < 0) {
                 goto fail;
             }
@@ -XXX,XX +XXX,XX @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 
     /* current L1 table */
     ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
-                             s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO);
+                             s->l1_table_offset, s->l1_size, CHECK_FRAG_INFO,
+                             fix);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
     for (i = 0; i < s->nb_snapshots; i++) {
         sn = s->snapshots + i;
         ret = check_refcounts_l1(bs, res, refcount_table, nb_clusters,
-                                 sn->l1_table_offset, sn->l1_size, 0);
+                                 sn->l1_table_offset, sn->l1_size, 0, fix);
         if (ret < 0) {
             return ret;
         }
diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/060
+++ b/tests/qemu-iotests/060
@@ -XXX,XX +XXX,XX @@ poke_file "$TEST_IMG" "$l2_offset" "\x80\x00\x00\x00\x00\x00\x2a\x01"
 # Let's write to it!
 $QEMU_IO -c "write 0 64k" "$TEST_IMG" | _filter_qemu_io
 
-# Can't repair this yet (TODO: We can just deallocate the cluster)
+echo '--- Repairing ---'
+_check_test_img -r all
 
 echo
 echo '=== Discarding with an unaligned refblock ==='
diff --git a/tests/qemu-iotests/060.out b/tests/qemu-iotests/060.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/060.out
+++ b/tests/qemu-iotests/060.out
@@ -XXX,XX +XXX,XX @@ discard 65536/65536 bytes at offset 0
 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 qcow2: Marking image as corrupt: Preallocated zero cluster offset 0x2a00 unaligned (guest offset: 0); further corruption events will be suppressed
 write failed: Input/output error
+--- Repairing ---
+Repairing offset=2a00: Preallocated zero cluster is not properly aligned; L2 entry corrupted.
+The following inconsistencies were found and repaired:
+
+    0 leaked clusters
+    1 corruptions
+
+Double checking the fixed image now...
+No errors were found on the image.
 
 === Discarding with an unaligned refblock ===
 
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

In some cases, these commands still use the deprecated @device
parameter.  Fix that so we can later drop that parameter from their
interface.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171110224302.14424-2-mreitz@redhat.com
Reviewed-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/118 | 184 +++++++++++++++++++++++--------------------------
 tests/qemu-iotests/155 |  60 ++++++++--------
 2 files changed, 113 insertions(+), 131 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 @@ from iotests import qemu_img
 old_img = os.path.join(iotests.test_dir, 'test0.img')
 new_img = os.path.join(iotests.test_dir, 'test1.img')
 
+def interface_to_device_name(interface):
+    if interface == 'ide':
+        return 'ide-cd'
+    elif interface == 'floppy':
+        return 'floppy'
+    else:
+        return None
+
 class ChangeBaseClass(iotests.QMPTestCase):
     has_opened = False
     has_closed = False
@@ -XXX,XX +XXX,XX @@ class ChangeBaseClass(iotests.QMPTestCase):
 
 class GeneralChangeTestsBaseClass(ChangeBaseClass):
 
-    device_name = None
+    device_name = 'qdev0'
 
     def test_change(self):
         result = self.vm.qmp('change', device='drive0', target=new_img,
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 
     def test_blockdev_change_medium(self):
-        if self.device_name is not None:
-            result = self.vm.qmp('blockdev-change-medium',
-                                 id=self.device_name, filename=new_img,
-                                 format=iotests.imgfmt)
-        else:
-            result = self.vm.qmp('blockdev-change-medium',
-                                 device='drive0', filename=new_img,
-                                 format=iotests.imgfmt)
+        result = self.vm.qmp('blockdev-change-medium',
+                             id=self.device_name, filename=new_img,
+                             format=iotests.imgfmt)
 
         self.assert_qmp(result, 'return', {})
 
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 
     def test_eject(self):
-        if self.device_name is not None:
-            result = self.vm.qmp('eject', id=self.device_name, force=True)
-        else:
-            result = self.vm.qmp('eject', device='drive0', force=True)
+        result = self.vm.qmp('eject', id=self.device_name, force=True)
         self.assert_qmp(result, 'return', {})
 
         self.wait_for_open()
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
         self.assert_qmp_absent(result, 'return[0]/inserted')
 
     def test_tray_eject_change(self):
-        if self.device_name is not None:
-            result = self.vm.qmp('eject', id=self.device_name, force=True)
-        else:
-            result = self.vm.qmp('eject', device='drive0', force=True)
+        result = self.vm.qmp('eject', id=self.device_name, force=True)
         self.assert_qmp(result, 'return', {})
 
         self.wait_for_open()
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
             self.assert_qmp(result, 'return[0]/tray_open', True)
         self.assert_qmp_absent(result, 'return[0]/inserted')
 
-        if self.device_name is not None:
-            result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
-                                 filename=new_img, format=iotests.imgfmt)
-        else:
-            result = self.vm.qmp('blockdev-change-medium', device='drive0',
-                                 filename=new_img, format=iotests.imgfmt)
+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
+                             filename=new_img, format=iotests.imgfmt)
         self.assert_qmp(result, 'return', {})
 
         self.wait_for_close()
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 
     def test_tray_open_close(self):
-        if self.device_name is not None:
-            result = self.vm.qmp('blockdev-open-tray',
-                                 id=self.device_name, force=True)
-        else:
-            result = self.vm.qmp('blockdev-open-tray',
-                                 device='drive0', force=True)
+        result = self.vm.qmp('blockdev-open-tray',
+                             id=self.device_name, force=True)
         self.assert_qmp(result, 'return', {})
 
         self.wait_for_open()
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
         else:
             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
-        if self.device_name is not None:
-            result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
-        else:
-            result = self.vm.qmp('blockdev-close-tray', device='drive0')
+        result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
         self.assert_qmp(result, 'return', {})
 
         if self.has_real_tray or not self.was_empty:
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
     def test_tray_eject_close(self):
-        result = self.vm.qmp('eject', device='drive0', force=True)
+        result = self.vm.qmp('eject', id=self.device_name, force=True)
         self.assert_qmp(result, 'return', {})
 
         self.wait_for_open()
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
             self.assert_qmp(result, 'return[0]/tray_open', True)
         self.assert_qmp_absent(result, 'return[0]/inserted')
 
-        if self.device_name is not None:
-            result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
-        else:
-            result = self.vm.qmp('blockdev-close-tray', device='drive0')
+        result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
         self.assert_qmp(result, 'return', {})
 
         self.wait_for_close()
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
         self.assert_qmp_absent(result, 'return[0]/inserted')
 
     def test_tray_open_change(self):
-        result = self.vm.qmp('blockdev-open-tray', device='drive0', force=True)
+        result = self.vm.qmp('blockdev-open-tray', id=self.device_name,
+                                                   force=True)
         self.assert_qmp(result, 'return', {})
 
         self.wait_for_open()
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
         else:
             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
-        result = self.vm.qmp('blockdev-change-medium', device='drive0',
+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
                                                        filename=new_img,
                                                        format=iotests.imgfmt)
         self.assert_qmp(result, 'return', {})
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
                                     'driver': 'file'})
         self.assert_qmp(result, 'return', {})
 
-        if self.device_name is not None:
-            result = self.vm.qmp('blockdev-open-tray',
-                                 id=self.device_name, force=True)
-        else:
-            result = self.vm.qmp('blockdev-open-tray',
-                                 device='drive0', force=True)
+        result = self.vm.qmp('blockdev-open-tray',
+                             id=self.device_name, force=True)
         self.assert_qmp(result, 'return', {})
 
         self.wait_for_open()
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
         else:
             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
-        if self.device_name is not None:
-            result = self.vm.qmp('x-blockdev-remove-medium',
-                                 id=self.device_name)
-        else:
-            result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
+        result = self.vm.qmp('x-blockdev-remove-medium',
+                             id=self.device_name)
         self.assert_qmp(result, 'return', {})
 
         result = self.vm.qmp('query-block')
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
             self.assert_qmp(result, 'return[0]/tray_open', True)
         self.assert_qmp_absent(result, 'return[0]/inserted')
 
-        if self.device_name is not None:
-            result = self.vm.qmp('x-blockdev-insert-medium',
-                                 id=self.device_name, node_name='new')
-        else:
-            result = self.vm.qmp('x-blockdev-insert-medium',
-                                 device='drive0', node_name='new')
+        result = self.vm.qmp('x-blockdev-insert-medium',
+                             id=self.device_name, node_name='new')
         self.assert_qmp(result, 'return', {})
 
         result = self.vm.qmp('query-block')
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
             self.assert_qmp(result, 'return[0]/tray_open', True)
         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 
-        if self.device_name is not None:
-            result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
-        else:
-            result = self.vm.qmp('blockdev-close-tray', device='drive0')
+        result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
         self.assert_qmp(result, 'return', {})
 
         self.wait_for_close()
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 
     def test_close_on_closed(self):
-        result = self.vm.qmp('blockdev-close-tray', device='drive0')
+        result = self.vm.qmp('blockdev-close-tray', id=self.device_name)
         # Should be a no-op
         self.assert_qmp(result, 'return', {})
         self.assertEquals(self.vm.get_qmp_events(wait=False), [])
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
         if not self.has_real_tray:
             return
 
-        result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
+        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
         self.assert_qmp(result, 'error/class', 'GenericError')
 
     def test_insert_on_closed(self):
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
                                    'driver': 'file'})
         self.assert_qmp(result, 'return', {})
 
-        result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
+        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
                                                        node_name='new')
         self.assert_qmp(result, 'error/class', 'GenericError')
 
@@ -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()
-        if interface == 'ide':
-            self.device_name = 'qdev0'
-            self.vm.add_drive(old_img, 'media=%s' % media, 'none')
-            self.vm.add_device('ide-cd,drive=drive0,id=%s' % self.device_name)
-        else:
-            self.vm.add_drive(old_img, 'media=%s' % media, interface)
+        self.vm.add_drive(old_img, 'media=%s' % media, 'none')
+        self.vm.add_device('%s,drive=drive0,id=%s' %
+                           (interface_to_device_name(interface),
+                            self.device_name))
         self.vm.launch()
 
     def tearDown(self):
@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):
                                    'driver': 'file'})
         self.assert_qmp(result, 'return', {})
 
-        result = self.vm.qmp('blockdev-open-tray', device='drive0')
+        result = self.vm.qmp('blockdev-open-tray', id=self.device_name)
         self.assert_qmp(result, 'return', {})
 
         self.wait_for_open()
 
-        result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
+        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
                                                        node_name='new')
         self.assert_qmp(result, 'error/class', 'GenericError')
 
@@ -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, interface)
+        self.vm = iotests.VM().add_drive(None, 'media=%s' % media, 'none')
+        self.vm.add_device('%s,drive=drive0,id=%s' %
+                           (interface_to_device_name(interface),
+                            self.device_name))
         self.vm.launch()
 
     def tearDown(self):
@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
         os.remove(new_img)
 
     def test_remove_on_empty(self):
-        result = self.vm.qmp('blockdev-open-tray', device='drive0')
+        result = self.vm.qmp('blockdev-open-tray', id=self.device_name)
         self.assert_qmp(result, 'return', {})
 
         self.wait_for_open()
 
-        result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
+        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
         # Should be a no-op
         self.assert_qmp(result, 'return', {})
 
@@ -XXX,XX +XXX,XX @@ class TestFloppyInitiallyEmpty(TestInitiallyEmpty):
         self.has_opened = True
 
 class TestChangeReadOnly(ChangeBaseClass):
+    device_name = 'qdev0'
+
     def setUp(self):
         qemu_img('create', '-f', iotests.imgfmt, old_img, '1440k')
         qemu_img('create', '-f', iotests.imgfmt, new_img, '1440k')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
     def test_ro_ro_retain(self):
         os.chmod(old_img, 0444)
         os.chmod(new_img, 0444)
-        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
+        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')
+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
         self.vm.launch()
 
         result = self.vm.qmp('query-block')
         self.assert_qmp(result, 'return[0]/inserted/ro', True)
         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
-        result = self.vm.qmp('blockdev-change-medium', device='drive0',
+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
                                                        filename=new_img,
                                                        format=iotests.imgfmt,
                                                        read_only_mode='retain')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
 
     def test_ro_rw_retain(self):
         os.chmod(old_img, 0444)
-        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
+        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')
+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
         self.vm.launch()
 
         result = self.vm.qmp('query-block')
         self.assert_qmp(result, 'return[0]/inserted/ro', True)
         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
-        result = self.vm.qmp('blockdev-change-medium', device='drive0',
+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
                                                        filename=new_img,
                                                        format=iotests.imgfmt,
                                                        read_only_mode='retain')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
 
     def test_rw_ro_retain(self):
         os.chmod(new_img, 0444)
-        self.vm.add_drive(old_img, 'media=disk', 'floppy')
+        self.vm.add_drive(old_img, 'media=disk', 'none')
+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
         self.vm.launch()
 
         result = self.vm.qmp('query-block')
         self.assert_qmp(result, 'return[0]/inserted/ro', False)
         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
-        result = self.vm.qmp('blockdev-change-medium', device='drive0',
+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
                                                        filename=new_img,
                                                        format=iotests.imgfmt,
                                                        read_only_mode='retain')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
 
     def test_ro_rw(self):
         os.chmod(old_img, 0444)
-        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
+        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')
+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
         self.vm.launch()
 
         result = self.vm.qmp('query-block')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
         result = self.vm.qmp('blockdev-change-medium',
-                             device='drive0',
+                             id=self.device_name,
                              filename=new_img,
                              format=iotests.imgfmt,
                              read_only_mode='read-write')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
 
     def test_rw_ro(self):
         os.chmod(new_img, 0444)
-        self.vm.add_drive(old_img, 'media=disk', 'floppy')
+        self.vm.add_drive(old_img, 'media=disk', 'none')
+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
         self.vm.launch()
 
         result = self.vm.qmp('query-block')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
         result = self.vm.qmp('blockdev-change-medium',
-                             device='drive0',
+                             id=self.device_name,
                              filename=new_img,
                              format=iotests.imgfmt,
                              read_only_mode='read-only')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
         self.assert_qmp(result, 'return[0]/inserted/image/filename', new_img)
 
     def test_make_rw_ro(self):
-        self.vm.add_drive(old_img, 'media=disk', 'floppy')
+        self.vm.add_drive(old_img, 'media=disk', 'none')
+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
         self.vm.launch()
 
         result = self.vm.qmp('query-block')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
         result = self.vm.qmp('blockdev-change-medium',
-                             device='drive0',
+                             id=self.device_name,
                              filename=new_img,
                              format=iotests.imgfmt,
                              read_only_mode='read-only')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
 
     def test_make_ro_rw(self):
         os.chmod(new_img, 0444)
-        self.vm.add_drive(old_img, 'media=disk', 'floppy')
+        self.vm.add_drive(old_img, 'media=disk', 'none')
+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
         self.vm.launch()
 
         result = self.vm.qmp('query-block')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
         result = self.vm.qmp('blockdev-change-medium',
-                             device='drive0',
+                             id=self.device_name,
                              filename=new_img,
                              format=iotests.imgfmt,
                              read_only_mode='read-write')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
 
     def test_make_rw_ro_by_retain(self):
         os.chmod(old_img, 0444)
-        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'floppy')
+        self.vm.add_drive(old_img, 'media=disk,read-only=on', 'none')
+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
         self.vm.launch()
 
         result = self.vm.qmp('query-block')
         self.assert_qmp(result, 'return[0]/inserted/ro', True)
         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
-        result = self.vm.qmp('blockdev-change-medium', device='drive0',
+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
                                                        filename=new_img,
                                                        format=iotests.imgfmt,
                                                        read_only_mode='retain')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
 
     def test_make_ro_rw_by_retain(self):
         os.chmod(new_img, 0444)
-        self.vm.add_drive(old_img, 'media=disk', 'floppy')
+        self.vm.add_drive(old_img, 'media=disk', 'none')
+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
         self.vm.launch()
 
         result = self.vm.qmp('query-block')
         self.assert_qmp(result, 'return[0]/inserted/ro', False)
         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
-        result = self.vm.qmp('blockdev-change-medium', device='drive0',
+        result = self.vm.qmp('blockdev-change-medium', id=self.device_name,
                                                        filename=new_img,
                                                        format=iotests.imgfmt,
                                                        read_only_mode='retain')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
 
     def test_rw_ro_cycle(self):
         os.chmod(new_img, 0444)
-        self.vm.add_drive(old_img, 'media=disk', 'floppy')
+        self.vm.add_drive(old_img, 'media=disk', 'none')
+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
         self.vm.launch()
 
         result = self.vm.qmp('query-block')
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
         self.assert_qmp(result, 'return[0]/inserted/ro', False)
         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
-        result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
+        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
         self.assert_qmp(result, 'return', {})
 
         result = self.vm.qmp('query-block')
         self.assert_qmp_absent(result, 'return[0]/inserted')
 
-        result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
+        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
                                                        node_name='new')
         self.assert_qmp(result, 'return', {})
 
@@ -XXX,XX +XXX,XX @@ TestInitiallyEmpty = None
 
 
 class TestBlockJobsAfterCycle(ChangeBaseClass):
+    device_name = 'qdev0'
+
     def setUp(self):
-        qemu_img('create', '-f', iotests.imgfmt, old_img, '1M')
+        qemu_img('create', '-f', iotests.imgfmt, old_img, '1440K')
 
         self.vm = iotests.VM()
         self.vm.add_drive_raw("id=drive0,driver=null-co,if=none")
+        self.vm.add_device('floppy,drive=drive0,id=%s' % self.device_name)
         self.vm.launch()
 
         result = self.vm.qmp('query-block')
@@ -XXX,XX +XXX,XX @@ class TestBlockJobsAfterCycle(ChangeBaseClass):
 
         # For device-less BBs, calling blockdev-open-tray or blockdev-close-tray
         # is not necessary
-        result = self.vm.qmp('x-blockdev-remove-medium', device='drive0')
+        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
         self.assert_qmp(result, 'return', {})
 
         result = self.vm.qmp('query-block')
@@ -XXX,XX +XXX,XX @@ class TestBlockJobsAfterCycle(ChangeBaseClass):
                                    'driver': 'file'})
         self.assert_qmp(result, 'return', {})
 
-        result = self.vm.qmp('x-blockdev-insert-medium', device='drive0',
+        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
                                                        node_name='node0')
         self.assert_qmp(result, 'return', {})
 
diff --git a/tests/qemu-iotests/155 b/tests/qemu-iotests/155
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/155
+++ b/tests/qemu-iotests/155
@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
     target_real_backing = None
 
     def setUp(self):
-        qemu_img('create', '-f', iotests.imgfmt, back0_img, '1M')
+        qemu_img('create', '-f', iotests.imgfmt, back0_img, '1440K')
         qemu_img('create', '-f', iotests.imgfmt, '-b', back0_img, back1_img)
         qemu_img('create', '-f', iotests.imgfmt, '-b', back1_img, back2_img)
         qemu_img('create', '-f', iotests.imgfmt, '-b', back2_img, source_img)
 
         self.vm = iotests.VM()
-        self.vm.add_drive(None, '', 'none')
-        self.vm.launch()
-
         # Add the BDS via blockdev-add so it stays around after the mirror block
         # job has been completed
-        result = self.vm.qmp('blockdev-add',
-                             node_name='source',
-                             driver=iotests.imgfmt,
-                             file={'driver': 'file',
-                                   'filename': source_img})
-        self.assert_qmp(result, 'return', {})
-
-        result = self.vm.qmp('x-blockdev-insert-medium',
-                             device='drive0', node_name='source')
-        self.assert_qmp(result, 'return', {})
+        blockdev = {'node-name': 'source',
+                    'driver': iotests.imgfmt,
+                    'file': {'driver': 'file',
+                             'filename': source_img}}
+        self.vm.add_blockdev(self.qmp_to_opts(blockdev))
+        self.vm.add_device('floppy,id=qdev0,drive=source')
+        self.vm.launch()
 
         self.assertIntactSourceBackingChain()
 
         if self.existing:
             if self.target_backing:
                 qemu_img('create', '-f', iotests.imgfmt,
-                         '-b', self.target_backing, target_img, '1M')
+                         '-b', self.target_backing, target_img, '1440K')
             else:
-                qemu_img('create', '-f', iotests.imgfmt, target_img, '1M')
+                qemu_img('create', '-f', iotests.imgfmt, target_img, '1440K')
 
             if self.cmd == 'blockdev-mirror':
                 options = { 'node-name': 'target',
@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
         except OSError:
             pass
 
-    def findBlockNode(self, node_name, id=None):
-        if id:
+    def findBlockNode(self, node_name, qdev=None):
+        if qdev:
             result = self.vm.qmp('query-block')
             for device in result['return']:
-                if device['device'] == id:
+                if device['qdev'] == qdev:
                     if node_name:
                         self.assert_qmp(device, 'inserted/node-name', node_name)
                     return device['inserted']
@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
                 if node['node-name'] == node_name:
                     return node
 
-        self.fail('Cannot find node %s/%s' % (id, node_name))
+        self.fail('Cannot find node %s/%s' % (qdev, node_name))
 
     def assertIntactSourceBackingChain(self):
         node = self.findBlockNode('source')
@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
 class MirrorBaseClass(BaseClass):
     def runMirror(self, sync):
         if self.cmd == 'blockdev-mirror':
-            result = self.vm.qmp(self.cmd, device='drive0', sync=sync,
-                                 target='target')
+            result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source',
+                                 sync=sync, target='target')
         else:
             if self.existing:
                 mode = 'existing'
             else:
                 mode = 'absolute-paths'
-            result = self.vm.qmp(self.cmd, device='drive0', sync=sync,
-                                 target=target_img, format=iotests.imgfmt,
-                                 mode=mode, node_name='target')
+            result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source',
+                                 sync=sync, target=target_img,
+                                 format=iotests.imgfmt, mode=mode,
+                                 node_name='target')
 
         self.assert_qmp(result, 'return', {})
 
         self.vm.event_wait('BLOCK_JOB_READY')
 
-        result = self.vm.qmp('block-job-complete', device='drive0')
+        result = self.vm.qmp('block-job-complete', device='mirror-job')
         self.assert_qmp(result, 'return', {})
 
         self.vm.event_wait('BLOCK_JOB_COMPLETED')
@@ -XXX,XX +XXX,XX @@ class MirrorBaseClass(BaseClass):
     def testFull(self):
         self.runMirror('full')
 
-        node = self.findBlockNode('target', 'drive0')
+        node = self.findBlockNode('target', 'qdev0')
         self.assertCorrectBackingImage(node, None)
         self.assertIntactSourceBackingChain()
 
     def testTop(self):
         self.runMirror('top')
 
-        node = self.findBlockNode('target', 'drive0')
+        node = self.findBlockNode('target', 'qdev0')
         self.assertCorrectBackingImage(node, back2_img)
         self.assertIntactSourceBackingChain()
 
     def testNone(self):
         self.runMirror('none')
 
-        node = self.findBlockNode('target', 'drive0')
+        node = self.findBlockNode('target', 'qdev0')
         self.assertCorrectBackingImage(node, source_img)
         self.assertIntactSourceBackingChain()
 
@@ -XXX,XX +XXX,XX @@ class TestCommit(BaseClass):
     existing = False
 
     def testCommit(self):
-        result = self.vm.qmp('block-commit', device='drive0', base=back1_img)
+        result = self.vm.qmp('block-commit', job_id='commit-job',
+                             device='source', base=back1_img)
         self.assert_qmp(result, 'return', {})
 
         self.vm.event_wait('BLOCK_JOB_READY')
 
-        result = self.vm.qmp('block-job-complete', device='drive0')
+        result = self.vm.qmp('block-job-complete', device='commit-job')
         self.assert_qmp(result, 'return', {})
 
         self.vm.event_wait('BLOCK_JOB_COMPLETED')
 
-        node = self.findBlockNode(None, 'drive0')
+        node = self.findBlockNode(None, 'qdev0')
         self.assert_qmp(node, 'image' + '/backing-image' * 0 + '/filename',
                         back1_img)
         self.assert_qmp(node, 'image' + '/backing-image' * 1 + '/filename',
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

Currently, the tray and medium commands in the AHCI test use the
deprecated @device parameter.  This patch switches all invocations over
to use @id.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171110224302.14424-3-mreitz@redhat.com
Reviewed-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/ahci-test.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/ahci-test.c b/tests/ahci-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/ahci-test.c
+++ b/tests/ahci-test.c
@@ -XXX,XX +XXX,XX @@ static void test_atapi_tray(void)
     QDict *rsp;
 
     fd = prepare_iso(iso_size, &tx, &iso);
-    ahci = ahci_boot_and_enable("-drive if=none,id=drive0,file=%s,format=raw "
+    ahci = ahci_boot_and_enable("-blockdev node-name=drive0,driver=file,filename=%s "
                                 "-M q35 "
-                                "-device ide-cd,drive=drive0 ", iso);
+                                "-device ide-cd,id=cd0,drive=drive0 ", iso);
     port = ahci_port_select(ahci);
 
     ahci_atapi_eject(ahci, port);
@@ -XXX,XX +XXX,XX @@ static void test_atapi_tray(void)
 
     /* Remove media */
     qmp_async("{'execute': 'blockdev-open-tray', "
-               "'arguments': {'device': 'drive0'}}");
+               "'arguments': {'id': 'cd0'}}");
     atapi_wait_tray(true);
     rsp = qmp_receive();
     QDECREF(rsp);
 
     qmp_discard_response("{'execute': 'x-blockdev-remove-medium', "
-                         "'arguments': {'device': 'drive0'}}");
+                         "'arguments': {'id': 'cd0'}}");
 
     /* Test the tray without a medium */
     ahci_atapi_load(ahci, port);
@@ -XXX,XX +XXX,XX @@ static void test_atapi_tray(void)
                                         "'file': { 'driver': 'file', "
                                                   "'filename': %s }}}", iso);
     qmp_discard_response("{'execute': 'x-blockdev-insert-medium',"
-                          "'arguments': { 'device': 'drive0', "
+                          "'arguments': { 'id': 'cd0', "
                                          "'node-name': 'node0' }}");
 
     /* Again, the event shows up first */
     qmp_async("{'execute': 'blockdev-close-tray', "
-               "'arguments': {'device': 'drive0'}}");
+               "'arguments': {'id': 'cd0'}}");
     atapi_wait_tray(false);
     rsp = qmp_receive();
     QDECREF(rsp);
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

This is an incompatible change, which is fine as the commands are
experimental.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171110224302.14424-4-mreitz@redhat.com
Reviewed-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qapi/block-core.json | 10 ++--------
 blockdev.c           | 30 +++++++++++++++++++++++-------
 2 files changed, 25 insertions(+), 15 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #
 # If the tray is open and there is no medium inserted, this will be a no-op.
 #
-# @device: Block device name (deprecated, use @id instead)
-#
 # @id:     The name or QOM path of the guest device (since: 2.8)
 #
 # Note: This command is still a work in progress and is considered experimental.
@@ -XXX,XX +XXX,XX @@
 #
 ##
 { 'command': 'x-blockdev-remove-medium',
-  'data': { '*device': 'str',
-            '*id': 'str' } }
+  'data': { 'id': 'str' } }
 
 ##
 # @x-blockdev-insert-medium:
@@ -XXX,XX +XXX,XX @@
 # device's tray must currently be open (unless there is no attached guest
 # device) and there must be no medium inserted already.
 #
-# @device:    Block device name (deprecated, use @id instead)
-#
 # @id:        The name or QOM path of the guest device (since: 2.8)
 #
 # @node-name: name of a node in the block driver state graph
@@ -XXX,XX +XXX,XX @@
 #
 ##
 { 'command': 'x-blockdev-insert-medium',
-  'data': { '*device': 'str',
-            '*id': 'str',
+  'data': { 'id': 'str',
             'node-name': 'str'} }
 
 
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ static QTAILQ_HEAD(, BlockDriverState) monitor_bdrv_states =
 
 static int do_open_tray(const char *blk_name, const char *qdev_id,
                         bool force, Error **errp);
+static void blockdev_remove_medium(bool has_device, const char *device,
+                                   bool has_id, const char *id, Error **errp);
+static void blockdev_insert_medium(bool has_device, const char *device,
+                                   bool has_id, const char *id,
+                                   const char *node_name, Error **errp);
 
 static const char *const if_name[IF_COUNT] = {
     [IF_NONE] = "none",
@@ -XXX,XX +XXX,XX @@ void qmp_eject(bool has_device, const char *device,
     }
     error_free(local_err);
 
-    qmp_x_blockdev_remove_medium(has_device, device, has_id, id, errp);
+    blockdev_remove_medium(has_device, device, has_id, id, errp);
 }
 
 void qmp_block_passwd(bool has_device, const char *device,
@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_close_tray(bool has_device, const char *device,
     }
 }
 
-void qmp_x_blockdev_remove_medium(bool has_device, const char *device,
-                                  bool has_id, const char *id, Error **errp)
+static void blockdev_remove_medium(bool has_device, const char *device,
+                                   bool has_id, const char *id, Error **errp)
 {
     BlockBackend *blk;
     BlockDriverState *bs;
@@ -XXX,XX +XXX,XX @@ out:
     aio_context_release(aio_context);
 }
 
+void qmp_x_blockdev_remove_medium(const char *id, Error **errp)
+{
+    blockdev_remove_medium(false, NULL, true, id, errp);
+}
+
 static void qmp_blockdev_insert_anon_medium(BlockBackend *blk,
                                             BlockDriverState *bs, Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ static void qmp_blockdev_insert_anon_medium(BlockBackend *blk,
     }
 }
 
-void qmp_x_blockdev_insert_medium(bool has_device, const char *device,
-                                  bool has_id, const char *id,
-                                  const char *node_name, Error **errp)
+static void blockdev_insert_medium(bool has_device, const char *device,
+                                   bool has_id, const char *id,
+                                   const char *node_name, Error **errp)
 {
     BlockBackend *blk;
     BlockDriverState *bs;
@@ -XXX,XX +XXX,XX @@ void qmp_x_blockdev_insert_medium(bool has_device, const char *device,
     qmp_blockdev_insert_anon_medium(blk, bs, errp);
 }
 
+void qmp_x_blockdev_insert_medium(const char *id, const char *node_name,
+                                  Error **errp)
+{
+    blockdev_insert_medium(false, NULL, true, id, node_name, errp);
+}
+
 void qmp_blockdev_change_medium(bool has_device, const char *device,
                                 bool has_id, const char *id,
                                 const char *filename,
@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_change_medium(bool has_device, const char *device,
     error_free(err);
     err = NULL;
 
-    qmp_x_blockdev_remove_medium(has_device, device, has_id, id, &err);
+    blockdev_remove_medium(has_device, device, has_id, id, &err);
     if (err) {
         error_propagate(errp, err);
         goto fail;
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

Now that iotest 093 test proves that the throttling configuration
survives a blockdev-remove-medium/blockdev-insert-medium pair, the
original reason for declaring these commands experimental is gone
(see commit 6e0abc251dd4f8eba1f53656dfede12e5840e83b).

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171110224302.14424-5-mreitz@redhat.com
Reviewed-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 qapi/block-core.json   | 32 +++++++++++++-------------------
 blockdev.c             |  6 +++---
 tests/ahci-test.c      |  4 ++--
 tests/qemu-iotests/093 |  6 +++---
 tests/qemu-iotests/118 | 20 ++++++++++----------
 tests/qemu-iotests/139 |  2 +-
 6 files changed, 32 insertions(+), 38 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
             '*id': 'str' } }
 
 ##
-# @x-blockdev-remove-medium:
+# @blockdev-remove-medium:
 #
 # Removes a medium (a block driver state tree) from a block device. That block
 # device's tray must currently be open (unless there is no attached guest
@@ -XXX,XX +XXX,XX @@
 #
 # If the tray is open and there is no medium inserted, this will be a no-op.
 #
-# @id:     The name or QOM path of the guest device (since: 2.8)
-#
-# Note: This command is still a work in progress and is considered experimental.
-# Stay away from it unless you want to help with its development.
+# @id:     The name or QOM path of the guest device
 #
-# Since: 2.5
+# Since: 2.12
 #
 # Example:
 #
-# -> { "execute": "x-blockdev-remove-medium",
+# -> { "execute": "blockdev-remove-medium",
 #      "arguments": { "id": "ide0-1-0" } }
 #
 # <- { "error": { "class": "GenericError",
@@ -XXX,XX +XXX,XX @@
 #
 # <- { "return": {} }
 #
-# -> { "execute": "x-blockdev-remove-medium",
+# -> { "execute": "blockdev-remove-medium",
 #      "arguments": { "id": "ide0-1-0" } }
 #
 # <- { "return": {} }
 #
 ##
-{ 'command': 'x-blockdev-remove-medium',
+{ 'command': 'blockdev-remove-medium',
   'data': { 'id': 'str' } }
 
 ##
-# @x-blockdev-insert-medium:
+# @blockdev-insert-medium:
 #
 # Inserts a medium (a block driver state tree) into a block device. That block
 # device's tray must currently be open (unless there is no attached guest
 # device) and there must be no medium inserted already.
 #
-# @id:        The name or QOM path of the guest device (since: 2.8)
+# @id:        The name or QOM path of the guest device
 #
 # @node-name: name of a node in the block driver state graph
 #
-# Note: This command is still a work in progress and is considered experimental.
-# Stay away from it unless you want to help with its development.
-#
-# Since: 2.5
+# Since: 2.12
 #
 # Example:
 #
@@ -XXX,XX +XXX,XX @@
 #                    "filename": "fedora.iso" } } }
 # <- { "return": {} }
 #
-# -> { "execute": "x-blockdev-insert-medium",
+# -> { "execute": "blockdev-insert-medium",
 #      "arguments": { "id": "ide0-1-0",
 #                     "node-name": "node0" } }
 #
 # <- { "return": {} }
 #
 ##
-{ 'command': 'x-blockdev-insert-medium',
+{ 'command': 'blockdev-insert-medium',
   'data': { 'id': 'str',
             'node-name': 'str'} }
 
@@ -XXX,XX +XXX,XX @@
 #
 # Changes the medium inserted into a block device by ejecting the current medium
 # and loading a new image file which is inserted as the new medium (this command
-# combines blockdev-open-tray, x-blockdev-remove-medium,
-# x-blockdev-insert-medium and blockdev-close-tray).
+# combines blockdev-open-tray, blockdev-remove-medium, blockdev-insert-medium
+# and blockdev-close-tray).
 #
 # @device:          Block device name (deprecated, use @id instead)
 #
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ out:
     aio_context_release(aio_context);
 }
 
-void qmp_x_blockdev_remove_medium(const char *id, Error **errp)
+void qmp_blockdev_remove_medium(const char *id, Error **errp)
 {
     blockdev_remove_medium(false, NULL, true, id, errp);
 }
@@ -XXX,XX +XXX,XX @@ static void blockdev_insert_medium(bool has_device, const char *device,
     qmp_blockdev_insert_anon_medium(blk, bs, errp);
 }
 
-void qmp_x_blockdev_insert_medium(const char *id, const char *node_name,
-                                  Error **errp)
+void qmp_blockdev_insert_medium(const char *id, const char *node_name,
+                                Error **errp)
 {
     blockdev_insert_medium(false, NULL, true, id, node_name, errp);
 }
diff --git a/tests/ahci-test.c b/tests/ahci-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/ahci-test.c
+++ b/tests/ahci-test.c
@@ -XXX,XX +XXX,XX @@ static void test_atapi_tray(void)
     rsp = qmp_receive();
     QDECREF(rsp);
 
-    qmp_discard_response("{'execute': 'x-blockdev-remove-medium', "
+    qmp_discard_response("{'execute': 'blockdev-remove-medium', "
                          "'arguments': {'id': 'cd0'}}");
 
     /* Test the tray without a medium */
@@ -XXX,XX +XXX,XX @@ static void test_atapi_tray(void)
                                         "'driver': 'raw', "
                                         "'file': { 'driver': 'file', "
                                                   "'filename': %s }}}", iso);
-    qmp_discard_response("{'execute': 'x-blockdev-insert-medium',"
+    qmp_discard_response("{'execute': 'blockdev-insert-medium',"
                           "'arguments': { 'id': 'cd0', "
                                          "'node-name': 'node0' }}");
 
diff --git a/tests/qemu-iotests/093 b/tests/qemu-iotests/093
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/093
+++ b/tests/qemu-iotests/093
@@ -XXX,XX +XXX,XX @@ class ThrottleTestRemovableMedia(iotests.QMPTestCase):
         # Now eject cd0 and insert cd1
         result = self.vm.qmp("blockdev-open-tray", id='dev0')
         self.assert_qmp(result, 'return', {})
-        result = self.vm.qmp("x-blockdev-remove-medium", id='dev0')
+        result = self.vm.qmp("blockdev-remove-medium", id='dev0')
         self.assert_qmp(result, 'return', {})
-        result = self.vm.qmp("x-blockdev-insert-medium", id='dev0', node_name='cd1')
+        result = self.vm.qmp("blockdev-insert-medium", id='dev0', node_name='cd1')
         self.assert_qmp(result, 'return', {})
 
         # Check that the I/O limits are still the same
@@ -XXX,XX +XXX,XX @@ class ThrottleTestRemovableMedia(iotests.QMPTestCase):
         self.assert_qmp(result, 'return[0]/inserted/bps',   50)
 
         # Eject cd1
-        result = self.vm.qmp("x-blockdev-remove-medium", id='dev0')
+        result = self.vm.qmp("blockdev-remove-medium", id='dev0')
         self.assert_qmp(result, 'return', {})
 
         # Check that we can't set limits if the device has no medium
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):
         else:
             self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
-        result = self.vm.qmp('x-blockdev-remove-medium',
+        result = self.vm.qmp('blockdev-remove-medium',
                              id=self.device_name)
         self.assert_qmp(result, 'return', {})
 
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
             self.assert_qmp(result, 'return[0]/tray_open', True)
         self.assert_qmp_absent(result, 'return[0]/inserted')
 
-        result = self.vm.qmp('x-blockdev-insert-medium',
+        result = self.vm.qmp('blockdev-insert-medium',
                              id=self.device_name, node_name='new')
         self.assert_qmp(result, 'return', {})
 
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
         if not self.has_real_tray:
             return
 
-        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
+        result = self.vm.qmp('blockdev-remove-medium', id=self.device_name)
         self.assert_qmp(result, 'error/class', 'GenericError')
 
     def test_insert_on_closed(self):
@@ -XXX,XX +XXX,XX @@ class GeneralChangeTestsBaseClass(ChangeBaseClass):
                                    'driver': 'file'})
         self.assert_qmp(result, 'return', {})
 
-        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
+        result = self.vm.qmp('blockdev-insert-medium', id=self.device_name,
                                                        node_name='new')
         self.assert_qmp(result, 'error/class', 'GenericError')
 
@@ -XXX,XX +XXX,XX @@ class TestInitiallyFilled(GeneralChangeTestsBaseClass):
 
         self.wait_for_open()
 
-        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
+        result = self.vm.qmp('blockdev-insert-medium', id=self.device_name,
                                                        node_name='new')
         self.assert_qmp(result, 'error/class', 'GenericError')
 
@@ -XXX,XX +XXX,XX @@ class TestInitiallyEmpty(GeneralChangeTestsBaseClass):
 
         self.wait_for_open()
 
-        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
+        result = self.vm.qmp('blockdev-remove-medium', id=self.device_name)
         # Should be a no-op
         self.assert_qmp(result, 'return', {})
 
@@ -XXX,XX +XXX,XX @@ class TestChangeReadOnly(ChangeBaseClass):
         self.assert_qmp(result, 'return[0]/inserted/ro', False)
         self.assert_qmp(result, 'return[0]/inserted/image/filename', old_img)
 
-        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
+        result = self.vm.qmp('blockdev-remove-medium', id=self.device_name)
         self.assert_qmp(result, 'return', {})
 
         result = self.vm.qmp('query-block')
         self.assert_qmp_absent(result, 'return[0]/inserted')
 
-        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
+        result = self.vm.qmp('blockdev-insert-medium', id=self.device_name,
                                                        node_name='new')
         self.assert_qmp(result, 'return', {})
 
@@ -XXX,XX +XXX,XX @@ class TestBlockJobsAfterCycle(ChangeBaseClass):
 
         # For device-less BBs, calling blockdev-open-tray or blockdev-close-tray
         # is not necessary
-        result = self.vm.qmp('x-blockdev-remove-medium', id=self.device_name)
+        result = self.vm.qmp('blockdev-remove-medium', id=self.device_name)
         self.assert_qmp(result, 'return', {})
 
         result = self.vm.qmp('query-block')
@@ -XXX,XX +XXX,XX @@ class TestBlockJobsAfterCycle(ChangeBaseClass):
                                    'driver': 'file'})
         self.assert_qmp(result, 'return', {})
 
-        result = self.vm.qmp('x-blockdev-insert-medium', id=self.device_name,
+        result = self.vm.qmp('blockdev-insert-medium', id=self.device_name,
                                                        node_name='node0')
         self.assert_qmp(result, 'return', {})
 
diff --git a/tests/qemu-iotests/139 b/tests/qemu-iotests/139
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/139
+++ b/tests/qemu-iotests/139
@@ -XXX,XX +XXX,XX @@ class TestBlockdevDel(iotests.QMPTestCase):
     # Insert a BlockDriverState
     def insertDrive(self, device, node):
         self.checkBlockDriverState(node)
-        result = self.vm.qmp('x-blockdev-insert-medium',
+        result = self.vm.qmp('blockdev-insert-medium',
                              id = device, node_name = node)
         self.assert_qmp(result, 'return', {})
         self.checkBlockDriverState(node)
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

102 truncates a qcow2 file (the raw file) on purpose while a VM is
running.  However, image locking will usually prevent exactly this.

The fact that most people have not noticed until now (I suppose you may
have seen sporadic failures, but not taken them too seriously, like me)
further shows that this truncation is actually not really done
concurrently, but that the VM is still starting up by this point and has
not yet opened the image.  Remedy this by waiting for the monitor shell
to appear before the qemu-img invocation so we know the VM is up.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171129185102.29390-1-mreitz@redhat.com
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/102     | 7 ++++++-
 tests/qemu-iotests/102.out | 3 ++-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/102 b/tests/qemu-iotests/102
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/102
+++ b/tests/qemu-iotests/102
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c 'write 0 64k' "$TEST_IMG" | _filter_qemu_io
 
 qemu_comm_method=monitor _launch_qemu -drive if=none,file="$TEST_IMG",id=drv0
 
-$QEMU_IMG resize -f raw --shrink "$TEST_IMG" $((5 * 64 * 1024))
+# Wait for a prompt to appear (so we know qemu has opened the image)
+_send_qemu_cmd '' '(qemu)'
+
+$QEMU_IMG resize --shrink --image-opts \
+    "driver=raw,file.driver=file,file.filename=$TEST_IMG,file.locking=off" \
+    $((5 * 64 * 1024))
 
 _send_qemu_cmd $QEMU_HANDLE 'qemu-io drv0 map' 'allocated' \
     | sed -e 's/^(qemu).*qemu-io drv0 map...$/(qemu) qemu-io drv0 map/'
diff --git a/tests/qemu-iotests/102.out b/tests/qemu-iotests/102.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/102.out
+++ b/tests/qemu-iotests/102.out
@@ -XXX,XX +XXX,XX @@ Offset          Length          Mapped to       File
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=65536
 wrote 65536/65536 bytes at offset 0
 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-Image resized.
 QEMU X.Y.Z monitor - type 'help' for more information
+Image resized.
+(qemu)
 (qemu) qemu-io drv0 map
 64 KiB (0x10000) bytes     allocated at offset 0 bytes (0x0)
 *** done
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

Persistent dirty bitmaps require a properly functioning
autoclear_features field, or we cannot track when an unsupporting
program might overwrite them.  Therefore, we cannot support them for
compat=0.10 images.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-3-mreitz@redhat.com
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/qcow2-bitmap.c | 10 ++++++++++
 block/qcow2.c        | 14 +++++++++++---
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-bitmap.c
+++ b/block/qcow2-bitmap.c
@@ -XXX,XX +XXX,XX @@ bool qcow2_can_store_new_dirty_bitmap(BlockDriverState *bs,
     bool found;
     Qcow2BitmapList *bm_list;
 
+    if (s->qcow_version < 3) {
+        /* Without autoclear_features, we would always have to assume
+         * that a program without persistent dirty bitmap support has
+         * accessed this qcow2 file when opening it, and would thus
+         * have to drop all dirty bitmaps (defeating their purpose).
+         */
+        error_setg(errp, "Cannot store dirty bitmaps in qcow2 v2 files");
+        goto fail;
+    }
+
     if (check_constraints_on_bitmap(bs, name, granularity, errp) != 0) {
         goto 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 qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
             }
 
             if (!(s->autoclear_features & QCOW2_AUTOCLEAR_BITMAPS)) {
-                warn_report("a program lacking bitmap support "
-                            "modified this file, so all bitmaps are now "
-                            "considered inconsistent");
+                if (s->qcow_version < 3) {
+                    /* Let's be a bit more specific */
+                    warn_report("This qcow2 v2 image contains bitmaps, but "
+                                "they may have been modified by a program "
+                                "without persistent bitmap support; so now "
+                                "they must all be considered inconsistent");
+                } else {
+                    warn_report("a program lacking bitmap support "
+                                "modified this file, so all bitmaps are now "
+                                "considered inconsistent");
+                }
                 error_printf("Some clusters may be leaked, "
                              "run 'qemu-img check -r' on the image "
                              "file to fix.");
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

This is not necessarily complete, but it should include the most
important places.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-4-mreitz@redhat.com
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/qcow.c | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

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,
         /* update the L1 entry */
         s->l1_table[l1_index] = l2_offset;
         tmp = cpu_to_be64(l2_offset);
+        BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
         ret = bdrv_pwrite_sync(bs->file,
                                s->l1_table_offset + l1_index * sizeof(tmp),
                                &tmp, sizeof(tmp));
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
         }
     }
     l2_table = s->l2_cache + (min_index << s->l2_bits);
+    BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
     if (new_l2_table) {
         memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
         ret = bdrv_pwrite_sync(bs->file, l2_offset, l2_table,
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
         ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1)) {
         if (!allocate)
             return 0;
+        BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
         /* allocate a new cluster */
         if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
             (n_end - n_start) < s->cluster_sectors) {
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
             }
             cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size);
             /* write the cluster content */
+            BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
             ret = bdrv_pwrite(bs->file, cluster_offset, s->cluster_cache,
                               s->cluster_size);
             if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
                                                       NULL) < 0) {
                                 return -EIO;
                             }
+                            BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
                             ret = bdrv_pwrite(bs->file,
                                               cluster_offset + i * 512,
                                               s->cluster_data, 512);
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
         /* update L2 table */
         tmp = cpu_to_be64(cluster_offset);
         l2_table[l2_index] = tmp;
+        if (allocate == 2) {
+            BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
+        } else {
+            BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
+        }
         ret = bdrv_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
                                &tmp, sizeof(tmp));
         if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ static int decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
     if (s->cluster_cache_offset != coffset) {
         csize = cluster_offset >> (63 - s->cluster_bits);
         csize &= (s->cluster_size - 1);
+        BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
         ret = bdrv_pread(bs->file, coffset, s->cluster_data, csize);
         if (ret != csize)
             return -1;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
                 hd_iov.iov_len = n * 512;
                 qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
                 qemu_co_mutex_unlock(&s->lock);
+                /* qcow2 emits this on bs->file instead of bs->backing */
+                BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
                 ret = bdrv_co_readv(bs->backing, sector_num, n, &hd_qiov);
                 qemu_co_mutex_lock(&s->lock);
                 if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_readv(BlockDriverState *bs, int64_t sector_num,
             hd_iov.iov_len = n * 512;
             qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
             qemu_co_mutex_unlock(&s->lock);
+            BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
             ret = bdrv_co_readv(bs->file,
                                 (cluster_offset >> 9) + index_in_cluster,
                                 n, &hd_qiov);
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow_co_writev(BlockDriverState *bs, int64_t sector_num,
         hd_iov.iov_len = n * 512;
         qemu_iovec_init_external(&hd_qiov, &hd_iov, 1);
         qemu_co_mutex_unlock(&s->lock);
+        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
         ret = bdrv_co_writev(bs->file,
                              (cluster_offset >> 9) + index_in_cluster,
                              n, &hd_qiov);
@@ -XXX,XX +XXX,XX @@ qcow_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
         .iov_len    = out_len,
     };
     qemu_iovec_init_external(&hd_qiov, &iov, 1);
+    BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
     ret = bdrv_co_pwritev(bs->file, cluster_offset, out_len, &hd_qiov, 0);
     if (ret < 0) {
         goto fail;
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

This is certainly not complete, but it includes at least write_aio and
read_aio.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-5-mreitz@redhat.com
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 block/vmdk.c | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
     /* Read backing data before skip range */
     if (skip_start_bytes > 0) {
         if (bs->backing) {
+            /* qcow2 emits this on bs->file instead of bs->backing */
+            BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
             ret = bdrv_pread(bs->backing, offset, whole_grain,
                              skip_start_bytes);
             if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
                 goto exit;
             }
         }
+        BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
         ret = bdrv_pwrite(extent->file, cluster_offset, whole_grain,
                           skip_start_bytes);
         if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
     /* Read backing data after skip range */
     if (skip_end_bytes < cluster_bytes) {
         if (bs->backing) {
+            /* qcow2 emits this on bs->file instead of bs->backing */
+            BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
             ret = bdrv_pread(bs->backing, offset + skip_end_bytes,
                              whole_grain + skip_end_bytes,
                              cluster_bytes - skip_end_bytes);
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
                 goto exit;
             }
         }
+        BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
         ret = bdrv_pwrite(extent->file, cluster_offset + skip_end_bytes,
                           whole_grain + skip_end_bytes,
                           cluster_bytes - skip_end_bytes);
@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
 {
     offset = cpu_to_le32(offset);
     /* update L2 table */
+    BLKDBG_EVENT(extent->file, BLKDBG_L2_UPDATE);
     if (bdrv_pwrite_sync(extent->file,
                 ((int64_t)m_data->l2_offset * 512)
                     + (m_data->l2_index * sizeof(offset)),
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
         }
     }
     l2_table = extent->l2_cache + (min_index * extent->l2_size);
+    BLKDBG_EVENT(extent->file, BLKDBG_L2_LOAD);
     if (bdrv_pread(extent->file,
                 (int64_t)l2_offset * 512,
                 l2_table,
@@ -XXX,XX +XXX,XX @@ static int vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
             .iov_len    = n_bytes,
         };
         qemu_iovec_init_external(&local_qiov, &iov, 1);
+
+        BLKDBG_EVENT(extent->file, BLKDBG_WRITE_COMPRESSED);
     } else {
         qemu_iovec_init(&local_qiov, qiov->niov);
         qemu_iovec_concat(&local_qiov, qiov, qiov_offset, n_bytes);
+
+        BLKDBG_EVENT(extent->file, BLKDBG_WRITE_AIO);
     }
 
     write_offset = cluster_offset + offset_in_cluster;
@@ -XXX,XX +XXX,XX @@ static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
 
 
     if (!extent->compressed) {
+        BLKDBG_EVENT(extent->file, BLKDBG_READ_AIO);
         ret = bdrv_co_preadv(extent->file,
                              cluster_offset + offset_in_cluster, bytes,
                              qiov, 0);
@@ -XXX,XX +XXX,XX @@ static int vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
     buf_bytes = cluster_bytes * 2;
     cluster_buf = g_malloc(buf_bytes);
     uncomp_buf = g_malloc(cluster_bytes);
+    BLKDBG_EVENT(extent->file, BLKDBG_READ_COMPRESSED);
     ret = bdrv_pread(extent->file,
                 cluster_offset,
                 cluster_buf, buf_bytes);
@@ -XXX,XX +XXX,XX @@ vmdk_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
                 qemu_iovec_reset(&local_qiov);
                 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
 
+                /* qcow2 emits this on bs->file instead of bs->backing */
+                BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
                 ret = bdrv_co_preadv(bs->backing, offset, n_bytes,
                                      &local_qiov, 0);
                 if (ret < 0) {
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

_filter_img_info should remove format-specific information, too.  We
already have such a filter in _img_info, and it is very useful for
query-block-named-block-nodes (etc.), too.

However, in 198 we need that information (but we still want the rest of
the filter), so make that filtering optional.  Note that "the rest of
the filter" includes filtering of the test directory, so we can drop the
_filter_testdir from 198 at the same time.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-7-mreitz@redhat.com
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/198           |  6 ++++--
 tests/qemu-iotests/common.filter | 29 ++++++++++++++++++++++++++++-
 2 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/tests/qemu-iotests/198 b/tests/qemu-iotests/198
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/198
+++ b/tests/qemu-iotests/198
@@ -XXX,XX +XXX,XX @@ $QEMU_IO --object $SECRET0 --object $SECRET1 -c "read -P 0x9 0 $size" --image-op
 
 echo
 echo "== checking image base =="
-$QEMU_IMG info --image-opts $IMGSPECBASE | _filter_img_info | _filter_testdir | sed -e "/^disk size:/ D"
+$QEMU_IMG info --image-opts $IMGSPECBASE | _filter_img_info --format-specific \
+    | sed -e "/^disk size:/ D"
 
 echo
 echo "== checking image layer =="
-$QEMU_IMG info --image-opts $IMGSPECLAYER | _filter_img_info | _filter_testdir | sed -e "/^disk size:/ D"
+$QEMU_IMG info --image-opts $IMGSPECLAYER | _filter_img_info --format-specific \
+    | sed -e "/^disk size:/ D"
 
 
 # success, all done
diff --git a/tests/qemu-iotests/common.filter b/tests/qemu-iotests/common.filter
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.filter
+++ b/tests/qemu-iotests/common.filter
@@ -XXX,XX +XXX,XX @@ _filter_img_create()
 
 _filter_img_info()
 {
+    if [[ "$1" == "--format-specific" ]]; then
+        local format_specific=1
+        shift
+    else
+        local format_specific=0
+    fi
+
+    discard=0
+    regex_json_spec_start='^ *"format-specific": \{'
     sed -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
         -e "s#$TEST_DIR#TEST_DIR#g" \
         -e "s#$IMGFMT#IMGFMT#g" \
@@ -XXX,XX +XXX,XX @@ _filter_img_info()
         -e "/block_state_zero: \$on\\|off\$/d" \
         -e "/log_size: [0-9]\\+/d" \
         -e "s/iters: [0-9]\\+/iters: 1024/" \
-        -e "s/uuid: [-a-f0-9]\\+/uuid: 00000000-0000-0000-0000-000000000000/"
+        -e "s/uuid: [-a-f0-9]\\+/uuid: 00000000-0000-0000-0000-000000000000/" | \
+    while IFS='' read -r line; do
+        if [[ $format_specific == 1 ]]; then
+            discard=0
+        elif [[ $line == "Format specific information:" ]]; then
+            discard=1
+        elif [[ $line =~ $regex_json_spec_start ]]; then
+            discard=2
+            regex_json_spec_end="^${line%%[^ ]*}\\},? *$"
+        fi
+        if [[ $discard == 0 ]]; then
+            echo "$line"
+        elif [[ $discard == 1 && ! $line ]]; then
+            echo
+            discard=0
+        elif [[ $discard == 2 && $line =~ $regex_json_spec_end ]]; then
+            discard=0
+        fi
+    done
 }
 
 # filter out offsets and file names from qemu-img map; good for both
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

This test does funny things like TEST_IMG="TEST_IMG.base" _make_test_img
that usually only work with the file protocol.  More specifically, they
do not work with the most interesting non-file protocols, so we might as
well skip this for anything but file.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-8-mreitz@redhat.com
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/020 | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/tests/qemu-iotests/020 b/tests/qemu-iotests/020
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/020
+++ b/tests/qemu-iotests/020
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 
 # Any format supporting backing files
 _supported_fmt qcow qcow2 vmdk qed
-_supported_proto generic
-_unsupported_proto vxhs
+_supported_proto file
 _supported_os Linux
 _unsupported_imgopts "subformat=monolithicFlat" \
                      "subformat=twoGbMaxExtentFlat" \
                      "subformat=twoGbMaxExtentSparse"
 
-# NFS does not support bdrv_reopen_prepare thus qemu-img commit fails.
-if [ "$IMGPROTO" = "nfs" ]; then
-    _notrun "image protocol $IMGPROTO does not support bdrv_commit"
-fi
-
 TEST_OFFSETS="0 4294967296"
 
 TEST_IMG_SAVE="$TEST_IMG"
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

vmdk cannot work with anything but vmdk backing files, so make the
backing file be the same format as the overlay.

Reported-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-11-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/020     | 9 ++++++---
 tests/qemu-iotests/020.out | 6 ++++--
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/tests/qemu-iotests/020 b/tests/qemu-iotests/020
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/020
+++ b/tests/qemu-iotests/020
@@ -XXX,XX +XXX,XX @@ echo
 echo 'Testing failing commit'
 echo
 
+TEST_IMG="$TEST_IMG.base" _make_test_img 1M
+
 # Create an image with a null backing file to which committing will fail (with
 # ENOSPC so we can distinguish the result from some generic EIO which may be
 # generated anywhere in the block layer)
-_make_test_img -b "json:{'driver': 'raw',
+_make_test_img -b "json:{'driver': '$IMGFMT',
                          'file': {
                              'driver': 'blkdebug',
                              'inject-error': [{
@@ -XXX,XX +XXX,XX @@ _make_test_img -b "json:{'driver': 'raw',
                                  'once': true
                              }],
                              'image': {
-                                 'driver': 'null-co'
+                                 'driver': 'file',
+                                 'filename': '$TEST_IMG.base'
                              }}}"
 
 # Just write anything so committing will not be a no-op
 $QEMU_IO -c 'writev 0 64k' "$TEST_IMG" | _filter_qemu_io
 
 $QEMU_IMG commit "$TEST_IMG"
-_cleanup_test_img
+_cleanup
 
 # success, all done
 echo "*** done"
diff --git a/tests/qemu-iotests/020.out b/tests/qemu-iotests/020.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/020.out
+++ b/tests/qemu-iotests/020.out
@@ -XXX,XX +XXX,XX @@ No errors were found on the image.
 
 Testing failing commit
 
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 backing_file=json:{'driver': 'raw',,
+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=1048576
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=json:{'driver': 'IMGFMT',,
                          'file': {
                              'driver': 'blkdebug',,
                              'inject-error': [{
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1073741824 backing_file=json:{'d
                                  'once': true
                              }],,
                              'image': {
-                                 'driver': 'null-co'
+                                 'driver': 'file',,
+                                 'filename': 'TEST_DIR/t.IMGFMT.base'
                              }}}
 wrote 65536/65536 bytes at offset 0
 64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

051 has both compat=1.1 and compat=0.10 tests (once it uses
lazy_refcounts, once it tests that setting them does not work).
For the compat=0.10 tests, it already explicitly creates a suitable
image.  So let's just ignore the user-specified compat level for the
lazy_refcounts test and explicitly create a compat=1.1 image there, too.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-12-mreitz@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/051        | 2 ++
 tests/qemu-iotests/051.out    | 1 +
 tests/qemu-iotests/051.pc.out | 1 +
 3 files changed, 4 insertions(+)

diff --git a/tests/qemu-iotests/051 b/tests/qemu-iotests/051
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/051
+++ b/tests/qemu-iotests/051
@@ -XXX,XX +XXX,XX @@ echo
 echo === Enable and disable lazy refcounting on the command line, plus some invalid values ===
 echo
 
+_make_test_img -o compat=1.1 "$size"
+
 run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=on
 run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=off
 run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=
diff --git a/tests/qemu-iotests/051.out b/tests/qemu-iotests/051.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/051.out
+++ b/tests/qemu-iotests/051.out
@@ -XXX,XX +XXX,XX @@ QEMU_PROG: -drive file=TEST_DIR/t.qcow2,file.backing.driver=qcow2,file.backing.f
 
 === Enable and disable lazy refcounting on the command line, plus some invalid values ===
 
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
 Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=on
 QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) quit
diff --git a/tests/qemu-iotests/051.pc.out b/tests/qemu-iotests/051.pc.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/051.pc.out
+++ b/tests/qemu-iotests/051.pc.out
@@ -XXX,XX +XXX,XX @@ QEMU_PROG: -drive file=TEST_DIR/t.qcow2,file.backing.driver=qcow2,file.backing.f
 
 === Enable and disable lazy refcounting on the command line, plus some invalid values ===
 
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
 Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,lazy-refcounts=on
 QEMU X.Y.Z monitor - type 'help' for more information
 (qemu) quit
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

As of commit 9877860e7bd1e26ee70ab9bb5ebc34c92bf23bf5, vmdk fails
differently when opening the sample image.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-13-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/059.out | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/059.out b/tests/qemu-iotests/059.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/059.out
+++ b/tests/qemu-iotests/059.out
@@ -XXX,XX +XXX,XX @@ Offset          Length          Mapped to       File
 0x140000000     0x10000         0x50000         TEST_DIR/t-s003.vmdk
 
 === Testing afl image with a very large capacity ===
-qemu-img: Can't get image size 'TEST_DIR/afl9.IMGFMT': File too large
+qemu-img: Could not open 'TEST_DIR/afl9.IMGFMT': Could not open 'TEST_DIR/afl9.IMGFMT': Invalid argument
 *** done
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

067 works very well with compat=0.10 once you remove format-specific
information from the QMP output.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-14-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/067     |  3 +-
 tests/qemu-iotests/067.out | 97 +++++++++++++---------------------------------
 2 files changed, 28 insertions(+), 72 deletions(-)

diff --git a/tests/qemu-iotests/067 b/tests/qemu-iotests/067
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/067
+++ b/tests/qemu-iotests/067
@@ -XXX,XX +XXX,XX @@ function run_qemu()
 {
     do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qmp | _filter_qemu \
                           | _filter_actual_image_size \
-                          | _filter_generated_node_ids | _filter_qmp_events
+                          | _filter_generated_node_ids | _filter_qmp_events \
+                          | _filter_img_info
 }
 
 size=128M
diff --git a/tests/qemu-iotests/067.out b/tests/qemu-iotests/067.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/067.out
+++ b/tests/qemu-iotests/067.out
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728
 
 === -drive/-device and device_del ===
 
-Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk -device virtio-blk,drive=disk,id=virtio0
+Testing: -drive file=TEST_DIR/t.IMGFMT,format=IMGFMT,if=none,id=disk -device virtio-blk,drive=disk,id=virtio0
 {
     QMP_VERSION
 }
@@ -XXX,XX +XXX,XX @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk -device virti
                 "detect_zeroes": "off",
                 "image": {
                     "virtual-size": 134217728,
-                    "filename": "TEST_DIR/t.qcow2",
+                    "filename": "TEST_DIR/t.IMGFMT",
                     "cluster-size": 65536,
-                    "format": "qcow2",
+                    "format": "IMGFMT",
                     "actual-size": SIZE,
-                    "format-specific": {
-                        "type": "qcow2",
-                        "data": {
-                            "compat": "1.1",
-                            "lazy-refcounts": false,
-                            "refcount-bits": 16,
-                            "corrupt": false
-                        }
-                    },
                     "dirty-flag": false
                 },
                 "iops_wr": 0,
                 "ro": false,
                 "node-name": "NODE_NAME",
                 "backing_file_depth": 0,
-                "drv": "qcow2",
+                "drv": "IMGFMT",
                 "iops": 0,
                 "bps_wr": 0,
                 "write_threshold": 0,
@@ -XXX,XX +XXX,XX @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk -device virti
                     "direct": false,
                     "writeback": true
                 },
-                "file": "TEST_DIR/t.qcow2",
+                "file": "TEST_DIR/t.IMGFMT",
                 "encryption_key_missing": false
             },
             "qdev": "/machine/peripheral/virtio0/virtio-backend",
@@ -XXX,XX +XXX,XX @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk -device virti
 
 === -drive/device_add and device_del ===
 
-Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk
+Testing: -drive file=TEST_DIR/t.IMGFMT,format=IMGFMT,if=none,id=disk
 {
     QMP_VERSION
 }
@@ -XXX,XX +XXX,XX @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk
                 "detect_zeroes": "off",
                 "image": {
                     "virtual-size": 134217728,
-                    "filename": "TEST_DIR/t.qcow2",
+                    "filename": "TEST_DIR/t.IMGFMT",
                     "cluster-size": 65536,
-                    "format": "qcow2",
+                    "format": "IMGFMT",
                     "actual-size": SIZE,
-                    "format-specific": {
-                        "type": "qcow2",
-                        "data": {
-                            "compat": "1.1",
-                            "lazy-refcounts": false,
-                            "refcount-bits": 16,
-                            "corrupt": false
-                        }
-                    },
                     "dirty-flag": false
                 },
                 "iops_wr": 0,
                 "ro": false,
                 "node-name": "NODE_NAME",
                 "backing_file_depth": 0,
-                "drv": "qcow2",
+                "drv": "IMGFMT",
                 "iops": 0,
                 "bps_wr": 0,
                 "write_threshold": 0,
@@ -XXX,XX +XXX,XX @@ Testing: -drive file=TEST_DIR/t.qcow2,format=qcow2,if=none,id=disk
                     "direct": false,
                     "writeback": true
                 },
-                "file": "TEST_DIR/t.qcow2",
+                "file": "TEST_DIR/t.IMGFMT",
                 "encryption_key_missing": false
             },
             "type": "unknown"
@@ -XXX,XX +XXX,XX @@ Testing:
                 "detect_zeroes": "off",
                 "image": {
                     "virtual-size": 134217728,
-                    "filename": "TEST_DIR/t.qcow2",
+                    "filename": "TEST_DIR/t.IMGFMT",
                     "cluster-size": 65536,
-                    "format": "qcow2",
+                    "format": "IMGFMT",
                     "actual-size": SIZE,
-                    "format-specific": {
-                        "type": "qcow2",
-                        "data": {
-                            "compat": "1.1",
-                            "lazy-refcounts": false,
-                            "refcount-bits": 16,
-                            "corrupt": false
-                        }
-                    },
                     "dirty-flag": false
                 },
                 "iops_wr": 0,
                 "ro": false,
                 "node-name": "NODE_NAME",
                 "backing_file_depth": 0,
-                "drv": "qcow2",
+                "drv": "IMGFMT",
                 "iops": 0,
                 "bps_wr": 0,
                 "write_threshold": 0,
@@ -XXX,XX +XXX,XX @@ Testing:
                     "direct": false,
                     "writeback": true
                 },
-                "file": "TEST_DIR/t.qcow2",
+                "file": "TEST_DIR/t.IMGFMT",
                 "encryption_key_missing": false
             },
             "type": "unknown"
@@ -XXX,XX +XXX,XX @@ Testing:
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 134217728,
-                "filename": "TEST_DIR/t.qcow2",
+                "filename": "TEST_DIR/t.IMGFMT",
                 "cluster-size": 65536,
-                "format": "qcow2",
+                "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "qcow2",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
                 "dirty-flag": false
             },
             "iops_wr": 0,
             "ro": false,
             "node-name": "disk",
             "backing_file_depth": 0,
-            "drv": "qcow2",
+            "drv": "IMGFMT",
             "iops": 0,
             "bps_wr": 0,
             "write_threshold": 0,
@@ -XXX,XX +XXX,XX @@ Testing:
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2",
+            "file": "TEST_DIR/t.IMGFMT",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ Testing:
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 197120,
-                "filename": "TEST_DIR/t.qcow2",
+                "filename": "TEST_DIR/t.IMGFMT",
                 "format": "file",
                 "actual-size": SIZE,
                 "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ Testing:
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2",
+            "file": "TEST_DIR/t.IMGFMT",
             "encryption_key_missing": false
         }
     ]
@@ -XXX,XX +XXX,XX @@ Testing:
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 134217728,
-                "filename": "TEST_DIR/t.qcow2",
+                "filename": "TEST_DIR/t.IMGFMT",
                 "cluster-size": 65536,
-                "format": "qcow2",
+                "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "qcow2",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
                 "dirty-flag": false
             },
             "iops_wr": 0,
             "ro": false,
             "node-name": "disk",
             "backing_file_depth": 0,
-            "drv": "qcow2",
+            "drv": "IMGFMT",
             "iops": 0,
             "bps_wr": 0,
             "write_threshold": 0,
@@ -XXX,XX +XXX,XX @@ Testing:
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2",
+            "file": "TEST_DIR/t.IMGFMT",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ Testing:
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 197120,
-                "filename": "TEST_DIR/t.qcow2",
+                "filename": "TEST_DIR/t.IMGFMT",
                 "format": "file",
                 "actual-size": SIZE,
                 "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ Testing:
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2",
+            "file": "TEST_DIR/t.IMGFMT",
             "encryption_key_missing": false
         }
     ]
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

The only thing that is missing is a _filter_img_info after the
"$QEMU_IO -c info" invocations.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-15-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/089     |  4 ++--
 tests/qemu-iotests/089.out | 10 ----------
 2 files changed, 2 insertions(+), 12 deletions(-)

diff --git a/tests/qemu-iotests/089 b/tests/qemu-iotests/089
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/089
+++ b/tests/qemu-iotests/089
@@ -XXX,XX +XXX,XX @@ echo
 
 # Both options given directly and those given in the filename should be used
 $QEMU_IO -c "open -o driver=qcow2 json:{\"file.filename\":\"$TEST_IMG\"}" \
-         -c "info" 2>&1 | _filter_testdir | _filter_imgfmt
+         -c "info" 2>&1 | _filter_img_info
 
 # Options given directly should be prioritized over those given in the filename
 $QEMU_IO -c "open -o driver=qcow2 json:{\"driver\":\"raw\",\"file.filename\":\"$TEST_IMG\"}" \
-         -c "info" 2>&1 | _filter_testdir | _filter_imgfmt
+         -c "info" 2>&1 | _filter_img_info
 
 
 # success, all done
diff --git a/tests/qemu-iotests/089.out b/tests/qemu-iotests/089.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/089.out
+++ b/tests/qemu-iotests/089.out
@@ -XXX,XX +XXX,XX @@ cluster_size: 65536
 format name: IMGFMT
 cluster size: 64 KiB
 vm state offset: 512 MiB
-Format specific information:
-    compat: 1.1
-    lazy refcounts: false
-    refcount bits: 16
-    corrupt: false
 format name: IMGFMT
 cluster size: 64 KiB
 vm state offset: 512 MiB
-Format specific information:
-    compat: 1.1
-    lazy refcounts: false
-    refcount bits: 16
-    corrupt: false
 *** done
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

184 does not need an image, so don't use one.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-16-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/184     | 25 ++++--------------
 tests/qemu-iotests/184.out | 63 +++++++---------------------------------------
 2 files changed, 14 insertions(+), 74 deletions(-)

diff --git a/tests/qemu-iotests/184 b/tests/qemu-iotests/184
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/184
+++ b/tests/qemu-iotests/184
@@ -XXX,XX +XXX,XX @@ echo "QA output created by $seq"
 here=`pwd`
 status=1	# failure is the default!
 
-_cleanup()
-{
-    _cleanup_test_img
-}
-trap "_cleanup; exit \$status" 0 1 2 3 15
+trap "exit \$status" 0 1 2 3 15
 
 # get standard environment, filters and checks
 . ./common.rc
 . ./common.filter
 
-_supported_fmt qcow2
-_supported_proto file
 _supported_os Linux
 
 function do_run_qemu()
@@ -XXX,XX +XXX,XX @@ function run_qemu()
                           | _filter_actual_image_size
 }
 
-_make_test_img 64M
 test_throttle=$($QEMU_IMG --help|grep throttle)
 [ "$test_throttle" = "" ] && _supported_fmt throttle
 
@@ -XXX,XX +XXX,XX @@ run_qemu <<EOF
 { "execute": "qmp_capabilities" }
 { "execute": "blockdev-add",
   "arguments": {
-    "driver": "$IMGFMT",
-    "node-name": "disk0",
-    "file": {
-      "driver": "file",
-      "filename": "$TEST_IMG"
-    }
+    "driver": "null-co",
+    "node-name": "disk0"
   }
 }
 { "execute": "object-add",
@@ -XXX,XX +XXX,XX @@ run_qemu <<EOF
 { "execute": "qmp_capabilities" }
 { "execute": "blockdev-add",
   "arguments": {
-    "driver": "$IMGFMT",
-    "node-name": "disk0",
-    "file": {
-      "driver": "file",
-      "filename": "$TEST_IMG"
-    }
+    "driver": "null-co",
+    "node-name": "disk0"
   }
 }
 { "execute": "blockdev-add",
diff --git a/tests/qemu-iotests/184.out b/tests/qemu-iotests/184.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/184.out
+++ b/tests/qemu-iotests/184.out
@@ -XXX,XX +XXX,XX @@
 QA output created by 184
-Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864
 
 == checking interface ==
 Testing:
@@ -XXX,XX +XXX,XX @@ Testing:
             "iops_rd": 0,
             "detect_zeroes": "off",
             "image": {
-                "virtual-size": 67108864,
-                "filename": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"qcow2\", \"file\": {\"driver\": \"file\", \"filename\": \"TEST_DIR/t.qcow2\"}}}",
-                "cluster-size": 65536,
-                "format": "throttle",
-                "actual-size": SIZE,
-                "dirty-flag": false
+                "virtual-size": 1073741824,
+                "filename": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"null-co\"}}",
+                "format": "throttle"
             },
             "iops_wr": 0,
             "ro": false,
@@ -XXX,XX +XXX,XX @@ Testing:
                 "direct": false,
                 "writeback": true
             },
-            "file": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"qcow2\", \"file\": {\"driver\": \"file\", \"filename\": \"TEST_DIR/t.qcow2\"}}}",
+            "file": "json:{\"throttle-group\": \"group0\", \"driver\": \"throttle\", \"file\": {\"driver\": \"null-co\"}}",
             "encryption_key_missing": false
         },
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
             "image": {
-                "virtual-size": 67108864,
-                "filename": "TEST_DIR/t.qcow2",
-                "cluster-size": 65536,
-                "format": "qcow2",
-                "actual-size": SIZE,
-                "format-specific": {
-                    "type": "qcow2",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
-                "dirty-flag": false
+                "virtual-size": 1073741824,
+                "filename": "null-co://",
+                "format": "null-co"
             },
             "iops_wr": 0,
             "ro": false,
             "node-name": "disk0",
             "backing_file_depth": 0,
-            "drv": "qcow2",
+            "drv": "null-co",
             "iops": 0,
             "bps_wr": 0,
             "write_threshold": 0,
@@ -XXX,XX +XXX,XX @@ Testing:
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2",
-            "encryption_key_missing": false
-        },
-        {
-            "iops_rd": 0,
-            "detect_zeroes": "off",
-            "image": {
-                "virtual-size": 197120,
-                "filename": "TEST_DIR/t.qcow2",
-                "format": "file",
-                "actual-size": SIZE,
-                "dirty-flag": false
-            },
-            "iops_wr": 0,
-            "ro": false,
-            "node-name": "NODE_NAME",
-            "backing_file_depth": 0,
-            "drv": "file",
-            "iops": 0,
-            "bps_wr": 0,
-            "write_threshold": 0,
-            "encrypted": false,
-            "bps": 0,
-            "bps_rd": 0,
-            "cache": {
-                "no-flush": false,
-                "direct": false,
-                "writeback": true
-            },
-            "file": "TEST_DIR/t.qcow2",
+            "file": "null-co://",
             "encryption_key_missing": false
         }
     ]
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

In order for 191 to work with an explicit refcount_bits or compat=0.10,
we should strip format-specific information from the output--and we can
do so by using _filter_img_info.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-17-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/191     |   5 +-
 tests/qemu-iotests/191.out | 313 +++++++++++++--------------------------------
 2 files changed, 91 insertions(+), 227 deletions(-)

diff --git a/tests/qemu-iotests/191 b/tests/qemu-iotests/191
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/191
+++ b/tests/qemu-iotests/191
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 . ./common.qemu
 
 _supported_fmt qcow2
-_unsupported_imgopts compat=0.10
 _supported_proto file
 _supported_os Linux
 
@@ -XXX,XX +XXX,XX @@ echo === Check that both top and top2 point to base now ===
 echo
 
 _send_qemu_cmd $h "{ 'execute': 'query-named-block-nodes' }" "^}" |
-    _filter_generated_node_ids | _filter_actual_image_size
+    _filter_generated_node_ids | _filter_actual_image_size | _filter_img_info
 
 _send_qemu_cmd $h "{ 'execute': 'quit' }" "^}"
 wait=1 _cleanup_qemu
@@ -XXX,XX +XXX,XX @@ echo === Check that both top and top2 point to base now ===
 echo
 
 _send_qemu_cmd $h "{ 'execute': 'query-named-block-nodes' }" "^}" |
-    _filter_generated_node_ids | _filter_actual_image_size
+    _filter_generated_node_ids | _filter_actual_image_size | _filter_img_info
 
 _send_qemu_cmd $h "{ 'execute': 'quit' }" "^}"
 wait=1 _cleanup_qemu
diff --git a/tests/qemu-iotests/191.out b/tests/qemu-iotests/191.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/191.out
+++ b/tests/qemu-iotests/191.out
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "image": {
                 "backing-image": {
                     "virtual-size": 67108864,
-                    "filename": "TEST_DIR/t.qcow2.base",
+                    "filename": "TEST_DIR/t.IMGFMT.base",
                     "cluster-size": 65536,
-                    "format": "qcow2",
+                    "format": "IMGFMT",
                     "actual-size": SIZE,
-                    "format-specific": {
-                        "type": "qcow2",
-                        "data": {
-                            "compat": "1.1",
-                            "lazy-refcounts": false,
-                            "refcount-bits": 16,
-                            "corrupt": false
-                        }
-                    },
                     "dirty-flag": false
                 },
-                "backing-filename-format": "qcow2",
+                "backing-filename-format": "IMGFMT",
                 "virtual-size": 67108864,
-                "filename": "TEST_DIR/t.qcow2.ovl2",
+                "filename": "TEST_DIR/t.IMGFMT.ovl2",
                 "cluster-size": 65536,
-                "format": "qcow2",
+                "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "qcow2",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
-                "full-backing-filename": "TEST_DIR/t.qcow2.base",
-                "backing-filename": "TEST_DIR/t.qcow2.base",
+                "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
+                "backing-filename": "TEST_DIR/t.IMGFMT.base",
                 "dirty-flag": false
             },
             "iops_wr": 0,
             "ro": false,
             "node-name": "top2",
             "backing_file_depth": 1,
-            "drv": "qcow2",
+            "drv": "IMGFMT",
             "iops": 0,
             "bps_wr": 0,
             "write_threshold": 0,
-            "backing_file": "TEST_DIR/t.qcow2.base",
+            "backing_file": "TEST_DIR/t.IMGFMT.base",
             "encrypted": false,
             "bps": 0,
             "bps_rd": 0,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.ovl2",
+            "file": "TEST_DIR/t.IMGFMT.ovl2",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 197120,
-                "filename": "TEST_DIR/t.qcow2.ovl2",
+                "filename": "TEST_DIR/t.IMGFMT.ovl2",
                 "format": "file",
                 "actual-size": SIZE,
                 "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.ovl2",
+            "file": "TEST_DIR/t.IMGFMT.ovl2",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "image": {
                 "backing-image": {
                     "virtual-size": 67108864,
-                    "filename": "TEST_DIR/t.qcow2.base",
+                    "filename": "TEST_DIR/t.IMGFMT.base",
                     "cluster-size": 65536,
-                    "format": "qcow2",
+                    "format": "IMGFMT",
                     "actual-size": SIZE,
-                    "format-specific": {
-                        "type": "qcow2",
-                        "data": {
-                            "compat": "1.1",
-                            "lazy-refcounts": false,
-                            "refcount-bits": 16,
-                            "corrupt": false
-                        }
-                    },
                     "dirty-flag": false
                 },
-                "backing-filename-format": "qcow2",
+                "backing-filename-format": "IMGFMT",
                 "virtual-size": 67108864,
-                "filename": "TEST_DIR/t.qcow2",
+                "filename": "TEST_DIR/t.IMGFMT",
                 "cluster-size": 65536,
-                "format": "qcow2",
+                "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "qcow2",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
-                "full-backing-filename": "TEST_DIR/t.qcow2.base",
-                "backing-filename": "TEST_DIR/t.qcow2.base",
+                "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
+                "backing-filename": "TEST_DIR/t.IMGFMT.base",
                 "dirty-flag": false
             },
             "iops_wr": 0,
             "ro": false,
             "node-name": "top",
             "backing_file_depth": 1,
-            "drv": "qcow2",
+            "drv": "IMGFMT",
             "iops": 0,
             "bps_wr": 0,
             "write_threshold": 0,
-            "backing_file": "TEST_DIR/t.qcow2.base",
+            "backing_file": "TEST_DIR/t.IMGFMT.base",
             "encrypted": false,
             "bps": 0,
             "bps_rd": 0,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2",
+            "file": "TEST_DIR/t.IMGFMT",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 197120,
-                "filename": "TEST_DIR/t.qcow2",
+                "filename": "TEST_DIR/t.IMGFMT",
                 "format": "file",
                 "actual-size": SIZE,
                 "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2",
+            "file": "TEST_DIR/t.IMGFMT",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "image": {
                 "backing-image": {
                     "virtual-size": 67108864,
-                    "filename": "TEST_DIR/t.qcow2.base",
+                    "filename": "TEST_DIR/t.IMGFMT.base",
                     "cluster-size": 65536,
-                    "format": "qcow2",
+                    "format": "IMGFMT",
                     "actual-size": SIZE,
-                    "format-specific": {
-                        "type": "qcow2",
-                        "data": {
-                            "compat": "1.1",
-                            "lazy-refcounts": false,
-                            "refcount-bits": 16,
-                            "corrupt": false
-                        }
-                    },
                     "dirty-flag": false
                 },
-                "backing-filename-format": "qcow2",
+                "backing-filename-format": "IMGFMT",
                 "virtual-size": 67108864,
-                "filename": "TEST_DIR/t.qcow2.mid",
+                "filename": "TEST_DIR/t.IMGFMT.mid",
                 "cluster-size": 65536,
-                "format": "qcow2",
+                "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "qcow2",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
-                "full-backing-filename": "TEST_DIR/t.qcow2.base",
-                "backing-filename": "TEST_DIR/t.qcow2.base",
+                "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
+                "backing-filename": "TEST_DIR/t.IMGFMT.base",
                 "dirty-flag": false
             },
             "iops_wr": 0,
             "ro": false,
             "node-name": "mid",
             "backing_file_depth": 1,
-            "drv": "qcow2",
+            "drv": "IMGFMT",
             "iops": 0,
             "bps_wr": 0,
             "write_threshold": 0,
-            "backing_file": "TEST_DIR/t.qcow2.base",
+            "backing_file": "TEST_DIR/t.IMGFMT.base",
             "encrypted": false,
             "bps": 0,
             "bps_rd": 0,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.mid",
+            "file": "TEST_DIR/t.IMGFMT.mid",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 393216,
-                "filename": "TEST_DIR/t.qcow2.mid",
+                "filename": "TEST_DIR/t.IMGFMT.mid",
                 "format": "file",
                 "actual-size": SIZE,
                 "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.mid",
+            "file": "TEST_DIR/t.IMGFMT.mid",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 67108864,
-                "filename": "TEST_DIR/t.qcow2.base",
+                "filename": "TEST_DIR/t.IMGFMT.base",
                 "cluster-size": 65536,
-                "format": "qcow2",
+                "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "qcow2",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
                 "dirty-flag": false
             },
             "iops_wr": 0,
             "ro": false,
             "node-name": "base",
             "backing_file_depth": 0,
-            "drv": "qcow2",
+            "drv": "IMGFMT",
             "iops": 0,
             "bps_wr": 0,
             "write_threshold": 0,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.base",
+            "file": "TEST_DIR/t.IMGFMT.base",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 393216,
-                "filename": "TEST_DIR/t.qcow2.base",
+                "filename": "TEST_DIR/t.IMGFMT.base",
                 "format": "file",
                 "actual-size": SIZE,
                 "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.base",
+            "file": "TEST_DIR/t.IMGFMT.base",
             "encryption_key_missing": false
         }
     ]
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "image": {
                 "backing-image": {
                     "virtual-size": 67108864,
-                    "filename": "TEST_DIR/t.qcow2.base",
+                    "filename": "TEST_DIR/t.IMGFMT.base",
                     "cluster-size": 65536,
-                    "format": "qcow2",
+                    "format": "IMGFMT",
                     "actual-size": SIZE,
-                    "format-specific": {
-                        "type": "qcow2",
-                        "data": {
-                            "compat": "1.1",
-                            "lazy-refcounts": false,
-                            "refcount-bits": 16,
-                            "corrupt": false
-                        }
-                    },
                     "dirty-flag": false
                 },
-                "backing-filename-format": "qcow2",
+                "backing-filename-format": "IMGFMT",
                 "virtual-size": 67108864,
-                "filename": "TEST_DIR/t.qcow2.ovl2",
+                "filename": "TEST_DIR/t.IMGFMT.ovl2",
                 "cluster-size": 65536,
-                "format": "qcow2",
+                "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "qcow2",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
-                "full-backing-filename": "TEST_DIR/t.qcow2.base",
-                "backing-filename": "TEST_DIR/t.qcow2.base",
+                "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
+                "backing-filename": "TEST_DIR/t.IMGFMT.base",
                 "dirty-flag": false
             },
             "iops_wr": 0,
             "ro": true,
             "node-name": "NODE_NAME",
             "backing_file_depth": 1,
-            "drv": "qcow2",
+            "drv": "IMGFMT",
             "iops": 0,
             "bps_wr": 0,
             "write_threshold": 0,
-            "backing_file": "TEST_DIR/t.qcow2.base",
+            "backing_file": "TEST_DIR/t.IMGFMT.base",
             "encrypted": false,
             "bps": 0,
             "bps_rd": 0,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.ovl2",
+            "file": "TEST_DIR/t.IMGFMT.ovl2",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 197120,
-                "filename": "TEST_DIR/t.qcow2.ovl2",
+                "filename": "TEST_DIR/t.IMGFMT.ovl2",
                 "format": "file",
                 "actual-size": SIZE,
                 "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.ovl2",
+            "file": "TEST_DIR/t.IMGFMT.ovl2",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "backing-image": {
                     "backing-image": {
                         "virtual-size": 67108864,
-                        "filename": "TEST_DIR/t.qcow2.base",
+                        "filename": "TEST_DIR/t.IMGFMT.base",
                         "cluster-size": 65536,
-                        "format": "qcow2",
+                        "format": "IMGFMT",
                         "actual-size": SIZE,
-                        "format-specific": {
-                            "type": "qcow2",
-                            "data": {
-                                "compat": "1.1",
-                                "lazy-refcounts": false,
-                                "refcount-bits": 16,
-                                "corrupt": false
-                            }
-                        },
                         "dirty-flag": false
                     },
-                    "backing-filename-format": "qcow2",
+                    "backing-filename-format": "IMGFMT",
                     "virtual-size": 67108864,
-                    "filename": "TEST_DIR/t.qcow2.ovl2",
+                    "filename": "TEST_DIR/t.IMGFMT.ovl2",
                     "cluster-size": 65536,
-                    "format": "qcow2",
+                    "format": "IMGFMT",
                     "actual-size": SIZE,
-                    "format-specific": {
-                        "type": "qcow2",
-                        "data": {
-                            "compat": "1.1",
-                            "lazy-refcounts": false,
-                            "refcount-bits": 16,
-                            "corrupt": false
-                        }
-                    },
-                    "full-backing-filename": "TEST_DIR/t.qcow2.base",
-                    "backing-filename": "TEST_DIR/t.qcow2.base",
+                    "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
+                    "backing-filename": "TEST_DIR/t.IMGFMT.base",
                     "dirty-flag": false
                 },
-                "backing-filename-format": "qcow2",
+                "backing-filename-format": "IMGFMT",
                 "virtual-size": 67108864,
-                "filename": "TEST_DIR/t.qcow2.ovl3",
+                "filename": "TEST_DIR/t.IMGFMT.ovl3",
                 "cluster-size": 65536,
-                "format": "qcow2",
+                "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "qcow2",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
-                "full-backing-filename": "TEST_DIR/t.qcow2.ovl2",
-                "backing-filename": "TEST_DIR/t.qcow2.ovl2",
+                "full-backing-filename": "TEST_DIR/t.IMGFMT.ovl2",
+                "backing-filename": "TEST_DIR/t.IMGFMT.ovl2",
                 "dirty-flag": false
             },
             "iops_wr": 0,
             "ro": false,
             "node-name": "top2",
             "backing_file_depth": 2,
-            "drv": "qcow2",
+            "drv": "IMGFMT",
             "iops": 0,
             "bps_wr": 0,
             "write_threshold": 0,
-            "backing_file": "TEST_DIR/t.qcow2.ovl2",
+            "backing_file": "TEST_DIR/t.IMGFMT.ovl2",
             "encrypted": false,
             "bps": 0,
             "bps_rd": 0,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.ovl3",
+            "file": "TEST_DIR/t.IMGFMT.ovl3",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 197120,
-                "filename": "TEST_DIR/t.qcow2.ovl3",
+                "filename": "TEST_DIR/t.IMGFMT.ovl3",
                 "format": "file",
                 "actual-size": SIZE,
                 "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.ovl3",
+            "file": "TEST_DIR/t.IMGFMT.ovl3",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 67108864,
-                "filename": "TEST_DIR/t.qcow2.base",
+                "filename": "TEST_DIR/t.IMGFMT.base",
                 "cluster-size": 65536,
-                "format": "qcow2",
+                "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "qcow2",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
                 "dirty-flag": false
             },
             "iops_wr": 0,
             "ro": true,
             "node-name": "NODE_NAME",
             "backing_file_depth": 0,
-            "drv": "qcow2",
+            "drv": "IMGFMT",
             "iops": 0,
             "bps_wr": 0,
             "write_threshold": 0,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.base",
+            "file": "TEST_DIR/t.IMGFMT.base",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 393216,
-                "filename": "TEST_DIR/t.qcow2.base",
+                "filename": "TEST_DIR/t.IMGFMT.base",
                 "format": "file",
                 "actual-size": SIZE,
                 "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2.base",
+            "file": "TEST_DIR/t.IMGFMT.base",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "image": {
                 "backing-image": {
                     "virtual-size": 67108864,
-                    "filename": "TEST_DIR/t.qcow2.base",
+                    "filename": "TEST_DIR/t.IMGFMT.base",
                     "cluster-size": 65536,
-                    "format": "qcow2",
+                    "format": "IMGFMT",
                     "actual-size": SIZE,
-                    "format-specific": {
-                        "type": "qcow2",
-                        "data": {
-                            "compat": "1.1",
-                            "lazy-refcounts": false,
-                            "refcount-bits": 16,
-                            "corrupt": false
-                        }
-                    },
                     "dirty-flag": false
                 },
-                "backing-filename-format": "qcow2",
+                "backing-filename-format": "IMGFMT",
                 "virtual-size": 67108864,
-                "filename": "TEST_DIR/t.qcow2",
+                "filename": "TEST_DIR/t.IMGFMT",
                 "cluster-size": 65536,
-                "format": "qcow2",
+                "format": "IMGFMT",
                 "actual-size": SIZE,
-                "format-specific": {
-                    "type": "qcow2",
-                    "data": {
-                        "compat": "1.1",
-                        "lazy-refcounts": false,
-                        "refcount-bits": 16,
-                        "corrupt": false
-                    }
-                },
-                "full-backing-filename": "TEST_DIR/t.qcow2.base",
-                "backing-filename": "TEST_DIR/t.qcow2.base",
+                "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
+                "backing-filename": "TEST_DIR/t.IMGFMT.base",
                 "dirty-flag": false
             },
             "iops_wr": 0,
             "ro": false,
             "node-name": "top",
             "backing_file_depth": 1,
-            "drv": "qcow2",
+            "drv": "IMGFMT",
             "iops": 0,
             "bps_wr": 0,
             "write_threshold": 0,
-            "backing_file": "TEST_DIR/t.qcow2.base",
+            "backing_file": "TEST_DIR/t.IMGFMT.base",
             "encrypted": false,
             "bps": 0,
             "bps_rd": 0,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2",
+            "file": "TEST_DIR/t.IMGFMT",
             "encryption_key_missing": false
         },
         {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
             "detect_zeroes": "off",
             "image": {
                 "virtual-size": 197120,
-                "filename": "TEST_DIR/t.qcow2",
+                "filename": "TEST_DIR/t.IMGFMT",
                 "format": "file",
                 "actual-size": SIZE,
                 "dirty-flag": false
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
                 "direct": false,
                 "writeback": true
             },
-            "file": "TEST_DIR/t.qcow2",
+            "file": "TEST_DIR/t.IMGFMT",
             "encryption_key_missing": false
         }
     ]
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

There is a bit of image-specific information which depends on the qcow2
compat level.  Filter it so that 198 works with compat=0.10 (and any
refcount_bits value).

Note that we cannot simply drop the --format-specific switch because we
do need the "encrypt" information.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-id: 20171123020832.8165-18-mreitz@redhat.com
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/198     | 6 ++++--
 tests/qemu-iotests/198.out | 8 --------
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/tests/qemu-iotests/198 b/tests/qemu-iotests/198
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/198
+++ b/tests/qemu-iotests/198
@@ -XXX,XX +XXX,XX @@ $QEMU_IO --object $SECRET0 --object $SECRET1 -c "read -P 0x9 0 $size" --image-op
 echo
 echo "== checking image base =="
 $QEMU_IMG info --image-opts $IMGSPECBASE | _filter_img_info --format-specific \
-    | sed -e "/^disk size:/ D"
+    | sed -e "/^disk size:/ D" -e '/refcount bits:/ D' -e '/compat:/ D' \
+          -e '/lazy refcounts:/ D' -e '/corrupt:/ D'
 
 echo
 echo "== checking image layer =="
 $QEMU_IMG info --image-opts $IMGSPECLAYER | _filter_img_info --format-specific \
-    | sed -e "/^disk size:/ D"
+    | sed -e "/^disk size:/ D" -e '/refcount bits:/ D' -e '/compat:/ D' \
+          -e '/lazy refcounts:/ D' -e '/corrupt:/ D'
 
 
 # success, all done
diff --git a/tests/qemu-iotests/198.out b/tests/qemu-iotests/198.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/198.out
+++ b/tests/qemu-iotests/198.out
@@ -XXX,XX +XXX,XX @@ image: json:{"encrypt.key-secret": "sec0", "driver": "IMGFMT", "file": {"driver"
 file format: IMGFMT
 virtual size: 16M (16777216 bytes)
 Format specific information:
-    compat: 1.1
-    lazy refcounts: false
-    refcount bits: 16
     encrypt:
         ivgen alg: plain64
         hash alg: sha256
@@ -XXX,XX +XXX,XX @@ Format specific information:
                 key offset: 1810432
         payload offset: 2068480
         master key iters: 1024
-    corrupt: false
 
 == checking image layer ==
 image: json:{"encrypt.key-secret": "sec1", "driver": "IMGFMT", "file": {"driver": "file", "filename": "TEST_DIR/t.IMGFMT"}}
@@ -XXX,XX +XXX,XX @@ file format: IMGFMT
 virtual size: 16M (16777216 bytes)
 backing file: TEST_DIR/t.IMGFMT.base
 Format specific information:
-    compat: 1.1
-    lazy refcounts: false
-    refcount bits: 16
     encrypt:
         ivgen alg: plain64
         hash alg: sha256
@@ -XXX,XX +XXX,XX @@ Format specific information:
                 key offset: 1810432
         payload offset: 2068480
         master key iters: 1024
-    corrupt: false
 *** done
-- 
2.13.6

From: Eric Blake <eblake@redhat.com>

When originally written, test 177 explicitly took care to run
with compat=0.10.  Then I botched my own test in commit
81c219ac and f0a9c18f, by adding additional actions that require
v3 images.  Split out the new code into a new v3-only test, 204,
and revert 177 back to its original state other than a new comment.

Reported-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-id: 20180117165420.15946-2-eblake@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/177     |  20 +++-----
 tests/qemu-iotests/177.out |  22 ++-------
 tests/qemu-iotests/204     | 119 +++++++++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/204.out |  63 ++++++++++++++++++++++++
 tests/qemu-iotests/group   |   1 +
 5 files changed, 193 insertions(+), 32 deletions(-)
 create mode 100755 tests/qemu-iotests/204
 create mode 100644 tests/qemu-iotests/204.out

diff --git a/tests/qemu-iotests/177 b/tests/qemu-iotests/177
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/177
+++ b/tests/qemu-iotests/177
@@ -XXX,XX +XXX,XX @@
 #
 # Test corner cases with unusual block geometries
 #
-# Copyright (C) 2016-2017 Red Hat, Inc.
+# Copyright (C) 2016-2018 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
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 . ./common.rc
 . ./common.filter
 
+# This test is runnable under compat=0.10; see test 204 for additional
+# tests specific to compat=1.1.
+
 _supported_fmt qcow2
 _supported_proto file
 
 CLUSTER_SIZE=1M
 size=128M
 options=driver=blkdebug,image.driver=qcow2
-nested_opts=image.file.driver=file,image.file.filename=$TEST_IMG
 
 echo
 echo "== setting up files =="
@@ -XXX,XX +XXX,XX @@ echo "== setting up files =="
 TEST_IMG="$TEST_IMG.base" _make_test_img $size
 $QEMU_IO -c "write -P 11 0 $size" "$TEST_IMG.base" | _filter_qemu_io
 _make_test_img -b "$TEST_IMG.base"
-$QEMU_IO -c "write -P 22 0 110M" "$TEST_IMG" | _filter_qemu_io
+$QEMU_IO -c "write -P 22 0 $size" "$TEST_IMG" | _filter_qemu_io
 
 # Limited to 64k max-transfer
 echo
@@ -XXX,XX +XXX,XX @@ $QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
          -c "discard 80000001 30M" | _filter_qemu_io
 
 echo
-echo "== block status smaller than alignment =="
-limits=align=4k
-$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
-	 -c "alloc 1 1" -c "alloc 0x6dffff0 1000" -c "alloc 127m 5P" \
-	 -c map | _filter_qemu_io
-
-echo
 echo "== verify image content =="
 
 function verify_io()
@@ -XXX,XX +XXX,XX @@ function verify_io()
     echo read -P 0 32M 32M
     echo read -P 22 64M 13M
     echo read -P $discarded 77M 29M
-    echo read -P 22 106M 4M
-    echo read -P 11 110M 18M
+    echo read -P 22 106M 22M
 }
 
 verify_io | $QEMU_IO -r "$TEST_IMG" | _filter_qemu_io
-$QEMU_IMG map --image-opts "$options,$nested_opts,align=4k" \
-    | _filter_qemu_img_map
 
 _check_test_img
 
diff --git a/tests/qemu-iotests/177.out b/tests/qemu-iotests/177.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/177.out
+++ b/tests/qemu-iotests/177.out
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=134217728
 wrote 134217728/134217728 bytes at offset 0
 128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/t.IMGFMT.base
-wrote 115343360/115343360 bytes at offset 0
-110 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 134217728/134217728 bytes at offset 0
+128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
 == constrained alignment and max-transfer ==
 wrote 131072/131072 bytes at offset 1000
@@ -XXX,XX +XXX,XX @@ wrote 33554432/33554432 bytes at offset 33554432
 discard 31457280/31457280 bytes at offset 80000001
 30 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 
-== block status smaller than alignment ==
-1/1 bytes allocated at offset 1 bytes
-16/1000 bytes allocated at offset 110 MiB
-0/1048576 bytes allocated at offset 127 MiB
-110 MiB (0x6e00000) bytes     allocated at offset 0 bytes (0x0)
-18 MiB (0x1200000) bytes not allocated at offset 110 MiB (0x6e00000)
-
 == verify image content ==
 read 1000/1000 bytes at offset 0
 1000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
@@ -XXX,XX +XXX,XX @@ read 13631488/13631488 bytes at offset 67108864
 13 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 read 30408704/30408704 bytes at offset 80740352
 29 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-read 4194304/4194304 bytes at offset 111149056
-4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-read 18874368/18874368 bytes at offset 115343360
-18 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-Offset          Length          File
-0               0x800000        TEST_DIR/t.IMGFMT
-0x900000        0x2400000       TEST_DIR/t.IMGFMT
-0x3c00000       0x1100000       TEST_DIR/t.IMGFMT
-0x6a00000       0x400000        TEST_DIR/t.IMGFMT
+read 23068672/23068672 bytes at offset 111149056
+22 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 No errors were found on the image.
 *** done
diff --git a/tests/qemu-iotests/204 b/tests/qemu-iotests/204
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/204
@@ -XXX,XX +XXX,XX @@
+#!/bin/bash
+#
+# Test corner cases with unusual block geometries
+#
+# Copyright (C) 2016-2018 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=eblake@redhat.com
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+here=`pwd`
+status=1	# failure is the default!
+
+_cleanup()
+{
+	_cleanup_test_img
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+
+_supported_fmt qcow2
+_supported_proto file
+# This test assumes that discard leaves zero clusters; see test 177 for
+# other tests that also work in older images
+_unsupported_imgopts 'compat=0.10'
+
+CLUSTER_SIZE=1M
+size=128M
+options=driver=blkdebug,image.driver=qcow2
+nested_opts=image.file.driver=file,image.file.filename=$TEST_IMG
+
+echo
+echo "== setting up files =="
+
+TEST_IMG="$TEST_IMG.base" _make_test_img $size
+$QEMU_IO -c "write -P 11 0 $size" "$TEST_IMG.base" | _filter_qemu_io
+_make_test_img -b "$TEST_IMG.base"
+$QEMU_IO -c "write -P 22 0 110M" "$TEST_IMG" | _filter_qemu_io
+
+# Limited to 64k max-transfer
+echo
+echo "== constrained alignment and max-transfer =="
+limits=align=4k,max-transfer=64k
+$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
+         -c "write -P 33 1000 128k" -c "read -P 33 1000 128k" | _filter_qemu_io
+
+echo
+echo "== write zero with constrained max-transfer =="
+limits=align=512,max-transfer=64k,opt-write-zero=$CLUSTER_SIZE
+$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
+         -c "write -z 8003584 2093056" | _filter_qemu_io
+
+# non-power-of-2 write-zero/discard alignments
+echo
+echo "== non-power-of-2 write zeroes limits =="
+
+limits=align=512,opt-write-zero=15M,max-write-zero=15M,opt-discard=15M,max-discard=15M
+$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
+         -c "write -z 32M 32M" | _filter_qemu_io
+
+echo
+echo "== non-power-of-2 discard limits =="
+
+limits=align=512,opt-write-zero=15M,max-write-zero=15M,opt-discard=15M,max-discard=15M
+$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
+         -c "discard 80000001 30M" | _filter_qemu_io
+
+echo
+echo "== block status smaller than alignment =="
+limits=align=4k
+$QEMU_IO -c "open -o $options,$limits blkdebug::$TEST_IMG" \
+	 -c "alloc 1 1" -c "alloc 0x6dffff0 1000" -c "alloc 127m 5P" \
+	 -c map | _filter_qemu_io
+
+echo
+echo "== verify image content =="
+
+function verify_io()
+{
+    echo read -P 22 0 1000
+    echo read -P 33 1000 128k
+    echo read -P 22 132072 7871512
+    echo read -P 0 8003584 2093056
+    echo read -P 22 10096640 23457792
+    echo read -P 0 32M 32M
+    echo read -P 22 64M 13M
+    echo read -P 0 77M 29M
+    echo read -P 22 106M 4M
+    echo read -P 11 110M 18M
+}
+
+verify_io | $QEMU_IO -r "$TEST_IMG" | _filter_qemu_io
+$QEMU_IMG map --image-opts "$options,$nested_opts,align=4k" \
+    | _filter_qemu_img_map
+
+_check_test_img
+
+# success, all done
+echo "*** done"
+status=0
diff --git a/tests/qemu-iotests/204.out b/tests/qemu-iotests/204.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/204.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 204
+
+== setting up files ==
+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=134217728
+wrote 134217728/134217728 bytes at offset 0
+128 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=134217728 backing_file=TEST_DIR/t.IMGFMT.base
+wrote 115343360/115343360 bytes at offset 0
+110 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== constrained alignment and max-transfer ==
+wrote 131072/131072 bytes at offset 1000
+128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 131072/131072 bytes at offset 1000
+128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== write zero with constrained max-transfer ==
+wrote 2093056/2093056 bytes at offset 8003584
+1.996 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== non-power-of-2 write zeroes limits ==
+wrote 33554432/33554432 bytes at offset 33554432
+32 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== non-power-of-2 discard limits ==
+discard 31457280/31457280 bytes at offset 80000001
+30 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+== block status smaller than alignment ==
+1/1 bytes allocated at offset 1 bytes
+16/1000 bytes allocated at offset 110 MiB
+0/1048576 bytes allocated at offset 127 MiB
+110 MiB (0x6e00000) bytes     allocated at offset 0 bytes (0x0)
+18 MiB (0x1200000) bytes not allocated at offset 110 MiB (0x6e00000)
+
+== verify image content ==
+read 1000/1000 bytes at offset 0
+1000 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 131072/131072 bytes at offset 1000
+128 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 7871512/7871512 bytes at offset 132072
+7.507 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 2093056/2093056 bytes at offset 8003584
+1.996 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 23457792/23457792 bytes at offset 10096640
+22.371 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 33554432/33554432 bytes at offset 33554432
+32 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 13631488/13631488 bytes at offset 67108864
+13 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 30408704/30408704 bytes at offset 80740352
+29 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 4194304/4194304 bytes at offset 111149056
+4 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 18874368/18874368 bytes at offset 115343360
+18 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+Offset          Length          File
+0               0x800000        TEST_DIR/t.IMGFMT
+0x900000        0x2400000       TEST_DIR/t.IMGFMT
+0x3c00000       0x1100000       TEST_DIR/t.IMGFMT
+0x6a00000       0x400000        TEST_DIR/t.IMGFMT
+No errors were found on the image.
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 201 rw auto migration
 202 rw auto quick
 203 rw auto
+204 rw auto quick
-- 
2.13.6

From: Max Reitz <mreitz@redhat.com>

Tests 080, 130, 137, and 176 simply do not work with compat=0.10 for the
reasons stated there.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20171123020832.8165-10-mreitz@redhat.com>
[eblake: fix 177 in a separate commit]
Signed-off-by: Eric Blake <eblake@redhat.com>
Message-id: 20180117165420.15946-3-eblake@redhat.com
Signed-off-by: Max Reitz <mreitz@redhat.com>
---
 tests/qemu-iotests/080 | 5 +++--
 tests/qemu-iotests/130 | 2 ++
 tests/qemu-iotests/137 | 2 ++
 tests/qemu-iotests/176 | 2 ++
 4 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/080 b/tests/qemu-iotests/080
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/080
+++ b/tests/qemu-iotests/080
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2
 _supported_proto file
 _supported_os Linux
-# Internal snapshots are (currently) impossible with refcount_bits=1
-_unsupported_imgopts 'refcount_bits=1[^0-9]'
+# - Internal snapshots are (currently) impossible with refcount_bits=1
+# - This is generally a test for compat=1.1 images
+_unsupported_imgopts 'refcount_bits=1[^0-9]' 'compat=0.10'
 
 header_size=104
 
diff --git a/tests/qemu-iotests/130 b/tests/qemu-iotests/130
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/130
+++ b/tests/qemu-iotests/130
@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow2
 _supported_proto generic
 _unsupported_proto vxhs
 _supported_os Linux
+# We are going to use lazy-refcounts
+_unsupported_imgopts 'compat=0.10'
 
 qemu_comm_method="monitor"
 
diff --git a/tests/qemu-iotests/137 b/tests/qemu-iotests/137
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/137
+++ b/tests/qemu-iotests/137
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2
 _supported_proto file
 _supported_os Linux
+# We are going to use lazy-refcounts
+_unsupported_imgopts 'compat=0.10'
 
 
 _make_test_img 64M
diff --git a/tests/qemu-iotests/176 b/tests/qemu-iotests/176
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/176
+++ b/tests/qemu-iotests/176
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2
 _supported_proto file
 _supported_os Linux
+# Persistent dirty bitmaps require compat=1.1
+_unsupported_imgopts 'compat=0.10'
 
 function run_qemu()
 {
-- 
2.13.6

The following changes since commit ec11dc41eec5142b4776db1296972c6323ba5847:

Merge tag 'pull-misc-2022-05-11' of git://repo.or.cz/qemu/armbru into staging (2022-05-11 09:00:26 -0700)

are available in the Git repository at:

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

for you to fetch changes up to f70625299ecc9ba577c87f3d1d75012c747c7d88:

qemu-iotests: inline common.config into common.rc (2022-05-12 15:42:49 +0200)

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

- coroutine: Fix crashes due to too large pool batch size
- fdc: Prevent end-of-track overrun
- nbd: MULTI_CONN for shared writable exports
- iotests test runner improvements

----------------------------------------------------------------
Daniel P. Berrangé (2):
      tests/qemu-iotests: print intent to run a test in TAP mode
      .gitlab-ci.d: export meson testlog.txt as an artifact

Eric Blake (2):
      qemu-nbd: Pass max connections to blockdev layer
      nbd/server: Allow MULTI_CONN for shared writable exports

Hanna Reitz (1):
      iotests/testrunner: Flush after run_test()

Kevin Wolf (2):
      coroutine: Rename qemu_coroutine_inc/dec_pool_size()
      coroutine: Revert to constant batch size

Paolo Bonzini (1):
      qemu-iotests: inline common.config into common.rc

Philippe Mathieu-Daudé (2):
      hw/block/fdc: Prevent end-of-track overrun (CVE-2021-3507)
      tests/qtest/fdc-test: Add a regression test for CVE-2021-3507

qapi/block-export.json                           |   8 +-
 docs/interop/nbd.txt                             |   1 +
 docs/tools/qemu-nbd.rst                          |   3 +-
 include/block/nbd.h                              |   5 +-
 include/qemu/coroutine.h                         |   6 +-
 blockdev-nbd.c                                   |  13 +-
 hw/block/fdc.c                                   |   8 ++
 hw/block/virtio-blk.c                            |   6 +-
 nbd/server.c                                     |  10 +-
 qemu-nbd.c                                       |   2 +-
 tests/qtest/fdc-test.c                           |  21 ++++
 util/qemu-coroutine.c                            |  26 ++--
 tests/qemu-iotests/testrunner.py                 |   4 +
 .gitlab-ci.d/buildtest-template.yml              |  12 +-
 MAINTAINERS                                      |   1 +
 tests/qemu-iotests/common.config                 |  41 -------
 tests/qemu-iotests/common.rc                     |  31 +++--
 tests/qemu-iotests/tests/nbd-multiconn           | 145 +++++++++++++++++++++++
 tests/qemu-iotests/tests/nbd-multiconn.out       |   5 +
 tests/qemu-iotests/tests/nbd-qemu-allocation.out |   2 +-
 20 files changed, 261 insertions(+), 89 deletions(-)
 delete mode 100644 tests/qemu-iotests/common.config
 create mode 100755 tests/qemu-iotests/tests/nbd-multiconn
 create mode 100644 tests/qemu-iotests/tests/nbd-multiconn.out

It's true that these functions currently affect the batch size in which
coroutines are reused (i.e. moved from the global release pool to the
allocation pool of a specific thread), but this is a bug and will be
fixed in a separate patch.

In fact, the comment in the header file already just promises that it
influences the pool size, so reflect this in the name of the functions.
As a nice side effect, the shorter function name makes some line
wrapping unnecessary.

Cc: qemu-stable@nongnu.org
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20220510151020.105528-2-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/qemu/coroutine.h | 6 +++---
 hw/block/virtio-blk.c    | 6 ++----
 util/qemu-coroutine.c    | 4 ++--
 3 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/include/qemu/coroutine.h b/include/qemu/coroutine.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/coroutine.h
+++ b/include/qemu/coroutine.h
@@ -XXX,XX +XXX,XX @@ void coroutine_fn yield_until_fd_readable(int fd);
 /**
  * Increase coroutine pool size
  */
-void qemu_coroutine_increase_pool_batch_size(unsigned int additional_pool_size);
+void qemu_coroutine_inc_pool_size(unsigned int additional_pool_size);
 
 /**
- * Devcrease coroutine pool size
+ * Decrease coroutine pool size
  */
-void qemu_coroutine_decrease_pool_batch_size(unsigned int additional_pool_size);
+void qemu_coroutine_dec_pool_size(unsigned int additional_pool_size);
 
 #include "qemu/lockable.h"
 
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp)
     for (i = 0; i < conf->num_queues; i++) {
         virtio_add_queue(vdev, conf->queue_size, virtio_blk_handle_output);
     }
-    qemu_coroutine_increase_pool_batch_size(conf->num_queues * conf->queue_size
-                                            / 2);
+    qemu_coroutine_inc_pool_size(conf->num_queues * conf->queue_size / 2);
     virtio_blk_data_plane_create(vdev, conf, &s->dataplane, &err);
     if (err != NULL) {
         error_propagate(errp, err);
@@ -XXX,XX +XXX,XX @@ static void virtio_blk_device_unrealize(DeviceState *dev)
     for (i = 0; i < conf->num_queues; i++) {
         virtio_del_queue(vdev, i);
     }
-    qemu_coroutine_decrease_pool_batch_size(conf->num_queues * conf->queue_size
-                                            / 2);
+    qemu_coroutine_dec_pool_size(conf->num_queues * conf->queue_size / 2);
     qemu_del_vm_change_state_handler(s->change);
     blockdev_mark_auto_del(s->blk);
     virtio_cleanup(vdev);
diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine.c
+++ b/util/qemu-coroutine.c
@@ -XXX,XX +XXX,XX @@ AioContext *coroutine_fn qemu_coroutine_get_aio_context(Coroutine *co)
     return co->ctx;
 }
 
-void qemu_coroutine_increase_pool_batch_size(unsigned int additional_pool_size)
+void qemu_coroutine_inc_pool_size(unsigned int additional_pool_size)
 {
     qatomic_add(&pool_batch_size, additional_pool_size);
 }
 
-void qemu_coroutine_decrease_pool_batch_size(unsigned int removing_pool_size)
+void qemu_coroutine_dec_pool_size(unsigned int removing_pool_size)
 {
     qatomic_sub(&pool_batch_size, removing_pool_size);
 }
-- 
2.35.3

Commit 4c41c69e changed the way the coroutine pool is sized because for
virtio-blk devices with a large queue size and heavy I/O, it was just
too small and caused coroutines to be deleted and reallocated soon
afterwards. The change made the size dynamic based on the number of
queues and the queue size of virtio-blk devices.

There are two important numbers here: Slightly simplified, when a
coroutine terminates, it is generally stored in the global release pool
up to a certain pool size, and if the pool is full, it is freed.
Conversely, when allocating a new coroutine, the coroutines in the
release pool are reused if the pool already has reached a certain
minimum size (the batch size), otherwise we allocate new coroutines.

The problem after commit 4c41c69e is that it not only increases the
maximum pool size (which is the intended effect), but also the batch
size for reusing coroutines (which is a bug). It means that in cases
with many devices and/or a large queue size (which defaults to the
number of vcpus for virtio-blk-pci), many thousand coroutines could be
sitting in the release pool without being reused.

This is not only a waste of memory and allocations, but it actually
makes the QEMU process likely to hit the vm.max_map_count limit on Linux
because each coroutine requires two mappings (its stack and the guard
page for the stack), causing it to abort() in qemu_alloc_stack() because
when the limit is hit, mprotect() starts to fail with ENOMEM.

In order to fix the problem, change the batch size back to 64 to avoid
uselessly accumulating coroutines in the release pool, but keep the
dynamic maximum pool size so that coroutines aren't freed too early
in heavy I/O scenarios.

Note that this fix doesn't strictly make it impossible to hit the limit,
but this would only happen if most of the coroutines are actually in use
at the same time, not just sitting in a pool. This is the same behaviour
as we already had before commit 4c41c69e. Fully preventing this would
require allowing qemu_coroutine_create() to return an error, but it
doesn't seem to be a scenario that people hit in practice.

Cc: qemu-stable@nongnu.org
Resolves: https://bugzilla.redhat.com/show_bug.cgi?id=2079938
Fixes: 4c41c69e05fe28c0f95f8abd2ebf407e95a4f04b
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20220510151020.105528-3-kwolf@redhat.com>
Tested-by: Hiroki Narukawa <hnarukaw@yahoo-corp.jp>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 util/qemu-coroutine.c | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/util/qemu-coroutine.c b/util/qemu-coroutine.c
index XXXXXXX..XXXXXXX 100644
--- a/util/qemu-coroutine.c
+++ b/util/qemu-coroutine.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/coroutine-tls.h"
 #include "block/aio.h"
 
-/** Initial batch size is 64, and is increased on demand */
+/**
+ * The minimal batch size is always 64, coroutines from the release_pool are
+ * reused as soon as there are 64 coroutines in it. The maximum pool size starts
+ * with 64 and is increased on demand so that coroutines are not deleted even if
+ * they are not immediately reused.
+ */
 enum {
-    POOL_INITIAL_BATCH_SIZE = 64,
+    POOL_MIN_BATCH_SIZE = 64,
+    POOL_INITIAL_MAX_SIZE = 64,
 };
 
 /** Free list to speed up creation */
 static QSLIST_HEAD(, Coroutine) release_pool = QSLIST_HEAD_INITIALIZER(pool);
-static unsigned int pool_batch_size = POOL_INITIAL_BATCH_SIZE;
+static unsigned int pool_max_size = POOL_INITIAL_MAX_SIZE;
 static unsigned int release_pool_size;
 
 typedef QSLIST_HEAD(, Coroutine) CoroutineQSList;
@@ -XXX,XX +XXX,XX @@ Coroutine *qemu_coroutine_create(CoroutineEntry *entry, void *opaque)
 
         co = QSLIST_FIRST(alloc_pool);
         if (!co) {
-            if (release_pool_size > qatomic_read(&pool_batch_size)) {
+            if (release_pool_size > POOL_MIN_BATCH_SIZE) {
                 /* Slow path; a good place to register the destructor, too.  */
                 Notifier *notifier = get_ptr_coroutine_pool_cleanup_notifier();
                 if (!notifier->notify) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_delete(Coroutine *co)
     co->caller = NULL;
 
     if (CONFIG_COROUTINE_POOL) {
-        if (release_pool_size < qatomic_read(&pool_batch_size) * 2) {
+        if (release_pool_size < qatomic_read(&pool_max_size) * 2) {
             QSLIST_INSERT_HEAD_ATOMIC(&release_pool, co, pool_next);
             qatomic_inc(&release_pool_size);
             return;
         }
-        if (get_alloc_pool_size() < qatomic_read(&pool_batch_size)) {
+        if (get_alloc_pool_size() < qatomic_read(&pool_max_size)) {
             QSLIST_INSERT_HEAD(get_ptr_alloc_pool(), co, pool_next);
             set_alloc_pool_size(get_alloc_pool_size() + 1);
             return;
@@ -XXX,XX +XXX,XX @@ AioContext *coroutine_fn qemu_coroutine_get_aio_context(Coroutine *co)
 
 void qemu_coroutine_inc_pool_size(unsigned int additional_pool_size)
 {
-    qatomic_add(&pool_batch_size, additional_pool_size);
+    qatomic_add(&pool_max_size, additional_pool_size);
 }
 
 void qemu_coroutine_dec_pool_size(unsigned int removing_pool_size)
 {
-    qatomic_sub(&pool_batch_size, removing_pool_size);
+    qatomic_sub(&pool_max_size, removing_pool_size);
 }
-- 
2.35.3

From: Hanna Reitz <hreitz@redhat.com>

When stdout is not a terminal, the buffer may not be flushed at each end
of line, so we should flush after each test is done.  This is especially
apparent when run by check-block, in two ways:

First, when running make check-block -jX with X > 1, progress indication
was missing, even though testrunner.py does theoretically print each
test's status once it has been run, even in multi-processing mode.
Flushing after each test restores this progress indication.

Second, sometimes make check-block failed altogether, with an error
message that "too few tests [were] run".  I presume that's because one
worker process in the job pool did not get to flush its stdout before
the main process exited, and so meson did not get to see that worker's
test results.  In any case, by flushing at the end of run_test(), the
problem has disappeared for me.

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20220506134215.10086-1-hreitz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/testrunner.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/qemu-iotests/testrunner.py b/tests/qemu-iotests/testrunner.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/testrunner.py
+++ b/tests/qemu-iotests/testrunner.py
@@ -XXX,XX +XXX,XX @@ def run_test(self, test: str,
             else:
                 print(res.casenotrun)
 
+        sys.stdout.flush()
         return res
 
     def run_tests(self, tests: List[str], jobs: int = 1) -> bool:
-- 
2.35.3

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

When running I/O tests using TAP output mode, we get a single TAP test
with a sub-test reported for each I/O test that is run. The output looks
something like this:

1..123
 ok qcow2 011
 ok qcow2 012
 ok qcow2 013
 ok qcow2 217
 ...

If everything runs or fails normally this is fine, but periodically we
have been seeing the test harness abort early before all 123 tests have
been run, just leaving a fairly useless message like

TAP parsing error: Too few tests run (expected 123, got 107)

we have no idea which tests were running at the time the test harness
abruptly exited. This change causes us to print a message about our
intent to run each test, so we have a record of what is active at the
time the harness exits abnormally.

1..123
 # running qcow2 011
 ok qcow2 011
 # running qcow2 012
 ok qcow2 012
 # running qcow2 013
 ok qcow2 013
 # running qcow2 217
 ok qcow2 217
 ...

Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20220509124134.867431-2-berrange@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/testrunner.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/tests/qemu-iotests/testrunner.py b/tests/qemu-iotests/testrunner.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/testrunner.py
+++ b/tests/qemu-iotests/testrunner.py
@@ -XXX,XX +XXX,XX @@ def run_test(self, test: str,
                                      starttime=start,
                                      lasttime=last_el,
                                      end = '\n' if mp else '\r')
+        else:
+            testname = os.path.basename(test)
+            print(f'# running {self.env.imgfmt} {testname}')
 
         res = self.do_run_test(test, mp)
 
-- 
2.35.3

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

When running 'make check' we only get a summary of progress on the
console. Fortunately meson/ninja have saved the raw test output to a
logfile. Exposing this log will make it easier to debug failures that
happen in CI.

Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
Message-Id: <20220509124134.867431-3-berrange@redhat.com>
Reviewed-by: Thomas Huth <thuth@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 .gitlab-ci.d/buildtest-template.yml | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/.gitlab-ci.d/buildtest-template.yml b/.gitlab-ci.d/buildtest-template.yml
index XXXXXXX..XXXXXXX 100644
--- a/.gitlab-ci.d/buildtest-template.yml
+++ b/.gitlab-ci.d/buildtest-template.yml
@@ -XXX,XX +XXX,XX @@
         make -j"$JOBS" $MAKE_CHECK_ARGS ;
       fi
 
-.native_test_job_template:
+.common_test_job_template:
   stage: test
   image: $CI_REGISTRY_IMAGE/qemu/$IMAGE:latest
   script:
@@ -XXX,XX +XXX,XX @@
     # Avoid recompiling by hiding ninja with NINJA=":"
     - make NINJA=":" $MAKE_CHECK_ARGS
 
+.native_test_job_template:
+  extends: .common_test_job_template
+  artifacts:
+    name: "$CI_JOB_NAME-$CI_COMMIT_REF_SLUG"
+    expire_in: 7 days
+    paths:
+      - build/meson-logs/testlog.txt
+
 .avocado_test_job_template:
-  extends: .native_test_job_template
+  extends: .common_test_job_template
   cache:
     key: "${CI_JOB_NAME}-cache"
     paths:
-- 
2.35.3

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

Per the 82078 datasheet, if the end-of-track (EOT byte in
the FIFO) is more than the number of sectors per side, the
command is terminated unsuccessfully:

* 5.2.5 DATA TRANSFER TERMINATION

The 82078 supports terminal count explicitly through
  the TC pin and implicitly through the underrun/over-
  run and end-of-track (EOT) functions. For full sector
  transfers, the EOT parameter can define the last
  sector to be transferred in a single or multisector
  transfer. If the last sector to be transferred is a par-
  tial sector, the host can stop transferring the data in
  mid-sector, and the 82078 will continue to complete
  the sector as if a hardware TC was received. The
  only difference between these implicit functions and
  TC is that they return "abnormal termination" result
  status. Such status indications can be ignored if they
  were expected.

* 6.1.3 READ TRACK

This command terminates when the EOT specified
  number of sectors have been read. If the 82078
  does not find an I D Address Mark on the diskette
  after the second· occurrence of a pulse on the
  INDX# pin, then it sets the IC code in Status Regis-
  ter 0 to "01" (Abnormal termination), sets the MA bit
  in Status Register 1 to "1", and terminates the com-
  mand.

* 6.1.6 VERIFY

Refer to Table 6-6 and Table 6-7 for information
  concerning the values of MT and EC versus SC and
  EOT value.

* Table 6·6. Result Phase Table

* Table 6-7. Verify Command Result Phase Table

Fix by aborting the transfer when EOT > # Sectors Per Side.

Cc: qemu-stable@nongnu.org
Cc: Hervé Poussineau <hpoussin@reactos.org>
Fixes: baca51faff0 ("floppy driver: disk geometry auto detect")
Reported-by: Alexander Bulekov <alxndr@bu.edu>
Resolves: https://gitlab.com/qemu-project/qemu/-/issues/339
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-Id: <20211118115733.4038610-2-philmd@redhat.com>
Reviewed-by: Hanna Reitz <hreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 hw/block/fdc.c | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/hw/block/fdc.c b/hw/block/fdc.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/fdc.c
+++ b/hw/block/fdc.c
@@ -XXX,XX +XXX,XX @@ static void fdctrl_start_transfer(FDCtrl *fdctrl, int direction)
         int tmp;
         fdctrl->data_len = 128 << (fdctrl->fifo[5] > 7 ? 7 : fdctrl->fifo[5]);
         tmp = (fdctrl->fifo[6] - ks + 1);
+        if (tmp < 0) {
+            FLOPPY_DPRINTF("invalid EOT: %d\n", tmp);
+            fdctrl_stop_transfer(fdctrl, FD_SR0_ABNTERM, FD_SR1_MA, 0x00);
+            fdctrl->fifo[3] = kt;
+            fdctrl->fifo[4] = kh;
+            fdctrl->fifo[5] = ks;
+            return;
+        }
         if (fdctrl->fifo[0] & 0x80)
             tmp += fdctrl->fifo[6];
         fdctrl->data_len *= tmp;
-- 
2.35.3

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

Add the reproducer from https://gitlab.com/qemu-project/qemu/-/issues/339

Without the previous commit, when running 'make check-qtest-i386'
with QEMU configured with '--enable-sanitizers' we get:

==4028352==ERROR: AddressSanitizer: heap-buffer-overflow on address 0x619000062a00 at pc 0x5626d03c491a bp 0x7ffdb4199410 sp 0x7ffdb4198bc0
  READ of size 786432 at 0x619000062a00 thread T0
      #0 0x5626d03c4919 in __asan_memcpy (qemu-system-i386+0x1e65919)
      #1 0x5626d1c023cc in flatview_write_continue softmmu/physmem.c:2787:13
      #2 0x5626d1bf0c0f in flatview_write softmmu/physmem.c:2822:14
      #3 0x5626d1bf0798 in address_space_write softmmu/physmem.c:2914:18
      #4 0x5626d1bf0f37 in address_space_rw softmmu/physmem.c:2924:16
      #5 0x5626d1bf14c8 in cpu_physical_memory_rw softmmu/physmem.c:2933:5
      #6 0x5626d0bd5649 in cpu_physical_memory_write include/exec/cpu-common.h:82:5
      #7 0x5626d0bd0a07 in i8257_dma_write_memory hw/dma/i8257.c:452:9
      #8 0x5626d09f825d in fdctrl_transfer_handler hw/block/fdc.c:1616:13
      #9 0x5626d0a048b4 in fdctrl_start_transfer hw/block/fdc.c:1539:13
      #10 0x5626d09f4c3e in fdctrl_write_data hw/block/fdc.c:2266:13
      #11 0x5626d09f22f7 in fdctrl_write hw/block/fdc.c:829:9
      #12 0x5626d1c20bc5 in portio_write softmmu/ioport.c:207:17

0x619000062a00 is located 0 bytes to the right of 512-byte region [0x619000062800,0x619000062a00)
  allocated by thread T0 here:
      #0 0x5626d03c66ec in posix_memalign (qemu-system-i386+0x1e676ec)
      #1 0x5626d2b988d4 in qemu_try_memalign util/oslib-posix.c:210:11
      #2 0x5626d2b98b0c in qemu_memalign util/oslib-posix.c:226:27
      #3 0x5626d09fbaf0 in fdctrl_realize_common hw/block/fdc.c:2341:20
      #4 0x5626d0a150ed in isabus_fdc_realize hw/block/fdc-isa.c:113:5
      #5 0x5626d2367935 in device_set_realized hw/core/qdev.c:531:13

SUMMARY: AddressSanitizer: heap-buffer-overflow (qemu-system-i386+0x1e65919) in __asan_memcpy
  Shadow bytes around the buggy address:
    0x0c32800044f0: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
    0x0c3280004500: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
    0x0c3280004510: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
    0x0c3280004520: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
    0x0c3280004530: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  =>0x0c3280004540:[fa]fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
    0x0c3280004550: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
    0x0c3280004560: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
    0x0c3280004570: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
    0x0c3280004580: fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa fa
    0x0c3280004590: fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd fd
  Shadow byte legend (one shadow byte represents 8 application bytes):
    Addressable:           00
    Heap left redzone:       fa
    Freed heap region:       fd
  ==4028352==ABORTING

[ kwolf: Added snapshot=on to prevent write file lock failure ]

Reported-by: Alexander Bulekov <alxndr@bu.edu>
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Alexander Bulekov <alxndr@bu.edu>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qtest/fdc-test.c | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/tests/qtest/fdc-test.c b/tests/qtest/fdc-test.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/qtest/fdc-test.c
+++ b/tests/qtest/fdc-test.c
@@ -XXX,XX +XXX,XX @@ static void test_cve_2021_20196(void)
     qtest_quit(s);
 }
 
+static void test_cve_2021_3507(void)
+{
+    QTestState *s;
+
+    s = qtest_initf("-nographic -m 32M -nodefaults "
+                    "-drive file=%s,format=raw,if=floppy,snapshot=on",
+                    test_image);
+    qtest_outl(s, 0x9, 0x0a0206);
+    qtest_outw(s, 0x3f4, 0x1600);
+    qtest_outw(s, 0x3f4, 0x0000);
+    qtest_outw(s, 0x3f4, 0x0000);
+    qtest_outw(s, 0x3f4, 0x0000);
+    qtest_outw(s, 0x3f4, 0x0200);
+    qtest_outw(s, 0x3f4, 0x0200);
+    qtest_outw(s, 0x3f4, 0x0000);
+    qtest_outw(s, 0x3f4, 0x0000);
+    qtest_outw(s, 0x3f4, 0x0000);
+    qtest_quit(s);
+}
+
 int main(int argc, char **argv)
 {
     int fd;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     qtest_add_func("/fdc/read_no_dma_19", test_read_no_dma_19);
     qtest_add_func("/fdc/fuzz-registers", fuzz_registers);
     qtest_add_func("/fdc/fuzz/cve_2021_20196", test_cve_2021_20196);
+    qtest_add_func("/fdc/fuzz/cve_2021_3507", test_cve_2021_3507);
 
     ret = g_test_run();
 
-- 
2.35.3

From: Eric Blake <eblake@redhat.com>

The next patch wants to adjust whether the NBD server code advertises
MULTI_CONN based on whether it is known if the server limits to
exactly one client.  For a server started by QMP, this information is
obtained through nbd_server_start (which can support more than one
export); but for qemu-nbd (which supports exactly one export), it is
controlled only by the command-line option -e/--shared.  Since we
already have a hook function used by qemu-nbd, it's easiest to just
alter its signature to fit our needs.

Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <20220512004924.417153-2-eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/nbd.h | 2 +-
 blockdev-nbd.c      | 8 ++++----
 qemu-nbd.c          | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/include/block/nbd.h b/include/block/nbd.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/nbd.h
+++ b/include/block/nbd.h
@@ -XXX,XX +XXX,XX @@ void nbd_client_new(QIOChannelSocket *sioc,
 void nbd_client_get(NBDClient *client);
 void nbd_client_put(NBDClient *client);
 
-void nbd_server_is_qemu_nbd(bool value);
+void nbd_server_is_qemu_nbd(int max_connections);
 bool nbd_server_is_running(void);
 void nbd_server_start(SocketAddress *addr, const char *tls_creds,
                       const char *tls_authz, uint32_t max_connections,
diff --git a/blockdev-nbd.c b/blockdev-nbd.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev-nbd.c
+++ b/blockdev-nbd.c
@@ -XXX,XX +XXX,XX @@ typedef struct NBDServerData {
 } NBDServerData;
 
 static NBDServerData *nbd_server;
-static bool is_qemu_nbd;
+static int qemu_nbd_connections = -1; /* Non-negative if this is qemu-nbd */
 
 static void nbd_update_server_watch(NBDServerData *s);
 
-void nbd_server_is_qemu_nbd(bool value)
+void nbd_server_is_qemu_nbd(int max_connections)
 {
-    is_qemu_nbd = value;
+    qemu_nbd_connections = max_connections;
 }
 
 bool nbd_server_is_running(void)
 {
-    return nbd_server || is_qemu_nbd;
+    return nbd_server || qemu_nbd_connections >= 0;
 }
 
 static void nbd_blockdev_client_closed(NBDClient *client, bool ignored)
diff --git a/qemu-nbd.c b/qemu-nbd.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-nbd.c
+++ b/qemu-nbd.c
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
 
     bs->detect_zeroes = detect_zeroes;
 
-    nbd_server_is_qemu_nbd(true);
+    nbd_server_is_qemu_nbd(shared);
 
     export_opts = g_new(BlockExportOptions, 1);
     *export_opts = (BlockExportOptions) {
-- 
2.35.3

From: Eric Blake <eblake@redhat.com>

According to the NBD spec, a server that advertises
NBD_FLAG_CAN_MULTI_CONN promises that multiple client connections will
not see any cache inconsistencies: when properly separated by a single
flush, actions performed by one client will be visible to another
client, regardless of which client did the flush.

We always satisfy these conditions in qemu - even when we support
multiple clients, ALL clients go through a single point of reference
into the block layer, with no local caching.  The effect of one client
is instantly visible to the next client.  Even if our backend were a
network device, we argue that any multi-path caching effects that
would cause inconsistencies in back-to-back actions not seeing the
effect of previous actions would be a bug in that backend, and not the
fault of caching in qemu.  As such, it is safe to unconditionally
advertise CAN_MULTI_CONN for any qemu NBD server situation that
supports parallel clients.

Note, however, that we don't want to advertise CAN_MULTI_CONN when we
know that a second client cannot connect (for historical reasons,
qemu-nbd defaults to a single connection while nbd-server-add and QMP
commands default to unlimited connections; but we already have
existing means to let either style of NBD server creation alter those
defaults).  This is visible by no longer advertising MULTI_CONN for
'qemu-nbd -r' without -e, as in the iotest nbd-qemu-allocation.

The harder part of this patch is setting up an iotest to demonstrate
behavior of multiple NBD clients to a single server.  It might be
possible with parallel qemu-io processes, but I found it easier to do
in python with the help of libnbd, and help from Nir and Vladimir in
writing the test.

Signed-off-by: Eric Blake <eblake@redhat.com>
Suggested-by: Nir Soffer <nsoffer@redhat.com>
Suggested-by: Vladimir Sementsov-Ogievskiy <v.sementsov-og@mail.ru>
Message-Id: <20220512004924.417153-3-eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-export.json                        |   8 +-
 docs/interop/nbd.txt                          |   1 +
 docs/tools/qemu-nbd.rst                       |   3 +-
 include/block/nbd.h                           |   3 +-
 blockdev-nbd.c                                |   5 +
 nbd/server.c                                  |  10 +-
 MAINTAINERS                                   |   1 +
 tests/qemu-iotests/tests/nbd-multiconn        | 145 ++++++++++++++++++
 tests/qemu-iotests/tests/nbd-multiconn.out    |   5 +
 .../tests/nbd-qemu-allocation.out             |   2 +-
 10 files changed, 172 insertions(+), 11 deletions(-)
 create mode 100755 tests/qemu-iotests/tests/nbd-multiconn
 create mode 100644 tests/qemu-iotests/tests/nbd-multiconn.out

diff --git a/qapi/block-export.json b/qapi/block-export.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-export.json
+++ b/qapi/block-export.json
@@ -XXX,XX +XXX,XX @@
 #             recreated on the fly while the NBD server is active.
 #             If missing, it will default to denying access (since 4.0).
 # @max-connections: The maximum number of connections to allow at the same
-#                   time, 0 for unlimited. (since 5.2; default: 0)
+#                   time, 0 for unlimited. Setting this to 1 also stops
+#                   the server from advertising multiple client support
+#                   (since 5.2; default: 0)
 #
 # Since: 4.2
 ##
@@ -XXX,XX +XXX,XX @@
 #             recreated on the fly while the NBD server is active.
 #             If missing, it will default to denying access (since 4.0).
 # @max-connections: The maximum number of connections to allow at the same
-#                   time, 0 for unlimited. (since 5.2; default: 0)
+#                   time, 0 for unlimited. Setting this to 1 also stops
+#                   the server from advertising multiple client support
+#                   (since 5.2; default: 0).
 #
 # Returns: error if the server is already running.
 #
diff --git a/docs/interop/nbd.txt b/docs/interop/nbd.txt
index XXXXXXX..XXXXXXX 100644
--- a/docs/interop/nbd.txt
+++ b/docs/interop/nbd.txt
@@ -XXX,XX +XXX,XX @@ NBD_CMD_BLOCK_STATUS for "qemu:dirty-bitmap:", NBD_CMD_CACHE
 * 4.2: NBD_FLAG_CAN_MULTI_CONN for shareable read-only exports,
 NBD_CMD_FLAG_FAST_ZERO
 * 5.2: NBD_CMD_BLOCK_STATUS for "qemu:allocation-depth"
+* 7.1: NBD_FLAG_CAN_MULTI_CONN for shareable writable exports
diff --git a/docs/tools/qemu-nbd.rst b/docs/tools/qemu-nbd.rst
index XXXXXXX..XXXXXXX 100644
--- a/docs/tools/qemu-nbd.rst
+++ b/docs/tools/qemu-nbd.rst
@@ -XXX,XX +XXX,XX @@ driver options if :option:`--image-opts` is specified.
 .. option:: -e, --shared=NUM
 
   Allow up to *NUM* clients to share the device (default
-  ``1``), 0 for unlimited. Safe for readers, but for now,
-  consistency is not guaranteed between multiple writers.
+  ``1``), 0 for unlimited.
 
 .. option:: -t, --persistent
 
diff --git a/include/block/nbd.h b/include/block/nbd.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/nbd.h
+++ b/include/block/nbd.h
@@ -XXX,XX +XXX,XX @@
 /*
- *  Copyright (C) 2016-2020 Red Hat, Inc.
+ *  Copyright (C) 2016-2022 Red Hat, Inc.
  *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
  *
  *  Network Block Device
@@ -XXX,XX +XXX,XX @@ void nbd_client_put(NBDClient *client);
 
 void nbd_server_is_qemu_nbd(int max_connections);
 bool nbd_server_is_running(void);
+int nbd_server_max_connections(void);
 void nbd_server_start(SocketAddress *addr, const char *tls_creds,
                       const char *tls_authz, uint32_t max_connections,
                       Error **errp);
diff --git a/blockdev-nbd.c b/blockdev-nbd.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev-nbd.c
+++ b/blockdev-nbd.c
@@ -XXX,XX +XXX,XX @@ bool nbd_server_is_running(void)
     return nbd_server || qemu_nbd_connections >= 0;
 }
 
+int nbd_server_max_connections(void)
+{
+    return nbd_server ? nbd_server->max_connections : qemu_nbd_connections;
+}
+
 static void nbd_blockdev_client_closed(NBDClient *client, bool ignored)
 {
     nbd_client_put(client);
diff --git a/nbd/server.c b/nbd/server.c
index XXXXXXX..XXXXXXX 100644
--- a/nbd/server.c
+++ b/nbd/server.c
@@ -XXX,XX +XXX,XX @@
 /*
- *  Copyright (C) 2016-2021 Red Hat, Inc.
+ *  Copyright (C) 2016-2022 Red Hat, Inc.
  *  Copyright (C) 2005  Anthony Liguori <anthony@codemonkey.ws>
  *
  *  Network Block Device Server Side
@@ -XXX,XX +XXX,XX @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
     int64_t size;
     uint64_t perm, shared_perm;
     bool readonly = !exp_args->writable;
-    bool shared = !exp_args->writable;
     BlockDirtyBitmapOrStrList *bitmaps;
     size_t i;
     int ret;
@@ -XXX,XX +XXX,XX @@ static int nbd_export_create(BlockExport *blk_exp, BlockExportOptions *exp_args,
     exp->description = g_strdup(arg->description);
     exp->nbdflags = (NBD_FLAG_HAS_FLAGS | NBD_FLAG_SEND_FLUSH |
                      NBD_FLAG_SEND_FUA | NBD_FLAG_SEND_CACHE);
+
+    if (nbd_server_max_connections() != 1) {
+        exp->nbdflags |= NBD_FLAG_CAN_MULTI_CONN;
+    }
     if (readonly) {
         exp->nbdflags |= NBD_FLAG_READ_ONLY;
-        if (shared) {
-            exp->nbdflags |= NBD_FLAG_CAN_MULTI_CONN;
-        }
     } else {
         exp->nbdflags |= (NBD_FLAG_SEND_TRIM | NBD_FLAG_SEND_WRITE_ZEROES |
                           NBD_FLAG_SEND_FAST_ZERO);
diff --git a/MAINTAINERS b/MAINTAINERS
index XXXXXXX..XXXXXXX 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -XXX,XX +XXX,XX @@ F: qemu-nbd.*
 F: blockdev-nbd.c
 F: docs/interop/nbd.txt
 F: docs/tools/qemu-nbd.rst
+F: tests/qemu-iotests/tests/*nbd*
 T: git https://repo.or.cz/qemu/ericb.git nbd
 T: git https://src.openvz.org/scm/~vsementsov/qemu.git nbd
 
diff --git a/tests/qemu-iotests/tests/nbd-multiconn b/tests/qemu-iotests/tests/nbd-multiconn
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/nbd-multiconn
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python3
+# group: rw auto quick
+#
+# Test cases for NBD multi-conn advertisement
+#
+# Copyright (C) 2022 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/>.
+
+import os
+from contextlib import contextmanager
+import iotests
+from iotests import qemu_img_create, qemu_io
+
+
+disk = os.path.join(iotests.test_dir, 'disk')
+size = '4M'
+nbd_sock = os.path.join(iotests.sock_dir, 'nbd_sock')
+nbd_uri = 'nbd+unix:///{}?socket=' + nbd_sock
+
+
+@contextmanager
+def open_nbd(export_name):
+    h = nbd.NBD()
+    try:
+        h.connect_uri(nbd_uri.format(export_name))
+        yield h
+    finally:
+        h.shutdown()
+
+class TestNbdMulticonn(iotests.QMPTestCase):
+    def setUp(self):
+        qemu_img_create('-f', iotests.imgfmt, disk, size)
+        qemu_io('-c', 'w -P 1 0 2M', '-c', 'w -P 2 2M 2M', disk)
+
+        self.vm = iotests.VM()
+        self.vm.launch()
+        result = self.vm.qmp('blockdev-add', {
+            'driver': 'qcow2',
+            'node-name': 'n',
+            'file': {'driver': 'file', 'filename': disk}
+        })
+        self.assert_qmp(result, 'return', {})
+
+    def tearDown(self):
+        self.vm.shutdown()
+        os.remove(disk)
+        try:
+            os.remove(nbd_sock)
+        except OSError:
+            pass
+
+    @contextmanager
+    def run_server(self, max_connections=None):
+        args = {
+            'addr': {
+                'type': 'unix',
+                'data': {'path': nbd_sock}
+            }
+        }
+        if max_connections is not None:
+            args['max-connections'] = max_connections
+
+        result = self.vm.qmp('nbd-server-start', args)
+        self.assert_qmp(result, 'return', {})
+        yield
+
+        result = self.vm.qmp('nbd-server-stop')
+        self.assert_qmp(result, 'return', {})
+
+    def add_export(self, name, writable=None):
+        args = {
+            'type': 'nbd',
+            'id': name,
+            'node-name': 'n',
+            'name': name,
+        }
+        if writable is not None:
+            args['writable'] = writable
+
+        result = self.vm.qmp('block-export-add', args)
+        self.assert_qmp(result, 'return', {})
+
+    def test_default_settings(self):
+        with self.run_server():
+            self.add_export('r')
+            self.add_export('w', writable=True)
+            with open_nbd('r') as h:
+                self.assertTrue(h.can_multi_conn())
+            with open_nbd('w') as h:
+                self.assertTrue(h.can_multi_conn())
+
+    def test_limited_connections(self):
+        with self.run_server(max_connections=1):
+            self.add_export('r')
+            self.add_export('w', writable=True)
+            with open_nbd('r') as h:
+                self.assertFalse(h.can_multi_conn())
+            with open_nbd('w') as h:
+                self.assertFalse(h.can_multi_conn())
+
+    def test_parallel_writes(self):
+        with self.run_server():
+            self.add_export('w', writable=True)
+
+            clients = [nbd.NBD() for _ in range(3)]
+            for c in clients:
+                c.connect_uri(nbd_uri.format('w'))
+                self.assertTrue(c.can_multi_conn())
+
+            initial_data = clients[0].pread(1024 * 1024, 0)
+            self.assertEqual(initial_data, b'\x01' * 1024 * 1024)
+
+            updated_data = b'\x03' * 1024 * 1024
+            clients[1].pwrite(updated_data, 0)
+            clients[2].flush()
+            current_data = clients[0].pread(1024 * 1024, 0)
+
+            self.assertEqual(updated_data, current_data)
+
+            for i in range(3):
+                clients[i].shutdown()
+
+
+if __name__ == '__main__':
+    try:
+        # Easier to use libnbd than to try and set up parallel
+        # 'qemu-nbd --list' or 'qemu-io' processes, but not all systems
+        # have libnbd installed.
+        import nbd  # type: ignore
+
+        iotests.main(supported_fmts=['qcow2'])
+    except ImportError:
+        iotests.notrun('libnbd not installed')
diff --git a/tests/qemu-iotests/tests/nbd-multiconn.out b/tests/qemu-iotests/tests/nbd-multiconn.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/nbd-multiconn.out
@@ -XXX,XX +XXX,XX @@
+...
+----------------------------------------------------------------------
+Ran 3 tests
+
+OK
diff --git a/tests/qemu-iotests/tests/nbd-qemu-allocation.out b/tests/qemu-iotests/tests/nbd-qemu-allocation.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/tests/nbd-qemu-allocation.out
+++ b/tests/qemu-iotests/tests/nbd-qemu-allocation.out
@@ -XXX,XX +XXX,XX @@ wrote 2097152/2097152 bytes at offset 1048576
 exports available: 1
  export: ''
   size:  4194304
-  flags: 0x58f ( readonly flush fua df multi cache )
+  flags: 0x48f ( readonly flush fua df cache )
   min block: 1
   opt block: 4096
   max block: 33554432
-- 
2.35.3

From: Paolo Bonzini <pbonzini@redhat.com>

common.rc has some complicated logic to find the common.config that
dates back to xfstests and is completely unnecessary now.  Just include
the contents of the file.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-Id: <20220505094723.732116-1-pbonzini@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/common.config | 41 --------------------------------
 tests/qemu-iotests/common.rc     | 31 ++++++++++++++----------
 2 files changed, 19 insertions(+), 53 deletions(-)
 delete mode 100644 tests/qemu-iotests/common.config

diff --git a/tests/qemu-iotests/common.config b/tests/qemu-iotests/common.config
deleted file mode 100644
index XXXXXXX..XXXXXXX
--- a/tests/qemu-iotests/common.config
+++ /dev/null
@@ -XXX,XX +XXX,XX @@
-#!/usr/bin/env bash
-#
-# Copyright (C) 2009 Red Hat, Inc.
-# Copyright (c) 2000-2003,2006 Silicon Graphics, Inc.  All Rights Reserved.
-#
-# 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.
-#
-# This program is distributed in the hope that it would 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/>.
-#
-# all tests should use a common language setting to prevent golden
-# output mismatches.
-export LANG=C
-
-PATH=".:$PATH"
-
-HOSTOS=$(uname -s)
-arch=$(uname -m)
-[[ "$arch" =~ "ppc64" ]] && qemu_arch=ppc64 || qemu_arch="$arch"
-
-# make sure we have a standard umask
-umask 022
-
-_optstr_add()
-{
-    if [ -n "$1" ]; then
-        echo "$1,$2"
-    else
-        echo "$2"
-    fi
-}
-
-# make sure this script returns success
-true
diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+export LANG=C
+
+PATH=".:$PATH"
+
+HOSTOS=$(uname -s)
+arch=$(uname -m)
+[[ "$arch" =~ "ppc64" ]] && qemu_arch=ppc64 || qemu_arch="$arch"
+
+# make sure we have a standard umask
+umask 022
+
 # bail out, setting up .notrun file
 _notrun()
 {
@@ -XXX,XX +XXX,XX @@ peek_file_raw()
     dd if="$1" bs=1 skip="$2" count="$3" status=none
 }
 
-config=common.config
-test -f $config || config=../common.config
-if ! test -f $config
-then
-    echo "$0: failed to find common.config"
-    exit 1
-fi
-if ! . $config
-    then
-    echo "$0: failed to source common.config"
-    exit 1
-fi
+_optstr_add()
+{
+    if [ -n "$1" ]; then
+        echo "$1,$2"
+    else
+        echo "$2"
+    fi
+}
 
 # Set the variables to the empty string to turn Valgrind off
 # for specific processes, e.g.
-- 
2.35.3