Series comparison

-[PULL 00/30] Block layer patches
+[Qemu-devel] [PULL v3 00/35] Block layer patches
-The following changes since commit aceeaa69d28e6f08a24395d0aa6915b687d0a681:
+The following changes since commit 281f327487c9c9b1599f93c589a408bbf4a651b8:
-  Merge remote-tracking branch 'remotes/huth-gitlab/tags/pull-request-2019-12-17' into staging (2019-12-17 15:55:20 +0000)
+  Merge remote-tracking branch 'remotes/vivier/tags/m68k-for-2.12-pull-request' into staging (2017-12-22 00:11:36 +0000)
-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 f62f08ab7a9d902da70078992248ec5c98f652ad:
+for you to fetch changes up to 1a63a907507fbbcfaee3f622907ec244b7eabda8:
-  iotests: Test external snapshot with VM state (2019-12-19 18:04:25 +0100)
+  block: Keep nodes drained between reopen_queue/multiple (2017-12-22 15:05:32 +0100)
 ----------------------------------------------------------------
-Block layer patches:
+Block layer patches
 - qemu-img: fix info --backing-chain --image-opts
 - Error out on image creation with conflicting size options
 - Fix external snapshot with VM state
 - hmp: Allow using qdev ID for qemu-io command
 - Misc code cleanup
 - Many iotests improvements
 ----------------------------------------------------------------
-Alberto Garcia (1):
+Doug Gale (1):
-      qcow2: Use offset_into_cluster()
+      nvme: Add tracing
-Daniel P. Berrangé (1):
+Edgar Kaziakhmedov (1):
-      qapi: better document NVMe blockdev @device parameter
+      qcow2: get rid of qcow2_backing_read1 routine
-Kevin Wolf (19):
+Fam Zheng (2):
-      block: Error out on image creation with conflicting size options
+      block: Open backing image in force share mode for size probe
-      blockjob: Fix error message for negative speed
+      block: Remove unused bdrv_requests_pending
       qcow2: Declare BDRV_REQ_NO_FALLBACK supported
       iotests: Add qemu_io_log()
       iotests: Fix timeout in run_job()
       iotests: Support job-complete in run_job()
       iotests: Create VM.blockdev_create()
       iotests: 255: Drop blockdev_create()
       iotests: 206: Convert to VM.blockdev_create()
       iotests: 210: Convert to VM.blockdev_create()
       iotests: 212: Convert to VM.blockdev_create()
       iotests: 213: Convert to VM.blockdev_create()
       iotests: 237: Convert to VM.blockdev_create()
       iotests: 266: Convert to VM.blockdev_create()
       iotests: 207: Remove duplication with VM.blockdev_create()
       iotests: 211: Remove duplication with VM.blockdev_create()
       block: Activate recursively even for already active nodes
       hmp: Allow using qdev ID for qemu-io command
       iotests: Test external snapshot with VM state
-Max Reitz (2):
+John Snow (1):
-      iotests/273: Filter format-specific information
+      iotests: fix 197 for vpc
       iotests: Fix IMGOPTSSYNTAX for nbd
-Stefan Hajnoczi (1):
+Kevin Wolf (27):
-      qemu-img: fix info --backing-chain --image-opts
+      block: Formats don't need CONSISTENT_READ with NO_IO
       block: Make bdrv_drain_invoke() recursive
       block: Call .drain_begin only once in bdrv_drain_all_begin()
       test-bdrv-drain: Test BlockDriver callbacks for drain
       block: bdrv_drain_recurse(): Remove unused begin parameter
       block: Don't wait for requests in bdrv_drain*_end()
       block: Unify order in drain functions
       block: Don't acquire AioContext in hmp_qemu_io()
       block: Document that x-blockdev-change breaks quorum children list
       block: Assert drain_all is only called from main AioContext
       block: Make bdrv_drain() driver callbacks non-recursive
       test-bdrv-drain: Test callback for bdrv_drain
       test-bdrv-drain: Test bs->quiesce_counter
       blockjob: Pause job on draining any job BDS
       test-bdrv-drain: Test drain vs. block jobs
       block: Don't block_job_pause_all() in bdrv_drain_all()
       block: Nested drain_end must still call callbacks
       test-bdrv-drain: Test nested drain sections
       block: Don't notify parents in drain call chain
       block: Add bdrv_subtree_drained_begin/end()
       test-bdrv-drain: Tests for bdrv_subtree_drain
       test-bdrv-drain: Test behaviour in coroutine context
       test-bdrv-drain: Recursive draining with multiple parents
       block: Allow graph changes in subtree drained section
       test-bdrv-drain: Test graph changes in drained section
       commit: Simplify reopen of base
       block: Keep nodes drained between reopen_queue/multiple
-Thomas Huth (4):
+Thomas Huth (3):
-      iotests: Provide a function for checking the creation of huge files
+      block: Remove the obsolete -drive boot=on|off parameter
-      iotests: Skip test 060 if it is not possible to create large files
+      block: Remove the deprecated -hdachs option
-      iotests: Skip test 079 if it is not possible to create large files
+      block: Mention -drive cyls/heads/secs/trans/serial/addr in deprecation chapter
       iotests: Add more "_require_drivers" checks to the shell-based tests
-Tuguoyi (1):
+ qapi/block-core.json             |   4 +
-      qcow2: Move error check of local_err near its assignment
+ block/qcow2.h                    |   3 -
  include/block/block.h            |  15 +-
  include/block/block_int.h        |   6 +-
  block.c                          |  75 ++++-
  block/commit.c                   |   8 +-
  block/io.c                       | 164 +++++++---
  block/qcow2.c                    |  51 +--
  block/replication.c              |   6 +
  blockdev.c                       |  11 -
  blockjob.c                       |  22 +-
  hmp.c                            |   6 -
  hw/block/nvme.c                  | 349 +++++++++++++++++----
  qemu-io-cmds.c                   |   3 +
  tests/test-bdrv-drain.c          | 651 +++++++++++++++++++++++++++++++++++++++
  vl.c                             |  86 +-----
  hw/block/trace-events            |  93 ++++++
  qemu-doc.texi                    |  29 +-
  qemu-options.hx                  |  19 +-
  tests/Makefile.include           |   2 +
  tests/qemu-iotests/197           |   4 +
  tests/qemu-iotests/common.filter |   3 +-
 files changed, 1294 insertions(+), 316 deletions(-)
  create mode 100644 tests/test-bdrv-drain.c
-Vladimir Sementsov-Ogievskiy (1):
-      MAINTAINERS: fix qcow2-bitmap.c under Dirty Bitmaps header
- qapi/block-core.json          |   6 +-
- block.c                       |  60 ++++++-----
- block/qcow2.c                 |  21 ++--
- blockjob.c                    |   3 +-
- monitor/hmp-cmds.c            |  28 +++--
- qemu-img.c                    |   3 +
- MAINTAINERS                   |   6 +-
- hmp-commands.hx               |   8 +-
- tests/qemu-iotests/005        |   5 +-
- tests/qemu-iotests/030        |   4 +-
- tests/qemu-iotests/049        |   5 +
- tests/qemu-iotests/049.out    |   5 +
- tests/qemu-iotests/051        |   1 +
- tests/qemu-iotests/060        |   3 +
- tests/qemu-iotests/079        |   3 +
- tests/qemu-iotests/206        | 232 ++++++++++++++++++++----------------------
- tests/qemu-iotests/207        |   8 +-
- tests/qemu-iotests/210        |  81 +++++++--------
- tests/qemu-iotests/211        |  12 +--
- tests/qemu-iotests/212        | 101 +++++++++---------
- tests/qemu-iotests/213        | 113 ++++++++++----------
- tests/qemu-iotests/220        |   6 +-
- tests/qemu-iotests/237        | 139 ++++++++++++-------------
- tests/qemu-iotests/255        |  10 --
- tests/qemu-iotests/266        |  69 ++++++-------
- tests/qemu-iotests/266.out    |  14 +++
- tests/qemu-iotests/267        |   1 +
- tests/qemu-iotests/273        |   3 +-
- tests/qemu-iotests/273.out    |  27 -----
- tests/qemu-iotests/279        |  57 +++++++++++
- tests/qemu-iotests/279.out    |  35 +++++++
- tests/qemu-iotests/280        |  83 +++++++++++++++
- tests/qemu-iotests/280.out    |  50 +++++++++
- tests/qemu-iotests/common.rc  |  13 ++-
- tests/qemu-iotests/group      |   2 +
- tests/qemu-iotests/iotests.py |  25 ++++-
-files changed, 724 insertions(+), 518 deletions(-)
- create mode 100755 tests/qemu-iotests/279
- create mode 100644 tests/qemu-iotests/279.out
- create mode 100755 tests/qemu-iotests/280
- create mode 100644 tests/qemu-iotests/280.out

-[PULL 25/30] iotests: 266: Convert to VM.blockdev_create()
+[Qemu-devel] [PULL v3 01/35] block: Formats don't need CONSISTENT_READ with NO_IO
-Instead of having a separate blockdev_create() function, make use of the
+Commit 1f4ad7d fixed 'qemu-img info' for raw images that are currently
-VM.blockdev_create() offered by iotests.py.
+in use as a mirror target. It is not enough for image formats, though,
 as these still unconditionally request BLK_PERM_CONSISTENT_READ.
 As this permission is geared towards whether the guest-visible data is
 consistent, and has no impact on whether the metadata is sane, and
 'qemu-img info' does not read guest-visible data (except for the raw
 format), it makes sense to not require BLK_PERM_CONSISTENT_READ if there
 is not going to be any guest I/O performed, regardless of image format.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/266     | 69 +++++++++++++++++---------------------
+ block.c | 6 +++++-
- tests/qemu-iotests/266.out | 14 ++++++++
+file changed, 5 insertions(+), 1 deletion(-)
 files changed, 44 insertions(+), 39 deletions(-)
-diff --git a/tests/qemu-iotests/266 b/tests/qemu-iotests/266
+diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/266
 +++ b/tests/qemu-iotests/266
@@ -XXX,XX +XXX,XX @@ import iotests
  from iotests import imgfmt
 -def blockdev_create(vm, options):
 -    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
 -                        filters=[iotests.filter_qmp_testfiles])
 -
 -    if 'return' in result:
 -        assert result['return'] == {}
 -        vm.run_job('job0')
 -
 -
  # Successful image creation (defaults)
  def implicit_defaults(vm, file_path):
      iotests.log("=== Successful image creation (defaults) ===")
@@ -XXX,XX +XXX,XX @@ def implicit_defaults(vm, file_path):
      # (Close to 64 MB)
      size = 8 * 964 * 17 * 512
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'protocol-node',
 -                          'size': size })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'protocol-node',
 +                         'size': size })
  # Successful image creation (explicit defaults)
@@ -XXX,XX +XXX,XX @@ def explicit_defaults(vm, file_path):
      # (Close to 128 MB)
      size = 16 * 964 * 17 * 512
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'protocol-node',
 -                          'size': size,
 -                          'subformat': 'dynamic',
 -                          'force-size': False })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'protocol-node',
 +                         'size': size,
 +                         'subformat': 'dynamic',
 +                         'force-size': False })
  # Successful image creation (non-default options)
@@ -XXX,XX +XXX,XX @@ def non_defaults(vm, file_path):
      # Not representable in CHS (fine with force-size=True)
      size = 1048576
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'protocol-node',
 -                          'size': size,
 -                          'subformat': 'fixed',
 -                          'force-size': True })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'protocol-node',
 +                         'size': size,
 +                         'subformat': 'fixed',
 +                         'force-size': True })
  # Size not representable in CHS with force-size=False
@@ -XXX,XX +XXX,XX @@ def non_chs_size_without_force(vm, file_path):
      # Not representable in CHS (will not work with force-size=False)
      size = 1048576
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'protocol-node',
 -                          'size': size,
 -                          'force-size': False })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'protocol-node',
 +                         'size': size,
 +                         'force-size': False })
  # Zero size
@@ -XXX,XX +XXX,XX @@ def zero_size(vm, file_path):
      iotests.log("=== Zero size===")
      iotests.log("")
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'protocol-node',
 -                          'size': 0 })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'protocol-node',
 +                         'size': 0 })
  # Maximum CHS size
@@ -XXX,XX +XXX,XX @@ def maximum_chs_size(vm, file_path):
      iotests.log("=== Maximum CHS size===")
      iotests.log("")
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'protocol-node',
 -                          'size': 16 * 65535 * 255 * 512 })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'protocol-node',
 +                         'size': 16 * 65535 * 255 * 512 })
  # Actual maximum size
@@ -XXX,XX +XXX,XX @@ def maximum_size(vm, file_path):
      iotests.log("=== Actual maximum size===")
      iotests.log("")
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'protocol-node',
 -                          'size': 0xff000000 * 512,
 -                          'force-size': True })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'protocol-node',
 +                         'size': 0xff000000 * 512,
 +                         'force-size': True })
  def main():
@@ -XXX,XX +XXX,XX @@ def main():
              vm.launch()
              iotests.log('--- Creating empty file ---')
 -            blockdev_create(vm, { 'driver': 'file',
 -                                  'filename': file_path,
 -                                  'size': 0 })
 +            vm.blockdev_create({ 'driver': 'file',
 +                                 'filename': file_path,
 +                                 'size': 0 })
              vm.qmp_log('blockdev-add', driver='file', filename=file_path,
                         node_name='protocol-node',
 diff --git a/tests/qemu-iotests/266.out b/tests/qemu-iotests/266.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/266.out
+--- a/block.c
-+++ b/tests/qemu-iotests/266.out
++++ b/block.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
- {"return": {}}
+     assert(role == &child_backing || role == &child_file);
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
+     if (!backing) {
 +        int flags = bdrv_reopen_get_flags(reopen_queue, bs);
 +
- {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
+         /* Apart from the modifications below, the same permissions are
- {"return": {}}
+          * forwarded and left alone as for filters */
+         bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
- {"return": {}}
+         /* bs->file always needs to be consistent because of the metadata. We
+          * can never allow other users to resize or write to it. */
-+
+-        perm |= BLK_PERM_CONSISTENT_READ;
- image: TEST_IMG
++        if (!(flags & BDRV_O_NO_IO)) {
- file format: IMGFMT
++            perm |= BLK_PERM_CONSISTENT_READ;
- virtual size: 64 MiB (67125248 bytes)
++        }
-@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
+         shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
- {"return": {}}
+     } else {
- {"execute": "job-dismiss", "arguments": {"id": "job0"}}
+         /* We want consistent read from backing files if the parent needs it.
  {"return": {}}
 +
  {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
  {"return": {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
  {"execute": "job-dismiss", "arguments": {"id": "job0"}}
  {"return": {}}
 +
  image: TEST_IMG
  file format: IMGFMT
  virtual size: 128 MiB (134250496 bytes)
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
  {"return": {}}
  {"execute": "job-dismiss", "arguments": {"id": "job0"}}
  {"return": {}}
 +
  {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
  {"return": {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
  {"execute": "job-dismiss", "arguments": {"id": "job0"}}
  {"return": {}}
 +
  image: TEST_IMG
  file format: IMGFMT
  virtual size: 1 MiB (1048576 bytes)
@@ -XXX,XX +XXX,XX @@ virtual size: 1 MiB (1048576 bytes)
  {"return": {}}
  {"execute": "job-dismiss", "arguments": {"id": "job0"}}
  {"return": {}}
 +
  {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
  {"return": {}}
@@ -XXX,XX +XXX,XX @@ Job failed: The requested image size cannot be represented in CHS geometry
  {"execute": "job-dismiss", "arguments": {"id": "job0"}}
  {"return": {}}
 +
  qemu-img: Could not open 'TEST_IMG': File too small for a VHD header
  --- Creating empty file ---
@@ -XXX,XX +XXX,XX @@ qemu-img: Could not open 'TEST_IMG': File too small for a VHD header
  {"return": {}}
  {"execute": "job-dismiss", "arguments": {"id": "job0"}}
  {"return": {}}
 +
  {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
  {"return": {}}
@@ -XXX,XX +XXX,XX @@ qemu-img: Could not open 'TEST_IMG': File too small for a VHD header
  {"execute": "job-dismiss", "arguments": {"id": "job0"}}
  {"return": {}}
 +
  image: TEST_IMG
  file format: IMGFMT
  virtual size: 0 B (0 bytes)
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
  {"return": {}}
  {"execute": "job-dismiss", "arguments": {"id": "job0"}}
  {"return": {}}
 +
  {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
  {"return": {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
  {"execute": "job-dismiss", "arguments": {"id": "job0"}}
  {"return": {}}
 +
  image: TEST_IMG
  file format: IMGFMT
  virtual size: 127 GiB (136899993600 bytes)
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
  {"return": {}}
  {"execute": "job-dismiss", "arguments": {"id": "job0"}}
  {"return": {}}
 +
  {"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-t.vpc", "node-name": "protocol-node"}}
  {"return": {}}
@@ -XXX,XX +XXX,XX @@ cluster_size: 2097152
  {"execute": "job-dismiss", "arguments": {"id": "job0"}}
  {"return": {}}
 +
  image: TEST_IMG
  file format: IMGFMT
  virtual size: 1.99 TiB (2190433320960 bytes)
 --
-.20.1
+.13.6

-New patch
+[Qemu-devel] [PULL v3 02/35] iotests: fix 197 for vpc
+From: John Snow <jsnow@redhat.com>
+VPC has some difficulty creating geometries of particular size.
+However, we can indeed force it to use a literal one, so let's
+do that for the sake of test 197, which is testing some specific
+offsets.
+Signed-off-by: John Snow <jsnow@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Lukáš Doktor <ldoktor@redhat.com>
+---
+ tests/qemu-iotests/197           | 4 ++++
+ tests/qemu-iotests/common.filter | 3 ++-
+files changed, 6 insertions(+), 1 deletion(-)
+diff --git a/tests/qemu-iotests/197 b/tests/qemu-iotests/197
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/197
++++ b/tests/qemu-iotests/197
+@@ -XXX,XX +XXX,XX @@ echo '=== Copy-on-read ==='
+ echo
+ # Prep the images
++# VPC rounds image sizes to a specific geometry, force a specific size.
++if [ "$IMGFMT" = "vpc" ]; then
++    IMGOPTS=$(_optstr_add "$IMGOPTS" "force_size")
++fi
+ _make_test_img 4G
+ $QEMU_IO -c "write -P 55 3G 1k" "$TEST_IMG" | _filter_qemu_io
+ IMGPROTO=file IMGFMT=qcow2 IMGOPTS= TEST_IMG_FILE="$TEST_WRAP" \
+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()
+         -e "s# log_size=[0-9]\\+##g" \
+         -e "s# refcount_bits=[0-9]\\+##g" \
+         -e "s# key-secret=[a-zA-Z0-9]\\+##g" \
+-        -e "s# iter-time=[0-9]\\+##g"
++        -e "s# iter-time=[0-9]\\+##g" \
++        -e "s# force_size=\\(on\\|off\\)##g"
+ }
+ _filter_img_info()
+--
+.13.6

-[PULL 28/30] block: Activate recursively even for already active nodes
+[Qemu-devel] [PULL v3 03/35] block: Make bdrv_drain_invoke() recursive
-bdrv_invalidate_cache_all() assumes that all nodes in a given subtree
+This change separates bdrv_drain_invoke(), which calls the BlockDriver
-are either active or inactive when it starts. Therefore, as soon as it
+drain callbacks, from bdrv_drain_recurse(). Instead, the function
-arrives at an already active node, it stops.
+performs its own recursion now.
-However, this assumption is wrong. For example, it's possible to take a
+One reason for this is that bdrv_drain_recurse() can be called multiple
-snapshot of an inactive node, which results in an active overlay over an
+times by bdrv_drain_all_begin(), but the callbacks may only be called
-inactive backing file. The active overlay is probably also the root node
+once. The separation is necessary to fix this bug.
 of an inactive BlockBackend (blk->disable_perm == true).
-In this case, bdrv_invalidate_cache_all() does not need to do anything
+The other reason is that we intend to go to a model where we call all
-to activate the overlay node, but it still needs to recurse into the
+driver callbacks first, and only then start polling. This is not fully
-children and the parents to make sure that after returning success,
+achieved yet with this patch, as bdrv_drain_invoke() contains a
-really everything is activated.
+BDRV_POLL_WHILE() loop for the block driver callbacks, which can still
 call callbacks for any unrelated event. It's a step in this direction
 anyway.
 Cc: qemu-stable@nongnu.org
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block.c | 50 ++++++++++++++++++++++++--------------------------
+ block/io.c | 14 +++++++++++---
-file changed, 24 insertions(+), 26 deletions(-)
+file changed, 11 insertions(+), 3 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/block/io.c
-+++ b/block.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_drain_invoke_entry(void *opaque)
-         return;
+     bdrv_wakeup(bs);
  }
 +/* Recursively call BlockDriver.bdrv_co_drain_begin/end callbacks */
  static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)
  {
 +    BdrvChild *child, *tmp;
      BdrvCoDrainData data = { .bs = bs, .done = false, .begin = begin};
      if (!bs->drv || (begin && !bs->drv->bdrv_co_drain_begin) ||
@@ -XXX,XX +XXX,XX @@ static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)
      data.co = qemu_coroutine_create(bdrv_drain_invoke_entry, &data);
      bdrv_coroutine_enter(bs, data.co);
      BDRV_POLL_WHILE(bs, !data.done);
 +
 +    QLIST_FOREACH_SAFE(child, &bs->children, next, tmp) {
 +        bdrv_drain_invoke(child->bs, begin);
 +    }
  }
  static bool bdrv_drain_recurse(BlockDriverState *bs, bool begin)
@@ -XXX,XX +XXX,XX @@ static bool bdrv_drain_recurse(BlockDriverState *bs, bool begin)
      BdrvChild *child, *tmp;
      bool waited;
 -    /* Ensure any pending metadata writes are submitted to bs->file.  */
 -    bdrv_drain_invoke(bs, begin);
 -
      /* Wait for drained requests to finish */
      waited = BDRV_POLL_WHILE(bs, atomic_read(&bs->in_flight) > 0);
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)
          bdrv_parent_drained_begin(bs);
      }
--    if (!(bs->open_flags & BDRV_O_INACTIVE)) {
++    bdrv_drain_invoke(bs, true);
--        return;
+     bdrv_drain_recurse(bs, true);
--    }
+ }
--
-     QLIST_FOREACH(child, &bs->children, next) {
+@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
          bdrv_co_invalidate_cache(child->bs, &local_err);
          if (local_err) {
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_invalidate_cache(BlockDriverState *bs,
       * just keep the extended permissions for the next time that an activation
       * of the image is tried.
       */
 -    bs->open_flags &= ~BDRV_O_INACTIVE;
 -    bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
 -    ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, NULL, &local_err);
 -    if (ret < 0) {
 -        bs->open_flags |= BDRV_O_INACTIVE;
 -        error_propagate(errp, local_err);
 -        return;
 -    }
 -    bdrv_set_perm(bs, perm, shared_perm);
 -
 -    if (bs->drv->bdrv_co_invalidate_cache) {
 -        bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
 -        if (local_err) {
 +    if (bs->open_flags & BDRV_O_INACTIVE) {
 +        bs->open_flags &= ~BDRV_O_INACTIVE;
 +        bdrv_get_cumulative_perm(bs, &perm, &shared_perm);
 +        ret = bdrv_check_perm(bs, NULL, perm, shared_perm, NULL, NULL, &local_err);
 +        if (ret < 0) {
              bs->open_flags |= BDRV_O_INACTIVE;
              error_propagate(errp, local_err);
              return;
          }
 -    }
 +        bdrv_set_perm(bs, perm, shared_perm);
 -    FOR_EACH_DIRTY_BITMAP(bs, bm) {
 -        bdrv_dirty_bitmap_skip_store(bm, false);
 -    }
 +        if (bs->drv->bdrv_co_invalidate_cache) {
 +            bs->drv->bdrv_co_invalidate_cache(bs, &local_err);
 +            if (local_err) {
 +                bs->open_flags |= BDRV_O_INACTIVE;
 +                error_propagate(errp, local_err);
 +                return;
 +            }
 +        }
 -    ret = refresh_total_sectors(bs, bs->total_sectors);
 -    if (ret < 0) {
 -        bs->open_flags |= BDRV_O_INACTIVE;
 -        error_setg_errno(errp, -ret, "Could not refresh total sector count");
 -        return;
 +        FOR_EACH_DIRTY_BITMAP(bs, bm) {
 +            bdrv_dirty_bitmap_skip_store(bm, false);
 +        }
 +
 +        ret = refresh_total_sectors(bs, bs->total_sectors);
 +        if (ret < 0) {
 +            bs->open_flags |= BDRV_O_INACTIVE;
 +            error_setg_errno(errp, -ret, "Could not refresh total sector count");
 +            return;
 +        }
      }
-     QLIST_FOREACH(parent, &bs->parents, next_parent) {
+     bdrv_parent_drained_end(bs);
 +    bdrv_drain_invoke(bs, false);
      bdrv_drain_recurse(bs, false);
      aio_enable_external(bdrv_get_aio_context(bs));
  }
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
              aio_context_acquire(aio_context);
              for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
                  if (aio_context == bdrv_get_aio_context(bs)) {
 +                    /* FIXME Calling this multiple times is wrong */
 +                    bdrv_drain_invoke(bs, true);
                      waited |= bdrv_drain_recurse(bs, true);
                  }
              }
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
          aio_context_acquire(aio_context);
          aio_enable_external(aio_context);
          bdrv_parent_drained_end(bs);
 +        bdrv_drain_invoke(bs, false);
          bdrv_drain_recurse(bs, false);
          aio_context_release(aio_context);
      }
 --
-.20.1
+.13.6

-New patch
+[Qemu-devel] [PULL v3 04/35] block: Call .drain_begin only once in bdrv_drain_all_begin()
+bdrv_drain_all_begin() used to call the .bdrv_co_drain_begin() driver
+callback inside its polling loop. This means that how many times it got
+called for each node depended on long it had to poll the event loop.
+This is obviously not right and results in nodes that stay drained even
+after bdrv_drain_all_end(), which calls .bdrv_co_drain_begin() once per
+node.
+Fix bdrv_drain_all_begin() to call the callback only once, too.
+Cc: qemu-stable@nongnu.org
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+---
+ block/io.c | 3 +--
+file changed, 1 insertion(+), 2 deletions(-)
+diff --git a/block/io.c b/block/io.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/io.c
++++ b/block/io.c
+@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
+         aio_context_acquire(aio_context);
+         bdrv_parent_drained_begin(bs);
+         aio_disable_external(aio_context);
++        bdrv_drain_invoke(bs, true);
+         aio_context_release(aio_context);
+         if (!g_slist_find(aio_ctxs, aio_context)) {
+@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
+             aio_context_acquire(aio_context);
+             for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
+                 if (aio_context == bdrv_get_aio_context(bs)) {
+-                    /* FIXME Calling this multiple times is wrong */
+-                    bdrv_drain_invoke(bs, true);
+                     waited |= bdrv_drain_recurse(bs, true);
+                 }
+             }
+--
+.13.6

-[PULL 30/30] iotests: Test external snapshot with VM state
+[Qemu-devel] [PULL v3 05/35] test-bdrv-drain: Test BlockDriver callbacks for drain
-This tests creating an external snapshot with VM state (which results in
+This adds a test case that the BlockDriver callbacks for drain are
-an active overlay over an inactive backing file, which is also the root
+called in bdrv_drained_all_begin/end(), and that both of them are called
-node of an inactive BlockBackend), re-activating the images and
+exactly once.
 performing some operations to test that the re-activation worked as
 intended.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 ---
- tests/qemu-iotests/280     | 83 ++++++++++++++++++++++++++++++++++++++
+ tests/test-bdrv-drain.c | 137 ++++++++++++++++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/280.out | 50 +++++++++++++++++++++++
+ tests/Makefile.include  |   2 +
- tests/qemu-iotests/group   |  1 +
+files changed, 139 insertions(+)
-files changed, 134 insertions(+)
+ create mode 100644 tests/test-bdrv-drain.c
  create mode 100755 tests/qemu-iotests/280
  create mode 100644 tests/qemu-iotests/280.out
-diff --git a/tests/qemu-iotests/280 b/tests/qemu-iotests/280
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/280
@@ -XXX,XX +XXX,XX @@
 +#!/usr/bin/env python
 +#
 +# Copyright (C) 2019 Red Hat, Inc.
 +#
 +# This program is free software; you can redistribute it and/or modify
 +# it under the terms of the GNU General Public License as published by
 +# the Free Software Foundation; either version 2 of the License, or
 +# (at your option) any later version.
 +#
 +# This program is distributed in the hope that it will be useful,
 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +# GNU General Public License for more details.
 +#
 +# You should have received a copy of the GNU General Public License
 +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 +#
 +# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
 +#
 +# Test migration to file for taking an external snapshot with VM state.
 +
 +import iotests
 +import os
 +
 +iotests.verify_image_format(supported_fmts=['qcow2'])
 +iotests.verify_protocol(supported=['file'])
 +iotests.verify_platform(['linux'])
 +
 +with iotests.FilePath('base') as base_path , \
 +     iotests.FilePath('top') as top_path, \
 +     iotests.VM() as vm:
 +
 +    iotests.qemu_img_log('create', '-f', iotests.imgfmt, base_path, '64M')
 +
 +    iotests.log('=== Launch VM ===')
 +    vm.add_object('iothread,id=iothread0')
 +    vm.add_blockdev('file,filename=%s,node-name=base-file' % (base_path))
 +    vm.add_blockdev('%s,file=base-file,node-name=base-fmt' % (iotests.imgfmt))
 +    vm.add_device('virtio-blk,drive=base-fmt,iothread=iothread0,id=vda')
 +    vm.launch()
 +
 +    vm.enable_migration_events('VM')
 +
 +    iotests.log('\n=== Migrate to file ===')
 +    vm.qmp_log('migrate', uri='exec:cat > /dev/null')
 +
 +    with iotests.Timeout(3, 'Migration does not complete'):
 +        vm.wait_migration()
 +
 +    iotests.log('\nVM is now stopped:')
 +    iotests.log(vm.qmp('query-migrate')['return']['status'])
 +    vm.qmp_log('query-status')
 +
 +    iotests.log('\n=== Create a snapshot of the disk image ===')
 +    vm.blockdev_create({
 +        'driver': 'file',
 +        'filename': top_path,
 +        'size': 0,
 +    })
 +    vm.qmp_log('blockdev-add', node_name='top-file',
 +               driver='file', filename=top_path,
 +               filters=[iotests.filter_qmp_testfiles])
 +
 +    vm.blockdev_create({
 +        'driver': iotests.imgfmt,
 +        'file': 'top-file',
 +        'size': 1024 * 1024,
 +    })
 +    vm.qmp_log('blockdev-add', node_name='top-fmt',
 +               driver=iotests.imgfmt, file='top-file')
 +
 +    vm.qmp_log('blockdev-snapshot', node='base-fmt', overlay='top-fmt')
 +
 +    iotests.log('\n=== Resume the VM and simulate a write request ===')
 +    vm.qmp_log('cont')
 +    iotests.log(vm.hmp_qemu_io('-d vda/virtio-backend', 'write 4k 4k'))
 +
 +    iotests.log('\n=== Commit it to the backing file ===')
 +    result = vm.qmp_log('block-commit', job_id='job0', auto_dismiss=False,
 +                        device='top-fmt', top_node='top-fmt',
 +                        filters=[iotests.filter_qmp_testfiles])
 +    if 'return' in result:
 +        vm.run_job('job0')
 diff --git a/tests/qemu-iotests/280.out b/tests/qemu-iotests/280.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/280.out
++++ b/tests/test-bdrv-drain.c
 @@ -XXX,XX +XXX,XX @@
-+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=67108864 cluster_size=65536 lazy_refcounts=off refcount_bits=16
++/*
 + * Block node draining tests
 + *
 + * Copyright (c) 2017 Kevin Wolf <kwolf@redhat.com>
 + *
 + * Permission is hereby granted, free of charge, to any person obtaining a copy
 + * of this software and associated documentation files (the "Software"), to deal
 + * in the Software without restriction, including without limitation the rights
 + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 + * copies of the Software, and to permit persons to whom the Software is
 + * furnished to do so, subject to the following conditions:
 + *
 + * The above copyright notice and this permission notice shall be included in
 + * all copies or substantial portions of the Software.
 + *
 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 + * THE SOFTWARE.
 + */
 +
-+=== Launch VM ===
++#include "qemu/osdep.h"
-+Enabling migration QMP events on VM...
++#include "block/block.h"
-+{"return": {}}
++#include "sysemu/block-backend.h"
 +#include "qapi/error.h"
 +
-+=== Migrate to file ===
++typedef struct BDRVTestState {
-+{"execute": "migrate", "arguments": {"uri": "exec:cat > /dev/null"}}
++    int drain_count;
-+{"return": {}}
++} BDRVTestState;
 +{"data": {"status": "setup"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"data": {"status": "active"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"data": {"status": "completed"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +
-+VM is now stopped:
++static void coroutine_fn bdrv_test_co_drain_begin(BlockDriverState *bs)
-+completed
++{
-+{"execute": "query-status", "arguments": {}}
++    BDRVTestState *s = bs->opaque;
-+{"return": {"running": false, "singlestep": false, "status": "postmigrate"}}
++    s->drain_count++;
 +}
 +
-+=== Create a snapshot of the disk image ===
++static void coroutine_fn bdrv_test_co_drain_end(BlockDriverState *bs)
-+{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "file", "filename": "TEST_DIR/PID-top", "size": 0}}}
++{
-+{"return": {}}
++    BDRVTestState *s = bs->opaque;
-+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
++    s->drain_count--;
-+{"return": {}}
++}
 +
-+{"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-top", "node-name": "top-file"}}
++static void bdrv_test_close(BlockDriverState *bs)
-+{"return": {}}
++{
-+{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "qcow2", "file": "top-file", "size": 1048576}}}
++    BDRVTestState *s = bs->opaque;
-+{"return": {}}
++    g_assert_cmpint(s->drain_count, >, 0);
-+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
++}
 +{"return": {}}
 +
-+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": "top-file", "node-name": "top-fmt"}}
++static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
-+{"return": {}}
++                                            uint64_t offset, uint64_t bytes,
-+{"execute": "blockdev-snapshot", "arguments": {"node": "base-fmt", "overlay": "top-fmt"}}
++                                            QEMUIOVector *qiov, int flags)
-+{"return": {}}
++{
 +    /* We want this request to stay until the polling loop in drain waits for
 +     * it to complete. We need to sleep a while as bdrv_drain_invoke() comes
 +     * first and polls its result, too, but it shouldn't accidentally complete
 +     * this request yet. */
 +    qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
 +
-+=== Resume the VM and simulate a write request ===
++    return 0;
-+{"execute": "cont", "arguments": {}}
++}
 +{"return": {}}
 +{"return": ""}
 +
-+=== Commit it to the backing file ===
++static BlockDriver bdrv_test = {
-+{"execute": "block-commit", "arguments": {"auto-dismiss": false, "device": "top-fmt", "job-id": "job0", "top-node": "top-fmt"}}
++    .format_name            = "test",
-+{"return": {}}
++    .instance_size          = sizeof(BDRVTestState),
-+{"execute": "job-complete", "arguments": {"id": "job0"}}
++
-+{"return": {}}
++    .bdrv_close             = bdrv_test_close,
-+{"data": {"device": "job0", "len": 65536, "offset": 65536, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++    .bdrv_co_preadv         = bdrv_test_co_preadv,
-+{"data": {"device": "job0", "len": 65536, "offset": 65536, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
++
-+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
++    .bdrv_co_drain_begin    = bdrv_test_co_drain_begin,
-+{"return": {}}
++    .bdrv_co_drain_end      = bdrv_test_co_drain_end,
-diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
++};
 +
 +static void aio_ret_cb(void *opaque, int ret)
 +{
 +    int *aio_ret = opaque;
 +    *aio_ret = ret;
 +}
 +
 +static void test_drv_cb_drain_all(void)
 +{
 +    BlockBackend *blk;
 +    BlockDriverState *bs;
 +    BDRVTestState *s;
 +    BlockAIOCB *acb;
 +    int aio_ret;
 +
 +    QEMUIOVector qiov;
 +    struct iovec iov = {
 +        .iov_base = NULL,
 +        .iov_len = 0,
 +    };
 +    qemu_iovec_init_external(&qiov, &iov, 1);
 +
 +    blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
 +    bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
 +                              &error_abort);
 +    s = bs->opaque;
 +    blk_insert_bs(blk, bs, &error_abort);
 +
 +    /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
 +    g_assert_cmpint(s->drain_count, ==, 0);
 +    bdrv_drain_all_begin();
 +    g_assert_cmpint(s->drain_count, ==, 1);
 +    bdrv_drain_all_end();
 +    g_assert_cmpint(s->drain_count, ==, 0);
 +
 +    /* Now do the same while a request is pending */
 +    aio_ret = -EINPROGRESS;
 +    acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret);
 +    g_assert(acb != NULL);
 +    g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
 +
 +    g_assert_cmpint(s->drain_count, ==, 0);
 +    bdrv_drain_all_begin();
 +    g_assert_cmpint(aio_ret, ==, 0);
 +    g_assert_cmpint(s->drain_count, ==, 1);
 +    bdrv_drain_all_end();
 +    g_assert_cmpint(s->drain_count, ==, 0);
 +
 +    bdrv_unref(bs);
 +    blk_unref(blk);
 +}
 +
 +int main(int argc, char **argv)
 +{
 +    bdrv_init();
 +    qemu_init_main_loop(&error_abort);
 +
 +    g_test_init(&argc, &argv, NULL);
 +
 +    g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
 +
 +    return g_test_run();
 +}
 diff --git a/tests/Makefile.include b/tests/Makefile.include
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/group
+--- a/tests/Makefile.include
-+++ b/tests/qemu-iotests/group
++++ b/tests/Makefile.include
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ gcov-files-test-thread-pool-y = thread-pool.c
-backing quick
+ gcov-files-test-hbitmap-y = util/hbitmap.c
-rw quick
+ check-unit-y += tests/test-hbitmap$(EXESUF)
-rw backing quick
+ gcov-files-test-hbitmap-y = blockjob.c
-+280 rw migration quick
++check-unit-y += tests/test-bdrv-drain$(EXESUF)
  check-unit-y += tests/test-blockjob$(EXESUF)
  check-unit-y += tests/test-blockjob-txn$(EXESUF)
  check-unit-y += tests/test-x86-cpuid$(EXESUF)
@@ -XXX,XX +XXX,XX @@ tests/test-coroutine$(EXESUF): tests/test-coroutine.o $(test-block-obj-y)
  tests/test-aio$(EXESUF): tests/test-aio.o $(test-block-obj-y)
  tests/test-aio-multithread$(EXESUF): tests/test-aio-multithread.o $(test-block-obj-y)
  tests/test-throttle$(EXESUF): tests/test-throttle.o $(test-block-obj-y)
 +tests/test-bdrv-drain$(EXESUF): tests/test-bdrv-drain.o $(test-block-obj-y) $(test-util-obj-y)
  tests/test-blockjob$(EXESUF): tests/test-blockjob.o $(test-block-obj-y) $(test-util-obj-y)
  tests/test-blockjob-txn$(EXESUF): tests/test-blockjob-txn.o $(test-block-obj-y) $(test-util-obj-y)
  tests/test-thread-pool$(EXESUF): tests/test-thread-pool.o $(test-block-obj-y)
 --
-.20.1
+.13.6

-[PULL 11/30] iotests: Support job-complete in run_job()
+[Qemu-devel] [PULL v3 06/35] block: bdrv_drain_recurse(): Remove unused begin parameter
-Automatically complete jobs that have a 'ready' state and need an
+Now that the bdrv_drain_invoke() calls are pulled up to the callers of
-explicit job-complete. Without this, run_job() would hang for such
+bdrv_drain_recurse(), the 'begin' parameter isn't needed any more.
 jobs.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/iotests.py | 2 ++
+ block/io.c | 12 ++++++------
-file changed, 2 insertions(+)
+file changed, 6 insertions(+), 6 deletions(-)
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
+--- a/block/io.c
-+++ b/tests/qemu-iotests/iotests.py
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
+@@ -XXX,XX +XXX,XX @@ static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)
-                         error = j['error']
+     }
-                         if use_log:
+ }
-                             log('Job failed: %s' % (j['error']))
-+            elif status == 'ready':
+-static bool bdrv_drain_recurse(BlockDriverState *bs, bool begin)
-+                self.qmp_log('job-complete', id=job)
++static bool bdrv_drain_recurse(BlockDriverState *bs)
-             elif status == 'pending' and not auto_finalize:
+ {
-                 if pre_finalize:
+     BdrvChild *child, *tmp;
-                     pre_finalize()
+     bool waited;
@@ -XXX,XX +XXX,XX @@ static bool bdrv_drain_recurse(BlockDriverState *bs, bool begin)
               */
              bdrv_ref(bs);
          }
 -        waited |= bdrv_drain_recurse(bs, begin);
 +        waited |= bdrv_drain_recurse(bs);
          if (in_main_loop) {
              bdrv_unref(bs);
          }
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)
      }
      bdrv_drain_invoke(bs, true);
 -    bdrv_drain_recurse(bs, true);
 +    bdrv_drain_recurse(bs);
  }
  void bdrv_drained_end(BlockDriverState *bs)
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
      bdrv_parent_drained_end(bs);
      bdrv_drain_invoke(bs, false);
 -    bdrv_drain_recurse(bs, false);
 +    bdrv_drain_recurse(bs);
      aio_enable_external(bdrv_get_aio_context(bs));
  }
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
              aio_context_acquire(aio_context);
              for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
                  if (aio_context == bdrv_get_aio_context(bs)) {
 -                    waited |= bdrv_drain_recurse(bs, true);
 +                    waited |= bdrv_drain_recurse(bs);
                  }
              }
              aio_context_release(aio_context);
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
          aio_enable_external(aio_context);
          bdrv_parent_drained_end(bs);
          bdrv_drain_invoke(bs, false);
 -        bdrv_drain_recurse(bs, false);
 +        bdrv_drain_recurse(bs);
          aio_context_release(aio_context);
      }
 --
-.20.1
+.13.6

-[PULL 10/30] iotests: Fix timeout in run_job()
+[Qemu-devel] [PULL v3 07/35] block: Don't wait for requests in bdrv_drain*_end()
-run_job() accepts a wait parameter for a timeout, but it doesn't
+The device is drained, so there is no point in waiting for requests at
-actually use it. The only thing that is missing is passing it to
+the end of the drained section. Remove the bdrv_drain_recurse() calls
-events_wait(), so do that now.
+there.
 The bdrv_drain_recurse() calls were introduced in commit 481cad48e5e
 in order to call the .bdrv_co_drain_end() driver callback. This is now
 done by a separate bdrv_drain_invoke() call.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/iotests.py | 2 +-
+ block/io.c | 2 --
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 2 deletions(-)
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
+--- a/block/io.c
-+++ b/tests/qemu-iotests/iotests.py
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
+@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
-         ]
-         error = None
+     bdrv_parent_drained_end(bs);
-         while True:
+     bdrv_drain_invoke(bs, false);
--            ev = filter_qmp_event(self.events_wait(events))
+-    bdrv_drain_recurse(bs);
-+            ev = filter_qmp_event(self.events_wait(events, timeout=wait))
+     aio_enable_external(bdrv_get_aio_context(bs));
-             if ev['event'] != 'JOB_STATUS_CHANGE':
+ }
-                 if use_log:
-                     log(ev)
+@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
          aio_enable_external(aio_context);
          bdrv_parent_drained_end(bs);
          bdrv_drain_invoke(bs, false);
 -        bdrv_drain_recurse(bs);
          aio_context_release(aio_context);
      }
 --
-.20.1
+.13.6

-[PULL 09/30] iotests: Add qemu_io_log()
+[Qemu-devel] [PULL v3 08/35] block: Unify order in drain functions
-Add a function that runs qemu-io and logs the output with the
+Drain requests are propagated to child nodes, parent nodes and directly
-appropriate filters applied.
+to the AioContext. The order in which this happened was different
 between all combinations of drain/drain_all and begin/end.
 The correct order is to keep children only drained when their parents
 are also drained. This means that at the start of a drained section, the
 AioContext needs to be drained first, the parents second and only then
 the children. The correct order for the end of a drained section is the
 opposite.
 This patch changes the three other functions to follow the example of
 bdrv_drained_begin(), which is the only one that got it right.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/iotests.py | 5 +++++
+ block/io.c | 12 ++++++++----
-file changed, 5 insertions(+)
+file changed, 8 insertions(+), 4 deletions(-)
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
+--- a/block/io.c
-+++ b/tests/qemu-iotests/iotests.py
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ def qemu_io(*args):
+@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)
-         sys.stderr.write('qemu-io received signal %i: %s\n' % (-exitcode, ' '.join(args)))
+         return;
-     return subp.communicate()[0]
+     }
-+def qemu_io_log(*args):
++    /* Stop things in parent-to-child order */
-+    result = qemu_io(*args)
+     if (atomic_fetch_inc(&bs->quiesce_counter) == 0) {
-+    log(result, filters=[filter_testfiles, filter_qemu_io])
+         aio_disable_external(bdrv_get_aio_context(bs));
-+    return result
+         bdrv_parent_drained_begin(bs);
-+
+@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
- def qemu_io_silent(*args):
+         return;
-     '''Run qemu-io and return the exit code, suppressing stdout'''
+     }
-     args = qemu_io_args + list(args)
 -    bdrv_parent_drained_end(bs);
 +    /* Re-enable things in child-to-parent order */
      bdrv_drain_invoke(bs, false);
 +    bdrv_parent_drained_end(bs);
      aio_enable_external(bdrv_get_aio_context(bs));
  }
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
      for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
          AioContext *aio_context = bdrv_get_aio_context(bs);
 +        /* Stop things in parent-to-child order */
          aio_context_acquire(aio_context);
 -        bdrv_parent_drained_begin(bs);
          aio_disable_external(aio_context);
 +        bdrv_parent_drained_begin(bs);
          bdrv_drain_invoke(bs, true);
          aio_context_release(aio_context);
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
      for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
          AioContext *aio_context = bdrv_get_aio_context(bs);
 +        /* Re-enable things in child-to-parent order */
          aio_context_acquire(aio_context);
 -        aio_enable_external(aio_context);
 -        bdrv_parent_drained_end(bs);
          bdrv_drain_invoke(bs, false);
 +        bdrv_parent_drained_end(bs);
 +        aio_enable_external(aio_context);
          aio_context_release(aio_context);
      }
 --
-.20.1
+.13.6

-[PULL 29/30] hmp: Allow using qdev ID for qemu-io command
+[Qemu-devel] [PULL v3 09/35] block: Don't acquire AioContext in hmp_qemu_io()
-In order to issue requests on an existing BlockBackend with the
+Commit 15afd94a047 added code to acquire and release the AioContext in
-'qemu-io' HMP command, allow specifying the BlockBackend not only with a
+qemuio_command(). This means that the lock is taken twice now in the
-BlockBackend name, but also with a qdev ID/QOM path for a device that
+call path from hmp_qemu_io(). This causes BDRV_POLL_WHILE() to hang for
-owns the (possibly anonymous) BlockBackend.
+any requests issued to nodes in a non-mainloop AioContext.
-Because qdev names could be conflicting with BlockBackend and node
+Dropping the first locking from hmp_qemu_io() fixes the problem.
 names, introduce a -d option to explicitly address a device. If the
 option is not given, a BlockBackend or a node is addressed.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- monitor/hmp-cmds.c | 28 ++++++++++++++++++----------
+ hmp.c | 6 ------
- hmp-commands.hx    |  8 +++++---
+file changed, 6 deletions(-)
 files changed, 23 insertions(+), 13 deletions(-)
-diff --git a/monitor/hmp-cmds.c b/monitor/hmp-cmds.c
+diff --git a/hmp.c b/hmp.c
 index XXXXXXX..XXXXXXX 100644
---- a/monitor/hmp-cmds.c
+--- a/hmp.c
-+++ b/monitor/hmp-cmds.c
++++ b/hmp.c
 @@ -XXX,XX +XXX,XX @@ void hmp_qemu_io(Monitor *mon, const QDict *qdict)
  {
      BlockBackend *blk;
      BlockBackend *local_blk = NULL;
-+    bool qdev = qdict_get_try_bool(qdict, "qdev", false);
+-    AioContext *aio_context;
      const char* device = qdict_get_str(qdict, "device");
      const char* command = qdict_get_str(qdict, "command");
      Error *err = NULL;
-     int ret;
+@@ -XXX,XX +XXX,XX @@ void hmp_qemu_io(Monitor *mon, const QDict *qdict)
 -    blk = blk_by_name(device);
 -    if (!blk) {
 -        BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err);
 -        if (bs) {
 -            blk = local_blk = blk_new(bdrv_get_aio_context(bs),
 -                                      0, BLK_PERM_ALL);
 -            ret = blk_insert_bs(blk, bs, &err);
 -            if (ret < 0) {
 +    if (qdev) {
 +        blk = blk_by_qdev_id(device, &err);
 +        if (!blk) {
 +            goto fail;
 +        }
 +    } else {
 +        blk = blk_by_name(device);
 +        if (!blk) {
 +            BlockDriverState *bs = bdrv_lookup_bs(NULL, device, &err);
 +            if (bs) {
 +                blk = local_blk = blk_new(bdrv_get_aio_context(bs),
 +                                          0, BLK_PERM_ALL);
 +                ret = blk_insert_bs(blk, bs, &err);
 +                if (ret < 0) {
 +                    goto fail;
 +                }
 +            } else {
                  goto fail;
              }
 -        } else {
 -            goto fail;
          }
      }
-diff --git a/hmp-commands.hx b/hmp-commands.hx
+-    aio_context = blk_get_aio_context(blk);
-index XXXXXXX..XXXXXXX 100644
+-    aio_context_acquire(aio_context);
---- a/hmp-commands.hx
+-
-+++ b/hmp-commands.hx
+     /*
-@@ -XXX,XX +XXX,XX @@ ETEXI
+      * Notably absent: Proper permission management. This is sad, but it seems
+      * almost impossible to achieve without changing the semantics and thereby
-     {
+@@ -XXX,XX +XXX,XX @@ void hmp_qemu_io(Monitor *mon, const QDict *qdict)
-         .name       = "qemu-io",
+      */
--        .args_type  = "device:B,command:s",
+     qemuio_command(blk, command);
--        .params     = "[device] \"[command]\"",
--        .help       = "run a qemu-io command on a block device",
+-    aio_context_release(aio_context);
-+        .args_type  = "qdev:-d,device:B,command:s",
+-
-+        .params     = "[-d] [device] \"[command]\"",
+ fail:
-+        .help       = "run a qemu-io command on a block device\n\t\t\t"
+     blk_unref(local_blk);
-+                      "-d: [device] is a device ID rather than a "
+     hmp_handle_error(mon, &err);
 +                      "drive ID or node name",
          .cmd        = hmp_qemu_io,
      },
 --
-.20.1
+.13.6

-[PULL 12/30] qcow2: Use offset_into_cluster()
+[Qemu-devel] [PULL v3 10/35] qcow2: get rid of qcow2_backing_read1 routine
-From: Alberto Garcia <berto@igalia.com>
+From: Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com>
-There's a couple of places left in the qcow2 code that still do the
+Since bdrv_co_preadv does all neccessary checks including
-calculation manually, so let's replace them.
+reading after the end of the backing file, avoid duplication
 of verification before bdrv_co_preadv call.
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+Signed-off-by: Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com>
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2.c | 8 +++-----
+ block/qcow2.h |  3 ---
-file changed, 3 insertions(+), 5 deletions(-)
+ block/qcow2.c | 51 ++++++++-------------------------------------------
 files changed, 8 insertions(+), 46 deletions(-)
+diff --git a/block/qcow2.h b/block/qcow2.h
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2.h
++++ b/block/qcow2.h
+@@ -XXX,XX +XXX,XX @@ uint32_t offset_to_reftable_index(BDRVQcow2State *s, uint64_t offset)
+ }
+ /* qcow2.c functions */
+-int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
+-                  int64_t sector_num, int nb_sectors);
+-
+ int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,
+                                      int refcount_order, bool generous_increase,
+                                      uint64_t *refblock_count);
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ static int qcow2_read_extensions(BlockDriverState *bs, uint64_t start_offset,
+@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
-                 return -EINVAL;
+     return status;
-             }
+ }
--            if (bitmaps_ext.bitmap_directory_offset & (s->cluster_size - 1)) {
+-/* handle reading after the end of the backing file */
-+            if (offset_into_cluster(s, bitmaps_ext.bitmap_directory_offset)) {
+-int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
-                 error_setg(errp, "bitmaps_ext: "
+-                        int64_t offset, int bytes)
-                                  "invalid bitmap directory offset");
+-{
-                 return -EINVAL;
+-    uint64_t bs_size = bs->total_sectors * BDRV_SECTOR_SIZE;
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
+-    int n1;
 -
 -    if ((offset + bytes) <= bs_size) {
 -        return bytes;
 -    }
 -
 -    if (offset >= bs_size) {
 -        n1 = 0;
 -    } else {
 -        n1 = bs_size - offset;
 -    }
 -
 -    qemu_iovec_memset(qiov, n1, 0, bytes - n1);
 -
 -    return n1;
 -}
 -
  static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
                                          uint64_t bytes, QEMUIOVector *qiov,
                                          int flags)
  {
      BDRVQcow2State *s = bs->opaque;
-     uint64_t cluster_offset;
+-    int offset_in_cluster, n1;
--    int index_in_cluster, ret;
++    int offset_in_cluster;
-     unsigned int bytes;
+     int ret;
--    int status = 0;
+     unsigned int cur_bytes; /* number of bytes in current iteration */
-+    int ret, status = 0;
+     uint64_t cluster_offset = 0;
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
-     qemu_co_mutex_lock(&s->lock);
+         case QCOW2_CLUSTER_UNALLOCATED:
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_block_status(BlockDriverState *bs,
+             if (bs->backing) {
+-                /* read from the base image */
-     if ((ret == QCOW2_CLUSTER_NORMAL || ret == QCOW2_CLUSTER_ZERO_ALLOC) &&
+-                n1 = qcow2_backing_read1(bs->backing->bs, &hd_qiov,
-         !s->crypto) {
+-                                         offset, cur_bytes);
--        index_in_cluster = offset & (s->cluster_size - 1);
+-                if (n1 > 0) {
--        *map = cluster_offset | index_in_cluster;
+-                    QEMUIOVector local_qiov;
-+        *map = cluster_offset | offset_into_cluster(s, offset);
+-
-         *file = s->data_file->bs;
+-                    qemu_iovec_init(&local_qiov, hd_qiov.niov);
-         status |= BDRV_BLOCK_OFFSET_VALID;
+-                    qemu_iovec_concat(&local_qiov, &hd_qiov, 0, n1);
-     }
+-
 -                    BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
 -                    qemu_co_mutex_unlock(&s->lock);
 -                    ret = bdrv_co_preadv(bs->backing, offset, n1,
 -                                         &local_qiov, 0);
 -                    qemu_co_mutex_lock(&s->lock);
 -
 -                    qemu_iovec_destroy(&local_qiov);
 -
 -                    if (ret < 0) {
 -                        goto fail;
 -                    }
 +                BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
 +                qemu_co_mutex_unlock(&s->lock);
 +                ret = bdrv_co_preadv(bs->backing, offset, cur_bytes,
 +                                     &hd_qiov, 0);
 +                qemu_co_mutex_lock(&s->lock);
 +                if (ret < 0) {
 +                    goto fail;
                  }
              } else {
                  /* Note: in this case, no need to wait */
 --
-.20.1
+.13.6

-[PULL 04/30] qapi: better document NVMe blockdev @device parameter
+[Qemu-devel] [PULL v3 11/35] block: Document that x-blockdev-change breaks quorum children list
-From: Daniel P. Berrangé <berrange@redhat.com>
+Removing a quorum child node with x-blockdev-change results in a quorum
 driver state that cannot be recreated with create options because it
 would require a list with gaps. This causes trouble in at least
 .bdrv_refresh_filename().
-Mention that this is a PCI device address & give the format it is
+Document this problem so that we won't accidentally mark the command
-expected in. Also mention that it must be first unbound from any
+stable without having addressed it.
 host kernel driver.
-Signed-off-by: Daniel P. Berrangé <berrange@redhat.com>
-Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
 ---
- qapi/block-core.json | 6 +++++-
+ qapi/block-core.json | 4 ++++
-file changed, 5 insertions(+), 1 deletion(-)
+file changed, 4 insertions(+)
 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 @@
+ # does not support all kinds of operations, all kinds of children, nor
+ # all block drivers.
  #
- # Driver specific block device options for the NVMe backend.
++# FIXME Removing children from a quorum node means introducing gaps in the
 +# child indices. This cannot be represented in the 'children' list of
 +# BlockdevOptionsQuorum, as returned by .bdrv_refresh_filename().
 +#
  # Warning: The data in a new quorum child MUST be consistent with that of
  # the rest of the array.
  #
--# @device:    controller address of the NVMe device.
-+# @device:    PCI controller address of the NVMe device in
-+#             format hhhh:bb:ss.f (host:bus:slot.function)
- # @namespace: namespace number of the device, starting from 1.
- #
-+# Note that the PCI @device must have been unbound from any host
-+# kernel driver before instructing QEMU to add the blockdev.
-+#
- # Since: 2.12
- ##
- { 'struct': 'BlockdevOptionsNVMe',
 --
-.20.1
+.13.6

-[PULL 13/30] MAINTAINERS: fix qcow2-bitmap.c under Dirty Bitmaps header
+[Qemu-devel] [PULL v3 12/35] nvme: Add tracing
-From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+From: Doug Gale <doug16k@gmail.com>
-Somehow I wrote not full path to the file. Fix that.
+Add trace output for commands, errors, and undefined behavior.
 Add guest error log output for undefined behavior.
 Report invalid undefined accesses to MMIO.
 Annotate unlikely error checks with unlikely.
-Also, while being here, rearrange entries, so that includes go first,
+Signed-off-by: Doug Gale <doug16k@gmail.com>
-then block, than migration, than util.
+Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Fixes: 052db8e71444d
 Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- MAINTAINERS | 6 +++---
+ hw/block/nvme.c       | 349 ++++++++++++++++++++++++++++++++++++++++++--------
-file changed, 3 insertions(+), 3 deletions(-)
+ hw/block/trace-events |  93 ++++++++++++++
 files changed, 390 insertions(+), 52 deletions(-)
-diff --git a/MAINTAINERS b/MAINTAINERS
+diff --git a/hw/block/nvme.c b/hw/block/nvme.c
 index XXXXXXX..XXXXXXX 100644
---- a/MAINTAINERS
+--- a/hw/block/nvme.c
-+++ b/MAINTAINERS
++++ b/hw/block/nvme.c
-@@ -XXX,XX +XXX,XX @@ M: John Snow <jsnow@redhat.com>
+@@ -XXX,XX +XXX,XX @@
- R: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+ #include "qapi/visitor.h"
- L: qemu-block@nongnu.org
+ #include "sysemu/block-backend.h"
- S: Supported
--F: util/hbitmap.c
++#include "qemu/log.h"
--F: block/dirty-bitmap.c
++#include "trace.h"
- F: include/qemu/hbitmap.h
+ #include "nvme.h"
- F: include/block/dirty-bitmap.h
--F: qcow2-bitmap.c
++#define NVME_GUEST_ERR(trace, fmt, ...) \
-+F: block/dirty-bitmap.c
++    do { \
-+F: block/qcow2-bitmap.c
++        (trace_##trace)(__VA_ARGS__); \
- F: migration/block-dirty-bitmap.c
++        qemu_log_mask(LOG_GUEST_ERROR, #trace \
-+F: util/hbitmap.c
++            " in %s: " fmt "\n", __func__, ## __VA_ARGS__); \
- F: tests/test-hbitmap.c
++    } while (0)
- F: docs/interop/bitmaps.rst
++
- T: git https://github.com/jnsnow/qemu.git bitmaps
+ static void nvme_process_sq(void *opaque);
  static void nvme_addr_read(NvmeCtrl *n, hwaddr addr, void *buf, int size)
@@ -XXX,XX +XXX,XX @@ static void nvme_isr_notify(NvmeCtrl *n, NvmeCQueue *cq)
  {
      if (cq->irq_enabled) {
          if (msix_enabled(&(n->parent_obj))) {
 +            trace_nvme_irq_msix(cq->vector);
              msix_notify(&(n->parent_obj), cq->vector);
          } else {
 +            trace_nvme_irq_pin();
              pci_irq_pulse(&n->parent_obj);
          }
 +    } else {
 +        trace_nvme_irq_masked();
      }
  }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
      trans_len = MIN(len, trans_len);
      int num_prps = (len >> n->page_bits) + 1;
 -    if (!prp1) {
 +    if (unlikely(!prp1)) {
 +        trace_nvme_err_invalid_prp();
          return NVME_INVALID_FIELD | NVME_DNR;
      } else if (n->cmbsz && prp1 >= n->ctrl_mem.addr &&
                 prp1 < n->ctrl_mem.addr + int128_get64(n->ctrl_mem.size)) {
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
      }
      len -= trans_len;
      if (len) {
 -        if (!prp2) {
 +        if (unlikely(!prp2)) {
 +            trace_nvme_err_invalid_prp2_missing();
              goto unmap;
          }
          if (len > n->page_size) {
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
                  uint64_t prp_ent = le64_to_cpu(prp_list[i]);
                  if (i == n->max_prp_ents - 1 && len > n->page_size) {
 -                    if (!prp_ent || prp_ent & (n->page_size - 1)) {
 +                    if (unlikely(!prp_ent || prp_ent & (n->page_size - 1))) {
 +                        trace_nvme_err_invalid_prplist_ent(prp_ent);
                          goto unmap;
                      }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
                      prp_ent = le64_to_cpu(prp_list[i]);
                  }
 -                if (!prp_ent || prp_ent & (n->page_size - 1)) {
 +                if (unlikely(!prp_ent || prp_ent & (n->page_size - 1))) {
 +                    trace_nvme_err_invalid_prplist_ent(prp_ent);
                      goto unmap;
                  }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
                  i++;
              }
          } else {
 -            if (prp2 & (n->page_size - 1)) {
 +            if (unlikely(prp2 & (n->page_size - 1))) {
 +                trace_nvme_err_invalid_prp2_align(prp2);
                  goto unmap;
              }
              if (qsg->nsg) {
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_dma_read_prp(NvmeCtrl *n, uint8_t *ptr, uint32_t len,
      QEMUIOVector iov;
      uint16_t status = NVME_SUCCESS;
 +    trace_nvme_dma_read(prp1, prp2);
 +
      if (nvme_map_prp(&qsg, &iov, prp1, prp2, len, n)) {
          return NVME_INVALID_FIELD | NVME_DNR;
      }
      if (qsg.nsg > 0) {
 -        if (dma_buf_read(ptr, len, &qsg)) {
 +        if (unlikely(dma_buf_read(ptr, len, &qsg))) {
 +            trace_nvme_err_invalid_dma();
              status = NVME_INVALID_FIELD | NVME_DNR;
          }
          qemu_sglist_destroy(&qsg);
      } else {
 -        if (qemu_iovec_to_buf(&iov, 0, ptr, len) != len) {
 +        if (unlikely(qemu_iovec_to_buf(&iov, 0, ptr, len) != len)) {
 +            trace_nvme_err_invalid_dma();
              status = NVME_INVALID_FIELD | NVME_DNR;
          }
          qemu_iovec_destroy(&iov);
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_write_zeros(NvmeCtrl *n, NvmeNamespace *ns, NvmeCmd *cmd,
      uint64_t aio_slba = slba << (data_shift - BDRV_SECTOR_BITS);
      uint32_t aio_nlb = nlb << (data_shift - BDRV_SECTOR_BITS);
 -    if (slba + nlb > ns->id_ns.nsze) {
 +    if (unlikely(slba + nlb > ns->id_ns.nsze)) {
 +        trace_nvme_err_invalid_lba_range(slba, nlb, ns->id_ns.nsze);
          return NVME_LBA_RANGE | NVME_DNR;
      }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_rw(NvmeCtrl *n, NvmeNamespace *ns, NvmeCmd *cmd,
      int is_write = rw->opcode == NVME_CMD_WRITE ? 1 : 0;
      enum BlockAcctType acct = is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ;
 -    if ((slba + nlb) > ns->id_ns.nsze) {
 +    trace_nvme_rw(is_write ? "write" : "read", nlb, data_size, slba);
 +
 +    if (unlikely((slba + nlb) > ns->id_ns.nsze)) {
          block_acct_invalid(blk_get_stats(n->conf.blk), acct);
 +        trace_nvme_err_invalid_lba_range(slba, nlb, ns->id_ns.nsze);
          return NVME_LBA_RANGE | NVME_DNR;
      }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_io_cmd(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
      NvmeNamespace *ns;
      uint32_t nsid = le32_to_cpu(cmd->nsid);
 -    if (nsid == 0 || nsid > n->num_namespaces) {
 +    if (unlikely(nsid == 0 || nsid > n->num_namespaces)) {
 +        trace_nvme_err_invalid_ns(nsid, n->num_namespaces);
          return NVME_INVALID_NSID | NVME_DNR;
      }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_io_cmd(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
      case NVME_CMD_READ:
          return nvme_rw(n, ns, cmd, req);
      default:
 +        trace_nvme_err_invalid_opc(cmd->opcode);
          return NVME_INVALID_OPCODE | NVME_DNR;
      }
  }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_del_sq(NvmeCtrl *n, NvmeCmd *cmd)
      NvmeCQueue *cq;
      uint16_t qid = le16_to_cpu(c->qid);
 -    if (!qid || nvme_check_sqid(n, qid)) {
 +    if (unlikely(!qid || nvme_check_sqid(n, qid))) {
 +        trace_nvme_err_invalid_del_sq(qid);
          return NVME_INVALID_QID | NVME_DNR;
      }
 +    trace_nvme_del_sq(qid);
 +
      sq = n->sq[qid];
      while (!QTAILQ_EMPTY(&sq->out_req_list)) {
          req = QTAILQ_FIRST(&sq->out_req_list);
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_create_sq(NvmeCtrl *n, NvmeCmd *cmd)
      uint16_t qflags = le16_to_cpu(c->sq_flags);
      uint64_t prp1 = le64_to_cpu(c->prp1);
 -    if (!cqid || nvme_check_cqid(n, cqid)) {
 +    trace_nvme_create_sq(prp1, sqid, cqid, qsize, qflags);
 +
 +    if (unlikely(!cqid || nvme_check_cqid(n, cqid))) {
 +        trace_nvme_err_invalid_create_sq_cqid(cqid);
          return NVME_INVALID_CQID | NVME_DNR;
      }
 -    if (!sqid || !nvme_check_sqid(n, sqid)) {
 +    if (unlikely(!sqid || !nvme_check_sqid(n, sqid))) {
 +        trace_nvme_err_invalid_create_sq_sqid(sqid);
          return NVME_INVALID_QID | NVME_DNR;
      }
 -    if (!qsize || qsize > NVME_CAP_MQES(n->bar.cap)) {
 +    if (unlikely(!qsize || qsize > NVME_CAP_MQES(n->bar.cap))) {
 +        trace_nvme_err_invalid_create_sq_size(qsize);
          return NVME_MAX_QSIZE_EXCEEDED | NVME_DNR;
      }
 -    if (!prp1 || prp1 & (n->page_size - 1)) {
 +    if (unlikely(!prp1 || prp1 & (n->page_size - 1))) {
 +        trace_nvme_err_invalid_create_sq_addr(prp1);
          return NVME_INVALID_FIELD | NVME_DNR;
      }
 -    if (!(NVME_SQ_FLAGS_PC(qflags))) {
 +    if (unlikely(!(NVME_SQ_FLAGS_PC(qflags)))) {
 +        trace_nvme_err_invalid_create_sq_qflags(NVME_SQ_FLAGS_PC(qflags));
          return NVME_INVALID_FIELD | NVME_DNR;
      }
      sq = g_malloc0(sizeof(*sq));
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_del_cq(NvmeCtrl *n, NvmeCmd *cmd)
      NvmeCQueue *cq;
      uint16_t qid = le16_to_cpu(c->qid);
 -    if (!qid || nvme_check_cqid(n, qid)) {
 +    if (unlikely(!qid || nvme_check_cqid(n, qid))) {
 +        trace_nvme_err_invalid_del_cq_cqid(qid);
          return NVME_INVALID_CQID | NVME_DNR;
      }
      cq = n->cq[qid];
 -    if (!QTAILQ_EMPTY(&cq->sq_list)) {
 +    if (unlikely(!QTAILQ_EMPTY(&cq->sq_list))) {
 +        trace_nvme_err_invalid_del_cq_notempty(qid);
          return NVME_INVALID_QUEUE_DEL;
      }
 +    trace_nvme_del_cq(qid);
      nvme_free_cq(cq, n);
      return NVME_SUCCESS;
  }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_create_cq(NvmeCtrl *n, NvmeCmd *cmd)
      uint16_t qflags = le16_to_cpu(c->cq_flags);
      uint64_t prp1 = le64_to_cpu(c->prp1);
 -    if (!cqid || !nvme_check_cqid(n, cqid)) {
 +    trace_nvme_create_cq(prp1, cqid, vector, qsize, qflags,
 +                         NVME_CQ_FLAGS_IEN(qflags) != 0);
 +
 +    if (unlikely(!cqid || !nvme_check_cqid(n, cqid))) {
 +        trace_nvme_err_invalid_create_cq_cqid(cqid);
          return NVME_INVALID_CQID | NVME_DNR;
      }
 -    if (!qsize || qsize > NVME_CAP_MQES(n->bar.cap)) {
 +    if (unlikely(!qsize || qsize > NVME_CAP_MQES(n->bar.cap))) {
 +        trace_nvme_err_invalid_create_cq_size(qsize);
          return NVME_MAX_QSIZE_EXCEEDED | NVME_DNR;
      }
 -    if (!prp1) {
 +    if (unlikely(!prp1)) {
 +        trace_nvme_err_invalid_create_cq_addr(prp1);
          return NVME_INVALID_FIELD | NVME_DNR;
      }
 -    if (vector > n->num_queues) {
 +    if (unlikely(vector > n->num_queues)) {
 +        trace_nvme_err_invalid_create_cq_vector(vector);
          return NVME_INVALID_IRQ_VECTOR | NVME_DNR;
      }
 -    if (!(NVME_CQ_FLAGS_PC(qflags))) {
 +    if (unlikely(!(NVME_CQ_FLAGS_PC(qflags)))) {
 +        trace_nvme_err_invalid_create_cq_qflags(NVME_CQ_FLAGS_PC(qflags));
          return NVME_INVALID_FIELD | NVME_DNR;
      }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_identify_ctrl(NvmeCtrl *n, NvmeIdentify *c)
      uint64_t prp1 = le64_to_cpu(c->prp1);
      uint64_t prp2 = le64_to_cpu(c->prp2);
 +    trace_nvme_identify_ctrl();
 +
      return nvme_dma_read_prp(n, (uint8_t *)&n->id_ctrl, sizeof(n->id_ctrl),
          prp1, prp2);
  }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_identify_ns(NvmeCtrl *n, NvmeIdentify *c)
      uint64_t prp1 = le64_to_cpu(c->prp1);
      uint64_t prp2 = le64_to_cpu(c->prp2);
 -    if (nsid == 0 || nsid > n->num_namespaces) {
 +    trace_nvme_identify_ns(nsid);
 +
 +    if (unlikely(nsid == 0 || nsid > n->num_namespaces)) {
 +        trace_nvme_err_invalid_ns(nsid, n->num_namespaces);
          return NVME_INVALID_NSID | NVME_DNR;
      }
      ns = &n->namespaces[nsid - 1];
 +
      return nvme_dma_read_prp(n, (uint8_t *)&ns->id_ns, sizeof(ns->id_ns),
          prp1, prp2);
  }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_identify_nslist(NvmeCtrl *n, NvmeIdentify *c)
      uint16_t ret;
      int i, j = 0;
 +    trace_nvme_identify_nslist(min_nsid);
 +
      list = g_malloc0(data_len);
      for (i = 0; i < n->num_namespaces; i++) {
          if (i < min_nsid) {
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_identify(NvmeCtrl *n, NvmeCmd *cmd)
      case 0x02:
          return nvme_identify_nslist(n, c);
      default:
 +        trace_nvme_err_invalid_identify_cns(le32_to_cpu(c->cns));
          return NVME_INVALID_FIELD | NVME_DNR;
      }
  }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
      switch (dw10) {
      case NVME_VOLATILE_WRITE_CACHE:
          result = blk_enable_write_cache(n->conf.blk);
 +        trace_nvme_getfeat_vwcache(result ? "enabled" : "disabled");
          break;
      case NVME_NUMBER_OF_QUEUES:
          result = cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
 +        trace_nvme_getfeat_numq(result);
          break;
      default:
 +        trace_nvme_err_invalid_getfeat(dw10);
          return NVME_INVALID_FIELD | NVME_DNR;
      }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_set_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
          blk_set_enable_write_cache(n->conf.blk, dw11 & 1);
          break;
      case NVME_NUMBER_OF_QUEUES:
 +        trace_nvme_setfeat_numq((dw11 & 0xFFFF) + 1,
 +                                ((dw11 >> 16) & 0xFFFF) + 1,
 +                                n->num_queues - 1, n->num_queues - 1);
          req->cqe.result =
              cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
          break;
      default:
 +        trace_nvme_err_invalid_setfeat(dw10);
          return NVME_INVALID_FIELD | NVME_DNR;
      }
      return NVME_SUCCESS;
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_admin_cmd(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
      case NVME_ADM_CMD_GET_FEATURES:
          return nvme_get_feature(n, cmd, req);
      default:
 +        trace_nvme_err_invalid_admin_opc(cmd->opcode);
          return NVME_INVALID_OPCODE | NVME_DNR;
      }
  }
@@ -XXX,XX +XXX,XX @@ static int nvme_start_ctrl(NvmeCtrl *n)
      uint32_t page_bits = NVME_CC_MPS(n->bar.cc) + 12;
      uint32_t page_size = 1 << page_bits;
 -    if (n->cq[0] || n->sq[0] || !n->bar.asq || !n->bar.acq ||
 -            n->bar.asq & (page_size - 1) || n->bar.acq & (page_size - 1) ||
 -            NVME_CC_MPS(n->bar.cc) < NVME_CAP_MPSMIN(n->bar.cap) ||
 -            NVME_CC_MPS(n->bar.cc) > NVME_CAP_MPSMAX(n->bar.cap) ||
 -            NVME_CC_IOCQES(n->bar.cc) < NVME_CTRL_CQES_MIN(n->id_ctrl.cqes) ||
 -            NVME_CC_IOCQES(n->bar.cc) > NVME_CTRL_CQES_MAX(n->id_ctrl.cqes) ||
 -            NVME_CC_IOSQES(n->bar.cc) < NVME_CTRL_SQES_MIN(n->id_ctrl.sqes) ||
 -            NVME_CC_IOSQES(n->bar.cc) > NVME_CTRL_SQES_MAX(n->id_ctrl.sqes) ||
 -            !NVME_AQA_ASQS(n->bar.aqa) || !NVME_AQA_ACQS(n->bar.aqa)) {
 +    if (unlikely(n->cq[0])) {
 +        trace_nvme_err_startfail_cq();
 +        return -1;
 +    }
 +    if (unlikely(n->sq[0])) {
 +        trace_nvme_err_startfail_sq();
 +        return -1;
 +    }
 +    if (unlikely(!n->bar.asq)) {
 +        trace_nvme_err_startfail_nbarasq();
 +        return -1;
 +    }
 +    if (unlikely(!n->bar.acq)) {
 +        trace_nvme_err_startfail_nbaracq();
 +        return -1;
 +    }
 +    if (unlikely(n->bar.asq & (page_size - 1))) {
 +        trace_nvme_err_startfail_asq_misaligned(n->bar.asq);
 +        return -1;
 +    }
 +    if (unlikely(n->bar.acq & (page_size - 1))) {
 +        trace_nvme_err_startfail_acq_misaligned(n->bar.acq);
 +        return -1;
 +    }
 +    if (unlikely(NVME_CC_MPS(n->bar.cc) <
 +                 NVME_CAP_MPSMIN(n->bar.cap))) {
 +        trace_nvme_err_startfail_page_too_small(
 +                    NVME_CC_MPS(n->bar.cc),
 +                    NVME_CAP_MPSMIN(n->bar.cap));
 +        return -1;
 +    }
 +    if (unlikely(NVME_CC_MPS(n->bar.cc) >
 +                 NVME_CAP_MPSMAX(n->bar.cap))) {
 +        trace_nvme_err_startfail_page_too_large(
 +                    NVME_CC_MPS(n->bar.cc),
 +                    NVME_CAP_MPSMAX(n->bar.cap));
 +        return -1;
 +    }
 +    if (unlikely(NVME_CC_IOCQES(n->bar.cc) <
 +                 NVME_CTRL_CQES_MIN(n->id_ctrl.cqes))) {
 +        trace_nvme_err_startfail_cqent_too_small(
 +                    NVME_CC_IOCQES(n->bar.cc),
 +                    NVME_CTRL_CQES_MIN(n->bar.cap));
 +        return -1;
 +    }
 +    if (unlikely(NVME_CC_IOCQES(n->bar.cc) >
 +                 NVME_CTRL_CQES_MAX(n->id_ctrl.cqes))) {
 +        trace_nvme_err_startfail_cqent_too_large(
 +                    NVME_CC_IOCQES(n->bar.cc),
 +                    NVME_CTRL_CQES_MAX(n->bar.cap));
 +        return -1;
 +    }
 +    if (unlikely(NVME_CC_IOSQES(n->bar.cc) <
 +                 NVME_CTRL_SQES_MIN(n->id_ctrl.sqes))) {
 +        trace_nvme_err_startfail_sqent_too_small(
 +                    NVME_CC_IOSQES(n->bar.cc),
 +                    NVME_CTRL_SQES_MIN(n->bar.cap));
 +        return -1;
 +    }
 +    if (unlikely(NVME_CC_IOSQES(n->bar.cc) >
 +                 NVME_CTRL_SQES_MAX(n->id_ctrl.sqes))) {
 +        trace_nvme_err_startfail_sqent_too_large(
 +                    NVME_CC_IOSQES(n->bar.cc),
 +                    NVME_CTRL_SQES_MAX(n->bar.cap));
 +        return -1;
 +    }
 +    if (unlikely(!NVME_AQA_ASQS(n->bar.aqa))) {
 +        trace_nvme_err_startfail_asqent_sz_zero();
 +        return -1;
 +    }
 +    if (unlikely(!NVME_AQA_ACQS(n->bar.aqa))) {
 +        trace_nvme_err_startfail_acqent_sz_zero();
          return -1;
      }
@@ -XXX,XX +XXX,XX @@ static int nvme_start_ctrl(NvmeCtrl *n)
  static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
      unsigned size)
  {
 +    if (unlikely(offset & (sizeof(uint32_t) - 1))) {
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_misaligned32,
 +                       "MMIO write not 32-bit aligned,"
 +                       " offset=0x%"PRIx64"", offset);
 +        /* should be ignored, fall through for now */
 +    }
 +
 +    if (unlikely(size < sizeof(uint32_t))) {
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_toosmall,
 +                       "MMIO write smaller than 32-bits,"
 +                       " offset=0x%"PRIx64", size=%u",
 +                       offset, size);
 +        /* should be ignored, fall through for now */
 +    }
 +
      switch (offset) {
 -    case 0xc:
 +    case 0xc:   /* INTMS */
 +        if (unlikely(msix_enabled(&(n->parent_obj)))) {
 +            NVME_GUEST_ERR(nvme_ub_mmiowr_intmask_with_msix,
 +                           "undefined access to interrupt mask set"
 +                           " when MSI-X is enabled");
 +            /* should be ignored, fall through for now */
 +        }
          n->bar.intms |= data & 0xffffffff;
          n->bar.intmc = n->bar.intms;
 +        trace_nvme_mmio_intm_set(data & 0xffffffff,
 +                                 n->bar.intmc);
          break;
 -    case 0x10:
 +    case 0x10:  /* INTMC */
 +        if (unlikely(msix_enabled(&(n->parent_obj)))) {
 +            NVME_GUEST_ERR(nvme_ub_mmiowr_intmask_with_msix,
 +                           "undefined access to interrupt mask clr"
 +                           " when MSI-X is enabled");
 +            /* should be ignored, fall through for now */
 +        }
          n->bar.intms &= ~(data & 0xffffffff);
          n->bar.intmc = n->bar.intms;
 +        trace_nvme_mmio_intm_clr(data & 0xffffffff,
 +                                 n->bar.intmc);
          break;
 -    case 0x14:
 +    case 0x14:  /* CC */
 +        trace_nvme_mmio_cfg(data & 0xffffffff);
          /* Windows first sends data, then sends enable bit */
          if (!NVME_CC_EN(data) && !NVME_CC_EN(n->bar.cc) &&
              !NVME_CC_SHN(data) && !NVME_CC_SHN(n->bar.cc))
@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
          if (NVME_CC_EN(data) && !NVME_CC_EN(n->bar.cc)) {
              n->bar.cc = data;
 -            if (nvme_start_ctrl(n)) {
 +            if (unlikely(nvme_start_ctrl(n))) {
 +                trace_nvme_err_startfail();
                  n->bar.csts = NVME_CSTS_FAILED;
              } else {
 +                trace_nvme_mmio_start_success();
                  n->bar.csts = NVME_CSTS_READY;
              }
          } else if (!NVME_CC_EN(data) && NVME_CC_EN(n->bar.cc)) {
 +            trace_nvme_mmio_stopped();
              nvme_clear_ctrl(n);
              n->bar.csts &= ~NVME_CSTS_READY;
          }
          if (NVME_CC_SHN(data) && !(NVME_CC_SHN(n->bar.cc))) {
 -                nvme_clear_ctrl(n);
 -                n->bar.cc = data;
 -                n->bar.csts |= NVME_CSTS_SHST_COMPLETE;
 +            trace_nvme_mmio_shutdown_set();
 +            nvme_clear_ctrl(n);
 +            n->bar.cc = data;
 +            n->bar.csts |= NVME_CSTS_SHST_COMPLETE;
          } else if (!NVME_CC_SHN(data) && NVME_CC_SHN(n->bar.cc)) {
 -                n->bar.csts &= ~NVME_CSTS_SHST_COMPLETE;
 -                n->bar.cc = data;
 +            trace_nvme_mmio_shutdown_cleared();
 +            n->bar.csts &= ~NVME_CSTS_SHST_COMPLETE;
 +            n->bar.cc = data;
 +        }
 +        break;
 +    case 0x1C:  /* CSTS */
 +        if (data & (1 << 4)) {
 +            NVME_GUEST_ERR(nvme_ub_mmiowr_ssreset_w1c_unsupported,
 +                           "attempted to W1C CSTS.NSSRO"
 +                           " but CAP.NSSRS is zero (not supported)");
 +        } else if (data != 0) {
 +            NVME_GUEST_ERR(nvme_ub_mmiowr_ro_csts,
 +                           "attempted to set a read only bit"
 +                           " of controller status");
 +        }
 +        break;
 +    case 0x20:  /* NSSR */
 +        if (data == 0x4E564D65) {
 +            trace_nvme_ub_mmiowr_ssreset_unsupported();
 +        } else {
 +            /* The spec says that writes of other values have no effect */
 +            return;
          }
          break;
 -    case 0x24:
 +    case 0x24:  /* AQA */
          n->bar.aqa = data & 0xffffffff;
 +        trace_nvme_mmio_aqattr(data & 0xffffffff);
          break;
 -    case 0x28:
 +    case 0x28:  /* ASQ */
          n->bar.asq = data;
 +        trace_nvme_mmio_asqaddr(data);
          break;
 -    case 0x2c:
 +    case 0x2c:  /* ASQ hi */
          n->bar.asq |= data << 32;
 +        trace_nvme_mmio_asqaddr_hi(data, n->bar.asq);
          break;
 -    case 0x30:
 +    case 0x30:  /* ACQ */
 +        trace_nvme_mmio_acqaddr(data);
          n->bar.acq = data;
          break;
 -    case 0x34:
 +    case 0x34:  /* ACQ hi */
          n->bar.acq |= data << 32;
 +        trace_nvme_mmio_acqaddr_hi(data, n->bar.acq);
          break;
 +    case 0x38:  /* CMBLOC */
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_cmbloc_reserved,
 +                       "invalid write to reserved CMBLOC"
 +                       " when CMBSZ is zero, ignored");
 +        return;
 +    case 0x3C:  /* CMBSZ */
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_cmbsz_readonly,
 +                       "invalid write to read only CMBSZ, ignored");
 +        return;
      default:
 +        NVME_GUEST_ERR(nvme_ub_mmiowr_invalid,
 +                       "invalid MMIO write,"
 +                       " offset=0x%"PRIx64", data=%"PRIx64"",
 +                       offset, data);
          break;
      }
  }
@@ -XXX,XX +XXX,XX @@ static uint64_t nvme_mmio_read(void *opaque, hwaddr addr, unsigned size)
      uint8_t *ptr = (uint8_t *)&n->bar;
      uint64_t val = 0;
 +    if (unlikely(addr & (sizeof(uint32_t) - 1))) {
 +        NVME_GUEST_ERR(nvme_ub_mmiord_misaligned32,
 +                       "MMIO read not 32-bit aligned,"
 +                       " offset=0x%"PRIx64"", addr);
 +        /* should RAZ, fall through for now */
 +    } else if (unlikely(size < sizeof(uint32_t))) {
 +        NVME_GUEST_ERR(nvme_ub_mmiord_toosmall,
 +                       "MMIO read smaller than 32-bits,"
 +                       " offset=0x%"PRIx64"", addr);
 +        /* should RAZ, fall through for now */
 +    }
 +
      if (addr < sizeof(n->bar)) {
          memcpy(&val, ptr + addr, size);
 +    } else {
 +        NVME_GUEST_ERR(nvme_ub_mmiord_invalid_ofs,
 +                       "MMIO read beyond last register,"
 +                       " offset=0x%"PRIx64", returning 0", addr);
      }
 +
      return val;
  }
@@ -XXX,XX +XXX,XX @@ static void nvme_process_db(NvmeCtrl *n, hwaddr addr, int val)
  {
      uint32_t qid;
 -    if (addr & ((1 << 2) - 1)) {
 +    if (unlikely(addr & ((1 << 2) - 1))) {
 +        NVME_GUEST_ERR(nvme_ub_db_wr_misaligned,
 +                       "doorbell write not 32-bit aligned,"
 +                       " offset=0x%"PRIx64", ignoring", addr);
          return;
      }
      if (((addr - 0x1000) >> 2) & 1) {
 +        /* Completion queue doorbell write */
 +
          uint16_t new_head = val & 0xffff;
          int start_sqs;
          NvmeCQueue *cq;
          qid = (addr - (0x1000 + (1 << 2))) >> 3;
 -        if (nvme_check_cqid(n, qid)) {
 +        if (unlikely(nvme_check_cqid(n, qid))) {
 +            NVME_GUEST_ERR(nvme_ub_db_wr_invalid_cq,
 +                           "completion queue doorbell write"
 +                           " for nonexistent queue,"
 +                           " sqid=%"PRIu32", ignoring", qid);
              return;
          }
          cq = n->cq[qid];
 -        if (new_head >= cq->size) {
 +        if (unlikely(new_head >= cq->size)) {
 +            NVME_GUEST_ERR(nvme_ub_db_wr_invalid_cqhead,
 +                           "completion queue doorbell write value"
 +                           " beyond queue size, sqid=%"PRIu32","
 +                           " new_head=%"PRIu16", ignoring",
 +                           qid, new_head);
              return;
          }
@@ -XXX,XX +XXX,XX @@ static void nvme_process_db(NvmeCtrl *n, hwaddr addr, int val)
              nvme_isr_notify(n, cq);
          }
      } else {
 +        /* Submission queue doorbell write */
 +
          uint16_t new_tail = val & 0xffff;
          NvmeSQueue *sq;
          qid = (addr - 0x1000) >> 3;
 -        if (nvme_check_sqid(n, qid)) {
 +        if (unlikely(nvme_check_sqid(n, qid))) {
 +            NVME_GUEST_ERR(nvme_ub_db_wr_invalid_sq,
 +                           "submission queue doorbell write"
 +                           " for nonexistent queue,"
 +                           " sqid=%"PRIu32", ignoring", qid);
              return;
          }
          sq = n->sq[qid];
 -        if (new_tail >= sq->size) {
 +        if (unlikely(new_tail >= sq->size)) {
 +            NVME_GUEST_ERR(nvme_ub_db_wr_invalid_sqtail,
 +                           "submission queue doorbell write value"
 +                           " beyond queue size, sqid=%"PRIu32","
 +                           " new_tail=%"PRIu16", ignoring",
 +                           qid, new_tail);
              return;
          }
 diff --git a/hw/block/trace-events b/hw/block/trace-events
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/trace-events
 +++ b/hw/block/trace-events
@@ -XXX,XX +XXX,XX @@ virtio_blk_submit_multireq(void *vdev, void *mrb, int start, int num_reqs, uint6
  hd_geometry_lchs_guess(void *blk, int cyls, int heads, int secs) "blk %p LCHS %d %d %d"
  hd_geometry_guess(void *blk, uint32_t cyls, uint32_t heads, uint32_t secs, int trans) "blk %p CHS %u %u %u trans %d"
 +# hw/block/nvme.c
 +# nvme traces for successful events
 +nvme_irq_msix(uint32_t vector) "raising MSI-X IRQ vector %u"
 +nvme_irq_pin(void) "pulsing IRQ pin"
 +nvme_irq_masked(void) "IRQ is masked"
 +nvme_dma_read(uint64_t prp1, uint64_t prp2) "DMA read, prp1=0x%"PRIx64" prp2=0x%"PRIx64""
 +nvme_rw(char const *verb, uint32_t blk_count, uint64_t byte_count, uint64_t lba) "%s %"PRIu32" blocks (%"PRIu64" bytes) from LBA %"PRIu64""
 +nvme_create_sq(uint64_t addr, uint16_t sqid, uint16_t cqid, uint16_t qsize, uint16_t qflags) "create submission queue, addr=0x%"PRIx64", sqid=%"PRIu16", cqid=%"PRIu16", qsize=%"PRIu16", qflags=%"PRIu16""
 +nvme_create_cq(uint64_t addr, uint16_t cqid, uint16_t vector, uint16_t size, uint16_t qflags, int ien) "create completion queue, addr=0x%"PRIx64", cqid=%"PRIu16", vector=%"PRIu16", qsize=%"PRIu16", qflags=%"PRIu16", ien=%d"
 +nvme_del_sq(uint16_t qid) "deleting submission queue sqid=%"PRIu16""
 +nvme_del_cq(uint16_t cqid) "deleted completion queue, sqid=%"PRIu16""
 +nvme_identify_ctrl(void) "identify controller"
 +nvme_identify_ns(uint16_t ns) "identify namespace, nsid=%"PRIu16""
 +nvme_identify_nslist(uint16_t ns) "identify namespace list, nsid=%"PRIu16""
 +nvme_getfeat_vwcache(char const* result) "get feature volatile write cache, result=%s"
 +nvme_getfeat_numq(int result) "get feature number of queues, result=%d"
 +nvme_setfeat_numq(int reqcq, int reqsq, int gotcq, int gotsq) "requested cq_count=%d sq_count=%d, responding with cq_count=%d sq_count=%d"
 +nvme_mmio_intm_set(uint64_t data, uint64_t new_mask) "wrote MMIO, interrupt mask set, data=0x%"PRIx64", new_mask=0x%"PRIx64""
 +nvme_mmio_intm_clr(uint64_t data, uint64_t new_mask) "wrote MMIO, interrupt mask clr, data=0x%"PRIx64", new_mask=0x%"PRIx64""
 +nvme_mmio_cfg(uint64_t data) "wrote MMIO, config controller config=0x%"PRIx64""
 +nvme_mmio_aqattr(uint64_t data) "wrote MMIO, admin queue attributes=0x%"PRIx64""
 +nvme_mmio_asqaddr(uint64_t data) "wrote MMIO, admin submission queue address=0x%"PRIx64""
 +nvme_mmio_acqaddr(uint64_t data) "wrote MMIO, admin completion queue address=0x%"PRIx64""
 +nvme_mmio_asqaddr_hi(uint64_t data, uint64_t new_addr) "wrote MMIO, admin submission queue high half=0x%"PRIx64", new_address=0x%"PRIx64""
 +nvme_mmio_acqaddr_hi(uint64_t data, uint64_t new_addr) "wrote MMIO, admin completion queue high half=0x%"PRIx64", new_address=0x%"PRIx64""
 +nvme_mmio_start_success(void) "setting controller enable bit succeeded"
 +nvme_mmio_stopped(void) "cleared controller enable bit"
 +nvme_mmio_shutdown_set(void) "shutdown bit set"
 +nvme_mmio_shutdown_cleared(void) "shutdown bit cleared"
 +
 +# nvme traces for error conditions
 +nvme_err_invalid_dma(void) "PRP/SGL is too small for transfer size"
 +nvme_err_invalid_prplist_ent(uint64_t prplist) "PRP list entry is null or not page aligned: 0x%"PRIx64""
 +nvme_err_invalid_prp2_align(uint64_t prp2) "PRP2 is not page aligned: 0x%"PRIx64""
 +nvme_err_invalid_prp2_missing(void) "PRP2 is null and more data to be transferred"
 +nvme_err_invalid_field(void) "invalid field"
 +nvme_err_invalid_prp(void) "invalid PRP"
 +nvme_err_invalid_sgl(void) "invalid SGL"
 +nvme_err_invalid_ns(uint32_t ns, uint32_t limit) "invalid namespace %u not within 1-%u"
 +nvme_err_invalid_opc(uint8_t opc) "invalid opcode 0x%"PRIx8""
 +nvme_err_invalid_admin_opc(uint8_t opc) "invalid admin opcode 0x%"PRIx8""
 +nvme_err_invalid_lba_range(uint64_t start, uint64_t len, uint64_t limit) "Invalid LBA start=%"PRIu64" len=%"PRIu64" limit=%"PRIu64""
 +nvme_err_invalid_del_sq(uint16_t qid) "invalid submission queue deletion, sid=%"PRIu16""
 +nvme_err_invalid_create_sq_cqid(uint16_t cqid) "failed creating submission queue, invalid cqid=%"PRIu16""
 +nvme_err_invalid_create_sq_sqid(uint16_t sqid) "failed creating submission queue, invalid sqid=%"PRIu16""
 +nvme_err_invalid_create_sq_size(uint16_t qsize) "failed creating submission queue, invalid qsize=%"PRIu16""
 +nvme_err_invalid_create_sq_addr(uint64_t addr) "failed creating submission queue, addr=0x%"PRIx64""
 +nvme_err_invalid_create_sq_qflags(uint16_t qflags) "failed creating submission queue, qflags=%"PRIu16""
 +nvme_err_invalid_del_cq_cqid(uint16_t cqid) "failed deleting completion queue, cqid=%"PRIu16""
 +nvme_err_invalid_del_cq_notempty(uint16_t cqid) "failed deleting completion queue, it is not empty, cqid=%"PRIu16""
 +nvme_err_invalid_create_cq_cqid(uint16_t cqid) "failed creating completion queue, cqid=%"PRIu16""
 +nvme_err_invalid_create_cq_size(uint16_t size) "failed creating completion queue, size=%"PRIu16""
 +nvme_err_invalid_create_cq_addr(uint64_t addr) "failed creating completion queue, addr=0x%"PRIx64""
 +nvme_err_invalid_create_cq_vector(uint16_t vector) "failed creating completion queue, vector=%"PRIu16""
 +nvme_err_invalid_create_cq_qflags(uint16_t qflags) "failed creating completion queue, qflags=%"PRIu16""
 +nvme_err_invalid_identify_cns(uint16_t cns) "identify, invalid cns=0x%"PRIx16""
 +nvme_err_invalid_getfeat(int dw10) "invalid get features, dw10=0x%"PRIx32""
 +nvme_err_invalid_setfeat(uint32_t dw10) "invalid set features, dw10=0x%"PRIx32""
 +nvme_err_startfail_cq(void) "nvme_start_ctrl failed because there are non-admin completion queues"
 +nvme_err_startfail_sq(void) "nvme_start_ctrl failed because there are non-admin submission queues"
 +nvme_err_startfail_nbarasq(void) "nvme_start_ctrl failed because the admin submission queue address is null"
 +nvme_err_startfail_nbaracq(void) "nvme_start_ctrl failed because the admin completion queue address is null"
 +nvme_err_startfail_asq_misaligned(uint64_t addr) "nvme_start_ctrl failed because the admin submission queue address is misaligned: 0x%"PRIx64""
 +nvme_err_startfail_acq_misaligned(uint64_t addr) "nvme_start_ctrl failed because the admin completion queue address is misaligned: 0x%"PRIx64""
 +nvme_err_startfail_page_too_small(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the page size is too small: log2size=%u, min=%u"
 +nvme_err_startfail_page_too_large(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the page size is too large: log2size=%u, max=%u"
 +nvme_err_startfail_cqent_too_small(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the completion queue entry size is too small: log2size=%u, min=%u"
 +nvme_err_startfail_cqent_too_large(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the completion queue entry size is too large: log2size=%u, max=%u"
 +nvme_err_startfail_sqent_too_small(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the submission queue entry size is too small: log2size=%u, min=%u"
 +nvme_err_startfail_sqent_too_large(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the submission queue entry size is too large: log2size=%u, max=%u"
 +nvme_err_startfail_asqent_sz_zero(void) "nvme_start_ctrl failed because the admin submission queue size is zero"
 +nvme_err_startfail_acqent_sz_zero(void) "nvme_start_ctrl failed because the admin completion queue size is zero"
 +nvme_err_startfail(void) "setting controller enable bit failed"
 +
 +# Traces for undefined behavior
 +nvme_ub_mmiowr_misaligned32(uint64_t offset) "MMIO write not 32-bit aligned, offset=0x%"PRIx64""
 +nvme_ub_mmiowr_toosmall(uint64_t offset, unsigned size) "MMIO write smaller than 32 bits, offset=0x%"PRIx64", size=%u"
 +nvme_ub_mmiowr_intmask_with_msix(void) "undefined access to interrupt mask set when MSI-X is enabled"
 +nvme_ub_mmiowr_ro_csts(void) "attempted to set a read only bit of controller status"
 +nvme_ub_mmiowr_ssreset_w1c_unsupported(void) "attempted to W1C CSTS.NSSRO but CAP.NSSRS is zero (not supported)"
 +nvme_ub_mmiowr_ssreset_unsupported(void) "attempted NVM subsystem reset but CAP.NSSRS is zero (not supported)"
 +nvme_ub_mmiowr_cmbloc_reserved(void) "invalid write to reserved CMBLOC when CMBSZ is zero, ignored"
 +nvme_ub_mmiowr_cmbsz_readonly(void) "invalid write to read only CMBSZ, ignored"
 +nvme_ub_mmiowr_invalid(uint64_t offset, uint64_t data) "invalid MMIO write, offset=0x%"PRIx64", data=0x%"PRIx64""
 +nvme_ub_mmiord_misaligned32(uint64_t offset) "MMIO read not 32-bit aligned, offset=0x%"PRIx64""
 +nvme_ub_mmiord_toosmall(uint64_t offset) "MMIO read smaller than 32-bits, offset=0x%"PRIx64""
 +nvme_ub_mmiord_invalid_ofs(uint64_t offset) "MMIO read beyond last register, offset=0x%"PRIx64", returning 0"
 +nvme_ub_db_wr_misaligned(uint64_t offset) "doorbell write not 32-bit aligned, offset=0x%"PRIx64", ignoring"
 +nvme_ub_db_wr_invalid_cq(uint32_t qid) "completion queue doorbell write for nonexistent queue, cqid=%"PRIu32", ignoring"
 +nvme_ub_db_wr_invalid_cqhead(uint32_t qid, uint16_t new_head) "completion queue doorbell write value beyond queue size, cqid=%"PRIu32", new_head=%"PRIu16", ignoring"
 +nvme_ub_db_wr_invalid_sq(uint32_t qid) "submission queue doorbell write for nonexistent queue, sqid=%"PRIu32", ignoring"
 +nvme_ub_db_wr_invalid_sqtail(uint32_t qid, uint16_t new_tail) "submission queue doorbell write value beyond queue size, sqid=%"PRIu32", new_head=%"PRIu16", ignoring"
 +
  # hw/block/xen_disk.c
  xen_disk_alloc(char *name) "%s"
  xen_disk_init(char *name) "%s"
 --
-.20.1
+.13.6

-[PULL 16/30] iotests: Fix IMGOPTSSYNTAX for nbd
+[Qemu-devel] [PULL v3 13/35] block: Open backing image in force share mode for size probe
-From: Max Reitz <mreitz@redhat.com>
+From: Fam Zheng <famz@redhat.com>
-There is no $SOCKDIR, only $SOCK_DIR.
+Management tools create overlays of running guests with qemu-img:
-Fixes: f3923a72f199b2c63747a7032db74730546f55c6
+  $ qemu-img create -b /image/in/use.qcow2 -f qcow2 /overlay/image.qcow2
-Signed-off-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+but this doesn't work anymore due to image locking:
     qemu-img: /overlay/image.qcow2: Failed to get shared "write" lock
     Is another process using the image?
     Could not open backing image to determine size.
 Use the force share option to allow this use case again.
 Cc: qemu-stable@nongnu.org
 Signed-off-by: Fam Zheng <famz@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/common.rc | 3 ++-
+ block.c | 3 ++-
 file changed, 2 insertions(+), 1 deletion(-)
-diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
+diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/common.rc
+--- a/block.c
-+++ b/tests/qemu-iotests/common.rc
++++ b/block.c
-@@ -XXX,XX +XXX,XX @@ if [ "$IMGOPTSSYNTAX" = "true" ]; then
+@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,
-         TEST_IMG="$DRIVER,file.filename=$TEST_DIR/t.$IMGFMT"
+         back_flags = flags;
-     elif [ "$IMGPROTO" = "nbd" ]; then
+         back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
-         TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
--        TEST_IMG="$DRIVER,file.driver=nbd,file.type=unix,file.path=$SOCKDIR/nbd"
++        backing_options = qdict_new();
-+        TEST_IMG="$DRIVER,file.driver=nbd,file.type=unix"
+         if (backing_fmt) {
-+        TEST_IMG="$TEST_IMG,file.path=$SOCK_DIR/nbd"
+-            backing_options = qdict_new();
-     elif [ "$IMGPROTO" = "ssh" ]; then
+             qdict_put_str(backing_options, "driver", backing_fmt);
-         TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
+         }
-         TEST_IMG="$DRIVER,file.driver=ssh,file.host=127.0.0.1,file.path=$TEST_IMG_FILE"
++        qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
          bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
                         &local_err);
 --
-.20.1
+.13.6

-[PULL 14/30] iotests: Add more "_require_drivers" checks to the shell-based tests
+[Qemu-devel] [PULL v3 14/35] block: Remove the obsolete -drive boot=on|off parameter
 From: Thomas Huth <thuth@redhat.com>
-Test 051 should be skipped if nbd is not available, and 267 should
+It's not working anymore since QEMU v1.3.0 - time to remove it now.
 be skipped if copy-on-read is not enabled.
 Signed-off-by: Thomas Huth <thuth@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: John Snow <jsnow@redhat.com>
 Reviewed-by: Markus Armbruster <armbru@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/051 | 1 +
+ blockdev.c    | 11 -----------
- tests/qemu-iotests/267 | 1 +
+ qemu-doc.texi |  6 ------
-files changed, 2 insertions(+)
+files changed, 17 deletions(-)
-diff --git a/tests/qemu-iotests/051 b/tests/qemu-iotests/051
+diff --git a/blockdev.c b/blockdev.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/051
+--- a/blockdev.c
-+++ b/tests/qemu-iotests/051
++++ b/blockdev.c
-@@ -XXX,XX +XXX,XX @@ _supported_proto file
+@@ -XXX,XX +XXX,XX @@ QemuOptsList qemu_legacy_drive_opts = {
- # A compat=0.10 image is created in this test which does not support anything
+             .type = QEMU_OPT_STRING,
- # other than refcount_bits=16
+             .help = "chs translation (auto, lba, none)",
- _unsupported_imgopts 'refcount_bits=\([^1]\|.\([^6]\|$\)\)'
+         },{
-+_require_drivers nbd
+-            .name = "boot",
+-            .type = QEMU_OPT_BOOL,
- do_run_qemu()
+-            .help = "(deprecated, ignored)",
- {
+-        },{
-diff --git a/tests/qemu-iotests/267 b/tests/qemu-iotests/267
+             .name = "addr",
-index XXXXXXX..XXXXXXX 100755
+             .type = QEMU_OPT_STRING,
---- a/tests/qemu-iotests/267
+             .help = "pci address (virtio only)",
-+++ b/tests/qemu-iotests/267
+@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+         goto fail;
- _supported_fmt qcow2
+     }
- _supported_proto file
- _supported_os Linux
+-    /* Deprecated option boot=[on|off] */
-+_require_drivers copy-on-read
+-    if (qemu_opt_get(legacy_opts, "boot") != NULL) {
+-        fprintf(stderr, "qemu-kvm: boot=on|off is deprecated and will be "
- # Internal snapshots are (currently) impossible with refcount_bits=1
+-                "ignored. Future versions will reject this parameter. Please "
- _unsupported_imgopts 'refcount_bits=1[^0-9]'
+-                "update your scripts.\n");
 -    }
 -
      /* Other deprecated options */
      if (!qtest_enabled()) {
          for (i = 0; i < ARRAY_SIZE(deprecated); i++) {
 diff --git a/qemu-doc.texi b/qemu-doc.texi
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-doc.texi
 +++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ deprecated.
  @section System emulator command line arguments
 -@subsection -drive boot=on|off (since 1.3.0)
 -
 -The ``boot=on|off'' option to the ``-drive'' argument is
 -ignored. Applications should use the ``bootindex=N'' parameter
 -to set an absolute ordering between devices instead.
 -
  @subsection -tdf (since 1.3.0)
  The ``-tdf'' argument is ignored. The behaviour implemented
 --
-.20.1
+.13.6

-[PULL 02/30] iotests: Skip test 060 if it is not possible to create large files
+[Qemu-devel] [PULL v3 15/35] block: Remove the deprecated -hdachs option
 From: Thomas Huth <thuth@redhat.com>
-Test 060 fails in the arm64, s390x and ppc64le LXD containers on Travis
+It's been marked as deprecated since QEMU v2.10.0, and so far nobody
-(which we will hopefully enable in our CI soon). These containers
+complained that we should keep it, so let's remove this legacy option
-apparently do not allow large files to be created. The repair process
+now to simplify the code quite a bit.
 in test 060 creates a file of 64 GiB, so test first whether such large
 files are possible and skip the test if that's not the case.
 Signed-off-by: Thomas Huth <thuth@redhat.com>
+Reviewed-by: John Snow <jsnow@redhat.com>
+Reviewed-by: Markus Armbruster <armbru@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/060 | 3 +++
+ vl.c            | 86 ++-------------------------------------------------------
-file changed, 3 insertions(+)
+ qemu-doc.texi   |  8 ------
+ qemu-options.hx | 19 ++-----------
-diff --git a/tests/qemu-iotests/060 b/tests/qemu-iotests/060
+files changed, 4 insertions(+), 109 deletions(-)
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/060
+diff --git a/vl.c b/vl.c
-+++ b/tests/qemu-iotests/060
+index XXXXXXX..XXXXXXX 100644
-@@ -XXX,XX +XXX,XX @@ _supported_fmt qcow2
+--- a/vl.c
- _supported_proto file
++++ b/vl.c
- _supported_os Linux
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
+     const char *boot_order = NULL;
-+# The repair process will create a large file - so check for availability first
+     const char *boot_once = NULL;
-+_require_large_file 64G
+     DisplayState *ds;
-+
+-    int cyls, heads, secs, translation;
- rt_offset=65536  # 0x10000 (XXX: just an assumption)
+     QemuOpts *opts, *machine_opts;
- rb_offset=131072 # 0x20000 (XXX: just an assumption)
+-    QemuOpts *hda_opts = NULL, *icount_opts = NULL, *accel_opts = NULL;
- l1_offset=196608 # 0x30000 (XXX: just an assumption)
++    QemuOpts *icount_opts = NULL, *accel_opts = NULL;
      QemuOptsList *olist;
      int optind;
      const char *optarg;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
      cpu_model = NULL;
      snapshot = 0;
 -    cyls = heads = secs = 0;
 -    translation = BIOS_ATA_TRANSLATION_AUTO;
      nb_nics = 0;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
          if (optind >= argc)
              break;
          if (argv[optind][0] != '-') {
 -            hda_opts = drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
 +            drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
          } else {
              const QEMUOption *popt;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
                  cpu_model = optarg;
                  break;
              case QEMU_OPTION_hda:
 -                {
 -                    char buf[256];
 -                    if (cyls == 0)
 -                        snprintf(buf, sizeof(buf), "%s", HD_OPTS);
 -                    else
 -                        snprintf(buf, sizeof(buf),
 -                                 "%s,cyls=%d,heads=%d,secs=%d%s",
 -                                 HD_OPTS , cyls, heads, secs,
 -                                 translation == BIOS_ATA_TRANSLATION_LBA ?
 -                                 ",trans=lba" :
 -                                 translation == BIOS_ATA_TRANSLATION_NONE ?
 -                                 ",trans=none" : "");
 -                    drive_add(IF_DEFAULT, 0, optarg, buf);
 -                    break;
 -                }
              case QEMU_OPTION_hdb:
              case QEMU_OPTION_hdc:
              case QEMU_OPTION_hdd:
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
              case QEMU_OPTION_snapshot:
                  snapshot = 1;
                  break;
 -            case QEMU_OPTION_hdachs:
 -                {
 -                    const char *p;
 -                    p = optarg;
 -                    cyls = strtol(p, (char **)&p, 0);
 -                    if (cyls < 1 || cyls > 16383)
 -                        goto chs_fail;
 -                    if (*p != ',')
 -                        goto chs_fail;
 -                    p++;
 -                    heads = strtol(p, (char **)&p, 0);
 -                    if (heads < 1 || heads > 16)
 -                        goto chs_fail;
 -                    if (*p != ',')
 -                        goto chs_fail;
 -                    p++;
 -                    secs = strtol(p, (char **)&p, 0);
 -                    if (secs < 1 || secs > 63)
 -                        goto chs_fail;
 -                    if (*p == ',') {
 -                        p++;
 -                        if (!strcmp(p, "large")) {
 -                            translation = BIOS_ATA_TRANSLATION_LARGE;
 -                        } else if (!strcmp(p, "rechs")) {
 -                            translation = BIOS_ATA_TRANSLATION_RECHS;
 -                        } else if (!strcmp(p, "none")) {
 -                            translation = BIOS_ATA_TRANSLATION_NONE;
 -                        } else if (!strcmp(p, "lba")) {
 -                            translation = BIOS_ATA_TRANSLATION_LBA;
 -                        } else if (!strcmp(p, "auto")) {
 -                            translation = BIOS_ATA_TRANSLATION_AUTO;
 -                        } else {
 -                            goto chs_fail;
 -                        }
 -                    } else if (*p != '\0') {
 -                    chs_fail:
 -                        error_report("invalid physical CHS format");
 -                        exit(1);
 -                    }
 -                    if (hda_opts != NULL) {
 -                        qemu_opt_set_number(hda_opts, "cyls", cyls,
 -                                            &error_abort);
 -                        qemu_opt_set_number(hda_opts, "heads", heads,
 -                                            &error_abort);
 -                        qemu_opt_set_number(hda_opts, "secs", secs,
 -                                            &error_abort);
 -                        if (translation == BIOS_ATA_TRANSLATION_LARGE) {
 -                            qemu_opt_set(hda_opts, "trans", "large",
 -                                         &error_abort);
 -                        } else if (translation == BIOS_ATA_TRANSLATION_RECHS) {
 -                            qemu_opt_set(hda_opts, "trans", "rechs",
 -                                         &error_abort);
 -                        } else if (translation == BIOS_ATA_TRANSLATION_LBA) {
 -                            qemu_opt_set(hda_opts, "trans", "lba",
 -                                         &error_abort);
 -                        } else if (translation == BIOS_ATA_TRANSLATION_NONE) {
 -                            qemu_opt_set(hda_opts, "trans", "none",
 -                                         &error_abort);
 -                        }
 -                    }
 -                }
 -                error_report("'-hdachs' is deprecated, please use '-device"
 -                             " ide-hd,cyls=c,heads=h,secs=s,...' instead");
 -                break;
              case QEMU_OPTION_numa:
                  opts = qemu_opts_parse_noisily(qemu_find_opts("numa"),
                                                 optarg, true);
 diff --git a/qemu-doc.texi b/qemu-doc.texi
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-doc.texi
 +++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ The ``--net dump'' argument is now replaced with the
  ``-object filter-dump'' argument which works in combination
  with the modern ``-netdev`` backends instead.
 -@subsection -hdachs (since 2.10.0)
 -
 -The ``-hdachs'' argument is now a synonym for setting
 -the ``cyls'', ``heads'', ``secs'', and ``trans'' properties
 -on the ``ide-hd'' device using the ``-device'' argument.
 -The new syntax allows different settings to be provided
 -per disk.
 -
  @subsection -usbdevice (since 2.10.0)
  The ``-usbdevice DEV'' argument is now a synonym for setting
 diff --git a/qemu-options.hx b/qemu-options.hx
 index XXXXXXX..XXXXXXX 100644
 --- a/qemu-options.hx
 +++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ of available connectors of a given interface type.
  @item media=@var{media}
  This option defines the type of the media: disk or cdrom.
  @item cyls=@var{c},heads=@var{h},secs=@var{s}[,trans=@var{t}]
 -These options have the same definition as they have in @option{-hdachs}.
 -These parameters are deprecated, use the corresponding parameters
 +Force disk physical geometry and the optional BIOS translation (trans=none or
 +lba). These parameters are deprecated, use the corresponding parameters
  of @code{-device} instead.
  @item snapshot=@var{snapshot}
  @var{snapshot} is "on" or "off" and controls snapshot mode for the given drive
@@ -XXX,XX +XXX,XX @@ the raw disk image you use is not written back. You can however force
  the write back by pressing @key{C-a s} (@pxref{disk_images}).
  ETEXI
 -DEF("hdachs", HAS_ARG, QEMU_OPTION_hdachs, \
 -    "-hdachs c,h,s[,t]\n" \
 -    "                force hard disk 0 physical geometry and the optional BIOS\n" \
 -    "                translation (t=none or lba) (usually QEMU can guess them)\n",
 -    QEMU_ARCH_ALL)
 -STEXI
 -@item -hdachs @var{c},@var{h},@var{s},[,@var{t}]
 -@findex -hdachs
 -Force hard disk 0 physical geometry (1 <= @var{c} <= 16383, 1 <=
 -@var{h} <= 16, 1 <= @var{s} <= 63) and optionally force the BIOS
 -translation mode (@var{t}=none, lba or auto). Usually QEMU can guess
 -all those parameters. This option is deprecated, please use
 -@code{-device ide-hd,cyls=c,heads=h,secs=s,...} instead.
 -ETEXI
 -
  DEF("fsdev", HAS_ARG, QEMU_OPTION_fsdev,
      "-fsdev fsdriver,id=id[,path=path,][security_model={mapped-xattr|mapped-file|passthrough|none}]\n"
      " [,writeout=immediate][,readonly][,socket=socket|sock_fd=sock_fd][,fmode=fmode][,dmode=dmode]\n"
 --
-.20.1
+.13.6

-[PULL 03/30] iotests: Skip test 079 if it is not possible to create large files
+[Qemu-devel] [PULL v3 16/35] block: Mention -drive cyls/heads/secs/trans/serial/addr in deprecation chapter
 From: Thomas Huth <thuth@redhat.com>
-Test 079 fails in the arm64, s390x and ppc64le LXD containers on Travis
+Looks like we forgot to announce the deprecation of these options in
-(which we will hopefully enable in our CI soon). These containers
+the corresponding chapter of the qemu-doc text, so let's do that now.
 apparently do not allow large files to be created. Test 079 tries to
 create a 4G sparse file, which is apparently already too big for these
 containers, so check first whether we can really create such files before
 executing the test.
 Signed-off-by: Thomas Huth <thuth@redhat.com>
+Reviewed-by: John Snow <jsnow@redhat.com>
+Reviewed-by: Markus Armbruster <armbru@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/079 | 3 +++
+ qemu-doc.texi | 15 +++++++++++++++
-file changed, 3 insertions(+)
+file changed, 15 insertions(+)
-diff --git a/tests/qemu-iotests/079 b/tests/qemu-iotests/079
+diff --git a/qemu-doc.texi b/qemu-doc.texi
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/079
+--- a/qemu-doc.texi
-+++ b/tests/qemu-iotests/079
++++ b/qemu-doc.texi
-@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+@@ -XXX,XX +XXX,XX @@ longer be directly supported in QEMU.
- _supported_fmt qcow2
+ The ``-drive if=scsi'' argument is replaced by the the
- _supported_proto file nfs
+ ``-device BUS-TYPE'' argument combined with ``-drive if=none''.
-+# Some containers (e.g. non-x86 on Travis) do not allow large files
++@subsection -drive cyls=...,heads=...,secs=...,trans=... (since 2.10.0)
 +_require_large_file 4G
 +
- echo "=== Check option preallocation and cluster_size ==="
++The drive geometry arguments are replaced by the the geometry arguments
- echo
++that can be specified with the ``-device'' parameter.
- cluster_sizes="16384 32768 65536 131072 262144 524288 1048576 2097152 4194304"
++
 +@subsection -drive serial=... (since 2.10.0)
 +
 +The drive serial argument is replaced by the the serial argument
 +that can be specified with the ``-device'' parameter.
 +
 +@subsection -drive addr=... (since 2.10.0)
 +
 +The drive addr argument is replaced by the the addr argument
 +that can be specified with the ``-device'' parameter.
 +
  @subsection -net dump (since 2.10.0)
  The ``--net dump'' argument is now replaced with the
 --
-.20.1
+.13.6

-[PULL 17/30] qcow2: Move error check of local_err near its assignment
+[Qemu-devel] [PULL v3 17/35] block: Remove unused bdrv_requests_pending
-From: Tuguoyi <tu.guoyi@h3c.com>
+From: Fam Zheng <famz@redhat.com>
-The local_err check outside of the if block was necessary
+Signed-off-by: Fam Zheng <famz@redhat.com>
 when it was introduced in commit d1258dd0c87 because it needed to be
 executed even if qcow2_load_autoloading_dirty_bitmaps() returned false.
 After some modifications that all required the error check to remain
 where it is, commit 9c98f145dfb finally moved the
 qcow2_load_dirty_bitmaps() call into the if block, so now the error
 check should be there, too.
 Signed-off-by: Guoyi Tu <tu.guoyi@h3c.com>
 Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2.c | 10 +++++-----
+ include/block/block_int.h |  1 -
-file changed, 5 insertions(+), 5 deletions(-)
+ block/io.c                | 18 ------------------
 files changed, 19 deletions(-)
-diff --git a/block/qcow2.c b/block/qcow2.c
+diff --git a/include/block/block_int.h b/include/block/block_int.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2.c
+--- a/include/block/block_int.h
-+++ b/block/qcow2.c
++++ b/include/block/block_int.h
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+@@ -XXX,XX +XXX,XX @@ bool blk_dev_is_tray_open(BlockBackend *blk);
-     if (!(bdrv_get_flags(bs) & BDRV_O_INACTIVE)) {
+ bool blk_dev_is_medium_locked(BlockBackend *blk);
-         /* It's case 1, 2 or 3.2. Or 3.1 which is BUG in management layer. */
-         bool header_updated = qcow2_load_dirty_bitmaps(bs, &local_err);
+ void bdrv_set_dirty(BlockDriverState *bs, int64_t offset, int64_t bytes);
-+        if (local_err != NULL) {
+-bool bdrv_requests_pending(BlockDriverState *bs);
-+            error_propagate(errp, local_err);
-+            ret = -EINVAL;
+ void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out);
-+            goto fail;
+ void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in);
-+        }
+diff --git a/block/io.c b/block/io.c
+index XXXXXXX..XXXXXXX 100644
-         update_header = update_header && !header_updated;
+--- a/block/io.c
-     }
++++ b/block/io.c
--    if (local_err != NULL) {
+@@ -XXX,XX +XXX,XX @@ void bdrv_disable_copy_on_read(BlockDriverState *bs)
--        error_propagate(errp, local_err);
+     assert(old >= 1);
--        ret = -EINVAL;
+ }
--        goto fail;
 -/* Check if any requests are in-flight (including throttled requests) */
 -bool bdrv_requests_pending(BlockDriverState *bs)
 -{
 -    BdrvChild *child;
 -
 -    if (atomic_read(&bs->in_flight)) {
 -        return true;
 -    }
+-
-     if (update_header) {
+-    QLIST_FOREACH(child, &bs->children, next) {
-         ret = qcow2_update_header(bs);
+-        if (bdrv_requests_pending(child->bs)) {
 -            return true;
 -        }
 -    }
 -
 -    return false;
 -}
 -
  typedef struct {
      Coroutine *co;
      BlockDriverState *bs;
 --
-.20.1
+.13.6

-New patch
+[Qemu-devel] [PULL v3 18/35] block: Assert drain_all is only called from main AioContext
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Fam Zheng <famz@redhat.com>
+---
+ block/io.c | 6 ++++++
+file changed, 6 insertions(+)
+diff --git a/block/io.c b/block/io.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/io.c
++++ b/block/io.c
+@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
+     BdrvNextIterator it;
+     GSList *aio_ctxs = NULL, *ctx;
++    /* BDRV_POLL_WHILE() for a node can only be called from its own I/O thread
++     * or the main loop AioContext. We potentially use BDRV_POLL_WHILE() on
++     * nodes in several different AioContexts, so make sure we're in the main
++     * context. */
++    assert(qemu_get_current_aio_context() == qemu_get_aio_context());
++
+     block_job_pause_all();
+     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
+--
+.13.6

-[PULL 27/30] iotests: 211: Remove duplication with VM.blockdev_create()
+[Qemu-devel] [PULL v3 19/35] block: Make bdrv_drain() driver callbacks non-recursive
-The blockdev_create() function in this test case adds an error check
+bdrv_drained_begin() doesn't increase bs->quiesce_counter recursively
-that skips the test in case of failure because of memory shortage, but
+and also doesn't notify other parent nodes of children, which both means
-provides otherwise the same functionality as VM.blockdev_create() from
+that the child nodes are not actually drained, and bdrv_drained_begin()
-iotests.py. Make it a thin wrapper around the iotests.py function.
+is providing useful functionality only on a single node.
 To keep things consistent, we also shouldn't call the block driver
 callbacks recursively.
 A proper recursive drain version that provides an actually working
 drained section for child nodes will be introduced later.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Fam Zheng <famz@redhat.com>
 ---
- tests/qemu-iotests/211 | 12 +++---------
+ block/io.c | 16 +++++++++-------
-file changed, 3 insertions(+), 9 deletions(-)
+file changed, 9 insertions(+), 7 deletions(-)
-diff --git a/tests/qemu-iotests/211 b/tests/qemu-iotests/211
+diff --git a/block/io.c b/block/io.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/211
+--- a/block/io.c
-+++ b/tests/qemu-iotests/211
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ iotests.verify_image_format(supported_fmts=['vdi'])
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_drain_invoke_entry(void *opaque)
- iotests.verify_protocol(supported=['file'])
+ }
- def blockdev_create(vm, options):
+ /* Recursively call BlockDriver.bdrv_co_drain_begin/end callbacks */
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
+-static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)
--                        filters=[iotests.filter_qmp_testfiles])
++static void bdrv_drain_invoke(BlockDriverState *bs, bool begin, bool recursive)
--
+ {
--    if 'return' in result:
+     BdrvChild *child, *tmp;
--        assert result['return'] == {}
+     BdrvCoDrainData data = { .bs = bs, .done = false, .begin = begin};
--        error = vm.run_job('job0')
+@@ -XXX,XX +XXX,XX @@ static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)
--        if error and 'Could not allocate bmap' in error:
+     bdrv_coroutine_enter(bs, data.co);
--            iotests.notrun('Insufficient memory')
+     BDRV_POLL_WHILE(bs, !data.done);
--    iotests.log("")
-+    error = vm.blockdev_create(options)
+-    QLIST_FOREACH_SAFE(child, &bs->children, next, tmp) {
-+    if error and 'Could not allocate bmap' in error:
+-        bdrv_drain_invoke(child->bs, begin);
-+        iotests.notrun('Insufficient memory')
++    if (recursive) {
++        QLIST_FOREACH_SAFE(child, &bs->children, next, tmp) {
- with iotests.FilePath('t.vdi') as disk_path, \
++            bdrv_drain_invoke(child->bs, begin, true);
-      iotests.VM() as vm:
++        }
      }
  }
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)
          bdrv_parent_drained_begin(bs);
      }
 -    bdrv_drain_invoke(bs, true);
 +    bdrv_drain_invoke(bs, true, false);
      bdrv_drain_recurse(bs);
  }
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
      }
      /* Re-enable things in child-to-parent order */
 -    bdrv_drain_invoke(bs, false);
 +    bdrv_drain_invoke(bs, false, false);
      bdrv_parent_drained_end(bs);
      aio_enable_external(bdrv_get_aio_context(bs));
  }
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
          aio_context_acquire(aio_context);
          aio_disable_external(aio_context);
          bdrv_parent_drained_begin(bs);
 -        bdrv_drain_invoke(bs, true);
 +        bdrv_drain_invoke(bs, true, true);
          aio_context_release(aio_context);
          if (!g_slist_find(aio_ctxs, aio_context)) {
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
          /* Re-enable things in child-to-parent order */
          aio_context_acquire(aio_context);
 -        bdrv_drain_invoke(bs, false);
 +        bdrv_drain_invoke(bs, false, true);
          bdrv_parent_drained_end(bs);
          aio_enable_external(aio_context);
          aio_context_release(aio_context);
 --
-.20.1
+.13.6

-[PULL 01/30] iotests: Provide a function for checking the creation of huge files
+[Qemu-devel] [PULL v3 20/35] test-bdrv-drain: Test callback for bdrv_drain
-From: Thomas Huth <thuth@redhat.com>
+The existing test is for bdrv_drain_all_begin/end() only. Generalise the
 test case so that it can be run for the other variants as well. At the
 moment this is only bdrv_drain_begin/end(), but in a while, we'll add
 another one.
-Some tests create huge (but sparse) files, and to be able to run those
+Also, add a backing file to the test node to test whether the operations
-tests in certain limited environments (like CI containers), we have to
+work recursively.
 check for the possibility to create such files first. Thus let's introduce
 a common function to check for large files, and replace the already
 existing checks in the iotests 005 and 220 with this function.
-Signed-off-by: Thomas Huth <thuth@redhat.com>
-Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/005       |  5 +----
+ tests/test-bdrv-drain.c | 69 ++++++++++++++++++++++++++++++++++++++++++++-----
- tests/qemu-iotests/220       |  6 ++----
+file changed, 62 insertions(+), 7 deletions(-)
  tests/qemu-iotests/common.rc | 10 ++++++++++
 files changed, 13 insertions(+), 8 deletions(-)
-diff --git a/tests/qemu-iotests/005 b/tests/qemu-iotests/005
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/005
+--- a/tests/test-bdrv-drain.c
-+++ b/tests/qemu-iotests/005
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ fi
+@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_test = {
- # Sanity check: For raw, we require a file system that permits the creation
- # of a HUGE (but very sparse) file. Check we can create it before continuing.
+     .bdrv_co_drain_begin    = bdrv_test_co_drain_begin,
- if [ "$IMGFMT" = "raw" ]; then
+     .bdrv_co_drain_end      = bdrv_test_co_drain_end,
 -    if ! truncate --size=5T "$TEST_IMG"; then
 -        _notrun "file system on $TEST_DIR does not support large enough files"
 -    fi
 -    rm "$TEST_IMG"
 +    _require_large_file 5T
  fi
  echo
 diff --git a/tests/qemu-iotests/220 b/tests/qemu-iotests/220
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/220
 +++ b/tests/qemu-iotests/220
@@ -XXX,XX +XXX,XX @@ echo "== Creating huge file =="
  # Sanity check: We require a file system that permits the creation
  # of a HUGE (but very sparse) file.  tmpfs works, ext4 does not.
 -if ! truncate --size=513T "$TEST_IMG"; then
 -    _notrun "file system on $TEST_DIR does not support large enough files"
 -fi
 -rm "$TEST_IMG"
 +_require_large_file 513T
 +
- IMGOPTS='cluster_size=2M,refcount_bits=1' _make_test_img 513T
++    .bdrv_child_perm        = bdrv_format_default_perms,
+ };
- echo "== Populating refcounts =="
-diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
+ static void aio_ret_cb(void *opaque, int ret)
-index XXXXXXX..XXXXXXX 100644
+@@ -XXX,XX +XXX,XX @@ static void aio_ret_cb(void *opaque, int ret)
---- a/tests/qemu-iotests/common.rc
+     *aio_ret = ret;
 +++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@ _require_drivers()
      done
  }
-+# Check that we have a file system that allows huge (but very sparse) files
+-static void test_drv_cb_drain_all(void)
-+#
++enum drain_type {
-+_require_large_file()
++    BDRV_DRAIN_ALL,
 +    BDRV_DRAIN,
 +};
 +
 +static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
 +{
-+    if ! truncate --size="$1" "$TEST_IMG"; then
++    switch (drain_type) {
-+        _notrun "file system on $TEST_DIR does not support large enough files"
++    case BDRV_DRAIN_ALL:        bdrv_drain_all_begin(); break;
-+    fi
++    case BDRV_DRAIN:            bdrv_drained_begin(bs); break;
-+    rm "$TEST_IMG"
++    default:                    g_assert_not_reached();
 +    }
 +}
 +
- # make sure this script returns success
++static void do_drain_end(enum drain_type drain_type, BlockDriverState *bs)
- true
++{
 +    switch (drain_type) {
 +    case BDRV_DRAIN_ALL:        bdrv_drain_all_end(); break;
 +    case BDRV_DRAIN:            bdrv_drained_end(bs); break;
 +    default:                    g_assert_not_reached();
 +    }
 +}
 +
 +static void test_drv_cb_common(enum drain_type drain_type, bool recursive)
  {
      BlockBackend *blk;
 -    BlockDriverState *bs;
 -    BDRVTestState *s;
 +    BlockDriverState *bs, *backing;
 +    BDRVTestState *s, *backing_s;
      BlockAIOCB *acb;
      int aio_ret;
@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_drain_all(void)
      s = bs->opaque;
      blk_insert_bs(blk, bs, &error_abort);
 +    backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 +    backing_s = backing->opaque;
 +    bdrv_set_backing_hd(bs, backing, &error_abort);
 +
      /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
      g_assert_cmpint(s->drain_count, ==, 0);
 -    bdrv_drain_all_begin();
 +    g_assert_cmpint(backing_s->drain_count, ==, 0);
 +
 +    do_drain_begin(drain_type, bs);
 +
      g_assert_cmpint(s->drain_count, ==, 1);
 -    bdrv_drain_all_end();
 +    g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
 +
 +    do_drain_end(drain_type, bs);
 +
      g_assert_cmpint(s->drain_count, ==, 0);
 +    g_assert_cmpint(backing_s->drain_count, ==, 0);
      /* Now do the same while a request is pending */
      aio_ret = -EINPROGRESS;
@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_drain_all(void)
      g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
      g_assert_cmpint(s->drain_count, ==, 0);
 -    bdrv_drain_all_begin();
 +    g_assert_cmpint(backing_s->drain_count, ==, 0);
 +
 +    do_drain_begin(drain_type, bs);
 +
      g_assert_cmpint(aio_ret, ==, 0);
      g_assert_cmpint(s->drain_count, ==, 1);
 -    bdrv_drain_all_end();
 +    g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
 +
 +    do_drain_end(drain_type, bs);
 +
      g_assert_cmpint(s->drain_count, ==, 0);
 +    g_assert_cmpint(backing_s->drain_count, ==, 0);
 +    bdrv_unref(backing);
      bdrv_unref(bs);
      blk_unref(blk);
  }
 +static void test_drv_cb_drain_all(void)
 +{
 +    test_drv_cb_common(BDRV_DRAIN_ALL, true);
 +}
 +
 +static void test_drv_cb_drain(void)
 +{
 +    test_drv_cb_common(BDRV_DRAIN, false);
 +}
 +
  int main(int argc, char **argv)
  {
      bdrv_init();
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
      g_test_init(&argc, &argv, NULL);
      g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
 +    g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
      return g_test_run();
  }
 --
-.20.1
+.13.6

-[PULL 24/30] iotests: 237: Convert to VM.blockdev_create()
+[Qemu-devel] [PULL v3 21/35] test-bdrv-drain: Test bs->quiesce_counter
-Instead of having a separate blockdev_create() function, make use of the
+This is currently only working correctly for bdrv_drain(), not for
-VM.blockdev_create() offered by iotests.py.
+bdrv_drain_all(). Leave a comment for the drain_all case, we'll address
 it later.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/237 | 139 +++++++++++++++++++----------------------
+ tests/test-bdrv-drain.c | 45 +++++++++++++++++++++++++++++++++++++++++++++
-file changed, 65 insertions(+), 74 deletions(-)
+file changed, 45 insertions(+)
-diff --git a/tests/qemu-iotests/237 b/tests/qemu-iotests/237
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/237
+--- a/tests/test-bdrv-drain.c
-+++ b/tests/qemu-iotests/237
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
+@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_drain(void)
+     test_drv_cb_common(BDRV_DRAIN, false);
- iotests.verify_image_format(supported_fmts=['vmdk'])
+ }
--def blockdev_create(vm, options):
++static void test_quiesce_common(enum drain_type drain_type, bool recursive)
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
++{
--                        filters=[iotests.filter_qmp_testfiles])
++    BlockBackend *blk;
--
++    BlockDriverState *bs, *backing;
 -    if 'return' in result:
 -        assert result['return'] == {}
 -        vm.run_job('job0')
 -    iotests.log("")
 -
  with iotests.FilePath('t.vmdk') as disk_path, \
       iotests.FilePath('t.vmdk.1') as extent1_path, \
       iotests.FilePath('t.vmdk.2') as extent2_path, \
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
      size = 5 * 1024 * 1024 * 1024
      vm.launch()
 -    blockdev_create(vm, { 'driver': 'file',
 -                          'filename': disk_path,
 -                          'size': 0 })
 +    vm.blockdev_create({ 'driver': 'file',
 +                         'filename': disk_path,
 +                         'size': 0 })
      vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
                 node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'imgfile',
 -                          'size': size })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'imgfile',
 +                         'size': size })
      vm.shutdown()
      iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
      size = 64 * 1024 * 1024
      vm.launch()
 -    blockdev_create(vm, { 'driver': 'file',
 -                          'filename': disk_path,
 -                          'size': 0 })
 -
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': {
 -                              'driver': 'file',
 -                              'filename': disk_path,
 -                          },
 -                          'size': size,
 -                          'extents': [],
 -                          'subformat': 'monolithicSparse',
 -                          'adapter-type': 'ide',
 -                          'hwversion': '4',
 -                          'zeroed-grain': False })
 +    vm.blockdev_create({ 'driver': 'file',
 +                         'filename': disk_path,
 +                         'size': 0 })
 +
-+    vm.blockdev_create({ 'driver': imgfmt,
++    blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
-+                         'file': {
++    bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
-+                             'driver': 'file',
++                              &error_abort);
-+                             'filename': disk_path,
++    blk_insert_bs(blk, bs, &error_abort);
 +                         },
 +                         'size': size,
 +                         'extents': [],
 +                         'subformat': 'monolithicSparse',
 +                         'adapter-type': 'ide',
 +                         'hwversion': '4',
 +                         'zeroed-grain': False })
      vm.shutdown()
      iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
      size = 32 * 1024 * 1024
      vm.launch()
 -    blockdev_create(vm, { 'driver': 'file',
 -                          'filename': disk_path,
 -                          'size': 0 })
 -
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': {
 -                              'driver': 'file',
 -                              'filename': disk_path,
 -                          },
 -                          'size': size,
 -                          'extents': [],
 -                          'subformat': 'monolithicSparse',
 -                          'adapter-type': 'buslogic',
 -                          'zeroed-grain': True })
 +    vm.blockdev_create({ 'driver': 'file',
 +                         'filename': disk_path,
 +                         'size': 0 })
 +
-+    vm.blockdev_create({ 'driver': imgfmt,
++    backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
-+                         'file': {
++    bdrv_set_backing_hd(bs, backing, &error_abort);
-+                             'driver': 'file',
++
-+                             'filename': disk_path,
++    g_assert_cmpint(bs->quiesce_counter, ==, 0);
-+                         },
++    g_assert_cmpint(backing->quiesce_counter, ==, 0);
-+                         'size': size,
++
-+                         'extents': [],
++    do_drain_begin(drain_type, bs);
-+                         'subformat': 'monolithicSparse',
++
-+                         'adapter-type': 'buslogic',
++    g_assert_cmpint(bs->quiesce_counter, ==, 1);
-+                         'zeroed-grain': True })
++    g_assert_cmpint(backing->quiesce_counter, ==, !!recursive);
-     vm.shutdown()
++
++    do_drain_end(drain_type, bs);
-     iotests.img_info_log(disk_path)
++
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
++    g_assert_cmpint(bs->quiesce_counter, ==, 0);
-     iotests.log("")
++    g_assert_cmpint(backing->quiesce_counter, ==, 0);
++
-     vm.launch()
++    bdrv_unref(backing);
--    blockdev_create(vm, { 'driver': imgfmt,
++    bdrv_unref(bs);
--                          'file': "this doesn't exist",
++    blk_unref(blk);
--                          'size': size })
++}
-+    vm.blockdev_create({ 'driver': imgfmt,
++
-+                         'file': "this doesn't exist",
++static void test_quiesce_drain_all(void)
-+                         'size': size })
++{
-     vm.shutdown()
++    // XXX drain_all doesn't quiesce
++    //test_quiesce_common(BDRV_DRAIN_ALL, true);
-     #
++}
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
++
++static void test_quiesce_drain(void)
-     vm.launch()
++{
-     for adapter_type in [ 'ide', 'buslogic', 'lsilogic', 'legacyESX' ]:
++    test_quiesce_common(BDRV_DRAIN, false);
--        blockdev_create(vm, { 'driver': imgfmt,
++}
--                              'file': 'node0',
++
--                              'size': size,
+ int main(int argc, char **argv)
--                              'adapter-type': adapter_type })
+ {
-+        vm.blockdev_create({ 'driver': imgfmt,
+     bdrv_init();
-+                             'file': 'node0',
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
-+                             'size': size,
+     g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
-+                             'adapter-type': adapter_type })
+     g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
-     vm.shutdown()
++    g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
-     # Invalid
++    g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
++
+     return g_test_run();
-     vm.launch()
+ }
      for adapter_type in [ 'foo', 'IDE', 'legacyesx', 1 ]:
 -        blockdev_create(vm, { 'driver': imgfmt,
 -                              'file': 'node0',
 -                              'size': size,
 -                              'adapter-type': adapter_type })
 +        vm.blockdev_create({ 'driver': imgfmt,
 +                             'file': 'node0',
 +                             'size': size,
 +                             'adapter-type': adapter_type })
      vm.shutdown()
      #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
      iotests.log("")
      vm.launch()
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': size,
 -                          'subformat': 'monolithicFlat' })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': size,
 +                         'subformat': 'monolithicFlat' })
      vm.shutdown()
      # Correct extent
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
      iotests.log("")
      vm.launch()
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': size,
 -                          'subformat': 'monolithicFlat',
 -                          'extents': ['ext1'] })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': size,
 +                         'subformat': 'monolithicFlat',
 +                         'extents': ['ext1'] })
      vm.shutdown()
      # Extra extent
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
      iotests.log("")
      vm.launch()
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': 512,
 -                          'subformat': 'monolithicFlat',
 -                          'extents': ['ext1', 'ext2', 'ext3'] })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': 512,
 +                         'subformat': 'monolithicFlat',
 +                         'extents': ['ext1', 'ext2', 'ext3'] })
      vm.shutdown()
      # Split formats
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vmdk') as disk_path, \
              extents = [ "ext%d" % (i) for i in range(1, num_extents + 1) ]
              vm.launch()
 -            blockdev_create(vm, { 'driver': imgfmt,
 -                                  'file': 'node0',
 -                                  'size': size,
 -                                  'subformat': subfmt,
 -                                  'extents': extents })
 +            vm.blockdev_create({ 'driver': imgfmt,
 +                                 'file': 'node0',
 +                                 'size': size,
 +                                 'subformat': subfmt,
 +                                 'extents': extents })
              vm.shutdown()
              iotests.img_info_log(disk_path)
 --
-.20.1
+.13.6

-[PULL 07/30] blockjob: Fix error message for negative speed
+[Qemu-devel] [PULL v3 22/35] blockjob: Pause job on draining any job BDS
-The error message for a negative speed uses QERR_INVALID_PARAMETER,
+Block jobs already paused themselves when their main BlockBackend
-which implies that the 'speed' option doesn't even exist:
+entered a drained section. This is not good enough: We also want to
 pause a block job and may not submit new requests if, for example, the
 mirror target node should be drained.
-    {"error": {"class": "GenericError", "desc": "Invalid parameter 'speed'"}}
+This implements .drained_begin/end callbacks in child_job in order to
+consider all block nodes related to the job, and removes the
-Make it use QERR_INVALID_PARAMETER_VALUE instead:
+BlockBackend callbacks which are unnecessary now because the root of the
+job main BlockBackend is always referenced with a child_job, too.
     {"error": {"class": "GenericError", "desc": "Parameter 'speed' expects a non-negative value"}}
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
 ---
- blockjob.c             | 3 ++-
+ blockjob.c | 22 +++++++++-------------
- tests/qemu-iotests/030 | 4 ++--
+file changed, 9 insertions(+), 13 deletions(-)
 files changed, 4 insertions(+), 3 deletions(-)
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
-@@ -XXX,XX +XXX,XX @@ void block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static char *child_job_get_parent_desc(BdrvChild *c)
-         return;
+                            job->id);
-     }
+ }
-     if (speed < 0) {
--        error_setg(errp, QERR_INVALID_PARAMETER, "speed");
+-static const BdrvChildRole child_job = {
-+        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "speed",
+-    .get_parent_desc    = child_job_get_parent_desc,
-+                   "a non-negative value");
+-    .stay_at_node       = true,
-         return;
+-};
-     }
+-
+-static void block_job_drained_begin(void *opaque)
-diff --git a/tests/qemu-iotests/030 b/tests/qemu-iotests/030
++static void child_job_drained_begin(BdrvChild *c)
-index XXXXXXX..XXXXXXX 100755
+ {
---- a/tests/qemu-iotests/030
+-    BlockJob *job = opaque;
-+++ b/tests/qemu-iotests/030
++    BlockJob *job = c->opaque;
-@@ -XXX,XX +XXX,XX @@ class TestSetSpeed(iotests.QMPTestCase):
+     block_job_pause(job);
-         self.assert_no_active_block_jobs()
+ }
-         result = self.vm.qmp('block-stream', device='drive0', speed=-1)
+-static void block_job_drained_end(void *opaque)
--        self.assert_qmp(result, 'error/desc', "Invalid parameter 'speed'")
++static void child_job_drained_end(BdrvChild *c)
-+        self.assert_qmp(result, 'error/desc', "Parameter 'speed' expects a non-negative value")
+ {
+-    BlockJob *job = opaque;
-         self.assert_no_active_block_jobs()
++    BlockJob *job = c->opaque;
+     block_job_resume(job);
-@@ -XXX,XX +XXX,XX @@ class TestSetSpeed(iotests.QMPTestCase):
+ }
-         self.assert_qmp(result, 'return', {})
+-static const BlockDevOps block_job_dev_ops = {
-         result = self.vm.qmp('block-job-set-speed', device='drive0', speed=-1)
+-    .drained_begin = block_job_drained_begin,
--        self.assert_qmp(result, 'error/desc', "Invalid parameter 'speed'")
+-    .drained_end = block_job_drained_end,
-+        self.assert_qmp(result, 'error/desc', "Parameter 'speed' expects a non-negative value")
++static const BdrvChildRole child_job = {
++    .get_parent_desc    = child_job_get_parent_desc,
-         self.cancel_and_wait(resume=True)
++    .drained_begin      = child_job_drained_begin,
++    .drained_end        = child_job_drained_end,
 +    .stay_at_node       = true,
  };
  void block_job_remove_all_bdrv(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
      block_job_add_bdrv(job, "main node", bs, 0, BLK_PERM_ALL, &error_abort);
      bs->job = job;
 -    blk_set_dev_ops(blk, &block_job_dev_ops, job);
      bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
      QLIST_INSERT_HEAD(&block_jobs, job, job_list);
 --
-.20.1
+.13.6

-[PULL 23/30] iotests: 213: Convert to VM.blockdev_create()
+[Qemu-devel] [PULL v3 23/35] test-bdrv-drain: Test drain vs. block jobs
-Instead of having a separate blockdev_create() function, make use of the
+Block jobs must be paused if any of the involved nodes are drained.
 VM.blockdev_create() offered by iotests.py.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/213 | 113 +++++++++++++++++++----------------------
+ tests/test-bdrv-drain.c | 121 ++++++++++++++++++++++++++++++++++++++++++++++++
-file changed, 52 insertions(+), 61 deletions(-)
+file changed, 121 insertions(+)
-diff --git a/tests/qemu-iotests/213 b/tests/qemu-iotests/213
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/213
+--- a/tests/test-bdrv-drain.c
-+++ b/tests/qemu-iotests/213
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
+@@ -XXX,XX +XXX,XX @@
- iotests.verify_image_format(supported_fmts=['vhdx'])
- iotests.verify_protocol(supported=['file'])
+ #include "qemu/osdep.h"
+ #include "block/block.h"
--def blockdev_create(vm, options):
++#include "block/blockjob_int.h"
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
+ #include "sysemu/block-backend.h"
--                        filters=[iotests.filter_qmp_testfiles])
+ #include "qapi/error.h"
--
--    if 'return' in result:
+@@ -XXX,XX +XXX,XX @@ static void test_quiesce_drain(void)
--        assert result['return'] == {}
+     test_quiesce_common(BDRV_DRAIN, false);
--        vm.run_job('job0')
+ }
--    iotests.log("")
--
++
- with iotests.FilePath('t.vhdx') as disk_path, \
++typedef struct TestBlockJob {
-      iotests.VM() as vm:
++    BlockJob common;
++    bool should_complete;
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
++} TestBlockJob;
-     size = 128 * 1024 * 1024
++
++static void test_job_completed(BlockJob *job, void *opaque)
-     vm.launch()
++{
--    blockdev_create(vm, { 'driver': 'file',
++    block_job_completed(job, 0);
--                          'filename': disk_path,
++}
--                          'size': 0 })
++
-+    vm.blockdev_create({ 'driver': 'file',
++static void coroutine_fn test_job_start(void *opaque)
-+                         'filename': disk_path,
++{
-+                         'size': 0 })
++    TestBlockJob *s = opaque;
++
-     vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
++    while (!s->should_complete) {
-                node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
++        block_job_sleep_ns(&s->common, 100000);
++    }
--    blockdev_create(vm, { 'driver': imgfmt,
++
--                          'file': 'imgfile',
++    block_job_defer_to_main_loop(&s->common, test_job_completed, NULL);
--                          'size': size })
++}
-+    vm.blockdev_create({ 'driver': imgfmt,
++
-+                         'file': 'imgfile',
++static void test_job_complete(BlockJob *job, Error **errp)
-+                         'size': size })
++{
-     vm.shutdown()
++    TestBlockJob *s = container_of(job, TestBlockJob, common);
++    s->should_complete = true;
-     iotests.img_info_log(disk_path)
++}
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
++
-     size = 64 * 1024 * 1024
++BlockJobDriver test_job_driver = {
++    .instance_size  = sizeof(TestBlockJob),
-     vm.launch()
++    .start          = test_job_start,
--    blockdev_create(vm, { 'driver': 'file',
++    .complete       = test_job_complete,
--                          'filename': disk_path,
++};
--                          'size': 0 })
++
--    blockdev_create(vm, { 'driver': imgfmt,
++static void test_blockjob_common(enum drain_type drain_type)
--                          'file': {
++{
--                              'driver': 'file',
++    BlockBackend *blk_src, *blk_target;
--                              'filename': disk_path,
++    BlockDriverState *src, *target;
--                          },
++    BlockJob *job;
--                          'size': size,
++    int ret;
--                          'log-size': 1048576,
++
--                          'block-size': 8388608,
++    src = bdrv_new_open_driver(&bdrv_test, "source", BDRV_O_RDWR,
--                          'subformat': 'dynamic',
++                               &error_abort);
--                          'block-state-zero': True })
++    blk_src = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
-+    vm.blockdev_create({ 'driver': 'file',
++    blk_insert_bs(blk_src, src, &error_abort);
-+                         'filename': disk_path,
++
-+                         'size': 0 })
++    target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
-+    vm.blockdev_create({ 'driver': imgfmt,
++                                  &error_abort);
-+                         'file': {
++    blk_target = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
-+                             'driver': 'file',
++    blk_insert_bs(blk_target, target, &error_abort);
-+                             'filename': disk_path,
++
-+                         },
++    job = block_job_create("job0", &test_job_driver, src, 0, BLK_PERM_ALL, 0,
-+                         'size': size,
++                           0, NULL, NULL, &error_abort);
-+                         'log-size': 1048576,
++    block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
-+                         'block-size': 8388608,
++    block_job_start(job);
-+                         'subformat': 'dynamic',
++
-+                         'block-state-zero': True })
++    g_assert_cmpint(job->pause_count, ==, 0);
-     vm.shutdown()
++    g_assert_false(job->paused);
++    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
-     iotests.img_info_log(disk_path)
++
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
++    do_drain_begin(drain_type, src);
-     size = 32 * 1024 * 1024
++
++    if (drain_type == BDRV_DRAIN_ALL) {
-     vm.launch()
++        /* bdrv_drain_all() drains both src and target, and involves an
--    blockdev_create(vm, { 'driver': 'file',
++         * additional block_job_pause_all() */
--                          'filename': disk_path,
++        g_assert_cmpint(job->pause_count, ==, 3);
--                          'size': 0 })
++    } else {
--    blockdev_create(vm, { 'driver': imgfmt,
++        g_assert_cmpint(job->pause_count, ==, 1);
--                          'file': {
++    }
--                              'driver': 'file',
++    /* XXX We don't wait until the job is actually paused. Is this okay? */
--                              'filename': disk_path,
++    /* g_assert_true(job->paused); */
--                          },
++    g_assert_false(job->busy); /* The job is paused */
--                          'size': size,
++
--                          'log-size': 8388608,
++    do_drain_end(drain_type, src);
--                          'block-size': 268435456,
++
--                          'subformat': 'fixed',
++    g_assert_cmpint(job->pause_count, ==, 0);
--                          'block-state-zero': False })
++    g_assert_false(job->paused);
-+    vm.blockdev_create({ 'driver': 'file',
++    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
-+                         'filename': disk_path,
++
-+                         'size': 0 })
++    do_drain_begin(drain_type, target);
-+    vm.blockdev_create({ 'driver': imgfmt,
++
-+                         'file': {
++    if (drain_type == BDRV_DRAIN_ALL) {
-+                             'driver': 'file',
++        /* bdrv_drain_all() drains both src and target, and involves an
-+                             'filename': disk_path,
++         * additional block_job_pause_all() */
-+                         },
++        g_assert_cmpint(job->pause_count, ==, 3);
-+                         'size': size,
++    } else {
-+                         'log-size': 8388608,
++        g_assert_cmpint(job->pause_count, ==, 1);
-+                         'block-size': 268435456,
++    }
-+                         'subformat': 'fixed',
++    /* XXX We don't wait until the job is actually paused. Is this okay? */
-+                         'block-state-zero': False })
++    /* g_assert_true(job->paused); */
-     vm.shutdown()
++    g_assert_false(job->busy); /* The job is paused */
++
-     iotests.img_info_log(disk_path)
++    do_drain_end(drain_type, target);
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
++
-     iotests.log("")
++    g_assert_cmpint(job->pause_count, ==, 0);
++    g_assert_false(job->paused);
-     vm.launch()
++    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
--    blockdev_create(vm, { 'driver': imgfmt,
++
--                          'file': "this doesn't exist",
++    ret = block_job_complete_sync(job, &error_abort);
--                          'size': size })
++    g_assert_cmpint(ret, ==, 0);
-+    vm.blockdev_create({ 'driver': imgfmt,
++
-+                         'file': "this doesn't exist",
++    blk_unref(blk_src);
-+                         'size': size })
++    blk_unref(blk_target);
-     vm.shutdown()
++    bdrv_unref(src);
++    bdrv_unref(target);
-     #
++}
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
++
++static void test_blockjob_drain_all(void)
-     vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
++{
-     vm.launch()
++    test_blockjob_common(BDRV_DRAIN_ALL);
--    blockdev_create(vm, { 'driver': imgfmt,
++}
--                          'file': 'node0',
++
--                          'size': 0 })
++static void test_blockjob_drain(void)
-+    vm.blockdev_create({ 'driver': imgfmt,
++{
-+                         'file': 'node0',
++    test_blockjob_common(BDRV_DRAIN);
-+                         'size': 0 })
++}
-     vm.shutdown()
++
+ int main(int argc, char **argv)
-     iotests.img_info_log(disk_path)
+ {
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
+     bdrv_init();
-     iotests.log("")
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
+     g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
-     vm.launch()
+     g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
--    blockdev_create(vm, { 'driver': imgfmt,
--                          'file': 'node0',
++    g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
--                          'size': 70368744177664 })
++    g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
-+    vm.blockdev_create({ 'driver': imgfmt,
++
-+                         'file': 'node0',
+     return g_test_run();
-+                         'size': 70368744177664 })
+ }
      vm.shutdown()
      iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
      vm.launch()
      for size in [ 18446744073709551104, 9223372036854775808,
                    9223372036854775296, 70368744177665 ]:
 -        blockdev_create(vm, { 'driver': imgfmt,
 -                              'file': 'node0',
 -                              'size': size })
 +        vm.blockdev_create({ 'driver': imgfmt,
 +                             'file': 'node0',
 +                             'size': size })
      vm.shutdown()
      #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
      vm.launch()
      for bsize in [ 1234567, 128, 3145728, 536870912, 0 ]:
 -        blockdev_create(vm, { 'driver': imgfmt,
 -                              'file': 'node0',
 -                              'size': 67108864,
 -                              'block-size': bsize })
 +        vm.blockdev_create({ 'driver': imgfmt,
 +                             'file': 'node0',
 +                             'size': 67108864,
 +                             'block-size': bsize })
      vm.shutdown()
      #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.vhdx') as disk_path, \
      vm.launch()
      for lsize in [ 1234567, 128, 4294967296, 0 ]:
 -        blockdev_create(vm, { 'driver': imgfmt,
 -                              'file': 'node0',
 -                              'size': 67108864,
 -                              'log-size': lsize })
 +        vm.blockdev_create({ 'driver': imgfmt,
 +                             'file': 'node0',
 +                             'size': 67108864,
 +                             'log-size': lsize })
      vm.shutdown()
 --
-.20.1
+.13.6

-[PULL 22/30] iotests: 212: Convert to VM.blockdev_create()
+[Qemu-devel] [PULL v3 24/35] block: Don't block_job_pause_all() in bdrv_drain_all()
-Instead of having a separate blockdev_create() function, make use of the
+Block jobs are already paused using the BdrvChildRole drain callbacks,
-VM.blockdev_create() offered by iotests.py.
+so we don't need an additional block_job_pause_all() call.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/212 | 101 +++++++++++++++++++----------------------
+ block/io.c              |  4 ----
-file changed, 46 insertions(+), 55 deletions(-)
+ tests/test-bdrv-drain.c | 10 ++++------
 files changed, 4 insertions(+), 10 deletions(-)
-diff --git a/tests/qemu-iotests/212 b/tests/qemu-iotests/212
+diff --git a/block/io.c b/block/io.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/212
+--- a/block/io.c
-+++ b/tests/qemu-iotests/212
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
+@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
- iotests.verify_image_format(supported_fmts=['parallels'])
+      * context. */
- iotests.verify_protocol(supported=['file'])
+     assert(qemu_get_current_aio_context() == qemu_get_aio_context());
--def blockdev_create(vm, options):
+-    block_job_pause_all();
 -    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
 -                        filters=[iotests.filter_qmp_testfiles])
 -
--    if 'return' in result:
+     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
--        assert result['return'] == {}
+         AioContext *aio_context = bdrv_get_aio_context(bs);
--        vm.run_job('job0')
--    iotests.log("")
+@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
          aio_enable_external(aio_context);
          aio_context_release(aio_context);
      }
 -
- with iotests.FilePath('t.parallels') as disk_path, \
+-    block_job_resume_all();
-      iotests.VM() as vm:
+ }
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
+ void bdrv_drain_all(void)
-     size = 128 * 1024 * 1024
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
+index XXXXXXX..XXXXXXX 100644
-     vm.launch()
+--- a/tests/test-bdrv-drain.c
--    blockdev_create(vm, { 'driver': 'file',
++++ b/tests/test-bdrv-drain.c
--                          'filename': disk_path,
+@@ -XXX,XX +XXX,XX @@ static void test_blockjob_common(enum drain_type drain_type)
--                          'size': 0 })
+     do_drain_begin(drain_type, src);
-+    vm.blockdev_create({ 'driver': 'file',
-+                         'filename': disk_path,
+     if (drain_type == BDRV_DRAIN_ALL) {
-+                         'size': 0 })
+-        /* bdrv_drain_all() drains both src and target, and involves an
+-         * additional block_job_pause_all() */
-     vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
+-        g_assert_cmpint(job->pause_count, ==, 3);
-                node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
++        /* bdrv_drain_all() drains both src and target */
++        g_assert_cmpint(job->pause_count, ==, 2);
--    blockdev_create(vm, { 'driver': imgfmt,
+     } else {
--                          'file': 'imgfile',
+         g_assert_cmpint(job->pause_count, ==, 1);
--                          'size': size })
+     }
-+    vm.blockdev_create({ 'driver': imgfmt,
+@@ -XXX,XX +XXX,XX @@ static void test_blockjob_common(enum drain_type drain_type)
-+                         'file': 'imgfile',
+     do_drain_begin(drain_type, target);
-+                         'size': size })
-     vm.shutdown()
+     if (drain_type == BDRV_DRAIN_ALL) {
+-        /* bdrv_drain_all() drains both src and target, and involves an
-     iotests.img_info_log(disk_path)
+-         * additional block_job_pause_all() */
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
+-        g_assert_cmpint(job->pause_count, ==, 3);
-     size = 64 * 1024 * 1024
++        /* bdrv_drain_all() drains both src and target */
++        g_assert_cmpint(job->pause_count, ==, 2);
-     vm.launch()
+     } else {
--    blockdev_create(vm, { 'driver': 'file',
+         g_assert_cmpint(job->pause_count, ==, 1);
--                          'filename': disk_path,
+     }
 -                          'size': 0 })
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': {
 -                              'driver': 'file',
 -                              'filename': disk_path,
 -                          },
 -                          'size': size,
 -                          'cluster-size': 1048576 })
 +    vm.blockdev_create({ 'driver': 'file',
 +                         'filename': disk_path,
 +                         'size': 0 })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': {
 +                             'driver': 'file',
 +                             'filename': disk_path,
 +                         },
 +                         'size': size,
 +                         'cluster-size': 1048576 })
      vm.shutdown()
      iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
      size = 32 * 1024 * 1024
      vm.launch()
 -    blockdev_create(vm, { 'driver': 'file',
 -                          'filename': disk_path,
 -                          'size': 0 })
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': {
 -                              'driver': 'file',
 -                              'filename': disk_path,
 -                          },
 -                          'size': size,
 -                          'cluster-size': 65536 })
 +    vm.blockdev_create({ 'driver': 'file',
 +                         'filename': disk_path,
 +                         'size': 0 })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': {
 +                             'driver': 'file',
 +                             'filename': disk_path,
 +                         },
 +                         'size': size,
 +                         'cluster-size': 65536 })
      vm.shutdown()
      iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
      iotests.log("")
      vm.launch()
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': "this doesn't exist",
 -                          'size': size })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': "this doesn't exist",
 +                         'size': size })
      vm.shutdown()
      #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
      vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
      vm.launch()
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': 0 })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': 0 })
      vm.shutdown()
      iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
      iotests.log("")
      vm.launch()
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': 4503599627369984})
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': 4503599627369984})
      vm.shutdown()
      iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
      vm.launch()
      for size in [ 1234, 18446744073709551104, 9223372036854775808,
                    9223372036854775296, 4503599627370497 ]:
 -        blockdev_create(vm, { 'driver': imgfmt,
 -                              'file': 'node0',
 -                              'size': size })
 +        vm.blockdev_create({ 'driver': imgfmt,
 +                             'file': 'node0',
 +                             'size': size })
      vm.shutdown()
      #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.parallels') as disk_path, \
      vm.launch()
      for csize in [ 1234, 128, 4294967296, 9223372036854775808,
                     18446744073709551104, 0 ]:
 -        blockdev_create(vm, { 'driver': imgfmt,
 -                              'file': 'node0',
 -                              'size': 67108864,
 -                              'cluster-size': csize })
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': 281474976710656,
 -                          'cluster-size': 512 })
 +        vm.blockdev_create({ 'driver': imgfmt,
 +                             'file': 'node0',
 +                             'size': 67108864,
 +                             'cluster-size': csize })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': 281474976710656,
 +                         'cluster-size': 512 })
      vm.shutdown()
 --
-.20.1
+.13.6

-[PULL 21/30] iotests: 210: Convert to VM.blockdev_create()
+[Qemu-devel] [PULL v3 25/35] block: Nested drain_end must still call callbacks
-Instead of having a separate blockdev_create() function, make use of the
+bdrv_do_drained_begin() restricts the call of parent callbacks and
-VM.blockdev_create() offered by iotests.py.
+aio_disable_external() to the outermost drain section, but the block
 driver callbacks are always called. bdrv_do_drained_end() must match
 this behaviour, otherwise nodes stay drained even if begin/end calls
 were balanced.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/210 | 81 +++++++++++++++++++-----------------------
+ block/io.c | 12 +++++++-----
-file changed, 36 insertions(+), 45 deletions(-)
+file changed, 7 insertions(+), 5 deletions(-)
-diff --git a/tests/qemu-iotests/210 b/tests/qemu-iotests/210
+diff --git a/block/io.c b/block/io.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/210
+--- a/block/io.c
-+++ b/tests/qemu-iotests/210
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
+@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)
- iotests.verify_image_format(supported_fmts=['luks'])
- iotests.verify_protocol(supported=['file'])
+ void bdrv_drained_end(BlockDriverState *bs)
+ {
--def blockdev_create(vm, options):
++    int old_quiesce_counter;
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
++
--                        filters=[iotests.filter_qmp_testfiles])
+     if (qemu_in_coroutine()) {
--
+         bdrv_co_yield_to_drain(bs, false);
--    if 'return' in result:
+         return;
--        assert result['return'] == {}
+     }
--        vm.run_job('job0')
+     assert(bs->quiesce_counter > 0);
--    iotests.log("")
+-    if (atomic_fetch_dec(&bs->quiesce_counter) > 1) {
--
+-        return;
- with iotests.FilePath('t.luks') as disk_path, \
+-    }
-      iotests.VM() as vm:
++    old_quiesce_counter = atomic_fetch_dec(&bs->quiesce_counter);
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
+     /* Re-enable things in child-to-parent order */
-     size = 128 * 1024 * 1024
+     bdrv_drain_invoke(bs, false, false);
+-    bdrv_parent_drained_end(bs);
-     vm.launch()
+-    aio_enable_external(bdrv_get_aio_context(bs));
--    blockdev_create(vm, { 'driver': 'file',
++    if (old_quiesce_counter == 1) {
--                          'filename': disk_path,
++        bdrv_parent_drained_end(bs);
--                          'size': 0 })
++        aio_enable_external(bdrv_get_aio_context(bs));
-+    vm.blockdev_create({ 'driver': 'file',
++    }
-+                         'filename': disk_path,
+ }
-+                         'size': 0 })
+ /*
      vm.qmp_log('blockdev-add', driver='file', filename=disk_path,
                 node_name='imgfile', filters=[iotests.filter_qmp_testfiles])
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'imgfile',
 -                          'key-secret': 'keysec0',
 -                          'size': size,
 -                          'iter-time': 10 })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'imgfile',
 +                         'key-secret': 'keysec0',
 +                         'size': size,
 +                         'iter-time': 10 })
      vm.shutdown()
      # TODO Proper support for images to be used with imgopts and/or protocols
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
      size = 64 * 1024 * 1024
      vm.launch()
 -    blockdev_create(vm, { 'driver': 'file',
 -                          'filename': disk_path,
 -                          'size': 0 })
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': {
 -                              'driver': 'file',
 -                              'filename': disk_path,
 -                          },
 -                          'size': size,
 -                          'key-secret': 'keysec0',
 -                          'cipher-alg': 'twofish-128',
 -                          'cipher-mode': 'ctr',
 -                          'ivgen-alg': 'plain64',
 -                          'ivgen-hash-alg': 'md5',
 -                          'hash-alg': 'sha1',
 -                          'iter-time': 10 })
 +    vm.blockdev_create({ 'driver': 'file',
 +                         'filename': disk_path,
 +                         'size': 0 })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': {
 +                             'driver': 'file',
 +                             'filename': disk_path,
 +                         },
 +                         'size': size,
 +                         'key-secret': 'keysec0',
 +                         'cipher-alg': 'twofish-128',
 +                         'cipher-mode': 'ctr',
 +                         'ivgen-alg': 'plain64',
 +                         'ivgen-hash-alg': 'md5',
 +                         'hash-alg': 'sha1',
 +                         'iter-time': 10 })
      vm.shutdown()
      # TODO Proper support for images to be used with imgopts and/or protocols
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
      size = 64 * 1024 * 1024
      vm.launch()
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': "this doesn't exist",
 -                          'size': size })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': "this doesn't exist",
 +                         'size': size })
      vm.shutdown()
      #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
      vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))
      vm.launch()
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'key-secret': 'keysec0',
 -                          'size': 0,
 -                          'iter-time': 10 })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'key-secret': 'keysec0',
 +                         'size': 0,
 +                         'iter-time': 10 })
      vm.shutdown()
      # TODO Proper support for images to be used with imgopts and/or protocols
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.luks') as disk_path, \
      vm.launch()
      for size in [ 18446744073709551104, 9223372036854775808, 9223372036854775296 ]:
 -        blockdev_create(vm, { 'driver': imgfmt,
 -                              'file': 'node0',
 -                              'key-secret': 'keysec0',
 -                              'size': size })
 +        vm.blockdev_create({ 'driver': imgfmt,
 +                             'file': 'node0',
 +                             'key-secret': 'keysec0',
 +                             'size': size })
      vm.shutdown()
      #
 --
-.20.1
+.13.6

-[PULL 15/30] iotests/273: Filter format-specific information
+[Qemu-devel] [PULL v3 26/35] test-bdrv-drain: Test nested drain sections
-From: Max Reitz <mreitz@redhat.com>
-Doing this allows running this test with e.g. -o compat=0.10 or
--o compat=refcount_bits=1.
-Signed-off-by: Max Reitz <mreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/273     |  3 ++-
+ tests/test-bdrv-drain.c | 57 +++++++++++++++++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/273.out | 27 ---------------------------
+file changed, 57 insertions(+)
 files changed, 2 insertions(+), 28 deletions(-)
-diff --git a/tests/qemu-iotests/273 b/tests/qemu-iotests/273
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/273
+--- a/tests/test-bdrv-drain.c
-+++ b/tests/qemu-iotests/273
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ do_run_qemu()
+@@ -XXX,XX +XXX,XX @@ static void aio_ret_cb(void *opaque, int ret)
- run_qemu()
+ enum drain_type {
- {
+     BDRV_DRAIN_ALL,
-     do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qemu | _filter_qmp |
+     BDRV_DRAIN,
--        _filter_generated_node_ids | _filter_imgfmt | _filter_actual_image_size
++    DRAIN_TYPE_MAX,
-+        _filter_generated_node_ids | _filter_imgfmt |
+ };
-+        _filter_actual_image_size | _filter_img_info
  static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
@@ -XXX,XX +XXX,XX @@ static void test_quiesce_drain(void)
      test_quiesce_common(BDRV_DRAIN, false);
  }
- TEST_IMG="$TEST_IMG.base" _make_test_img 64M
++static void test_nested(void)
-diff --git a/tests/qemu-iotests/273.out b/tests/qemu-iotests/273.out
++{
-index XXXXXXX..XXXXXXX 100644
++    BlockBackend *blk;
---- a/tests/qemu-iotests/273.out
++    BlockDriverState *bs, *backing;
-+++ b/tests/qemu-iotests/273.out
++    BDRVTestState *s, *backing_s;
-@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
++    enum drain_type outer, inner;
-                     "cluster-size": 65536,
++
-                     "format": "IMGFMT",
++    blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
-                     "actual-size": SIZE,
++    bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
--                    "format-specific": {
++                              &error_abort);
--                        "type": "IMGFMT",
++    s = bs->opaque;
--                        "data": {
++    blk_insert_bs(blk, bs, &error_abort);
--                            "compat": "1.1",
++
--                            "lazy-refcounts": false,
++    backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
--                            "refcount-bits": 16,
++    backing_s = backing->opaque;
--                            "corrupt": false
++    bdrv_set_backing_hd(bs, backing, &error_abort);
--                        }
++
--                    },
++    for (outer = 0; outer < DRAIN_TYPE_MAX; outer++) {
-                     "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
++        for (inner = 0; inner < DRAIN_TYPE_MAX; inner++) {
-                     "backing-filename": "TEST_DIR/t.IMGFMT.base",
++            /* XXX bdrv_drain_all() doesn't increase the quiesce_counter */
-                     "dirty-flag": false
++            int bs_quiesce      = (outer != BDRV_DRAIN_ALL) +
-@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
++                                  (inner != BDRV_DRAIN_ALL);
-                 "cluster-size": 65536,
++            int backing_quiesce = 0;
-                 "format": "IMGFMT",
++            int backing_cb_cnt  = (outer != BDRV_DRAIN) +
-                 "actual-size": SIZE,
++                                  (inner != BDRV_DRAIN);
--                "format-specific": {
++
--                    "type": "IMGFMT",
++            g_assert_cmpint(bs->quiesce_counter, ==, 0);
--                    "data": {
++            g_assert_cmpint(backing->quiesce_counter, ==, 0);
--                        "compat": "1.1",
++            g_assert_cmpint(s->drain_count, ==, 0);
--                        "lazy-refcounts": false,
++            g_assert_cmpint(backing_s->drain_count, ==, 0);
--                        "refcount-bits": 16,
++
--                        "corrupt": false
++            do_drain_begin(outer, bs);
--                    }
++            do_drain_begin(inner, bs);
--                },
++
-                 "full-backing-filename": "TEST_DIR/t.IMGFMT.mid",
++            g_assert_cmpint(bs->quiesce_counter, ==, bs_quiesce);
-                 "backing-filename": "TEST_DIR/t.IMGFMT.mid",
++            g_assert_cmpint(backing->quiesce_counter, ==, backing_quiesce);
-                 "dirty-flag": false
++            g_assert_cmpint(s->drain_count, ==, 2);
-@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
++            g_assert_cmpint(backing_s->drain_count, ==, backing_cb_cnt);
-                 "cluster-size": 65536,
++
-                 "format": "IMGFMT",
++            do_drain_end(inner, bs);
-                 "actual-size": SIZE,
++            do_drain_end(outer, bs);
--                "format-specific": {
++
--                    "type": "IMGFMT",
++            g_assert_cmpint(bs->quiesce_counter, ==, 0);
--                    "data": {
++            g_assert_cmpint(backing->quiesce_counter, ==, 0);
--                        "compat": "1.1",
++            g_assert_cmpint(s->drain_count, ==, 0);
--                        "lazy-refcounts": false,
++            g_assert_cmpint(backing_s->drain_count, ==, 0);
--                        "refcount-bits": 16,
++        }
--                        "corrupt": false
++    }
--                    }
++
--                },
++    bdrv_unref(backing);
-                 "full-backing-filename": "TEST_DIR/t.IMGFMT.base",
++    bdrv_unref(bs);
-                 "backing-filename": "TEST_DIR/t.IMGFMT.base",
++    blk_unref(blk);
-                 "dirty-flag": false
++}
 +
  typedef struct TestBlockJob {
      BlockJob common;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
      g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
      g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
 +    g_test_add_func("/bdrv-drain/nested", test_nested);
 +
      g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
      g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
 --
-.20.1
+.13.6

-New patch
+[Qemu-devel] [PULL v3 27/35] block: Don't notify parents in drain call chain
+This is in preparation for subtree drains, i.e. drained sections that
 affect not only a single node, but recursively all child nodes, too.
 Calling the parent callbacks for drain is pointless when we just came
 from that parent node recursively and leads to multiple increases of
 bs->quiesce_counter in a single drain call. Don't do it.
 In order for this to work correctly, the parent callback must be called
 for every bdrv_drain_begin/end() call, not only for the outermost one:
 If we have a node N with two parents A and B, recursive draining of A
 should cause the quiesce_counter of B to increase because its child N is
 drained independently of B. If now B is recursively drained, too, A must
 increase its quiesce_counter because N is drained independently of A
 only now, even if N is going from quiesce_counter 1 to 2.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
  include/block/block.h |  4 ++--
  block.c               | 13 +++++++++----
  block/io.c            | 47 ++++++++++++++++++++++++++++++++++-------------
 files changed, 45 insertions(+), 19 deletions(-)
 diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block.h
 +++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ void bdrv_io_unplug(BlockDriverState *bs);
   * Begin a quiesced section of all users of @bs. This is part of
   * bdrv_drained_begin.
   */
 -void bdrv_parent_drained_begin(BlockDriverState *bs);
 +void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore);
  /**
   * bdrv_parent_drained_end:
@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_begin(BlockDriverState *bs);
   * End a quiesced section of all users of @bs. This is part of
   * bdrv_drained_end.
   */
 -void bdrv_parent_drained_end(BlockDriverState *bs);
 +void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore);
  /**
   * bdrv_drained_begin:
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
                                        BlockDriverState *new_bs)
  {
      BlockDriverState *old_bs = child->bs;
 +    int i;
      if (old_bs && new_bs) {
          assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
      }
      if (old_bs) {
          if (old_bs->quiesce_counter && child->role->drained_end) {
 -            child->role->drained_end(child);
 +            for (i = 0; i < old_bs->quiesce_counter; i++) {
 +                child->role->drained_end(child);
 +            }
          }
          if (child->role->detach) {
              child->role->detach(child);
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
      if (new_bs) {
          QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
          if (new_bs->quiesce_counter && child->role->drained_begin) {
 -            child->role->drained_begin(child);
 +            for (i = 0; i < new_bs->quiesce_counter; i++) {
 +                child->role->drained_begin(child);
 +            }
          }
          if (child->role->attach) {
@@ -XXX,XX +XXX,XX @@ void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
      AioContext *ctx = bdrv_get_aio_context(bs);
      aio_disable_external(ctx);
 -    bdrv_parent_drained_begin(bs);
 +    bdrv_parent_drained_begin(bs, NULL);
      bdrv_drain(bs); /* ensure there are no in-flight requests */
      while (aio_poll(ctx, false)) {
@@ -XXX,XX +XXX,XX @@ void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
       */
      aio_context_acquire(new_context);
      bdrv_attach_aio_context(bs, new_context);
 -    bdrv_parent_drained_end(bs);
 +    bdrv_parent_drained_end(bs, NULL);
      aio_enable_external(ctx);
      aio_context_release(new_context);
  }
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
@@ -XXX,XX +XXX,XX @@
  static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
      int64_t offset, int bytes, BdrvRequestFlags flags);
 -void bdrv_parent_drained_begin(BlockDriverState *bs)
 +void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore)
  {
      BdrvChild *c, *next;
      QLIST_FOREACH_SAFE(c, &bs->parents, next_parent, next) {
 +        if (c == ignore) {
 +            continue;
 +        }
          if (c->role->drained_begin) {
              c->role->drained_begin(c);
          }
      }
  }
 -void bdrv_parent_drained_end(BlockDriverState *bs)
 +void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore)
  {
      BdrvChild *c, *next;
      QLIST_FOREACH_SAFE(c, &bs->parents, next_parent, next) {
 +        if (c == ignore) {
 +            continue;
 +        }
          if (c->role->drained_end) {
              c->role->drained_end(c);
          }
@@ -XXX,XX +XXX,XX @@ typedef struct {
      BlockDriverState *bs;
      bool done;
      bool begin;
 +    BdrvChild *parent;
  } BdrvCoDrainData;
  static void coroutine_fn bdrv_drain_invoke_entry(void *opaque)
@@ -XXX,XX +XXX,XX @@ static bool bdrv_drain_recurse(BlockDriverState *bs)
      return waited;
  }
 +static void bdrv_do_drained_begin(BlockDriverState *bs, BdrvChild *parent);
 +static void bdrv_do_drained_end(BlockDriverState *bs, BdrvChild *parent);
 +
  static void bdrv_co_drain_bh_cb(void *opaque)
  {
      BdrvCoDrainData *data = opaque;
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_drain_bh_cb(void *opaque)
      bdrv_dec_in_flight(bs);
      if (data->begin) {
 -        bdrv_drained_begin(bs);
 +        bdrv_do_drained_begin(bs, data->parent);
      } else {
 -        bdrv_drained_end(bs);
 +        bdrv_do_drained_end(bs, data->parent);
      }
      data->done = true;
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_drain_bh_cb(void *opaque)
  }
  static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
 -                                                bool begin)
 +                                                bool begin, BdrvChild *parent)
  {
      BdrvCoDrainData data;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
          .bs = bs,
          .done = false,
          .begin = begin,
 +        .parent = parent,
      };
      bdrv_inc_in_flight(bs);
      aio_bh_schedule_oneshot(bdrv_get_aio_context(bs),
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
      assert(data.done);
  }
 -void bdrv_drained_begin(BlockDriverState *bs)
 +static void bdrv_do_drained_begin(BlockDriverState *bs, BdrvChild *parent)
  {
      if (qemu_in_coroutine()) {
 -        bdrv_co_yield_to_drain(bs, true);
 +        bdrv_co_yield_to_drain(bs, true, parent);
          return;
      }
      /* Stop things in parent-to-child order */
      if (atomic_fetch_inc(&bs->quiesce_counter) == 0) {
          aio_disable_external(bdrv_get_aio_context(bs));
 -        bdrv_parent_drained_begin(bs);
      }
 +    bdrv_parent_drained_begin(bs, parent);
      bdrv_drain_invoke(bs, true, false);
      bdrv_drain_recurse(bs);
  }
 -void bdrv_drained_end(BlockDriverState *bs)
 +void bdrv_drained_begin(BlockDriverState *bs)
 +{
 +    bdrv_do_drained_begin(bs, NULL);
 +}
 +
 +static void bdrv_do_drained_end(BlockDriverState *bs, BdrvChild *parent)
  {
      int old_quiesce_counter;
      if (qemu_in_coroutine()) {
 -        bdrv_co_yield_to_drain(bs, false);
 +        bdrv_co_yield_to_drain(bs, false, parent);
          return;
      }
      assert(bs->quiesce_counter > 0);
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
      /* Re-enable things in child-to-parent order */
      bdrv_drain_invoke(bs, false, false);
 +    bdrv_parent_drained_end(bs, parent);
      if (old_quiesce_counter == 1) {
 -        bdrv_parent_drained_end(bs);
          aio_enable_external(bdrv_get_aio_context(bs));
      }
  }
 +void bdrv_drained_end(BlockDriverState *bs)
 +{
 +    bdrv_do_drained_end(bs, NULL);
 +}
 +
  /*
   * Wait for pending requests to complete on a single BlockDriverState subtree,
   * and suspend block driver's internal I/O until next request arrives.
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
          /* Stop things in parent-to-child order */
          aio_context_acquire(aio_context);
          aio_disable_external(aio_context);
 -        bdrv_parent_drained_begin(bs);
 +        bdrv_parent_drained_begin(bs, NULL);
          bdrv_drain_invoke(bs, true, true);
          aio_context_release(aio_context);
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
          /* Re-enable things in child-to-parent order */
          aio_context_acquire(aio_context);
          bdrv_drain_invoke(bs, false, true);
 -        bdrv_parent_drained_end(bs);
 +        bdrv_parent_drained_end(bs, NULL);
          aio_enable_external(aio_context);
          aio_context_release(aio_context);
      }
 --
 .13.6

-[PULL 08/30] qcow2: Declare BDRV_REQ_NO_FALLBACK supported
+[Qemu-devel] [PULL v3 28/35] block: Add bdrv_subtree_drained_begin/end()
-In the common case, qcow2_co_pwrite_zeroes() already only modifies
+bdrv_drained_begin() waits for the completion of requests in the whole
-metadata case, so we're fine with or without BDRV_REQ_NO_FALLBACK set.
+subtree, but it only actually keeps its immediate bs parameter quiesced
 until bdrv_drained_end().
-The only exception is when using an external data file, where the
+Add a version that keeps the whole subtree drained. As of this commit,
-request is passed down to the block driver of the external data file. We
+graph changes cannot be allowed during a subtree drained section, but
-are forwarding the BDRV_REQ_NO_FALLBACK flag there, though, so this is
+this will be fixed soon.
 fine, too.
 Declare the flag supported therefore.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
 ---
- block/qcow2.c | 3 ++-
+ include/block/block.h | 13 +++++++++++++
-file changed, 2 insertions(+), 1 deletion(-)
+ block/io.c            | 54 ++++++++++++++++++++++++++++++++++++++++-----------
 files changed, 56 insertions(+), 11 deletions(-)
-diff --git a/block/qcow2.c b/block/qcow2.c
+diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2.c
+--- a/include/block/block.h
-+++ b/block/qcow2.c
++++ b/include/block/block.h
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
+@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore);
-         }
+ void bdrv_drained_begin(BlockDriverState *bs);
  /**
 + * Like bdrv_drained_begin, but recursively begins a quiesced section for
 + * exclusive access to all child nodes as well.
 + *
 + * Graph changes are not allowed during a subtree drain section.
 + */
 +void bdrv_subtree_drained_begin(BlockDriverState *bs);
 +
 +/**
   * bdrv_drained_end:
   *
   * End a quiescent section started by bdrv_drained_begin().
   */
  void bdrv_drained_end(BlockDriverState *bs);
 +/**
 + * End a quiescent section started by bdrv_subtree_drained_begin().
 + */
 +void bdrv_subtree_drained_end(BlockDriverState *bs);
 +
  void bdrv_add_child(BlockDriverState *parent, BlockDriverState *child,
                      Error **errp);
  void bdrv_del_child(BlockDriverState *parent, BdrvChild *child, Error **errp);
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ typedef struct {
      BlockDriverState *bs;
      bool done;
      bool begin;
 +    bool recursive;
      BdrvChild *parent;
  } BdrvCoDrainData;
@@ -XXX,XX +XXX,XX @@ static bool bdrv_drain_recurse(BlockDriverState *bs)
      return waited;
  }
 -static void bdrv_do_drained_begin(BlockDriverState *bs, BdrvChild *parent);
 -static void bdrv_do_drained_end(BlockDriverState *bs, BdrvChild *parent);
 +static void bdrv_do_drained_begin(BlockDriverState *bs, bool recursive,
 +                                  BdrvChild *parent);
 +static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
 +                                BdrvChild *parent);
  static void bdrv_co_drain_bh_cb(void *opaque)
  {
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_drain_bh_cb(void *opaque)
      bdrv_dec_in_flight(bs);
      if (data->begin) {
 -        bdrv_do_drained_begin(bs, data->parent);
 +        bdrv_do_drained_begin(bs, data->recursive, data->parent);
      } else {
 -        bdrv_do_drained_end(bs, data->parent);
 +        bdrv_do_drained_end(bs, data->recursive, data->parent);
      }
--    bs->supported_zero_flags = header.version >= 3 ? BDRV_REQ_MAY_UNMAP : 0;
+     data->done = true;
-+    bs->supported_zero_flags = header.version >= 3 ?
+@@ -XXX,XX +XXX,XX @@ static void bdrv_co_drain_bh_cb(void *opaque)
-+                               BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
+ }
-     /* Repair image if dirty */
+ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
-     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
+-                                                bool begin, BdrvChild *parent)
 +                                                bool begin, bool recursive,
 +                                                BdrvChild *parent)
  {
      BdrvCoDrainData data;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
          .bs = bs,
          .done = false,
          .begin = begin,
 +        .recursive = recursive,
          .parent = parent,
      };
      bdrv_inc_in_flight(bs);
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
      assert(data.done);
  }
 -static void bdrv_do_drained_begin(BlockDriverState *bs, BdrvChild *parent)
 +static void bdrv_do_drained_begin(BlockDriverState *bs, bool recursive,
 +                                  BdrvChild *parent)
  {
 +    BdrvChild *child, *next;
 +
      if (qemu_in_coroutine()) {
 -        bdrv_co_yield_to_drain(bs, true, parent);
 +        bdrv_co_yield_to_drain(bs, true, recursive, parent);
          return;
      }
@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_begin(BlockDriverState *bs, BdrvChild *parent)
      bdrv_parent_drained_begin(bs, parent);
      bdrv_drain_invoke(bs, true, false);
      bdrv_drain_recurse(bs);
 +
 +    if (recursive) {
 +        QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
 +            bdrv_do_drained_begin(child->bs, true, child);
 +        }
 +    }
  }
  void bdrv_drained_begin(BlockDriverState *bs)
  {
 -    bdrv_do_drained_begin(bs, NULL);
 +    bdrv_do_drained_begin(bs, false, NULL);
 +}
 +
 +void bdrv_subtree_drained_begin(BlockDriverState *bs)
 +{
 +    bdrv_do_drained_begin(bs, true, NULL);
  }
 -static void bdrv_do_drained_end(BlockDriverState *bs, BdrvChild *parent)
 +static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
 +                                BdrvChild *parent)
  {
 +    BdrvChild *child, *next;
      int old_quiesce_counter;
      if (qemu_in_coroutine()) {
 -        bdrv_co_yield_to_drain(bs, false, parent);
 +        bdrv_co_yield_to_drain(bs, false, recursive, parent);
          return;
      }
      assert(bs->quiesce_counter > 0);
@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_end(BlockDriverState *bs, BdrvChild *parent)
      if (old_quiesce_counter == 1) {
          aio_enable_external(bdrv_get_aio_context(bs));
      }
 +
 +    if (recursive) {
 +        QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
 +            bdrv_do_drained_end(child->bs, true, child);
 +        }
 +    }
  }
  void bdrv_drained_end(BlockDriverState *bs)
  {
 -    bdrv_do_drained_end(bs, NULL);
 +    bdrv_do_drained_end(bs, false, NULL);
 +}
 +
 +void bdrv_subtree_drained_end(BlockDriverState *bs)
 +{
 +    bdrv_do_drained_end(bs, true, NULL);
  }
  /*
 --
-.20.1
+.13.6

-[PULL 20/30] iotests: 206: Convert to VM.blockdev_create()
+[Qemu-devel] [PULL v3 29/35] test-bdrv-drain: Tests for bdrv_subtree_drain
-Instead of having a separate blockdev_create() function, make use of the
+Add a subtree drain version to the existing test cases.
 VM.blockdev_create() offered by iotests.py.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/206 | 232 ++++++++++++++++++++---------------------
+ tests/test-bdrv-drain.c | 27 ++++++++++++++++++++++++++-
-file changed, 111 insertions(+), 121 deletions(-)
+file changed, 26 insertions(+), 1 deletion(-)
-diff --git a/tests/qemu-iotests/206 b/tests/qemu-iotests/206
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/206
+--- a/tests/test-bdrv-drain.c
-+++ b/tests/qemu-iotests/206
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
+@@ -XXX,XX +XXX,XX @@ static void aio_ret_cb(void *opaque, int ret)
+ enum drain_type {
- iotests.verify_image_format(supported_fmts=['qcow2'])
+     BDRV_DRAIN_ALL,
+     BDRV_DRAIN,
--def blockdev_create(vm, options):
++    BDRV_SUBTREE_DRAIN,
--    result = vm.qmp_log('blockdev-create',
+     DRAIN_TYPE_MAX,
--                        filters=[iotests.filter_qmp_testfiles],
+ };
--                        job_id='job0', options=options)
--
+@@ -XXX,XX +XXX,XX @@ static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
--    if 'return' in result:
+     switch (drain_type) {
--        assert result['return'] == {}
+     case BDRV_DRAIN_ALL:        bdrv_drain_all_begin(); break;
--        vm.run_job('job0')
+     case BDRV_DRAIN:            bdrv_drained_begin(bs); break;
--    iotests.log("")
++    case BDRV_SUBTREE_DRAIN:    bdrv_subtree_drained_begin(bs); break;
--
+     default:                    g_assert_not_reached();
- with iotests.FilePath('t.qcow2') as disk_path, \
+     }
-      iotests.FilePath('t.qcow2.base') as backing_path, \
+ }
-      iotests.VM() as vm:
+@@ -XXX,XX +XXX,XX @@ static void do_drain_end(enum drain_type drain_type, BlockDriverState *bs)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
+     switch (drain_type) {
-     size = 128 * 1024 * 1024
+     case BDRV_DRAIN_ALL:        bdrv_drain_all_end(); break;
+     case BDRV_DRAIN:            bdrv_drained_end(bs); break;
-     vm.launch()
++    case BDRV_SUBTREE_DRAIN:    bdrv_subtree_drained_end(bs); break;
--    blockdev_create(vm, { 'driver': 'file',
+     default:                    g_assert_not_reached();
--                          'filename': disk_path,
+     }
--                          'size': 0 })
+ }
-+    vm.blockdev_create({ 'driver': 'file',
+@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_drain(void)
-+                         'filename': disk_path,
+     test_drv_cb_common(BDRV_DRAIN, false);
-+                         'size': 0 })
+ }
-     vm.qmp_log('blockdev-add',
++static void test_drv_cb_drain_subtree(void)
-                filters=[iotests.filter_qmp_testfiles],
++{
-                driver='file', filename=disk_path,
++    test_drv_cb_common(BDRV_SUBTREE_DRAIN, true);
-                node_name='imgfile')
++}
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'imgfile',
 -                          'size': size })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'imgfile',
 +                         'size': size })
      vm.shutdown()
      iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
      size = 64 * 1024 * 1024
      vm.launch()
 -    blockdev_create(vm, { 'driver': 'file',
 -                          'filename': disk_path,
 -                          'size': 0,
 -                          'preallocation': 'off',
 -                          'nocow': False })
 -
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': {
 -                              'driver': 'file',
 -                              'filename': disk_path,
 -                          },
 -                          'size': size,
 -                          'version': 'v3',
 -                          'cluster-size': 65536,
 -                          'preallocation': 'off',
 -                          'lazy-refcounts': False,
 -                          'refcount-bits': 16 })
 +    vm.blockdev_create({ 'driver': 'file',
 +                         'filename': disk_path,
 +                         'size': 0,
 +                         'preallocation': 'off',
 +                         'nocow': False })
 +
-+    vm.blockdev_create({ 'driver': imgfmt,
+ static void test_quiesce_common(enum drain_type drain_type, bool recursive)
-+                         'file': {
+ {
-+                             'driver': 'file',
+     BlockBackend *blk;
-+                             'filename': disk_path,
+@@ -XXX,XX +XXX,XX @@ static void test_quiesce_drain(void)
-+                         },
+     test_quiesce_common(BDRV_DRAIN, false);
-+                         'size': size,
+ }
-+                         'version': 'v3',
-+                         'cluster-size': 65536,
++static void test_quiesce_drain_subtree(void)
-+                         'preallocation': 'off',
++{
-+                         'lazy-refcounts': False,
++    test_quiesce_common(BDRV_SUBTREE_DRAIN, true);
-+                         'refcount-bits': 16 })
++}
      vm.shutdown()
      iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
      size = 32 * 1024 * 1024
      vm.launch()
 -    blockdev_create(vm, { 'driver': 'file',
 -                          'filename': disk_path,
 -                          'size': 0,
 -                          'preallocation': 'falloc',
 -                          'nocow': True })
 -
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': {
 -                              'driver': 'file',
 -                              'filename': disk_path,
 -                          },
 -                          'size': size,
 -                          'version': 'v3',
 -                          'cluster-size': 2097152,
 -                          'preallocation': 'metadata',
 -                          'lazy-refcounts': True,
 -                          'refcount-bits': 1 })
 +    vm.blockdev_create({ 'driver': 'file',
 +                         'filename': disk_path,
 +                         'size': 0,
 +                         'preallocation': 'falloc',
 +                         'nocow': True })
 +
-+    vm.blockdev_create({ 'driver': imgfmt,
+ static void test_nested(void)
-+                         'file': {
+ {
-+                             'driver': 'file',
+     BlockBackend *blk;
-+                             'filename': disk_path,
+@@ -XXX,XX +XXX,XX @@ static void test_nested(void)
-+                         },
+             /* XXX bdrv_drain_all() doesn't increase the quiesce_counter */
-+                         'size': size,
+             int bs_quiesce      = (outer != BDRV_DRAIN_ALL) +
-+                         'version': 'v3',
+                                   (inner != BDRV_DRAIN_ALL);
-+                         'cluster-size': 2097152,
+-            int backing_quiesce = 0;
-+                         'preallocation': 'metadata',
++            int backing_quiesce = (outer == BDRV_SUBTREE_DRAIN) +
-+                         'lazy-refcounts': True,
++                                  (inner == BDRV_SUBTREE_DRAIN);
-+                         'refcount-bits': 1 })
+             int backing_cb_cnt  = (outer != BDRV_DRAIN) +
-     vm.shutdown()
+                                   (inner != BDRV_DRAIN);
-     iotests.img_info_log(disk_path)
+@@ -XXX,XX +XXX,XX @@ static void test_blockjob_drain(void)
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
+     test_blockjob_common(BDRV_DRAIN);
-     iotests.log("")
+ }
-     vm.launch()
++static void test_blockjob_drain_subtree(void)
--    blockdev_create(vm, { 'driver': 'file',
++{
--                          'filename': disk_path,
++    test_blockjob_common(BDRV_SUBTREE_DRAIN);
--                          'size': 0 })
++}
 -
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': {
 -                              'driver': 'file',
 -                              'filename': disk_path,
 -                          },
 -                          'size': size,
 -                          'backing-file': backing_path,
 -                          'backing-fmt': 'qcow2',
 -                          'version': 'v2',
 -                          'cluster-size': 512 })
 +    vm.blockdev_create({ 'driver': 'file',
 +                         'filename': disk_path,
 +                         'size': 0 })
 +
-+    vm.blockdev_create({ 'driver': imgfmt,
+ int main(int argc, char **argv)
-+                         'file': {
+ {
-+                             'driver': 'file',
+     bdrv_init();
-+                             'filename': disk_path,
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
-+                         },
-+                         'size': size,
+     g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
-+                         'backing-file': backing_path,
+     g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
-+                         'backing-fmt': 'qcow2',
++    g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
-+                         'version': 'v2',
++                    test_drv_cb_drain_subtree);
-+                         'cluster-size': 512 })
-     vm.shutdown()
+     g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
+     g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
-     iotests.img_info_log(disk_path)
++    g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
-@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
++                    test_quiesce_drain_subtree);
-     iotests.log("")
+     g_test_add_func("/bdrv-drain/nested", test_nested);
-     vm.launch()
--    blockdev_create(vm, { 'driver': imgfmt,
+     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
--                          'file': {
+     g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
--                              'driver': 'file',
++    g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
--                              'filename': disk_path,
++                    test_blockjob_drain_subtree);
--                          },
--                          'size': size,
+     return g_test_run();
--                          'encrypt': {
+ }
 -                              'format': 'luks',
 -                              'key-secret': 'keysec0',
 -                              'cipher-alg': 'twofish-128',
 -                              'cipher-mode': 'ctr',
 -                              'ivgen-alg': 'plain64',
 -                              'ivgen-hash-alg': 'md5',
 -                              'hash-alg': 'sha1',
 -                              'iter-time': 10,
 -                          }})
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': {
 +                             'driver': 'file',
 +                             'filename': disk_path,
 +                         },
 +                         'size': size,
 +                         'encrypt': {
 +                             'format': 'luks',
 +                             'key-secret': 'keysec0',
 +                             'cipher-alg': 'twofish-128',
 +                             'cipher-mode': 'ctr',
 +                             'ivgen-alg': 'plain64',
 +                             'ivgen-hash-alg': 'md5',
 +                             'hash-alg': 'sha1',
 +                             'iter-time': 10,
 +                         }})
      vm.shutdown()
      iotests.img_info_log(disk_path)
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
      iotests.log("")
      vm.launch()
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': "this doesn't exist",
 -                          'size': size })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': "this doesn't exist",
 +                         'size': size })
      vm.shutdown()
      #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
      vm.launch()
      for size in [ 1234, 18446744073709551104, 9223372036854775808,
                    9223372036854775296 ]:
 -        blockdev_create(vm, { 'driver': imgfmt,
 -                              'file': 'node0',
 -                              'size': size })
 +        vm.blockdev_create({ 'driver': imgfmt,
 +                             'file': 'node0',
 +                             'size': size })
      vm.shutdown()
      #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
      iotests.log("=== Invalid version ===")
      vm.launch()
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': 67108864,
 -                          'version': 'v1' })
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': 67108864,
 -                          'version': 'v2',
 -                          'lazy-refcounts': True })
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': 67108864,
 -                          'version': 'v2',
 -                          'refcount-bits': 8 })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': 67108864,
 +                         'version': 'v1' })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': 67108864,
 +                         'version': 'v2',
 +                         'lazy-refcounts': True })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': 67108864,
 +                         'version': 'v2',
 +                         'refcount-bits': 8 })
      vm.shutdown()
      #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
      iotests.log("=== Invalid backing file options ===")
      vm.launch()
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': 67108864,
 -                          'backing-file': '/dev/null',
 -                          'preallocation': 'full' })
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': 67108864,
 -                          'backing-fmt': imgfmt })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': 67108864,
 +                         'backing-file': '/dev/null',
 +                         'preallocation': 'full' })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': 67108864,
 +                         'backing-fmt': imgfmt })
      vm.shutdown()
      #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
      vm.launch()
      for csize in [ 1234, 128, 4194304, 0 ]:
 -        blockdev_create(vm, { 'driver': imgfmt,
 -                              'file': 'node0',
 -                              'size': 67108864,
 -                              'cluster-size': csize })
 -    blockdev_create(vm, { 'driver': imgfmt,
 -                          'file': 'node0',
 -                          'size': 281474976710656,
 -                          'cluster-size': 512 })
 +        vm.blockdev_create({ 'driver': imgfmt,
 +                             'file': 'node0',
 +                             'size': 67108864,
 +                             'cluster-size': csize })
 +    vm.blockdev_create({ 'driver': imgfmt,
 +                         'file': 'node0',
 +                         'size': 281474976710656,
 +                         'cluster-size': 512 })
      vm.shutdown()
      #
@@ -XXX,XX +XXX,XX @@ with iotests.FilePath('t.qcow2') as disk_path, \
      vm.launch()
      for refcount_bits in [ 128, 0, 7 ]:
 -        blockdev_create(vm, { 'driver': imgfmt,
 -                              'file': 'node0',
 -                              'size': 67108864,
 -                              'refcount-bits': refcount_bits })
 +        vm.blockdev_create({ 'driver': imgfmt,
 +                             'file': 'node0',
 +                             'size': 67108864,
 +                             'refcount-bits': refcount_bits })
      vm.shutdown()
 --
-.20.1
+.13.6

-[PULL 19/30] iotests: 255: Drop blockdev_create()
+[Qemu-devel] [PULL v3 30/35] test-bdrv-drain: Test behaviour in coroutine context
-blockdev_create() is completely unused in this test case, so we can just
+If bdrv_do_drained_begin/end() are called in coroutine context, they
-drop it.
+first use a BH to get out of the coroutine context. Call some existing
 tests again from a coroutine to cover this code path.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/255 | 10 ----------
+ tests/test-bdrv-drain.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++
-file changed, 10 deletions(-)
+file changed, 59 insertions(+)
-diff --git a/tests/qemu-iotests/255 b/tests/qemu-iotests/255
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/255
+--- a/tests/test-bdrv-drain.c
-+++ b/tests/qemu-iotests/255
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ from iotests import imgfmt
+@@ -XXX,XX +XXX,XX @@ static void aio_ret_cb(void *opaque, int ret)
+     *aio_ret = ret;
- iotests.verify_image_format(supported_fmts=['qcow2'])
+ }
--def blockdev_create(vm, options):
++typedef struct CallInCoroutineData {
--    result = vm.qmp_log('blockdev-create',
++    void (*entry)(void);
--                        filters=[iotests.filter_qmp_testfiles],
++    bool done;
--                        job_id='job0', options=options)
++} CallInCoroutineData;
--
++
--    if 'return' in result:
++static coroutine_fn void call_in_coroutine_entry(void *opaque)
--        assert result['return'] == {}
++{
--        vm.run_job('job0')
++    CallInCoroutineData *data = opaque;
--    iotests.log("")
++
--
++    data->entry();
- iotests.log('Finishing a commit job with background reads')
++    data->done = true;
- iotests.log('============================================')
++}
- iotests.log('')
++
 +static void call_in_coroutine(void (*entry)(void))
 +{
 +    Coroutine *co;
 +    CallInCoroutineData data = {
 +        .entry  = entry,
 +        .done   = false,
 +    };
 +
 +    co = qemu_coroutine_create(call_in_coroutine_entry, &data);
 +    qemu_coroutine_enter(co);
 +    while (!data.done) {
 +        aio_poll(qemu_get_aio_context(), true);
 +    }
 +}
 +
  enum drain_type {
      BDRV_DRAIN_ALL,
      BDRV_DRAIN,
@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_drain_subtree(void)
      test_drv_cb_common(BDRV_SUBTREE_DRAIN, true);
  }
 +static void test_drv_cb_co_drain(void)
 +{
 +    call_in_coroutine(test_drv_cb_drain);
 +}
 +
 +static void test_drv_cb_co_drain_subtree(void)
 +{
 +    call_in_coroutine(test_drv_cb_drain_subtree);
 +}
 +
  static void test_quiesce_common(enum drain_type drain_type, bool recursive)
  {
      BlockBackend *blk;
@@ -XXX,XX +XXX,XX @@ static void test_quiesce_drain_subtree(void)
      test_quiesce_common(BDRV_SUBTREE_DRAIN, true);
  }
 +static void test_quiesce_co_drain(void)
 +{
 +    call_in_coroutine(test_quiesce_drain);
 +}
 +
 +static void test_quiesce_co_drain_subtree(void)
 +{
 +    call_in_coroutine(test_quiesce_drain_subtree);
 +}
 +
  static void test_nested(void)
  {
      BlockBackend *blk;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
      g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
                      test_drv_cb_drain_subtree);
 +    // XXX bdrv_drain_all() doesn't work in coroutine context
 +    g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain);
 +    g_test_add_func("/bdrv-drain/driver-cb/co/drain_subtree",
 +                    test_drv_cb_co_drain_subtree);
 +
 +
      g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
      g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
      g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
                      test_quiesce_drain_subtree);
 +    // XXX bdrv_drain_all() doesn't work in coroutine context
 +    g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain);
 +    g_test_add_func("/bdrv-drain/quiesce/co/drain_subtree",
 +                    test_quiesce_co_drain_subtree);
 +
      g_test_add_func("/bdrv-drain/nested", test_nested);
      g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
 --
-.20.1
+.13.6

-[PULL 18/30] iotests: Create VM.blockdev_create()
+[Qemu-devel] [PULL v3 31/35] test-bdrv-drain: Recursive draining with multiple parents
-We have several almost identical copies of a blockdev_create() function
+Test that drain sections are correctly propagated through the graph.
 in different test cases. Time to create one unified function in
 iotests.py.
 To keep the diff managable, this patch only creates the function and
 follow-up patches will convert the individual test cases.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/iotests.py | 16 ++++++++++++++++
+ tests/test-bdrv-drain.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++++
-file changed, 16 insertions(+)
+file changed, 74 insertions(+)
-diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/iotests.py
+--- a/tests/test-bdrv-drain.c
-+++ b/tests/qemu-iotests/iotests.py
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
+@@ -XXX,XX +XXX,XX @@ static void test_nested(void)
-             elif status == 'null':
+     blk_unref(blk);
-                 return error
+ }
-+    # Returns None on success, and an error string on failure
++static void test_multiparent(void)
-+    def blockdev_create(self, options, job_id='job0', filters=None):
++{
-+        if filters is None:
++    BlockBackend *blk_a, *blk_b;
-+            filters = [filter_qmp_testfiles]
++    BlockDriverState *bs_a, *bs_b, *backing;
-+        result = self.qmp_log('blockdev-create', filters=filters,
++    BDRVTestState *a_s, *b_s, *backing_s;
 +                              job_id=job_id, options=options)
 +
-+        if 'return' in result:
++    blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
-+            assert result['return'] == {}
++    bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
-+            job_result = self.run_job(job_id)
++                                &error_abort);
-+        else:
++    a_s = bs_a->opaque;
-+            job_result = result['error']
++    blk_insert_bs(blk_a, bs_a, &error_abort);
 +
-+        log("")
++    blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
-+        return job_result
++    bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
 +                                &error_abort);
 +    b_s = bs_b->opaque;
 +    blk_insert_bs(blk_b, bs_b, &error_abort);
 +
-     def enable_migration_events(self, name):
++    backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
-         log('Enabling migration QMP events on %s...' % name)
++    backing_s = backing->opaque;
-         log(self.qmp('migrate-set-capabilities', capabilities=[
++    bdrv_set_backing_hd(bs_a, backing, &error_abort);
 +    bdrv_set_backing_hd(bs_b, backing, &error_abort);
 +
 +    g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 +    g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 +    g_assert_cmpint(backing->quiesce_counter, ==, 0);
 +    g_assert_cmpint(a_s->drain_count, ==, 0);
 +    g_assert_cmpint(b_s->drain_count, ==, 0);
 +    g_assert_cmpint(backing_s->drain_count, ==, 0);
 +
 +    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 +
 +    g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 +    g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 +    g_assert_cmpint(backing->quiesce_counter, ==, 1);
 +    g_assert_cmpint(a_s->drain_count, ==, 1);
 +    g_assert_cmpint(b_s->drain_count, ==, 1);
 +    g_assert_cmpint(backing_s->drain_count, ==, 1);
 +
 +    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 +
 +    g_assert_cmpint(bs_a->quiesce_counter, ==, 2);
 +    g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
 +    g_assert_cmpint(backing->quiesce_counter, ==, 2);
 +    g_assert_cmpint(a_s->drain_count, ==, 2);
 +    g_assert_cmpint(b_s->drain_count, ==, 2);
 +    g_assert_cmpint(backing_s->drain_count, ==, 2);
 +
 +    do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 +
 +    g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
 +    g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
 +    g_assert_cmpint(backing->quiesce_counter, ==, 1);
 +    g_assert_cmpint(a_s->drain_count, ==, 1);
 +    g_assert_cmpint(b_s->drain_count, ==, 1);
 +    g_assert_cmpint(backing_s->drain_count, ==, 1);
 +
 +    do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 +
 +    g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 +    g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 +    g_assert_cmpint(backing->quiesce_counter, ==, 0);
 +    g_assert_cmpint(a_s->drain_count, ==, 0);
 +    g_assert_cmpint(b_s->drain_count, ==, 0);
 +    g_assert_cmpint(backing_s->drain_count, ==, 0);
 +
 +    bdrv_unref(backing);
 +    bdrv_unref(bs_a);
 +    bdrv_unref(bs_b);
 +    blk_unref(blk_a);
 +    blk_unref(blk_b);
 +}
 +
  typedef struct TestBlockJob {
      BlockJob common;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
                      test_quiesce_co_drain_subtree);
      g_test_add_func("/bdrv-drain/nested", test_nested);
 +    g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
      g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
      g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
 --
-.20.1
+.13.6

-New patch
+[Qemu-devel] [PULL v3 32/35] block: Allow graph changes in subtree drained section
+We need to remember how many of the drain sections in which a node is
 were recursive (i.e. subtree drain rather than node drain), so that they
 can be correctly applied when children are added or removed during the
 drained section.
 With this change, it is safe to modify the graph even inside a
 bdrv_subtree_drained_begin/end() section.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
  include/block/block.h     |  2 --
  include/block/block_int.h |  5 +++++
  block.c                   | 32 +++++++++++++++++++++++++++++---
  block/io.c                | 28 ++++++++++++++++++++++++----
 files changed, 58 insertions(+), 9 deletions(-)
 diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block.h
 +++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs);
  /**
   * Like bdrv_drained_begin, but recursively begins a quiesced section for
   * exclusive access to all child nodes as well.
 - *
 - * Graph changes are not allowed during a subtree drain section.
   */
  void bdrv_subtree_drained_begin(BlockDriverState *bs);
 diff --git a/include/block/block_int.h b/include/block/block_int.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block_int.h
 +++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
      /* Accessed with atomic ops.  */
      int quiesce_counter;
 +    int recursive_quiesce_counter;
 +
      unsigned int write_gen;               /* Current data generation */
      /* Protected by reqs_lock.  */
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
      int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
      BdrvRequestFlags flags);
 +void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent);
 +void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent);
 +
  int get_tmp_filename(char *filename, int size);
  BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
                              const char *filename);
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_child_cb_drained_end(BdrvChild *child)
      bdrv_drained_end(bs);
  }
 +static void bdrv_child_cb_attach(BdrvChild *child)
 +{
 +    BlockDriverState *bs = child->opaque;
 +    bdrv_apply_subtree_drain(child, bs);
 +}
 +
 +static void bdrv_child_cb_detach(BdrvChild *child)
 +{
 +    BlockDriverState *bs = child->opaque;
 +    bdrv_unapply_subtree_drain(child, bs);
 +}
 +
  static int bdrv_child_cb_inactivate(BdrvChild *child)
  {
      BlockDriverState *bs = child->opaque;
@@ -XXX,XX +XXX,XX @@ const BdrvChildRole child_file = {
      .inherit_options = bdrv_inherited_options,
      .drained_begin   = bdrv_child_cb_drained_begin,
      .drained_end     = bdrv_child_cb_drained_end,
 +    .attach          = bdrv_child_cb_attach,
 +    .detach          = bdrv_child_cb_detach,
      .inactivate      = bdrv_child_cb_inactivate,
  };
@@ -XXX,XX +XXX,XX @@ const BdrvChildRole child_format = {
      .inherit_options = bdrv_inherited_fmt_options,
      .drained_begin   = bdrv_child_cb_drained_begin,
      .drained_end     = bdrv_child_cb_drained_end,
 +    .attach          = bdrv_child_cb_attach,
 +    .detach          = bdrv_child_cb_detach,
      .inactivate      = bdrv_child_cb_inactivate,
  };
@@ -XXX,XX +XXX,XX @@ static void bdrv_backing_attach(BdrvChild *c)
                      parent->backing_blocker);
      bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
                      parent->backing_blocker);
 +
 +    bdrv_child_cb_attach(c);
  }
  static void bdrv_backing_detach(BdrvChild *c)
@@ -XXX,XX +XXX,XX @@ static void bdrv_backing_detach(BdrvChild *c)
      bdrv_op_unblock_all(c->bs, parent->backing_blocker);
      error_free(parent->backing_blocker);
      parent->backing_blocker = NULL;
 +
 +    bdrv_child_cb_detach(c);
  }
  /*
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
          assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
      }
      if (old_bs) {
 +        /* Detach first so that the recursive drain sections coming from @child
 +         * are already gone and we only end the drain sections that came from
 +         * elsewhere. */
 +        if (child->role->detach) {
 +            child->role->detach(child);
 +        }
          if (old_bs->quiesce_counter && child->role->drained_end) {
              for (i = 0; i < old_bs->quiesce_counter; i++) {
                  child->role->drained_end(child);
              }
          }
 -        if (child->role->detach) {
 -            child->role->detach(child);
 -        }
          QLIST_REMOVE(child, next_parent);
      }
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
              }
          }
 +        /* Attach only after starting new drained sections, so that recursive
 +         * drain sections coming from @child don't get an extra .drained_begin
 +         * callback. */
          if (child->role->attach) {
              child->role->attach(child);
          }
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
      assert(data.done);
  }
 -static void bdrv_do_drained_begin(BlockDriverState *bs, bool recursive,
 -                                  BdrvChild *parent)
 +void bdrv_do_drained_begin(BlockDriverState *bs, bool recursive,
 +                           BdrvChild *parent)
  {
      BdrvChild *child, *next;
@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_begin(BlockDriverState *bs, bool recursive,
      bdrv_drain_recurse(bs);
      if (recursive) {
 +        bs->recursive_quiesce_counter++;
          QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
              bdrv_do_drained_begin(child->bs, true, child);
          }
@@ -XXX,XX +XXX,XX @@ void bdrv_subtree_drained_begin(BlockDriverState *bs)
      bdrv_do_drained_begin(bs, true, NULL);
  }
 -static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
 -                                BdrvChild *parent)
 +void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
 +                         BdrvChild *parent)
  {
      BdrvChild *child, *next;
      int old_quiesce_counter;
@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
      }
      if (recursive) {
 +        bs->recursive_quiesce_counter--;
          QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
              bdrv_do_drained_end(child->bs, true, child);
          }
@@ -XXX,XX +XXX,XX @@ void bdrv_subtree_drained_end(BlockDriverState *bs)
      bdrv_do_drained_end(bs, true, NULL);
  }
 +void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent)
 +{
 +    int i;
 +
 +    for (i = 0; i < new_parent->recursive_quiesce_counter; i++) {
 +        bdrv_do_drained_begin(child->bs, true, child);
 +    }
 +}
 +
 +void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent)
 +{
 +    int i;
 +
 +    for (i = 0; i < old_parent->recursive_quiesce_counter; i++) {
 +        bdrv_do_drained_end(child->bs, true, child);
 +    }
 +}
 +
  /*
   * Wait for pending requests to complete on a single BlockDriverState subtree,
   * and suspend block driver's internal I/O until next request arrives.
 --
 .13.6

-[PULL 05/30] qemu-img: fix info --backing-chain --image-opts
+[Qemu-devel] [PULL v3 33/35] test-bdrv-drain: Test graph changes in drained section
-From: Stefan Hajnoczi <stefanha@redhat.com>
-Only apply --image-opts to the topmost image when listing an entire
-backing chain.  It is incorrect to treat backing filenames as image
-options.  Assuming we have the backing chain t.IMGFMT.base <-
-t.IMGFMT.mid <- t.IMGFMT, qemu-img info fails as follows:
-  $ qemu-img info --backing-chain --image-opts \
-      driver=qcow2,file.driver=file,file.filename=t.IMGFMT
-  qemu-img: Could not open 'TEST_DIR/t.IMGFMT.mid': Cannot find device=TEST_DIR/t.IMGFMT.mid nor node_name=TEST_DIR/t.IMGFMT.mid
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qemu-img.c                 |  3 ++
+ tests/test-bdrv-drain.c | 80 +++++++++++++++++++++++++++++++++++++++++++++++++
- tests/qemu-iotests/279     | 57 ++++++++++++++++++++++++++++++++++++++
+file changed, 80 insertions(+)
  tests/qemu-iotests/279.out | 35 +++++++++++++++++++++++
  tests/qemu-iotests/group   |  1 +
 files changed, 96 insertions(+)
  create mode 100755 tests/qemu-iotests/279
  create mode 100644 tests/qemu-iotests/279.out
-diff --git a/qemu-img.c b/qemu-img.c
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
---- a/qemu-img.c
+--- a/tests/test-bdrv-drain.c
-+++ b/qemu-img.c
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ static ImageInfoList *collect_image_info_list(bool image_opts,
+@@ -XXX,XX +XXX,XX @@ static void test_multiparent(void)
+     blk_unref(blk_b);
-         blk_unref(blk);
+ }
-+        /* Clear parameters that only apply to the topmost image */
++static void test_graph_change(void)
-         filename = fmt = NULL;
++{
-+        image_opts = false;
++    BlockBackend *blk_a, *blk_b;
 +    BlockDriverState *bs_a, *bs_b, *backing;
 +    BDRVTestState *a_s, *b_s, *backing_s;
 +
-         if (chain) {
++    blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
-             if (info->has_full_backing_filename) {
++    bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
-                 filename = info->full_backing_filename;
++                                &error_abort);
-diff --git a/tests/qemu-iotests/279 b/tests/qemu-iotests/279
++    a_s = bs_a->opaque;
-new file mode 100755
++    blk_insert_bs(blk_a, bs_a, &error_abort);
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/279
@@ -XXX,XX +XXX,XX @@
 +#!/usr/bin/env bash
 +#
 +# Test qemu-img --backing-chain --image-opts
 +#
 +# Copyright (C) 2019 Red Hat, Inc.
 +#
 +# This program is free software; you can redistribute it and/or modify
 +# it under the terms of the GNU General Public License as published by
 +# the Free Software Foundation; either version 2 of the License, or
 +# (at your option) any later version.
 +#
 +# This program is distributed in the hope that it will be useful,
 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +# GNU General Public License for more details.
 +#
 +# You should have received a copy of the GNU General Public License
 +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 +#
 +
-+seq=$(basename "$0")
++    blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
-+echo "QA output created by $seq"
++    bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
 +                                &error_abort);
 +    b_s = bs_b->opaque;
 +    blk_insert_bs(blk_b, bs_b, &error_abort);
 +
-+status=1    # failure is the default!
++    backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
 +    backing_s = backing->opaque;
 +    bdrv_set_backing_hd(bs_a, backing, &error_abort);
 +
-+_cleanup()
++    g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
-+{
++    g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
-+    _cleanup_test_img
++    g_assert_cmpint(backing->quiesce_counter, ==, 0);
-+    rm -f "$TEST_IMG.mid"
++    g_assert_cmpint(a_s->drain_count, ==, 0);
 +    g_assert_cmpint(b_s->drain_count, ==, 0);
 +    g_assert_cmpint(backing_s->drain_count, ==, 0);
 +
 +    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 +    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 +    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
 +    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 +    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
 +
 +    bdrv_set_backing_hd(bs_b, backing, &error_abort);
 +    g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
 +    g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
 +    g_assert_cmpint(backing->quiesce_counter, ==, 5);
 +    g_assert_cmpint(a_s->drain_count, ==, 5);
 +    g_assert_cmpint(b_s->drain_count, ==, 5);
 +    g_assert_cmpint(backing_s->drain_count, ==, 5);
 +
 +    bdrv_set_backing_hd(bs_b, NULL, &error_abort);
 +    g_assert_cmpint(bs_a->quiesce_counter, ==, 3);
 +    g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
 +    g_assert_cmpint(backing->quiesce_counter, ==, 3);
 +    g_assert_cmpint(a_s->drain_count, ==, 3);
 +    g_assert_cmpint(b_s->drain_count, ==, 2);
 +    g_assert_cmpint(backing_s->drain_count, ==, 3);
 +
 +    bdrv_set_backing_hd(bs_b, backing, &error_abort);
 +    g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
 +    g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
 +    g_assert_cmpint(backing->quiesce_counter, ==, 5);
 +    g_assert_cmpint(a_s->drain_count, ==, 5);
 +    g_assert_cmpint(b_s->drain_count, ==, 5);
 +    g_assert_cmpint(backing_s->drain_count, ==, 5);
 +
 +    do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 +    do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
 +    do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 +    do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 +    do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
 +
 +    g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
 +    g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
 +    g_assert_cmpint(backing->quiesce_counter, ==, 0);
 +    g_assert_cmpint(a_s->drain_count, ==, 0);
 +    g_assert_cmpint(b_s->drain_count, ==, 0);
 +    g_assert_cmpint(backing_s->drain_count, ==, 0);
 +
 +    bdrv_unref(backing);
 +    bdrv_unref(bs_a);
 +    bdrv_unref(bs_b);
 +    blk_unref(blk_a);
 +    blk_unref(blk_b);
 +}
-+trap "_cleanup; exit \$status" 0 1 2 3 15
 +
-+# get standard environment, filters and checks
-+. ./common.rc
+ typedef struct TestBlockJob {
-+. ./common.filter
+     BlockJob common;
-+
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
-+# Backing files are required...
-+_supported_fmt qcow qcow2 vmdk qed
+     g_test_add_func("/bdrv-drain/nested", test_nested);
-+_supported_proto file
+     g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
-+_supported_os Linux
++    g_test_add_func("/bdrv-drain/graph-change", test_graph_change);
-+
-+TEST_IMG="$TEST_IMG.base" _make_test_img 64M
+     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
-+TEST_IMG="$TEST_IMG.mid" _make_test_img -b "$TEST_IMG.base"
+     g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
 +_make_test_img -b "$TEST_IMG.mid"
 +
 +echo
 +echo '== qemu-img info --backing-chain =='
 +_img_info --backing-chain | _filter_img_info
 +
 +echo
 +echo '== qemu-img info --backing-chain --image-opts =='
 +TEST_IMG="driver=qcow2,file.driver=file,file.filename=$TEST_IMG" _img_info --backing-chain --image-opts | _filter_img_info
 +
 +# success, all done
 +echo "*** done"
 +rm -f $seq.full
 +status=0
 diff --git a/tests/qemu-iotests/279.out b/tests/qemu-iotests/279.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/279.out
@@ -XXX,XX +XXX,XX @@
 +QA output created by 279
 +Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864
 +Formatting 'TEST_DIR/t.IMGFMT.mid', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.base
 +Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.mid
 +
 +== qemu-img info --backing-chain ==
 +image: TEST_DIR/t.IMGFMT
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +backing file: TEST_DIR/t.IMGFMT.mid
 +
 +image: TEST_DIR/t.IMGFMT.mid
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +backing file: TEST_DIR/t.IMGFMT.base
 +
 +image: TEST_DIR/t.IMGFMT.base
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +
 +== qemu-img info --backing-chain --image-opts ==
 +image: TEST_DIR/t.IMGFMT
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +backing file: TEST_DIR/t.IMGFMT.mid
 +
 +image: TEST_DIR/t.IMGFMT.mid
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +backing file: TEST_DIR/t.IMGFMT.base
 +
 +image: TEST_DIR/t.IMGFMT.base
 +file format: IMGFMT
 +virtual size: 64 MiB (67108864 bytes)
 +*** done
 diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/group
 +++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 rw
 backing quick
 rw quick
 +279 rw backing quick
 --
-.20.1
+.13.6

-[PULL 26/30] iotests: 207: Remove duplication with VM.blockdev_create()
+[Qemu-devel] [PULL v3 34/35] commit: Simplify reopen of base
-The blockdev_create() function in this test case adds another filter to
+Since commit bde70715, base is the only node that is reopened in
-the logging, but provides otherwise the same functionality as
+commit_start(). This means that the code, which still involves an
-VM.blockdev_create() from iotests.py. Make it a thin wrapper around the
+explicit BlockReopenQueue, can now be simplified by using bdrv_reopen().
 iotests.py function.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Fam Zheng <famz@redhat.com>
 ---
- tests/qemu-iotests/207 | 8 +-------
+ block/commit.c | 8 +-------
 file changed, 1 insertion(+), 7 deletions(-)
-diff --git a/tests/qemu-iotests/207 b/tests/qemu-iotests/207
+diff --git a/block/commit.c b/block/commit.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/207
+--- a/block/commit.c
-+++ b/tests/qemu-iotests/207
++++ b/block/commit.c
-@@ -XXX,XX +XXX,XX @@ def filter_hash(qmsg):
+@@ -XXX,XX +XXX,XX @@ void commit_start(const char *job_id, BlockDriverState *bs,
-     return iotests.filter_qmp(qmsg, _filter)
+                   const char *filter_node_name, Error **errp)
+ {
- def blockdev_create(vm, options):
+     CommitBlockJob *s;
--    result = vm.qmp_log('blockdev-create', job_id='job0', options=options,
+-    BlockReopenQueue *reopen_queue = NULL;
--                        filters=[iotests.filter_qmp_testfiles, filter_hash])
+     int orig_base_flags;
      BlockDriverState *iter;
      BlockDriverState *commit_top_bs = NULL;
@@ -XXX,XX +XXX,XX @@ void commit_start(const char *job_id, BlockDriverState *bs,
      /* convert base to r/w, if necessary */
      orig_base_flags = bdrv_get_flags(base);
      if (!(orig_base_flags & BDRV_O_RDWR)) {
 -        reopen_queue = bdrv_reopen_queue(reopen_queue, base, NULL,
 -                                         orig_base_flags | BDRV_O_RDWR);
 -    }
 -
--    if 'return' in result:
+-    if (reopen_queue) {
--        assert result['return'] == {}
+-        bdrv_reopen_multiple(bdrv_get_aio_context(bs), reopen_queue, &local_err);
--        vm.run_job('job0')
++        bdrv_reopen(base, orig_base_flags | BDRV_O_RDWR, &local_err);
--    iotests.log("")
+         if (local_err != NULL) {
-+    vm.blockdev_create(options, filters=[iotests.filter_qmp_testfiles, filter_hash])
+             error_propagate(errp, local_err);
+             goto fail;
  with iotests.FilePath('t.img') as disk_path, \
       iotests.VM() as vm:
 --
-.20.1
+.13.6

-[PULL 06/30] block: Error out on image creation with conflicting size options
+[Qemu-devel] [PULL v3 35/35] block: Keep nodes drained between reopen_queue/multiple
-If both the create options (qemu-img create -o ...) and the size
+The bdrv_reopen*() implementation doesn't like it if the graph is
-parameter were given, the size parameter was silently ignored. Instead,
+changed between queuing nodes for reopen and actually reopening them
-make specifying two sizes an error.
+(one of the reasons is that queuing can be recursive).
 So instead of draining the device only in bdrv_reopen_multiple(),
 require that callers already drained all affected nodes, and assert this
 in bdrv_reopen_queue().
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Fam Zheng <famz@redhat.com>
 ---
- block.c                    | 10 ++++++++--
+ block.c             | 23 ++++++++++++++++-------
- tests/qemu-iotests/049     |  5 +++++
+ block/replication.c |  6 ++++++
- tests/qemu-iotests/049.out |  5 +++++
+ qemu-io-cmds.c      |  3 +++
-files changed, 18 insertions(+), 2 deletions(-)
+files changed, 25 insertions(+), 7 deletions(-)
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
-@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,
+@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_open(const char *filename, const char *reference,
-         return;
+  * returns a pointer to bs_queue, which is either the newly allocated
   * bs_queue, or the existing bs_queue being used.
   *
 + * bs must be drained between bdrv_reopen_queue() and bdrv_reopen_multiple().
   */
  static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
                                                   BlockDriverState *bs,
@@ -XXX,XX +XXX,XX @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
      BdrvChild *child;
      QDict *old_options, *explicit_options;
 +    /* Make sure that the caller remembered to use a drained section. This is
 +     * important to avoid graph changes between the recursive queuing here and
 +     * bdrv_reopen_multiple(). */
 +    assert(bs->quiesce_counter > 0);
 +
      if (bs_queue == NULL) {
          bs_queue = g_new0(BlockReopenQueue, 1);
          QSIMPLEQ_INIT(bs_queue);
@@ -XXX,XX +XXX,XX @@ BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
   * If all devices prepare successfully, then the changes are committed
   * to all devices.
   *
 + * All affected nodes must be drained between bdrv_reopen_queue() and
 + * bdrv_reopen_multiple().
   */
  int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp)
  {
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **er
      assert(bs_queue != NULL);
 -    aio_context_release(ctx);
 -    bdrv_drain_all_begin();
 -    aio_context_acquire(ctx);
 -
      QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
 +        assert(bs_entry->state.bs->quiesce_counter > 0);
          if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
              error_propagate(errp, local_err);
              goto cleanup;
@@ -XXX,XX +XXX,XX @@ cleanup:
      }
+     g_free(bs_queue);
-+    /* Create parameter list */
-     create_opts = qemu_opts_append(create_opts, drv->create_opts);
+-    bdrv_drain_all_end();
-     create_opts = qemu_opts_append(create_opts, proto_drv->create_opts);
+-
+     return ret;
--    /* Create parameter list with default values */
+ }
-     opts = qemu_opts_create(create_opts, NULL, 0, &error_abort);
--    qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
+@@ -XXX,XX +XXX,XX @@ int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
+ {
-     /* Parse -o options */
+     int ret = -1;
-     if (options) {
+     Error *local_err = NULL;
-@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,
+-    BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
-         }
++    BlockReopenQueue *queue;
 +    bdrv_subtree_drained_begin(bs);
 +
 +    queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
      ret = bdrv_reopen_multiple(bdrv_get_aio_context(bs), queue, &local_err);
      if (local_err != NULL) {
          error_propagate(errp, local_err);
      }
-+    if (!qemu_opt_get(opts, BLOCK_OPT_SIZE)) {
-+        qemu_opt_set_number(opts, BLOCK_OPT_SIZE, img_size, &error_abort);
-+    } else if (img_size != UINT64_C(-1)) {
-+        error_setg(errp, "The image size must be specified only once");
-+        goto out;
-+    }
 +
-     if (base_filename) {
++    bdrv_subtree_drained_end(bs);
          qemu_opt_set(opts, BLOCK_OPT_BACKING_FILE, base_filename, &local_err);
          if (local_err) {
 diff --git a/tests/qemu-iotests/049 b/tests/qemu-iotests/049
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/049
 +++ b/tests/qemu-iotests/049
@@ -XXX,XX +XXX,XX @@ for s in $sizes; do
      test_qemu_img create -f $IMGFMT -o size=$s "$TEST_IMG"
  done
 +echo "== 4. Specify size twice (-o and traditional parameter) =="
 +echo
 +
-+test_qemu_img create -f $IMGFMT -o size=10M "$TEST_IMG" 20M
+     return ret;
  }
 diff --git a/block/replication.c b/block/replication.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/replication.c
 +++ b/block/replication.c
@@ -XXX,XX +XXX,XX @@ static void reopen_backing_file(BlockDriverState *bs, bool writable,
          new_secondary_flags = s->orig_secondary_flags;
      }
 +    bdrv_subtree_drained_begin(s->hidden_disk->bs);
 +    bdrv_subtree_drained_begin(s->secondary_disk->bs);
 +
- echo "== Check correct interpretation of suffixes for cluster size =="
+     if (orig_hidden_flags != new_hidden_flags) {
- echo
+         reopen_queue = bdrv_reopen_queue(reopen_queue, s->hidden_disk->bs, NULL,
- sizes="1024 1024b 1k 1K 1M "
+                                          new_hidden_flags);
-diff --git a/tests/qemu-iotests/049.out b/tests/qemu-iotests/049.out
+@@ -XXX,XX +XXX,XX @@ static void reopen_backing_file(BlockDriverState *bs, bool writable,
                               reopen_queue, &local_err);
          error_propagate(errp, local_err);
      }
 +
 +    bdrv_subtree_drained_end(s->hidden_disk->bs);
 +    bdrv_subtree_drained_end(s->secondary_disk->bs);
  }
  static void backup_job_cleanup(BlockDriverState *bs)
 diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/049.out
+--- a/qemu-io-cmds.c
-+++ b/tests/qemu-iotests/049.out
++++ b/qemu-io-cmds.c
-@@ -XXX,XX +XXX,XX @@ qemu-img: TEST_DIR/t.qcow2: Parameter 'size' expects a non-negative number below
+@@ -XXX,XX +XXX,XX @@ static int reopen_f(BlockBackend *blk, int argc, char **argv)
- Optional suffix k, M, G, T, P or E means kilo-, mega-, giga-, tera-, peta-
+     opts = qopts ? qemu_opts_to_qdict(qopts, NULL) : NULL;
- and exabytes, respectively.
+     qemu_opts_reset(&reopen_opts);
-+== 4. Specify size twice (-o and traditional parameter) ==
++    bdrv_subtree_drained_begin(bs);
      brq = bdrv_reopen_queue(NULL, bs, opts, flags);
      bdrv_reopen_multiple(bdrv_get_aio_context(bs), brq, &local_err);
 +    bdrv_subtree_drained_end(bs);
 +
-+qemu-img create -f qcow2 -o size=10M TEST_DIR/t.qcow2 20M
+     if (local_err) {
-+qemu-img: TEST_DIR/t.qcow2: The image size must be specified only once
+         error_report_err(local_err);
-+
+     } else {
  == Check correct interpretation of suffixes for cluster size ==
  qemu-img create -f qcow2 -o cluster_size=1024 TEST_DIR/t.qcow2 64M
 --
-.20.1
+.13.6

The following changes since commit aceeaa69d28e6f08a24395d0aa6915b687d0a681:

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

are available in the Git repository at:

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

for you to fetch changes up to f62f08ab7a9d902da70078992248ec5c98f652ad:

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

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

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

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

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

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

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

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

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

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

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

From: Thomas Huth <thuth@redhat.com>

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

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

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

From: Thomas Huth <thuth@redhat.com>

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

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

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

From: Thomas Huth <thuth@redhat.com>

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

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

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

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

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

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

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #
 # Driver specific block device options for the NVMe backend.
 #
-# @device:    controller address of the NVMe device.
+# @device:    PCI controller address of the NVMe device in
+#             format hhhh:bb:ss.f (host:bus:slot.function)
 # @namespace: namespace number of the device, starting from 1.
 #
+# Note that the PCI @device must have been unbound from any host
+# kernel driver before instructing QEMU to add the blockdev.
+#
 # Since: 2.12
 ##
 { 'struct': 'BlockdevOptionsNVMe',
-- 
2.20.1

From: Stefan Hajnoczi <stefanha@redhat.com>

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

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

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

diff --git a/qemu-img.c b/qemu-img.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-img.c
+++ b/qemu-img.c
@@ -XXX,XX +XXX,XX @@ static ImageInfoList *collect_image_info_list(bool image_opts,
 
         blk_unref(blk);
 
+        /* Clear parameters that only apply to the topmost image */
         filename = fmt = NULL;
+        image_opts = false;
+
         if (chain) {
             if (info->has_full_backing_filename) {
                 filename = info->full_backing_filename;
diff --git a/tests/qemu-iotests/279 b/tests/qemu-iotests/279
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/279
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env bash
+#
+# Test qemu-img --backing-chain --image-opts
+#
+# Copyright (C) 2019 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+seq=$(basename "$0")
+echo "QA output created by $seq"
+
+status=1	# failure is the default!
+
+_cleanup()
+{
+    _cleanup_test_img
+    rm -f "$TEST_IMG.mid"
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+
+# Backing files are required...
+_supported_fmt qcow qcow2 vmdk qed
+_supported_proto file
+_supported_os Linux
+
+TEST_IMG="$TEST_IMG.base" _make_test_img 64M
+TEST_IMG="$TEST_IMG.mid" _make_test_img -b "$TEST_IMG.base"
+_make_test_img -b "$TEST_IMG.mid"
+
+echo
+echo '== qemu-img info --backing-chain =='
+_img_info --backing-chain | _filter_img_info
+
+echo
+echo '== qemu-img info --backing-chain --image-opts =='
+TEST_IMG="driver=qcow2,file.driver=file,file.filename=$TEST_IMG" _img_info --backing-chain --image-opts | _filter_img_info
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/279.out b/tests/qemu-iotests/279.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/279.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 279
+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=67108864
+Formatting 'TEST_DIR/t.IMGFMT.mid', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.base
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=67108864 backing_file=TEST_DIR/t.IMGFMT.mid
+
+== qemu-img info --backing-chain ==
+image: TEST_DIR/t.IMGFMT
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+backing file: TEST_DIR/t.IMGFMT.mid
+
+image: TEST_DIR/t.IMGFMT.mid
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+backing file: TEST_DIR/t.IMGFMT.base
+
+image: TEST_DIR/t.IMGFMT.base
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+
+== qemu-img info --backing-chain --image-opts ==
+image: TEST_DIR/t.IMGFMT
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+backing file: TEST_DIR/t.IMGFMT.mid
+
+image: TEST_DIR/t.IMGFMT.mid
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+backing file: TEST_DIR/t.IMGFMT.base
+
+image: TEST_DIR/t.IMGFMT.base
+file format: IMGFMT
+virtual size: 64 MiB (67108864 bytes)
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 272 rw
 273 backing quick
 277 rw quick
+279 rw backing quick
-- 
2.20.1

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

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

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

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

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

Make it use QERR_INVALID_PARAMETER_VALUE instead:

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

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

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

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

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

Declare the flag supported therefore.

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

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_do_open(BlockDriverState *bs, QDict *options,
         }
     }
 
-    bs->supported_zero_flags = header.version >= 3 ? BDRV_REQ_MAY_UNMAP : 0;
+    bs->supported_zero_flags = header.version >= 3 ?
+                               BDRV_REQ_MAY_UNMAP | BDRV_REQ_NO_FALLBACK : 0;
 
     /* Repair image if dirty */
     if (!(flags & (BDRV_O_CHECK | BDRV_O_INACTIVE)) && !bs->read_only &&
-- 
2.20.1

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

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

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

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

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

From: Alberto Garcia <berto@igalia.com>

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

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

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

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

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

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

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

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

From: Thomas Huth <thuth@redhat.com>

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

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

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

From: Max Reitz <mreitz@redhat.com>

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

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

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

From: Max Reitz <mreitz@redhat.com>

There is no $SOCKDIR, only $SOCK_DIR.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

diff --git a/tests/qemu-iotests/280 b/tests/qemu-iotests/280
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/280
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python
+#
+# Copyright (C) 2019 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+#
+# Test migration to file for taking an external snapshot with VM state.
+
+import iotests
+import os
+
+iotests.verify_image_format(supported_fmts=['qcow2'])
+iotests.verify_protocol(supported=['file'])
+iotests.verify_platform(['linux'])
+
+with iotests.FilePath('base') as base_path , \
+     iotests.FilePath('top') as top_path, \
+     iotests.VM() as vm:
+
+    iotests.qemu_img_log('create', '-f', iotests.imgfmt, base_path, '64M')
+
+    iotests.log('=== Launch VM ===')
+    vm.add_object('iothread,id=iothread0')
+    vm.add_blockdev('file,filename=%s,node-name=base-file' % (base_path))
+    vm.add_blockdev('%s,file=base-file,node-name=base-fmt' % (iotests.imgfmt))
+    vm.add_device('virtio-blk,drive=base-fmt,iothread=iothread0,id=vda')
+    vm.launch()
+
+    vm.enable_migration_events('VM')
+
+    iotests.log('\n=== Migrate to file ===')
+    vm.qmp_log('migrate', uri='exec:cat > /dev/null')
+
+    with iotests.Timeout(3, 'Migration does not complete'):
+        vm.wait_migration()
+
+    iotests.log('\nVM is now stopped:')
+    iotests.log(vm.qmp('query-migrate')['return']['status'])
+    vm.qmp_log('query-status')
+
+    iotests.log('\n=== Create a snapshot of the disk image ===')
+    vm.blockdev_create({
+        'driver': 'file',
+        'filename': top_path,
+        'size': 0,
+    })
+    vm.qmp_log('blockdev-add', node_name='top-file',
+               driver='file', filename=top_path,
+               filters=[iotests.filter_qmp_testfiles])
+
+    vm.blockdev_create({
+        'driver': iotests.imgfmt,
+        'file': 'top-file',
+        'size': 1024 * 1024,
+    })
+    vm.qmp_log('blockdev-add', node_name='top-fmt',
+               driver=iotests.imgfmt, file='top-file')
+
+    vm.qmp_log('blockdev-snapshot', node='base-fmt', overlay='top-fmt')
+
+    iotests.log('\n=== Resume the VM and simulate a write request ===')
+    vm.qmp_log('cont')
+    iotests.log(vm.hmp_qemu_io('-d vda/virtio-backend', 'write 4k 4k'))
+
+    iotests.log('\n=== Commit it to the backing file ===')
+    result = vm.qmp_log('block-commit', job_id='job0', auto_dismiss=False,
+                        device='top-fmt', top_node='top-fmt',
+                        filters=[iotests.filter_qmp_testfiles])
+    if 'return' in result:
+        vm.run_job('job0')
diff --git a/tests/qemu-iotests/280.out b/tests/qemu-iotests/280.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/280.out
@@ -XXX,XX +XXX,XX @@
+Formatting 'TEST_DIR/PID-base', fmt=qcow2 size=67108864 cluster_size=65536 lazy_refcounts=off refcount_bits=16
+
+=== Launch VM ===
+Enabling migration QMP events on VM...
+{"return": {}}
+
+=== Migrate to file ===
+{"execute": "migrate", "arguments": {"uri": "exec:cat > /dev/null"}}
+{"return": {}}
+{"data": {"status": "setup"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"status": "active"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"status": "completed"}, "event": "MIGRATION", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+
+VM is now stopped:
+completed
+{"execute": "query-status", "arguments": {}}
+{"return": {"running": false, "singlestep": false, "status": "postmigrate"}}
+
+=== Create a snapshot of the disk image ===
+{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "file", "filename": "TEST_DIR/PID-top", "size": 0}}}
+{"return": {}}
+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
+{"return": {}}
+
+{"execute": "blockdev-add", "arguments": {"driver": "file", "filename": "TEST_DIR/PID-top", "node-name": "top-file"}}
+{"return": {}}
+{"execute": "blockdev-create", "arguments": {"job-id": "job0", "options": {"driver": "qcow2", "file": "top-file", "size": 1048576}}}
+{"return": {}}
+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
+{"return": {}}
+
+{"execute": "blockdev-add", "arguments": {"driver": "qcow2", "file": "top-file", "node-name": "top-fmt"}}
+{"return": {}}
+{"execute": "blockdev-snapshot", "arguments": {"node": "base-fmt", "overlay": "top-fmt"}}
+{"return": {}}
+
+=== Resume the VM and simulate a write request ===
+{"execute": "cont", "arguments": {}}
+{"return": {}}
+{"return": ""}
+
+=== Commit it to the backing file ===
+{"execute": "block-commit", "arguments": {"auto-dismiss": false, "device": "top-fmt", "job-id": "job0", "top-node": "top-fmt"}}
+{"return": {}}
+{"execute": "job-complete", "arguments": {"id": "job0"}}
+{"return": {}}
+{"data": {"device": "job0", "len": 65536, "offset": 65536, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"device": "job0", "len": 65536, "offset": 65536, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"execute": "job-dismiss", "arguments": {"id": "job0"}}
+{"return": {}}
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 273 backing quick
 277 rw quick
 279 rw backing quick
+280 rw migration quick
-- 
2.20.1

The following changes since commit 281f327487c9c9b1599f93c589a408bbf4a651b8:

Merge remote-tracking branch 'remotes/vivier/tags/m68k-for-2.12-pull-request' into staging (2017-12-22 00:11:36 +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 1a63a907507fbbcfaee3f622907ec244b7eabda8:

block: Keep nodes drained between reopen_queue/multiple (2017-12-22 15:05:32 +0100)

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

----------------------------------------------------------------
Doug Gale (1):
      nvme: Add tracing

Edgar Kaziakhmedov (1):
      qcow2: get rid of qcow2_backing_read1 routine

Fam Zheng (2):
      block: Open backing image in force share mode for size probe
      block: Remove unused bdrv_requests_pending

John Snow (1):
      iotests: fix 197 for vpc

Kevin Wolf (27):
      block: Formats don't need CONSISTENT_READ with NO_IO
      block: Make bdrv_drain_invoke() recursive
      block: Call .drain_begin only once in bdrv_drain_all_begin()
      test-bdrv-drain: Test BlockDriver callbacks for drain
      block: bdrv_drain_recurse(): Remove unused begin parameter
      block: Don't wait for requests in bdrv_drain*_end()
      block: Unify order in drain functions
      block: Don't acquire AioContext in hmp_qemu_io()
      block: Document that x-blockdev-change breaks quorum children list
      block: Assert drain_all is only called from main AioContext
      block: Make bdrv_drain() driver callbacks non-recursive
      test-bdrv-drain: Test callback for bdrv_drain
      test-bdrv-drain: Test bs->quiesce_counter
      blockjob: Pause job on draining any job BDS
      test-bdrv-drain: Test drain vs. block jobs
      block: Don't block_job_pause_all() in bdrv_drain_all()
      block: Nested drain_end must still call callbacks
      test-bdrv-drain: Test nested drain sections
      block: Don't notify parents in drain call chain
      block: Add bdrv_subtree_drained_begin/end()
      test-bdrv-drain: Tests for bdrv_subtree_drain
      test-bdrv-drain: Test behaviour in coroutine context
      test-bdrv-drain: Recursive draining with multiple parents
      block: Allow graph changes in subtree drained section
      test-bdrv-drain: Test graph changes in drained section
      commit: Simplify reopen of base
      block: Keep nodes drained between reopen_queue/multiple

Thomas Huth (3):
      block: Remove the obsolete -drive boot=on|off parameter
      block: Remove the deprecated -hdachs option
      block: Mention -drive cyls/heads/secs/trans/serial/addr in deprecation chapter

Commit 1f4ad7d fixed 'qemu-img info' for raw images that are currently
in use as a mirror target. It is not enough for image formats, though,
as these still unconditionally request BLK_PERM_CONSISTENT_READ.

As this permission is geared towards whether the guest-visible data is
consistent, and has no impact on whether the metadata is sane, and
'qemu-img info' does not read guest-visible data (except for the raw
format), it makes sense to not require BLK_PERM_CONSISTENT_READ if there
is not going to be any guest I/O performed, regardless of image format.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
     assert(role == &child_backing || role == &child_file);
 
     if (!backing) {
+        int flags = bdrv_reopen_get_flags(reopen_queue, bs);
+
         /* Apart from the modifications below, the same permissions are
          * forwarded and left alone as for filters */
         bdrv_filter_default_perms(bs, c, role, reopen_queue, perm, shared,
@@ -XXX,XX +XXX,XX @@ void bdrv_format_default_perms(BlockDriverState *bs, BdrvChild *c,
 
         /* bs->file always needs to be consistent because of the metadata. We
          * can never allow other users to resize or write to it. */
-        perm |= BLK_PERM_CONSISTENT_READ;
+        if (!(flags & BDRV_O_NO_IO)) {
+            perm |= BLK_PERM_CONSISTENT_READ;
+        }
         shared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
     } else {
         /* We want consistent read from backing files if the parent needs it.
-- 
2.13.6

From: John Snow <jsnow@redhat.com>

VPC has some difficulty creating geometries of particular size.
However, we can indeed force it to use a literal one, so let's
do that for the sake of test 197, which is testing some specific
offsets.

Signed-off-by: John Snow <jsnow@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Lukáš Doktor <ldoktor@redhat.com>
---
 tests/qemu-iotests/197           | 4 ++++
 tests/qemu-iotests/common.filter | 3 ++-
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/197 b/tests/qemu-iotests/197
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/197
+++ b/tests/qemu-iotests/197
@@ -XXX,XX +XXX,XX @@ echo '=== Copy-on-read ==='
 echo
 
 # Prep the images
+# VPC rounds image sizes to a specific geometry, force a specific size.
+if [ "$IMGFMT" = "vpc" ]; then
+    IMGOPTS=$(_optstr_add "$IMGOPTS" "force_size")
+fi
 _make_test_img 4G
 $QEMU_IO -c "write -P 55 3G 1k" "$TEST_IMG" | _filter_qemu_io
 IMGPROTO=file IMGFMT=qcow2 IMGOPTS= TEST_IMG_FILE="$TEST_WRAP" \
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()
         -e "s# log_size=[0-9]\\+##g" \
         -e "s# refcount_bits=[0-9]\\+##g" \
         -e "s# key-secret=[a-zA-Z0-9]\\+##g" \
-        -e "s# iter-time=[0-9]\\+##g"
+        -e "s# iter-time=[0-9]\\+##g" \
+        -e "s# force_size=\$on\\|off\$##g"
 }
 
 _filter_img_info()
-- 
2.13.6

This change separates bdrv_drain_invoke(), which calls the BlockDriver
drain callbacks, from bdrv_drain_recurse(). Instead, the function
performs its own recursion now.

One reason for this is that bdrv_drain_recurse() can be called multiple
times by bdrv_drain_all_begin(), but the callbacks may only be called
once. The separation is necessary to fix this bug.

The other reason is that we intend to go to a model where we call all
driver callbacks first, and only then start polling. This is not fully
achieved yet with this patch, as bdrv_drain_invoke() contains a
BDRV_POLL_WHILE() loop for the block driver callbacks, which can still
call callbacks for any unrelated event. It's a step in this direction
anyway.

Cc: qemu-stable@nongnu.org
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 14 +++++++++++---
 1 file changed, 11 insertions(+), 3 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_drain_invoke_entry(void *opaque)
     bdrv_wakeup(bs);
 }
 
+/* Recursively call BlockDriver.bdrv_co_drain_begin/end callbacks */
 static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)
 {
+    BdrvChild *child, *tmp;
     BdrvCoDrainData data = { .bs = bs, .done = false, .begin = begin};
 
     if (!bs->drv || (begin && !bs->drv->bdrv_co_drain_begin) ||
@@ -XXX,XX +XXX,XX @@ static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)
     data.co = qemu_coroutine_create(bdrv_drain_invoke_entry, &data);
     bdrv_coroutine_enter(bs, data.co);
     BDRV_POLL_WHILE(bs, !data.done);
+
+    QLIST_FOREACH_SAFE(child, &bs->children, next, tmp) {
+        bdrv_drain_invoke(child->bs, begin);
+    }
 }
 
 static bool bdrv_drain_recurse(BlockDriverState *bs, bool begin)
@@ -XXX,XX +XXX,XX @@ static bool bdrv_drain_recurse(BlockDriverState *bs, bool begin)
     BdrvChild *child, *tmp;
     bool waited;
 
-    /* Ensure any pending metadata writes are submitted to bs->file.  */
-    bdrv_drain_invoke(bs, begin);
-
     /* Wait for drained requests to finish */
     waited = BDRV_POLL_WHILE(bs, atomic_read(&bs->in_flight) > 0);
 
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)
         bdrv_parent_drained_begin(bs);
     }
 
+    bdrv_drain_invoke(bs, true);
     bdrv_drain_recurse(bs, true);
 }
 
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
     }
 
     bdrv_parent_drained_end(bs);
+    bdrv_drain_invoke(bs, false);
     bdrv_drain_recurse(bs, false);
     aio_enable_external(bdrv_get_aio_context(bs));
 }
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
             aio_context_acquire(aio_context);
             for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
                 if (aio_context == bdrv_get_aio_context(bs)) {
+                    /* FIXME Calling this multiple times is wrong */
+                    bdrv_drain_invoke(bs, true);
                     waited |= bdrv_drain_recurse(bs, true);
                 }
             }
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
         aio_context_acquire(aio_context);
         aio_enable_external(aio_context);
         bdrv_parent_drained_end(bs);
+        bdrv_drain_invoke(bs, false);
         bdrv_drain_recurse(bs, false);
         aio_context_release(aio_context);
     }
-- 
2.13.6

bdrv_drain_all_begin() used to call the .bdrv_co_drain_begin() driver
callback inside its polling loop. This means that how many times it got
called for each node depended on long it had to poll the event loop.

This is obviously not right and results in nodes that stay drained even
after bdrv_drain_all_end(), which calls .bdrv_co_drain_begin() once per
node.

Fix bdrv_drain_all_begin() to call the callback only once, too.

Cc: qemu-stable@nongnu.org
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
         aio_context_acquire(aio_context);
         bdrv_parent_drained_begin(bs);
         aio_disable_external(aio_context);
+        bdrv_drain_invoke(bs, true);
         aio_context_release(aio_context);
 
         if (!g_slist_find(aio_ctxs, aio_context)) {
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
             aio_context_acquire(aio_context);
             for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
                 if (aio_context == bdrv_get_aio_context(bs)) {
-                    /* FIXME Calling this multiple times is wrong */
-                    bdrv_drain_invoke(bs, true);
                     waited |= bdrv_drain_recurse(bs, true);
                 }
             }
-- 
2.13.6

This adds a test case that the BlockDriver callbacks for drain are
called in bdrv_drained_all_begin/end(), and that both of them are called
exactly once.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
---
 tests/test-bdrv-drain.c | 137 ++++++++++++++++++++++++++++++++++++++++++++++++
 tests/Makefile.include  |   2 +
 2 files changed, 139 insertions(+)
 create mode 100644 tests/test-bdrv-drain.c

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@
+/*
+ * Block node draining tests
+ *
+ * Copyright (c) 2017 Kevin Wolf <kwolf@redhat.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+#include "qemu/osdep.h"
+#include "block/block.h"
+#include "sysemu/block-backend.h"
+#include "qapi/error.h"
+
+typedef struct BDRVTestState {
+    int drain_count;
+} BDRVTestState;
+
+static void coroutine_fn bdrv_test_co_drain_begin(BlockDriverState *bs)
+{
+    BDRVTestState *s = bs->opaque;
+    s->drain_count++;
+}
+
+static void coroutine_fn bdrv_test_co_drain_end(BlockDriverState *bs)
+{
+    BDRVTestState *s = bs->opaque;
+    s->drain_count--;
+}
+
+static void bdrv_test_close(BlockDriverState *bs)
+{
+    BDRVTestState *s = bs->opaque;
+    g_assert_cmpint(s->drain_count, >, 0);
+}
+
+static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
+                                            uint64_t offset, uint64_t bytes,
+                                            QEMUIOVector *qiov, int flags)
+{
+    /* We want this request to stay until the polling loop in drain waits for
+     * it to complete. We need to sleep a while as bdrv_drain_invoke() comes
+     * first and polls its result, too, but it shouldn't accidentally complete
+     * this request yet. */
+    qemu_co_sleep_ns(QEMU_CLOCK_REALTIME, 100000);
+
+    return 0;
+}
+
+static BlockDriver bdrv_test = {
+    .format_name            = "test",
+    .instance_size          = sizeof(BDRVTestState),
+
+    .bdrv_close             = bdrv_test_close,
+    .bdrv_co_preadv         = bdrv_test_co_preadv,
+
+    .bdrv_co_drain_begin    = bdrv_test_co_drain_begin,
+    .bdrv_co_drain_end      = bdrv_test_co_drain_end,
+};
+
+static void aio_ret_cb(void *opaque, int ret)
+{
+    int *aio_ret = opaque;
+    *aio_ret = ret;
+}
+
+static void test_drv_cb_drain_all(void)
+{
+    BlockBackend *blk;
+    BlockDriverState *bs;
+    BDRVTestState *s;
+    BlockAIOCB *acb;
+    int aio_ret;
+
+    QEMUIOVector qiov;
+    struct iovec iov = {
+        .iov_base = NULL,
+        .iov_len = 0,
+    };
+    qemu_iovec_init_external(&qiov, &iov, 1);
+
+    blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
+    bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
+                              &error_abort);
+    s = bs->opaque;
+    blk_insert_bs(blk, bs, &error_abort);
+
+    /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
+    g_assert_cmpint(s->drain_count, ==, 0);
+    bdrv_drain_all_begin();
+    g_assert_cmpint(s->drain_count, ==, 1);
+    bdrv_drain_all_end();
+    g_assert_cmpint(s->drain_count, ==, 0);
+
+    /* Now do the same while a request is pending */
+    aio_ret = -EINPROGRESS;
+    acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret);
+    g_assert(acb != NULL);
+    g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
+
+    g_assert_cmpint(s->drain_count, ==, 0);
+    bdrv_drain_all_begin();
+    g_assert_cmpint(aio_ret, ==, 0);
+    g_assert_cmpint(s->drain_count, ==, 1);
+    bdrv_drain_all_end();
+    g_assert_cmpint(s->drain_count, ==, 0);
+
+    bdrv_unref(bs);
+    blk_unref(blk);
+}
+
+int main(int argc, char **argv)
+{
+    bdrv_init();
+    qemu_init_main_loop(&error_abort);
+
+    g_test_init(&argc, &argv, NULL);
+
+    g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
+
+    return g_test_run();
+}
diff --git a/tests/Makefile.include b/tests/Makefile.include
index XXXXXXX..XXXXXXX 100644
--- a/tests/Makefile.include
+++ b/tests/Makefile.include
@@ -XXX,XX +XXX,XX @@ gcov-files-test-thread-pool-y = thread-pool.c
 gcov-files-test-hbitmap-y = util/hbitmap.c
 check-unit-y += tests/test-hbitmap$(EXESUF)
 gcov-files-test-hbitmap-y = blockjob.c
+check-unit-y += tests/test-bdrv-drain$(EXESUF)
 check-unit-y += tests/test-blockjob$(EXESUF)
 check-unit-y += tests/test-blockjob-txn$(EXESUF)
 check-unit-y += tests/test-x86-cpuid$(EXESUF)
@@ -XXX,XX +XXX,XX @@ tests/test-coroutine$(EXESUF): tests/test-coroutine.o $(test-block-obj-y)
 tests/test-aio$(EXESUF): tests/test-aio.o $(test-block-obj-y)
 tests/test-aio-multithread$(EXESUF): tests/test-aio-multithread.o $(test-block-obj-y)
 tests/test-throttle$(EXESUF): tests/test-throttle.o $(test-block-obj-y)
+tests/test-bdrv-drain$(EXESUF): tests/test-bdrv-drain.o $(test-block-obj-y) $(test-util-obj-y)
 tests/test-blockjob$(EXESUF): tests/test-blockjob.o $(test-block-obj-y) $(test-util-obj-y)
 tests/test-blockjob-txn$(EXESUF): tests/test-blockjob-txn.o $(test-block-obj-y) $(test-util-obj-y)
 tests/test-thread-pool$(EXESUF): tests/test-thread-pool.o $(test-block-obj-y)
-- 
2.13.6

Now that the bdrv_drain_invoke() calls are pulled up to the callers of
bdrv_drain_recurse(), the 'begin' parameter isn't needed any more.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)
     }
 }
 
-static bool bdrv_drain_recurse(BlockDriverState *bs, bool begin)
+static bool bdrv_drain_recurse(BlockDriverState *bs)
 {
     BdrvChild *child, *tmp;
     bool waited;
@@ -XXX,XX +XXX,XX @@ static bool bdrv_drain_recurse(BlockDriverState *bs, bool begin)
              */
             bdrv_ref(bs);
         }
-        waited |= bdrv_drain_recurse(bs, begin);
+        waited |= bdrv_drain_recurse(bs);
         if (in_main_loop) {
             bdrv_unref(bs);
         }
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)
     }
 
     bdrv_drain_invoke(bs, true);
-    bdrv_drain_recurse(bs, true);
+    bdrv_drain_recurse(bs);
 }
 
 void bdrv_drained_end(BlockDriverState *bs)
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
 
     bdrv_parent_drained_end(bs);
     bdrv_drain_invoke(bs, false);
-    bdrv_drain_recurse(bs, false);
+    bdrv_drain_recurse(bs);
     aio_enable_external(bdrv_get_aio_context(bs));
 }
 
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
             aio_context_acquire(aio_context);
             for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
                 if (aio_context == bdrv_get_aio_context(bs)) {
-                    waited |= bdrv_drain_recurse(bs, true);
+                    waited |= bdrv_drain_recurse(bs);
                 }
             }
             aio_context_release(aio_context);
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
         aio_enable_external(aio_context);
         bdrv_parent_drained_end(bs);
         bdrv_drain_invoke(bs, false);
-        bdrv_drain_recurse(bs, false);
+        bdrv_drain_recurse(bs);
         aio_context_release(aio_context);
     }
 
-- 
2.13.6

The device is drained, so there is no point in waiting for requests at
the end of the drained section. Remove the bdrv_drain_recurse() calls
there.

The bdrv_drain_recurse() calls were introduced in commit 481cad48e5e
in order to call the .bdrv_co_drain_end() driver callback. This is now
done by a separate bdrv_drain_invoke() call.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 2 --
 1 file changed, 2 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
 
     bdrv_parent_drained_end(bs);
     bdrv_drain_invoke(bs, false);
-    bdrv_drain_recurse(bs);
     aio_enable_external(bdrv_get_aio_context(bs));
 }
 
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
         aio_enable_external(aio_context);
         bdrv_parent_drained_end(bs);
         bdrv_drain_invoke(bs, false);
-        bdrv_drain_recurse(bs);
         aio_context_release(aio_context);
     }
 
-- 
2.13.6

Drain requests are propagated to child nodes, parent nodes and directly
to the AioContext. The order in which this happened was different
between all combinations of drain/drain_all and begin/end.

The correct order is to keep children only drained when their parents
are also drained. This means that at the start of a drained section, the
AioContext needs to be drained first, the parents second and only then
the children. The correct order for the end of a drained section is the
opposite.

This patch changes the three other functions to follow the example of
bdrv_drained_begin(), which is the only one that got it right.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/io.c | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)
         return;
     }
 
+    /* Stop things in parent-to-child order */
     if (atomic_fetch_inc(&bs->quiesce_counter) == 0) {
         aio_disable_external(bdrv_get_aio_context(bs));
         bdrv_parent_drained_begin(bs);
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
         return;
     }
 
-    bdrv_parent_drained_end(bs);
+    /* Re-enable things in child-to-parent order */
     bdrv_drain_invoke(bs, false);
+    bdrv_parent_drained_end(bs);
     aio_enable_external(bdrv_get_aio_context(bs));
 }
 
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
         AioContext *aio_context = bdrv_get_aio_context(bs);
 
+        /* Stop things in parent-to-child order */
         aio_context_acquire(aio_context);
-        bdrv_parent_drained_begin(bs);
         aio_disable_external(aio_context);
+        bdrv_parent_drained_begin(bs);
         bdrv_drain_invoke(bs, true);
         aio_context_release(aio_context);
 
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
         AioContext *aio_context = bdrv_get_aio_context(bs);
 
+        /* Re-enable things in child-to-parent order */
         aio_context_acquire(aio_context);
-        aio_enable_external(aio_context);
-        bdrv_parent_drained_end(bs);
         bdrv_drain_invoke(bs, false);
+        bdrv_parent_drained_end(bs);
+        aio_enable_external(aio_context);
         aio_context_release(aio_context);
     }
 
-- 
2.13.6

Commit 15afd94a047 added code to acquire and release the AioContext in
qemuio_command(). This means that the lock is taken twice now in the
call path from hmp_qemu_io(). This causes BDRV_POLL_WHILE() to hang for
any requests issued to nodes in a non-mainloop AioContext.

Dropping the first locking from hmp_qemu_io() fixes the problem.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 hmp.c | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/hmp.c b/hmp.c
index XXXXXXX..XXXXXXX 100644
--- a/hmp.c
+++ b/hmp.c
@@ -XXX,XX +XXX,XX @@ void hmp_qemu_io(Monitor *mon, const QDict *qdict)
 {
     BlockBackend *blk;
     BlockBackend *local_blk = NULL;
-    AioContext *aio_context;
     const char* device = qdict_get_str(qdict, "device");
     const char* command = qdict_get_str(qdict, "command");
     Error *err = NULL;
@@ -XXX,XX +XXX,XX @@ void hmp_qemu_io(Monitor *mon, const QDict *qdict)
         }
     }
 
-    aio_context = blk_get_aio_context(blk);
-    aio_context_acquire(aio_context);
-
     /*
      * Notably absent: Proper permission management. This is sad, but it seems
      * almost impossible to achieve without changing the semantics and thereby
@@ -XXX,XX +XXX,XX @@ void hmp_qemu_io(Monitor *mon, const QDict *qdict)
      */
     qemuio_command(blk, command);
 
-    aio_context_release(aio_context);
-
 fail:
     blk_unref(local_blk);
     hmp_handle_error(mon, &err);
-- 
2.13.6

From: Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com>

Since bdrv_co_preadv does all neccessary checks including
reading after the end of the backing file, avoid duplication
of verification before bdrv_co_preadv call.

Signed-off-by: Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.h |  3 ---
 block/qcow2.c | 51 ++++++++-------------------------------------------
 2 files changed, 8 insertions(+), 46 deletions(-)

diff --git a/block/qcow2.h b/block/qcow2.h
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -XXX,XX +XXX,XX @@ uint32_t offset_to_reftable_index(BDRVQcow2State *s, uint64_t offset)
 }
 
 /* qcow2.c functions */
-int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
-                  int64_t sector_num, int nb_sectors);
-
 int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,
                                      int refcount_order, bool generous_increase,
                                      uint64_t *refblock_count);
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 int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
     return status;
 }
 
-/* handle reading after the end of the backing file */
-int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
-                        int64_t offset, int bytes)
-{
-    uint64_t bs_size = bs->total_sectors * BDRV_SECTOR_SIZE;
-    int n1;
-
-    if ((offset + bytes) <= bs_size) {
-        return bytes;
-    }
-
-    if (offset >= bs_size) {
-        n1 = 0;
-    } else {
-        n1 = bs_size - offset;
-    }
-
-    qemu_iovec_memset(qiov, n1, 0, bytes - n1);
-
-    return n1;
-}
-
 static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
                                         uint64_t bytes, QEMUIOVector *qiov,
                                         int flags)
 {
     BDRVQcow2State *s = bs->opaque;
-    int offset_in_cluster, n1;
+    int offset_in_cluster;
     int ret;
     unsigned int cur_bytes; /* number of bytes in current iteration */
     uint64_t cluster_offset = 0;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
         case QCOW2_CLUSTER_UNALLOCATED:
 
             if (bs->backing) {
-                /* read from the base image */
-                n1 = qcow2_backing_read1(bs->backing->bs, &hd_qiov,
-                                         offset, cur_bytes);
-                if (n1 > 0) {
-                    QEMUIOVector local_qiov;
-
-                    qemu_iovec_init(&local_qiov, hd_qiov.niov);
-                    qemu_iovec_concat(&local_qiov, &hd_qiov, 0, n1);
-
-                    BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
-                    qemu_co_mutex_unlock(&s->lock);
-                    ret = bdrv_co_preadv(bs->backing, offset, n1,
-                                         &local_qiov, 0);
-                    qemu_co_mutex_lock(&s->lock);
-
-                    qemu_iovec_destroy(&local_qiov);
-
-                    if (ret < 0) {
-                        goto fail;
-                    }
+                BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
+                qemu_co_mutex_unlock(&s->lock);
+                ret = bdrv_co_preadv(bs->backing, offset, cur_bytes,
+                                     &hd_qiov, 0);
+                qemu_co_mutex_lock(&s->lock);
+                if (ret < 0) {
+                    goto fail;
                 }
             } else {
                 /* Note: in this case, no need to wait */
-- 
2.13.6

Removing a quorum child node with x-blockdev-change results in a quorum
driver state that cannot be recreated with create options because it
would require a list with gaps. This causes trouble in at least
.bdrv_refresh_filename().

Document this problem so that we won't accidentally mark the command
stable without having addressed it.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
---
 qapi/block-core.json | 4 ++++
 1 file changed, 4 insertions(+)

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 @@
 # does not support all kinds of operations, all kinds of children, nor
 # all block drivers.
 #
+# FIXME Removing children from a quorum node means introducing gaps in the
+# child indices. This cannot be represented in the 'children' list of
+# BlockdevOptionsQuorum, as returned by .bdrv_refresh_filename().
+#
 # Warning: The data in a new quorum child MUST be consistent with that of
 # the rest of the array.
 #
-- 
2.13.6

From: Doug Gale <doug16k@gmail.com>

Add trace output for commands, errors, and undefined behavior.
Add guest error log output for undefined behavior.
Report invalid undefined accesses to MMIO.
Annotate unlikely error checks with unlikely.

Signed-off-by: Doug Gale <doug16k@gmail.com>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 hw/block/nvme.c       | 349 ++++++++++++++++++++++++++++++++++++++++++--------
 hw/block/trace-events |  93 ++++++++++++++
 2 files changed, 390 insertions(+), 52 deletions(-)

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 @@
 #include "qapi/visitor.h"
 #include "sysemu/block-backend.h"
 
+#include "qemu/log.h"
+#include "trace.h"
 #include "nvme.h"
 
+#define NVME_GUEST_ERR(trace, fmt, ...) \
+    do { \
+        (trace_##trace)(__VA_ARGS__); \
+        qemu_log_mask(LOG_GUEST_ERROR, #trace \
+            " in %s: " fmt "\n", __func__, ## __VA_ARGS__); \
+    } while (0)
+
 static void nvme_process_sq(void *opaque);
 
 static void nvme_addr_read(NvmeCtrl *n, hwaddr addr, void *buf, int size)
@@ -XXX,XX +XXX,XX @@ static void nvme_isr_notify(NvmeCtrl *n, NvmeCQueue *cq)
 {
     if (cq->irq_enabled) {
         if (msix_enabled(&(n->parent_obj))) {
+            trace_nvme_irq_msix(cq->vector);
             msix_notify(&(n->parent_obj), cq->vector);
         } else {
+            trace_nvme_irq_pin();
             pci_irq_pulse(&n->parent_obj);
         }
+    } else {
+        trace_nvme_irq_masked();
     }
 }
 
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
     trans_len = MIN(len, trans_len);
     int num_prps = (len >> n->page_bits) + 1;
 
-    if (!prp1) {
+    if (unlikely(!prp1)) {
+        trace_nvme_err_invalid_prp();
         return NVME_INVALID_FIELD | NVME_DNR;
     } else if (n->cmbsz && prp1 >= n->ctrl_mem.addr &&
                prp1 < n->ctrl_mem.addr + int128_get64(n->ctrl_mem.size)) {
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
     }
     len -= trans_len;
     if (len) {
-        if (!prp2) {
+        if (unlikely(!prp2)) {
+            trace_nvme_err_invalid_prp2_missing();
             goto unmap;
         }
         if (len > n->page_size) {
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
                 uint64_t prp_ent = le64_to_cpu(prp_list[i]);
 
                 if (i == n->max_prp_ents - 1 && len > n->page_size) {
-                    if (!prp_ent || prp_ent & (n->page_size - 1)) {
+                    if (unlikely(!prp_ent || prp_ent & (n->page_size - 1))) {
+                        trace_nvme_err_invalid_prplist_ent(prp_ent);
                         goto unmap;
                     }
 
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
                     prp_ent = le64_to_cpu(prp_list[i]);
                 }
 
-                if (!prp_ent || prp_ent & (n->page_size - 1)) {
+                if (unlikely(!prp_ent || prp_ent & (n->page_size - 1))) {
+                    trace_nvme_err_invalid_prplist_ent(prp_ent);
                     goto unmap;
                 }
 
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_map_prp(QEMUSGList *qsg, QEMUIOVector *iov, uint64_t prp1,
                 i++;
             }
         } else {
-            if (prp2 & (n->page_size - 1)) {
+            if (unlikely(prp2 & (n->page_size - 1))) {
+                trace_nvme_err_invalid_prp2_align(prp2);
                 goto unmap;
             }
             if (qsg->nsg) {
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_dma_read_prp(NvmeCtrl *n, uint8_t *ptr, uint32_t len,
     QEMUIOVector iov;
     uint16_t status = NVME_SUCCESS;
 
+    trace_nvme_dma_read(prp1, prp2);
+
     if (nvme_map_prp(&qsg, &iov, prp1, prp2, len, n)) {
         return NVME_INVALID_FIELD | NVME_DNR;
     }
     if (qsg.nsg > 0) {
-        if (dma_buf_read(ptr, len, &qsg)) {
+        if (unlikely(dma_buf_read(ptr, len, &qsg))) {
+            trace_nvme_err_invalid_dma();
             status = NVME_INVALID_FIELD | NVME_DNR;
         }
         qemu_sglist_destroy(&qsg);
     } else {
-        if (qemu_iovec_to_buf(&iov, 0, ptr, len) != len) {
+        if (unlikely(qemu_iovec_to_buf(&iov, 0, ptr, len) != len)) {
+            trace_nvme_err_invalid_dma();
             status = NVME_INVALID_FIELD | NVME_DNR;
         }
         qemu_iovec_destroy(&iov);
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_write_zeros(NvmeCtrl *n, NvmeNamespace *ns, NvmeCmd *cmd,
     uint64_t aio_slba = slba << (data_shift - BDRV_SECTOR_BITS);
     uint32_t aio_nlb = nlb << (data_shift - BDRV_SECTOR_BITS);
 
-    if (slba + nlb > ns->id_ns.nsze) {
+    if (unlikely(slba + nlb > ns->id_ns.nsze)) {
+        trace_nvme_err_invalid_lba_range(slba, nlb, ns->id_ns.nsze);
         return NVME_LBA_RANGE | NVME_DNR;
     }
 
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_rw(NvmeCtrl *n, NvmeNamespace *ns, NvmeCmd *cmd,
     int is_write = rw->opcode == NVME_CMD_WRITE ? 1 : 0;
     enum BlockAcctType acct = is_write ? BLOCK_ACCT_WRITE : BLOCK_ACCT_READ;
 
-    if ((slba + nlb) > ns->id_ns.nsze) {
+    trace_nvme_rw(is_write ? "write" : "read", nlb, data_size, slba);
+
+    if (unlikely((slba + nlb) > ns->id_ns.nsze)) {
         block_acct_invalid(blk_get_stats(n->conf.blk), acct);
+        trace_nvme_err_invalid_lba_range(slba, nlb, ns->id_ns.nsze);
         return NVME_LBA_RANGE | NVME_DNR;
     }
 
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_io_cmd(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
     NvmeNamespace *ns;
     uint32_t nsid = le32_to_cpu(cmd->nsid);
 
-    if (nsid == 0 || nsid > n->num_namespaces) {
+    if (unlikely(nsid == 0 || nsid > n->num_namespaces)) {
+        trace_nvme_err_invalid_ns(nsid, n->num_namespaces);
         return NVME_INVALID_NSID | NVME_DNR;
     }
 
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_io_cmd(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
     case NVME_CMD_READ:
         return nvme_rw(n, ns, cmd, req);
     default:
+        trace_nvme_err_invalid_opc(cmd->opcode);
         return NVME_INVALID_OPCODE | NVME_DNR;
     }
 }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_del_sq(NvmeCtrl *n, NvmeCmd *cmd)
     NvmeCQueue *cq;
     uint16_t qid = le16_to_cpu(c->qid);
 
-    if (!qid || nvme_check_sqid(n, qid)) {
+    if (unlikely(!qid || nvme_check_sqid(n, qid))) {
+        trace_nvme_err_invalid_del_sq(qid);
         return NVME_INVALID_QID | NVME_DNR;
     }
 
+    trace_nvme_del_sq(qid);
+
     sq = n->sq[qid];
     while (!QTAILQ_EMPTY(&sq->out_req_list)) {
         req = QTAILQ_FIRST(&sq->out_req_list);
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_create_sq(NvmeCtrl *n, NvmeCmd *cmd)
     uint16_t qflags = le16_to_cpu(c->sq_flags);
     uint64_t prp1 = le64_to_cpu(c->prp1);
 
-    if (!cqid || nvme_check_cqid(n, cqid)) {
+    trace_nvme_create_sq(prp1, sqid, cqid, qsize, qflags);
+
+    if (unlikely(!cqid || nvme_check_cqid(n, cqid))) {
+        trace_nvme_err_invalid_create_sq_cqid(cqid);
         return NVME_INVALID_CQID | NVME_DNR;
     }
-    if (!sqid || !nvme_check_sqid(n, sqid)) {
+    if (unlikely(!sqid || !nvme_check_sqid(n, sqid))) {
+        trace_nvme_err_invalid_create_sq_sqid(sqid);
         return NVME_INVALID_QID | NVME_DNR;
     }
-    if (!qsize || qsize > NVME_CAP_MQES(n->bar.cap)) {
+    if (unlikely(!qsize || qsize > NVME_CAP_MQES(n->bar.cap))) {
+        trace_nvme_err_invalid_create_sq_size(qsize);
         return NVME_MAX_QSIZE_EXCEEDED | NVME_DNR;
     }
-    if (!prp1 || prp1 & (n->page_size - 1)) {
+    if (unlikely(!prp1 || prp1 & (n->page_size - 1))) {
+        trace_nvme_err_invalid_create_sq_addr(prp1);
         return NVME_INVALID_FIELD | NVME_DNR;
     }
-    if (!(NVME_SQ_FLAGS_PC(qflags))) {
+    if (unlikely(!(NVME_SQ_FLAGS_PC(qflags)))) {
+        trace_nvme_err_invalid_create_sq_qflags(NVME_SQ_FLAGS_PC(qflags));
         return NVME_INVALID_FIELD | NVME_DNR;
     }
     sq = g_malloc0(sizeof(*sq));
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_del_cq(NvmeCtrl *n, NvmeCmd *cmd)
     NvmeCQueue *cq;
     uint16_t qid = le16_to_cpu(c->qid);
 
-    if (!qid || nvme_check_cqid(n, qid)) {
+    if (unlikely(!qid || nvme_check_cqid(n, qid))) {
+        trace_nvme_err_invalid_del_cq_cqid(qid);
         return NVME_INVALID_CQID | NVME_DNR;
     }
 
     cq = n->cq[qid];
-    if (!QTAILQ_EMPTY(&cq->sq_list)) {
+    if (unlikely(!QTAILQ_EMPTY(&cq->sq_list))) {
+        trace_nvme_err_invalid_del_cq_notempty(qid);
         return NVME_INVALID_QUEUE_DEL;
     }
+    trace_nvme_del_cq(qid);
     nvme_free_cq(cq, n);
     return NVME_SUCCESS;
 }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_create_cq(NvmeCtrl *n, NvmeCmd *cmd)
     uint16_t qflags = le16_to_cpu(c->cq_flags);
     uint64_t prp1 = le64_to_cpu(c->prp1);
 
-    if (!cqid || !nvme_check_cqid(n, cqid)) {
+    trace_nvme_create_cq(prp1, cqid, vector, qsize, qflags,
+                         NVME_CQ_FLAGS_IEN(qflags) != 0);
+
+    if (unlikely(!cqid || !nvme_check_cqid(n, cqid))) {
+        trace_nvme_err_invalid_create_cq_cqid(cqid);
         return NVME_INVALID_CQID | NVME_DNR;
     }
-    if (!qsize || qsize > NVME_CAP_MQES(n->bar.cap)) {
+    if (unlikely(!qsize || qsize > NVME_CAP_MQES(n->bar.cap))) {
+        trace_nvme_err_invalid_create_cq_size(qsize);
         return NVME_MAX_QSIZE_EXCEEDED | NVME_DNR;
     }
-    if (!prp1) {
+    if (unlikely(!prp1)) {
+        trace_nvme_err_invalid_create_cq_addr(prp1);
         return NVME_INVALID_FIELD | NVME_DNR;
     }
-    if (vector > n->num_queues) {
+    if (unlikely(vector > n->num_queues)) {
+        trace_nvme_err_invalid_create_cq_vector(vector);
         return NVME_INVALID_IRQ_VECTOR | NVME_DNR;
     }
-    if (!(NVME_CQ_FLAGS_PC(qflags))) {
+    if (unlikely(!(NVME_CQ_FLAGS_PC(qflags)))) {
+        trace_nvme_err_invalid_create_cq_qflags(NVME_CQ_FLAGS_PC(qflags));
         return NVME_INVALID_FIELD | NVME_DNR;
     }
 
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_identify_ctrl(NvmeCtrl *n, NvmeIdentify *c)
     uint64_t prp1 = le64_to_cpu(c->prp1);
     uint64_t prp2 = le64_to_cpu(c->prp2);
 
+    trace_nvme_identify_ctrl();
+
     return nvme_dma_read_prp(n, (uint8_t *)&n->id_ctrl, sizeof(n->id_ctrl),
         prp1, prp2);
 }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_identify_ns(NvmeCtrl *n, NvmeIdentify *c)
     uint64_t prp1 = le64_to_cpu(c->prp1);
     uint64_t prp2 = le64_to_cpu(c->prp2);
 
-    if (nsid == 0 || nsid > n->num_namespaces) {
+    trace_nvme_identify_ns(nsid);
+
+    if (unlikely(nsid == 0 || nsid > n->num_namespaces)) {
+        trace_nvme_err_invalid_ns(nsid, n->num_namespaces);
         return NVME_INVALID_NSID | NVME_DNR;
     }
 
     ns = &n->namespaces[nsid - 1];
+
     return nvme_dma_read_prp(n, (uint8_t *)&ns->id_ns, sizeof(ns->id_ns),
         prp1, prp2);
 }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_identify_nslist(NvmeCtrl *n, NvmeIdentify *c)
     uint16_t ret;
     int i, j = 0;
 
+    trace_nvme_identify_nslist(min_nsid);
+
     list = g_malloc0(data_len);
     for (i = 0; i < n->num_namespaces; i++) {
         if (i < min_nsid) {
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_identify(NvmeCtrl *n, NvmeCmd *cmd)
     case 0x02:
         return nvme_identify_nslist(n, c);
     default:
+        trace_nvme_err_invalid_identify_cns(le32_to_cpu(c->cns));
         return NVME_INVALID_FIELD | NVME_DNR;
     }
 }
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
     switch (dw10) {
     case NVME_VOLATILE_WRITE_CACHE:
         result = blk_enable_write_cache(n->conf.blk);
+        trace_nvme_getfeat_vwcache(result ? "enabled" : "disabled");
         break;
     case NVME_NUMBER_OF_QUEUES:
         result = cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
+        trace_nvme_getfeat_numq(result);
         break;
     default:
+        trace_nvme_err_invalid_getfeat(dw10);
         return NVME_INVALID_FIELD | NVME_DNR;
     }
 
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_set_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
         blk_set_enable_write_cache(n->conf.blk, dw11 & 1);
         break;
     case NVME_NUMBER_OF_QUEUES:
+        trace_nvme_setfeat_numq((dw11 & 0xFFFF) + 1,
+                                ((dw11 >> 16) & 0xFFFF) + 1,
+                                n->num_queues - 1, n->num_queues - 1);
         req->cqe.result =
             cpu_to_le32((n->num_queues - 2) | ((n->num_queues - 2) << 16));
         break;
     default:
+        trace_nvme_err_invalid_setfeat(dw10);
         return NVME_INVALID_FIELD | NVME_DNR;
     }
     return NVME_SUCCESS;
@@ -XXX,XX +XXX,XX @@ static uint16_t nvme_admin_cmd(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
     case NVME_ADM_CMD_GET_FEATURES:
         return nvme_get_feature(n, cmd, req);
     default:
+        trace_nvme_err_invalid_admin_opc(cmd->opcode);
         return NVME_INVALID_OPCODE | NVME_DNR;
     }
 }
@@ -XXX,XX +XXX,XX @@ static int nvme_start_ctrl(NvmeCtrl *n)
     uint32_t page_bits = NVME_CC_MPS(n->bar.cc) + 12;
     uint32_t page_size = 1 << page_bits;
 
-    if (n->cq[0] || n->sq[0] || !n->bar.asq || !n->bar.acq ||
-            n->bar.asq & (page_size - 1) || n->bar.acq & (page_size - 1) ||
-            NVME_CC_MPS(n->bar.cc) < NVME_CAP_MPSMIN(n->bar.cap) ||
-            NVME_CC_MPS(n->bar.cc) > NVME_CAP_MPSMAX(n->bar.cap) ||
-            NVME_CC_IOCQES(n->bar.cc) < NVME_CTRL_CQES_MIN(n->id_ctrl.cqes) ||
-            NVME_CC_IOCQES(n->bar.cc) > NVME_CTRL_CQES_MAX(n->id_ctrl.cqes) ||
-            NVME_CC_IOSQES(n->bar.cc) < NVME_CTRL_SQES_MIN(n->id_ctrl.sqes) ||
-            NVME_CC_IOSQES(n->bar.cc) > NVME_CTRL_SQES_MAX(n->id_ctrl.sqes) ||
-            !NVME_AQA_ASQS(n->bar.aqa) || !NVME_AQA_ACQS(n->bar.aqa)) {
+    if (unlikely(n->cq[0])) {
+        trace_nvme_err_startfail_cq();
+        return -1;
+    }
+    if (unlikely(n->sq[0])) {
+        trace_nvme_err_startfail_sq();
+        return -1;
+    }
+    if (unlikely(!n->bar.asq)) {
+        trace_nvme_err_startfail_nbarasq();
+        return -1;
+    }
+    if (unlikely(!n->bar.acq)) {
+        trace_nvme_err_startfail_nbaracq();
+        return -1;
+    }
+    if (unlikely(n->bar.asq & (page_size - 1))) {
+        trace_nvme_err_startfail_asq_misaligned(n->bar.asq);
+        return -1;
+    }
+    if (unlikely(n->bar.acq & (page_size - 1))) {
+        trace_nvme_err_startfail_acq_misaligned(n->bar.acq);
+        return -1;
+    }
+    if (unlikely(NVME_CC_MPS(n->bar.cc) <
+                 NVME_CAP_MPSMIN(n->bar.cap))) {
+        trace_nvme_err_startfail_page_too_small(
+                    NVME_CC_MPS(n->bar.cc),
+                    NVME_CAP_MPSMIN(n->bar.cap));
+        return -1;
+    }
+    if (unlikely(NVME_CC_MPS(n->bar.cc) >
+                 NVME_CAP_MPSMAX(n->bar.cap))) {
+        trace_nvme_err_startfail_page_too_large(
+                    NVME_CC_MPS(n->bar.cc),
+                    NVME_CAP_MPSMAX(n->bar.cap));
+        return -1;
+    }
+    if (unlikely(NVME_CC_IOCQES(n->bar.cc) <
+                 NVME_CTRL_CQES_MIN(n->id_ctrl.cqes))) {
+        trace_nvme_err_startfail_cqent_too_small(
+                    NVME_CC_IOCQES(n->bar.cc),
+                    NVME_CTRL_CQES_MIN(n->bar.cap));
+        return -1;
+    }
+    if (unlikely(NVME_CC_IOCQES(n->bar.cc) >
+                 NVME_CTRL_CQES_MAX(n->id_ctrl.cqes))) {
+        trace_nvme_err_startfail_cqent_too_large(
+                    NVME_CC_IOCQES(n->bar.cc),
+                    NVME_CTRL_CQES_MAX(n->bar.cap));
+        return -1;
+    }
+    if (unlikely(NVME_CC_IOSQES(n->bar.cc) <
+                 NVME_CTRL_SQES_MIN(n->id_ctrl.sqes))) {
+        trace_nvme_err_startfail_sqent_too_small(
+                    NVME_CC_IOSQES(n->bar.cc),
+                    NVME_CTRL_SQES_MIN(n->bar.cap));
+        return -1;
+    }
+    if (unlikely(NVME_CC_IOSQES(n->bar.cc) >
+                 NVME_CTRL_SQES_MAX(n->id_ctrl.sqes))) {
+        trace_nvme_err_startfail_sqent_too_large(
+                    NVME_CC_IOSQES(n->bar.cc),
+                    NVME_CTRL_SQES_MAX(n->bar.cap));
+        return -1;
+    }
+    if (unlikely(!NVME_AQA_ASQS(n->bar.aqa))) {
+        trace_nvme_err_startfail_asqent_sz_zero();
+        return -1;
+    }
+    if (unlikely(!NVME_AQA_ACQS(n->bar.aqa))) {
+        trace_nvme_err_startfail_acqent_sz_zero();
         return -1;
     }
 
@@ -XXX,XX +XXX,XX @@ static int nvme_start_ctrl(NvmeCtrl *n)
 static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
     unsigned size)
 {
+    if (unlikely(offset & (sizeof(uint32_t) - 1))) {
+        NVME_GUEST_ERR(nvme_ub_mmiowr_misaligned32,
+                       "MMIO write not 32-bit aligned,"
+                       " offset=0x%"PRIx64"", offset);
+        /* should be ignored, fall through for now */
+    }
+
+    if (unlikely(size < sizeof(uint32_t))) {
+        NVME_GUEST_ERR(nvme_ub_mmiowr_toosmall,
+                       "MMIO write smaller than 32-bits,"
+                       " offset=0x%"PRIx64", size=%u",
+                       offset, size);
+        /* should be ignored, fall through for now */
+    }
+
     switch (offset) {
-    case 0xc:
+    case 0xc:   /* INTMS */
+        if (unlikely(msix_enabled(&(n->parent_obj)))) {
+            NVME_GUEST_ERR(nvme_ub_mmiowr_intmask_with_msix,
+                           "undefined access to interrupt mask set"
+                           " when MSI-X is enabled");
+            /* should be ignored, fall through for now */
+        }
         n->bar.intms |= data & 0xffffffff;
         n->bar.intmc = n->bar.intms;
+        trace_nvme_mmio_intm_set(data & 0xffffffff,
+                                 n->bar.intmc);
         break;
-    case 0x10:
+    case 0x10:  /* INTMC */
+        if (unlikely(msix_enabled(&(n->parent_obj)))) {
+            NVME_GUEST_ERR(nvme_ub_mmiowr_intmask_with_msix,
+                           "undefined access to interrupt mask clr"
+                           " when MSI-X is enabled");
+            /* should be ignored, fall through for now */
+        }
         n->bar.intms &= ~(data & 0xffffffff);
         n->bar.intmc = n->bar.intms;
+        trace_nvme_mmio_intm_clr(data & 0xffffffff,
+                                 n->bar.intmc);
         break;
-    case 0x14:
+    case 0x14:  /* CC */
+        trace_nvme_mmio_cfg(data & 0xffffffff);
         /* Windows first sends data, then sends enable bit */
         if (!NVME_CC_EN(data) && !NVME_CC_EN(n->bar.cc) &&
             !NVME_CC_SHN(data) && !NVME_CC_SHN(n->bar.cc))
@@ -XXX,XX +XXX,XX @@ static void nvme_write_bar(NvmeCtrl *n, hwaddr offset, uint64_t data,
 
         if (NVME_CC_EN(data) && !NVME_CC_EN(n->bar.cc)) {
             n->bar.cc = data;
-            if (nvme_start_ctrl(n)) {
+            if (unlikely(nvme_start_ctrl(n))) {
+                trace_nvme_err_startfail();
                 n->bar.csts = NVME_CSTS_FAILED;
             } else {
+                trace_nvme_mmio_start_success();
                 n->bar.csts = NVME_CSTS_READY;
             }
         } else if (!NVME_CC_EN(data) && NVME_CC_EN(n->bar.cc)) {
+            trace_nvme_mmio_stopped();
             nvme_clear_ctrl(n);
             n->bar.csts &= ~NVME_CSTS_READY;
         }
         if (NVME_CC_SHN(data) && !(NVME_CC_SHN(n->bar.cc))) {
-                nvme_clear_ctrl(n);
-                n->bar.cc = data;
-                n->bar.csts |= NVME_CSTS_SHST_COMPLETE;
+            trace_nvme_mmio_shutdown_set();
+            nvme_clear_ctrl(n);
+            n->bar.cc = data;
+            n->bar.csts |= NVME_CSTS_SHST_COMPLETE;
         } else if (!NVME_CC_SHN(data) && NVME_CC_SHN(n->bar.cc)) {
-                n->bar.csts &= ~NVME_CSTS_SHST_COMPLETE;
-                n->bar.cc = data;
+            trace_nvme_mmio_shutdown_cleared();
+            n->bar.csts &= ~NVME_CSTS_SHST_COMPLETE;
+            n->bar.cc = data;
+        }
+        break;
+    case 0x1C:  /* CSTS */
+        if (data & (1 << 4)) {
+            NVME_GUEST_ERR(nvme_ub_mmiowr_ssreset_w1c_unsupported,
+                           "attempted to W1C CSTS.NSSRO"
+                           " but CAP.NSSRS is zero (not supported)");
+        } else if (data != 0) {
+            NVME_GUEST_ERR(nvme_ub_mmiowr_ro_csts,
+                           "attempted to set a read only bit"
+                           " of controller status");
+        }
+        break;
+    case 0x20:  /* NSSR */
+        if (data == 0x4E564D65) {
+            trace_nvme_ub_mmiowr_ssreset_unsupported();
+        } else {
+            /* The spec says that writes of other values have no effect */
+            return;
         }
         break;
-    case 0x24:
+    case 0x24:  /* AQA */
         n->bar.aqa = data & 0xffffffff;
+        trace_nvme_mmio_aqattr(data & 0xffffffff);
         break;
-    case 0x28:
+    case 0x28:  /* ASQ */
         n->bar.asq = data;
+        trace_nvme_mmio_asqaddr(data);
         break;
-    case 0x2c:
+    case 0x2c:  /* ASQ hi */
         n->bar.asq |= data << 32;
+        trace_nvme_mmio_asqaddr_hi(data, n->bar.asq);
         break;
-    case 0x30:
+    case 0x30:  /* ACQ */
+        trace_nvme_mmio_acqaddr(data);
         n->bar.acq = data;
         break;
-    case 0x34:
+    case 0x34:  /* ACQ hi */
         n->bar.acq |= data << 32;
+        trace_nvme_mmio_acqaddr_hi(data, n->bar.acq);
         break;
+    case 0x38:  /* CMBLOC */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_cmbloc_reserved,
+                       "invalid write to reserved CMBLOC"
+                       " when CMBSZ is zero, ignored");
+        return;
+    case 0x3C:  /* CMBSZ */
+        NVME_GUEST_ERR(nvme_ub_mmiowr_cmbsz_readonly,
+                       "invalid write to read only CMBSZ, ignored");
+        return;
     default:
+        NVME_GUEST_ERR(nvme_ub_mmiowr_invalid,
+                       "invalid MMIO write,"
+                       " offset=0x%"PRIx64", data=%"PRIx64"",
+                       offset, data);
         break;
     }
 }
@@ -XXX,XX +XXX,XX @@ static uint64_t nvme_mmio_read(void *opaque, hwaddr addr, unsigned size)
     uint8_t *ptr = (uint8_t *)&n->bar;
     uint64_t val = 0;
 
+    if (unlikely(addr & (sizeof(uint32_t) - 1))) {
+        NVME_GUEST_ERR(nvme_ub_mmiord_misaligned32,
+                       "MMIO read not 32-bit aligned,"
+                       " offset=0x%"PRIx64"", addr);
+        /* should RAZ, fall through for now */
+    } else if (unlikely(size < sizeof(uint32_t))) {
+        NVME_GUEST_ERR(nvme_ub_mmiord_toosmall,
+                       "MMIO read smaller than 32-bits,"
+                       " offset=0x%"PRIx64"", addr);
+        /* should RAZ, fall through for now */
+    }
+
     if (addr < sizeof(n->bar)) {
         memcpy(&val, ptr + addr, size);
+    } else {
+        NVME_GUEST_ERR(nvme_ub_mmiord_invalid_ofs,
+                       "MMIO read beyond last register,"
+                       " offset=0x%"PRIx64", returning 0", addr);
     }
+
     return val;
 }
 
@@ -XXX,XX +XXX,XX @@ static void nvme_process_db(NvmeCtrl *n, hwaddr addr, int val)
 {
     uint32_t qid;
 
-    if (addr & ((1 << 2) - 1)) {
+    if (unlikely(addr & ((1 << 2) - 1))) {
+        NVME_GUEST_ERR(nvme_ub_db_wr_misaligned,
+                       "doorbell write not 32-bit aligned,"
+                       " offset=0x%"PRIx64", ignoring", addr);
         return;
     }
 
     if (((addr - 0x1000) >> 2) & 1) {
+        /* Completion queue doorbell write */
+
         uint16_t new_head = val & 0xffff;
         int start_sqs;
         NvmeCQueue *cq;
 
         qid = (addr - (0x1000 + (1 << 2))) >> 3;
-        if (nvme_check_cqid(n, qid)) {
+        if (unlikely(nvme_check_cqid(n, qid))) {
+            NVME_GUEST_ERR(nvme_ub_db_wr_invalid_cq,
+                           "completion queue doorbell write"
+                           " for nonexistent queue,"
+                           " sqid=%"PRIu32", ignoring", qid);
             return;
         }
 
         cq = n->cq[qid];
-        if (new_head >= cq->size) {
+        if (unlikely(new_head >= cq->size)) {
+            NVME_GUEST_ERR(nvme_ub_db_wr_invalid_cqhead,
+                           "completion queue doorbell write value"
+                           " beyond queue size, sqid=%"PRIu32","
+                           " new_head=%"PRIu16", ignoring",
+                           qid, new_head);
             return;
         }
 
@@ -XXX,XX +XXX,XX @@ static void nvme_process_db(NvmeCtrl *n, hwaddr addr, int val)
             nvme_isr_notify(n, cq);
         }
     } else {
+        /* Submission queue doorbell write */
+
         uint16_t new_tail = val & 0xffff;
         NvmeSQueue *sq;
 
         qid = (addr - 0x1000) >> 3;
-        if (nvme_check_sqid(n, qid)) {
+        if (unlikely(nvme_check_sqid(n, qid))) {
+            NVME_GUEST_ERR(nvme_ub_db_wr_invalid_sq,
+                           "submission queue doorbell write"
+                           " for nonexistent queue,"
+                           " sqid=%"PRIu32", ignoring", qid);
             return;
         }
 
         sq = n->sq[qid];
-        if (new_tail >= sq->size) {
+        if (unlikely(new_tail >= sq->size)) {
+            NVME_GUEST_ERR(nvme_ub_db_wr_invalid_sqtail,
+                           "submission queue doorbell write value"
+                           " beyond queue size, sqid=%"PRIu32","
+                           " new_tail=%"PRIu16", ignoring",
+                           qid, new_tail);
             return;
         }
 
diff --git a/hw/block/trace-events b/hw/block/trace-events
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/trace-events
+++ b/hw/block/trace-events
@@ -XXX,XX +XXX,XX @@ virtio_blk_submit_multireq(void *vdev, void *mrb, int start, int num_reqs, uint6
 hd_geometry_lchs_guess(void *blk, int cyls, int heads, int secs) "blk %p LCHS %d %d %d"
 hd_geometry_guess(void *blk, uint32_t cyls, uint32_t heads, uint32_t secs, int trans) "blk %p CHS %u %u %u trans %d"
 
+# hw/block/nvme.c
+# nvme traces for successful events
+nvme_irq_msix(uint32_t vector) "raising MSI-X IRQ vector %u"
+nvme_irq_pin(void) "pulsing IRQ pin"
+nvme_irq_masked(void) "IRQ is masked"
+nvme_dma_read(uint64_t prp1, uint64_t prp2) "DMA read, prp1=0x%"PRIx64" prp2=0x%"PRIx64""
+nvme_rw(char const *verb, uint32_t blk_count, uint64_t byte_count, uint64_t lba) "%s %"PRIu32" blocks (%"PRIu64" bytes) from LBA %"PRIu64""
+nvme_create_sq(uint64_t addr, uint16_t sqid, uint16_t cqid, uint16_t qsize, uint16_t qflags) "create submission queue, addr=0x%"PRIx64", sqid=%"PRIu16", cqid=%"PRIu16", qsize=%"PRIu16", qflags=%"PRIu16""
+nvme_create_cq(uint64_t addr, uint16_t cqid, uint16_t vector, uint16_t size, uint16_t qflags, int ien) "create completion queue, addr=0x%"PRIx64", cqid=%"PRIu16", vector=%"PRIu16", qsize=%"PRIu16", qflags=%"PRIu16", ien=%d"
+nvme_del_sq(uint16_t qid) "deleting submission queue sqid=%"PRIu16""
+nvme_del_cq(uint16_t cqid) "deleted completion queue, sqid=%"PRIu16""
+nvme_identify_ctrl(void) "identify controller"
+nvme_identify_ns(uint16_t ns) "identify namespace, nsid=%"PRIu16""
+nvme_identify_nslist(uint16_t ns) "identify namespace list, nsid=%"PRIu16""
+nvme_getfeat_vwcache(char const* result) "get feature volatile write cache, result=%s"
+nvme_getfeat_numq(int result) "get feature number of queues, result=%d"
+nvme_setfeat_numq(int reqcq, int reqsq, int gotcq, int gotsq) "requested cq_count=%d sq_count=%d, responding with cq_count=%d sq_count=%d"
+nvme_mmio_intm_set(uint64_t data, uint64_t new_mask) "wrote MMIO, interrupt mask set, data=0x%"PRIx64", new_mask=0x%"PRIx64""
+nvme_mmio_intm_clr(uint64_t data, uint64_t new_mask) "wrote MMIO, interrupt mask clr, data=0x%"PRIx64", new_mask=0x%"PRIx64""
+nvme_mmio_cfg(uint64_t data) "wrote MMIO, config controller config=0x%"PRIx64""
+nvme_mmio_aqattr(uint64_t data) "wrote MMIO, admin queue attributes=0x%"PRIx64""
+nvme_mmio_asqaddr(uint64_t data) "wrote MMIO, admin submission queue address=0x%"PRIx64""
+nvme_mmio_acqaddr(uint64_t data) "wrote MMIO, admin completion queue address=0x%"PRIx64""
+nvme_mmio_asqaddr_hi(uint64_t data, uint64_t new_addr) "wrote MMIO, admin submission queue high half=0x%"PRIx64", new_address=0x%"PRIx64""
+nvme_mmio_acqaddr_hi(uint64_t data, uint64_t new_addr) "wrote MMIO, admin completion queue high half=0x%"PRIx64", new_address=0x%"PRIx64""
+nvme_mmio_start_success(void) "setting controller enable bit succeeded"
+nvme_mmio_stopped(void) "cleared controller enable bit"
+nvme_mmio_shutdown_set(void) "shutdown bit set"
+nvme_mmio_shutdown_cleared(void) "shutdown bit cleared"
+
+# nvme traces for error conditions
+nvme_err_invalid_dma(void) "PRP/SGL is too small for transfer size"
+nvme_err_invalid_prplist_ent(uint64_t prplist) "PRP list entry is null or not page aligned: 0x%"PRIx64""
+nvme_err_invalid_prp2_align(uint64_t prp2) "PRP2 is not page aligned: 0x%"PRIx64""
+nvme_err_invalid_prp2_missing(void) "PRP2 is null and more data to be transferred"
+nvme_err_invalid_field(void) "invalid field"
+nvme_err_invalid_prp(void) "invalid PRP"
+nvme_err_invalid_sgl(void) "invalid SGL"
+nvme_err_invalid_ns(uint32_t ns, uint32_t limit) "invalid namespace %u not within 1-%u"
+nvme_err_invalid_opc(uint8_t opc) "invalid opcode 0x%"PRIx8""
+nvme_err_invalid_admin_opc(uint8_t opc) "invalid admin opcode 0x%"PRIx8""
+nvme_err_invalid_lba_range(uint64_t start, uint64_t len, uint64_t limit) "Invalid LBA start=%"PRIu64" len=%"PRIu64" limit=%"PRIu64""
+nvme_err_invalid_del_sq(uint16_t qid) "invalid submission queue deletion, sid=%"PRIu16""
+nvme_err_invalid_create_sq_cqid(uint16_t cqid) "failed creating submission queue, invalid cqid=%"PRIu16""
+nvme_err_invalid_create_sq_sqid(uint16_t sqid) "failed creating submission queue, invalid sqid=%"PRIu16""
+nvme_err_invalid_create_sq_size(uint16_t qsize) "failed creating submission queue, invalid qsize=%"PRIu16""
+nvme_err_invalid_create_sq_addr(uint64_t addr) "failed creating submission queue, addr=0x%"PRIx64""
+nvme_err_invalid_create_sq_qflags(uint16_t qflags) "failed creating submission queue, qflags=%"PRIu16""
+nvme_err_invalid_del_cq_cqid(uint16_t cqid) "failed deleting completion queue, cqid=%"PRIu16""
+nvme_err_invalid_del_cq_notempty(uint16_t cqid) "failed deleting completion queue, it is not empty, cqid=%"PRIu16""
+nvme_err_invalid_create_cq_cqid(uint16_t cqid) "failed creating completion queue, cqid=%"PRIu16""
+nvme_err_invalid_create_cq_size(uint16_t size) "failed creating completion queue, size=%"PRIu16""
+nvme_err_invalid_create_cq_addr(uint64_t addr) "failed creating completion queue, addr=0x%"PRIx64""
+nvme_err_invalid_create_cq_vector(uint16_t vector) "failed creating completion queue, vector=%"PRIu16""
+nvme_err_invalid_create_cq_qflags(uint16_t qflags) "failed creating completion queue, qflags=%"PRIu16""
+nvme_err_invalid_identify_cns(uint16_t cns) "identify, invalid cns=0x%"PRIx16""
+nvme_err_invalid_getfeat(int dw10) "invalid get features, dw10=0x%"PRIx32""
+nvme_err_invalid_setfeat(uint32_t dw10) "invalid set features, dw10=0x%"PRIx32""
+nvme_err_startfail_cq(void) "nvme_start_ctrl failed because there are non-admin completion queues"
+nvme_err_startfail_sq(void) "nvme_start_ctrl failed because there are non-admin submission queues"
+nvme_err_startfail_nbarasq(void) "nvme_start_ctrl failed because the admin submission queue address is null"
+nvme_err_startfail_nbaracq(void) "nvme_start_ctrl failed because the admin completion queue address is null"
+nvme_err_startfail_asq_misaligned(uint64_t addr) "nvme_start_ctrl failed because the admin submission queue address is misaligned: 0x%"PRIx64""
+nvme_err_startfail_acq_misaligned(uint64_t addr) "nvme_start_ctrl failed because the admin completion queue address is misaligned: 0x%"PRIx64""
+nvme_err_startfail_page_too_small(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the page size is too small: log2size=%u, min=%u"
+nvme_err_startfail_page_too_large(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the page size is too large: log2size=%u, max=%u"
+nvme_err_startfail_cqent_too_small(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the completion queue entry size is too small: log2size=%u, min=%u"
+nvme_err_startfail_cqent_too_large(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the completion queue entry size is too large: log2size=%u, max=%u"
+nvme_err_startfail_sqent_too_small(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the submission queue entry size is too small: log2size=%u, min=%u"
+nvme_err_startfail_sqent_too_large(uint8_t log2ps, uint8_t maxlog2ps) "nvme_start_ctrl failed because the submission queue entry size is too large: log2size=%u, max=%u"
+nvme_err_startfail_asqent_sz_zero(void) "nvme_start_ctrl failed because the admin submission queue size is zero"
+nvme_err_startfail_acqent_sz_zero(void) "nvme_start_ctrl failed because the admin completion queue size is zero"
+nvme_err_startfail(void) "setting controller enable bit failed"
+
+# Traces for undefined behavior
+nvme_ub_mmiowr_misaligned32(uint64_t offset) "MMIO write not 32-bit aligned, offset=0x%"PRIx64""
+nvme_ub_mmiowr_toosmall(uint64_t offset, unsigned size) "MMIO write smaller than 32 bits, offset=0x%"PRIx64", size=%u"
+nvme_ub_mmiowr_intmask_with_msix(void) "undefined access to interrupt mask set when MSI-X is enabled"
+nvme_ub_mmiowr_ro_csts(void) "attempted to set a read only bit of controller status"
+nvme_ub_mmiowr_ssreset_w1c_unsupported(void) "attempted to W1C CSTS.NSSRO but CAP.NSSRS is zero (not supported)"
+nvme_ub_mmiowr_ssreset_unsupported(void) "attempted NVM subsystem reset but CAP.NSSRS is zero (not supported)"
+nvme_ub_mmiowr_cmbloc_reserved(void) "invalid write to reserved CMBLOC when CMBSZ is zero, ignored"
+nvme_ub_mmiowr_cmbsz_readonly(void) "invalid write to read only CMBSZ, ignored"
+nvme_ub_mmiowr_invalid(uint64_t offset, uint64_t data) "invalid MMIO write, offset=0x%"PRIx64", data=0x%"PRIx64""
+nvme_ub_mmiord_misaligned32(uint64_t offset) "MMIO read not 32-bit aligned, offset=0x%"PRIx64""
+nvme_ub_mmiord_toosmall(uint64_t offset) "MMIO read smaller than 32-bits, offset=0x%"PRIx64""
+nvme_ub_mmiord_invalid_ofs(uint64_t offset) "MMIO read beyond last register, offset=0x%"PRIx64", returning 0"
+nvme_ub_db_wr_misaligned(uint64_t offset) "doorbell write not 32-bit aligned, offset=0x%"PRIx64", ignoring"
+nvme_ub_db_wr_invalid_cq(uint32_t qid) "completion queue doorbell write for nonexistent queue, cqid=%"PRIu32", ignoring"
+nvme_ub_db_wr_invalid_cqhead(uint32_t qid, uint16_t new_head) "completion queue doorbell write value beyond queue size, cqid=%"PRIu32", new_head=%"PRIu16", ignoring"
+nvme_ub_db_wr_invalid_sq(uint32_t qid) "submission queue doorbell write for nonexistent queue, sqid=%"PRIu32", ignoring"
+nvme_ub_db_wr_invalid_sqtail(uint32_t qid, uint16_t new_tail) "submission queue doorbell write value beyond queue size, sqid=%"PRIu32", new_head=%"PRIu16", ignoring"
+
 # hw/block/xen_disk.c
 xen_disk_alloc(char *name) "%s"
 xen_disk_init(char *name) "%s"
-- 
2.13.6

From: Fam Zheng <famz@redhat.com>

Management tools create overlays of running guests with qemu-img:

$ qemu-img create -b /image/in/use.qcow2 -f qcow2 /overlay/image.qcow2

but this doesn't work anymore due to image locking:

qemu-img: /overlay/image.qcow2: Failed to get shared "write" lock
    Is another process using the image?
    Could not open backing image to determine size.
Use the force share option to allow this use case again.

Cc: qemu-stable@nongnu.org
Signed-off-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,
         back_flags = flags;
         back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
 
+        backing_options = qdict_new();
         if (backing_fmt) {
-            backing_options = qdict_new();
             qdict_put_str(backing_options, "driver", backing_fmt);
         }
+        qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
 
         bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
                        &local_err);
-- 
2.13.6

From: Thomas Huth <thuth@redhat.com>

It's not working anymore since QEMU v1.3.0 - time to remove it now.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockdev.c    | 11 -----------
 qemu-doc.texi |  6 ------
 2 files changed, 17 deletions(-)

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ QemuOptsList qemu_legacy_drive_opts = {
             .type = QEMU_OPT_STRING,
             .help = "chs translation (auto, lba, none)",
         },{
-            .name = "boot",
-            .type = QEMU_OPT_BOOL,
-            .help = "(deprecated, ignored)",
-        },{
             .name = "addr",
             .type = QEMU_OPT_STRING,
             .help = "pci address (virtio only)",
@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
         goto fail;
     }
 
-    /* Deprecated option boot=[on|off] */
-    if (qemu_opt_get(legacy_opts, "boot") != NULL) {
-        fprintf(stderr, "qemu-kvm: boot=on|off is deprecated and will be "
-                "ignored. Future versions will reject this parameter. Please "
-                "update your scripts.\n");
-    }
-
     /* Other deprecated options */
     if (!qtest_enabled()) {
         for (i = 0; i < ARRAY_SIZE(deprecated); i++) {
diff --git a/qemu-doc.texi b/qemu-doc.texi
index XXXXXXX..XXXXXXX 100644
--- a/qemu-doc.texi
+++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ deprecated.
 
 @section System emulator command line arguments
 
-@subsection -drive boot=on|off (since 1.3.0)
-
-The ``boot=on|off'' option to the ``-drive'' argument is
-ignored. Applications should use the ``bootindex=N'' parameter
-to set an absolute ordering between devices instead.
-
 @subsection -tdf (since 1.3.0)
 
 The ``-tdf'' argument is ignored. The behaviour implemented
-- 
2.13.6

From: Thomas Huth <thuth@redhat.com>

It's been marked as deprecated since QEMU v2.10.0, and so far nobody
complained that we should keep it, so let's remove this legacy option
now to simplify the code quite a bit.

Signed-off-by: Thomas Huth <thuth@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 vl.c            | 86 ++-------------------------------------------------------
 qemu-doc.texi   |  8 ------
 qemu-options.hx | 19 ++-----------
 3 files changed, 4 insertions(+), 109 deletions(-)

diff --git a/vl.c b/vl.c
index XXXXXXX..XXXXXXX 100644
--- a/vl.c
+++ b/vl.c
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
     const char *boot_order = NULL;
     const char *boot_once = NULL;
     DisplayState *ds;
-    int cyls, heads, secs, translation;
     QemuOpts *opts, *machine_opts;
-    QemuOpts *hda_opts = NULL, *icount_opts = NULL, *accel_opts = NULL;
+    QemuOpts *icount_opts = NULL, *accel_opts = NULL;
     QemuOptsList *olist;
     int optind;
     const char *optarg;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
 
     cpu_model = NULL;
     snapshot = 0;
-    cyls = heads = secs = 0;
-    translation = BIOS_ATA_TRANSLATION_AUTO;
 
     nb_nics = 0;
 
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
         if (optind >= argc)
             break;
         if (argv[optind][0] != '-') {
-            hda_opts = drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
+            drive_add(IF_DEFAULT, 0, argv[optind++], HD_OPTS);
         } else {
             const QEMUOption *popt;
 
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
                 cpu_model = optarg;
                 break;
             case QEMU_OPTION_hda:
-                {
-                    char buf[256];
-                    if (cyls == 0)
-                        snprintf(buf, sizeof(buf), "%s", HD_OPTS);
-                    else
-                        snprintf(buf, sizeof(buf),
-                                 "%s,cyls=%d,heads=%d,secs=%d%s",
-                                 HD_OPTS , cyls, heads, secs,
-                                 translation == BIOS_ATA_TRANSLATION_LBA ?
-                                 ",trans=lba" :
-                                 translation == BIOS_ATA_TRANSLATION_NONE ?
-                                 ",trans=none" : "");
-                    drive_add(IF_DEFAULT, 0, optarg, buf);
-                    break;
-                }
             case QEMU_OPTION_hdb:
             case QEMU_OPTION_hdc:
             case QEMU_OPTION_hdd:
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv, char **envp)
             case QEMU_OPTION_snapshot:
                 snapshot = 1;
                 break;
-            case QEMU_OPTION_hdachs:
-                {
-                    const char *p;
-                    p = optarg;
-                    cyls = strtol(p, (char **)&p, 0);
-                    if (cyls < 1 || cyls > 16383)
-                        goto chs_fail;
-                    if (*p != ',')
-                        goto chs_fail;
-                    p++;
-                    heads = strtol(p, (char **)&p, 0);
-                    if (heads < 1 || heads > 16)
-                        goto chs_fail;
-                    if (*p != ',')
-                        goto chs_fail;
-                    p++;
-                    secs = strtol(p, (char **)&p, 0);
-                    if (secs < 1 || secs > 63)
-                        goto chs_fail;
-                    if (*p == ',') {
-                        p++;
-                        if (!strcmp(p, "large")) {
-                            translation = BIOS_ATA_TRANSLATION_LARGE;
-                        } else if (!strcmp(p, "rechs")) {
-                            translation = BIOS_ATA_TRANSLATION_RECHS;
-                        } else if (!strcmp(p, "none")) {
-                            translation = BIOS_ATA_TRANSLATION_NONE;
-                        } else if (!strcmp(p, "lba")) {
-                            translation = BIOS_ATA_TRANSLATION_LBA;
-                        } else if (!strcmp(p, "auto")) {
-                            translation = BIOS_ATA_TRANSLATION_AUTO;
-                        } else {
-                            goto chs_fail;
-                        }
-                    } else if (*p != '\0') {
-                    chs_fail:
-                        error_report("invalid physical CHS format");
-                        exit(1);
-                    }
-                    if (hda_opts != NULL) {
-                        qemu_opt_set_number(hda_opts, "cyls", cyls,
-                                            &error_abort);
-                        qemu_opt_set_number(hda_opts, "heads", heads,
-                                            &error_abort);
-                        qemu_opt_set_number(hda_opts, "secs", secs,
-                                            &error_abort);
-                        if (translation == BIOS_ATA_TRANSLATION_LARGE) {
-                            qemu_opt_set(hda_opts, "trans", "large",
-                                         &error_abort);
-                        } else if (translation == BIOS_ATA_TRANSLATION_RECHS) {
-                            qemu_opt_set(hda_opts, "trans", "rechs",
-                                         &error_abort);
-                        } else if (translation == BIOS_ATA_TRANSLATION_LBA) {
-                            qemu_opt_set(hda_opts, "trans", "lba",
-                                         &error_abort);
-                        } else if (translation == BIOS_ATA_TRANSLATION_NONE) {
-                            qemu_opt_set(hda_opts, "trans", "none",
-                                         &error_abort);
-                        }
-                    }
-                }
-                error_report("'-hdachs' is deprecated, please use '-device"
-                             " ide-hd,cyls=c,heads=h,secs=s,...' instead");
-                break;
             case QEMU_OPTION_numa:
                 opts = qemu_opts_parse_noisily(qemu_find_opts("numa"),
                                                optarg, true);
diff --git a/qemu-doc.texi b/qemu-doc.texi
index XXXXXXX..XXXXXXX 100644
--- a/qemu-doc.texi
+++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ The ``--net dump'' argument is now replaced with the
 ``-object filter-dump'' argument which works in combination
 with the modern ``-netdev`` backends instead.
 
-@subsection -hdachs (since 2.10.0)
-
-The ``-hdachs'' argument is now a synonym for setting
-the ``cyls'', ``heads'', ``secs'', and ``trans'' properties
-on the ``ide-hd'' device using the ``-device'' argument.
-The new syntax allows different settings to be provided
-per disk.
-
 @subsection -usbdevice (since 2.10.0)
 
 The ``-usbdevice DEV'' argument is now a synonym for setting
diff --git a/qemu-options.hx b/qemu-options.hx
index XXXXXXX..XXXXXXX 100644
--- a/qemu-options.hx
+++ b/qemu-options.hx
@@ -XXX,XX +XXX,XX @@ of available connectors of a given interface type.
 @item media=@var{media}
 This option defines the type of the media: disk or cdrom.
 @item cyls=@var{c},heads=@var{h},secs=@var{s}[,trans=@var{t}]
-These options have the same definition as they have in @option{-hdachs}.
-These parameters are deprecated, use the corresponding parameters
+Force disk physical geometry and the optional BIOS translation (trans=none or
+lba). These parameters are deprecated, use the corresponding parameters
 of @code{-device} instead.
 @item snapshot=@var{snapshot}
 @var{snapshot} is "on" or "off" and controls snapshot mode for the given drive
@@ -XXX,XX +XXX,XX @@ the raw disk image you use is not written back. You can however force
 the write back by pressing @key{C-a s} (@pxref{disk_images}).
 ETEXI
 
-DEF("hdachs", HAS_ARG, QEMU_OPTION_hdachs, \
-    "-hdachs c,h,s[,t]\n" \
-    "                force hard disk 0 physical geometry and the optional BIOS\n" \
-    "                translation (t=none or lba) (usually QEMU can guess them)\n",
-    QEMU_ARCH_ALL)
-STEXI
-@item -hdachs @var{c},@var{h},@var{s},[,@var{t}]
-@findex -hdachs
-Force hard disk 0 physical geometry (1 <= @var{c} <= 16383, 1 <=
-@var{h} <= 16, 1 <= @var{s} <= 63) and optionally force the BIOS
-translation mode (@var{t}=none, lba or auto). Usually QEMU can guess
-all those parameters. This option is deprecated, please use
-@code{-device ide-hd,cyls=c,heads=h,secs=s,...} instead.
-ETEXI
-
 DEF("fsdev", HAS_ARG, QEMU_OPTION_fsdev,
     "-fsdev fsdriver,id=id[,path=path,][security_model={mapped-xattr|mapped-file|passthrough|none}]\n"
     " [,writeout=immediate][,readonly][,socket=socket|sock_fd=sock_fd][,fmode=fmode][,dmode=dmode]\n"
-- 
2.13.6

From: Thomas Huth <thuth@redhat.com>

Looks like we forgot to announce the deprecation of these options in
the corresponding chapter of the qemu-doc text, so let's do that now.

diff --git a/qemu-doc.texi b/qemu-doc.texi
index XXXXXXX..XXXXXXX 100644
--- a/qemu-doc.texi
+++ b/qemu-doc.texi
@@ -XXX,XX +XXX,XX @@ longer be directly supported in QEMU.
 The ``-drive if=scsi'' argument is replaced by the the
 ``-device BUS-TYPE'' argument combined with ``-drive if=none''.
 
+@subsection -drive cyls=...,heads=...,secs=...,trans=... (since 2.10.0)
+
+The drive geometry arguments are replaced by the the geometry arguments
+that can be specified with the ``-device'' parameter.
+
+@subsection -drive serial=... (since 2.10.0)
+
+The drive serial argument is replaced by the the serial argument
+that can be specified with the ``-device'' parameter.
+
+@subsection -drive addr=... (since 2.10.0)
+
+The drive addr argument is replaced by the the addr argument
+that can be specified with the ``-device'' parameter.
+
 @subsection -net dump (since 2.10.0)
 
 The ``--net dump'' argument is now replaced with the
-- 
2.13.6

From: Fam Zheng <famz@redhat.com>

Signed-off-by: Fam Zheng <famz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block_int.h |  1 -
 block/io.c                | 18 ------------------
 2 files changed, 19 deletions(-)

diff --git a/include/block/block_int.h b/include/block/block_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ bool blk_dev_is_tray_open(BlockBackend *blk);
 bool blk_dev_is_medium_locked(BlockBackend *blk);
 
 void bdrv_set_dirty(BlockDriverState *bs, int64_t offset, int64_t bytes);
-bool bdrv_requests_pending(BlockDriverState *bs);
 
 void bdrv_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap **out);
 void bdrv_undo_clear_dirty_bitmap(BdrvDirtyBitmap *bitmap, HBitmap *in);
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ void bdrv_disable_copy_on_read(BlockDriverState *bs)
     assert(old >= 1);
 }
 
-/* Check if any requests are in-flight (including throttled requests) */
-bool bdrv_requests_pending(BlockDriverState *bs)
-{
-    BdrvChild *child;
-
-    if (atomic_read(&bs->in_flight)) {
-        return true;
-    }
-
-    QLIST_FOREACH(child, &bs->children, next) {
-        if (bdrv_requests_pending(child->bs)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
 typedef struct {
     Coroutine *co;
     BlockDriverState *bs;
-- 
2.13.6

bdrv_drained_begin() doesn't increase bs->quiesce_counter recursively
and also doesn't notify other parent nodes of children, which both means
that the child nodes are not actually drained, and bdrv_drained_begin()
is providing useful functionality only on a single node.

To keep things consistent, we also shouldn't call the block driver
callbacks recursively.

A proper recursive drain version that provides an actually working
drained section for child nodes will be introduced later.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
---
 block/io.c | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_drain_invoke_entry(void *opaque)
 }
 
 /* Recursively call BlockDriver.bdrv_co_drain_begin/end callbacks */
-static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)
+static void bdrv_drain_invoke(BlockDriverState *bs, bool begin, bool recursive)
 {
     BdrvChild *child, *tmp;
     BdrvCoDrainData data = { .bs = bs, .done = false, .begin = begin};
@@ -XXX,XX +XXX,XX @@ static void bdrv_drain_invoke(BlockDriverState *bs, bool begin)
     bdrv_coroutine_enter(bs, data.co);
     BDRV_POLL_WHILE(bs, !data.done);
 
-    QLIST_FOREACH_SAFE(child, &bs->children, next, tmp) {
-        bdrv_drain_invoke(child->bs, begin);
+    if (recursive) {
+        QLIST_FOREACH_SAFE(child, &bs->children, next, tmp) {
+            bdrv_drain_invoke(child->bs, begin, true);
+        }
     }
 }
 
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)
         bdrv_parent_drained_begin(bs);
     }
 
-    bdrv_drain_invoke(bs, true);
+    bdrv_drain_invoke(bs, true, false);
     bdrv_drain_recurse(bs);
 }
 
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
     }
 
     /* Re-enable things in child-to-parent order */
-    bdrv_drain_invoke(bs, false);
+    bdrv_drain_invoke(bs, false, false);
     bdrv_parent_drained_end(bs);
     aio_enable_external(bdrv_get_aio_context(bs));
 }
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
         aio_context_acquire(aio_context);
         aio_disable_external(aio_context);
         bdrv_parent_drained_begin(bs);
-        bdrv_drain_invoke(bs, true);
+        bdrv_drain_invoke(bs, true, true);
         aio_context_release(aio_context);
 
         if (!g_slist_find(aio_ctxs, aio_context)) {
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
 
         /* Re-enable things in child-to-parent order */
         aio_context_acquire(aio_context);
-        bdrv_drain_invoke(bs, false);
+        bdrv_drain_invoke(bs, false, true);
         bdrv_parent_drained_end(bs);
         aio_enable_external(aio_context);
         aio_context_release(aio_context);
-- 
2.13.6

The existing test is for bdrv_drain_all_begin/end() only. Generalise the
test case so that it can be run for the other variants as well. At the
moment this is only bdrv_drain_begin/end(), but in a while, we'll add
another one.

Also, add a backing file to the test node to test whether the operations
work recursively.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/test-bdrv-drain.c | 69 ++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 62 insertions(+), 7 deletions(-)

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_test = {
 
     .bdrv_co_drain_begin    = bdrv_test_co_drain_begin,
     .bdrv_co_drain_end      = bdrv_test_co_drain_end,
+
+    .bdrv_child_perm        = bdrv_format_default_perms,
 };
 
 static void aio_ret_cb(void *opaque, int ret)
@@ -XXX,XX +XXX,XX @@ static void aio_ret_cb(void *opaque, int ret)
     *aio_ret = ret;
 }
 
-static void test_drv_cb_drain_all(void)
+enum drain_type {
+    BDRV_DRAIN_ALL,
+    BDRV_DRAIN,
+};
+
+static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
+{
+    switch (drain_type) {
+    case BDRV_DRAIN_ALL:        bdrv_drain_all_begin(); break;
+    case BDRV_DRAIN:            bdrv_drained_begin(bs); break;
+    default:                    g_assert_not_reached();
+    }
+}
+
+static void do_drain_end(enum drain_type drain_type, BlockDriverState *bs)
+{
+    switch (drain_type) {
+    case BDRV_DRAIN_ALL:        bdrv_drain_all_end(); break;
+    case BDRV_DRAIN:            bdrv_drained_end(bs); break;
+    default:                    g_assert_not_reached();
+    }
+}
+
+static void test_drv_cb_common(enum drain_type drain_type, bool recursive)
 {
     BlockBackend *blk;
-    BlockDriverState *bs;
-    BDRVTestState *s;
+    BlockDriverState *bs, *backing;
+    BDRVTestState *s, *backing_s;
     BlockAIOCB *acb;
     int aio_ret;
 
@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_drain_all(void)
     s = bs->opaque;
     blk_insert_bs(blk, bs, &error_abort);
 
+    backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
+    backing_s = backing->opaque;
+    bdrv_set_backing_hd(bs, backing, &error_abort);
+
     /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
     g_assert_cmpint(s->drain_count, ==, 0);
-    bdrv_drain_all_begin();
+    g_assert_cmpint(backing_s->drain_count, ==, 0);
+
+    do_drain_begin(drain_type, bs);
+
     g_assert_cmpint(s->drain_count, ==, 1);
-    bdrv_drain_all_end();
+    g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
+
+    do_drain_end(drain_type, bs);
+
     g_assert_cmpint(s->drain_count, ==, 0);
+    g_assert_cmpint(backing_s->drain_count, ==, 0);
 
     /* Now do the same while a request is pending */
     aio_ret = -EINPROGRESS;
@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_drain_all(void)
     g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
 
     g_assert_cmpint(s->drain_count, ==, 0);
-    bdrv_drain_all_begin();
+    g_assert_cmpint(backing_s->drain_count, ==, 0);
+
+    do_drain_begin(drain_type, bs);
+
     g_assert_cmpint(aio_ret, ==, 0);
     g_assert_cmpint(s->drain_count, ==, 1);
-    bdrv_drain_all_end();
+    g_assert_cmpint(backing_s->drain_count, ==, !!recursive);
+
+    do_drain_end(drain_type, bs);
+
     g_assert_cmpint(s->drain_count, ==, 0);
+    g_assert_cmpint(backing_s->drain_count, ==, 0);
 
+    bdrv_unref(backing);
     bdrv_unref(bs);
     blk_unref(blk);
 }
 
+static void test_drv_cb_drain_all(void)
+{
+    test_drv_cb_common(BDRV_DRAIN_ALL, true);
+}
+
+static void test_drv_cb_drain(void)
+{
+    test_drv_cb_common(BDRV_DRAIN, false);
+}
+
 int main(int argc, char **argv)
 {
     bdrv_init();
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_init(&argc, &argv, NULL);
 
     g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
+    g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
 
     return g_test_run();
 }
-- 
2.13.6

This is currently only working correctly for bdrv_drain(), not for
bdrv_drain_all(). Leave a comment for the drain_all case, we'll address
it later.

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

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_drain(void)
     test_drv_cb_common(BDRV_DRAIN, false);
 }
 
+static void test_quiesce_common(enum drain_type drain_type, bool recursive)
+{
+    BlockBackend *blk;
+    BlockDriverState *bs, *backing;
+
+    blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
+    bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
+                              &error_abort);
+    blk_insert_bs(blk, bs, &error_abort);
+
+    backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
+    bdrv_set_backing_hd(bs, backing, &error_abort);
+
+    g_assert_cmpint(bs->quiesce_counter, ==, 0);
+    g_assert_cmpint(backing->quiesce_counter, ==, 0);
+
+    do_drain_begin(drain_type, bs);
+
+    g_assert_cmpint(bs->quiesce_counter, ==, 1);
+    g_assert_cmpint(backing->quiesce_counter, ==, !!recursive);
+
+    do_drain_end(drain_type, bs);
+
+    g_assert_cmpint(bs->quiesce_counter, ==, 0);
+    g_assert_cmpint(backing->quiesce_counter, ==, 0);
+
+    bdrv_unref(backing);
+    bdrv_unref(bs);
+    blk_unref(blk);
+}
+
+static void test_quiesce_drain_all(void)
+{
+    // XXX drain_all doesn't quiesce
+    //test_quiesce_common(BDRV_DRAIN_ALL, true);
+}
+
+static void test_quiesce_drain(void)
+{
+    test_quiesce_common(BDRV_DRAIN, false);
+}
+
 int main(int argc, char **argv)
 {
     bdrv_init();
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
     g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
 
+    g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
+    g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
+
     return g_test_run();
 }
-- 
2.13.6

Block jobs already paused themselves when their main BlockBackend
entered a drained section. This is not good enough: We also want to
pause a block job and may not submit new requests if, for example, the
mirror target node should be drained.

This implements .drained_begin/end callbacks in child_job in order to
consider all block nodes related to the job, and removes the
BlockBackend callbacks which are unnecessary now because the root of the
job main BlockBackend is always referenced with a child_job, too.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockjob.c | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static char *child_job_get_parent_desc(BdrvChild *c)
                            job->id);
 }
 
-static const BdrvChildRole child_job = {
-    .get_parent_desc    = child_job_get_parent_desc,
-    .stay_at_node       = true,
-};
-
-static void block_job_drained_begin(void *opaque)
+static void child_job_drained_begin(BdrvChild *c)
 {
-    BlockJob *job = opaque;
+    BlockJob *job = c->opaque;
     block_job_pause(job);
 }
 
-static void block_job_drained_end(void *opaque)
+static void child_job_drained_end(BdrvChild *c)
 {
-    BlockJob *job = opaque;
+    BlockJob *job = c->opaque;
     block_job_resume(job);
 }
 
-static const BlockDevOps block_job_dev_ops = {
-    .drained_begin = block_job_drained_begin,
-    .drained_end = block_job_drained_end,
+static const BdrvChildRole child_job = {
+    .get_parent_desc    = child_job_get_parent_desc,
+    .drained_begin      = child_job_drained_begin,
+    .drained_end        = child_job_drained_end,
+    .stay_at_node       = true,
 };
 
 void block_job_remove_all_bdrv(BlockJob *job)
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
     block_job_add_bdrv(job, "main node", bs, 0, BLK_PERM_ALL, &error_abort);
     bs->job = job;
 
-    blk_set_dev_ops(blk, &block_job_dev_ops, job);
     bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
 
     QLIST_INSERT_HEAD(&block_jobs, job, job_list);
-- 
2.13.6

Block jobs must be paused if any of the involved nodes are drained.

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

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@
 
 #include "qemu/osdep.h"
 #include "block/block.h"
+#include "block/blockjob_int.h"
 #include "sysemu/block-backend.h"
 #include "qapi/error.h"
 
@@ -XXX,XX +XXX,XX @@ static void test_quiesce_drain(void)
     test_quiesce_common(BDRV_DRAIN, false);
 }
 
+
+typedef struct TestBlockJob {
+    BlockJob common;
+    bool should_complete;
+} TestBlockJob;
+
+static void test_job_completed(BlockJob *job, void *opaque)
+{
+    block_job_completed(job, 0);
+}
+
+static void coroutine_fn test_job_start(void *opaque)
+{
+    TestBlockJob *s = opaque;
+
+    while (!s->should_complete) {
+        block_job_sleep_ns(&s->common, 100000);
+    }
+
+    block_job_defer_to_main_loop(&s->common, test_job_completed, NULL);
+}
+
+static void test_job_complete(BlockJob *job, Error **errp)
+{
+    TestBlockJob *s = container_of(job, TestBlockJob, common);
+    s->should_complete = true;
+}
+
+BlockJobDriver test_job_driver = {
+    .instance_size  = sizeof(TestBlockJob),
+    .start          = test_job_start,
+    .complete       = test_job_complete,
+};
+
+static void test_blockjob_common(enum drain_type drain_type)
+{
+    BlockBackend *blk_src, *blk_target;
+    BlockDriverState *src, *target;
+    BlockJob *job;
+    int ret;
+
+    src = bdrv_new_open_driver(&bdrv_test, "source", BDRV_O_RDWR,
+                               &error_abort);
+    blk_src = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
+    blk_insert_bs(blk_src, src, &error_abort);
+
+    target = bdrv_new_open_driver(&bdrv_test, "target", BDRV_O_RDWR,
+                                  &error_abort);
+    blk_target = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
+    blk_insert_bs(blk_target, target, &error_abort);
+
+    job = block_job_create("job0", &test_job_driver, src, 0, BLK_PERM_ALL, 0,
+                           0, NULL, NULL, &error_abort);
+    block_job_add_bdrv(job, "target", target, 0, BLK_PERM_ALL, &error_abort);
+    block_job_start(job);
+
+    g_assert_cmpint(job->pause_count, ==, 0);
+    g_assert_false(job->paused);
+    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
+
+    do_drain_begin(drain_type, src);
+
+    if (drain_type == BDRV_DRAIN_ALL) {
+        /* bdrv_drain_all() drains both src and target, and involves an
+         * additional block_job_pause_all() */
+        g_assert_cmpint(job->pause_count, ==, 3);
+    } else {
+        g_assert_cmpint(job->pause_count, ==, 1);
+    }
+    /* XXX We don't wait until the job is actually paused. Is this okay? */
+    /* g_assert_true(job->paused); */
+    g_assert_false(job->busy); /* The job is paused */
+
+    do_drain_end(drain_type, src);
+
+    g_assert_cmpint(job->pause_count, ==, 0);
+    g_assert_false(job->paused);
+    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
+
+    do_drain_begin(drain_type, target);
+
+    if (drain_type == BDRV_DRAIN_ALL) {
+        /* bdrv_drain_all() drains both src and target, and involves an
+         * additional block_job_pause_all() */
+        g_assert_cmpint(job->pause_count, ==, 3);
+    } else {
+        g_assert_cmpint(job->pause_count, ==, 1);
+    }
+    /* XXX We don't wait until the job is actually paused. Is this okay? */
+    /* g_assert_true(job->paused); */
+    g_assert_false(job->busy); /* The job is paused */
+
+    do_drain_end(drain_type, target);
+
+    g_assert_cmpint(job->pause_count, ==, 0);
+    g_assert_false(job->paused);
+    g_assert_false(job->busy); /* We're in block_job_sleep_ns() */
+
+    ret = block_job_complete_sync(job, &error_abort);
+    g_assert_cmpint(ret, ==, 0);
+
+    blk_unref(blk_src);
+    blk_unref(blk_target);
+    bdrv_unref(src);
+    bdrv_unref(target);
+}
+
+static void test_blockjob_drain_all(void)
+{
+    test_blockjob_common(BDRV_DRAIN_ALL);
+}
+
+static void test_blockjob_drain(void)
+{
+    test_blockjob_common(BDRV_DRAIN);
+}
+
 int main(int argc, char **argv)
 {
     bdrv_init();
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
     g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
 
+    g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
+    g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
+
     return g_test_run();
 }
-- 
2.13.6

Block jobs are already paused using the BdrvChildRole drain callbacks,
so we don't need an additional block_job_pause_all() call.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/io.c              |  4 ----
 tests/test-bdrv-drain.c | 10 ++++------
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
      * context. */
     assert(qemu_get_current_aio_context() == qemu_get_aio_context());
 
-    block_job_pause_all();
-
     for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) {
         AioContext *aio_context = bdrv_get_aio_context(bs);
 
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
         aio_enable_external(aio_context);
         aio_context_release(aio_context);
     }
-
-    block_job_resume_all();
 }
 
 void bdrv_drain_all(void)
diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void test_blockjob_common(enum drain_type drain_type)
     do_drain_begin(drain_type, src);
 
     if (drain_type == BDRV_DRAIN_ALL) {
-        /* bdrv_drain_all() drains both src and target, and involves an
-         * additional block_job_pause_all() */
-        g_assert_cmpint(job->pause_count, ==, 3);
+        /* bdrv_drain_all() drains both src and target */
+        g_assert_cmpint(job->pause_count, ==, 2);
     } else {
         g_assert_cmpint(job->pause_count, ==, 1);
     }
@@ -XXX,XX +XXX,XX @@ static void test_blockjob_common(enum drain_type drain_type)
     do_drain_begin(drain_type, target);
 
     if (drain_type == BDRV_DRAIN_ALL) {
-        /* bdrv_drain_all() drains both src and target, and involves an
-         * additional block_job_pause_all() */
-        g_assert_cmpint(job->pause_count, ==, 3);
+        /* bdrv_drain_all() drains both src and target */
+        g_assert_cmpint(job->pause_count, ==, 2);
     } else {
         g_assert_cmpint(job->pause_count, ==, 1);
     }
-- 
2.13.6

bdrv_do_drained_begin() restricts the call of parent callbacks and
aio_disable_external() to the outermost drain section, but the block
driver callbacks are always called. bdrv_do_drained_end() must match
this behaviour, otherwise nodes stay drained even if begin/end calls
were balanced.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/io.c | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)
 
 void bdrv_drained_end(BlockDriverState *bs)
 {
+    int old_quiesce_counter;
+
     if (qemu_in_coroutine()) {
         bdrv_co_yield_to_drain(bs, false);
         return;
     }
     assert(bs->quiesce_counter > 0);
-    if (atomic_fetch_dec(&bs->quiesce_counter) > 1) {
-        return;
-    }
+    old_quiesce_counter = atomic_fetch_dec(&bs->quiesce_counter);
 
     /* Re-enable things in child-to-parent order */
     bdrv_drain_invoke(bs, false, false);
-    bdrv_parent_drained_end(bs);
-    aio_enable_external(bdrv_get_aio_context(bs));
+    if (old_quiesce_counter == 1) {
+        bdrv_parent_drained_end(bs);
+        aio_enable_external(bdrv_get_aio_context(bs));
+    }
 }
 
 /*
-- 
2.13.6

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

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void aio_ret_cb(void *opaque, int ret)
 enum drain_type {
     BDRV_DRAIN_ALL,
     BDRV_DRAIN,
+    DRAIN_TYPE_MAX,
 };
 
 static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
@@ -XXX,XX +XXX,XX @@ static void test_quiesce_drain(void)
     test_quiesce_common(BDRV_DRAIN, false);
 }
 
+static void test_nested(void)
+{
+    BlockBackend *blk;
+    BlockDriverState *bs, *backing;
+    BDRVTestState *s, *backing_s;
+    enum drain_type outer, inner;
+
+    blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
+    bs = bdrv_new_open_driver(&bdrv_test, "test-node", BDRV_O_RDWR,
+                              &error_abort);
+    s = bs->opaque;
+    blk_insert_bs(blk, bs, &error_abort);
+
+    backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
+    backing_s = backing->opaque;
+    bdrv_set_backing_hd(bs, backing, &error_abort);
+
+    for (outer = 0; outer < DRAIN_TYPE_MAX; outer++) {
+        for (inner = 0; inner < DRAIN_TYPE_MAX; inner++) {
+            /* XXX bdrv_drain_all() doesn't increase the quiesce_counter */
+            int bs_quiesce      = (outer != BDRV_DRAIN_ALL) +
+                                  (inner != BDRV_DRAIN_ALL);
+            int backing_quiesce = 0;
+            int backing_cb_cnt  = (outer != BDRV_DRAIN) +
+                                  (inner != BDRV_DRAIN);
+
+            g_assert_cmpint(bs->quiesce_counter, ==, 0);
+            g_assert_cmpint(backing->quiesce_counter, ==, 0);
+            g_assert_cmpint(s->drain_count, ==, 0);
+            g_assert_cmpint(backing_s->drain_count, ==, 0);
+
+            do_drain_begin(outer, bs);
+            do_drain_begin(inner, bs);
+
+            g_assert_cmpint(bs->quiesce_counter, ==, bs_quiesce);
+            g_assert_cmpint(backing->quiesce_counter, ==, backing_quiesce);
+            g_assert_cmpint(s->drain_count, ==, 2);
+            g_assert_cmpint(backing_s->drain_count, ==, backing_cb_cnt);
+
+            do_drain_end(inner, bs);
+            do_drain_end(outer, bs);
+
+            g_assert_cmpint(bs->quiesce_counter, ==, 0);
+            g_assert_cmpint(backing->quiesce_counter, ==, 0);
+            g_assert_cmpint(s->drain_count, ==, 0);
+            g_assert_cmpint(backing_s->drain_count, ==, 0);
+        }
+    }
+
+    bdrv_unref(backing);
+    bdrv_unref(bs);
+    blk_unref(blk);
+}
+
 
 typedef struct TestBlockJob {
     BlockJob common;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
     g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
 
+    g_test_add_func("/bdrv-drain/nested", test_nested);
+
     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
     g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
 
-- 
2.13.6

This is in preparation for subtree drains, i.e. drained sections that
affect not only a single node, but recursively all child nodes, too.

Calling the parent callbacks for drain is pointless when we just came
from that parent node recursively and leads to multiple increases of
bs->quiesce_counter in a single drain call. Don't do it.

In order for this to work correctly, the parent callback must be called
for every bdrv_drain_begin/end() call, not only for the outermost one:

If we have a node N with two parents A and B, recursive draining of A
should cause the quiesce_counter of B to increase because its child N is
drained independently of B. If now B is recursively drained, too, A must
increase its quiesce_counter because N is drained independently of A
only now, even if N is going from quiesce_counter 1 to 2.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block.h |  4 ++--
 block.c               | 13 +++++++++----
 block/io.c            | 47 ++++++++++++++++++++++++++++++++++-------------
 3 files changed, 45 insertions(+), 19 deletions(-)

diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ void bdrv_io_unplug(BlockDriverState *bs);
  * Begin a quiesced section of all users of @bs. This is part of
  * bdrv_drained_begin.
  */
-void bdrv_parent_drained_begin(BlockDriverState *bs);
+void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore);
 
 /**
  * bdrv_parent_drained_end:
@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_begin(BlockDriverState *bs);
  * End a quiesced section of all users of @bs. This is part of
  * bdrv_drained_end.
  */
-void bdrv_parent_drained_end(BlockDriverState *bs);
+void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore);
 
 /**
  * bdrv_drained_begin:
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
                                       BlockDriverState *new_bs)
 {
     BlockDriverState *old_bs = child->bs;
+    int i;
 
     if (old_bs && new_bs) {
         assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
     }
     if (old_bs) {
         if (old_bs->quiesce_counter && child->role->drained_end) {
-            child->role->drained_end(child);
+            for (i = 0; i < old_bs->quiesce_counter; i++) {
+                child->role->drained_end(child);
+            }
         }
         if (child->role->detach) {
             child->role->detach(child);
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
     if (new_bs) {
         QLIST_INSERT_HEAD(&new_bs->parents, child, next_parent);
         if (new_bs->quiesce_counter && child->role->drained_begin) {
-            child->role->drained_begin(child);
+            for (i = 0; i < new_bs->quiesce_counter; i++) {
+                child->role->drained_begin(child);
+            }
         }
 
         if (child->role->attach) {
@@ -XXX,XX +XXX,XX @@ void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
     AioContext *ctx = bdrv_get_aio_context(bs);
 
     aio_disable_external(ctx);
-    bdrv_parent_drained_begin(bs);
+    bdrv_parent_drained_begin(bs, NULL);
     bdrv_drain(bs); /* ensure there are no in-flight requests */
 
     while (aio_poll(ctx, false)) {
@@ -XXX,XX +XXX,XX @@ void bdrv_set_aio_context(BlockDriverState *bs, AioContext *new_context)
      */
     aio_context_acquire(new_context);
     bdrv_attach_aio_context(bs, new_context);
-    bdrv_parent_drained_end(bs);
+    bdrv_parent_drained_end(bs, NULL);
     aio_enable_external(ctx);
     aio_context_release(new_context);
 }
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@
 static int coroutine_fn bdrv_co_do_pwrite_zeroes(BlockDriverState *bs,
     int64_t offset, int bytes, BdrvRequestFlags flags);
 
-void bdrv_parent_drained_begin(BlockDriverState *bs)
+void bdrv_parent_drained_begin(BlockDriverState *bs, BdrvChild *ignore)
 {
     BdrvChild *c, *next;
 
     QLIST_FOREACH_SAFE(c, &bs->parents, next_parent, next) {
+        if (c == ignore) {
+            continue;
+        }
         if (c->role->drained_begin) {
             c->role->drained_begin(c);
         }
     }
 }
 
-void bdrv_parent_drained_end(BlockDriverState *bs)
+void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore)
 {
     BdrvChild *c, *next;
 
     QLIST_FOREACH_SAFE(c, &bs->parents, next_parent, next) {
+        if (c == ignore) {
+            continue;
+        }
         if (c->role->drained_end) {
             c->role->drained_end(c);
         }
@@ -XXX,XX +XXX,XX @@ typedef struct {
     BlockDriverState *bs;
     bool done;
     bool begin;
+    BdrvChild *parent;
 } BdrvCoDrainData;
 
 static void coroutine_fn bdrv_drain_invoke_entry(void *opaque)
@@ -XXX,XX +XXX,XX @@ static bool bdrv_drain_recurse(BlockDriverState *bs)
     return waited;
 }
 
+static void bdrv_do_drained_begin(BlockDriverState *bs, BdrvChild *parent);
+static void bdrv_do_drained_end(BlockDriverState *bs, BdrvChild *parent);
+
 static void bdrv_co_drain_bh_cb(void *opaque)
 {
     BdrvCoDrainData *data = opaque;
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_drain_bh_cb(void *opaque)
 
     bdrv_dec_in_flight(bs);
     if (data->begin) {
-        bdrv_drained_begin(bs);
+        bdrv_do_drained_begin(bs, data->parent);
     } else {
-        bdrv_drained_end(bs);
+        bdrv_do_drained_end(bs, data->parent);
     }
 
     data->done = true;
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_drain_bh_cb(void *opaque)
 }
 
 static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
-                                                bool begin)
+                                                bool begin, BdrvChild *parent)
 {
     BdrvCoDrainData data;
 
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
         .bs = bs,
         .done = false,
         .begin = begin,
+        .parent = parent,
     };
     bdrv_inc_in_flight(bs);
     aio_bh_schedule_oneshot(bdrv_get_aio_context(bs),
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
     assert(data.done);
 }
 
-void bdrv_drained_begin(BlockDriverState *bs)
+static void bdrv_do_drained_begin(BlockDriverState *bs, BdrvChild *parent)
 {
     if (qemu_in_coroutine()) {
-        bdrv_co_yield_to_drain(bs, true);
+        bdrv_co_yield_to_drain(bs, true, parent);
         return;
     }
 
     /* Stop things in parent-to-child order */
     if (atomic_fetch_inc(&bs->quiesce_counter) == 0) {
         aio_disable_external(bdrv_get_aio_context(bs));
-        bdrv_parent_drained_begin(bs);
     }
 
+    bdrv_parent_drained_begin(bs, parent);
     bdrv_drain_invoke(bs, true, false);
     bdrv_drain_recurse(bs);
 }
 
-void bdrv_drained_end(BlockDriverState *bs)
+void bdrv_drained_begin(BlockDriverState *bs)
+{
+    bdrv_do_drained_begin(bs, NULL);
+}
+
+static void bdrv_do_drained_end(BlockDriverState *bs, BdrvChild *parent)
 {
     int old_quiesce_counter;
 
     if (qemu_in_coroutine()) {
-        bdrv_co_yield_to_drain(bs, false);
+        bdrv_co_yield_to_drain(bs, false, parent);
         return;
     }
     assert(bs->quiesce_counter > 0);
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
 
     /* Re-enable things in child-to-parent order */
     bdrv_drain_invoke(bs, false, false);
+    bdrv_parent_drained_end(bs, parent);
     if (old_quiesce_counter == 1) {
-        bdrv_parent_drained_end(bs);
         aio_enable_external(bdrv_get_aio_context(bs));
     }
 }
 
+void bdrv_drained_end(BlockDriverState *bs)
+{
+    bdrv_do_drained_end(bs, NULL);
+}
+
 /*
  * Wait for pending requests to complete on a single BlockDriverState subtree,
  * and suspend block driver's internal I/O until next request arrives.
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_begin(void)
         /* Stop things in parent-to-child order */
         aio_context_acquire(aio_context);
         aio_disable_external(aio_context);
-        bdrv_parent_drained_begin(bs);
+        bdrv_parent_drained_begin(bs, NULL);
         bdrv_drain_invoke(bs, true, true);
         aio_context_release(aio_context);
 
@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
         /* Re-enable things in child-to-parent order */
         aio_context_acquire(aio_context);
         bdrv_drain_invoke(bs, false, true);
-        bdrv_parent_drained_end(bs);
+        bdrv_parent_drained_end(bs, NULL);
         aio_enable_external(aio_context);
         aio_context_release(aio_context);
     }
-- 
2.13.6

bdrv_drained_begin() waits for the completion of requests in the whole
subtree, but it only actually keeps its immediate bs parameter quiesced
until bdrv_drained_end().

Add a version that keeps the whole subtree drained. As of this commit,
graph changes cannot be allowed during a subtree drained section, but
this will be fixed soon.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block.h | 13 +++++++++++++
 block/io.c            | 54 ++++++++++++++++++++++++++++++++++++++++-----------
 2 files changed, 56 insertions(+), 11 deletions(-)

diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore);
 void bdrv_drained_begin(BlockDriverState *bs);
 
 /**
+ * Like bdrv_drained_begin, but recursively begins a quiesced section for
+ * exclusive access to all child nodes as well.
+ *
+ * Graph changes are not allowed during a subtree drain section.
+ */
+void bdrv_subtree_drained_begin(BlockDriverState *bs);
+
+/**
  * bdrv_drained_end:
  *
  * End a quiescent section started by bdrv_drained_begin().
  */
 void bdrv_drained_end(BlockDriverState *bs);
 
+/**
+ * End a quiescent section started by bdrv_subtree_drained_begin().
+ */
+void bdrv_subtree_drained_end(BlockDriverState *bs);
+
 void bdrv_add_child(BlockDriverState *parent, BlockDriverState *child,
                     Error **errp);
 void bdrv_del_child(BlockDriverState *parent, BdrvChild *child, Error **errp);
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ typedef struct {
     BlockDriverState *bs;
     bool done;
     bool begin;
+    bool recursive;
     BdrvChild *parent;
 } BdrvCoDrainData;
 
@@ -XXX,XX +XXX,XX @@ static bool bdrv_drain_recurse(BlockDriverState *bs)
     return waited;
 }
 
-static void bdrv_do_drained_begin(BlockDriverState *bs, BdrvChild *parent);
-static void bdrv_do_drained_end(BlockDriverState *bs, BdrvChild *parent);
+static void bdrv_do_drained_begin(BlockDriverState *bs, bool recursive,
+                                  BdrvChild *parent);
+static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
+                                BdrvChild *parent);
 
 static void bdrv_co_drain_bh_cb(void *opaque)
 {
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_drain_bh_cb(void *opaque)
 
     bdrv_dec_in_flight(bs);
     if (data->begin) {
-        bdrv_do_drained_begin(bs, data->parent);
+        bdrv_do_drained_begin(bs, data->recursive, data->parent);
     } else {
-        bdrv_do_drained_end(bs, data->parent);
+        bdrv_do_drained_end(bs, data->recursive, data->parent);
     }
 
     data->done = true;
@@ -XXX,XX +XXX,XX @@ static void bdrv_co_drain_bh_cb(void *opaque)
 }
 
 static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
-                                                bool begin, BdrvChild *parent)
+                                                bool begin, bool recursive,
+                                                BdrvChild *parent)
 {
     BdrvCoDrainData data;
 
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
         .bs = bs,
         .done = false,
         .begin = begin,
+        .recursive = recursive,
         .parent = parent,
     };
     bdrv_inc_in_flight(bs);
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
     assert(data.done);
 }
 
-static void bdrv_do_drained_begin(BlockDriverState *bs, BdrvChild *parent)
+static void bdrv_do_drained_begin(BlockDriverState *bs, bool recursive,
+                                  BdrvChild *parent)
 {
+    BdrvChild *child, *next;
+
     if (qemu_in_coroutine()) {
-        bdrv_co_yield_to_drain(bs, true, parent);
+        bdrv_co_yield_to_drain(bs, true, recursive, parent);
         return;
     }
 
@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_begin(BlockDriverState *bs, BdrvChild *parent)
     bdrv_parent_drained_begin(bs, parent);
     bdrv_drain_invoke(bs, true, false);
     bdrv_drain_recurse(bs);
+
+    if (recursive) {
+        QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
+            bdrv_do_drained_begin(child->bs, true, child);
+        }
+    }
 }
 
 void bdrv_drained_begin(BlockDriverState *bs)
 {
-    bdrv_do_drained_begin(bs, NULL);
+    bdrv_do_drained_begin(bs, false, NULL);
+}
+
+void bdrv_subtree_drained_begin(BlockDriverState *bs)
+{
+    bdrv_do_drained_begin(bs, true, NULL);
 }
 
-static void bdrv_do_drained_end(BlockDriverState *bs, BdrvChild *parent)
+static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
+                                BdrvChild *parent)
 {
+    BdrvChild *child, *next;
     int old_quiesce_counter;
 
     if (qemu_in_coroutine()) {
-        bdrv_co_yield_to_drain(bs, false, parent);
+        bdrv_co_yield_to_drain(bs, false, recursive, parent);
         return;
     }
     assert(bs->quiesce_counter > 0);
@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_end(BlockDriverState *bs, BdrvChild *parent)
     if (old_quiesce_counter == 1) {
         aio_enable_external(bdrv_get_aio_context(bs));
     }
+
+    if (recursive) {
+        QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
+            bdrv_do_drained_end(child->bs, true, child);
+        }
+    }
 }
 
 void bdrv_drained_end(BlockDriverState *bs)
 {
-    bdrv_do_drained_end(bs, NULL);
+    bdrv_do_drained_end(bs, false, NULL);
+}
+
+void bdrv_subtree_drained_end(BlockDriverState *bs)
+{
+    bdrv_do_drained_end(bs, true, NULL);
 }
 
 /*
-- 
2.13.6

Add a subtree drain version to the existing test cases.

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

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void aio_ret_cb(void *opaque, int ret)
 enum drain_type {
     BDRV_DRAIN_ALL,
     BDRV_DRAIN,
+    BDRV_SUBTREE_DRAIN,
     DRAIN_TYPE_MAX,
 };
 
@@ -XXX,XX +XXX,XX @@ static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
     switch (drain_type) {
     case BDRV_DRAIN_ALL:        bdrv_drain_all_begin(); break;
     case BDRV_DRAIN:            bdrv_drained_begin(bs); break;
+    case BDRV_SUBTREE_DRAIN:    bdrv_subtree_drained_begin(bs); break;
     default:                    g_assert_not_reached();
     }
 }
@@ -XXX,XX +XXX,XX @@ static void do_drain_end(enum drain_type drain_type, BlockDriverState *bs)
     switch (drain_type) {
     case BDRV_DRAIN_ALL:        bdrv_drain_all_end(); break;
     case BDRV_DRAIN:            bdrv_drained_end(bs); break;
+    case BDRV_SUBTREE_DRAIN:    bdrv_subtree_drained_end(bs); break;
     default:                    g_assert_not_reached();
     }
 }
@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_drain(void)
     test_drv_cb_common(BDRV_DRAIN, false);
 }
 
+static void test_drv_cb_drain_subtree(void)
+{
+    test_drv_cb_common(BDRV_SUBTREE_DRAIN, true);
+}
+
 static void test_quiesce_common(enum drain_type drain_type, bool recursive)
 {
     BlockBackend *blk;
@@ -XXX,XX +XXX,XX @@ static void test_quiesce_drain(void)
     test_quiesce_common(BDRV_DRAIN, false);
 }
 
+static void test_quiesce_drain_subtree(void)
+{
+    test_quiesce_common(BDRV_SUBTREE_DRAIN, true);
+}
+
 static void test_nested(void)
 {
     BlockBackend *blk;
@@ -XXX,XX +XXX,XX @@ static void test_nested(void)
             /* XXX bdrv_drain_all() doesn't increase the quiesce_counter */
             int bs_quiesce      = (outer != BDRV_DRAIN_ALL) +
                                   (inner != BDRV_DRAIN_ALL);
-            int backing_quiesce = 0;
+            int backing_quiesce = (outer == BDRV_SUBTREE_DRAIN) +
+                                  (inner == BDRV_SUBTREE_DRAIN);
             int backing_cb_cnt  = (outer != BDRV_DRAIN) +
                                   (inner != BDRV_DRAIN);
 
@@ -XXX,XX +XXX,XX @@ static void test_blockjob_drain(void)
     test_blockjob_common(BDRV_DRAIN);
 }
 
+static void test_blockjob_drain_subtree(void)
+{
+    test_blockjob_common(BDRV_SUBTREE_DRAIN);
+}
+
 int main(int argc, char **argv)
 {
     bdrv_init();
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
 
     g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
     g_test_add_func("/bdrv-drain/driver-cb/drain", test_drv_cb_drain);
+    g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
+                    test_drv_cb_drain_subtree);
 
     g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
     g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
+    g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
+                    test_quiesce_drain_subtree);
 
     g_test_add_func("/bdrv-drain/nested", test_nested);
 
     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
     g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
+    g_test_add_func("/bdrv-drain/blockjob/drain_subtree",
+                    test_blockjob_drain_subtree);
 
     return g_test_run();
 }
-- 
2.13.6

If bdrv_do_drained_begin/end() are called in coroutine context, they
first use a BH to get out of the coroutine context. Call some existing
tests again from a coroutine to cover this code path.

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

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void aio_ret_cb(void *opaque, int ret)
     *aio_ret = ret;
 }
 
+typedef struct CallInCoroutineData {
+    void (*entry)(void);
+    bool done;
+} CallInCoroutineData;
+
+static coroutine_fn void call_in_coroutine_entry(void *opaque)
+{
+    CallInCoroutineData *data = opaque;
+
+    data->entry();
+    data->done = true;
+}
+
+static void call_in_coroutine(void (*entry)(void))
+{
+    Coroutine *co;
+    CallInCoroutineData data = {
+        .entry  = entry,
+        .done   = false,
+    };
+
+    co = qemu_coroutine_create(call_in_coroutine_entry, &data);
+    qemu_coroutine_enter(co);
+    while (!data.done) {
+        aio_poll(qemu_get_aio_context(), true);
+    }
+}
+
 enum drain_type {
     BDRV_DRAIN_ALL,
     BDRV_DRAIN,
@@ -XXX,XX +XXX,XX @@ static void test_drv_cb_drain_subtree(void)
     test_drv_cb_common(BDRV_SUBTREE_DRAIN, true);
 }
 
+static void test_drv_cb_co_drain(void)
+{
+    call_in_coroutine(test_drv_cb_drain);
+}
+
+static void test_drv_cb_co_drain_subtree(void)
+{
+    call_in_coroutine(test_drv_cb_drain_subtree);
+}
+
 static void test_quiesce_common(enum drain_type drain_type, bool recursive)
 {
     BlockBackend *blk;
@@ -XXX,XX +XXX,XX @@ static void test_quiesce_drain_subtree(void)
     test_quiesce_common(BDRV_SUBTREE_DRAIN, true);
 }
 
+static void test_quiesce_co_drain(void)
+{
+    call_in_coroutine(test_quiesce_drain);
+}
+
+static void test_quiesce_co_drain_subtree(void)
+{
+    call_in_coroutine(test_quiesce_drain_subtree);
+}
+
 static void test_nested(void)
 {
     BlockBackend *blk;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
     g_test_add_func("/bdrv-drain/driver-cb/drain_subtree",
                     test_drv_cb_drain_subtree);
 
+    // XXX bdrv_drain_all() doesn't work in coroutine context
+    g_test_add_func("/bdrv-drain/driver-cb/co/drain", test_drv_cb_co_drain);
+    g_test_add_func("/bdrv-drain/driver-cb/co/drain_subtree",
+                    test_drv_cb_co_drain_subtree);
+
+
     g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
     g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
     g_test_add_func("/bdrv-drain/quiesce/drain_subtree",
                     test_quiesce_drain_subtree);
 
+    // XXX bdrv_drain_all() doesn't work in coroutine context
+    g_test_add_func("/bdrv-drain/quiesce/co/drain", test_quiesce_co_drain);
+    g_test_add_func("/bdrv-drain/quiesce/co/drain_subtree",
+                    test_quiesce_co_drain_subtree);
+
     g_test_add_func("/bdrv-drain/nested", test_nested);
 
     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
-- 
2.13.6

Test that drain sections are correctly propagated through the graph.

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

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void test_nested(void)
     blk_unref(blk);
 }
 
+static void test_multiparent(void)
+{
+    BlockBackend *blk_a, *blk_b;
+    BlockDriverState *bs_a, *bs_b, *backing;
+    BDRVTestState *a_s, *b_s, *backing_s;
+
+    blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
+    bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
+                                &error_abort);
+    a_s = bs_a->opaque;
+    blk_insert_bs(blk_a, bs_a, &error_abort);
+
+    blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
+    bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
+                                &error_abort);
+    b_s = bs_b->opaque;
+    blk_insert_bs(blk_b, bs_b, &error_abort);
+
+    backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
+    backing_s = backing->opaque;
+    bdrv_set_backing_hd(bs_a, backing, &error_abort);
+    bdrv_set_backing_hd(bs_b, backing, &error_abort);
+
+    g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
+    g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
+    g_assert_cmpint(backing->quiesce_counter, ==, 0);
+    g_assert_cmpint(a_s->drain_count, ==, 0);
+    g_assert_cmpint(b_s->drain_count, ==, 0);
+    g_assert_cmpint(backing_s->drain_count, ==, 0);
+
+    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
+
+    g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
+    g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
+    g_assert_cmpint(backing->quiesce_counter, ==, 1);
+    g_assert_cmpint(a_s->drain_count, ==, 1);
+    g_assert_cmpint(b_s->drain_count, ==, 1);
+    g_assert_cmpint(backing_s->drain_count, ==, 1);
+
+    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
+
+    g_assert_cmpint(bs_a->quiesce_counter, ==, 2);
+    g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
+    g_assert_cmpint(backing->quiesce_counter, ==, 2);
+    g_assert_cmpint(a_s->drain_count, ==, 2);
+    g_assert_cmpint(b_s->drain_count, ==, 2);
+    g_assert_cmpint(backing_s->drain_count, ==, 2);
+
+    do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
+
+    g_assert_cmpint(bs_a->quiesce_counter, ==, 1);
+    g_assert_cmpint(bs_b->quiesce_counter, ==, 1);
+    g_assert_cmpint(backing->quiesce_counter, ==, 1);
+    g_assert_cmpint(a_s->drain_count, ==, 1);
+    g_assert_cmpint(b_s->drain_count, ==, 1);
+    g_assert_cmpint(backing_s->drain_count, ==, 1);
+
+    do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
+
+    g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
+    g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
+    g_assert_cmpint(backing->quiesce_counter, ==, 0);
+    g_assert_cmpint(a_s->drain_count, ==, 0);
+    g_assert_cmpint(b_s->drain_count, ==, 0);
+    g_assert_cmpint(backing_s->drain_count, ==, 0);
+
+    bdrv_unref(backing);
+    bdrv_unref(bs_a);
+    bdrv_unref(bs_b);
+    blk_unref(blk_a);
+    blk_unref(blk_b);
+}
+
 
 typedef struct TestBlockJob {
     BlockJob common;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
                     test_quiesce_co_drain_subtree);
 
     g_test_add_func("/bdrv-drain/nested", test_nested);
+    g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
 
     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
     g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
-- 
2.13.6

We need to remember how many of the drain sections in which a node is
were recursive (i.e. subtree drain rather than node drain), so that they
can be correctly applied when children are added or removed during the
drained section.

With this change, it is safe to modify the graph even inside a
bdrv_subtree_drained_begin/end() section.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block.h     |  2 --
 include/block/block_int.h |  5 +++++
 block.c                   | 32 +++++++++++++++++++++++++++++---
 block/io.c                | 28 ++++++++++++++++++++++++----
 4 files changed, 58 insertions(+), 9 deletions(-)

diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs);
 /**
  * Like bdrv_drained_begin, but recursively begins a quiesced section for
  * exclusive access to all child nodes as well.
- *
- * Graph changes are not allowed during a subtree drain section.
  */
 void bdrv_subtree_drained_begin(BlockDriverState *bs);
 
diff --git a/include/block/block_int.h b/include/block/block_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriverState {
 
     /* Accessed with atomic ops.  */
     int quiesce_counter;
+    int recursive_quiesce_counter;
+
     unsigned int write_gen;               /* Current data generation */
 
     /* Protected by reqs_lock.  */
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
     int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
     BdrvRequestFlags flags);
 
+void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent);
+void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent);
+
 int get_tmp_filename(char *filename, int size);
 BlockDriver *bdrv_probe_all(const uint8_t *buf, int buf_size,
                             const char *filename);
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_child_cb_drained_end(BdrvChild *child)
     bdrv_drained_end(bs);
 }
 
+static void bdrv_child_cb_attach(BdrvChild *child)
+{
+    BlockDriverState *bs = child->opaque;
+    bdrv_apply_subtree_drain(child, bs);
+}
+
+static void bdrv_child_cb_detach(BdrvChild *child)
+{
+    BlockDriverState *bs = child->opaque;
+    bdrv_unapply_subtree_drain(child, bs);
+}
+
 static int bdrv_child_cb_inactivate(BdrvChild *child)
 {
     BlockDriverState *bs = child->opaque;
@@ -XXX,XX +XXX,XX @@ const BdrvChildRole child_file = {
     .inherit_options = bdrv_inherited_options,
     .drained_begin   = bdrv_child_cb_drained_begin,
     .drained_end     = bdrv_child_cb_drained_end,
+    .attach          = bdrv_child_cb_attach,
+    .detach          = bdrv_child_cb_detach,
     .inactivate      = bdrv_child_cb_inactivate,
 };
 
@@ -XXX,XX +XXX,XX @@ const BdrvChildRole child_format = {
     .inherit_options = bdrv_inherited_fmt_options,
     .drained_begin   = bdrv_child_cb_drained_begin,
     .drained_end     = bdrv_child_cb_drained_end,
+    .attach          = bdrv_child_cb_attach,
+    .detach          = bdrv_child_cb_detach,
     .inactivate      = bdrv_child_cb_inactivate,
 };
 
@@ -XXX,XX +XXX,XX @@ static void bdrv_backing_attach(BdrvChild *c)
                     parent->backing_blocker);
     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
                     parent->backing_blocker);
+
+    bdrv_child_cb_attach(c);
 }
 
 static void bdrv_backing_detach(BdrvChild *c)
@@ -XXX,XX +XXX,XX @@ static void bdrv_backing_detach(BdrvChild *c)
     bdrv_op_unblock_all(c->bs, parent->backing_blocker);
     error_free(parent->backing_blocker);
     parent->backing_blocker = NULL;
+
+    bdrv_child_cb_detach(c);
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
         assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));
     }
     if (old_bs) {
+        /* Detach first so that the recursive drain sections coming from @child
+         * are already gone and we only end the drain sections that came from
+         * elsewhere. */
+        if (child->role->detach) {
+            child->role->detach(child);
+        }
         if (old_bs->quiesce_counter && child->role->drained_end) {
             for (i = 0; i < old_bs->quiesce_counter; i++) {
                 child->role->drained_end(child);
             }
         }
-        if (child->role->detach) {
-            child->role->detach(child);
-        }
         QLIST_REMOVE(child, next_parent);
     }
 
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
             }
         }
 
+        /* Attach only after starting new drained sections, so that recursive
+         * drain sections coming from @child don't get an extra .drained_begin
+         * callback. */
         if (child->role->attach) {
             child->role->attach(child);
         }
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
     assert(data.done);
 }
 
-static void bdrv_do_drained_begin(BlockDriverState *bs, bool recursive,
-                                  BdrvChild *parent)
+void bdrv_do_drained_begin(BlockDriverState *bs, bool recursive,
+                           BdrvChild *parent)
 {
     BdrvChild *child, *next;
 
@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_begin(BlockDriverState *bs, bool recursive,
     bdrv_drain_recurse(bs);
 
     if (recursive) {
+        bs->recursive_quiesce_counter++;
         QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
             bdrv_do_drained_begin(child->bs, true, child);
         }
@@ -XXX,XX +XXX,XX @@ void bdrv_subtree_drained_begin(BlockDriverState *bs)
     bdrv_do_drained_begin(bs, true, NULL);
 }
 
-static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
-                                BdrvChild *parent)
+void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
+                         BdrvChild *parent)
 {
     BdrvChild *child, *next;
     int old_quiesce_counter;
@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
     }
 
     if (recursive) {
+        bs->recursive_quiesce_counter--;
         QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
             bdrv_do_drained_end(child->bs, true, child);
         }
@@ -XXX,XX +XXX,XX @@ void bdrv_subtree_drained_end(BlockDriverState *bs)
     bdrv_do_drained_end(bs, true, NULL);
 }
 
+void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent)
+{
+    int i;
+
+    for (i = 0; i < new_parent->recursive_quiesce_counter; i++) {
+        bdrv_do_drained_begin(child->bs, true, child);
+    }
+}
+
+void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent)
+{
+    int i;
+
+    for (i = 0; i < old_parent->recursive_quiesce_counter; i++) {
+        bdrv_do_drained_end(child->bs, true, child);
+    }
+}
+
 /*
  * Wait for pending requests to complete on a single BlockDriverState subtree,
  * and suspend block driver's internal I/O until next request arrives.
-- 
2.13.6

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

diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/test-bdrv-drain.c
+++ b/tests/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void test_multiparent(void)
     blk_unref(blk_b);
 }
 
+static void test_graph_change(void)
+{
+    BlockBackend *blk_a, *blk_b;
+    BlockDriverState *bs_a, *bs_b, *backing;
+    BDRVTestState *a_s, *b_s, *backing_s;
+
+    blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
+    bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
+                                &error_abort);
+    a_s = bs_a->opaque;
+    blk_insert_bs(blk_a, bs_a, &error_abort);
+
+    blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
+    bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
+                                &error_abort);
+    b_s = bs_b->opaque;
+    blk_insert_bs(blk_b, bs_b, &error_abort);
+
+    backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
+    backing_s = backing->opaque;
+    bdrv_set_backing_hd(bs_a, backing, &error_abort);
+
+    g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
+    g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
+    g_assert_cmpint(backing->quiesce_counter, ==, 0);
+    g_assert_cmpint(a_s->drain_count, ==, 0);
+    g_assert_cmpint(b_s->drain_count, ==, 0);
+    g_assert_cmpint(backing_s->drain_count, ==, 0);
+
+    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
+    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
+    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
+    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
+    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
+
+    bdrv_set_backing_hd(bs_b, backing, &error_abort);
+    g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
+    g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
+    g_assert_cmpint(backing->quiesce_counter, ==, 5);
+    g_assert_cmpint(a_s->drain_count, ==, 5);
+    g_assert_cmpint(b_s->drain_count, ==, 5);
+    g_assert_cmpint(backing_s->drain_count, ==, 5);
+
+    bdrv_set_backing_hd(bs_b, NULL, &error_abort);
+    g_assert_cmpint(bs_a->quiesce_counter, ==, 3);
+    g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
+    g_assert_cmpint(backing->quiesce_counter, ==, 3);
+    g_assert_cmpint(a_s->drain_count, ==, 3);
+    g_assert_cmpint(b_s->drain_count, ==, 2);
+    g_assert_cmpint(backing_s->drain_count, ==, 3);
+
+    bdrv_set_backing_hd(bs_b, backing, &error_abort);
+    g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
+    g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
+    g_assert_cmpint(backing->quiesce_counter, ==, 5);
+    g_assert_cmpint(a_s->drain_count, ==, 5);
+    g_assert_cmpint(b_s->drain_count, ==, 5);
+    g_assert_cmpint(backing_s->drain_count, ==, 5);
+
+    do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
+    do_drain_end(BDRV_SUBTREE_DRAIN, bs_b);
+    do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
+    do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
+    do_drain_end(BDRV_SUBTREE_DRAIN, bs_a);
+
+    g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
+    g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
+    g_assert_cmpint(backing->quiesce_counter, ==, 0);
+    g_assert_cmpint(a_s->drain_count, ==, 0);
+    g_assert_cmpint(b_s->drain_count, ==, 0);
+    g_assert_cmpint(backing_s->drain_count, ==, 0);
+
+    bdrv_unref(backing);
+    bdrv_unref(bs_a);
+    bdrv_unref(bs_b);
+    blk_unref(blk_a);
+    blk_unref(blk_b);
+}
+
 
 typedef struct TestBlockJob {
     BlockJob common;
@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
 
     g_test_add_func("/bdrv-drain/nested", test_nested);
     g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
+    g_test_add_func("/bdrv-drain/graph-change", test_graph_change);
 
     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
     g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
-- 
2.13.6

Since commit bde70715, base is the only node that is reopened in
commit_start(). This means that the code, which still involves an
explicit BlockReopenQueue, can now be simplified by using bdrv_reopen().

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
---
 block/commit.c | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/block/commit.c b/block/commit.c
index XXXXXXX..XXXXXXX 100644
--- a/block/commit.c
+++ b/block/commit.c
@@ -XXX,XX +XXX,XX @@ void commit_start(const char *job_id, BlockDriverState *bs,
                   const char *filter_node_name, Error **errp)
 {
     CommitBlockJob *s;
-    BlockReopenQueue *reopen_queue = NULL;
     int orig_base_flags;
     BlockDriverState *iter;
     BlockDriverState *commit_top_bs = NULL;
@@ -XXX,XX +XXX,XX @@ void commit_start(const char *job_id, BlockDriverState *bs,
     /* convert base to r/w, if necessary */
     orig_base_flags = bdrv_get_flags(base);
     if (!(orig_base_flags & BDRV_O_RDWR)) {
-        reopen_queue = bdrv_reopen_queue(reopen_queue, base, NULL,
-                                         orig_base_flags | BDRV_O_RDWR);
-    }
-
-    if (reopen_queue) {
-        bdrv_reopen_multiple(bdrv_get_aio_context(bs), reopen_queue, &local_err);
+        bdrv_reopen(base, orig_base_flags | BDRV_O_RDWR, &local_err);
         if (local_err != NULL) {
             error_propagate(errp, local_err);
             goto fail;
-- 
2.13.6

The bdrv_reopen*() implementation doesn't like it if the graph is
changed between queuing nodes for reopen and actually reopening them
(one of the reasons is that queuing can be recursive).

So instead of draining the device only in bdrv_reopen_multiple(),
require that callers already drained all affected nodes, and assert this
in bdrv_reopen_queue().

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
---
 block.c             | 23 ++++++++++++++++-------
 block/replication.c |  6 ++++++
 qemu-io-cmds.c      |  3 +++
 3 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_open(const char *filename, const char *reference,
  * returns a pointer to bs_queue, which is either the newly allocated
  * bs_queue, or the existing bs_queue being used.
  *
+ * bs must be drained between bdrv_reopen_queue() and bdrv_reopen_multiple().
  */
 static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
                                                  BlockDriverState *bs,
@@ -XXX,XX +XXX,XX @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
     BdrvChild *child;
     QDict *old_options, *explicit_options;
 
+    /* Make sure that the caller remembered to use a drained section. This is
+     * important to avoid graph changes between the recursive queuing here and
+     * bdrv_reopen_multiple(). */
+    assert(bs->quiesce_counter > 0);
+
     if (bs_queue == NULL) {
         bs_queue = g_new0(BlockReopenQueue, 1);
         QSIMPLEQ_INIT(bs_queue);
@@ -XXX,XX +XXX,XX @@ BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
  * If all devices prepare successfully, then the changes are committed
  * to all devices.
  *
+ * All affected nodes must be drained between bdrv_reopen_queue() and
+ * bdrv_reopen_multiple().
  */
 int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **er
 
     assert(bs_queue != NULL);
 
-    aio_context_release(ctx);
-    bdrv_drain_all_begin();
-    aio_context_acquire(ctx);
-
     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
+        assert(bs_entry->state.bs->quiesce_counter > 0);
         if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
             error_propagate(errp, local_err);
             goto cleanup;
@@ -XXX,XX +XXX,XX @@ cleanup:
     }
     g_free(bs_queue);
 
-    bdrv_drain_all_end();
-
     return ret;
 }
 
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
 {
     int ret = -1;
     Error *local_err = NULL;
-    BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
+    BlockReopenQueue *queue;
 
+    bdrv_subtree_drained_begin(bs);
+
+    queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
     ret = bdrv_reopen_multiple(bdrv_get_aio_context(bs), queue, &local_err);
     if (local_err != NULL) {
         error_propagate(errp, local_err);
     }
+
+    bdrv_subtree_drained_end(bs);
+
     return ret;
 }
 
diff --git a/block/replication.c b/block/replication.c
index XXXXXXX..XXXXXXX 100644
--- a/block/replication.c
+++ b/block/replication.c
@@ -XXX,XX +XXX,XX @@ static void reopen_backing_file(BlockDriverState *bs, bool writable,
         new_secondary_flags = s->orig_secondary_flags;
     }
 
+    bdrv_subtree_drained_begin(s->hidden_disk->bs);
+    bdrv_subtree_drained_begin(s->secondary_disk->bs);
+
     if (orig_hidden_flags != new_hidden_flags) {
         reopen_queue = bdrv_reopen_queue(reopen_queue, s->hidden_disk->bs, NULL,
                                          new_hidden_flags);
@@ -XXX,XX +XXX,XX @@ static void reopen_backing_file(BlockDriverState *bs, bool writable,
                              reopen_queue, &local_err);
         error_propagate(errp, local_err);
     }
+
+    bdrv_subtree_drained_end(s->hidden_disk->bs);
+    bdrv_subtree_drained_end(s->secondary_disk->bs);
 }
 
 static void backup_job_cleanup(BlockDriverState *bs)
diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qemu-io-cmds.c
+++ b/qemu-io-cmds.c
@@ -XXX,XX +XXX,XX @@ static int reopen_f(BlockBackend *blk, int argc, char **argv)
     opts = qopts ? qemu_opts_to_qdict(qopts, NULL) : NULL;
     qemu_opts_reset(&reopen_opts);
 
+    bdrv_subtree_drained_begin(bs);
     brq = bdrv_reopen_queue(NULL, bs, opts, flags);
     bdrv_reopen_multiple(bdrv_get_aio_context(bs), brq, &local_err);
+    bdrv_subtree_drained_end(bs);
+
     if (local_err) {
         error_report_err(local_err);
     } else {
-- 
2.13.6