Series comparison

-[PULL 00/13] Block layer patches
+[PULL 00/25] Block layer patches
-The following changes since commit ba29883206d92a29ad5a466e679ccfc2ee6132ef:
+The following changes since commit d922088eb4ba6bc31a99f17b32cf75e59dd306cd:
-  Merge remote-tracking branch 'remotes/borntraeger/tags/s390x-20200310' into staging (2020-03-10 16:50:28 +0000)
+  Merge tag 'ui-pull-request' of https://gitlab.com/marcandre.lureau/qemu into staging (2025-02-03 13:42:02 -0500)
 are available in the Git repository at:
-  git://repo.or.cz/qemu/kevin.git tags/for-upstream
+  https://repo.or.cz/qemu/kevin.git tags/for-upstream
-for you to fetch changes up to 8bb3b023f2055054ee119cb45b42d2b14be7fc8a:
+for you to fetch changes up to fc4e394b2887e15d5f83994e4fc7b26c895c627a:
-  qemu-iotests: adding LUKS cleanup for non-UTF8 secret error (2020-03-11 15:54:38 +0100)
+  block: remove unused BLOCK_OP_TYPE_DATAPLANE (2025-02-06 14:51:10 +0100)
 ----------------------------------------------------------------
-Block layer patches:
+Block layer patches
-- Relax restrictions for blockdev-snapshot (allows libvirt to do live
+- Managing inactive nodes (enables QSD migration with shared storage)
-  storage migration with blockdev-mirror)
+- Fix swapped values for BLOCK_IO_ERROR 'device' and 'qom-path'
-- luks: Delete created files when block_crypto_co_create_opts_luks fails
+- vpc: Read images exported from Azure correctly
-- Fix memleaks in qmp_object_add
+- scripts/qemu-gdb: Support coroutine dumps in coredumps
 - Minor cleanups
 ----------------------------------------------------------------
-Daniel Henrique Barboza (4):
+Fabiano Rosas (1):
-      block: introducing 'bdrv_co_delete_file' interface
+      block: Fix leak in send_qmp_error_event
       block.c: adding bdrv_co_delete_file
       crypto.c: cleanup created file when block_crypto_co_create_opts_luks fails
       qemu-iotests: adding LUKS cleanup for non-UTF8 secret error
-Kevin Wolf (6):
+Kevin Wolf (16):
-      block: Make bdrv_get_cumulative_perm() public
+      block: Add 'active' field to BlockDeviceInfo
-      block: Relax restrictions for blockdev-snapshot
+      block: Allow inactivating already inactive nodes
-      iotests: Fix run_job() with use_log=False
+      block: Inactivate external snapshot overlays when necessary
-      iotests: Test mirror with temporarily disabled target backing file
+      migration/block-active: Remove global active flag
-      block: Fix cross-AioContext blockdev-snapshot
+      block: Don't attach inactive child to active node
-      iotests: Add iothread cases to 155
+      block: Fix crash on block_resize on inactive node
+      block: Add option to create inactive nodes
-Pan Nengyuan (1):
+      block: Add blockdev-set-active QMP command
-      qom-qmp-cmds: fix two memleaks in qmp_object_add
+      block: Support inactive nodes in blk_insert_bs()
       block/export: Don't ignore image activation error in blk_exp_add()
       block: Drain nodes before inactivating them
       block/export: Add option to allow export of inactive nodes
       nbd/server: Support inactive nodes
       iotests: Add filter_qtest()
       iotests: Add qsd-migrate case
       iotests: Add (NBD-based) tests for inactive nodes
 Peter Krempa (1):
-      qapi: Add '@allow-write-only-overlay' feature for 'blockdev-snapshot'
+      block-backend: Fix argument order when calling 'qapi_event_send_block_io_error()'
 Peter Xu (3):
       scripts/qemu-gdb: Always do full stack dump for python errors
       scripts/qemu-gdb: Simplify fs_base fetching for coroutines
       scripts/qemu-gdb: Support coroutine dumps in coredumps
 Philippe Mathieu-Daudé (1):
-      tests/qemu-iotests: Fix socket_scm_helper build path
+      block: Improve blk_get_attached_dev_id() docstring
- qapi/block-core.json          |  9 ++++-
+Stefan Hajnoczi (1):
- include/block/block.h         |  1 +
+      block: remove unused BLOCK_OP_TYPE_DATAPLANE
- include/block/block_int.h     |  7 ++++
- block.c                       | 33 ++++++++++++++--
+Vitaly Kuznetsov (2):
- block/crypto.c                | 18 +++++++++
+      vpc: Split off vpc_ignore_current_size() helper
- block/file-posix.c            | 23 +++++++++++
+      vpc: Read images exported from Azure correctly
- blockdev.c                    | 30 ++++-----------
- qom/qom-qmp-cmds.c            | 16 +++-----
+ qapi/block-core.json                           |  44 +++-
- tests/qemu-iotests/iotests.py |  5 ++-
+ qapi/block-export.json                         |  10 +-
- tests/Makefile.include        |  1 +
+ include/block/block-common.h                   |   2 +-
- tests/qemu-iotests/085.out    |  4 +-
+ include/block/block-global-state.h             |   6 +
- tests/qemu-iotests/155        | 88 ++++++++++++++++++++++++++++++++++++-------
+ include/block/export.h                         |   3 +
- tests/qemu-iotests/155.out    |  4 +-
+ include/system/block-backend-io.h              |   7 +
- tests/qemu-iotests/282        | 67 ++++++++++++++++++++++++++++++++
+ migration/migration.h                          |   3 -
- tests/qemu-iotests/282.out    | 11 ++++++
+ block.c                                        |  64 +++++-
- tests/qemu-iotests/group      |  1 +
+ block/block-backend.c                          |  32 ++-
- tests/qtest/Makefile.include  |  1 -
+ block/export/export.c                          |  29 ++-
-files changed, 262 insertions(+), 57 deletions(-)
+ block/monitor/block-hmp-cmds.c                 |   5 +-
- create mode 100755 tests/qemu-iotests/282
+ block/qapi.c                                   |   1 +
- create mode 100644 tests/qemu-iotests/282.out
+ block/replication.c                            |   1 -
  block/vpc.c                                    |  65 +++---
  blockdev.c                                     |  48 ++++
  blockjob.c                                     |   2 -
  hw/block/virtio-blk.c                          |   9 -
  hw/scsi/virtio-scsi.c                          |   3 -
  migration/block-active.c                       |  46 ----
  migration/migration.c                          |   8 -
  nbd/server.c                                   |  17 ++
  scripts/qemu-gdb.py                            |   2 +
  scripts/qemugdb/coroutine.py                   | 102 ++++++---
  tests/qemu-iotests/iotests.py                  |   8 +
  tests/qemu-iotests/041                         |   4 +-
  tests/qemu-iotests/165                         |   4 +-
  tests/qemu-iotests/184.out                     |   2 +
  tests/qemu-iotests/191.out                     |  16 ++
  tests/qemu-iotests/273.out                     |   5 +
  tests/qemu-iotests/tests/copy-before-write     |   3 +-
  tests/qemu-iotests/tests/inactive-node-nbd     | 303 +++++++++++++++++++++++++
  tests/qemu-iotests/tests/inactive-node-nbd.out | 239 +++++++++++++++++++
  tests/qemu-iotests/tests/migrate-bitmaps-test  |   7 +-
  tests/qemu-iotests/tests/qsd-migrate           | 140 ++++++++++++
  tests/qemu-iotests/tests/qsd-migrate.out       |  59 +++++
 files changed, 1133 insertions(+), 166 deletions(-)
  create mode 100755 tests/qemu-iotests/tests/inactive-node-nbd
  create mode 100644 tests/qemu-iotests/tests/inactive-node-nbd.out
  create mode 100755 tests/qemu-iotests/tests/qsd-migrate
  create mode 100644 tests/qemu-iotests/tests/qsd-migrate.out

-[PULL 10/13] block: introducing 'bdrv_co_delete_file' interface
+[PULL 01/25] vpc: Split off vpc_ignore_current_size() helper
-From: Daniel Henrique Barboza <danielhb413@gmail.com>
+From: Vitaly Kuznetsov <vkuznets@redhat.com>
-Adding to Block Drivers the capability of being able to clean up
+In preparation to making changes to the logic deciding whether CHS or
-its created files can be useful in certain situations. For the
+'current_size' need to be used in determining the image size, split off
-LUKS driver, for instance, a failure in one of its authentication
+vpc_ignore_current_size() helper.
 steps can leave files in the host that weren't there before.
-This patch adds the 'bdrv_co_delete_file' interface to block
+No functional change intended.
 drivers and add it to the 'file' driver in file-posix.c. The
 implementation is given by 'raw_co_delete_file'.
-Suggested-by: Daniel P. Berrangé <berrange@redhat.com>
+Signed-off-by: Vitaly Kuznetsov <vkuznets@redhat.com>
-Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
+Message-ID: <20241212134504.1983757-2-vkuznets@redhat.com>
-Message-Id: <20200130213907.2830642-2-danielhb413@gmail.com>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/block/block_int.h |  4 ++++
+ block/vpc.c | 67 +++++++++++++++++++++++++++++------------------------
- block/file-posix.c        | 23 +++++++++++++++++++++++
+file changed, 37 insertions(+), 30 deletions(-)
 files changed, 27 insertions(+)
-diff --git a/include/block/block_int.h b/include/block/block_int.h
+diff --git a/block/vpc.c b/block/vpc.c
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/block_int.h
+--- a/block/vpc.c
-+++ b/include/block/block_int.h
++++ b/block/vpc.c
-@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
+@@ -XXX,XX +XXX,XX @@ static void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
-      */
+     }
      int coroutine_fn (*bdrv_co_flush)(BlockDriverState *bs);
 +    /* Delete a created file. */
 +    int coroutine_fn (*bdrv_co_delete_file)(BlockDriverState *bs,
 +                                            Error **errp);
 +
      /*
       * Flushes all data that was already written to the OS all the way down to
       * the disk (for example file-posix.c calls fsync()).
 diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/file-posix.c
 +++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts,
      return raw_co_create(&options, errp);
  }
-+static int coroutine_fn raw_co_delete_file(BlockDriverState *bs,
++/*
-+                                           Error **errp)
++ * Microsoft Virtual PC and Microsoft Hyper-V produce and read
 + * VHD image sizes differently.  VPC will rely on CHS geometry,
 + * while Hyper-V and disk2vhd use the size specified in the footer.
 + *
 + * We use a couple of approaches to try and determine the correct method:
 + * look at the Creator App field, and look for images that have CHS
 + * geometry that is the maximum value.
 + *
 + * If the CHS geometry is the maximum CHS geometry, then we assume that
 + * the size is the footer->current_size to avoid truncation.  Otherwise,
 + * we follow the table based on footer->creator_app:
 + *
 + *  Known creator apps:
 + *      'vpc '  :  CHS              Virtual PC (uses disk geometry)
 + *      'qemu'  :  CHS              QEMU (uses disk geometry)
 + *      'qem2'  :  current_size     QEMU (uses current_size)
 + *      'win '  :  current_size     Hyper-V
 + *      'd2v '  :  current_size     Disk2vhd
 + *      'tap\0' :  current_size     XenServer
 + *      'CTXS'  :  current_size     XenConverter
 + *
 + *  The user can override the table values via drive options, however
 + *  even with an override we will still use current_size for images
 + *  that have CHS geometry of the maximum size.
 + */
 +static bool vpc_ignore_current_size(VHDFooter *footer)
 +{
-+    struct stat st;
++    return !!strncmp(footer->creator_app, "win ", 4) &&
-+    int ret;
++           !!strncmp(footer->creator_app, "qem2", 4) &&
-+
++           !!strncmp(footer->creator_app, "d2v ", 4) &&
-+    if (!(stat(bs->filename, &st) == 0) || !S_ISREG(st.st_mode)) {
++           !!strncmp(footer->creator_app, "CTXS", 4) &&
-+        error_setg_errno(errp, ENOENT, "%s is not a regular file",
++           !!memcmp(footer->creator_app, "tap", 4));
 +                         bs->filename);
 +        return -ENOENT;
 +    }
 +
 +    ret = unlink(bs->filename);
 +    if (ret < 0) {
 +        ret = -errno;
 +        error_setg_errno(errp, -ret, "Error when deleting file %s",
 +                         bs->filename);
 +    }
 +
 +    return ret;
 +}
 +
- /*
+ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
-  * Find allocation range in @bs around offset @start.
+                     Error **errp)
-  * May change underlying file descriptor's file offset.
+ {
-@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_file = {
+@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
-     .bdrv_co_block_status = raw_co_block_status,
+     bs->total_sectors = (int64_t)
-     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
+         be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;
-     .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
-+    .bdrv_co_delete_file = raw_co_delete_file,
+-    /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
+-     * VHD image sizes differently.  VPC will rely on CHS geometry,
-     .bdrv_co_preadv         = raw_co_preadv,
+-     * while Hyper-V and disk2vhd use the size specified in the footer.
-     .bdrv_co_pwritev        = raw_co_pwritev,
+-     *
 -     * We use a couple of approaches to try and determine the correct method:
 -     * look at the Creator App field, and look for images that have CHS
 -     * geometry that is the maximum value.
 -     *
 -     * If the CHS geometry is the maximum CHS geometry, then we assume that
 -     * the size is the footer->current_size to avoid truncation.  Otherwise,
 -     * we follow the table based on footer->creator_app:
 -     *
 -     *  Known creator apps:
 -     *      'vpc '  :  CHS              Virtual PC (uses disk geometry)
 -     *      'qemu'  :  CHS              QEMU (uses disk geometry)
 -     *      'qem2'  :  current_size     QEMU (uses current_size)
 -     *      'win '  :  current_size     Hyper-V
 -     *      'd2v '  :  current_size     Disk2vhd
 -     *      'tap\0' :  current_size     XenServer
 -     *      'CTXS'  :  current_size     XenConverter
 -     *
 -     *  The user can override the table values via drive options, however
 -     *  even with an override we will still use current_size for images
 -     *  that have CHS geometry of the maximum size.
 -     */
 -    use_chs = (!!strncmp(footer->creator_app, "win ", 4) &&
 -               !!strncmp(footer->creator_app, "qem2", 4) &&
 -               !!strncmp(footer->creator_app, "d2v ", 4) &&
 -               !!strncmp(footer->creator_app, "CTXS", 4) &&
 -               !!memcmp(footer->creator_app, "tap", 4)) || s->force_use_chs;
 +    /* Use CHS or current_size to determine the image size. */
 +    use_chs = vpc_ignore_current_size(footer) || s->force_use_chs;
      if (!use_chs || bs->total_sectors == VHD_MAX_GEOMETRY || s->force_use_sz) {
          bs->total_sectors = be64_to_cpu(footer->current_size) /
 --
-.20.1
+.48.1

-New patch
+[PULL 02/25] vpc: Read images exported from Azure correctly
+From: Vitaly Kuznetsov <vkuznets@redhat.com>
+It was found that 'qemu-nbd' is not able to work with some disk images
+exported from Azure. Looking at the 512b footer (which contains VPC
+metadata):
+00000000  63 6f 6e 65 63 74 69 78  00 00 00 02 00 01 00 00  |conectix........|
+00000010  ff ff ff ff ff ff ff ff  2e c7 9b 96 77 61 00 00  |............wa..|
+00000020  00 07 00 00 57 69 32 6b  00 00 00 01 40 00 00 00  |....Wi2k....@...|
+00000030  00 00 00 01 40 00 00 00  28 a2 10 3f 00 00 00 02  |....@...(..?....|
+00000040  ff ff e7 47 8c 54 df 94  bd 35 71 4c 94 5f e5 44  |...G.T...5qL._.D|
+00000050  44 53 92 1a 00 00 00 00  00 00 00 00 00 00 00 00  |DS..............|
+00000060  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
+we can see that Azure uses a different 'Creator application' --
+'wa\0\0' (offset 0x1c, likely reads as 'Windows Azure') and QEMU uses this
+field to determine how it can get image size. Apparently, Azure uses 'new'
+method, just like Hyper-V.
+Overall, it seems that only VPC and old QEMUs need to be ignored as all new
+creator apps seem to have reliable current_size. Invert the logic and make
+'current_size' method the default to avoid adding every new creator app to
+the list.
+Signed-off-by: Vitaly Kuznetsov <vkuznets@redhat.com>
+Message-ID: <20241212134504.1983757-3-vkuznets@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/vpc.c | 8 +++-----
+file changed, 3 insertions(+), 5 deletions(-)
+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 void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
+  *      'd2v '  :  current_size     Disk2vhd
+  *      'tap\0' :  current_size     XenServer
+  *      'CTXS'  :  current_size     XenConverter
++ *      'wa\0\0':  current_size     Azure
+  *
+  *  The user can override the table values via drive options, however
+  *  even with an override we will still use current_size for images
+@@ -XXX,XX +XXX,XX @@ static void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
+  */
+ static bool vpc_ignore_current_size(VHDFooter *footer)
+ {
+-    return !!strncmp(footer->creator_app, "win ", 4) &&
+-           !!strncmp(footer->creator_app, "qem2", 4) &&
+-           !!strncmp(footer->creator_app, "d2v ", 4) &&
+-           !!strncmp(footer->creator_app, "CTXS", 4) &&
+-           !!memcmp(footer->creator_app, "tap", 4));
++    return !strncmp(footer->creator_app, "vpc ", 4) ||
++           !strncmp(footer->creator_app, "qemu", 4);
+ }
+ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
+--
+.48.1

-[PULL 07/13] iotests: Add iothread cases to 155
+[PULL 03/25] block: Improve blk_get_attached_dev_id() docstring
-This patch adds test cases for attaching the backing chain to a mirror
+From: Philippe Mathieu-Daudé <philmd@linaro.org>
 job target right before finalising the job, where the image is in a
 non-mainloop AioContext (i.e. the backing chain needs to be moved to the
 AioContext of the mirror target).
-This requires switching the test case from virtio-blk to virtio-scsi
+Expose the method docstring in the header, and mention
-because virtio-blk only actually starts using the iothreads when the
+returned value must be free'd by caller.
 guest driver initialises the device (which never happens in a test case
 without a guest OS). virtio-scsi always keeps its block nodes in the
 AioContext of the the requested iothread without guest interaction.
-Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reported-by: Fabiano Rosas <farosas@suse.de>
-Message-Id: <20200310113831.27293-7-kwolf@redhat.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>
-Reviewed-by: Peter Krempa <pkrempa@redhat.com>
+Message-ID: <20241111170333.43833-2-philmd@linaro.org>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/155     | 32 +++++++++++++++++++++++---------
+ include/system/block-backend-io.h |  7 +++++++
- tests/qemu-iotests/155.out |  4 ++--
+ block/block-backend.c             | 12 ++++++++----
-files changed, 25 insertions(+), 11 deletions(-)
+files changed, 15 insertions(+), 4 deletions(-)
-diff --git a/tests/qemu-iotests/155 b/tests/qemu-iotests/155
+diff --git a/include/system/block-backend-io.h b/include/system/block-backend-io.h
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/155
 +++ b/tests/qemu-iotests/155
@@ -XXX,XX +XXX,XX @@ target_img = os.path.join(iotests.test_dir, 'target.' + iotests.imgfmt)
  #                           chain opened right away. If False, blockdev-add
  #                           opens it without a backing file and job completion
  #                           is supposed to open the backing chain.
 +# use_iothread: If True, an iothread is configured for the virtio-blk device
 +#               that uses the image being mirrored
  class BaseClass(iotests.QMPTestCase):
      target_blockdev_backing = None
      target_real_backing = None
      target_open_with_backing = True
 +    use_iothread = False
      def setUp(self):
          qemu_img('create', '-f', iotests.imgfmt, back0_img, '1440K')
@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
                      'file': {'driver': 'file',
                               'filename': source_img}}
          self.vm.add_blockdev(self.vm.qmp_to_opts(blockdev))
 -        self.vm.add_device('virtio-blk,id=qdev0,drive=source')
 +
 +        if self.use_iothread:
 +            self.vm.add_object('iothread,id=iothread0')
 +            iothread = ",iothread=iothread0"
 +        else:
 +            iothread = ""
 +
 +        self.vm.add_device('virtio-scsi%s' % iothread)
 +        self.vm.add_device('scsi-hd,id=qdev0,drive=source')
 +
          self.vm.launch()
          self.assertIntactSourceBackingChain()
@@ -XXX,XX +XXX,XX @@ class MirrorBaseClass(BaseClass):
      def testFull(self):
          self.runMirror('full')
 -        node = self.findBlockNode('target',
 -                                  '/machine/peripheral/qdev0/virtio-backend')
 +        node = self.findBlockNode('target', 'qdev0')
          self.assertCorrectBackingImage(node, None)
          self.assertIntactSourceBackingChain()
      def testTop(self):
          self.runMirror('top')
 -        node = self.findBlockNode('target',
 -                                  '/machine/peripheral/qdev0/virtio-backend')
 +        node = self.findBlockNode('target', 'qdev0')
          self.assertCorrectBackingImage(node, back2_img)
          self.assertIntactSourceBackingChain()
      def testNone(self):
          self.runMirror('none')
 -        node = self.findBlockNode('target',
 -                                  '/machine/peripheral/qdev0/virtio-backend')
 +        node = self.findBlockNode('target', 'qdev0')
          self.assertCorrectBackingImage(node, source_img)
          self.assertIntactSourceBackingChain()
@@ -XXX,XX +XXX,XX @@ class TestBlockdevMirrorReopen(MirrorBaseClass):
                                   backing="backing")
              self.assert_qmp(result, 'return', {})
 +class TestBlockdevMirrorReopenIothread(TestBlockdevMirrorReopen):
 +    use_iothread = True
 +
  # Attach the backing chain only during completion, with blockdev-snapshot
  class TestBlockdevMirrorSnapshot(MirrorBaseClass):
      cmd = 'blockdev-mirror'
@@ -XXX,XX +XXX,XX @@ class TestBlockdevMirrorSnapshot(MirrorBaseClass):
                                   overlay="target")
              self.assert_qmp(result, 'return', {})
 +class TestBlockdevMirrorSnapshotIothread(TestBlockdevMirrorSnapshot):
 +    use_iothread = True
 +
  class TestCommit(BaseClass):
      existing = False
@@ -XXX,XX +XXX,XX @@ class TestCommit(BaseClass):
          self.vm.event_wait('BLOCK_JOB_COMPLETED')
 -        node = self.findBlockNode(None,
 -                                  '/machine/peripheral/qdev0/virtio-backend')
 +        node = self.findBlockNode(None, 'qdev0')
          self.assert_qmp(node, 'image' + '/backing-image' * 0 + '/filename',
                          back1_img)
          self.assert_qmp(node, 'image' + '/backing-image' * 1 + '/filename',
 diff --git a/tests/qemu-iotests/155.out b/tests/qemu-iotests/155.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/155.out
+--- a/include/system/block-backend-io.h
-+++ b/tests/qemu-iotests/155.out
++++ b/include/system/block-backend-io.h
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow);
--.........................
+ void blk_set_disable_request_queuing(BlockBackend *blk, bool disable);
-+...............................
+ bool blk_iostatus_is_enabled(const BlockBackend *blk);
- ----------------------------------------------------------------------
--Ran 25 tests
++/*
-+Ran 31 tests
++ * Return the qdev ID, or if no ID is assigned the QOM path,
++ * of the block device attached to the BlockBackend.
- OK
++ *
 + * The caller is responsible for releasing the value returned
 + * with g_free() after use.
 + */
  char *blk_get_attached_dev_id(BlockBackend *blk);
  BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
 diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-backend.c
 +++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ DeviceState *blk_get_attached_dev(BlockBackend *blk)
      return blk->dev;
  }
 +/*
 + * The caller is responsible for releasing the value returned
 + * with g_free() after use.
 + */
  static char *blk_get_attached_dev_id_or_path(BlockBackend *blk, bool want_id)
  {
      DeviceState *dev = blk->dev;
@@ -XXX,XX +XXX,XX @@ static char *blk_get_attached_dev_id_or_path(BlockBackend *blk, bool want_id)
      return object_get_canonical_path(OBJECT(dev)) ?: g_strdup("");
  }
 -/*
 - * Return the qdev ID, or if no ID is assigned the QOM path, of the block
 - * device attached to the BlockBackend.
 - */
  char *blk_get_attached_dev_id(BlockBackend *blk)
  {
      return blk_get_attached_dev_id_or_path(blk, true);
  }
 +/*
 + * The caller is responsible for releasing the value returned
 + * with g_free() after use.
 + */
  static char *blk_get_attached_dev_path(BlockBackend *blk)
  {
      return blk_get_attached_dev_id_or_path(blk, false);
 --
-.20.1
+.48.1

-[PULL 01/13] qom-qmp-cmds: fix two memleaks in qmp_object_add
+[PULL 04/25] block: Fix leak in send_qmp_error_event
-From: Pan Nengyuan <pannengyuan@huawei.com>
+From: Fabiano Rosas <farosas@suse.de>
-'type/id' forgot to free in qmp_object_add, this patch fix that.
+ASAN detected a leak when running the ahci-test
 /ahci/io/dma/lba28/retry:
-The leak stack:
+Direct leak of 35 byte(s) in 1 object(s) allocated from:
-Direct leak of 84 byte(s) in 6 object(s) allocated from:
+    #0 in malloc
-    #0 0x7fe2a5ebf768 in __interceptor_malloc (/lib64/libasan.so.5+0xef768)
+    #1 in __vasprintf_internal
-    #1 0x7fe2a5044445 in g_malloc (/lib64/libglib-2.0.so.0+0x52445)
+    #2 in vasprintf
-    #2 0x7fe2a505dd92 in g_strdup (/lib64/libglib-2.0.so.0+0x6bd92)
+    #3 in g_vasprintf
-    #3 0x56344954e692 in qmp_object_add /mnt/sdb/qemu-new/qemu_test/qemu/qom/qom-qmp-cmds.c:258
+    #4 in g_strdup_vprintf
-    #4 0x563449960f5a in do_qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qmp-dispatch.c:132
+    #5 in g_strdup_printf
-    #5 0x563449960f5a in qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qmp-dispatch.c:175
+    #6 in object_get_canonical_path ../qom/object.c:2096:19
-    #6 0x563449498a30 in monitor_qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/monitor/qmp.c:145
+    #7 in blk_get_attached_dev_id_or_path ../block/block-backend.c:1033:12
-    #7 0x56344949a64f in monitor_qmp_bh_dispatcher /mnt/sdb/qemu-new/qemu_test/qemu/monitor/qmp.c:234
+    #8 in blk_get_attached_dev_path ../block/block-backend.c:1047:12
-    #8 0x563449a92a3a in aio_bh_call /mnt/sdb/qemu-new/qemu_test/qemu/util/async.c:136
+    #9 in send_qmp_error_event ../block/block-backend.c:2140:36
     #10 in blk_error_action ../block/block-backend.c:2172:9
     #11 in ide_handle_rw_error ../hw/ide/core.c:875:5
     #12 in ide_dma_cb ../hw/ide/core.c:894:13
     #13 in dma_complete ../system/dma-helpers.c:107:9
     #14 in dma_blk_cb ../system/dma-helpers.c:129:9
     #15 in blk_aio_complete ../block/block-backend.c:1552:9
     #16 in blk_aio_write_entry ../block/block-backend.c:1619:5
     #17 in coroutine_trampoline ../util/coroutine-ucontext.c:175:9
-Direct leak of 54 byte(s) in 6 object(s) allocated from:
+Plug the leak by freeing the device path string.
     #0 0x7fe2a5ebf768 in __interceptor_malloc (/lib64/libasan.so.5+0xef768)
     #1 0x7fe2a5044445 in g_malloc (/lib64/libglib-2.0.so.0+0x52445)
     #2 0x7fe2a505dd92 in g_strdup (/lib64/libglib-2.0.so.0+0x6bd92)
     #3 0x56344954e6c4 in qmp_object_add /mnt/sdb/qemu-new/qemu_test/qemu/qom/qom-qmp-cmds.c:267
     #4 0x563449960f5a in do_qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qmp-dispatch.c:132
     #5 0x563449960f5a in qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qmp-dispatch.c:175
     #6 0x563449498a30 in monitor_qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/monitor/qmp.c:145
     #7 0x56344949a64f in monitor_qmp_bh_dispatcher /mnt/sdb/qemu-new/qemu_test/qemu/monitor/qmp.c:234
     #8 0x563449a92a3a in aio_bh_call /mnt/sdb/qemu-new/qemu_test/qemu/util/async.c:136
-Fixes: 5f07c4d60d091320186e7b0edaf9ed2cc16b2d1e
+Signed-off-by: Fabiano Rosas <farosas@suse.de>
-Reported-by: Euler Robot <euler.robot@huawei.com>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
-Signed-off-by: Pan Nengyuan <pannengyuan@huawei.com>
+Message-ID: <20241111145214.8261-1-farosas@suse.de>
-Message-Id: <20200310064640.5059-1-pannengyuan@huawei.com>
+[PMD: Use g_autofree]
-Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
+Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>
-Acked-by: Igor Mammedov <imammedo@redhat.com>
+Message-ID: <20241111170333.43833-3-philmd@linaro.org>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qom/qom-qmp-cmds.c | 16 ++++++----------
+ block/block-backend.c | 4 ++--
-file changed, 6 insertions(+), 10 deletions(-)
+file changed, 2 insertions(+), 2 deletions(-)
-diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
+diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
---- a/qom/qom-qmp-cmds.c
+--- a/block/block-backend.c
-+++ b/qom/qom-qmp-cmds.c
++++ b/block/block-backend.c
-@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static void send_qmp_error_event(BlockBackend *blk,
-     QDict *pdict;
+ {
-     Visitor *v;
+     IoOperationType optype;
-     Object *obj;
+     BlockDriverState *bs = blk_bs(blk);
--    const char *type;
++    g_autofree char *path = blk_get_attached_dev_path(blk);
--    const char *id;
-+    g_autofree char *type = NULL;
+     optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
-+    g_autofree char *id = NULL;
+-    qapi_event_send_block_io_error(blk_name(blk),
+-                                   blk_get_attached_dev_path(blk),
--    type = qdict_get_try_str(qdict, "qom-type");
++    qapi_event_send_block_io_error(blk_name(blk), path,
-+    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
+                                    bs ? bdrv_get_node_name(bs) : NULL, optype,
-     if (!type) {
+                                    action, blk_iostatus_is_enabled(blk),
-         error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
+                                    error == ENOSPC, strerror(error));
          return;
 -    } else {
 -        type = g_strdup(type);
 -        qdict_del(qdict, "qom-type");
      }
 +    qdict_del(qdict, "qom-type");
 -    id = qdict_get_try_str(qdict, "id");
 +    id = g_strdup(qdict_get_try_str(qdict, "id"));
      if (!id) {
          error_setg(errp, QERR_MISSING_PARAMETER, "id");
          return;
 -    } else {
 -        id = g_strdup(id);
 -        qdict_del(qdict, "id");
      }
 +    qdict_del(qdict, "id");
      props = qdict_get(qdict, "props");
      if (props) {
 --
-.20.1
+.48.1

-New patch
+[PULL 05/25] scripts/qemu-gdb: Always do full stack dump for python errors
+From: Peter Xu <peterx@redhat.com>
+It's easier for either debugging plugin errors, or issue reports.
+Signed-off-by: Peter Xu <peterx@redhat.com>
+Message-ID: <20241212204801.1420528-2-peterx@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ scripts/qemu-gdb.py | 2 ++
+file changed, 2 insertions(+)
+diff --git a/scripts/qemu-gdb.py b/scripts/qemu-gdb.py
+index XXXXXXX..XXXXXXX 100644
+--- a/scripts/qemu-gdb.py
++++ b/scripts/qemu-gdb.py
+@@ -XXX,XX +XXX,XX @@ def __init__(self):
+ # Default to silently passing through SIGUSR1, because QEMU sends it
+ # to itself a lot.
+ gdb.execute('handle SIGUSR1 pass noprint nostop')
++# Always print full stack for python errors, easier to debug and report issues
++gdb.execute('set python print-stack full')
+--
+.48.1

-New patch
+[PULL 06/25] scripts/qemu-gdb: Simplify fs_base fetching for coroutines
+From: Peter Xu <peterx@redhat.com>
+There're a bunch of code trying to fetch fs_base in different ways.  IIUC
+the simplest way instead is "$fs_base".  It also has the benefit that it'll
+work for both live gdb session or coredumps.
+Signed-off-by: Peter Xu <peterx@redhat.com>
+Message-ID: <20241212204801.1420528-3-peterx@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ scripts/qemugdb/coroutine.py | 23 ++---------------------
+file changed, 2 insertions(+), 21 deletions(-)
+diff --git a/scripts/qemugdb/coroutine.py b/scripts/qemugdb/coroutine.py
+index XXXXXXX..XXXXXXX 100644
+--- a/scripts/qemugdb/coroutine.py
++++ b/scripts/qemugdb/coroutine.py
+@@ -XXX,XX +XXX,XX @@
+ VOID_PTR = gdb.lookup_type('void').pointer()
+-def get_fs_base():
+-    '''Fetch %fs base value using arch_prctl(ARCH_GET_FS).  This is
+-       pthread_self().'''
+-    # %rsp - 120 is scratch space according to the SystemV ABI
+-    old = gdb.parse_and_eval('*(uint64_t*)($rsp - 120)')
+-    gdb.execute('call (int)arch_prctl(0x1003, $rsp - 120)', False, True)
+-    fs_base = gdb.parse_and_eval('*(uint64_t*)($rsp - 120)')
+-    gdb.execute('set *(uint64_t*)($rsp - 120) = %s' % old, False, True)
+-    return fs_base
+-
+ def pthread_self():
+-    '''Fetch pthread_self() from the glibc start_thread function.'''
+-    f = gdb.newest_frame()
+-    while f.name() != 'start_thread':
+-        f = f.older()
+-        if f is None:
+-            return get_fs_base()
+-
+-    try:
+-        return f.read_var("arg")
+-    except ValueError:
+-        return get_fs_base()
++    '''Fetch the base address of TLS.'''
++    return gdb.parse_and_eval("$fs_base")
+ def get_glibc_pointer_guard():
+     '''Fetch glibc pointer guard value'''
+--
+.48.1

-New patch
+[PULL 07/25] scripts/qemu-gdb: Support coroutine dumps in coredumps
+From: Peter Xu <peterx@redhat.com>
+Dumping coroutines don't yet work with coredumps.  Let's make it work.
+We still kept most of the old code because they can be either more
+flexible, or prettier.  Only add the fallbacks when they stop working.
+Currently the raw unwind is pretty ugly, but it works, like this:
+  (gdb) qemu bt
+  #0  process_incoming_migration_co (opaque=0x0) at ../migration/migration.c:788
+  #1  0x000055ae6c0dc4d9 in coroutine_trampoline (i0=-1711718576, i1=21934) at ../util/coroutine-ucontext.c:175
+  #2  0x00007f9f59d72f40 in ??? () at /lib64/libc.so.6
+  #3  0x00007ffd549214a0 in ??? ()
+  #4  0x0000000000000000 in ??? ()
+  Coroutine at 0x7f9f4c57c748:
+  #0  0x55ae6c0dc9a8 in qemu_coroutine_switch<+120> () at ../util/coroutine-ucontext.c:321
+  #1  0x55ae6c0da2f8 in qemu_aio_coroutine_enter<+356> () at ../util/qemu-coroutine.c:293
+  #2  0x55ae6c0da3f1 in qemu_coroutine_enter<+34> () at ../util/qemu-coroutine.c:316
+  #3  0x55ae6baf775e in migration_incoming_process<+43> () at ../migration/migration.c:876
+  #4  0x55ae6baf7ab4 in migration_ioc_process_incoming<+490> () at ../migration/migration.c:1008
+  #5  0x55ae6bae9ae7 in migration_channel_process_incoming<+145> () at ../migration/channel.c:45
+  #6  0x55ae6bb18e35 in socket_accept_incoming_migration<+118> () at ../migration/socket.c:132
+  #7  0x55ae6be939ef in qio_net_listener_channel_func<+131> () at ../io/net-listener.c:54
+  #8  0x55ae6be8ce1a in qio_channel_fd_source_dispatch<+78> () at ../io/channel-watch.c:84
+  #9  0x7f9f5b26728c in g_main_context_dispatch_unlocked.lto_priv<+315> ()
+  #10  0x7f9f5b267555 in g_main_context_dispatch<+36> ()
+  #11  0x55ae6c0d91a7 in glib_pollfds_poll<+90> () at ../util/main-loop.c:287
+  #12  0x55ae6c0d9235 in os_host_main_loop_wait<+128> () at ../util/main-loop.c:310
+  #13  0x55ae6c0d9364 in main_loop_wait<+203> () at ../util/main-loop.c:589
+  #14  0x55ae6bac212a in qemu_main_loop<+41> () at ../system/runstate.c:835
+  #15  0x55ae6bfdf522 in qemu_default_main<+19> () at ../system/main.c:37
+  #16  0x55ae6bfdf55f in main<+40> () at ../system/main.c:48
+  #17  0x7f9f59d42248 in __libc_start_call_main<+119> ()
+  #18  0x7f9f59d4230b in __libc_start_main_impl<+138> ()
+Signed-off-by: Peter Xu <peterx@redhat.com>
+Message-ID: <20241212204801.1420528-4-peterx@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ scripts/qemugdb/coroutine.py | 79 +++++++++++++++++++++++++++++++++---
+file changed, 73 insertions(+), 6 deletions(-)
+diff --git a/scripts/qemugdb/coroutine.py b/scripts/qemugdb/coroutine.py
+index XXXXXXX..XXXXXXX 100644
+--- a/scripts/qemugdb/coroutine.py
++++ b/scripts/qemugdb/coroutine.py
+@@ -XXX,XX +XXX,XX @@ def get_jmpbuf_regs(jmpbuf):
+         'r15': jmpbuf[JB_R15],
+         'rip': glibc_ptr_demangle(jmpbuf[JB_PC], pointer_guard) }
+-def bt_jmpbuf(jmpbuf):
+-    '''Backtrace a jmpbuf'''
+-    regs = get_jmpbuf_regs(jmpbuf)
++def symbol_lookup(addr):
++    # Example: "__clone3 + 44 in section .text of /lib64/libc.so.6"
++    result = gdb.execute(f"info symbol {hex(addr)}", to_string=True).strip()
++    try:
++        if "+" in result:
++            (func, result) = result.split(" + ")
++            (offset, result) = result.split(" in ")
++        else:
++            offset = "0"
++            (func, result) = result.split(" in ")
++        func_str = f"{func}<+{offset}> ()"
++    except:
++        return f"??? ({result})"
++
++    # Example: Line 321 of "../util/coroutine-ucontext.c" starts at address
++    # 0x55cf3894d993 <qemu_coroutine_switch+99> and ends at 0x55cf3894d9ab
++    # <qemu_coroutine_switch+123>.
++    result = gdb.execute(f"info line *{hex(addr)}", to_string=True).strip()
++    if not result.startswith("Line "):
++        return func_str
++    result = result[5:]
++
++    try:
++        result = result.split(" starts ")[0]
++        (line, path) = result.split(" of ")
++        path = path.replace("\"", "")
++    except:
++        return func_str
++
++    return f"{func_str} at {path}:{line}"
++
++def dump_backtrace(regs):
++    '''
++    Backtrace dump with raw registers, mimic GDB command 'bt'.
++    '''
++    # Here only rbp and rip that matter..
++    rbp = regs['rbp']
++    rip = regs['rip']
++    i = 0
++
++    while rbp:
++        # For all return addresses on stack, we want to look up symbol/line
++        # on the CALL command, because the return address is the next
++        # instruction instead of the CALL.  Here -1 would work for any
++        # sized CALL instruction.
++        print(f"#{i}  {hex(rip)} in {symbol_lookup(rip if i == 0 else rip-1)}")
++        rip = gdb.parse_and_eval(f"*(uint64_t *)(uint64_t)({hex(rbp)} + 8)")
++        rbp = gdb.parse_and_eval(f"*(uint64_t *)(uint64_t)({hex(rbp)})")
++        i += 1
++
++def dump_backtrace_live(regs):
++    '''
++    Backtrace dump with gdb's 'bt' command, only usable in a live session.
++    '''
+     old = dict()
+     # remember current stack frame and select the topmost
+@@ -XXX,XX +XXX,XX @@ def bt_jmpbuf(jmpbuf):
+     selected_frame.select()
++def bt_jmpbuf(jmpbuf):
++    '''Backtrace a jmpbuf'''
++    regs = get_jmpbuf_regs(jmpbuf)
++    try:
++        # This reuses gdb's "bt" command, which can be slightly prettier
++        # but only works with live sessions.
++        dump_backtrace_live(regs)
++    except:
++        # If above doesn't work, fallback to poor man's unwind
++        dump_backtrace(regs)
++
+ def co_cast(co):
+     return co.cast(gdb.lookup_type('CoroutineUContext').pointer())
+@@ -XXX,XX +XXX,XX @@ def invoke(self, arg, from_tty):
+         gdb.execute("bt")
+-        if gdb.parse_and_eval("qemu_in_coroutine()") == False:
+-            return
++        try:
++            # This only works with a live session
++            co_ptr = gdb.parse_and_eval("qemu_coroutine_self()")
++        except:
++            # Fallback to use hard-coded ucontext vars if it's coredump
++            co_ptr = gdb.parse_and_eval("co_tls_current")
+-        co_ptr = gdb.parse_and_eval("qemu_coroutine_self()")
++        if co_ptr == False:
++            return
+         while True:
+             co = co_cast(co_ptr)
+--
+.48.1

-[PULL 09/13] tests/qemu-iotests: Fix socket_scm_helper build path
+[PULL 08/25] block-backend: Fix argument order when calling 'qapi_event_send_block_io_error()'
-From: Philippe Mathieu-Daudé <philmd@redhat.com>
+From: Peter Krempa <pkrempa@redhat.com>
-The socket_scm_helper path got corrupted during the mechanical
+Commit 7452162adec25c10 introduced 'qom-path' argument to BLOCK_IO_ERROR
-refactor moving the qtests files into their own sub-directory.
+event but when the event is instantiated in 'send_qmp_error_event()' the
 arguments for 'device' and 'qom_path' in
 qapi_event_send_block_io_error() were reversed :
-Fixes: 1e8a1fae7 ("test: Move qtests to a separate directory")
+Generated code for sending event:
-Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Message-Id: <20200306165751.18986-1-philmd@redhat.com>
+  void qapi_event_send_block_io_error(const char *qom_path,
-Reviewed-by: Laurent Vivier <laurent@vivier.eu>
+                                      const char *device,
                                       const char *node_name,
                                       IoOperationType operation,
                                       [...]
 Call inside send_qmp_error_event():
      qapi_event_send_block_io_error(blk_name(blk),
                                     blk_get_attached_dev_path(blk),
                                     bs ? bdrv_get_node_name(bs) : NULL, optype,
                                     [...]
 This results into reporting the QOM path as the device alias and vice
 versa which in turn breaks libvirt, which expects the device alias being
 either a valid alias or empty (which would make libvirt do the lookup by
 node-name instead).
 Cc: qemu-stable@nongnu.org
 Fixes: 7452162adec2 ("qapi: add qom-path to BLOCK_IO_ERROR event")
 Signed-off-by: Peter Krempa <pkrempa@redhat.com>
 Message-ID: <09728d784888b38d7a8f09ee5e9e9c542c875e1e.1737973614.git.pkrempa@redhat.com>
 Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/Makefile.include       | 1 +
+ block/block-backend.c | 2 +-
- tests/qtest/Makefile.include | 1 -
+file changed, 1 insertion(+), 1 deletion(-)
 files changed, 1 insertion(+), 1 deletion(-)
-diff --git a/tests/Makefile.include b/tests/Makefile.include
+diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/Makefile.include
+--- a/block/block-backend.c
-+++ b/tests/Makefile.include
++++ b/block/block-backend.c
-@@ -XXX,XX +XXX,XX @@ include $(SRC_PATH)/tests/qtest/Makefile.include
+@@ -XXX,XX +XXX,XX @@ static void send_qmp_error_event(BlockBackend *blk,
- tests/test-qga$(EXESUF): qemu-ga$(EXESUF)
+     g_autofree char *path = blk_get_attached_dev_path(blk);
- tests/test-qga$(EXESUF): tests/test-qga.o $(qtest-obj-y)
- tests/vhost-user-bridge$(EXESUF): tests/vhost-user-bridge.o $(test-util-obj-y) libvhost-user.a
+     optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
-+tests/qemu-iotests/socket_scm_helper$(EXESUF): tests/qemu-iotests/socket_scm_helper.o
+-    qapi_event_send_block_io_error(blk_name(blk), path,
++    qapi_event_send_block_io_error(path, blk_name(blk),
- SPEED = quick
+                                    bs ? bdrv_get_node_name(bs) : NULL, optype,
+                                    action, blk_iostatus_is_enabled(blk),
-diff --git a/tests/qtest/Makefile.include b/tests/qtest/Makefile.include
+                                    error == ENOSPC, strerror(error));
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qtest/Makefile.include
 +++ b/tests/qtest/Makefile.include
@@ -XXX,XX +XXX,XX @@ tests/qtest/usb-hcd-ehci-test$(EXESUF): tests/qtest/usb-hcd-ehci-test.o $(libqos
  tests/qtest/usb-hcd-xhci-test$(EXESUF): tests/qtest/usb-hcd-xhci-test.o $(libqos-usb-obj-y)
  tests/qtest/cpu-plug-test$(EXESUF): tests/qtest/cpu-plug-test.o
  tests/qtest/migration-test$(EXESUF): tests/qtest/migration-test.o tests/qtest/migration-helpers.o
 -tests/qtest/qemu-iotests/qtest/socket_scm_helper$(EXESUF): tests/qtest/qemu-iotests/qtest/socket_scm_helper.o
  tests/qtest/test-netfilter$(EXESUF): tests/qtest/test-netfilter.o $(qtest-obj-y)
  tests/qtest/test-filter-mirror$(EXESUF): tests/qtest/test-filter-mirror.o $(qtest-obj-y)
  tests/qtest/test-filter-redirector$(EXESUF): tests/qtest/test-filter-redirector.o $(qtest-obj-y)
 --
-.20.1
+.48.1

-New patch
+[PULL 09/25] block: Add 'active' field to BlockDeviceInfo
+This allows querying from QMP (and also HMP) whether an image is
+currently active or inactive (in the sense of BDRV_O_INACTIVE).
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-ID: <20250204211407.381505-2-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ qapi/block-core.json               |  6 +++++-
+ include/block/block-global-state.h |  3 +++
+ block.c                            |  4 ++++
+ block/monitor/block-hmp-cmds.c     |  5 +++--
+ block/qapi.c                       |  1 +
+ tests/qemu-iotests/184.out         |  2 ++
+ tests/qemu-iotests/191.out         | 16 ++++++++++++++++
+ tests/qemu-iotests/273.out         |  5 +++++
+files changed, 39 insertions(+), 3 deletions(-)
+diff --git a/qapi/block-core.json b/qapi/block-core.json
+index XXXXXXX..XXXXXXX 100644
+--- a/qapi/block-core.json
++++ b/qapi/block-core.json
+@@ -XXX,XX +XXX,XX @@
+ # @backing_file_depth: number of files in the backing file chain
+ #     (since: 1.2)
+ #
++# @active: true if the backend is active; typical cases for inactive backends
++#     are on the migration source instance after migration completes and on the
++#     destination before it completes. (since: 10.0)
++#
+ # @encrypted: true if the backing device is encrypted
+ #
+ # @detect_zeroes: detect and optimize zero writes (Since 2.1)
+@@ -XXX,XX +XXX,XX @@
+ { 'struct': 'BlockDeviceInfo',
+   'data': { 'file': 'str', '*node-name': 'str', 'ro': 'bool', 'drv': 'str',
+             '*backing_file': 'str', 'backing_file_depth': 'int',
+-            'encrypted': 'bool',
++            'active': 'bool', 'encrypted': 'bool',
+             'detect_zeroes': 'BlockdevDetectZeroesOptions',
+             'bps': 'int', 'bps_rd': 'int', 'bps_wr': 'int',
+             'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int',
+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 @@ BlockDriverState * GRAPH_RDLOCK
+ check_to_replace_node(BlockDriverState *parent_bs, const char *node_name,
+                       Error **errp);
++
++bool GRAPH_RDLOCK bdrv_is_inactive(BlockDriverState *bs);
++
+ int no_coroutine_fn GRAPH_RDLOCK
+ bdrv_activate(BlockDriverState *bs, Error **errp);
+diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block.c
++++ b/block.c
+@@ -XXX,XX +XXX,XX @@ void bdrv_init_with_whitelist(void)
+     bdrv_init();
+ }
++bool bdrv_is_inactive(BlockDriverState *bs) {
++    return bs->open_flags & BDRV_O_INACTIVE;
++}
++
+ int bdrv_activate(BlockDriverState *bs, Error **errp)
+ {
+     BdrvChild *child, *parent;
+diff --git a/block/monitor/block-hmp-cmds.c b/block/monitor/block-hmp-cmds.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/monitor/block-hmp-cmds.c
++++ b/block/monitor/block-hmp-cmds.c
+@@ -XXX,XX +XXX,XX @@ static void print_block_info(Monitor *mon, BlockInfo *info,
+     }
+     if (inserted) {
+-        monitor_printf(mon, ": %s (%s%s%s)\n",
++        monitor_printf(mon, ": %s (%s%s%s%s)\n",
+                        inserted->file,
+                        inserted->drv,
+                        inserted->ro ? ", read-only" : "",
+-                       inserted->encrypted ? ", encrypted" : "");
++                       inserted->encrypted ? ", encrypted" : "",
++                       inserted->active ? "" : ", inactive");
+     } else {
+         monitor_printf(mon, ": [not inserted]\n");
+     }
+diff --git a/block/qapi.c b/block/qapi.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qapi.c
++++ b/block/qapi.c
+@@ -XXX,XX +XXX,XX @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
+     info->file                   = g_strdup(bs->filename);
+     info->ro                     = bdrv_is_read_only(bs);
+     info->drv                    = g_strdup(bs->drv->format_name);
++    info->active                 = !bdrv_is_inactive(bs);
+     info->encrypted              = bs->encrypted;
+     info->cache = g_new(BlockdevCacheInfo, 1);
+diff --git a/tests/qemu-iotests/184.out b/tests/qemu-iotests/184.out
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/184.out
++++ b/tests/qemu-iotests/184.out
+@@ -XXX,XX +XXX,XX @@ Testing:
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "backing-image": {
+                     "virtual-size": 1073741824,
+@@ -XXX,XX +XXX,XX @@ Testing:
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 1073741824,
+                 "filename": "null-co://",
+diff --git a/tests/qemu-iotests/191.out b/tests/qemu-iotests/191.out
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/191.out
++++ b/tests/qemu-iotests/191.out
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "backing-image": {
+                     "virtual-size": 67108864,
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 197120,
+                 "filename": "TEST_DIR/t.IMGFMT.ovl2",
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "backing-image": {
+                     "virtual-size": 67108864,
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 197120,
+                 "filename": "TEST_DIR/t.IMGFMT",
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "backing-image": {
+                     "virtual-size": 67108864,
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 393216,
+                 "filename": "TEST_DIR/t.IMGFMT.mid",
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 67108864,
+                 "filename": "TEST_DIR/t.IMGFMT.base",
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 393216,
+                 "filename": "TEST_DIR/t.IMGFMT.base",
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "backing-image": {
+                     "virtual-size": 67108864,
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 197120,
+                 "filename": "TEST_DIR/t.IMGFMT.ovl2",
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "backing-image": {
+                     "backing-image": {
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 197120,
+                 "filename": "TEST_DIR/t.IMGFMT.ovl3",
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 67108864,
+                 "filename": "TEST_DIR/t.IMGFMT.base",
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 393216,
+                 "filename": "TEST_DIR/t.IMGFMT.base",
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "backing-image": {
+                     "virtual-size": 67108864,
+@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 197120,
+                 "filename": "TEST_DIR/t.IMGFMT",
+diff --git a/tests/qemu-iotests/273.out b/tests/qemu-iotests/273.out
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/273.out
++++ b/tests/qemu-iotests/273.out
+@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "backing-image": {
+                     "backing-image": {
+@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 197120,
+                 "filename": "TEST_DIR/t.IMGFMT",
+@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "backing-image": {
+                     "virtual-size": 197120,
+@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 197120,
+                 "filename": "TEST_DIR/t.IMGFMT.mid",
+@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
+         {
+             "iops_rd": 0,
+             "detect_zeroes": "off",
++            "active": true,
+             "image": {
+                 "virtual-size": 197120,
+                 "filename": "TEST_DIR/t.IMGFMT.base",
+--
+.48.1

-New patch
+[PULL 10/25] block: Allow inactivating already inactive nodes
+What we wanted to catch with the assertion is cases where the recursion
+finds that a child was inactive before its parent. This should never
+happen. But if the user tries to inactivate an image that is already
+inactive, that's harmless and we don't want to fail the assertion.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-ID: <20250204211407.381505-3-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block.c | 16 ++++++++++++----
+file changed, 12 insertions(+), 4 deletions(-)
+diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block.c
++++ b/block.c
+@@ -XXX,XX +XXX,XX @@ bdrv_has_bds_parent(BlockDriverState *bs, bool only_active)
+     return false;
+ }
+-static int GRAPH_RDLOCK bdrv_inactivate_recurse(BlockDriverState *bs)
++static int GRAPH_RDLOCK
++bdrv_inactivate_recurse(BlockDriverState *bs, bool top_level)
+ {
+     BdrvChild *child, *parent;
+     int ret;
+@@ -XXX,XX +XXX,XX @@ static int GRAPH_RDLOCK bdrv_inactivate_recurse(BlockDriverState *bs)
+         return 0;
+     }
+-    assert(!(bs->open_flags & BDRV_O_INACTIVE));
++    /*
++     * Inactivating an already inactive node on user request is harmless, but if
++     * a child is already inactive before its parent, that's bad.
++     */
++    if (bs->open_flags & BDRV_O_INACTIVE) {
++        assert(top_level);
++        return 0;
++    }
+     /* Inactivate this node */
+     if (bs->drv->bdrv_inactivate) {
+@@ -XXX,XX +XXX,XX @@ static int GRAPH_RDLOCK bdrv_inactivate_recurse(BlockDriverState *bs)
+     /* Recursively inactivate children */
+     QLIST_FOREACH(child, &bs->children, next) {
+-        ret = bdrv_inactivate_recurse(child->bs);
++        ret = bdrv_inactivate_recurse(child->bs, false);
+         if (ret < 0) {
+             return ret;
+         }
+@@ -XXX,XX +XXX,XX @@ int bdrv_inactivate_all(void)
+         if (bdrv_has_bds_parent(bs, false)) {
+             continue;
+         }
+-        ret = bdrv_inactivate_recurse(bs);
++        ret = bdrv_inactivate_recurse(bs, true);
+         if (ret < 0) {
+             bdrv_next_cleanup(&it);
+             break;
+--
+.48.1

-[PULL 03/13] block: Relax restrictions for blockdev-snapshot
+[PULL 11/25] block: Inactivate external snapshot overlays when necessary
-blockdev-snapshot returned an error if the overlay was already in use,
+Putting an active block node on top of an inactive one is strictly
-which it defined as having any BlockBackend parent. This is in fact both
+speaking an invalid configuration and the next patch will turn it into a
-too strict (some parents can tolerate the change of visible data caused
+hard error.
 by attaching a backing file) and too loose (some non-BlockBackend
 parents may not be happy with it).
-One important use case that is prevented by the too strict check is live
+However, taking a snapshot while disk images are inactive after
-storage migration with blockdev-mirror. Here, the target node is
+completing migration has an important use case: After migrating to a
-usually opened without a backing file so that the active layer is
+file, taking an external snapshot is what is needed to take a full VM
-mirrored while its backing chain can be copied in the background.
+snapshot.
-The backing chain should be attached to the mirror target node when
+In order for this to keep working after the later patches, change
-finalising the job, just before switching the users of the source node
+creating a snapshot such that it automatically inactivates an overlay
-to the new copy (at which point the mirror job still has a reference to
+that is added on top of an already inactive node.
 the node). drive-mirror did this automatically, but with blockdev-mirror
 this is the job of the QMP client, so it needs a way to do this.
 blockdev-snapshot is the obvious way, so this patch makes it work in
 this scenario. The new condition is that no parent uses CONSISTENT_READ
 permissions. This will ensure that the operation will still be blocked
 when the node is attached to the guest device, so blockdev-snapshot
 remains safe.
 (For the sake of completeness, x-blockdev-reopen can be used to achieve
 the same, however it is a big hammer, performs the graph change
 completely unchecked and is still experimental. So even with the option
 of using x-blockdev-reopen, there are reasons why blockdev-snapshot
 should be able to perform this operation.)
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20200310113831.27293-3-kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
-Reviewed-by: Peter Krempa <pkrempa@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
-Tested-by: Peter Krempa <pkrempa@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-ID: <20250204211407.381505-4-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- blockdev.c                 | 14 ++++++++------
+ blockdev.c | 16 ++++++++++++++++
- tests/qemu-iotests/085.out |  4 ++--
+file changed, 16 insertions(+)
 files changed, 10 insertions(+), 8 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 external_snapshot_prepare(BlkActionState *common,
+@@ -XXX,XX +XXX,XX @@ static void external_snapshot_action(TransactionAction *action,
-     TransactionAction *action = common->action;
+         return;
      AioContext *aio_context;
      AioContext *old_context;
 +    uint64_t perm, shared;
      int ret;
      /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,
          goto out;
      }
--    if (bdrv_has_blk(state->new_bs)) {
 +    /*
-+     * Allow attaching a backing file to an overlay that's already in use only
++     * Older QEMU versions have allowed adding an active parent node to an
-+     * if the parents don't assume that they are already seeing a valid image.
++     * inactive child node. This is unsafe in the general case, but there is an
-+     * (Specifically, allow it as a mirror target, which is write-only access.)
++     * important use case, which is taking a VM snapshot with migration to file
 +     * and then adding an external snapshot while the VM is still stopped and
 +     * images are inactive. Requiring the user to explicitly create the overlay
 +     * as inactive would break compatibility, so just do it automatically here
 +     * to keep this working.
 +     */
-+    bdrv_get_cumulative_perm(state->new_bs, &perm, &shared);
++    if (bdrv_is_inactive(state->old_bs) && !bdrv_is_inactive(state->new_bs)) {
-+    if (perm & BLK_PERM_CONSISTENT_READ) {
++        ret = bdrv_inactivate(state->new_bs, errp);
-         error_setg(errp, "The overlay is already in use");
++        if (ret < 0) {
-         goto out;
++            return;
-     }
++        }
++    }
--    if (bdrv_op_is_blocked(state->new_bs, BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
++
--                           errp)) {
+     ret = bdrv_append(state->new_bs, state->old_bs, errp);
--        goto out;
+     if (ret < 0) {
--    }
+         return;
 -
      if (state->new_bs->backing != NULL) {
          error_setg(errp, "The overlay already has a backing image");
          goto out;
 diff --git a/tests/qemu-iotests/085.out b/tests/qemu-iotests/085.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/085.out
 +++ b/tests/qemu-iotests/085.out
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/12-snapshot-v0.IMGFMT', fmt=IMGFMT size=134217728 backing_f
  === Invalid command - cannot create a snapshot using a file BDS ===
  { 'execute': 'blockdev-snapshot', 'arguments': { 'node':'virtio0', 'overlay':'file_12' } }
 -{"error": {"class": "GenericError", "desc": "The overlay does not support backing images"}}
 +{"error": {"class": "GenericError", "desc": "The overlay is already in use"}}
  === Invalid command - snapshot node used as active layer ===
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/12-snapshot-v0.IMGFMT', fmt=IMGFMT size=134217728 backing_f
  === Invalid command - snapshot node used as backing hd ===
  { 'execute': 'blockdev-snapshot', 'arguments': { 'node': 'virtio0', 'overlay':'snap_11' } }
 -{"error": {"class": "GenericError", "desc": "Node 'snap_11' is busy: node is used as backing hd of 'snap_12'"}}
 +{"error": {"class": "GenericError", "desc": "The overlay is already in use"}}
  === Invalid command - snapshot node has a backing image ===
 --
-.20.1
+.48.1

-New patch
+[PULL 12/25] migration/block-active: Remove global active flag
+Block devices have an individual active state, a single global flag
+can't cover this correctly. This becomes more important as we allow
+users to manually manage which nodes are active or inactive.
+Now that it's allowed to call bdrv_inactivate_all() even when some
+nodes are already inactive, we can remove the flag and just
+unconditionally call bdrv_inactivate_all() and, more importantly,
+bdrv_activate_all() before we make use of the nodes.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-ID: <20250204211407.381505-5-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ migration/migration.h    |  3 ---
+ migration/block-active.c | 46 ----------------------------------------
+ migration/migration.c    |  8 -------
+files changed, 57 deletions(-)
+diff --git a/migration/migration.h b/migration/migration.h
+index XXXXXXX..XXXXXXX 100644
+--- a/migration/migration.h
++++ b/migration/migration.h
+@@ -XXX,XX +XXX,XX @@ void migration_bitmap_sync_precopy(bool last_stage);
+ void dirty_bitmap_mig_init(void);
+ bool should_send_vmdesc(void);
+-/* migration/block-active.c */
+-void migration_block_active_setup(bool active);
+-
+ #endif
+diff --git a/migration/block-active.c b/migration/block-active.c
+index XXXXXXX..XXXXXXX 100644
+--- a/migration/block-active.c
++++ b/migration/block-active.c
+@@ -XXX,XX +XXX,XX @@
+ #include "qemu/error-report.h"
+ #include "trace.h"
+-/*
+- * Migration-only cache to remember the block layer activation status.
+- * Protected by BQL.
+- *
+- * We need this because..
+- *
+- * - Migration can fail after block devices are invalidated (during
+- *   switchover phase).  When that happens, we need to be able to recover
+- *   the block drive status by re-activating them.
+- *
+- * - Currently bdrv_inactivate_all() is not safe to be invoked on top of
+- *   invalidated drives (even if bdrv_activate_all() is actually safe to be
+- *   called any time!).  It means remembering this could help migration to
+- *   make sure it won't invalidate twice in a row, crashing QEMU.  It can
+- *   happen when we migrate a PAUSED VM from host1 to host2, then migrate
+- *   again to host3 without starting it.  TODO: a cleaner solution is to
+- *   allow safe invoke of bdrv_inactivate_all() at anytime, like
+- *   bdrv_activate_all().
+- *
+- * For freshly started QEMU, the flag is initialized to TRUE reflecting the
+- * scenario where QEMU owns block device ownerships.
+- *
+- * For incoming QEMU taking a migration stream, the flag is initialized to
+- * FALSE reflecting that the incoming side doesn't own the block devices,
+- * not until switchover happens.
+- */
+-static bool migration_block_active;
+-
+-/* Setup the disk activation status */
+-void migration_block_active_setup(bool active)
+-{
+-    migration_block_active = active;
+-}
+-
+ bool migration_block_activate(Error **errp)
+ {
+     ERRP_GUARD();
+     assert(bql_locked());
+-    if (migration_block_active) {
+-        trace_migration_block_activation("active-skipped");
+-        return true;
+-    }
+-
+     trace_migration_block_activation("active");
+     bdrv_activate_all(errp);
+@@ -XXX,XX +XXX,XX @@ bool migration_block_activate(Error **errp)
+         return false;
+     }
+-    migration_block_active = true;
+     return true;
+ }
+@@ -XXX,XX +XXX,XX @@ bool migration_block_inactivate(void)
+     assert(bql_locked());
+-    if (!migration_block_active) {
+-        trace_migration_block_activation("inactive-skipped");
+-        return true;
+-    }
+-
+     trace_migration_block_activation("inactive");
+     ret = bdrv_inactivate_all();
+@@ -XXX,XX +XXX,XX @@ bool migration_block_inactivate(void)
+         return false;
+     }
+-    migration_block_active = false;
+     return true;
+ }
+diff --git a/migration/migration.c b/migration/migration.c
+index XXXXXXX..XXXXXXX 100644
+--- a/migration/migration.c
++++ b/migration/migration.c
+@@ -XXX,XX +XXX,XX @@ void qmp_migrate_incoming(const char *uri, bool has_channels,
+         return;
+     }
+-    /*
+-     * Newly setup incoming QEMU.  Mark the block active state to reflect
+-     * that the src currently owns the disks.
+-     */
+-    migration_block_active_setup(false);
+-
+     once = false;
+ }
+@@ -XXX,XX +XXX,XX @@ static void migration_instance_init(Object *obj)
+     ms->state = MIGRATION_STATUS_NONE;
+     ms->mbps = -1;
+     ms->pages_per_second = -1;
+-    /* Freshly started QEMU owns all the block devices */
+-    migration_block_active_setup(true);
+     qemu_sem_init(&ms->pause_sem, 0);
+     qemu_mutex_init(&ms->error_mutex);
+--
+.48.1

-New patch
+[PULL 13/25] block: Don't attach inactive child to active node
+An active node makes unrestricted use of its children and would possibly
+run into assertion failures when it operates on an inactive child node.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-ID: <20250204211407.381505-6-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block.c | 5 +++++
+file changed, 5 insertions(+)
+diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block.c
++++ b/block.c
+@@ -XXX,XX +XXX,XX @@ bdrv_attach_child_noperm(BlockDriverState *parent_bs,
+                    child_bs->node_name, child_name, parent_bs->node_name);
+         return NULL;
+     }
++    if (bdrv_is_inactive(child_bs) && !bdrv_is_inactive(parent_bs)) {
++        error_setg(errp, "Inactive '%s' can't be a %s child of active '%s'",
++                   child_bs->node_name, child_name, parent_bs->node_name);
++        return NULL;
++    }
+     bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
+     bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
+--
+.48.1

-[PULL 02/13] block: Make bdrv_get_cumulative_perm() public
+[PULL 14/25] block: Fix crash on block_resize on inactive node
+In order for block_resize to fail gracefully on an inactive node instead
+of crashing with an assertion failure in bdrv_co_write_req_prepare()
+(called from bdrv_co_truncate()), we need to check for inactive nodes
+also when they are attached as a root node and make sure that
+BLK_PERM_RESIZE isn't among the permissions allowed for inactive nodes.
+To this effect, don't enumerate the permissions that are incompatible
+with inactive nodes any more, but allow only BLK_PERM_CONSISTENT_READ
+for them.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20200310113831.27293-2-kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
-Reviewed-by: Peter Krempa <pkrempa@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-ID: <20250204211407.381505-7-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/block/block_int.h | 3 +++
+ block.c               | 7 +++++++
- block.c                   | 6 ++----
+ block/block-backend.c | 2 +-
-files changed, 5 insertions(+), 4 deletions(-)
+files changed, 8 insertions(+), 1 deletion(-)
-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 @@ BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
-                                   void *opaque, Error **errp);
- void bdrv_root_unref_child(BdrvChild *child);
-+void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
-+                              uint64_t *shared_perm);
-+
- /**
-  * Sets a BdrvChild's permissions.  Avoid if the parent is a BDS; use
-  * bdrv_child_refresh_perms() instead and make the parent's
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
-@@ -XXX,XX +XXX,XX @@ static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
+@@ -XXX,XX +XXX,XX @@ bdrv_attach_child_common(BlockDriverState *child_bs,
-                                  bool *tighten_restrictions, Error **errp);
+     assert(child_class->get_parent_desc);
- static void bdrv_child_abort_perm_update(BdrvChild *c);
+     GLOBAL_STATE_CODE();
- static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared);
--static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
++    if (bdrv_is_inactive(child_bs) && (perm & ~BLK_PERM_CONSISTENT_READ)) {
--                                     uint64_t *shared_perm);
++        g_autofree char *perm_names = bdrv_perm_names(perm);
++        error_setg(errp, "Permission '%s' unavailable on inactive node",
- typedef struct BlockReopenQueueEntry {
++                   perm_names);
-      bool prepared;
++        return NULL;
-@@ -XXX,XX +XXX,XX @@ static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,
++    }
 +
      new_child = g_new(BdrvChild, 1);
      *new_child = (BdrvChild) {
          .bs             = NULL,
 diff --git a/block/block-backend.c b/block/block-backend.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/block-backend.c
 +++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ static bool blk_can_inactivate(BlockBackend *blk)
       * guest.  For block job BBs that satisfy this, we can just allow
       * it.  This is the case for mirror job source, which is required
       * by libvirt non-shared block migration. */
 -    if (!(blk->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED))) {
 +    if (!(blk->perm & ~BLK_PERM_CONSISTENT_READ)) {
          return true;
      }
- }
 -static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
 -                                     uint64_t *shared_perm)
 +void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
 +                              uint64_t *shared_perm)
  {
      BdrvChild *c;
      uint64_t cumulative_perms = 0;
 --
-.20.1
+.48.1

-[PULL 08/13] qapi: Add '@allow-write-only-overlay' feature for 'blockdev-snapshot'
+[PULL 15/25] block: Add option to create inactive nodes
-From: Peter Krempa <pkrempa@redhat.com>
+In QEMU, nodes are automatically created inactive while expecting an
 incoming migration (i.e. RUN_STATE_INMIGRATE). In qemu-storage-daemon,
 the notion of runstates doesn't exist. It also wouldn't necessarily make
 sense to introduce it because a single daemon can serve multiple VMs
 that can be in different states.
-Anounce that 'blockdev-snapshot' command's permissions allow changing
+Therefore, allow the user to explicitly open images as inactive with a
-of the backing file if the 'consistent_read' permission is not required.
+new option. The default is as before: Nodes are usually active, except
 when created during RUN_STATE_INMIGRATE.
-This is useful for libvirt to allow late opening of the backing chain
-during a blockdev-mirror.
-Signed-off-by: Peter Krempa <pkrempa@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20200310113831.27293-8-kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-ID: <20250204211407.381505-8-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json | 9 ++++++++-
+ qapi/block-core.json         | 6 ++++++
-file changed, 8 insertions(+), 1 deletion(-)
+ include/block/block-common.h | 1 +
  block.c                      | 9 +++++++++
 files changed, 16 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 @@
  #
- # For the arguments, see the documentation of BlockdevSnapshot.
+ # @cache: cache-related options
  #
-+# Features:
++# @active: whether the block node should be activated (default: true).
-+# @allow-write-only-overlay: If present, the check whether this operation is safe
++#     Having inactive block nodes is useful primarily for migration because it
-+#                            was relaxed so that it can be used to change
++#     allows opening an image on the destination while the source is still
-+#                            backing file of a destination of a blockdev-mirror.
++#     holding locks for it. (Since 10.0)
 +#                            (since 5.0)
 +#
- # Since: 2.5
+ # @read-only: whether the block device should be read-only (default:
- #
+ #     false).  Note that some block drivers support only read-only
- # Example:
+ #     access, either generally or in certain configurations.  In this
 @@ -XXX,XX +XXX,XX @@
- #
+             '*node-name': 'str',
- ##
+             '*discard': 'BlockdevDiscardOptions',
- { 'command': 'blockdev-snapshot',
+             '*cache': 'BlockdevCacheOptions',
--  'data': 'BlockdevSnapshot' }
++            '*active': 'bool',
-+  'data': 'BlockdevSnapshot',
+             '*read-only': 'bool',
-+  'features': [ 'allow-write-only-overlay' ] }
+             '*auto-read-only': 'bool',
+             '*force-share': 'bool',
- ##
+diff --git a/include/block/block-common.h b/include/block/block-common.h
- # @change-backing-file:
+index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block-common.h
 +++ b/include/block/block-common.h
@@ -XXX,XX +XXX,XX @@ typedef enum {
  #define BDRV_OPT_AUTO_READ_ONLY "auto-read-only"
  #define BDRV_OPT_DISCARD        "discard"
  #define BDRV_OPT_FORCE_SHARE    "force-share"
 +#define BDRV_OPT_ACTIVE         "active"
  #define BDRV_SECTOR_BITS   9
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
@@ -XXX,XX +XXX,XX @@ static void update_flags_from_options(int *flags, QemuOpts *opts)
      if (qemu_opt_get_bool_del(opts, BDRV_OPT_AUTO_READ_ONLY, false)) {
          *flags |= BDRV_O_AUTO_RDONLY;
      }
 +
 +    if (!qemu_opt_get_bool_del(opts, BDRV_OPT_ACTIVE, true)) {
 +        *flags |= BDRV_O_INACTIVE;
 +    }
  }
  static void update_options_from_flags(QDict *options, int flags)
@@ -XXX,XX +XXX,XX @@ QemuOptsList bdrv_runtime_opts = {
              .type = QEMU_OPT_BOOL,
              .help = "Ignore flush requests",
          },
 +        {
 +            .name = BDRV_OPT_ACTIVE,
 +            .type = QEMU_OPT_BOOL,
 +            .help = "Node is activated",
 +        },
          {
              .name = BDRV_OPT_READ_ONLY,
              .type = QEMU_OPT_BOOL,
 --
-.20.1
+.48.1

-[PULL 11/13] block.c: adding bdrv_co_delete_file
+[PULL 16/25] block: Add blockdev-set-active QMP command
-From: Daniel Henrique Barboza <danielhb413@gmail.com>
+The system emulator tries to automatically activate and inactivate block
 nodes at the right point during migration. However, there are still
 cases where it's necessary that the user can do this manually.
-Using the new 'bdrv_co_delete_file' interface, a pure co_routine function
+Images are only activated on the destination VM of a migration when the
-'bdrv_co_delete_file' inside block.c can can be used in a way similar of
+VM is actually resumed. If the VM was paused, this doesn't happen
-the existing bdrv_create_file to to clean up a created file.
+automatically. The user may want to perform some operation on a block
 device (e.g. taking a snapshot or starting a block job) without also
 resuming the VM yet. This is an example where a manual command is
 necessary.
-We're creating a pure co_routine because the only caller of
+Another example is VM migration when the image files are opened by an
-'bdrv_co_delete_file' will be already in co_routine context, thus there
+external qemu-storage-daemon instance on each side. In this case, the
-is no need to add all the machinery to check for qemu_in_coroutine() and
+process that needs to hand over the images isn't even part of the
-create a separated co_routine to do the job.
+migration and can't know when the migration completes. Management tools
 need a way to explicitly inactivate images on the source and activate
 them on the destination.
-Suggested-by: Daniel P. Berrangé <berrange@redhat.com>
+This adds a new blockdev-set-active QMP command that lets the user
-Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
+change the status of individual nodes (this is necessary in
-Message-Id: <20200130213907.2830642-3-danielhb413@gmail.com>
+qemu-storage-daemon because it could be serving multiple VMs and only
 one of them migrates at a time). For convenience, operating on all
 devices (like QEMU does automatically during migration) is offered as an
 option, too, and can be used in the context of single VM.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 Acked-by: Fabiano Rosas <farosas@suse.de>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-ID: <20250204211407.381505-9-kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/block/block.h |  1 +
+ qapi/block-core.json               | 32 ++++++++++++++++++++++++++++++
- block.c               | 26 ++++++++++++++++++++++++++
+ include/block/block-global-state.h |  3 +++
-files changed, 27 insertions(+)
+ block.c                            | 21 ++++++++++++++++++++
  blockdev.c                         | 32 ++++++++++++++++++++++++++++++
 files changed, 88 insertions(+)
-diff --git a/include/block/block.h b/include/block/block.h
+diff --git a/qapi/block-core.json b/qapi/block-core.json
 index XXXXXXX..XXXXXXX 100644
---- a/include/block/block.h
+--- a/qapi/block-core.json
-+++ b/include/block/block.h
++++ b/qapi/block-core.json
-@@ -XXX,XX +XXX,XX @@ bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,
+@@ -XXX,XX +XXX,XX @@
- int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
+ { 'command': 'blockdev-del', 'data': { 'node-name': 'str' },
-                               Error **errp);
+   'allow-preconfig': true }
- void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base);
-+int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp);
++##
++# @blockdev-set-active:
++#
- typedef struct BdrvCheckResult {
++# Activate or inactivate a block device. Use this to manage the handover of
 +# block devices on migration with qemu-storage-daemon.
 +#
 +# Activating a node automatically activates all of its child nodes first.
 +# Inactivating a node automatically inactivates any of its child nodes that are
 +# not in use by a still active node.
 +#
 +# @node-name: Name of the graph node to activate or inactivate. By default, all
 +#     nodes are affected by the operation.
 +#
 +# @active: true if the nodes should be active when the command returns success,
 +#     false if they should be inactive.
 +#
 +# Since: 10.0
 +#
 +# .. qmp-example::
 +#
 +#     -> { "execute": "blockdev-set-active",
 +#          "arguments": {
 +#               "node-name": "node0",
 +#               "active": false
 +#          }
 +#        }
 +#     <- { "return": {} }
 +##
 +{ 'command': 'blockdev-set-active',
 +  'data': { '*node-name': 'str', 'active': 'bool' },
 +  'allow-preconfig': true }
 +
  ##
  # @BlockdevCreateOptionsFile:
  #
 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 @@ bdrv_activate(BlockDriverState *bs, Error **errp);
  int coroutine_fn no_co_wrapper_bdrv_rdlock
  bdrv_co_activate(BlockDriverState *bs, Error **errp);
 +int no_coroutine_fn
 +bdrv_inactivate(BlockDriverState *bs, Error **errp);
 +
  void bdrv_activate_all(Error **errp);
  int bdrv_inactivate_all(void);
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
-@@ -XXX,XX +XXX,XX @@ int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
+@@ -XXX,XX +XXX,XX @@ bdrv_inactivate_recurse(BlockDriverState *bs, bool top_level)
-     }
+     return 0;
  }
-+int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp)
++int bdrv_inactivate(BlockDriverState *bs, Error **errp)
 +{
-+    Error *local_err = NULL;
 +    int ret;
 +
-+    assert(bs != NULL);
++    GLOBAL_STATE_CODE();
 +    GRAPH_RDLOCK_GUARD_MAINLOOP();
 +
-+    if (!bs->drv) {
++    if (bdrv_has_bds_parent(bs, true)) {
-+        error_setg(errp, "Block node '%s' is not opened", bs->filename);
++        error_setg(errp, "Node has active parent node");
-+        return -ENOMEDIUM;
++        return -EPERM;
 +    }
 +
-+    if (!bs->drv->bdrv_co_delete_file) {
++    ret = bdrv_inactivate_recurse(bs, true);
-+        error_setg(errp, "Driver '%s' does not support image deletion",
++    if (ret < 0) {
-+                   bs->drv->format_name);
++        error_setg_errno(errp, -ret, "Failed to inactivate node");
-+        return -ENOTSUP;
++        return ret;
 +    }
 +
-+    ret = bs->drv->bdrv_co_delete_file(bs, &local_err);
++    return 0;
 +    if (ret < 0) {
 +        error_propagate(errp, local_err);
 +    }
 +
 +    return ret;
 +}
 +
- /**
+ int bdrv_inactivate_all(void)
-  * Try to get @bs's logical and physical block size.
+ {
-  * On success, store them in @bsz struct and return 0.
+     BlockDriverState *bs = NULL;
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_del(const char *node_name, Error **errp)
      bdrv_unref(bs);
  }
 +void qmp_blockdev_set_active(const char *node_name, bool active, Error **errp)
 +{
 +    int ret;
 +
 +    GLOBAL_STATE_CODE();
 +    GRAPH_RDLOCK_GUARD_MAINLOOP();
 +
 +    if (!node_name) {
 +        if (active) {
 +            bdrv_activate_all(errp);
 +        } else {
 +            ret = bdrv_inactivate_all();
 +            if (ret < 0) {
 +                error_setg_errno(errp, -ret, "Failed to inactivate all nodes");
 +            }
 +        }
 +    } else {
 +        BlockDriverState *bs = bdrv_find_node(node_name);
 +        if (!bs) {
 +            error_setg(errp, "Failed to find node with node-name='%s'",
 +                       node_name);
 +            return;
 +        }
 +
 +        if (active) {
 +            bdrv_activate(bs, errp);
 +        } else {
 +            bdrv_inactivate(bs, errp);
 +        }
 +    }
 +}
 +
  static BdrvChild * GRAPH_RDLOCK
  bdrv_find_child(BlockDriverState *parent_bs, const char *child_name)
  {
 --
-.20.1
+.48.1

-New patch
+[PULL 17/25] block: Support inactive nodes in blk_insert_bs()
+Device models have a relatively complex way to set up their block
+backends, in which blk_attach_dev() sets blk->disable_perm = true.
+We want to support inactive images in exports, too, so that
+qemu-storage-daemon can be used with migration. Because they don't use
+blk_attach_dev(), they need another way to set this flag. The most
+convenient is to do this automatically when an inactive node is attached
+to a BlockBackend that can be inactivated.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-ID: <20250204211407.381505-10-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/block-backend.c | 14 ++++++++++++--
+file changed, 12 insertions(+), 2 deletions(-)
+diff --git a/block/block-backend.c b/block/block-backend.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/block-backend.c
++++ b/block/block-backend.c
+@@ -XXX,XX +XXX,XX @@ void blk_remove_bs(BlockBackend *blk)
+ int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
+ {
+     ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
++    uint64_t perm, shared_perm;
+     GLOBAL_STATE_CODE();
+     bdrv_ref(bs);
+     bdrv_graph_wrlock();
++
++    if ((bs->open_flags & BDRV_O_INACTIVE) && blk_can_inactivate(blk)) {
++        blk->disable_perm = true;
++        perm = 0;
++        shared_perm = BLK_PERM_ALL;
++    } else {
++        perm = blk->perm;
++        shared_perm = blk->shared_perm;
++    }
++
+     blk->root = bdrv_root_attach_child(bs, "root", &child_root,
+                                        BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
+-                                       blk->perm, blk->shared_perm,
+-                                       blk, errp);
++                                       perm, shared_perm, blk, errp);
+     bdrv_graph_wrunlock();
+     if (blk->root == NULL) {
+         return -EPERM;
+--
+.48.1

-New patch
+[PULL 18/25] block/export: Don't ignore image activation error in blk_exp_add()
+Currently, block exports can't handle inactive images correctly.
+Incoming write requests would run into assertion failures. Make sure
+that we return an error when creating an export can't activate the
+image.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-ID: <20250204211407.381505-11-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/export/export.c | 6 +++++-
+file changed, 5 insertions(+), 1 deletion(-)
+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)
+      * ctx was acquired in the caller.
+      */
+     bdrv_graph_rdlock_main_loop();
+-    bdrv_activate(bs, NULL);
++    ret = bdrv_activate(bs, errp);
++    if (ret < 0) {
++        bdrv_graph_rdunlock_main_loop();
++        goto fail;
++    }
+     bdrv_graph_rdunlock_main_loop();
+     perm = BLK_PERM_CONSISTENT_READ;
+--
+.48.1

-[PULL 06/13] block: Fix cross-AioContext blockdev-snapshot
+[PULL 19/25] block: Drain nodes before inactivating them
-external_snapshot_prepare() tries to move the overlay to the AioContext
+So far the assumption has always been that if we try to inactivate a
-of the backing file (the snapshotted node). However, it's possible that
+node, it is already idle. This doesn't hold true any more if we allow
-this doesn't work, but the backing file can instead be moved to the
+inactivating exported nodes because we can't know when new external
-overlay's AioContext (e.g. opening the backing chain for a mirror
+requests come in.
 target).
-bdrv_append() already indirectly uses bdrv_attach_node(), which takes
+Drain the node around setting BDRV_O_INACTIVE so that requests can't
-care to move nodes to make sure they use the same AioContext and which
+start operating on an active node and then in the middle it suddenly
-tries both directions.
+becomes inactive. With this change, it's enough for exports to check
+for new requests that they operate on an active node (or, like reads,
-So the problem has a simple fix: Just delete the unnecessary extra
+are allowed even on an inactive node).
 bdrv_try_set_aio_context() call in external_snapshot_prepare() and
 instead assert in bdrv_append() that both nodes were indeed moved to the
 same AioContext.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20200310113831.27293-6-kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
-Tested-by: Peter Krempa <pkrempa@redhat.com>
+Message-ID: <20250204211407.381505-12-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>
 ---
- block.c    |  1 +
+ block.c | 2 ++
- blockdev.c | 16 ----------------
+file changed, 2 insertions(+)
 files changed, 1 insertion(+), 16 deletions(-)
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
-@@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
+@@ -XXX,XX +XXX,XX @@ bdrv_inactivate_recurse(BlockDriverState *bs, bool top_level)
-     bdrv_ref(from);
+         return -EPERM;
      assert(qemu_get_current_aio_context() == qemu_get_aio_context());
 +    assert(bdrv_get_aio_context(from) == bdrv_get_aio_context(to));
      bdrv_drained_begin(from);
      /* Put all parents into @list and calculate their cumulative permissions */
 diff --git a/blockdev.c b/blockdev.c
 index XXXXXXX..XXXXXXX 100644
 --- a/blockdev.c
 +++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,
                               DO_UPCAST(ExternalSnapshotState, common, common);
      TransactionAction *action = common->action;
      AioContext *aio_context;
 -    AioContext *old_context;
      uint64_t perm, shared;
 -    int ret;
      /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
       * purpose but a different set of parameters */
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,
          goto out;
      }
--    /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
++    bdrv_drained_begin(bs);
--    old_context = bdrv_get_aio_context(state->new_bs);
+     bs->open_flags |= BDRV_O_INACTIVE;
--    aio_context_release(aio_context);
++    bdrv_drained_end(bs);
--    aio_context_acquire(old_context);
--
+     /*
--    ret = bdrv_try_set_aio_context(state->new_bs, aio_context, errp);
+      * Update permissions, they may differ for inactive nodes.
 -
 -    aio_context_release(old_context);
 -    aio_context_acquire(aio_context);
 -
 -    if (ret < 0) {
 -        goto out;
 -    }
 -
      /* This removes our old bs and adds the new bs. This is an operation that
       * can fail, so we need to do it in .prepare; undoing it for abort is
       * always possible. */
 --
-.20.1
+.48.1

-New patch
+[PULL 20/25] block/export: Add option to allow export of inactive nodes
+Add an option in BlockExportOptions to allow creating an export on an
+inactive node without activating the node. This mode needs to be
+explicitly supported by the export type (so that it doesn't perform any
+operations that are forbidden for inactive nodes), so this patch alone
+doesn't allow this option to be successfully used yet.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-ID: <20250204211407.381505-13-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ qapi/block-export.json | 10 +++++++++-
+ include/block/export.h |  3 +++
+ block/export/export.c  | 31 +++++++++++++++++++++----------
+files changed, 33 insertions(+), 11 deletions(-)
+diff --git a/qapi/block-export.json b/qapi/block-export.json
+index XXXXXXX..XXXXXXX 100644
+--- a/qapi/block-export.json
++++ b/qapi/block-export.json
+@@ -XXX,XX +XXX,XX @@
+ #     cannot be moved to the iothread.  The default is false.
+ #     (since: 5.2)
+ #
++# @allow-inactive: If true, the export allows the exported node to be inactive.
++#     If it is created for an inactive block node, the node remains inactive. If
++#     the export type doesn't support running on an inactive node, an error is
++#     returned. If false, inactive block nodes are automatically activated before
++#     creating the export and trying to inactivate them later fails.
++#     (since: 10.0; default: false)
++#
+ # Since: 4.2
+ ##
+ { 'union': 'BlockExportOptions',
+@@ -XXX,XX +XXX,XX @@
+             '*iothread': 'str',
+             'node-name': 'str',
+             '*writable': 'bool',
+-            '*writethrough': 'bool' },
++            '*writethrough': 'bool',
++            '*allow-inactive': 'bool' },
+   'discriminator': 'type',
+   'data': {
+       'nbd': 'BlockExportOptionsNbd',
+diff --git a/include/block/export.h b/include/block/export.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/block/export.h
++++ b/include/block/export.h
+@@ -XXX,XX +XXX,XX @@ typedef struct BlockExportDriver {
+      */
+     size_t instance_size;
++    /* True if the export type supports running on an inactive node */
++    bool supports_inactive;
++
+     /* Creates and starts a new block export */
+     int (*create)(BlockExport *, BlockExportOptions *, Error **);
+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 @@ static const BlockExportDriver *blk_exp_find_driver(BlockExportType type)
+ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
+ {
+     bool fixed_iothread = export->has_fixed_iothread && export->fixed_iothread;
++    bool allow_inactive = export->has_allow_inactive && export->allow_inactive;
+     const BlockExportDriver *drv;
+     BlockExport *exp = NULL;
+     BlockDriverState *bs;
+@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
+         }
+     }
+-    /*
+-     * Block exports are used for non-shared storage migration. Make sure
+-     * that BDRV_O_INACTIVE is cleared and the image is ready for write
+-     * access since the export could be available before migration handover.
+-     * ctx was acquired in the caller.
+-     */
+     bdrv_graph_rdlock_main_loop();
+-    ret = bdrv_activate(bs, errp);
+-    if (ret < 0) {
+-        bdrv_graph_rdunlock_main_loop();
+-        goto fail;
++    if (allow_inactive) {
++        if (!drv->supports_inactive) {
++            error_setg(errp, "Export type does not support inactive exports");
++            bdrv_graph_rdunlock_main_loop();
++            goto fail;
++        }
++    } else {
++        /*
++         * Block exports are used for non-shared storage migration. Make sure
++         * that BDRV_O_INACTIVE is cleared and the image is ready for write
++         * access since the export could be available before migration handover.
++         */
++        ret = bdrv_activate(bs, errp);
++        if (ret < 0) {
++            bdrv_graph_rdunlock_main_loop();
++            goto fail;
++        }
+     }
+     bdrv_graph_rdunlock_main_loop();
+@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
+     if (!fixed_iothread) {
+         blk_set_allow_aio_context_change(blk, true);
+     }
++    if (allow_inactive) {
++        blk_set_force_allow_inactivate(blk);
++    }
+     ret = blk_insert_bs(blk, bs, errp);
+     if (ret < 0) {
+--
+.48.1

-[PULL 12/13] crypto.c: cleanup created file when block_crypto_co_create_opts_luks fails
+[PULL 21/25] nbd/server: Support inactive nodes
-From: Daniel Henrique Barboza <danielhb413@gmail.com>
+In order to support running an NBD export on inactive nodes, we must
 make sure to return errors for any operations that aren't allowed on
 inactive nodes. Reads are the only operation we know we need for
 inactive images, so to err on the side of caution, return errors for
 everything else, even if some operations could possibly be okay.
-When using a non-UTF8 secret to create a volume using qemu-img, the
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-following error happens:
+Acked-by: Fabiano Rosas <farosas@suse.de>
+Message-ID: <20250204211407.381505-14-kwolf@redhat.com>
-$ qemu-img create -f luks --object secret,id=vol_1_encrypt0,file=vol_resize_pool.vol_1.secret.qzVQrI -o key-secret=vol_1_encrypt0 /var/tmp/pool_target/vol_1 10240K
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 Formatting '/var/tmp/pool_target/vol_1', fmt=luks size=10485760 key-secret=vol_1_encrypt0
 qemu-img: /var/tmp/pool_target/vol_1: Data from secret vol_1_encrypt0 is not valid UTF-8
 However, the created file '/var/tmp/pool_target/vol_1' is left behind in the
 file system after the failure. This behavior can be observed when creating
 the volume using Libvirt, via 'virsh vol-create', and then getting "volume
 target path already exist" errors when trying to re-create the volume.
 The volume file is created inside block_crypto_co_create_opts_luks(), in
 block/crypto.c. If the bdrv_create_file() call is successful but any
 succeeding step fails*, the existing 'fail' label does not take into
 account the created file, leaving it behind.
 This patch changes block_crypto_co_create_opts_luks() to delete
 'filename' in case of failure. A failure in this point means that
 the volume is now truncated/corrupted, so even if 'filename' was an
 existing volume before calling qemu-img, it is now unusable. Deleting
 the file it is not much worse than leaving it in the filesystem in
 this scenario, and we don't have to deal with checking the file
 pre-existence in the code.
 * in our case, block_crypto_co_create_generic calls qcrypto_block_create,
 which calls qcrypto_block_luks_create, and this function fails when
 calling qcrypto_secret_lookup_as_utf8.
 Reported-by: Srikanth Aithal <bssrikanth@in.ibm.com>
 Suggested-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
 Message-Id: <20200130213907.2830642-4-danielhb413@gmail.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/crypto.c | 18 ++++++++++++++++++
+ nbd/server.c | 17 +++++++++++++++++
-file changed, 18 insertions(+)
+file changed, 17 insertions(+)
-diff --git a/block/crypto.c b/block/crypto.c
+diff --git a/nbd/server.c b/nbd/server.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/crypto.c
+--- a/nbd/server.c
-+++ b/block/crypto.c
++++ b/nbd/server.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static void nbd_export_delete(BlockExport *blk_exp)
- #include "qapi/error.h"
+ const BlockExportDriver blk_exp_nbd = {
- #include "qemu/module.h"
+     .type               = BLOCK_EXPORT_TYPE_NBD,
- #include "qemu/option.h"
+     .instance_size      = sizeof(NBDExport),
-+#include "qemu/cutils.h"
++    .supports_inactive  = true,
- #include "crypto.h"
+     .create             = nbd_export_create,
+     .delete             = nbd_export_delete,
- typedef struct BlockCrypto BlockCrypto;
+     .request_shutdown   = nbd_export_request_shutdown,
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
+@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nbd_handle_request(NBDClient *client,
+     NBDExport *exp = client->exp;
-     ret = 0;
+     char *msg;
- fail:
+     size_t i;
-+    /*
++    bool inactive;
-+     * If an error occurred, delete 'filename'. Even if the file existed
++
-+     * beforehand, it has been truncated and corrupted in the process.
++    WITH_GRAPH_RDLOCK_GUARD() {
-+     */
++        inactive = bdrv_is_inactive(blk_bs(exp->common.blk));
-+    if (ret && bs) {
++        if (inactive) {
-+        Error *local_delete_err = NULL;
++            switch (request->type) {
-+        int r_del = bdrv_co_delete_file(bs, &local_delete_err);
++            case NBD_CMD_READ:
-+        /*
++                /* These commands are allowed on inactive nodes */
-+         * ENOTSUP will happen if the block driver doesn't support
++                break;
-+         * the 'bdrv_co_delete_file' interface. This is a predictable
++            default:
-+         * scenario and shouldn't be reported back to the user.
++                /* Return an error for the rest */
-+         */
++                return nbd_send_generic_reply(client, request, -EPERM,
-+        if ((r_del < 0) && (r_del != -ENOTSUP)) {
++                                              "export is inactive", errp);
-+            error_report_err(local_delete_err);
++            }
 +        }
 +    }
-+
-     bdrv_unref(bs);
+     switch (request->type) {
-     qapi_free_QCryptoBlockCreateOptions(create_opts);
+     case NBD_CMD_CACHE:
      qobject_unref(cryptoopts);
 --
-.20.1
+.48.1

-[PULL 05/13] iotests: Test mirror with temporarily disabled target backing file
+[PULL 22/25] iotests: Add filter_qtest()
-The newly tested scenario is a common live storage migration scenario:
+The open-coded form of this filter has been copied into enough tests
-The target node is opened without a backing file so that the active
+that it's better to move it into iotests.py.
 layer is mirrored while its backing chain can be copied in the
 background.
 The backing chain should be attached to the mirror target node when
 finalising the job, just before switching the users of the source node
 to the new copy (at which point the mirror job still has a reference to
 the node). drive-mirror did this automatically, but with blockdev-mirror
 this is the job of the QMP client.
 This patch adds test cases for two ways to achieve the desired result,
 using either x-blockdev-reopen or blockdev-snapshot.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20200310113831.27293-5-kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
-Reviewed-by: Peter Krempa <pkrempa@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
 Message-ID: <20250204211407.381505-15-kwolf@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/155     | 56 ++++++++++++++++++++++++++++++++++----
+ tests/qemu-iotests/iotests.py                 | 4 ++++
- tests/qemu-iotests/155.out |  4 +--
+ tests/qemu-iotests/041                        | 4 +---
-files changed, 53 insertions(+), 7 deletions(-)
+ tests/qemu-iotests/165                        | 4 +---
  tests/qemu-iotests/tests/copy-before-write    | 3 +--
  tests/qemu-iotests/tests/migrate-bitmaps-test | 7 +++----
 files changed, 10 insertions(+), 12 deletions(-)
-diff --git a/tests/qemu-iotests/155 b/tests/qemu-iotests/155
+diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/iotests.py
 +++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@ def _filter(_key, value):
  def filter_nbd_exports(output: str) -> str:
      return re.sub(r'((min|opt|max) block): [0-9]+', r'\1: XXX', output)
 +def filter_qtest(output: str) -> str:
 +    output = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', output)
 +    output = re.sub(r'\n?\[I \+\d+\.\d+\] CLOSED\n?$', '', output)
 +    return output
  Msg = TypeVar('Msg', Dict[str, Any], List[Any], str)
 diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041
 index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/155
+--- a/tests/qemu-iotests/041
-+++ b/tests/qemu-iotests/155
++++ b/tests/qemu-iotests/041
-@@ -XXX,XX +XXX,XX @@ target_img = os.path.join(iotests.test_dir, 'target.' + iotests.imgfmt)
+@@ -XXX,XX +XXX,XX @@ class TestRepairQuorum(iotests.QMPTestCase):
- #                      image during runtime, only makes sense if
- #                      target_blockdev_backing is not None
+         # Check the full error message now
- #                      (None: same as target_backing)
+         self.vm.shutdown()
-+# target_open_with_backing: If True, the target image is added with its backing
+-        log = self.vm.get_log()
-+#                           chain opened right away. If False, blockdev-add
+-        log = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', log)
-+#                           opens it without a backing file and job completion
++        log = iotests.filter_qtest(self.vm.get_log())
-+#                           is supposed to open the backing chain.
+         log = re.sub(r'^Formatting.*\n', '', log)
+-        log = re.sub(r'\n\[I \+\d+\.\d+\] CLOSED\n?$', '', log)
- class BaseClass(iotests.QMPTestCase):
+         log = re.sub(r'^%s: ' % os.path.basename(iotests.qemu_prog), '', log)
-     target_blockdev_backing = None
-     target_real_backing = None
+         self.assertEqual(log,
-+    target_open_with_backing = True
+diff --git a/tests/qemu-iotests/165 b/tests/qemu-iotests/165
+index XXXXXXX..XXXXXXX 100755
-     def setUp(self):
+--- a/tests/qemu-iotests/165
-         qemu_img('create', '-f', iotests.imgfmt, back0_img, '1440K')
++++ b/tests/qemu-iotests/165
-@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
+@@ -XXX,XX +XXX,XX @@ class TestPersistentDirtyBitmap(iotests.QMPTestCase):
-                 options = { 'node-name': 'target',
+         self.vm.shutdown()
-                             'driver': iotests.imgfmt,
-                             'file': { 'driver': 'file',
+         #catch 'Persistent bitmaps are lost' possible error
-+                                      'node-name': 'target-file',
+-        log = self.vm.get_log()
-                                       'filename': target_img } }
+-        log = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', log)
--                if self.target_blockdev_backing:
+-        log = re.sub(r'\[I \+\d+\.\d+\] CLOSED\n?$', '', log)
--                    options['backing'] = self.target_blockdev_backing
++        log = iotests.filter_qtest(self.vm.get_log())
-+
+         if log:
-+                if not self.target_open_with_backing:
+             print(log)
-+                        options['backing'] = None
-+                elif self.target_blockdev_backing:
+diff --git a/tests/qemu-iotests/tests/copy-before-write b/tests/qemu-iotests/tests/copy-before-write
-+                        options['backing'] = self.target_blockdev_backing
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/tests/copy-before-write
-                 result = self.vm.qmp('blockdev-add', **options)
++++ b/tests/qemu-iotests/tests/copy-before-write
-                 self.assert_qmp(result, 'return', {})
+@@ -XXX,XX +XXX,XX @@ class TestCbwError(iotests.QMPTestCase):
-@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
- # cmd: Mirroring command to execute, either drive-mirror or blockdev-mirror
+         self.vm.shutdown()
+         log = self.vm.get_log()
- class MirrorBaseClass(BaseClass):
+-        log = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', log)
-+    def openBacking(self):
+-        log = re.sub(r'\[I \+\d+\.\d+\] CLOSED\n?$', '', log)
-+        pass
++        log = iotests.filter_qtest(log)
-+
+         log = iotests.filter_qemu_io(log)
-     def runMirror(self, sync):
+         return log
-         if self.cmd == 'blockdev-mirror':
-             result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source',
+diff --git a/tests/qemu-iotests/tests/migrate-bitmaps-test b/tests/qemu-iotests/tests/migrate-bitmaps-test
--                                 sync=sync, target='target')
+index XXXXXXX..XXXXXXX 100755
-+                                 sync=sync, target='target',
+--- a/tests/qemu-iotests/tests/migrate-bitmaps-test
-+                                 auto_finalize=False)
++++ b/tests/qemu-iotests/tests/migrate-bitmaps-test
-         else:
+@@ -XXX,XX +XXX,XX @@ class TestDirtyBitmapMigration(iotests.QMPTestCase):
-             if self.existing:
-                 mode = 'existing'
+         # catch 'Could not reopen qcow2 layer: Bitmap already exists'
-@@ -XXX,XX +XXX,XX @@ class MirrorBaseClass(BaseClass):
+         # possible error
-             result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source',
+-        log = self.vm_a.get_log()
-                                  sync=sync, target=target_img,
+-        log = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', log)
-                                  format=iotests.imgfmt, mode=mode,
+-        log = re.sub(r'^(wrote .* bytes at offset .*\n.*KiB.*ops.*sec.*\n){3}',
--                                 node_name='target')
++        log = iotests.filter_qtest(self.vm_a.get_log())
-+                                 node_name='target', auto_finalize=False)
++        log = re.sub(r'^(wrote .* bytes at offset .*\n'
++                     r'.*KiB.*ops.*sec.*\n?){3}',
-         self.assert_qmp(result, 'return', {})
+                      '', log)
+-        log = re.sub(r'\[I \+\d+\.\d+\] CLOSED\n?$', '', log)
--        self.complete_and_wait('mirror-job')
+         self.assertEqual(log, '')
-+        self.vm.run_job('mirror-job', use_log=False, auto_finalize=False,
-+                        pre_finalize=self.openBacking, auto_dismiss=True)
+         # test that bitmap is still persistent
      def testFull(self):
          self.runMirror('full')
@@ -XXX,XX +XXX,XX @@ class TestBlockdevMirrorForcedBacking(MirrorBaseClass):
      target_blockdev_backing = { 'driver': 'null-co' }
      target_real_backing = 'null-co://'
 +# Attach the backing chain only during completion, with blockdev-reopen
 +class TestBlockdevMirrorReopen(MirrorBaseClass):
 +    cmd = 'blockdev-mirror'
 +    existing = True
 +    target_backing = 'null-co://'
 +    target_open_with_backing = False
 +
 +    def openBacking(self):
 +        if not self.target_open_with_backing:
 +            result = self.vm.qmp('blockdev-add', node_name="backing",
 +                                 driver="null-co")
 +            self.assert_qmp(result, 'return', {})
 +            result = self.vm.qmp('x-blockdev-reopen', node_name="target",
 +                                 driver=iotests.imgfmt, file="target-file",
 +                                 backing="backing")
 +            self.assert_qmp(result, 'return', {})
 +
 +# Attach the backing chain only during completion, with blockdev-snapshot
 +class TestBlockdevMirrorSnapshot(MirrorBaseClass):
 +    cmd = 'blockdev-mirror'
 +    existing = True
 +    target_backing = 'null-co://'
 +    target_open_with_backing = False
 +
 +    def openBacking(self):
 +        if not self.target_open_with_backing:
 +            result = self.vm.qmp('blockdev-add', node_name="backing",
 +                                 driver="null-co")
 +            self.assert_qmp(result, 'return', {})
 +            result = self.vm.qmp('blockdev-snapshot', node="backing",
 +                                 overlay="target")
 +            self.assert_qmp(result, 'return', {})
  class TestCommit(BaseClass):
      existing = False
 diff --git a/tests/qemu-iotests/155.out b/tests/qemu-iotests/155.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/155.out
 +++ b/tests/qemu-iotests/155.out
@@ -XXX,XX +XXX,XX @@
 -...................
 +.........................
  ----------------------------------------------------------------------
 -Ran 19 tests
 +Ran 25 tests
  OK
 --
-.20.1
+.48.1

-[PULL 13/13] qemu-iotests: adding LUKS cleanup for non-UTF8 secret error
+[PULL 23/25] iotests: Add qsd-migrate case
-From: Daniel Henrique Barboza <danielhb413@gmail.com>
+Test that it's possible to migrate a VM that uses an image on shared
 storage through qemu-storage-daemon.
-This patch adds a new test file to exercise the case where
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-qemu-img fails to complete for the LUKS format when a non-UTF8
+Acked-by: Fabiano Rosas <farosas@suse.de>
-secret is used.
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Message-ID: <20250204211407.381505-16-kwolf@redhat.com>
-Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-Id: <20200130213907.2830642-5-danielhb413@gmail.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/282     | 67 ++++++++++++++++++++++++++++++++++++++
+ tests/qemu-iotests/tests/qsd-migrate     | 140 +++++++++++++++++++++++
- tests/qemu-iotests/282.out | 11 +++++++
+ tests/qemu-iotests/tests/qsd-migrate.out |  59 ++++++++++
- tests/qemu-iotests/group   |  1 +
+files changed, 199 insertions(+)
-files changed, 79 insertions(+)
+ create mode 100755 tests/qemu-iotests/tests/qsd-migrate
- create mode 100755 tests/qemu-iotests/282
+ create mode 100644 tests/qemu-iotests/tests/qsd-migrate.out
  create mode 100644 tests/qemu-iotests/282.out
-diff --git a/tests/qemu-iotests/282 b/tests/qemu-iotests/282
+diff --git a/tests/qemu-iotests/tests/qsd-migrate b/tests/qemu-iotests/tests/qsd-migrate
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/282
++++ b/tests/qemu-iotests/tests/qsd-migrate
 @@ -XXX,XX +XXX,XX @@
-+#!/usr/bin/env bash
++#!/usr/bin/env python3
-+#
++# group: rw quick
-+# Test qemu-img file cleanup for LUKS when using a non-UTF8 secret
++#
-+#
++# Copyright (C) Red Hat, Inc.
 +# Copyright (C) 2020, IBM Corporation.
 +#
 +# This program is free software; you can redistribute it and/or modify
 +# it under the terms of the GNU General Public License as published by
 +# the Free Software Foundation; either version 2 of the License, or
 +# (at your option) any later version.
 ...
 +# GNU General Public License for more details.
 +#
 +# You should have received a copy of the GNU General Public License
 +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 +#
-+
++# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
-+seq=`basename $0`
++
-+echo "QA output created by $seq"
++import iotests
 +
-+status=1    # failure is the default!
++from iotests import filter_qemu_io, filter_qtest
-+TEST_IMAGE_FILE='vol.img'
++
-+
++iotests.script_initialize(supported_fmts=['generic'],
-+_cleanup()
++                          supported_protocols=['file'],
-+{
++                          supported_platforms=['linux'])
-+  _cleanup_test_img
++
-+  rm non_utf8_secret
++with iotests.FilePath('disk.img') as path, \
-+  rm -f $TEST_IMAGE_FILE
++     iotests.FilePath('nbd-src.sock', base_dir=iotests.sock_dir) as nbd_src, \
-+}
++     iotests.FilePath('nbd-dst.sock', base_dir=iotests.sock_dir) as nbd_dst, \
-+trap "_cleanup; exit \$status" 0 1 2 3 15
++     iotests.FilePath('migrate.sock', base_dir=iotests.sock_dir) as mig_sock, \
-+
++     iotests.VM(path_suffix="-src") as vm_src, \
-+# get standard environment, filters and checks
++     iotests.VM(path_suffix="-dst") as vm_dst:
-+. ./common.rc
++
-+. ./common.filter
++    img_size = '10M'
 +
-+_supported_fmt luks
++    iotests.log('Preparing disk...')
-+_supported_proto generic
++    iotests.qemu_img_create('-f', iotests.imgfmt, path, img_size)
-+_unsupported_proto vxhs
++
-+
++    iotests.log('Launching source QSD...')
-+echo "== Create non-UTF8 secret =="
++    qsd_src = iotests.QemuStorageDaemon(
-+echo -n -e '\x3a\x3c\x3b\xff' > non_utf8_secret
++        '--blockdev', f'file,node-name=disk-file,filename={path}',
-+SECRET="secret,id=sec0,file=non_utf8_secret"
++        '--blockdev', f'{iotests.imgfmt},file=disk-file,node-name=disk-fmt',
-+
++        '--nbd-server', f'addr.type=unix,addr.path={nbd_src}',
-+echo "== Throws an error because of invalid UTF-8 secret =="
++        '--export', 'nbd,id=exp0,node-name=disk-fmt,writable=true,'
-+$QEMU_IMG create -f $IMGFMT --object $SECRET -o "key-secret=sec0" $TEST_IMAGE_FILE 4M
++                    'allow-inactive=true',
-+
++        qmp=True,
-+echo "== Image file should not exist after the error =="
++    )
-+if test -f "$TEST_IMAGE_FILE"; then
++
-+    exit 1
++    iotests.log('Launching source VM...')
-+fi
++    vm_src.add_args('-blockdev', f'nbd,node-name=disk,server.type=unix,'
-+
++                                 f'server.path={nbd_src},export=disk-fmt')
-+echo "== Create a stub image file and run qemu-img again =="
++    vm_src.add_args('-device', 'virtio-blk,drive=disk,id=virtio0')
-+touch $TEST_IMAGE_FILE
++    vm_src.launch()
-+$QEMU_IMG create -f $IMGFMT --object $SECRET -o "key-secret=sec0" $TEST_IMAGE_FILE 4M
++
-+
++    iotests.log('Launching destination QSD...')
-+echo "== Pre-existing image file should also be deleted after the error =="
++    qsd_dst = iotests.QemuStorageDaemon(
-+if test -f "$TEST_IMAGE_FILE"; then
++        '--blockdev', f'file,node-name=disk-file,filename={path},active=off',
-+    exit 1
++        '--blockdev', f'{iotests.imgfmt},file=disk-file,node-name=disk-fmt,'
-+fi
++                      f'active=off',
-+
++        '--nbd-server', f'addr.type=unix,addr.path={nbd_dst}',
-+# success, all done
++        '--export', 'nbd,id=exp0,node-name=disk-fmt,writable=true,'
-+echo "*** done"
++                    'allow-inactive=true',
-+rm -f $seq.full
++        qmp=True,
-+status=0
++        instance_id='b',
-diff --git a/tests/qemu-iotests/282.out b/tests/qemu-iotests/282.out
++    )
 +
 +    iotests.log('Launching destination VM...')
 +    vm_dst.add_args('-blockdev', f'nbd,node-name=disk,server.type=unix,'
 +                                 f'server.path={nbd_dst},export=disk-fmt')
 +    vm_dst.add_args('-device', 'virtio-blk,drive=disk,id=virtio0')
 +    vm_dst.add_args('-incoming', f'unix:{mig_sock}')
 +    vm_dst.launch()
 +
 +    iotests.log('\nTest I/O on the source')
 +    vm_src.hmp_qemu_io('virtio0/virtio-backend', 'write -P 0x11 0 4k',
 +                       use_log=True, qdev=True)
 +    vm_src.hmp_qemu_io('virtio0/virtio-backend', 'read -P 0x11 0 4k',
 +                       use_log=True, qdev=True)
 +
 +    iotests.log('\nStarting migration...')
 +
 +    mig_caps = [
 +        {'capability': 'events', 'state': True},
 +        {'capability': 'pause-before-switchover', 'state': True},
 +    ]
 +    vm_src.qmp_log('migrate-set-capabilities', capabilities=mig_caps)
 +    vm_dst.qmp_log('migrate-set-capabilities', capabilities=mig_caps)
 +    vm_src.qmp_log('migrate', uri=f'unix:{mig_sock}',
 +                   filters=[iotests.filter_qmp_testfiles])
 +
 +    vm_src.event_wait('MIGRATION',
 +                      match={'data': {'status': 'pre-switchover'}})
 +
 +    iotests.log('\nPre-switchover: Reconfigure QSD instances')
 +
 +    iotests.log(qsd_src.qmp('blockdev-set-active', {'active': False}))
 +
 +    # Reading is okay from both sides while the image is inactive. Note that
 +    # the destination may have stale data until it activates the image, though.
 +    vm_src.hmp_qemu_io('virtio0/virtio-backend', 'read -P 0x11 0 4k',
 +                       use_log=True, qdev=True)
 +    vm_dst.hmp_qemu_io('virtio0/virtio-backend', 'read 0 4k',
 +                       use_log=True, qdev=True)
 +
 +    iotests.log(qsd_dst.qmp('blockdev-set-active', {'active': True}))
 +
 +    iotests.log('\nCompleting migration...')
 +
 +    vm_src.qmp_log('migrate-continue', state='pre-switchover')
 +    vm_dst.event_wait('MIGRATION', match={'data': {'status': 'completed'}})
 +
 +    iotests.log('\nTest I/O on the destination')
 +
 +    # Now the destination must see what the source wrote
 +    vm_dst.hmp_qemu_io('virtio0/virtio-backend', 'read -P 0x11 0 4k',
 +                       use_log=True, qdev=True)
 +
 +    # And be able to overwrite it
 +    vm_dst.hmp_qemu_io('virtio0/virtio-backend', 'write -P 0x22 0 4k',
 +                       use_log=True, qdev=True)
 +    vm_dst.hmp_qemu_io('virtio0/virtio-backend', 'read -P 0x22 0 4k',
 +                       use_log=True, qdev=True)
 +
 +    iotests.log('\nDone')
 +
 +    vm_src.shutdown()
 +    iotests.log('\n--- vm_src log ---')
 +    log = vm_src.get_log()
 +    if log:
 +        iotests.log(log, [filter_qtest, filter_qemu_io])
 +    qsd_src.stop()
 +
 +    vm_dst.shutdown()
 +    iotests.log('\n--- vm_dst log ---')
 +    log = vm_dst.get_log()
 +    if log:
 +        iotests.log(log, [filter_qtest, filter_qemu_io])
 +    qsd_dst.stop()
 diff --git a/tests/qemu-iotests/tests/qsd-migrate.out b/tests/qemu-iotests/tests/qsd-migrate.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/282.out
++++ b/tests/qemu-iotests/tests/qsd-migrate.out
 @@ -XXX,XX +XXX,XX @@
-+QA output created by 282
++Preparing disk...
-+== Create non-UTF8 secret ==
++Launching source QSD...
-+== Throws an error because of invalid UTF-8 secret ==
++Launching source VM...
-+qemu-img: vol.img: Data from secret sec0 is not valid UTF-8
++Launching destination QSD...
-+Formatting 'vol.img', fmt=luks size=4194304 key-secret=sec0
++Launching destination VM...
-+== Image file should not exist after the error ==
++
-+== Create a stub image file and run qemu-img again ==
++Test I/O on the source
-+qemu-img: vol.img: Data from secret sec0 is not valid UTF-8
++{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"write -P 0x11 0 4k\""}}
-+Formatting 'vol.img', fmt=luks size=4194304 key-secret=sec0
++{"return": ""}
-+== Pre-existing image file should also be deleted after the error ==
++{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"read -P 0x11 0 4k\""}}
-+ *** done
++{"return": ""}
-diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
++
-index XXXXXXX..XXXXXXX 100644
++Starting migration...
---- a/tests/qemu-iotests/group
++{"execute": "migrate-set-capabilities", "arguments": {"capabilities": [{"capability": "events", "state": true}, {"capability": "pause-before-switchover", "state": true}]}}
-+++ b/tests/qemu-iotests/group
++{"return": {}}
-@@ -XXX,XX +XXX,XX @@
++{"execute": "migrate-set-capabilities", "arguments": {"capabilities": [{"capability": "events", "state": true}, {"capability": "pause-before-switchover", "state": true}]}}
-rw backing quick
++{"return": {}}
-rw migration quick
++{"execute": "migrate", "arguments": {"uri": "unix:SOCK_DIR/PID-migrate.sock"}}
-rw quick
++{"return": {}}
-+282 rw img quick
++
-auto quick
++Pre-switchover: Reconfigure QSD instances
-rw
++{"return": {}}
-rw quick
++{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"read -P 0x11 0 4k\""}}
 +{"return": ""}
 +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"read 0 4k\""}}
 +{"return": ""}
 +{"return": {}}
 +
 +Completing migration...
 +{"execute": "migrate-continue", "arguments": {"state": "pre-switchover"}}
 +{"return": {}}
 +
 +Test I/O on the destination
 +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"read -P 0x11 0 4k\""}}
 +{"return": ""}
 +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"write -P 0x22 0 4k\""}}
 +{"return": ""}
 +{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"read -P 0x22 0 4k\""}}
 +{"return": ""}
 +
 +Done
 +
 +--- vm_src log ---
 +wrote 4096/4096 bytes at offset 0
 +4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 4096/4096 bytes at offset 0
 +4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 4096/4096 bytes at offset 0
 +4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +--- vm_dst log ---
 +read 4096/4096 bytes at offset 0
 +4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 4096/4096 bytes at offset 0
 +4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 4096/4096 bytes at offset 0
 +4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 4096/4096 bytes at offset 0
 +4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 --
-.20.1
+.48.1

-[PULL 04/13] iotests: Fix run_job() with use_log=False
+[PULL 24/25] iotests: Add (NBD-based) tests for inactive nodes
-The 'job-complete' QMP command should be run with qmp() rather than
+This tests different types of operations on inactive block nodes
-qmp_log() if use_log=False is passed.
+(including graph changes, block jobs and NBD exports) to make sure that
 users manually activating and inactivating nodes doesn't break things.
 Support for inactive nodes in other export types will have to come with
 separate test cases because they have different dependencies like blkio
 or root permissions and we don't want to disable this basic test when
 they are not fulfilled.
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20200310113831.27293-4-kwolf@redhat.com>
+Acked-by: Fabiano Rosas <farosas@suse.de>
-Reviewed-by: Peter Krempa <pkrempa@redhat.com>
+Message-ID: <20250204211407.381505-17-kwolf@redhat.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/iotests.py | 5 ++++-
+ tests/qemu-iotests/iotests.py                 |   4 +
-file changed, 4 insertions(+), 1 deletion(-)
+ tests/qemu-iotests/tests/inactive-node-nbd    | 303 ++++++++++++++++++
  .../qemu-iotests/tests/inactive-node-nbd.out  | 239 ++++++++++++++
 files changed, 546 insertions(+)
  create mode 100755 tests/qemu-iotests/tests/inactive-node-nbd
  create mode 100644 tests/qemu-iotests/tests/inactive-node-nbd.out
 diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/iotests.py
 +++ b/tests/qemu-iotests/iotests.py
-@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
+@@ -XXX,XX +XXX,XX @@ def add_incoming(self, addr):
-                         if use_log:
+         self._args.append(addr)
-                             log('Job failed: %s' % (j['error']))
+         return self
-             elif status == 'ready':
--                self.qmp_log('job-complete', id=job)
++    def add_paused(self):
-+                if use_log:
++        self._args.append('-S')
-+                    self.qmp_log('job-complete', id=job)
++        return self
-+                else:
++
-+                    self.qmp('job-complete', id=job)
+     def hmp(self, command_line: str, use_log: bool = False) -> QMPMessage:
-             elif status == 'pending' and not auto_finalize:
+         cmd = 'human-monitor-command'
-                 if pre_finalize:
+         kwargs: Dict[str, Any] = {'command-line': command_line}
-                     pre_finalize()
+diff --git a/tests/qemu-iotests/tests/inactive-node-nbd b/tests/qemu-iotests/tests/inactive-node-nbd
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/tests/inactive-node-nbd
@@ -XXX,XX +XXX,XX @@
 +#!/usr/bin/env python3
 +# group: rw quick
 +#
 +# Copyright (C) Red Hat, Inc.
 +#
 +# This program is free software; you can redistribute it and/or modify
 +# it under the terms of the GNU General Public License as published by
 +# the Free Software Foundation; either version 2 of the License, or
 +# (at your option) any later version.
 +#
 +# This program is distributed in the hope that it will be useful,
 +# but WITHOUT ANY WARRANTY; without even the implied warranty of
 +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 +# GNU General Public License for more details.
 +#
 +# You should have received a copy of the GNU General Public License
 +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 +#
 +# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
 +
 +import iotests
 +
 +from iotests import QemuIoInteractive
 +from iotests import filter_qemu_io, filter_qtest, filter_qmp_testfiles
 +
 +iotests.script_initialize(supported_fmts=['generic'],
 +                          supported_protocols=['file'],
 +                          supported_platforms=['linux'])
 +
 +def get_export(node_name='disk-fmt', allow_inactive=None):
 +    exp = {
 +        'id': 'exp0',
 +        'type': 'nbd',
 +        'node-name': node_name,
 +        'writable': True,
 +    }
 +
 +    if allow_inactive is not None:
 +        exp['allow-inactive'] = allow_inactive
 +
 +    return exp
 +
 +def node_is_active(_vm, node_name):
 +    nodes = _vm.cmd('query-named-block-nodes', flat=True)
 +    node = next(n for n in nodes if n['node-name'] == node_name)
 +    return node['active']
 +
 +with iotests.FilePath('disk.img') as path, \
 +     iotests.FilePath('snap.qcow2') as snap_path, \
 +     iotests.FilePath('snap2.qcow2') as snap2_path, \
 +     iotests.FilePath('target.img') as target_path, \
 +     iotests.FilePath('nbd.sock', base_dir=iotests.sock_dir) as nbd_sock, \
 +     iotests.VM() as vm:
 +
 +    img_size = '10M'
 +
 +    iotests.log('Preparing disk...')
 +    iotests.qemu_img_create('-f', iotests.imgfmt, path, img_size)
 +    iotests.qemu_img_create('-f', iotests.imgfmt, target_path, img_size)
 +
 +    iotests.qemu_img_create('-f', 'qcow2', '-b', path, '-F', iotests.imgfmt,
 +                            snap_path)
 +    iotests.qemu_img_create('-f', 'qcow2', '-b', snap_path, '-F', 'qcow2',
 +                            snap2_path)
 +
 +    iotests.log('Launching VM...')
 +    vm.add_blockdev(f'file,node-name=disk-file,filename={path}')
 +    vm.add_blockdev(f'{iotests.imgfmt},file=disk-file,node-name=disk-fmt,'
 +                     'active=off')
 +    vm.add_blockdev(f'file,node-name=target-file,filename={target_path}')
 +    vm.add_blockdev(f'{iotests.imgfmt},file=target-file,node-name=target-fmt')
 +    vm.add_blockdev(f'file,node-name=snap-file,filename={snap_path}')
 +    vm.add_blockdev(f'file,node-name=snap2-file,filename={snap2_path}')
 +
 +    # Actually running the VM activates all images
 +    vm.add_paused()
 +
 +    vm.launch()
 +    vm.qmp_log('nbd-server-start',
 +                addr={'type': 'unix', 'data':{'path': nbd_sock}},
 +                filters=[filter_qmp_testfiles])
 +
 +    iotests.log('\n=== Creating export of inactive node ===')
 +
 +    iotests.log('\nExports activate nodes without allow-inactive')
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    vm.qmp_log('block-export-add', **get_export())
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    vm.qmp_log('query-block-exports')
 +    vm.qmp_log('block-export-del', id='exp0')
 +    vm.event_wait('BLOCK_EXPORT_DELETED')
 +    vm.qmp_log('query-block-exports')
 +
 +    iotests.log('\nExports activate nodes with allow-inactive=false')
 +    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    vm.qmp_log('block-export-add', **get_export(allow_inactive=False))
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    vm.qmp_log('query-block-exports')
 +    vm.qmp_log('block-export-del', id='exp0')
 +    vm.event_wait('BLOCK_EXPORT_DELETED')
 +    vm.qmp_log('query-block-exports')
 +
 +    iotests.log('\nExport leaves nodes inactive with allow-inactive=true')
 +    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    vm.qmp_log('block-export-add', **get_export(allow_inactive=True))
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    vm.qmp_log('query-block-exports')
 +    vm.qmp_log('block-export-del', id='exp0')
 +    vm.event_wait('BLOCK_EXPORT_DELETED')
 +    vm.qmp_log('query-block-exports')
 +
 +    iotests.log('\n=== Inactivating node with existing export ===')
 +
 +    iotests.log('\nInactivating nodes with an export fails without '
 +                'allow-inactive')
 +    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=True)
 +    vm.qmp_log('block-export-add', **get_export(node_name='disk-fmt'))
 +    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    vm.qmp_log('query-block-exports')
 +    vm.qmp_log('block-export-del', id='exp0')
 +    vm.event_wait('BLOCK_EXPORT_DELETED')
 +    vm.qmp_log('query-block-exports')
 +
 +    iotests.log('\nInactivating nodes with an export fails with '
 +                'allow-inactive=false')
 +    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=True)
 +    vm.qmp_log('block-export-add',
 +               **get_export(node_name='disk-fmt', allow_inactive=False))
 +    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    vm.qmp_log('query-block-exports')
 +    vm.qmp_log('block-export-del', id='exp0')
 +    vm.event_wait('BLOCK_EXPORT_DELETED')
 +    vm.qmp_log('query-block-exports')
 +
 +    iotests.log('\nInactivating nodes with an export works with '
 +                'allow-inactive=true')
 +    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=True)
 +    vm.qmp_log('block-export-add',
 +               **get_export(node_name='disk-fmt', allow_inactive=True))
 +    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    vm.qmp_log('query-block-exports')
 +    vm.qmp_log('block-export-del', id='exp0')
 +    vm.event_wait('BLOCK_EXPORT_DELETED')
 +    vm.qmp_log('query-block-exports')
 +
 +    iotests.log('\n=== Inactive nodes with parent ===')
 +
 +    iotests.log('\nInactivating nodes with an active parent fails')
 +    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=True)
 +    vm.qmp_log('blockdev-set-active', node_name='disk-file', active=False)
 +    iotests.log('disk-file active: %s' % node_is_active(vm, 'disk-file'))
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +
 +    iotests.log('\nInactivating nodes with an inactive parent works')
 +    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
 +    vm.qmp_log('blockdev-set-active', node_name='disk-file', active=False)
 +    iotests.log('disk-file active: %s' % node_is_active(vm, 'disk-file'))
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +
 +    iotests.log('\nCreating active parent node with an inactive child fails')
 +    vm.qmp_log('blockdev-add', driver='raw', file='disk-fmt',
 +               node_name='disk-filter')
 +    vm.qmp_log('blockdev-add', driver='raw', file='disk-fmt',
 +               node_name='disk-filter', active=True)
 +
 +    iotests.log('\nCreating inactive parent node with an inactive child works')
 +    vm.qmp_log('blockdev-add', driver='raw', file='disk-fmt',
 +               node_name='disk-filter', active=False)
 +    vm.qmp_log('blockdev-del', node_name='disk-filter')
 +
 +    iotests.log('\n=== Resizing an inactive node ===')
 +    vm.qmp_log('block_resize', node_name='disk-fmt', size=16*1024*1024)
 +
 +    iotests.log('\n=== Taking a snapshot of an inactive node ===')
 +
 +    iotests.log('\nActive overlay over inactive backing file automatically '
 +                'makes both inactive for compatibility')
 +    vm.qmp_log('blockdev-add', driver='qcow2', node_name='snap-fmt',
 +               file='snap-file', backing=None)
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
 +    vm.qmp_log('blockdev-snapshot', node='disk-fmt', overlay='snap-fmt')
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
 +    vm.qmp_log('blockdev-del', node_name='snap-fmt')
 +
 +    iotests.log('\nInactive overlay over inactive backing file just works')
 +    vm.qmp_log('blockdev-add', driver='qcow2', node_name='snap-fmt',
 +               file='snap-file', backing=None, active=False)
 +    vm.qmp_log('blockdev-snapshot', node='disk-fmt', overlay='snap-fmt')
 +
 +    iotests.log('\n=== Block jobs with inactive nodes ===')
 +
 +    iotests.log('\nStreaming into an inactive node')
 +    vm.qmp_log('block-stream', device='snap-fmt',
 +               filters=[iotests.filter_qmp_generated_node_ids])
 +
 +    iotests.log('\nCommitting an inactive root node (active commit)')
 +    vm.qmp_log('block-commit', job_id='job0', device='snap-fmt',
 +               filters=[iotests.filter_qmp_generated_node_ids])
 +
 +    iotests.log('\nCommitting an inactive intermediate node to inactive base')
 +    vm.qmp_log('blockdev-add', driver='qcow2', node_name='snap2-fmt',
 +               file='snap2-file', backing='snap-fmt', active=False)
 +
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
 +    iotests.log('snap2-fmt active: %s' % node_is_active(vm, 'snap2-fmt'))
 +
 +    vm.qmp_log('block-commit', job_id='job0', device='snap2-fmt',
 +               top_node='snap-fmt',
 +               filters=[iotests.filter_qmp_generated_node_ids])
 +
 +    iotests.log('\nCommitting an inactive intermediate node to active base')
 +    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=True)
 +    vm.qmp_log('block-commit', job_id='job0', device='snap2-fmt',
 +               top_node='snap-fmt',
 +               filters=[iotests.filter_qmp_generated_node_ids])
 +
 +    iotests.log('\nMirror from inactive source to active target')
 +    vm.qmp_log('blockdev-mirror', job_id='job0', device='snap2-fmt',
 +               target='target-fmt', sync='full',
 +               filters=[iotests.filter_qmp_generated_node_ids])
 +
 +    iotests.log('\nMirror from active source to inactive target')
 +
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
 +    iotests.log('snap2-fmt active: %s' % node_is_active(vm, 'snap2-fmt'))
 +    iotests.log('target-fmt active: %s' % node_is_active(vm, 'target-fmt'))
 +
 +    # Activating snap2-fmt recursively activates the whole backing chain
 +    vm.qmp_log('blockdev-set-active', node_name='snap2-fmt', active=True)
 +    vm.qmp_log('blockdev-set-active', node_name='target-fmt', active=False)
 +
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
 +    iotests.log('snap2-fmt active: %s' % node_is_active(vm, 'snap2-fmt'))
 +    iotests.log('target-fmt active: %s' % node_is_active(vm, 'target-fmt'))
 +
 +    vm.qmp_log('blockdev-mirror', job_id='job0', device='snap2-fmt',
 +               target='target-fmt', sync='full',
 +               filters=[iotests.filter_qmp_generated_node_ids])
 +
 +    iotests.log('\nBackup from active source to inactive target')
 +
 +    vm.qmp_log('blockdev-backup', job_id='job0', device='snap2-fmt',
 +               target='target-fmt', sync='full',
 +               filters=[iotests.filter_qmp_generated_node_ids])
 +
 +    iotests.log('\nBackup from inactive source to active target')
 +
 +    # Inactivating snap2-fmt recursively inactivates the whole backing chain
 +    vm.qmp_log('blockdev-set-active', node_name='snap2-fmt', active=False)
 +    vm.qmp_log('blockdev-set-active', node_name='target-fmt', active=True)
 +
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
 +    iotests.log('snap2-fmt active: %s' % node_is_active(vm, 'snap2-fmt'))
 +    iotests.log('target-fmt active: %s' % node_is_active(vm, 'target-fmt'))
 +
 +    vm.qmp_log('blockdev-backup', job_id='job0', device='snap2-fmt',
 +               target='target-fmt', sync='full',
 +               filters=[iotests.filter_qmp_generated_node_ids])
 +
 +    iotests.log('\n=== Accessing export on inactive node ===')
 +
 +    # Use the target node because it has the right image format and isn't the
 +    # (read-only) backing file of a qcow2 node
 +    vm.qmp_log('blockdev-set-active', node_name='target-fmt', active=False)
 +    vm.qmp_log('block-export-add',
 +               **get_export(node_name='target-fmt', allow_inactive=True))
 +
 +    # The read should succeed, everything else should fail gracefully
 +    qemu_io = QemuIoInteractive('-f', 'raw',
 +                                f'nbd+unix:///target-fmt?socket={nbd_sock}')
 +    iotests.log(qemu_io.cmd('read 0 64k'), filters=[filter_qemu_io])
 +    iotests.log(qemu_io.cmd('write 0 64k'), filters=[filter_qemu_io])
 +    iotests.log(qemu_io.cmd('write -z 0 64k'), filters=[filter_qemu_io])
 +    iotests.log(qemu_io.cmd('write -zu 0 64k'), filters=[filter_qemu_io])
 +    iotests.log(qemu_io.cmd('discard 0 64k'), filters=[filter_qemu_io])
 +    iotests.log(qemu_io.cmd('flush'), filters=[filter_qemu_io])
 +    iotests.log(qemu_io.cmd('map'), filters=[filter_qemu_io])
 +    qemu_io.close()
 +
 +    iotests.log('\n=== Resuming VM activates all images ===')
 +    vm.qmp_log('cont')
 +
 +    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
 +    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
 +    iotests.log('snap2-fmt active: %s' % node_is_active(vm, 'snap2-fmt'))
 +    iotests.log('target-fmt active: %s' % node_is_active(vm, 'target-fmt'))
 +
 +    iotests.log('\nShutting down...')
 +    vm.shutdown()
 +    log = vm.get_log()
 +    if log:
 +        iotests.log(log, [filter_qtest, filter_qemu_io])
 diff --git a/tests/qemu-iotests/tests/inactive-node-nbd.out b/tests/qemu-iotests/tests/inactive-node-nbd.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
 +++ b/tests/qemu-iotests/tests/inactive-node-nbd.out
@@ -XXX,XX +XXX,XX @@
 +Preparing disk...
 +Launching VM...
 +{"execute": "nbd-server-start", "arguments": {"addr": {"data": {"path": "SOCK_DIR/PID-nbd.sock"}, "type": "unix"}}}
 +{"return": {}}
 +
 +=== Creating export of inactive node ===
 +
 +Exports activate nodes without allow-inactive
 +disk-fmt active: False
 +{"execute": "block-export-add", "arguments": {"id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
 +{"return": {}}
 +disk-fmt active: True
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
 +{"execute": "block-export-del", "arguments": {"id": "exp0"}}
 +{"return": {}}
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": []}
 +
 +Exports activate nodes with allow-inactive=false
 +{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
 +{"return": {}}
 +disk-fmt active: False
 +{"execute": "block-export-add", "arguments": {"allow-inactive": false, "id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
 +{"return": {}}
 +disk-fmt active: True
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
 +{"execute": "block-export-del", "arguments": {"id": "exp0"}}
 +{"return": {}}
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": []}
 +
 +Export leaves nodes inactive with allow-inactive=true
 +{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
 +{"return": {}}
 +disk-fmt active: False
 +{"execute": "block-export-add", "arguments": {"allow-inactive": true, "id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
 +{"return": {}}
 +disk-fmt active: False
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
 +{"execute": "block-export-del", "arguments": {"id": "exp0"}}
 +{"return": {}}
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": []}
 +
 +=== Inactivating node with existing export ===
 +
 +Inactivating nodes with an export fails without allow-inactive
 +{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "disk-fmt"}}
 +{"return": {}}
 +{"execute": "block-export-add", "arguments": {"id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
 +{"return": {}}
 +{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
 +{"error": {"class": "GenericError", "desc": "Failed to inactivate node: Operation not permitted"}}
 +disk-fmt active: True
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
 +{"execute": "block-export-del", "arguments": {"id": "exp0"}}
 +{"return": {}}
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": []}
 +
 +Inactivating nodes with an export fails with allow-inactive=false
 +{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "disk-fmt"}}
 +{"return": {}}
 +{"execute": "block-export-add", "arguments": {"allow-inactive": false, "id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
 +{"return": {}}
 +{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
 +{"error": {"class": "GenericError", "desc": "Failed to inactivate node: Operation not permitted"}}
 +disk-fmt active: True
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
 +{"execute": "block-export-del", "arguments": {"id": "exp0"}}
 +{"return": {}}
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": []}
 +
 +Inactivating nodes with an export works with allow-inactive=true
 +{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "disk-fmt"}}
 +{"return": {}}
 +{"execute": "block-export-add", "arguments": {"allow-inactive": true, "id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
 +{"return": {}}
 +{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
 +{"return": {}}
 +disk-fmt active: False
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
 +{"execute": "block-export-del", "arguments": {"id": "exp0"}}
 +{"return": {}}
 +{"execute": "query-block-exports", "arguments": {}}
 +{"return": []}
 +
 +=== Inactive nodes with parent ===
 +
 +Inactivating nodes with an active parent fails
 +{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "disk-fmt"}}
 +{"return": {}}
 +{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-file"}}
 +{"error": {"class": "GenericError", "desc": "Node has active parent node"}}
 +disk-file active: True
 +disk-fmt active: True
 +
 +Inactivating nodes with an inactive parent works
 +{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
 +{"return": {}}
 +{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-file"}}
 +{"return": {}}
 +disk-file active: False
 +disk-fmt active: False
 +
 +Creating active parent node with an inactive child fails
 +{"execute": "blockdev-add", "arguments": {"driver": "raw", "file": "disk-fmt", "node-name": "disk-filter"}}
 +{"error": {"class": "GenericError", "desc": "Inactive 'disk-fmt' can't be a file child of active 'disk-filter'"}}
 +{"execute": "blockdev-add", "arguments": {"active": true, "driver": "raw", "file": "disk-fmt", "node-name": "disk-filter"}}
 +{"error": {"class": "GenericError", "desc": "Inactive 'disk-fmt' can't be a file child of active 'disk-filter'"}}
 +
 +Creating inactive parent node with an inactive child works
 +{"execute": "blockdev-add", "arguments": {"active": false, "driver": "raw", "file": "disk-fmt", "node-name": "disk-filter"}}
 +{"return": {}}
 +{"execute": "blockdev-del", "arguments": {"node-name": "disk-filter"}}
 +{"return": {}}
 +
 +=== Resizing an inactive node ===
 +{"execute": "block_resize", "arguments": {"node-name": "disk-fmt", "size": 16777216}}
 +{"error": {"class": "GenericError", "desc": "Permission 'resize' unavailable on inactive node"}}
 +
 +=== Taking a snapshot of an inactive node ===
 +
 +Active overlay over inactive backing file automatically makes both inactive for compatibility
 +{"execute": "blockdev-add", "arguments": {"backing": null, "driver": "qcow2", "file": "snap-file", "node-name": "snap-fmt"}}
 +{"return": {}}
 +disk-fmt active: False
 +snap-fmt active: True
 +{"execute": "blockdev-snapshot", "arguments": {"node": "disk-fmt", "overlay": "snap-fmt"}}
 +{"return": {}}
 +disk-fmt active: False
 +snap-fmt active: False
 +{"execute": "blockdev-del", "arguments": {"node-name": "snap-fmt"}}
 +{"return": {}}
 +
 +Inactive overlay over inactive backing file just works
 +{"execute": "blockdev-add", "arguments": {"active": false, "backing": null, "driver": "qcow2", "file": "snap-file", "node-name": "snap-fmt"}}
 +{"return": {}}
 +{"execute": "blockdev-snapshot", "arguments": {"node": "disk-fmt", "overlay": "snap-fmt"}}
 +{"return": {}}
 +
 +=== Block jobs with inactive nodes ===
 +
 +Streaming into an inactive node
 +{"execute": "block-stream", "arguments": {"device": "snap-fmt"}}
 +{"error": {"class": "GenericError", "desc": "Could not create node: Inactive 'snap-fmt' can't be a file child of active 'NODE_NAME'"}}
 +
 +Committing an inactive root node (active commit)
 +{"execute": "block-commit", "arguments": {"device": "snap-fmt", "job-id": "job0"}}
 +{"error": {"class": "GenericError", "desc": "Inactive 'snap-fmt' can't be a backing child of active 'NODE_NAME'"}}
 +
 +Committing an inactive intermediate node to inactive base
 +{"execute": "blockdev-add", "arguments": {"active": false, "backing": "snap-fmt", "driver": "qcow2", "file": "snap2-file", "node-name": "snap2-fmt"}}
 +{"return": {}}
 +disk-fmt active: False
 +snap-fmt active: False
 +snap2-fmt active: False
 +{"execute": "block-commit", "arguments": {"device": "snap2-fmt", "job-id": "job0", "top-node": "snap-fmt"}}
 +{"error": {"class": "GenericError", "desc": "Inactive 'snap-fmt' can't be a backing child of active 'NODE_NAME'"}}
 +
 +Committing an inactive intermediate node to active base
 +{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "disk-fmt"}}
 +{"return": {}}
 +{"execute": "block-commit", "arguments": {"device": "snap2-fmt", "job-id": "job0", "top-node": "snap-fmt"}}
 +{"error": {"class": "GenericError", "desc": "Inactive 'snap-fmt' can't be a backing child of active 'NODE_NAME'"}}
 +
 +Mirror from inactive source to active target
 +{"execute": "blockdev-mirror", "arguments": {"device": "snap2-fmt", "job-id": "job0", "sync": "full", "target": "target-fmt"}}
 +{"error": {"class": "GenericError", "desc": "Inactive 'snap2-fmt' can't be a backing child of active 'NODE_NAME'"}}
 +
 +Mirror from active source to inactive target
 +disk-fmt active: True
 +snap-fmt active: False
 +snap2-fmt active: False
 +target-fmt active: True
 +{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "snap2-fmt"}}
 +{"return": {}}
 +{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "target-fmt"}}
 +{"return": {}}
 +disk-fmt active: True
 +snap-fmt active: True
 +snap2-fmt active: True
 +target-fmt active: False
 +{"execute": "blockdev-mirror", "arguments": {"device": "snap2-fmt", "job-id": "job0", "sync": "full", "target": "target-fmt"}}
 +{"error": {"class": "GenericError", "desc": "Permission 'write' unavailable on inactive node"}}
 +
 +Backup from active source to inactive target
 +{"execute": "blockdev-backup", "arguments": {"device": "snap2-fmt", "job-id": "job0", "sync": "full", "target": "target-fmt"}}
 +{"error": {"class": "GenericError", "desc": "Could not create node: Inactive 'target-fmt' can't be a target child of active 'NODE_NAME'"}}
 +
 +Backup from inactive source to active target
 +{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "snap2-fmt"}}
 +{"return": {}}
 +{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "target-fmt"}}
 +{"return": {}}
 +disk-fmt active: False
 +snap-fmt active: False
 +snap2-fmt active: False
 +target-fmt active: True
 +{"execute": "blockdev-backup", "arguments": {"device": "snap2-fmt", "job-id": "job0", "sync": "full", "target": "target-fmt"}}
 +{"error": {"class": "GenericError", "desc": "Could not create node: Inactive 'snap2-fmt' can't be a file child of active 'NODE_NAME'"}}
 +
 +=== Accessing export on inactive node ===
 +{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "target-fmt"}}
 +{"return": {}}
 +{"execute": "block-export-add", "arguments": {"allow-inactive": true, "id": "exp0", "node-name": "target-fmt", "type": "nbd", "writable": true}}
 +{"return": {}}
 +read 65536/65536 bytes at offset 0
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +write failed: Operation not permitted
 +
 +write failed: Operation not permitted
 +
 +write failed: Operation not permitted
 +
 +discard failed: Operation not permitted
 +
 +
 +qemu-io: Failed to get allocation status: Operation not permitted
 +
 +
 +=== Resuming VM activates all images ===
 +{"execute": "cont", "arguments": {}}
 +{"return": {}}
 +disk-fmt active: True
 +snap-fmt active: True
 +snap2-fmt active: True
 +target-fmt active: True
 +
 +Shutting down...
 +
 --
-.20.1
+.48.1

-New patch
+[PULL 25/25] block: remove unused BLOCK_OP_TYPE_DATAPLANE
+From: Stefan Hajnoczi <stefanha@redhat.com>
+BLOCK_OP_TYPE_DATAPLANE prevents BlockDriverState from being used by
+virtio-blk/virtio-scsi with IOThread. Commit b112a65c52aa ("block:
+declare blockjobs and dataplane friends!") eliminated the main reason
+for this blocker in 2014.
+Nowadays the block layer supports I/O from multiple AioContexts, so
+there is even less reason to block IOThread users. Any legitimate
+reasons related to interference would probably also apply to
+non-IOThread users.
+The only remaining users are bdrv_op_unblock(BLOCK_OP_TYPE_DATAPLANE)
+calls after bdrv_op_block_all(). If we remove BLOCK_OP_TYPE_DATAPLANE
+their behavior doesn't change.
+Existing bdrv_op_block_all() callers that don't explicitly unblock
+BLOCK_OP_TYPE_DATAPLANE seem to do so simply because no one bothered to
+rather than because it is necessary to keep BLOCK_OP_TYPE_DATAPLANE
+blocked.
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-ID: <20250203182529.269066-1-stefanha@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ include/block/block-common.h | 1 -
+ block/replication.c          | 1 -
+ blockjob.c                   | 2 --
+ hw/block/virtio-blk.c        | 9 ---------
+ hw/scsi/virtio-scsi.c        | 3 ---
+files changed, 16 deletions(-)
+diff --git a/include/block/block-common.h b/include/block/block-common.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/block/block-common.h
++++ b/include/block/block-common.h
+@@ -XXX,XX +XXX,XX @@ typedef enum BlockOpType {
+     BLOCK_OP_TYPE_CHANGE,
+     BLOCK_OP_TYPE_COMMIT_SOURCE,
+     BLOCK_OP_TYPE_COMMIT_TARGET,
+-    BLOCK_OP_TYPE_DATAPLANE,
+     BLOCK_OP_TYPE_DRIVE_DEL,
+     BLOCK_OP_TYPE_EJECT,
+     BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
+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 replication_start(ReplicationState *rs, ReplicationMode mode,
+             return;
+         }
+         bdrv_op_block_all(top_bs, s->blocker);
+-        bdrv_op_unblock(top_bs, BLOCK_OP_TYPE_DATAPLANE, s->blocker);
+         bdrv_graph_wrunlock();
+diff --git a/blockjob.c b/blockjob.c
+index XXXXXXX..XXXXXXX 100644
+--- a/blockjob.c
++++ b/blockjob.c
+@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
+         goto fail;
+     }
+-    bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
+-
+     if (!block_job_set_speed(job, speed, errp)) {
+         goto fail;
+     }
+diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/block/virtio-blk.c
++++ b/hw/block/virtio-blk.c
+@@ -XXX,XX +XXX,XX @@ static bool virtio_blk_vq_aio_context_init(VirtIOBlock *s, Error **errp)
+             error_setg(errp, "ioeventfd is required for iothread");
+             return false;
+         }
+-
+-        /*
+-         * If ioeventfd is (re-)enabled while the guest is running there could
+-         * be block jobs that can conflict.
+-         */
+-        if (blk_op_is_blocked(conf->conf.blk, BLOCK_OP_TYPE_DATAPLANE, errp)) {
+-            error_prepend(errp, "cannot start virtio-blk ioeventfd: ");
+-            return false;
+-        }
+     }
+     s->vq_aio_context = g_new(AioContext *, conf->num_queues);
+diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/scsi/virtio-scsi.c
++++ b/hw/scsi/virtio-scsi.c
+@@ -XXX,XX +XXX,XX @@ static void virtio_scsi_hotplug(HotplugHandler *hotplug_dev, DeviceState *dev,
+     int ret;
+     if (s->ctx && !s->dataplane_fenced) {
+-        if (blk_op_is_blocked(sd->conf.blk, BLOCK_OP_TYPE_DATAPLANE, errp)) {
+-            return;
+-        }
+         ret = blk_set_aio_context(sd->conf.blk, s->ctx, errp);
+         if (ret < 0) {
+             return;
+--
+.48.1

The following changes since commit ba29883206d92a29ad5a466e679ccfc2ee6132ef:

Merge remote-tracking branch 'remotes/borntraeger/tags/s390x-20200310' into staging (2020-03-10 16:50:28 +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 8bb3b023f2055054ee119cb45b42d2b14be7fc8a:

qemu-iotests: adding LUKS cleanup for non-UTF8 secret error (2020-03-11 15:54:38 +0100)

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

- Relax restrictions for blockdev-snapshot (allows libvirt to do live
  storage migration with blockdev-mirror)
- luks: Delete created files when block_crypto_co_create_opts_luks fails
- Fix memleaks in qmp_object_add

----------------------------------------------------------------
Daniel Henrique Barboza (4):
      block: introducing 'bdrv_co_delete_file' interface
      block.c: adding bdrv_co_delete_file
      crypto.c: cleanup created file when block_crypto_co_create_opts_luks fails
      qemu-iotests: adding LUKS cleanup for non-UTF8 secret error

Kevin Wolf (6):
      block: Make bdrv_get_cumulative_perm() public
      block: Relax restrictions for blockdev-snapshot
      iotests: Fix run_job() with use_log=False
      iotests: Test mirror with temporarily disabled target backing file
      block: Fix cross-AioContext blockdev-snapshot
      iotests: Add iothread cases to 155

Pan Nengyuan (1):
      qom-qmp-cmds: fix two memleaks in qmp_object_add

Peter Krempa (1):
      qapi: Add '@allow-write-only-overlay' feature for 'blockdev-snapshot'

Philippe Mathieu-Daudé (1):
      tests/qemu-iotests: Fix socket_scm_helper build path

From: Pan Nengyuan <pannengyuan@huawei.com>

'type/id' forgot to free in qmp_object_add, this patch fix that.

The leak stack:
Direct leak of 84 byte(s) in 6 object(s) allocated from:
    #0 0x7fe2a5ebf768 in __interceptor_malloc (/lib64/libasan.so.5+0xef768)
    #1 0x7fe2a5044445 in g_malloc (/lib64/libglib-2.0.so.0+0x52445)
    #2 0x7fe2a505dd92 in g_strdup (/lib64/libglib-2.0.so.0+0x6bd92)
    #3 0x56344954e692 in qmp_object_add /mnt/sdb/qemu-new/qemu_test/qemu/qom/qom-qmp-cmds.c:258
    #4 0x563449960f5a in do_qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qmp-dispatch.c:132
    #5 0x563449960f5a in qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qmp-dispatch.c:175
    #6 0x563449498a30 in monitor_qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/monitor/qmp.c:145
    #7 0x56344949a64f in monitor_qmp_bh_dispatcher /mnt/sdb/qemu-new/qemu_test/qemu/monitor/qmp.c:234
    #8 0x563449a92a3a in aio_bh_call /mnt/sdb/qemu-new/qemu_test/qemu/util/async.c:136

Direct leak of 54 byte(s) in 6 object(s) allocated from:
    #0 0x7fe2a5ebf768 in __interceptor_malloc (/lib64/libasan.so.5+0xef768)
    #1 0x7fe2a5044445 in g_malloc (/lib64/libglib-2.0.so.0+0x52445)
    #2 0x7fe2a505dd92 in g_strdup (/lib64/libglib-2.0.so.0+0x6bd92)
    #3 0x56344954e6c4 in qmp_object_add /mnt/sdb/qemu-new/qemu_test/qemu/qom/qom-qmp-cmds.c:267
    #4 0x563449960f5a in do_qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qmp-dispatch.c:132
    #5 0x563449960f5a in qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/qapi/qmp-dispatch.c:175
    #6 0x563449498a30 in monitor_qmp_dispatch /mnt/sdb/qemu-new/qemu_test/qemu/monitor/qmp.c:145
    #7 0x56344949a64f in monitor_qmp_bh_dispatcher /mnt/sdb/qemu-new/qemu_test/qemu/monitor/qmp.c:234
    #8 0x563449a92a3a in aio_bh_call /mnt/sdb/qemu-new/qemu_test/qemu/util/async.c:136

Fixes: 5f07c4d60d091320186e7b0edaf9ed2cc16b2d1e
Reported-by: Euler Robot <euler.robot@huawei.com>
Signed-off-by: Pan Nengyuan <pannengyuan@huawei.com>
Message-Id: <20200310064640.5059-1-pannengyuan@huawei.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Acked-by: Igor Mammedov <imammedo@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qom/qom-qmp-cmds.c | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/qom/qom-qmp-cmds.c b/qom/qom-qmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/qom/qom-qmp-cmds.c
+++ b/qom/qom-qmp-cmds.c
@@ -XXX,XX +XXX,XX @@ void qmp_object_add(QDict *qdict, QObject **ret_data, Error **errp)
     QDict *pdict;
     Visitor *v;
     Object *obj;
-    const char *type;
-    const char *id;
+    g_autofree char *type = NULL;
+    g_autofree char *id = NULL;
 
-    type = qdict_get_try_str(qdict, "qom-type");
+    type = g_strdup(qdict_get_try_str(qdict, "qom-type"));
     if (!type) {
         error_setg(errp, QERR_MISSING_PARAMETER, "qom-type");
         return;
-    } else {
-        type = g_strdup(type);
-        qdict_del(qdict, "qom-type");
     }
+    qdict_del(qdict, "qom-type");
 
-    id = qdict_get_try_str(qdict, "id");
+    id = g_strdup(qdict_get_try_str(qdict, "id"));
     if (!id) {
         error_setg(errp, QERR_MISSING_PARAMETER, "id");
         return;
-    } else {
-        id = g_strdup(id);
-        qdict_del(qdict, "id");
     }
+    qdict_del(qdict, "id");
 
     props = qdict_get(qdict, "props");
     if (props) {
-- 
2.20.1

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200310113831.27293-2-kwolf@redhat.com>
Reviewed-by: Peter Krempa <pkrempa@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block_int.h | 3 +++
 block.c                   | 6 ++----
 2 files changed, 5 insertions(+), 4 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 @@ BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
                                   void *opaque, Error **errp);
 void bdrv_root_unref_child(BdrvChild *child);
 
+void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
+                              uint64_t *shared_perm);
+
 /**
  * Sets a BdrvChild's permissions.  Avoid if the parent is a BDS; use
  * bdrv_child_refresh_perms() instead and make the parent's
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static int bdrv_child_check_perm(BdrvChild *c, BlockReopenQueue *q,
                                  bool *tighten_restrictions, Error **errp);
 static void bdrv_child_abort_perm_update(BdrvChild *c);
 static void bdrv_child_set_perm(BdrvChild *c, uint64_t perm, uint64_t shared);
-static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
-                                     uint64_t *shared_perm);
 
 typedef struct BlockReopenQueueEntry {
      bool prepared;
@@ -XXX,XX +XXX,XX @@ static void bdrv_set_perm(BlockDriverState *bs, uint64_t cumulative_perms,
     }
 }
 
-static void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
-                                     uint64_t *shared_perm)
+void bdrv_get_cumulative_perm(BlockDriverState *bs, uint64_t *perm,
+                              uint64_t *shared_perm)
 {
     BdrvChild *c;
     uint64_t cumulative_perms = 0;
-- 
2.20.1

blockdev-snapshot returned an error if the overlay was already in use,
which it defined as having any BlockBackend parent. This is in fact both
too strict (some parents can tolerate the change of visible data caused
by attaching a backing file) and too loose (some non-BlockBackend
parents may not be happy with it).

One important use case that is prevented by the too strict check is live
storage migration with blockdev-mirror. Here, the target node is
usually opened without a backing file so that the active layer is
mirrored while its backing chain can be copied in the background.

The backing chain should be attached to the mirror target node when
finalising the job, just before switching the users of the source node
to the new copy (at which point the mirror job still has a reference to
the node). drive-mirror did this automatically, but with blockdev-mirror
this is the job of the QMP client, so it needs a way to do this.

blockdev-snapshot is the obvious way, so this patch makes it work in
this scenario. The new condition is that no parent uses CONSISTENT_READ
permissions. This will ensure that the operation will still be blocked
when the node is attached to the guest device, so blockdev-snapshot
remains safe.

(For the sake of completeness, x-blockdev-reopen can be used to achieve
the same, however it is a big hammer, performs the graph change
completely unchecked and is still experimental. So even with the option
of using x-blockdev-reopen, there are reasons why blockdev-snapshot
should be able to perform this operation.)

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200310113831.27293-3-kwolf@redhat.com>
Reviewed-by: Peter Krempa <pkrempa@redhat.com>
Tested-by: Peter Krempa <pkrempa@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockdev.c                 | 14 ++++++++------
 tests/qemu-iotests/085.out |  4 ++--
 2 files changed, 10 insertions(+), 8 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 external_snapshot_prepare(BlkActionState *common,
     TransactionAction *action = common->action;
     AioContext *aio_context;
     AioContext *old_context;
+    uint64_t perm, shared;
     int ret;
 
     /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,
         goto out;
     }
 
-    if (bdrv_has_blk(state->new_bs)) {
+    /*
+     * Allow attaching a backing file to an overlay that's already in use only
+     * if the parents don't assume that they are already seeing a valid image.
+     * (Specifically, allow it as a mirror target, which is write-only access.)
+     */
+    bdrv_get_cumulative_perm(state->new_bs, &perm, &shared);
+    if (perm & BLK_PERM_CONSISTENT_READ) {
         error_setg(errp, "The overlay is already in use");
         goto out;
     }
 
-    if (bdrv_op_is_blocked(state->new_bs, BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
-                           errp)) {
-        goto out;
-    }
-
     if (state->new_bs->backing != NULL) {
         error_setg(errp, "The overlay already has a backing image");
         goto out;
diff --git a/tests/qemu-iotests/085.out b/tests/qemu-iotests/085.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/085.out
+++ b/tests/qemu-iotests/085.out
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/12-snapshot-v0.IMGFMT', fmt=IMGFMT size=134217728 backing_f
 === Invalid command - cannot create a snapshot using a file BDS ===
 
 { 'execute': 'blockdev-snapshot', 'arguments': { 'node':'virtio0', 'overlay':'file_12' } }
-{"error": {"class": "GenericError", "desc": "The overlay does not support backing images"}}
+{"error": {"class": "GenericError", "desc": "The overlay is already in use"}}
 
 === Invalid command - snapshot node used as active layer ===
 
@@ -XXX,XX +XXX,XX @@ Formatting 'TEST_DIR/12-snapshot-v0.IMGFMT', fmt=IMGFMT size=134217728 backing_f
 === Invalid command - snapshot node used as backing hd ===
 
 { 'execute': 'blockdev-snapshot', 'arguments': { 'node': 'virtio0', 'overlay':'snap_11' } }
-{"error": {"class": "GenericError", "desc": "Node 'snap_11' is busy: node is used as backing hd of 'snap_12'"}}
+{"error": {"class": "GenericError", "desc": "The overlay is already in use"}}
 
 === Invalid command - snapshot node has a backing image ===
 
-- 
2.20.1

The 'job-complete' QMP command should be run with qmp() rather than
qmp_log() if use_log=False is passed.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200310113831.27293-4-kwolf@redhat.com>
Reviewed-by: Peter Krempa <pkrempa@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/iotests.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/iotests.py
+++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@ class VM(qtest.QEMUQtestMachine):
                         if use_log:
                             log('Job failed: %s' % (j['error']))
             elif status == 'ready':
-                self.qmp_log('job-complete', id=job)
+                if use_log:
+                    self.qmp_log('job-complete', id=job)
+                else:
+                    self.qmp('job-complete', id=job)
             elif status == 'pending' and not auto_finalize:
                 if pre_finalize:
                     pre_finalize()
-- 
2.20.1

The newly tested scenario is a common live storage migration scenario:
The target node is opened without a backing file so that the active
layer is mirrored while its backing chain can be copied in the
background.

This patch adds test cases for two ways to achieve the desired result,
using either x-blockdev-reopen or blockdev-snapshot.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200310113831.27293-5-kwolf@redhat.com>
Reviewed-by: Peter Krempa <pkrempa@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/155     | 56 ++++++++++++++++++++++++++++++++++----
 tests/qemu-iotests/155.out |  4 +--
 2 files changed, 53 insertions(+), 7 deletions(-)

diff --git a/tests/qemu-iotests/155 b/tests/qemu-iotests/155
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/155
+++ b/tests/qemu-iotests/155
@@ -XXX,XX +XXX,XX @@ target_img = os.path.join(iotests.test_dir, 'target.' + iotests.imgfmt)
 #                      image during runtime, only makes sense if
 #                      target_blockdev_backing is not None
 #                      (None: same as target_backing)
+# target_open_with_backing: If True, the target image is added with its backing
+#                           chain opened right away. If False, blockdev-add
+#                           opens it without a backing file and job completion
+#                           is supposed to open the backing chain.
 
 class BaseClass(iotests.QMPTestCase):
     target_blockdev_backing = None
     target_real_backing = None
+    target_open_with_backing = True
 
     def setUp(self):
         qemu_img('create', '-f', iotests.imgfmt, back0_img, '1440K')
@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
                 options = { 'node-name': 'target',
                             'driver': iotests.imgfmt,
                             'file': { 'driver': 'file',
+                                      'node-name': 'target-file',
                                       'filename': target_img } }
-                if self.target_blockdev_backing:
-                    options['backing'] = self.target_blockdev_backing
+
+                if not self.target_open_with_backing:
+                        options['backing'] = None
+                elif self.target_blockdev_backing:
+                        options['backing'] = self.target_blockdev_backing
 
                 result = self.vm.qmp('blockdev-add', **options)
                 self.assert_qmp(result, 'return', {})
@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
 # cmd: Mirroring command to execute, either drive-mirror or blockdev-mirror
 
 class MirrorBaseClass(BaseClass):
+    def openBacking(self):
+        pass
+
     def runMirror(self, sync):
         if self.cmd == 'blockdev-mirror':
             result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source',
-                                 sync=sync, target='target')
+                                 sync=sync, target='target',
+                                 auto_finalize=False)
         else:
             if self.existing:
                 mode = 'existing'
@@ -XXX,XX +XXX,XX @@ class MirrorBaseClass(BaseClass):
             result = self.vm.qmp(self.cmd, job_id='mirror-job', device='source',
                                  sync=sync, target=target_img,
                                  format=iotests.imgfmt, mode=mode,
-                                 node_name='target')
+                                 node_name='target', auto_finalize=False)
 
         self.assert_qmp(result, 'return', {})
 
-        self.complete_and_wait('mirror-job')
+        self.vm.run_job('mirror-job', use_log=False, auto_finalize=False,
+                        pre_finalize=self.openBacking, auto_dismiss=True)
 
     def testFull(self):
         self.runMirror('full')
@@ -XXX,XX +XXX,XX @@ class TestBlockdevMirrorForcedBacking(MirrorBaseClass):
     target_blockdev_backing = { 'driver': 'null-co' }
     target_real_backing = 'null-co://'
 
+# Attach the backing chain only during completion, with blockdev-reopen
+class TestBlockdevMirrorReopen(MirrorBaseClass):
+    cmd = 'blockdev-mirror'
+    existing = True
+    target_backing = 'null-co://'
+    target_open_with_backing = False
+
+    def openBacking(self):
+        if not self.target_open_with_backing:
+            result = self.vm.qmp('blockdev-add', node_name="backing",
+                                 driver="null-co")
+            self.assert_qmp(result, 'return', {})
+            result = self.vm.qmp('x-blockdev-reopen', node_name="target",
+                                 driver=iotests.imgfmt, file="target-file",
+                                 backing="backing")
+            self.assert_qmp(result, 'return', {})
+
+# Attach the backing chain only during completion, with blockdev-snapshot
+class TestBlockdevMirrorSnapshot(MirrorBaseClass):
+    cmd = 'blockdev-mirror'
+    existing = True
+    target_backing = 'null-co://'
+    target_open_with_backing = False
+
+    def openBacking(self):
+        if not self.target_open_with_backing:
+            result = self.vm.qmp('blockdev-add', node_name="backing",
+                                 driver="null-co")
+            self.assert_qmp(result, 'return', {})
+            result = self.vm.qmp('blockdev-snapshot', node="backing",
+                                 overlay="target")
+            self.assert_qmp(result, 'return', {})
 
 class TestCommit(BaseClass):
     existing = False
diff --git a/tests/qemu-iotests/155.out b/tests/qemu-iotests/155.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/155.out
+++ b/tests/qemu-iotests/155.out
@@ -XXX,XX +XXX,XX @@
-...................
+.........................
 ----------------------------------------------------------------------
-Ran 19 tests
+Ran 25 tests
 
 OK
-- 
2.20.1

external_snapshot_prepare() tries to move the overlay to the AioContext
of the backing file (the snapshotted node). However, it's possible that
this doesn't work, but the backing file can instead be moved to the
overlay's AioContext (e.g. opening the backing chain for a mirror
target).

bdrv_append() already indirectly uses bdrv_attach_node(), which takes
care to move nodes to make sure they use the same AioContext and which
tries both directions.

So the problem has a simple fix: Just delete the unnecessary extra
bdrv_try_set_aio_context() call in external_snapshot_prepare() and
instead assert in bdrv_append() that both nodes were indeed moved to the
same AioContext.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200310113831.27293-6-kwolf@redhat.com>
Tested-by: Peter Krempa <pkrempa@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c    |  1 +
 blockdev.c | 16 ----------------
 2 files changed, 1 insertion(+), 16 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void bdrv_replace_node(BlockDriverState *from, BlockDriverState *to,
     bdrv_ref(from);
 
     assert(qemu_get_current_aio_context() == qemu_get_aio_context());
+    assert(bdrv_get_aio_context(from) == bdrv_get_aio_context(to));
     bdrv_drained_begin(from);
 
     /* Put all parents into @list and calculate their cumulative permissions */
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,
                              DO_UPCAST(ExternalSnapshotState, common, common);
     TransactionAction *action = common->action;
     AioContext *aio_context;
-    AioContext *old_context;
     uint64_t perm, shared;
-    int ret;
 
     /* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar
      * purpose but a different set of parameters */
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_prepare(BlkActionState *common,
         goto out;
     }
 
-    /* Honor bdrv_try_set_aio_context() context acquisition requirements. */
-    old_context = bdrv_get_aio_context(state->new_bs);
-    aio_context_release(aio_context);
-    aio_context_acquire(old_context);
-
-    ret = bdrv_try_set_aio_context(state->new_bs, aio_context, errp);
-
-    aio_context_release(old_context);
-    aio_context_acquire(aio_context);
-
-    if (ret < 0) {
-        goto out;
-    }
-
     /* This removes our old bs and adds the new bs. This is an operation that
      * can fail, so we need to do it in .prepare; undoing it for abort is
      * always possible. */
-- 
2.20.1

This patch adds test cases for attaching the backing chain to a mirror
job target right before finalising the job, where the image is in a
non-mainloop AioContext (i.e. the backing chain needs to be moved to the
AioContext of the mirror target).

This requires switching the test case from virtio-blk to virtio-scsi
because virtio-blk only actually starts using the iothreads when the
guest driver initialises the device (which never happens in a test case
without a guest OS). virtio-scsi always keeps its block nodes in the
AioContext of the the requested iothread without guest interaction.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200310113831.27293-7-kwolf@redhat.com>
Reviewed-by: Peter Krempa <pkrempa@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/155     | 32 +++++++++++++++++++++++---------
 tests/qemu-iotests/155.out |  4 ++--
 2 files changed, 25 insertions(+), 11 deletions(-)

diff --git a/tests/qemu-iotests/155 b/tests/qemu-iotests/155
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/155
+++ b/tests/qemu-iotests/155
@@ -XXX,XX +XXX,XX @@ target_img = os.path.join(iotests.test_dir, 'target.' + iotests.imgfmt)
 #                           chain opened right away. If False, blockdev-add
 #                           opens it without a backing file and job completion
 #                           is supposed to open the backing chain.
+# use_iothread: If True, an iothread is configured for the virtio-blk device
+#               that uses the image being mirrored
 
 class BaseClass(iotests.QMPTestCase):
     target_blockdev_backing = None
     target_real_backing = None
     target_open_with_backing = True
+    use_iothread = False
 
     def setUp(self):
         qemu_img('create', '-f', iotests.imgfmt, back0_img, '1440K')
@@ -XXX,XX +XXX,XX @@ class BaseClass(iotests.QMPTestCase):
                     'file': {'driver': 'file',
                              'filename': source_img}}
         self.vm.add_blockdev(self.vm.qmp_to_opts(blockdev))
-        self.vm.add_device('virtio-blk,id=qdev0,drive=source')
+
+        if self.use_iothread:
+            self.vm.add_object('iothread,id=iothread0')
+            iothread = ",iothread=iothread0"
+        else:
+            iothread = ""
+
+        self.vm.add_device('virtio-scsi%s' % iothread)
+        self.vm.add_device('scsi-hd,id=qdev0,drive=source')
+
         self.vm.launch()
 
         self.assertIntactSourceBackingChain()
@@ -XXX,XX +XXX,XX @@ class MirrorBaseClass(BaseClass):
     def testFull(self):
         self.runMirror('full')
 
-        node = self.findBlockNode('target',
-                                  '/machine/peripheral/qdev0/virtio-backend')
+        node = self.findBlockNode('target', 'qdev0')
         self.assertCorrectBackingImage(node, None)
         self.assertIntactSourceBackingChain()
 
     def testTop(self):
         self.runMirror('top')
 
-        node = self.findBlockNode('target',
-                                  '/machine/peripheral/qdev0/virtio-backend')
+        node = self.findBlockNode('target', 'qdev0')
         self.assertCorrectBackingImage(node, back2_img)
         self.assertIntactSourceBackingChain()
 
     def testNone(self):
         self.runMirror('none')
 
-        node = self.findBlockNode('target',
-                                  '/machine/peripheral/qdev0/virtio-backend')
+        node = self.findBlockNode('target', 'qdev0')
         self.assertCorrectBackingImage(node, source_img)
         self.assertIntactSourceBackingChain()
 
@@ -XXX,XX +XXX,XX @@ class TestBlockdevMirrorReopen(MirrorBaseClass):
                                  backing="backing")
             self.assert_qmp(result, 'return', {})
 
+class TestBlockdevMirrorReopenIothread(TestBlockdevMirrorReopen):
+    use_iothread = True
+
 # Attach the backing chain only during completion, with blockdev-snapshot
 class TestBlockdevMirrorSnapshot(MirrorBaseClass):
     cmd = 'blockdev-mirror'
@@ -XXX,XX +XXX,XX @@ class TestBlockdevMirrorSnapshot(MirrorBaseClass):
                                  overlay="target")
             self.assert_qmp(result, 'return', {})
 
+class TestBlockdevMirrorSnapshotIothread(TestBlockdevMirrorSnapshot):
+    use_iothread = True
+
 class TestCommit(BaseClass):
     existing = False
 
@@ -XXX,XX +XXX,XX @@ class TestCommit(BaseClass):
 
         self.vm.event_wait('BLOCK_JOB_COMPLETED')
 
-        node = self.findBlockNode(None,
-                                  '/machine/peripheral/qdev0/virtio-backend')
+        node = self.findBlockNode(None, 'qdev0')
         self.assert_qmp(node, 'image' + '/backing-image' * 0 + '/filename',
                         back1_img)
         self.assert_qmp(node, 'image' + '/backing-image' * 1 + '/filename',
diff --git a/tests/qemu-iotests/155.out b/tests/qemu-iotests/155.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/155.out
+++ b/tests/qemu-iotests/155.out
@@ -XXX,XX +XXX,XX @@
-.........................
+...............................
 ----------------------------------------------------------------------
-Ran 25 tests
+Ran 31 tests
 
 OK
-- 
2.20.1

From: Peter Krempa <pkrempa@redhat.com>

Anounce that 'blockdev-snapshot' command's permissions allow changing
of the backing file if the 'consistent_read' permission is not required.

This is useful for libvirt to allow late opening of the backing chain
during a blockdev-mirror.

Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200310113831.27293-8-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 #
 # For the arguments, see the documentation of BlockdevSnapshot.
 #
+# Features:
+# @allow-write-only-overlay: If present, the check whether this operation is safe
+#                            was relaxed so that it can be used to change
+#                            backing file of a destination of a blockdev-mirror.
+#                            (since 5.0)
+#
 # Since: 2.5
 #
 # Example:
@@ -XXX,XX +XXX,XX @@
 #
 ##
 { 'command': 'blockdev-snapshot',
-  'data': 'BlockdevSnapshot' }
+  'data': 'BlockdevSnapshot',
+  'features': [ 'allow-write-only-overlay' ] }
 
 ##
 # @change-backing-file:
-- 
2.20.1

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

The socket_scm_helper path got corrupted during the mechanical
refactor moving the qtests files into their own sub-directory.

Fixes: 1e8a1fae7 ("test: Move qtests to a separate directory")
Signed-off-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-Id: <20200306165751.18986-1-philmd@redhat.com>
Reviewed-by: Laurent Vivier <laurent@vivier.eu>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/Makefile.include       | 1 +
 tests/qtest/Makefile.include | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

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 @@ include $(SRC_PATH)/tests/qtest/Makefile.include
 tests/test-qga$(EXESUF): qemu-ga$(EXESUF)
 tests/test-qga$(EXESUF): tests/test-qga.o $(qtest-obj-y)
 tests/vhost-user-bridge$(EXESUF): tests/vhost-user-bridge.o $(test-util-obj-y) libvhost-user.a
+tests/qemu-iotests/socket_scm_helper$(EXESUF): tests/qemu-iotests/socket_scm_helper.o
 
 SPEED = quick
 
diff --git a/tests/qtest/Makefile.include b/tests/qtest/Makefile.include
index XXXXXXX..XXXXXXX 100644
--- a/tests/qtest/Makefile.include
+++ b/tests/qtest/Makefile.include
@@ -XXX,XX +XXX,XX @@ tests/qtest/usb-hcd-ehci-test$(EXESUF): tests/qtest/usb-hcd-ehci-test.o $(libqos
 tests/qtest/usb-hcd-xhci-test$(EXESUF): tests/qtest/usb-hcd-xhci-test.o $(libqos-usb-obj-y)
 tests/qtest/cpu-plug-test$(EXESUF): tests/qtest/cpu-plug-test.o
 tests/qtest/migration-test$(EXESUF): tests/qtest/migration-test.o tests/qtest/migration-helpers.o
-tests/qtest/qemu-iotests/qtest/socket_scm_helper$(EXESUF): tests/qtest/qemu-iotests/qtest/socket_scm_helper.o
 tests/qtest/test-netfilter$(EXESUF): tests/qtest/test-netfilter.o $(qtest-obj-y)
 tests/qtest/test-filter-mirror$(EXESUF): tests/qtest/test-filter-mirror.o $(qtest-obj-y)
 tests/qtest/test-filter-redirector$(EXESUF): tests/qtest/test-filter-redirector.o $(qtest-obj-y)
-- 
2.20.1

From: Daniel Henrique Barboza <danielhb413@gmail.com>

Adding to Block Drivers the capability of being able to clean up
its created files can be useful in certain situations. For the
LUKS driver, for instance, a failure in one of its authentication
steps can leave files in the host that weren't there before.

This patch adds the 'bdrv_co_delete_file' interface to block
drivers and add it to the 'file' driver in file-posix.c. The
implementation is given by 'raw_co_delete_file'.

Suggested-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
Message-Id: <20200130213907.2830642-2-danielhb413@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block_int.h |  4 ++++
 block/file-posix.c        | 23 +++++++++++++++++++++++
 2 files changed, 27 insertions(+)

diff --git a/include/block/block_int.h b/include/block/block_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
      */
     int coroutine_fn (*bdrv_co_flush)(BlockDriverState *bs);
 
+    /* Delete a created file. */
+    int coroutine_fn (*bdrv_co_delete_file)(BlockDriverState *bs,
+                                            Error **errp);
+
     /*
      * Flushes all data that was already written to the OS all the way down to
      * the disk (for example file-posix.c calls fsync()).
diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_create_opts(const char *filename, QemuOpts *opts,
     return raw_co_create(&options, errp);
 }
 
+static int coroutine_fn raw_co_delete_file(BlockDriverState *bs,
+                                           Error **errp)
+{
+    struct stat st;
+    int ret;
+
+    if (!(stat(bs->filename, &st) == 0) || !S_ISREG(st.st_mode)) {
+        error_setg_errno(errp, ENOENT, "%s is not a regular file",
+                         bs->filename);
+        return -ENOENT;
+    }
+
+    ret = unlink(bs->filename);
+    if (ret < 0) {
+        ret = -errno;
+        error_setg_errno(errp, -ret, "Error when deleting file %s",
+                         bs->filename);
+    }
+
+    return ret;
+}
+
 /*
  * Find allocation range in @bs around offset @start.
  * May change underlying file descriptor's file offset.
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_file = {
     .bdrv_co_block_status = raw_co_block_status,
     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
     .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
+    .bdrv_co_delete_file = raw_co_delete_file,
 
     .bdrv_co_preadv         = raw_co_preadv,
     .bdrv_co_pwritev        = raw_co_pwritev,
-- 
2.20.1

From: Daniel Henrique Barboza <danielhb413@gmail.com>

Using the new 'bdrv_co_delete_file' interface, a pure co_routine function
'bdrv_co_delete_file' inside block.c can can be used in a way similar of
the existing bdrv_create_file to to clean up a created file.

We're creating a pure co_routine because the only caller of
'bdrv_co_delete_file' will be already in co_routine context, thus there
is no need to add all the machinery to check for qemu_in_coroutine() and
create a separated co_routine to do the job.

Suggested-by: Daniel P. Berrangé <berrange@redhat.com>
Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
Message-Id: <20200130213907.2830642-3-danielhb413@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block.h |  1 +
 block.c               | 26 ++++++++++++++++++++++++++
 2 files changed, 27 insertions(+)

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 @@ bool bdrv_is_backing_chain_frozen(BlockDriverState *bs, BlockDriverState *base,
 int bdrv_freeze_backing_chain(BlockDriverState *bs, BlockDriverState *base,
                               Error **errp);
 void bdrv_unfreeze_backing_chain(BlockDriverState *bs, BlockDriverState *base);
+int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp);
 
 
 typedef struct BdrvCheckResult {
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_create_file(const char *filename, QemuOpts *opts, Error **errp)
     }
 }
 
+int coroutine_fn bdrv_co_delete_file(BlockDriverState *bs, Error **errp)
+{
+    Error *local_err = NULL;
+    int ret;
+
+    assert(bs != NULL);
+
+    if (!bs->drv) {
+        error_setg(errp, "Block node '%s' is not opened", bs->filename);
+        return -ENOMEDIUM;
+    }
+
+    if (!bs->drv->bdrv_co_delete_file) {
+        error_setg(errp, "Driver '%s' does not support image deletion",
+                   bs->drv->format_name);
+        return -ENOTSUP;
+    }
+
+    ret = bs->drv->bdrv_co_delete_file(bs, &local_err);
+    if (ret < 0) {
+        error_propagate(errp, local_err);
+    }
+
+    return ret;
+}
+
 /**
  * Try to get @bs's logical and physical block size.
  * On success, store them in @bsz struct and return 0.
-- 
2.20.1

From: Daniel Henrique Barboza <danielhb413@gmail.com>

When using a non-UTF8 secret to create a volume using qemu-img, the
following error happens:

$ qemu-img create -f luks --object secret,id=vol_1_encrypt0,file=vol_resize_pool.vol_1.secret.qzVQrI -o key-secret=vol_1_encrypt0 /var/tmp/pool_target/vol_1 10240K

Formatting '/var/tmp/pool_target/vol_1', fmt=luks size=10485760 key-secret=vol_1_encrypt0
qemu-img: /var/tmp/pool_target/vol_1: Data from secret vol_1_encrypt0 is not valid UTF-8

However, the created file '/var/tmp/pool_target/vol_1' is left behind in the
file system after the failure. This behavior can be observed when creating
the volume using Libvirt, via 'virsh vol-create', and then getting "volume
target path already exist" errors when trying to re-create the volume.

The volume file is created inside block_crypto_co_create_opts_luks(), in
block/crypto.c. If the bdrv_create_file() call is successful but any
succeeding step fails*, the existing 'fail' label does not take into
account the created file, leaving it behind.

This patch changes block_crypto_co_create_opts_luks() to delete
'filename' in case of failure. A failure in this point means that
the volume is now truncated/corrupted, so even if 'filename' was an
existing volume before calling qemu-img, it is now unusable. Deleting
the file it is not much worse than leaving it in the filesystem in
this scenario, and we don't have to deal with checking the file
pre-existence in the code.

* in our case, block_crypto_co_create_generic calls qcrypto_block_create,
which calls qcrypto_block_luks_create, and this function fails when
calling qcrypto_secret_lookup_as_utf8.

Reported-by: Srikanth Aithal <bssrikanth@in.ibm.com>
Suggested-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
Message-Id: <20200130213907.2830642-4-danielhb413@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/crypto.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

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 @@
 #include "qapi/error.h"
 #include "qemu/module.h"
 #include "qemu/option.h"
+#include "qemu/cutils.h"
 #include "crypto.h"
 
 typedef struct BlockCrypto BlockCrypto;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn block_crypto_co_create_opts_luks(const char *filename,
 
     ret = 0;
 fail:
+    /*
+     * If an error occurred, delete 'filename'. Even if the file existed
+     * beforehand, it has been truncated and corrupted in the process.
+     */
+    if (ret && bs) {
+        Error *local_delete_err = NULL;
+        int r_del = bdrv_co_delete_file(bs, &local_delete_err);
+        /*
+         * ENOTSUP will happen if the block driver doesn't support
+         * the 'bdrv_co_delete_file' interface. This is a predictable
+         * scenario and shouldn't be reported back to the user.
+         */
+        if ((r_del < 0) && (r_del != -ENOTSUP)) {
+            error_report_err(local_delete_err);
+        }
+    }
+
     bdrv_unref(bs);
     qapi_free_QCryptoBlockCreateOptions(create_opts);
     qobject_unref(cryptoopts);
-- 
2.20.1

From: Daniel Henrique Barboza <danielhb413@gmail.com>

This patch adds a new test file to exercise the case where
qemu-img fails to complete for the LUKS format when a non-UTF8
secret is used.

Signed-off-by: Daniel Henrique Barboza <danielhb413@gmail.com>
Message-Id: <20200130213907.2830642-5-danielhb413@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/282     | 67 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/282.out | 11 +++++++
 tests/qemu-iotests/group   |  1 +
 3 files changed, 79 insertions(+)
 create mode 100755 tests/qemu-iotests/282
 create mode 100644 tests/qemu-iotests/282.out

diff --git a/tests/qemu-iotests/282 b/tests/qemu-iotests/282
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/282
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env bash
+#
+# Test qemu-img file cleanup for LUKS when using a non-UTF8 secret
+#
+# Copyright (C) 2020, IBM Corporation.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+status=1	# failure is the default!
+TEST_IMAGE_FILE='vol.img'
+
+_cleanup()
+{
+  _cleanup_test_img
+  rm non_utf8_secret
+  rm -f $TEST_IMAGE_FILE
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+
+_supported_fmt luks
+_supported_proto generic
+_unsupported_proto vxhs
+
+echo "== Create non-UTF8 secret =="
+echo -n -e '\x3a\x3c\x3b\xff' > non_utf8_secret
+SECRET="secret,id=sec0,file=non_utf8_secret"
+
+echo "== Throws an error because of invalid UTF-8 secret =="
+$QEMU_IMG create -f $IMGFMT --object $SECRET -o "key-secret=sec0" $TEST_IMAGE_FILE 4M
+
+echo "== Image file should not exist after the error =="
+if test -f "$TEST_IMAGE_FILE"; then
+    exit 1
+fi
+
+echo "== Create a stub image file and run qemu-img again =="
+touch $TEST_IMAGE_FILE
+$QEMU_IMG create -f $IMGFMT --object $SECRET -o "key-secret=sec0" $TEST_IMAGE_FILE 4M
+
+echo "== Pre-existing image file should also be deleted after the error =="
+if test -f "$TEST_IMAGE_FILE"; then
+    exit 1
+fi
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/282.out b/tests/qemu-iotests/282.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/282.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 282
+== Create non-UTF8 secret ==
+== Throws an error because of invalid UTF-8 secret ==
+qemu-img: vol.img: Data from secret sec0 is not valid UTF-8
+Formatting 'vol.img', fmt=luks size=4194304 key-secret=sec0
+== Image file should not exist after the error ==
+== Create a stub image file and run qemu-img again ==
+qemu-img: vol.img: Data from secret sec0 is not valid UTF-8
+Formatting 'vol.img', fmt=luks size=4194304 key-secret=sec0
+== Pre-existing image file should also be deleted after the error ==
+ *** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 279 rw backing quick
 280 rw migration quick
 281 rw quick
+282 rw img quick
 283 auto quick
 284 rw
 286 rw quick
-- 
2.20.1

The following changes since commit d922088eb4ba6bc31a99f17b32cf75e59dd306cd:

Merge tag 'ui-pull-request' of https://gitlab.com/marcandre.lureau/qemu into staging (2025-02-03 13:42:02 -0500)

are available in the Git repository at:

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

for you to fetch changes up to fc4e394b2887e15d5f83994e4fc7b26c895c627a:

block: remove unused BLOCK_OP_TYPE_DATAPLANE (2025-02-06 14:51:10 +0100)

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

- Managing inactive nodes (enables QSD migration with shared storage)
- Fix swapped values for BLOCK_IO_ERROR 'device' and 'qom-path'
- vpc: Read images exported from Azure correctly
- scripts/qemu-gdb: Support coroutine dumps in coredumps
- Minor cleanups

----------------------------------------------------------------
Fabiano Rosas (1):
      block: Fix leak in send_qmp_error_event

Kevin Wolf (16):
      block: Add 'active' field to BlockDeviceInfo
      block: Allow inactivating already inactive nodes
      block: Inactivate external snapshot overlays when necessary
      migration/block-active: Remove global active flag
      block: Don't attach inactive child to active node
      block: Fix crash on block_resize on inactive node
      block: Add option to create inactive nodes
      block: Add blockdev-set-active QMP command
      block: Support inactive nodes in blk_insert_bs()
      block/export: Don't ignore image activation error in blk_exp_add()
      block: Drain nodes before inactivating them
      block/export: Add option to allow export of inactive nodes
      nbd/server: Support inactive nodes
      iotests: Add filter_qtest()
      iotests: Add qsd-migrate case
      iotests: Add (NBD-based) tests for inactive nodes

Peter Krempa (1):
      block-backend: Fix argument order when calling 'qapi_event_send_block_io_error()'

Peter Xu (3):
      scripts/qemu-gdb: Always do full stack dump for python errors
      scripts/qemu-gdb: Simplify fs_base fetching for coroutines
      scripts/qemu-gdb: Support coroutine dumps in coredumps

Philippe Mathieu-Daudé (1):
      block: Improve blk_get_attached_dev_id() docstring

Stefan Hajnoczi (1):
      block: remove unused BLOCK_OP_TYPE_DATAPLANE

Vitaly Kuznetsov (2):
      vpc: Split off vpc_ignore_current_size() helper
      vpc: Read images exported from Azure correctly

From: Vitaly Kuznetsov <vkuznets@redhat.com>

In preparation to making changes to the logic deciding whether CHS or
'current_size' need to be used in determining the image size, split off
vpc_ignore_current_size() helper.

No functional change intended.

Signed-off-by: Vitaly Kuznetsov <vkuznets@redhat.com>
Message-ID: <20241212134504.1983757-2-vkuznets@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vpc.c | 67 +++++++++++++++++++++++++++++------------------------
 1 file changed, 37 insertions(+), 30 deletions(-)

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 void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
     }
 }
 
+/*
+ * Microsoft Virtual PC and Microsoft Hyper-V produce and read
+ * VHD image sizes differently.  VPC will rely on CHS geometry,
+ * while Hyper-V and disk2vhd use the size specified in the footer.
+ *
+ * We use a couple of approaches to try and determine the correct method:
+ * look at the Creator App field, and look for images that have CHS
+ * geometry that is the maximum value.
+ *
+ * If the CHS geometry is the maximum CHS geometry, then we assume that
+ * the size is the footer->current_size to avoid truncation.  Otherwise,
+ * we follow the table based on footer->creator_app:
+ *
+ *  Known creator apps:
+ *      'vpc '  :  CHS              Virtual PC (uses disk geometry)
+ *      'qemu'  :  CHS              QEMU (uses disk geometry)
+ *      'qem2'  :  current_size     QEMU (uses current_size)
+ *      'win '  :  current_size     Hyper-V
+ *      'd2v '  :  current_size     Disk2vhd
+ *      'tap\0' :  current_size     XenServer
+ *      'CTXS'  :  current_size     XenConverter
+ *
+ *  The user can override the table values via drive options, however
+ *  even with an override we will still use current_size for images
+ *  that have CHS geometry of the maximum size.
+ */
+static bool vpc_ignore_current_size(VHDFooter *footer)
+{
+    return !!strncmp(footer->creator_app, "win ", 4) &&
+           !!strncmp(footer->creator_app, "qem2", 4) &&
+           !!strncmp(footer->creator_app, "d2v ", 4) &&
+           !!strncmp(footer->creator_app, "CTXS", 4) &&
+           !!memcmp(footer->creator_app, "tap", 4));
+}
+
 static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
                     Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
     bs->total_sectors = (int64_t)
         be16_to_cpu(footer->cyls) * footer->heads * footer->secs_per_cyl;
 
-    /* Microsoft Virtual PC and Microsoft Hyper-V produce and read
-     * VHD image sizes differently.  VPC will rely on CHS geometry,
-     * while Hyper-V and disk2vhd use the size specified in the footer.
-     *
-     * We use a couple of approaches to try and determine the correct method:
-     * look at the Creator App field, and look for images that have CHS
-     * geometry that is the maximum value.
-     *
-     * If the CHS geometry is the maximum CHS geometry, then we assume that
-     * the size is the footer->current_size to avoid truncation.  Otherwise,
-     * we follow the table based on footer->creator_app:
-     *
-     *  Known creator apps:
-     *      'vpc '  :  CHS              Virtual PC (uses disk geometry)
-     *      'qemu'  :  CHS              QEMU (uses disk geometry)
-     *      'qem2'  :  current_size     QEMU (uses current_size)
-     *      'win '  :  current_size     Hyper-V
-     *      'd2v '  :  current_size     Disk2vhd
-     *      'tap\0' :  current_size     XenServer
-     *      'CTXS'  :  current_size     XenConverter
-     *
-     *  The user can override the table values via drive options, however
-     *  even with an override we will still use current_size for images
-     *  that have CHS geometry of the maximum size.
-     */
-    use_chs = (!!strncmp(footer->creator_app, "win ", 4) &&
-               !!strncmp(footer->creator_app, "qem2", 4) &&
-               !!strncmp(footer->creator_app, "d2v ", 4) &&
-               !!strncmp(footer->creator_app, "CTXS", 4) &&
-               !!memcmp(footer->creator_app, "tap", 4)) || s->force_use_chs;
+    /* Use CHS or current_size to determine the image size. */
+    use_chs = vpc_ignore_current_size(footer) || s->force_use_chs;
 
     if (!use_chs || bs->total_sectors == VHD_MAX_GEOMETRY || s->force_use_sz) {
         bs->total_sectors = be64_to_cpu(footer->current_size) /
-- 
2.48.1

From: Vitaly Kuznetsov <vkuznets@redhat.com>

It was found that 'qemu-nbd' is not able to work with some disk images
exported from Azure. Looking at the 512b footer (which contains VPC
metadata):

00000000  63 6f 6e 65 63 74 69 78  00 00 00 02 00 01 00 00  |conectix........|
00000010  ff ff ff ff ff ff ff ff  2e c7 9b 96 77 61 00 00  |............wa..|
00000020  00 07 00 00 57 69 32 6b  00 00 00 01 40 00 00 00  |....Wi2k....@...|
00000030  00 00 00 01 40 00 00 00  28 a2 10 3f 00 00 00 02  |....@...(..?....|
00000040  ff ff e7 47 8c 54 df 94  bd 35 71 4c 94 5f e5 44  |...G.T...5qL._.D|
00000050  44 53 92 1a 00 00 00 00  00 00 00 00 00 00 00 00  |DS..............|
00000060  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|

we can see that Azure uses a different 'Creator application' --
'wa\0\0' (offset 0x1c, likely reads as 'Windows Azure') and QEMU uses this
field to determine how it can get image size. Apparently, Azure uses 'new'
method, just like Hyper-V.

Overall, it seems that only VPC and old QEMUs need to be ignored as all new
creator apps seem to have reliable current_size. Invert the logic and make
'current_size' method the default to avoid adding every new creator app to
the list.

Signed-off-by: Vitaly Kuznetsov <vkuznets@redhat.com>
Message-ID: <20241212134504.1983757-3-vkuznets@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vpc.c | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

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 void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
  *      'd2v '  :  current_size     Disk2vhd
  *      'tap\0' :  current_size     XenServer
  *      'CTXS'  :  current_size     XenConverter
+ *      'wa\0\0':  current_size     Azure
  *
  *  The user can override the table values via drive options, however
  *  even with an override we will still use current_size for images
@@ -XXX,XX +XXX,XX @@ static void vpc_parse_options(BlockDriverState *bs, QemuOpts *opts,
  */
 static bool vpc_ignore_current_size(VHDFooter *footer)
 {
-    return !!strncmp(footer->creator_app, "win ", 4) &&
-           !!strncmp(footer->creator_app, "qem2", 4) &&
-           !!strncmp(footer->creator_app, "d2v ", 4) &&
-           !!strncmp(footer->creator_app, "CTXS", 4) &&
-           !!memcmp(footer->creator_app, "tap", 4));
+    return !strncmp(footer->creator_app, "vpc ", 4) ||
+           !strncmp(footer->creator_app, "qemu", 4);
 }
 
 static int vpc_open(BlockDriverState *bs, QDict *options, int flags,
-- 
2.48.1

From: Philippe Mathieu-Daudé <philmd@linaro.org>

Expose the method docstring in the header, and mention
returned value must be free'd by caller.

Reported-by: Fabiano Rosas <farosas@suse.de>
Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Message-ID: <20241111170333.43833-2-philmd@linaro.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/system/block-backend-io.h |  7 +++++++
 block/block-backend.c             | 12 ++++++++----
 2 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/include/system/block-backend-io.h b/include/system/block-backend-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/system/block-backend-io.h
+++ b/include/system/block-backend-io.h
@@ -XXX,XX +XXX,XX @@ void blk_set_allow_aio_context_change(BlockBackend *blk, bool allow);
 void blk_set_disable_request_queuing(BlockBackend *blk, bool disable);
 bool blk_iostatus_is_enabled(const BlockBackend *blk);
 
+/*
+ * Return the qdev ID, or if no ID is assigned the QOM path,
+ * of the block device attached to the BlockBackend.
+ *
+ * The caller is responsible for releasing the value returned
+ * with g_free() after use.
+ */
 char *blk_get_attached_dev_id(BlockBackend *blk);
 
 BlockAIOCB *blk_aio_pwrite_zeroes(BlockBackend *blk, int64_t offset,
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ DeviceState *blk_get_attached_dev(BlockBackend *blk)
     return blk->dev;
 }
 
+/*
+ * The caller is responsible for releasing the value returned
+ * with g_free() after use.
+ */
 static char *blk_get_attached_dev_id_or_path(BlockBackend *blk, bool want_id)
 {
     DeviceState *dev = blk->dev;
@@ -XXX,XX +XXX,XX @@ static char *blk_get_attached_dev_id_or_path(BlockBackend *blk, bool want_id)
     return object_get_canonical_path(OBJECT(dev)) ?: g_strdup("");
 }
 
-/*
- * Return the qdev ID, or if no ID is assigned the QOM path, of the block
- * device attached to the BlockBackend.
- */
 char *blk_get_attached_dev_id(BlockBackend *blk)
 {
     return blk_get_attached_dev_id_or_path(blk, true);
 }
 
+/*
+ * The caller is responsible for releasing the value returned
+ * with g_free() after use.
+ */
 static char *blk_get_attached_dev_path(BlockBackend *blk)
 {
     return blk_get_attached_dev_id_or_path(blk, false);
-- 
2.48.1

From: Fabiano Rosas <farosas@suse.de>

ASAN detected a leak when running the ahci-test
/ahci/io/dma/lba28/retry:

Direct leak of 35 byte(s) in 1 object(s) allocated from:
    #0 in malloc
    #1 in __vasprintf_internal
    #2 in vasprintf
    #3 in g_vasprintf
    #4 in g_strdup_vprintf
    #5 in g_strdup_printf
    #6 in object_get_canonical_path ../qom/object.c:2096:19
    #7 in blk_get_attached_dev_id_or_path ../block/block-backend.c:1033:12
    #8 in blk_get_attached_dev_path ../block/block-backend.c:1047:12
    #9 in send_qmp_error_event ../block/block-backend.c:2140:36
    #10 in blk_error_action ../block/block-backend.c:2172:9
    #11 in ide_handle_rw_error ../hw/ide/core.c:875:5
    #12 in ide_dma_cb ../hw/ide/core.c:894:13
    #13 in dma_complete ../system/dma-helpers.c:107:9
    #14 in dma_blk_cb ../system/dma-helpers.c:129:9
    #15 in blk_aio_complete ../block/block-backend.c:1552:9
    #16 in blk_aio_write_entry ../block/block-backend.c:1619:5
    #17 in coroutine_trampoline ../util/coroutine-ucontext.c:175:9

Plug the leak by freeing the device path string.

Signed-off-by: Fabiano Rosas <farosas@suse.de>
Reviewed-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Message-ID: <20241111145214.8261-1-farosas@suse.de>
[PMD: Use g_autofree]
Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Message-ID: <20241111170333.43833-3-philmd@linaro.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/block-backend.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ static void send_qmp_error_event(BlockBackend *blk,
 {
     IoOperationType optype;
     BlockDriverState *bs = blk_bs(blk);
+    g_autofree char *path = blk_get_attached_dev_path(blk);
 
     optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
-    qapi_event_send_block_io_error(blk_name(blk),
-                                   blk_get_attached_dev_path(blk),
+    qapi_event_send_block_io_error(blk_name(blk), path,
                                    bs ? bdrv_get_node_name(bs) : NULL, optype,
                                    action, blk_iostatus_is_enabled(blk),
                                    error == ENOSPC, strerror(error));
-- 
2.48.1

From: Peter Xu <peterx@redhat.com>

There're a bunch of code trying to fetch fs_base in different ways.  IIUC
the simplest way instead is "$fs_base".  It also has the benefit that it'll
work for both live gdb session or coredumps.

Signed-off-by: Peter Xu <peterx@redhat.com>
Message-ID: <20241212204801.1420528-3-peterx@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 scripts/qemugdb/coroutine.py | 23 ++---------------------
 1 file changed, 2 insertions(+), 21 deletions(-)

diff --git a/scripts/qemugdb/coroutine.py b/scripts/qemugdb/coroutine.py
index XXXXXXX..XXXXXXX 100644
--- a/scripts/qemugdb/coroutine.py
+++ b/scripts/qemugdb/coroutine.py
@@ -XXX,XX +XXX,XX @@
 
 VOID_PTR = gdb.lookup_type('void').pointer()
 
-def get_fs_base():
-    '''Fetch %fs base value using arch_prctl(ARCH_GET_FS).  This is
-       pthread_self().'''
-    # %rsp - 120 is scratch space according to the SystemV ABI
-    old = gdb.parse_and_eval('*(uint64_t*)($rsp - 120)')
-    gdb.execute('call (int)arch_prctl(0x1003, $rsp - 120)', False, True)
-    fs_base = gdb.parse_and_eval('*(uint64_t*)($rsp - 120)')
-    gdb.execute('set *(uint64_t*)($rsp - 120) = %s' % old, False, True)
-    return fs_base
-
 def pthread_self():
-    '''Fetch pthread_self() from the glibc start_thread function.'''
-    f = gdb.newest_frame()
-    while f.name() != 'start_thread':
-        f = f.older()
-        if f is None:
-            return get_fs_base()
-
-    try:
-        return f.read_var("arg")
-    except ValueError:
-        return get_fs_base()
+    '''Fetch the base address of TLS.'''
+    return gdb.parse_and_eval("$fs_base")
 
 def get_glibc_pointer_guard():
     '''Fetch glibc pointer guard value'''
-- 
2.48.1

From: Peter Xu <peterx@redhat.com>

Dumping coroutines don't yet work with coredumps.  Let's make it work.

We still kept most of the old code because they can be either more
flexible, or prettier.  Only add the fallbacks when they stop working.

Currently the raw unwind is pretty ugly, but it works, like this:

(gdb) qemu bt
  #0  process_incoming_migration_co (opaque=0x0) at ../migration/migration.c:788
  #1  0x000055ae6c0dc4d9 in coroutine_trampoline (i0=-1711718576, i1=21934) at ../util/coroutine-ucontext.c:175
  #2  0x00007f9f59d72f40 in ??? () at /lib64/libc.so.6
  #3  0x00007ffd549214a0 in ??? ()
  #4  0x0000000000000000 in ??? ()
  Coroutine at 0x7f9f4c57c748:
  #0  0x55ae6c0dc9a8 in qemu_coroutine_switch<+120> () at ../util/coroutine-ucontext.c:321
  #1  0x55ae6c0da2f8 in qemu_aio_coroutine_enter<+356> () at ../util/qemu-coroutine.c:293
  #2  0x55ae6c0da3f1 in qemu_coroutine_enter<+34> () at ../util/qemu-coroutine.c:316
  #3  0x55ae6baf775e in migration_incoming_process<+43> () at ../migration/migration.c:876
  #4  0x55ae6baf7ab4 in migration_ioc_process_incoming<+490> () at ../migration/migration.c:1008
  #5  0x55ae6bae9ae7 in migration_channel_process_incoming<+145> () at ../migration/channel.c:45
  #6  0x55ae6bb18e35 in socket_accept_incoming_migration<+118> () at ../migration/socket.c:132
  #7  0x55ae6be939ef in qio_net_listener_channel_func<+131> () at ../io/net-listener.c:54
  #8  0x55ae6be8ce1a in qio_channel_fd_source_dispatch<+78> () at ../io/channel-watch.c:84
  #9  0x7f9f5b26728c in g_main_context_dispatch_unlocked.lto_priv<+315> ()
  #10  0x7f9f5b267555 in g_main_context_dispatch<+36> ()
  #11  0x55ae6c0d91a7 in glib_pollfds_poll<+90> () at ../util/main-loop.c:287
  #12  0x55ae6c0d9235 in os_host_main_loop_wait<+128> () at ../util/main-loop.c:310
  #13  0x55ae6c0d9364 in main_loop_wait<+203> () at ../util/main-loop.c:589
  #14  0x55ae6bac212a in qemu_main_loop<+41> () at ../system/runstate.c:835
  #15  0x55ae6bfdf522 in qemu_default_main<+19> () at ../system/main.c:37
  #16  0x55ae6bfdf55f in main<+40> () at ../system/main.c:48
  #17  0x7f9f59d42248 in __libc_start_call_main<+119> ()
  #18  0x7f9f59d4230b in __libc_start_main_impl<+138> ()

Signed-off-by: Peter Xu <peterx@redhat.com>
Message-ID: <20241212204801.1420528-4-peterx@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 scripts/qemugdb/coroutine.py | 79 +++++++++++++++++++++++++++++++++---
 1 file changed, 73 insertions(+), 6 deletions(-)

diff --git a/scripts/qemugdb/coroutine.py b/scripts/qemugdb/coroutine.py
index XXXXXXX..XXXXXXX 100644
--- a/scripts/qemugdb/coroutine.py
+++ b/scripts/qemugdb/coroutine.py
@@ -XXX,XX +XXX,XX @@ def get_jmpbuf_regs(jmpbuf):
         'r15': jmpbuf[JB_R15],
         'rip': glibc_ptr_demangle(jmpbuf[JB_PC], pointer_guard) }
 
-def bt_jmpbuf(jmpbuf):
-    '''Backtrace a jmpbuf'''
-    regs = get_jmpbuf_regs(jmpbuf)
+def symbol_lookup(addr):
+    # Example: "__clone3 + 44 in section .text of /lib64/libc.so.6"
+    result = gdb.execute(f"info symbol {hex(addr)}", to_string=True).strip()
+    try:
+        if "+" in result:
+            (func, result) = result.split(" + ")
+            (offset, result) = result.split(" in ")
+        else:
+            offset = "0"
+            (func, result) = result.split(" in ")
+        func_str = f"{func}<+{offset}> ()"
+    except:
+        return f"??? ({result})"
+
+    # Example: Line 321 of "../util/coroutine-ucontext.c" starts at address
+    # 0x55cf3894d993 <qemu_coroutine_switch+99> and ends at 0x55cf3894d9ab
+    # <qemu_coroutine_switch+123>.
+    result = gdb.execute(f"info line *{hex(addr)}", to_string=True).strip()
+    if not result.startswith("Line "):
+        return func_str
+    result = result[5:]
+
+    try:
+        result = result.split(" starts ")[0]
+        (line, path) = result.split(" of ")
+        path = path.replace("\"", "")
+    except:
+        return func_str
+
+    return f"{func_str} at {path}:{line}"
+
+def dump_backtrace(regs):
+    '''
+    Backtrace dump with raw registers, mimic GDB command 'bt'.
+    '''
+    # Here only rbp and rip that matter..
+    rbp = regs['rbp']
+    rip = regs['rip']
+    i = 0
+
+    while rbp:
+        # For all return addresses on stack, we want to look up symbol/line
+        # on the CALL command, because the return address is the next
+        # instruction instead of the CALL.  Here -1 would work for any
+        # sized CALL instruction.
+        print(f"#{i}  {hex(rip)} in {symbol_lookup(rip if i == 0 else rip-1)}")
+        rip = gdb.parse_and_eval(f"*(uint64_t *)(uint64_t)({hex(rbp)} + 8)")
+        rbp = gdb.parse_and_eval(f"*(uint64_t *)(uint64_t)({hex(rbp)})")
+        i += 1
+
+def dump_backtrace_live(regs):
+    '''
+    Backtrace dump with gdb's 'bt' command, only usable in a live session.
+    '''
     old = dict()
 
     # remember current stack frame and select the topmost
@@ -XXX,XX +XXX,XX @@ def bt_jmpbuf(jmpbuf):
 
     selected_frame.select()
 
+def bt_jmpbuf(jmpbuf):
+    '''Backtrace a jmpbuf'''
+    regs = get_jmpbuf_regs(jmpbuf)
+    try:
+        # This reuses gdb's "bt" command, which can be slightly prettier
+        # but only works with live sessions.
+        dump_backtrace_live(regs)
+    except:
+        # If above doesn't work, fallback to poor man's unwind
+        dump_backtrace(regs)
+
 def co_cast(co):
     return co.cast(gdb.lookup_type('CoroutineUContext').pointer())
 
@@ -XXX,XX +XXX,XX @@ def invoke(self, arg, from_tty):
 
         gdb.execute("bt")
 
-        if gdb.parse_and_eval("qemu_in_coroutine()") == False:
-            return
+        try:
+            # This only works with a live session
+            co_ptr = gdb.parse_and_eval("qemu_coroutine_self()")
+        except:
+            # Fallback to use hard-coded ucontext vars if it's coredump
+            co_ptr = gdb.parse_and_eval("co_tls_current")
 
-        co_ptr = gdb.parse_and_eval("qemu_coroutine_self()")
+        if co_ptr == False:
+            return
 
         while True:
             co = co_cast(co_ptr)
-- 
2.48.1

From: Peter Krempa <pkrempa@redhat.com>

Commit 7452162adec25c10 introduced 'qom-path' argument to BLOCK_IO_ERROR
event but when the event is instantiated in 'send_qmp_error_event()' the
arguments for 'device' and 'qom_path' in
qapi_event_send_block_io_error() were reversed :

Generated code for sending event:

void qapi_event_send_block_io_error(const char *qom_path,
                                      const char *device,
                                      const char *node_name,
                                      IoOperationType operation,
                                      [...]

Call inside send_qmp_error_event():

qapi_event_send_block_io_error(blk_name(blk),
                                    blk_get_attached_dev_path(blk),
                                    bs ? bdrv_get_node_name(bs) : NULL, optype,
                                    [...]

This results into reporting the QOM path as the device alias and vice
versa which in turn breaks libvirt, which expects the device alias being
either a valid alias or empty (which would make libvirt do the lookup by
node-name instead).

Cc: qemu-stable@nongnu.org
Fixes: 7452162adec2 ("qapi: add qom-path to BLOCK_IO_ERROR event")
Signed-off-by: Peter Krempa <pkrempa@redhat.com>
Message-ID: <09728d784888b38d7a8f09ee5e9e9c542c875e1e.1737973614.git.pkrempa@redhat.com>
Reviewed-by: Daniel P. Berrangé <berrange@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/block-backend.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ static void send_qmp_error_event(BlockBackend *blk,
     g_autofree char *path = blk_get_attached_dev_path(blk);
 
     optype = is_read ? IO_OPERATION_TYPE_READ : IO_OPERATION_TYPE_WRITE;
-    qapi_event_send_block_io_error(blk_name(blk), path,
+    qapi_event_send_block_io_error(path, blk_name(blk),
                                    bs ? bdrv_get_node_name(bs) : NULL, optype,
                                    action, blk_iostatus_is_enabled(blk),
                                    error == ENOSPC, strerror(error));
-- 
2.48.1

This allows querying from QMP (and also HMP) whether an image is
currently active or inactive (in the sense of BDRV_O_INACTIVE).

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Acked-by: Fabiano Rosas <farosas@suse.de>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-ID: <20250204211407.381505-2-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json               |  6 +++++-
 include/block/block-global-state.h |  3 +++
 block.c                            |  4 ++++
 block/monitor/block-hmp-cmds.c     |  5 +++--
 block/qapi.c                       |  1 +
 tests/qemu-iotests/184.out         |  2 ++
 tests/qemu-iotests/191.out         | 16 ++++++++++++++++
 tests/qemu-iotests/273.out         |  5 +++++
 8 files changed, 39 insertions(+), 3 deletions(-)

diff --git a/qapi/block-core.json b/qapi/block-core.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-core.json
+++ b/qapi/block-core.json
@@ -XXX,XX +XXX,XX @@
 # @backing_file_depth: number of files in the backing file chain
 #     (since: 1.2)
 #
+# @active: true if the backend is active; typical cases for inactive backends
+#     are on the migration source instance after migration completes and on the
+#     destination before it completes. (since: 10.0)
+#
 # @encrypted: true if the backing device is encrypted
 #
 # @detect_zeroes: detect and optimize zero writes (Since 2.1)
@@ -XXX,XX +XXX,XX @@
 { 'struct': 'BlockDeviceInfo',
   'data': { 'file': 'str', '*node-name': 'str', 'ro': 'bool', 'drv': 'str',
             '*backing_file': 'str', 'backing_file_depth': 'int',
-            'encrypted': 'bool',
+            'active': 'bool', 'encrypted': 'bool',
             'detect_zeroes': 'BlockdevDetectZeroesOptions',
             'bps': 'int', 'bps_rd': 'int', 'bps_wr': 'int',
             'iops': 'int', 'iops_rd': 'int', 'iops_wr': 'int',
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 @@ BlockDriverState * GRAPH_RDLOCK
 check_to_replace_node(BlockDriverState *parent_bs, const char *node_name,
                       Error **errp);
 
+
+bool GRAPH_RDLOCK bdrv_is_inactive(BlockDriverState *bs);
+
 int no_coroutine_fn GRAPH_RDLOCK
 bdrv_activate(BlockDriverState *bs, Error **errp);
 
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ void bdrv_init_with_whitelist(void)
     bdrv_init();
 }
 
+bool bdrv_is_inactive(BlockDriverState *bs) {
+    return bs->open_flags & BDRV_O_INACTIVE;
+}
+
 int bdrv_activate(BlockDriverState *bs, Error **errp)
 {
     BdrvChild *child, *parent;
diff --git a/block/monitor/block-hmp-cmds.c b/block/monitor/block-hmp-cmds.c
index XXXXXXX..XXXXXXX 100644
--- a/block/monitor/block-hmp-cmds.c
+++ b/block/monitor/block-hmp-cmds.c
@@ -XXX,XX +XXX,XX @@ static void print_block_info(Monitor *mon, BlockInfo *info,
     }
 
     if (inserted) {
-        monitor_printf(mon, ": %s (%s%s%s)\n",
+        monitor_printf(mon, ": %s (%s%s%s%s)\n",
                        inserted->file,
                        inserted->drv,
                        inserted->ro ? ", read-only" : "",
-                       inserted->encrypted ? ", encrypted" : "");
+                       inserted->encrypted ? ", encrypted" : "",
+                       inserted->active ? "" : ", inactive");
     } else {
         monitor_printf(mon, ": [not inserted]\n");
     }
diff --git a/block/qapi.c b/block/qapi.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qapi.c
+++ b/block/qapi.c
@@ -XXX,XX +XXX,XX @@ BlockDeviceInfo *bdrv_block_device_info(BlockBackend *blk,
     info->file                   = g_strdup(bs->filename);
     info->ro                     = bdrv_is_read_only(bs);
     info->drv                    = g_strdup(bs->drv->format_name);
+    info->active                 = !bdrv_is_inactive(bs);
     info->encrypted              = bs->encrypted;
 
     info->cache = g_new(BlockdevCacheInfo, 1);
diff --git a/tests/qemu-iotests/184.out b/tests/qemu-iotests/184.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/184.out
+++ b/tests/qemu-iotests/184.out
@@ -XXX,XX +XXX,XX @@ Testing:
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "backing-image": {
                     "virtual-size": 1073741824,
@@ -XXX,XX +XXX,XX @@ Testing:
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 1073741824,
                 "filename": "null-co://",
diff --git a/tests/qemu-iotests/191.out b/tests/qemu-iotests/191.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/191.out
+++ b/tests/qemu-iotests/191.out
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "backing-image": {
                     "virtual-size": 67108864,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 197120,
                 "filename": "TEST_DIR/t.IMGFMT.ovl2",
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "backing-image": {
                     "virtual-size": 67108864,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 197120,
                 "filename": "TEST_DIR/t.IMGFMT",
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "backing-image": {
                     "virtual-size": 67108864,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 393216,
                 "filename": "TEST_DIR/t.IMGFMT.mid",
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 67108864,
                 "filename": "TEST_DIR/t.IMGFMT.base",
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 393216,
                 "filename": "TEST_DIR/t.IMGFMT.base",
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "backing-image": {
                     "virtual-size": 67108864,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 197120,
                 "filename": "TEST_DIR/t.IMGFMT.ovl2",
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "backing-image": {
                     "backing-image": {
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 197120,
                 "filename": "TEST_DIR/t.IMGFMT.ovl3",
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 67108864,
                 "filename": "TEST_DIR/t.IMGFMT.base",
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 393216,
                 "filename": "TEST_DIR/t.IMGFMT.base",
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "backing-image": {
                     "virtual-size": 67108864,
@@ -XXX,XX +XXX,XX @@ wrote 65536/65536 bytes at offset 1048576
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 197120,
                 "filename": "TEST_DIR/t.IMGFMT",
diff --git a/tests/qemu-iotests/273.out b/tests/qemu-iotests/273.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/273.out
+++ b/tests/qemu-iotests/273.out
@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "backing-image": {
                     "backing-image": {
@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 197120,
                 "filename": "TEST_DIR/t.IMGFMT",
@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "backing-image": {
                     "virtual-size": 197120,
@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 197120,
                 "filename": "TEST_DIR/t.IMGFMT.mid",
@@ -XXX,XX +XXX,XX @@ Testing: -blockdev file,node-name=base,filename=TEST_DIR/t.IMGFMT.base -blockdev
         {
             "iops_rd": 0,
             "detect_zeroes": "off",
+            "active": true,
             "image": {
                 "virtual-size": 197120,
                 "filename": "TEST_DIR/t.IMGFMT.base",
-- 
2.48.1

What we wanted to catch with the assertion is cases where the recursion
finds that a child was inactive before its parent. This should never
happen. But if the user tries to inactivate an image that is already
inactive, that's harmless and we don't want to fail the assertion.

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ bdrv_has_bds_parent(BlockDriverState *bs, bool only_active)
     return false;
 }
 
-static int GRAPH_RDLOCK bdrv_inactivate_recurse(BlockDriverState *bs)
+static int GRAPH_RDLOCK
+bdrv_inactivate_recurse(BlockDriverState *bs, bool top_level)
 {
     BdrvChild *child, *parent;
     int ret;
@@ -XXX,XX +XXX,XX @@ static int GRAPH_RDLOCK bdrv_inactivate_recurse(BlockDriverState *bs)
         return 0;
     }
 
-    assert(!(bs->open_flags & BDRV_O_INACTIVE));
+    /*
+     * Inactivating an already inactive node on user request is harmless, but if
+     * a child is already inactive before its parent, that's bad.
+     */
+    if (bs->open_flags & BDRV_O_INACTIVE) {
+        assert(top_level);
+        return 0;
+    }
 
     /* Inactivate this node */
     if (bs->drv->bdrv_inactivate) {
@@ -XXX,XX +XXX,XX @@ static int GRAPH_RDLOCK bdrv_inactivate_recurse(BlockDriverState *bs)
 
     /* Recursively inactivate children */
     QLIST_FOREACH(child, &bs->children, next) {
-        ret = bdrv_inactivate_recurse(child->bs);
+        ret = bdrv_inactivate_recurse(child->bs, false);
         if (ret < 0) {
             return ret;
         }
@@ -XXX,XX +XXX,XX @@ int bdrv_inactivate_all(void)
         if (bdrv_has_bds_parent(bs, false)) {
             continue;
         }
-        ret = bdrv_inactivate_recurse(bs);
+        ret = bdrv_inactivate_recurse(bs, true);
         if (ret < 0) {
             bdrv_next_cleanup(&it);
             break;
-- 
2.48.1

Putting an active block node on top of an inactive one is strictly
speaking an invalid configuration and the next patch will turn it into a
hard error.

However, taking a snapshot while disk images are inactive after
completing migration has an important use case: After migrating to a
file, taking an external snapshot is what is needed to take a full VM
snapshot.

In order for this to keep working after the later patches, change
creating a snapshot such that it automatically inactivates an overlay
that is added on top of an already inactive node.

diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ static void external_snapshot_action(TransactionAction *action,
         return;
     }
 
+    /*
+     * Older QEMU versions have allowed adding an active parent node to an
+     * inactive child node. This is unsafe in the general case, but there is an
+     * important use case, which is taking a VM snapshot with migration to file
+     * and then adding an external snapshot while the VM is still stopped and
+     * images are inactive. Requiring the user to explicitly create the overlay
+     * as inactive would break compatibility, so just do it automatically here
+     * to keep this working.
+     */
+    if (bdrv_is_inactive(state->old_bs) && !bdrv_is_inactive(state->new_bs)) {
+        ret = bdrv_inactivate(state->new_bs, errp);
+        if (ret < 0) {
+            return;
+        }
+    }
+
     ret = bdrv_append(state->new_bs, state->old_bs, errp);
     if (ret < 0) {
         return;
-- 
2.48.1

Block devices have an individual active state, a single global flag
can't cover this correctly. This becomes more important as we allow
users to manually manage which nodes are active or inactive.

Now that it's allowed to call bdrv_inactivate_all() even when some
nodes are already inactive, we can remove the flag and just
unconditionally call bdrv_inactivate_all() and, more importantly,
bdrv_activate_all() before we make use of the nodes.

diff --git a/migration/migration.h b/migration/migration.h
index XXXXXXX..XXXXXXX 100644
--- a/migration/migration.h
+++ b/migration/migration.h
@@ -XXX,XX +XXX,XX @@ void migration_bitmap_sync_precopy(bool last_stage);
 void dirty_bitmap_mig_init(void);
 bool should_send_vmdesc(void);
 
-/* migration/block-active.c */
-void migration_block_active_setup(bool active);
-
 #endif
diff --git a/migration/block-active.c b/migration/block-active.c
index XXXXXXX..XXXXXXX 100644
--- a/migration/block-active.c
+++ b/migration/block-active.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/error-report.h"
 #include "trace.h"
 
-/*
- * Migration-only cache to remember the block layer activation status.
- * Protected by BQL.
- *
- * We need this because..
- *
- * - Migration can fail after block devices are invalidated (during
- *   switchover phase).  When that happens, we need to be able to recover
- *   the block drive status by re-activating them.
- *
- * - Currently bdrv_inactivate_all() is not safe to be invoked on top of
- *   invalidated drives (even if bdrv_activate_all() is actually safe to be
- *   called any time!).  It means remembering this could help migration to
- *   make sure it won't invalidate twice in a row, crashing QEMU.  It can
- *   happen when we migrate a PAUSED VM from host1 to host2, then migrate
- *   again to host3 without starting it.  TODO: a cleaner solution is to
- *   allow safe invoke of bdrv_inactivate_all() at anytime, like
- *   bdrv_activate_all().
- *
- * For freshly started QEMU, the flag is initialized to TRUE reflecting the
- * scenario where QEMU owns block device ownerships.
- *
- * For incoming QEMU taking a migration stream, the flag is initialized to
- * FALSE reflecting that the incoming side doesn't own the block devices,
- * not until switchover happens.
- */
-static bool migration_block_active;
-
-/* Setup the disk activation status */
-void migration_block_active_setup(bool active)
-{
-    migration_block_active = active;
-}
-
 bool migration_block_activate(Error **errp)
 {
     ERRP_GUARD();
 
     assert(bql_locked());
 
-    if (migration_block_active) {
-        trace_migration_block_activation("active-skipped");
-        return true;
-    }
-
     trace_migration_block_activation("active");
 
     bdrv_activate_all(errp);
@@ -XXX,XX +XXX,XX @@ bool migration_block_activate(Error **errp)
         return false;
     }
 
-    migration_block_active = true;
     return true;
 }
 
@@ -XXX,XX +XXX,XX @@ bool migration_block_inactivate(void)
 
     assert(bql_locked());
 
-    if (!migration_block_active) {
-        trace_migration_block_activation("inactive-skipped");
-        return true;
-    }
-
     trace_migration_block_activation("inactive");
 
     ret = bdrv_inactivate_all();
@@ -XXX,XX +XXX,XX @@ bool migration_block_inactivate(void)
         return false;
     }
 
-    migration_block_active = false;
     return true;
 }
diff --git a/migration/migration.c b/migration/migration.c
index XXXXXXX..XXXXXXX 100644
--- a/migration/migration.c
+++ b/migration/migration.c
@@ -XXX,XX +XXX,XX @@ void qmp_migrate_incoming(const char *uri, bool has_channels,
         return;
     }
 
-    /*
-     * Newly setup incoming QEMU.  Mark the block active state to reflect
-     * that the src currently owns the disks.
-     */
-    migration_block_active_setup(false);
-
     once = false;
 }
 
@@ -XXX,XX +XXX,XX @@ static void migration_instance_init(Object *obj)
     ms->state = MIGRATION_STATUS_NONE;
     ms->mbps = -1;
     ms->pages_per_second = -1;
-    /* Freshly started QEMU owns all the block devices */
-    migration_block_active_setup(true);
     qemu_sem_init(&ms->pause_sem, 0);
     qemu_mutex_init(&ms->error_mutex);
 
-- 
2.48.1

An active node makes unrestricted use of its children and would possibly
run into assertion failures when it operates on an inactive child node.

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ bdrv_attach_child_noperm(BlockDriverState *parent_bs,
                    child_bs->node_name, child_name, parent_bs->node_name);
         return NULL;
     }
+    if (bdrv_is_inactive(child_bs) && !bdrv_is_inactive(parent_bs)) {
+        error_setg(errp, "Inactive '%s' can't be a %s child of active '%s'",
+                   child_bs->node_name, child_name, parent_bs->node_name);
+        return NULL;
+    }
 
     bdrv_get_cumulative_perm(parent_bs, &perm, &shared_perm);
     bdrv_child_perm(parent_bs, child_bs, NULL, child_role, NULL,
-- 
2.48.1

In order for block_resize to fail gracefully on an inactive node instead
of crashing with an assertion failure in bdrv_co_write_req_prepare()
(called from bdrv_co_truncate()), we need to check for inactive nodes
also when they are attached as a root node and make sure that
BLK_PERM_RESIZE isn't among the permissions allowed for inactive nodes.
To this effect, don't enumerate the permissions that are incompatible
with inactive nodes any more, but allow only BLK_PERM_CONSISTENT_READ
for them.

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ bdrv_attach_child_common(BlockDriverState *child_bs,
     assert(child_class->get_parent_desc);
     GLOBAL_STATE_CODE();
 
+    if (bdrv_is_inactive(child_bs) && (perm & ~BLK_PERM_CONSISTENT_READ)) {
+        g_autofree char *perm_names = bdrv_perm_names(perm);
+        error_setg(errp, "Permission '%s' unavailable on inactive node",
+                   perm_names);
+        return NULL;
+    }
+
     new_child = g_new(BdrvChild, 1);
     *new_child = (BdrvChild) {
         .bs             = NULL,
diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ static bool blk_can_inactivate(BlockBackend *blk)
      * guest.  For block job BBs that satisfy this, we can just allow
      * it.  This is the case for mirror job source, which is required
      * by libvirt non-shared block migration. */
-    if (!(blk->perm & (BLK_PERM_WRITE | BLK_PERM_WRITE_UNCHANGED))) {
+    if (!(blk->perm & ~BLK_PERM_CONSISTENT_READ)) {
         return true;
     }
 
-- 
2.48.1

In QEMU, nodes are automatically created inactive while expecting an
incoming migration (i.e. RUN_STATE_INMIGRATE). In qemu-storage-daemon,
the notion of runstates doesn't exist. It also wouldn't necessarily make
sense to introduce it because a single daemon can serve multiple VMs
that can be in different states.

Therefore, allow the user to explicitly open images as inactive with a
new option. The default is as before: Nodes are usually active, except
when created during RUN_STATE_INMIGRATE.

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 @@
 #
 # @cache: cache-related options
 #
+# @active: whether the block node should be activated (default: true).
+#     Having inactive block nodes is useful primarily for migration because it
+#     allows opening an image on the destination while the source is still
+#     holding locks for it. (Since 10.0)
+#
 # @read-only: whether the block device should be read-only (default:
 #     false).  Note that some block drivers support only read-only
 #     access, either generally or in certain configurations.  In this
@@ -XXX,XX +XXX,XX @@
             '*node-name': 'str',
             '*discard': 'BlockdevDiscardOptions',
             '*cache': 'BlockdevCacheOptions',
+            '*active': 'bool',
             '*read-only': 'bool',
             '*auto-read-only': 'bool',
             '*force-share': 'bool',
diff --git a/include/block/block-common.h b/include/block/block-common.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-common.h
+++ b/include/block/block-common.h
@@ -XXX,XX +XXX,XX @@ typedef enum {
 #define BDRV_OPT_AUTO_READ_ONLY "auto-read-only"
 #define BDRV_OPT_DISCARD        "discard"
 #define BDRV_OPT_FORCE_SHARE    "force-share"
+#define BDRV_OPT_ACTIVE         "active"
 
 
 #define BDRV_SECTOR_BITS   9
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static void update_flags_from_options(int *flags, QemuOpts *opts)
     if (qemu_opt_get_bool_del(opts, BDRV_OPT_AUTO_READ_ONLY, false)) {
         *flags |= BDRV_O_AUTO_RDONLY;
     }
+
+    if (!qemu_opt_get_bool_del(opts, BDRV_OPT_ACTIVE, true)) {
+        *flags |= BDRV_O_INACTIVE;
+    }
 }
 
 static void update_options_from_flags(QDict *options, int flags)
@@ -XXX,XX +XXX,XX @@ QemuOptsList bdrv_runtime_opts = {
             .type = QEMU_OPT_BOOL,
             .help = "Ignore flush requests",
         },
+        {
+            .name = BDRV_OPT_ACTIVE,
+            .type = QEMU_OPT_BOOL,
+            .help = "Node is activated",
+        },
         {
             .name = BDRV_OPT_READ_ONLY,
             .type = QEMU_OPT_BOOL,
-- 
2.48.1

The system emulator tries to automatically activate and inactivate block
nodes at the right point during migration. However, there are still
cases where it's necessary that the user can do this manually.

Images are only activated on the destination VM of a migration when the
VM is actually resumed. If the VM was paused, this doesn't happen
automatically. The user may want to perform some operation on a block
device (e.g. taking a snapshot or starting a block job) without also
resuming the VM yet. This is an example where a manual command is
necessary.

Another example is VM migration when the image files are opened by an
external qemu-storage-daemon instance on each side. In this case, the
process that needs to hand over the images isn't even part of the
migration and can't know when the migration completes. Management tools
need a way to explicitly inactivate images on the source and activate
them on the destination.

This adds a new blockdev-set-active QMP command that lets the user
change the status of individual nodes (this is necessary in
qemu-storage-daemon because it could be serving multiple VMs and only
one of them migrates at a time). For convenience, operating on all
devices (like QEMU does automatically during migration) is offered as an
option, too, and can be used in the context of single VM.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Acked-by: Fabiano Rosas <farosas@suse.de>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-ID: <20250204211407.381505-9-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 qapi/block-core.json               | 32 ++++++++++++++++++++++++++++++
 include/block/block-global-state.h |  3 +++
 block.c                            | 21 ++++++++++++++++++++
 blockdev.c                         | 32 ++++++++++++++++++++++++++++++
 4 files changed, 88 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 @@
 { 'command': 'blockdev-del', 'data': { 'node-name': 'str' },
   'allow-preconfig': true }
 
+##
+# @blockdev-set-active:
+#
+# Activate or inactivate a block device. Use this to manage the handover of
+# block devices on migration with qemu-storage-daemon.
+#
+# Activating a node automatically activates all of its child nodes first.
+# Inactivating a node automatically inactivates any of its child nodes that are
+# not in use by a still active node.
+#
+# @node-name: Name of the graph node to activate or inactivate. By default, all
+#     nodes are affected by the operation.
+#
+# @active: true if the nodes should be active when the command returns success,
+#     false if they should be inactive.
+#
+# Since: 10.0
+#
+# .. qmp-example::
+#
+#     -> { "execute": "blockdev-set-active",
+#          "arguments": {
+#               "node-name": "node0",
+#               "active": false
+#          }
+#        }
+#     <- { "return": {} }
+##
+{ 'command': 'blockdev-set-active',
+  'data': { '*node-name': 'str', 'active': 'bool' },
+  'allow-preconfig': true }
+
 ##
 # @BlockdevCreateOptionsFile:
 #
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 @@ bdrv_activate(BlockDriverState *bs, Error **errp);
 int coroutine_fn no_co_wrapper_bdrv_rdlock
 bdrv_co_activate(BlockDriverState *bs, Error **errp);
 
+int no_coroutine_fn
+bdrv_inactivate(BlockDriverState *bs, Error **errp);
+
 void bdrv_activate_all(Error **errp);
 int bdrv_inactivate_all(void);
 
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ bdrv_inactivate_recurse(BlockDriverState *bs, bool top_level)
     return 0;
 }
 
+int bdrv_inactivate(BlockDriverState *bs, Error **errp)
+{
+    int ret;
+
+    GLOBAL_STATE_CODE();
+    GRAPH_RDLOCK_GUARD_MAINLOOP();
+
+    if (bdrv_has_bds_parent(bs, true)) {
+        error_setg(errp, "Node has active parent node");
+        return -EPERM;
+    }
+
+    ret = bdrv_inactivate_recurse(bs, true);
+    if (ret < 0) {
+        error_setg_errno(errp, -ret, "Failed to inactivate node");
+        return ret;
+    }
+
+    return 0;
+}
+
 int bdrv_inactivate_all(void)
 {
     BlockDriverState *bs = NULL;
diff --git a/blockdev.c b/blockdev.c
index XXXXXXX..XXXXXXX 100644
--- a/blockdev.c
+++ b/blockdev.c
@@ -XXX,XX +XXX,XX @@ void qmp_blockdev_del(const char *node_name, Error **errp)
     bdrv_unref(bs);
 }
 
+void qmp_blockdev_set_active(const char *node_name, bool active, Error **errp)
+{
+    int ret;
+
+    GLOBAL_STATE_CODE();
+    GRAPH_RDLOCK_GUARD_MAINLOOP();
+
+    if (!node_name) {
+        if (active) {
+            bdrv_activate_all(errp);
+        } else {
+            ret = bdrv_inactivate_all();
+            if (ret < 0) {
+                error_setg_errno(errp, -ret, "Failed to inactivate all nodes");
+            }
+        }
+    } else {
+        BlockDriverState *bs = bdrv_find_node(node_name);
+        if (!bs) {
+            error_setg(errp, "Failed to find node with node-name='%s'",
+                       node_name);
+            return;
+        }
+
+        if (active) {
+            bdrv_activate(bs, errp);
+        } else {
+            bdrv_inactivate(bs, errp);
+        }
+    }
+}
+
 static BdrvChild * GRAPH_RDLOCK
 bdrv_find_child(BlockDriverState *parent_bs, const char *child_name)
 {
-- 
2.48.1

Device models have a relatively complex way to set up their block
backends, in which blk_attach_dev() sets blk->disable_perm = true.
We want to support inactive images in exports, too, so that
qemu-storage-daemon can be used with migration. Because they don't use
blk_attach_dev(), they need another way to set this flag. The most
convenient is to do this automatically when an inactive node is attached
to a BlockBackend that can be inactivated.

diff --git a/block/block-backend.c b/block/block-backend.c
index XXXXXXX..XXXXXXX 100644
--- a/block/block-backend.c
+++ b/block/block-backend.c
@@ -XXX,XX +XXX,XX @@ void blk_remove_bs(BlockBackend *blk)
 int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
 {
     ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
+    uint64_t perm, shared_perm;
 
     GLOBAL_STATE_CODE();
     bdrv_ref(bs);
     bdrv_graph_wrlock();
+
+    if ((bs->open_flags & BDRV_O_INACTIVE) && blk_can_inactivate(blk)) {
+        blk->disable_perm = true;
+        perm = 0;
+        shared_perm = BLK_PERM_ALL;
+    } else {
+        perm = blk->perm;
+        shared_perm = blk->shared_perm;
+    }
+
     blk->root = bdrv_root_attach_child(bs, "root", &child_root,
                                        BDRV_CHILD_FILTERED | BDRV_CHILD_PRIMARY,
-                                       blk->perm, blk->shared_perm,
-                                       blk, errp);
+                                       perm, shared_perm, blk, errp);
     bdrv_graph_wrunlock();
     if (blk->root == NULL) {
         return -EPERM;
-- 
2.48.1

Currently, block exports can't handle inactive images correctly.
Incoming write requests would run into assertion failures. Make sure
that we return an error when creating an export can't activate the
image.

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)
      * ctx was acquired in the caller.
      */
     bdrv_graph_rdlock_main_loop();
-    bdrv_activate(bs, NULL);
+    ret = bdrv_activate(bs, errp);
+    if (ret < 0) {
+        bdrv_graph_rdunlock_main_loop();
+        goto fail;
+    }
     bdrv_graph_rdunlock_main_loop();
 
     perm = BLK_PERM_CONSISTENT_READ;
-- 
2.48.1

So far the assumption has always been that if we try to inactivate a
node, it is already idle. This doesn't hold true any more if we allow
inactivating exported nodes because we can't know when new external
requests come in.

Drain the node around setting BDRV_O_INACTIVE so that requests can't
start operating on an active node and then in the middle it suddenly
becomes inactive. With this change, it's enough for exports to check
for new requests that they operate on an active node (or, like reads,
are allowed even on an inactive node).

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Acked-by: Fabiano Rosas <farosas@suse.de>
Message-ID: <20250204211407.381505-12-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>
---
 block.c | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ bdrv_inactivate_recurse(BlockDriverState *bs, bool top_level)
         return -EPERM;
     }
 
+    bdrv_drained_begin(bs);
     bs->open_flags |= BDRV_O_INACTIVE;
+    bdrv_drained_end(bs);
 
     /*
      * Update permissions, they may differ for inactive nodes.
-- 
2.48.1

Add an option in BlockExportOptions to allow creating an export on an
inactive node without activating the node. This mode needs to be
explicitly supported by the export type (so that it doesn't perform any
operations that are forbidden for inactive nodes), so this patch alone
doesn't allow this option to be successfully used yet.

diff --git a/qapi/block-export.json b/qapi/block-export.json
index XXXXXXX..XXXXXXX 100644
--- a/qapi/block-export.json
+++ b/qapi/block-export.json
@@ -XXX,XX +XXX,XX @@
 #     cannot be moved to the iothread.  The default is false.
 #     (since: 5.2)
 #
+# @allow-inactive: If true, the export allows the exported node to be inactive.
+#     If it is created for an inactive block node, the node remains inactive. If
+#     the export type doesn't support running on an inactive node, an error is
+#     returned. If false, inactive block nodes are automatically activated before
+#     creating the export and trying to inactivate them later fails.
+#     (since: 10.0; default: false)
+#
 # Since: 4.2
 ##
 { 'union': 'BlockExportOptions',
@@ -XXX,XX +XXX,XX @@
             '*iothread': 'str',
             'node-name': 'str',
             '*writable': 'bool',
-            '*writethrough': 'bool' },
+            '*writethrough': 'bool',
+            '*allow-inactive': 'bool' },
   'discriminator': 'type',
   'data': {
       'nbd': 'BlockExportOptionsNbd',
diff --git a/include/block/export.h b/include/block/export.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/export.h
+++ b/include/block/export.h
@@ -XXX,XX +XXX,XX @@ typedef struct BlockExportDriver {
      */
     size_t instance_size;
 
+    /* True if the export type supports running on an inactive node */
+    bool supports_inactive;
+
     /* Creates and starts a new block export */
     int (*create)(BlockExport *, BlockExportOptions *, Error **);
 
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 @@ static const BlockExportDriver *blk_exp_find_driver(BlockExportType type)
 BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
 {
     bool fixed_iothread = export->has_fixed_iothread && export->fixed_iothread;
+    bool allow_inactive = export->has_allow_inactive && export->allow_inactive;
     const BlockExportDriver *drv;
     BlockExport *exp = NULL;
     BlockDriverState *bs;
@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
         }
     }
 
-    /*
-     * Block exports are used for non-shared storage migration. Make sure
-     * that BDRV_O_INACTIVE is cleared and the image is ready for write
-     * access since the export could be available before migration handover.
-     * ctx was acquired in the caller.
-     */
     bdrv_graph_rdlock_main_loop();
-    ret = bdrv_activate(bs, errp);
-    if (ret < 0) {
-        bdrv_graph_rdunlock_main_loop();
-        goto fail;
+    if (allow_inactive) {
+        if (!drv->supports_inactive) {
+            error_setg(errp, "Export type does not support inactive exports");
+            bdrv_graph_rdunlock_main_loop();
+            goto fail;
+        }
+    } else {
+        /*
+         * Block exports are used for non-shared storage migration. Make sure
+         * that BDRV_O_INACTIVE is cleared and the image is ready for write
+         * access since the export could be available before migration handover.
+         */
+        ret = bdrv_activate(bs, errp);
+        if (ret < 0) {
+            bdrv_graph_rdunlock_main_loop();
+            goto fail;
+        }
     }
     bdrv_graph_rdunlock_main_loop();
 
@@ -XXX,XX +XXX,XX @@ BlockExport *blk_exp_add(BlockExportOptions *export, Error **errp)
     if (!fixed_iothread) {
         blk_set_allow_aio_context_change(blk, true);
     }
+    if (allow_inactive) {
+        blk_set_force_allow_inactivate(blk);
+    }
 
     ret = blk_insert_bs(blk, bs, errp);
     if (ret < 0) {
-- 
2.48.1

In order to support running an NBD export on inactive nodes, we must
make sure to return errors for any operations that aren't allowed on
inactive nodes. Reads are the only operation we know we need for
inactive images, so to err on the side of caution, return errors for
everything else, even if some operations could possibly be okay.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Acked-by: Fabiano Rosas <farosas@suse.de>
Message-ID: <20250204211407.381505-14-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>
---
 nbd/server.c | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/nbd/server.c b/nbd/server.c
index XXXXXXX..XXXXXXX 100644
--- a/nbd/server.c
+++ b/nbd/server.c
@@ -XXX,XX +XXX,XX @@ static void nbd_export_delete(BlockExport *blk_exp)
 const BlockExportDriver blk_exp_nbd = {
     .type               = BLOCK_EXPORT_TYPE_NBD,
     .instance_size      = sizeof(NBDExport),
+    .supports_inactive  = true,
     .create             = nbd_export_create,
     .delete             = nbd_export_delete,
     .request_shutdown   = nbd_export_request_shutdown,
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int nbd_handle_request(NBDClient *client,
     NBDExport *exp = client->exp;
     char *msg;
     size_t i;
+    bool inactive;
+
+    WITH_GRAPH_RDLOCK_GUARD() {
+        inactive = bdrv_is_inactive(blk_bs(exp->common.blk));
+        if (inactive) {
+            switch (request->type) {
+            case NBD_CMD_READ:
+                /* These commands are allowed on inactive nodes */
+                break;
+            default:
+                /* Return an error for the rest */
+                return nbd_send_generic_reply(client, request, -EPERM,
+                                              "export is inactive", errp);
+            }
+        }
+    }
 
     switch (request->type) {
     case NBD_CMD_CACHE:
-- 
2.48.1

The open-coded form of this filter has been copied into enough tests
that it's better to move it into iotests.py.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Acked-by: Fabiano Rosas <farosas@suse.de>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-ID: <20250204211407.381505-15-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/iotests.py                 | 4 ++++
 tests/qemu-iotests/041                        | 4 +---
 tests/qemu-iotests/165                        | 4 +---
 tests/qemu-iotests/tests/copy-before-write    | 3 +--
 tests/qemu-iotests/tests/migrate-bitmaps-test | 7 +++----
 5 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/iotests.py
+++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@ def _filter(_key, value):
 def filter_nbd_exports(output: str) -> str:
     return re.sub(r'((min|opt|max) block): [0-9]+', r'\1: XXX', output)
 
+def filter_qtest(output: str) -> str:
+    output = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', output)
+    output = re.sub(r'\n?\[I \+\d+\.\d+\] CLOSED\n?$', '', output)
+    return output
 
 Msg = TypeVar('Msg', Dict[str, Any], List[Any], str)
 
diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/041
+++ b/tests/qemu-iotests/041
@@ -XXX,XX +XXX,XX @@ class TestRepairQuorum(iotests.QMPTestCase):
 
         # Check the full error message now
         self.vm.shutdown()
-        log = self.vm.get_log()
-        log = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', log)
+        log = iotests.filter_qtest(self.vm.get_log())
         log = re.sub(r'^Formatting.*\n', '', log)
-        log = re.sub(r'\n\[I \+\d+\.\d+\] CLOSED\n?$', '', log)
         log = re.sub(r'^%s: ' % os.path.basename(iotests.qemu_prog), '', log)
 
         self.assertEqual(log,
diff --git a/tests/qemu-iotests/165 b/tests/qemu-iotests/165
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/165
+++ b/tests/qemu-iotests/165
@@ -XXX,XX +XXX,XX @@ class TestPersistentDirtyBitmap(iotests.QMPTestCase):
         self.vm.shutdown()
 
         #catch 'Persistent bitmaps are lost' possible error
-        log = self.vm.get_log()
-        log = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', log)
-        log = re.sub(r'\[I \+\d+\.\d+\] CLOSED\n?$', '', log)
+        log = iotests.filter_qtest(self.vm.get_log())
         if log:
             print(log)
 
diff --git a/tests/qemu-iotests/tests/copy-before-write b/tests/qemu-iotests/tests/copy-before-write
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/tests/copy-before-write
+++ b/tests/qemu-iotests/tests/copy-before-write
@@ -XXX,XX +XXX,XX @@ class TestCbwError(iotests.QMPTestCase):
 
         self.vm.shutdown()
         log = self.vm.get_log()
-        log = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', log)
-        log = re.sub(r'\[I \+\d+\.\d+\] CLOSED\n?$', '', log)
+        log = iotests.filter_qtest(log)
         log = iotests.filter_qemu_io(log)
         return log
 
diff --git a/tests/qemu-iotests/tests/migrate-bitmaps-test b/tests/qemu-iotests/tests/migrate-bitmaps-test
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/tests/migrate-bitmaps-test
+++ b/tests/qemu-iotests/tests/migrate-bitmaps-test
@@ -XXX,XX +XXX,XX @@ class TestDirtyBitmapMigration(iotests.QMPTestCase):
 
         # catch 'Could not reopen qcow2 layer: Bitmap already exists'
         # possible error
-        log = self.vm_a.get_log()
-        log = re.sub(r'^\[I \d+\.\d+\] OPENED\n', '', log)
-        log = re.sub(r'^(wrote .* bytes at offset .*\n.*KiB.*ops.*sec.*\n){3}',
+        log = iotests.filter_qtest(self.vm_a.get_log())
+        log = re.sub(r'^(wrote .* bytes at offset .*\n'
+                     r'.*KiB.*ops.*sec.*\n?){3}',
                      '', log)
-        log = re.sub(r'\[I \+\d+\.\d+\] CLOSED\n?$', '', log)
         self.assertEqual(log, '')
 
         # test that bitmap is still persistent
-- 
2.48.1

Test that it's possible to migrate a VM that uses an image on shared
storage through qemu-storage-daemon.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Acked-by: Fabiano Rosas <farosas@suse.de>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-ID: <20250204211407.381505-16-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/tests/qsd-migrate     | 140 +++++++++++++++++++++++
 tests/qemu-iotests/tests/qsd-migrate.out |  59 ++++++++++
 2 files changed, 199 insertions(+)
 create mode 100755 tests/qemu-iotests/tests/qsd-migrate
 create mode 100644 tests/qemu-iotests/tests/qsd-migrate.out

diff --git a/tests/qemu-iotests/tests/qsd-migrate b/tests/qemu-iotests/tests/qsd-migrate
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/qsd-migrate
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python3
+# group: rw quick
+#
+# Copyright (C) Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+
+import iotests
+
+from iotests import filter_qemu_io, filter_qtest
+
+iotests.script_initialize(supported_fmts=['generic'],
+                          supported_protocols=['file'],
+                          supported_platforms=['linux'])
+
+with iotests.FilePath('disk.img') as path, \
+     iotests.FilePath('nbd-src.sock', base_dir=iotests.sock_dir) as nbd_src, \
+     iotests.FilePath('nbd-dst.sock', base_dir=iotests.sock_dir) as nbd_dst, \
+     iotests.FilePath('migrate.sock', base_dir=iotests.sock_dir) as mig_sock, \
+     iotests.VM(path_suffix="-src") as vm_src, \
+     iotests.VM(path_suffix="-dst") as vm_dst:
+
+    img_size = '10M'
+
+    iotests.log('Preparing disk...')
+    iotests.qemu_img_create('-f', iotests.imgfmt, path, img_size)
+
+    iotests.log('Launching source QSD...')
+    qsd_src = iotests.QemuStorageDaemon(
+        '--blockdev', f'file,node-name=disk-file,filename={path}',
+        '--blockdev', f'{iotests.imgfmt},file=disk-file,node-name=disk-fmt',
+        '--nbd-server', f'addr.type=unix,addr.path={nbd_src}',
+        '--export', 'nbd,id=exp0,node-name=disk-fmt,writable=true,'
+                    'allow-inactive=true',
+        qmp=True,
+    )
+
+    iotests.log('Launching source VM...')
+    vm_src.add_args('-blockdev', f'nbd,node-name=disk,server.type=unix,'
+                                 f'server.path={nbd_src},export=disk-fmt')
+    vm_src.add_args('-device', 'virtio-blk,drive=disk,id=virtio0')
+    vm_src.launch()
+
+    iotests.log('Launching destination QSD...')
+    qsd_dst = iotests.QemuStorageDaemon(
+        '--blockdev', f'file,node-name=disk-file,filename={path},active=off',
+        '--blockdev', f'{iotests.imgfmt},file=disk-file,node-name=disk-fmt,'
+                      f'active=off',
+        '--nbd-server', f'addr.type=unix,addr.path={nbd_dst}',
+        '--export', 'nbd,id=exp0,node-name=disk-fmt,writable=true,'
+                    'allow-inactive=true',
+        qmp=True,
+        instance_id='b',
+    )
+
+    iotests.log('Launching destination VM...')
+    vm_dst.add_args('-blockdev', f'nbd,node-name=disk,server.type=unix,'
+                                 f'server.path={nbd_dst},export=disk-fmt')
+    vm_dst.add_args('-device', 'virtio-blk,drive=disk,id=virtio0')
+    vm_dst.add_args('-incoming', f'unix:{mig_sock}')
+    vm_dst.launch()
+
+    iotests.log('\nTest I/O on the source')
+    vm_src.hmp_qemu_io('virtio0/virtio-backend', 'write -P 0x11 0 4k',
+                       use_log=True, qdev=True)
+    vm_src.hmp_qemu_io('virtio0/virtio-backend', 'read -P 0x11 0 4k',
+                       use_log=True, qdev=True)
+
+    iotests.log('\nStarting migration...')
+
+    mig_caps = [
+        {'capability': 'events', 'state': True},
+        {'capability': 'pause-before-switchover', 'state': True},
+    ]
+    vm_src.qmp_log('migrate-set-capabilities', capabilities=mig_caps)
+    vm_dst.qmp_log('migrate-set-capabilities', capabilities=mig_caps)
+    vm_src.qmp_log('migrate', uri=f'unix:{mig_sock}',
+                   filters=[iotests.filter_qmp_testfiles])
+
+    vm_src.event_wait('MIGRATION',
+                      match={'data': {'status': 'pre-switchover'}})
+
+    iotests.log('\nPre-switchover: Reconfigure QSD instances')
+
+    iotests.log(qsd_src.qmp('blockdev-set-active', {'active': False}))
+
+    # Reading is okay from both sides while the image is inactive. Note that
+    # the destination may have stale data until it activates the image, though.
+    vm_src.hmp_qemu_io('virtio0/virtio-backend', 'read -P 0x11 0 4k',
+                       use_log=True, qdev=True)
+    vm_dst.hmp_qemu_io('virtio0/virtio-backend', 'read 0 4k',
+                       use_log=True, qdev=True)
+
+    iotests.log(qsd_dst.qmp('blockdev-set-active', {'active': True}))
+
+    iotests.log('\nCompleting migration...')
+
+    vm_src.qmp_log('migrate-continue', state='pre-switchover')
+    vm_dst.event_wait('MIGRATION', match={'data': {'status': 'completed'}})
+
+    iotests.log('\nTest I/O on the destination')
+
+    # Now the destination must see what the source wrote
+    vm_dst.hmp_qemu_io('virtio0/virtio-backend', 'read -P 0x11 0 4k',
+                       use_log=True, qdev=True)
+
+    # And be able to overwrite it
+    vm_dst.hmp_qemu_io('virtio0/virtio-backend', 'write -P 0x22 0 4k',
+                       use_log=True, qdev=True)
+    vm_dst.hmp_qemu_io('virtio0/virtio-backend', 'read -P 0x22 0 4k',
+                       use_log=True, qdev=True)
+
+    iotests.log('\nDone')
+
+    vm_src.shutdown()
+    iotests.log('\n--- vm_src log ---')
+    log = vm_src.get_log()
+    if log:
+        iotests.log(log, [filter_qtest, filter_qemu_io])
+    qsd_src.stop()
+
+    vm_dst.shutdown()
+    iotests.log('\n--- vm_dst log ---')
+    log = vm_dst.get_log()
+    if log:
+        iotests.log(log, [filter_qtest, filter_qemu_io])
+    qsd_dst.stop()
diff --git a/tests/qemu-iotests/tests/qsd-migrate.out b/tests/qemu-iotests/tests/qsd-migrate.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/qsd-migrate.out
@@ -XXX,XX +XXX,XX @@
+Preparing disk...
+Launching source QSD...
+Launching source VM...
+Launching destination QSD...
+Launching destination VM...
+
+Test I/O on the source
+{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"write -P 0x11 0 4k\""}}
+{"return": ""}
+{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"read -P 0x11 0 4k\""}}
+{"return": ""}
+
+Starting migration...
+{"execute": "migrate-set-capabilities", "arguments": {"capabilities": [{"capability": "events", "state": true}, {"capability": "pause-before-switchover", "state": true}]}}
+{"return": {}}
+{"execute": "migrate-set-capabilities", "arguments": {"capabilities": [{"capability": "events", "state": true}, {"capability": "pause-before-switchover", "state": true}]}}
+{"return": {}}
+{"execute": "migrate", "arguments": {"uri": "unix:SOCK_DIR/PID-migrate.sock"}}
+{"return": {}}
+
+Pre-switchover: Reconfigure QSD instances
+{"return": {}}
+{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"read -P 0x11 0 4k\""}}
+{"return": ""}
+{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"read 0 4k\""}}
+{"return": ""}
+{"return": {}}
+
+Completing migration...
+{"execute": "migrate-continue", "arguments": {"state": "pre-switchover"}}
+{"return": {}}
+
+Test I/O on the destination
+{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"read -P 0x11 0 4k\""}}
+{"return": ""}
+{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"write -P 0x22 0 4k\""}}
+{"return": ""}
+{"execute": "human-monitor-command", "arguments": {"command-line": "qemu-io -d virtio0/virtio-backend \"read -P 0x22 0 4k\""}}
+{"return": ""}
+
+Done
+
+--- vm_src log ---
+wrote 4096/4096 bytes at offset 0
+4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 4096/4096 bytes at offset 0
+4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 4096/4096 bytes at offset 0
+4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+--- vm_dst log ---
+read 4096/4096 bytes at offset 0
+4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 4096/4096 bytes at offset 0
+4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 4096/4096 bytes at offset 0
+4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 4096/4096 bytes at offset 0
+4 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-- 
2.48.1

This tests different types of operations on inactive block nodes
(including graph changes, block jobs and NBD exports) to make sure that
users manually activating and inactivating nodes doesn't break things.

Support for inactive nodes in other export types will have to come with
separate test cases because they have different dependencies like blkio
or root permissions and we don't want to disable this basic test when
they are not fulfilled.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Acked-by: Fabiano Rosas <farosas@suse.de>
Message-ID: <20250204211407.381505-17-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/iotests.py                 |   4 +
 tests/qemu-iotests/tests/inactive-node-nbd    | 303 ++++++++++++++++++
 .../qemu-iotests/tests/inactive-node-nbd.out  | 239 ++++++++++++++
 3 files changed, 546 insertions(+)
 create mode 100755 tests/qemu-iotests/tests/inactive-node-nbd
 create mode 100644 tests/qemu-iotests/tests/inactive-node-nbd.out

diff --git a/tests/qemu-iotests/iotests.py b/tests/qemu-iotests/iotests.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/iotests.py
+++ b/tests/qemu-iotests/iotests.py
@@ -XXX,XX +XXX,XX @@ def add_incoming(self, addr):
         self._args.append(addr)
         return self
 
+    def add_paused(self):
+        self._args.append('-S')
+        return self
+
     def hmp(self, command_line: str, use_log: bool = False) -> QMPMessage:
         cmd = 'human-monitor-command'
         kwargs: Dict[str, Any] = {'command-line': command_line}
diff --git a/tests/qemu-iotests/tests/inactive-node-nbd b/tests/qemu-iotests/tests/inactive-node-nbd
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/inactive-node-nbd
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python3
+# group: rw quick
+#
+# Copyright (C) Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# Creator/Owner: Kevin Wolf <kwolf@redhat.com>
+
+import iotests
+
+from iotests import QemuIoInteractive
+from iotests import filter_qemu_io, filter_qtest, filter_qmp_testfiles
+
+iotests.script_initialize(supported_fmts=['generic'],
+                          supported_protocols=['file'],
+                          supported_platforms=['linux'])
+
+def get_export(node_name='disk-fmt', allow_inactive=None):
+    exp = {
+        'id': 'exp0',
+        'type': 'nbd',
+        'node-name': node_name,
+        'writable': True,
+    }
+
+    if allow_inactive is not None:
+        exp['allow-inactive'] = allow_inactive
+
+    return exp
+
+def node_is_active(_vm, node_name):
+    nodes = _vm.cmd('query-named-block-nodes', flat=True)
+    node = next(n for n in nodes if n['node-name'] == node_name)
+    return node['active']
+
+with iotests.FilePath('disk.img') as path, \
+     iotests.FilePath('snap.qcow2') as snap_path, \
+     iotests.FilePath('snap2.qcow2') as snap2_path, \
+     iotests.FilePath('target.img') as target_path, \
+     iotests.FilePath('nbd.sock', base_dir=iotests.sock_dir) as nbd_sock, \
+     iotests.VM() as vm:
+
+    img_size = '10M'
+
+    iotests.log('Preparing disk...')
+    iotests.qemu_img_create('-f', iotests.imgfmt, path, img_size)
+    iotests.qemu_img_create('-f', iotests.imgfmt, target_path, img_size)
+
+    iotests.qemu_img_create('-f', 'qcow2', '-b', path, '-F', iotests.imgfmt,
+                            snap_path)
+    iotests.qemu_img_create('-f', 'qcow2', '-b', snap_path, '-F', 'qcow2',
+                            snap2_path)
+
+    iotests.log('Launching VM...')
+    vm.add_blockdev(f'file,node-name=disk-file,filename={path}')
+    vm.add_blockdev(f'{iotests.imgfmt},file=disk-file,node-name=disk-fmt,'
+                     'active=off')
+    vm.add_blockdev(f'file,node-name=target-file,filename={target_path}')
+    vm.add_blockdev(f'{iotests.imgfmt},file=target-file,node-name=target-fmt')
+    vm.add_blockdev(f'file,node-name=snap-file,filename={snap_path}')
+    vm.add_blockdev(f'file,node-name=snap2-file,filename={snap2_path}')
+
+    # Actually running the VM activates all images
+    vm.add_paused()
+
+    vm.launch()
+    vm.qmp_log('nbd-server-start',
+                addr={'type': 'unix', 'data':{'path': nbd_sock}},
+                filters=[filter_qmp_testfiles])
+
+    iotests.log('\n=== Creating export of inactive node ===')
+
+    iotests.log('\nExports activate nodes without allow-inactive')
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    vm.qmp_log('block-export-add', **get_export())
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    vm.qmp_log('query-block-exports')
+    vm.qmp_log('block-export-del', id='exp0')
+    vm.event_wait('BLOCK_EXPORT_DELETED')
+    vm.qmp_log('query-block-exports')
+
+    iotests.log('\nExports activate nodes with allow-inactive=false')
+    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    vm.qmp_log('block-export-add', **get_export(allow_inactive=False))
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    vm.qmp_log('query-block-exports')
+    vm.qmp_log('block-export-del', id='exp0')
+    vm.event_wait('BLOCK_EXPORT_DELETED')
+    vm.qmp_log('query-block-exports')
+
+    iotests.log('\nExport leaves nodes inactive with allow-inactive=true')
+    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    vm.qmp_log('block-export-add', **get_export(allow_inactive=True))
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    vm.qmp_log('query-block-exports')
+    vm.qmp_log('block-export-del', id='exp0')
+    vm.event_wait('BLOCK_EXPORT_DELETED')
+    vm.qmp_log('query-block-exports')
+
+    iotests.log('\n=== Inactivating node with existing export ===')
+
+    iotests.log('\nInactivating nodes with an export fails without '
+                'allow-inactive')
+    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=True)
+    vm.qmp_log('block-export-add', **get_export(node_name='disk-fmt'))
+    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    vm.qmp_log('query-block-exports')
+    vm.qmp_log('block-export-del', id='exp0')
+    vm.event_wait('BLOCK_EXPORT_DELETED')
+    vm.qmp_log('query-block-exports')
+
+    iotests.log('\nInactivating nodes with an export fails with '
+                'allow-inactive=false')
+    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=True)
+    vm.qmp_log('block-export-add',
+               **get_export(node_name='disk-fmt', allow_inactive=False))
+    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    vm.qmp_log('query-block-exports')
+    vm.qmp_log('block-export-del', id='exp0')
+    vm.event_wait('BLOCK_EXPORT_DELETED')
+    vm.qmp_log('query-block-exports')
+
+    iotests.log('\nInactivating nodes with an export works with '
+                'allow-inactive=true')
+    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=True)
+    vm.qmp_log('block-export-add',
+               **get_export(node_name='disk-fmt', allow_inactive=True))
+    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    vm.qmp_log('query-block-exports')
+    vm.qmp_log('block-export-del', id='exp0')
+    vm.event_wait('BLOCK_EXPORT_DELETED')
+    vm.qmp_log('query-block-exports')
+
+    iotests.log('\n=== Inactive nodes with parent ===')
+
+    iotests.log('\nInactivating nodes with an active parent fails')
+    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=True)
+    vm.qmp_log('blockdev-set-active', node_name='disk-file', active=False)
+    iotests.log('disk-file active: %s' % node_is_active(vm, 'disk-file'))
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+
+    iotests.log('\nInactivating nodes with an inactive parent works')
+    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=False)
+    vm.qmp_log('blockdev-set-active', node_name='disk-file', active=False)
+    iotests.log('disk-file active: %s' % node_is_active(vm, 'disk-file'))
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+
+    iotests.log('\nCreating active parent node with an inactive child fails')
+    vm.qmp_log('blockdev-add', driver='raw', file='disk-fmt',
+               node_name='disk-filter')
+    vm.qmp_log('blockdev-add', driver='raw', file='disk-fmt',
+               node_name='disk-filter', active=True)
+
+    iotests.log('\nCreating inactive parent node with an inactive child works')
+    vm.qmp_log('blockdev-add', driver='raw', file='disk-fmt',
+               node_name='disk-filter', active=False)
+    vm.qmp_log('blockdev-del', node_name='disk-filter')
+
+    iotests.log('\n=== Resizing an inactive node ===')
+    vm.qmp_log('block_resize', node_name='disk-fmt', size=16*1024*1024)
+
+    iotests.log('\n=== Taking a snapshot of an inactive node ===')
+
+    iotests.log('\nActive overlay over inactive backing file automatically '
+                'makes both inactive for compatibility')
+    vm.qmp_log('blockdev-add', driver='qcow2', node_name='snap-fmt',
+               file='snap-file', backing=None)
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
+    vm.qmp_log('blockdev-snapshot', node='disk-fmt', overlay='snap-fmt')
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
+    vm.qmp_log('blockdev-del', node_name='snap-fmt')
+
+    iotests.log('\nInactive overlay over inactive backing file just works')
+    vm.qmp_log('blockdev-add', driver='qcow2', node_name='snap-fmt',
+               file='snap-file', backing=None, active=False)
+    vm.qmp_log('blockdev-snapshot', node='disk-fmt', overlay='snap-fmt')
+
+    iotests.log('\n=== Block jobs with inactive nodes ===')
+
+    iotests.log('\nStreaming into an inactive node')
+    vm.qmp_log('block-stream', device='snap-fmt',
+               filters=[iotests.filter_qmp_generated_node_ids])
+
+    iotests.log('\nCommitting an inactive root node (active commit)')
+    vm.qmp_log('block-commit', job_id='job0', device='snap-fmt',
+               filters=[iotests.filter_qmp_generated_node_ids])
+
+    iotests.log('\nCommitting an inactive intermediate node to inactive base')
+    vm.qmp_log('blockdev-add', driver='qcow2', node_name='snap2-fmt',
+               file='snap2-file', backing='snap-fmt', active=False)
+
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
+    iotests.log('snap2-fmt active: %s' % node_is_active(vm, 'snap2-fmt'))
+
+    vm.qmp_log('block-commit', job_id='job0', device='snap2-fmt',
+               top_node='snap-fmt',
+               filters=[iotests.filter_qmp_generated_node_ids])
+
+    iotests.log('\nCommitting an inactive intermediate node to active base')
+    vm.qmp_log('blockdev-set-active', node_name='disk-fmt', active=True)
+    vm.qmp_log('block-commit', job_id='job0', device='snap2-fmt',
+               top_node='snap-fmt',
+               filters=[iotests.filter_qmp_generated_node_ids])
+
+    iotests.log('\nMirror from inactive source to active target')
+    vm.qmp_log('blockdev-mirror', job_id='job0', device='snap2-fmt',
+               target='target-fmt', sync='full',
+               filters=[iotests.filter_qmp_generated_node_ids])
+
+    iotests.log('\nMirror from active source to inactive target')
+
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
+    iotests.log('snap2-fmt active: %s' % node_is_active(vm, 'snap2-fmt'))
+    iotests.log('target-fmt active: %s' % node_is_active(vm, 'target-fmt'))
+
+    # Activating snap2-fmt recursively activates the whole backing chain
+    vm.qmp_log('blockdev-set-active', node_name='snap2-fmt', active=True)
+    vm.qmp_log('blockdev-set-active', node_name='target-fmt', active=False)
+
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
+    iotests.log('snap2-fmt active: %s' % node_is_active(vm, 'snap2-fmt'))
+    iotests.log('target-fmt active: %s' % node_is_active(vm, 'target-fmt'))
+
+    vm.qmp_log('blockdev-mirror', job_id='job0', device='snap2-fmt',
+               target='target-fmt', sync='full',
+               filters=[iotests.filter_qmp_generated_node_ids])
+
+    iotests.log('\nBackup from active source to inactive target')
+
+    vm.qmp_log('blockdev-backup', job_id='job0', device='snap2-fmt',
+               target='target-fmt', sync='full',
+               filters=[iotests.filter_qmp_generated_node_ids])
+
+    iotests.log('\nBackup from inactive source to active target')
+
+    # Inactivating snap2-fmt recursively inactivates the whole backing chain
+    vm.qmp_log('blockdev-set-active', node_name='snap2-fmt', active=False)
+    vm.qmp_log('blockdev-set-active', node_name='target-fmt', active=True)
+
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
+    iotests.log('snap2-fmt active: %s' % node_is_active(vm, 'snap2-fmt'))
+    iotests.log('target-fmt active: %s' % node_is_active(vm, 'target-fmt'))
+
+    vm.qmp_log('blockdev-backup', job_id='job0', device='snap2-fmt',
+               target='target-fmt', sync='full',
+               filters=[iotests.filter_qmp_generated_node_ids])
+
+    iotests.log('\n=== Accessing export on inactive node ===')
+
+    # Use the target node because it has the right image format and isn't the
+    # (read-only) backing file of a qcow2 node
+    vm.qmp_log('blockdev-set-active', node_name='target-fmt', active=False)
+    vm.qmp_log('block-export-add',
+               **get_export(node_name='target-fmt', allow_inactive=True))
+
+    # The read should succeed, everything else should fail gracefully
+    qemu_io = QemuIoInteractive('-f', 'raw',
+                                f'nbd+unix:///target-fmt?socket={nbd_sock}')
+    iotests.log(qemu_io.cmd('read 0 64k'), filters=[filter_qemu_io])
+    iotests.log(qemu_io.cmd('write 0 64k'), filters=[filter_qemu_io])
+    iotests.log(qemu_io.cmd('write -z 0 64k'), filters=[filter_qemu_io])
+    iotests.log(qemu_io.cmd('write -zu 0 64k'), filters=[filter_qemu_io])
+    iotests.log(qemu_io.cmd('discard 0 64k'), filters=[filter_qemu_io])
+    iotests.log(qemu_io.cmd('flush'), filters=[filter_qemu_io])
+    iotests.log(qemu_io.cmd('map'), filters=[filter_qemu_io])
+    qemu_io.close()
+
+    iotests.log('\n=== Resuming VM activates all images ===')
+    vm.qmp_log('cont')
+
+    iotests.log('disk-fmt active: %s' % node_is_active(vm, 'disk-fmt'))
+    iotests.log('snap-fmt active: %s' % node_is_active(vm, 'snap-fmt'))
+    iotests.log('snap2-fmt active: %s' % node_is_active(vm, 'snap2-fmt'))
+    iotests.log('target-fmt active: %s' % node_is_active(vm, 'target-fmt'))
+
+    iotests.log('\nShutting down...')
+    vm.shutdown()
+    log = vm.get_log()
+    if log:
+        iotests.log(log, [filter_qtest, filter_qemu_io])
diff --git a/tests/qemu-iotests/tests/inactive-node-nbd.out b/tests/qemu-iotests/tests/inactive-node-nbd.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/inactive-node-nbd.out
@@ -XXX,XX +XXX,XX @@
+Preparing disk...
+Launching VM...
+{"execute": "nbd-server-start", "arguments": {"addr": {"data": {"path": "SOCK_DIR/PID-nbd.sock"}, "type": "unix"}}}
+{"return": {}}
+
+=== Creating export of inactive node ===
+
+Exports activate nodes without allow-inactive
+disk-fmt active: False
+{"execute": "block-export-add", "arguments": {"id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
+{"return": {}}
+disk-fmt active: True
+{"execute": "query-block-exports", "arguments": {}}
+{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
+{"execute": "block-export-del", "arguments": {"id": "exp0"}}
+{"return": {}}
+{"execute": "query-block-exports", "arguments": {}}
+{"return": []}
+
+Exports activate nodes with allow-inactive=false
+{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
+{"return": {}}
+disk-fmt active: False
+{"execute": "block-export-add", "arguments": {"allow-inactive": false, "id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
+{"return": {}}
+disk-fmt active: True
+{"execute": "query-block-exports", "arguments": {}}
+{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
+{"execute": "block-export-del", "arguments": {"id": "exp0"}}
+{"return": {}}
+{"execute": "query-block-exports", "arguments": {}}
+{"return": []}
+
+Export leaves nodes inactive with allow-inactive=true
+{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
+{"return": {}}
+disk-fmt active: False
+{"execute": "block-export-add", "arguments": {"allow-inactive": true, "id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
+{"return": {}}
+disk-fmt active: False
+{"execute": "query-block-exports", "arguments": {}}
+{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
+{"execute": "block-export-del", "arguments": {"id": "exp0"}}
+{"return": {}}
+{"execute": "query-block-exports", "arguments": {}}
+{"return": []}
+
+=== Inactivating node with existing export ===
+
+Inactivating nodes with an export fails without allow-inactive
+{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "disk-fmt"}}
+{"return": {}}
+{"execute": "block-export-add", "arguments": {"id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
+{"return": {}}
+{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
+{"error": {"class": "GenericError", "desc": "Failed to inactivate node: Operation not permitted"}}
+disk-fmt active: True
+{"execute": "query-block-exports", "arguments": {}}
+{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
+{"execute": "block-export-del", "arguments": {"id": "exp0"}}
+{"return": {}}
+{"execute": "query-block-exports", "arguments": {}}
+{"return": []}
+
+Inactivating nodes with an export fails with allow-inactive=false
+{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "disk-fmt"}}
+{"return": {}}
+{"execute": "block-export-add", "arguments": {"allow-inactive": false, "id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
+{"return": {}}
+{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
+{"error": {"class": "GenericError", "desc": "Failed to inactivate node: Operation not permitted"}}
+disk-fmt active: True
+{"execute": "query-block-exports", "arguments": {}}
+{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
+{"execute": "block-export-del", "arguments": {"id": "exp0"}}
+{"return": {}}
+{"execute": "query-block-exports", "arguments": {}}
+{"return": []}
+
+Inactivating nodes with an export works with allow-inactive=true
+{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "disk-fmt"}}
+{"return": {}}
+{"execute": "block-export-add", "arguments": {"allow-inactive": true, "id": "exp0", "node-name": "disk-fmt", "type": "nbd", "writable": true}}
+{"return": {}}
+{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
+{"return": {}}
+disk-fmt active: False
+{"execute": "query-block-exports", "arguments": {}}
+{"return": [{"id": "exp0", "node-name": "disk-fmt", "shutting-down": false, "type": "nbd"}]}
+{"execute": "block-export-del", "arguments": {"id": "exp0"}}
+{"return": {}}
+{"execute": "query-block-exports", "arguments": {}}
+{"return": []}
+
+=== Inactive nodes with parent ===
+
+Inactivating nodes with an active parent fails
+{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "disk-fmt"}}
+{"return": {}}
+{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-file"}}
+{"error": {"class": "GenericError", "desc": "Node has active parent node"}}
+disk-file active: True
+disk-fmt active: True
+
+Inactivating nodes with an inactive parent works
+{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-fmt"}}
+{"return": {}}
+{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "disk-file"}}
+{"return": {}}
+disk-file active: False
+disk-fmt active: False
+
+Creating active parent node with an inactive child fails
+{"execute": "blockdev-add", "arguments": {"driver": "raw", "file": "disk-fmt", "node-name": "disk-filter"}}
+{"error": {"class": "GenericError", "desc": "Inactive 'disk-fmt' can't be a file child of active 'disk-filter'"}}
+{"execute": "blockdev-add", "arguments": {"active": true, "driver": "raw", "file": "disk-fmt", "node-name": "disk-filter"}}
+{"error": {"class": "GenericError", "desc": "Inactive 'disk-fmt' can't be a file child of active 'disk-filter'"}}
+
+Creating inactive parent node with an inactive child works
+{"execute": "blockdev-add", "arguments": {"active": false, "driver": "raw", "file": "disk-fmt", "node-name": "disk-filter"}}
+{"return": {}}
+{"execute": "blockdev-del", "arguments": {"node-name": "disk-filter"}}
+{"return": {}}
+
+=== Resizing an inactive node ===
+{"execute": "block_resize", "arguments": {"node-name": "disk-fmt", "size": 16777216}}
+{"error": {"class": "GenericError", "desc": "Permission 'resize' unavailable on inactive node"}}
+
+=== Taking a snapshot of an inactive node ===
+
+Active overlay over inactive backing file automatically makes both inactive for compatibility
+{"execute": "blockdev-add", "arguments": {"backing": null, "driver": "qcow2", "file": "snap-file", "node-name": "snap-fmt"}}
+{"return": {}}
+disk-fmt active: False
+snap-fmt active: True
+{"execute": "blockdev-snapshot", "arguments": {"node": "disk-fmt", "overlay": "snap-fmt"}}
+{"return": {}}
+disk-fmt active: False
+snap-fmt active: False
+{"execute": "blockdev-del", "arguments": {"node-name": "snap-fmt"}}
+{"return": {}}
+
+Inactive overlay over inactive backing file just works
+{"execute": "blockdev-add", "arguments": {"active": false, "backing": null, "driver": "qcow2", "file": "snap-file", "node-name": "snap-fmt"}}
+{"return": {}}
+{"execute": "blockdev-snapshot", "arguments": {"node": "disk-fmt", "overlay": "snap-fmt"}}
+{"return": {}}
+
+=== Block jobs with inactive nodes ===
+
+Streaming into an inactive node
+{"execute": "block-stream", "arguments": {"device": "snap-fmt"}}
+{"error": {"class": "GenericError", "desc": "Could not create node: Inactive 'snap-fmt' can't be a file child of active 'NODE_NAME'"}}
+
+Committing an inactive root node (active commit)
+{"execute": "block-commit", "arguments": {"device": "snap-fmt", "job-id": "job0"}}
+{"error": {"class": "GenericError", "desc": "Inactive 'snap-fmt' can't be a backing child of active 'NODE_NAME'"}}
+
+Committing an inactive intermediate node to inactive base
+{"execute": "blockdev-add", "arguments": {"active": false, "backing": "snap-fmt", "driver": "qcow2", "file": "snap2-file", "node-name": "snap2-fmt"}}
+{"return": {}}
+disk-fmt active: False
+snap-fmt active: False
+snap2-fmt active: False
+{"execute": "block-commit", "arguments": {"device": "snap2-fmt", "job-id": "job0", "top-node": "snap-fmt"}}
+{"error": {"class": "GenericError", "desc": "Inactive 'snap-fmt' can't be a backing child of active 'NODE_NAME'"}}
+
+Committing an inactive intermediate node to active base
+{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "disk-fmt"}}
+{"return": {}}
+{"execute": "block-commit", "arguments": {"device": "snap2-fmt", "job-id": "job0", "top-node": "snap-fmt"}}
+{"error": {"class": "GenericError", "desc": "Inactive 'snap-fmt' can't be a backing child of active 'NODE_NAME'"}}
+
+Mirror from inactive source to active target
+{"execute": "blockdev-mirror", "arguments": {"device": "snap2-fmt", "job-id": "job0", "sync": "full", "target": "target-fmt"}}
+{"error": {"class": "GenericError", "desc": "Inactive 'snap2-fmt' can't be a backing child of active 'NODE_NAME'"}}
+
+Mirror from active source to inactive target
+disk-fmt active: True
+snap-fmt active: False
+snap2-fmt active: False
+target-fmt active: True
+{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "snap2-fmt"}}
+{"return": {}}
+{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "target-fmt"}}
+{"return": {}}
+disk-fmt active: True
+snap-fmt active: True
+snap2-fmt active: True
+target-fmt active: False
+{"execute": "blockdev-mirror", "arguments": {"device": "snap2-fmt", "job-id": "job0", "sync": "full", "target": "target-fmt"}}
+{"error": {"class": "GenericError", "desc": "Permission 'write' unavailable on inactive node"}}
+
+Backup from active source to inactive target
+{"execute": "blockdev-backup", "arguments": {"device": "snap2-fmt", "job-id": "job0", "sync": "full", "target": "target-fmt"}}
+{"error": {"class": "GenericError", "desc": "Could not create node: Inactive 'target-fmt' can't be a target child of active 'NODE_NAME'"}}
+
+Backup from inactive source to active target
+{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "snap2-fmt"}}
+{"return": {}}
+{"execute": "blockdev-set-active", "arguments": {"active": true, "node-name": "target-fmt"}}
+{"return": {}}
+disk-fmt active: False
+snap-fmt active: False
+snap2-fmt active: False
+target-fmt active: True
+{"execute": "blockdev-backup", "arguments": {"device": "snap2-fmt", "job-id": "job0", "sync": "full", "target": "target-fmt"}}
+{"error": {"class": "GenericError", "desc": "Could not create node: Inactive 'snap2-fmt' can't be a file child of active 'NODE_NAME'"}}
+
+=== Accessing export on inactive node ===
+{"execute": "blockdev-set-active", "arguments": {"active": false, "node-name": "target-fmt"}}
+{"return": {}}
+{"execute": "block-export-add", "arguments": {"allow-inactive": true, "id": "exp0", "node-name": "target-fmt", "type": "nbd", "writable": true}}
+{"return": {}}
+read 65536/65536 bytes at offset 0
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+write failed: Operation not permitted
+
+write failed: Operation not permitted
+
+write failed: Operation not permitted
+
+discard failed: Operation not permitted
+
+
+qemu-io: Failed to get allocation status: Operation not permitted
+
+
+=== Resuming VM activates all images ===
+{"execute": "cont", "arguments": {}}
+{"return": {}}
+disk-fmt active: True
+snap-fmt active: True
+snap2-fmt active: True
+target-fmt active: True
+
+Shutting down...
+
-- 
2.48.1

From: Stefan Hajnoczi <stefanha@redhat.com>

BLOCK_OP_TYPE_DATAPLANE prevents BlockDriverState from being used by
virtio-blk/virtio-scsi with IOThread. Commit b112a65c52aa ("block:
declare blockjobs and dataplane friends!") eliminated the main reason
for this blocker in 2014.

Nowadays the block layer supports I/O from multiple AioContexts, so
there is even less reason to block IOThread users. Any legitimate
reasons related to interference would probably also apply to
non-IOThread users.

The only remaining users are bdrv_op_unblock(BLOCK_OP_TYPE_DATAPLANE)
calls after bdrv_op_block_all(). If we remove BLOCK_OP_TYPE_DATAPLANE
their behavior doesn't change.

Existing bdrv_op_block_all() callers that don't explicitly unblock
BLOCK_OP_TYPE_DATAPLANE seem to do so simply because no one bothered to
rather than because it is necessary to keep BLOCK_OP_TYPE_DATAPLANE
blocked.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-ID: <20250203182529.269066-1-stefanha@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block-common.h | 1 -
 block/replication.c          | 1 -
 blockjob.c                   | 2 --
 hw/block/virtio-blk.c        | 9 ---------
 hw/scsi/virtio-scsi.c        | 3 ---
 5 files changed, 16 deletions(-)

diff --git a/include/block/block-common.h b/include/block/block-common.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-common.h
+++ b/include/block/block-common.h
@@ -XXX,XX +XXX,XX @@ typedef enum BlockOpType {
     BLOCK_OP_TYPE_CHANGE,
     BLOCK_OP_TYPE_COMMIT_SOURCE,
     BLOCK_OP_TYPE_COMMIT_TARGET,
-    BLOCK_OP_TYPE_DATAPLANE,
     BLOCK_OP_TYPE_DRIVE_DEL,
     BLOCK_OP_TYPE_EJECT,
     BLOCK_OP_TYPE_EXTERNAL_SNAPSHOT,
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 replication_start(ReplicationState *rs, ReplicationMode mode,
             return;
         }
         bdrv_op_block_all(top_bs, s->blocker);
-        bdrv_op_unblock(top_bs, BLOCK_OP_TYPE_DATAPLANE, s->blocker);
 
         bdrv_graph_wrunlock();
 
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver,
         goto fail;
     }
 
-    bdrv_op_unblock(bs, BLOCK_OP_TYPE_DATAPLANE, job->blocker);
-
     if (!block_job_set_speed(job, speed, errp)) {
         goto fail;
     }
diff --git a/hw/block/virtio-blk.c b/hw/block/virtio-blk.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/virtio-blk.c
+++ b/hw/block/virtio-blk.c
@@ -XXX,XX +XXX,XX @@ static bool virtio_blk_vq_aio_context_init(VirtIOBlock *s, Error **errp)
             error_setg(errp, "ioeventfd is required for iothread");
             return false;
         }
-
-        /*
-         * If ioeventfd is (re-)enabled while the guest is running there could
-         * be block jobs that can conflict.
-         */
-        if (blk_op_is_blocked(conf->conf.blk, BLOCK_OP_TYPE_DATAPLANE, errp)) {
-            error_prepend(errp, "cannot start virtio-blk ioeventfd: ");
-            return false;
-        }
     }
 
     s->vq_aio_context = g_new(AioContext *, conf->num_queues);
diff --git a/hw/scsi/virtio-scsi.c b/hw/scsi/virtio-scsi.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/scsi/virtio-scsi.c
+++ b/hw/scsi/virtio-scsi.c
@@ -XXX,XX +XXX,XX @@ static void virtio_scsi_hotplug(HotplugHandler *hotplug_dev, DeviceState *dev,
     int ret;
 
     if (s->ctx && !s->dataplane_fenced) {
-        if (blk_op_is_blocked(sd->conf.blk, BLOCK_OP_TYPE_DATAPLANE, errp)) {
-            return;
-        }
         ret = blk_set_aio_context(sd->conf.blk, s->ctx, errp);
         if (ret < 0) {
             return;
-- 
2.48.1