Series comparison

-[PULL 00/18] Block layer patches
+[Qemu-devel] [PULL v3 00/35] Block layer patches
-The following changes since commit 6972ef1440a9d685482d78672620a7482f2bd09a:
+The following changes since commit 281f327487c9c9b1599f93c589a408bbf4a651b8:
-  Merge tag 'pull-tcg-20230516-3' of https://gitlab.com/rth7680/qemu into staging (2023-05-16 21:30:27 -0700)
+  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:
-  https://repo.or.cz/qemu/kevin.git tags/for-upstream
+  git://repo.or.cz/qemu/kevin.git tags/for-upstream
-for you to fetch changes up to 75b2591bbce5dc9f3da89f140b7bdc00e92fa8ec:
+for you to fetch changes up to 1a63a907507fbbcfaee3f622907ec244b7eabda8:
-  tested: add test for nested aio_poll() in poll handlers (2023-05-17 18:01:22 +0200)
+  block: Keep nodes drained between reopen_queue/multiple (2017-12-22 15:05:32 +0100)
 ----------------------------------------------------------------
 Block layer patches
-- qcow2 spec: Rename "zlib" compression to "deflate"
+----------------------------------------------------------------
-- Honour graph read lock even in the main thread + prerequisite fixes
+Doug Gale (1):
-- aio-posix: do not nest poll handlers (fixes infinite recursion)
+      nvme: Add tracing
 - Refactor QMP blockdev transactions
 - iotests/245: Check if 'compress' driver is available
-----------------------------------------------------------------
+Edgar Kaziakhmedov (1):
-Akihiro Suda (1):
+      qcow2: get rid of qcow2_backing_read1 routine
       docs/interop/qcow2.txt: fix description about "zlib" clusters
-Kevin Wolf (9):
+Fam Zheng (2):
-      block: Call .bdrv_co_create(_opts) unlocked
+      block: Open backing image in force share mode for size probe
-      block/export: Fix null pointer dereference in error path
+      block: Remove unused bdrv_requests_pending
       qcow2: Unlock the graph in qcow2_do_open() where necessary
       qemu-img: Take graph lock more selectively
       test-bdrv-drain: Take graph lock more selectively
       test-bdrv-drain: Call bdrv_co_unref() in coroutine context
       blockjob: Adhere to rate limit even when reentered early
       graph-lock: Honour read locks even in the main thread
       iotests/245: Check if 'compress' driver is available
-Stefan Hajnoczi (2):
+John Snow (1):
-      aio-posix: do not nest poll handlers
+      iotests: fix 197 for vpc
       tested: add test for nested aio_poll() in poll handlers
-Vladimir Sementsov-Ogievskiy (6):
+Kevin Wolf (27):
-      blockdev: refactor transaction to use Transaction API
+      block: Formats don't need CONSISTENT_READ with NO_IO
-      blockdev: transactions: rename some things
+      block: Make bdrv_drain_invoke() recursive
-      blockdev: qmp_transaction: refactor loop to classic for
+      block: Call .drain_begin only once in bdrv_drain_all_begin()
-      blockdev: transaction: refactor handling transaction properties
+      test-bdrv-drain: Test BlockDriver callbacks for drain
-      blockdev: use state.bitmap in block-dirty-bitmap-add action
+      block: bdrv_drain_recurse(): Remove unused begin parameter
-      blockdev: qmp_transaction: drop extra generic layer
+      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
- docs/interop/qcow2.txt             |  10 +-
+Thomas Huth (3):
- include/block/block-global-state.h |   8 +-
+      block: Remove the obsolete -drive boot=on|off parameter
- include/block/block_int-common.h   |   4 +-
+      block: Remove the deprecated -hdachs option
- include/block/blockjob_int.h       |  14 +-
+      block: Mention -drive cyls/heads/secs/trans/serial/addr in deprecation chapter
- block.c                            |   1 -
- block/commit.c                     |   7 +-
+ qapi/block-core.json             |   4 +
- block/create.c                     |   1 -
+ block/qcow2.h                    |   3 -
- block/crypto.c                     |  25 +-
+ include/block/block.h            |  15 +-
- block/export/export.c              |   6 +-
+ include/block/block_int.h        |   6 +-
- block/graph-lock.c                 |  10 -
+ block.c                          |  75 ++++-
- block/mirror.c                     |  23 +-
+ block/commit.c                   |   8 +-
- block/parallels.c                  |   6 +-
+ block/io.c                       | 164 +++++++---
- block/qcow.c                       |   6 +-
+ block/qcow2.c                    |  51 +--
- block/qcow2.c                      |  43 ++-
+ block/replication.c              |   6 +
- block/qed.c                        |   6 +-
+ blockdev.c                       |  11 -
- block/raw-format.c                 |   2 +-
+ blockjob.c                       |  22 +-
- block/stream.c                     |   7 +-
+ hmp.c                            |   6 -
- block/vdi.c                        |  11 +-
+ hw/block/nvme.c                  | 349 +++++++++++++++++----
- block/vhdx.c                       |   8 +-
+ qemu-io-cmds.c                   |   3 +
- block/vmdk.c                       |  27 +-
+ tests/test-bdrv-drain.c          | 651 +++++++++++++++++++++++++++++++++++++++
- block/vpc.c                        |   6 +-
+ vl.c                             |  86 +-----
- blockdev.c                         | 606 +++++++++++++++----------------------
+ hw/block/trace-events            |  93 ++++++
- blockjob.c                         |  22 +-
+ qemu-doc.texi                    |  29 +-
- qemu-img.c                         |   5 +-
+ qemu-options.hx                  |  19 +-
- tests/unit/test-bdrv-drain.c       |   6 +-
+ tests/Makefile.include           |   2 +
- tests/unit/test-nested-aio-poll.c  | 130 ++++++++
+ tests/qemu-iotests/197           |   4 +
- util/aio-posix.c                   |  11 +
+ tests/qemu-iotests/common.filter |   3 +-
- tests/qemu-iotests/245             |   7 +-
+files changed, 1294 insertions(+), 316 deletions(-)
- tests/qemu-iotests/245.out         |   9 +-
+ create mode 100644 tests/test-bdrv-drain.c
- tests/unit/meson.build             |   1 +
 files changed, 541 insertions(+), 487 deletions(-)
  create mode 100644 tests/unit/test-nested-aio-poll.c

-New patch
+[Qemu-devel] [PULL v3 01/35] block: Formats don't need CONSISTENT_READ with NO_IO
+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 +++++-
+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.
+--
+.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

-New patch
+[Qemu-devel] [PULL v3 03/35] block: Make bdrv_drain_invoke() recursive
+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 +++++++++++---
+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);
+     }
+--
+.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 18/18] tested: add test for nested aio_poll() in poll handlers
+[Qemu-devel] [PULL v3 05/35] test-bdrv-drain: Test BlockDriver callbacks for drain
-From: Stefan Hajnoczi <stefanha@redhat.com>
+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: Stefan Hajnoczi <stefanha@redhat.com>
-Message-Id: <20230502184134.534703-3-stefanha@redhat.com>
-Tested-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 ---
- tests/unit/test-nested-aio-poll.c | 130 ++++++++++++++++++++++++++++++
+ tests/test-bdrv-drain.c | 137 ++++++++++++++++++++++++++++++++++++++++++++++++
- tests/unit/meson.build            |   1 +
+ tests/Makefile.include  |   2 +
-files changed, 131 insertions(+)
+files changed, 139 insertions(+)
- create mode 100644 tests/unit/test-nested-aio-poll.c
+ create mode 100644 tests/test-bdrv-drain.c
-diff --git a/tests/unit/test-nested-aio-poll.c b/tests/unit/test-nested-aio-poll.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/unit/test-nested-aio-poll.c
++++ b/tests/test-bdrv-drain.c
 @@ -XXX,XX +XXX,XX @@
-+/* SPDX-License-Identifier: GPL-2.0-or-later */
 +/*
-+ * Test that poll handlers are not re-entrant in nested aio_poll()
++ * Block node draining tests
 + *
-+ * Copyright Red Hat
++ * Copyright (c) 2017 Kevin Wolf <kwolf@redhat.com>
 + *
-+ * Poll handlers are usually level-triggered. That means they continue firing
++ * Permission is hereby granted, free of charge, to any person obtaining a copy
-+ * until the condition is reset (e.g. a virtqueue becomes empty). If a poll
++ * of this software and associated documentation files (the "Software"), to deal
-+ * handler calls nested aio_poll() before the condition is reset, then infinite
++ * in the Software without restriction, including without limitation the rights
-+ * recursion occurs.
++ * 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:
 + *
-+ * aio_poll() is supposed to prevent this by disabling poll handlers in nested
++ * The above copyright notice and this permission notice shall be included in
-+ * aio_poll() calls. This test case checks that this is indeed what happens.
++ * 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/aio.h"
++#include "block/block.h"
 +#include "sysemu/block-backend.h"
 +#include "qapi/error.h"
 +
-+typedef struct {
++typedef struct BDRVTestState {
-+    AioContext *ctx;
++    int drain_count;
 +} BDRVTestState;
 +
-+    /* This is the EventNotifier that drives the test */
++static void coroutine_fn bdrv_test_co_drain_begin(BlockDriverState *bs)
 +    EventNotifier poll_notifier;
 +
 +    /* This EventNotifier is only used to wake aio_poll() */
 +    EventNotifier dummy_notifier;
 +
 +    bool nested;
 +} TestData;
 +
 +static void io_read(EventNotifier *notifier)
 +{
-+    fprintf(stderr, "%s %p\n", __func__, notifier);
++    BDRVTestState *s = bs->opaque;
-+    event_notifier_test_and_clear(notifier);
++    s->drain_count++;
 +}
 +
-+static bool io_poll_true(void *opaque)
++static void coroutine_fn bdrv_test_co_drain_end(BlockDriverState *bs)
 +{
-+    fprintf(stderr, "%s %p\n", __func__, opaque);
++    BDRVTestState *s = bs->opaque;
-+    return true;
++    s->drain_count--;
 +}
 +
-+static bool io_poll_false(void *opaque)
++static void bdrv_test_close(BlockDriverState *bs)
 +{
-+    fprintf(stderr, "%s %p\n", __func__, opaque);
++    BDRVTestState *s = bs->opaque;
-+    return false;
++    g_assert_cmpint(s->drain_count, >, 0);
 +}
 +
-+static void io_poll_ready(EventNotifier *notifier)
++static int coroutine_fn bdrv_test_co_preadv(BlockDriverState *bs,
 +                                            uint64_t offset, uint64_t bytes,
 +                                            QEMUIOVector *qiov, int flags)
 +{
-+    TestData *td = container_of(notifier, TestData, poll_notifier);
++    /* 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);
 +
-+    fprintf(stderr, "> %s\n", __func__);
++    return 0;
 +
 +    g_assert(!td->nested);
 +    td->nested = true;
 +
 +    /* Wake the following nested aio_poll() call */
 +    event_notifier_set(&td->dummy_notifier);
 +
 +    /* This nested event loop must not call io_poll()/io_poll_ready() */
 +    g_assert(aio_poll(td->ctx, true));
 +
 +    td->nested = false;
 +
 +    fprintf(stderr, "< %s\n", __func__);
 +}
 +
-+/* dummy_notifier never triggers */
++static BlockDriver bdrv_test = {
-+static void io_poll_never_ready(EventNotifier *notifier)
++    .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)
 +{
-+    g_assert_not_reached();
++    int *aio_ret = opaque;
 +    *aio_ret = ret;
 +}
 +
-+static void test(void)
++static void test_drv_cb_drain_all(void)
 +{
-+    TestData td = {
++    BlockBackend *blk;
-+        .ctx = aio_context_new(&error_abort),
++    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);
 +
-+    qemu_set_current_aio_context(td.ctx);
++    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);
 +
-+    /* Enable polling */
++    /* Simple bdrv_drain_all_begin/end pair, check that CBs are called */
-+    aio_context_set_poll_params(td.ctx, 1000000, 2, 2, &error_abort);
++    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 */
-+     * The GSource is unused but this has the side-effect of changing the fdmon
++    aio_ret = -EINPROGRESS;
-+     * that AioContext uses.
++    acb = blk_aio_preadv(blk, 0, &qiov, 0, aio_ret_cb, &aio_ret);
-+     */
++    g_assert(acb != NULL);
-+    aio_get_g_source(td.ctx);
++    g_assert_cmpint(aio_ret, ==, -EINPROGRESS);
 +
-+    /* Make the event notifier active (set) right away */
++    g_assert_cmpint(s->drain_count, ==, 0);
-+    event_notifier_init(&td.poll_notifier, 1);
++    bdrv_drain_all_begin();
-+    aio_set_event_notifier(td.ctx, &td.poll_notifier, false,
++    g_assert_cmpint(aio_ret, ==, 0);
-+                           io_read, io_poll_true, io_poll_ready);
++    g_assert_cmpint(s->drain_count, ==, 1);
 +    bdrv_drain_all_end();
 +    g_assert_cmpint(s->drain_count, ==, 0);
 +
-+    /* This event notifier will be used later */
++    bdrv_unref(bs);
-+    event_notifier_init(&td.dummy_notifier, 0);
++    blk_unref(blk);
 +    aio_set_event_notifier(td.ctx, &td.dummy_notifier, false,
 +                           io_read, io_poll_false, io_poll_never_ready);
 +
 +    /* Consume aio_notify() */
 +    g_assert(!aio_poll(td.ctx, false));
 +
 +    /*
 +     * Run the io_read() handler. This has the side-effect of activating
 +     * polling in future aio_poll() calls.
 +     */
 +    g_assert(aio_poll(td.ctx, true));
 +
 +    /* The second time around the io_poll()/io_poll_ready() handler runs */
 +    g_assert(aio_poll(td.ctx, true));
 +
 +    /* Run io_poll()/io_poll_ready() one more time to show it keeps working */
 +    g_assert(aio_poll(td.ctx, true));
 +
 +    aio_set_event_notifier(td.ctx, &td.dummy_notifier, false,
 +                           NULL, NULL, NULL);
 +    aio_set_event_notifier(td.ctx, &td.poll_notifier, false, NULL, NULL, NULL);
 +    event_notifier_cleanup(&td.dummy_notifier);
 +    event_notifier_cleanup(&td.poll_notifier);
 +    aio_context_unref(td.ctx);
 +}
 +
 +int main(int argc, char **argv)
 +{
++    bdrv_init();
++    qemu_init_main_loop(&error_abort);
++
 +    g_test_init(&argc, &argv, NULL);
-+    g_test_add_func("/nested-aio-poll", test);
++
 +    g_test_add_func("/bdrv-drain/driver-cb/drain_all", test_drv_cb_drain_all);
 +
 +    return g_test_run();
 +}
-diff --git a/tests/unit/meson.build b/tests/unit/meson.build
+diff --git a/tests/Makefile.include b/tests/Makefile.include
 index XXXXXXX..XXXXXXX 100644
---- a/tests/unit/meson.build
+--- a/tests/Makefile.include
-+++ b/tests/unit/meson.build
++++ b/tests/Makefile.include
-@@ -XXX,XX +XXX,XX @@ if have_block
+@@ -XXX,XX +XXX,XX @@ gcov-files-test-thread-pool-y = thread-pool.c
-     'test-coroutine': [testblock],
+ gcov-files-test-hbitmap-y = util/hbitmap.c
-     'test-aio': [testblock],
+ check-unit-y += tests/test-hbitmap$(EXESUF)
-     'test-aio-multithread': [testblock],
+ gcov-files-test-hbitmap-y = blockjob.c
-+    'test-nested-aio-poll': [testblock],
++check-unit-y += tests/test-bdrv-drain$(EXESUF)
-     'test-throttle': [testblock],
+ check-unit-y += tests/test-blockjob$(EXESUF)
-     'test-thread-pool': [testblock],
+ check-unit-y += tests/test-blockjob-txn$(EXESUF)
-     'test-hbitmap': [testblock],
+ 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)
 --
-.40.1
+.13.6

-New patch
+[Qemu-devel] [PULL v3 06/35] block: bdrv_drain_recurse(): Remove unused begin parameter
+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 ++++++------
+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);
+     }
+--
+.13.6

-[PULL 16/18] iotests/245: Check if 'compress' driver is available
+[Qemu-devel] [PULL v3 07/35] block: Don't wait for requests in bdrv_drain*_end()
-Skip TestBlockdevReopen.test_insert_compress_filter() if the 'compress'
+The device is drained, so there is no point in waiting for requests at
-driver isn't available.
+the end of the drained section. Remove the bdrv_drain_recurse() calls
 there.
-In order to make the test succeed when the case is skipped, we also need
+The bdrv_drain_recurse() calls were introduced in commit 481cad48e5e
-to remove any output from it (which would be missing in the case where
+in order to call the .bdrv_co_drain_end() driver callback. This is now
-we skip it). This is done by replacing qemu_io_log() with qemu_io(). In
+done by a separate bdrv_drain_invoke() call.
 case of failure, qemu_io() raises an exception with the output of the
 qemu-io binary in its message, so we don't actually lose anything.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20230511143801.255021-1-kwolf@redhat.com>
+Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/qemu-iotests/245     | 7 ++++---
+ block/io.c | 2 --
- tests/qemu-iotests/245.out | 9 +--------
+file changed, 2 deletions(-)
 files changed, 5 insertions(+), 11 deletions(-)
-diff --git a/tests/qemu-iotests/245 b/tests/qemu-iotests/245
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/245
 +++ b/tests/qemu-iotests/245
@@ -XXX,XX +XXX,XX @@ class TestBlockdevReopen(iotests.QMPTestCase):
          self.reopen(hd0_opts, {'file': 'hd0-file'})
      # Insert (and remove) a compress filter
 +    @iotests.skip_if_unsupported(['compress'])
      def test_insert_compress_filter(self):
          # Add an image to the VM: hd (raw) -> hd0 (qcow2) -> hd0-file (file)
          opts = {'driver': 'raw', 'node-name': 'hd', 'file': hd_opts(0)}
@@ -XXX,XX +XXX,XX @@ class TestBlockdevReopen(iotests.QMPTestCase):
          # Check the first byte of the first three L2 entries and verify that
          # the second one is compressed (0x40) while the others are not (0x80)
 -        iotests.qemu_io_log('-f', 'raw', '-c', 'read -P 0x80 0x40000 1',
 -                                         '-c', 'read -P 0x40 0x40008 1',
 -                                         '-c', 'read -P 0x80 0x40010 1', hd_path[0])
 +        iotests.qemu_io('-f', 'raw', '-c', 'read -P 0x80 0x40000 1',
 +                                     '-c', 'read -P 0x40 0x40008 1',
 +                                     '-c', 'read -P 0x80 0x40010 1', hd_path[0])
      # Swap the disk images of two active block devices
      def test_swap_files(self):
 diff --git a/tests/qemu-iotests/245.out b/tests/qemu-iotests/245.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/245.out
+--- a/block/io.c
-+++ b/tests/qemu-iotests/245.out
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
- {"return": {}}
- {"data": {"id": "stream0", "type": "stream"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+     bdrv_parent_drained_end(bs);
- {"data": {"device": "stream0", "len": 3145728, "offset": 3145728, "speed": 0, "type": "stream"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+     bdrv_drain_invoke(bs, false);
--....read 1/1 bytes at offset 262144
+-    bdrv_drain_recurse(bs);
--1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+     aio_enable_external(bdrv_get_aio_context(bs));
--read 1/1 bytes at offset 262152
+ }
--1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
--read 1/1 bytes at offset 262160
+@@ -XXX,XX +XXX,XX @@ void bdrv_drain_all_end(void)
--1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+         aio_enable_external(aio_context);
--
+         bdrv_parent_drained_end(bs);
--................
+         bdrv_drain_invoke(bs, false);
-+....................
+-        bdrv_drain_recurse(bs);
- ----------------------------------------------------------------------
+         aio_context_release(aio_context);
- Ran 26 tests
+     }
 --
-.40.1
+.13.6

-[PULL 12/18] test-bdrv-drain: Take graph lock more selectively
+[Qemu-devel] [PULL v3 08/35] block: Unify order in drain functions
-If we take a reader lock, we can't call any functions that take a writer
+Drain requests are propagated to child nodes, parent nodes and directly
-lock internally without causing deadlocks once the reader lock is
+to the AioContext. The order in which this happened was different
-actually enforced in the main thread, too. Take the reader lock only
+between all combinations of drain/drain_all and begin/end.
-where it is actually needed.
 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>
-Message-Id: <20230510203601.418015-6-kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/unit/test-bdrv-drain.c | 4 ++--
+ block/io.c | 12 ++++++++----
-file changed, 2 insertions(+), 2 deletions(-)
+file changed, 8 insertions(+), 4 deletions(-)
-diff --git a/tests/unit/test-bdrv-drain.c b/tests/unit/test-bdrv-drain.c
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/unit/test-bdrv-drain.c
+--- a/block/io.c
-+++ b/tests/unit/test-bdrv-drain.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static void coroutine_fn test_co_delete_by_drain(void *opaque)
+@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs)
-     void *buffer = g_malloc(65536);
+         return;
-     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buffer, 65536);
+     }
--    GRAPH_RDLOCK_GUARD();
++    /* Stop things in parent-to-child order */
--
+     if (atomic_fetch_inc(&bs->quiesce_counter) == 0) {
-     /* Pretend some internal write operation from parent to child.
+         aio_disable_external(bdrv_get_aio_context(bs));
-      * Important: We have to read from the child, not from the parent!
+         bdrv_parent_drained_begin(bs);
-      * Draining works by first propagating it all up the tree to the
+@@ -XXX,XX +XXX,XX @@ void bdrv_drained_end(BlockDriverState *bs)
-@@ -XXX,XX +XXX,XX @@ static void coroutine_fn test_co_delete_by_drain(void *opaque)
+         return;
-      * everything will be drained before we go back down the tree, but
+     }
-      * we do not want that.  We want to be in the middle of draining
-      * when this following requests returns. */
+-    bdrv_parent_drained_end(bs);
-+    bdrv_graph_co_rdlock();
++    /* Re-enable things in child-to-parent order */
-     bdrv_co_preadv(tts->wait_child, 0, 65536, &qiov, 0);
+     bdrv_drain_invoke(bs, false);
-+    bdrv_graph_co_rdunlock();
++    bdrv_parent_drained_end(bs);
+     aio_enable_external(bdrv_get_aio_context(bs));
-     g_assert_cmpint(bs->refcnt, ==, 1);
+ }
@@ -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);
      }
 --
-.40.1
+.13.6

-New patch
+[Qemu-devel] [PULL v3 09/35] block: Don't acquire AioContext in hmp_qemu_io()
+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 ------
+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);
+--
+.13.6

-[PULL 10/18] qcow2: Unlock the graph in qcow2_do_open() where necessary
+[Qemu-devel] [PULL v3 10/35] qcow2: get rid of qcow2_backing_read1 routine
-qcow2_do_open() calls a few no_co_wrappers that wrap functions taking
+From: Edgar Kaziakhmedov <edgar.kaziakhmedov@virtuozzo.com>
 the graph lock internally as a writer. Therefore, it can't hold the
 reader lock across these calls, it causes deadlocks. Drop the lock
 temporarily around the calls.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Since bdrv_co_preadv does all neccessary checks including
-Message-Id: <20230510203601.418015-4-kwolf@redhat.com>
+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.c | 6 ++++++
+ block/qcow2.h |  3 ---
-file changed, 6 insertions(+)
+ 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 @@ qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
+@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn qcow2_co_get_block_status(BlockDriverState *bs,
+     return status;
-     if (open_data_file) {
+ }
-         /* Open external data file */
-+        bdrv_graph_co_rdunlock();
+-/* handle reading after the end of the backing file */
-         s->data_file = bdrv_co_open_child(NULL, options, "data-file", bs,
+-int qcow2_backing_read1(BlockDriverState *bs, QEMUIOVector *qiov,
-                                           &child_of_bds, BDRV_CHILD_DATA,
+-                        int64_t offset, int bytes)
-                                           true, errp);
+-{
-+        bdrv_graph_co_rdlock();
+-    uint64_t bs_size = bs->total_sectors * BDRV_SECTOR_SIZE;
-         if (*errp) {
+-    int n1;
-             ret = -EINVAL;
+-
-             goto fail;
+-    if ((offset + bytes) <= bs_size) {
-@@ -XXX,XX +XXX,XX @@ qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
+-        return bytes;
+-    }
-         if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
+-
-             if (!s->data_file && s->image_data_file) {
+-    if (offset >= bs_size) {
-+                bdrv_graph_co_rdunlock();
+-        n1 = 0;
-                 s->data_file = bdrv_co_open_child(s->image_data_file, options,
+-    } else {
-                                                   "data-file", bs,
+-        n1 = bs_size - offset;
-                                                   &child_of_bds,
+-    }
-                                                   BDRV_CHILD_DATA, false, errp);
+-
-+                bdrv_graph_co_rdlock();
+-    qemu_iovec_memset(qiov, n1, 0, bytes - n1);
-                 if (!s->data_file) {
+-
-                     ret = -EINVAL;
+-    return n1;
-                     goto fail;
+-}
-@@ -XXX,XX +XXX,XX @@ qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
+-
-  fail:
+ static coroutine_fn int qcow2_co_preadv(BlockDriverState *bs, uint64_t offset,
-     g_free(s->image_data_file);
+                                         uint64_t bytes, QEMUIOVector *qiov,
-     if (open_data_file && has_data_file(bs)) {
+                                         int flags)
-+        bdrv_graph_co_rdunlock();
+ {
-         bdrv_unref_child(bs, s->data_file);
+     BDRVQcow2State *s = bs->opaque;
-+        bdrv_graph_co_rdlock();
+-    int offset_in_cluster, n1;
-         s->data_file = NULL;
++    int offset_in_cluster;
-     }
+     int ret;
-     g_free(s->unknown_header_fields);
+     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 */
 --
-.40.1
+.13.6

-New patch
+[Qemu-devel] [PULL v3 11/35] block: Document that x-blockdev-change breaks quorum children list
+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 ++++
+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.
+ #
+--
+.13.6

-New patch
+[Qemu-devel] [PULL v3 12/35] nvme: Add tracing
+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 ++++++++++++++
+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"
+--
+.13.6

-[PULL 13/18] test-bdrv-drain: Call bdrv_co_unref() in coroutine context
+[Qemu-devel] [PULL v3 13/35] block: Open backing image in force share mode for size probe
-bdrv_unref() is a no_coroutine_fn, so calling it from coroutine context
+From: Fam Zheng <famz@redhat.com>
 is invalid. Use bdrv_co_unref() instead.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Management tools create overlays of running guests with qemu-img:
-Message-Id: <20230510203601.418015-7-kwolf@redhat.com>
   $ 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>
 ---
- tests/unit/test-bdrv-drain.c | 2 +-
+ block.c | 3 ++-
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 2 insertions(+), 1 deletion(-)
-diff --git a/tests/unit/test-bdrv-drain.c b/tests/unit/test-bdrv-drain.c
+diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/unit/test-bdrv-drain.c
+--- a/block.c
-+++ b/tests/unit/test-bdrv-drain.c
++++ b/block.c
-@@ -XXX,XX +XXX,XX @@ static void coroutine_fn test_co_delete_by_drain(void *opaque)
+@@ -XXX,XX +XXX,XX @@ void bdrv_img_create(const char *filename, const char *fmt,
-     g_assert_cmpint(bs->refcnt, ==, 1);
+         back_flags = flags;
+         back_flags &= ~(BDRV_O_RDWR | BDRV_O_SNAPSHOT | BDRV_O_NO_BACKING);
-     if (!dbdd->detach_instead_of_delete) {
--        blk_unref(blk);
++        backing_options = qdict_new();
-+        blk_co_unref(blk);
+         if (backing_fmt) {
-     } else {
+-            backing_options = qdict_new();
-         BdrvChild *c, *next_c;
+             qdict_put_str(backing_options, "driver", backing_fmt);
-         QLIST_FOREACH_SAFE(c, &bs->children, next, next_c) {
+         }
 +        qdict_put_bool(backing_options, BDRV_OPT_FORCE_SHARE, true);
          bs = bdrv_open(full_backing, NULL, backing_options, back_flags,
                         &local_err);
 --
-.40.1
+.13.6

-[PULL 03/18] blockdev: qmp_transaction: refactor loop to classic for
+[Qemu-devel] [PULL v3 14/35] block: Remove the obsolete -drive boot=on|off parameter
-From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
+From: Thomas Huth <thuth@redhat.com>
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
+It's not working anymore since QEMU v1.3.0 - time to remove it now.
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20230510150624.310640-4-vsementsov@yandex-team.ru>
+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 | 9 +++------
+ blockdev.c    | 11 -----------
-file changed, 3 insertions(+), 6 deletions(-)
+ qemu-doc.texi |  6 ------
 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 @@ void qmp_transaction(TransactionActionList *actions,
+@@ -XXX,XX +XXX,XX @@ QemuOptsList qemu_legacy_drive_opts = {
-                      struct TransactionProperties *properties,
+             .type = QEMU_OPT_STRING,
-                      Error **errp)
+             .help = "chs translation (auto, lba, none)",
- {
+         },{
--    TransactionActionList *act = actions;
+-            .name = "boot",
-+    TransactionActionList *act;
+-            .type = QEMU_OPT_BOOL,
-     bool has_properties = !!properties;
+-            .help = "(deprecated, ignored)",
-     JobTxn *block_job_txn = NULL;
+-        },{
-     Error *local_err = NULL;
+             .name = "addr",
-@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *actions,
+             .type = QEMU_OPT_STRING,
-     bdrv_drain_all();
+             .help = "pci address (virtio only)",
+@@ -XXX,XX +XXX,XX @@ DriveInfo *drive_new(QemuOpts *all_opts, BlockInterfaceType block_default_type)
-     /* We don't do anything in this loop that commits us to the operations */
+         goto fail;
--    while (NULL != act) {
+     }
--        TransactionAction *dev_info = NULL;
-+    for (act = actions; act; act = act->next) {
+-    /* Deprecated option boot=[on|off] */
-+        TransactionAction *dev_info = act->value;
+-    if (qemu_opt_get(legacy_opts, "boot") != NULL) {
-         const BlkActionOps *ops;
+-        fprintf(stderr, "qemu-kvm: boot=on|off is deprecated and will be "
-         BlkActionState *state;
+-                "ignored. Future versions will reject this parameter. Please "
+-                "update your scripts.\n");
--        dev_info = act->value;
+-    }
 -        act = act->next;
 -
-         assert(dev_info->type < ARRAY_SIZE(actions_map));
+     /* Other deprecated options */
+     if (!qtest_enabled()) {
-         ops = &actions_map[dev_info->type];
+         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
 --
-.40.1
+.13.6

-New patch
+[Qemu-devel] [PULL v3 15/35] block: Remove the deprecated -hdachs option
+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 ++-----------
 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"
 --
 .13.6

-New patch
+[Qemu-devel] [PULL v3 16/35] block: Mention -drive cyls/heads/secs/trans/serial/addr in deprecation chapter
+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.
+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>
+---
+ qemu-doc.texi | 15 +++++++++++++++
+file changed, 15 insertions(+)
+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
+--
+.13.6

-[PULL 15/18] graph-lock: Honour read locks even in the main thread
+[Qemu-devel] [PULL v3 17/35] block: Remove unused bdrv_requests_pending
-There are some conditions under which we don't actually need to do
+From: Fam Zheng <famz@redhat.com>
 anything for taking a reader lock: Writing the graph is only possible
 from the main context while holding the BQL. So if a reader is running
 in the main context under the BQL and knows that it won't be interrupted
 until the next writer runs, we don't actually need to do anything.
-This is the case if the reader code neither has a nested event loop
+Signed-off-by: Fam Zheng <famz@redhat.com>
 (this is forbidden anyway while you hold the lock) nor is a coroutine
 (because a writer could run when the coroutine has yielded).
 These conditions are exactly what bdrv_graph_rdlock_main_loop() asserts.
 They are not fulfilled in bdrv_graph_co_rdlock(), which always runs in a
 coroutine.
 This deletes the shortcuts in bdrv_graph_co_rdlock() that skip taking
 the reader lock in the main thread.
 Reported-by: Fiona Ebner <f.ebner@proxmox.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Message-Id: <20230510203601.418015-9-kwolf@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/graph-lock.c | 10 ----------
+ include/block/block_int.h |  1 -
-file changed, 10 deletions(-)
+ block/io.c                | 18 ------------------
 files changed, 19 deletions(-)
-diff --git a/block/graph-lock.c b/block/graph-lock.c
+diff --git a/include/block/block_int.h b/include/block/block_int.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/graph-lock.c
+--- a/include/block/block_int.h
-+++ b/block/graph-lock.c
++++ b/include/block/block_int.h
-@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_graph_co_rdlock(void)
+@@ -XXX,XX +XXX,XX @@ bool blk_dev_is_tray_open(BlockBackend *blk);
-     BdrvGraphRWlock *bdrv_graph;
+ bool blk_dev_is_medium_locked(BlockBackend *blk);
-     bdrv_graph = qemu_get_current_aio_context()->bdrv_graph;
+ void bdrv_set_dirty(BlockDriverState *bs, int64_t offset, int64_t bytes);
--    /* Do not lock if in main thread */
+-bool bdrv_requests_pending(BlockDriverState *bs);
--    if (qemu_in_main_thread()) {
--        return;
+ 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;
 -    }
 -
-     for (;;) {
+-    QLIST_FOREACH(child, &bs->children, next) {
-         qatomic_set(&bdrv_graph->reader_count,
+-        if (bdrv_requests_pending(child->bs)) {
-                     bdrv_graph->reader_count + 1);
+-            return true;
-@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_graph_co_rdunlock(void)
+-        }
      BdrvGraphRWlock *bdrv_graph;
      bdrv_graph = qemu_get_current_aio_context()->bdrv_graph;
 -    /* Do not lock if in main thread */
 -    if (qemu_in_main_thread()) {
 -        return;
 -    }
 -
-     qatomic_store_release(&bdrv_graph->reader_count,
+-    return false;
-                           bdrv_graph->reader_count - 1);
+-}
-     /* make sure writer sees reader_count before we check has_writer */
+-
  typedef struct {
      Coroutine *co;
      BlockDriverState *bs;
 --
-.40.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

-New patch
+[Qemu-devel] [PULL v3 19/35] block: Make bdrv_drain() driver callbacks non-recursive
+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 +++++++++-------
+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);
+--
+.13.6

-New patch
+[Qemu-devel] [PULL v3 20/35] test-bdrv-drain: Test callback for bdrv_drain
+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 ++++++++++++++++++++++++++++++++++++++++++++-----
+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();
+ }
+--
+.13.6

-New patch
+[Qemu-devel] [PULL v3 21/35] test-bdrv-drain: Test bs->quiesce_counter
+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 +++++++++++++++++++++++++++++++++++++++++++++
+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();
+ }
+--
+.13.6

-[PULL 14/18] blockjob: Adhere to rate limit even when reentered early
+[Qemu-devel] [PULL v3 22/35] blockjob: Pause job on draining any job BDS
-When jobs are sleeping, for example to enforce a given rate limit, they
+Block jobs already paused themselves when their main BlockBackend
-can be reentered early, in particular in order to get paused, to update
+entered a drained section. This is not good enough: We also want to
-the rate limit or to get cancelled.
+pause a block job and may not submit new requests if, for example, the
 mirror target node should be drained.
-Before this patch, they behave in this case as if they had fully
+This implements .drained_begin/end callbacks in child_job in order to
-completed their rate limiting delay. This means that requests are sped
+consider all block nodes related to the job, and removes the
-up beyond their limit, violating the constraints that the user gave us.
+BlockBackend callbacks which are unnecessary now because the root of the
+job main BlockBackend is always referenced with a child_job, too.
 Change the block jobs to sleep in a loop until the necessary delay is
 completed, while still allowing cancelling them immediately as well
 pausing (handled by the pause point in job_sleep_ns()) and updating the
 rate limit.
 This change is also motivated by iotests cases being prone to fail
 because drain operations pause and unpause them so often that block jobs
 complete earlier than they are supposed to. In particular, the next
 commit would fail iotests 030 without this change.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20230510203601.418015-8-kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/block/blockjob_int.h | 14 ++++++++++----
+ blockjob.c | 22 +++++++++-------------
- block/commit.c               |  7 ++-----
+file changed, 9 insertions(+), 13 deletions(-)
  block/mirror.c               | 23 ++++++++++-------------
  block/stream.c               |  7 ++-----
  blockjob.c                   | 22 ++++++++++++++++++++--
 files changed, 44 insertions(+), 29 deletions(-)
-diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/blockjob_int.h
-+++ b/include/block/blockjob_int.h
-@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(Job *job);
-  */
- /**
-- * block_job_ratelimit_get_delay:
-+ * block_job_ratelimit_processed_bytes:
-  *
-- * Calculate and return delay for the next request in ns. See the documentation
-- * of ratelimit_calculate_delay() for details.
-+ * To be called after some work has been done. Adjusts the delay for the next
-+ * request. See the documentation of ratelimit_calculate_delay() for details.
-  */
--int64_t block_job_ratelimit_get_delay(BlockJob *job, uint64_t n);
-+void block_job_ratelimit_processed_bytes(BlockJob *job, uint64_t n);
-+
-+/**
-+ * Put the job to sleep (assuming that it wasn't canceled) to throttle it to the
-+ * right speed according to its rate limiting.
-+ */
-+void block_job_ratelimit_sleep(BlockJob *job);
- /**
-  * block_job_error_action:
-diff --git a/block/commit.c b/block/commit.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/commit.c
-+++ b/block/commit.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
- {
-     CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
-     int64_t offset;
--    uint64_t delay_ns = 0;
-     int ret = 0;
-     int64_t n = 0; /* bytes */
-     QEMU_AUTO_VFREE void *buf = NULL;
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
-         /* Note that even when no rate limit is applied we need to yield
-          * with no pending I/O here so that bdrv_drain_all() returns.
-          */
--        job_sleep_ns(&s->common.job, delay_ns);
-+        block_job_ratelimit_sleep(&s->common);
-         if (job_is_cancelled(&s->common.job)) {
-             break;
-         }
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
-         job_progress_update(&s->common.job, n);
-         if (copy) {
--            delay_ns = block_job_ratelimit_get_delay(&s->common, n);
--        } else {
--            delay_ns = 0;
-+            block_job_ratelimit_processed_bytes(&s->common, n);
-         }
-     }
-diff --git a/block/mirror.c b/block/mirror.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/mirror.c
-+++ b/block/mirror.c
-@@ -XXX,XX +XXX,XX @@ static unsigned mirror_perform(MirrorBlockJob *s, int64_t offset,
-     return bytes_handled;
- }
--static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s)
-+static void coroutine_fn mirror_iteration(MirrorBlockJob *s)
- {
-     BlockDriverState *source = s->mirror_top_bs->backing->bs;
-     MirrorOp *pseudo_op;
-     int64_t offset;
--    uint64_t delay_ns = 0, ret = 0;
-     /* At least the first dirty chunk is mirrored in one iteration. */
-     int nb_chunks = 1;
-     bool write_zeroes_ok = bdrv_can_write_zeroes_with_unmap(blk_bs(s->target));
-@@ -XXX,XX +XXX,XX @@ static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s)
-         assert(io_bytes);
-         offset += io_bytes;
-         nb_chunks -= DIV_ROUND_UP(io_bytes, s->granularity);
--        delay_ns = block_job_ratelimit_get_delay(&s->common, io_bytes_acct);
-+        block_job_ratelimit_processed_bytes(&s->common, io_bytes_acct);
-     }
--    ret = delay_ns;
- fail:
-     QTAILQ_REMOVE(&s->ops_in_flight, pseudo_op, next);
-     qemu_co_queue_restart_all(&pseudo_op->waiting_requests);
-     g_free(pseudo_op);
--
--    return ret;
- }
- static void mirror_free_init(MirrorBlockJob *s)
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
-     assert(!s->dbi);
-     s->dbi = bdrv_dirty_iter_new(s->dirty_bitmap);
-     for (;;) {
--        uint64_t delay_ns = 0;
-         int64_t cnt, delta;
-         bool should_complete;
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
-                 mirror_wait_for_free_in_flight_slot(s);
-                 continue;
-             } else if (cnt != 0) {
--                delay_ns = mirror_iteration(s);
-+                mirror_iteration(s);
-             }
-         }
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
-         }
-         if (job_is_ready(&s->common.job) && !should_complete) {
--            delay_ns = (s->in_flight == 0 &&
--                        cnt == 0 ? BLOCK_JOB_SLICE_TIME : 0);
-+            if (s->in_flight == 0 && cnt == 0) {
-+                trace_mirror_before_sleep(s, cnt, job_is_ready(&s->common.job),
-+                                          BLOCK_JOB_SLICE_TIME);
-+                job_sleep_ns(&s->common.job, BLOCK_JOB_SLICE_TIME);
-+            }
-+        } else {
-+            block_job_ratelimit_sleep(&s->common);
-         }
--        trace_mirror_before_sleep(s, cnt, job_is_ready(&s->common.job),
--                                  delay_ns);
--        job_sleep_ns(&s->common.job, delay_ns);
-         s->last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
-     }
-diff --git a/block/stream.c b/block/stream.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/stream.c
-+++ b/block/stream.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_run(Job *job, Error **errp)
-     BlockDriverState *unfiltered_bs = bdrv_skip_filters(s->target_bs);
-     int64_t len;
-     int64_t offset = 0;
--    uint64_t delay_ns = 0;
-     int error = 0;
-     int64_t n = 0; /* bytes */
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_run(Job *job, Error **errp)
-         /* Note that even when no rate limit is applied we need to yield
-          * with no pending I/O here so that bdrv_drain_all() returns.
-          */
--        job_sleep_ns(&s->common.job, delay_ns);
-+        block_job_ratelimit_sleep(&s->common);
-         if (job_is_cancelled(&s->common.job)) {
-             break;
-         }
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_run(Job *job, Error **errp)
-         /* Publish progress */
-         job_progress_update(&s->common.job, n);
-         if (copy) {
--            delay_ns = block_job_ratelimit_get_delay(&s->common, n);
--        } else {
--            delay_ns = 0;
-+            block_job_ratelimit_processed_bytes(&s->common, n);
-         }
-     }
 diff --git a/blockjob.c b/blockjob.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockjob.c
 +++ b/blockjob.c
-@@ -XXX,XX +XXX,XX @@ static bool 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 block_job_set_speed_locked(job, speed, errp);
+                            job->id);
  }
--int64_t block_job_ratelimit_get_delay(BlockJob *job, uint64_t n)
+-static const BdrvChildRole child_job = {
-+void block_job_ratelimit_processed_bytes(BlockJob *job, uint64_t n)
+-    .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)
  {
-     IO_CODE();
+-    BlockJob *job = opaque;
--    return ratelimit_calculate_delay(&job->limit, n);
++    BlockJob *job = c->opaque;
-+    ratelimit_calculate_delay(&job->limit, n);
+     block_job_pause(job);
 +}
 +
 +void block_job_ratelimit_sleep(BlockJob *job)
 +{
 +    uint64_t delay_ns;
 +
 +    /*
 +     * Sleep at least once. If the job is reentered early, keep waiting until
 +     * we've waited for the full time that is necessary to keep the job at the
 +     * right speed.
 +     *
 +     * Make sure to recalculate the delay after each (possibly interrupted)
 +     * sleep because the speed can change while the job has yielded.
 +     */
 +    do {
 +        delay_ns = ratelimit_calculate_delay(&job->limit, 0);
 +        job_sleep_ns(&job->job, delay_ns);
 +    } while (delay_ns && !job_is_cancelled(&job->job));
  }
- BlockJobInfo *block_job_query_locked(BlockJob *job, Error **errp)
+-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);
 --
-.40.1
+.13.6

-[PULL 02/18] blockdev: transactions: rename some things
+[Qemu-devel] [PULL v3 23/35] test-bdrv-drain: Test drain vs. block jobs
-From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
+Block jobs must be paused if any of the involved nodes are drained.
-Look at qmp_transaction(): dev_list is not obvious name for list of
-actions. Let's look at qapi spec, this argument is "actions". Let's
-follow the common practice of using same argument names in qapi scheme
-and code.
-To be honest, rename props to properties for same reason.
-Next, we have to rename global map of actions, to not conflict with new
-name for function argument.
-Rename also dev_entry loop variable accordingly to new name of the
-list.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20230510150624.310640-3-vsementsov@yandex-team.ru>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- blockdev.c | 30 +++++++++++++++---------------
+ tests/test-bdrv-drain.c | 121 ++++++++++++++++++++++++++++++++++++++++++++++++
-file changed, 15 insertions(+), 15 deletions(-)
+file changed, 121 insertions(+)
-diff --git a/blockdev.c b/blockdev.c
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockdev.c
+--- a/tests/test-bdrv-drain.c
-+++ b/blockdev.c
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ static void abort_commit(void *opaque)
+@@ -XXX,XX +XXX,XX @@
-     g_assert_not_reached(); /* this action never succeeds */
  #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);
  }
--static const BlkActionOps actions[] = {
++
-+static const BlkActionOps actions_map[] = {
++typedef struct TestBlockJob {
-     [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {
++    BlockJob common;
-         .instance_size = sizeof(ExternalSnapshotState),
++    bool should_complete;
-         .action  = external_snapshot_action,
++} TestBlockJob;
-@@ -XXX,XX +XXX,XX @@ static TransactionProperties *get_transaction_properties(
++
-  *
++static void test_job_completed(BlockJob *job, void *opaque)
-  * Always run under BQL.
++{
-  */
++    block_job_completed(job, 0);
--void qmp_transaction(TransactionActionList *dev_list,
++}
--                     struct TransactionProperties *props,
++
-+void qmp_transaction(TransactionActionList *actions,
++static void coroutine_fn test_job_start(void *opaque)
-+                     struct TransactionProperties *properties,
++{
-                      Error **errp)
++    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)
  {
--    TransactionActionList *dev_entry = dev_list;
+     bdrv_init();
--    bool has_props = !!props;
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
-+    TransactionActionList *act = actions;
+     g_test_add_func("/bdrv-drain/quiesce/drain_all", test_quiesce_drain_all);
-+    bool has_properties = !!properties;
+     g_test_add_func("/bdrv-drain/quiesce/drain", test_quiesce_drain);
-     JobTxn *block_job_txn = NULL;
-     Error *local_err = NULL;
++    g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
-     Transaction *tran = tran_new();
++    g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
-@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,
++
-     /* Does this transaction get canceled as a group on failure?
+     return g_test_run();
       * If not, we don't really need to make a JobTxn.
       */
 -    props = get_transaction_properties(props);
 -    if (props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
 +    properties = get_transaction_properties(properties);
 +    if (properties->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
          block_job_txn = job_txn_new();
      }
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,
      bdrv_drain_all();
      /* We don't do anything in this loop that commits us to the operations */
 -    while (NULL != dev_entry) {
 +    while (NULL != act) {
          TransactionAction *dev_info = NULL;
          const BlkActionOps *ops;
          BlkActionState *state;
 -        dev_info = dev_entry->value;
 -        dev_entry = dev_entry->next;
 +        dev_info = act->value;
 +        act = act->next;
 -        assert(dev_info->type < ARRAY_SIZE(actions));
 +        assert(dev_info->type < ARRAY_SIZE(actions_map));
 -        ops = &actions[dev_info->type];
 +        ops = &actions_map[dev_info->type];
          assert(ops->instance_size > 0);
          state = g_malloc0(ops->instance_size);
          state->ops = ops;
          state->action = dev_info;
          state->block_job_txn = block_job_txn;
 -        state->txn_props = props;
 +        state->txn_props = properties;
          state->ops->action(state, tran, &local_err);
          if (local_err) {
@@ -XXX,XX +XXX,XX @@ delete_and_fail:
      /* failure, and it is all-or-none; roll back all operations */
      tran_abort(tran);
  exit:
 -    if (!has_props) {
 -        qapi_free_TransactionProperties(props);
 +    if (!has_properties) {
 +        qapi_free_TransactionProperties(properties);
      }
      job_txn_unref(block_job_txn);
  }
 --
-.40.1
+.13.6

-New patch
+[Qemu-devel] [PULL v3 24/35] block: Don't block_job_pause_all() in bdrv_drain_all()
+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 ++++------
+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);
+     }
+--
+.13.6

-New patch
+[Qemu-devel] [PULL v3 25/35] block: Nested drain_end must still call callbacks
+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 +++++++-----
+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));
++    }
+ }
+ /*
+--
+.13.6

-[PULL 07/18] docs/interop/qcow2.txt: fix description about "zlib" clusters
+[Qemu-devel] [PULL v3 26/35] test-bdrv-drain: Test nested drain sections
-From: Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp>
-"zlib" clusters are actually raw deflate (RFC1951) clusters without
-zlib headers.
-Signed-off-by: Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp>
-Message-Id: <168424874322.11954.1340942046351859521-0@git.sr.ht>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- docs/interop/qcow2.txt | 10 +++++++---
+ tests/test-bdrv-drain.c | 57 +++++++++++++++++++++++++++++++++++++++++++++++++
-file changed, 7 insertions(+), 3 deletions(-)
+file changed, 57 insertions(+)
-diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
---- a/docs/interop/qcow2.txt
+--- a/tests/test-bdrv-drain.c
-+++ b/docs/interop/qcow2.txt
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ version 2.
+@@ -XXX,XX +XXX,XX @@ static void aio_ret_cb(void *opaque, int ret)
-                     type.
+ enum drain_type {
+     BDRV_DRAIN_ALL,
-                     If the incompatible bit "Compression type" is set: the field
+     BDRV_DRAIN,
--                    must be present and non-zero (which means non-zlib
++    DRAIN_TYPE_MAX,
-+                    must be present and non-zero (which means non-deflate
+ };
-                     compression type). Otherwise, this field must not be present
--                    or must be zero (which means zlib).
+ static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
-+                    or must be zero (which means deflate).
+@@ -XXX,XX +XXX,XX @@ static void test_quiesce_drain(void)
+     test_quiesce_common(BDRV_DRAIN, false);
-                     Available compression type values:
+ }
--                        0: zlib <https://www.zlib.net/>
-+                        0: deflate <https://www.ietf.org/rfc/rfc1951.txt>
++static void test_nested(void)
-: zstd <http://github.com/facebook/zstd>
++{
++    BlockBackend *blk;
-+                    The deflate compression type is called "zlib"
++    BlockDriverState *bs, *backing;
-+                    <https://www.zlib.net/> in QEMU. However, clusters with the
++    BDRVTestState *s, *backing_s;
-+                    deflate compression type do not have zlib headers.
++    enum drain_type outer, inner;
 +
++    blk = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
- === Header padding ===
++    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);
 --
-.40.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 01/18] blockdev: refactor transaction to use Transaction API
+[Qemu-devel] [PULL v3 28/35] block: Add bdrv_subtree_drained_begin/end()
-From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
+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().
-We are going to add more block-graph modifying transaction actions,
+Add a version that keeps the whole subtree drained. As of this commit,
-and block-graph modifying functions are already based on Transaction
+graph changes cannot be allowed during a subtree drained section, but
-API.
+this will be fixed soon.
-Next, we'll need to separately update permissions after several
-graph-modifying actions, and this would be simple with help of
-Transaction API.
-So, now let's just transform what we have into new-style transaction
-actions.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
-Message-Id: <20230510150624.310640-2-vsementsov@yandex-team.ru>
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- blockdev.c | 309 ++++++++++++++++++++++++++++++-----------------------
+ include/block/block.h | 13 +++++++++++++
-file changed, 178 insertions(+), 131 deletions(-)
+ block/io.c            | 54 ++++++++++++++++++++++++++++++++++++++++-----------
 files changed, 56 insertions(+), 11 deletions(-)
-diff --git a/blockdev.c b/blockdev.c
+diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
---- a/blockdev.c
+--- a/include/block/block.h
-+++ b/blockdev.c
++++ b/include/block/block.h
-@@ -XXX,XX +XXX,XX @@ typedef struct BlkActionState BlkActionState;
+@@ -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().
   */
- typedef struct BlkActionOps {
+ void bdrv_drained_end(BlockDriverState *bs);
-     size_t instance_size;
--    void (*prepare)(BlkActionState *common, Error **errp);
++/**
--    void (*commit)(BlkActionState *common);
++ * End a quiescent section started by bdrv_subtree_drained_begin().
--    void (*abort)(BlkActionState *common);
++ */
--    void (*clean)(BlkActionState *common);
++void bdrv_subtree_drained_end(BlockDriverState *bs);
-+    void (*action)(BlkActionState *common, Transaction *tran, Error **errp);
++
- } BlkActionOps;
+ void bdrv_add_child(BlockDriverState *parent, BlockDriverState *child,
+                     Error **errp);
- /**
+ void bdrv_del_child(BlockDriverState *parent, BdrvChild *child, Error **errp);
-@@ -XXX,XX +XXX,XX @@ typedef struct InternalSnapshotState {
+diff --git a/block/io.c b/block/io.c
-     bool created;
+index XXXXXXX..XXXXXXX 100644
- } InternalSnapshotState;
+--- a/block/io.c
++++ b/block/io.c
-+static void internal_snapshot_abort(void *opaque);
+@@ -XXX,XX +XXX,XX @@ typedef struct {
-+static void internal_snapshot_clean(void *opaque);
+     BlockDriverState *bs;
-+TransactionActionDrv internal_snapshot_drv = {
+     bool done;
-+    .abort = internal_snapshot_abort,
+     bool begin;
-+    .clean = internal_snapshot_clean,
++    bool recursive;
-+};
+     BdrvChild *parent;
+ } BdrvCoDrainData;
- static int action_check_completion_mode(BlkActionState *s, Error **errp)
@@ -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 int action_check_completion_mode(BlkActionState *s, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static void bdrv_co_drain_bh_cb(void *opaque)
-     return 0;
      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 internal_snapshot_prepare(BlkActionState *common,
+ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
--                                      Error **errp)
+-                                                bool begin, BdrvChild *parent)
-+static void internal_snapshot_action(BlkActionState *common,
++                                                bool begin, bool recursive,
-+                                     Transaction *tran, Error **errp)
++                                                BdrvChild *parent)
  {
-     Error *local_err = NULL;
+     BdrvCoDrainData data;
-     const char *device;
-@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_prepare(BlkActionState *common,
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn bdrv_co_yield_to_drain(BlockDriverState *bs,
-     internal = common->action->u.blockdev_snapshot_internal_sync.data;
+         .bs = bs,
-     state = DO_UPCAST(InternalSnapshotState, common, common);
+         .done = false,
+         .begin = begin,
-+    tran_add(tran, &internal_snapshot_drv, state);
++        .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;
 +
-     /* 1. parse input */
+     if (qemu_in_coroutine()) {
-     device = internal->device;
+-        bdrv_co_yield_to_drain(bs, true, parent);
-     name = internal->name;
++        bdrv_co_yield_to_drain(bs, true, recursive, parent);
@@ -XXX,XX +XXX,XX @@ out:
      aio_context_release(aio_context);
  }
 -static void internal_snapshot_abort(BlkActionState *common)
 +static void internal_snapshot_abort(void *opaque)
  {
 -    InternalSnapshotState *state =
 -                             DO_UPCAST(InternalSnapshotState, common, common);
 +    InternalSnapshotState *state = opaque;
      BlockDriverState *bs = state->bs;
      QEMUSnapshotInfo *sn = &state->sn;
      AioContext *aio_context;
@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_abort(BlkActionState *common)
      aio_context_release(aio_context);
  }
 -static void internal_snapshot_clean(BlkActionState *common)
 +static void internal_snapshot_clean(void *opaque)
  {
 -    InternalSnapshotState *state = DO_UPCAST(InternalSnapshotState,
 -                                             common, common);
 +    g_autofree InternalSnapshotState *state = opaque;
      AioContext *aio_context;
      if (!state->bs) {
@@ -XXX,XX +XXX,XX @@ typedef struct ExternalSnapshotState {
      bool overlay_appended;
  } ExternalSnapshotState;
 -static void external_snapshot_prepare(BlkActionState *common,
 -                                      Error **errp)
 +static void external_snapshot_commit(void *opaque);
 +static void external_snapshot_abort(void *opaque);
 +static void external_snapshot_clean(void *opaque);
 +TransactionActionDrv external_snapshot_drv = {
 +    .commit = external_snapshot_commit,
 +    .abort = external_snapshot_abort,
 +    .clean = external_snapshot_clean,
 +};
 +
 +static void external_snapshot_action(BlkActionState *common, Transaction *tran,
 +                                     Error **errp)
  {
      int ret;
      int flags = 0;
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,
      AioContext *aio_context;
      uint64_t perm, shared;
 +    tran_add(tran, &external_snapshot_drv, state);
 +
      /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
       * purpose but a different set of parameters */
      switch (action->type) {
@@ -XXX,XX +XXX,XX @@ out:
      aio_context_release(aio_context);
  }
 -static void external_snapshot_commit(BlkActionState *common)
 +static void external_snapshot_commit(void *opaque)
  {
 -    ExternalSnapshotState *state =
 -                             DO_UPCAST(ExternalSnapshotState, common, common);
 +    ExternalSnapshotState *state = opaque;
      AioContext *aio_context;
      aio_context = bdrv_get_aio_context(state->old_bs);
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_commit(BlkActionState *common)
      aio_context_release(aio_context);
  }
 -static void external_snapshot_abort(BlkActionState *common)
 +static void external_snapshot_abort(void *opaque)
  {
 -    ExternalSnapshotState *state =
 -                             DO_UPCAST(ExternalSnapshotState, common, common);
 +    ExternalSnapshotState *state = opaque;
      if (state->new_bs) {
          if (state->overlay_appended) {
              AioContext *aio_context;
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_abort(BlkActionState *common)
      }
  }
 -static void external_snapshot_clean(BlkActionState *common)
 +static void external_snapshot_clean(void *opaque)
  {
 -    ExternalSnapshotState *state =
 -                             DO_UPCAST(ExternalSnapshotState, common, common);
 +    g_autofree ExternalSnapshotState *state = opaque;
      AioContext *aio_context;
      if (!state->old_bs) {
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_backup_common(BackupCommon *backup,
                                    AioContext *aio_context,
                                    JobTxn *txn, Error **errp);
 -static void drive_backup_prepare(BlkActionState *common, Error **errp)
 +static void drive_backup_commit(void *opaque);
 +static void drive_backup_abort(void *opaque);
 +static void drive_backup_clean(void *opaque);
 +TransactionActionDrv drive_backup_drv = {
 +    .commit = drive_backup_commit,
 +    .abort = drive_backup_abort,
 +    .clean = drive_backup_clean,
 +};
 +
 +static void drive_backup_action(BlkActionState *common, Transaction *tran,
 +                                Error **errp)
  {
      DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
      DriveBackup *backup;
@@ -XXX,XX +XXX,XX @@ static void drive_backup_prepare(BlkActionState *common, Error **errp)
      bool set_backing_hd = false;
      int ret;
 +    tran_add(tran, &drive_backup_drv, state);
 +
      assert(common->action->type == TRANSACTION_ACTION_KIND_DRIVE_BACKUP);
      backup = common->action->u.drive_backup.data;
@@ -XXX,XX +XXX,XX @@ out:
      aio_context_release(aio_context);
  }
 -static void drive_backup_commit(BlkActionState *common)
 +static void drive_backup_commit(void *opaque)
  {
 -    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
 +    DriveBackupState *state = opaque;
      AioContext *aio_context;
      aio_context = bdrv_get_aio_context(state->bs);
@@ -XXX,XX +XXX,XX @@ static void drive_backup_commit(BlkActionState *common)
      aio_context_release(aio_context);
  }
 -static void drive_backup_abort(BlkActionState *common)
 +static void drive_backup_abort(void *opaque)
  {
 -    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
 +    DriveBackupState *state = opaque;
      if (state->job) {
          job_cancel_sync(&state->job->job, true);
      }
  }
 -static void drive_backup_clean(BlkActionState *common)
 +static void drive_backup_clean(void *opaque)
  {
 -    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
 +    g_autofree DriveBackupState *state = opaque;
      AioContext *aio_context;
      if (!state->bs) {
@@ -XXX,XX +XXX,XX @@ typedef struct BlockdevBackupState {
      BlockJob *job;
  } BlockdevBackupState;
 -static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
 +static void blockdev_backup_commit(void *opaque);
 +static void blockdev_backup_abort(void *opaque);
 +static void blockdev_backup_clean(void *opaque);
 +TransactionActionDrv blockdev_backup_drv = {
 +    .commit = blockdev_backup_commit,
 +    .abort = blockdev_backup_abort,
 +    .clean = blockdev_backup_clean,
 +};
 +
 +static void blockdev_backup_action(BlkActionState *common, Transaction *tran,
 +                                   Error **errp)
  {
      BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
      BlockdevBackup *backup;
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
      AioContext *old_context;
      int ret;
 +    tran_add(tran, &blockdev_backup_drv, state);
 +
      assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
      backup = common->action->u.blockdev_backup.data;
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
      aio_context_release(aio_context);
  }
 -static void blockdev_backup_commit(BlkActionState *common)
 +static void blockdev_backup_commit(void *opaque)
  {
 -    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
 +    BlockdevBackupState *state = opaque;
      AioContext *aio_context;
      aio_context = bdrv_get_aio_context(state->bs);
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_commit(BlkActionState *common)
      aio_context_release(aio_context);
  }
 -static void blockdev_backup_abort(BlkActionState *common)
 +static void blockdev_backup_abort(void *opaque)
  {
 -    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
 +    BlockdevBackupState *state = opaque;
      if (state->job) {
          job_cancel_sync(&state->job->job, true);
      }
  }
 -static void blockdev_backup_clean(BlkActionState *common)
 +static void blockdev_backup_clean(void *opaque)
  {
 -    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
 +    g_autofree BlockdevBackupState *state = opaque;
      AioContext *aio_context;
      if (!state->bs) {
@@ -XXX,XX +XXX,XX @@ typedef struct BlockDirtyBitmapState {
      bool was_enabled;
  } BlockDirtyBitmapState;
 -static void block_dirty_bitmap_add_prepare(BlkActionState *common,
 -                                           Error **errp)
 +static void block_dirty_bitmap_add_abort(void *opaque);
 +TransactionActionDrv block_dirty_bitmap_add_drv = {
 +    .abort = block_dirty_bitmap_add_abort,
 +    .clean = g_free,
 +};
 +
 +static void block_dirty_bitmap_add_action(BlkActionState *common,
 +                                          Transaction *tran, Error **errp)
  {
      Error *local_err = NULL;
      BlockDirtyBitmapAdd *action;
      BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                               common, common);
 +    tran_add(tran, &block_dirty_bitmap_add_drv, state);
 +
      if (action_check_completion_mode(common, errp) < 0) {
          return;
      }
-@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_add_prepare(BlkActionState *common,
-     }
+@@ -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);
 +        }
 +    }
  }
--static void block_dirty_bitmap_add_abort(BlkActionState *common)
+ void bdrv_drained_begin(BlockDriverState *bs)
 +static void block_dirty_bitmap_add_abort(void *opaque)
  {
-     BlockDirtyBitmapAdd *action;
+-    bdrv_do_drained_begin(bs, NULL);
--    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
++    bdrv_do_drained_begin(bs, false, NULL);
--                                             common, common);
++}
-+    BlockDirtyBitmapState *state = opaque;
++
++void bdrv_subtree_drained_begin(BlockDriverState *bs)
--    action = common->action->u.block_dirty_bitmap_add.data;
++{
-+    action = state->common.action->u.block_dirty_bitmap_add.data;
++    bdrv_do_drained_begin(bs, true, NULL);
      /* Should not be able to fail: IF the bitmap was added via .prepare(),
       * then the node reference and bitmap name must have been valid.
       */
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_add_abort(BlkActionState *common)
      }
  }
--static void block_dirty_bitmap_clear_prepare(BlkActionState *common,
+-static void bdrv_do_drained_end(BlockDriverState *bs, BdrvChild *parent)
--                                             Error **errp)
++static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
-+static void block_dirty_bitmap_restore(void *opaque);
++                                BdrvChild *parent)
 +static void block_dirty_bitmap_free_backup(void *opaque);
 +TransactionActionDrv block_dirty_bitmap_clear_drv = {
 +    .abort = block_dirty_bitmap_restore,
 +    .commit = block_dirty_bitmap_free_backup,
 +    .clean = g_free,
 +};
 +
 +static void block_dirty_bitmap_clear_action(BlkActionState *common,
 +                                            Transaction *tran, Error **errp)
  {
-     BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
++    BdrvChild *child, *next;
-                                              common, common);
+     int old_quiesce_counter;
-     BlockDirtyBitmap *action;
+     if (qemu_in_coroutine()) {
-+    tran_add(tran, &block_dirty_bitmap_clear_drv, state);
+-        bdrv_co_yield_to_drain(bs, false, parent);
-+
++        bdrv_co_yield_to_drain(bs, false, recursive, parent);
      if (action_check_completion_mode(common, errp) < 0) {
          return;
      }
-@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_clear_prepare(BlkActionState *common,
+     assert(bs->quiesce_counter > 0);
-     bdrv_clear_dirty_bitmap(state->bitmap, &state->backup);
+@@ -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);
 +        }
 +    }
  }
--static void block_dirty_bitmap_restore(BlkActionState *common)
+ void bdrv_drained_end(BlockDriverState *bs)
 +static void block_dirty_bitmap_restore(void *opaque)
  {
--    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
+-    bdrv_do_drained_end(bs, NULL);
--                                             common, common);
++    bdrv_do_drained_end(bs, false, NULL);
-+    BlockDirtyBitmapState *state = opaque;
++}
++
-     if (state->backup) {
++void bdrv_subtree_drained_end(BlockDriverState *bs)
-         bdrv_restore_dirty_bitmap(state->bitmap, state->backup);
++{
-     }
++    bdrv_do_drained_end(bs, true, NULL);
  }
--static void block_dirty_bitmap_free_backup(BlkActionState *common)
+ /*
 +static void block_dirty_bitmap_free_backup(void *opaque)
  {
 -    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
 -                                             common, common);
 +    BlockDirtyBitmapState *state = opaque;
      hbitmap_free(state->backup);
  }
 -static void block_dirty_bitmap_enable_prepare(BlkActionState *common,
 -                                              Error **errp)
 +static void block_dirty_bitmap_enable_abort(void *opaque);
 +TransactionActionDrv block_dirty_bitmap_enable_drv = {
 +    .abort = block_dirty_bitmap_enable_abort,
 +    .clean = g_free,
 +};
 +
 +static void block_dirty_bitmap_enable_action(BlkActionState *common,
 +                                             Transaction *tran, Error **errp)
  {
      BlockDirtyBitmap *action;
      BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                               common, common);
 +    tran_add(tran, &block_dirty_bitmap_enable_drv, state);
 +
      if (action_check_completion_mode(common, errp) < 0) {
          return;
      }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_enable_prepare(BlkActionState *common,
      bdrv_enable_dirty_bitmap(state->bitmap);
  }
 -static void block_dirty_bitmap_enable_abort(BlkActionState *common)
 +static void block_dirty_bitmap_enable_abort(void *opaque)
  {
 -    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
 -                                             common, common);
 +    BlockDirtyBitmapState *state = opaque;
      if (!state->was_enabled) {
          bdrv_disable_dirty_bitmap(state->bitmap);
      }
  }
 -static void block_dirty_bitmap_disable_prepare(BlkActionState *common,
 -                                               Error **errp)
 +static void block_dirty_bitmap_disable_abort(void *opaque);
 +TransactionActionDrv block_dirty_bitmap_disable_drv = {
 +    .abort = block_dirty_bitmap_disable_abort,
 +    .clean = g_free,
 +};
 +
 +static void block_dirty_bitmap_disable_action(BlkActionState *common,
 +                                              Transaction *tran, Error **errp)
  {
      BlockDirtyBitmap *action;
      BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                               common, common);
 +    tran_add(tran, &block_dirty_bitmap_disable_drv, state);
 +
      if (action_check_completion_mode(common, errp) < 0) {
          return;
      }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_disable_prepare(BlkActionState *common,
      bdrv_disable_dirty_bitmap(state->bitmap);
  }
 -static void block_dirty_bitmap_disable_abort(BlkActionState *common)
 +static void block_dirty_bitmap_disable_abort(void *opaque)
  {
 -    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
 -                                             common, common);
 +    BlockDirtyBitmapState *state = opaque;
      if (state->was_enabled) {
          bdrv_enable_dirty_bitmap(state->bitmap);
      }
  }
 -static void block_dirty_bitmap_merge_prepare(BlkActionState *common,
 -                                             Error **errp)
 +TransactionActionDrv block_dirty_bitmap_merge_drv = {
 +    .commit = block_dirty_bitmap_free_backup,
 +    .abort = block_dirty_bitmap_restore,
 +    .clean = g_free,
 +};
 +
 +static void block_dirty_bitmap_merge_action(BlkActionState *common,
 +                                            Transaction *tran, Error **errp)
  {
      BlockDirtyBitmapMerge *action;
      BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                               common, common);
 +    tran_add(tran, &block_dirty_bitmap_merge_drv, state);
 +
      if (action_check_completion_mode(common, errp) < 0) {
          return;
      }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_merge_prepare(BlkActionState *common,
                                               errp);
  }
 -static void block_dirty_bitmap_remove_prepare(BlkActionState *common,
 -                                              Error **errp)
 +static void block_dirty_bitmap_remove_commit(void *opaque);
 +static void block_dirty_bitmap_remove_abort(void *opaque);
 +TransactionActionDrv block_dirty_bitmap_remove_drv = {
 +    .commit = block_dirty_bitmap_remove_commit,
 +    .abort = block_dirty_bitmap_remove_abort,
 +    .clean = g_free,
 +};
 +
 +static void block_dirty_bitmap_remove_action(BlkActionState *common,
 +                                             Transaction *tran, Error **errp)
  {
      BlockDirtyBitmap *action;
      BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                               common, common);
 +    tran_add(tran, &block_dirty_bitmap_remove_drv, state);
 +
      if (action_check_completion_mode(common, errp) < 0) {
          return;
      }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_remove_prepare(BlkActionState *common,
      }
  }
 -static void block_dirty_bitmap_remove_abort(BlkActionState *common)
 +static void block_dirty_bitmap_remove_abort(void *opaque)
  {
 -    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
 -                                             common, common);
 +    BlockDirtyBitmapState *state = opaque;
      if (state->bitmap) {
          bdrv_dirty_bitmap_skip_store(state->bitmap, false);
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_remove_abort(BlkActionState *common)
      }
  }
 -static void block_dirty_bitmap_remove_commit(BlkActionState *common)
 +static void block_dirty_bitmap_remove_commit(void *opaque)
  {
 -    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
 -                                             common, common);
 +    BlockDirtyBitmapState *state = opaque;
      bdrv_dirty_bitmap_set_busy(state->bitmap, false);
      bdrv_release_dirty_bitmap(state->bitmap);
  }
 -static void abort_prepare(BlkActionState *common, Error **errp)
 +static void abort_commit(void *opaque);
 +TransactionActionDrv abort_drv = {
 +    .commit = abort_commit,
 +    .clean = g_free,
 +};
 +
 +static void abort_action(BlkActionState *common, Transaction *tran,
 +                         Error **errp)
  {
 +    tran_add(tran, &abort_drv, common);
      error_setg(errp, "Transaction aborted using Abort action");
  }
 -static void abort_commit(BlkActionState *common)
 +static void abort_commit(void *opaque)
  {
      g_assert_not_reached(); /* this action never succeeds */
  }
@@ -XXX,XX +XXX,XX @@ static void abort_commit(BlkActionState *common)
  static const BlkActionOps actions[] = {
      [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {
          .instance_size = sizeof(ExternalSnapshotState),
 -        .prepare  = external_snapshot_prepare,
 -        .commit   = external_snapshot_commit,
 -        .abort = external_snapshot_abort,
 -        .clean = external_snapshot_clean,
 +        .action  = external_snapshot_action,
      },
      [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC] = {
          .instance_size = sizeof(ExternalSnapshotState),
 -        .prepare  = external_snapshot_prepare,
 -        .commit   = external_snapshot_commit,
 -        .abort = external_snapshot_abort,
 -        .clean = external_snapshot_clean,
 +        .action  = external_snapshot_action,
      },
      [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] = {
          .instance_size = sizeof(DriveBackupState),
 -        .prepare = drive_backup_prepare,
 -        .commit = drive_backup_commit,
 -        .abort = drive_backup_abort,
 -        .clean = drive_backup_clean,
 +        .action = drive_backup_action,
      },
      [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] = {
          .instance_size = sizeof(BlockdevBackupState),
 -        .prepare = blockdev_backup_prepare,
 -        .commit = blockdev_backup_commit,
 -        .abort = blockdev_backup_abort,
 -        .clean = blockdev_backup_clean,
 +        .action = blockdev_backup_action,
      },
      [TRANSACTION_ACTION_KIND_ABORT] = {
          .instance_size = sizeof(BlkActionState),
 -        .prepare = abort_prepare,
 -        .commit = abort_commit,
 +        .action = abort_action,
      },
      [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC] = {
          .instance_size = sizeof(InternalSnapshotState),
 -        .prepare  = internal_snapshot_prepare,
 -        .abort = internal_snapshot_abort,
 -        .clean = internal_snapshot_clean,
 +        .action  = internal_snapshot_action,
      },
      [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD] = {
          .instance_size = sizeof(BlockDirtyBitmapState),
 -        .prepare = block_dirty_bitmap_add_prepare,
 -        .abort = block_dirty_bitmap_add_abort,
 +        .action = block_dirty_bitmap_add_action,
      },
      [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR] = {
          .instance_size = sizeof(BlockDirtyBitmapState),
 -        .prepare = block_dirty_bitmap_clear_prepare,
 -        .commit = block_dirty_bitmap_free_backup,
 -        .abort = block_dirty_bitmap_restore,
 +        .action = block_dirty_bitmap_clear_action,
      },
      [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE] = {
          .instance_size = sizeof(BlockDirtyBitmapState),
 -        .prepare = block_dirty_bitmap_enable_prepare,
 -        .abort = block_dirty_bitmap_enable_abort,
 +        .action = block_dirty_bitmap_enable_action,
      },
      [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE] = {
          .instance_size = sizeof(BlockDirtyBitmapState),
 -        .prepare = block_dirty_bitmap_disable_prepare,
 -        .abort = block_dirty_bitmap_disable_abort,
 +        .action = block_dirty_bitmap_disable_action,
      },
      [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE] = {
          .instance_size = sizeof(BlockDirtyBitmapState),
 -        .prepare = block_dirty_bitmap_merge_prepare,
 -        .commit = block_dirty_bitmap_free_backup,
 -        .abort = block_dirty_bitmap_restore,
 +        .action = block_dirty_bitmap_merge_action,
      },
      [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE] = {
          .instance_size = sizeof(BlockDirtyBitmapState),
 -        .prepare = block_dirty_bitmap_remove_prepare,
 -        .commit = block_dirty_bitmap_remove_commit,
 -        .abort = block_dirty_bitmap_remove_abort,
 +        .action = block_dirty_bitmap_remove_action,
      },
      /* Where are transactions for MIRROR, COMMIT and STREAM?
       * Although these blockjobs use transaction callbacks like the backup job,
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,
      TransactionActionList *dev_entry = dev_list;
      bool has_props = !!props;
      JobTxn *block_job_txn = NULL;
 -    BlkActionState *state, *next;
      Error *local_err = NULL;
 +    Transaction *tran = tran_new();
      GLOBAL_STATE_CODE();
 -    QTAILQ_HEAD(, BlkActionState) snap_bdrv_states;
 -    QTAILQ_INIT(&snap_bdrv_states);
 -
      /* Does this transaction get canceled as a group on failure?
       * If not, we don't really need to make a JobTxn.
       */
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,
      while (NULL != dev_entry) {
          TransactionAction *dev_info = NULL;
          const BlkActionOps *ops;
 +        BlkActionState *state;
          dev_info = dev_entry->value;
          dev_entry = dev_entry->next;
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,
          state->action = dev_info;
          state->block_job_txn = block_job_txn;
          state->txn_props = props;
 -        QTAILQ_INSERT_TAIL(&snap_bdrv_states, state, entry);
 -        state->ops->prepare(state, &local_err);
 +        state->ops->action(state, tran, &local_err);
          if (local_err) {
              error_propagate(errp, local_err);
              goto delete_and_fail;
          }
      }
 -    QTAILQ_FOREACH(state, &snap_bdrv_states, entry) {
 -        if (state->ops->commit) {
 -            state->ops->commit(state);
 -        }
 -    }
 +    tran_commit(tran);
      /* success */
      goto exit;
  delete_and_fail:
      /* failure, and it is all-or-none; roll back all operations */
 -    QTAILQ_FOREACH_REVERSE(state, &snap_bdrv_states, entry) {
 -        if (state->ops->abort) {
 -            state->ops->abort(state);
 -        }
 -    }
 +    tran_abort(tran);
  exit:
 -    QTAILQ_FOREACH_SAFE(state, &snap_bdrv_states, entry, next) {
 -        if (state->ops->clean) {
 -            state->ops->clean(state);
 -        }
 -        g_free(state);
 -    }
      if (!has_props) {
          qapi_free_TransactionProperties(props);
      }
 --
-.40.1
+.13.6

-[PULL 17/18] aio-posix: do not nest poll handlers
+[Qemu-devel] [PULL v3 29/35] test-bdrv-drain: Tests for bdrv_subtree_drain
-From: Stefan Hajnoczi <stefanha@redhat.com>
+Add a subtree drain version to the existing test cases.
-QEMU's event loop supports nesting, which means that event handler
-functions may themselves call aio_poll(). The condition that triggered a
-handler must be reset before the nested aio_poll() call, otherwise the
-same handler will be called and immediately re-enter aio_poll. This
-leads to an infinite loop and stack exhaustion.
-Poll handlers are especially prone to this issue, because they typically
-reset their condition by finishing the processing of pending work.
-Unfortunately it is during the processing of pending work that nested
-aio_poll() calls typically occur and the condition has not yet been
-reset.
-Disable a poll handler during ->io_poll_ready() so that a nested
-aio_poll() call cannot invoke ->io_poll_ready() again. As a result, the
-disabled poll handler and its associated fd handler do not run during
-the nested aio_poll(). Calling aio_set_fd_handler() from inside nested
-aio_poll() could cause it to run again. If the fd handler is pending
-inside nested aio_poll(), then it will also run again.
-In theory fd handlers can be affected by the same issue, but they are
-more likely to reset the condition before calling nested aio_poll().
-This is a special case and it's somewhat complex, but I don't see a way
-around it as long as nested aio_poll() is supported.
-Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=2186181
-Fixes: c38270692593 ("block: Mark bdrv_co_io_(un)plug() and callers GRAPH_RDLOCK")
-Cc: Kevin Wolf <kwolf@redhat.com>
-Cc: Emanuele Giuseppe Esposito <eesposit@redhat.com>
-Cc: Paolo Bonzini <pbonzini@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-Message-Id: <20230502184134.534703-2-stefanha@redhat.com>
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- util/aio-posix.c | 11 +++++++++++
+ tests/test-bdrv-drain.c | 27 ++++++++++++++++++++++++++-
-file changed, 11 insertions(+)
+file changed, 26 insertions(+), 1 deletion(-)
-diff --git a/util/aio-posix.c b/util/aio-posix.c
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
---- a/util/aio-posix.c
+--- a/tests/test-bdrv-drain.c
-+++ b/util/aio-posix.c
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handler(AioContext *ctx, AioHandler *node)
+@@ -XXX,XX +XXX,XX @@ static void aio_ret_cb(void *opaque, int ret)
-         poll_ready && revents == 0 &&
+ enum drain_type {
-         aio_node_check(ctx, node->is_external) &&
+     BDRV_DRAIN_ALL,
-         node->io_poll_ready) {
+     BDRV_DRAIN,
-+        /*
++    BDRV_SUBTREE_DRAIN,
-+         * Remove temporarily to avoid infinite loops when ->io_poll_ready()
+     DRAIN_TYPE_MAX,
-+         * calls aio_poll() before clearing the condition that made the poll
+ };
-+         * handler become ready.
-+         */
+@@ -XXX,XX +XXX,XX @@ static void do_drain_begin(enum drain_type drain_type, BlockDriverState *bs)
-+        QLIST_SAFE_REMOVE(node, node_poll);
+     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);
 +}
 +
-         node->io_poll_ready(node->opaque);
+ static void test_quiesce_common(enum drain_type drain_type, bool recursive)
+ {
-+        if (!QLIST_IS_INSERTED(node, node_poll)) {
+     BlockBackend *blk;
-+            QLIST_INSERT_HEAD(&ctx->poll_aio_handlers, node, node_poll);
+@@ -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)
-          * Return early since revents was zero. aio_notify() does not count as
+ {
-          * progress.
+     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();
  }
 --
-.40.1
+.13.6

-[PULL 09/18] block/export: Fix null pointer dereference in error path
+[Qemu-devel] [PULL v3 30/35] test-bdrv-drain: Test behaviour in coroutine context
-There are some error paths in blk_exp_add() that jump to 'fail:' before
+If bdrv_do_drained_begin/end() are called in coroutine context, they
-'exp' is even created. So we can't just unconditionally access exp->blk.
+first use a BH to get out of the coroutine context. Call some existing
 tests again from a coroutine to cover this code path.
-Add a NULL check, and switch from exp->blk to blk, which is available
-earlier, just to be extra sure that we really cover all cases where
-BlockDevOps could have been set for it (in practice, this only happens
-in drv->create() today, so this part of the change isn't strictly
-necessary).
-Fixes: Coverity CID 1509238
-Fixes: de79b52604e43fdeba6cee4f5af600b62169f2d2
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20230510203601.418015-3-kwolf@redhat.com>
-Reviewed-by: Eric Blake <eblake@redhat.com>
-Tested-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/export/export.c | 6 ++++--
+ tests/test-bdrv-drain.c | 59 +++++++++++++++++++++++++++++++++++++++++++++++++
-file changed, 4 insertions(+), 2 deletions(-)
+file changed, 59 insertions(+)
-diff --git a/block/export/export.c b/block/export/export.c
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/export/export.c
+--- a/tests/test-bdrv-drain.c
-+++ b/block/export/export.c
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static void aio_ret_cb(void *opaque, int ret)
-     return exp;
+     *aio_ret = ret;
+ }
- fail:
--    blk_set_dev_ops(exp->blk, NULL, NULL);
++typedef struct CallInCoroutineData {
--    blk_unref(blk);
++    void (*entry)(void);
-+    if (blk) {
++    bool done;
-+        blk_set_dev_ops(blk, NULL, NULL);
++} CallInCoroutineData;
-+        blk_unref(blk);
++
 +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);
 +    }
-     aio_context_release(ctx);
++}
-     if (exp) {
++
-         g_free(exp->id);
+ 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);
 --
-.40.1
+.13.6

-[PULL 05/18] blockdev: use state.bitmap in block-dirty-bitmap-add action
+[Qemu-devel] [PULL v3 31/35] test-bdrv-drain: Recursive draining with multiple parents
-From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
+Test that drain sections are correctly propagated through the graph.
-Other bitmap related actions use the .bitmap pointer in .abort action,
-let's do same here:
-. It helps further refactoring, as bitmap-add is the only bitmap
-   action that uses state.action in .abort
-. It must be safe: transaction actions rely on the fact that on
-   .abort() the state is the same as at the end of .prepare(), so that
-   in .abort() we could precisely rollback the changes done by
-   .prepare().
-   The only way to remove the bitmap during transaction should be
-   block-dirty-bitmap-remove action, but it postpones actual removal to
-   .commit(), so we are OK on any rollback path. (Note also that
-   bitmap-remove is the only bitmap action that has .commit() phase,
-   except for simple g_free the state on .clean())
-. Again, other bitmap actions behave this way: keep the bitmap pointer
-   during the transaction.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
-Message-Id: <20230510150624.310640-6-vsementsov@yandex-team.ru>
-[kwolf: Also remove the now unused BlockDirtyBitmapState.prepared]
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- blockdev.c | 13 ++++---------
+ tests/test-bdrv-drain.c | 74 +++++++++++++++++++++++++++++++++++++++++++++++++
-file changed, 4 insertions(+), 9 deletions(-)
+file changed, 74 insertions(+)
-diff --git a/blockdev.c b/blockdev.c
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockdev.c
+--- a/tests/test-bdrv-drain.c
-+++ b/blockdev.c
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ typedef struct BlockDirtyBitmapState {
+@@ -XXX,XX +XXX,XX @@ static void test_nested(void)
-     BdrvDirtyBitmap *bitmap;
+     blk_unref(blk);
      BlockDriverState *bs;
      HBitmap *backup;
 -    bool prepared;
      bool was_enabled;
  } BlockDirtyBitmapState;
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_add_action(BlkActionState *common,
                                 &local_err);
      if (!local_err) {
 -        state->prepared = true;
 +        state->bitmap = block_dirty_bitmap_lookup(action->node, action->name,
 +                                                  NULL, &error_abort);
      } else {
          error_propagate(errp, local_err);
      }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_add_action(BlkActionState *common,
  static void block_dirty_bitmap_add_abort(void *opaque)
  {
 -    BlockDirtyBitmapAdd *action;
      BlockDirtyBitmapState *state = opaque;
 -    action = state->common.action->u.block_dirty_bitmap_add.data;
 -    /* Should not be able to fail: IF the bitmap was added via .prepare(),
 -     * then the node reference and bitmap name must have been valid.
 -     */
 -    if (state->prepared) {
 -        qmp_block_dirty_bitmap_remove(action->node, action->name, &error_abort);
 +    if (state->bitmap) {
 +        bdrv_release_dirty_bitmap(state->bitmap);
      }
  }
++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);
 --
-.40.1
+.13.6

-[PULL 04/18] blockdev: transaction: refactor handling transaction properties
+[Qemu-devel] [PULL v3 32/35] block: Allow graph changes in subtree drained section
-From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
+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
-Only backup supports GROUPED mode. Make this logic more clear. And
+can be correctly applied when children are added or removed during the
-avoid passing extra thing to each action.
+drained section.
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
+With this change, it is safe to modify the graph even inside a
-Message-Id: <20230510150624.310640-5-vsementsov@yandex-team.ru>
+bdrv_subtree_drained_begin/end() section.
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- blockdev.c | 96 +++++++++++++-----------------------------------------
+ include/block/block.h     |  2 --
-file changed, 22 insertions(+), 74 deletions(-)
+ include/block/block_int.h |  5 +++++
+ block.c                   | 32 +++++++++++++++++++++++++++++---
-diff --git a/blockdev.c b/blockdev.c
+ block/io.c                | 28 ++++++++++++++++++++++++----
-index XXXXXXX..XXXXXXX 100644
+files changed, 58 insertions(+), 9 deletions(-)
---- a/blockdev.c
-+++ b/blockdev.c
+diff --git a/include/block/block.h b/include/block/block.h
-@@ -XXX,XX +XXX,XX @@ struct BlkActionState {
+index XXXXXXX..XXXXXXX 100644
-     TransactionAction *action;
+--- a/include/block/block.h
-     const BlkActionOps *ops;
++++ b/include/block/block.h
-     JobTxn *block_job_txn;
+@@ -XXX,XX +XXX,XX @@ void bdrv_drained_begin(BlockDriverState *bs);
--    TransactionProperties *txn_props;
+ /**
-     QTAILQ_ENTRY(BlkActionState) entry;
+  * 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 @@ TransactionActionDrv internal_snapshot_drv = {
+@@ -XXX,XX +XXX,XX @@ const BdrvChildRole child_format = {
-     .clean = internal_snapshot_clean,
+     .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,
  };
--static int action_check_completion_mode(BlkActionState *s, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static void bdrv_backing_attach(BdrvChild *c)
--{
+                     parent->backing_blocker);
--    if (s->txn_props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
+     bdrv_op_unblock(backing_hd, BLOCK_OP_TYPE_BACKUP_TARGET,
--        error_setg(errp,
+                     parent->backing_blocker);
--                   "Action '%s' does not support Transaction property "
++
--                   "completion-mode = %s",
++    bdrv_child_cb_attach(c);
--                   TransactionActionKind_str(s->action->type),
+ }
--                   ActionCompletionMode_str(s->txn_props->completion_mode));
--        return -1;
+ static void bdrv_backing_detach(BdrvChild *c)
--    }
+@@ -XXX,XX +XXX,XX @@ static void bdrv_backing_detach(BdrvChild *c)
--    return 0;
+     bdrv_op_unblock_all(c->bs, parent->backing_blocker);
--}
+     error_free(parent->backing_blocker);
--
+     parent->backing_blocker = NULL;
- static void internal_snapshot_action(BlkActionState *common,
++
-                                      Transaction *tran, Error **errp)
++    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)
  {
-@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_action(BlkActionState *common,
+     BdrvChild *child, *next;
-     tran_add(tran, &internal_snapshot_drv, state);
+@@ -XXX,XX +XXX,XX @@ static void bdrv_do_drained_begin(BlockDriverState *bs, bool recursive,
+     bdrv_drain_recurse(bs);
--    /* 1. parse input */
-     device = internal->device;
+     if (recursive) {
-     name = internal->name;
++        bs->recursive_quiesce_counter++;
+         QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
--    /* 2. check for validation */
+             bdrv_do_drained_begin(child->bs, true, child);
--    if (action_check_completion_mode(common, errp) < 0) {
+         }
--        return;
+@@ -XXX,XX +XXX,XX @@ void bdrv_subtree_drained_begin(BlockDriverState *bs)
--    }
+     bdrv_do_drained_begin(bs, true, NULL);
--
+ }
-     bs = qmp_get_root_bs(device, errp);
-     if (!bs) {
+-static void bdrv_do_drained_end(BlockDriverState *bs, bool recursive,
-         return;
+-                                BdrvChild *parent)
-@@ -XXX,XX +XXX,XX @@ static void external_snapshot_action(BlkActionState *common, Transaction *tran,
++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,
      }
-     /* start processing */
+     if (recursive) {
--    if (action_check_completion_mode(common, errp) < 0) {
++        bs->recursive_quiesce_counter--;
--        return;
+         QLIST_FOREACH_SAFE(child, &bs->children, next, next) {
--    }
+             bdrv_do_drained_end(child->bs, true, child);
+         }
-     state->old_bs = bdrv_lookup_bs(device, node_name, errp);
+@@ -XXX,XX +XXX,XX @@ void bdrv_subtree_drained_end(BlockDriverState *bs)
-     if (!state->old_bs) {
+     bdrv_do_drained_end(bs, true, NULL);
-@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_add_action(BlkActionState *common,
+ }
-     tran_add(tran, &block_dirty_bitmap_add_drv, state);
++void bdrv_apply_subtree_drain(BdrvChild *child, BlockDriverState *new_parent)
++{
--    if (action_check_completion_mode(common, errp) < 0) {
++    int i;
--        return;
++
--    }
++    for (i = 0; i < new_parent->recursive_quiesce_counter; i++) {
--
++        bdrv_do_drained_begin(child->bs, true, child);
-     action = common->action->u.block_dirty_bitmap_add.data;
++    }
-     /* AIO context taken and released within qmp_block_dirty_bitmap_add */
++}
-     qmp_block_dirty_bitmap_add(action->node, action->name,
++
-@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_clear_action(BlkActionState *common,
++void bdrv_unapply_subtree_drain(BdrvChild *child, BlockDriverState *old_parent)
++{
-     tran_add(tran, &block_dirty_bitmap_clear_drv, state);
++    int i;
++
--    if (action_check_completion_mode(common, errp) < 0) {
++    for (i = 0; i < old_parent->recursive_quiesce_counter; i++) {
--        return;
++        bdrv_do_drained_end(child->bs, true, child);
--    }
++    }
--
++}
-     action = common->action->u.block_dirty_bitmap_clear.data;
++
      state->bitmap = block_dirty_bitmap_lookup(action->node,
                                                action->name,
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_enable_action(BlkActionState *common,
      tran_add(tran, &block_dirty_bitmap_enable_drv, state);
 -    if (action_check_completion_mode(common, errp) < 0) {
 -        return;
 -    }
 -
      action = common->action->u.block_dirty_bitmap_enable.data;
      state->bitmap = block_dirty_bitmap_lookup(action->node,
                                                action->name,
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_disable_action(BlkActionState *common,
      tran_add(tran, &block_dirty_bitmap_disable_drv, state);
 -    if (action_check_completion_mode(common, errp) < 0) {
 -        return;
 -    }
 -
      action = common->action->u.block_dirty_bitmap_disable.data;
      state->bitmap = block_dirty_bitmap_lookup(action->node,
                                                action->name,
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_merge_action(BlkActionState *common,
      tran_add(tran, &block_dirty_bitmap_merge_drv, state);
 -    if (action_check_completion_mode(common, errp) < 0) {
 -        return;
 -    }
 -
      action = common->action->u.block_dirty_bitmap_merge.data;
      state->bitmap = block_dirty_bitmap_merge(action->node, action->target,
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_remove_action(BlkActionState *common,
      tran_add(tran, &block_dirty_bitmap_remove_drv, state);
 -    if (action_check_completion_mode(common, errp) < 0) {
 -        return;
 -    }
 -
      action = common->action->u.block_dirty_bitmap_remove.data;
      state->bitmap = block_dirty_bitmap_remove(action->node, action->name,
@@ -XXX,XX +XXX,XX @@ static const BlkActionOps actions_map[] = {
       */
  };
 -/**
 - * Allocate a TransactionProperties structure if necessary, and fill
 - * that structure with desired defaults if they are unset.
 - */
 -static TransactionProperties *get_transaction_properties(
 -    TransactionProperties *props)
 -{
 -    if (!props) {
 -        props = g_new0(TransactionProperties, 1);
 -    }
 -
 -    if (!props->has_completion_mode) {
 -        props->has_completion_mode = true;
 -        props->completion_mode = ACTION_COMPLETION_MODE_INDIVIDUAL;
 -    }
 -
 -    return props;
 -}
 -
  /*
-  * 'Atomic' group operations.  The operations are performed as a set, and if
+  * Wait for pending requests to complete on a single BlockDriverState subtree,
-  * any fail then we roll back all operations in the group.
+  * and suspend block driver's internal I/O until next request arrives.
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *actions,
                       Error **errp)
  {
      TransactionActionList *act;
 -    bool has_properties = !!properties;
      JobTxn *block_job_txn = NULL;
      Error *local_err = NULL;
 -    Transaction *tran = tran_new();
 +    Transaction *tran;
 +    ActionCompletionMode comp_mode =
 +        properties ? properties->completion_mode :
 +        ACTION_COMPLETION_MODE_INDIVIDUAL;
      GLOBAL_STATE_CODE();
      /* Does this transaction get canceled as a group on failure?
       * If not, we don't really need to make a JobTxn.
       */
 -    properties = get_transaction_properties(properties);
 -    if (properties->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
 +    if (comp_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
 +        for (act = actions; act; act = act->next) {
 +            TransactionActionKind type = act->value->type;
 +
 +            if (type != TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP &&
 +                type != TRANSACTION_ACTION_KIND_DRIVE_BACKUP)
 +            {
 +                error_setg(errp,
 +                           "Action '%s' does not support transaction property "
 +                           "completion-mode = %s",
 +                           TransactionActionKind_str(type),
 +                           ActionCompletionMode_str(comp_mode));
 +                return;
 +            }
 +        }
 +
          block_job_txn = job_txn_new();
      }
      /* drain all i/o before any operations */
      bdrv_drain_all();
 +    tran = tran_new();
 +
      /* We don't do anything in this loop that commits us to the operations */
      for (act = actions; act; act = act->next) {
          TransactionAction *dev_info = act->value;
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *actions,
          state->ops = ops;
          state->action = dev_info;
          state->block_job_txn = block_job_txn;
 -        state->txn_props = properties;
          state->ops->action(state, tran, &local_err);
          if (local_err) {
@@ -XXX,XX +XXX,XX @@ delete_and_fail:
      /* failure, and it is all-or-none; roll back all operations */
      tran_abort(tran);
  exit:
 -    if (!has_properties) {
 -        qapi_free_TransactionProperties(properties);
 -    }
      job_txn_unref(block_job_txn);
  }
 --
-.40.1
+.13.6

-[PULL 06/18] blockdev: qmp_transaction: drop extra generic layer
+[Qemu-devel] [PULL v3 33/35] test-bdrv-drain: Test graph changes in drained section
-From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
-Let's simplify things:
-First, actions generally don't need access to common BlkActionState
-structure. The only exclusion are backup actions that need
-block_job_txn.
-Next, for transaction actions of Transaction API is more native to
-allocated state structure in the action itself.
-So, do the following transformation:
-. Let all actions be represented by a function with corresponding
-   structure as arguments.
-. Instead of array-map marshaller, let's make a function, that calls
-   corresponding action directly.
-. BlkActionOps and BlkActionState structures become unused
-Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
-Message-Id: <20230510150624.310640-7-vsementsov@yandex-team.ru>
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- blockdev.c | 265 +++++++++++++++++------------------------------------
+ tests/test-bdrv-drain.c | 80 +++++++++++++++++++++++++++++++++++++++++++++++++
-file changed, 85 insertions(+), 180 deletions(-)
+file changed, 80 insertions(+)
-diff --git a/blockdev.c b/blockdev.c
+diff --git a/tests/test-bdrv-drain.c b/tests/test-bdrv-drain.c
 index XXXXXXX..XXXXXXX 100644
---- a/blockdev.c
+--- a/tests/test-bdrv-drain.c
-+++ b/blockdev.c
++++ b/tests/test-bdrv-drain.c
-@@ -XXX,XX +XXX,XX @@ out_aio_context:
+@@ -XXX,XX +XXX,XX @@ static void test_multiparent(void)
-     return NULL;
+     blk_unref(blk_b);
  }
--/* New and old BlockDriverState structs for atomic group operations */
++static void test_graph_change(void)
 -
 -typedef struct BlkActionState BlkActionState;
 -
 -/**
 - * BlkActionOps:
 - * Table of operations that define an Action.
 - *
 - * @instance_size: Size of state struct, in bytes.
 - * @prepare: Prepare the work, must NOT be NULL.
 - * @commit: Commit the changes, can be NULL.
 - * @abort: Abort the changes on fail, can be NULL.
 - * @clean: Clean up resources after all transaction actions have called
 - *         commit() or abort(). Can be NULL.
 - *
 - * Only prepare() may fail. In a single transaction, only one of commit() or
 - * abort() will be called. clean() will always be called if it is present.
 - *
 - * Always run under BQL.
 - */
 -typedef struct BlkActionOps {
 -    size_t instance_size;
 -    void (*action)(BlkActionState *common, Transaction *tran, Error **errp);
 -} BlkActionOps;
 -
 -/**
 - * BlkActionState:
 - * Describes one Action's state within a Transaction.
 - *
 - * @action: QAPI-defined enum identifying which Action to perform.
 - * @ops: Table of ActionOps this Action can perform.
 - * @block_job_txn: Transaction which this action belongs to.
 - * @entry: List membership for all Actions in this Transaction.
 - *
 - * This structure must be arranged as first member in a subclassed type,
 - * assuming that the compiler will also arrange it to the same offsets as the
 - * base class.
 - */
 -struct BlkActionState {
 -    TransactionAction *action;
 -    const BlkActionOps *ops;
 -    JobTxn *block_job_txn;
 -    QTAILQ_ENTRY(BlkActionState) entry;
 -};
 -
  /* internal snapshot private data */
  typedef struct InternalSnapshotState {
 -    BlkActionState common;
      BlockDriverState *bs;
      QEMUSnapshotInfo sn;
      bool created;
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv internal_snapshot_drv = {
      .clean = internal_snapshot_clean,
  };
 -static void internal_snapshot_action(BlkActionState *common,
 +static void internal_snapshot_action(BlockdevSnapshotInternal *internal,
                                       Transaction *tran, Error **errp)
  {
      Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_action(BlkActionState *common,
      QEMUSnapshotInfo old_sn, *sn;
      bool ret;
      int64_t rt;
 -    BlockdevSnapshotInternal *internal;
 -    InternalSnapshotState *state;
 +    InternalSnapshotState *state = g_new0(InternalSnapshotState, 1);
      AioContext *aio_context;
      int ret1;
 -    g_assert(common->action->type ==
 -             TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC);
 -    internal = common->action->u.blockdev_snapshot_internal_sync.data;
 -    state = DO_UPCAST(InternalSnapshotState, common, common);
 -
      tran_add(tran, &internal_snapshot_drv, state);
      device = internal->device;
@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_clean(void *opaque)
  /* external snapshot private data */
  typedef struct ExternalSnapshotState {
 -    BlkActionState common;
      BlockDriverState *old_bs;
      BlockDriverState *new_bs;
      bool overlay_appended;
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv external_snapshot_drv = {
      .clean = external_snapshot_clean,
  };
 -static void external_snapshot_action(BlkActionState *common, Transaction *tran,
 -                                     Error **errp)
 +static void external_snapshot_action(TransactionAction *action,
 +                                     Transaction *tran, Error **errp)
  {
      int ret;
      int flags = 0;
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_action(BlkActionState *common, Transaction *tran,
      const char *snapshot_ref;
      /* File name of the new image (for 'blockdev-snapshot-sync') */
      const char *new_image_file;
 -    ExternalSnapshotState *state =
 -                             DO_UPCAST(ExternalSnapshotState, common, common);
 -    TransactionAction *action = common->action;
 +    ExternalSnapshotState *state = g_new0(ExternalSnapshotState, 1);
      AioContext *aio_context;
      uint64_t perm, shared;
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_clean(void *opaque)
  }
  typedef struct DriveBackupState {
 -    BlkActionState common;
      BlockDriverState *bs;
      BlockJob *job;
  } DriveBackupState;
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv drive_backup_drv = {
      .clean = drive_backup_clean,
  };
 -static void drive_backup_action(BlkActionState *common, Transaction *tran,
 -                                Error **errp)
 +static void drive_backup_action(DriveBackup *backup,
 +                                JobTxn *block_job_txn,
 +                                Transaction *tran, Error **errp)
  {
 -    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
 -    DriveBackup *backup;
 +    DriveBackupState *state = g_new0(DriveBackupState, 1);
      BlockDriverState *bs;
      BlockDriverState *target_bs;
      BlockDriverState *source = NULL;
@@ -XXX,XX +XXX,XX @@ static void drive_backup_action(BlkActionState *common, Transaction *tran,
      tran_add(tran, &drive_backup_drv, state);
 -    assert(common->action->type == TRANSACTION_ACTION_KIND_DRIVE_BACKUP);
 -    backup = common->action->u.drive_backup.data;
 -
      if (!backup->has_mode) {
          backup->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
      }
@@ -XXX,XX +XXX,XX @@ static void drive_backup_action(BlkActionState *common, Transaction *tran,
      state->job = do_backup_common(qapi_DriveBackup_base(backup),
                                    bs, target_bs, aio_context,
 -                                  common->block_job_txn, errp);
 +                                  block_job_txn, errp);
  unref:
      bdrv_unref(target_bs);
@@ -XXX,XX +XXX,XX @@ static void drive_backup_clean(void *opaque)
  }
  typedef struct BlockdevBackupState {
 -    BlkActionState common;
      BlockDriverState *bs;
      BlockJob *job;
  } BlockdevBackupState;
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv blockdev_backup_drv = {
      .clean = blockdev_backup_clean,
  };
 -static void blockdev_backup_action(BlkActionState *common, Transaction *tran,
 -                                   Error **errp)
 +static void blockdev_backup_action(BlockdevBackup *backup,
 +                                   JobTxn *block_job_txn,
 +                                   Transaction *tran, Error **errp)
  {
 -    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
 -    BlockdevBackup *backup;
 +    BlockdevBackupState *state = g_new0(BlockdevBackupState, 1);
      BlockDriverState *bs;
      BlockDriverState *target_bs;
      AioContext *aio_context;
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_action(BlkActionState *common, Transaction *tran,
      tran_add(tran, &blockdev_backup_drv, state);
 -    assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
 -    backup = common->action->u.blockdev_backup.data;
 -
      bs = bdrv_lookup_bs(backup->device, backup->device, errp);
      if (!bs) {
          return;
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_action(BlkActionState *common, Transaction *tran,
      state->job = do_backup_common(qapi_BlockdevBackup_base(backup),
                                    bs, target_bs, aio_context,
 -                                  common->block_job_txn, errp);
 +                                  block_job_txn, errp);
      aio_context_release(aio_context);
  }
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_clean(void *opaque)
  }
  typedef struct BlockDirtyBitmapState {
 -    BlkActionState common;
      BdrvDirtyBitmap *bitmap;
      BlockDriverState *bs;
      HBitmap *backup;
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_add_drv = {
      .clean = g_free,
  };
 -static void block_dirty_bitmap_add_action(BlkActionState *common,
 +static void block_dirty_bitmap_add_action(BlockDirtyBitmapAdd *action,
                                            Transaction *tran, Error **errp)
  {
      Error *local_err = NULL;
 -    BlockDirtyBitmapAdd *action;
 -    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
 -                                             common, common);
 +    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
      tran_add(tran, &block_dirty_bitmap_add_drv, state);
 -    action = common->action->u.block_dirty_bitmap_add.data;
      /* AIO context taken and released within qmp_block_dirty_bitmap_add */
      qmp_block_dirty_bitmap_add(action->node, action->name,
                                 action->has_granularity, action->granularity,
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_clear_drv = {
      .clean = g_free,
  };
 -static void block_dirty_bitmap_clear_action(BlkActionState *common,
 +static void block_dirty_bitmap_clear_action(BlockDirtyBitmap *action,
                                              Transaction *tran, Error **errp)
  {
 -    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
 -                                             common, common);
 -    BlockDirtyBitmap *action;
 +    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
      tran_add(tran, &block_dirty_bitmap_clear_drv, state);
 -    action = common->action->u.block_dirty_bitmap_clear.data;
      state->bitmap = block_dirty_bitmap_lookup(action->node,
                                                action->name,
                                                &state->bs,
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_enable_drv = {
      .clean = g_free,
  };
 -static void block_dirty_bitmap_enable_action(BlkActionState *common,
 +static void block_dirty_bitmap_enable_action(BlockDirtyBitmap *action,
                                               Transaction *tran, Error **errp)
  {
 -    BlockDirtyBitmap *action;
 -    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
 -                                             common, common);
 +    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
      tran_add(tran, &block_dirty_bitmap_enable_drv, state);
 -    action = common->action->u.block_dirty_bitmap_enable.data;
      state->bitmap = block_dirty_bitmap_lookup(action->node,
                                                action->name,
                                                NULL,
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_disable_drv = {
      .clean = g_free,
  };
 -static void block_dirty_bitmap_disable_action(BlkActionState *common,
 +static void block_dirty_bitmap_disable_action(BlockDirtyBitmap *action,
                                                Transaction *tran, Error **errp)
  {
 -    BlockDirtyBitmap *action;
 -    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
 -                                             common, common);
 +    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
      tran_add(tran, &block_dirty_bitmap_disable_drv, state);
 -    action = common->action->u.block_dirty_bitmap_disable.data;
      state->bitmap = block_dirty_bitmap_lookup(action->node,
                                                action->name,
                                                NULL,
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_merge_drv = {
      .clean = g_free,
  };
 -static void block_dirty_bitmap_merge_action(BlkActionState *common,
 +static void block_dirty_bitmap_merge_action(BlockDirtyBitmapMerge *action,
                                              Transaction *tran, Error **errp)
  {
 -    BlockDirtyBitmapMerge *action;
 -    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
 -                                             common, common);
 +    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
      tran_add(tran, &block_dirty_bitmap_merge_drv, state);
 -    action = common->action->u.block_dirty_bitmap_merge.data;
 -
      state->bitmap = block_dirty_bitmap_merge(action->node, action->target,
                                               action->bitmaps, &state->backup,
                                               errp);
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_remove_drv = {
      .clean = g_free,
  };
 -static void block_dirty_bitmap_remove_action(BlkActionState *common,
 +static void block_dirty_bitmap_remove_action(BlockDirtyBitmap *action,
                                               Transaction *tran, Error **errp)
  {
 -    BlockDirtyBitmap *action;
 -    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
 -                                             common, common);
 +    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
      tran_add(tran, &block_dirty_bitmap_remove_drv, state);
 -    action = common->action->u.block_dirty_bitmap_remove.data;
      state->bitmap = block_dirty_bitmap_remove(action->node, action->name,
                                                false, &state->bs, errp);
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_remove_commit(void *opaque)
  static void abort_commit(void *opaque);
  TransactionActionDrv abort_drv = {
      .commit = abort_commit,
 -    .clean = g_free,
  };
 -static void abort_action(BlkActionState *common, Transaction *tran,
 -                         Error **errp)
 +static void abort_action(Transaction *tran, Error **errp)
  {
 -    tran_add(tran, &abort_drv, common);
 +    tran_add(tran, &abort_drv, NULL);
      error_setg(errp, "Transaction aborted using Abort action");
  }
@@ -XXX,XX +XXX,XX @@ static void abort_commit(void *opaque)
      g_assert_not_reached(); /* this action never succeeds */
  }
 -static const BlkActionOps actions_map[] = {
 -    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {
 -        .instance_size = sizeof(ExternalSnapshotState),
 -        .action  = external_snapshot_action,
 -    },
 -    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC] = {
 -        .instance_size = sizeof(ExternalSnapshotState),
 -        .action  = external_snapshot_action,
 -    },
 -    [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] = {
 -        .instance_size = sizeof(DriveBackupState),
 -        .action = drive_backup_action,
 -    },
 -    [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] = {
 -        .instance_size = sizeof(BlockdevBackupState),
 -        .action = blockdev_backup_action,
 -    },
 -    [TRANSACTION_ACTION_KIND_ABORT] = {
 -        .instance_size = sizeof(BlkActionState),
 -        .action = abort_action,
 -    },
 -    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC] = {
 -        .instance_size = sizeof(InternalSnapshotState),
 -        .action  = internal_snapshot_action,
 -    },
 -    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD] = {
 -        .instance_size = sizeof(BlockDirtyBitmapState),
 -        .action = block_dirty_bitmap_add_action,
 -    },
 -    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR] = {
 -        .instance_size = sizeof(BlockDirtyBitmapState),
 -        .action = block_dirty_bitmap_clear_action,
 -    },
 -    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE] = {
 -        .instance_size = sizeof(BlockDirtyBitmapState),
 -        .action = block_dirty_bitmap_enable_action,
 -    },
 -    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE] = {
 -        .instance_size = sizeof(BlockDirtyBitmapState),
 -        .action = block_dirty_bitmap_disable_action,
 -    },
 -    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE] = {
 -        .instance_size = sizeof(BlockDirtyBitmapState),
 -        .action = block_dirty_bitmap_merge_action,
 -    },
 -    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE] = {
 -        .instance_size = sizeof(BlockDirtyBitmapState),
 -        .action = block_dirty_bitmap_remove_action,
 -    },
 -    /* Where are transactions for MIRROR, COMMIT and STREAM?
 +static void transaction_action(TransactionAction *act, JobTxn *block_job_txn,
 +                               Transaction *tran, Error **errp)
 +{
-+    switch (act->type) {
++    BlockBackend *blk_a, *blk_b;
-+    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT:
++    BlockDriverState *bs_a, *bs_b, *backing;
-+    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC:
++    BDRVTestState *a_s, *b_s, *backing_s;
-+        external_snapshot_action(act, tran, errp);
++
-+        return;
++    blk_a = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
-+    case TRANSACTION_ACTION_KIND_DRIVE_BACKUP:
++    bs_a = bdrv_new_open_driver(&bdrv_test, "test-node-a", BDRV_O_RDWR,
-+        drive_backup_action(act->u.drive_backup.data,
++                                &error_abort);
-+                            block_job_txn, tran, errp);
++    a_s = bs_a->opaque;
-+        return;
++    blk_insert_bs(blk_a, bs_a, &error_abort);
-+    case TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP:
++
-+        blockdev_backup_action(act->u.blockdev_backup.data,
++    blk_b = blk_new(BLK_PERM_ALL, BLK_PERM_ALL);
-+                               block_job_txn, tran, errp);
++    bs_b = bdrv_new_open_driver(&bdrv_test, "test-node-b", BDRV_O_RDWR,
-+        return;
++                                &error_abort);
-+    case TRANSACTION_ACTION_KIND_ABORT:
++    b_s = bs_b->opaque;
-+        abort_action(tran, errp);
++    blk_insert_bs(blk_b, bs_b, &error_abort);
-+        return;
++
-+    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC:
++    backing = bdrv_new_open_driver(&bdrv_test, "backing", 0, &error_abort);
-+        internal_snapshot_action(act->u.blockdev_snapshot_internal_sync.data,
++    backing_s = backing->opaque;
-+                                 tran, errp);
++    bdrv_set_backing_hd(bs_a, backing, &error_abort);
-+        return;
++
-+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD:
++    g_assert_cmpint(bs_a->quiesce_counter, ==, 0);
-+        block_dirty_bitmap_add_action(act->u.block_dirty_bitmap_add.data,
++    g_assert_cmpint(bs_b->quiesce_counter, ==, 0);
-+                                      tran, errp);
++    g_assert_cmpint(backing->quiesce_counter, ==, 0);
-+        return;
++    g_assert_cmpint(a_s->drain_count, ==, 0);
-+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR:
++    g_assert_cmpint(b_s->drain_count, ==, 0);
-+        block_dirty_bitmap_clear_action(act->u.block_dirty_bitmap_clear.data,
++    g_assert_cmpint(backing_s->drain_count, ==, 0);
-+                                        tran, errp);
++
-+        return;
++    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
-+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE:
++    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
-+        block_dirty_bitmap_enable_action(act->u.block_dirty_bitmap_enable.data,
++    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_a);
-+                                         tran, errp);
++    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
-+        return;
++    do_drain_begin(BDRV_SUBTREE_DRAIN, bs_b);
-+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE:
++
-+        block_dirty_bitmap_disable_action(
++    bdrv_set_backing_hd(bs_b, backing, &error_abort);
-+                act->u.block_dirty_bitmap_disable.data, tran, errp);
++    g_assert_cmpint(bs_a->quiesce_counter, ==, 5);
-+        return;
++    g_assert_cmpint(bs_b->quiesce_counter, ==, 5);
-+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE:
++    g_assert_cmpint(backing->quiesce_counter, ==, 5);
-+        block_dirty_bitmap_merge_action(act->u.block_dirty_bitmap_merge.data,
++    g_assert_cmpint(a_s->drain_count, ==, 5);
-+                                        tran, errp);
++    g_assert_cmpint(b_s->drain_count, ==, 5);
-+        return;
++    g_assert_cmpint(backing_s->drain_count, ==, 5);
-+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE:
++
-+        block_dirty_bitmap_remove_action(act->u.block_dirty_bitmap_remove.data,
++    bdrv_set_backing_hd(bs_b, NULL, &error_abort);
-+                                         tran, errp);
++    g_assert_cmpint(bs_a->quiesce_counter, ==, 3);
-+        return;
++    g_assert_cmpint(bs_b->quiesce_counter, ==, 2);
-+    /*
++    g_assert_cmpint(backing->quiesce_counter, ==, 3);
-+     * Where are transactions for MIRROR, COMMIT and STREAM?
++    g_assert_cmpint(a_s->drain_count, ==, 3);
-      * Although these blockjobs use transaction callbacks like the backup job,
++    g_assert_cmpint(b_s->drain_count, ==, 2);
-      * these jobs do not necessarily adhere to transaction semantics.
++    g_assert_cmpint(backing_s->drain_count, ==, 3);
-      * These jobs may not fully undo all of their actions on abort, nor do they
++
-      * necessarily work in transactions with more than one job in them.
++    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);
-+    case TRANSACTION_ACTION_KIND__MAX:
++    g_assert_cmpint(backing->quiesce_counter, ==, 5);
-+    default:
++    g_assert_cmpint(a_s->drain_count, ==, 5);
-+        g_assert_not_reached();
++    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 {
-  * 'Atomic' group operations.  The operations are performed as a set, and if
+     BlockJob common;
-@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *actions,
+@@ -XXX,XX +XXX,XX @@ int main(int argc, char **argv)
-     /* We don't do anything in this loop that commits us to the operations */
+     g_test_add_func("/bdrv-drain/nested", test_nested);
-     for (act = actions; act; act = act->next) {
+     g_test_add_func("/bdrv-drain/multiparent", test_multiparent);
--        TransactionAction *dev_info = act->value;
++    g_test_add_func("/bdrv-drain/graph-change", test_graph_change);
--        const BlkActionOps *ops;
--        BlkActionState *state;
+     g_test_add_func("/bdrv-drain/blockjob/drain_all", test_blockjob_drain_all);
--
+     g_test_add_func("/bdrv-drain/blockjob/drain", test_blockjob_drain);
 -        assert(dev_info->type < ARRAY_SIZE(actions_map));
 -
 -        ops = &actions_map[dev_info->type];
 -        assert(ops->instance_size > 0);
 -
 -        state = g_malloc0(ops->instance_size);
 -        state->ops = ops;
 -        state->action = dev_info;
 -        state->block_job_txn = block_job_txn;
 -
 -        state->ops->action(state, tran, &local_err);
 +        transaction_action(act->value, block_job_txn, tran, &local_err);
          if (local_err) {
              error_propagate(errp, local_err);
              goto delete_and_fail;
 --
-.40.1
+.13.6

-[PULL 11/18] qemu-img: Take graph lock more selectively
+[Qemu-devel] [PULL v3 34/35] commit: Simplify reopen of base
-If we take a reader lock, we can't call any functions that take a writer
+Since commit bde70715, base is the only node that is reopened in
-lock internally without causing deadlocks once the reader lock is
+commit_start(). This means that the code, which still involves an
-actually enforced in the main thread, too. Take the reader lock only
+explicit BlockReopenQueue, can now be simplified by using bdrv_reopen().
 where it is actually needed.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20230510203601.418015-5-kwolf@redhat.com>
+Reviewed-by: Fam Zheng <famz@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qemu-img.c | 5 +++--
+ block/commit.c | 8 +-------
-file changed, 3 insertions(+), 2 deletions(-)
+file changed, 1 insertion(+), 7 deletions(-)
-diff --git a/qemu-img.c b/qemu-img.c
+diff --git a/block/commit.c b/block/commit.c
 index XXXXXXX..XXXXXXX 100644
---- a/qemu-img.c
+--- a/block/commit.c
-+++ b/qemu-img.c
++++ b/block/commit.c
-@@ -XXX,XX +XXX,XX @@ static BlockGraphInfoList *collect_image_info_list(bool image_opts,
+@@ -XXX,XX +XXX,XX @@ void commit_start(const char *job_id, BlockDriverState *bs,
-         }
+                   const char *filter_node_name, Error **errp)
-         bs = blk_bs(blk);
+ {
+     CommitBlockJob *s;
--        GRAPH_RDLOCK_GUARD_MAINLOOP();
+-    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) {
-          * Note that the returned BlockGraphInfo object will not have
+-        bdrv_reopen_multiple(bdrv_get_aio_context(bs), reopen_queue, &local_err);
-          * information about this image's backing node, because we have opened
++        bdrv_reopen(base, orig_base_flags | BDRV_O_RDWR, &local_err);
-@@ -XXX,XX +XXX,XX @@ static BlockGraphInfoList *collect_image_info_list(bool image_opts,
+         if (local_err != NULL) {
-          * duplicate the backing chain information that we obtain by walking
+             error_propagate(errp, local_err);
-          * the chain manually here.
+             goto fail;
           */
 +        bdrv_graph_rdlock_main_loop();
          bdrv_query_block_graph_info(bs, &info, &err);
 +        bdrv_graph_rdunlock_main_loop();
 +
          if (err) {
              error_report_err(err);
              blk_unref(blk);
 --
-.40.1
+.13.6

-[PULL 08/18] block: Call .bdrv_co_create(_opts) unlocked
+[Qemu-devel] [PULL v3 35/35] block: Keep nodes drained between reopen_queue/multiple
-These are functions that modify the graph, so they must be able to take
+The bdrv_reopen*() implementation doesn't like it if the graph is
-a writer lock. This is impossible if they already hold the reader lock.
+changed between queuing nodes for reopen and actually reopening them
-If they need a reader lock for some of their operations, they should
+(one of the reasons is that queuing can be recursive).
 take it internally.
-Many of them go through blk_*(), which will always take the lock itself.
+So instead of draining the device only in bdrv_reopen_multiple(),
-Direct calls of bdrv_*() need to take the reader lock. Note that while
+require that callers already drained all affected nodes, and assert this
-locking for bdrv_co_*() calls is checked by TSA, this is not the case
+in bdrv_reopen_queue().
 for the mixed_coroutine_fns bdrv_*(). Holding the lock is still required
 when they are called from coroutine context like here!
 This effectively reverts 4ec8df0183, but adds some internal locking
 instead.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20230510203601.418015-2-kwolf@redhat.com>
+Reviewed-by: Fam Zheng <famz@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/block/block-global-state.h |  8 +++----
+ block.c             | 23 ++++++++++++++++-------
- include/block/block_int-common.h   |  4 ++--
+ block/replication.c |  6 ++++++
- block.c                            |  1 -
+ qemu-io-cmds.c      |  3 +++
- block/create.c                     |  1 -
+files changed, 25 insertions(+), 7 deletions(-)
  block/crypto.c                     | 25 ++++++++++----------
  block/parallels.c                  |  6 ++---
  block/qcow.c                       |  6 ++---
  block/qcow2.c                      | 37 +++++++++++++++++++-----------
  block/qed.c                        |  6 ++---
  block/raw-format.c                 |  2 +-
  block/vdi.c                        | 11 +++++----
  block/vhdx.c                       |  8 ++++---
  block/vmdk.c                       | 27 ++++++++++------------
  block/vpc.c                        |  6 ++---
 files changed, 78 insertions(+), 70 deletions(-)
-diff --git a/include/block/block-global-state.h b/include/block/block-global-state.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/block-global-state.h
-+++ b/include/block/block-global-state.h
-@@ -XXX,XX +XXX,XX @@ BlockDriver *bdrv_find_protocol(const char *filename,
-                                 Error **errp);
- BlockDriver *bdrv_find_format(const char *format_name);
--int coroutine_fn GRAPH_RDLOCK
-+int coroutine_fn GRAPH_UNLOCKED
- bdrv_co_create(BlockDriver *drv, const char *filename, QemuOpts *opts,
-                Error **errp);
--int co_wrapper_bdrv_rdlock bdrv_create(BlockDriver *drv, const char *filename,
--                                       QemuOpts *opts, Error **errp);
-+int co_wrapper bdrv_create(BlockDriver *drv, const char *filename,
-+                           QemuOpts *opts, Error **errp);
--int coroutine_fn GRAPH_RDLOCK
-+int coroutine_fn GRAPH_UNLOCKED
- bdrv_co_create_file(const char *filename, QemuOpts *opts, Error **errp);
- BlockDriverState *bdrv_new(void);
-diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/block_int-common.h
-+++ b/include/block/block_int-common.h
-@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
-         BlockDriverState *bs, QDict *options, int flags, Error **errp);
-     void (*bdrv_close)(BlockDriverState *bs);
--    int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_create)(
-+    int coroutine_fn GRAPH_UNLOCKED_PTR (*bdrv_co_create)(
-         BlockdevCreateOptions *opts, Error **errp);
--    int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_create_opts)(
-+    int coroutine_fn GRAPH_UNLOCKED_PTR (*bdrv_co_create_opts)(
-         BlockDriver *drv, const char *filename, QemuOpts *opts, Error **errp);
-     int (*bdrv_amend_options)(BlockDriverState *bs,
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
-@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_create(BlockDriver *drv, const char *filename,
+@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_open(const char *filename, const char *reference,
-     int ret;
+  * returns a pointer to bs_queue, which is either the newly allocated
-     GLOBAL_STATE_CODE();
+  * bs_queue, or the existing bs_queue being used.
-     ERRP_GUARD();
+  *
--    assert_bdrv_graph_readable();
++ * bs must be drained between bdrv_reopen_queue() and bdrv_reopen_multiple().
+  */
-     if (!drv->bdrv_co_create_opts) {
+ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
-         error_setg(errp, "Driver '%s' does not support image creation",
+                                                  BlockDriverState *bs,
-diff --git a/block/create.c b/block/create.c
+@@ -XXX,XX +XXX,XX @@ static BlockReopenQueue *bdrv_reopen_queue_child(BlockReopenQueue *bs_queue,
-index XXXXXXX..XXXXXXX 100644
+     BdrvChild *child;
---- a/block/create.c
+     QDict *old_options, *explicit_options;
-+++ b/block/create.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn blockdev_create_run(Job *job, Error **errp)
++    /* Make sure that the caller remembered to use a drained section. This is
-     int ret;
++     * important to avoid graph changes between the recursive queuing here and
++     * bdrv_reopen_multiple(). */
-     GLOBAL_STATE_CODE();
++    assert(bs->quiesce_counter > 0);
--    GRAPH_RDLOCK_GUARD();
++
+     if (bs_queue == NULL) {
-     job_progress_set_remaining(&s->common, 1);
+         bs_queue = g_new0(BlockReopenQueue, 1);
-     ret = s->drv->bdrv_co_create(s->opts, errp);
+         QSIMPLEQ_INIT(bs_queue);
-diff --git a/block/crypto.c b/block/crypto.c
+@@ -XXX,XX +XXX,XX @@ BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
-index XXXXXXX..XXXXXXX 100644
+  * If all devices prepare successfully, then the changes are committed
---- a/block/crypto.c
+  * to all devices.
-+++ b/block/crypto.c
+  *
-@@ -XXX,XX +XXX,XX @@ struct BlockCryptoCreateData {
++ * 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)
 -static int block_crypto_create_write_func(QCryptoBlock *block,
 -                                          size_t offset,
 -                                          const uint8_t *buf,
 -                                          size_t buflen,
 -                                          void *opaque,
 -                                          Error **errp)
 +static int coroutine_fn GRAPH_UNLOCKED
 +block_crypto_create_write_func(QCryptoBlock *block, size_t offset,
 +                               const uint8_t *buf, size_t buflen, void *opaque,
 +                               Error **errp)
  {
-     struct BlockCryptoCreateData *data = opaque;
+@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_multiple(AioContext *ctx, BlockReopenQueue *bs_queue, Error **er
-     ssize_t ret;
-@@ -XXX,XX +XXX,XX @@ static int block_crypto_create_write_func(QCryptoBlock *block,
+     assert(bs_queue != NULL);
-     return 0;
- }
+-    aio_context_release(ctx);
+-    bdrv_drain_all_begin();
--static int block_crypto_create_init_func(QCryptoBlock *block,
+-    aio_context_acquire(ctx);
--                                         size_t headerlen,
+-
--                                         void *opaque,
+     QSIMPLEQ_FOREACH(bs_entry, bs_queue, entry) {
--                                         Error **errp)
++        assert(bs_entry->state.bs->quiesce_counter > 0);
-+static int coroutine_fn GRAPH_UNLOCKED
+         if (bdrv_reopen_prepare(&bs_entry->state, bs_queue, &local_err)) {
-+block_crypto_create_init_func(QCryptoBlock *block, size_t headerlen,
+             error_propagate(errp, local_err);
-+                              void *opaque, Error **errp)
+             goto cleanup;
- {
+@@ -XXX,XX +XXX,XX @@ cleanup:
-     struct BlockCryptoCreateData *data = opaque;
+     }
-     Error *local_error = NULL;
+     g_free(bs_queue);
-@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
- }
+-    bdrv_drain_all_end();
+-
 -static int coroutine_fn
 +static int coroutine_fn GRAPH_UNLOCKED
  block_crypto_co_create_generic(BlockDriverState *bs, int64_t size,
                                 QCryptoBlockCreateOptions *opts,
                                 PreallocMode prealloc, Error **errp)
@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_luks(BlockDriverState *bs,
                                       bs, options, flags, errp);
  }
 -static int coroutine_fn
 +static int coroutine_fn GRAPH_UNLOCKED
  block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)
  {
      BlockdevCreateOptionsLUKS *luks_opts;
@@ -XXX,XX +XXX,XX @@ fail:
      return ret;
  }
--static int coroutine_fn GRAPH_RDLOCK
+@@ -XXX,XX +XXX,XX @@ int bdrv_reopen(BlockDriverState *bs, int bdrv_flags, Error **errp)
 +static int coroutine_fn GRAPH_UNLOCKED
  block_crypto_co_create_opts_luks(BlockDriver *drv, const char *filename,
                                   QemuOpts *opts, Error **errp)
  {
-@@ -XXX,XX +XXX,XX @@ fail:
+     int ret = -1;
-      * beforehand, it has been truncated and corrupted in the process.
+     Error *local_err = NULL;
-      */
+-    BlockReopenQueue *queue = bdrv_reopen_queue(NULL, bs, NULL, bdrv_flags);
-     if (ret) {
++    BlockReopenQueue *queue;
-+        bdrv_graph_co_rdlock();
-         bdrv_co_delete_file_noerr(bs);
++    bdrv_subtree_drained_begin(bs);
-+        bdrv_graph_co_rdunlock();
++
 +    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_co_unref(bs);
++    bdrv_subtree_drained_end(bs);
-diff --git a/block/parallels.c b/block/parallels.c
++
 index XXXXXXX..XXXXXXX 100644
 --- a/block/parallels.c
 +++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ out:
  }
 -static int coroutine_fn parallels_co_create(BlockdevCreateOptions* opts,
 -                                            Error **errp)
 +static int coroutine_fn GRAPH_UNLOCKED
 +parallels_co_create(BlockdevCreateOptions* opts, Error **errp)
  {
      BlockdevCreateOptionsParallels *parallels_opts;
      BlockDriverState *bs;
@@ -XXX,XX +XXX,XX @@ exit:
      goto out;
  }
 -static int coroutine_fn GRAPH_RDLOCK
 +static int coroutine_fn GRAPH_UNLOCKED
  parallels_co_create_opts(BlockDriver *drv, const char *filename,
                           QemuOpts *opts, Error **errp)
  {
 diff --git a/block/qcow.c b/block/qcow.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow.c
 +++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static void qcow_close(BlockDriverState *bs)
      error_free(s->migration_blocker);
  }
 -static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
 -                                       Error **errp)
 +static int coroutine_fn GRAPH_UNLOCKED
 +qcow_co_create(BlockdevCreateOptions *opts, Error **errp)
  {
      BlockdevCreateOptionsQcow *qcow_opts;
      int header_size, backing_filename_len, l1_size, shift, i;
@@ -XXX,XX +XXX,XX @@ exit:
      return ret;
  }
--static int coroutine_fn GRAPH_RDLOCK
+diff --git a/block/replication.c b/block/replication.c
 +static int coroutine_fn GRAPH_UNLOCKED
  qcow_co_create_opts(BlockDriver *drv, const char *filename,
                      QemuOpts *opts, Error **errp)
  {
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2.c
+--- a/block/replication.c
-+++ b/block/qcow2.c
++++ b/block/replication.c
-@@ -XXX,XX +XXX,XX @@ static int qcow2_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
+@@ -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)
--static int qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
+diff --git a/qemu-io-cmds.c b/qemu-io-cmds.c
--                                      void *opaque, Error **errp)
+index XXXXXXX..XXXXXXX 100644
-+static int coroutine_fn GRAPH_RDLOCK
+--- a/qemu-io-cmds.c
-+qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen, void *opaque,
++++ b/qemu-io-cmds.c
-+                           Error **errp)
+@@ -XXX,XX +XXX,XX @@ static int reopen_f(BlockBackend *blk, int argc, char **argv)
- {
+     opts = qopts ? qemu_opts_to_qdict(qopts, NULL) : NULL;
-     BlockDriverState *bs = opaque;
+     qemu_opts_reset(&reopen_opts);
-     BDRVQcow2State *s = bs->opaque;
-@@ -XXX,XX +XXX,XX @@ static int qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
++    bdrv_subtree_drained_begin(bs);
-      */
+     brq = bdrv_reopen_queue(NULL, bs, opts, flags);
-     clusterlen = size_to_clusters(s, headerlen) * s->cluster_size;
+     bdrv_reopen_multiple(bdrv_get_aio_context(bs), brq, &local_err);
-     assert(qcow2_pre_write_overlap_check(bs, 0, ret, clusterlen, false) == 0);
++    bdrv_subtree_drained_end(bs);
 -    ret = bdrv_pwrite_zeroes(bs->file,
 -                             ret,
 -                             clusterlen, 0);
 +    ret = bdrv_co_pwrite_zeroes(bs->file, ret, clusterlen, 0);
      if (ret < 0) {
          error_setg_errno(errp, -ret, "Could not zero fill encryption header");
          return -1;
@@ -XXX,XX +XXX,XX @@ static int qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
  }
 -static int qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
 -                                       const uint8_t *buf, size_t buflen,
 -                                       void *opaque, Error **errp)
 +/* The graph lock must be held when called in coroutine context */
 +static int coroutine_mixed_fn
 +qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
 +                            const uint8_t *buf, size_t buflen,
 +                            void *opaque, Error **errp)
  {
      BlockDriverState *bs = opaque;
      BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static int qcow2_change_backing_file(BlockDriverState *bs,
      return qcow2_update_header(bs);
  }
 -static int qcow2_set_up_encryption(BlockDriverState *bs,
 -                                   QCryptoBlockCreateOptions *cryptoopts,
 -                                   Error **errp)
 +static int coroutine_fn GRAPH_RDLOCK
 +qcow2_set_up_encryption(BlockDriverState *bs,
 +                        QCryptoBlockCreateOptions *cryptoopts,
 +                        Error **errp)
  {
      BDRVQcow2State *s = bs->opaque;
      QCryptoBlock *crypto = NULL;
@@ -XXX,XX +XXX,XX @@ static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts *opts, int version,
      return refcount_bits;
  }
 -static int coroutine_fn
 +static int coroutine_fn GRAPH_UNLOCKED
  qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
  {
      BlockdevCreateOptionsQcow2 *qcow2_opts;
@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
          goto out;
      }
 +    bdrv_graph_co_rdlock();
      ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size);
      if (ret < 0) {
 +        bdrv_graph_co_rdunlock();
          error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 "
                           "header and refcount table");
          goto out;
@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
      /* Create a full header (including things like feature table) */
      ret = qcow2_update_header(blk_bs(blk));
 +    bdrv_graph_co_rdunlock();
 +
-     if (ret < 0) {
+     if (local_err) {
-         error_setg_errno(errp, -ret, "Could not update qcow2 header");
+         error_report_err(local_err);
          goto out;
@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
      /* Want encryption? There you go. */
      if (qcow2_opts->encrypt) {
 +        bdrv_graph_co_rdlock();
          ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp);
 +        bdrv_graph_co_rdunlock();
 +
          if (ret < 0) {
              goto out;
          }
@@ -XXX,XX +XXX,XX @@ out:
      return ret;
  }
 -static int coroutine_fn GRAPH_RDLOCK
 +static int coroutine_fn GRAPH_UNLOCKED
  qcow2_co_create_opts(BlockDriver *drv, const char *filename, QemuOpts *opts,
                       Error **errp)
  {
@@ -XXX,XX +XXX,XX @@ qcow2_co_create_opts(BlockDriver *drv, const char *filename, QemuOpts *opts,
      ret = qcow2_co_create(create_options, errp);
  finish:
      if (ret < 0) {
 +        bdrv_graph_co_rdlock();
          bdrv_co_delete_file_noerr(bs);
          bdrv_co_delete_file_noerr(data_bs);
 +        bdrv_graph_co_rdunlock();
      } else {
-         ret = 0;
-     }
-diff --git a/block/qed.c b/block/qed.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/qed.c
-+++ b/block/qed.c
-@@ -XXX,XX +XXX,XX @@ static void bdrv_qed_close(BlockDriverState *bs)
-     qemu_vfree(s->l1_table);
- }
--static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
--                                           Error **errp)
-+static int coroutine_fn GRAPH_UNLOCKED
-+bdrv_qed_co_create(BlockdevCreateOptions *opts, Error **errp)
- {
-     BlockdevCreateOptionsQed *qed_opts;
-     BlockBackend *blk = NULL;
-@@ -XXX,XX +XXX,XX @@ out:
-     return ret;
- }
--static int coroutine_fn GRAPH_RDLOCK
-+static int coroutine_fn GRAPH_UNLOCKED
- bdrv_qed_co_create_opts(BlockDriver *drv, const char *filename,
-                         QemuOpts *opts, Error **errp)
- {
-diff --git a/block/raw-format.c b/block/raw-format.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/raw-format.c
-+++ b/block/raw-format.c
-@@ -XXX,XX +XXX,XX @@ static int raw_has_zero_init(BlockDriverState *bs)
-     return bdrv_has_zero_init(bs->file->bs);
- }
--static int coroutine_fn GRAPH_RDLOCK
-+static int coroutine_fn GRAPH_UNLOCKED
- raw_co_create_opts(BlockDriver *drv, const char *filename,
-                    QemuOpts *opts, Error **errp)
- {
-diff --git a/block/vdi.c b/block/vdi.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/vdi.c
-+++ b/block/vdi.c
-@@ -XXX,XX +XXX,XX @@ nonallocating_write:
-     return ret;
- }
--static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
--                                         size_t block_size, Error **errp)
-+static int coroutine_fn GRAPH_UNLOCKED
-+vdi_co_do_create(BlockdevCreateOptions *create_options, size_t block_size,
-+                 Error **errp)
- {
-     BlockdevCreateOptionsVdi *vdi_opts;
-     int ret = 0;
-@@ -XXX,XX +XXX,XX @@ exit:
-     return ret;
- }
--static int coroutine_fn vdi_co_create(BlockdevCreateOptions *create_options,
--                                      Error **errp)
-+static int coroutine_fn GRAPH_UNLOCKED
-+vdi_co_create(BlockdevCreateOptions *create_options, Error **errp)
- {
-     return vdi_co_do_create(create_options, DEFAULT_CLUSTER_SIZE, errp);
- }
--static int coroutine_fn GRAPH_RDLOCK
-+static int coroutine_fn GRAPH_UNLOCKED
- vdi_co_create_opts(BlockDriver *drv, const char *filename,
-                    QemuOpts *opts, Error **errp)
- {
-diff --git a/block/vhdx.c b/block/vhdx.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/vhdx.c
-+++ b/block/vhdx.c
-@@ -XXX,XX +XXX,XX @@ exit:
-  * There are 2 headers, and the highest sequence number will represent
-  * the active header
-  */
--static int coroutine_fn GRAPH_RDLOCK
-+static int coroutine_fn GRAPH_UNLOCKED
- vhdx_create_new_headers(BlockBackend *blk, uint64_t image_size,
-                         uint32_t log_size)
- {
-@@ -XXX,XX +XXX,XX @@ vhdx_create_new_headers(BlockBackend *blk, uint64_t image_size,
-     int ret = 0;
-     VHDXHeader *hdr = NULL;
-+    GRAPH_RDLOCK_GUARD();
-+
-     hdr = g_new0(VHDXHeader, 1);
-     hdr->signature       = VHDX_HEADER_SIGNATURE;
-@@ -XXX,XX +XXX,XX @@ exit:
-  *    .---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------.
-  *   1MB
-  */
--static int coroutine_fn GRAPH_RDLOCK
-+static int coroutine_fn GRAPH_UNLOCKED
- vhdx_co_create(BlockdevCreateOptions *opts, Error **errp)
- {
-     BlockdevCreateOptionsVhdx *vhdx_opts;
-@@ -XXX,XX +XXX,XX @@ delete_and_exit:
-     return ret;
- }
--static int coroutine_fn GRAPH_RDLOCK
-+static int coroutine_fn GRAPH_UNLOCKED
- vhdx_co_create_opts(BlockDriver *drv, const char *filename,
-                     QemuOpts *opts, Error **errp)
- {
-diff --git a/block/vmdk.c b/block/vmdk.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/vmdk.c
-+++ b/block/vmdk.c
-@@ -XXX,XX +XXX,XX @@ vmdk_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-     return ret;
- }
--static int vmdk_init_extent(BlockBackend *blk,
--                            int64_t filesize, bool flat,
--                            bool compress, bool zeroed_grain,
--                            Error **errp)
-+static int GRAPH_UNLOCKED
-+vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
-+                 bool zeroed_grain, Error **errp)
- {
-     int ret, i;
-     VMDK4Header header;
-@@ -XXX,XX +XXX,XX @@ exit:
-     return ret;
- }
--static int coroutine_fn GRAPH_RDLOCK
-+static int coroutine_fn GRAPH_UNLOCKED
- vmdk_create_extent(const char *filename, int64_t filesize, bool flat,
-                    bool compress, bool zeroed_grain, BlockBackend **pbb,
-                    QemuOpts *opts, Error **errp)
-@@ -XXX,XX +XXX,XX @@ static int filename_decompose(const char *filename, char *path, char *prefix,
-  *           non-split format.
-  * idx >= 1: get the n-th extent if in a split subformat
-  */
--typedef BlockBackend * coroutine_fn /* GRAPH_RDLOCK */
-+typedef BlockBackend * coroutine_fn GRAPH_UNLOCKED_PTR
-     (*vmdk_create_extent_fn)(int64_t size, int idx, bool flat, bool split,
-                              bool compress, bool zeroed_grain, void *opaque,
-                              Error **errp);
-@@ -XXX,XX +XXX,XX @@ static void vmdk_desc_add_extent(GString *desc,
-     g_free(basename);
- }
--static int coroutine_fn GRAPH_RDLOCK
-+static int coroutine_fn GRAPH_UNLOCKED
- vmdk_co_do_create(int64_t size,
-                   BlockdevVmdkSubformat subformat,
-                   BlockdevVmdkAdapterType adapter_type,
-@@ -XXX,XX +XXX,XX @@ typedef struct {
-     QemuOpts *opts;
- } VMDKCreateOptsData;
--static BlockBackend * coroutine_fn GRAPH_RDLOCK
-+static BlockBackend * coroutine_fn GRAPH_UNLOCKED
- vmdk_co_create_opts_cb(int64_t size, int idx, bool flat, bool split,
-                        bool compress, bool zeroed_grain, void *opaque,
-                        Error **errp)
-@@ -XXX,XX +XXX,XX @@ exit:
-     return blk;
- }
--static int coroutine_fn GRAPH_RDLOCK
-+static int coroutine_fn GRAPH_UNLOCKED
- vmdk_co_create_opts(BlockDriver *drv, const char *filename,
-                     QemuOpts *opts, Error **errp)
- {
-@@ -XXX,XX +XXX,XX @@ exit:
-     return ret;
- }
--static BlockBackend * coroutine_fn vmdk_co_create_cb(int64_t size, int idx,
--                                                     bool flat, bool split,
--                                                     bool compress,
--                                                     bool zeroed_grain,
--                                                     void *opaque, Error **errp)
-+static BlockBackend * coroutine_fn GRAPH_UNLOCKED
-+vmdk_co_create_cb(int64_t size, int idx, bool flat, bool split, bool compress,
-+                  bool zeroed_grain, void *opaque, Error **errp)
- {
-     int ret;
-     BlockDriverState *bs;
-@@ -XXX,XX +XXX,XX @@ static BlockBackend * coroutine_fn vmdk_co_create_cb(int64_t size, int idx,
-     return blk;
- }
--static int coroutine_fn GRAPH_RDLOCK
-+static int coroutine_fn GRAPH_UNLOCKED
- vmdk_co_create(BlockdevCreateOptions *create_options, Error **errp)
- {
-     BlockdevCreateOptionsVmdk *opts;
-diff --git a/block/vpc.c b/block/vpc.c
-index XXXXXXX..XXXXXXX 100644
---- a/block/vpc.c
-+++ b/block/vpc.c
-@@ -XXX,XX +XXX,XX @@ static int calculate_rounded_image_size(BlockdevCreateOptionsVpc *vpc_opts,
-     return 0;
- }
--static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
--                                      Error **errp)
-+static int coroutine_fn GRAPH_UNLOCKED
-+vpc_co_create(BlockdevCreateOptions *opts, Error **errp)
- {
-     BlockdevCreateOptionsVpc *vpc_opts;
-     BlockBackend *blk = NULL;
-@@ -XXX,XX +XXX,XX @@ out:
-     return ret;
- }
--static int coroutine_fn GRAPH_RDLOCK
-+static int coroutine_fn GRAPH_UNLOCKED
- vpc_co_create_opts(BlockDriver *drv, const char *filename,
-                    QemuOpts *opts, Error **errp)
- {
 --
-.40.1
+.13.6

The following changes since commit 6972ef1440a9d685482d78672620a7482f2bd09a:

Merge tag 'pull-tcg-20230516-3' of https://gitlab.com/rth7680/qemu into staging (2023-05-16 21:30:27 -0700)

are available in the Git repository at:

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

for you to fetch changes up to 75b2591bbce5dc9f3da89f140b7bdc00e92fa8ec:

tested: add test for nested aio_poll() in poll handlers (2023-05-17 18:01:22 +0200)

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

- qcow2 spec: Rename "zlib" compression to "deflate"
- Honour graph read lock even in the main thread + prerequisite fixes
- aio-posix: do not nest poll handlers (fixes infinite recursion)
- Refactor QMP blockdev transactions
- iotests/245: Check if 'compress' driver is available

----------------------------------------------------------------
Akihiro Suda (1):
      docs/interop/qcow2.txt: fix description about "zlib" clusters

Kevin Wolf (9):
      block: Call .bdrv_co_create(_opts) unlocked
      block/export: Fix null pointer dereference in error path
      qcow2: Unlock the graph in qcow2_do_open() where necessary
      qemu-img: Take graph lock more selectively
      test-bdrv-drain: Take graph lock more selectively
      test-bdrv-drain: Call bdrv_co_unref() in coroutine context
      blockjob: Adhere to rate limit even when reentered early
      graph-lock: Honour read locks even in the main thread
      iotests/245: Check if 'compress' driver is available

Stefan Hajnoczi (2):
      aio-posix: do not nest poll handlers
      tested: add test for nested aio_poll() in poll handlers

Vladimir Sementsov-Ogievskiy (6):
      blockdev: refactor transaction to use Transaction API
      blockdev: transactions: rename some things
      blockdev: qmp_transaction: refactor loop to classic for
      blockdev: transaction: refactor handling transaction properties
      blockdev: use state.bitmap in block-dirty-bitmap-add action
      blockdev: qmp_transaction: drop extra generic layer

From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

We are going to add more block-graph modifying transaction actions,
and block-graph modifying functions are already based on Transaction
API.

Next, we'll need to separately update permissions after several
graph-modifying actions, and this would be simple with help of
Transaction API.

So, now let's just transform what we have into new-style transaction
actions.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Message-Id: <20230510150624.310640-2-vsementsov@yandex-team.ru>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockdev.c | 309 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 178 insertions(+), 131 deletions(-)

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ typedef struct BlkActionState BlkActionState;
  */
 typedef struct BlkActionOps {
     size_t instance_size;
-    void (*prepare)(BlkActionState *common, Error **errp);
-    void (*commit)(BlkActionState *common);
-    void (*abort)(BlkActionState *common);
-    void (*clean)(BlkActionState *common);
+    void (*action)(BlkActionState *common, Transaction *tran, Error **errp);
 } BlkActionOps;
 
 /**
@@ -XXX,XX +XXX,XX @@ typedef struct InternalSnapshotState {
     bool created;
 } InternalSnapshotState;
 
+static void internal_snapshot_abort(void *opaque);
+static void internal_snapshot_clean(void *opaque);
+TransactionActionDrv internal_snapshot_drv = {
+    .abort = internal_snapshot_abort,
+    .clean = internal_snapshot_clean,
+};
 
 static int action_check_completion_mode(BlkActionState *s, Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ static int action_check_completion_mode(BlkActionState *s, Error **errp)
     return 0;
 }
 
-static void internal_snapshot_prepare(BlkActionState *common,
-                                      Error **errp)
+static void internal_snapshot_action(BlkActionState *common,
+                                     Transaction *tran, Error **errp)
 {
     Error *local_err = NULL;
     const char *device;
@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_prepare(BlkActionState *common,
     internal = common->action->u.blockdev_snapshot_internal_sync.data;
     state = DO_UPCAST(InternalSnapshotState, common, common);
 
+    tran_add(tran, &internal_snapshot_drv, state);
+
     /* 1. parse input */
     device = internal->device;
     name = internal->name;
@@ -XXX,XX +XXX,XX @@ out:
     aio_context_release(aio_context);
 }
 
-static void internal_snapshot_abort(BlkActionState *common)
+static void internal_snapshot_abort(void *opaque)
 {
-    InternalSnapshotState *state =
-                             DO_UPCAST(InternalSnapshotState, common, common);
+    InternalSnapshotState *state = opaque;
     BlockDriverState *bs = state->bs;
     QEMUSnapshotInfo *sn = &state->sn;
     AioContext *aio_context;
@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_abort(BlkActionState *common)
     aio_context_release(aio_context);
 }
 
-static void internal_snapshot_clean(BlkActionState *common)
+static void internal_snapshot_clean(void *opaque)
 {
-    InternalSnapshotState *state = DO_UPCAST(InternalSnapshotState,
-                                             common, common);
+    g_autofree InternalSnapshotState *state = opaque;
     AioContext *aio_context;
 
     if (!state->bs) {
@@ -XXX,XX +XXX,XX @@ typedef struct ExternalSnapshotState {
     bool overlay_appended;
 } ExternalSnapshotState;
 
-static void external_snapshot_prepare(BlkActionState *common,
-                                      Error **errp)
+static void external_snapshot_commit(void *opaque);
+static void external_snapshot_abort(void *opaque);
+static void external_snapshot_clean(void *opaque);
+TransactionActionDrv external_snapshot_drv = {
+    .commit = external_snapshot_commit,
+    .abort = external_snapshot_abort,
+    .clean = external_snapshot_clean,
+};
+
+static void external_snapshot_action(BlkActionState *common, Transaction *tran,
+                                     Error **errp)
 {
     int ret;
     int flags = 0;
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,
     AioContext *aio_context;
     uint64_t perm, shared;
 
+    tran_add(tran, &external_snapshot_drv, state);
+
     /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
      * purpose but a different set of parameters */
     switch (action->type) {
@@ -XXX,XX +XXX,XX @@ out:
     aio_context_release(aio_context);
 }
 
-static void external_snapshot_commit(BlkActionState *common)
+static void external_snapshot_commit(void *opaque)
 {
-    ExternalSnapshotState *state =
-                             DO_UPCAST(ExternalSnapshotState, common, common);
+    ExternalSnapshotState *state = opaque;
     AioContext *aio_context;
 
     aio_context = bdrv_get_aio_context(state->old_bs);
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_commit(BlkActionState *common)
     aio_context_release(aio_context);
 }
 
-static void external_snapshot_abort(BlkActionState *common)
+static void external_snapshot_abort(void *opaque)
 {
-    ExternalSnapshotState *state =
-                             DO_UPCAST(ExternalSnapshotState, common, common);
+    ExternalSnapshotState *state = opaque;
     if (state->new_bs) {
         if (state->overlay_appended) {
             AioContext *aio_context;
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_abort(BlkActionState *common)
     }
 }
 
-static void external_snapshot_clean(BlkActionState *common)
+static void external_snapshot_clean(void *opaque)
 {
-    ExternalSnapshotState *state =
-                             DO_UPCAST(ExternalSnapshotState, common, common);
+    g_autofree ExternalSnapshotState *state = opaque;
     AioContext *aio_context;
 
     if (!state->old_bs) {
@@ -XXX,XX +XXX,XX @@ static BlockJob *do_backup_common(BackupCommon *backup,
                                   AioContext *aio_context,
                                   JobTxn *txn, Error **errp);
 
-static void drive_backup_prepare(BlkActionState *common, Error **errp)
+static void drive_backup_commit(void *opaque);
+static void drive_backup_abort(void *opaque);
+static void drive_backup_clean(void *opaque);
+TransactionActionDrv drive_backup_drv = {
+    .commit = drive_backup_commit,
+    .abort = drive_backup_abort,
+    .clean = drive_backup_clean,
+};
+
+static void drive_backup_action(BlkActionState *common, Transaction *tran,
+                                Error **errp)
 {
     DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
     DriveBackup *backup;
@@ -XXX,XX +XXX,XX @@ static void drive_backup_prepare(BlkActionState *common, Error **errp)
     bool set_backing_hd = false;
     int ret;
 
+    tran_add(tran, &drive_backup_drv, state);
+
     assert(common->action->type == TRANSACTION_ACTION_KIND_DRIVE_BACKUP);
     backup = common->action->u.drive_backup.data;
 
@@ -XXX,XX +XXX,XX @@ out:
     aio_context_release(aio_context);
 }
 
-static void drive_backup_commit(BlkActionState *common)
+static void drive_backup_commit(void *opaque)
 {
-    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
+    DriveBackupState *state = opaque;
     AioContext *aio_context;
 
     aio_context = bdrv_get_aio_context(state->bs);
@@ -XXX,XX +XXX,XX @@ static void drive_backup_commit(BlkActionState *common)
     aio_context_release(aio_context);
 }
 
-static void drive_backup_abort(BlkActionState *common)
+static void drive_backup_abort(void *opaque)
 {
-    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
+    DriveBackupState *state = opaque;
 
     if (state->job) {
         job_cancel_sync(&state->job->job, true);
     }
 }
 
-static void drive_backup_clean(BlkActionState *common)
+static void drive_backup_clean(void *opaque)
 {
-    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
+    g_autofree DriveBackupState *state = opaque;
     AioContext *aio_context;
 
     if (!state->bs) {
@@ -XXX,XX +XXX,XX @@ typedef struct BlockdevBackupState {
     BlockJob *job;
 } BlockdevBackupState;
 
-static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
+static void blockdev_backup_commit(void *opaque);
+static void blockdev_backup_abort(void *opaque);
+static void blockdev_backup_clean(void *opaque);
+TransactionActionDrv blockdev_backup_drv = {
+    .commit = blockdev_backup_commit,
+    .abort = blockdev_backup_abort,
+    .clean = blockdev_backup_clean,
+};
+
+static void blockdev_backup_action(BlkActionState *common, Transaction *tran,
+                                   Error **errp)
 {
     BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
     BlockdevBackup *backup;
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
     AioContext *old_context;
     int ret;
 
+    tran_add(tran, &blockdev_backup_drv, state);
+
     assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
     backup = common->action->u.blockdev_backup.data;
 
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_prepare(BlkActionState *common, Error **errp)
     aio_context_release(aio_context);
 }
 
-static void blockdev_backup_commit(BlkActionState *common)
+static void blockdev_backup_commit(void *opaque)
 {
-    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
+    BlockdevBackupState *state = opaque;
     AioContext *aio_context;
 
     aio_context = bdrv_get_aio_context(state->bs);
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_commit(BlkActionState *common)
     aio_context_release(aio_context);
 }
 
-static void blockdev_backup_abort(BlkActionState *common)
+static void blockdev_backup_abort(void *opaque)
 {
-    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
+    BlockdevBackupState *state = opaque;
 
     if (state->job) {
         job_cancel_sync(&state->job->job, true);
     }
 }
 
-static void blockdev_backup_clean(BlkActionState *common)
+static void blockdev_backup_clean(void *opaque)
 {
-    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
+    g_autofree BlockdevBackupState *state = opaque;
     AioContext *aio_context;
 
     if (!state->bs) {
@@ -XXX,XX +XXX,XX @@ typedef struct BlockDirtyBitmapState {
     bool was_enabled;
 } BlockDirtyBitmapState;
 
-static void block_dirty_bitmap_add_prepare(BlkActionState *common,
-                                           Error **errp)
+static void block_dirty_bitmap_add_abort(void *opaque);
+TransactionActionDrv block_dirty_bitmap_add_drv = {
+    .abort = block_dirty_bitmap_add_abort,
+    .clean = g_free,
+};
+
+static void block_dirty_bitmap_add_action(BlkActionState *common,
+                                          Transaction *tran, Error **errp)
 {
     Error *local_err = NULL;
     BlockDirtyBitmapAdd *action;
     BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                              common, common);
 
+    tran_add(tran, &block_dirty_bitmap_add_drv, state);
+
     if (action_check_completion_mode(common, errp) < 0) {
         return;
     }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_add_prepare(BlkActionState *common,
     }
 }
 
-static void block_dirty_bitmap_add_abort(BlkActionState *common)
+static void block_dirty_bitmap_add_abort(void *opaque)
 {
     BlockDirtyBitmapAdd *action;
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = opaque;
 
-    action = common->action->u.block_dirty_bitmap_add.data;
+    action = state->common.action->u.block_dirty_bitmap_add.data;
     /* Should not be able to fail: IF the bitmap was added via .prepare(),
      * then the node reference and bitmap name must have been valid.
      */
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_add_abort(BlkActionState *common)
     }
 }
 
-static void block_dirty_bitmap_clear_prepare(BlkActionState *common,
-                                             Error **errp)
+static void block_dirty_bitmap_restore(void *opaque);
+static void block_dirty_bitmap_free_backup(void *opaque);
+TransactionActionDrv block_dirty_bitmap_clear_drv = {
+    .abort = block_dirty_bitmap_restore,
+    .commit = block_dirty_bitmap_free_backup,
+    .clean = g_free,
+};
+
+static void block_dirty_bitmap_clear_action(BlkActionState *common,
+                                            Transaction *tran, Error **errp)
 {
     BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                              common, common);
     BlockDirtyBitmap *action;
 
+    tran_add(tran, &block_dirty_bitmap_clear_drv, state);
+
     if (action_check_completion_mode(common, errp) < 0) {
         return;
     }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_clear_prepare(BlkActionState *common,
     bdrv_clear_dirty_bitmap(state->bitmap, &state->backup);
 }
 
-static void block_dirty_bitmap_restore(BlkActionState *common)
+static void block_dirty_bitmap_restore(void *opaque)
 {
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = opaque;
 
     if (state->backup) {
         bdrv_restore_dirty_bitmap(state->bitmap, state->backup);
     }
 }
 
-static void block_dirty_bitmap_free_backup(BlkActionState *common)
+static void block_dirty_bitmap_free_backup(void *opaque)
 {
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = opaque;
 
     hbitmap_free(state->backup);
 }
 
-static void block_dirty_bitmap_enable_prepare(BlkActionState *common,
-                                              Error **errp)
+static void block_dirty_bitmap_enable_abort(void *opaque);
+TransactionActionDrv block_dirty_bitmap_enable_drv = {
+    .abort = block_dirty_bitmap_enable_abort,
+    .clean = g_free,
+};
+
+static void block_dirty_bitmap_enable_action(BlkActionState *common,
+                                             Transaction *tran, Error **errp)
 {
     BlockDirtyBitmap *action;
     BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                              common, common);
 
+    tran_add(tran, &block_dirty_bitmap_enable_drv, state);
+
     if (action_check_completion_mode(common, errp) < 0) {
         return;
     }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_enable_prepare(BlkActionState *common,
     bdrv_enable_dirty_bitmap(state->bitmap);
 }
 
-static void block_dirty_bitmap_enable_abort(BlkActionState *common)
+static void block_dirty_bitmap_enable_abort(void *opaque)
 {
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = opaque;
 
     if (!state->was_enabled) {
         bdrv_disable_dirty_bitmap(state->bitmap);
     }
 }
 
-static void block_dirty_bitmap_disable_prepare(BlkActionState *common,
-                                               Error **errp)
+static void block_dirty_bitmap_disable_abort(void *opaque);
+TransactionActionDrv block_dirty_bitmap_disable_drv = {
+    .abort = block_dirty_bitmap_disable_abort,
+    .clean = g_free,
+};
+
+static void block_dirty_bitmap_disable_action(BlkActionState *common,
+                                              Transaction *tran, Error **errp)
 {
     BlockDirtyBitmap *action;
     BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                              common, common);
 
+    tran_add(tran, &block_dirty_bitmap_disable_drv, state);
+
     if (action_check_completion_mode(common, errp) < 0) {
         return;
     }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_disable_prepare(BlkActionState *common,
     bdrv_disable_dirty_bitmap(state->bitmap);
 }
 
-static void block_dirty_bitmap_disable_abort(BlkActionState *common)
+static void block_dirty_bitmap_disable_abort(void *opaque)
 {
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = opaque;
 
     if (state->was_enabled) {
         bdrv_enable_dirty_bitmap(state->bitmap);
     }
 }
 
-static void block_dirty_bitmap_merge_prepare(BlkActionState *common,
-                                             Error **errp)
+TransactionActionDrv block_dirty_bitmap_merge_drv = {
+    .commit = block_dirty_bitmap_free_backup,
+    .abort = block_dirty_bitmap_restore,
+    .clean = g_free,
+};
+
+static void block_dirty_bitmap_merge_action(BlkActionState *common,
+                                            Transaction *tran, Error **errp)
 {
     BlockDirtyBitmapMerge *action;
     BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                              common, common);
 
+    tran_add(tran, &block_dirty_bitmap_merge_drv, state);
+
     if (action_check_completion_mode(common, errp) < 0) {
         return;
     }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_merge_prepare(BlkActionState *common,
                                              errp);
 }
 
-static void block_dirty_bitmap_remove_prepare(BlkActionState *common,
-                                              Error **errp)
+static void block_dirty_bitmap_remove_commit(void *opaque);
+static void block_dirty_bitmap_remove_abort(void *opaque);
+TransactionActionDrv block_dirty_bitmap_remove_drv = {
+    .commit = block_dirty_bitmap_remove_commit,
+    .abort = block_dirty_bitmap_remove_abort,
+    .clean = g_free,
+};
+
+static void block_dirty_bitmap_remove_action(BlkActionState *common,
+                                             Transaction *tran, Error **errp)
 {
     BlockDirtyBitmap *action;
     BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
                                              common, common);
 
+    tran_add(tran, &block_dirty_bitmap_remove_drv, state);
+
     if (action_check_completion_mode(common, errp) < 0) {
         return;
     }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_remove_prepare(BlkActionState *common,
     }
 }
 
-static void block_dirty_bitmap_remove_abort(BlkActionState *common)
+static void block_dirty_bitmap_remove_abort(void *opaque)
 {
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = opaque;
 
     if (state->bitmap) {
         bdrv_dirty_bitmap_skip_store(state->bitmap, false);
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_remove_abort(BlkActionState *common)
     }
 }
 
-static void block_dirty_bitmap_remove_commit(BlkActionState *common)
+static void block_dirty_bitmap_remove_commit(void *opaque)
 {
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = opaque;
 
     bdrv_dirty_bitmap_set_busy(state->bitmap, false);
     bdrv_release_dirty_bitmap(state->bitmap);
 }
 
-static void abort_prepare(BlkActionState *common, Error **errp)
+static void abort_commit(void *opaque);
+TransactionActionDrv abort_drv = {
+    .commit = abort_commit,
+    .clean = g_free,
+};
+
+static void abort_action(BlkActionState *common, Transaction *tran,
+                         Error **errp)
 {
+    tran_add(tran, &abort_drv, common);
     error_setg(errp, "Transaction aborted using Abort action");
 }
 
-static void abort_commit(BlkActionState *common)
+static void abort_commit(void *opaque)
 {
     g_assert_not_reached(); /* this action never succeeds */
 }
@@ -XXX,XX +XXX,XX @@ static void abort_commit(BlkActionState *common)
 static const BlkActionOps actions[] = {
     [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {
         .instance_size = sizeof(ExternalSnapshotState),
-        .prepare  = external_snapshot_prepare,
-        .commit   = external_snapshot_commit,
-        .abort = external_snapshot_abort,
-        .clean = external_snapshot_clean,
+        .action  = external_snapshot_action,
     },
     [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC] = {
         .instance_size = sizeof(ExternalSnapshotState),
-        .prepare  = external_snapshot_prepare,
-        .commit   = external_snapshot_commit,
-        .abort = external_snapshot_abort,
-        .clean = external_snapshot_clean,
+        .action  = external_snapshot_action,
     },
     [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] = {
         .instance_size = sizeof(DriveBackupState),
-        .prepare = drive_backup_prepare,
-        .commit = drive_backup_commit,
-        .abort = drive_backup_abort,
-        .clean = drive_backup_clean,
+        .action = drive_backup_action,
     },
     [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] = {
         .instance_size = sizeof(BlockdevBackupState),
-        .prepare = blockdev_backup_prepare,
-        .commit = blockdev_backup_commit,
-        .abort = blockdev_backup_abort,
-        .clean = blockdev_backup_clean,
+        .action = blockdev_backup_action,
     },
     [TRANSACTION_ACTION_KIND_ABORT] = {
         .instance_size = sizeof(BlkActionState),
-        .prepare = abort_prepare,
-        .commit = abort_commit,
+        .action = abort_action,
     },
     [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC] = {
         .instance_size = sizeof(InternalSnapshotState),
-        .prepare  = internal_snapshot_prepare,
-        .abort = internal_snapshot_abort,
-        .clean = internal_snapshot_clean,
+        .action  = internal_snapshot_action,
     },
     [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD] = {
         .instance_size = sizeof(BlockDirtyBitmapState),
-        .prepare = block_dirty_bitmap_add_prepare,
-        .abort = block_dirty_bitmap_add_abort,
+        .action = block_dirty_bitmap_add_action,
     },
     [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR] = {
         .instance_size = sizeof(BlockDirtyBitmapState),
-        .prepare = block_dirty_bitmap_clear_prepare,
-        .commit = block_dirty_bitmap_free_backup,
-        .abort = block_dirty_bitmap_restore,
+        .action = block_dirty_bitmap_clear_action,
     },
     [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE] = {
         .instance_size = sizeof(BlockDirtyBitmapState),
-        .prepare = block_dirty_bitmap_enable_prepare,
-        .abort = block_dirty_bitmap_enable_abort,
+        .action = block_dirty_bitmap_enable_action,
     },
     [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE] = {
         .instance_size = sizeof(BlockDirtyBitmapState),
-        .prepare = block_dirty_bitmap_disable_prepare,
-        .abort = block_dirty_bitmap_disable_abort,
+        .action = block_dirty_bitmap_disable_action,
     },
     [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE] = {
         .instance_size = sizeof(BlockDirtyBitmapState),
-        .prepare = block_dirty_bitmap_merge_prepare,
-        .commit = block_dirty_bitmap_free_backup,
-        .abort = block_dirty_bitmap_restore,
+        .action = block_dirty_bitmap_merge_action,
     },
     [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE] = {
         .instance_size = sizeof(BlockDirtyBitmapState),
-        .prepare = block_dirty_bitmap_remove_prepare,
-        .commit = block_dirty_bitmap_remove_commit,
-        .abort = block_dirty_bitmap_remove_abort,
+        .action = block_dirty_bitmap_remove_action,
     },
     /* Where are transactions for MIRROR, COMMIT and STREAM?
      * Although these blockjobs use transaction callbacks like the backup job,
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,
     TransactionActionList *dev_entry = dev_list;
     bool has_props = !!props;
     JobTxn *block_job_txn = NULL;
-    BlkActionState *state, *next;
     Error *local_err = NULL;
+    Transaction *tran = tran_new();
 
     GLOBAL_STATE_CODE();
 
-    QTAILQ_HEAD(, BlkActionState) snap_bdrv_states;
-    QTAILQ_INIT(&snap_bdrv_states);
-
     /* Does this transaction get canceled as a group on failure?
      * If not, we don't really need to make a JobTxn.
      */
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,
     while (NULL != dev_entry) {
         TransactionAction *dev_info = NULL;
         const BlkActionOps *ops;
+        BlkActionState *state;
 
         dev_info = dev_entry->value;
         dev_entry = dev_entry->next;
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,
         state->action = dev_info;
         state->block_job_txn = block_job_txn;
         state->txn_props = props;
-        QTAILQ_INSERT_TAIL(&snap_bdrv_states, state, entry);
 
-        state->ops->prepare(state, &local_err);
+        state->ops->action(state, tran, &local_err);
         if (local_err) {
             error_propagate(errp, local_err);
             goto delete_and_fail;
         }
     }
 
-    QTAILQ_FOREACH(state, &snap_bdrv_states, entry) {
-        if (state->ops->commit) {
-            state->ops->commit(state);
-        }
-    }
+    tran_commit(tran);
 
     /* success */
     goto exit;
 
 delete_and_fail:
     /* failure, and it is all-or-none; roll back all operations */
-    QTAILQ_FOREACH_REVERSE(state, &snap_bdrv_states, entry) {
-        if (state->ops->abort) {
-            state->ops->abort(state);
-        }
-    }
+    tran_abort(tran);
 exit:
-    QTAILQ_FOREACH_SAFE(state, &snap_bdrv_states, entry, next) {
-        if (state->ops->clean) {
-            state->ops->clean(state);
-        }
-        g_free(state);
-    }
     if (!has_props) {
         qapi_free_TransactionProperties(props);
     }
-- 
2.40.1

From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

Look at qmp_transaction(): dev_list is not obvious name for list of
actions. Let's look at qapi spec, this argument is "actions". Let's
follow the common practice of using same argument names in qapi scheme
and code.

To be honest, rename props to properties for same reason.

Next, we have to rename global map of actions, to not conflict with new
name for function argument.

Rename also dev_entry loop variable accordingly to new name of the
list.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230510150624.310640-3-vsementsov@yandex-team.ru>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockdev.c | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ static void abort_commit(void *opaque)
     g_assert_not_reached(); /* this action never succeeds */
 }
 
-static const BlkActionOps actions[] = {
+static const BlkActionOps actions_map[] = {
     [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {
         .instance_size = sizeof(ExternalSnapshotState),
         .action  = external_snapshot_action,
@@ -XXX,XX +XXX,XX @@ static TransactionProperties *get_transaction_properties(
  *
  * Always run under BQL.
  */
-void qmp_transaction(TransactionActionList *dev_list,
-                     struct TransactionProperties *props,
+void qmp_transaction(TransactionActionList *actions,
+                     struct TransactionProperties *properties,
                      Error **errp)
 {
-    TransactionActionList *dev_entry = dev_list;
-    bool has_props = !!props;
+    TransactionActionList *act = actions;
+    bool has_properties = !!properties;
     JobTxn *block_job_txn = NULL;
     Error *local_err = NULL;
     Transaction *tran = tran_new();
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,
     /* Does this transaction get canceled as a group on failure?
      * If not, we don't really need to make a JobTxn.
      */
-    props = get_transaction_properties(props);
-    if (props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
+    properties = get_transaction_properties(properties);
+    if (properties->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
         block_job_txn = job_txn_new();
     }
 
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *dev_list,
     bdrv_drain_all();
 
     /* We don't do anything in this loop that commits us to the operations */
-    while (NULL != dev_entry) {
+    while (NULL != act) {
         TransactionAction *dev_info = NULL;
         const BlkActionOps *ops;
         BlkActionState *state;
 
-        dev_info = dev_entry->value;
-        dev_entry = dev_entry->next;
+        dev_info = act->value;
+        act = act->next;
 
-        assert(dev_info->type < ARRAY_SIZE(actions));
+        assert(dev_info->type < ARRAY_SIZE(actions_map));
 
-        ops = &actions[dev_info->type];
+        ops = &actions_map[dev_info->type];
         assert(ops->instance_size > 0);
 
         state = g_malloc0(ops->instance_size);
         state->ops = ops;
         state->action = dev_info;
         state->block_job_txn = block_job_txn;
-        state->txn_props = props;
+        state->txn_props = properties;
 
         state->ops->action(state, tran, &local_err);
         if (local_err) {
@@ -XXX,XX +XXX,XX @@ delete_and_fail:
     /* failure, and it is all-or-none; roll back all operations */
     tran_abort(tran);
 exit:
-    if (!has_props) {
-        qapi_free_TransactionProperties(props);
+    if (!has_properties) {
+        qapi_free_TransactionProperties(properties);
     }
     job_txn_unref(block_job_txn);
 }
-- 
2.40.1

From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230510150624.310640-4-vsementsov@yandex-team.ru>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockdev.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *actions,
                      struct TransactionProperties *properties,
                      Error **errp)
 {
-    TransactionActionList *act = actions;
+    TransactionActionList *act;
     bool has_properties = !!properties;
     JobTxn *block_job_txn = NULL;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *actions,
     bdrv_drain_all();
 
     /* We don't do anything in this loop that commits us to the operations */
-    while (NULL != act) {
-        TransactionAction *dev_info = NULL;
+    for (act = actions; act; act = act->next) {
+        TransactionAction *dev_info = act->value;
         const BlkActionOps *ops;
         BlkActionState *state;
 
-        dev_info = act->value;
-        act = act->next;
-
         assert(dev_info->type < ARRAY_SIZE(actions_map));
 
         ops = &actions_map[dev_info->type];
-- 
2.40.1

From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

Only backup supports GROUPED mode. Make this logic more clear. And
avoid passing extra thing to each action.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Message-Id: <20230510150624.310640-5-vsementsov@yandex-team.ru>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockdev.c | 96 +++++++++++++-----------------------------------------
 1 file changed, 22 insertions(+), 74 deletions(-)

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ struct BlkActionState {
     TransactionAction *action;
     const BlkActionOps *ops;
     JobTxn *block_job_txn;
-    TransactionProperties *txn_props;
     QTAILQ_ENTRY(BlkActionState) entry;
 };
 
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv internal_snapshot_drv = {
     .clean = internal_snapshot_clean,
 };
 
-static int action_check_completion_mode(BlkActionState *s, Error **errp)
-{
-    if (s->txn_props->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
-        error_setg(errp,
-                   "Action '%s' does not support Transaction property "
-                   "completion-mode = %s",
-                   TransactionActionKind_str(s->action->type),
-                   ActionCompletionMode_str(s->txn_props->completion_mode));
-        return -1;
-    }
-    return 0;
-}
-
 static void internal_snapshot_action(BlkActionState *common,
                                      Transaction *tran, Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_action(BlkActionState *common,
 
     tran_add(tran, &internal_snapshot_drv, state);
 
-    /* 1. parse input */
     device = internal->device;
     name = internal->name;
 
-    /* 2. check for validation */
-    if (action_check_completion_mode(common, errp) < 0) {
-        return;
-    }
-
     bs = qmp_get_root_bs(device, errp);
     if (!bs) {
         return;
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_action(BlkActionState *common, Transaction *tran,
     }
 
     /* start processing */
-    if (action_check_completion_mode(common, errp) < 0) {
-        return;
-    }
 
     state->old_bs = bdrv_lookup_bs(device, node_name, errp);
     if (!state->old_bs) {
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_add_action(BlkActionState *common,
 
     tran_add(tran, &block_dirty_bitmap_add_drv, state);
 
-    if (action_check_completion_mode(common, errp) < 0) {
-        return;
-    }
-
     action = common->action->u.block_dirty_bitmap_add.data;
     /* AIO context taken and released within qmp_block_dirty_bitmap_add */
     qmp_block_dirty_bitmap_add(action->node, action->name,
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_clear_action(BlkActionState *common,
 
     tran_add(tran, &block_dirty_bitmap_clear_drv, state);
 
-    if (action_check_completion_mode(common, errp) < 0) {
-        return;
-    }
-
     action = common->action->u.block_dirty_bitmap_clear.data;
     state->bitmap = block_dirty_bitmap_lookup(action->node,
                                               action->name,
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_enable_action(BlkActionState *common,
 
     tran_add(tran, &block_dirty_bitmap_enable_drv, state);
 
-    if (action_check_completion_mode(common, errp) < 0) {
-        return;
-    }
-
     action = common->action->u.block_dirty_bitmap_enable.data;
     state->bitmap = block_dirty_bitmap_lookup(action->node,
                                               action->name,
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_disable_action(BlkActionState *common,
 
     tran_add(tran, &block_dirty_bitmap_disable_drv, state);
 
-    if (action_check_completion_mode(common, errp) < 0) {
-        return;
-    }
-
     action = common->action->u.block_dirty_bitmap_disable.data;
     state->bitmap = block_dirty_bitmap_lookup(action->node,
                                               action->name,
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_merge_action(BlkActionState *common,
 
     tran_add(tran, &block_dirty_bitmap_merge_drv, state);
 
-    if (action_check_completion_mode(common, errp) < 0) {
-        return;
-    }
-
     action = common->action->u.block_dirty_bitmap_merge.data;
 
     state->bitmap = block_dirty_bitmap_merge(action->node, action->target,
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_remove_action(BlkActionState *common,
 
     tran_add(tran, &block_dirty_bitmap_remove_drv, state);
 
-    if (action_check_completion_mode(common, errp) < 0) {
-        return;
-    }
-
     action = common->action->u.block_dirty_bitmap_remove.data;
 
     state->bitmap = block_dirty_bitmap_remove(action->node, action->name,
@@ -XXX,XX +XXX,XX @@ static const BlkActionOps actions_map[] = {
      */
 };
 
-/**
- * Allocate a TransactionProperties structure if necessary, and fill
- * that structure with desired defaults if they are unset.
- */
-static TransactionProperties *get_transaction_properties(
-    TransactionProperties *props)
-{
-    if (!props) {
-        props = g_new0(TransactionProperties, 1);
-    }
-
-    if (!props->has_completion_mode) {
-        props->has_completion_mode = true;
-        props->completion_mode = ACTION_COMPLETION_MODE_INDIVIDUAL;
-    }
-
-    return props;
-}
-
 /*
  * 'Atomic' group operations.  The operations are performed as a set, and if
  * any fail then we roll back all operations in the group.
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *actions,
                      Error **errp)
 {
     TransactionActionList *act;
-    bool has_properties = !!properties;
     JobTxn *block_job_txn = NULL;
     Error *local_err = NULL;
-    Transaction *tran = tran_new();
+    Transaction *tran;
+    ActionCompletionMode comp_mode =
+        properties ? properties->completion_mode :
+        ACTION_COMPLETION_MODE_INDIVIDUAL;
 
     GLOBAL_STATE_CODE();
 
     /* Does this transaction get canceled as a group on failure?
      * If not, we don't really need to make a JobTxn.
      */
-    properties = get_transaction_properties(properties);
-    if (properties->completion_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
+    if (comp_mode != ACTION_COMPLETION_MODE_INDIVIDUAL) {
+        for (act = actions; act; act = act->next) {
+            TransactionActionKind type = act->value->type;
+
+            if (type != TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP &&
+                type != TRANSACTION_ACTION_KIND_DRIVE_BACKUP)
+            {
+                error_setg(errp,
+                           "Action '%s' does not support transaction property "
+                           "completion-mode = %s",
+                           TransactionActionKind_str(type),
+                           ActionCompletionMode_str(comp_mode));
+                return;
+            }
+        }
+
         block_job_txn = job_txn_new();
     }
 
     /* drain all i/o before any operations */
     bdrv_drain_all();
 
+    tran = tran_new();
+
     /* We don't do anything in this loop that commits us to the operations */
     for (act = actions; act; act = act->next) {
         TransactionAction *dev_info = act->value;
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *actions,
         state->ops = ops;
         state->action = dev_info;
         state->block_job_txn = block_job_txn;
-        state->txn_props = properties;
 
         state->ops->action(state, tran, &local_err);
         if (local_err) {
@@ -XXX,XX +XXX,XX @@ delete_and_fail:
     /* failure, and it is all-or-none; roll back all operations */
     tran_abort(tran);
 exit:
-    if (!has_properties) {
-        qapi_free_TransactionProperties(properties);
-    }
     job_txn_unref(block_job_txn);
 }
 
-- 
2.40.1

From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

Other bitmap related actions use the .bitmap pointer in .abort action,
let's do same here:

1. It helps further refactoring, as bitmap-add is the only bitmap
   action that uses state.action in .abort

2. It must be safe: transaction actions rely on the fact that on
   .abort() the state is the same as at the end of .prepare(), so that
   in .abort() we could precisely rollback the changes done by
   .prepare().
   The only way to remove the bitmap during transaction should be
   block-dirty-bitmap-remove action, but it postpones actual removal to
   .commit(), so we are OK on any rollback path. (Note also that
   bitmap-remove is the only bitmap action that has .commit() phase,
   except for simple g_free the state on .clean())

3. Again, other bitmap actions behave this way: keep the bitmap pointer
   during the transaction.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Message-Id: <20230510150624.310640-6-vsementsov@yandex-team.ru>
[kwolf: Also remove the now unused BlockDirtyBitmapState.prepared]
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockdev.c | 13 ++++---------
 1 file changed, 4 insertions(+), 9 deletions(-)

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ typedef struct BlockDirtyBitmapState {
     BdrvDirtyBitmap *bitmap;
     BlockDriverState *bs;
     HBitmap *backup;
-    bool prepared;
     bool was_enabled;
 } BlockDirtyBitmapState;
 
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_add_action(BlkActionState *common,
                                &local_err);
 
     if (!local_err) {
-        state->prepared = true;
+        state->bitmap = block_dirty_bitmap_lookup(action->node, action->name,
+                                                  NULL, &error_abort);
     } else {
         error_propagate(errp, local_err);
     }
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_add_action(BlkActionState *common,
 
 static void block_dirty_bitmap_add_abort(void *opaque)
 {
-    BlockDirtyBitmapAdd *action;
     BlockDirtyBitmapState *state = opaque;
 
-    action = state->common.action->u.block_dirty_bitmap_add.data;
-    /* Should not be able to fail: IF the bitmap was added via .prepare(),
-     * then the node reference and bitmap name must have been valid.
-     */
-    if (state->prepared) {
-        qmp_block_dirty_bitmap_remove(action->node, action->name, &error_abort);
+    if (state->bitmap) {
+        bdrv_release_dirty_bitmap(state->bitmap);
     }
 }
 
-- 
2.40.1

From: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>

Let's simplify things:

First, actions generally don't need access to common BlkActionState
structure. The only exclusion are backup actions that need
block_job_txn.

Next, for transaction actions of Transaction API is more native to
allocated state structure in the action itself.

So, do the following transformation:

1. Let all actions be represented by a function with corresponding
   structure as arguments.

2. Instead of array-map marshaller, let's make a function, that calls
   corresponding action directly.

3. BlkActionOps and BlkActionState structures become unused

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@yandex-team.ru>
Message-Id: <20230510150624.310640-7-vsementsov@yandex-team.ru>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockdev.c | 265 +++++++++++++++++------------------------------------
 1 file changed, 85 insertions(+), 180 deletions(-)

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ out_aio_context:
     return NULL;
 }
 
-/* New and old BlockDriverState structs for atomic group operations */
-
-typedef struct BlkActionState BlkActionState;
-
-/**
- * BlkActionOps:
- * Table of operations that define an Action.
- *
- * @instance_size: Size of state struct, in bytes.
- * @prepare: Prepare the work, must NOT be NULL.
- * @commit: Commit the changes, can be NULL.
- * @abort: Abort the changes on fail, can be NULL.
- * @clean: Clean up resources after all transaction actions have called
- *         commit() or abort(). Can be NULL.
- *
- * Only prepare() may fail. In a single transaction, only one of commit() or
- * abort() will be called. clean() will always be called if it is present.
- *
- * Always run under BQL.
- */
-typedef struct BlkActionOps {
-    size_t instance_size;
-    void (*action)(BlkActionState *common, Transaction *tran, Error **errp);
-} BlkActionOps;
-
-/**
- * BlkActionState:
- * Describes one Action's state within a Transaction.
- *
- * @action: QAPI-defined enum identifying which Action to perform.
- * @ops: Table of ActionOps this Action can perform.
- * @block_job_txn: Transaction which this action belongs to.
- * @entry: List membership for all Actions in this Transaction.
- *
- * This structure must be arranged as first member in a subclassed type,
- * assuming that the compiler will also arrange it to the same offsets as the
- * base class.
- */
-struct BlkActionState {
-    TransactionAction *action;
-    const BlkActionOps *ops;
-    JobTxn *block_job_txn;
-    QTAILQ_ENTRY(BlkActionState) entry;
-};
-
 /* internal snapshot private data */
 typedef struct InternalSnapshotState {
-    BlkActionState common;
     BlockDriverState *bs;
     QEMUSnapshotInfo sn;
     bool created;
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv internal_snapshot_drv = {
     .clean = internal_snapshot_clean,
 };
 
-static void internal_snapshot_action(BlkActionState *common,
+static void internal_snapshot_action(BlockdevSnapshotInternal *internal,
                                      Transaction *tran, Error **errp)
 {
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_action(BlkActionState *common,
     QEMUSnapshotInfo old_sn, *sn;
     bool ret;
     int64_t rt;
-    BlockdevSnapshotInternal *internal;
-    InternalSnapshotState *state;
+    InternalSnapshotState *state = g_new0(InternalSnapshotState, 1);
     AioContext *aio_context;
     int ret1;
 
-    g_assert(common->action->type ==
-             TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC);
-    internal = common->action->u.blockdev_snapshot_internal_sync.data;
-    state = DO_UPCAST(InternalSnapshotState, common, common);
-
     tran_add(tran, &internal_snapshot_drv, state);
 
     device = internal->device;
@@ -XXX,XX +XXX,XX @@ static void internal_snapshot_clean(void *opaque)
 
 /* external snapshot private data */
 typedef struct ExternalSnapshotState {
-    BlkActionState common;
     BlockDriverState *old_bs;
     BlockDriverState *new_bs;
     bool overlay_appended;
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv external_snapshot_drv = {
     .clean = external_snapshot_clean,
 };
 
-static void external_snapshot_action(BlkActionState *common, Transaction *tran,
-                                     Error **errp)
+static void external_snapshot_action(TransactionAction *action,
+                                     Transaction *tran, Error **errp)
 {
     int ret;
     int flags = 0;
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_action(BlkActionState *common, Transaction *tran,
     const char *snapshot_ref;
     /* File name of the new image (for 'blockdev-snapshot-sync') */
     const char *new_image_file;
-    ExternalSnapshotState *state =
-                             DO_UPCAST(ExternalSnapshotState, common, common);
-    TransactionAction *action = common->action;
+    ExternalSnapshotState *state = g_new0(ExternalSnapshotState, 1);
     AioContext *aio_context;
     uint64_t perm, shared;
 
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_clean(void *opaque)
 }
 
 typedef struct DriveBackupState {
-    BlkActionState common;
     BlockDriverState *bs;
     BlockJob *job;
 } DriveBackupState;
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv drive_backup_drv = {
     .clean = drive_backup_clean,
 };
 
-static void drive_backup_action(BlkActionState *common, Transaction *tran,
-                                Error **errp)
+static void drive_backup_action(DriveBackup *backup,
+                                JobTxn *block_job_txn,
+                                Transaction *tran, Error **errp)
 {
-    DriveBackupState *state = DO_UPCAST(DriveBackupState, common, common);
-    DriveBackup *backup;
+    DriveBackupState *state = g_new0(DriveBackupState, 1);
     BlockDriverState *bs;
     BlockDriverState *target_bs;
     BlockDriverState *source = NULL;
@@ -XXX,XX +XXX,XX @@ static void drive_backup_action(BlkActionState *common, Transaction *tran,
 
     tran_add(tran, &drive_backup_drv, state);
 
-    assert(common->action->type == TRANSACTION_ACTION_KIND_DRIVE_BACKUP);
-    backup = common->action->u.drive_backup.data;
-
     if (!backup->has_mode) {
         backup->mode = NEW_IMAGE_MODE_ABSOLUTE_PATHS;
     }
@@ -XXX,XX +XXX,XX @@ static void drive_backup_action(BlkActionState *common, Transaction *tran,
 
     state->job = do_backup_common(qapi_DriveBackup_base(backup),
                                   bs, target_bs, aio_context,
-                                  common->block_job_txn, errp);
+                                  block_job_txn, errp);
 
 unref:
     bdrv_unref(target_bs);
@@ -XXX,XX +XXX,XX @@ static void drive_backup_clean(void *opaque)
 }
 
 typedef struct BlockdevBackupState {
-    BlkActionState common;
     BlockDriverState *bs;
     BlockJob *job;
 } BlockdevBackupState;
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv blockdev_backup_drv = {
     .clean = blockdev_backup_clean,
 };
 
-static void blockdev_backup_action(BlkActionState *common, Transaction *tran,
-                                   Error **errp)
+static void blockdev_backup_action(BlockdevBackup *backup,
+                                   JobTxn *block_job_txn,
+                                   Transaction *tran, Error **errp)
 {
-    BlockdevBackupState *state = DO_UPCAST(BlockdevBackupState, common, common);
-    BlockdevBackup *backup;
+    BlockdevBackupState *state = g_new0(BlockdevBackupState, 1);
     BlockDriverState *bs;
     BlockDriverState *target_bs;
     AioContext *aio_context;
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_action(BlkActionState *common, Transaction *tran,
 
     tran_add(tran, &blockdev_backup_drv, state);
 
-    assert(common->action->type == TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP);
-    backup = common->action->u.blockdev_backup.data;
-
     bs = bdrv_lookup_bs(backup->device, backup->device, errp);
     if (!bs) {
         return;
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_action(BlkActionState *common, Transaction *tran,
 
     state->job = do_backup_common(qapi_BlockdevBackup_base(backup),
                                   bs, target_bs, aio_context,
-                                  common->block_job_txn, errp);
+                                  block_job_txn, errp);
 
     aio_context_release(aio_context);
 }
@@ -XXX,XX +XXX,XX @@ static void blockdev_backup_clean(void *opaque)
 }
 
 typedef struct BlockDirtyBitmapState {
-    BlkActionState common;
     BdrvDirtyBitmap *bitmap;
     BlockDriverState *bs;
     HBitmap *backup;
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_add_drv = {
     .clean = g_free,
 };
 
-static void block_dirty_bitmap_add_action(BlkActionState *common,
+static void block_dirty_bitmap_add_action(BlockDirtyBitmapAdd *action,
                                           Transaction *tran, Error **errp)
 {
     Error *local_err = NULL;
-    BlockDirtyBitmapAdd *action;
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
 
     tran_add(tran, &block_dirty_bitmap_add_drv, state);
 
-    action = common->action->u.block_dirty_bitmap_add.data;
     /* AIO context taken and released within qmp_block_dirty_bitmap_add */
     qmp_block_dirty_bitmap_add(action->node, action->name,
                                action->has_granularity, action->granularity,
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_clear_drv = {
     .clean = g_free,
 };
 
-static void block_dirty_bitmap_clear_action(BlkActionState *common,
+static void block_dirty_bitmap_clear_action(BlockDirtyBitmap *action,
                                             Transaction *tran, Error **errp)
 {
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
-    BlockDirtyBitmap *action;
+    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
 
     tran_add(tran, &block_dirty_bitmap_clear_drv, state);
 
-    action = common->action->u.block_dirty_bitmap_clear.data;
     state->bitmap = block_dirty_bitmap_lookup(action->node,
                                               action->name,
                                               &state->bs,
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_enable_drv = {
     .clean = g_free,
 };
 
-static void block_dirty_bitmap_enable_action(BlkActionState *common,
+static void block_dirty_bitmap_enable_action(BlockDirtyBitmap *action,
                                              Transaction *tran, Error **errp)
 {
-    BlockDirtyBitmap *action;
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
 
     tran_add(tran, &block_dirty_bitmap_enable_drv, state);
 
-    action = common->action->u.block_dirty_bitmap_enable.data;
     state->bitmap = block_dirty_bitmap_lookup(action->node,
                                               action->name,
                                               NULL,
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_disable_drv = {
     .clean = g_free,
 };
 
-static void block_dirty_bitmap_disable_action(BlkActionState *common,
+static void block_dirty_bitmap_disable_action(BlockDirtyBitmap *action,
                                               Transaction *tran, Error **errp)
 {
-    BlockDirtyBitmap *action;
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
 
     tran_add(tran, &block_dirty_bitmap_disable_drv, state);
 
-    action = common->action->u.block_dirty_bitmap_disable.data;
     state->bitmap = block_dirty_bitmap_lookup(action->node,
                                               action->name,
                                               NULL,
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_merge_drv = {
     .clean = g_free,
 };
 
-static void block_dirty_bitmap_merge_action(BlkActionState *common,
+static void block_dirty_bitmap_merge_action(BlockDirtyBitmapMerge *action,
                                             Transaction *tran, Error **errp)
 {
-    BlockDirtyBitmapMerge *action;
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
 
     tran_add(tran, &block_dirty_bitmap_merge_drv, state);
 
-    action = common->action->u.block_dirty_bitmap_merge.data;
-
     state->bitmap = block_dirty_bitmap_merge(action->node, action->target,
                                              action->bitmaps, &state->backup,
                                              errp);
@@ -XXX,XX +XXX,XX @@ TransactionActionDrv block_dirty_bitmap_remove_drv = {
     .clean = g_free,
 };
 
-static void block_dirty_bitmap_remove_action(BlkActionState *common,
+static void block_dirty_bitmap_remove_action(BlockDirtyBitmap *action,
                                              Transaction *tran, Error **errp)
 {
-    BlockDirtyBitmap *action;
-    BlockDirtyBitmapState *state = DO_UPCAST(BlockDirtyBitmapState,
-                                             common, common);
+    BlockDirtyBitmapState *state = g_new0(BlockDirtyBitmapState, 1);
 
     tran_add(tran, &block_dirty_bitmap_remove_drv, state);
 
-    action = common->action->u.block_dirty_bitmap_remove.data;
 
     state->bitmap = block_dirty_bitmap_remove(action->node, action->name,
                                               false, &state->bs, errp);
@@ -XXX,XX +XXX,XX @@ static void block_dirty_bitmap_remove_commit(void *opaque)
 static void abort_commit(void *opaque);
 TransactionActionDrv abort_drv = {
     .commit = abort_commit,
-    .clean = g_free,
 };
 
-static void abort_action(BlkActionState *common, Transaction *tran,
-                         Error **errp)
+static void abort_action(Transaction *tran, Error **errp)
 {
-    tran_add(tran, &abort_drv, common);
+    tran_add(tran, &abort_drv, NULL);
     error_setg(errp, "Transaction aborted using Abort action");
 }
 
@@ -XXX,XX +XXX,XX @@ static void abort_commit(void *opaque)
     g_assert_not_reached(); /* this action never succeeds */
 }
 
-static const BlkActionOps actions_map[] = {
-    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT] = {
-        .instance_size = sizeof(ExternalSnapshotState),
-        .action  = external_snapshot_action,
-    },
-    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC] = {
-        .instance_size = sizeof(ExternalSnapshotState),
-        .action  = external_snapshot_action,
-    },
-    [TRANSACTION_ACTION_KIND_DRIVE_BACKUP] = {
-        .instance_size = sizeof(DriveBackupState),
-        .action = drive_backup_action,
-    },
-    [TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP] = {
-        .instance_size = sizeof(BlockdevBackupState),
-        .action = blockdev_backup_action,
-    },
-    [TRANSACTION_ACTION_KIND_ABORT] = {
-        .instance_size = sizeof(BlkActionState),
-        .action = abort_action,
-    },
-    [TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC] = {
-        .instance_size = sizeof(InternalSnapshotState),
-        .action  = internal_snapshot_action,
-    },
-    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD] = {
-        .instance_size = sizeof(BlockDirtyBitmapState),
-        .action = block_dirty_bitmap_add_action,
-    },
-    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR] = {
-        .instance_size = sizeof(BlockDirtyBitmapState),
-        .action = block_dirty_bitmap_clear_action,
-    },
-    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE] = {
-        .instance_size = sizeof(BlockDirtyBitmapState),
-        .action = block_dirty_bitmap_enable_action,
-    },
-    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE] = {
-        .instance_size = sizeof(BlockDirtyBitmapState),
-        .action = block_dirty_bitmap_disable_action,
-    },
-    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE] = {
-        .instance_size = sizeof(BlockDirtyBitmapState),
-        .action = block_dirty_bitmap_merge_action,
-    },
-    [TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE] = {
-        .instance_size = sizeof(BlockDirtyBitmapState),
-        .action = block_dirty_bitmap_remove_action,
-    },
-    /* Where are transactions for MIRROR, COMMIT and STREAM?
+static void transaction_action(TransactionAction *act, JobTxn *block_job_txn,
+                               Transaction *tran, Error **errp)
+{
+    switch (act->type) {
+    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT:
+    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_SYNC:
+        external_snapshot_action(act, tran, errp);
+        return;
+    case TRANSACTION_ACTION_KIND_DRIVE_BACKUP:
+        drive_backup_action(act->u.drive_backup.data,
+                            block_job_txn, tran, errp);
+        return;
+    case TRANSACTION_ACTION_KIND_BLOCKDEV_BACKUP:
+        blockdev_backup_action(act->u.blockdev_backup.data,
+                               block_job_txn, tran, errp);
+        return;
+    case TRANSACTION_ACTION_KIND_ABORT:
+        abort_action(tran, errp);
+        return;
+    case TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC:
+        internal_snapshot_action(act->u.blockdev_snapshot_internal_sync.data,
+                                 tran, errp);
+        return;
+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ADD:
+        block_dirty_bitmap_add_action(act->u.block_dirty_bitmap_add.data,
+                                      tran, errp);
+        return;
+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_CLEAR:
+        block_dirty_bitmap_clear_action(act->u.block_dirty_bitmap_clear.data,
+                                        tran, errp);
+        return;
+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_ENABLE:
+        block_dirty_bitmap_enable_action(act->u.block_dirty_bitmap_enable.data,
+                                         tran, errp);
+        return;
+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_DISABLE:
+        block_dirty_bitmap_disable_action(
+                act->u.block_dirty_bitmap_disable.data, tran, errp);
+        return;
+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_MERGE:
+        block_dirty_bitmap_merge_action(act->u.block_dirty_bitmap_merge.data,
+                                        tran, errp);
+        return;
+    case TRANSACTION_ACTION_KIND_BLOCK_DIRTY_BITMAP_REMOVE:
+        block_dirty_bitmap_remove_action(act->u.block_dirty_bitmap_remove.data,
+                                         tran, errp);
+        return;
+    /*
+     * Where are transactions for MIRROR, COMMIT and STREAM?
      * Although these blockjobs use transaction callbacks like the backup job,
      * these jobs do not necessarily adhere to transaction semantics.
      * These jobs may not fully undo all of their actions on abort, nor do they
      * necessarily work in transactions with more than one job in them.
      */
-};
+    case TRANSACTION_ACTION_KIND__MAX:
+    default:
+        g_assert_not_reached();
+    };
+}
+
 
 /*
  * 'Atomic' group operations.  The operations are performed as a set, and if
@@ -XXX,XX +XXX,XX @@ void qmp_transaction(TransactionActionList *actions,
 
     /* We don't do anything in this loop that commits us to the operations */
     for (act = actions; act; act = act->next) {
-        TransactionAction *dev_info = act->value;
-        const BlkActionOps *ops;
-        BlkActionState *state;
-
-        assert(dev_info->type < ARRAY_SIZE(actions_map));
-
-        ops = &actions_map[dev_info->type];
-        assert(ops->instance_size > 0);
-
-        state = g_malloc0(ops->instance_size);
-        state->ops = ops;
-        state->action = dev_info;
-        state->block_job_txn = block_job_txn;
-
-        state->ops->action(state, tran, &local_err);
+        transaction_action(act->value, block_job_txn, tran, &local_err);
         if (local_err) {
             error_propagate(errp, local_err);
             goto delete_and_fail;
-- 
2.40.1

From: Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp>

"zlib" clusters are actually raw deflate (RFC1951) clusters without
zlib headers.

Signed-off-by: Akihiro Suda <akihiro.suda.cz@hco.ntt.co.jp>
Message-Id: <168424874322.11954.1340942046351859521-0@git.sr.ht>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 docs/interop/qcow2.txt | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
index XXXXXXX..XXXXXXX 100644
--- a/docs/interop/qcow2.txt
+++ b/docs/interop/qcow2.txt
@@ -XXX,XX +XXX,XX @@ version 2.
                     type.
 
                     If the incompatible bit "Compression type" is set: the field
-                    must be present and non-zero (which means non-zlib
+                    must be present and non-zero (which means non-deflate
                     compression type). Otherwise, this field must not be present
-                    or must be zero (which means zlib).
+                    or must be zero (which means deflate).
 
                     Available compression type values:
-                        0: zlib <https://www.zlib.net/>
+                        0: deflate <https://www.ietf.org/rfc/rfc1951.txt>
                         1: zstd <http://github.com/facebook/zstd>
 
+                    The deflate compression type is called "zlib"
+                    <https://www.zlib.net/> in QEMU. However, clusters with the
+                    deflate compression type do not have zlib headers.
+
 
 === Header padding ===
 
-- 
2.40.1

These are functions that modify the graph, so they must be able to take
a writer lock. This is impossible if they already hold the reader lock.
If they need a reader lock for some of their operations, they should
take it internally.

Many of them go through blk_*(), which will always take the lock itself.
Direct calls of bdrv_*() need to take the reader lock. Note that while
locking for bdrv_co_*() calls is checked by TSA, this is not the case
for the mixed_coroutine_fns bdrv_*(). Holding the lock is still required
when they are called from coroutine context like here!

This effectively reverts 4ec8df0183, but adds some internal locking
instead.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230510203601.418015-2-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block-global-state.h |  8 +++----
 include/block/block_int-common.h   |  4 ++--
 block.c                            |  1 -
 block/create.c                     |  1 -
 block/crypto.c                     | 25 ++++++++++----------
 block/parallels.c                  |  6 ++---
 block/qcow.c                       |  6 ++---
 block/qcow2.c                      | 37 +++++++++++++++++++-----------
 block/qed.c                        |  6 ++---
 block/raw-format.c                 |  2 +-
 block/vdi.c                        | 11 +++++----
 block/vhdx.c                       |  8 ++++---
 block/vmdk.c                       | 27 ++++++++++------------
 block/vpc.c                        |  6 ++---
 14 files changed, 78 insertions(+), 70 deletions(-)

diff --git a/include/block/block-global-state.h b/include/block/block-global-state.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-global-state.h
+++ b/include/block/block-global-state.h
@@ -XXX,XX +XXX,XX @@ BlockDriver *bdrv_find_protocol(const char *filename,
                                 Error **errp);
 BlockDriver *bdrv_find_format(const char *format_name);
 
-int coroutine_fn GRAPH_RDLOCK
+int coroutine_fn GRAPH_UNLOCKED
 bdrv_co_create(BlockDriver *drv, const char *filename, QemuOpts *opts,
                Error **errp);
 
-int co_wrapper_bdrv_rdlock bdrv_create(BlockDriver *drv, const char *filename,
-                                       QemuOpts *opts, Error **errp);
+int co_wrapper bdrv_create(BlockDriver *drv, const char *filename,
+                           QemuOpts *opts, Error **errp);
 
-int coroutine_fn GRAPH_RDLOCK
+int coroutine_fn GRAPH_UNLOCKED
 bdrv_co_create_file(const char *filename, QemuOpts *opts, Error **errp);
 
 BlockDriverState *bdrv_new(void);
diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int-common.h
+++ b/include/block/block_int-common.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
         BlockDriverState *bs, QDict *options, int flags, Error **errp);
     void (*bdrv_close)(BlockDriverState *bs);
 
-    int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_create)(
+    int coroutine_fn GRAPH_UNLOCKED_PTR (*bdrv_co_create)(
         BlockdevCreateOptions *opts, Error **errp);
 
-    int coroutine_fn GRAPH_RDLOCK_PTR (*bdrv_co_create_opts)(
+    int coroutine_fn GRAPH_UNLOCKED_PTR (*bdrv_co_create_opts)(
         BlockDriver *drv, const char *filename, QemuOpts *opts, Error **errp);
 
     int (*bdrv_amend_options)(BlockDriverState *bs,
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_create(BlockDriver *drv, const char *filename,
     int ret;
     GLOBAL_STATE_CODE();
     ERRP_GUARD();
-    assert_bdrv_graph_readable();
 
     if (!drv->bdrv_co_create_opts) {
         error_setg(errp, "Driver '%s' does not support image creation",
diff --git a/block/create.c b/block/create.c
index XXXXXXX..XXXXXXX 100644
--- a/block/create.c
+++ b/block/create.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn blockdev_create_run(Job *job, Error **errp)
     int ret;
 
     GLOBAL_STATE_CODE();
-    GRAPH_RDLOCK_GUARD();
 
     job_progress_set_remaining(&s->common, 1);
     ret = s->drv->bdrv_co_create(s->opts, errp);
diff --git a/block/crypto.c b/block/crypto.c
index XXXXXXX..XXXXXXX 100644
--- a/block/crypto.c
+++ b/block/crypto.c
@@ -XXX,XX +XXX,XX @@ struct BlockCryptoCreateData {
 };
 
 
-static int block_crypto_create_write_func(QCryptoBlock *block,
-                                          size_t offset,
-                                          const uint8_t *buf,
-                                          size_t buflen,
-                                          void *opaque,
-                                          Error **errp)
+static int coroutine_fn GRAPH_UNLOCKED
+block_crypto_create_write_func(QCryptoBlock *block, size_t offset,
+                               const uint8_t *buf, size_t buflen, void *opaque,
+                               Error **errp)
 {
     struct BlockCryptoCreateData *data = opaque;
     ssize_t ret;
@@ -XXX,XX +XXX,XX @@ static int block_crypto_create_write_func(QCryptoBlock *block,
     return 0;
 }
 
-static int block_crypto_create_init_func(QCryptoBlock *block,
-                                         size_t headerlen,
-                                         void *opaque,
-                                         Error **errp)
+static int coroutine_fn GRAPH_UNLOCKED
+block_crypto_create_init_func(QCryptoBlock *block, size_t headerlen,
+                              void *opaque, Error **errp)
 {
     struct BlockCryptoCreateData *data = opaque;
     Error *local_error = NULL;
@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_generic(QCryptoBlockFormat format,
 }
 
 
-static int coroutine_fn
+static int coroutine_fn GRAPH_UNLOCKED
 block_crypto_co_create_generic(BlockDriverState *bs, int64_t size,
                                QCryptoBlockCreateOptions *opts,
                                PreallocMode prealloc, Error **errp)
@@ -XXX,XX +XXX,XX @@ static int block_crypto_open_luks(BlockDriverState *bs,
                                      bs, options, flags, errp);
 }
 
-static int coroutine_fn
+static int coroutine_fn GRAPH_UNLOCKED
 block_crypto_co_create_luks(BlockdevCreateOptions *create_options, Error **errp)
 {
     BlockdevCreateOptionsLUKS *luks_opts;
@@ -XXX,XX +XXX,XX @@ fail:
     return ret;
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 block_crypto_co_create_opts_luks(BlockDriver *drv, const char *filename,
                                  QemuOpts *opts, Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ fail:
      * beforehand, it has been truncated and corrupted in the process.
      */
     if (ret) {
+        bdrv_graph_co_rdlock();
         bdrv_co_delete_file_noerr(bs);
+        bdrv_graph_co_rdunlock();
     }
 
     bdrv_co_unref(bs);
diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ out:
 }
 
 
-static int coroutine_fn parallels_co_create(BlockdevCreateOptions* opts,
-                                            Error **errp)
+static int coroutine_fn GRAPH_UNLOCKED
+parallels_co_create(BlockdevCreateOptions* opts, Error **errp)
 {
     BlockdevCreateOptionsParallels *parallels_opts;
     BlockDriverState *bs;
@@ -XXX,XX +XXX,XX @@ exit:
     goto out;
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 parallels_co_create_opts(BlockDriver *drv, const char *filename,
                          QemuOpts *opts, Error **errp)
 {
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ static void qcow_close(BlockDriverState *bs)
     error_free(s->migration_blocker);
 }
 
-static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,
-                                       Error **errp)
+static int coroutine_fn GRAPH_UNLOCKED
+qcow_co_create(BlockdevCreateOptions *opts, Error **errp)
 {
     BlockdevCreateOptionsQcow *qcow_opts;
     int header_size, backing_filename_len, l1_size, shift, i;
@@ -XXX,XX +XXX,XX @@ exit:
     return ret;
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 qcow_co_create_opts(BlockDriver *drv, const char *filename,
                     QemuOpts *opts, Error **errp)
 {
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_crypto_hdr_read_func(QCryptoBlock *block, size_t offset,
 }
 
 
-static int qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
-                                      void *opaque, Error **errp)
+static int coroutine_fn GRAPH_RDLOCK
+qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen, void *opaque,
+                           Error **errp)
 {
     BlockDriverState *bs = opaque;
     BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static int qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
      */
     clusterlen = size_to_clusters(s, headerlen) * s->cluster_size;
     assert(qcow2_pre_write_overlap_check(bs, 0, ret, clusterlen, false) == 0);
-    ret = bdrv_pwrite_zeroes(bs->file,
-                             ret,
-                             clusterlen, 0);
+    ret = bdrv_co_pwrite_zeroes(bs->file, ret, clusterlen, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not zero fill encryption header");
         return -1;
@@ -XXX,XX +XXX,XX @@ static int qcow2_crypto_hdr_init_func(QCryptoBlock *block, size_t headerlen,
 }
 
 
-static int qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
-                                       const uint8_t *buf, size_t buflen,
-                                       void *opaque, Error **errp)
+/* The graph lock must be held when called in coroutine context */
+static int coroutine_mixed_fn
+qcow2_crypto_hdr_write_func(QCryptoBlock *block, size_t offset,
+                            const uint8_t *buf, size_t buflen,
+                            void *opaque, Error **errp)
 {
     BlockDriverState *bs = opaque;
     BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static int qcow2_change_backing_file(BlockDriverState *bs,
     return qcow2_update_header(bs);
 }
 
-static int qcow2_set_up_encryption(BlockDriverState *bs,
-                                   QCryptoBlockCreateOptions *cryptoopts,
-                                   Error **errp)
+static int coroutine_fn GRAPH_RDLOCK
+qcow2_set_up_encryption(BlockDriverState *bs,
+                        QCryptoBlockCreateOptions *cryptoopts,
+                        Error **errp)
 {
     BDRVQcow2State *s = bs->opaque;
     QCryptoBlock *crypto = NULL;
@@ -XXX,XX +XXX,XX @@ static uint64_t qcow2_opt_get_refcount_bits_del(QemuOpts *opts, int version,
     return refcount_bits;
 }
 
-static int coroutine_fn
+static int coroutine_fn GRAPH_UNLOCKED
 qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
 {
     BlockdevCreateOptionsQcow2 *qcow2_opts;
@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
         goto out;
     }
 
+    bdrv_graph_co_rdlock();
     ret = qcow2_alloc_clusters(blk_bs(blk), 3 * cluster_size);
     if (ret < 0) {
+        bdrv_graph_co_rdunlock();
         error_setg_errno(errp, -ret, "Could not allocate clusters for qcow2 "
                          "header and refcount table");
         goto out;
@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
 
     /* Create a full header (including things like feature table) */
     ret = qcow2_update_header(blk_bs(blk));
+    bdrv_graph_co_rdunlock();
+
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Could not update qcow2 header");
         goto out;
@@ -XXX,XX +XXX,XX @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp)
 
     /* Want encryption? There you go. */
     if (qcow2_opts->encrypt) {
+        bdrv_graph_co_rdlock();
         ret = qcow2_set_up_encryption(blk_bs(blk), qcow2_opts->encrypt, errp);
+        bdrv_graph_co_rdunlock();
+
         if (ret < 0) {
             goto out;
         }
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 qcow2_co_create_opts(BlockDriver *drv, const char *filename, QemuOpts *opts,
                      Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ qcow2_co_create_opts(BlockDriver *drv, const char *filename, QemuOpts *opts,
     ret = qcow2_co_create(create_options, errp);
 finish:
     if (ret < 0) {
+        bdrv_graph_co_rdlock();
         bdrv_co_delete_file_noerr(bs);
         bdrv_co_delete_file_noerr(data_bs);
+        bdrv_graph_co_rdunlock();
     } else {
         ret = 0;
     }
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_qed_close(BlockDriverState *bs)
     qemu_vfree(s->l1_table);
 }
 
-static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,
-                                           Error **errp)
+static int coroutine_fn GRAPH_UNLOCKED
+bdrv_qed_co_create(BlockdevCreateOptions *opts, Error **errp)
 {
     BlockdevCreateOptionsQed *qed_opts;
     BlockBackend *blk = NULL;
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 bdrv_qed_co_create_opts(BlockDriver *drv, const char *filename,
                         QemuOpts *opts, Error **errp)
 {
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int raw_has_zero_init(BlockDriverState *bs)
     return bdrv_has_zero_init(bs->file->bs);
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 raw_co_create_opts(BlockDriver *drv, const char *filename,
                    QemuOpts *opts, Error **errp)
 {
diff --git a/block/vdi.c b/block/vdi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vdi.c
+++ b/block/vdi.c
@@ -XXX,XX +XXX,XX @@ nonallocating_write:
     return ret;
 }
 
-static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options,
-                                         size_t block_size, Error **errp)
+static int coroutine_fn GRAPH_UNLOCKED
+vdi_co_do_create(BlockdevCreateOptions *create_options, size_t block_size,
+                 Error **errp)
 {
     BlockdevCreateOptionsVdi *vdi_opts;
     int ret = 0;
@@ -XXX,XX +XXX,XX @@ exit:
     return ret;
 }
 
-static int coroutine_fn vdi_co_create(BlockdevCreateOptions *create_options,
-                                      Error **errp)
+static int coroutine_fn GRAPH_UNLOCKED
+vdi_co_create(BlockdevCreateOptions *create_options, Error **errp)
 {
     return vdi_co_do_create(create_options, DEFAULT_CLUSTER_SIZE, errp);
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 vdi_co_create_opts(BlockDriver *drv, const char *filename,
                    QemuOpts *opts, Error **errp)
 {
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ exit:
  * There are 2 headers, and the highest sequence number will represent
  * the active header
  */
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 vhdx_create_new_headers(BlockBackend *blk, uint64_t image_size,
                         uint32_t log_size)
 {
@@ -XXX,XX +XXX,XX @@ vhdx_create_new_headers(BlockBackend *blk, uint64_t image_size,
     int ret = 0;
     VHDXHeader *hdr = NULL;
 
+    GRAPH_RDLOCK_GUARD();
+
     hdr = g_new0(VHDXHeader, 1);
 
     hdr->signature       = VHDX_HEADER_SIGNATURE;
@@ -XXX,XX +XXX,XX @@ exit:
  *    .---- ~ ----------- ~ ------------ ~ ---------------- ~ -----------.
  *   1MB
  */
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 vhdx_co_create(BlockdevCreateOptions *opts, Error **errp)
 {
     BlockdevCreateOptionsVhdx *vhdx_opts;
@@ -XXX,XX +XXX,XX @@ delete_and_exit:
     return ret;
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 vhdx_co_create_opts(BlockDriver *drv, const char *filename,
                     QemuOpts *opts, Error **errp)
 {
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ vmdk_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
     return ret;
 }
 
-static int vmdk_init_extent(BlockBackend *blk,
-                            int64_t filesize, bool flat,
-                            bool compress, bool zeroed_grain,
-                            Error **errp)
+static int GRAPH_UNLOCKED
+vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
+                 bool zeroed_grain, Error **errp)
 {
     int ret, i;
     VMDK4Header header;
@@ -XXX,XX +XXX,XX @@ exit:
     return ret;
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 vmdk_create_extent(const char *filename, int64_t filesize, bool flat,
                    bool compress, bool zeroed_grain, BlockBackend **pbb,
                    QemuOpts *opts, Error **errp)
@@ -XXX,XX +XXX,XX @@ static int filename_decompose(const char *filename, char *path, char *prefix,
  *           non-split format.
  * idx >= 1: get the n-th extent if in a split subformat
  */
-typedef BlockBackend * coroutine_fn /* GRAPH_RDLOCK */
+typedef BlockBackend * coroutine_fn GRAPH_UNLOCKED_PTR
     (*vmdk_create_extent_fn)(int64_t size, int idx, bool flat, bool split,
                              bool compress, bool zeroed_grain, void *opaque,
                              Error **errp);
@@ -XXX,XX +XXX,XX @@ static void vmdk_desc_add_extent(GString *desc,
     g_free(basename);
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 vmdk_co_do_create(int64_t size,
                   BlockdevVmdkSubformat subformat,
                   BlockdevVmdkAdapterType adapter_type,
@@ -XXX,XX +XXX,XX @@ typedef struct {
     QemuOpts *opts;
 } VMDKCreateOptsData;
 
-static BlockBackend * coroutine_fn GRAPH_RDLOCK
+static BlockBackend * coroutine_fn GRAPH_UNLOCKED
 vmdk_co_create_opts_cb(int64_t size, int idx, bool flat, bool split,
                        bool compress, bool zeroed_grain, void *opaque,
                        Error **errp)
@@ -XXX,XX +XXX,XX @@ exit:
     return blk;
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 vmdk_co_create_opts(BlockDriver *drv, const char *filename,
                     QemuOpts *opts, Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ exit:
     return ret;
 }
 
-static BlockBackend * coroutine_fn vmdk_co_create_cb(int64_t size, int idx,
-                                                     bool flat, bool split,
-                                                     bool compress,
-                                                     bool zeroed_grain,
-                                                     void *opaque, Error **errp)
+static BlockBackend * coroutine_fn GRAPH_UNLOCKED
+vmdk_co_create_cb(int64_t size, int idx, bool flat, bool split, bool compress,
+                  bool zeroed_grain, void *opaque, Error **errp)
 {
     int ret;
     BlockDriverState *bs;
@@ -XXX,XX +XXX,XX @@ static BlockBackend * coroutine_fn vmdk_co_create_cb(int64_t size, int idx,
     return blk;
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 vmdk_co_create(BlockdevCreateOptions *create_options, Error **errp)
 {
     BlockdevCreateOptionsVmdk *opts;
diff --git a/block/vpc.c b/block/vpc.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vpc.c
+++ b/block/vpc.c
@@ -XXX,XX +XXX,XX @@ static int calculate_rounded_image_size(BlockdevCreateOptionsVpc *vpc_opts,
     return 0;
 }
 
-static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,
-                                      Error **errp)
+static int coroutine_fn GRAPH_UNLOCKED
+vpc_co_create(BlockdevCreateOptions *opts, Error **errp)
 {
     BlockdevCreateOptionsVpc *vpc_opts;
     BlockBackend *blk = NULL;
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
-static int coroutine_fn GRAPH_RDLOCK
+static int coroutine_fn GRAPH_UNLOCKED
 vpc_co_create_opts(BlockDriver *drv, const char *filename,
                    QemuOpts *opts, Error **errp)
 {
-- 
2.40.1

There are some error paths in blk_exp_add() that jump to 'fail:' before
'exp' is even created. So we can't just unconditionally access exp->blk.

Add a NULL check, and switch from exp->blk to blk, which is available
earlier, just to be extra sure that we really cover all cases where
BlockDevOps could have been set for it (in practice, this only happens
in drv->create() today, so this part of the change isn't strictly
necessary).

Fixes: Coverity CID 1509238
Fixes: de79b52604e43fdeba6cee4f5af600b62169f2d2
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230510203601.418015-3-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Tested-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/export/export.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/block/export/export.c b/block/export/export.c
index XXXXXXX..XXXXXXX 100644
--- a/block/export/export.c
+++ b/block/export/export.c
@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
     return exp;
 
 fail:
-    blk_set_dev_ops(exp->blk, NULL, NULL);
-    blk_unref(blk);
+    if (blk) {
+        blk_set_dev_ops(blk, NULL, NULL);
+        blk_unref(blk);
+    }
     aio_context_release(ctx);
     if (exp) {
         g_free(exp->id);
-- 
2.40.1

qcow2_do_open() calls a few no_co_wrappers that wrap functions taking
the graph lock internally as a writer. Therefore, it can't hold the
reader lock across these calls, it causes deadlocks. Drop the lock
temporarily around the calls.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230510203601.418015-4-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
 
     if (open_data_file) {
         /* Open external data file */
+        bdrv_graph_co_rdunlock();
         s->data_file = bdrv_co_open_child(NULL, options, "data-file", bs,
                                           &child_of_bds, BDRV_CHILD_DATA,
                                           true, errp);
+        bdrv_graph_co_rdlock();
         if (*errp) {
             ret = -EINVAL;
             goto fail;
@@ -XXX,XX +XXX,XX @@ qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
 
         if (s->incompatible_features & QCOW2_INCOMPAT_DATA_FILE) {
             if (!s->data_file && s->image_data_file) {
+                bdrv_graph_co_rdunlock();
                 s->data_file = bdrv_co_open_child(s->image_data_file, options,
                                                   "data-file", bs,
                                                   &child_of_bds,
                                                   BDRV_CHILD_DATA, false, errp);
+                bdrv_graph_co_rdlock();
                 if (!s->data_file) {
                     ret = -EINVAL;
                     goto fail;
@@ -XXX,XX +XXX,XX @@ qcow2_do_open(BlockDriverState *bs, QDict *options, int flags,
  fail:
     g_free(s->image_data_file);
     if (open_data_file && has_data_file(bs)) {
+        bdrv_graph_co_rdunlock();
         bdrv_unref_child(bs, s->data_file);
+        bdrv_graph_co_rdlock();
         s->data_file = NULL;
     }
     g_free(s->unknown_header_fields);
-- 
2.40.1

If we take a reader lock, we can't call any functions that take a writer
lock internally without causing deadlocks once the reader lock is
actually enforced in the main thread, too. Take the reader lock only
where it is actually needed.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230510203601.418015-5-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qemu-img.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

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 BlockGraphInfoList *collect_image_info_list(bool image_opts,
         }
         bs = blk_bs(blk);
 
-        GRAPH_RDLOCK_GUARD_MAINLOOP();
-
         /*
          * Note that the returned BlockGraphInfo object will not have
          * information about this image's backing node, because we have opened
@@ -XXX,XX +XXX,XX @@ static BlockGraphInfoList *collect_image_info_list(bool image_opts,
          * duplicate the backing chain information that we obtain by walking
          * the chain manually here.
          */
+        bdrv_graph_rdlock_main_loop();
         bdrv_query_block_graph_info(bs, &info, &err);
+        bdrv_graph_rdunlock_main_loop();
+
         if (err) {
             error_report_err(err);
             blk_unref(blk);
-- 
2.40.1

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230510203601.418015-6-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/unit/test-bdrv-drain.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/unit/test-bdrv-drain.c b/tests/unit/test-bdrv-drain.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-bdrv-drain.c
+++ b/tests/unit/test-bdrv-drain.c
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn test_co_delete_by_drain(void *opaque)
     void *buffer = g_malloc(65536);
     QEMUIOVector qiov = QEMU_IOVEC_INIT_BUF(qiov, buffer, 65536);
 
-    GRAPH_RDLOCK_GUARD();
-
     /* Pretend some internal write operation from parent to child.
      * Important: We have to read from the child, not from the parent!
      * Draining works by first propagating it all up the tree to the
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn test_co_delete_by_drain(void *opaque)
      * everything will be drained before we go back down the tree, but
      * we do not want that.  We want to be in the middle of draining
      * when this following requests returns. */
+    bdrv_graph_co_rdlock();
     bdrv_co_preadv(tts->wait_child, 0, 65536, &qiov, 0);
+    bdrv_graph_co_rdunlock();
 
     g_assert_cmpint(bs->refcnt, ==, 1);
 
-- 
2.40.1

When jobs are sleeping, for example to enforce a given rate limit, they
can be reentered early, in particular in order to get paused, to update
the rate limit or to get cancelled.

Before this patch, they behave in this case as if they had fully
completed their rate limiting delay. This means that requests are sped
up beyond their limit, violating the constraints that the user gave us.

Change the block jobs to sleep in a loop until the necessary delay is
completed, while still allowing cancelling them immediately as well
pausing (handled by the pause point in job_sleep_ns()) and updating the
rate limit.

This change is also motivated by iotests cases being prone to fail
because drain operations pause and unpause them so often that block jobs
complete earlier than they are supposed to. In particular, the next
commit would fail iotests 030 without this change.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230510203601.418015-8-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/blockjob_int.h | 14 ++++++++++----
 block/commit.c               |  7 ++-----
 block/mirror.c               | 23 ++++++++++-------------
 block/stream.c               |  7 ++-----
 blockjob.c                   | 22 ++++++++++++++++++++--
 5 files changed, 44 insertions(+), 29 deletions(-)

diff --git a/include/block/blockjob_int.h b/include/block/blockjob_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/blockjob_int.h
+++ b/include/block/blockjob_int.h
@@ -XXX,XX +XXX,XX @@ void block_job_user_resume(Job *job);
  */
 
 /**
- * block_job_ratelimit_get_delay:
+ * block_job_ratelimit_processed_bytes:
  *
- * Calculate and return delay for the next request in ns. See the documentation
- * of ratelimit_calculate_delay() for details.
+ * To be called after some work has been done. Adjusts the delay for the next
+ * request. See the documentation of ratelimit_calculate_delay() for details.
  */
-int64_t block_job_ratelimit_get_delay(BlockJob *job, uint64_t n);
+void block_job_ratelimit_processed_bytes(BlockJob *job, uint64_t n);
+
+/**
+ * Put the job to sleep (assuming that it wasn't canceled) to throttle it to the
+ * right speed according to its rate limiting.
+ */
+void block_job_ratelimit_sleep(BlockJob *job);
 
 /**
  * block_job_error_action:
diff --git a/block/commit.c b/block/commit.c
index XXXXXXX..XXXXXXX 100644
--- a/block/commit.c
+++ b/block/commit.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
 {
     CommitBlockJob *s = container_of(job, CommitBlockJob, common.job);
     int64_t offset;
-    uint64_t delay_ns = 0;
     int ret = 0;
     int64_t n = 0; /* bytes */
     QEMU_AUTO_VFREE void *buf = NULL;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
         /* Note that even when no rate limit is applied we need to yield
          * with no pending I/O here so that bdrv_drain_all() returns.
          */
-        job_sleep_ns(&s->common.job, delay_ns);
+        block_job_ratelimit_sleep(&s->common);
         if (job_is_cancelled(&s->common.job)) {
             break;
         }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn commit_run(Job *job, Error **errp)
         job_progress_update(&s->common.job, n);
 
         if (copy) {
-            delay_ns = block_job_ratelimit_get_delay(&s->common, n);
-        } else {
-            delay_ns = 0;
+            block_job_ratelimit_processed_bytes(&s->common, n);
         }
     }
 
diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static unsigned mirror_perform(MirrorBlockJob *s, int64_t offset,
     return bytes_handled;
 }
 
-static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s)
+static void coroutine_fn mirror_iteration(MirrorBlockJob *s)
 {
     BlockDriverState *source = s->mirror_top_bs->backing->bs;
     MirrorOp *pseudo_op;
     int64_t offset;
-    uint64_t delay_ns = 0, ret = 0;
     /* At least the first dirty chunk is mirrored in one iteration. */
     int nb_chunks = 1;
     bool write_zeroes_ok = bdrv_can_write_zeroes_with_unmap(blk_bs(s->target));
@@ -XXX,XX +XXX,XX @@ static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s)
         assert(io_bytes);
         offset += io_bytes;
         nb_chunks -= DIV_ROUND_UP(io_bytes, s->granularity);
-        delay_ns = block_job_ratelimit_get_delay(&s->common, io_bytes_acct);
+        block_job_ratelimit_processed_bytes(&s->common, io_bytes_acct);
     }
 
-    ret = delay_ns;
 fail:
     QTAILQ_REMOVE(&s->ops_in_flight, pseudo_op, next);
     qemu_co_queue_restart_all(&pseudo_op->waiting_requests);
     g_free(pseudo_op);
-
-    return ret;
 }
 
 static void mirror_free_init(MirrorBlockJob *s)
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
     assert(!s->dbi);
     s->dbi = bdrv_dirty_iter_new(s->dirty_bitmap);
     for (;;) {
-        uint64_t delay_ns = 0;
         int64_t cnt, delta;
         bool should_complete;
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
                 mirror_wait_for_free_in_flight_slot(s);
                 continue;
             } else if (cnt != 0) {
-                delay_ns = mirror_iteration(s);
+                mirror_iteration(s);
             }
         }
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
         }
 
         if (job_is_ready(&s->common.job) && !should_complete) {
-            delay_ns = (s->in_flight == 0 &&
-                        cnt == 0 ? BLOCK_JOB_SLICE_TIME : 0);
+            if (s->in_flight == 0 && cnt == 0) {
+                trace_mirror_before_sleep(s, cnt, job_is_ready(&s->common.job),
+                                          BLOCK_JOB_SLICE_TIME);
+                job_sleep_ns(&s->common.job, BLOCK_JOB_SLICE_TIME);
+            }
+        } else {
+            block_job_ratelimit_sleep(&s->common);
         }
-        trace_mirror_before_sleep(s, cnt, job_is_ready(&s->common.job),
-                                  delay_ns);
-        job_sleep_ns(&s->common.job, delay_ns);
         s->last_pause_ns = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
     }
 
diff --git a/block/stream.c b/block/stream.c
index XXXXXXX..XXXXXXX 100644
--- a/block/stream.c
+++ b/block/stream.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_run(Job *job, Error **errp)
     BlockDriverState *unfiltered_bs = bdrv_skip_filters(s->target_bs);
     int64_t len;
     int64_t offset = 0;
-    uint64_t delay_ns = 0;
     int error = 0;
     int64_t n = 0; /* bytes */
 
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_run(Job *job, Error **errp)
         /* Note that even when no rate limit is applied we need to yield
          * with no pending I/O here so that bdrv_drain_all() returns.
          */
-        job_sleep_ns(&s->common.job, delay_ns);
+        block_job_ratelimit_sleep(&s->common);
         if (job_is_cancelled(&s->common.job)) {
             break;
         }
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn stream_run(Job *job, Error **errp)
         /* Publish progress */
         job_progress_update(&s->common.job, n);
         if (copy) {
-            delay_ns = block_job_ratelimit_get_delay(&s->common, n);
-        } else {
-            delay_ns = 0;
+            block_job_ratelimit_processed_bytes(&s->common, n);
         }
     }
 
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static bool block_job_set_speed(BlockJob *job, int64_t speed, Error **errp)
     return block_job_set_speed_locked(job, speed, errp);
 }
 
-int64_t block_job_ratelimit_get_delay(BlockJob *job, uint64_t n)
+void block_job_ratelimit_processed_bytes(BlockJob *job, uint64_t n)
 {
     IO_CODE();
-    return ratelimit_calculate_delay(&job->limit, n);
+    ratelimit_calculate_delay(&job->limit, n);
+}
+
+void block_job_ratelimit_sleep(BlockJob *job)
+{
+    uint64_t delay_ns;
+
+    /*
+     * Sleep at least once. If the job is reentered early, keep waiting until
+     * we've waited for the full time that is necessary to keep the job at the
+     * right speed.
+     *
+     * Make sure to recalculate the delay after each (possibly interrupted)
+     * sleep because the speed can change while the job has yielded.
+     */
+    do {
+        delay_ns = ratelimit_calculate_delay(&job->limit, 0);
+        job_sleep_ns(&job->job, delay_ns);
+    } while (delay_ns && !job_is_cancelled(&job->job));
 }
 
 BlockJobInfo *block_job_query_locked(BlockJob *job, Error **errp)
-- 
2.40.1

There are some conditions under which we don't actually need to do
anything for taking a reader lock: Writing the graph is only possible
from the main context while holding the BQL. So if a reader is running
in the main context under the BQL and knows that it won't be interrupted
until the next writer runs, we don't actually need to do anything.

This is the case if the reader code neither has a nested event loop
(this is forbidden anyway while you hold the lock) nor is a coroutine
(because a writer could run when the coroutine has yielded).

These conditions are exactly what bdrv_graph_rdlock_main_loop() asserts.
They are not fulfilled in bdrv_graph_co_rdlock(), which always runs in a
coroutine.

This deletes the shortcuts in bdrv_graph_co_rdlock() that skip taking
the reader lock in the main thread.

Reported-by: Fiona Ebner <f.ebner@proxmox.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230510203601.418015-9-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/graph-lock.c | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/block/graph-lock.c b/block/graph-lock.c
index XXXXXXX..XXXXXXX 100644
--- a/block/graph-lock.c
+++ b/block/graph-lock.c
@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_graph_co_rdlock(void)
     BdrvGraphRWlock *bdrv_graph;
     bdrv_graph = qemu_get_current_aio_context()->bdrv_graph;
 
-    /* Do not lock if in main thread */
-    if (qemu_in_main_thread()) {
-        return;
-    }
-
     for (;;) {
         qatomic_set(&bdrv_graph->reader_count,
                     bdrv_graph->reader_count + 1);
@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_graph_co_rdunlock(void)
     BdrvGraphRWlock *bdrv_graph;
     bdrv_graph = qemu_get_current_aio_context()->bdrv_graph;
 
-    /* Do not lock if in main thread */
-    if (qemu_in_main_thread()) {
-        return;
-    }
-
     qatomic_store_release(&bdrv_graph->reader_count,
                           bdrv_graph->reader_count - 1);
     /* make sure writer sees reader_count before we check has_writer */
-- 
2.40.1

Skip TestBlockdevReopen.test_insert_compress_filter() if the 'compress'
driver isn't available.

In order to make the test succeed when the case is skipped, we also need
to remove any output from it (which would be missing in the case where
we skip it). This is done by replacing qemu_io_log() with qemu_io(). In
case of failure, qemu_io() raises an exception with the output of the
qemu-io binary in its message, so we don't actually lose anything.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20230511143801.255021-1-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/245     | 7 ++++---
 tests/qemu-iotests/245.out | 9 +--------
 2 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/tests/qemu-iotests/245 b/tests/qemu-iotests/245
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/245
+++ b/tests/qemu-iotests/245
@@ -XXX,XX +XXX,XX @@ class TestBlockdevReopen(iotests.QMPTestCase):
         self.reopen(hd0_opts, {'file': 'hd0-file'})
 
     # Insert (and remove) a compress filter
+    @iotests.skip_if_unsupported(['compress'])
     def test_insert_compress_filter(self):
         # Add an image to the VM: hd (raw) -> hd0 (qcow2) -> hd0-file (file)
         opts = {'driver': 'raw', 'node-name': 'hd', 'file': hd_opts(0)}
@@ -XXX,XX +XXX,XX @@ class TestBlockdevReopen(iotests.QMPTestCase):
 
         # Check the first byte of the first three L2 entries and verify that
         # the second one is compressed (0x40) while the others are not (0x80)
-        iotests.qemu_io_log('-f', 'raw', '-c', 'read -P 0x80 0x40000 1',
-                                         '-c', 'read -P 0x40 0x40008 1',
-                                         '-c', 'read -P 0x80 0x40010 1', hd_path[0])
+        iotests.qemu_io('-f', 'raw', '-c', 'read -P 0x80 0x40000 1',
+                                     '-c', 'read -P 0x40 0x40008 1',
+                                     '-c', 'read -P 0x80 0x40010 1', hd_path[0])
 
     # Swap the disk images of two active block devices
     def test_swap_files(self):
diff --git a/tests/qemu-iotests/245.out b/tests/qemu-iotests/245.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/245.out
+++ b/tests/qemu-iotests/245.out
@@ -XXX,XX +XXX,XX @@
 {"return": {}}
 {"data": {"id": "stream0", "type": "stream"}, "event": "BLOCK_JOB_PENDING", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 {"data": {"device": "stream0", "len": 3145728, "offset": 3145728, "speed": 0, "type": "stream"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
-....read 1/1 bytes at offset 262144
-1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-read 1/1 bytes at offset 262152
-1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-read 1/1 bytes at offset 262160
-1 bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-
-................
+....................
 ----------------------------------------------------------------------
 Ran 26 tests
 
-- 
2.40.1

From: Stefan Hajnoczi <stefanha@redhat.com>

QEMU's event loop supports nesting, which means that event handler
functions may themselves call aio_poll(). The condition that triggered a
handler must be reset before the nested aio_poll() call, otherwise the
same handler will be called and immediately re-enter aio_poll. This
leads to an infinite loop and stack exhaustion.

Poll handlers are especially prone to this issue, because they typically
reset their condition by finishing the processing of pending work.
Unfortunately it is during the processing of pending work that nested
aio_poll() calls typically occur and the condition has not yet been
reset.

Disable a poll handler during ->io_poll_ready() so that a nested
aio_poll() call cannot invoke ->io_poll_ready() again. As a result, the
disabled poll handler and its associated fd handler do not run during
the nested aio_poll(). Calling aio_set_fd_handler() from inside nested
aio_poll() could cause it to run again. If the fd handler is pending
inside nested aio_poll(), then it will also run again.

In theory fd handlers can be affected by the same issue, but they are
more likely to reset the condition before calling nested aio_poll().

This is a special case and it's somewhat complex, but I don't see a way
around it as long as nested aio_poll() is supported.

Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=2186181
Fixes: c38270692593 ("block: Mark bdrv_co_io_(un)plug() and callers GRAPH_RDLOCK")
Cc: Kevin Wolf <kwolf@redhat.com>
Cc: Emanuele Giuseppe Esposito <eesposit@redhat.com>
Cc: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20230502184134.534703-2-stefanha@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 util/aio-posix.c | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/util/aio-posix.c b/util/aio-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/util/aio-posix.c
+++ b/util/aio-posix.c
@@ -XXX,XX +XXX,XX @@ static bool aio_dispatch_handler(AioContext *ctx, AioHandler *node)
         poll_ready && revents == 0 &&
         aio_node_check(ctx, node->is_external) &&
         node->io_poll_ready) {
+        /*
+         * Remove temporarily to avoid infinite loops when ->io_poll_ready()
+         * calls aio_poll() before clearing the condition that made the poll
+         * handler become ready.
+         */
+        QLIST_SAFE_REMOVE(node, node_poll);
+
         node->io_poll_ready(node->opaque);
 
+        if (!QLIST_IS_INSERTED(node, node_poll)) {
+            QLIST_INSERT_HEAD(&ctx->poll_aio_handlers, node, node_poll);
+        }
+
         /*
          * Return early since revents was zero. aio_notify() does not count as
          * progress.
-- 
2.40.1

From: Stefan Hajnoczi <stefanha@redhat.com>

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20230502184134.534703-3-stefanha@redhat.com>
Tested-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/unit/test-nested-aio-poll.c | 130 ++++++++++++++++++++++++++++++
 tests/unit/meson.build            |   1 +
 2 files changed, 131 insertions(+)
 create mode 100644 tests/unit/test-nested-aio-poll.c

diff --git a/tests/unit/test-nested-aio-poll.c b/tests/unit/test-nested-aio-poll.c
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/unit/test-nested-aio-poll.c
@@ -XXX,XX +XXX,XX @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/*
+ * Test that poll handlers are not re-entrant in nested aio_poll()
+ *
+ * Copyright Red Hat
+ *
+ * Poll handlers are usually level-triggered. That means they continue firing
+ * until the condition is reset (e.g. a virtqueue becomes empty). If a poll
+ * handler calls nested aio_poll() before the condition is reset, then infinite
+ * recursion occurs.
+ *
+ * aio_poll() is supposed to prevent this by disabling poll handlers in nested
+ * aio_poll() calls. This test case checks that this is indeed what happens.
+ */
+#include "qemu/osdep.h"
+#include "block/aio.h"
+#include "qapi/error.h"
+
+typedef struct {
+    AioContext *ctx;
+
+    /* This is the EventNotifier that drives the test */
+    EventNotifier poll_notifier;
+
+    /* This EventNotifier is only used to wake aio_poll() */
+    EventNotifier dummy_notifier;
+
+    bool nested;
+} TestData;
+
+static void io_read(EventNotifier *notifier)
+{
+    fprintf(stderr, "%s %p\n", __func__, notifier);
+    event_notifier_test_and_clear(notifier);
+}
+
+static bool io_poll_true(void *opaque)
+{
+    fprintf(stderr, "%s %p\n", __func__, opaque);
+    return true;
+}
+
+static bool io_poll_false(void *opaque)
+{
+    fprintf(stderr, "%s %p\n", __func__, opaque);
+    return false;
+}
+
+static void io_poll_ready(EventNotifier *notifier)
+{
+    TestData *td = container_of(notifier, TestData, poll_notifier);
+
+    fprintf(stderr, "> %s\n", __func__);
+
+    g_assert(!td->nested);
+    td->nested = true;
+
+    /* Wake the following nested aio_poll() call */
+    event_notifier_set(&td->dummy_notifier);
+
+    /* This nested event loop must not call io_poll()/io_poll_ready() */
+    g_assert(aio_poll(td->ctx, true));
+
+    td->nested = false;
+
+    fprintf(stderr, "< %s\n", __func__);
+}
+
+/* dummy_notifier never triggers */
+static void io_poll_never_ready(EventNotifier *notifier)
+{
+    g_assert_not_reached();
+}
+
+static void test(void)
+{
+    TestData td = {
+        .ctx = aio_context_new(&error_abort),
+    };
+
+    qemu_set_current_aio_context(td.ctx);
+
+    /* Enable polling */
+    aio_context_set_poll_params(td.ctx, 1000000, 2, 2, &error_abort);
+
+    /*
+     * The GSource is unused but this has the side-effect of changing the fdmon
+     * that AioContext uses.
+     */
+    aio_get_g_source(td.ctx);
+
+    /* Make the event notifier active (set) right away */
+    event_notifier_init(&td.poll_notifier, 1);
+    aio_set_event_notifier(td.ctx, &td.poll_notifier, false,
+                           io_read, io_poll_true, io_poll_ready);
+
+    /* This event notifier will be used later */
+    event_notifier_init(&td.dummy_notifier, 0);
+    aio_set_event_notifier(td.ctx, &td.dummy_notifier, false,
+                           io_read, io_poll_false, io_poll_never_ready);
+
+    /* Consume aio_notify() */
+    g_assert(!aio_poll(td.ctx, false));
+
+    /*
+     * Run the io_read() handler. This has the side-effect of activating
+     * polling in future aio_poll() calls.
+     */
+    g_assert(aio_poll(td.ctx, true));
+
+    /* The second time around the io_poll()/io_poll_ready() handler runs */
+    g_assert(aio_poll(td.ctx, true));
+
+    /* Run io_poll()/io_poll_ready() one more time to show it keeps working */
+    g_assert(aio_poll(td.ctx, true));
+
+    aio_set_event_notifier(td.ctx, &td.dummy_notifier, false,
+                           NULL, NULL, NULL);
+    aio_set_event_notifier(td.ctx, &td.poll_notifier, false, NULL, NULL, NULL);
+    event_notifier_cleanup(&td.dummy_notifier);
+    event_notifier_cleanup(&td.poll_notifier);
+    aio_context_unref(td.ctx);
+}
+
+int main(int argc, char **argv)
+{
+    g_test_init(&argc, &argv, NULL);
+    g_test_add_func("/nested-aio-poll", test);
+    return g_test_run();
+}
diff --git a/tests/unit/meson.build b/tests/unit/meson.build
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/meson.build
+++ b/tests/unit/meson.build
@@ -XXX,XX +XXX,XX @@ if have_block
     'test-coroutine': [testblock],
     'test-aio': [testblock],
     'test-aio-multithread': [testblock],
+    'test-nested-aio-poll': [testblock],
     'test-throttle': [testblock],
     'test-thread-pool': [testblock],
     'test-hbitmap': [testblock],
-- 
2.40.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