Series comparison

-[Qemu-devel] [PULL for-2.11-rc2 0/5] Block patches
+[PULL 0/5] Block patches
-The following changes since commit 508ba0f7e2092d3ca56e3f75e894d52d8b94818e:
+The following changes since commit 711c0418c8c1ce3a24346f058b001c4c5a2f0f81:
-  Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20171109' into staging (2017-11-13 11:41:47 +0000)
+  Merge remote-tracking branch 'remotes/philmd/tags/mips-20210702' into staging (2021-07-04 14:04:12 +0100)
-are available in the git repository at:
+are available in the Git repository at:
-  git://github.com/stefanha/qemu.git tags/block-pull-request
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 0761562687e0d8135310a94b1d3e08376387c027:
+for you to fetch changes up to 9f460c64e13897117f35ffb61f6f5e0102cabc70:
-  qemu-iotests: Test I/O limits with removable media (2017-11-13 15:46:26 +0000)
+  block/io: Merge discard request alignments (2021-07-06 14:28:55 +0100)
 ----------------------------------------------------------------
 Pull request
-The following disk I/O throttling fixes solve recent bugs.
 ----------------------------------------------------------------
-Alberto Garcia (3):
+Akihiko Odaki (3):
-  block: Check for inserted BlockDriverState in blk_io_limits_disable()
+  block/file-posix: Optimize for macOS
-  block: Leave valid throttle timers when removing a BDS from a backend
+  block: Add backend_defaults property
-  qemu-iotests: Test I/O limits with removable media
+  block/io: Merge discard request alignments
-Stefan Hajnoczi (1):
+Stefan Hajnoczi (2):
-  throttle-groups: drain before detaching ThrottleState
+  util/async: add a human-readable name to BHs for debugging
   util/async: print leaked BH name when AioContext finalizes
-Zhengui (1):
+ include/block/aio.h            | 31 ++++++++++++++++++++++---
-  block: all I/O should be completed before removing throttle timers.
+ include/hw/block/block.h       |  3 +++
+ include/qemu/main-loop.h       |  4 +++-
- block/block-backend.c      | 36 ++++++++++++++++++---------
+ block/file-posix.c             | 27 ++++++++++++++++++++--
- block/throttle-groups.c    |  6 +++++
+ block/io.c                     |  2 ++
- tests/qemu-iotests/093     | 62 ++++++++++++++++++++++++++++++++++++++++++++++
+ hw/block/block.c               | 42 ++++++++++++++++++++++++++++++----
- tests/qemu-iotests/093.out |  4 +--
+ tests/unit/ptimer-test-stubs.c |  2 +-
-files changed, 94 insertions(+), 14 deletions(-)
+ util/async.c                   | 25 ++++++++++++++++----
  util/main-loop.c               |  4 ++--
  tests/qemu-iotests/172.out     | 38 ++++++++++++++++++++++++++++++
 files changed, 161 insertions(+), 17 deletions(-)
 --
-.13.6
+.31.1

-[Qemu-devel] [PULL for-2.11-rc2 5/5] qemu-iotests: Test I/O limits with removable media
+[PULL 1/5] util/async: add a human-readable name to BHs for debugging
-From: Alberto Garcia <berto@igalia.com>
+It can be difficult to debug issues with BHs in production environments.
 Although BHs can usually be identified by looking up their ->cb()
 function pointer, this requires debug information for the program. It is
 also not possible to print human-readable diagnostics about BHs because
 they have no identifier.
-This test hotplugs a CD drive to a VM and checks that I/O limits can
+This patch adds a name to each BH. The name is not unique per instance
-be set only when the drive has media inserted and that they are kept
+but differentiates between cb() functions, which is usually enough. It's
-when the media is replaced.
+done by changing aio_bh_new() and friends to macros that stringify cb.
-This also tests the removal of a device with valid I/O limits set but
+The next patch will use the name field when reporting leaked BHs.
 no media inserted. This involves deleting and disabling the limits
 of a BlockBackend without BlockDriverState, a scenario that has been
 crashing until the fixes from the last couple of patches.
-[Python PEP8 fixup: "Don't use spaces are the = sign when used to
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
-indicate a keyword argument or a default parameter value"
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
---Stefan]
+Message-Id: <20210414200247.917496-2-stefanha@redhat.com>
 ---
  include/block/aio.h            | 31 ++++++++++++++++++++++++++++---
  include/qemu/main-loop.h       |  4 +++-
  tests/unit/ptimer-test-stubs.c |  2 +-
  util/async.c                   |  9 +++++++--
  util/main-loop.c               |  4 ++--
 files changed, 41 insertions(+), 9 deletions(-)
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+diff --git a/include/block/aio.h b/include/block/aio.h
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+index XXXXXXX..XXXXXXX 100644
-Message-id: 071eb397118ed207c5a7f01d58766e415ee18d6a.1510339534.git.berto@igalia.com
+--- a/include/block/aio.h
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
++++ b/include/block/aio.h
----
+@@ -XXX,XX +XXX,XX @@ void aio_context_acquire(AioContext *ctx);
- tests/qemu-iotests/093     | 62 ++++++++++++++++++++++++++++++++++++++++++++++
+ /* Relinquish ownership of the AioContext. */
- tests/qemu-iotests/093.out |  4 +--
+ void aio_context_release(AioContext *ctx);
-files changed, 64 insertions(+), 2 deletions(-)
 +/**
 + * aio_bh_schedule_oneshot_full: Allocate a new bottom half structure that will
 + * run only once and as soon as possible.
 + *
 + * @name: A human-readable identifier for debugging purposes.
 + */
 +void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
 +                                  const char *name);
 +
  /**
   * aio_bh_schedule_oneshot: Allocate a new bottom half structure that will run
   * only once and as soon as possible.
 + *
 + * A convenience wrapper for aio_bh_schedule_oneshot_full() that uses cb as the
 + * name string.
   */
 -void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
 +#define aio_bh_schedule_oneshot(ctx, cb, opaque) \
 +    aio_bh_schedule_oneshot_full((ctx), (cb), (opaque), (stringify(cb)))
  /**
 - * aio_bh_new: Allocate a new bottom half structure.
 + * aio_bh_new_full: Allocate a new bottom half structure.
   *
   * Bottom halves are lightweight callbacks whose invocation is guaranteed
   * to be wait-free, thread-safe and signal-safe.  The #QEMUBH structure
   * is opaque and must be allocated prior to its use.
 + *
 + * @name: A human-readable identifier for debugging purposes.
   */
 -QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
 +QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
 +                        const char *name);
 +
 +/**
 + * aio_bh_new: Allocate a new bottom half structure
 + *
 + * A convenience wrapper for aio_bh_new_full() that uses the cb as the name
 + * string.
 + */
 +#define aio_bh_new(ctx, cb, opaque) \
 +    aio_bh_new_full((ctx), (cb), (opaque), (stringify(cb)))
  /**
   * aio_notify: Force processing of pending events.
 diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/qemu/main-loop.h
 +++ b/include/qemu/main-loop.h
@@ -XXX,XX +XXX,XX @@ void qemu_cond_timedwait_iothread(QemuCond *cond, int ms);
  void qemu_fd_register(int fd);
 -QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
 +#define qemu_bh_new(cb, opaque) \
 +    qemu_bh_new_full((cb), (opaque), (stringify(cb)))
 +QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name);
  void qemu_bh_schedule_idle(QEMUBH *bh);
  enum {
 diff --git a/tests/unit/ptimer-test-stubs.c b/tests/unit/ptimer-test-stubs.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/unit/ptimer-test-stubs.c
 +++ b/tests/unit/ptimer-test-stubs.c
@@ -XXX,XX +XXX,XX @@ int64_t qemu_clock_deadline_ns_all(QEMUClockType type, int attr_mask)
      return deadline;
  }
 -QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
 +QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
  {
      QEMUBH *bh = g_new(QEMUBH, 1);
 diff --git a/util/async.c b/util/async.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/async.c
 +++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ enum {
  struct QEMUBH {
      AioContext *ctx;
 +    const char *name;
      QEMUBHFunc *cb;
      void *opaque;
      QSLIST_ENTRY(QEMUBH) next;
@@ -XXX,XX +XXX,XX @@ static QEMUBH *aio_bh_dequeue(BHList *head, unsigned *flags)
      return bh;
  }
 -void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
 +void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb,
 +                                  void *opaque, const char *name)
  {
      QEMUBH *bh;
      bh = g_new(QEMUBH, 1);
@@ -XXX,XX +XXX,XX @@ void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
          .ctx = ctx,
          .cb = cb,
          .opaque = opaque,
 +        .name = name,
      };
      aio_bh_enqueue(bh, BH_SCHEDULED | BH_ONESHOT);
  }
 -QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
 +QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
 +                        const char *name)
  {
      QEMUBH *bh;
      bh = g_new(QEMUBH, 1);
@@ -XXX,XX +XXX,XX @@ QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
          .ctx = ctx,
          .cb = cb,
          .opaque = opaque,
 +        .name = name,
      };
      return bh;
  }
 diff --git a/util/main-loop.c b/util/main-loop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/main-loop.c
 +++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@ void main_loop_wait(int nonblocking)
  /* Functions to operate on the main QEMU AioContext.  */
 -QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
 +QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
  {
 -    return aio_bh_new(qemu_aio_context, cb, opaque);
 +    return aio_bh_new_full(qemu_aio_context, cb, opaque, name);
  }
  /*
 --
 .31.1
-diff --git a/tests/qemu-iotests/093 b/tests/qemu-iotests/093
-index XXXXXXX..XXXXXXX 100755
---- a/tests/qemu-iotests/093
-+++ b/tests/qemu-iotests/093
-@@ -XXX,XX +XXX,XX @@ class ThrottleTestGroupNames(iotests.QMPTestCase):
-             groupname = "group%d" % i
-             self.verify_name(devname, groupname)
-+class ThrottleTestRemovableMedia(iotests.QMPTestCase):
-+    def setUp(self):
-+        self.vm = iotests.VM()
-+        if iotests.qemu_default_machine == 's390-ccw-virtio':
-+            self.vm.add_device("virtio-scsi-ccw,id=virtio-scsi")
-+        else:
-+            self.vm.add_device("virtio-scsi-pci,id=virtio-scsi")
-+        self.vm.launch()
-+
-+    def tearDown(self):
-+        self.vm.shutdown()
-+
-+    def test_removable_media(self):
-+        # Add a couple of dummy nodes named cd0 and cd1
-+        result = self.vm.qmp("blockdev-add", driver="null-aio",
-+                             node_name="cd0")
-+        self.assert_qmp(result, 'return', {})
-+        result = self.vm.qmp("blockdev-add", driver="null-aio",
-+                             node_name="cd1")
-+        self.assert_qmp(result, 'return', {})
-+
-+        # Attach a CD drive with cd0 inserted
-+        result = self.vm.qmp("device_add", driver="scsi-cd",
-+                             id="dev0", drive="cd0")
-+        self.assert_qmp(result, 'return', {})
-+
-+        # Set I/O limits
-+        args = { "id": "dev0", "iops": 100, "iops_rd": 0, "iops_wr": 0,
-+                                "bps":  50,  "bps_rd": 0,  "bps_wr": 0 }
-+        result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **args)
-+        self.assert_qmp(result, 'return', {})
-+
-+        # Check that the I/O limits have been set
-+        result = self.vm.qmp("query-block")
-+        self.assert_qmp(result, 'return[0]/inserted/iops', 100)
-+        self.assert_qmp(result, 'return[0]/inserted/bps',   50)
-+
-+        # Now eject cd0 and insert cd1
-+        result = self.vm.qmp("blockdev-open-tray", id='dev0')
-+        self.assert_qmp(result, 'return', {})
-+        result = self.vm.qmp("x-blockdev-remove-medium", id='dev0')
-+        self.assert_qmp(result, 'return', {})
-+        result = self.vm.qmp("x-blockdev-insert-medium", id='dev0', node_name='cd1')
-+        self.assert_qmp(result, 'return', {})
-+
-+        # Check that the I/O limits are still the same
-+        result = self.vm.qmp("query-block")
-+        self.assert_qmp(result, 'return[0]/inserted/iops', 100)
-+        self.assert_qmp(result, 'return[0]/inserted/bps',   50)
-+
-+        # Eject cd1
-+        result = self.vm.qmp("x-blockdev-remove-medium", id='dev0')
-+        self.assert_qmp(result, 'return', {})
-+
-+        # Check that we can't set limits if the device has no medium
-+        result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **args)
-+        self.assert_qmp(result, 'error/class', 'GenericError')
-+
-+        # Remove the CD drive
-+        result = self.vm.qmp("device_del", id='dev0')
-+        self.assert_qmp(result, 'return', {})
-+
- if __name__ == '__main__':
-     iotests.main(supported_fmts=["raw"])
-diff --git a/tests/qemu-iotests/093.out b/tests/qemu-iotests/093.out
-index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/093.out
-+++ b/tests/qemu-iotests/093.out
-@@ -XXX,XX +XXX,XX @@
--.......
-+........
- ----------------------------------------------------------------------
--Ran 7 tests
-+Ran 8 tests
- OK
---
-.13.6

-[Qemu-devel] [PULL for-2.11-rc2 3/5] block: Check for inserted BlockDriverState in blk_io_limits_disable()
+[PULL 2/5] util/async: print leaked BH name when AioContext finalizes
-From: Alberto Garcia <berto@igalia.com>
+BHs must be deleted before the AioContext is finalized. If not, it's a
 bug and probably indicates that some part of the program still expects
 the BH to run in the future. That can lead to memory leaks, inconsistent
 state, or just hangs.
-When you set I/O limits using block_set_io_throttle or the command
+Unfortunately the assert(flags & BH_DELETED) call in aio_ctx_finalize()
-line throttling.* options they are kept in the BlockBackend regardless
+is difficult to debug because the assertion failure contains no
-of whether a BlockDriverState is attached to the backend or not.
+information about the BH!
-Therefore when removing the limits using blk_io_limits_disable() we
+Use the QEMUBH name field added in the previous patch to show a useful
-need to check if there's a BDS before attempting to drain it, else it
+error when a leaked BH is detected.
 will crash QEMU. This can be reproduced very easily using HMP:
-     (qemu) drive_add 0 if=none,throttling.iops-total=5000
+Suggested-by: Eric Ernst <eric.g.ernst@gmail.com>
-     (qemu) drive_del none0
+Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Message-Id: <20210414200247.917496-3-stefanha@redhat.com>
 ---
  util/async.c | 16 ++++++++++++++--
 file changed, 14 insertions(+), 2 deletions(-)
-Reported-by: sochin jiang <sochin.jiang@huawei.com>
+diff --git a/util/async.c b/util/async.c
-Signed-off-by: Alberto Garcia <berto@igalia.com>
+index XXXXXXX..XXXXXXX 100644
-Reviewed-by: Max Reitz <mreitz@redhat.com>
+--- a/util/async.c
-Message-id: 0d3a67ce8d948bb33e08672564714dcfb76a3d8c.1510339534.git.berto@igalia.com
++++ b/util/async.c
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+@@ -XXX,XX +XXX,XX @@ aio_ctx_finalize(GSource     *source)
----
+     assert(QSIMPLEQ_EMPTY(&ctx->bh_slice_list));
- block/block-backend.c | 14 ++++++++++----
-file changed, 10 insertions(+), 4 deletions(-)
+     while ((bh = aio_bh_dequeue(&ctx->bh_list, &flags))) {
 -        /* qemu_bh_delete() must have been called on BHs in this AioContext */
 -        assert(flags & BH_DELETED);
 +        /*
 +         * qemu_bh_delete() must have been called on BHs in this AioContext. In
 +         * many cases memory leaks, hangs, or inconsistent state occur when a
 +         * BH is leaked because something still expects it to run.
 +         *
 +         * If you hit this, fix the lifecycle of the BH so that
 +         * qemu_bh_delete() and any associated cleanup is called before the
 +         * AioContext is finalized.
 +         */
 +        if (unlikely(!(flags & BH_DELETED))) {
 +            fprintf(stderr, "%s: BH '%s' leaked, aborting...\n",
 +                    __func__, bh->name);
 +            abort();
 +        }
          g_free(bh);
      }
 --
 .31.1
-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_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)
- void blk_io_limits_disable(BlockBackend *blk)
- {
--    assert(blk->public.throttle_group_member.throttle_state);
--    bdrv_drained_begin(blk_bs(blk));
--    throttle_group_unregister_tgm(&blk->public.throttle_group_member);
--    bdrv_drained_end(blk_bs(blk));
-+    BlockDriverState *bs = blk_bs(blk);
-+    ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
-+    assert(tgm->throttle_state);
-+    if (bs) {
-+        bdrv_drained_begin(bs);
-+    }
-+    throttle_group_unregister_tgm(tgm);
-+    if (bs) {
-+        bdrv_drained_end(bs);
-+    }
- }
- /* should be called before blk_set_io_limits if a limit is set */
---
-.13.6

-[Qemu-devel] [PULL for-2.11-rc2 4/5] block: Leave valid throttle timers when removing a BDS from a backend
+[PULL 3/5] block/file-posix: Optimize for macOS
-From: Alberto Garcia <berto@igalia.com>
+From: Akihiko Odaki <akihiko.odaki@gmail.com>
-If a BlockBackend has I/O limits set then its ThrottleGroupMember
+This commit introduces "punch hole" operation and optimizes transfer
-structure uses the AioContext from its attached BlockDriverState.
+block size for macOS.
 Those two contexts must be kept in sync manually. This is not
 ideal and will be fixed in the future by removing the throttling
 configuration from the BlockBackend and storing it in an implicit
 filter node instead, but for now we have to live with this.
-When you remove the BlockDriverState from the backend then the
+Thanks to Konstantin Nazarov for detailed analysis of a flaw in an
-throttle timers are destroyed. If a new BlockDriverState is later
+old version of this change:
-inserted then they are created again using the new AioContext.
+https://gist.github.com/akihikodaki/87df4149e7ca87f18dc56807ec5a1bc5#gistcomment-3654667
-There are a couple of problems with this:
+Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
+Message-id: 20210705130458.97642-1-akihiko.odaki@gmail.com
    a) The code manipulates the timers directly, leaving the
       ThrottleGroupMember.aio_context field in an inconsisent state.
    b) If you remove the I/O limits (e.g by destroying the backend)
       when the timers are gone then throttle_group_unregister_tgm()
       will attempt to destroy them again, crashing QEMU.
 While b) could be fixed easily by allowing the timers to be freed
 twice, this would result in a situation in which we can no longer
 guarantee that a valid ThrottleState has a valid AioContext and
 timers.
 This patch ensures that the timers and AioContext are always valid
 when I/O limits are set, regardless of whether the BlockBackend has a
 BlockDriverState inserted or not.
 [Fixed "There'a" typo as suggested by Max Reitz <mreitz@redhat.com>
 --Stefan]
 Reported-by: sochin jiang <sochin.jiang@huawei.com>
 Signed-off-by: Alberto Garcia <berto@igalia.com>
 Reviewed-by: Max Reitz <mreitz@redhat.com>
 Message-id: e089c66e7c20289b046d782cea4373b765c5bc1d.1510339534.git.berto@igalia.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/block-backend.c | 16 ++++++++--------
+ block/file-posix.c | 27 +++++++++++++++++++++++++--
-file changed, 8 insertions(+), 8 deletions(-)
+file changed, 25 insertions(+), 2 deletions(-)
-diff --git a/block/block-backend.c b/block/block-backend.c
+diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/block-backend.c
+--- a/block/file-posix.c
-+++ b/block/block-backend.c
++++ b/block/file-posix.c
-@@ -XXX,XX +XXX,XX @@ BlockBackend *blk_by_public(BlockBackendPublic *public)
+@@ -XXX,XX +XXX,XX @@
-  */
+ #if defined(HAVE_HOST_BLOCK_DEVICE)
- void blk_remove_bs(BlockBackend *blk)
+ #include <paths.h>
  #include <sys/param.h>
 +#include <sys/mount.h>
  #include <IOKit/IOKitLib.h>
  #include <IOKit/IOBSD.h>
  #include <IOKit/storage/IOMediaBSDClient.h>
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
          return;
      }
 +#if defined(__APPLE__) && (__MACH__)
 +    struct statfs buf;
 +
 +    if (!fstatfs(s->fd, &buf)) {
 +        bs->bl.opt_transfer = buf.f_iosize;
 +        bs->bl.pdiscard_alignment = buf.f_bsize;
 +    }
 +#endif
 +
      if (bs->sg || S_ISBLK(st.st_mode)) {
          int ret = hdev_get_max_hw_transfer(s->fd, &st);
@@ -XXX,XX +XXX,XX @@ out:
      }
  }
 +#if defined(CONFIG_FALLOCATE) || defined(BLKZEROOUT) || defined(BLKDISCARD)
  static int translate_err(int err)
  {
-+    ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
+     if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
-     BlockDriverState *bs;
+@@ -XXX,XX +XXX,XX @@ static int translate_err(int err)
 -    ThrottleTimers *tt;
      notifier_list_notify(&blk->remove_bs_notifiers, blk);
 -    if (blk->public.throttle_group_member.throttle_state) {
 -        tt = &blk->public.throttle_group_member.throttle_timers;
 +    if (tgm->throttle_state) {
          bs = blk_bs(blk);
          bdrv_drained_begin(bs);
 -        throttle_timers_detach_aio_context(tt);
 +        throttle_group_detach_aio_context(tgm);
 +        throttle_group_attach_aio_context(tgm, qemu_get_aio_context());
          bdrv_drained_end(bs);
      }
+     return err;
-@@ -XXX,XX +XXX,XX @@ void blk_remove_bs(BlockBackend *blk)
+ }
-  */
++#endif
- int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
- {
+ #ifdef CONFIG_FALLOCATE
-+    ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
+ static int do_fallocate(int fd, int mode, off_t offset, off_t len)
-     blk->root = bdrv_root_attach_child(bs, "root", &child_root,
+@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_discard(void *opaque)
-                                        blk->perm, blk->shared_perm, blk, errp);
+             }
-     if (blk->root == NULL) {
+         } while (errno == EINTR);
-@@ -XXX,XX +XXX,XX @@ int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
-     bdrv_ref(bs);
+-        ret = -errno;
++        ret = translate_err(-errno);
-     notifier_list_notify(&blk->insert_bs_notifiers, blk);
+ #endif
--    if (blk->public.throttle_group_member.throttle_state) {
+     } else {
--        throttle_timers_attach_aio_context(
+ #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
--            &blk->public.throttle_group_member.throttle_timers,
+         ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
--            bdrv_get_aio_context(bs));
+                            aiocb->aio_offset, aiocb->aio_nbytes);
-+    if (tgm->throttle_state) {
++        ret = translate_err(-errno);
-+        throttle_group_detach_aio_context(tgm);
++#elif defined(__APPLE__) && (__MACH__)
-+        throttle_group_attach_aio_context(tgm, bdrv_get_aio_context(bs));
++        fpunchhole_t fpunchhole;
 +        fpunchhole.fp_flags = 0;
 +        fpunchhole.reserved = 0;
 +        fpunchhole.fp_offset = aiocb->aio_offset;
 +        fpunchhole.fp_length = aiocb->aio_nbytes;
 +        if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) {
 +            ret = errno == ENODEV ? -ENOTSUP : -errno;
 +        } else {
 +            ret = 0;
 +        }
  #endif
      }
-     return 0;
+-    ret = translate_err(ret);
      if (ret == -ENOTSUP) {
          s->has_discard = false;
      }
 --
-.13.6
+.31.1

-[Qemu-devel] [PULL for-2.11-rc2 2/5] throttle-groups: drain before detaching ThrottleState
+[PULL 4/5] block: Add backend_defaults property
-I/O requests hang after stop/cont commands at least since QEMU 2.10.0
+From: Akihiko Odaki <akihiko.odaki@gmail.com>
-with -drive iops=100:
+backend_defaults property allow users to control if default block
-  (guest)$ dd if=/dev/zero of=/dev/vdb oflag=direct count=1000
+properties should be decided with backend information.
-  (qemu) stop
-  (qemu) cont
+If it is off, any backend information will be discarded, which is
-  ...I/O is stuck...
+suitable if you plan to perform live migration to a different disk backend.
-This happens because blk_set_aio_context() detaches the ThrottleState
+If it is on, a block device may utilize backend information more
-while requests may still be in flight:
+aggressively.
-  if (tgm->throttle_state) {
+By default, it is auto, which uses backend information for block
-      throttle_group_detach_aio_context(tgm);
+sizes and ignores the others, which is consistent with the older
-      throttle_group_attach_aio_context(tgm, new_context);
+versions.
-  }
+Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
-This patch encloses the detach/attach calls in a drained region so no
+Message-id: 20210705130458.97642-2-akihiko.odaki@gmail.com
 I/O request is left hanging.  Also add assertions so we don't make the
 same mistake again in the future.
 Reported-by: Yongxue Hong <yhong@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Message-id: 20171110151934.16883-1-stefanha@redhat.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/block-backend.c   | 2 ++
+ include/hw/block/block.h   |  3 +++
- block/throttle-groups.c | 6 ++++++
+ hw/block/block.c           | 42 ++++++++++++++++++++++++++++++++++----
-files changed, 8 insertions(+)
+ tests/qemu-iotests/172.out | 38 ++++++++++++++++++++++++++++++++++
+files changed, 79 insertions(+), 4 deletions(-)
-diff --git a/block/block-backend.c b/block/block-backend.c
 diff --git a/include/hw/block/block.h b/include/hw/block/block.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/block-backend.c
+--- a/include/hw/block/block.h
-+++ b/block/block-backend.c
++++ b/include/hw/block/block.h
-@@ -XXX,XX +XXX,XX @@ void blk_set_aio_context(BlockBackend *blk, AioContext *new_context)
+@@ -XXX,XX +XXX,XX @@
-     if (bs) {
+ typedef struct BlockConf {
-         if (tgm->throttle_state) {
+     BlockBackend *blk;
-+            bdrv_drained_begin(bs);
++    OnOffAuto backend_defaults;
-             throttle_group_detach_aio_context(tgm);
+     uint32_t physical_block_size;
-             throttle_group_attach_aio_context(tgm, new_context);
+     uint32_t logical_block_size;
-+            bdrv_drained_end(bs);
+     uint32_t min_io_size;
@@ -XXX,XX +XXX,XX @@ static inline unsigned int get_physical_block_exp(BlockConf *conf)
  }
  #define DEFINE_BLOCK_PROPERTIES_BASE(_state, _conf)                     \
 +    DEFINE_PROP_ON_OFF_AUTO("backend_defaults", _state,                 \
 +                            _conf.backend_defaults, ON_OFF_AUTO_AUTO),  \
      DEFINE_PROP_BLOCKSIZE("logical_block_size", _state,                 \
                            _conf.logical_block_size),                    \
      DEFINE_PROP_BLOCKSIZE("physical_block_size", _state,                \
 diff --git a/hw/block/block.c b/hw/block/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/block.c
 +++ b/hw/block/block.c
@@ -XXX,XX +XXX,XX @@ bool blkconf_blocksizes(BlockConf *conf, Error **errp)
  {
      BlockBackend *blk = conf->blk;
      BlockSizes blocksizes;
 -    int backend_ret;
 +    BlockDriverState *bs;
 +    bool use_blocksizes;
 +    bool use_bs;
 +
 +    switch (conf->backend_defaults) {
 +    case ON_OFF_AUTO_AUTO:
 +        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
 +        use_bs = false;
 +        break;
 +
 +    case ON_OFF_AUTO_ON:
 +        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
 +        bs = blk_bs(blk);
 +        use_bs = bs;
 +        break;
 +
 +    case ON_OFF_AUTO_OFF:
 +        use_blocksizes = false;
 +        use_bs = false;
 +        break;
 +
 +    default:
 +        abort();
 +    }
 -    backend_ret = blk_probe_blocksizes(blk, &blocksizes);
      /* fill in detected values if they are not defined via qemu command line */
      if (!conf->physical_block_size) {
 -        if (!backend_ret) {
 +        if (use_blocksizes) {
             conf->physical_block_size = blocksizes.phys;
          } else {
              conf->physical_block_size = BDRV_SECTOR_SIZE;
          }
-         bdrv_set_aio_context(bs, new_context);
      }
-diff --git a/block/throttle-groups.c b/block/throttle-groups.c
+     if (!conf->logical_block_size) {
 -        if (!backend_ret) {
 +        if (use_blocksizes) {
              conf->logical_block_size = blocksizes.log;
          } else {
              conf->logical_block_size = BDRV_SECTOR_SIZE;
          }
      }
 +    if (use_bs) {
 +        if (!conf->opt_io_size) {
 +            conf->opt_io_size = bs->bl.opt_transfer;
 +        }
 +        if (conf->discard_granularity == -1) {
 +            if (bs->bl.pdiscard_alignment) {
 +                conf->discard_granularity = bs->bl.pdiscard_alignment;
 +            } else if (bs->bl.request_alignment != 1) {
 +                conf->discard_granularity = bs->bl.request_alignment;
 +            }
 +        }
 +    }
      if (conf->logical_block_size > conf->physical_block_size) {
          error_setg(errp,
 diff --git a/tests/qemu-iotests/172.out b/tests/qemu-iotests/172.out
 index XXXXXXX..XXXXXXX 100644
---- a/block/throttle-groups.c
+--- a/tests/qemu-iotests/172.out
-+++ b/block/throttle-groups.c
++++ b/tests/qemu-iotests/172.out
-@@ -XXX,XX +XXX,XX @@ void throttle_group_attach_aio_context(ThrottleGroupMember *tgm,
+@@ -XXX,XX +XXX,XX @@ Testing:
- void throttle_group_detach_aio_context(ThrottleGroupMember *tgm)
+               dev: floppy, id ""
- {
+                 unit = 0 (0x0)
-     ThrottleTimers *tt = &tgm->throttle_timers;
+                 drive = "floppy0"
-+
++                backend_defaults = "auto"
-+    /* Requests must have been drained */
+                 logical_block_size = 512 (512 B)
-+    assert(tgm->pending_reqs[0] == 0 && tgm->pending_reqs[1] == 0);
+                 physical_block_size = 512 (512 B)
-+    assert(qemu_co_queue_empty(&tgm->throttled_reqs[0]));
+                 min_io_size = 0 (0 B)
-+    assert(qemu_co_queue_empty(&tgm->throttled_reqs[1]));
+@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2
-+
+               dev: floppy, id ""
-     throttle_timers_detach_aio_context(tt);
+                 unit = 0 (0x0)
-     tgm->aio_context = NULL;
+                 drive = "floppy0"
- }
++                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,unit=1
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -global floppy.drive=none0 -device
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = ""
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=120
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = ""
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=144
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = ""
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=288
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = ""
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,logical
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,physica
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
 --
-.13.6
+.31.1

-[Qemu-devel] [PULL for-2.11-rc2 1/5] block: all I/O should be completed before removing throttle timers.
+[PULL 5/5] block/io: Merge discard request alignments
-From: Zhengui <lizhengui@huawei.com>
+From: Akihiko Odaki <akihiko.odaki@gmail.com>
-In blk_remove_bs, all I/O should be completed before removing throttle
+Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
-timers. If there has inflight I/O, removing throttle timers here will
+Message-id: 20210705130458.97642-3-akihiko.odaki@gmail.com
 cause the inflight I/O never return.
 This patch add bdrv_drained_begin before throttle_timers_detach_aio_context
 to let all I/O completed before removing throttle timers.
 [Moved declaration of bs as suggested by Alberto Garcia
 <berto@igalia.com>.
 --Stefan]
 Signed-off-by: Zhengui <lizhengui@huawei.com>
 Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Message-id: 1508564040-120700-1-git-send-email-lizhengui@huawei.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- block/block-backend.c | 4 ++++
+ block/io.c | 2 ++
-file changed, 4 insertions(+)
+file changed, 2 insertions(+)
-diff --git a/block/block-backend.c b/block/block-backend.c
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/block-backend.c
+--- a/block/io.c
-+++ b/block/block-backend.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ BlockBackend *blk_by_public(BlockBackendPublic *public)
+@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_begin_single(BdrvChild *c, bool poll)
-  */
- void blk_remove_bs(BlockBackend *blk)
+ static void bdrv_merge_limits(BlockLimits *dst, const BlockLimits *src)
  {
-+    BlockDriverState *bs;
++    dst->pdiscard_alignment = MAX(dst->pdiscard_alignment,
-     ThrottleTimers *tt;
++                                  src->pdiscard_alignment);
+     dst->opt_transfer = MAX(dst->opt_transfer, src->opt_transfer);
-     notifier_list_notify(&blk->remove_bs_notifiers, blk);
+     dst->max_transfer = MIN_NON_ZERO(dst->max_transfer, src->max_transfer);
-     if (blk->public.throttle_group_member.throttle_state) {
+     dst->max_hw_transfer = MIN_NON_ZERO(dst->max_hw_transfer,
          tt = &blk->public.throttle_group_member.throttle_timers;
 +        bs = blk_bs(blk);
 +        bdrv_drained_begin(bs);
          throttle_timers_detach_aio_context(tt);
 +        bdrv_drained_end(bs);
      }
      blk_update_root_state(blk);
 --
-.13.6
+.31.1

The following changes since commit 508ba0f7e2092d3ca56e3f75e894d52d8b94818e:

Merge remote-tracking branch 'remotes/cohuck/tags/s390x-20171109' into staging (2017-11-13 11:41:47 +0000)

are available in the git repository at:

git://github.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 0761562687e0d8135310a94b1d3e08376387c027:

qemu-iotests: Test I/O limits with removable media (2017-11-13 15:46:26 +0000)

----------------------------------------------------------------
Pull request

The following disk I/O throttling fixes solve recent bugs.

----------------------------------------------------------------

Alberto Garcia (3):
  block: Check for inserted BlockDriverState in blk_io_limits_disable()
  block: Leave valid throttle timers when removing a BDS from a backend
  qemu-iotests: Test I/O limits with removable media

Stefan Hajnoczi (1):
  throttle-groups: drain before detaching ThrottleState

Zhengui (1):
  block: all I/O should be completed before removing throttle timers.

block/block-backend.c      | 36 ++++++++++++++++++---------
 block/throttle-groups.c    |  6 +++++
 tests/qemu-iotests/093     | 62 ++++++++++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/093.out |  4 +--
 4 files changed, 94 insertions(+), 14 deletions(-)

-- 
2.13.6

From: Zhengui <lizhengui@huawei.com>

In blk_remove_bs, all I/O should be completed before removing throttle
timers. If there has inflight I/O, removing throttle timers here will
cause the inflight I/O never return.
This patch add bdrv_drained_begin before throttle_timers_detach_aio_context
to let all I/O completed before removing throttle timers.

[Moved declaration of bs as suggested by Alberto Garcia
<berto@igalia.com>.
--Stefan]

Signed-off-by: Zhengui <lizhengui@huawei.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Message-id: 1508564040-120700-1-git-send-email-lizhengui@huawei.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/block-backend.c | 4 ++++
 1 file changed, 4 insertions(+)

I/O requests hang after stop/cont commands at least since QEMU 2.10.0
with -drive iops=100:

(guest)$ dd if=/dev/zero of=/dev/vdb oflag=direct count=1000
  (qemu) stop
  (qemu) cont
  ...I/O is stuck...

This happens because blk_set_aio_context() detaches the ThrottleState
while requests may still be in flight:

if (tgm->throttle_state) {
      throttle_group_detach_aio_context(tgm);
      throttle_group_attach_aio_context(tgm, new_context);
  }

This patch encloses the detach/attach calls in a drained region so no
I/O request is left hanging.  Also add assertions so we don't make the
same mistake again in the future.

Reported-by: Yongxue Hong <yhong@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Message-id: 20171110151934.16883-1-stefanha@redhat.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/block-backend.c   | 2 ++
 block/throttle-groups.c | 6 ++++++
 2 files changed, 8 insertions(+)

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_set_aio_context(BlockBackend *blk, AioContext *new_context)
 
     if (bs) {
         if (tgm->throttle_state) {
+            bdrv_drained_begin(bs);
             throttle_group_detach_aio_context(tgm);
             throttle_group_attach_aio_context(tgm, new_context);
+            bdrv_drained_end(bs);
         }
         bdrv_set_aio_context(bs, new_context);
     }
diff --git a/block/throttle-groups.c b/block/throttle-groups.c
index XXXXXXX..XXXXXXX 100644
--- a/block/throttle-groups.c
+++ b/block/throttle-groups.c
@@ -XXX,XX +XXX,XX @@ void throttle_group_attach_aio_context(ThrottleGroupMember *tgm,
 void throttle_group_detach_aio_context(ThrottleGroupMember *tgm)
 {
     ThrottleTimers *tt = &tgm->throttle_timers;
+
+    /* Requests must have been drained */
+    assert(tgm->pending_reqs[0] == 0 && tgm->pending_reqs[1] == 0);
+    assert(qemu_co_queue_empty(&tgm->throttled_reqs[0]));
+    assert(qemu_co_queue_empty(&tgm->throttled_reqs[1]));
+
     throttle_timers_detach_aio_context(tt);
     tgm->aio_context = NULL;
 }
-- 
2.13.6

From: Alberto Garcia <berto@igalia.com>

When you set I/O limits using block_set_io_throttle or the command
line throttling.* options they are kept in the BlockBackend regardless
of whether a BlockDriverState is attached to the backend or not.

Therefore when removing the limits using blk_io_limits_disable() we
need to check if there's a BDS before attempting to drain it, else it
will crash QEMU. This can be reproduced very easily using HMP:

(qemu) drive_add 0 if=none,throttling.iops-total=5000
     (qemu) drive_del none0

Reported-by: sochin jiang <sochin.jiang@huawei.com>
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: 0d3a67ce8d948bb33e08672564714dcfb76a3d8c.1510339534.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/block-backend.c | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 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_set_io_limits(BlockBackend *blk, ThrottleConfig *cfg)
 
 void blk_io_limits_disable(BlockBackend *blk)
 {
-    assert(blk->public.throttle_group_member.throttle_state);
-    bdrv_drained_begin(blk_bs(blk));
-    throttle_group_unregister_tgm(&blk->public.throttle_group_member);
-    bdrv_drained_end(blk_bs(blk));
+    BlockDriverState *bs = blk_bs(blk);
+    ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
+    assert(tgm->throttle_state);
+    if (bs) {
+        bdrv_drained_begin(bs);
+    }
+    throttle_group_unregister_tgm(tgm);
+    if (bs) {
+        bdrv_drained_end(bs);
+    }
 }
 
 /* should be called before blk_set_io_limits if a limit is set */
-- 
2.13.6

From: Alberto Garcia <berto@igalia.com>

If a BlockBackend has I/O limits set then its ThrottleGroupMember
structure uses the AioContext from its attached BlockDriverState.
Those two contexts must be kept in sync manually. This is not
ideal and will be fixed in the future by removing the throttling
configuration from the BlockBackend and storing it in an implicit
filter node instead, but for now we have to live with this.

When you remove the BlockDriverState from the backend then the
throttle timers are destroyed. If a new BlockDriverState is later
inserted then they are created again using the new AioContext.

There are a couple of problems with this:

a) The code manipulates the timers directly, leaving the
      ThrottleGroupMember.aio_context field in an inconsisent state.

b) If you remove the I/O limits (e.g by destroying the backend)
      when the timers are gone then throttle_group_unregister_tgm()
      will attempt to destroy them again, crashing QEMU.

While b) could be fixed easily by allowing the timers to be freed
twice, this would result in a situation in which we can no longer
guarantee that a valid ThrottleState has a valid AioContext and
timers.

This patch ensures that the timers and AioContext are always valid
when I/O limits are set, regardless of whether the BlockBackend has a
BlockDriverState inserted or not.

[Fixed "There'a" typo as suggested by Max Reitz <mreitz@redhat.com>
--Stefan]

Reported-by: sochin jiang <sochin.jiang@huawei.com>
Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: e089c66e7c20289b046d782cea4373b765c5bc1d.1510339534.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/block-backend.c | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 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 @@ BlockBackend *blk_by_public(BlockBackendPublic *public)
  */
 void blk_remove_bs(BlockBackend *blk)
 {
+    ThrottleGroupMember *tgm = &blk->public.throttle_group_member;
     BlockDriverState *bs;
-    ThrottleTimers *tt;
 
     notifier_list_notify(&blk->remove_bs_notifiers, blk);
-    if (blk->public.throttle_group_member.throttle_state) {
-        tt = &blk->public.throttle_group_member.throttle_timers;
+    if (tgm->throttle_state) {
         bs = blk_bs(blk);
         bdrv_drained_begin(bs);
-        throttle_timers_detach_aio_context(tt);
+        throttle_group_detach_aio_context(tgm);
+        throttle_group_attach_aio_context(tgm, qemu_get_aio_context());
         bdrv_drained_end(bs);
     }
 
@@ -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;
     blk->root = bdrv_root_attach_child(bs, "root", &child_root,
                                        blk->perm, blk->shared_perm, blk, errp);
     if (blk->root == NULL) {
@@ -XXX,XX +XXX,XX @@ int blk_insert_bs(BlockBackend *blk, BlockDriverState *bs, Error **errp)
     bdrv_ref(bs);
 
     notifier_list_notify(&blk->insert_bs_notifiers, blk);
-    if (blk->public.throttle_group_member.throttle_state) {
-        throttle_timers_attach_aio_context(
-            &blk->public.throttle_group_member.throttle_timers,
-            bdrv_get_aio_context(bs));
+    if (tgm->throttle_state) {
+        throttle_group_detach_aio_context(tgm);
+        throttle_group_attach_aio_context(tgm, bdrv_get_aio_context(bs));
     }
 
     return 0;
-- 
2.13.6

From: Alberto Garcia <berto@igalia.com>

This test hotplugs a CD drive to a VM and checks that I/O limits can
be set only when the drive has media inserted and that they are kept
when the media is replaced.

This also tests the removal of a device with valid I/O limits set but
no media inserted. This involves deleting and disabling the limits
of a BlockBackend without BlockDriverState, a scenario that has been
crashing until the fixes from the last couple of patches.

[Python PEP8 fixup: "Don't use spaces are the = sign when used to
indicate a keyword argument or a default parameter value"
--Stefan]

Signed-off-by: Alberto Garcia <berto@igalia.com>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Message-id: 071eb397118ed207c5a7f01d58766e415ee18d6a.1510339534.git.berto@igalia.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/qemu-iotests/093     | 62 ++++++++++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/093.out |  4 +--
 2 files changed, 64 insertions(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/093 b/tests/qemu-iotests/093
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/093
+++ b/tests/qemu-iotests/093
@@ -XXX,XX +XXX,XX @@ class ThrottleTestGroupNames(iotests.QMPTestCase):
             groupname = "group%d" % i
             self.verify_name(devname, groupname)
 
+class ThrottleTestRemovableMedia(iotests.QMPTestCase):
+    def setUp(self):
+        self.vm = iotests.VM()
+        if iotests.qemu_default_machine == 's390-ccw-virtio':
+            self.vm.add_device("virtio-scsi-ccw,id=virtio-scsi")
+        else:
+            self.vm.add_device("virtio-scsi-pci,id=virtio-scsi")
+        self.vm.launch()
+
+    def tearDown(self):
+        self.vm.shutdown()
+
+    def test_removable_media(self):
+        # Add a couple of dummy nodes named cd0 and cd1
+        result = self.vm.qmp("blockdev-add", driver="null-aio",
+                             node_name="cd0")
+        self.assert_qmp(result, 'return', {})
+        result = self.vm.qmp("blockdev-add", driver="null-aio",
+                             node_name="cd1")
+        self.assert_qmp(result, 'return', {})
+
+        # Attach a CD drive with cd0 inserted
+        result = self.vm.qmp("device_add", driver="scsi-cd",
+                             id="dev0", drive="cd0")
+        self.assert_qmp(result, 'return', {})
+
+        # Set I/O limits
+        args = { "id": "dev0", "iops": 100, "iops_rd": 0, "iops_wr": 0,
+                                "bps":  50,  "bps_rd": 0,  "bps_wr": 0 }
+        result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **args)
+        self.assert_qmp(result, 'return', {})
+
+        # Check that the I/O limits have been set
+        result = self.vm.qmp("query-block")
+        self.assert_qmp(result, 'return[0]/inserted/iops', 100)
+        self.assert_qmp(result, 'return[0]/inserted/bps',   50)
+
+        # Now eject cd0 and insert cd1
+        result = self.vm.qmp("blockdev-open-tray", id='dev0')
+        self.assert_qmp(result, 'return', {})
+        result = self.vm.qmp("x-blockdev-remove-medium", id='dev0')
+        self.assert_qmp(result, 'return', {})
+        result = self.vm.qmp("x-blockdev-insert-medium", id='dev0', node_name='cd1')
+        self.assert_qmp(result, 'return', {})
+
+        # Check that the I/O limits are still the same
+        result = self.vm.qmp("query-block")
+        self.assert_qmp(result, 'return[0]/inserted/iops', 100)
+        self.assert_qmp(result, 'return[0]/inserted/bps',   50)
+
+        # Eject cd1
+        result = self.vm.qmp("x-blockdev-remove-medium", id='dev0')
+        self.assert_qmp(result, 'return', {})
+
+        # Check that we can't set limits if the device has no medium
+        result = self.vm.qmp("block_set_io_throttle", conv_keys=False, **args)
+        self.assert_qmp(result, 'error/class', 'GenericError')
+
+        # Remove the CD drive
+        result = self.vm.qmp("device_del", id='dev0')
+        self.assert_qmp(result, 'return', {})
+
 
 if __name__ == '__main__':
     iotests.main(supported_fmts=["raw"])
diff --git a/tests/qemu-iotests/093.out b/tests/qemu-iotests/093.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/093.out
+++ b/tests/qemu-iotests/093.out
@@ -XXX,XX +XXX,XX @@
-.......
+........
 ----------------------------------------------------------------------
-Ran 7 tests
+Ran 8 tests
 
 OK
-- 
2.13.6

The following changes since commit 711c0418c8c1ce3a24346f058b001c4c5a2f0f81:

Merge remote-tracking branch 'remotes/philmd/tags/mips-20210702' into staging (2021-07-04 14:04:12 +0100)

are available in the Git repository at:

https://gitlab.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 9f460c64e13897117f35ffb61f6f5e0102cabc70:

block/io: Merge discard request alignments (2021-07-06 14:28:55 +0100)

----------------------------------------------------------------
Pull request

----------------------------------------------------------------

Akihiko Odaki (3):
  block/file-posix: Optimize for macOS
  block: Add backend_defaults property
  block/io: Merge discard request alignments

Stefan Hajnoczi (2):
  util/async: add a human-readable name to BHs for debugging
  util/async: print leaked BH name when AioContext finalizes

-- 
2.31.1

It can be difficult to debug issues with BHs in production environments.
Although BHs can usually be identified by looking up their ->cb()
function pointer, this requires debug information for the program. It is
also not possible to print human-readable diagnostics about BHs because
they have no identifier.

This patch adds a name to each BH. The name is not unique per instance
but differentiates between cb() functions, which is usually enough. It's
done by changing aio_bh_new() and friends to macros that stringify cb.

The next patch will use the name field when reporting leaked BHs.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-Id: <20210414200247.917496-2-stefanha@redhat.com>
---
 include/block/aio.h            | 31 ++++++++++++++++++++++++++++---
 include/qemu/main-loop.h       |  4 +++-
 tests/unit/ptimer-test-stubs.c |  2 +-
 util/async.c                   |  9 +++++++--
 util/main-loop.c               |  4 ++--
 5 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/include/block/aio.h b/include/block/aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ void aio_context_acquire(AioContext *ctx);
 /* Relinquish ownership of the AioContext. */
 void aio_context_release(AioContext *ctx);
 
+/**
+ * aio_bh_schedule_oneshot_full: Allocate a new bottom half structure that will
+ * run only once and as soon as possible.
+ *
+ * @name: A human-readable identifier for debugging purposes.
+ */
+void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
+                                  const char *name);
+
 /**
  * aio_bh_schedule_oneshot: Allocate a new bottom half structure that will run
  * only once and as soon as possible.
+ *
+ * A convenience wrapper for aio_bh_schedule_oneshot_full() that uses cb as the
+ * name string.
  */
-void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
+#define aio_bh_schedule_oneshot(ctx, cb, opaque) \
+    aio_bh_schedule_oneshot_full((ctx), (cb), (opaque), (stringify(cb)))
 
 /**
- * aio_bh_new: Allocate a new bottom half structure.
+ * aio_bh_new_full: Allocate a new bottom half structure.
  *
  * Bottom halves are lightweight callbacks whose invocation is guaranteed
  * to be wait-free, thread-safe and signal-safe.  The #QEMUBH structure
  * is opaque and must be allocated prior to its use.
+ *
+ * @name: A human-readable identifier for debugging purposes.
  */
-QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
+QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
+                        const char *name);
+
+/**
+ * aio_bh_new: Allocate a new bottom half structure
+ *
+ * A convenience wrapper for aio_bh_new_full() that uses the cb as the name
+ * string.
+ */
+#define aio_bh_new(ctx, cb, opaque) \
+    aio_bh_new_full((ctx), (cb), (opaque), (stringify(cb)))
 
 /**
  * aio_notify: Force processing of pending events.
diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/main-loop.h
+++ b/include/qemu/main-loop.h
@@ -XXX,XX +XXX,XX @@ void qemu_cond_timedwait_iothread(QemuCond *cond, int ms);
 
 void qemu_fd_register(int fd);
 
-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
+#define qemu_bh_new(cb, opaque) \
+    qemu_bh_new_full((cb), (opaque), (stringify(cb)))
+QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name);
 void qemu_bh_schedule_idle(QEMUBH *bh);
 
 enum {
diff --git a/tests/unit/ptimer-test-stubs.c b/tests/unit/ptimer-test-stubs.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/ptimer-test-stubs.c
+++ b/tests/unit/ptimer-test-stubs.c
@@ -XXX,XX +XXX,XX @@ int64_t qemu_clock_deadline_ns_all(QEMUClockType type, int attr_mask)
     return deadline;
 }
 
-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
+QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
 {
     QEMUBH *bh = g_new(QEMUBH, 1);
 
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ enum {
 
 struct QEMUBH {
     AioContext *ctx;
+    const char *name;
     QEMUBHFunc *cb;
     void *opaque;
     QSLIST_ENTRY(QEMUBH) next;
@@ -XXX,XX +XXX,XX @@ static QEMUBH *aio_bh_dequeue(BHList *head, unsigned *flags)
     return bh;
 }
 
-void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
+void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb,
+                                  void *opaque, const char *name)
 {
     QEMUBH *bh;
     bh = g_new(QEMUBH, 1);
@@ -XXX,XX +XXX,XX @@ void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
         .ctx = ctx,
         .cb = cb,
         .opaque = opaque,
+        .name = name,
     };
     aio_bh_enqueue(bh, BH_SCHEDULED | BH_ONESHOT);
 }
 
-QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
+QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
+                        const char *name)
 {
     QEMUBH *bh;
     bh = g_new(QEMUBH, 1);
@@ -XXX,XX +XXX,XX @@ QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
         .ctx = ctx,
         .cb = cb,
         .opaque = opaque,
+        .name = name,
     };
     return bh;
 }
diff --git a/util/main-loop.c b/util/main-loop.c
index XXXXXXX..XXXXXXX 100644
--- a/util/main-loop.c
+++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@ void main_loop_wait(int nonblocking)
 
 /* Functions to operate on the main QEMU AioContext.  */
 
-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
+QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
 {
-    return aio_bh_new(qemu_aio_context, cb, opaque);
+    return aio_bh_new_full(qemu_aio_context, cb, opaque, name);
 }
 
 /*
-- 
2.31.1

BHs must be deleted before the AioContext is finalized. If not, it's a
bug and probably indicates that some part of the program still expects
the BH to run in the future. That can lead to memory leaks, inconsistent
state, or just hangs.

Unfortunately the assert(flags & BH_DELETED) call in aio_ctx_finalize()
is difficult to debug because the assertion failure contains no
information about the BH!

Use the QEMUBH name field added in the previous patch to show a useful
error when a leaked BH is detected.

Suggested-by: Eric Ernst <eric.g.ernst@gmail.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20210414200247.917496-3-stefanha@redhat.com>
---
 util/async.c | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ aio_ctx_finalize(GSource     *source)
     assert(QSIMPLEQ_EMPTY(&ctx->bh_slice_list));
 
     while ((bh = aio_bh_dequeue(&ctx->bh_list, &flags))) {
-        /* qemu_bh_delete() must have been called on BHs in this AioContext */
-        assert(flags & BH_DELETED);
+        /*
+         * qemu_bh_delete() must have been called on BHs in this AioContext. In
+         * many cases memory leaks, hangs, or inconsistent state occur when a
+         * BH is leaked because something still expects it to run.
+         *
+         * If you hit this, fix the lifecycle of the BH so that
+         * qemu_bh_delete() and any associated cleanup is called before the
+         * AioContext is finalized.
+         */
+        if (unlikely(!(flags & BH_DELETED))) {
+            fprintf(stderr, "%s: BH '%s' leaked, aborting...\n",
+                    __func__, bh->name);
+            abort();
+        }
 
         g_free(bh);
     }
-- 
2.31.1

From: Akihiko Odaki <akihiko.odaki@gmail.com>

This commit introduces "punch hole" operation and optimizes transfer
block size for macOS.

Thanks to Konstantin Nazarov for detailed analysis of a flaw in an
old version of this change:
https://gist.github.com/akihikodaki/87df4149e7ca87f18dc56807ec5a1bc5#gistcomment-3654667

Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Message-id: 20210705130458.97642-1-akihiko.odaki@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/file-posix.c | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@
 #if defined(HAVE_HOST_BLOCK_DEVICE)
 #include <paths.h>
 #include <sys/param.h>
+#include <sys/mount.h>
 #include <IOKit/IOKitLib.h>
 #include <IOKit/IOBSD.h>
 #include <IOKit/storage/IOMediaBSDClient.h>
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
         return;
     }
 
+#if defined(__APPLE__) && (__MACH__)
+    struct statfs buf;
+
+    if (!fstatfs(s->fd, &buf)) {
+        bs->bl.opt_transfer = buf.f_iosize;
+        bs->bl.pdiscard_alignment = buf.f_bsize;
+    }
+#endif
+
     if (bs->sg || S_ISBLK(st.st_mode)) {
         int ret = hdev_get_max_hw_transfer(s->fd, &st);
 
@@ -XXX,XX +XXX,XX @@ out:
     }
 }
 
+#if defined(CONFIG_FALLOCATE) || defined(BLKZEROOUT) || defined(BLKDISCARD)
 static int translate_err(int err)
 {
     if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
@@ -XXX,XX +XXX,XX @@ static int translate_err(int err)
     }
     return err;
 }
+#endif
 
 #ifdef CONFIG_FALLOCATE
 static int do_fallocate(int fd, int mode, off_t offset, off_t len)
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_discard(void *opaque)
             }
         } while (errno == EINTR);
 
-        ret = -errno;
+        ret = translate_err(-errno);
 #endif
     } else {
 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
         ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
                            aiocb->aio_offset, aiocb->aio_nbytes);
+        ret = translate_err(-errno);
+#elif defined(__APPLE__) && (__MACH__)
+        fpunchhole_t fpunchhole;
+        fpunchhole.fp_flags = 0;
+        fpunchhole.reserved = 0;
+        fpunchhole.fp_offset = aiocb->aio_offset;
+        fpunchhole.fp_length = aiocb->aio_nbytes;
+        if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) {
+            ret = errno == ENODEV ? -ENOTSUP : -errno;
+        } else {
+            ret = 0;
+        }
 #endif
     }
 
-    ret = translate_err(ret);
     if (ret == -ENOTSUP) {
         s->has_discard = false;
     }
-- 
2.31.1

From: Akihiko Odaki <akihiko.odaki@gmail.com>

backend_defaults property allow users to control if default block
properties should be decided with backend information.

If it is off, any backend information will be discarded, which is
suitable if you plan to perform live migration to a different disk backend.

If it is on, a block device may utilize backend information more
aggressively.

By default, it is auto, which uses backend information for block
sizes and ignores the others, which is consistent with the older
versions.

Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Message-id: 20210705130458.97642-2-akihiko.odaki@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/block/block.h   |  3 +++
 hw/block/block.c           | 42 ++++++++++++++++++++++++++++++++++----
 tests/qemu-iotests/172.out | 38 ++++++++++++++++++++++++++++++++++
 3 files changed, 79 insertions(+), 4 deletions(-)

diff --git a/include/hw/block/block.h b/include/hw/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/block/block.h
+++ b/include/hw/block/block.h
@@ -XXX,XX +XXX,XX @@
 
 typedef struct BlockConf {
     BlockBackend *blk;
+    OnOffAuto backend_defaults;
     uint32_t physical_block_size;
     uint32_t logical_block_size;
     uint32_t min_io_size;
@@ -XXX,XX +XXX,XX @@ static inline unsigned int get_physical_block_exp(BlockConf *conf)
 }
 
 #define DEFINE_BLOCK_PROPERTIES_BASE(_state, _conf)                     \
+    DEFINE_PROP_ON_OFF_AUTO("backend_defaults", _state,                 \
+                            _conf.backend_defaults, ON_OFF_AUTO_AUTO),  \
     DEFINE_PROP_BLOCKSIZE("logical_block_size", _state,                 \
                           _conf.logical_block_size),                    \
     DEFINE_PROP_BLOCKSIZE("physical_block_size", _state,                \
diff --git a/hw/block/block.c b/hw/block/block.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/block.c
+++ b/hw/block/block.c
@@ -XXX,XX +XXX,XX @@ bool blkconf_blocksizes(BlockConf *conf, Error **errp)
 {
     BlockBackend *blk = conf->blk;
     BlockSizes blocksizes;
-    int backend_ret;
+    BlockDriverState *bs;
+    bool use_blocksizes;
+    bool use_bs;
+
+    switch (conf->backend_defaults) {
+    case ON_OFF_AUTO_AUTO:
+        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
+        use_bs = false;
+        break;
+
+    case ON_OFF_AUTO_ON:
+        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
+        bs = blk_bs(blk);
+        use_bs = bs;
+        break;
+
+    case ON_OFF_AUTO_OFF:
+        use_blocksizes = false;
+        use_bs = false;
+        break;
+
+    default:
+        abort();
+    }
 
-    backend_ret = blk_probe_blocksizes(blk, &blocksizes);
     /* fill in detected values if they are not defined via qemu command line */
     if (!conf->physical_block_size) {
-        if (!backend_ret) {
+        if (use_blocksizes) {
            conf->physical_block_size = blocksizes.phys;
         } else {
             conf->physical_block_size = BDRV_SECTOR_SIZE;
         }
     }
     if (!conf->logical_block_size) {
-        if (!backend_ret) {
+        if (use_blocksizes) {
             conf->logical_block_size = blocksizes.log;
         } else {
             conf->logical_block_size = BDRV_SECTOR_SIZE;
         }
     }
+    if (use_bs) {
+        if (!conf->opt_io_size) {
+            conf->opt_io_size = bs->bl.opt_transfer;
+        }
+        if (conf->discard_granularity == -1) {
+            if (bs->bl.pdiscard_alignment) {
+                conf->discard_granularity = bs->bl.pdiscard_alignment;
+            } else if (bs->bl.request_alignment != 1) {
+                conf->discard_granularity = bs->bl.request_alignment;
+            }
+        }
+    }
 
     if (conf->logical_block_size > conf->physical_block_size) {
         error_setg(errp,
diff --git a/tests/qemu-iotests/172.out b/tests/qemu-iotests/172.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/172.out
+++ b/tests/qemu-iotests/172.out
@@ -XXX,XX +XXX,XX @@ Testing:
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,unit=1
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -global floppy.drive=none0 -device
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=120
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=144
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=288
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,logical
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,physica
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
-- 
2.31.1