Series comparison

-[PULL 00/11] Block layer patches
+[PULL 00/23] Block layer patches
-The following changes since commit 2ccad61746ca7de5dd3e25146062264387e43bd4:
+The following changes since commit 52ed34cbddde1cb89b2ac263e758e349a77f21e1:
-  Merge tag 'pull-tcg-20221109' of https://gitlab.com/rth7680/qemu into staging (2022-11-09 13:26:45 -0500)
+  Merge tag 'pull-request-2023-06-26' of https://gitlab.com/thuth/qemu into staging (2023-06-26 10:38:41 +0200)
 are available in the Git repository at:
   https://repo.or.cz/qemu/kevin.git tags/for-upstream
-for you to fetch changes up to b04af371af685c12970ea93027dc6d8bf86265aa:
+for you to fetch changes up to 17362398ee1a7f04e8006a46333145d8b707fd35:
-  tests/stream-under-throttle: New test (2022-11-11 13:02:43 +0100)
+  block: use bdrv_co_debug_event in coroutine context (2023-06-28 09:46:34 +0200)
 ----------------------------------------------------------------
 Block layer patches
-- Fix deadlock in graph modification with iothreads
+- Re-enable the graph lock
-- mirror: Fix non-converging cases for active mirror
+- More fixes to coroutine_fn marking
 - qapi: Fix BlockdevOptionsNvmeIoUring @path description
 - blkio: Set BlockDriver::has_variable_length to false
 ----------------------------------------------------------------
-Alberto Faria (2):
+Kevin Wolf (11):
-      qapi/block-core: Fix BlockdevOptionsNvmeIoUring @path description
+      iotests: Test active commit with iothread and background I/O
-      block/blkio: Set BlockDriver::has_variable_length to false
+      qdev-properties-system: Lock AioContext for blk_insert_bs()
       test-block-iothread: Lock AioContext for blk_insert_bs()
       block: Fix AioContext locking in bdrv_open_child()
       block: Fix AioContext locking in bdrv_attach_child_common()
       block: Fix AioContext locking in bdrv_reopen_parse_file_or_backing()
       block: Fix AioContext locking in bdrv_open_inherit()
       block: Fix AioContext locking in bdrv_open_backing_file()
       blockjob: Fix AioContext locking in block_job_add_bdrv()
       graph-lock: Unlock the AioContext while polling
       Revert "graph-lock: Disable locking for now"
-Hanna Reitz (9):
+Paolo Bonzini (12):
-      block/mirror: Do not wait for active writes
+      file-posix: remove incorrect coroutine_fn calls
-      block/mirror: Drop mirror_wait_for_any_operation()
+      qed: mark more functions as coroutine_fns and GRAPH_RDLOCK
-      block/mirror: Fix NULL s->job in active writes
+      vpc: mark more functions as coroutine_fns and GRAPH_RDLOCK
-      iotests/151: Test that active mirror progresses
+      bochs: mark more functions as coroutine_fns and GRAPH_RDLOCK
-      iotests/151: Test active requests on mirror start
+      block: mark another function as coroutine_fns and GRAPH_UNLOCKED
-      block: Make bdrv_child_get_parent_aio_context I/O
+      cloop: mark more functions as coroutine_fns and GRAPH_RDLOCK
-      block-backend: Update ctx immediately after root
+      dmg: mark more functions as coroutine_fns and GRAPH_RDLOCK
-      block: Start/end drain on correct AioContext
+      vmdk: mark more functions as coroutine_fns and GRAPH_RDLOCK
-      tests/stream-under-throttle: New test
+      vhdx: mark more functions as coroutine_fns and GRAPH_RDLOCK
       qcow2: mark more functions as coroutine_fns and GRAPH_RDLOCK
       block: use bdrv_co_getlength in coroutine context
       block: use bdrv_co_debug_event in coroutine context
- qapi/block-core.json                               |   2 +-
+ block/qcow2.h                                      |  33 +++--
- include/block/block-global-state.h                 |   1 -
+ block/vhdx.h                                       |   5 +-
- include/block/block-io.h                           |   2 +
+ include/block/block-io.h                           |   7 ++
- include/block/block_int-common.h                   |   4 +-
+ include/block/graph-lock.h                         |   6 +-
- block.c                                            |   2 +-
+ block.c                                            | 114 ++++++++++++++++--
- block/blkio.c                                      |   1 -
+ block/bochs.c                                      |   7 +-
- block/block-backend.c                              |   9 +-
+ block/cloop.c                                      |   9 +-
- block/io.c                                         |   6 +-
+ block/dmg.c                                        |  21 ++--
- block/mirror.c                                     |  78 ++++---
+ block/file-posix.c                                 |  29 +++--
- blockjob.c                                         |   3 +-
+ block/graph-lock.c                                 |  43 +++----
- tests/qemu-iotests/151                             | 227 ++++++++++++++++++++-
+ block/io.c                                         |  14 +--
- tests/qemu-iotests/151.out                         |   4 +-
+ block/parallels.c                                  |   4 +-
- tests/qemu-iotests/tests/stream-under-throttle     | 121 +++++++++++
+ block/qcow.c                                       |  30 ++---
- tests/qemu-iotests/tests/stream-under-throttle.out |   5 +
+ block/qcow2-bitmap.c                               |  26 ++--
-files changed, 424 insertions(+), 41 deletions(-)
+ block/qcow2-cluster.c                              |  24 ++--
- create mode 100755 tests/qemu-iotests/tests/stream-under-throttle
+ block/qcow2-refcount.c                             | 134 +++++++++++----------
- create mode 100644 tests/qemu-iotests/tests/stream-under-throttle.out
+ block/qcow2.c                                      |  20 +--
  block/qed-check.c                                  |   5 +-
  block/qed-table.c                                  |   6 +-
  block/qed.c                                        |  15 +--
  block/raw-format.c                                 |   4 +-
  block/vhdx-log.c                                   |  36 +++---
  block/vhdx.c                                       |  73 ++++++-----
  block/vmdk.c                                       |  55 ++++-----
  block/vpc.c                                        |  52 ++++----
  blockjob.c                                         |  17 ++-
  hw/core/qdev-properties-system.c                   |   8 +-
  tests/unit/test-block-iothread.c                   |   7 +-
  tests/qemu-iotests/tests/iothreads-commit-active   |  85 +++++++++++++
  .../qemu-iotests/tests/iothreads-commit-active.out |  23 ++++
 files changed, 573 insertions(+), 339 deletions(-)
  create mode 100755 tests/qemu-iotests/tests/iothreads-commit-active
  create mode 100644 tests/qemu-iotests/tests/iothreads-commit-active.out

-[PULL 11/11] tests/stream-under-throttle: New test
+[PULL 01/23] iotests: Test active commit with iothread and background I/O
-From: Hanna Reitz <hreitz@redhat.com>
+This is a better regression test for the bugs hidden by commit 80fc5d26
 ('graph-lock: Disable locking for now'). With that commit reverted, it
 hangs instantaneously and reliably for me.
-Test streaming a base image into the top image underneath two throttle
+It is important to have a reliable test like this, because the following
-nodes.  This was reported to make qemu 7.1 hang
+commits will set out to fix the actual root cause of the deadlocks and
-(https://gitlab.com/qemu-project/qemu/-/issues/1215), so this serves as
+then finally revert commit 80fc5d26, which was only a stopgap solution.
 a regression test.
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Message-Id: <20221110160921.33158-1-hreitz@redhat.com>
+Message-ID: <20230605085711.21261-2-kwolf@redhat.com>
-Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- .../qemu-iotests/tests/stream-under-throttle  | 121 ++++++++++++++++++
+ .../tests/iothreads-commit-active             | 85 +++++++++++++++++++
- .../tests/stream-under-throttle.out           |   5 +
+ .../tests/iothreads-commit-active.out         | 23 +++++
-files changed, 126 insertions(+)
+files changed, 108 insertions(+)
- create mode 100755 tests/qemu-iotests/tests/stream-under-throttle
+ create mode 100755 tests/qemu-iotests/tests/iothreads-commit-active
- create mode 100644 tests/qemu-iotests/tests/stream-under-throttle.out
+ create mode 100644 tests/qemu-iotests/tests/iothreads-commit-active.out
-diff --git a/tests/qemu-iotests/tests/stream-under-throttle b/tests/qemu-iotests/tests/stream-under-throttle
+diff --git a/tests/qemu-iotests/tests/iothreads-commit-active b/tests/qemu-iotests/tests/iothreads-commit-active
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/tests/stream-under-throttle
++++ b/tests/qemu-iotests/tests/iothreads-commit-active
 @@ -XXX,XX +XXX,XX @@
 +#!/usr/bin/env python3
-+# group: rw
++# group: rw quick auto
 +#
-+# Test streaming with throttle nodes on top
++# Copyright (C) 2023 Red Hat, Inc.
 +#
 +# Copyright (C) 2022 Red Hat, Inc.
 +#
 +# This program is free software; you can redistribute it and/or modify
 +# it under the terms of the GNU General Public License as published by
 +# the Free Software Foundation; either version 2 of the License, or
 +# (at your option) any later version.
 ...
 +# 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 asyncio
-+import os
-+from typing import List
 +import iotests
-+from iotests import qemu_img_create, qemu_io
 +
++iotests.script_initialize(supported_fmts=['qcow2'],
++                          supported_platforms=['linux'])
++iotests.verify_virtio_scsi_pci_or_ccw()
 +
-+image_size = 256 * 1024 * 1024
++with iotests.FilePath('disk0.img') as img_path, \
-+base_img = os.path.join(iotests.test_dir, 'base.img')
++     iotests.FilePath('disk0-snap.img') as snap_path, \
-+top_img = os.path.join(iotests.test_dir, 'top.img')
++     iotests.FilePath('mirror-src.img') as src_path, \
 +     iotests.FilePath('mirror-dst.img') as dst_path, \
 +     iotests.VM() as vm:
 +
++    img_size = '10M'
++    iotests.qemu_img_create('-f', iotests.imgfmt, img_path, img_size)
++    iotests.qemu_img_create('-f', iotests.imgfmt, '-b', img_path,
++                            '-F', iotests.imgfmt, snap_path)
++    iotests.qemu_img_create('-f', iotests.imgfmt, src_path, img_size)
++    iotests.qemu_img_create('-f', iotests.imgfmt, dst_path, img_size)
 +
-+class TcgVM(iotests.VM):
++    iotests.qemu_io_log('-c', 'write 0 64k', img_path)
-+    '''
++    iotests.qemu_io_log('-c', 'write 1M 64k', snap_path)
-+    Variant of iotests.VM that uses -accel tcg.  Simply using
++    iotests.qemu_io_log('-c', 'write 3M 64k', snap_path)
 +    iotests.VM.add_args('-accel', 'tcg') is not sufficient, because that will
 +    put -accel qtest before -accel tcg, and -accel arguments are prioritized in
 +    the order they appear.
 +    '''
 +    @property
 +    def _base_args(self) -> List[str]:
 +        # Put -accel tcg first so it takes precedence
 +        return ['-accel', 'tcg'] + super()._base_args
 +
++    iotests.qemu_io_log('-c', f'write 0 {img_size}', src_path)
 +
-+class TestStreamWithThrottle(iotests.QMPTestCase):
++    iotests.log('Launching VM...')
-+    def setUp(self) -> None:
++    vm.add_object('iothread,id=iothread0')
-+        '''
++    vm.add_object('throttle-group,x-bps-write=1048576,id=tg0')
-+        Create a simple backing chain between two images, write something to
++    vm.add_blockdev(f'file,node-name=disk0-file,filename={img_path}')
-+        the base image.  Attach them to the VM underneath two throttle nodes,
++    vm.add_blockdev('qcow2,node-name=disk0-fmt,file=disk0-file')
-+        one of which has actually no limits set, but the other does.  Then put
++    vm.add_drive(snap_path, 'backing=disk0-fmt,node-name=disk0',
-+        a virtio-blk device on top.
++                 interface='none')
-+        This test configuration has been taken from
++    vm.add_device('virtio-scsi,iothread=iothread0')
-+        https://gitlab.com/qemu-project/qemu/-/issues/1215
++    vm.add_device('scsi-hd,drive=drive0')
 +        '''
 +        qemu_img_create('-f', iotests.imgfmt, base_img, str(image_size))
 +        qemu_img_create('-f', iotests.imgfmt, '-b', base_img, '-F',
 +                        iotests.imgfmt, top_img, str(image_size))
 +
-+        # Write something to stream
++    vm.add_blockdev(f'file,filename={src_path},node-name=mirror-src-file')
-+        qemu_io(base_img, '-c', f'write 0 {image_size}')
++    vm.add_blockdev('qcow2,file=mirror-src-file,node-name=mirror-src')
 +    vm.add_blockdev(f'file,filename={dst_path},node-name=mirror-dst-file')
 +    vm.add_blockdev('qcow2,file=mirror-dst-file,node-name=mirror-dst-fmt')
 +    vm.add_blockdev('throttle,throttle-group=tg0,file=mirror-dst-fmt,'
 +                    'node-name=mirror-dst')
 +    vm.add_device('scsi-hd,drive=mirror-src')
 +
-+        blockdev = {
++    vm.launch()
 +            'driver': 'throttle',
 +            'node-name': 'throttled-node',
 +            'throttle-group': 'thrgr-limited',
 +            'file': {
 +                'driver': 'throttle',
 +                'throttle-group': 'thrgr-unlimited',
 +                'file': {
 +                    'driver': iotests.imgfmt,
 +                    'node-name': 'unthrottled-node',
 +                    'file': {
 +                        'driver': 'file',
 +                        'filename': top_img
 +                    }
 +                }
 +            }
 +        }
 +
-+        # Issue 1215 is not reproducible in qtest mode, which is why we need to
++    # The background I/O is created on unrelated nodes (so that they won't be
-+        # create an -accel tcg VM
++    # drained together with the other ones), but on the same iothread
-+        self.vm = TcgVM()
++    iotests.log('Creating some background I/O...')
-+        self.vm.add_object('iothread,id=iothr0')
++    iotests.log(vm.qmp('blockdev-mirror', job_id='job0', sync='full',
-+        self.vm.add_object('throttle-group,id=thrgr-unlimited')
++                       device='mirror-src', target='mirror-dst',
-+        self.vm.add_object('throttle-group,id=thrgr-limited,'
++                       auto_dismiss=False))
 +                           'x-iops-total=10000,x-bps-total=104857600')
 +        self.vm.add_blockdev(self.vm.qmp_to_opts(blockdev))
 +        self.vm.add_device('virtio-blk,iothread=iothr0,drive=throttled-node')
 +        self.vm.launch()
 +
-+    def tearDown(self) -> None:
++    iotests.log('Starting active commit...')
-+        self.vm.shutdown()
++    iotests.log(vm.qmp('block-commit', device='disk0', job_id='job1',
-+        os.remove(top_img)
++                       auto_dismiss=False))
 +        os.remove(base_img)
 +
-+    def test_stream(self) -> None:
++    # Should succeed and not time out
-+        '''
++    try:
-+        Do a simple stream beneath the two throttle nodes.  Should complete
++        vm.run_job('job1', wait=5.0)
-+        with no problems.
++        vm.shutdown()
-+        '''
++    except asyncio.TimeoutError:
-+        result = self.vm.qmp('block-stream',
++        # VM may be stuck, kill it
-+                             job_id='stream',
++        vm.kill()
-+                             device='unthrottled-node')
++        raise
-+        self.assert_qmp(result, 'return', {})
+diff --git a/tests/qemu-iotests/tests/iothreads-commit-active.out b/tests/qemu-iotests/tests/iothreads-commit-active.out
 +
 +        # Should succeed and not time out
 +        try:
 +            self.vm.run_job('stream')
 +        except asyncio.exceptions.TimeoutError:
 +            # VM may be stuck, kill it before tearDown()
 +            self.vm.kill()
 +            raise
 +
 +
 +if __name__ == '__main__':
 +    # Must support backing images
 +    iotests.main(supported_fmts=['qcow', 'qcow2', 'qed'],
 +                 supported_protocols=['file'],
 +                 required_fmts=['throttle'])
 diff --git a/tests/qemu-iotests/tests/stream-under-throttle.out b/tests/qemu-iotests/tests/stream-under-throttle.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/tests/stream-under-throttle.out
++++ b/tests/qemu-iotests/tests/iothreads-commit-active.out
 @@ -XXX,XX +XXX,XX @@
-+.
++wrote 65536/65536 bytes at offset 0
-+----------------------------------------------------------------------
++64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +Ran 1 tests
 +
-+OK
++wrote 65536/65536 bytes at offset 1048576
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +wrote 65536/65536 bytes at offset 3145728
 +64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +wrote 10485760/10485760 bytes at offset 0
 +10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +
 +Launching VM...
 +Creating some background I/O...
 +{"return": {}}
 +Starting active commit...
 +{"return": {}}
 +{"execute": "job-complete", "arguments": {"id": "job1"}}
 +{"return": {}}
 +{"data": {"device": "job1", "len": 131072, "offset": 131072, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"data": {"device": "job1", "len": 131072, "offset": 131072, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
 +{"execute": "job-dismiss", "arguments": {"id": "job1"}}
 +{"return": {}}
 --
-.38.1
+.41.0

-New patch
+[PULL 02/23] qdev-properties-system: Lock AioContext for blk_insert_bs()
+blk_insert_bs() requires that callers hold the AioContext lock for the
+node that should be inserted. Take it.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20230605085711.21261-3-kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ hw/core/qdev-properties-system.c | 8 ++++++--
+file changed, 6 insertions(+), 2 deletions(-)
+diff --git a/hw/core/qdev-properties-system.c b/hw/core/qdev-properties-system.c
+index XXXXXXX..XXXXXXX 100644
+--- a/hw/core/qdev-properties-system.c
++++ b/hw/core/qdev-properties-system.c
+@@ -XXX,XX +XXX,XX @@ static void set_drive_helper(Object *obj, Visitor *v, const char *name,
+              * aware of iothreads require their BlockBackends to be in the main
+              * AioContext.
+              */
+-            ctx = iothread ? bdrv_get_aio_context(bs) : qemu_get_aio_context();
+-            blk = blk_new(ctx, 0, BLK_PERM_ALL);
++            ctx = bdrv_get_aio_context(bs);
++            blk = blk_new(iothread ? ctx : qemu_get_aio_context(),
++                          0, BLK_PERM_ALL);
+             blk_created = true;
++            aio_context_acquire(ctx);
+             ret = blk_insert_bs(blk, bs, errp);
++            aio_context_release(ctx);
++
+             if (ret < 0) {
+                 goto fail;
+             }
+--
+.41.0

-New patch
+[PULL 03/23] test-block-iothread: Lock AioContext for blk_insert_bs()
+blk_insert_bs() requires that callers hold the AioContext lock for the
+node that should be inserted. Take it.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20230605085711.21261-4-kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/unit/test-block-iothread.c | 7 ++++++-
+file changed, 6 insertions(+), 1 deletion(-)
+diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/unit/test-block-iothread.c
++++ b/tests/unit/test-block-iothread.c
+@@ -XXX,XX +XXX,XX @@ static void test_attach_second_node(void)
+     BlockDriverState *bs, *filter;
+     QDict *options;
++    aio_context_acquire(main_ctx);
+     blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
+     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
+     blk_insert_bs(blk, bs, &error_abort);
+@@ -XXX,XX +XXX,XX @@ static void test_attach_second_node(void)
+     qdict_put_str(options, "driver", "raw");
+     qdict_put_str(options, "file", "base");
+-    aio_context_acquire(main_ctx);
+     filter = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
+     aio_context_release(main_ctx);
+@@ -XXX,XX +XXX,XX @@ static void test_attach_preserve_blk_ctx(void)
+ {
+     IOThread *iothread = iothread_new();
+     AioContext *ctx = iothread_get_aio_context(iothread);
++    AioContext *main_ctx = qemu_get_aio_context();
+     BlockBackend *blk;
+     BlockDriverState *bs;
++    aio_context_acquire(main_ctx);
+     blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
+     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
+     bs->total_sectors = 65536 / BDRV_SECTOR_SIZE;
+@@ -XXX,XX +XXX,XX @@ static void test_attach_preserve_blk_ctx(void)
+     blk_insert_bs(blk, bs, &error_abort);
+     g_assert(blk_get_aio_context(blk) == ctx);
+     g_assert(bdrv_get_aio_context(bs) == ctx);
++    aio_context_release(main_ctx);
+     /* Remove the node again */
+     aio_context_acquire(ctx);
+@@ -XXX,XX +XXX,XX @@ static void test_attach_preserve_blk_ctx(void)
+     g_assert(bdrv_get_aio_context(bs) == qemu_get_aio_context());
+     /* Re-attach the node */
++    aio_context_acquire(main_ctx);
+     blk_insert_bs(blk, bs, &error_abort);
++    aio_context_release(main_ctx);
+     g_assert(blk_get_aio_context(blk) == ctx);
+     g_assert(bdrv_get_aio_context(bs) == ctx);
+--
+.41.0

-New patch
+[PULL 04/23] block: Fix AioContext locking in bdrv_open_child()
+bdrv_attach_child() requires that the caller holds the AioContext lock
+for the new child node. Take it in bdrv_open_child() and document that
+the caller must not hold any AioContext apart from the main AioContext.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20230605085711.21261-5-kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block.c | 13 +++++++++++--
+file changed, 11 insertions(+), 2 deletions(-)
+diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block.c
++++ b/block.c
+@@ -XXX,XX +XXX,XX @@ done:
+  *
+  * The BlockdevRef will be removed from the options QDict.
+  *
++ * The caller must hold the lock of the main AioContext and no other AioContext.
+  * @parent can move to a different AioContext in this function. Callers must
+  * make sure that their AioContext locking is still correct after this.
+  */
+@@ -XXX,XX +XXX,XX @@ BdrvChild *bdrv_open_child(const char *filename,
+                            bool allow_none, Error **errp)
+ {
+     BlockDriverState *bs;
++    BdrvChild *child;
++    AioContext *ctx;
+     GLOBAL_STATE_CODE();
+@@ -XXX,XX +XXX,XX @@ BdrvChild *bdrv_open_child(const char *filename,
+         return NULL;
+     }
+-    return bdrv_attach_child(parent, bs, bdref_key, child_class, child_role,
+-                             errp);
++    ctx = bdrv_get_aio_context(bs);
++    aio_context_acquire(ctx);
++    child = bdrv_attach_child(parent, bs, bdref_key, child_class, child_role,
++                              errp);
++    aio_context_release(ctx);
++
++    return child;
+ }
+ /*
+  * Wrapper on bdrv_open_child() for most popular case: open primary child of bs.
+  *
++ * The caller must hold the lock of the main AioContext and no other AioContext.
+  * @parent can move to a different AioContext in this function. Callers must
+  * make sure that their AioContext locking is still correct after this.
+  */
+--
+.41.0

-New patch
+[PULL 05/23] block: Fix AioContext locking in bdrv_attach_child_common()
+The function can move the child node to a different AioContext. In this
+case, it also must take the AioContext lock for the new context before
+calling functions that require the caller to hold the AioContext for the
+child node.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20230605085711.21261-6-kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block.c | 21 ++++++++++++++++++++-
+file changed, 20 insertions(+), 1 deletion(-)
+diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block.c
++++ b/block.c
+@@ -XXX,XX +XXX,XX @@ static TransactionActionDrv bdrv_attach_child_common_drv = {
+  * Function doesn't update permissions, caller is responsible for this.
+  *
+  * Returns new created child.
++ *
++ * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
++ * @child_bs can move to a different AioContext in this function. Callers must
++ * make sure that their AioContext locking is still correct after this.
+  */
+ static BdrvChild *bdrv_attach_child_common(BlockDriverState *child_bs,
+                                            const char *child_name,
+@@ -XXX,XX +XXX,XX @@ static BdrvChild *bdrv_attach_child_common(BlockDriverState *child_bs,
+                                            Transaction *tran, Error **errp)
+ {
+     BdrvChild *new_child;
+-    AioContext *parent_ctx;
++    AioContext *parent_ctx, *new_child_ctx;
+     AioContext *child_ctx = bdrv_get_aio_context(child_bs);
+     assert(child_class->get_parent_desc);
+@@ -XXX,XX +XXX,XX @@ static BdrvChild *bdrv_attach_child_common(BlockDriverState *child_bs,
+         }
+     }
++    new_child_ctx = bdrv_get_aio_context(child_bs);
++    if (new_child_ctx != child_ctx) {
++        aio_context_release(child_ctx);
++        aio_context_acquire(new_child_ctx);
++    }
++
+     bdrv_ref(child_bs);
+     /*
+      * Let every new BdrvChild start with a drained parent. Inserting the child
+@@ -XXX,XX +XXX,XX @@ static BdrvChild *bdrv_attach_child_common(BlockDriverState *child_bs,
+     };
+     tran_add(tran, &bdrv_attach_child_common_drv, s);
++    if (new_child_ctx != child_ctx) {
++        aio_context_release(new_child_ctx);
++        aio_context_acquire(child_ctx);
++    }
++
+     return new_child;
+ }
+ /*
+  * Function doesn't update permissions, caller is responsible for this.
++ *
++ * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
++ * @child_bs can move to a different AioContext in this function. Callers must
++ * make sure that their AioContext locking is still correct after this.
+  */
+ static BdrvChild *bdrv_attach_child_noperm(BlockDriverState *parent_bs,
+                                            BlockDriverState *child_bs,
+--
+.41.0

-New patch
+[PULL 06/23] block: Fix AioContext locking in bdrv_reopen_parse_file_or_backing()
+bdrv_set_file_or_backing_noperm() requires the caller to hold the
+AioContext lock for the child node, but we hold the one for the parent
+node in bdrv_reopen_parse_file_or_backing(). Take the other one
+temporarily.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20230605085711.21261-7-kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block.c | 35 +++++++++++++++++++++++++++++++++--
+file changed, 33 insertions(+), 2 deletions(-)
+diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block.c
++++ b/block.c
+@@ -XXX,XX +XXX,XX @@ static BdrvChildRole bdrv_backing_role(BlockDriverState *bs)
+  * callers which don't need their own reference any more must call bdrv_unref().
+  *
+  * Function doesn't update permissions, caller is responsible for this.
++ *
++ * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
++ * @child_bs can move to a different AioContext in this function. Callers must
++ * make sure that their AioContext locking is still correct after this.
+  */
+ static int bdrv_set_file_or_backing_noperm(BlockDriverState *parent_bs,
+                                            BlockDriverState *child_bs,
+@@ -XXX,XX +XXX,XX @@ out:
+     return 0;
+ }
++/*
++ * The caller must hold the AioContext lock for @backing_hd. Both @bs and
++ * @backing_hd can move to a different AioContext in this function. Callers must
++ * make sure that their AioContext locking is still correct after this.
++ */
+ static int bdrv_set_backing_noperm(BlockDriverState *bs,
+                                    BlockDriverState *backing_hd,
+                                    Transaction *tran, Error **errp)
+@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
+  * backing BlockDriverState (or NULL).
+  *
+  * Return 0 on success, otherwise return < 0 and set @errp.
++ *
++ * The caller must hold the AioContext lock of @reopen_state->bs.
++ * @reopen_state->bs can move to a different AioContext in this function.
++ * Callers must make sure that their AioContext locking is still correct after
++ * this.
+  */
+ static int bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,
+                                              bool is_backing, Transaction *tran,
+@@ -XXX,XX +XXX,XX @@ static int bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,
+     const char *child_name = is_backing ? "backing" : "file";
+     QObject *value;
+     const char *str;
++    AioContext *ctx, *old_ctx;
++    int ret;
+     GLOBAL_STATE_CODE();
+@@ -XXX,XX +XXX,XX @@ static int bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,
+         reopen_state->old_file_bs = old_child_bs;
+     }
+-    return bdrv_set_file_or_backing_noperm(bs, new_child_bs, is_backing,
+-                                           tran, errp);
++    old_ctx = bdrv_get_aio_context(bs);
++    ctx = bdrv_get_aio_context(new_child_bs);
++    if (old_ctx != ctx) {
++        aio_context_release(old_ctx);
++        aio_context_acquire(ctx);
++    }
++
++    ret = bdrv_set_file_or_backing_noperm(bs, new_child_bs, is_backing,
++                                          tran, errp);
++
++    if (old_ctx != ctx) {
++        aio_context_release(ctx);
++        aio_context_acquire(old_ctx);
++    }
++
++    return ret;
+ }
+ /*
+@@ -XXX,XX +XXX,XX @@ static int bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,
+  * It is the responsibility of the caller to then call the abort() or
+  * commit() for any other BDS that have been left in a prepare() state
+  *
++ * The caller must hold the AioContext lock of @reopen_state->bs.
+  */
+ static int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
+                                BlockReopenQueue *queue,
+--
+.41.0

-New patch
+[PULL 07/23] block: Fix AioContext locking in bdrv_open_inherit()
+bdrv_open_inherit() calls several functions for which it needs to hold
+the AioContext lock, but currently doesn't. This includes calls in
+bdrv_append_temp_snapshot(), for which bdrv_open_inherit() is the only
+caller. Fix the locking in these places.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20230605085711.21261-8-kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block.c | 25 ++++++++++++++++++++++++-
+file changed, 24 insertions(+), 1 deletion(-)
+diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block.c
++++ b/block.c
+@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
+     int64_t total_size;
+     QemuOpts *opts = NULL;
+     BlockDriverState *bs_snapshot = NULL;
++    AioContext *ctx = bdrv_get_aio_context(bs);
+     int ret;
+     GLOBAL_STATE_CODE();
+@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
+        instead of opening 'filename' directly */
+     /* Get the required size from the image */
++    aio_context_acquire(ctx);
+     total_size = bdrv_getlength(bs);
++    aio_context_release(ctx);
++
+     if (total_size < 0) {
+         error_setg_errno(errp, -total_size, "Could not get image size");
+         goto out;
+@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
+         goto out;
+     }
++    aio_context_acquire(ctx);
+     ret = bdrv_append(bs_snapshot, bs, errp);
++    aio_context_release(ctx);
++
+     if (ret < 0) {
+         bs_snapshot = NULL;
+         goto out;
+@@ -XXX,XX +XXX,XX @@ bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
+     Error *local_err = NULL;
+     QDict *snapshot_options = NULL;
+     int snapshot_flags = 0;
++    AioContext *ctx = qemu_get_aio_context();
+     assert(!child_class || !flags);
+     assert(!child_class == !parent);
+@@ -XXX,XX +XXX,XX @@ bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
+             /* Not requesting BLK_PERM_CONSISTENT_READ because we're only
+              * looking at the header to guess the image format. This works even
+              * in cases where a guest would not see a consistent state. */
+-            file = blk_new(bdrv_get_aio_context(file_bs), 0, BLK_PERM_ALL);
++            ctx = bdrv_get_aio_context(file_bs);
++            aio_context_acquire(ctx);
++            file = blk_new(ctx, 0, BLK_PERM_ALL);
+             blk_insert_bs(file, file_bs, &local_err);
+             bdrv_unref(file_bs);
++            aio_context_release(ctx);
++
+             if (local_err) {
+                 goto fail;
+             }
+@@ -XXX,XX +XXX,XX @@ bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
+         goto fail;
+     }
++    /* The AioContext could have changed during bdrv_open_common() */
++    ctx = bdrv_get_aio_context(bs);
++
+     if (file) {
++        aio_context_acquire(ctx);
+         blk_unref(file);
++        aio_context_release(ctx);
+         file = NULL;
+     }
+@@ -XXX,XX +XXX,XX @@ bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
+          * (snapshot_bs); thus, we have to drop the strong reference to bs
+          * (which we obtained by calling bdrv_new()). bs will not be deleted,
+          * though, because the overlay still has a reference to it. */
++        aio_context_acquire(ctx);
+         bdrv_unref(bs);
++        aio_context_release(ctx);
+         bs = snapshot_bs;
+     }
+     return bs;
+ fail:
++    aio_context_acquire(ctx);
+     blk_unref(file);
+     qobject_unref(snapshot_options);
+     qobject_unref(bs->explicit_options);
+@@ -XXX,XX +XXX,XX @@ fail:
+     bs->options = NULL;
+     bs->explicit_options = NULL;
+     bdrv_unref(bs);
++    aio_context_release(ctx);
+     error_propagate(errp, local_err);
+     return NULL;
+ close_and_fail:
++    aio_context_acquire(ctx);
+     bdrv_unref(bs);
++    aio_context_release(ctx);
+     qobject_unref(snapshot_options);
+     qobject_unref(options);
+     error_propagate(errp, local_err);
+--
+.41.0

-New patch
+[PULL 08/23] block: Fix AioContext locking in bdrv_open_backing_file()
+bdrv_set_backing() requires the caller to hold the AioContext lock for
+@backing_hd. Take it in bdrv_open_backing_file() before calling the
+function.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20230605085711.21261-9-kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@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 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
+     int ret = 0;
+     bool implicit_backing = false;
+     BlockDriverState *backing_hd;
++    AioContext *backing_hd_ctx;
+     QDict *options;
+     QDict *tmp_parent_options = NULL;
+     Error *local_err = NULL;
+@@ -XXX,XX +XXX,XX @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
+     /* Hook up the backing file link; drop our reference, bs owns the
+      * backing_hd reference now */
++    backing_hd_ctx = bdrv_get_aio_context(backing_hd);
++    aio_context_acquire(backing_hd_ctx);
+     ret = bdrv_set_backing_hd(bs, backing_hd, errp);
+     bdrv_unref(backing_hd);
++    aio_context_release(backing_hd_ctx);
++
+     if (ret < 0) {
+         goto free_exit;
+     }
+--
+.41.0

-New patch
+[PULL 09/23] blockjob: Fix AioContext locking in block_job_add_bdrv()
+bdrv_root_attach_child() requires callers to hold the AioContext lock
+for child_bs. Take it in block_job_add_bdrv() before calling the
+function.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20230605085711.21261-10-kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ blockjob.c | 17 ++++++++++++-----
+file changed, 12 insertions(+), 5 deletions(-)
+diff --git a/blockjob.c b/blockjob.c
+index XXXXXXX..XXXXXXX 100644
+--- a/blockjob.c
++++ b/blockjob.c
+@@ -XXX,XX +XXX,XX @@ int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,
+                        uint64_t perm, uint64_t shared_perm, Error **errp)
+ {
+     BdrvChild *c;
++    AioContext *ctx = bdrv_get_aio_context(bs);
+     bool need_context_ops;
+     GLOBAL_STATE_CODE();
+     bdrv_ref(bs);
+-    need_context_ops = bdrv_get_aio_context(bs) != job->job.aio_context;
++    need_context_ops = ctx != job->job.aio_context;
+-    if (need_context_ops && job->job.aio_context != qemu_get_aio_context()) {
+-        aio_context_release(job->job.aio_context);
++    if (need_context_ops) {
++        if (job->job.aio_context != qemu_get_aio_context()) {
++            aio_context_release(job->job.aio_context);
++        }
++        aio_context_acquire(ctx);
+     }
+     c = bdrv_root_attach_child(bs, name, &child_job, 0, perm, shared_perm, job,
+                                errp);
+-    if (need_context_ops && job->job.aio_context != qemu_get_aio_context()) {
+-        aio_context_acquire(job->job.aio_context);
++    if (need_context_ops) {
++        aio_context_release(ctx);
++        if (job->job.aio_context != qemu_get_aio_context()) {
++            aio_context_acquire(job->job.aio_context);
++        }
+     }
+     if (c == NULL) {
+         return -EPERM;
+--
+.41.0

-New patch
+[PULL 10/23] graph-lock: Unlock the AioContext while polling
+If the caller keeps the AioContext lock for a block node in an iothread,
+polling in bdrv_graph_wrlock() deadlocks if the condition isn't
+fulfilled immediately.
+Now that all callers make sure to actually have the AioContext locked
+when they call bdrv_replace_child_noperm() like they should, we can
+change bdrv_graph_wrlock() to take a BlockDriverState whose AioContext
+lock the caller holds (NULL if it doesn't) and unlock it temporarily
+while polling.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20230605085711.21261-11-kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ include/block/graph-lock.h |  6 ++++--
+ block.c                    |  4 ++--
+ block/graph-lock.c         | 23 ++++++++++++++++++++++-
+files changed, 28 insertions(+), 5 deletions(-)
+diff --git a/include/block/graph-lock.h b/include/block/graph-lock.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/block/graph-lock.h
++++ b/include/block/graph-lock.h
+@@ -XXX,XX +XXX,XX @@ void unregister_aiocontext(AioContext *ctx);
+  * The wrlock can only be taken from the main loop, with BQL held, as only the
+  * main loop is allowed to modify the graph.
+  *
++ * If @bs is non-NULL, its AioContext is temporarily released.
++ *
+  * This function polls. Callers must not hold the lock of any AioContext other
+- * than the current one.
++ * than the current one and the one of @bs.
+  */
+-void bdrv_graph_wrlock(void) TSA_ACQUIRE(graph_lock) TSA_NO_TSA;
++void bdrv_graph_wrlock(BlockDriverState *bs) TSA_ACQUIRE(graph_lock) TSA_NO_TSA;
+ /*
+  * bdrv_graph_wrunlock:
+diff --git a/block.c b/block.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block.c
++++ b/block.c
+@@ -XXX,XX +XXX,XX @@ uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm)
+  * Replaces the node that a BdrvChild points to without updating permissions.
+  *
+  * If @new_bs is non-NULL, the parent of @child must already be drained through
+- * @child.
++ * @child and the caller must hold the AioContext lock for @new_bs.
+  */
+ static void bdrv_replace_child_noperm(BdrvChild *child,
+                                       BlockDriverState *new_bs)
+@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
+     }
+     /* TODO Pull this up into the callers to avoid polling here */
+-    bdrv_graph_wrlock();
++    bdrv_graph_wrlock(new_bs);
+     if (old_bs) {
+         if (child->klass->detach) {
+             child->klass->detach(child);
+diff --git a/block/graph-lock.c b/block/graph-lock.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/graph-lock.c
++++ b/block/graph-lock.c
+@@ -XXX,XX +XXX,XX @@ static uint32_t reader_count(void)
+ }
+ #endif
+-void bdrv_graph_wrlock(void)
++void bdrv_graph_wrlock(BlockDriverState *bs)
+ {
++    AioContext *ctx = NULL;
++
+     GLOBAL_STATE_CODE();
+     /*
+      * TODO Some callers hold an AioContext lock when this is called, which
+@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrlock(void)
+      */
+ #if 0
+     assert(!qatomic_read(&has_writer));
++#endif
++
++    /*
++     * Release only non-mainloop AioContext. The mainloop often relies on the
++     * BQL and doesn't lock the main AioContext before doing things.
++     */
++    if (bs) {
++        ctx = bdrv_get_aio_context(bs);
++        if (ctx != qemu_get_aio_context()) {
++            aio_context_release(ctx);
++        } else {
++            ctx = NULL;
++        }
++    }
++#if 0
+     /* Make sure that constantly arriving new I/O doesn't cause starvation */
+     bdrv_drain_all_begin_nopoll();
+@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrlock(void)
+     bdrv_drain_all_end();
+ #endif
++
++    if (ctx) {
++        aio_context_acquire(bdrv_get_aio_context(bs));
++    }
+ }
+ void bdrv_graph_wrunlock(void)
+--
+.41.0

-New patch
+[PULL 11/23] Revert "graph-lock: Disable locking for now"
+Now that bdrv_graph_wrlock() temporarily drops the AioContext lock that
+its caller holds, it can poll without causing deadlocks. We can now
+re-enable graph locking.
+This reverts commit ad128dff0bf4b6f971d05eb4335a627883a19c1d.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20230605085711.21261-12-kwolf@redhat.com>
+Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/graph-lock.c | 26 --------------------------
+file changed, 26 deletions(-)
+diff --git a/block/graph-lock.c b/block/graph-lock.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/graph-lock.c
++++ b/block/graph-lock.c
+@@ -XXX,XX +XXX,XX @@ BdrvGraphLock graph_lock;
+ /* Protects the list of aiocontext and orphaned_reader_count */
+ static QemuMutex aio_context_list_lock;
+-#if 0
+ /* Written and read with atomic operations. */
+ static int has_writer;
+-#endif
+ /*
+  * A reader coroutine could move from an AioContext to another.
+@@ -XXX,XX +XXX,XX @@ void unregister_aiocontext(AioContext *ctx)
+     g_free(ctx->bdrv_graph);
+ }
+-#if 0
+ static uint32_t reader_count(void)
+ {
+     BdrvGraphRWlock *brdv_graph;
+@@ -XXX,XX +XXX,XX @@ static uint32_t reader_count(void)
+     assert((int32_t)rd >= 0);
+     return rd;
+ }
+-#endif
+ void bdrv_graph_wrlock(BlockDriverState *bs)
+ {
+     AioContext *ctx = NULL;
+     GLOBAL_STATE_CODE();
+-    /*
+-     * TODO Some callers hold an AioContext lock when this is called, which
+-     * causes deadlocks. Reenable once the AioContext locking is cleaned up (or
+-     * AioContext locks are gone).
+-     */
+-#if 0
+     assert(!qatomic_read(&has_writer));
+-#endif
+     /*
+      * Release only non-mainloop AioContext. The mainloop often relies on the
+@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrlock(BlockDriverState *bs)
+         }
+     }
+-#if 0
+     /* Make sure that constantly arriving new I/O doesn't cause starvation */
+     bdrv_drain_all_begin_nopoll();
+@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrlock(BlockDriverState *bs)
+     } while (reader_count() >= 1);
+     bdrv_drain_all_end();
+-#endif
+     if (ctx) {
+         aio_context_acquire(bdrv_get_aio_context(bs));
+@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrlock(BlockDriverState *bs)
+ void bdrv_graph_wrunlock(void)
+ {
+     GLOBAL_STATE_CODE();
+-#if 0
+     QEMU_LOCK_GUARD(&aio_context_list_lock);
+     assert(qatomic_read(&has_writer));
+@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrunlock(void)
+     /* Wake up all coroutine that are waiting to read the graph */
+     qemu_co_enter_all(&reader_queue, &aio_context_list_lock);
+-#endif
+ }
+ void coroutine_fn bdrv_graph_co_rdlock(void)
+ {
+-    /* TODO Reenable when wrlock is reenabled */
+-#if 0
+     BdrvGraphRWlock *bdrv_graph;
+     bdrv_graph = qemu_get_current_aio_context()->bdrv_graph;
+@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_graph_co_rdlock(void)
+             qemu_co_queue_wait(&reader_queue, &aio_context_list_lock);
+         }
+     }
+-#endif
+ }
+ void coroutine_fn bdrv_graph_co_rdunlock(void)
+ {
+-#if 0
+     BdrvGraphRWlock *bdrv_graph;
+     bdrv_graph = qemu_get_current_aio_context()->bdrv_graph;
+@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_graph_co_rdunlock(void)
+     if (qatomic_read(&has_writer)) {
+         aio_wait_kick();
+     }
+-#endif
+ }
+ void bdrv_graph_rdlock_main_loop(void)
+@@ -XXX,XX +XXX,XX @@ void bdrv_graph_rdunlock_main_loop(void)
+ void assert_bdrv_graph_readable(void)
+ {
+     /* reader_count() is slow due to aio_context_list_lock lock contention */
+-    /* TODO Reenable when wrlock is reenabled */
+-#if 0
+ #ifdef CONFIG_DEBUG_GRAPH_LOCK
+     assert(qemu_in_main_thread() || reader_count());
+ #endif
+-#endif
+ }
+ void assert_bdrv_graph_writable(void)
+ {
+     assert(qemu_in_main_thread());
+-    /* TODO Reenable when wrlock is reenabled */
+-#if 0
+     assert(qatomic_read(&has_writer));
+-#endif
+ }
+--
+.41.0

-New patch
+[PULL 12/23] file-posix: remove incorrect coroutine_fn calls
+From: Paolo Bonzini <pbonzini@redhat.com>
+raw_co_getlength is called by handle_aiocb_write_zeroes, which is not a coroutine
+function.  This is harmless because raw_co_getlength does not actually suspend,
+but in the interest of clarity make it a non-coroutine_fn that is just wrapped
+by the coroutine_fn raw_co_getlength.  Likewise, check_cache_dropped was only
+a coroutine_fn because it called raw_co_getlength, so it can be made non-coroutine
+as well.
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Message-ID: <20230601115145.196465-2-pbonzini@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/file-posix.c | 29 +++++++++++++++++------------
+file changed, 17 insertions(+), 12 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 @@ static int fd_open(BlockDriverState *bs)
+     return -EIO;
+ }
+-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs);
++static int64_t raw_getlength(BlockDriverState *bs);
+ typedef struct RawPosixAIOData {
+     BlockDriverState *bs;
+@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_write_zeroes(void *opaque)
+ #ifdef CONFIG_FALLOCATE
+     /* Last resort: we are trying to extend the file with zeroed data. This
+      * can be done via fallocate(fd, 0) */
+-    len = raw_co_getlength(aiocb->bs);
++    len = raw_getlength(aiocb->bs);
+     if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
+         int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
+         if (ret == 0 || ret != -ENOTSUP) {
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
+     }
+     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
+-        int64_t cur_length = raw_co_getlength(bs);
++        int64_t cur_length = raw_getlength(bs);
+         if (offset != cur_length && exact) {
+             error_setg(errp, "Cannot resize device files");
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
+ }
+ #ifdef __OpenBSD__
+-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
++static int64_t raw_getlength(BlockDriverState *bs)
+ {
+     BDRVRawState *s = bs->opaque;
+     int fd = s->fd;
+@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
+         return st.st_size;
+ }
+ #elif defined(__NetBSD__)
+-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
++static int64_t raw_getlength(BlockDriverState *bs)
+ {
+     BDRVRawState *s = bs->opaque;
+     int fd = s->fd;
+@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
+         return st.st_size;
+ }
+ #elif defined(__sun__)
+-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
++static int64_t raw_getlength(BlockDriverState *bs)
+ {
+     BDRVRawState *s = bs->opaque;
+     struct dk_minfo minfo;
+@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
+     return size;
+ }
+ #elif defined(CONFIG_BSD)
+-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
++static int64_t raw_getlength(BlockDriverState *bs)
+ {
+     BDRVRawState *s = bs->opaque;
+     int fd = s->fd;
+@@ -XXX,XX +XXX,XX @@ again:
+     return size;
+ }
+ #else
+-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
++static int64_t raw_getlength(BlockDriverState *bs)
+ {
+     BDRVRawState *s = bs->opaque;
+     int ret;
+@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
+ }
+ #endif
++static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
++{
++    return raw_getlength(bs);
++}
++
+ static int64_t coroutine_fn raw_co_get_allocated_file_size(BlockDriverState *bs)
+ {
+     struct stat st;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
+          * round up if necessary.
+          */
+         if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
+-            int64_t file_length = raw_co_getlength(bs);
++            int64_t file_length = raw_getlength(bs);
+             if (file_length > 0) {
+                 /* Ignore errors, this is just a safeguard */
+                 assert(hole == file_length);
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
+ #if defined(__linux__)
+ /* Verify that the file is not in the page cache */
+-static void coroutine_fn check_cache_dropped(BlockDriverState *bs, Error **errp)
++static void check_cache_dropped(BlockDriverState *bs, Error **errp)
+ {
+     const size_t window_size = 128 * 1024 * 1024;
+     BDRVRawState *s = bs->opaque;
+@@ -XXX,XX +XXX,XX @@ static void coroutine_fn check_cache_dropped(BlockDriverState *bs, Error **errp)
+     page_size = sysconf(_SC_PAGESIZE);
+     vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
+-    end = raw_co_getlength(bs);
++    end = raw_getlength(bs);
+     for (offset = 0; offset < end; offset += window_size) {
+         void *new_window;
+@@ -XXX,XX +XXX,XX @@ static int cdrom_reopen(BlockDriverState *bs)
+ static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs)
+ {
+-    return raw_co_getlength(bs) > 0;
++    return raw_getlength(bs) > 0;
+ }
+ static void coroutine_fn cdrom_co_eject(BlockDriverState *bs, bool eject_flag)
+--
+.41.0

-New patch
+[PULL 13/23] qed: mark more functions as coroutine_fns and GRAPH_RDLOCK
+From: Paolo Bonzini <pbonzini@redhat.com>
+Mark functions as coroutine_fn when they are only called by other coroutine_fns
+and they can suspend.  Change calls to co_wrappers to use the non-wrapped
+functions, which in turn requires adding GRAPH_RDLOCK annotations.
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
+Message-ID: <20230601115145.196465-3-pbonzini@redhat.com>
+Reviewed-by: Kevin Wolf <kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/qed-check.c | 5 +++--
+ block/qed.c       | 7 ++++---
+files changed, 7 insertions(+), 5 deletions(-)
+diff --git a/block/qed-check.c b/block/qed-check.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qed-check.c
++++ b/block/qed-check.c
+@@ -XXX,XX +XXX,XX @@ static void qed_check_for_leaks(QEDCheck *check)
+ /**
+  * Mark an image clean once it passes check or has been repaired
+  */
+-static void qed_check_mark_clean(BDRVQEDState *s, BdrvCheckResult *result)
++static void coroutine_fn GRAPH_RDLOCK
++qed_check_mark_clean(BDRVQEDState *s, BdrvCheckResult *result)
+ {
+     /* Skip if there were unfixable corruptions or I/O errors */
+     if (result->corruptions > 0 || result->check_errors > 0) {
+@@ -XXX,XX +XXX,XX @@ static void qed_check_mark_clean(BDRVQEDState *s, BdrvCheckResult *result)
+     }
+     /* Ensure fixes reach storage before clearing check bit */
+-    bdrv_flush(s->bs);
++    bdrv_co_flush(s->bs);
+     s->header.features &= ~QED_F_NEED_CHECK;
+     qed_write_header_sync(s);
+diff --git a/block/qed.c b/block/qed.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qed.c
++++ b/block/qed.c
+@@ -XXX,XX +XXX,XX @@ static bool qed_is_image_size_valid(uint64_t image_size, uint32_t cluster_size,
+  *
+  * The string is NUL-terminated.
+  */
+-static int qed_read_string(BdrvChild *file, uint64_t offset, size_t n,
+-                           char *buf, size_t buflen)
++static int coroutine_fn GRAPH_RDLOCK
++qed_read_string(BdrvChild *file, uint64_t offset,
++                size_t n, char *buf, size_t buflen)
+ {
+     int ret;
+     if (n >= buflen) {
+         return -EINVAL;
+     }
+-    ret = bdrv_pread(file, offset, n, buf, 0);
++    ret = bdrv_co_pread(file, offset, n, buf, 0);
+     if (ret < 0) {
+         return ret;
+     }
+--
+.41.0

-[PULL 07/11] block/blkio: Set BlockDriver::has_variable_length to false
+[PULL 14/23] vpc: mark more functions as coroutine_fns and GRAPH_RDLOCK
-From: Alberto Faria <afaria@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-Setting it to true can cause the device size to be queried from libblkio
+Mark functions as coroutine_fn when they are only called by other coroutine_fns
-in otherwise fast paths, degrading performance. Set it to false and
+and they can suspend.  Change calls to co_wrappers to use the non-wrapped
-require users to refresh the device size explicitly instead.
+functions, which in turn requires adding GRAPH_RDLOCK annotations.
-Fixes: 4c8f4fda0504 ("block/blkio: Tolerate device size changes")
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Suggested-by: Kevin Wolf <kwolf@redhat.com>
+Message-ID: <20230601115145.196465-4-pbonzini@redhat.com>
 Signed-off-by: Alberto Faria <afaria@redhat.com>
 Message-Id: <20221108144433.1334074-1-afaria@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/blkio.c | 1 -
+ block/vpc.c | 52 ++++++++++++++++++++++++++--------------------------
-file changed, 1 deletion(-)
+file changed, 26 insertions(+), 26 deletions(-)
-diff --git a/block/blkio.c b/block/blkio.c
+diff --git a/block/vpc.c b/block/vpc.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/blkio.c
+--- a/block/vpc.c
-+++ b/block/blkio.c
++++ b/block/vpc.c
-@@ -XXX,XX +XXX,XX @@ static void blkio_refresh_limits(BlockDriverState *bs, Error **errp)
+@@ -XXX,XX +XXX,XX @@ static int vpc_reopen_prepare(BDRVReopenState *state,
-     { \
+  * operation (the block bitmaps is updated then), 0 otherwise.
-         .format_name             = name, \
+  * If write is true then err must not be NULL.
-         .protocol_name           = name, \
+  */
--        .has_variable_length     = true, \
+-static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
-         .instance_size           = sizeof(BDRVBlkioState), \
+-                                       bool write, int *err)
-         .bdrv_file_open          = blkio_file_open, \
++static int64_t coroutine_fn GRAPH_RDLOCK
-         .bdrv_close              = blkio_close, \
++get_image_offset(BlockDriverState *bs, uint64_t offset, bool write, int *err)
  {
      BDRVVPCState *s = bs->opaque;
      uint64_t bitmap_offset, block_offset;
@@ -XXX,XX +XXX,XX @@ static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
          s->last_bitmap_offset = bitmap_offset;
          memset(bitmap, 0xff, s->bitmap_size);
 -        r = bdrv_pwrite_sync(bs->file, bitmap_offset, s->bitmap_size, bitmap,
 -                             0);
 +        r = bdrv_co_pwrite_sync(bs->file, bitmap_offset, s->bitmap_size, bitmap, 0);
          if (r < 0) {
              *err = r;
              return -2;
@@ -XXX,XX +XXX,XX @@ static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
   *
   * Returns 0 on success and < 0 on error
   */
 -static int rewrite_footer(BlockDriverState *bs)
 +static int coroutine_fn GRAPH_RDLOCK rewrite_footer(BlockDriverState *bs)
  {
      int ret;
      BDRVVPCState *s = bs->opaque;
      int64_t offset = s->free_data_block_offset;
 -    ret = bdrv_pwrite_sync(bs->file, offset, sizeof(s->footer), &s->footer, 0);
 +    ret = bdrv_co_pwrite_sync(bs->file, offset, sizeof(s->footer), &s->footer, 0);
      if (ret < 0)
          return ret;
@@ -XXX,XX +XXX,XX @@ static int rewrite_footer(BlockDriverState *bs)
   *
   * Returns the sectors' offset in the image file on success and < 0 on error
   */
 -static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
 +static int64_t coroutine_fn GRAPH_RDLOCK
 +alloc_block(BlockDriverState *bs, int64_t offset)
  {
      BDRVVPCState *s = bs->opaque;
      int64_t bat_offset;
@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
      /* Initialize the block's bitmap */
      memset(bitmap, 0xff, s->bitmap_size);
 -    ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset,
 -                           s->bitmap_size, bitmap, 0);
 +    ret = bdrv_co_pwrite_sync(bs->file, s->free_data_block_offset,
 +                              s->bitmap_size, bitmap, 0);
      if (ret < 0) {
          return ret;
      }
@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
      /* Write BAT entry to disk */
      bat_offset = s->bat_offset + (4 * index);
      bat_value = cpu_to_be32(s->pagetable[index]);
 -    ret = bdrv_pwrite_sync(bs->file, bat_offset, 4, &bat_value, 0);
 +    ret = bdrv_co_pwrite_sync(bs->file, bat_offset, 4, &bat_value, 0);
      if (ret < 0)
          goto fail;
@@ -XXX,XX +XXX,XX @@ fail:
      return ret;
  }
 -static int coroutine_fn vpc_co_block_status(BlockDriverState *bs,
 -                                            bool want_zero,
 -                                            int64_t offset, int64_t bytes,
 -                                            int64_t *pnum, int64_t *map,
 -                                            BlockDriverState **file)
 +static int coroutine_fn GRAPH_RDLOCK
 +vpc_co_block_status(BlockDriverState *bs, bool want_zero,
 +                    int64_t offset, int64_t bytes,
 +                    int64_t *pnum, int64_t *map,
 +                    BlockDriverState **file)
  {
      BDRVVPCState *s = bs->opaque;
      int64_t image_offset;
@@ -XXX,XX +XXX,XX @@ static int calculate_geometry(int64_t total_sectors, uint16_t *cyls,
      return 0;
  }
 -static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
 -                               int64_t total_sectors)
 +static int coroutine_fn create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
 +                                            int64_t total_sectors)
  {
      VHDDynDiskHeader dyndisk_header;
      uint8_t bat_sector[512];
@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
      block_size = 0x200000;
      num_bat_entries = DIV_ROUND_UP(total_sectors, block_size / 512);
 -    ret = blk_pwrite(blk, offset, sizeof(*footer), footer, 0);
 +    ret = blk_co_pwrite(blk, offset, sizeof(*footer), footer, 0);
      if (ret < 0) {
          goto fail;
      }
      offset = 1536 + ((num_bat_entries * 4 + 511) & ~511);
 -    ret = blk_pwrite(blk, offset, sizeof(*footer), footer, 0);
 +    ret = blk_co_pwrite(blk, offset, sizeof(*footer), footer, 0);
      if (ret < 0) {
          goto fail;
      }
@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
      memset(bat_sector, 0xFF, 512);
      for (i = 0; i < DIV_ROUND_UP(num_bat_entries * 4, 512); i++) {
 -        ret = blk_pwrite(blk, offset, 512, bat_sector, 0);
 +        ret = blk_co_pwrite(blk, offset, 512, bat_sector, 0);
          if (ret < 0) {
              goto fail;
          }
@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
      /* Write the header */
      offset = 512;
 -    ret = blk_pwrite(blk, offset, sizeof(dyndisk_header), &dyndisk_header, 0);
 +    ret = blk_co_pwrite(blk, offset, sizeof(dyndisk_header), &dyndisk_header, 0);
      if (ret < 0) {
          goto fail;
      }
@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
      return ret;
  }
 -static int create_fixed_disk(BlockBackend *blk, VHDFooter *footer,
 -                             int64_t total_size, Error **errp)
 +static int coroutine_fn create_fixed_disk(BlockBackend *blk, VHDFooter *footer,
 +                                          int64_t total_size, Error **errp)
  {
      int ret;
      /* Add footer to total size */
      total_size += sizeof(*footer);
 -    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
 +    ret = blk_co_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
      if (ret < 0) {
          return ret;
      }
 -    ret = blk_pwrite(blk, total_size - sizeof(*footer), sizeof(*footer),
 -                     footer, 0);
 +    ret = blk_co_pwrite(blk, total_size - sizeof(*footer), sizeof(*footer),
 +                        footer, 0);
      if (ret < 0) {
          error_setg_errno(errp, -ret, "Unable to write VHD header");
          return ret;
 --
-.38.1
+.41.0

-[PULL 06/11] qapi/block-core: Fix BlockdevOptionsNvmeIoUring @path description
+[PULL 15/23] bochs: mark more functions as coroutine_fns and GRAPH_RDLOCK
-From: Alberto Faria <afaria@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-The nvme-io_uring BlockDriver's path option must point at the character
+Mark functions as coroutine_fn when they are only called by other coroutine_fns
-device of an NVMe namespace, not at an image file.
+and they can suspend.  Change calls to co_wrappers to use the non-wrapped
 functions, which in turn requires adding GRAPH_RDLOCK annotations.
-Fixes: fd66dbd424f5 ("blkio: add libblkio block driver")
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Suggested-by: Stefano Garzarella <sgarzare@redhat.com>
+Message-ID: <20230601115145.196465-5-pbonzini@redhat.com>
 Signed-off-by: Alberto Faria <afaria@redhat.com>
 Message-Id: <20221108142347.1322674-1-afaria@redhat.com>
 Reviewed-by: Stefano Garzarella <sgarzare@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- qapi/block-core.json | 2 +-
+ block/bochs.c | 7 ++++---
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 4 insertions(+), 3 deletions(-)
-diff --git a/qapi/block-core.json b/qapi/block-core.json
+diff --git a/block/bochs.c b/block/bochs.c
 index XXXXXXX..XXXXXXX 100644
---- a/qapi/block-core.json
+--- a/block/bochs.c
-+++ b/qapi/block-core.json
++++ b/block/bochs.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static void bochs_refresh_limits(BlockDriverState *bs, Error **errp)
- #
+     bs->bl.request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O */
- # Driver specific block device options for the nvme-io_uring backend.
+ }
- #
--# @path: path to the image file
+-static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)
-+# @path: path to the NVMe namespace's character device (e.g. /dev/ng0n1).
++static int64_t coroutine_fn GRAPH_RDLOCK
- #
++seek_to_sector(BlockDriverState *bs, int64_t sector_num)
- # Since: 7.2
+ {
- ##
+     BDRVBochsState *s = bs->opaque;
      uint64_t offset = sector_num * 512;
@@ -XXX,XX +XXX,XX @@ static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)
          (s->extent_blocks + s->bitmap_blocks));
      /* read in bitmap for current extent */
 -    ret = bdrv_pread(bs->file, bitmap_offset + (extent_offset / 8), 1,
 -                     &bitmap_entry, 0);
 +    ret = bdrv_co_pread(bs->file, bitmap_offset + (extent_offset / 8), 1,
 +                        &bitmap_entry, 0);
      if (ret < 0) {
          return ret;
      }
 --
-.38.1
+.41.0

-[PULL 08/11] block: Make bdrv_child_get_parent_aio_context I/O
+[PULL 16/23] block: mark another function as coroutine_fns and GRAPH_UNLOCKED
-From: Hanna Reitz <hreitz@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-We want to use bdrv_child_get_parent_aio_context() from
+Mark functions as coroutine_fn when they are only called by other coroutine_fns
-bdrv_parent_drained_{begin,end}_single(), both of which are "I/O or GS"
+and they can suspend.  Because this function operates on a BlockBackend, mark it
-functions.
+GRAPH_UNLOCKED.
-Prior to 3ed4f708fe1, all the implementations were I/O code anyway.
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-ed4f708fe1 has put block jobs' AioContext field under the job mutex, so
+Message-ID: <20230601115145.196465-6-pbonzini@redhat.com>
 to make child_job_get_parent_aio_context() work in an I/O context, we
 need to take that lock there.
 Furthermore, blk_root_get_parent_aio_context() is not marked as
 anything, but is safe to run in an I/O context, so mark it that way now.
 (blk_get_aio_context() is an I/O code function.)
 With that done, all implementations explicitly are I/O code, so we can
 mark bdrv_child_get_parent_aio_context() as I/O code, too, so callers
 know it is safe to run from both GS and I/O contexts.
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 Message-Id: <20221107151321.211175-2-hreitz@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- include/block/block-global-state.h | 1 -
+ block.c | 11 ++++++-----
- include/block/block-io.h           | 2 ++
+file changed, 6 insertions(+), 5 deletions(-)
  include/block/block_int-common.h   | 4 ++--
  block.c                            | 2 +-
  block/block-backend.c              | 1 +
  blockjob.c                         | 3 ++-
 files changed, 8 insertions(+), 5 deletions(-)
-diff --git a/include/block/block-global-state.h b/include/block/block-global-state.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/block-global-state.h
-+++ b/include/block/block-global-state.h
-@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_co_lock(BlockDriverState *bs);
-  */
- void coroutine_fn bdrv_co_unlock(BlockDriverState *bs);
--AioContext *bdrv_child_get_parent_aio_context(BdrvChild *c);
- bool bdrv_child_change_aio_context(BdrvChild *c, AioContext *ctx,
-                                    GHashTable *visited, Transaction *tran,
-                                    Error **errp);
-diff --git a/include/block/block-io.h b/include/block/block-io.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/block-io.h
-+++ b/include/block/block-io.h
-@@ -XXX,XX +XXX,XX @@ void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event);
-  */
- AioContext *bdrv_get_aio_context(BlockDriverState *bs);
-+AioContext *bdrv_child_get_parent_aio_context(BdrvChild *c);
-+
- /**
-  * Move the current coroutine to the AioContext of @bs and return the old
-  * AioContext of the coroutine. Increase bs->in_flight so that draining @bs
-diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
-index XXXXXXX..XXXXXXX 100644
---- a/include/block/block_int-common.h
-+++ b/include/block/block_int-common.h
-@@ -XXX,XX +XXX,XX @@ struct BdrvChildClass {
-                            GHashTable *visited, Transaction *tran,
-                            Error **errp);
--    AioContext *(*get_parent_aio_context)(BdrvChild *child);
--
-     /*
-      * I/O API functions. These functions are thread-safe.
-      *
-@@ -XXX,XX +XXX,XX @@ struct BdrvChildClass {
-      */
-     const char *(*get_name)(BdrvChild *child);
-+    AioContext *(*get_parent_aio_context)(BdrvChild *child);
-+
-     /*
-      * If this pair of functions is implemented, the parent doesn't issue new
-      * requests after returning from .drained_begin() until .drained_end() is
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
-@@ -XXX,XX +XXX,XX @@ const BdrvChildClass child_of_bds = {
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_create(BlockDriver *drv, const char *filename,
+  * On success, return @blk's actual length.
- AioContext *bdrv_child_get_parent_aio_context(BdrvChild *c)
+  * Otherwise, return -errno.
   */
 -static int64_t create_file_fallback_truncate(BlockBackend *blk,
 -                                             int64_t minimum_size, Error **errp)
 +static int64_t coroutine_fn GRAPH_UNLOCKED
 +create_file_fallback_truncate(BlockBackend *blk, int64_t minimum_size,
 +                              Error **errp)
  {
--    GLOBAL_STATE_CODE();
+     Error *local_err = NULL;
-+    IO_CODE();
+     int64_t size;
-     return c->klass->get_parent_aio_context(c);
+@@ -XXX,XX +XXX,XX @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,
- }
+     GLOBAL_STATE_CODE();
-diff --git a/block/block-backend.c b/block/block-backend.c
-index XXXXXXX..XXXXXXX 100644
+-    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
---- a/block/block-backend.c
+-                       &local_err);
-+++ b/block/block-backend.c
++    ret = blk_co_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
-@@ -XXX,XX +XXX,XX @@ static void blk_root_detach(BdrvChild *child)
++                          &local_err);
- static AioContext *blk_root_get_parent_aio_context(BdrvChild *c)
+     if (ret < 0 && ret != -ENOTSUP) {
- {
+         error_propagate(errp, local_err);
-     BlockBackend *blk = c->opaque;
+         return ret;
-+    IO_CODE();
+     }
-     return blk_get_aio_context(blk);
+-    size = blk_getlength(blk);
- }
++    size = blk_co_getlength(blk);
-diff --git a/blockjob.c b/blockjob.c
+     if (size < 0) {
-index XXXXXXX..XXXXXXX 100644
+         error_free(local_err);
---- a/blockjob.c
+         error_setg_errno(errp, -size,
 +++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static bool child_job_change_aio_ctx(BdrvChild *c, AioContext *ctx,
  static AioContext *child_job_get_parent_aio_context(BdrvChild *c)
  {
      BlockJob *job = c->opaque;
 -    GLOBAL_STATE_CODE();
 +    IO_CODE();
 +    JOB_LOCK_GUARD();
      return job->job.aio_context;
  }
 --
-.38.1
+.41.0

-[PULL 05/11] iotests/151: Test active requests on mirror start
+[PULL 17/23] cloop: mark more functions as coroutine_fns and GRAPH_RDLOCK
-From: Hanna Reitz <hreitz@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-Have write requests happen to the source node right when we start a
+Mark functions as coroutine_fn when they are only called by other coroutine_fns
-mirror job.  The mirror filter node may encounter MirrorBDSOpaque.job
+and they can suspend.  Change calls to co_wrappers to use the non-wrapped
-being NULL, but this should not cause a segfault.
+functions, which in turn requires adding GRAPH_RDLOCK annotations.
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Message-Id: <20221109165452.67927-6-hreitz@redhat.com>
+Message-ID: <20230601115145.196465-7-pbonzini@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/151     | 53 +++++++++++++++++++++++++++++++++++---
+ block/cloop.c | 9 +++++----
- tests/qemu-iotests/151.out |  4 +--
+file changed, 5 insertions(+), 4 deletions(-)
 files changed, 52 insertions(+), 5 deletions(-)
-diff --git a/tests/qemu-iotests/151 b/tests/qemu-iotests/151
+diff --git a/block/cloop.c b/block/cloop.c
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/151
 +++ b/tests/qemu-iotests/151
@@ -XXX,XX +XXX,XX @@
  import math
  import os
  import subprocess
 -from typing import List
 +import time
 +from typing import List, Optional
  import iotests
  from iotests import qemu_img
@@ -XXX,XX +XXX,XX @@ class TestActiveMirror(iotests.QMPTestCase):
          self.potential_writes_in_flight = False
 -class TestThrottledWithNbdExport(iotests.QMPTestCase):
 +class TestThrottledWithNbdExportBase(iotests.QMPTestCase):
      image_len = 128 * 1024 * 1024  # MB
 -    iops = 16
 +    iops: Optional[int] = None
      background_processes: List['subprocess.Popen[str]'] = []
      def setUp(self):
 +        # Must be set by subclasses
 +        self.assertIsNotNone(self.iops)
 +
          qemu_img('create', '-f', iotests.imgfmt, source_img, '128M')
          qemu_img('create', '-f', iotests.imgfmt, target_img, '128M')
@@ -XXX,XX +XXX,XX @@ class TestThrottledWithNbdExport(iotests.QMPTestCase):
          os.remove(source_img)
          os.remove(target_img)
 +
 +class TestLowThrottledWithNbdExport(TestThrottledWithNbdExportBase):
 +    iops = 16
 +
      def testUnderLoad(self):
          '''
          Throttle the source node, then issue a whole bunch of external requests
@@ -XXX,XX +XXX,XX @@ class TestThrottledWithNbdExport(iotests.QMPTestCase):
          self.assertGreater(start_remaining - end_remaining, 0)
 +class TestHighThrottledWithNbdExport(TestThrottledWithNbdExportBase):
 +    iops = 1024
 +
 +    def testActiveOnCreation(self):
 +        '''
 +        Issue requests on the mirror source node right as the mirror is
 +        instated.  It's possible that requests occur before the actual job is
 +        created, but after the node has been put into the graph.  Write
 +        requests across the node must in that case be forwarded to the source
 +        node without attempting to mirror them (there is no job object yet, so
 +        attempting to access it would cause a segfault).
 +        We do this with a lightly throttled node (i.e. quite high IOPS limit).
 +        Using throttling seems to increase reproductivity, but if the limit is
 +        too low, all requests allowed per second will be submitted before
 +        mirror_start_job() gets to the problematic point.
 +        '''
 +
 +        # Let qemu-img bench create write requests (enough for two seconds on
 +        # the virtual clock)
 +        bench_args = ['bench', '-w', '-d', '1024', '-f', 'nbd',
 +                      '-c', str(self.iops * 2), self.nbd_url]
 +        p = iotests.qemu_tool_popen(iotests.qemu_img_args + bench_args)
 +        self.background_processes += [p]
 +
 +        # Give qemu-img bench time to start up and issue requests
 +        time.sleep(1.0)
 +        # Flush the request queue, so new requests can come in right as we
 +        # start blockdev-mirror
 +        self.vm.qtest(f'clock_step {1 * 1000 * 1000 * 1000}')
 +
 +        result = self.vm.qmp('blockdev-mirror',
 +                             job_id='mirror',
 +                             device='source-node',
 +                             target='target-node',
 +                             sync='full',
 +                             copy_mode='write-blocking')
 +        self.assert_qmp(result, 'return', {})
 +
 +
  if __name__ == '__main__':
      iotests.main(supported_fmts=['qcow2', 'raw'],
                   supported_protocols=['file'])
 diff --git a/tests/qemu-iotests/151.out b/tests/qemu-iotests/151.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/151.out
+--- a/block/cloop.c
-+++ b/tests/qemu-iotests/151.out
++++ b/block/cloop.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static void cloop_refresh_limits(BlockDriverState *bs, Error **errp)
--.....
+     bs->bl.request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O */
-+......
+ }
- ----------------------------------------------------------------------
--Ran 5 tests
+-static inline int cloop_read_block(BlockDriverState *bs, int block_num)
-+Ran 6 tests
++static int coroutine_fn GRAPH_RDLOCK
++cloop_read_block(BlockDriverState *bs, int block_num)
- OK
+ {
      BDRVCloopState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)
          int ret;
          uint32_t bytes = s->offsets[block_num + 1] - s->offsets[block_num];
 -        ret = bdrv_pread(bs->file, s->offsets[block_num], bytes,
 -                         s->compressed_block, 0);
 +        ret = bdrv_co_pread(bs->file, s->offsets[block_num], bytes,
 +                            s->compressed_block, 0);
          if (ret < 0) {
              return -1;
          }
@@ -XXX,XX +XXX,XX @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)
      return 0;
  }
 -static int coroutine_fn
 +static int coroutine_fn GRAPH_RDLOCK
  cloop_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                  QEMUIOVector *qiov, BdrvRequestFlags flags)
  {
 --
-.38.1
+.41.0

-[PULL 04/11] iotests/151: Test that active mirror progresses
+[PULL 18/23] dmg: mark more functions as coroutine_fns and GRAPH_RDLOCK
-From: Hanna Reitz <hreitz@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-Before this series, a mirror job in write-blocking mode would pause
+Mark functions as coroutine_fn when they are only called by other coroutine_fns
-issuing background requests while active requests are in flight.  Thus,
+and they can suspend.  Change calls to co_wrappers to use the non-wrapped
-if the source is constantly in use by active requests, no actual
+functions, which in turn requires adding GRAPH_RDLOCK annotations.
 progress can be made.
-This series should have fixed that, making the mirror job issue
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-background requests even while active requests are in flight.
+Message-ID: <20230601115145.196465-8-pbonzini@redhat.com>
 Have a new test case in 151 verify this.
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 Message-Id: <20221109165452.67927-5-hreitz@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/151     | 180 ++++++++++++++++++++++++++++++++++++-
+ block/dmg.c | 21 +++++++++++----------
- tests/qemu-iotests/151.out |   4 +-
+file changed, 11 insertions(+), 10 deletions(-)
 files changed, 181 insertions(+), 3 deletions(-)
-diff --git a/tests/qemu-iotests/151 b/tests/qemu-iotests/151
+diff --git a/block/dmg.c b/block/dmg.c
 index XXXXXXX..XXXXXXX 100755
 --- a/tests/qemu-iotests/151
 +++ b/tests/qemu-iotests/151
@@ -XXX,XX +XXX,XX @@
  # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  #
 +import math
  import os
 +import subprocess
 +from typing import List
  import iotests
  from iotests import qemu_img
@@ -XXX,XX +XXX,XX @@ class TestActiveMirror(iotests.QMPTestCase):
          self.vm = iotests.VM()
          self.vm.add_drive_raw(self.vm.qmp_to_opts(blk_source))
          self.vm.add_blockdev(self.vm.qmp_to_opts(blk_target))
 -        self.vm.add_device('virtio-blk,drive=source')
 +        self.vm.add_device('virtio-blk,id=vblk,drive=source')
          self.vm.launch()
      def tearDown(self):
@@ -XXX,XX +XXX,XX @@ class TestActiveMirror(iotests.QMPTestCase):
          self.potential_writes_in_flight = False
 +class TestThrottledWithNbdExport(iotests.QMPTestCase):
 +    image_len = 128 * 1024 * 1024  # MB
 +    iops = 16
 +    background_processes: List['subprocess.Popen[str]'] = []
 +
 +    def setUp(self):
 +        qemu_img('create', '-f', iotests.imgfmt, source_img, '128M')
 +        qemu_img('create', '-f', iotests.imgfmt, target_img, '128M')
 +
 +        self.vm = iotests.VM()
 +        self.vm.launch()
 +
 +        result = self.vm.qmp('object-add', **{
 +            'qom-type': 'throttle-group',
 +            'id': 'thrgr',
 +            'limits': {
 +                'iops-total': self.iops,
 +                'iops-total-max': self.iops
 +            }
 +        })
 +        self.assert_qmp(result, 'return', {})
 +
 +        result = self.vm.qmp('blockdev-add', **{
 +            'node-name': 'source-node',
 +            'driver': 'throttle',
 +            'throttle-group': 'thrgr',
 +            'file': {
 +                'driver': iotests.imgfmt,
 +                'file': {
 +                    'driver': 'file',
 +                    'filename': source_img
 +                }
 +            }
 +        })
 +        self.assert_qmp(result, 'return', {})
 +
 +        result = self.vm.qmp('blockdev-add', **{
 +            'node-name': 'target-node',
 +            'driver': iotests.imgfmt,
 +            'file': {
 +                'driver': 'file',
 +                'filename': target_img
 +            }
 +        })
 +        self.assert_qmp(result, 'return', {})
 +
 +        self.nbd_sock = iotests.file_path('nbd.sock',
 +                                          base_dir=iotests.sock_dir)
 +        self.nbd_url = f'nbd+unix:///source-node?socket={self.nbd_sock}'
 +
 +        result = self.vm.qmp('nbd-server-start', addr={
 +            'type': 'unix',
 +            'data': {
 +                'path': self.nbd_sock
 +            }
 +        })
 +        self.assert_qmp(result, 'return', {})
 +
 +        result = self.vm.qmp('block-export-add', id='exp0', type='nbd',
 +                             node_name='source-node', writable=True)
 +        self.assert_qmp(result, 'return', {})
 +
 +    def tearDown(self):
 +        # Wait for background requests to settle
 +        try:
 +            while True:
 +                p = self.background_processes.pop()
 +                while True:
 +                    try:
 +                        p.wait(timeout=0.0)
 +                        break
 +                    except subprocess.TimeoutExpired:
 +                        self.vm.qtest(f'clock_step {1 * 1000 * 1000 * 1000}')
 +        except IndexError:
 +            pass
 +
 +        # Cancel ongoing block jobs
 +        for job in self.vm.qmp('query-jobs')['return']:
 +            self.vm.qmp('block-job-cancel', device=job['id'], force=True)
 +
 +        while True:
 +            self.vm.qtest(f'clock_step {1 * 1000 * 1000 * 1000}')
 +            if len(self.vm.qmp('query-jobs')['return']) == 0:
 +                break
 +
 +        self.vm.shutdown()
 +        os.remove(source_img)
 +        os.remove(target_img)
 +
 +    def testUnderLoad(self):
 +        '''
 +        Throttle the source node, then issue a whole bunch of external requests
 +        while the mirror job (in write-blocking mode) is running.  We want to
 +        see background requests being issued even while the source is under
 +        full load by active writes, so that progress can be made towards READY.
 +        '''
 +
 +        # Fill the first half of the source image; do not fill the second half,
 +        # that is where we will have active requests occur.  This ensures that
 +        # active mirroring itself will not directly contribute to the job's
 +        # progress (because when the job was started, those areas were not
 +        # intended to be copied, so active mirroring will only lead to not
 +        # losing progress, but also not making any).
 +        self.vm.hmp_qemu_io('source-node',
 +                            f'aio_write -P 1 0 {self.image_len // 2}')
 +        self.vm.qtest(f'clock_step {1 * 1000 * 1000 * 1000}')
 +
 +        # Launch the mirror job
 +        mirror_buf_size = 65536
 +        result = self.vm.qmp('blockdev-mirror',
 +                             job_id='mirror',
 +                             filter_node_name='mirror-node',
 +                             device='source-node',
 +                             target='target-node',
 +                             sync='full',
 +                             copy_mode='write-blocking',
 +                             buf_size=mirror_buf_size)
 +        self.assert_qmp(result, 'return', {})
 +
 +        # We create the external requests via qemu-io processes on the NBD
 +        # server.  Have their offset start in the middle of the image so they
 +        # do not overlap with the background requests (which start from the
 +        # beginning).
 +        active_request_offset = self.image_len // 2
 +        active_request_len = 4096
 +
 +        # Create enough requests to saturate the node for 5 seconds
 +        for _ in range(0, 5 * self.iops):
 +            req = f'write -P 42 {active_request_offset} {active_request_len}'
 +            active_request_offset += active_request_len
 +            p = iotests.qemu_io_popen('-f', 'nbd', self.nbd_url, '-c', req)
 +            self.background_processes += [p]
 +
 +        # Now advance the clock one I/O operation at a time by the 4 seconds
 +        # (i.e. one less than 5).  We expect the mirror job to issue background
 +        # operations here, even though active requests are still in flight.
 +        # The active requests will take precedence, however, because they have
 +        # been issued earlier than mirror's background requests.
 +        # Once the active requests we have started above are done (i.e. after 5
 +        # virtual seconds), we expect those background requests to be worked
 +        # on.  We only advance 4 seconds here to avoid race conditions.
 +        for _ in range(0, 4 * self.iops):
 +            step = math.ceil(1 * 1000 * 1000 * 1000 / self.iops)
 +            self.vm.qtest(f'clock_step {step}')
 +
 +        # Note how much remains to be done until the mirror job is finished
 +        job_status = self.vm.qmp('query-jobs')['return'][0]
 +        start_remaining = job_status['total-progress'] - \
 +            job_status['current-progress']
 +
 +        # Create a whole bunch of more active requests
 +        for _ in range(0, 10 * self.iops):
 +            req = f'write -P 42 {active_request_offset} {active_request_len}'
 +            active_request_offset += active_request_len
 +            p = iotests.qemu_io_popen('-f', 'nbd', self.nbd_url, '-c', req)
 +            self.background_processes += [p]
 +
 +        # Let the clock advance more.  After 1 second, as noted above, we
 +        # expect the background requests to be worked on.  Give them a couple
 +        # of seconds (specifically 4) to see their impact.
 +        for _ in range(0, 5 * self.iops):
 +            step = math.ceil(1 * 1000 * 1000 * 1000 / self.iops)
 +            self.vm.qtest(f'clock_step {step}')
 +
 +        # Note how much remains to be done now.  We expect this number to be
 +        # reduced thanks to those background requests.
 +        job_status = self.vm.qmp('query-jobs')['return'][0]
 +        end_remaining = job_status['total-progress'] - \
 +            job_status['current-progress']
 +
 +        # See that indeed progress was being made on the job, even while the
 +        # node was saturated with active requests
 +        self.assertGreater(start_remaining - end_remaining, 0)
 +
 +
  if __name__ == '__main__':
      iotests.main(supported_fmts=['qcow2', 'raw'],
                   supported_protocols=['file'])
 diff --git a/tests/qemu-iotests/151.out b/tests/qemu-iotests/151.out
 index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/151.out
+--- a/block/dmg.c
-+++ b/tests/qemu-iotests/151.out
++++ b/block/dmg.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ err:
--....
+     return s->n_chunks; /* error */
-+.....
+ }
- ----------------------------------------------------------------------
--Ran 4 tests
+-static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
-+Ran 5 tests
++static int coroutine_fn GRAPH_RDLOCK
++dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
- OK
+ {
      BDRVDMGState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
          case UDZO: { /* zlib compressed */
              /* we need to buffer, because only the chunk as whole can be
               * inflated. */
 -            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
 -                             s->compressed_chunk, 0);
 +            ret = bdrv_co_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
 +                                s->compressed_chunk, 0);
              if (ret < 0) {
                  return -1;
              }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
              }
              /* we need to buffer, because only the chunk as whole can be
               * inflated. */
 -            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
 -                             s->compressed_chunk, 0);
 +            ret = bdrv_co_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
 +                                s->compressed_chunk, 0);
              if (ret < 0) {
                  return -1;
              }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
              }
              /* we need to buffer, because only the chunk as whole can be
               * inflated. */
 -            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
 -                             s->compressed_chunk, 0);
 +            ret = bdrv_co_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
 +                                s->compressed_chunk, 0);
              if (ret < 0) {
                  return -1;
              }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
              }
              break;
          case UDRW: /* copy */
 -            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
 -                             s->uncompressed_chunk, 0);
 +            ret = bdrv_co_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
 +                                s->uncompressed_chunk, 0);
              if (ret < 0) {
                  return -1;
              }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
      return 0;
  }
 -static int coroutine_fn
 +static int coroutine_fn GRAPH_RDLOCK
  dmg_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                QEMUIOVector *qiov, BdrvRequestFlags flags)
  {
 --
-.38.1
+.41.0

-[PULL 03/11] block/mirror: Fix NULL s->job in active writes
+[PULL 19/23] vmdk: mark more functions as coroutine_fns and GRAPH_RDLOCK
-From: Hanna Reitz <hreitz@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-There is a small gap in mirror_start_job() before putting the mirror
+Mark functions as coroutine_fn when they are only called by other coroutine_fns
-filter node into the block graph (bdrv_append() call) and the actual job
+and they can suspend.  Change calls to co_wrappers to use the non-wrapped
-being created.  Before the job is created, MirrorBDSOpaque.job is NULL.
+functions, which in turn requires adding GRAPH_RDLOCK annotations.
-It is possible that requests come in when bdrv_drained_end() is called,
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-and those requests would see MirrorBDSOpaque.job == NULL.  Have our
+Message-ID: <20230601115145.196465-9-pbonzini@redhat.com>
 filter node handle that case gracefully.
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 Message-Id: <20221109165452.67927-4-hreitz@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/mirror.c | 20 ++++++++++++--------
+ block/vmdk.c | 27 ++++++++++++++-------------
-file changed, 12 insertions(+), 8 deletions(-)
+file changed, 14 insertions(+), 13 deletions(-)
-diff --git a/block/mirror.c b/block/mirror.c
+diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/mirror.c
+--- a/block/vmdk.c
-+++ b/block/mirror.c
++++ b/block/vmdk.c
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_mirror_top_do_write(BlockDriverState *bs,
+@@ -XXX,XX +XXX,XX @@ out:
-     MirrorOp *op = NULL;
+     return ret;
-     MirrorBDSOpaque *s = bs->opaque;
+ }
-     int ret = 0;
--    bool copy_to_target;
+-static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
-+    bool copy_to_target = false;
++static int coroutine_fn GRAPH_RDLOCK
++vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
--    copy_to_target = s->job->ret >= 0 &&
+ {
--                     !job_is_cancelled(&s->job->common.job) &&
+     char *desc, *tmp_desc;
--                     s->job->copy_mode == MIRROR_COPY_MODE_WRITE_BLOCKING;
+     char *p_name, *tmp_str;
-+    if (s->job) {
+@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
-+        copy_to_target = s->job->ret >= 0 &&
-+                         !job_is_cancelled(&s->job->common.job) &&
+     desc = g_malloc0(DESC_SIZE);
-+                         s->job->copy_mode == MIRROR_COPY_MODE_WRITE_BLOCKING;
+     tmp_desc = g_malloc0(DESC_SIZE);
-+    }
+-    ret = bdrv_pread(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
++    ret = bdrv_co_pread(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
-     if (copy_to_target) {
+     if (ret < 0) {
-         op = active_write_prepare(s->job, offset, bytes);
+         goto out;
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_mirror_top_pwritev(BlockDriverState *bs,
+     }
-     QEMUIOVector bounce_qiov;
+@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
-     void *bounce_buf;
+         pstrcat(desc, DESC_SIZE, tmp_desc);
-     int ret = 0;
+     }
--    bool copy_to_target;
-+    bool copy_to_target = false;
+-    ret = bdrv_pwrite_sync(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
++    ret = bdrv_co_pwrite_sync(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
--    copy_to_target = s->job->ret >= 0 &&
--                     !job_is_cancelled(&s->job->common.job) &&
+ out:
--                     s->job->copy_mode == MIRROR_COPY_MODE_WRITE_BLOCKING;
+     g_free(desc);
-+    if (s->job) {
+@@ -XXX,XX +XXX,XX @@ vmdk_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
-+        copy_to_target = s->job->ret >= 0 &&
+     return ret;
-+                         !job_is_cancelled(&s->job->common.job) &&
+ }
-+                         s->job->copy_mode == MIRROR_COPY_MODE_WRITE_BLOCKING;
-+    }
+-static int GRAPH_UNLOCKED
++static int coroutine_fn GRAPH_UNLOCKED
-     if (copy_to_target) {
+ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
-         /* The guest might concurrently modify the data to write; but
+                  bool zeroed_grain, Error **errp)
  {
@@ -XXX,XX +XXX,XX @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
      int gd_buf_size;
      if (flat) {
 -        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, 0, errp);
 +        ret = blk_co_truncate(blk, filesize, false, PREALLOC_MODE_OFF, 0, errp);
          goto exit;
      }
      magic = cpu_to_be32(VMDK4_MAGIC);
@@ -XXX,XX +XXX,XX @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
      header.check_bytes[3] = 0xa;
      /* write all the data */
 -    ret = blk_pwrite(blk, 0, sizeof(magic), &magic, 0);
 +    ret = blk_co_pwrite(blk, 0, sizeof(magic), &magic, 0);
      if (ret < 0) {
          error_setg(errp, QERR_IO_ERROR);
          goto exit;
      }
 -    ret = blk_pwrite(blk, sizeof(magic), sizeof(header), &header, 0);
 +    ret = blk_co_pwrite(blk, sizeof(magic), sizeof(header), &header, 0);
      if (ret < 0) {
          error_setg(errp, QERR_IO_ERROR);
          goto exit;
      }
 -    ret = blk_truncate(blk, le64_to_cpu(header.grain_offset) << 9, false,
 -                       PREALLOC_MODE_OFF, 0, errp);
 +    ret = blk_co_truncate(blk, le64_to_cpu(header.grain_offset) << 9, false,
 +                          PREALLOC_MODE_OFF, 0, errp);
      if (ret < 0) {
          goto exit;
      }
@@ -XXX,XX +XXX,XX @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
           i < gt_count; i++, tmp += gt_size) {
          gd_buf[i] = cpu_to_le32(tmp);
      }
 -    ret = blk_pwrite(blk, le64_to_cpu(header.rgd_offset) * BDRV_SECTOR_SIZE,
 -                     gd_buf_size, gd_buf, 0);
 +    ret = blk_co_pwrite(blk, le64_to_cpu(header.rgd_offset) * BDRV_SECTOR_SIZE,
 +                        gd_buf_size, gd_buf, 0);
      if (ret < 0) {
          error_setg(errp, QERR_IO_ERROR);
          goto exit;
@@ -XXX,XX +XXX,XX @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
           i < gt_count; i++, tmp += gt_size) {
          gd_buf[i] = cpu_to_le32(tmp);
      }
 -    ret = blk_pwrite(blk, le64_to_cpu(header.gd_offset) * BDRV_SECTOR_SIZE,
 -                     gd_buf_size, gd_buf, 0);
 +    ret = blk_co_pwrite(blk, le64_to_cpu(header.gd_offset) * BDRV_SECTOR_SIZE,
 +                        gd_buf_size, gd_buf, 0);
      if (ret < 0) {
          error_setg(errp, QERR_IO_ERROR);
      }
 --
-.38.1
+.41.0

-[PULL 02/11] block/mirror: Drop mirror_wait_for_any_operation()
+[PULL 20/23] vhdx: mark more functions as coroutine_fns and GRAPH_RDLOCK
-From: Hanna Reitz <hreitz@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-mirror_wait_for_free_in_flight_slot() is the only remaining user of
+Mark functions as coroutine_fn when they are only called by other coroutine_fns
-mirror_wait_for_any_operation(), so inline the latter into the former.
+and they can suspend.  Change calls to co_wrappers to use the non-wrapped
 functions, which in turn requires adding GRAPH_RDLOCK annotations.
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-Message-Id: <20221109165452.67927-3-hreitz@redhat.com>
+Message-ID: <20230601115145.196465-10-pbonzini@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/mirror.c | 21 ++++++++-------------
+ block/vhdx.h     |  5 ++--
-file changed, 8 insertions(+), 13 deletions(-)
+ block/vhdx-log.c | 36 +++++++++++++-----------
  block/vhdx.c     | 73 +++++++++++++++++++++++-------------------------
 files changed, 57 insertions(+), 57 deletions(-)
-diff --git a/block/mirror.c b/block/mirror.c
+diff --git a/block/vhdx.h b/block/vhdx.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/mirror.c
+--- a/block/vhdx.h
-+++ b/block/mirror.c
++++ b/block/vhdx.h
-@@ -XXX,XX +XXX,XX @@ static int mirror_cow_align(MirrorBlockJob *s, int64_t *offset,
+@@ -XXX,XX +XXX,XX @@ bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset);
  int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed,
                     Error **errp);
 -int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
 -                             void *data, uint32_t length, uint64_t offset);
 +int coroutine_fn GRAPH_RDLOCK
 +vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
 +                         void *data, uint32_t length, uint64_t offset);
  static inline void leguid_to_cpus(MSGUID *guid)
  {
 diff --git a/block/vhdx-log.c b/block/vhdx-log.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vhdx-log.c
 +++ b/block/vhdx-log.c
@@ -XXX,XX +XXX,XX @@ exit:
   * It is assumed that 'buffer' is at least 4096*num_sectors large.
   *
   * 0 is returned on success, -errno otherwise */
 -static int vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log,
 -                                  uint32_t *sectors_written, void *buffer,
 -                                  uint32_t num_sectors)
 +static int coroutine_fn GRAPH_RDLOCK
 +vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log,
 +                       uint32_t *sectors_written, void *buffer,
 +                       uint32_t num_sectors)
  {
      int ret = 0;
      uint64_t offset;
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log,
              /* full */
              break;
          }
 -        ret = bdrv_pwrite(bs->file, offset, VHDX_LOG_SECTOR_SIZE, buffer_tmp,
 -                          0);
 +        ret = bdrv_co_pwrite(bs->file, offset, VHDX_LOG_SECTOR_SIZE, buffer_tmp, 0);
          if (ret < 0) {
              goto exit;
          }
@@ -XXX,XX +XXX,XX @@ static void vhdx_log_raw_to_le_sector(VHDXLogDescriptor *desc,
  }
- static inline void coroutine_fn
--mirror_wait_for_any_operation(MirrorBlockJob *s, bool active)
+-static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
-+mirror_wait_for_free_in_flight_slot(MirrorBlockJob *s)
+-                          void *data, uint32_t length, uint64_t offset)
- {
++static int coroutine_fn GRAPH_RDLOCK
-     MirrorOp *op;
++vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
++               void *data, uint32_t length, uint64_t offset)
-     QTAILQ_FOREACH(op, &s->ops_in_flight, next) {
+ {
--        /* Do not wait on pseudo ops, because it may in turn wait on
+     int ret = 0;
-+        /*
+     void *buffer = NULL;
-+         * Do not wait on pseudo ops, because it may in turn wait on
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
-          * some other operation to start, which may in fact be the
-          * caller of this function.  Since there is only one pseudo op
+     sectors += partial_sectors;
-          * at any given time, we will always find some real operation
--         * to wait on. */
+-    file_length = bdrv_getlength(bs->file->bs);
--        if (!op->is_pseudo_op && op->is_in_flight &&
++    file_length = bdrv_co_getlength(bs->file->bs);
--            op->is_active_write == active)
+     if (file_length < 0) {
--        {
+         ret = file_length;
-+         * to wait on.
+         goto exit;
-+         * Also, do not wait on active operations, because they do not
+@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
-+         * use up in-flight slots.
-+         */
+         if (i == 0 && leading_length) {
-+        if (!op->is_pseudo_op && op->is_in_flight && !op->is_active_write) {
+             /* partial sector at the front of the buffer */
-             qemu_co_queue_wait(&op->waiting_requests, NULL);
+-            ret = bdrv_pread(bs->file, file_offset, VHDX_LOG_SECTOR_SIZE,
-             return;
+-                             merged_sector, 0);
-         }
++            ret = bdrv_co_pread(bs->file, file_offset, VHDX_LOG_SECTOR_SIZE,
-@@ -XXX,XX +XXX,XX @@ mirror_wait_for_any_operation(MirrorBlockJob *s, bool active)
++                                merged_sector, 0);
-     abort();
+             if (ret < 0) {
                  goto exit;
              }
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
              sector_write = merged_sector;
          } else if (i == sectors - 1 && trailing_length) {
              /* partial sector at the end of the buffer */
 -            ret = bdrv_pread(bs->file, file_offset + trailing_length,
 -                             VHDX_LOG_SECTOR_SIZE - trailing_length,
 -                             merged_sector + trailing_length, 0);
 +            ret = bdrv_co_pread(bs->file, file_offset + trailing_length,
 +                                VHDX_LOG_SECTOR_SIZE - trailing_length,
 +                                merged_sector + trailing_length, 0);
              if (ret < 0) {
                  goto exit;
              }
@@ -XXX,XX +XXX,XX @@ exit:
  }
--static inline void coroutine_fn
+ /* Perform a log write, and then immediately flush the entire log */
--mirror_wait_for_free_in_flight_slot(MirrorBlockJob *s)
+-int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
--{
+-                             void *data, uint32_t length, uint64_t offset)
--    /* Only non-active operations use up in-flight slots */
++int coroutine_fn
--    mirror_wait_for_any_operation(s, false);
++vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
--}
++                         void *data, uint32_t length, uint64_t offset)
--
+ {
- /* Perform a mirror copy operation.
+     int ret = 0;
      VHDXLogSequence logs = { .valid = true,
@@ -XXX,XX +XXX,XX @@ int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
      /* Make sure data written (new and/or changed blocks) is stable
       * on disk, before creating log entry */
 -    ret = bdrv_flush(bs);
 +    ret = bdrv_co_flush(bs);
      if (ret < 0) {
          goto exit;
      }
@@ -XXX,XX +XXX,XX @@ int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
      logs.log = s->log;
      /* Make sure log is stable on disk */
 -    ret = bdrv_flush(bs);
 +    ret = bdrv_co_flush(bs);
      if (ret < 0) {
          goto exit;
      }
 diff --git a/block/vhdx.c b/block/vhdx.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vhdx.c
 +++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ exit:
   *
-  * *op->bytes_handled is set to the number of bytes copied after and
+  * Returns the file offset start of the new payload block
   */
 -static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
 -                               uint64_t *new_offset, bool *need_zero)
 +static int coroutine_fn GRAPH_RDLOCK
 +vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
 +                    uint64_t *new_offset, bool *need_zero)
  {
      int64_t current_len;
 -    current_len = bdrv_getlength(bs->file->bs);
 +    current_len = bdrv_co_getlength(bs->file->bs);
      if (current_len < 0) {
          return current_len;
      }
@@ -XXX,XX +XXX,XX @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
      if (*need_zero) {
          int ret;
 -        ret = bdrv_truncate(bs->file, *new_offset + s->block_size, false,
 -                            PREALLOC_MODE_OFF, BDRV_REQ_ZERO_WRITE, NULL);
 +        ret = bdrv_co_truncate(bs->file, *new_offset + s->block_size, false,
 +                               PREALLOC_MODE_OFF, BDRV_REQ_ZERO_WRITE, NULL);
          if (ret != -ENOTSUP) {
              *need_zero = false;
              return ret;
          }
      }
 -    return bdrv_truncate(bs->file, *new_offset + s->block_size, false,
 -                         PREALLOC_MODE_OFF, 0, NULL);
 +    return bdrv_co_truncate(bs->file, *new_offset + s->block_size, false,
 +                            PREALLOC_MODE_OFF, 0, NULL);
  }
  /*
@@ -XXX,XX +XXX,XX @@ exit:
   * The first 64KB of the Metadata section is reserved for the metadata
   * header and entries; beyond that, the metadata items themselves reside.
   */
 -static int vhdx_create_new_metadata(BlockBackend *blk,
 -                                    uint64_t image_size,
 -                                    uint32_t block_size,
 -                                    uint32_t sector_size,
 -                                    uint64_t metadata_offset,
 -                                    VHDXImageType type)
 +static int coroutine_fn
 +vhdx_create_new_metadata(BlockBackend *blk, uint64_t image_size,
 +                         uint32_t block_size, uint32_t sector_size,
 +                         uint64_t metadata_offset, VHDXImageType type)
  {
      int ret = 0;
      uint32_t offset = 0;
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_new_metadata(BlockBackend *blk,
                                     VHDX_META_FLAGS_IS_VIRTUAL_DISK;
      vhdx_metadata_entry_le_export(&md_table_entry[4]);
 -    ret = blk_pwrite(blk, metadata_offset, VHDX_HEADER_BLOCK_SIZE, buffer, 0);
 +    ret = blk_co_pwrite(blk, metadata_offset, VHDX_HEADER_BLOCK_SIZE, buffer, 0);
      if (ret < 0) {
          goto exit;
      }
 -    ret = blk_pwrite(blk, metadata_offset + (64 * KiB),
 -                     VHDX_METADATA_ENTRY_BUFFER_SIZE, entry_buffer, 0);
 +    ret = blk_co_pwrite(blk, metadata_offset + (64 * KiB),
 +                        VHDX_METADATA_ENTRY_BUFFER_SIZE, entry_buffer, 0);
      if (ret < 0) {
          goto exit;
      }
@@ -XXX,XX +XXX,XX @@ exit:
   *  Fixed images: default state of the BAT is fully populated, with
   *                file offsets and state PAYLOAD_BLOCK_FULLY_PRESENT.
   */
 -static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
 -                           uint64_t image_size, VHDXImageType type,
 -                           bool use_zero_blocks, uint64_t file_offset,
 -                           uint32_t length, Error **errp)
 +static int coroutine_fn
 +vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
 +                uint64_t image_size, VHDXImageType type,
 +                bool use_zero_blocks, uint64_t file_offset,
 +                uint32_t length, Error **errp)
  {
      int ret = 0;
      uint64_t data_file_offset;
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
      if (type == VHDX_TYPE_DYNAMIC) {
          /* All zeroes, so we can just extend the file - the end of the BAT
           * is the furthest thing we have written yet */
 -        ret = blk_truncate(blk, data_file_offset, false, PREALLOC_MODE_OFF,
 -                           0, errp);
 +        ret = blk_co_truncate(blk, data_file_offset, false, PREALLOC_MODE_OFF,
 +                              0, errp);
          if (ret < 0) {
              goto exit;
          }
      } else if (type == VHDX_TYPE_FIXED) {
 -        ret = blk_truncate(blk, data_file_offset + image_size, false,
 -                           PREALLOC_MODE_OFF, 0, errp);
 +        ret = blk_co_truncate(blk, data_file_offset + image_size, false,
 +                              PREALLOC_MODE_OFF, 0, errp);
          if (ret < 0) {
              goto exit;
          }
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
              s->bat[sinfo.bat_idx] = cpu_to_le64(s->bat[sinfo.bat_idx]);
              sector_num += s->sectors_per_block;
          }
 -        ret = blk_pwrite(blk, file_offset, length, s->bat, 0);
 +        ret = blk_co_pwrite(blk, file_offset, length, s->bat, 0);
          if (ret < 0) {
              error_setg_errno(errp, -ret, "Failed to write the BAT");
              goto exit;
@@ -XXX,XX +XXX,XX @@ exit:
   * to create the BAT itself, we will also cause the BAT to be
   * created.
   */
 -static int vhdx_create_new_region_table(BlockBackend *blk,
 -                                        uint64_t image_size,
 -                                        uint32_t block_size,
 -                                        uint32_t sector_size,
 -                                        uint32_t log_size,
 -                                        bool use_zero_blocks,
 -                                        VHDXImageType type,
 -                                        uint64_t *metadata_offset,
 -                                        Error **errp)
 +static int coroutine_fn
 +vhdx_create_new_region_table(BlockBackend *blk, uint64_t image_size,
 +                             uint32_t block_size, uint32_t sector_size,
 +                             uint32_t log_size, bool use_zero_blocks,
 +                             VHDXImageType type, uint64_t *metadata_offset,
 +                             Error **errp)
  {
      int ret = 0;
      uint32_t offset = 0;
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_new_region_table(BlockBackend *blk,
      }
      /* Now write out the region headers to disk */
 -    ret = blk_pwrite(blk, VHDX_REGION_TABLE_OFFSET, VHDX_HEADER_BLOCK_SIZE,
 -                     buffer, 0);
 +    ret = blk_co_pwrite(blk, VHDX_REGION_TABLE_OFFSET, VHDX_HEADER_BLOCK_SIZE,
 +                        buffer, 0);
      if (ret < 0) {
          error_setg_errno(errp, -ret, "Failed to write first region table");
          goto exit;
      }
 -    ret = blk_pwrite(blk, VHDX_REGION_TABLE2_OFFSET, VHDX_HEADER_BLOCK_SIZE,
 -                     buffer, 0);
 +    ret = blk_co_pwrite(blk, VHDX_REGION_TABLE2_OFFSET, VHDX_HEADER_BLOCK_SIZE,
 +                        buffer, 0);
      if (ret < 0) {
          error_setg_errno(errp, -ret, "Failed to write second region table");
          goto exit;
 --
-.38.1
+.41.0

-[PULL 09/11] block-backend: Update ctx immediately after root
+[PULL 21/23] qcow2: mark more functions as coroutine_fns and GRAPH_RDLOCK
-From: Hanna Reitz <hreitz@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-blk_get_aio_context() asserts that blk->ctx is always equal to the root
+Mark functions as coroutine_fn when they are only called by other coroutine_fns
-BDS's context (if there is a root BDS).  Therefore,
+and they can suspend.  Change calls to co_wrappers to use the non-wrapped
-blk_do_set_aio_context() must update blk->ctx immediately after the root
+functions, which in turn requires adding GRAPH_RDLOCK annotations.
 BDS's context has changed.
-Without this patch, the next patch would break iotest 238, because
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-bdrv_drained_begin() (called by blk_do_set_aio_context()) may then
+Message-ID: <20230601115145.196465-11-pbonzini@redhat.com>
 invoke bdrv_child_get_parent_aio_context() on the root child, i.e.
 blk_get_aio_context().  However, by this point, blk->ctx would not have
 been updated and thus differ from the root node's context.  This patch
 fixes that.
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20221107151321.211175-3-hreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/block-backend.c | 8 +++++++-
+ block/qcow2.h          |  33 +++++------
-file changed, 7 insertions(+), 1 deletion(-)
+ block/qcow2-bitmap.c   |  26 +++++----
  block/qcow2-cluster.c  |  12 ++--
  block/qcow2-refcount.c | 130 +++++++++++++++++++++--------------------
  block/qcow2.c          |   2 +-
 files changed, 105 insertions(+), 98 deletions(-)
-diff --git a/block/block-backend.c b/block/block-backend.c
+diff --git a/block/qcow2.h b/block/qcow2.h
 index XXXXXXX..XXXXXXX 100644
---- a/block/block-backend.c
+--- a/block/qcow2.h
-+++ b/block/block-backend.c
++++ b/block/qcow2.h
-@@ -XXX,XX +XXX,XX @@ static int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context,
+@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,
-                 return ret;
  int qcow2_mark_dirty(BlockDriverState *bs);
  int qcow2_mark_corrupt(BlockDriverState *bs);
 -int qcow2_mark_consistent(BlockDriverState *bs);
  int qcow2_update_header(BlockDriverState *bs);
  void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t offset,
  int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size);
  int64_t coroutine_fn qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
                                               int64_t nb_clusters);
 -int64_t coroutine_fn qcow2_alloc_bytes(BlockDriverState *bs, int size);
 +int64_t coroutine_fn GRAPH_RDLOCK qcow2_alloc_bytes(BlockDriverState *bs, int size);
  void qcow2_free_clusters(BlockDriverState *bs,
                            int64_t offset, int64_t size,
                            enum qcow2_discard_type type);
@@ -XXX,XX +XXX,XX @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
  int qcow2_flush_caches(BlockDriverState *bs);
  int qcow2_write_caches(BlockDriverState *bs);
 -int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 -                          BdrvCheckMode fix);
 +int coroutine_fn qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 +                                       BdrvCheckMode fix);
  void qcow2_process_discards(BlockDriverState *bs, int ret);
@@ -XXX,XX +XXX,XX @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
                                   int64_t size);
  int qcow2_pre_write_overlap_check(BlockDriverState *bs, int ign, int64_t offset,
                                    int64_t size, bool data_file);
 -int qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
 -                             void **refcount_table,
 -                             int64_t *refcount_table_size,
 -                             int64_t offset, int64_t size);
 +int coroutine_fn qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
 +                                          void **refcount_table,
 +                                          int64_t *refcount_table_size,
 +                                          int64_t offset, int64_t size);
  int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
                                  BlockDriverAmendStatusCB *status_cb,
@@ -XXX,XX +XXX,XX @@ int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset,
  int coroutine_fn qcow2_alloc_host_offset(BlockDriverState *bs, uint64_t offset,
                                           unsigned int *bytes,
                                           uint64_t *host_offset, QCowL2Meta **m);
 -int coroutine_fn qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
 -                                                       uint64_t offset,
 -                                                       int compressed_size,
 -                                                       uint64_t *host_offset);
 +int coroutine_fn GRAPH_RDLOCK
 +qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, uint64_t offset,
 +                                      int compressed_size, uint64_t *host_offset);
  void qcow2_parse_compressed_l2_entry(BlockDriverState *bs, uint64_t l2_entry,
                                       uint64_t *coffset, int *csize);
@@ -XXX,XX +XXX,XX @@ void *qcow2_cache_is_table_offset(Qcow2Cache *c, uint64_t offset);
  void qcow2_cache_discard(Qcow2Cache *c, void *table);
  /* qcow2-bitmap.c functions */
 -int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 -                                  void **refcount_table,
 -                                  int64_t *refcount_table_size);
 -bool coroutine_fn qcow2_load_dirty_bitmaps(BlockDriverState *bs,
 -                                           bool *header_updated, Error **errp);
 +int coroutine_fn
 +qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 +                              void **refcount_table,
 +                              int64_t *refcount_table_size);
 +bool coroutine_fn GRAPH_RDLOCK
 +qcow2_load_dirty_bitmaps(BlockDriverState *bs, bool *header_updated, Error **errp);
  bool qcow2_get_bitmap_info_list(BlockDriverState *bs,
                                  Qcow2BitmapInfoList **info_list, Error **errp);
  int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp);
 diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2-bitmap.c
 +++ b/block/qcow2-bitmap.c
@@ -XXX,XX +XXX,XX @@ static int free_bitmap_clusters(BlockDriverState *bs, Qcow2BitmapTable *tb)
  /* load_bitmap_data
   * @bitmap_table entries must satisfy specification constraints.
   * @bitmap must be cleared */
 -static int load_bitmap_data(BlockDriverState *bs,
 -                            const uint64_t *bitmap_table,
 -                            uint32_t bitmap_table_size,
 -                            BdrvDirtyBitmap *bitmap)
 +static int coroutine_fn GRAPH_RDLOCK
 +load_bitmap_data(BlockDriverState *bs, const uint64_t *bitmap_table,
 +                 uint32_t bitmap_table_size, BdrvDirtyBitmap *bitmap)
  {
      int ret = 0;
      BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static int load_bitmap_data(BlockDriverState *bs,
                   * already cleared */
              }
          } else {
 -            ret = bdrv_pread(bs->file, data_offset, s->cluster_size, buf, 0);
 +            ret = bdrv_co_pread(bs->file, data_offset, s->cluster_size, buf, 0);
              if (ret < 0) {
                  goto finish;
              }
@@ -XXX,XX +XXX,XX @@ finish:
      return ret;
  }
 -static BdrvDirtyBitmap *load_bitmap(BlockDriverState *bs,
 -                                    Qcow2Bitmap *bm, Error **errp)
 +static coroutine_fn GRAPH_RDLOCK
 +BdrvDirtyBitmap *load_bitmap(BlockDriverState *bs,
 +                             Qcow2Bitmap *bm, Error **errp)
  {
      int ret;
      uint64_t *bitmap_table = NULL;
@@ -XXX,XX +XXX,XX @@ fail:
      return NULL;
  }
 -int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 -                                  void **refcount_table,
 -                                  int64_t *refcount_table_size)
 +int coroutine_fn
 +qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 +                              void **refcount_table,
 +                              int64_t *refcount_table_size)
  {
      int ret;
      BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static void set_readonly_helper(gpointer bitmap, gpointer value)
   * If header_updated is not NULL then it is set appropriately regardless of
   * the return value.
   */
 -bool coroutine_fn qcow2_load_dirty_bitmaps(BlockDriverState *bs,
 -                                           bool *header_updated, Error **errp)
 +bool coroutine_fn GRAPH_RDLOCK
 +qcow2_load_dirty_bitmaps(BlockDriverState *bs,
 +                         bool *header_updated, Error **errp)
  {
      BDRVQcow2State *s = bs->opaque;
      Qcow2BitmapList *bm_list;
 diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2-cluster.c
 +++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ static int get_cluster_table(BlockDriverState *bs, uint64_t offset,
   *
   * Return 0 on success and -errno in error cases
   */
 -int coroutine_fn qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
 -                                                       uint64_t offset,
 -                                                       int compressed_size,
 -                                                       uint64_t *host_offset)
 +int coroutine_fn GRAPH_RDLOCK
 +qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, uint64_t offset,
 +                                      int compressed_size, uint64_t *host_offset)
  {
      BDRVQcow2State *s = bs->opaque;
      int l2_index, ret;
@@ -XXX,XX +XXX,XX @@ fail:
   * all clusters in the same L2 slice) and returns the number of zeroed
   * clusters.
   */
 -static int zero_in_l2_slice(BlockDriverState *bs, uint64_t offset,
 -                            uint64_t nb_clusters, int flags)
 +static int coroutine_fn
 +zero_in_l2_slice(BlockDriverState *bs, uint64_t offset,
 +                 uint64_t nb_clusters, int flags)
  {
      BDRVQcow2State *s = bs->opaque;
      uint64_t *l2_slice;
 diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2-refcount.c
 +++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@ int64_t coroutine_fn qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offs
  /* only used to allocate compressed sectors. We try to allocate
     contiguous sectors. size must be <= cluster_size */
 -int64_t coroutine_fn qcow2_alloc_bytes(BlockDriverState *bs, int size)
 +int64_t coroutine_fn GRAPH_RDLOCK qcow2_alloc_bytes(BlockDriverState *bs, int size)
  {
      BDRVQcow2State *s = bs->opaque;
      int64_t offset;
@@ -XXX,XX +XXX,XX @@ static int realloc_refcount_array(BDRVQcow2State *s, void **array,
   *
   * Modifies the number of errors in res.
   */
 -int qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
 -                             void **refcount_table,
 -                             int64_t *refcount_table_size,
 -                             int64_t offset, int64_t size)
 +int coroutine_fn GRAPH_RDLOCK
 +qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
 +                         void **refcount_table,
 +                         int64_t *refcount_table_size,
 +                         int64_t offset, int64_t size)
  {
      BDRVQcow2State *s = bs->opaque;
      uint64_t start, last, cluster_offset, k, refcount;
@@ -XXX,XX +XXX,XX @@ int qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
          return 0;
      }
 -    file_len = bdrv_getlength(bs->file->bs);
 +    file_len = bdrv_co_getlength(bs->file->bs);
      if (file_len < 0) {
          return file_len;
      }
@@ -XXX,XX +XXX,XX @@ enum {
   *
   * On failure in-memory @l2_table may be modified.
   */
 -static int fix_l2_entry_by_zero(BlockDriverState *bs, BdrvCheckResult *res,
 -                                uint64_t l2_offset,
 -                                uint64_t *l2_table, int l2_index, bool active,
 -                                bool *metadata_overlap)
 +static int coroutine_fn GRAPH_RDLOCK
 +fix_l2_entry_by_zero(BlockDriverState *bs, BdrvCheckResult *res,
 +                     uint64_t l2_offset, uint64_t *l2_table,
 +                     int l2_index, bool active,
 +                     bool *metadata_overlap)
  {
      BDRVQcow2State *s = bs->opaque;
      int ret;
@@ -XXX,XX +XXX,XX @@ static int fix_l2_entry_by_zero(BlockDriverState *bs, BdrvCheckResult *res,
          goto fail;
      }
 -    ret = bdrv_pwrite_sync(bs->file, l2e_offset, l2_entry_size(s),
 -                           &l2_table[idx], 0);
 +    ret = bdrv_co_pwrite_sync(bs->file, l2e_offset, l2_entry_size(s),
 +                              &l2_table[idx], 0);
      if (ret < 0) {
          fprintf(stderr, "ERROR: Failed to overwrite L2 "
                  "table entry: %s\n", strerror(-ret));
@@ -XXX,XX +XXX,XX @@ fail:
   * Returns the number of errors found by the checks or -errno if an internal
   * error occurred.
   */
 -static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
 -                              void **refcount_table,
 -                              int64_t *refcount_table_size, int64_t l2_offset,
 -                              int flags, BdrvCheckMode fix, bool active)
 +static int coroutine_fn GRAPH_RDLOCK
 +check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
 +                   void **refcount_table,
 +                   int64_t *refcount_table_size, int64_t l2_offset,
 +                   int flags, BdrvCheckMode fix, bool active)
  {
      BDRVQcow2State *s = bs->opaque;
      uint64_t l2_entry, l2_bitmap;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
      bool metadata_overlap;
      /* Read L2 table from disk */
 -    ret = bdrv_pread(bs->file, l2_offset, l2_size_bytes, l2_table, 0);
 +    ret = bdrv_co_pread(bs->file, l2_offset, l2_size_bytes, l2_table, 0);
      if (ret < 0) {
          fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");
          res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
   * Returns the number of errors found by the checks or -errno if an internal
   * error occurred.
   */
 -static int check_refcounts_l1(BlockDriverState *bs,
 -                              BdrvCheckResult *res,
 -                              void **refcount_table,
 -                              int64_t *refcount_table_size,
 -                              int64_t l1_table_offset, int l1_size,
 -                              int flags, BdrvCheckMode fix, bool active)
 +static int coroutine_fn GRAPH_RDLOCK
 +check_refcounts_l1(BlockDriverState *bs, BdrvCheckResult *res,
 +                   void **refcount_table, int64_t *refcount_table_size,
 +                   int64_t l1_table_offset, int l1_size,
 +                   int flags, BdrvCheckMode fix, bool active)
  {
      BDRVQcow2State *s = bs->opaque;
      size_t l1_size_bytes = l1_size * L1E_SIZE;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
      }
      /* Read L1 table entries from disk */
 -    ret = bdrv_pread(bs->file, l1_table_offset, l1_size_bytes, l1_table, 0);
 +    ret = bdrv_co_pread(bs->file, l1_table_offset, l1_size_bytes, l1_table, 0);
      if (ret < 0) {
          fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");
          res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
   * have been already detected and sufficiently signaled by the calling function
   * (qcow2_check_refcounts) by the time this function is called).
   */
 -static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
 -                              BdrvCheckMode fix)
 +static int coroutine_fn GRAPH_RDLOCK
 +check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
  {
      BDRVQcow2State *s = bs->opaque;
      uint64_t *l2_table = qemu_blockalign(bs, s->cluster_size);
@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
              }
          }
-+        /*
-+         * Make blk->ctx consistent with the root node before we invoke any
+-        ret = bdrv_pread(bs->file, l2_offset, s->l2_size * l2_entry_size(s),
-+         * other operations like drain that might inquire blk->ctx
+-                         l2_table, 0);
-+         */
++        ret = bdrv_co_pread(bs->file, l2_offset, s->l2_size * l2_entry_size(s),
-+        blk->ctx = new_context;
++                            l2_table, 0);
-         if (tgm->throttle_state) {
+         if (ret < 0) {
-             bdrv_drained_begin(bs);
+             fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
-             throttle_group_detach_aio_context(tgm);
+                     strerror(-ret));
-@@ -XXX,XX +XXX,XX @@ static int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context,
+@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
-         }
+                 goto fail;
+             }
-         bdrv_unref(bs);
-+    } else {
+-            ret = bdrv_pwrite(bs->file, l2_offset, s->cluster_size, l2_table,
-+        blk->ctx = new_context;
+-                              0);
 +            ret = bdrv_co_pwrite(bs->file, l2_offset, s->cluster_size, l2_table, 0);
              if (ret < 0) {
                  fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
                          strerror(-ret));
@@ -XXX,XX +XXX,XX @@ fail:
   * Checks consistency of refblocks and accounts for each refblock in
   * *refcount_table.
   */
 -static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
 -                           BdrvCheckMode fix, bool *rebuild,
 -                           void **refcount_table, int64_t *nb_clusters)
 +static int coroutine_fn GRAPH_RDLOCK
 +check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
 +                BdrvCheckMode fix, bool *rebuild,
 +                void **refcount_table, int64_t *nb_clusters)
  {
      BDRVQcow2State *s = bs->opaque;
      int64_t i, size;
@@ -XXX,XX +XXX,XX @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
                      goto resize_fail;
                  }
 -                ret = bdrv_truncate(bs->file, offset + s->cluster_size, false,
 -                                    PREALLOC_MODE_OFF, 0, &local_err);
 +                ret = bdrv_co_truncate(bs->file, offset + s->cluster_size, false,
 +                                       PREALLOC_MODE_OFF, 0, &local_err);
                  if (ret < 0) {
                      error_report_err(local_err);
                      goto resize_fail;
                  }
 -                size = bdrv_getlength(bs->file->bs);
 +                size = bdrv_co_getlength(bs->file->bs);
                  if (size < 0) {
                      ret = size;
                      goto resize_fail;
@@ -XXX,XX +XXX,XX @@ resize_fail:
  /*
   * Calculates an in-memory refcount table.
   */
 -static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 -                               BdrvCheckMode fix, bool *rebuild,
 -                               void **refcount_table, int64_t *nb_clusters)
 +static int coroutine_fn GRAPH_RDLOCK
 +calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 +                    BdrvCheckMode fix, bool *rebuild,
 +                    void **refcount_table, int64_t *nb_clusters)
  {
      BDRVQcow2State *s = bs->opaque;
      int64_t i;
@@ -XXX,XX +XXX,XX @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
   * Compares the actual reference count for each cluster in the image against the
   * refcount as reported by the refcount structures on-disk.
   */
 -static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 -                              BdrvCheckMode fix, bool *rebuild,
 -                              int64_t *highest_cluster,
 -                              void *refcount_table, int64_t nb_clusters)
 +static void coroutine_fn
 +compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 +                  BdrvCheckMode fix, bool *rebuild,
 +                  int64_t *highest_cluster,
 +                  void *refcount_table, int64_t nb_clusters)
  {
      BDRVQcow2State *s = bs->opaque;
      int64_t i;
@@ -XXX,XX +XXX,XX @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs,
   * Return whether the on-disk reftable array was resized (true/false),
   * or -errno on error.
   */
 -static int rebuild_refcounts_write_refblocks(
 +static int coroutine_fn GRAPH_RDLOCK
 +rebuild_refcounts_write_refblocks(
          BlockDriverState *bs, void **refcount_table, int64_t *nb_clusters,
          int64_t first_cluster, int64_t end_cluster,
          uint64_t **on_disk_reftable_ptr, uint32_t *on_disk_reftable_entries_ptr,
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcounts_write_refblocks(
          on_disk_refblock = (void *)((char *) *refcount_table +
                                      refblock_index * s->cluster_size);
 -        ret = bdrv_pwrite(bs->file, refblock_offset, s->cluster_size,
 -                          on_disk_refblock, 0);
 +        ret = bdrv_co_pwrite(bs->file, refblock_offset, s->cluster_size,
 +                             on_disk_refblock, 0);
          if (ret < 0) {
              error_setg_errno(errp, -ret, "ERROR writing refblock");
              return ret;
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcounts_write_refblocks(
   * On success, the old refcount structure is leaked (it will be covered by the
   * new refcount structure).
   */
 -static int rebuild_refcount_structure(BlockDriverState *bs,
 -                                      BdrvCheckResult *res,
 -                                      void **refcount_table,
 -                                      int64_t *nb_clusters,
 -                                      Error **errp)
 +static int coroutine_fn GRAPH_RDLOCK
 +rebuild_refcount_structure(BlockDriverState *bs, BdrvCheckResult *res,
 +                           void **refcount_table, int64_t *nb_clusters,
 +                           Error **errp)
  {
      BDRVQcow2State *s = bs->opaque;
      int64_t reftable_offset = -1;
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
      }
--    blk->ctx = new_context;
+     assert(reftable_length < INT_MAX);
-     return 0;
+-    ret = bdrv_pwrite(bs->file, reftable_offset, reftable_length,
 -                      on_disk_reftable, 0);
 +    ret = bdrv_co_pwrite(bs->file, reftable_offset, reftable_length,
 +                         on_disk_reftable, 0);
      if (ret < 0) {
          error_setg_errno(errp, -ret, "ERROR writing reftable");
          goto fail;
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
      reftable_offset_and_clusters.reftable_offset = cpu_to_be64(reftable_offset);
      reftable_offset_and_clusters.reftable_clusters =
          cpu_to_be32(reftable_clusters);
 -    ret = bdrv_pwrite_sync(bs->file,
 -                           offsetof(QCowHeader, refcount_table_offset),
 -                           sizeof(reftable_offset_and_clusters),
 -                           &reftable_offset_and_clusters, 0);
 +    ret = bdrv_co_pwrite_sync(bs->file,
 +                              offsetof(QCowHeader, refcount_table_offset),
 +                              sizeof(reftable_offset_and_clusters),
 +                              &reftable_offset_and_clusters, 0);
      if (ret < 0) {
          error_setg_errno(errp, -ret, "ERROR setting reftable");
          goto fail;
@@ -XXX,XX +XXX,XX @@ fail:
   * Returns 0 if no errors are found, the number of errors in case the image is
   * detected as corrupted, and -errno when an internal error occurred.
   */
 -int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
 -                          BdrvCheckMode fix)
 +int coroutine_fn GRAPH_RDLOCK
 +qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
  {
      BDRVQcow2State *s = bs->opaque;
      BdrvCheckResult pre_compare_res;
@@ -XXX,XX +XXX,XX @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
      bool rebuild = false;
      int ret;
 -    size = bdrv_getlength(bs->file->bs);
 +    size = bdrv_co_getlength(bs->file->bs);
      if (size < 0) {
          res->check_errors++;
          return size;
@@ -XXX,XX +XXX,XX @@ done:
      return ret;
  }
+-static int64_t get_refblock_offset(BlockDriverState *bs, uint64_t offset)
++static int64_t coroutine_fn get_refblock_offset(BlockDriverState *bs,
++                                                uint64_t offset)
+ {
+     BDRVQcow2State *s = bs->opaque;
+     uint32_t index = offset_to_reftable_index(s, offset);
+@@ -XXX,XX +XXX,XX @@ int64_t coroutine_fn qcow2_get_last_cluster(BlockDriverState *bs, int64_t size)
+     return -EIO;
+ }
+-int coroutine_fn qcow2_detect_metadata_preallocation(BlockDriverState *bs)
++int coroutine_fn GRAPH_RDLOCK
++qcow2_detect_metadata_preallocation(BlockDriverState *bs)
+ {
+     BDRVQcow2State *s = bs->opaque;
+     int64_t i, end_cluster, cluster_count = 0, threshold;
+diff --git a/block/qcow2.c b/block/qcow2.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qcow2.c
++++ b/block/qcow2.c
+@@ -XXX,XX +XXX,XX @@ int qcow2_mark_corrupt(BlockDriverState *bs)
+  * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
+  * before if necessary.
+  */
+-int qcow2_mark_consistent(BlockDriverState *bs)
++static int coroutine_fn qcow2_mark_consistent(BlockDriverState *bs)
+ {
+     BDRVQcow2State *s = bs->opaque;
 --
-.38.1
+.41.0

-[PULL 01/11] block/mirror: Do not wait for active writes
+[PULL 22/23] block: use bdrv_co_getlength in coroutine context
-From: Hanna Reitz <hreitz@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-Waiting for all active writes to settle before daring to create a
+bdrv_co_getlength was recently introduced, with bdrv_getlength becoming
-background copying operation means that we will never do background
+a wrapper for use in unknown context.  Switch to bdrv_co_getlength when
-operations while the guest does anything (in write-blocking mode), and
+possible.
 therefore cannot converge.  Yes, we also will not diverge, but actually
 converging would be even nicer.
-It is unclear why we did decide to wait for all active writes to settle
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-before creating a background operation, but it just does not seem
+Message-ID: <20230601115145.196465-12-pbonzini@redhat.com>
 necessary.  Active writes will put themselves into the in_flight bitmap
 and thus properly block actually conflicting background requests.
 It is important for active requests to wait on overlapping background
 requests, which we do in active_write_prepare().  However, so far it was
 not documented why it is important.  Add such documentation now, and
 also to the other call of mirror_wait_on_conflicts(), so that it becomes
 more clear why and when requests need to actively wait for other
 requests to settle.
 Another thing to note is that of course we need to ensure that there are
 no active requests when the job completes, but that is done by virtue of
 the BDS being drained anyway, so there cannot be any active requests at
 that point.
 With this change, we will need to explicitly keep track of how many
 bytes are in flight in active requests so that
 job_progress_set_remaining() in mirror_run() can set the correct number
 of remaining bytes.
 Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=2123297
 Signed-off-by: Hanna Reitz <hreitz@redhat.com>
 Message-Id: <20221109165452.67927-2-hreitz@redhat.com>
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/mirror.c | 37 ++++++++++++++++++++++++++++++-------
+ block/io.c        | 10 +++++-----
-file changed, 30 insertions(+), 7 deletions(-)
+ block/parallels.c |  4 ++--
  block/qcow.c      |  6 +++---
  block/vmdk.c      |  4 ++--
 files changed, 12 insertions(+), 12 deletions(-)
-diff --git a/block/mirror.c b/block/mirror.c
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/mirror.c
+--- a/block/io.c
-+++ b/block/mirror.c
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ typedef struct MirrorBlockJob {
+@@ -XXX,XX +XXX,XX @@ bdrv_aligned_preadv(BdrvChild *child, BdrvTrackedRequest *req,
      int max_iov;
      bool initial_zeroing_ongoing;
      int in_active_write_counter;
 +    int64_t active_write_bytes_in_flight;
      bool prepared;
      bool in_drain;
  } MirrorBlockJob;
@@ -XXX,XX +XXX,XX @@ static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s)
      }
-     bdrv_dirty_bitmap_unlock(s->dirty_bitmap);
+     /* Forward the request to the BlockDriver, possibly fragmenting it */
-+    /*
+-    total_bytes = bdrv_getlength(bs);
-+     * Wait for concurrent requests to @offset.  The next loop will limit the
++    total_bytes = bdrv_co_getlength(bs);
-+     * copied area based on in_flight_bitmap so we only copy an area that does
+     if (total_bytes < 0) {
-+     * not overlap with concurrent in-flight requests.  Still, we would like to
+         ret = total_bytes;
-+     * copy something, so wait until there are at least no more requests to the
+         goto out;
-+     * very beginning of the area.
+@@ -XXX,XX +XXX,XX @@ bdrv_co_block_status(BlockDriverState *bs, bool want_zero,
-+     */
+     assert(pnum);
-     mirror_wait_on_conflicts(NULL, s, offset, 1);
+     assert_bdrv_graph_readable();
+     *pnum = 0;
-     job_pause_point(&s->common.job);
+-    total_size = bdrv_getlength(bs);
-@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
++    total_size = bdrv_co_getlength(bs);
-         int64_t cnt, delta;
+     if (total_size < 0) {
-         bool should_complete;
+         ret = total_size;
+         goto early_out;
--        /* Do not start passive operations while there are active
+@@ -XXX,XX +XXX,XX @@ bdrv_co_block_status(BlockDriverState *bs, bool want_zero,
--         * writes in progress */
+         bytes = n;
 -        while (s->in_active_write_counter) {
 -            mirror_wait_for_any_operation(s, true);
 -        }
 -
          if (s->ret < 0) {
              ret = s->ret;
              goto immediate_exit;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
          /* cnt is the number of dirty bytes remaining and s->bytes_in_flight is
           * the number of bytes currently being processed; together those are
           * the current remaining operation length */
 -        job_progress_set_remaining(&s->common.job, s->bytes_in_flight + cnt);
 +        job_progress_set_remaining(&s->common.job,
 +                                   s->bytes_in_flight + cnt +
 +                                   s->active_write_bytes_in_flight);
          /* Note that even when no rate limit is applied we need to yield
           * periodically with no pending I/O so that bdrv_drain_all() returns.
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
              s->in_drain = true;
              bdrv_drained_begin(bs);
 +
 +            /* Must be zero because we are drained */
 +            assert(s->in_active_write_counter == 0);
 +
              cnt = bdrv_get_dirty_count(s->dirty_bitmap);
              if (cnt > 0 || mirror_flush(s) < 0) {
                  bdrv_drained_end(bs);
@@ -XXX,XX +XXX,XX @@ do_sync_target_write(MirrorBlockJob *job, MirrorMethod method,
      }
-     job_progress_increase_remaining(&job->common.job, bytes);
+-    /* Must be non-NULL or bdrv_getlength() would have failed */
-+    job->active_write_bytes_in_flight += bytes;
++    /* Must be non-NULL or bdrv_co_getlength() would have failed */
+     assert(bs->drv);
-     switch (method) {
+     has_filtered_child = bdrv_filter_child(bs);
-     case MIRROR_METHOD_COPY:
+     if (!bs->drv->bdrv_co_block_status && !has_filtered_child) {
-@@ -XXX,XX +XXX,XX @@ do_sync_target_write(MirrorBlockJob *job, MirrorMethod method,
+@@ -XXX,XX +XXX,XX @@ bdrv_co_block_status(BlockDriverState *bs, bool want_zero,
-         abort();
+         if (!cow_bs) {
              ret |= BDRV_BLOCK_ZERO;
          } else if (want_zero) {
 -            int64_t size2 = bdrv_getlength(cow_bs);
 +            int64_t size2 = bdrv_co_getlength(cow_bs);
              if (size2 >= 0 && offset >= size2) {
                  ret |= BDRV_BLOCK_ZERO;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
          return ret;
      }
-+    job->active_write_bytes_in_flight -= bytes;
+-    old_size = bdrv_getlength(bs);
-     if (ret >= 0) {
++    old_size = bdrv_co_getlength(bs);
-         job_progress_update(&job->common.job, bytes);
+     if (old_size < 0) {
-     } else {
+         error_setg_errno(errp, -old_size, "Failed to get old image size");
-@@ -XXX,XX +XXX,XX @@ static MirrorOp *coroutine_fn active_write_prepare(MirrorBlockJob *s,
+         return old_size;
+diff --git a/block/parallels.c b/block/parallels.c
-     s->in_active_write_counter++;
+index XXXXXXX..XXXXXXX 100644
+--- a/block/parallels.c
-+    /*
++++ b/block/parallels.c
-+     * Wait for concurrent requests affecting the area.  If there are already
+@@ -XXX,XX +XXX,XX @@ allocate_clusters(BlockDriverState *bs, int64_t sector_num,
-+     * running requests that are copying off now-to-be stale data in the area,
+     assert(idx < s->bat_size && idx + to_allocate <= s->bat_size);
-+     * we must wait for them to finish before we begin writing fresh data to the
-+     * target so that the write operations appear in the correct order.
+     space = to_allocate * s->tracks;
-+     * Note that background requests (see mirror_iteration()) in contrast only
+-    len = bdrv_getlength(bs->file->bs);
-+     * wait for conflicting requests at the start of the dirty area, and then
++    len = bdrv_co_getlength(bs->file->bs);
-+     * (based on the in_flight_bitmap) truncate the area to copy so it will not
+     if (len < 0) {
-+     * conflict with any requests beyond that.  For active writes, however, we
+         return len;
-+     * cannot truncate that area.  The request from our parent must be blocked
+     }
-+     * until the area is copied in full.  Therefore, we must wait for the whole
+@@ -XXX,XX +XXX,XX @@ parallels_check_outside_image(BlockDriverState *bs, BdrvCheckResult *res,
-+     * area to become free of concurrent requests.
+     uint32_t i;
-+     */
+     int64_t off, high_off, size;
-     mirror_wait_on_conflicts(op, s, offset, bytes);
+-    size = bdrv_getlength(bs->file->bs);
-     bitmap_set(s->in_flight_bitmap, start_chunk, end_chunk - start_chunk);
++    size = bdrv_co_getlength(bs->file->bs);
      if (size < 0) {
          res->check_errors++;
          return size;
 diff --git a/block/qcow.c b/block/qcow.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow.c
 +++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
          if (!allocate)
              return 0;
          /* allocate a new l2 entry */
 -        l2_offset = bdrv_getlength(bs->file->bs);
 +        l2_offset = bdrv_co_getlength(bs->file->bs);
          if (l2_offset < 0) {
              return l2_offset;
          }
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
              if (decompress_cluster(bs, cluster_offset) < 0) {
                  return -EIO;
              }
 -            cluster_offset = bdrv_getlength(bs->file->bs);
 +            cluster_offset = bdrv_co_getlength(bs->file->bs);
              if ((int64_t) cluster_offset < 0) {
                  return cluster_offset;
              }
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
                  return ret;
              }
          } else {
 -            cluster_offset = bdrv_getlength(bs->file->bs);
 +            cluster_offset = bdrv_co_getlength(bs->file->bs);
              if ((int64_t) cluster_offset < 0) {
                  return cluster_offset;
              }
 diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/vmdk.c
 +++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, int64_t offset, int64_t bytes,
          int64_t length;
          for (i = 0; i < s->num_extents; i++) {
 -            length = bdrv_getlength(s->extents[i].file->bs);
 +            length = bdrv_co_getlength(s->extents[i].file->bs);
              if (length < 0) {
                  return length;
              }
@@ -XXX,XX +XXX,XX @@ vmdk_co_check(BlockDriverState *bs, BdrvCheckResult *result, BdrvCheckMode fix)
              break;
          }
          if (ret == VMDK_OK) {
 -            int64_t extent_len = bdrv_getlength(extent->file->bs);
 +            int64_t extent_len = bdrv_co_getlength(extent->file->bs);
              if (extent_len < 0) {
                  fprintf(stderr,
                          "ERROR: could not get extent file length for sector %"
 --
-.38.1
+.41.0

-[PULL 10/11] block: Start/end drain on correct AioContext
+[PULL 23/23] block: use bdrv_co_debug_event in coroutine context
-From: Hanna Reitz <hreitz@redhat.com>
+From: Paolo Bonzini <pbonzini@redhat.com>
-bdrv_parent_drained_{begin,end}_single() are supposed to operate on the
+bdrv_co_debug_event was recently introduced, with bdrv_debug_event
-parent, not on the child, so they should not attempt to get the context
+becoming a wrapper for use in unknown context.  Because most of the
-to poll from the child but the parent instead.  BDRV_POLL_WHILE(c->bs)
+time bdrv_debug_event is used on a BdrvChild via the wrapper macro
-does get the context from the child, so we should replace it with
+BLKDBG_EVENT, introduce a similar macro BLKDBG_CO_EVENT that calls
-AIO_WAIT_WHILE() on the parent's context instead.
+bdrv_co_debug_event, and switch whenever possible.
-This problem becomes apparent when bdrv_replace_child_noperm() invokes
+Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
-bdrv_parent_drained_end_single() after removing a child from a subgraph
+Message-ID: <20230601115145.196465-13-pbonzini@redhat.com>
 that is in an I/O thread.  By the time bdrv_parent_drained_end_single()
 is called, child->bs is NULL, and so BDRV_POLL_WHILE(c->bs, ...) will
 poll the main loop instead of the I/O thread; but anything that
 bdrv_parent_drained_end_single_no_poll() may have scheduled is going to
 want to run in the I/O thread, but because we poll the main loop, the
 I/O thread is never unpaused, and nothing is run, resulting in a
 deadlock.
 Closes: https://gitlab.com/qemu-project/qemu/-/issues/1215
 Reviewed-by: Kevin Wolf <kwolf@redhat.com>
-Signed-off-by: Hanna Reitz <hreitz@redhat.com>
-Message-Id: <20221107151321.211175-4-hreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/io.c | 6 ++++--
+ include/block/block-io.h |  7 +++++++
-file changed, 4 insertions(+), 2 deletions(-)
+ block/io.c               |  4 ++--
  block/qcow.c             | 24 ++++++++++++------------
  block/qcow2-cluster.c    | 12 ++++++------
  block/qcow2-refcount.c   |  4 ++--
  block/qcow2.c            | 18 +++++++++---------
  block/qed-table.c        |  6 +++---
  block/qed.c              |  8 ++++----
  block/raw-format.c       |  4 ++--
  block/vmdk.c             | 24 ++++++++++++------------
 files changed, 59 insertions(+), 52 deletions(-)
+diff --git a/include/block/block-io.h b/include/block/block-io.h
+index XXXXXXX..XXXXXXX 100644
+--- a/include/block/block-io.h
++++ b/include/block/block-io.h
+@@ -XXX,XX +XXX,XX @@ bdrv_co_debug_event(BlockDriverState *bs, BlkdebugEvent event);
+ void co_wrapper_mixed_bdrv_rdlock
+ bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event);
++#define BLKDBG_CO_EVENT(child, evt) \
++    do { \
++        if (child) { \
++            bdrv_co_debug_event(child->bs, evt); \
++        } \
++    } while (0)
++
+ #define BLKDBG_EVENT(child, evt) \
+     do { \
+         if (child) { \
 diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/io.c
 +++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ static void bdrv_parent_drained_end_single_no_poll(BdrvChild *c,
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
- void bdrv_parent_drained_end_single(BdrvChild *c)
+     }
      /* Write back cached data to the OS even with cache=unsafe */
 -    BLKDBG_EVENT(primary_child, BLKDBG_FLUSH_TO_OS);
 +    BLKDBG_CO_EVENT(primary_child, BLKDBG_FLUSH_TO_OS);
      if (bs->drv->bdrv_co_flush_to_os) {
          ret = bs->drv->bdrv_co_flush_to_os(bs);
          if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
          goto flush_children;
      }
 -    BLKDBG_EVENT(primary_child, BLKDBG_FLUSH_TO_DISK);
 +    BLKDBG_CO_EVENT(primary_child, BLKDBG_FLUSH_TO_DISK);
      if (!bs->drv) {
          /* bs->drv->bdrv_co_flush() might have ejected the BDS
           * (even in case of apparent success) */
 diff --git a/block/qcow.c b/block/qcow.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow.c
 +++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
          /* update the L1 entry */
          s->l1_table[l1_index] = l2_offset;
          tmp = cpu_to_be64(l2_offset);
 -        BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
 +        BLKDBG_CO_EVENT(bs->file, BLKDBG_L1_UPDATE);
          ret = bdrv_co_pwrite_sync(bs->file,
                                    s->l1_table_offset + l1_index * sizeof(tmp),
                                    sizeof(tmp), &tmp, 0);
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
          }
      }
      l2_table = s->l2_cache + (min_index << s->l2_bits);
 -    BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_L2_LOAD);
      if (new_l2_table) {
          memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
          ret = bdrv_co_pwrite_sync(bs->file, l2_offset,
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
          ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1)) {
          if (!allocate)
              return 0;
 -        BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
 +        BLKDBG_CO_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
          assert(QEMU_IS_ALIGNED(n_start | n_end, BDRV_SECTOR_SIZE));
          /* allocate a new cluster */
          if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
              }
              cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size);
              /* write the cluster content */
 -            BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
 +            BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
              ret = bdrv_co_pwrite(bs->file, cluster_offset, s->cluster_size,
                                   s->cluster_cache, 0);
              if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
                                                        NULL) < 0) {
                                  return -EIO;
                              }
 -                            BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
 +                            BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
                              ret = bdrv_co_pwrite(bs->file, cluster_offset + i,
                                                   BDRV_SECTOR_SIZE,
                                                   s->cluster_data, 0);
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
          tmp = cpu_to_be64(cluster_offset);
          l2_table[l2_index] = tmp;
          if (allocate == 2) {
 -            BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
 +            BLKDBG_CO_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
          } else {
 -            BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
 +            BLKDBG_CO_EVENT(bs->file, BLKDBG_L2_UPDATE);
          }
          ret = bdrv_co_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
                                    sizeof(tmp), &tmp, 0);
@@ -XXX,XX +XXX,XX @@ decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
      if (s->cluster_cache_offset != coffset) {
          csize = cluster_offset >> (63 - s->cluster_bits);
          csize &= (s->cluster_size - 1);
 -        BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
 +        BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
          ret = bdrv_co_pread(bs->file, coffset, csize, s->cluster_data, 0);
          if (ret < 0)
              return -1;
@@ -XXX,XX +XXX,XX @@ qcow_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                  /* read from the base image */
                  qemu_co_mutex_unlock(&s->lock);
                  /* qcow2 emits this on bs->file instead of bs->backing */
 -                BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
 +                BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
                  ret = bdrv_co_pread(bs->backing, offset, n, buf, 0);
                  qemu_co_mutex_lock(&s->lock);
                  if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ qcow_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                  break;
              }
              qemu_co_mutex_unlock(&s->lock);
 -            BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
 +            BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO);
              ret = bdrv_co_pread(bs->file, cluster_offset + offset_in_cluster,
                                  n, buf, 0);
              qemu_co_mutex_lock(&s->lock);
@@ -XXX,XX +XXX,XX @@ qcow_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
          }
          qemu_co_mutex_unlock(&s->lock);
 -        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
 +        BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
          ret = bdrv_co_pwrite(bs->file, cluster_offset + offset_in_cluster,
                               n, buf, 0);
          qemu_co_mutex_lock(&s->lock);
@@ -XXX,XX +XXX,XX @@ qcow_co_pwritev_compressed(BlockDriverState *bs, int64_t offset, int64_t bytes,
      }
      cluster_offset &= s->cluster_offset_mask;
 -    BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
      ret = bdrv_co_pwrite(bs->file, cluster_offset, out_len, out_buf, 0);
      if (ret < 0) {
          goto fail;
 diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2-cluster.c
 +++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_shrink_l1_table(BlockDriverState *bs,
      fprintf(stderr, "shrink l1_table from %d to %d\n", s->l1_size, new_l1_size);
  #endif
 -    BLKDBG_EVENT(bs->file, BLKDBG_L1_SHRINK_WRITE_TABLE);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_L1_SHRINK_WRITE_TABLE);
      ret = bdrv_co_pwrite_zeroes(bs->file,
                                  s->l1_table_offset + new_l1_size * L1E_SIZE,
                                  (s->l1_size - new_l1_size) * L1E_SIZE, 0);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_shrink_l1_table(BlockDriverState *bs,
          goto fail;
      }
 -    BLKDBG_EVENT(bs->file, BLKDBG_L1_SHRINK_FREE_L2_CLUSTERS);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_L1_SHRINK_FREE_L2_CLUSTERS);
      for (i = s->l1_size - 1; i > new_l1_size - 1; i--) {
          if ((s->l1_table[i] & L1E_OFFSET_MASK) == 0) {
              continue;
@@ -XXX,XX +XXX,XX @@ do_perform_cow_read(BlockDriverState *bs, uint64_t src_cluster_offset,
          return 0;
      }
 -    BLKDBG_EVENT(bs->file, BLKDBG_COW_READ);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_COW_READ);
      if (!bs->drv) {
          return -ENOMEDIUM;
@@ -XXX,XX +XXX,XX @@ do_perform_cow_write(BlockDriverState *bs, uint64_t cluster_offset,
          return ret;
      }
 -    BLKDBG_EVENT(bs->file, BLKDBG_COW_WRITE);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_COW_WRITE);
      ret = bdrv_co_pwritev(s->data_file, cluster_offset + offset_in_cluster,
                            qiov->size, qiov, 0);
      if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, uint64_t offset,
      /* compressed clusters never have the copied flag */
 -    BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
      qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_slice);
      set_l2_entry(s, l2_slice, l2_index, cluster_offset);
      if (has_subclusters(s)) {
@@ -XXX,XX +XXX,XX @@ perform_cow(BlockDriverState *bs, QCowL2Meta *m)
          /* NOTE: we have a write_aio blkdebug event here followed by
           * a cow_write one in do_perform_cow_write(), but there's only
           * one single I/O operation */
 -        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
 +        BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
          ret = do_perform_cow_write(bs, m->alloc_offset, start->offset, &qiov);
      } else {
          /* If there's no guest data then write both COW regions separately */
 diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2-refcount.c
 +++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_refcount_init(BlockDriverState *bs)
              ret = -ENOMEM;
              goto fail;
          }
 -        BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);
 +        BLKDBG_CO_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);
          ret = bdrv_co_pread(bs->file, s->refcount_table_offset,
                              refcount_table_size2, s->refcount_table, 0);
          if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ int64_t coroutine_fn GRAPH_RDLOCK qcow2_alloc_bytes(BlockDriverState *bs, int si
      size_t free_in_cluster;
      int ret;
 -    BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_BYTES);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_BYTES);
      assert(size > 0 && size <= s->cluster_size);
      assert(!s->free_byte_offset || offset_into_cluster(s, s->free_byte_offset));
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_encrypted(BlockDriverState *bs,
          return -ENOMEM;
      }
 -    BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO);
      ret = bdrv_co_pread(s->data_file, host_offset, bytes, buf, 0);
      if (ret < 0) {
          goto fail;
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_task(BlockDriverState *bs, QCow2SubclusterType subc_type,
      case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
          assert(bs->backing); /* otherwise handled in qcow2_co_preadv_part */
 -        BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
 +        BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
          return bdrv_co_preadv_part(bs->backing, offset, bytes,
                                     qiov, qiov_offset, 0);
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_task(BlockDriverState *bs, QCow2SubclusterType subc_type,
                                               offset, bytes, qiov, qiov_offset);
          }
 -        BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
 +        BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO);
          return bdrv_co_preadv_part(s->data_file, host_offset,
                                     bytes, qiov, qiov_offset, 0);
@@ -XXX,XX +XXX,XX @@ handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)
              return ret;
          }
 -        BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_SPACE);
 +        BLKDBG_CO_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_SPACE);
          ret = bdrv_co_pwrite_zeroes(s->data_file, start_offset, nb_bytes,
                                      BDRV_REQ_NO_FALLBACK);
          if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ int qcow2_co_pwritev_task(BlockDriverState *bs, uint64_t host_offset,
       * guest data now.
       */
      if (!merge_cow(offset, bytes, qiov, qiov_offset, l2meta)) {
 -        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
 +        BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
          trace_qcow2_writev_data(qemu_coroutine_self(), host_offset);
          ret = bdrv_co_pwritev_part(s->data_file, host_offset,
                                     bytes, qiov, qiov_offset, 0);
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed_task(BlockDriverState *bs,
          goto fail;
      }
 -    BLKDBG_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED);
 +    BLKDBG_CO_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED);
      ret = bdrv_co_pwrite(s->data_file, cluster_offset, out_len, out_buf, 0);
      if (ret < 0) {
          goto fail;
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
      out_buf = qemu_blockalign(bs, s->cluster_size);
 -    BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
      ret = bdrv_co_pread(bs->file, coffset, csize, buf, 0);
      if (ret < 0) {
          goto fail;
@@ -XXX,XX +XXX,XX @@ qcow2_co_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
          return offset;
      }
 -    BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
      return bs->drv->bdrv_co_pwritev_part(bs, offset, qiov->size, qiov, 0, 0);
  }
@@ -XXX,XX +XXX,XX @@ qcow2_co_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
          return offset;
      }
 -    BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
 +    BLKDBG_CO_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
      return bs->drv->bdrv_co_preadv_part(bs, offset, qiov->size, qiov, 0, 0);
  }
 diff --git a/block/qed-table.c b/block/qed-table.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qed-table.c
 +++ b/block/qed-table.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qed_read_l1_table_sync(BDRVQEDState *s)
  int coroutine_fn qed_write_l1_table(BDRVQEDState *s, unsigned int index,
                                      unsigned int n)
  {
-     int drained_end_counter = 0;
+-    BLKDBG_EVENT(s->bs->file, BLKDBG_L1_UPDATE);
-+    AioContext *ctx = bdrv_child_get_parent_aio_context(c);
++    BLKDBG_CO_EVENT(s->bs->file, BLKDBG_L1_UPDATE);
-     IO_OR_GS_CODE();
+     return qed_write_table(s, s->header.l1_table_offset,
-     bdrv_parent_drained_end_single_no_poll(c, &drained_end_counter);
+                            s->l1_table, index, n, false);
 -    BDRV_POLL_WHILE(c->bs, qatomic_read(&drained_end_counter) > 0);
 +    AIO_WAIT_WHILE(ctx, qatomic_read(&drained_end_counter) > 0);
  }
+@@ -XXX,XX +XXX,XX @@ int coroutine_fn qed_read_l2_table(BDRVQEDState *s, QEDRequest *request,
- static void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,
+     request->l2_table = qed_alloc_l2_cache_entry(&s->l2_cache);
-@@ -XXX,XX +XXX,XX @@ static bool bdrv_parent_drained_poll(BlockDriverState *bs, BdrvChild *ignore,
+     request->l2_table->table = qed_alloc_table(s);
- void bdrv_parent_drained_begin_single(BdrvChild *c, bool poll)
+-    BLKDBG_EVENT(s->bs->file, BLKDBG_L2_LOAD);
 +    BLKDBG_CO_EVENT(s->bs->file, BLKDBG_L2_LOAD);
      ret = qed_read_table(s, offset, request->l2_table->table);
      if (ret) {
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qed_write_l2_table(BDRVQEDState *s, QEDRequest *request,
                                      unsigned int index, unsigned int n,
                                      bool flush)
  {
-+    AioContext *ctx = bdrv_child_get_parent_aio_context(c);
+-    BLKDBG_EVENT(s->bs->file, BLKDBG_L2_UPDATE);
-     IO_OR_GS_CODE();
++    BLKDBG_CO_EVENT(s->bs->file, BLKDBG_L2_UPDATE);
-     c->parent_quiesce_counter++;
+     return qed_write_table(s, request->l2_table->offset,
-     if (c->klass->drained_begin) {
+                            request->l2_table->table, index, n, flush);
          c->klass->drained_begin(c);
      }
      if (poll) {
 -        BDRV_POLL_WHILE(c->bs, bdrv_parent_drained_poll_single(c));
 +        AIO_WAIT_WHILE(ctx, bdrv_parent_drained_poll_single(c));
      }
  }
+diff --git a/block/qed.c b/block/qed.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/qed.c
++++ b/block/qed.c
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn GRAPH_RDLOCK
+ qed_read_backing_file(BDRVQEDState *s, uint64_t pos, QEMUIOVector *qiov)
+ {
+     if (s->bs->backing) {
+-        BLKDBG_EVENT(s->bs->file, BLKDBG_READ_BACKING_AIO);
++        BLKDBG_CO_EVENT(s->bs->file, BLKDBG_READ_BACKING_AIO);
+         return bdrv_co_preadv(s->bs->backing, pos, qiov->size, qiov, 0);
+     }
+     qemu_iovec_memset(qiov, 0, 0, qiov->size);
+@@ -XXX,XX +XXX,XX @@ qed_copy_from_backing_file(BDRVQEDState *s, uint64_t pos, uint64_t len,
+         goto out;
+     }
+-    BLKDBG_EVENT(s->bs->file, BLKDBG_COW_WRITE);
++    BLKDBG_CO_EVENT(s->bs->file, BLKDBG_COW_WRITE);
+     ret = bdrv_co_pwritev(s->bs->file, offset, qiov.size, &qiov, 0);
+     if (ret < 0) {
+         goto out;
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn GRAPH_RDLOCK qed_aio_write_main(QEDAIOCB *acb)
+     trace_qed_aio_write_main(s, acb, 0, offset, acb->cur_qiov.size);
+-    BLKDBG_EVENT(s->bs->file, BLKDBG_WRITE_AIO);
++    BLKDBG_CO_EVENT(s->bs->file, BLKDBG_WRITE_AIO);
+     return bdrv_co_pwritev(s->bs->file, offset, acb->cur_qiov.size,
+                            &acb->cur_qiov, 0);
+ }
+@@ -XXX,XX +XXX,XX @@ qed_aio_read_data(void *opaque, int ret, uint64_t offset, size_t len)
+     } else if (ret != QED_CLUSTER_FOUND) {
+         r = qed_read_backing_file(s, acb->cur_pos, &acb->cur_qiov);
+     } else {
+-        BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
++        BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO);
+         r = bdrv_co_preadv(bs->file, offset, acb->cur_qiov.size,
+                            &acb->cur_qiov, 0);
+     }
+diff --git a/block/raw-format.c b/block/raw-format.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/raw-format.c
++++ b/block/raw-format.c
+@@ -XXX,XX +XXX,XX @@ raw_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
+         return ret;
+     }
+-    BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
++    BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO);
+     return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
+ }
+@@ -XXX,XX +XXX,XX @@ raw_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
+         goto fail;
+     }
+-    BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
++    BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
+     ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
+ fail:
+diff --git a/block/vmdk.c b/block/vmdk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vmdk.c
++++ b/block/vmdk.c
+@@ -XXX,XX +XXX,XX @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent,
+     if (skip_start_bytes > 0) {
+         if (copy_from_backing) {
+             /* qcow2 emits this on bs->file instead of bs->backing */
+-            BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
++            BLKDBG_CO_EVENT(extent->file, BLKDBG_COW_READ);
+             ret = bdrv_co_pread(bs->backing, offset, skip_start_bytes,
+                                 whole_grain, 0);
+             if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent,
+                 goto exit;
+             }
+         }
+-        BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
++        BLKDBG_CO_EVENT(extent->file, BLKDBG_COW_WRITE);
+         ret = bdrv_co_pwrite(extent->file, cluster_offset, skip_start_bytes,
+                              whole_grain, 0);
+         if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent,
+     if (skip_end_bytes < cluster_bytes) {
+         if (copy_from_backing) {
+             /* qcow2 emits this on bs->file instead of bs->backing */
+-            BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
++            BLKDBG_CO_EVENT(extent->file, BLKDBG_COW_READ);
+             ret = bdrv_co_pread(bs->backing, offset + skip_end_bytes,
+                                 cluster_bytes - skip_end_bytes,
+                                 whole_grain + skip_end_bytes, 0);
+@@ -XXX,XX +XXX,XX @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent,
+                 goto exit;
+             }
+         }
+-        BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
++        BLKDBG_CO_EVENT(extent->file, BLKDBG_COW_WRITE);
+         ret = bdrv_co_pwrite(extent->file, cluster_offset + skip_end_bytes,
+                              cluster_bytes - skip_end_bytes,
+                              whole_grain + skip_end_bytes, 0);
+@@ -XXX,XX +XXX,XX @@ vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data, uint32_t offset)
+ {
+     offset = cpu_to_le32(offset);
+     /* update L2 table */
+-    BLKDBG_EVENT(extent->file, BLKDBG_L2_UPDATE);
++    BLKDBG_CO_EVENT(extent->file, BLKDBG_L2_UPDATE);
+     if (bdrv_co_pwrite(extent->file,
+                        ((int64_t)m_data->l2_offset * 512)
+                            + (m_data->l2_index * sizeof(offset)),
+@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, VmdkExtent *extent,
+         }
+     }
+     l2_table = (char *)extent->l2_cache + (min_index * l2_size_bytes);
+-    BLKDBG_EVENT(extent->file, BLKDBG_L2_LOAD);
++    BLKDBG_CO_EVENT(extent->file, BLKDBG_L2_LOAD);
+     if (bdrv_co_pread(extent->file,
+                 (int64_t)l2_offset * 512,
+                 l2_size_bytes,
+@@ -XXX,XX +XXX,XX @@ vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
+         n_bytes = buf_len + sizeof(VmdkGrainMarker);
+         qemu_iovec_init_buf(&local_qiov, data, n_bytes);
+-        BLKDBG_EVENT(extent->file, BLKDBG_WRITE_COMPRESSED);
++        BLKDBG_CO_EVENT(extent->file, BLKDBG_WRITE_COMPRESSED);
+     } else {
+         qemu_iovec_init(&local_qiov, qiov->niov);
+         qemu_iovec_concat(&local_qiov, qiov, qiov_offset, n_bytes);
+-        BLKDBG_EVENT(extent->file, BLKDBG_WRITE_AIO);
++        BLKDBG_CO_EVENT(extent->file, BLKDBG_WRITE_AIO);
+     }
+     write_offset = cluster_offset + offset_in_cluster;
+@@ -XXX,XX +XXX,XX @@ vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
+     if (!extent->compressed) {
+-        BLKDBG_EVENT(extent->file, BLKDBG_READ_AIO);
++        BLKDBG_CO_EVENT(extent->file, BLKDBG_READ_AIO);
+         ret = bdrv_co_preadv(extent->file,
+                              cluster_offset + offset_in_cluster, bytes,
+                              qiov, 0);
+@@ -XXX,XX +XXX,XX @@ vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
+     buf_bytes = cluster_bytes * 2;
+     cluster_buf = g_malloc(buf_bytes);
+     uncomp_buf = g_malloc(cluster_bytes);
+-    BLKDBG_EVENT(extent->file, BLKDBG_READ_COMPRESSED);
++    BLKDBG_CO_EVENT(extent->file, BLKDBG_READ_COMPRESSED);
+     ret = bdrv_co_pread(extent->file, cluster_offset, buf_bytes, cluster_buf,
+);
+     if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ vmdk_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
+                 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
+                 /* qcow2 emits this on bs->file instead of bs->backing */
+-                BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
++                BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
+                 ret = bdrv_co_preadv(bs->backing, offset, n_bytes,
+                                      &local_qiov, 0);
+                 if (ret < 0) {
+@@ -XXX,XX +XXX,XX @@ vmdk_co_check(BlockDriverState *bs, BdrvCheckResult *result, BdrvCheckMode fix)
+     BDRVVmdkState *s = bs->opaque;
+     VmdkExtent *extent = NULL;
+     int64_t sector_num = 0;
+-    int64_t total_sectors = bdrv_nb_sectors(bs);
++    int64_t total_sectors = bdrv_co_nb_sectors(bs);
+     int ret;
+     uint64_t cluster_offset;
 --
-.38.1
+.41.0

The following changes since commit 2ccad61746ca7de5dd3e25146062264387e43bd4:

Merge tag 'pull-tcg-20221109' of https://gitlab.com/rth7680/qemu into staging (2022-11-09 13:26:45 -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 b04af371af685c12970ea93027dc6d8bf86265aa:

tests/stream-under-throttle: New test (2022-11-11 13:02:43 +0100)

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

- Fix deadlock in graph modification with iothreads
- mirror: Fix non-converging cases for active mirror
- qapi: Fix BlockdevOptionsNvmeIoUring @path description
- blkio: Set BlockDriver::has_variable_length to false

----------------------------------------------------------------
Alberto Faria (2):
      qapi/block-core: Fix BlockdevOptionsNvmeIoUring @path description
      block/blkio: Set BlockDriver::has_variable_length to false

Hanna Reitz (9):
      block/mirror: Do not wait for active writes
      block/mirror: Drop mirror_wait_for_any_operation()
      block/mirror: Fix NULL s->job in active writes
      iotests/151: Test that active mirror progresses
      iotests/151: Test active requests on mirror start
      block: Make bdrv_child_get_parent_aio_context I/O
      block-backend: Update ctx immediately after root
      block: Start/end drain on correct AioContext
      tests/stream-under-throttle: New test

qapi/block-core.json                               |   2 +-
 include/block/block-global-state.h                 |   1 -
 include/block/block-io.h                           |   2 +
 include/block/block_int-common.h                   |   4 +-
 block.c                                            |   2 +-
 block/blkio.c                                      |   1 -
 block/block-backend.c                              |   9 +-
 block/io.c                                         |   6 +-
 block/mirror.c                                     |  78 ++++---
 blockjob.c                                         |   3 +-
 tests/qemu-iotests/151                             | 227 ++++++++++++++++++++-
 tests/qemu-iotests/151.out                         |   4 +-
 tests/qemu-iotests/tests/stream-under-throttle     | 121 +++++++++++
 tests/qemu-iotests/tests/stream-under-throttle.out |   5 +
 14 files changed, 424 insertions(+), 41 deletions(-)
 create mode 100755 tests/qemu-iotests/tests/stream-under-throttle
 create mode 100644 tests/qemu-iotests/tests/stream-under-throttle.out

From: Hanna Reitz <hreitz@redhat.com>

Waiting for all active writes to settle before daring to create a
background copying operation means that we will never do background
operations while the guest does anything (in write-blocking mode), and
therefore cannot converge.  Yes, we also will not diverge, but actually
converging would be even nicer.

It is unclear why we did decide to wait for all active writes to settle
before creating a background operation, but it just does not seem
necessary.  Active writes will put themselves into the in_flight bitmap
and thus properly block actually conflicting background requests.

It is important for active requests to wait on overlapping background
requests, which we do in active_write_prepare().  However, so far it was
not documented why it is important.  Add such documentation now, and
also to the other call of mirror_wait_on_conflicts(), so that it becomes
more clear why and when requests need to actively wait for other
requests to settle.

Another thing to note is that of course we need to ensure that there are
no active requests when the job completes, but that is done by virtue of
the BDS being drained anyway, so there cannot be any active requests at
that point.

With this change, we will need to explicitly keep track of how many
bytes are in flight in active requests so that
job_progress_set_remaining() in mirror_run() can set the correct number
of remaining bytes.

Buglink: https://bugzilla.redhat.com/show_bug.cgi?id=2123297
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20221109165452.67927-2-hreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/mirror.c | 37 ++++++++++++++++++++++++++++++-------
 1 file changed, 30 insertions(+), 7 deletions(-)

diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ typedef struct MirrorBlockJob {
     int max_iov;
     bool initial_zeroing_ongoing;
     int in_active_write_counter;
+    int64_t active_write_bytes_in_flight;
     bool prepared;
     bool in_drain;
 } MirrorBlockJob;
@@ -XXX,XX +XXX,XX @@ static uint64_t coroutine_fn mirror_iteration(MirrorBlockJob *s)
     }
     bdrv_dirty_bitmap_unlock(s->dirty_bitmap);
 
+    /*
+     * Wait for concurrent requests to @offset.  The next loop will limit the
+     * copied area based on in_flight_bitmap so we only copy an area that does
+     * not overlap with concurrent in-flight requests.  Still, we would like to
+     * copy something, so wait until there are at least no more requests to the
+     * very beginning of the area.
+     */
     mirror_wait_on_conflicts(NULL, s, offset, 1);
 
     job_pause_point(&s->common.job);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
         int64_t cnt, delta;
         bool should_complete;
 
-        /* Do not start passive operations while there are active
-         * writes in progress */
-        while (s->in_active_write_counter) {
-            mirror_wait_for_any_operation(s, true);
-        }
-
         if (s->ret < 0) {
             ret = s->ret;
             goto immediate_exit;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
         /* cnt is the number of dirty bytes remaining and s->bytes_in_flight is
          * the number of bytes currently being processed; together those are
          * the current remaining operation length */
-        job_progress_set_remaining(&s->common.job, s->bytes_in_flight + cnt);
+        job_progress_set_remaining(&s->common.job,
+                                   s->bytes_in_flight + cnt +
+                                   s->active_write_bytes_in_flight);
 
         /* Note that even when no rate limit is applied we need to yield
          * periodically with no pending I/O so that bdrv_drain_all() returns.
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn mirror_run(Job *job, Error **errp)
 
             s->in_drain = true;
             bdrv_drained_begin(bs);
+
+            /* Must be zero because we are drained */
+            assert(s->in_active_write_counter == 0);
+
             cnt = bdrv_get_dirty_count(s->dirty_bitmap);
             if (cnt > 0 || mirror_flush(s) < 0) {
                 bdrv_drained_end(bs);
@@ -XXX,XX +XXX,XX @@ do_sync_target_write(MirrorBlockJob *job, MirrorMethod method,
     }
 
     job_progress_increase_remaining(&job->common.job, bytes);
+    job->active_write_bytes_in_flight += bytes;
 
     switch (method) {
     case MIRROR_METHOD_COPY:
@@ -XXX,XX +XXX,XX @@ do_sync_target_write(MirrorBlockJob *job, MirrorMethod method,
         abort();
     }
 
+    job->active_write_bytes_in_flight -= bytes;
     if (ret >= 0) {
         job_progress_update(&job->common.job, bytes);
     } else {
@@ -XXX,XX +XXX,XX @@ static MirrorOp *coroutine_fn active_write_prepare(MirrorBlockJob *s,
 
     s->in_active_write_counter++;
 
+    /*
+     * Wait for concurrent requests affecting the area.  If there are already
+     * running requests that are copying off now-to-be stale data in the area,
+     * we must wait for them to finish before we begin writing fresh data to the
+     * target so that the write operations appear in the correct order.
+     * Note that background requests (see mirror_iteration()) in contrast only
+     * wait for conflicting requests at the start of the dirty area, and then
+     * (based on the in_flight_bitmap) truncate the area to copy so it will not
+     * conflict with any requests beyond that.  For active writes, however, we
+     * cannot truncate that area.  The request from our parent must be blocked
+     * until the area is copied in full.  Therefore, we must wait for the whole
+     * area to become free of concurrent requests.
+     */
     mirror_wait_on_conflicts(op, s, offset, bytes);
 
     bitmap_set(s->in_flight_bitmap, start_chunk, end_chunk - start_chunk);
-- 
2.38.1

From: Hanna Reitz <hreitz@redhat.com>

mirror_wait_for_free_in_flight_slot() is the only remaining user of
mirror_wait_for_any_operation(), so inline the latter into the former.

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20221109165452.67927-3-hreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/mirror.c | 21 ++++++++-------------
 1 file changed, 8 insertions(+), 13 deletions(-)

diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static int mirror_cow_align(MirrorBlockJob *s, int64_t *offset,
 }
 
 static inline void coroutine_fn
-mirror_wait_for_any_operation(MirrorBlockJob *s, bool active)
+mirror_wait_for_free_in_flight_slot(MirrorBlockJob *s)
 {
     MirrorOp *op;
 
     QTAILQ_FOREACH(op, &s->ops_in_flight, next) {
-        /* Do not wait on pseudo ops, because it may in turn wait on
+        /*
+         * Do not wait on pseudo ops, because it may in turn wait on
          * some other operation to start, which may in fact be the
          * caller of this function.  Since there is only one pseudo op
          * at any given time, we will always find some real operation
-         * to wait on. */
-        if (!op->is_pseudo_op && op->is_in_flight &&
-            op->is_active_write == active)
-        {
+         * to wait on.
+         * Also, do not wait on active operations, because they do not
+         * use up in-flight slots.
+         */
+        if (!op->is_pseudo_op && op->is_in_flight && !op->is_active_write) {
             qemu_co_queue_wait(&op->waiting_requests, NULL);
             return;
         }
@@ -XXX,XX +XXX,XX @@ mirror_wait_for_any_operation(MirrorBlockJob *s, bool active)
     abort();
 }
 
-static inline void coroutine_fn
-mirror_wait_for_free_in_flight_slot(MirrorBlockJob *s)
-{
-    /* Only non-active operations use up in-flight slots */
-    mirror_wait_for_any_operation(s, false);
-}
-
 /* Perform a mirror copy operation.
  *
  * *op->bytes_handled is set to the number of bytes copied after and
-- 
2.38.1

From: Hanna Reitz <hreitz@redhat.com>

There is a small gap in mirror_start_job() before putting the mirror
filter node into the block graph (bdrv_append() call) and the actual job
being created.  Before the job is created, MirrorBDSOpaque.job is NULL.

It is possible that requests come in when bdrv_drained_end() is called,
and those requests would see MirrorBDSOpaque.job == NULL.  Have our
filter node handle that case gracefully.

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20221109165452.67927-4-hreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/mirror.c | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/block/mirror.c b/block/mirror.c
index XXXXXXX..XXXXXXX 100644
--- a/block/mirror.c
+++ b/block/mirror.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_mirror_top_do_write(BlockDriverState *bs,
     MirrorOp *op = NULL;
     MirrorBDSOpaque *s = bs->opaque;
     int ret = 0;
-    bool copy_to_target;
+    bool copy_to_target = false;
 
-    copy_to_target = s->job->ret >= 0 &&
-                     !job_is_cancelled(&s->job->common.job) &&
-                     s->job->copy_mode == MIRROR_COPY_MODE_WRITE_BLOCKING;
+    if (s->job) {
+        copy_to_target = s->job->ret >= 0 &&
+                         !job_is_cancelled(&s->job->common.job) &&
+                         s->job->copy_mode == MIRROR_COPY_MODE_WRITE_BLOCKING;
+    }
 
     if (copy_to_target) {
         op = active_write_prepare(s->job, offset, bytes);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn bdrv_mirror_top_pwritev(BlockDriverState *bs,
     QEMUIOVector bounce_qiov;
     void *bounce_buf;
     int ret = 0;
-    bool copy_to_target;
+    bool copy_to_target = false;
 
-    copy_to_target = s->job->ret >= 0 &&
-                     !job_is_cancelled(&s->job->common.job) &&
-                     s->job->copy_mode == MIRROR_COPY_MODE_WRITE_BLOCKING;
+    if (s->job) {
+        copy_to_target = s->job->ret >= 0 &&
+                         !job_is_cancelled(&s->job->common.job) &&
+                         s->job->copy_mode == MIRROR_COPY_MODE_WRITE_BLOCKING;
+    }
 
     if (copy_to_target) {
         /* The guest might concurrently modify the data to write; but
-- 
2.38.1

From: Hanna Reitz <hreitz@redhat.com>

Before this series, a mirror job in write-blocking mode would pause
issuing background requests while active requests are in flight.  Thus,
if the source is constantly in use by active requests, no actual
progress can be made.

This series should have fixed that, making the mirror job issue
background requests even while active requests are in flight.

Have a new test case in 151 verify this.

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20221109165452.67927-5-hreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/151     | 180 ++++++++++++++++++++++++++++++++++++-
 tests/qemu-iotests/151.out |   4 +-
 2 files changed, 181 insertions(+), 3 deletions(-)

diff --git a/tests/qemu-iotests/151 b/tests/qemu-iotests/151
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/151
+++ b/tests/qemu-iotests/151
@@ -XXX,XX +XXX,XX @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
+import math
 import os
+import subprocess
+from typing import List
 import iotests
 from iotests import qemu_img
 
@@ -XXX,XX +XXX,XX @@ class TestActiveMirror(iotests.QMPTestCase):
         self.vm = iotests.VM()
         self.vm.add_drive_raw(self.vm.qmp_to_opts(blk_source))
         self.vm.add_blockdev(self.vm.qmp_to_opts(blk_target))
-        self.vm.add_device('virtio-blk,drive=source')
+        self.vm.add_device('virtio-blk,id=vblk,drive=source')
         self.vm.launch()
 
     def tearDown(self):
@@ -XXX,XX +XXX,XX @@ class TestActiveMirror(iotests.QMPTestCase):
         self.potential_writes_in_flight = False
 
 
+class TestThrottledWithNbdExport(iotests.QMPTestCase):
+    image_len = 128 * 1024 * 1024  # MB
+    iops = 16
+    background_processes: List['subprocess.Popen[str]'] = []
+
+    def setUp(self):
+        qemu_img('create', '-f', iotests.imgfmt, source_img, '128M')
+        qemu_img('create', '-f', iotests.imgfmt, target_img, '128M')
+
+        self.vm = iotests.VM()
+        self.vm.launch()
+
+        result = self.vm.qmp('object-add', **{
+            'qom-type': 'throttle-group',
+            'id': 'thrgr',
+            'limits': {
+                'iops-total': self.iops,
+                'iops-total-max': self.iops
+            }
+        })
+        self.assert_qmp(result, 'return', {})
+
+        result = self.vm.qmp('blockdev-add', **{
+            'node-name': 'source-node',
+            'driver': 'throttle',
+            'throttle-group': 'thrgr',
+            'file': {
+                'driver': iotests.imgfmt,
+                'file': {
+                    'driver': 'file',
+                    'filename': source_img
+                }
+            }
+        })
+        self.assert_qmp(result, 'return', {})
+
+        result = self.vm.qmp('blockdev-add', **{
+            'node-name': 'target-node',
+            'driver': iotests.imgfmt,
+            'file': {
+                'driver': 'file',
+                'filename': target_img
+            }
+        })
+        self.assert_qmp(result, 'return', {})
+
+        self.nbd_sock = iotests.file_path('nbd.sock',
+                                          base_dir=iotests.sock_dir)
+        self.nbd_url = f'nbd+unix:///source-node?socket={self.nbd_sock}'
+
+        result = self.vm.qmp('nbd-server-start', addr={
+            'type': 'unix',
+            'data': {
+                'path': self.nbd_sock
+            }
+        })
+        self.assert_qmp(result, 'return', {})
+
+        result = self.vm.qmp('block-export-add', id='exp0', type='nbd',
+                             node_name='source-node', writable=True)
+        self.assert_qmp(result, 'return', {})
+
+    def tearDown(self):
+        # Wait for background requests to settle
+        try:
+            while True:
+                p = self.background_processes.pop()
+                while True:
+                    try:
+                        p.wait(timeout=0.0)
+                        break
+                    except subprocess.TimeoutExpired:
+                        self.vm.qtest(f'clock_step {1 * 1000 * 1000 * 1000}')
+        except IndexError:
+            pass
+
+        # Cancel ongoing block jobs
+        for job in self.vm.qmp('query-jobs')['return']:
+            self.vm.qmp('block-job-cancel', device=job['id'], force=True)
+
+        while True:
+            self.vm.qtest(f'clock_step {1 * 1000 * 1000 * 1000}')
+            if len(self.vm.qmp('query-jobs')['return']) == 0:
+                break
+
+        self.vm.shutdown()
+        os.remove(source_img)
+        os.remove(target_img)
+
+    def testUnderLoad(self):
+        '''
+        Throttle the source node, then issue a whole bunch of external requests
+        while the mirror job (in write-blocking mode) is running.  We want to
+        see background requests being issued even while the source is under
+        full load by active writes, so that progress can be made towards READY.
+        '''
+
+        # Fill the first half of the source image; do not fill the second half,
+        # that is where we will have active requests occur.  This ensures that
+        # active mirroring itself will not directly contribute to the job's
+        # progress (because when the job was started, those areas were not
+        # intended to be copied, so active mirroring will only lead to not
+        # losing progress, but also not making any).
+        self.vm.hmp_qemu_io('source-node',
+                            f'aio_write -P 1 0 {self.image_len // 2}')
+        self.vm.qtest(f'clock_step {1 * 1000 * 1000 * 1000}')
+
+        # Launch the mirror job
+        mirror_buf_size = 65536
+        result = self.vm.qmp('blockdev-mirror',
+                             job_id='mirror',
+                             filter_node_name='mirror-node',
+                             device='source-node',
+                             target='target-node',
+                             sync='full',
+                             copy_mode='write-blocking',
+                             buf_size=mirror_buf_size)
+        self.assert_qmp(result, 'return', {})
+
+        # We create the external requests via qemu-io processes on the NBD
+        # server.  Have their offset start in the middle of the image so they
+        # do not overlap with the background requests (which start from the
+        # beginning).
+        active_request_offset = self.image_len // 2
+        active_request_len = 4096
+
+        # Create enough requests to saturate the node for 5 seconds
+        for _ in range(0, 5 * self.iops):
+            req = f'write -P 42 {active_request_offset} {active_request_len}'
+            active_request_offset += active_request_len
+            p = iotests.qemu_io_popen('-f', 'nbd', self.nbd_url, '-c', req)
+            self.background_processes += [p]
+
+        # Now advance the clock one I/O operation at a time by the 4 seconds
+        # (i.e. one less than 5).  We expect the mirror job to issue background
+        # operations here, even though active requests are still in flight.
+        # The active requests will take precedence, however, because they have
+        # been issued earlier than mirror's background requests.
+        # Once the active requests we have started above are done (i.e. after 5
+        # virtual seconds), we expect those background requests to be worked
+        # on.  We only advance 4 seconds here to avoid race conditions.
+        for _ in range(0, 4 * self.iops):
+            step = math.ceil(1 * 1000 * 1000 * 1000 / self.iops)
+            self.vm.qtest(f'clock_step {step}')
+
+        # Note how much remains to be done until the mirror job is finished
+        job_status = self.vm.qmp('query-jobs')['return'][0]
+        start_remaining = job_status['total-progress'] - \
+            job_status['current-progress']
+
+        # Create a whole bunch of more active requests
+        for _ in range(0, 10 * self.iops):
+            req = f'write -P 42 {active_request_offset} {active_request_len}'
+            active_request_offset += active_request_len
+            p = iotests.qemu_io_popen('-f', 'nbd', self.nbd_url, '-c', req)
+            self.background_processes += [p]
+
+        # Let the clock advance more.  After 1 second, as noted above, we
+        # expect the background requests to be worked on.  Give them a couple
+        # of seconds (specifically 4) to see their impact.
+        for _ in range(0, 5 * self.iops):
+            step = math.ceil(1 * 1000 * 1000 * 1000 / self.iops)
+            self.vm.qtest(f'clock_step {step}')
+
+        # Note how much remains to be done now.  We expect this number to be
+        # reduced thanks to those background requests.
+        job_status = self.vm.qmp('query-jobs')['return'][0]
+        end_remaining = job_status['total-progress'] - \
+            job_status['current-progress']
+
+        # See that indeed progress was being made on the job, even while the
+        # node was saturated with active requests
+        self.assertGreater(start_remaining - end_remaining, 0)
+
+
 if __name__ == '__main__':
     iotests.main(supported_fmts=['qcow2', 'raw'],
                  supported_protocols=['file'])
diff --git a/tests/qemu-iotests/151.out b/tests/qemu-iotests/151.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/151.out
+++ b/tests/qemu-iotests/151.out
@@ -XXX,XX +XXX,XX @@
-....
+.....
 ----------------------------------------------------------------------
-Ran 4 tests
+Ran 5 tests
 
 OK
-- 
2.38.1

From: Hanna Reitz <hreitz@redhat.com>

Have write requests happen to the source node right when we start a
mirror job.  The mirror filter node may encounter MirrorBDSOpaque.job
being NULL, but this should not cause a segfault.

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20221109165452.67927-6-hreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/151     | 53 +++++++++++++++++++++++++++++++++++---
 tests/qemu-iotests/151.out |  4 +--
 2 files changed, 52 insertions(+), 5 deletions(-)

diff --git a/tests/qemu-iotests/151 b/tests/qemu-iotests/151
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/151
+++ b/tests/qemu-iotests/151
@@ -XXX,XX +XXX,XX @@
 import math
 import os
 import subprocess
-from typing import List
+import time
+from typing import List, Optional
 import iotests
 from iotests import qemu_img
 
@@ -XXX,XX +XXX,XX @@ class TestActiveMirror(iotests.QMPTestCase):
         self.potential_writes_in_flight = False
 
 
-class TestThrottledWithNbdExport(iotests.QMPTestCase):
+class TestThrottledWithNbdExportBase(iotests.QMPTestCase):
     image_len = 128 * 1024 * 1024  # MB
-    iops = 16
+    iops: Optional[int] = None
     background_processes: List['subprocess.Popen[str]'] = []
 
     def setUp(self):
+        # Must be set by subclasses
+        self.assertIsNotNone(self.iops)
+
         qemu_img('create', '-f', iotests.imgfmt, source_img, '128M')
         qemu_img('create', '-f', iotests.imgfmt, target_img, '128M')
 
@@ -XXX,XX +XXX,XX @@ class TestThrottledWithNbdExport(iotests.QMPTestCase):
         os.remove(source_img)
         os.remove(target_img)
 
+
+class TestLowThrottledWithNbdExport(TestThrottledWithNbdExportBase):
+    iops = 16
+
     def testUnderLoad(self):
         '''
         Throttle the source node, then issue a whole bunch of external requests
@@ -XXX,XX +XXX,XX @@ class TestThrottledWithNbdExport(iotests.QMPTestCase):
         self.assertGreater(start_remaining - end_remaining, 0)
 
 
+class TestHighThrottledWithNbdExport(TestThrottledWithNbdExportBase):
+    iops = 1024
+
+    def testActiveOnCreation(self):
+        '''
+        Issue requests on the mirror source node right as the mirror is
+        instated.  It's possible that requests occur before the actual job is
+        created, but after the node has been put into the graph.  Write
+        requests across the node must in that case be forwarded to the source
+        node without attempting to mirror them (there is no job object yet, so
+        attempting to access it would cause a segfault).
+        We do this with a lightly throttled node (i.e. quite high IOPS limit).
+        Using throttling seems to increase reproductivity, but if the limit is
+        too low, all requests allowed per second will be submitted before
+        mirror_start_job() gets to the problematic point.
+        '''
+
+        # Let qemu-img bench create write requests (enough for two seconds on
+        # the virtual clock)
+        bench_args = ['bench', '-w', '-d', '1024', '-f', 'nbd',
+                      '-c', str(self.iops * 2), self.nbd_url]
+        p = iotests.qemu_tool_popen(iotests.qemu_img_args + bench_args)
+        self.background_processes += [p]
+
+        # Give qemu-img bench time to start up and issue requests
+        time.sleep(1.0)
+        # Flush the request queue, so new requests can come in right as we
+        # start blockdev-mirror
+        self.vm.qtest(f'clock_step {1 * 1000 * 1000 * 1000}')
+
+        result = self.vm.qmp('blockdev-mirror',
+                             job_id='mirror',
+                             device='source-node',
+                             target='target-node',
+                             sync='full',
+                             copy_mode='write-blocking')
+        self.assert_qmp(result, 'return', {})
+
+
 if __name__ == '__main__':
     iotests.main(supported_fmts=['qcow2', 'raw'],
                  supported_protocols=['file'])
diff --git a/tests/qemu-iotests/151.out b/tests/qemu-iotests/151.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/151.out
+++ b/tests/qemu-iotests/151.out
@@ -XXX,XX +XXX,XX @@
-.....
+......
 ----------------------------------------------------------------------
-Ran 5 tests
+Ran 6 tests
 
 OK
-- 
2.38.1

From: Alberto Faria <afaria@redhat.com>

Setting it to true can cause the device size to be queried from libblkio
in otherwise fast paths, degrading performance. Set it to false and
require users to refresh the device size explicitly instead.

Fixes: 4c8f4fda0504 ("block/blkio: Tolerate device size changes")
Suggested-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Alberto Faria <afaria@redhat.com>
Message-Id: <20221108144433.1334074-1-afaria@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/blkio.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/block/blkio.c b/block/blkio.c
index XXXXXXX..XXXXXXX 100644
--- a/block/blkio.c
+++ b/block/blkio.c
@@ -XXX,XX +XXX,XX @@ static void blkio_refresh_limits(BlockDriverState *bs, Error **errp)
     { \
         .format_name             = name, \
         .protocol_name           = name, \
-        .has_variable_length     = true, \
         .instance_size           = sizeof(BDRVBlkioState), \
         .bdrv_file_open          = blkio_file_open, \
         .bdrv_close              = blkio_close, \
-- 
2.38.1

From: Hanna Reitz <hreitz@redhat.com>

We want to use bdrv_child_get_parent_aio_context() from
bdrv_parent_drained_{begin,end}_single(), both of which are "I/O or GS"
functions.

Prior to 3ed4f708fe1, all the implementations were I/O code anyway.
3ed4f708fe1 has put block jobs' AioContext field under the job mutex, so
to make child_job_get_parent_aio_context() work in an I/O context, we
need to take that lock there.

Furthermore, blk_root_get_parent_aio_context() is not marked as
anything, but is safe to run in an I/O context, so mark it that way now.
(blk_get_aio_context() is an I/O code function.)

With that done, all implementations explicitly are I/O code, so we can
mark bdrv_child_get_parent_aio_context() as I/O code, too, so callers
know it is safe to run from both GS and I/O contexts.

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20221107151321.211175-2-hreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block-global-state.h | 1 -
 include/block/block-io.h           | 2 ++
 include/block/block_int-common.h   | 4 ++--
 block.c                            | 2 +-
 block/block-backend.c              | 1 +
 blockjob.c                         | 3 ++-
 6 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/include/block/block-global-state.h b/include/block/block-global-state.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-global-state.h
+++ b/include/block/block-global-state.h
@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_co_lock(BlockDriverState *bs);
  */
 void coroutine_fn bdrv_co_unlock(BlockDriverState *bs);
 
-AioContext *bdrv_child_get_parent_aio_context(BdrvChild *c);
 bool bdrv_child_change_aio_context(BdrvChild *c, AioContext *ctx,
                                    GHashTable *visited, Transaction *tran,
                                    Error **errp);
diff --git a/include/block/block-io.h b/include/block/block-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-io.h
+++ b/include/block/block-io.h
@@ -XXX,XX +XXX,XX @@ void bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event);
  */
 AioContext *bdrv_get_aio_context(BlockDriverState *bs);
 
+AioContext *bdrv_child_get_parent_aio_context(BdrvChild *c);
+
 /**
  * Move the current coroutine to the AioContext of @bs and return the old
  * AioContext of the coroutine. Increase bs->in_flight so that draining @bs
diff --git a/include/block/block_int-common.h b/include/block/block_int-common.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int-common.h
+++ b/include/block/block_int-common.h
@@ -XXX,XX +XXX,XX @@ struct BdrvChildClass {
                            GHashTable *visited, Transaction *tran,
                            Error **errp);
 
-    AioContext *(*get_parent_aio_context)(BdrvChild *child);
-
     /*
      * I/O API functions. These functions are thread-safe.
      *
@@ -XXX,XX +XXX,XX @@ struct BdrvChildClass {
      */
     const char *(*get_name)(BdrvChild *child);
 
+    AioContext *(*get_parent_aio_context)(BdrvChild *child);
+
     /*
      * If this pair of functions is implemented, the parent doesn't issue new
      * requests after returning from .drained_begin() until .drained_end() is
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ const BdrvChildClass child_of_bds = {
 
 AioContext *bdrv_child_get_parent_aio_context(BdrvChild *c)
 {
-    GLOBAL_STATE_CODE();
+    IO_CODE();
     return c->klass->get_parent_aio_context(c);
 }
 
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 blk_root_detach(BdrvChild *child)
 static AioContext *blk_root_get_parent_aio_context(BdrvChild *c)
 {
     BlockBackend *blk = c->opaque;
+    IO_CODE();
 
     return blk_get_aio_context(blk);
 }
diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ static bool child_job_change_aio_ctx(BdrvChild *c, AioContext *ctx,
 static AioContext *child_job_get_parent_aio_context(BdrvChild *c)
 {
     BlockJob *job = c->opaque;
-    GLOBAL_STATE_CODE();
+    IO_CODE();
+    JOB_LOCK_GUARD();
 
     return job->job.aio_context;
 }
-- 
2.38.1

From: Hanna Reitz <hreitz@redhat.com>

blk_get_aio_context() asserts that blk->ctx is always equal to the root
BDS's context (if there is a root BDS).  Therefore,
blk_do_set_aio_context() must update blk->ctx immediately after the root
BDS's context has changed.

Without this patch, the next patch would break iotest 238, because
bdrv_drained_begin() (called by blk_do_set_aio_context()) may then
invoke bdrv_child_get_parent_aio_context() on the root child, i.e.
blk_get_aio_context().  However, by this point, blk->ctx would not have
been updated and thus differ from the root node's context.  This patch
fixes that.

Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20221107151321.211175-3-hreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/block-backend.c | 8 +++++++-
 1 file changed, 7 insertions(+), 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 int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context,
                 return ret;
             }
         }
+        /*
+         * Make blk->ctx consistent with the root node before we invoke any
+         * other operations like drain that might inquire blk->ctx
+         */
+        blk->ctx = new_context;
         if (tgm->throttle_state) {
             bdrv_drained_begin(bs);
             throttle_group_detach_aio_context(tgm);
@@ -XXX,XX +XXX,XX @@ static int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context,
         }
 
         bdrv_unref(bs);
+    } else {
+        blk->ctx = new_context;
     }
 
-    blk->ctx = new_context;
     return 0;
 }
 
-- 
2.38.1

From: Hanna Reitz <hreitz@redhat.com>

bdrv_parent_drained_{begin,end}_single() are supposed to operate on the
parent, not on the child, so they should not attempt to get the context
to poll from the child but the parent instead.  BDRV_POLL_WHILE(c->bs)
does get the context from the child, so we should replace it with
AIO_WAIT_WHILE() on the parent's context instead.

This problem becomes apparent when bdrv_replace_child_noperm() invokes
bdrv_parent_drained_end_single() after removing a child from a subgraph
that is in an I/O thread.  By the time bdrv_parent_drained_end_single()
is called, child->bs is NULL, and so BDRV_POLL_WHILE(c->bs, ...) will
poll the main loop instead of the I/O thread; but anything that
bdrv_parent_drained_end_single_no_poll() may have scheduled is going to
want to run in the I/O thread, but because we poll the main loop, the
I/O thread is never unpaused, and nothing is run, resulting in a
deadlock.

Closes: https://gitlab.com/qemu-project/qemu/-/issues/1215
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20221107151321.211175-4-hreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/io.c | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ static void bdrv_parent_drained_end_single_no_poll(BdrvChild *c,
 void bdrv_parent_drained_end_single(BdrvChild *c)
 {
     int drained_end_counter = 0;
+    AioContext *ctx = bdrv_child_get_parent_aio_context(c);
     IO_OR_GS_CODE();
     bdrv_parent_drained_end_single_no_poll(c, &drained_end_counter);
-    BDRV_POLL_WHILE(c->bs, qatomic_read(&drained_end_counter) > 0);
+    AIO_WAIT_WHILE(ctx, qatomic_read(&drained_end_counter) > 0);
 }
 
 static void bdrv_parent_drained_end(BlockDriverState *bs, BdrvChild *ignore,
@@ -XXX,XX +XXX,XX @@ static bool bdrv_parent_drained_poll(BlockDriverState *bs, BdrvChild *ignore,
 
 void bdrv_parent_drained_begin_single(BdrvChild *c, bool poll)
 {
+    AioContext *ctx = bdrv_child_get_parent_aio_context(c);
     IO_OR_GS_CODE();
     c->parent_quiesce_counter++;
     if (c->klass->drained_begin) {
         c->klass->drained_begin(c);
     }
     if (poll) {
-        BDRV_POLL_WHILE(c->bs, bdrv_parent_drained_poll_single(c));
+        AIO_WAIT_WHILE(ctx, bdrv_parent_drained_poll_single(c));
     }
 }
 
-- 
2.38.1

From: Hanna Reitz <hreitz@redhat.com>

Test streaming a base image into the top image underneath two throttle
nodes.  This was reported to make qemu 7.1 hang
(https://gitlab.com/qemu-project/qemu/-/issues/1215), so this serves as
a regression test.

Signed-off-by: Hanna Reitz <hreitz@redhat.com>
Message-Id: <20221110160921.33158-1-hreitz@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 .../qemu-iotests/tests/stream-under-throttle  | 121 ++++++++++++++++++
 .../tests/stream-under-throttle.out           |   5 +
 2 files changed, 126 insertions(+)
 create mode 100755 tests/qemu-iotests/tests/stream-under-throttle
 create mode 100644 tests/qemu-iotests/tests/stream-under-throttle.out

diff --git a/tests/qemu-iotests/tests/stream-under-throttle b/tests/qemu-iotests/tests/stream-under-throttle
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/stream-under-throttle
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python3
+# group: rw
+#
+# Test streaming with throttle nodes on top
+#
+# Copyright (C) 2022 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+import asyncio
+import os
+from typing import List
+import iotests
+from iotests import qemu_img_create, qemu_io
+
+
+image_size = 256 * 1024 * 1024
+base_img = os.path.join(iotests.test_dir, 'base.img')
+top_img = os.path.join(iotests.test_dir, 'top.img')
+
+
+class TcgVM(iotests.VM):
+    '''
+    Variant of iotests.VM that uses -accel tcg.  Simply using
+    iotests.VM.add_args('-accel', 'tcg') is not sufficient, because that will
+    put -accel qtest before -accel tcg, and -accel arguments are prioritized in
+    the order they appear.
+    '''
+    @property
+    def _base_args(self) -> List[str]:
+        # Put -accel tcg first so it takes precedence
+        return ['-accel', 'tcg'] + super()._base_args
+
+
+class TestStreamWithThrottle(iotests.QMPTestCase):
+    def setUp(self) -> None:
+        '''
+        Create a simple backing chain between two images, write something to
+        the base image.  Attach them to the VM underneath two throttle nodes,
+        one of which has actually no limits set, but the other does.  Then put
+        a virtio-blk device on top.
+        This test configuration has been taken from
+        https://gitlab.com/qemu-project/qemu/-/issues/1215
+        '''
+        qemu_img_create('-f', iotests.imgfmt, base_img, str(image_size))
+        qemu_img_create('-f', iotests.imgfmt, '-b', base_img, '-F',
+                        iotests.imgfmt, top_img, str(image_size))
+
+        # Write something to stream
+        qemu_io(base_img, '-c', f'write 0 {image_size}')
+
+        blockdev = {
+            'driver': 'throttle',
+            'node-name': 'throttled-node',
+            'throttle-group': 'thrgr-limited',
+            'file': {
+                'driver': 'throttle',
+                'throttle-group': 'thrgr-unlimited',
+                'file': {
+                    'driver': iotests.imgfmt,
+                    'node-name': 'unthrottled-node',
+                    'file': {
+                        'driver': 'file',
+                        'filename': top_img
+                    }
+                }
+            }
+        }
+
+        # Issue 1215 is not reproducible in qtest mode, which is why we need to
+        # create an -accel tcg VM
+        self.vm = TcgVM()
+        self.vm.add_object('iothread,id=iothr0')
+        self.vm.add_object('throttle-group,id=thrgr-unlimited')
+        self.vm.add_object('throttle-group,id=thrgr-limited,'
+                           'x-iops-total=10000,x-bps-total=104857600')
+        self.vm.add_blockdev(self.vm.qmp_to_opts(blockdev))
+        self.vm.add_device('virtio-blk,iothread=iothr0,drive=throttled-node')
+        self.vm.launch()
+
+    def tearDown(self) -> None:
+        self.vm.shutdown()
+        os.remove(top_img)
+        os.remove(base_img)
+
+    def test_stream(self) -> None:
+        '''
+        Do a simple stream beneath the two throttle nodes.  Should complete
+        with no problems.
+        '''
+        result = self.vm.qmp('block-stream',
+                             job_id='stream',
+                             device='unthrottled-node')
+        self.assert_qmp(result, 'return', {})
+
+        # Should succeed and not time out
+        try:
+            self.vm.run_job('stream')
+        except asyncio.exceptions.TimeoutError:
+            # VM may be stuck, kill it before tearDown()
+            self.vm.kill()
+            raise
+
+
+if __name__ == '__main__':
+    # Must support backing images
+    iotests.main(supported_fmts=['qcow', 'qcow2', 'qed'],
+                 supported_protocols=['file'],
+                 required_fmts=['throttle'])
diff --git a/tests/qemu-iotests/tests/stream-under-throttle.out b/tests/qemu-iotests/tests/stream-under-throttle.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/stream-under-throttle.out
@@ -XXX,XX +XXX,XX @@
+.
+----------------------------------------------------------------------
+Ran 1 tests
+
+OK
-- 
2.38.1

The following changes since commit 52ed34cbddde1cb89b2ac263e758e349a77f21e1:

Merge tag 'pull-request-2023-06-26' of https://gitlab.com/thuth/qemu into staging (2023-06-26 10:38:41 +0200)

are available in the Git repository at:

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

for you to fetch changes up to 17362398ee1a7f04e8006a46333145d8b707fd35:

block: use bdrv_co_debug_event in coroutine context (2023-06-28 09:46:34 +0200)

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

- Re-enable the graph lock
- More fixes to coroutine_fn marking

----------------------------------------------------------------
Kevin Wolf (11):
      iotests: Test active commit with iothread and background I/O
      qdev-properties-system: Lock AioContext for blk_insert_bs()
      test-block-iothread: Lock AioContext for blk_insert_bs()
      block: Fix AioContext locking in bdrv_open_child()
      block: Fix AioContext locking in bdrv_attach_child_common()
      block: Fix AioContext locking in bdrv_reopen_parse_file_or_backing()
      block: Fix AioContext locking in bdrv_open_inherit()
      block: Fix AioContext locking in bdrv_open_backing_file()
      blockjob: Fix AioContext locking in block_job_add_bdrv()
      graph-lock: Unlock the AioContext while polling
      Revert "graph-lock: Disable locking for now"

Paolo Bonzini (12):
      file-posix: remove incorrect coroutine_fn calls
      qed: mark more functions as coroutine_fns and GRAPH_RDLOCK
      vpc: mark more functions as coroutine_fns and GRAPH_RDLOCK
      bochs: mark more functions as coroutine_fns and GRAPH_RDLOCK
      block: mark another function as coroutine_fns and GRAPH_UNLOCKED
      cloop: mark more functions as coroutine_fns and GRAPH_RDLOCK
      dmg: mark more functions as coroutine_fns and GRAPH_RDLOCK
      vmdk: mark more functions as coroutine_fns and GRAPH_RDLOCK
      vhdx: mark more functions as coroutine_fns and GRAPH_RDLOCK
      qcow2: mark more functions as coroutine_fns and GRAPH_RDLOCK
      block: use bdrv_co_getlength in coroutine context
      block: use bdrv_co_debug_event in coroutine context

This is a better regression test for the bugs hidden by commit 80fc5d26
('graph-lock: Disable locking for now'). With that commit reverted, it
hangs instantaneously and reliably for me.

It is important to have a reliable test like this, because the following
commits will set out to fix the actual root cause of the deadlocks and
then finally revert commit 80fc5d26, which was only a stopgap solution.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20230605085711.21261-2-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 .../tests/iothreads-commit-active             | 85 +++++++++++++++++++
 .../tests/iothreads-commit-active.out         | 23 +++++
 2 files changed, 108 insertions(+)
 create mode 100755 tests/qemu-iotests/tests/iothreads-commit-active
 create mode 100644 tests/qemu-iotests/tests/iothreads-commit-active.out

diff --git a/tests/qemu-iotests/tests/iothreads-commit-active b/tests/qemu-iotests/tests/iothreads-commit-active
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/iothreads-commit-active
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env python3
+# group: rw quick auto
+#
+# Copyright (C) 2023 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 asyncio
+import iotests
+
+iotests.script_initialize(supported_fmts=['qcow2'],
+                          supported_platforms=['linux'])
+iotests.verify_virtio_scsi_pci_or_ccw()
+
+with iotests.FilePath('disk0.img') as img_path, \
+     iotests.FilePath('disk0-snap.img') as snap_path, \
+     iotests.FilePath('mirror-src.img') as src_path, \
+     iotests.FilePath('mirror-dst.img') as dst_path, \
+     iotests.VM() as vm:
+
+    img_size = '10M'
+    iotests.qemu_img_create('-f', iotests.imgfmt, img_path, img_size)
+    iotests.qemu_img_create('-f', iotests.imgfmt, '-b', img_path,
+                            '-F', iotests.imgfmt, snap_path)
+    iotests.qemu_img_create('-f', iotests.imgfmt, src_path, img_size)
+    iotests.qemu_img_create('-f', iotests.imgfmt, dst_path, img_size)
+
+    iotests.qemu_io_log('-c', 'write 0 64k', img_path)
+    iotests.qemu_io_log('-c', 'write 1M 64k', snap_path)
+    iotests.qemu_io_log('-c', 'write 3M 64k', snap_path)
+
+    iotests.qemu_io_log('-c', f'write 0 {img_size}', src_path)
+
+    iotests.log('Launching VM...')
+    vm.add_object('iothread,id=iothread0')
+    vm.add_object('throttle-group,x-bps-write=1048576,id=tg0')
+    vm.add_blockdev(f'file,node-name=disk0-file,filename={img_path}')
+    vm.add_blockdev('qcow2,node-name=disk0-fmt,file=disk0-file')
+    vm.add_drive(snap_path, 'backing=disk0-fmt,node-name=disk0',
+                 interface='none')
+    vm.add_device('virtio-scsi,iothread=iothread0')
+    vm.add_device('scsi-hd,drive=drive0')
+
+    vm.add_blockdev(f'file,filename={src_path},node-name=mirror-src-file')
+    vm.add_blockdev('qcow2,file=mirror-src-file,node-name=mirror-src')
+    vm.add_blockdev(f'file,filename={dst_path},node-name=mirror-dst-file')
+    vm.add_blockdev('qcow2,file=mirror-dst-file,node-name=mirror-dst-fmt')
+    vm.add_blockdev('throttle,throttle-group=tg0,file=mirror-dst-fmt,'
+                    'node-name=mirror-dst')
+    vm.add_device('scsi-hd,drive=mirror-src')
+
+    vm.launch()
+
+    # The background I/O is created on unrelated nodes (so that they won't be
+    # drained together with the other ones), but on the same iothread
+    iotests.log('Creating some background I/O...')
+    iotests.log(vm.qmp('blockdev-mirror', job_id='job0', sync='full',
+                       device='mirror-src', target='mirror-dst',
+                       auto_dismiss=False))
+
+    iotests.log('Starting active commit...')
+    iotests.log(vm.qmp('block-commit', device='disk0', job_id='job1',
+                       auto_dismiss=False))
+
+    # Should succeed and not time out
+    try:
+        vm.run_job('job1', wait=5.0)
+        vm.shutdown()
+    except asyncio.TimeoutError:
+        # VM may be stuck, kill it
+        vm.kill()
+        raise
diff --git a/tests/qemu-iotests/tests/iothreads-commit-active.out b/tests/qemu-iotests/tests/iothreads-commit-active.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/tests/iothreads-commit-active.out
@@ -XXX,XX +XXX,XX @@
+wrote 65536/65536 bytes at offset 0
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+wrote 65536/65536 bytes at offset 1048576
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+wrote 65536/65536 bytes at offset 3145728
+64 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+wrote 10485760/10485760 bytes at offset 0
+10 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+Launching VM...
+Creating some background I/O...
+{"return": {}}
+Starting active commit...
+{"return": {}}
+{"execute": "job-complete", "arguments": {"id": "job1"}}
+{"return": {}}
+{"data": {"device": "job1", "len": 131072, "offset": 131072, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_READY", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"data": {"device": "job1", "len": 131072, "offset": 131072, "speed": 0, "type": "commit"}, "event": "BLOCK_JOB_COMPLETED", "timestamp": {"microseconds": "USECS", "seconds": "SECS"}}
+{"execute": "job-dismiss", "arguments": {"id": "job1"}}
+{"return": {}}
-- 
2.41.0

blk_insert_bs() requires that callers hold the AioContext lock for the
node that should be inserted. Take it.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20230605085711.21261-3-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 hw/core/qdev-properties-system.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/hw/core/qdev-properties-system.c b/hw/core/qdev-properties-system.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/core/qdev-properties-system.c
+++ b/hw/core/qdev-properties-system.c
@@ -XXX,XX +XXX,XX @@ static void set_drive_helper(Object *obj, Visitor *v, const char *name,
              * aware of iothreads require their BlockBackends to be in the main
              * AioContext.
              */
-            ctx = iothread ? bdrv_get_aio_context(bs) : qemu_get_aio_context();
-            blk = blk_new(ctx, 0, BLK_PERM_ALL);
+            ctx = bdrv_get_aio_context(bs);
+            blk = blk_new(iothread ? ctx : qemu_get_aio_context(),
+                          0, BLK_PERM_ALL);
             blk_created = true;
 
+            aio_context_acquire(ctx);
             ret = blk_insert_bs(blk, bs, errp);
+            aio_context_release(ctx);
+
             if (ret < 0) {
                 goto fail;
             }
-- 
2.41.0

blk_insert_bs() requires that callers hold the AioContext lock for the
node that should be inserted. Take it.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20230605085711.21261-4-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/unit/test-block-iothread.c | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/tests/unit/test-block-iothread.c b/tests/unit/test-block-iothread.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/test-block-iothread.c
+++ b/tests/unit/test-block-iothread.c
@@ -XXX,XX +XXX,XX @@ static void test_attach_second_node(void)
     BlockDriverState *bs, *filter;
     QDict *options;
 
+    aio_context_acquire(main_ctx);
     blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
     blk_insert_bs(blk, bs, &error_abort);
@@ -XXX,XX +XXX,XX @@ static void test_attach_second_node(void)
     qdict_put_str(options, "driver", "raw");
     qdict_put_str(options, "file", "base");
 
-    aio_context_acquire(main_ctx);
     filter = bdrv_open(NULL, NULL, options, BDRV_O_RDWR, &error_abort);
     aio_context_release(main_ctx);
 
@@ -XXX,XX +XXX,XX @@ static void test_attach_preserve_blk_ctx(void)
 {
     IOThread *iothread = iothread_new();
     AioContext *ctx = iothread_get_aio_context(iothread);
+    AioContext *main_ctx = qemu_get_aio_context();
     BlockBackend *blk;
     BlockDriverState *bs;
 
+    aio_context_acquire(main_ctx);
     blk = blk_new(ctx, BLK_PERM_ALL, BLK_PERM_ALL);
     bs = bdrv_new_open_driver(&bdrv_test, "base", BDRV_O_RDWR, &error_abort);
     bs->total_sectors = 65536 / BDRV_SECTOR_SIZE;
@@ -XXX,XX +XXX,XX @@ static void test_attach_preserve_blk_ctx(void)
     blk_insert_bs(blk, bs, &error_abort);
     g_assert(blk_get_aio_context(blk) == ctx);
     g_assert(bdrv_get_aio_context(bs) == ctx);
+    aio_context_release(main_ctx);
 
     /* Remove the node again */
     aio_context_acquire(ctx);
@@ -XXX,XX +XXX,XX @@ static void test_attach_preserve_blk_ctx(void)
     g_assert(bdrv_get_aio_context(bs) == qemu_get_aio_context());
 
     /* Re-attach the node */
+    aio_context_acquire(main_ctx);
     blk_insert_bs(blk, bs, &error_abort);
+    aio_context_release(main_ctx);
     g_assert(blk_get_aio_context(blk) == ctx);
     g_assert(bdrv_get_aio_context(bs) == ctx);
 
-- 
2.41.0

bdrv_attach_child() requires that the caller holds the AioContext lock
for the new child node. Take it in bdrv_open_child() and document that
the caller must not hold any AioContext apart from the main AioContext.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20230605085711.21261-5-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ done:
  *
  * The BlockdevRef will be removed from the options QDict.
  *
+ * The caller must hold the lock of the main AioContext and no other AioContext.
  * @parent can move to a different AioContext in this function. Callers must
  * make sure that their AioContext locking is still correct after this.
  */
@@ -XXX,XX +XXX,XX @@ BdrvChild *bdrv_open_child(const char *filename,
                            bool allow_none, Error **errp)
 {
     BlockDriverState *bs;
+    BdrvChild *child;
+    AioContext *ctx;
 
     GLOBAL_STATE_CODE();
 
@@ -XXX,XX +XXX,XX @@ BdrvChild *bdrv_open_child(const char *filename,
         return NULL;
     }
 
-    return bdrv_attach_child(parent, bs, bdref_key, child_class, child_role,
-                             errp);
+    ctx = bdrv_get_aio_context(bs);
+    aio_context_acquire(ctx);
+    child = bdrv_attach_child(parent, bs, bdref_key, child_class, child_role,
+                              errp);
+    aio_context_release(ctx);
+
+    return child;
 }
 
 /*
  * Wrapper on bdrv_open_child() for most popular case: open primary child of bs.
  *
+ * The caller must hold the lock of the main AioContext and no other AioContext.
  * @parent can move to a different AioContext in this function. Callers must
  * make sure that their AioContext locking is still correct after this.
  */
-- 
2.41.0

The function can move the child node to a different AioContext. In this
case, it also must take the AioContext lock for the new context before
calling functions that require the caller to hold the AioContext for the
child node.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20230605085711.21261-6-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static TransactionActionDrv bdrv_attach_child_common_drv = {
  * Function doesn't update permissions, caller is responsible for this.
  *
  * Returns new created child.
+ *
+ * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
+ * @child_bs can move to a different AioContext in this function. Callers must
+ * make sure that their AioContext locking is still correct after this.
  */
 static BdrvChild *bdrv_attach_child_common(BlockDriverState *child_bs,
                                            const char *child_name,
@@ -XXX,XX +XXX,XX @@ static BdrvChild *bdrv_attach_child_common(BlockDriverState *child_bs,
                                            Transaction *tran, Error **errp)
 {
     BdrvChild *new_child;
-    AioContext *parent_ctx;
+    AioContext *parent_ctx, *new_child_ctx;
     AioContext *child_ctx = bdrv_get_aio_context(child_bs);
 
     assert(child_class->get_parent_desc);
@@ -XXX,XX +XXX,XX @@ static BdrvChild *bdrv_attach_child_common(BlockDriverState *child_bs,
         }
     }
 
+    new_child_ctx = bdrv_get_aio_context(child_bs);
+    if (new_child_ctx != child_ctx) {
+        aio_context_release(child_ctx);
+        aio_context_acquire(new_child_ctx);
+    }
+
     bdrv_ref(child_bs);
     /*
      * Let every new BdrvChild start with a drained parent. Inserting the child
@@ -XXX,XX +XXX,XX @@ static BdrvChild *bdrv_attach_child_common(BlockDriverState *child_bs,
     };
     tran_add(tran, &bdrv_attach_child_common_drv, s);
 
+    if (new_child_ctx != child_ctx) {
+        aio_context_release(new_child_ctx);
+        aio_context_acquire(child_ctx);
+    }
+
     return new_child;
 }
 
 /*
  * Function doesn't update permissions, caller is responsible for this.
+ *
+ * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
+ * @child_bs can move to a different AioContext in this function. Callers must
+ * make sure that their AioContext locking is still correct after this.
  */
 static BdrvChild *bdrv_attach_child_noperm(BlockDriverState *parent_bs,
                                            BlockDriverState *child_bs,
-- 
2.41.0

bdrv_set_file_or_backing_noperm() requires the caller to hold the
AioContext lock for the child node, but we hold the one for the parent
node in bdrv_reopen_parse_file_or_backing(). Take the other one
temporarily.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20230605085711.21261-7-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 35 +++++++++++++++++++++++++++++++++--
 1 file changed, 33 insertions(+), 2 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static BdrvChildRole bdrv_backing_role(BlockDriverState *bs)
  * callers which don't need their own reference any more must call bdrv_unref().
  *
  * Function doesn't update permissions, caller is responsible for this.
+ *
+ * The caller must hold the AioContext lock for @child_bs. Both @parent_bs and
+ * @child_bs can move to a different AioContext in this function. Callers must
+ * make sure that their AioContext locking is still correct after this.
  */
 static int bdrv_set_file_or_backing_noperm(BlockDriverState *parent_bs,
                                            BlockDriverState *child_bs,
@@ -XXX,XX +XXX,XX @@ out:
     return 0;
 }
 
+/*
+ * The caller must hold the AioContext lock for @backing_hd. Both @bs and
+ * @backing_hd can move to a different AioContext in this function. Callers must
+ * make sure that their AioContext locking is still correct after this.
+ */
 static int bdrv_set_backing_noperm(BlockDriverState *bs,
                                    BlockDriverState *backing_hd,
                                    Transaction *tran, Error **errp)
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_set_read_only(BlockDriverState *bs, bool read_only,
  * backing BlockDriverState (or NULL).
  *
  * Return 0 on success, otherwise return < 0 and set @errp.
+ *
+ * The caller must hold the AioContext lock of @reopen_state->bs.
+ * @reopen_state->bs can move to a different AioContext in this function.
+ * Callers must make sure that their AioContext locking is still correct after
+ * this.
  */
 static int bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,
                                              bool is_backing, Transaction *tran,
@@ -XXX,XX +XXX,XX @@ static int bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,
     const char *child_name = is_backing ? "backing" : "file";
     QObject *value;
     const char *str;
+    AioContext *ctx, *old_ctx;
+    int ret;
 
     GLOBAL_STATE_CODE();
 
@@ -XXX,XX +XXX,XX @@ static int bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,
         reopen_state->old_file_bs = old_child_bs;
     }
 
-    return bdrv_set_file_or_backing_noperm(bs, new_child_bs, is_backing,
-                                           tran, errp);
+    old_ctx = bdrv_get_aio_context(bs);
+    ctx = bdrv_get_aio_context(new_child_bs);
+    if (old_ctx != ctx) {
+        aio_context_release(old_ctx);
+        aio_context_acquire(ctx);
+    }
+
+    ret = bdrv_set_file_or_backing_noperm(bs, new_child_bs, is_backing,
+                                          tran, errp);
+
+    if (old_ctx != ctx) {
+        aio_context_release(ctx);
+        aio_context_acquire(old_ctx);
+    }
+
+    return ret;
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ static int bdrv_reopen_parse_file_or_backing(BDRVReopenState *reopen_state,
  * It is the responsibility of the caller to then call the abort() or
  * commit() for any other BDS that have been left in a prepare() state
  *
+ * The caller must hold the AioContext lock of @reopen_state->bs.
  */
 static int bdrv_reopen_prepare(BDRVReopenState *reopen_state,
                                BlockReopenQueue *queue,
-- 
2.41.0

bdrv_open_inherit() calls several functions for which it needs to hold
the AioContext lock, but currently doesn't. This includes calls in
bdrv_append_temp_snapshot(), for which bdrv_open_inherit() is the only
caller. Fix the locking in these places.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20230605085711.21261-8-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 25 ++++++++++++++++++++++++-
 1 file changed, 24 insertions(+), 1 deletion(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
     int64_t total_size;
     QemuOpts *opts = NULL;
     BlockDriverState *bs_snapshot = NULL;
+    AioContext *ctx = bdrv_get_aio_context(bs);
     int ret;
 
     GLOBAL_STATE_CODE();
@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
        instead of opening 'filename' directly */
 
     /* Get the required size from the image */
+    aio_context_acquire(ctx);
     total_size = bdrv_getlength(bs);
+    aio_context_release(ctx);
+
     if (total_size < 0) {
         error_setg_errno(errp, -total_size, "Could not get image size");
         goto out;
@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_append_temp_snapshot(BlockDriverState *bs,
         goto out;
     }
 
+    aio_context_acquire(ctx);
     ret = bdrv_append(bs_snapshot, bs, errp);
+    aio_context_release(ctx);
+
     if (ret < 0) {
         bs_snapshot = NULL;
         goto out;
@@ -XXX,XX +XXX,XX @@ bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
     Error *local_err = NULL;
     QDict *snapshot_options = NULL;
     int snapshot_flags = 0;
+    AioContext *ctx = qemu_get_aio_context();
 
     assert(!child_class || !flags);
     assert(!child_class == !parent);
@@ -XXX,XX +XXX,XX @@ bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
             /* Not requesting BLK_PERM_CONSISTENT_READ because we're only
              * looking at the header to guess the image format. This works even
              * in cases where a guest would not see a consistent state. */
-            file = blk_new(bdrv_get_aio_context(file_bs), 0, BLK_PERM_ALL);
+            ctx = bdrv_get_aio_context(file_bs);
+            aio_context_acquire(ctx);
+            file = blk_new(ctx, 0, BLK_PERM_ALL);
             blk_insert_bs(file, file_bs, &local_err);
             bdrv_unref(file_bs);
+            aio_context_release(ctx);
+
             if (local_err) {
                 goto fail;
             }
@@ -XXX,XX +XXX,XX @@ bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
         goto fail;
     }
 
+    /* The AioContext could have changed during bdrv_open_common() */
+    ctx = bdrv_get_aio_context(bs);
+
     if (file) {
+        aio_context_acquire(ctx);
         blk_unref(file);
+        aio_context_release(ctx);
         file = NULL;
     }
 
@@ -XXX,XX +XXX,XX @@ bdrv_open_inherit(const char *filename, const char *reference, QDict *options,
          * (snapshot_bs); thus, we have to drop the strong reference to bs
          * (which we obtained by calling bdrv_new()). bs will not be deleted,
          * though, because the overlay still has a reference to it. */
+        aio_context_acquire(ctx);
         bdrv_unref(bs);
+        aio_context_release(ctx);
         bs = snapshot_bs;
     }
 
     return bs;
 
 fail:
+    aio_context_acquire(ctx);
     blk_unref(file);
     qobject_unref(snapshot_options);
     qobject_unref(bs->explicit_options);
@@ -XXX,XX +XXX,XX @@ fail:
     bs->options = NULL;
     bs->explicit_options = NULL;
     bdrv_unref(bs);
+    aio_context_release(ctx);
     error_propagate(errp, local_err);
     return NULL;
 
 close_and_fail:
+    aio_context_acquire(ctx);
     bdrv_unref(bs);
+    aio_context_release(ctx);
     qobject_unref(snapshot_options);
     qobject_unref(options);
     error_propagate(errp, local_err);
-- 
2.41.0

bdrv_set_backing() requires the caller to hold the AioContext lock for
@backing_hd. Take it in bdrv_open_backing_file() before calling the
function.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20230605085711.21261-9-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 5 +++++
 1 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 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
     int ret = 0;
     bool implicit_backing = false;
     BlockDriverState *backing_hd;
+    AioContext *backing_hd_ctx;
     QDict *options;
     QDict *tmp_parent_options = NULL;
     Error *local_err = NULL;
@@ -XXX,XX +XXX,XX @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options,
 
     /* Hook up the backing file link; drop our reference, bs owns the
      * backing_hd reference now */
+    backing_hd_ctx = bdrv_get_aio_context(backing_hd);
+    aio_context_acquire(backing_hd_ctx);
     ret = bdrv_set_backing_hd(bs, backing_hd, errp);
     bdrv_unref(backing_hd);
+    aio_context_release(backing_hd_ctx);
+
     if (ret < 0) {
         goto free_exit;
     }
-- 
2.41.0

bdrv_root_attach_child() requires callers to hold the AioContext lock
for child_bs. Take it in block_job_add_bdrv() before calling the
function.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20230605085711.21261-10-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 blockjob.c | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/blockjob.c b/blockjob.c
index XXXXXXX..XXXXXXX 100644
--- a/blockjob.c
+++ b/blockjob.c
@@ -XXX,XX +XXX,XX @@ int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs,
                        uint64_t perm, uint64_t shared_perm, Error **errp)
 {
     BdrvChild *c;
+    AioContext *ctx = bdrv_get_aio_context(bs);
     bool need_context_ops;
     GLOBAL_STATE_CODE();
 
     bdrv_ref(bs);
 
-    need_context_ops = bdrv_get_aio_context(bs) != job->job.aio_context;
+    need_context_ops = ctx != job->job.aio_context;
 
-    if (need_context_ops && job->job.aio_context != qemu_get_aio_context()) {
-        aio_context_release(job->job.aio_context);
+    if (need_context_ops) {
+        if (job->job.aio_context != qemu_get_aio_context()) {
+            aio_context_release(job->job.aio_context);
+        }
+        aio_context_acquire(ctx);
     }
     c = bdrv_root_attach_child(bs, name, &child_job, 0, perm, shared_perm, job,
                                errp);
-    if (need_context_ops && job->job.aio_context != qemu_get_aio_context()) {
-        aio_context_acquire(job->job.aio_context);
+    if (need_context_ops) {
+        aio_context_release(ctx);
+        if (job->job.aio_context != qemu_get_aio_context()) {
+            aio_context_acquire(job->job.aio_context);
+        }
     }
     if (c == NULL) {
         return -EPERM;
-- 
2.41.0

If the caller keeps the AioContext lock for a block node in an iothread,
polling in bdrv_graph_wrlock() deadlocks if the condition isn't
fulfilled immediately.

Now that all callers make sure to actually have the AioContext locked
when they call bdrv_replace_child_noperm() like they should, we can
change bdrv_graph_wrlock() to take a BlockDriverState whose AioContext
lock the caller holds (NULL if it doesn't) and unlock it temporarily
while polling.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20230605085711.21261-11-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/graph-lock.h |  6 ++++--
 block.c                    |  4 ++--
 block/graph-lock.c         | 23 ++++++++++++++++++++++-
 3 files changed, 28 insertions(+), 5 deletions(-)

diff --git a/include/block/graph-lock.h b/include/block/graph-lock.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/graph-lock.h
+++ b/include/block/graph-lock.h
@@ -XXX,XX +XXX,XX @@ void unregister_aiocontext(AioContext *ctx);
  * The wrlock can only be taken from the main loop, with BQL held, as only the
  * main loop is allowed to modify the graph.
  *
+ * If @bs is non-NULL, its AioContext is temporarily released.
+ *
  * This function polls. Callers must not hold the lock of any AioContext other
- * than the current one.
+ * than the current one and the one of @bs.
  */
-void bdrv_graph_wrlock(void) TSA_ACQUIRE(graph_lock) TSA_NO_TSA;
+void bdrv_graph_wrlock(BlockDriverState *bs) TSA_ACQUIRE(graph_lock) TSA_NO_TSA;
 
 /*
  * bdrv_graph_wrunlock:
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm)
  * Replaces the node that a BdrvChild points to without updating permissions.
  *
  * If @new_bs is non-NULL, the parent of @child must already be drained through
- * @child.
+ * @child and the caller must hold the AioContext lock for @new_bs.
  */
 static void bdrv_replace_child_noperm(BdrvChild *child,
                                       BlockDriverState *new_bs)
@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,
     }
 
     /* TODO Pull this up into the callers to avoid polling here */
-    bdrv_graph_wrlock();
+    bdrv_graph_wrlock(new_bs);
     if (old_bs) {
         if (child->klass->detach) {
             child->klass->detach(child);
diff --git a/block/graph-lock.c b/block/graph-lock.c
index XXXXXXX..XXXXXXX 100644
--- a/block/graph-lock.c
+++ b/block/graph-lock.c
@@ -XXX,XX +XXX,XX @@ static uint32_t reader_count(void)
 }
 #endif
 
-void bdrv_graph_wrlock(void)
+void bdrv_graph_wrlock(BlockDriverState *bs)
 {
+    AioContext *ctx = NULL;
+
     GLOBAL_STATE_CODE();
     /*
      * TODO Some callers hold an AioContext lock when this is called, which
@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrlock(void)
      */
 #if 0
     assert(!qatomic_read(&has_writer));
+#endif
+
+    /*
+     * Release only non-mainloop AioContext. The mainloop often relies on the
+     * BQL and doesn't lock the main AioContext before doing things.
+     */
+    if (bs) {
+        ctx = bdrv_get_aio_context(bs);
+        if (ctx != qemu_get_aio_context()) {
+            aio_context_release(ctx);
+        } else {
+            ctx = NULL;
+        }
+    }
 
+#if 0
     /* Make sure that constantly arriving new I/O doesn't cause starvation */
     bdrv_drain_all_begin_nopoll();
 
@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrlock(void)
 
     bdrv_drain_all_end();
 #endif
+
+    if (ctx) {
+        aio_context_acquire(bdrv_get_aio_context(bs));
+    }
 }
 
 void bdrv_graph_wrunlock(void)
-- 
2.41.0

Now that bdrv_graph_wrlock() temporarily drops the AioContext lock that
its caller holds, it can poll without causing deadlocks. We can now
re-enable graph locking.

This reverts commit ad128dff0bf4b6f971d05eb4335a627883a19c1d.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-ID: <20230605085711.21261-12-kwolf@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/graph-lock.c | 26 --------------------------
 1 file changed, 26 deletions(-)

diff --git a/block/graph-lock.c b/block/graph-lock.c
index XXXXXXX..XXXXXXX 100644
--- a/block/graph-lock.c
+++ b/block/graph-lock.c
@@ -XXX,XX +XXX,XX @@ BdrvGraphLock graph_lock;
 /* Protects the list of aiocontext and orphaned_reader_count */
 static QemuMutex aio_context_list_lock;
 
-#if 0
 /* Written and read with atomic operations. */
 static int has_writer;
-#endif
 
 /*
  * A reader coroutine could move from an AioContext to another.
@@ -XXX,XX +XXX,XX @@ void unregister_aiocontext(AioContext *ctx)
     g_free(ctx->bdrv_graph);
 }
 
-#if 0
 static uint32_t reader_count(void)
 {
     BdrvGraphRWlock *brdv_graph;
@@ -XXX,XX +XXX,XX @@ static uint32_t reader_count(void)
     assert((int32_t)rd >= 0);
     return rd;
 }
-#endif
 
 void bdrv_graph_wrlock(BlockDriverState *bs)
 {
     AioContext *ctx = NULL;
 
     GLOBAL_STATE_CODE();
-    /*
-     * TODO Some callers hold an AioContext lock when this is called, which
-     * causes deadlocks. Reenable once the AioContext locking is cleaned up (or
-     * AioContext locks are gone).
-     */
-#if 0
     assert(!qatomic_read(&has_writer));
-#endif
 
     /*
      * Release only non-mainloop AioContext. The mainloop often relies on the
@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrlock(BlockDriverState *bs)
         }
     }
 
-#if 0
     /* Make sure that constantly arriving new I/O doesn't cause starvation */
     bdrv_drain_all_begin_nopoll();
 
@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrlock(BlockDriverState *bs)
     } while (reader_count() >= 1);
 
     bdrv_drain_all_end();
-#endif
 
     if (ctx) {
         aio_context_acquire(bdrv_get_aio_context(bs));
@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrlock(BlockDriverState *bs)
 void bdrv_graph_wrunlock(void)
 {
     GLOBAL_STATE_CODE();
-#if 0
     QEMU_LOCK_GUARD(&aio_context_list_lock);
     assert(qatomic_read(&has_writer));
 
@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrunlock(void)
 
     /* Wake up all coroutine that are waiting to read the graph */
     qemu_co_enter_all(&reader_queue, &aio_context_list_lock);
-#endif
 }
 
 void coroutine_fn bdrv_graph_co_rdlock(void)
 {
-    /* TODO Reenable when wrlock is reenabled */
-#if 0
     BdrvGraphRWlock *bdrv_graph;
     bdrv_graph = qemu_get_current_aio_context()->bdrv_graph;
 
@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_graph_co_rdlock(void)
             qemu_co_queue_wait(&reader_queue, &aio_context_list_lock);
         }
     }
-#endif
 }
 
 void coroutine_fn bdrv_graph_co_rdunlock(void)
 {
-#if 0
     BdrvGraphRWlock *bdrv_graph;
     bdrv_graph = qemu_get_current_aio_context()->bdrv_graph;
 
@@ -XXX,XX +XXX,XX @@ void coroutine_fn bdrv_graph_co_rdunlock(void)
     if (qatomic_read(&has_writer)) {
         aio_wait_kick();
     }
-#endif
 }
 
 void bdrv_graph_rdlock_main_loop(void)
@@ -XXX,XX +XXX,XX @@ void bdrv_graph_rdunlock_main_loop(void)
 void assert_bdrv_graph_readable(void)
 {
     /* reader_count() is slow due to aio_context_list_lock lock contention */
-    /* TODO Reenable when wrlock is reenabled */
-#if 0
 #ifdef CONFIG_DEBUG_GRAPH_LOCK
     assert(qemu_in_main_thread() || reader_count());
 #endif
-#endif
 }
 
 void assert_bdrv_graph_writable(void)
 {
     assert(qemu_in_main_thread());
-    /* TODO Reenable when wrlock is reenabled */
-#if 0
     assert(qatomic_read(&has_writer));
-#endif
 }
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

raw_co_getlength is called by handle_aiocb_write_zeroes, which is not a coroutine
function.  This is harmless because raw_co_getlength does not actually suspend,
but in the interest of clarity make it a non-coroutine_fn that is just wrapped
by the coroutine_fn raw_co_getlength.  Likewise, check_cache_dropped was only
a coroutine_fn because it called raw_co_getlength, so it can be made non-coroutine
as well.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-2-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/file-posix.c | 29 +++++++++++++++++------------
 1 file changed, 17 insertions(+), 12 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 @@ static int fd_open(BlockDriverState *bs)
     return -EIO;
 }
 
-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs);
+static int64_t raw_getlength(BlockDriverState *bs);
 
 typedef struct RawPosixAIOData {
     BlockDriverState *bs;
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_write_zeroes(void *opaque)
 #ifdef CONFIG_FALLOCATE
     /* Last resort: we are trying to extend the file with zeroed data. This
      * can be done via fallocate(fd, 0) */
-    len = raw_co_getlength(aiocb->bs);
+    len = raw_getlength(aiocb->bs);
     if (s->has_fallocate && len >= 0 && aiocb->aio_offset >= len) {
         int ret = do_fallocate(s->fd, 0, aiocb->aio_offset, aiocb->aio_nbytes);
         if (ret == 0 || ret != -ENOTSUP) {
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
     }
 
     if (S_ISCHR(st.st_mode) || S_ISBLK(st.st_mode)) {
-        int64_t cur_length = raw_co_getlength(bs);
+        int64_t cur_length = raw_getlength(bs);
 
         if (offset != cur_length && exact) {
             error_setg(errp, "Cannot resize device files");
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_truncate(BlockDriverState *bs, int64_t offset,
 }
 
 #ifdef __OpenBSD__
-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
+static int64_t raw_getlength(BlockDriverState *bs)
 {
     BDRVRawState *s = bs->opaque;
     int fd = s->fd;
@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
         return st.st_size;
 }
 #elif defined(__NetBSD__)
-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
+static int64_t raw_getlength(BlockDriverState *bs)
 {
     BDRVRawState *s = bs->opaque;
     int fd = s->fd;
@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
         return st.st_size;
 }
 #elif defined(__sun__)
-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
+static int64_t raw_getlength(BlockDriverState *bs)
 {
     BDRVRawState *s = bs->opaque;
     struct dk_minfo minfo;
@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
     return size;
 }
 #elif defined(CONFIG_BSD)
-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
+static int64_t raw_getlength(BlockDriverState *bs)
 {
     BDRVRawState *s = bs->opaque;
     int fd = s->fd;
@@ -XXX,XX +XXX,XX @@ again:
     return size;
 }
 #else
-static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
+static int64_t raw_getlength(BlockDriverState *bs)
 {
     BDRVRawState *s = bs->opaque;
     int ret;
@@ -XXX,XX +XXX,XX @@ static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
 }
 #endif
 
+static int64_t coroutine_fn raw_co_getlength(BlockDriverState *bs)
+{
+    return raw_getlength(bs);
+}
+
 static int64_t coroutine_fn raw_co_get_allocated_file_size(BlockDriverState *bs)
 {
     struct stat st;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
          * round up if necessary.
          */
         if (!QEMU_IS_ALIGNED(*pnum, bs->bl.request_alignment)) {
-            int64_t file_length = raw_co_getlength(bs);
+            int64_t file_length = raw_getlength(bs);
             if (file_length > 0) {
                 /* Ignore errors, this is just a safeguard */
                 assert(hole == file_length);
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn raw_co_block_status(BlockDriverState *bs,
 
 #if defined(__linux__)
 /* Verify that the file is not in the page cache */
-static void coroutine_fn check_cache_dropped(BlockDriverState *bs, Error **errp)
+static void check_cache_dropped(BlockDriverState *bs, Error **errp)
 {
     const size_t window_size = 128 * 1024 * 1024;
     BDRVRawState *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static void coroutine_fn check_cache_dropped(BlockDriverState *bs, Error **errp)
     page_size = sysconf(_SC_PAGESIZE);
     vec = g_malloc(DIV_ROUND_UP(window_size, page_size));
 
-    end = raw_co_getlength(bs);
+    end = raw_getlength(bs);
 
     for (offset = 0; offset < end; offset += window_size) {
         void *new_window;
@@ -XXX,XX +XXX,XX @@ static int cdrom_reopen(BlockDriverState *bs)
 
 static bool coroutine_fn cdrom_co_is_inserted(BlockDriverState *bs)
 {
-    return raw_co_getlength(bs) > 0;
+    return raw_getlength(bs) > 0;
 }
 
 static void coroutine_fn cdrom_co_eject(BlockDriverState *bs, bool eject_flag)
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

Mark functions as coroutine_fn when they are only called by other coroutine_fns
and they can suspend.  Change calls to co_wrappers to use the non-wrapped
functions, which in turn requires adding GRAPH_RDLOCK annotations.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-3-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qed-check.c | 5 +++--
 block/qed.c       | 7 ++++---
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/block/qed-check.c b/block/qed-check.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed-check.c
+++ b/block/qed-check.c
@@ -XXX,XX +XXX,XX @@ static void qed_check_for_leaks(QEDCheck *check)
 /**
  * Mark an image clean once it passes check or has been repaired
  */
-static void qed_check_mark_clean(BDRVQEDState *s, BdrvCheckResult *result)
+static void coroutine_fn GRAPH_RDLOCK
+qed_check_mark_clean(BDRVQEDState *s, BdrvCheckResult *result)
 {
     /* Skip if there were unfixable corruptions or I/O errors */
     if (result->corruptions > 0 || result->check_errors > 0) {
@@ -XXX,XX +XXX,XX @@ static void qed_check_mark_clean(BDRVQEDState *s, BdrvCheckResult *result)
     }
 
     /* Ensure fixes reach storage before clearing check bit */
-    bdrv_flush(s->bs);
+    bdrv_co_flush(s->bs);
 
     s->header.features &= ~QED_F_NEED_CHECK;
     qed_write_header_sync(s);
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static bool qed_is_image_size_valid(uint64_t image_size, uint32_t cluster_size,
  *
  * The string is NUL-terminated.
  */
-static int qed_read_string(BdrvChild *file, uint64_t offset, size_t n,
-                           char *buf, size_t buflen)
+static int coroutine_fn GRAPH_RDLOCK
+qed_read_string(BdrvChild *file, uint64_t offset,
+                size_t n, char *buf, size_t buflen)
 {
     int ret;
     if (n >= buflen) {
         return -EINVAL;
     }
-    ret = bdrv_pread(file, offset, n, buf, 0);
+    ret = bdrv_co_pread(file, offset, n, buf, 0);
     if (ret < 0) {
         return ret;
     }
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-4-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vpc.c | 52 ++++++++++++++++++++++++++--------------------------
 1 file changed, 26 insertions(+), 26 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 int vpc_reopen_prepare(BDRVReopenState *state,
  * operation (the block bitmaps is updated then), 0 otherwise.
  * If write is true then err must not be NULL.
  */
-static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
-                                       bool write, int *err)
+static int64_t coroutine_fn GRAPH_RDLOCK
+get_image_offset(BlockDriverState *bs, uint64_t offset, bool write, int *err)
 {
     BDRVVPCState *s = bs->opaque;
     uint64_t bitmap_offset, block_offset;
@@ -XXX,XX +XXX,XX @@ static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
 
         s->last_bitmap_offset = bitmap_offset;
         memset(bitmap, 0xff, s->bitmap_size);
-        r = bdrv_pwrite_sync(bs->file, bitmap_offset, s->bitmap_size, bitmap,
-                             0);
+        r = bdrv_co_pwrite_sync(bs->file, bitmap_offset, s->bitmap_size, bitmap, 0);
         if (r < 0) {
             *err = r;
             return -2;
@@ -XXX,XX +XXX,XX @@ static inline int64_t get_image_offset(BlockDriverState *bs, uint64_t offset,
  *
  * Returns 0 on success and < 0 on error
  */
-static int rewrite_footer(BlockDriverState *bs)
+static int coroutine_fn GRAPH_RDLOCK rewrite_footer(BlockDriverState *bs)
 {
     int ret;
     BDRVVPCState *s = bs->opaque;
     int64_t offset = s->free_data_block_offset;
 
-    ret = bdrv_pwrite_sync(bs->file, offset, sizeof(s->footer), &s->footer, 0);
+    ret = bdrv_co_pwrite_sync(bs->file, offset, sizeof(s->footer), &s->footer, 0);
     if (ret < 0)
         return ret;
 
@@ -XXX,XX +XXX,XX @@ static int rewrite_footer(BlockDriverState *bs)
  *
  * Returns the sectors' offset in the image file on success and < 0 on error
  */
-static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
+static int64_t coroutine_fn GRAPH_RDLOCK
+alloc_block(BlockDriverState *bs, int64_t offset)
 {
     BDRVVPCState *s = bs->opaque;
     int64_t bat_offset;
@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
 
     /* Initialize the block's bitmap */
     memset(bitmap, 0xff, s->bitmap_size);
-    ret = bdrv_pwrite_sync(bs->file, s->free_data_block_offset,
-                           s->bitmap_size, bitmap, 0);
+    ret = bdrv_co_pwrite_sync(bs->file, s->free_data_block_offset,
+                              s->bitmap_size, bitmap, 0);
     if (ret < 0) {
         return ret;
     }
@@ -XXX,XX +XXX,XX @@ static int64_t alloc_block(BlockDriverState *bs, int64_t offset)
     /* Write BAT entry to disk */
     bat_offset = s->bat_offset + (4 * index);
     bat_value = cpu_to_be32(s->pagetable[index]);
-    ret = bdrv_pwrite_sync(bs->file, bat_offset, 4, &bat_value, 0);
+    ret = bdrv_co_pwrite_sync(bs->file, bat_offset, 4, &bat_value, 0);
     if (ret < 0)
         goto fail;
 
@@ -XXX,XX +XXX,XX @@ fail:
     return ret;
 }
 
-static int coroutine_fn vpc_co_block_status(BlockDriverState *bs,
-                                            bool want_zero,
-                                            int64_t offset, int64_t bytes,
-                                            int64_t *pnum, int64_t *map,
-                                            BlockDriverState **file)
+static int coroutine_fn GRAPH_RDLOCK
+vpc_co_block_status(BlockDriverState *bs, bool want_zero,
+                    int64_t offset, int64_t bytes,
+                    int64_t *pnum, int64_t *map,
+                    BlockDriverState **file)
 {
     BDRVVPCState *s = bs->opaque;
     int64_t image_offset;
@@ -XXX,XX +XXX,XX @@ static int calculate_geometry(int64_t total_sectors, uint16_t *cyls,
     return 0;
 }
 
-static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
-                               int64_t total_sectors)
+static int coroutine_fn create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
+                                            int64_t total_sectors)
 {
     VHDDynDiskHeader dyndisk_header;
     uint8_t bat_sector[512];
@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
     block_size = 0x200000;
     num_bat_entries = DIV_ROUND_UP(total_sectors, block_size / 512);
 
-    ret = blk_pwrite(blk, offset, sizeof(*footer), footer, 0);
+    ret = blk_co_pwrite(blk, offset, sizeof(*footer), footer, 0);
     if (ret < 0) {
         goto fail;
     }
 
     offset = 1536 + ((num_bat_entries * 4 + 511) & ~511);
-    ret = blk_pwrite(blk, offset, sizeof(*footer), footer, 0);
+    ret = blk_co_pwrite(blk, offset, sizeof(*footer), footer, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
 
     memset(bat_sector, 0xFF, 512);
     for (i = 0; i < DIV_ROUND_UP(num_bat_entries * 4, 512); i++) {
-        ret = blk_pwrite(blk, offset, 512, bat_sector, 0);
+        ret = blk_co_pwrite(blk, offset, 512, bat_sector, 0);
         if (ret < 0) {
             goto fail;
         }
@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
     /* Write the header */
     offset = 512;
 
-    ret = blk_pwrite(blk, offset, sizeof(dyndisk_header), &dyndisk_header, 0);
+    ret = blk_co_pwrite(blk, offset, sizeof(dyndisk_header), &dyndisk_header, 0);
     if (ret < 0) {
         goto fail;
     }
@@ -XXX,XX +XXX,XX @@ static int create_dynamic_disk(BlockBackend *blk, VHDFooter *footer,
     return ret;
 }
 
-static int create_fixed_disk(BlockBackend *blk, VHDFooter *footer,
-                             int64_t total_size, Error **errp)
+static int coroutine_fn create_fixed_disk(BlockBackend *blk, VHDFooter *footer,
+                                          int64_t total_size, Error **errp)
 {
     int ret;
 
     /* Add footer to total size */
     total_size += sizeof(*footer);
 
-    ret = blk_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
+    ret = blk_co_truncate(blk, total_size, false, PREALLOC_MODE_OFF, 0, errp);
     if (ret < 0) {
         return ret;
     }
 
-    ret = blk_pwrite(blk, total_size - sizeof(*footer), sizeof(*footer),
-                     footer, 0);
+    ret = blk_co_pwrite(blk, total_size - sizeof(*footer), sizeof(*footer),
+                        footer, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Unable to write VHD header");
         return ret;
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-5-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/bochs.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/block/bochs.c b/block/bochs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/bochs.c
+++ b/block/bochs.c
@@ -XXX,XX +XXX,XX @@ static void bochs_refresh_limits(BlockDriverState *bs, Error **errp)
     bs->bl.request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O */
 }
 
-static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)
+static int64_t coroutine_fn GRAPH_RDLOCK
+seek_to_sector(BlockDriverState *bs, int64_t sector_num)
 {
     BDRVBochsState *s = bs->opaque;
     uint64_t offset = sector_num * 512;
@@ -XXX,XX +XXX,XX @@ static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)
         (s->extent_blocks + s->bitmap_blocks));
 
     /* read in bitmap for current extent */
-    ret = bdrv_pread(bs->file, bitmap_offset + (extent_offset / 8), 1,
-                     &bitmap_entry, 0);
+    ret = bdrv_co_pread(bs->file, bitmap_offset + (extent_offset / 8), 1,
+                        &bitmap_entry, 0);
     if (ret < 0) {
         return ret;
     }
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

Mark functions as coroutine_fn when they are only called by other coroutine_fns
and they can suspend.  Because this function operates on a BlockBackend, mark it
GRAPH_UNLOCKED.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-6-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_create(BlockDriver *drv, const char *filename,
  * On success, return @blk's actual length.
  * Otherwise, return -errno.
  */
-static int64_t create_file_fallback_truncate(BlockBackend *blk,
-                                             int64_t minimum_size, Error **errp)
+static int64_t coroutine_fn GRAPH_UNLOCKED
+create_file_fallback_truncate(BlockBackend *blk, int64_t minimum_size,
+                              Error **errp)
 {
     Error *local_err = NULL;
     int64_t size;
@@ -XXX,XX +XXX,XX @@ static int64_t create_file_fallback_truncate(BlockBackend *blk,
 
     GLOBAL_STATE_CODE();
 
-    ret = blk_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
-                       &local_err);
+    ret = blk_co_truncate(blk, minimum_size, false, PREALLOC_MODE_OFF, 0,
+                          &local_err);
     if (ret < 0 && ret != -ENOTSUP) {
         error_propagate(errp, local_err);
         return ret;
     }
 
-    size = blk_getlength(blk);
+    size = blk_co_getlength(blk);
     if (size < 0) {
         error_free(local_err);
         error_setg_errno(errp, -size,
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-7-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/cloop.c | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/block/cloop.c b/block/cloop.c
index XXXXXXX..XXXXXXX 100644
--- a/block/cloop.c
+++ b/block/cloop.c
@@ -XXX,XX +XXX,XX @@ static void cloop_refresh_limits(BlockDriverState *bs, Error **errp)
     bs->bl.request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O */
 }
 
-static inline int cloop_read_block(BlockDriverState *bs, int block_num)
+static int coroutine_fn GRAPH_RDLOCK
+cloop_read_block(BlockDriverState *bs, int block_num)
 {
     BDRVCloopState *s = bs->opaque;
 
@@ -XXX,XX +XXX,XX @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)
         int ret;
         uint32_t bytes = s->offsets[block_num + 1] - s->offsets[block_num];
 
-        ret = bdrv_pread(bs->file, s->offsets[block_num], bytes,
-                         s->compressed_block, 0);
+        ret = bdrv_co_pread(bs->file, s->offsets[block_num], bytes,
+                            s->compressed_block, 0);
         if (ret < 0) {
             return -1;
         }
@@ -XXX,XX +XXX,XX @@ static inline int cloop_read_block(BlockDriverState *bs, int block_num)
     return 0;
 }
 
-static int coroutine_fn
+static int coroutine_fn GRAPH_RDLOCK
 cloop_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                 QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-8-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/dmg.c | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/block/dmg.c b/block/dmg.c
index XXXXXXX..XXXXXXX 100644
--- a/block/dmg.c
+++ b/block/dmg.c
@@ -XXX,XX +XXX,XX @@ err:
     return s->n_chunks; /* error */
 }
 
-static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
+static int coroutine_fn GRAPH_RDLOCK
+dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
 {
     BDRVDMGState *s = bs->opaque;
 
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
         case UDZO: { /* zlib compressed */
             /* we need to buffer, because only the chunk as whole can be
              * inflated. */
-            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
-                             s->compressed_chunk, 0);
+            ret = bdrv_co_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
+                                s->compressed_chunk, 0);
             if (ret < 0) {
                 return -1;
             }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
             }
             /* we need to buffer, because only the chunk as whole can be
              * inflated. */
-            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
-                             s->compressed_chunk, 0);
+            ret = bdrv_co_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
+                                s->compressed_chunk, 0);
             if (ret < 0) {
                 return -1;
             }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
             }
             /* we need to buffer, because only the chunk as whole can be
              * inflated. */
-            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
-                             s->compressed_chunk, 0);
+            ret = bdrv_co_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
+                                s->compressed_chunk, 0);
             if (ret < 0) {
                 return -1;
             }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
             }
             break;
         case UDRW: /* copy */
-            ret = bdrv_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
-                             s->uncompressed_chunk, 0);
+            ret = bdrv_co_pread(bs->file, s->offsets[chunk], s->lengths[chunk],
+                                s->uncompressed_chunk, 0);
             if (ret < 0) {
                 return -1;
             }
@@ -XXX,XX +XXX,XX @@ static inline int dmg_read_chunk(BlockDriverState *bs, uint64_t sector_num)
     return 0;
 }
 
-static int coroutine_fn
+static int coroutine_fn GRAPH_RDLOCK
 dmg_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
               QEMUIOVector *qiov, BdrvRequestFlags flags)
 {
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-9-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vmdk.c | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ out:
     return ret;
 }
 
-static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
+static int coroutine_fn GRAPH_RDLOCK
+vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
 {
     char *desc, *tmp_desc;
     char *p_name, *tmp_str;
@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
 
     desc = g_malloc0(DESC_SIZE);
     tmp_desc = g_malloc0(DESC_SIZE);
-    ret = bdrv_pread(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
+    ret = bdrv_co_pread(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
     if (ret < 0) {
         goto out;
     }
@@ -XXX,XX +XXX,XX @@ static int vmdk_write_cid(BlockDriverState *bs, uint32_t cid)
         pstrcat(desc, DESC_SIZE, tmp_desc);
     }
 
-    ret = bdrv_pwrite_sync(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
+    ret = bdrv_co_pwrite_sync(bs->file, s->desc_offset, DESC_SIZE, desc, 0);
 
 out:
     g_free(desc);
@@ -XXX,XX +XXX,XX @@ vmdk_co_pwrite_zeroes(BlockDriverState *bs, int64_t offset, int64_t bytes,
     return ret;
 }
 
-static int GRAPH_UNLOCKED
+static int coroutine_fn GRAPH_UNLOCKED
 vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
                  bool zeroed_grain, Error **errp)
 {
@@ -XXX,XX +XXX,XX @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
     int gd_buf_size;
 
     if (flat) {
-        ret = blk_truncate(blk, filesize, false, PREALLOC_MODE_OFF, 0, errp);
+        ret = blk_co_truncate(blk, filesize, false, PREALLOC_MODE_OFF, 0, errp);
         goto exit;
     }
     magic = cpu_to_be32(VMDK4_MAGIC);
@@ -XXX,XX +XXX,XX @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
     header.check_bytes[3] = 0xa;
 
     /* write all the data */
-    ret = blk_pwrite(blk, 0, sizeof(magic), &magic, 0);
+    ret = blk_co_pwrite(blk, 0, sizeof(magic), &magic, 0);
     if (ret < 0) {
         error_setg(errp, QERR_IO_ERROR);
         goto exit;
     }
-    ret = blk_pwrite(blk, sizeof(magic), sizeof(header), &header, 0);
+    ret = blk_co_pwrite(blk, sizeof(magic), sizeof(header), &header, 0);
     if (ret < 0) {
         error_setg(errp, QERR_IO_ERROR);
         goto exit;
     }
 
-    ret = blk_truncate(blk, le64_to_cpu(header.grain_offset) << 9, false,
-                       PREALLOC_MODE_OFF, 0, errp);
+    ret = blk_co_truncate(blk, le64_to_cpu(header.grain_offset) << 9, false,
+                          PREALLOC_MODE_OFF, 0, errp);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
          i < gt_count; i++, tmp += gt_size) {
         gd_buf[i] = cpu_to_le32(tmp);
     }
-    ret = blk_pwrite(blk, le64_to_cpu(header.rgd_offset) * BDRV_SECTOR_SIZE,
-                     gd_buf_size, gd_buf, 0);
+    ret = blk_co_pwrite(blk, le64_to_cpu(header.rgd_offset) * BDRV_SECTOR_SIZE,
+                        gd_buf_size, gd_buf, 0);
     if (ret < 0) {
         error_setg(errp, QERR_IO_ERROR);
         goto exit;
@@ -XXX,XX +XXX,XX @@ vmdk_init_extent(BlockBackend *blk, int64_t filesize, bool flat, bool compress,
          i < gt_count; i++, tmp += gt_size) {
         gd_buf[i] = cpu_to_le32(tmp);
     }
-    ret = blk_pwrite(blk, le64_to_cpu(header.gd_offset) * BDRV_SECTOR_SIZE,
-                     gd_buf_size, gd_buf, 0);
+    ret = blk_co_pwrite(blk, le64_to_cpu(header.gd_offset) * BDRV_SECTOR_SIZE,
+                        gd_buf_size, gd_buf, 0);
     if (ret < 0) {
         error_setg(errp, QERR_IO_ERROR);
     }
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-10-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vhdx.h     |  5 ++--
 block/vhdx-log.c | 36 +++++++++++++-----------
 block/vhdx.c     | 73 +++++++++++++++++++++++-------------------------
 3 files changed, 57 insertions(+), 57 deletions(-)

diff --git a/block/vhdx.h b/block/vhdx.h
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.h
+++ b/block/vhdx.h
@@ -XXX,XX +XXX,XX @@ bool vhdx_checksum_is_valid(uint8_t *buf, size_t size, int crc_offset);
 int vhdx_parse_log(BlockDriverState *bs, BDRVVHDXState *s, bool *flushed,
                    Error **errp);
 
-int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
-                             void *data, uint32_t length, uint64_t offset);
+int coroutine_fn GRAPH_RDLOCK
+vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
+                         void *data, uint32_t length, uint64_t offset);
 
 static inline void leguid_to_cpus(MSGUID *guid)
 {
diff --git a/block/vhdx-log.c b/block/vhdx-log.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx-log.c
+++ b/block/vhdx-log.c
@@ -XXX,XX +XXX,XX @@ exit:
  * It is assumed that 'buffer' is at least 4096*num_sectors large.
  *
  * 0 is returned on success, -errno otherwise */
-static int vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log,
-                                  uint32_t *sectors_written, void *buffer,
-                                  uint32_t num_sectors)
+static int coroutine_fn GRAPH_RDLOCK
+vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log,
+                       uint32_t *sectors_written, void *buffer,
+                       uint32_t num_sectors)
 {
     int ret = 0;
     uint64_t offset;
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write_sectors(BlockDriverState *bs, VHDXLogEntries *log,
             /* full */
             break;
         }
-        ret = bdrv_pwrite(bs->file, offset, VHDX_LOG_SECTOR_SIZE, buffer_tmp,
-                          0);
+        ret = bdrv_co_pwrite(bs->file, offset, VHDX_LOG_SECTOR_SIZE, buffer_tmp, 0);
         if (ret < 0) {
             goto exit;
         }
@@ -XXX,XX +XXX,XX @@ static void vhdx_log_raw_to_le_sector(VHDXLogDescriptor *desc,
 }
 
 
-static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
-                          void *data, uint32_t length, uint64_t offset)
+static int coroutine_fn GRAPH_RDLOCK
+vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
+               void *data, uint32_t length, uint64_t offset)
 {
     int ret = 0;
     void *buffer = NULL;
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
 
     sectors += partial_sectors;
 
-    file_length = bdrv_getlength(bs->file->bs);
+    file_length = bdrv_co_getlength(bs->file->bs);
     if (file_length < 0) {
         ret = file_length;
         goto exit;
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
 
         if (i == 0 && leading_length) {
             /* partial sector at the front of the buffer */
-            ret = bdrv_pread(bs->file, file_offset, VHDX_LOG_SECTOR_SIZE,
-                             merged_sector, 0);
+            ret = bdrv_co_pread(bs->file, file_offset, VHDX_LOG_SECTOR_SIZE,
+                                merged_sector, 0);
             if (ret < 0) {
                 goto exit;
             }
@@ -XXX,XX +XXX,XX @@ static int vhdx_log_write(BlockDriverState *bs, BDRVVHDXState *s,
             sector_write = merged_sector;
         } else if (i == sectors - 1 && trailing_length) {
             /* partial sector at the end of the buffer */
-            ret = bdrv_pread(bs->file, file_offset + trailing_length,
-                             VHDX_LOG_SECTOR_SIZE - trailing_length,
-                             merged_sector + trailing_length, 0);
+            ret = bdrv_co_pread(bs->file, file_offset + trailing_length,
+                                VHDX_LOG_SECTOR_SIZE - trailing_length,
+                                merged_sector + trailing_length, 0);
             if (ret < 0) {
                 goto exit;
             }
@@ -XXX,XX +XXX,XX @@ exit:
 }
 
 /* Perform a log write, and then immediately flush the entire log */
-int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
-                             void *data, uint32_t length, uint64_t offset)
+int coroutine_fn
+vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
+                         void *data, uint32_t length, uint64_t offset)
 {
     int ret = 0;
     VHDXLogSequence logs = { .valid = true,
@@ -XXX,XX +XXX,XX @@ int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
 
     /* Make sure data written (new and/or changed blocks) is stable
      * on disk, before creating log entry */
-    ret = bdrv_flush(bs);
+    ret = bdrv_co_flush(bs);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ int vhdx_log_write_and_flush(BlockDriverState *bs, BDRVVHDXState *s,
     logs.log = s->log;
 
     /* Make sure log is stable on disk */
-    ret = bdrv_flush(bs);
+    ret = bdrv_co_flush(bs);
     if (ret < 0) {
         goto exit;
     }
diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ exit:
  *
  * Returns the file offset start of the new payload block
  */
-static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
-                               uint64_t *new_offset, bool *need_zero)
+static int coroutine_fn GRAPH_RDLOCK
+vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
+                    uint64_t *new_offset, bool *need_zero)
 {
     int64_t current_len;
 
-    current_len = bdrv_getlength(bs->file->bs);
+    current_len = bdrv_co_getlength(bs->file->bs);
     if (current_len < 0) {
         return current_len;
     }
@@ -XXX,XX +XXX,XX @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
     if (*need_zero) {
         int ret;
 
-        ret = bdrv_truncate(bs->file, *new_offset + s->block_size, false,
-                            PREALLOC_MODE_OFF, BDRV_REQ_ZERO_WRITE, NULL);
+        ret = bdrv_co_truncate(bs->file, *new_offset + s->block_size, false,
+                               PREALLOC_MODE_OFF, BDRV_REQ_ZERO_WRITE, NULL);
         if (ret != -ENOTSUP) {
             *need_zero = false;
             return ret;
         }
     }
 
-    return bdrv_truncate(bs->file, *new_offset + s->block_size, false,
-                         PREALLOC_MODE_OFF, 0, NULL);
+    return bdrv_co_truncate(bs->file, *new_offset + s->block_size, false,
+                            PREALLOC_MODE_OFF, 0, NULL);
 }
 
 /*
@@ -XXX,XX +XXX,XX @@ exit:
  * The first 64KB of the Metadata section is reserved for the metadata
  * header and entries; beyond that, the metadata items themselves reside.
  */
-static int vhdx_create_new_metadata(BlockBackend *blk,
-                                    uint64_t image_size,
-                                    uint32_t block_size,
-                                    uint32_t sector_size,
-                                    uint64_t metadata_offset,
-                                    VHDXImageType type)
+static int coroutine_fn
+vhdx_create_new_metadata(BlockBackend *blk, uint64_t image_size,
+                         uint32_t block_size, uint32_t sector_size,
+                         uint64_t metadata_offset, VHDXImageType type)
 {
     int ret = 0;
     uint32_t offset = 0;
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_new_metadata(BlockBackend *blk,
                                    VHDX_META_FLAGS_IS_VIRTUAL_DISK;
     vhdx_metadata_entry_le_export(&md_table_entry[4]);
 
-    ret = blk_pwrite(blk, metadata_offset, VHDX_HEADER_BLOCK_SIZE, buffer, 0);
+    ret = blk_co_pwrite(blk, metadata_offset, VHDX_HEADER_BLOCK_SIZE, buffer, 0);
     if (ret < 0) {
         goto exit;
     }
 
-    ret = blk_pwrite(blk, metadata_offset + (64 * KiB),
-                     VHDX_METADATA_ENTRY_BUFFER_SIZE, entry_buffer, 0);
+    ret = blk_co_pwrite(blk, metadata_offset + (64 * KiB),
+                        VHDX_METADATA_ENTRY_BUFFER_SIZE, entry_buffer, 0);
     if (ret < 0) {
         goto exit;
     }
@@ -XXX,XX +XXX,XX @@ exit:
  *  Fixed images: default state of the BAT is fully populated, with
  *                file offsets and state PAYLOAD_BLOCK_FULLY_PRESENT.
  */
-static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
-                           uint64_t image_size, VHDXImageType type,
-                           bool use_zero_blocks, uint64_t file_offset,
-                           uint32_t length, Error **errp)
+static int coroutine_fn
+vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
+                uint64_t image_size, VHDXImageType type,
+                bool use_zero_blocks, uint64_t file_offset,
+                uint32_t length, Error **errp)
 {
     int ret = 0;
     uint64_t data_file_offset;
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
     if (type == VHDX_TYPE_DYNAMIC) {
         /* All zeroes, so we can just extend the file - the end of the BAT
          * is the furthest thing we have written yet */
-        ret = blk_truncate(blk, data_file_offset, false, PREALLOC_MODE_OFF,
-                           0, errp);
+        ret = blk_co_truncate(blk, data_file_offset, false, PREALLOC_MODE_OFF,
+                              0, errp);
         if (ret < 0) {
             goto exit;
         }
     } else if (type == VHDX_TYPE_FIXED) {
-        ret = blk_truncate(blk, data_file_offset + image_size, false,
-                           PREALLOC_MODE_OFF, 0, errp);
+        ret = blk_co_truncate(blk, data_file_offset + image_size, false,
+                              PREALLOC_MODE_OFF, 0, errp);
         if (ret < 0) {
             goto exit;
         }
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_bat(BlockBackend *blk, BDRVVHDXState *s,
             s->bat[sinfo.bat_idx] = cpu_to_le64(s->bat[sinfo.bat_idx]);
             sector_num += s->sectors_per_block;
         }
-        ret = blk_pwrite(blk, file_offset, length, s->bat, 0);
+        ret = blk_co_pwrite(blk, file_offset, length, s->bat, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "Failed to write the BAT");
             goto exit;
@@ -XXX,XX +XXX,XX @@ exit:
  * to create the BAT itself, we will also cause the BAT to be
  * created.
  */
-static int vhdx_create_new_region_table(BlockBackend *blk,
-                                        uint64_t image_size,
-                                        uint32_t block_size,
-                                        uint32_t sector_size,
-                                        uint32_t log_size,
-                                        bool use_zero_blocks,
-                                        VHDXImageType type,
-                                        uint64_t *metadata_offset,
-                                        Error **errp)
+static int coroutine_fn
+vhdx_create_new_region_table(BlockBackend *blk, uint64_t image_size,
+                             uint32_t block_size, uint32_t sector_size,
+                             uint32_t log_size, bool use_zero_blocks,
+                             VHDXImageType type, uint64_t *metadata_offset,
+                             Error **errp)
 {
     int ret = 0;
     uint32_t offset = 0;
@@ -XXX,XX +XXX,XX @@ static int vhdx_create_new_region_table(BlockBackend *blk,
     }
 
     /* Now write out the region headers to disk */
-    ret = blk_pwrite(blk, VHDX_REGION_TABLE_OFFSET, VHDX_HEADER_BLOCK_SIZE,
-                     buffer, 0);
+    ret = blk_co_pwrite(blk, VHDX_REGION_TABLE_OFFSET, VHDX_HEADER_BLOCK_SIZE,
+                        buffer, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to write first region table");
         goto exit;
     }
 
-    ret = blk_pwrite(blk, VHDX_REGION_TABLE2_OFFSET, VHDX_HEADER_BLOCK_SIZE,
-                     buffer, 0);
+    ret = blk_co_pwrite(blk, VHDX_REGION_TABLE2_OFFSET, VHDX_HEADER_BLOCK_SIZE,
+                        buffer, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "Failed to write second region table");
         goto exit;
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-11-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.h          |  33 +++++------
 block/qcow2-bitmap.c   |  26 +++++----
 block/qcow2-cluster.c  |  12 ++--
 block/qcow2-refcount.c | 130 +++++++++++++++++++++--------------------
 block/qcow2.c          |   2 +-
 5 files changed, 105 insertions(+), 98 deletions(-)

diff --git a/block/qcow2.h b/block/qcow2.h
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_metadata_size(int64_t clusters, size_t cluster_size,
 
 int qcow2_mark_dirty(BlockDriverState *bs);
 int qcow2_mark_corrupt(BlockDriverState *bs);
-int qcow2_mark_consistent(BlockDriverState *bs);
 int qcow2_update_header(BlockDriverState *bs);
 
 void qcow2_signal_corruption(BlockDriverState *bs, bool fatal, int64_t offset,
@@ -XXX,XX +XXX,XX @@ int64_t qcow2_refcount_area(BlockDriverState *bs, uint64_t offset,
 int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size);
 int64_t coroutine_fn qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
                                              int64_t nb_clusters);
-int64_t coroutine_fn qcow2_alloc_bytes(BlockDriverState *bs, int size);
+int64_t coroutine_fn GRAPH_RDLOCK qcow2_alloc_bytes(BlockDriverState *bs, int size);
 void qcow2_free_clusters(BlockDriverState *bs,
                           int64_t offset, int64_t size,
                           enum qcow2_discard_type type);
@@ -XXX,XX +XXX,XX @@ int qcow2_update_snapshot_refcount(BlockDriverState *bs,
 
 int qcow2_flush_caches(BlockDriverState *bs);
 int qcow2_write_caches(BlockDriverState *bs);
-int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
-                          BdrvCheckMode fix);
+int coroutine_fn qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
+                                       BdrvCheckMode fix);
 
 void qcow2_process_discards(BlockDriverState *bs, int ret);
 
@@ -XXX,XX +XXX,XX @@ int qcow2_check_metadata_overlap(BlockDriverState *bs, int ign, int64_t offset,
                                  int64_t size);
 int qcow2_pre_write_overlap_check(BlockDriverState *bs, int ign, int64_t offset,
                                   int64_t size, bool data_file);
-int qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
-                             void **refcount_table,
-                             int64_t *refcount_table_size,
-                             int64_t offset, int64_t size);
+int coroutine_fn qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
+                                          void **refcount_table,
+                                          int64_t *refcount_table_size,
+                                          int64_t offset, int64_t size);
 
 int qcow2_change_refcount_order(BlockDriverState *bs, int refcount_order,
                                 BlockDriverAmendStatusCB *status_cb,
@@ -XXX,XX +XXX,XX @@ int qcow2_get_host_offset(BlockDriverState *bs, uint64_t offset,
 int coroutine_fn qcow2_alloc_host_offset(BlockDriverState *bs, uint64_t offset,
                                          unsigned int *bytes,
                                          uint64_t *host_offset, QCowL2Meta **m);
-int coroutine_fn qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
-                                                       uint64_t offset,
-                                                       int compressed_size,
-                                                       uint64_t *host_offset);
+int coroutine_fn GRAPH_RDLOCK
+qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, uint64_t offset,
+                                      int compressed_size, uint64_t *host_offset);
 void qcow2_parse_compressed_l2_entry(BlockDriverState *bs, uint64_t l2_entry,
                                      uint64_t *coffset, int *csize);
 
@@ -XXX,XX +XXX,XX @@ void *qcow2_cache_is_table_offset(Qcow2Cache *c, uint64_t offset);
 void qcow2_cache_discard(Qcow2Cache *c, void *table);
 
 /* qcow2-bitmap.c functions */
-int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
-                                  void **refcount_table,
-                                  int64_t *refcount_table_size);
-bool coroutine_fn qcow2_load_dirty_bitmaps(BlockDriverState *bs,
-                                           bool *header_updated, Error **errp);
+int coroutine_fn
+qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
+                              void **refcount_table,
+                              int64_t *refcount_table_size);
+bool coroutine_fn GRAPH_RDLOCK
+qcow2_load_dirty_bitmaps(BlockDriverState *bs, bool *header_updated, Error **errp);
 bool qcow2_get_bitmap_info_list(BlockDriverState *bs,
                                 Qcow2BitmapInfoList **info_list, Error **errp);
 int qcow2_reopen_bitmaps_rw(BlockDriverState *bs, Error **errp);
diff --git a/block/qcow2-bitmap.c b/block/qcow2-bitmap.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-bitmap.c
+++ b/block/qcow2-bitmap.c
@@ -XXX,XX +XXX,XX @@ static int free_bitmap_clusters(BlockDriverState *bs, Qcow2BitmapTable *tb)
 /* load_bitmap_data
  * @bitmap_table entries must satisfy specification constraints.
  * @bitmap must be cleared */
-static int load_bitmap_data(BlockDriverState *bs,
-                            const uint64_t *bitmap_table,
-                            uint32_t bitmap_table_size,
-                            BdrvDirtyBitmap *bitmap)
+static int coroutine_fn GRAPH_RDLOCK
+load_bitmap_data(BlockDriverState *bs, const uint64_t *bitmap_table,
+                 uint32_t bitmap_table_size, BdrvDirtyBitmap *bitmap)
 {
     int ret = 0;
     BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static int load_bitmap_data(BlockDriverState *bs,
                  * already cleared */
             }
         } else {
-            ret = bdrv_pread(bs->file, data_offset, s->cluster_size, buf, 0);
+            ret = bdrv_co_pread(bs->file, data_offset, s->cluster_size, buf, 0);
             if (ret < 0) {
                 goto finish;
             }
@@ -XXX,XX +XXX,XX @@ finish:
     return ret;
 }
 
-static BdrvDirtyBitmap *load_bitmap(BlockDriverState *bs,
-                                    Qcow2Bitmap *bm, Error **errp)
+static coroutine_fn GRAPH_RDLOCK
+BdrvDirtyBitmap *load_bitmap(BlockDriverState *bs,
+                             Qcow2Bitmap *bm, Error **errp)
 {
     int ret;
     uint64_t *bitmap_table = NULL;
@@ -XXX,XX +XXX,XX @@ fail:
     return NULL;
 }
 
-int qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
-                                  void **refcount_table,
-                                  int64_t *refcount_table_size)
+int coroutine_fn
+qcow2_check_bitmaps_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
+                              void **refcount_table,
+                              int64_t *refcount_table_size)
 {
     int ret;
     BDRVQcow2State *s = bs->opaque;
@@ -XXX,XX +XXX,XX @@ static void set_readonly_helper(gpointer bitmap, gpointer value)
  * If header_updated is not NULL then it is set appropriately regardless of
  * the return value.
  */
-bool coroutine_fn qcow2_load_dirty_bitmaps(BlockDriverState *bs,
-                                           bool *header_updated, Error **errp)
+bool coroutine_fn GRAPH_RDLOCK
+qcow2_load_dirty_bitmaps(BlockDriverState *bs,
+                         bool *header_updated, Error **errp)
 {
     BDRVQcow2State *s = bs->opaque;
     Qcow2BitmapList *bm_list;
diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ static int get_cluster_table(BlockDriverState *bs, uint64_t offset,
  *
  * Return 0 on success and -errno in error cases
  */
-int coroutine_fn qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs,
-                                                       uint64_t offset,
-                                                       int compressed_size,
-                                                       uint64_t *host_offset)
+int coroutine_fn GRAPH_RDLOCK
+qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, uint64_t offset,
+                                      int compressed_size, uint64_t *host_offset)
 {
     BDRVQcow2State *s = bs->opaque;
     int l2_index, ret;
@@ -XXX,XX +XXX,XX @@ fail:
  * all clusters in the same L2 slice) and returns the number of zeroed
  * clusters.
  */
-static int zero_in_l2_slice(BlockDriverState *bs, uint64_t offset,
-                            uint64_t nb_clusters, int flags)
+static int coroutine_fn
+zero_in_l2_slice(BlockDriverState *bs, uint64_t offset,
+                 uint64_t nb_clusters, int flags)
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t *l2_slice;
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@ int64_t coroutine_fn qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offs
 
 /* only used to allocate compressed sectors. We try to allocate
    contiguous sectors. size must be <= cluster_size */
-int64_t coroutine_fn qcow2_alloc_bytes(BlockDriverState *bs, int size)
+int64_t coroutine_fn GRAPH_RDLOCK qcow2_alloc_bytes(BlockDriverState *bs, int size)
 {
     BDRVQcow2State *s = bs->opaque;
     int64_t offset;
@@ -XXX,XX +XXX,XX @@ static int realloc_refcount_array(BDRVQcow2State *s, void **array,
  *
  * Modifies the number of errors in res.
  */
-int qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
-                             void **refcount_table,
-                             int64_t *refcount_table_size,
-                             int64_t offset, int64_t size)
+int coroutine_fn GRAPH_RDLOCK
+qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
+                         void **refcount_table,
+                         int64_t *refcount_table_size,
+                         int64_t offset, int64_t size)
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t start, last, cluster_offset, k, refcount;
@@ -XXX,XX +XXX,XX @@ int qcow2_inc_refcounts_imrt(BlockDriverState *bs, BdrvCheckResult *res,
         return 0;
     }
 
-    file_len = bdrv_getlength(bs->file->bs);
+    file_len = bdrv_co_getlength(bs->file->bs);
     if (file_len < 0) {
         return file_len;
     }
@@ -XXX,XX +XXX,XX @@ enum {
  *
  * On failure in-memory @l2_table may be modified.
  */
-static int fix_l2_entry_by_zero(BlockDriverState *bs, BdrvCheckResult *res,
-                                uint64_t l2_offset,
-                                uint64_t *l2_table, int l2_index, bool active,
-                                bool *metadata_overlap)
+static int coroutine_fn GRAPH_RDLOCK
+fix_l2_entry_by_zero(BlockDriverState *bs, BdrvCheckResult *res,
+                     uint64_t l2_offset, uint64_t *l2_table,
+                     int l2_index, bool active,
+                     bool *metadata_overlap)
 {
     BDRVQcow2State *s = bs->opaque;
     int ret;
@@ -XXX,XX +XXX,XX @@ static int fix_l2_entry_by_zero(BlockDriverState *bs, BdrvCheckResult *res,
         goto fail;
     }
 
-    ret = bdrv_pwrite_sync(bs->file, l2e_offset, l2_entry_size(s),
-                           &l2_table[idx], 0);
+    ret = bdrv_co_pwrite_sync(bs->file, l2e_offset, l2_entry_size(s),
+                              &l2_table[idx], 0);
     if (ret < 0) {
         fprintf(stderr, "ERROR: Failed to overwrite L2 "
                 "table entry: %s\n", strerror(-ret));
@@ -XXX,XX +XXX,XX @@ fail:
  * Returns the number of errors found by the checks or -errno if an internal
  * error occurred.
  */
-static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
-                              void **refcount_table,
-                              int64_t *refcount_table_size, int64_t l2_offset,
-                              int flags, BdrvCheckMode fix, bool active)
+static int coroutine_fn GRAPH_RDLOCK
+check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
+                   void **refcount_table,
+                   int64_t *refcount_table_size, int64_t l2_offset,
+                   int flags, BdrvCheckMode fix, bool active)
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t l2_entry, l2_bitmap;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
     bool metadata_overlap;
 
     /* Read L2 table from disk */
-    ret = bdrv_pread(bs->file, l2_offset, l2_size_bytes, l2_table, 0);
+    ret = bdrv_co_pread(bs->file, l2_offset, l2_size_bytes, l2_table, 0);
     if (ret < 0) {
         fprintf(stderr, "ERROR: I/O error in check_refcounts_l2\n");
         res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l2(BlockDriverState *bs, BdrvCheckResult *res,
  * Returns the number of errors found by the checks or -errno if an internal
  * error occurred.
  */
-static int check_refcounts_l1(BlockDriverState *bs,
-                              BdrvCheckResult *res,
-                              void **refcount_table,
-                              int64_t *refcount_table_size,
-                              int64_t l1_table_offset, int l1_size,
-                              int flags, BdrvCheckMode fix, bool active)
+static int coroutine_fn GRAPH_RDLOCK
+check_refcounts_l1(BlockDriverState *bs, BdrvCheckResult *res,
+                   void **refcount_table, int64_t *refcount_table_size,
+                   int64_t l1_table_offset, int l1_size,
+                   int flags, BdrvCheckMode fix, bool active)
 {
     BDRVQcow2State *s = bs->opaque;
     size_t l1_size_bytes = l1_size * L1E_SIZE;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
     }
 
     /* Read L1 table entries from disk */
-    ret = bdrv_pread(bs->file, l1_table_offset, l1_size_bytes, l1_table, 0);
+    ret = bdrv_co_pread(bs->file, l1_table_offset, l1_size_bytes, l1_table, 0);
     if (ret < 0) {
         fprintf(stderr, "ERROR: I/O error in check_refcounts_l1\n");
         res->check_errors++;
@@ -XXX,XX +XXX,XX @@ static int check_refcounts_l1(BlockDriverState *bs,
  * have been already detected and sufficiently signaled by the calling function
  * (qcow2_check_refcounts) by the time this function is called).
  */
-static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
-                              BdrvCheckMode fix)
+static int coroutine_fn GRAPH_RDLOCK
+check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t *l2_table = qemu_blockalign(bs, s->cluster_size);
@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
             }
         }
 
-        ret = bdrv_pread(bs->file, l2_offset, s->l2_size * l2_entry_size(s),
-                         l2_table, 0);
+        ret = bdrv_co_pread(bs->file, l2_offset, s->l2_size * l2_entry_size(s),
+                            l2_table, 0);
         if (ret < 0) {
             fprintf(stderr, "ERROR: Could not read L2 table: %s\n",
                     strerror(-ret));
@@ -XXX,XX +XXX,XX @@ static int check_oflag_copied(BlockDriverState *bs, BdrvCheckResult *res,
                 goto fail;
             }
 
-            ret = bdrv_pwrite(bs->file, l2_offset, s->cluster_size, l2_table,
-                              0);
+            ret = bdrv_co_pwrite(bs->file, l2_offset, s->cluster_size, l2_table, 0);
             if (ret < 0) {
                 fprintf(stderr, "ERROR: Could not write L2 table: %s\n",
                         strerror(-ret));
@@ -XXX,XX +XXX,XX @@ fail:
  * Checks consistency of refblocks and accounts for each refblock in
  * *refcount_table.
  */
-static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
-                           BdrvCheckMode fix, bool *rebuild,
-                           void **refcount_table, int64_t *nb_clusters)
+static int coroutine_fn GRAPH_RDLOCK
+check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
+                BdrvCheckMode fix, bool *rebuild,
+                void **refcount_table, int64_t *nb_clusters)
 {
     BDRVQcow2State *s = bs->opaque;
     int64_t i, size;
@@ -XXX,XX +XXX,XX @@ static int check_refblocks(BlockDriverState *bs, BdrvCheckResult *res,
                     goto resize_fail;
                 }
 
-                ret = bdrv_truncate(bs->file, offset + s->cluster_size, false,
-                                    PREALLOC_MODE_OFF, 0, &local_err);
+                ret = bdrv_co_truncate(bs->file, offset + s->cluster_size, false,
+                                       PREALLOC_MODE_OFF, 0, &local_err);
                 if (ret < 0) {
                     error_report_err(local_err);
                     goto resize_fail;
                 }
-                size = bdrv_getlength(bs->file->bs);
+                size = bdrv_co_getlength(bs->file->bs);
                 if (size < 0) {
                     ret = size;
                     goto resize_fail;
@@ -XXX,XX +XXX,XX @@ resize_fail:
 /*
  * Calculates an in-memory refcount table.
  */
-static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
-                               BdrvCheckMode fix, bool *rebuild,
-                               void **refcount_table, int64_t *nb_clusters)
+static int coroutine_fn GRAPH_RDLOCK
+calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
+                    BdrvCheckMode fix, bool *rebuild,
+                    void **refcount_table, int64_t *nb_clusters)
 {
     BDRVQcow2State *s = bs->opaque;
     int64_t i;
@@ -XXX,XX +XXX,XX @@ static int calculate_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
  * Compares the actual reference count for each cluster in the image against the
  * refcount as reported by the refcount structures on-disk.
  */
-static void compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
-                              BdrvCheckMode fix, bool *rebuild,
-                              int64_t *highest_cluster,
-                              void *refcount_table, int64_t nb_clusters)
+static void coroutine_fn
+compare_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
+                  BdrvCheckMode fix, bool *rebuild,
+                  int64_t *highest_cluster,
+                  void *refcount_table, int64_t nb_clusters)
 {
     BDRVQcow2State *s = bs->opaque;
     int64_t i;
@@ -XXX,XX +XXX,XX @@ static int64_t alloc_clusters_imrt(BlockDriverState *bs,
  * Return whether the on-disk reftable array was resized (true/false),
  * or -errno on error.
  */
-static int rebuild_refcounts_write_refblocks(
+static int coroutine_fn GRAPH_RDLOCK
+rebuild_refcounts_write_refblocks(
         BlockDriverState *bs, void **refcount_table, int64_t *nb_clusters,
         int64_t first_cluster, int64_t end_cluster,
         uint64_t **on_disk_reftable_ptr, uint32_t *on_disk_reftable_entries_ptr,
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcounts_write_refblocks(
         on_disk_refblock = (void *)((char *) *refcount_table +
                                     refblock_index * s->cluster_size);
 
-        ret = bdrv_pwrite(bs->file, refblock_offset, s->cluster_size,
-                          on_disk_refblock, 0);
+        ret = bdrv_co_pwrite(bs->file, refblock_offset, s->cluster_size,
+                             on_disk_refblock, 0);
         if (ret < 0) {
             error_setg_errno(errp, -ret, "ERROR writing refblock");
             return ret;
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcounts_write_refblocks(
  * On success, the old refcount structure is leaked (it will be covered by the
  * new refcount structure).
  */
-static int rebuild_refcount_structure(BlockDriverState *bs,
-                                      BdrvCheckResult *res,
-                                      void **refcount_table,
-                                      int64_t *nb_clusters,
-                                      Error **errp)
+static int coroutine_fn GRAPH_RDLOCK
+rebuild_refcount_structure(BlockDriverState *bs, BdrvCheckResult *res,
+                           void **refcount_table, int64_t *nb_clusters,
+                           Error **errp)
 {
     BDRVQcow2State *s = bs->opaque;
     int64_t reftable_offset = -1;
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
     }
 
     assert(reftable_length < INT_MAX);
-    ret = bdrv_pwrite(bs->file, reftable_offset, reftable_length,
-                      on_disk_reftable, 0);
+    ret = bdrv_co_pwrite(bs->file, reftable_offset, reftable_length,
+                         on_disk_reftable, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "ERROR writing reftable");
         goto fail;
@@ -XXX,XX +XXX,XX @@ static int rebuild_refcount_structure(BlockDriverState *bs,
     reftable_offset_and_clusters.reftable_offset = cpu_to_be64(reftable_offset);
     reftable_offset_and_clusters.reftable_clusters =
         cpu_to_be32(reftable_clusters);
-    ret = bdrv_pwrite_sync(bs->file,
-                           offsetof(QCowHeader, refcount_table_offset),
-                           sizeof(reftable_offset_and_clusters),
-                           &reftable_offset_and_clusters, 0);
+    ret = bdrv_co_pwrite_sync(bs->file,
+                              offsetof(QCowHeader, refcount_table_offset),
+                              sizeof(reftable_offset_and_clusters),
+                              &reftable_offset_and_clusters, 0);
     if (ret < 0) {
         error_setg_errno(errp, -ret, "ERROR setting reftable");
         goto fail;
@@ -XXX,XX +XXX,XX @@ fail:
  * Returns 0 if no errors are found, the number of errors in case the image is
  * detected as corrupted, and -errno when an internal error occurred.
  */
-int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
-                          BdrvCheckMode fix)
+int coroutine_fn GRAPH_RDLOCK
+qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res, BdrvCheckMode fix)
 {
     BDRVQcow2State *s = bs->opaque;
     BdrvCheckResult pre_compare_res;
@@ -XXX,XX +XXX,XX @@ int qcow2_check_refcounts(BlockDriverState *bs, BdrvCheckResult *res,
     bool rebuild = false;
     int ret;
 
-    size = bdrv_getlength(bs->file->bs);
+    size = bdrv_co_getlength(bs->file->bs);
     if (size < 0) {
         res->check_errors++;
         return size;
@@ -XXX,XX +XXX,XX @@ done:
     return ret;
 }
 
-static int64_t get_refblock_offset(BlockDriverState *bs, uint64_t offset)
+static int64_t coroutine_fn get_refblock_offset(BlockDriverState *bs,
+                                                uint64_t offset)
 {
     BDRVQcow2State *s = bs->opaque;
     uint32_t index = offset_to_reftable_index(s, offset);
@@ -XXX,XX +XXX,XX @@ int64_t coroutine_fn qcow2_get_last_cluster(BlockDriverState *bs, int64_t size)
     return -EIO;
 }
 
-int coroutine_fn qcow2_detect_metadata_preallocation(BlockDriverState *bs)
+int coroutine_fn GRAPH_RDLOCK
+qcow2_detect_metadata_preallocation(BlockDriverState *bs)
 {
     BDRVQcow2State *s = bs->opaque;
     int64_t i, end_cluster, cluster_count = 0, threshold;
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ int qcow2_mark_corrupt(BlockDriverState *bs)
  * Marks the image as consistent, i.e., unsets the corrupt bit, and flushes
  * before if necessary.
  */
-int qcow2_mark_consistent(BlockDriverState *bs)
+static int coroutine_fn qcow2_mark_consistent(BlockDriverState *bs)
 {
     BDRVQcow2State *s = bs->opaque;
 
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

bdrv_co_getlength was recently introduced, with bdrv_getlength becoming
a wrapper for use in unknown context.  Switch to bdrv_co_getlength when
possible.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-12-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/io.c        | 10 +++++-----
 block/parallels.c |  4 ++--
 block/qcow.c      |  6 +++---
 block/vmdk.c      |  4 ++--
 4 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ bdrv_aligned_preadv(BdrvChild *child, BdrvTrackedRequest *req,
     }
 
     /* Forward the request to the BlockDriver, possibly fragmenting it */
-    total_bytes = bdrv_getlength(bs);
+    total_bytes = bdrv_co_getlength(bs);
     if (total_bytes < 0) {
         ret = total_bytes;
         goto out;
@@ -XXX,XX +XXX,XX @@ bdrv_co_block_status(BlockDriverState *bs, bool want_zero,
     assert(pnum);
     assert_bdrv_graph_readable();
     *pnum = 0;
-    total_size = bdrv_getlength(bs);
+    total_size = bdrv_co_getlength(bs);
     if (total_size < 0) {
         ret = total_size;
         goto early_out;
@@ -XXX,XX +XXX,XX @@ bdrv_co_block_status(BlockDriverState *bs, bool want_zero,
         bytes = n;
     }
 
-    /* Must be non-NULL or bdrv_getlength() would have failed */
+    /* Must be non-NULL or bdrv_co_getlength() would have failed */
     assert(bs->drv);
     has_filtered_child = bdrv_filter_child(bs);
     if (!bs->drv->bdrv_co_block_status && !has_filtered_child) {
@@ -XXX,XX +XXX,XX @@ bdrv_co_block_status(BlockDriverState *bs, bool want_zero,
         if (!cow_bs) {
             ret |= BDRV_BLOCK_ZERO;
         } else if (want_zero) {
-            int64_t size2 = bdrv_getlength(cow_bs);
+            int64_t size2 = bdrv_co_getlength(cow_bs);
 
             if (size2 >= 0 && offset >= size2) {
                 ret |= BDRV_BLOCK_ZERO;
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_truncate(BdrvChild *child, int64_t offset, bool exact,
         return ret;
     }
 
-    old_size = bdrv_getlength(bs);
+    old_size = bdrv_co_getlength(bs);
     if (old_size < 0) {
         error_setg_errno(errp, -old_size, "Failed to get old image size");
         return old_size;
diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ allocate_clusters(BlockDriverState *bs, int64_t sector_num,
     assert(idx < s->bat_size && idx + to_allocate <= s->bat_size);
 
     space = to_allocate * s->tracks;
-    len = bdrv_getlength(bs->file->bs);
+    len = bdrv_co_getlength(bs->file->bs);
     if (len < 0) {
         return len;
     }
@@ -XXX,XX +XXX,XX @@ parallels_check_outside_image(BlockDriverState *bs, BdrvCheckResult *res,
     uint32_t i;
     int64_t off, high_off, size;
 
-    size = bdrv_getlength(bs->file->bs);
+    size = bdrv_co_getlength(bs->file->bs);
     if (size < 0) {
         res->check_errors++;
         return size;
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
         if (!allocate)
             return 0;
         /* allocate a new l2 entry */
-        l2_offset = bdrv_getlength(bs->file->bs);
+        l2_offset = bdrv_co_getlength(bs->file->bs);
         if (l2_offset < 0) {
             return l2_offset;
         }
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
             if (decompress_cluster(bs, cluster_offset) < 0) {
                 return -EIO;
             }
-            cluster_offset = bdrv_getlength(bs->file->bs);
+            cluster_offset = bdrv_co_getlength(bs->file->bs);
             if ((int64_t) cluster_offset < 0) {
                 return cluster_offset;
             }
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
                 return ret;
             }
         } else {
-            cluster_offset = bdrv_getlength(bs->file->bs);
+            cluster_offset = bdrv_co_getlength(bs->file->bs);
             if ((int64_t) cluster_offset < 0) {
                 return cluster_offset;
             }
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ vmdk_co_pwritev_compressed(BlockDriverState *bs, int64_t offset, int64_t bytes,
         int64_t length;
 
         for (i = 0; i < s->num_extents; i++) {
-            length = bdrv_getlength(s->extents[i].file->bs);
+            length = bdrv_co_getlength(s->extents[i].file->bs);
             if (length < 0) {
                 return length;
             }
@@ -XXX,XX +XXX,XX @@ vmdk_co_check(BlockDriverState *bs, BdrvCheckResult *result, BdrvCheckMode fix)
             break;
         }
         if (ret == VMDK_OK) {
-            int64_t extent_len = bdrv_getlength(extent->file->bs);
+            int64_t extent_len = bdrv_co_getlength(extent->file->bs);
             if (extent_len < 0) {
                 fprintf(stderr,
                         "ERROR: could not get extent file length for sector %"
-- 
2.41.0

From: Paolo Bonzini <pbonzini@redhat.com>

bdrv_co_debug_event was recently introduced, with bdrv_debug_event
becoming a wrapper for use in unknown context.  Because most of the
time bdrv_debug_event is used on a BdrvChild via the wrapper macro
BLKDBG_EVENT, introduce a similar macro BLKDBG_CO_EVENT that calls
bdrv_co_debug_event, and switch whenever possible.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Message-ID: <20230601115145.196465-13-pbonzini@redhat.com>
Reviewed-by: Kevin Wolf <kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 include/block/block-io.h |  7 +++++++
 block/io.c               |  4 ++--
 block/qcow.c             | 24 ++++++++++++------------
 block/qcow2-cluster.c    | 12 ++++++------
 block/qcow2-refcount.c   |  4 ++--
 block/qcow2.c            | 18 +++++++++---------
 block/qed-table.c        |  6 +++---
 block/qed.c              |  8 ++++----
 block/raw-format.c       |  4 ++--
 block/vmdk.c             | 24 ++++++++++++------------
 10 files changed, 59 insertions(+), 52 deletions(-)

diff --git a/include/block/block-io.h b/include/block/block-io.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block-io.h
+++ b/include/block/block-io.h
@@ -XXX,XX +XXX,XX @@ bdrv_co_debug_event(BlockDriverState *bs, BlkdebugEvent event);
 void co_wrapper_mixed_bdrv_rdlock
 bdrv_debug_event(BlockDriverState *bs, BlkdebugEvent event);
 
+#define BLKDBG_CO_EVENT(child, evt) \
+    do { \
+        if (child) { \
+            bdrv_co_debug_event(child->bs, evt); \
+        } \
+    } while (0)
+
 #define BLKDBG_EVENT(child, evt) \
     do { \
         if (child) { \
diff --git a/block/io.c b/block/io.c
index XXXXXXX..XXXXXXX 100644
--- a/block/io.c
+++ b/block/io.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
     }
 
     /* Write back cached data to the OS even with cache=unsafe */
-    BLKDBG_EVENT(primary_child, BLKDBG_FLUSH_TO_OS);
+    BLKDBG_CO_EVENT(primary_child, BLKDBG_FLUSH_TO_OS);
     if (bs->drv->bdrv_co_flush_to_os) {
         ret = bs->drv->bdrv_co_flush_to_os(bs);
         if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ int coroutine_fn bdrv_co_flush(BlockDriverState *bs)
         goto flush_children;
     }
 
-    BLKDBG_EVENT(primary_child, BLKDBG_FLUSH_TO_DISK);
+    BLKDBG_CO_EVENT(primary_child, BLKDBG_FLUSH_TO_DISK);
     if (!bs->drv) {
         /* bs->drv->bdrv_co_flush() might have ejected the BDS
          * (even in case of apparent success) */
diff --git a/block/qcow.c b/block/qcow.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow.c
+++ b/block/qcow.c
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
         /* update the L1 entry */
         s->l1_table[l1_index] = l2_offset;
         tmp = cpu_to_be64(l2_offset);
-        BLKDBG_EVENT(bs->file, BLKDBG_L1_UPDATE);
+        BLKDBG_CO_EVENT(bs->file, BLKDBG_L1_UPDATE);
         ret = bdrv_co_pwrite_sync(bs->file,
                                   s->l1_table_offset + l1_index * sizeof(tmp),
                                   sizeof(tmp), &tmp, 0);
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
         }
     }
     l2_table = s->l2_cache + (min_index << s->l2_bits);
-    BLKDBG_EVENT(bs->file, BLKDBG_L2_LOAD);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_L2_LOAD);
     if (new_l2_table) {
         memset(l2_table, 0, s->l2_size * sizeof(uint64_t));
         ret = bdrv_co_pwrite_sync(bs->file, l2_offset,
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
         ((cluster_offset & QCOW_OFLAG_COMPRESSED) && allocate == 1)) {
         if (!allocate)
             return 0;
-        BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
+        BLKDBG_CO_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
         assert(QEMU_IS_ALIGNED(n_start | n_end, BDRV_SECTOR_SIZE));
         /* allocate a new cluster */
         if ((cluster_offset & QCOW_OFLAG_COMPRESSED) &&
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
             }
             cluster_offset = QEMU_ALIGN_UP(cluster_offset, s->cluster_size);
             /* write the cluster content */
-            BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
+            BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
             ret = bdrv_co_pwrite(bs->file, cluster_offset, s->cluster_size,
                                  s->cluster_cache, 0);
             if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
                                                       NULL) < 0) {
                                 return -EIO;
                             }
-                            BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
+                            BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
                             ret = bdrv_co_pwrite(bs->file, cluster_offset + i,
                                                  BDRV_SECTOR_SIZE,
                                                  s->cluster_data, 0);
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, uint64_t offset, int allocate,
         tmp = cpu_to_be64(cluster_offset);
         l2_table[l2_index] = tmp;
         if (allocate == 2) {
-            BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
+            BLKDBG_CO_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
         } else {
-            BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE);
+            BLKDBG_CO_EVENT(bs->file, BLKDBG_L2_UPDATE);
         }
         ret = bdrv_co_pwrite_sync(bs->file, l2_offset + l2_index * sizeof(tmp),
                                   sizeof(tmp), &tmp, 0);
@@ -XXX,XX +XXX,XX @@ decompress_cluster(BlockDriverState *bs, uint64_t cluster_offset)
     if (s->cluster_cache_offset != coffset) {
         csize = cluster_offset >> (63 - s->cluster_bits);
         csize &= (s->cluster_size - 1);
-        BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
+        BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
         ret = bdrv_co_pread(bs->file, coffset, csize, s->cluster_data, 0);
         if (ret < 0)
             return -1;
@@ -XXX,XX +XXX,XX @@ qcow_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                 /* read from the base image */
                 qemu_co_mutex_unlock(&s->lock);
                 /* qcow2 emits this on bs->file instead of bs->backing */
-                BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
+                BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
                 ret = bdrv_co_pread(bs->backing, offset, n, buf, 0);
                 qemu_co_mutex_lock(&s->lock);
                 if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ qcow_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                 break;
             }
             qemu_co_mutex_unlock(&s->lock);
-            BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
+            BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO);
             ret = bdrv_co_pread(bs->file, cluster_offset + offset_in_cluster,
                                 n, buf, 0);
             qemu_co_mutex_lock(&s->lock);
@@ -XXX,XX +XXX,XX @@ qcow_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
         }
 
         qemu_co_mutex_unlock(&s->lock);
-        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
+        BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
         ret = bdrv_co_pwrite(bs->file, cluster_offset + offset_in_cluster,
                              n, buf, 0);
         qemu_co_mutex_lock(&s->lock);
@@ -XXX,XX +XXX,XX @@ qcow_co_pwritev_compressed(BlockDriverState *bs, int64_t offset, int64_t bytes,
     }
     cluster_offset &= s->cluster_offset_mask;
 
-    BLKDBG_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_COMPRESSED);
     ret = bdrv_co_pwrite(bs->file, cluster_offset, out_len, out_buf, 0);
     if (ret < 0) {
         goto fail;
diff --git a/block/qcow2-cluster.c b/block/qcow2-cluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-cluster.c
+++ b/block/qcow2-cluster.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_shrink_l1_table(BlockDriverState *bs,
     fprintf(stderr, "shrink l1_table from %d to %d\n", s->l1_size, new_l1_size);
 #endif
 
-    BLKDBG_EVENT(bs->file, BLKDBG_L1_SHRINK_WRITE_TABLE);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_L1_SHRINK_WRITE_TABLE);
     ret = bdrv_co_pwrite_zeroes(bs->file,
                                 s->l1_table_offset + new_l1_size * L1E_SIZE,
                                 (s->l1_size - new_l1_size) * L1E_SIZE, 0);
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_shrink_l1_table(BlockDriverState *bs,
         goto fail;
     }
 
-    BLKDBG_EVENT(bs->file, BLKDBG_L1_SHRINK_FREE_L2_CLUSTERS);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_L1_SHRINK_FREE_L2_CLUSTERS);
     for (i = s->l1_size - 1; i > new_l1_size - 1; i--) {
         if ((s->l1_table[i] & L1E_OFFSET_MASK) == 0) {
             continue;
@@ -XXX,XX +XXX,XX @@ do_perform_cow_read(BlockDriverState *bs, uint64_t src_cluster_offset,
         return 0;
     }
 
-    BLKDBG_EVENT(bs->file, BLKDBG_COW_READ);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_COW_READ);
 
     if (!bs->drv) {
         return -ENOMEDIUM;
@@ -XXX,XX +XXX,XX @@ do_perform_cow_write(BlockDriverState *bs, uint64_t cluster_offset,
         return ret;
     }
 
-    BLKDBG_EVENT(bs->file, BLKDBG_COW_WRITE);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_COW_WRITE);
     ret = bdrv_co_pwritev(s->data_file, cluster_offset + offset_in_cluster,
                           qiov->size, qiov, 0);
     if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ qcow2_alloc_compressed_cluster_offset(BlockDriverState *bs, uint64_t offset,
 
     /* compressed clusters never have the copied flag */
 
-    BLKDBG_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_L2_UPDATE_COMPRESSED);
     qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_slice);
     set_l2_entry(s, l2_slice, l2_index, cluster_offset);
     if (has_subclusters(s)) {
@@ -XXX,XX +XXX,XX @@ perform_cow(BlockDriverState *bs, QCowL2Meta *m)
         /* NOTE: we have a write_aio blkdebug event here followed by
          * a cow_write one in do_perform_cow_write(), but there's only
          * one single I/O operation */
-        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
+        BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
         ret = do_perform_cow_write(bs, m->alloc_offset, start->offset, &qiov);
     } else {
         /* If there's no guest data then write both COW regions separately */
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qcow2_refcount_init(BlockDriverState *bs)
             ret = -ENOMEM;
             goto fail;
         }
-        BLKDBG_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);
+        BLKDBG_CO_EVENT(bs->file, BLKDBG_REFTABLE_LOAD);
         ret = bdrv_co_pread(bs->file, s->refcount_table_offset,
                             refcount_table_size2, s->refcount_table, 0);
         if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ int64_t coroutine_fn GRAPH_RDLOCK qcow2_alloc_bytes(BlockDriverState *bs, int si
     size_t free_in_cluster;
     int ret;
 
-    BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_BYTES);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_BYTES);
     assert(size > 0 && size <= s->cluster_size);
     assert(!s->free_byte_offset || offset_into_cluster(s, s->free_byte_offset));
 
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_encrypted(BlockDriverState *bs,
         return -ENOMEM;
     }
 
-    BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO);
     ret = bdrv_co_pread(s->data_file, host_offset, bytes, buf, 0);
     if (ret < 0) {
         goto fail;
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_task(BlockDriverState *bs, QCow2SubclusterType subc_type,
     case QCOW2_SUBCLUSTER_UNALLOCATED_ALLOC:
         assert(bs->backing); /* otherwise handled in qcow2_co_preadv_part */
 
-        BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
+        BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
         return bdrv_co_preadv_part(bs->backing, offset, bytes,
                                    qiov, qiov_offset, 0);
 
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_task(BlockDriverState *bs, QCow2SubclusterType subc_type,
                                              offset, bytes, qiov, qiov_offset);
         }
 
-        BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
+        BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO);
         return bdrv_co_preadv_part(s->data_file, host_offset,
                                    bytes, qiov, qiov_offset, 0);
 
@@ -XXX,XX +XXX,XX @@ handle_alloc_space(BlockDriverState *bs, QCowL2Meta *l2meta)
             return ret;
         }
 
-        BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_SPACE);
+        BLKDBG_CO_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC_SPACE);
         ret = bdrv_co_pwrite_zeroes(s->data_file, start_offset, nb_bytes,
                                     BDRV_REQ_NO_FALLBACK);
         if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ int qcow2_co_pwritev_task(BlockDriverState *bs, uint64_t host_offset,
      * guest data now.
      */
     if (!merge_cow(offset, bytes, qiov, qiov_offset, l2meta)) {
-        BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
+        BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
         trace_qcow2_writev_data(qemu_coroutine_self(), host_offset);
         ret = bdrv_co_pwritev_part(s->data_file, host_offset,
                                    bytes, qiov, qiov_offset, 0);
@@ -XXX,XX +XXX,XX @@ qcow2_co_pwritev_compressed_task(BlockDriverState *bs,
         goto fail;
     }
 
-    BLKDBG_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED);
+    BLKDBG_CO_EVENT(s->data_file, BLKDBG_WRITE_COMPRESSED);
     ret = bdrv_co_pwrite(s->data_file, cluster_offset, out_len, out_buf, 0);
     if (ret < 0) {
         goto fail;
@@ -XXX,XX +XXX,XX @@ qcow2_co_preadv_compressed(BlockDriverState *bs,
 
     out_buf = qemu_blockalign(bs, s->cluster_size);
 
-    BLKDBG_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_COMPRESSED);
     ret = bdrv_co_pread(bs->file, coffset, csize, buf, 0);
     if (ret < 0) {
         goto fail;
@@ -XXX,XX +XXX,XX @@ qcow2_co_save_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
         return offset;
     }
 
-    BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_VMSTATE_SAVE);
     return bs->drv->bdrv_co_pwritev_part(bs, offset, qiov->size, qiov, 0, 0);
 }
 
@@ -XXX,XX +XXX,XX @@ qcow2_co_load_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
         return offset;
     }
 
-    BLKDBG_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_VMSTATE_LOAD);
     return bs->drv->bdrv_co_preadv_part(bs, offset, qiov->size, qiov, 0, 0);
 }
 
diff --git a/block/qed-table.c b/block/qed-table.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed-table.c
+++ b/block/qed-table.c
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qed_read_l1_table_sync(BDRVQEDState *s)
 int coroutine_fn qed_write_l1_table(BDRVQEDState *s, unsigned int index,
                                     unsigned int n)
 {
-    BLKDBG_EVENT(s->bs->file, BLKDBG_L1_UPDATE);
+    BLKDBG_CO_EVENT(s->bs->file, BLKDBG_L1_UPDATE);
     return qed_write_table(s, s->header.l1_table_offset,
                            s->l1_table, index, n, false);
 }
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qed_read_l2_table(BDRVQEDState *s, QEDRequest *request,
     request->l2_table = qed_alloc_l2_cache_entry(&s->l2_cache);
     request->l2_table->table = qed_alloc_table(s);
 
-    BLKDBG_EVENT(s->bs->file, BLKDBG_L2_LOAD);
+    BLKDBG_CO_EVENT(s->bs->file, BLKDBG_L2_LOAD);
     ret = qed_read_table(s, offset, request->l2_table->table);
 
     if (ret) {
@@ -XXX,XX +XXX,XX @@ int coroutine_fn qed_write_l2_table(BDRVQEDState *s, QEDRequest *request,
                                     unsigned int index, unsigned int n,
                                     bool flush)
 {
-    BLKDBG_EVENT(s->bs->file, BLKDBG_L2_UPDATE);
+    BLKDBG_CO_EVENT(s->bs->file, BLKDBG_L2_UPDATE);
     return qed_write_table(s, request->l2_table->offset,
                            request->l2_table->table, index, n, flush);
 }
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn GRAPH_RDLOCK
 qed_read_backing_file(BDRVQEDState *s, uint64_t pos, QEMUIOVector *qiov)
 {
     if (s->bs->backing) {
-        BLKDBG_EVENT(s->bs->file, BLKDBG_READ_BACKING_AIO);
+        BLKDBG_CO_EVENT(s->bs->file, BLKDBG_READ_BACKING_AIO);
         return bdrv_co_preadv(s->bs->backing, pos, qiov->size, qiov, 0);
     }
     qemu_iovec_memset(qiov, 0, 0, qiov->size);
@@ -XXX,XX +XXX,XX @@ qed_copy_from_backing_file(BDRVQEDState *s, uint64_t pos, uint64_t len,
         goto out;
     }
 
-    BLKDBG_EVENT(s->bs->file, BLKDBG_COW_WRITE);
+    BLKDBG_CO_EVENT(s->bs->file, BLKDBG_COW_WRITE);
     ret = bdrv_co_pwritev(s->bs->file, offset, qiov.size, &qiov, 0);
     if (ret < 0) {
         goto out;
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn GRAPH_RDLOCK qed_aio_write_main(QEDAIOCB *acb)
 
     trace_qed_aio_write_main(s, acb, 0, offset, acb->cur_qiov.size);
 
-    BLKDBG_EVENT(s->bs->file, BLKDBG_WRITE_AIO);
+    BLKDBG_CO_EVENT(s->bs->file, BLKDBG_WRITE_AIO);
     return bdrv_co_pwritev(s->bs->file, offset, acb->cur_qiov.size,
                            &acb->cur_qiov, 0);
 }
@@ -XXX,XX +XXX,XX @@ qed_aio_read_data(void *opaque, int ret, uint64_t offset, size_t len)
     } else if (ret != QED_CLUSTER_FOUND) {
         r = qed_read_backing_file(s, acb->cur_pos, &acb->cur_qiov);
     } else {
-        BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
+        BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO);
         r = bdrv_co_preadv(bs->file, offset, acb->cur_qiov.size,
                            &acb->cur_qiov, 0);
     }
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ raw_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
         return ret;
     }
 
-    BLKDBG_EVENT(bs->file, BLKDBG_READ_AIO);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_AIO);
     return bdrv_co_preadv(bs->file, offset, bytes, qiov, flags);
 }
 
@@ -XXX,XX +XXX,XX @@ raw_co_pwritev(BlockDriverState *bs, int64_t offset, int64_t bytes,
         goto fail;
     }
 
-    BLKDBG_EVENT(bs->file, BLKDBG_WRITE_AIO);
+    BLKDBG_CO_EVENT(bs->file, BLKDBG_WRITE_AIO);
     ret = bdrv_co_pwritev(bs->file, offset, bytes, qiov, flags);
 
 fail:
diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent,
     if (skip_start_bytes > 0) {
         if (copy_from_backing) {
             /* qcow2 emits this on bs->file instead of bs->backing */
-            BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
+            BLKDBG_CO_EVENT(extent->file, BLKDBG_COW_READ);
             ret = bdrv_co_pread(bs->backing, offset, skip_start_bytes,
                                 whole_grain, 0);
             if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent,
                 goto exit;
             }
         }
-        BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
+        BLKDBG_CO_EVENT(extent->file, BLKDBG_COW_WRITE);
         ret = bdrv_co_pwrite(extent->file, cluster_offset, skip_start_bytes,
                              whole_grain, 0);
         if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent,
     if (skip_end_bytes < cluster_bytes) {
         if (copy_from_backing) {
             /* qcow2 emits this on bs->file instead of bs->backing */
-            BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
+            BLKDBG_CO_EVENT(extent->file, BLKDBG_COW_READ);
             ret = bdrv_co_pread(bs->backing, offset + skip_end_bytes,
                                 cluster_bytes - skip_end_bytes,
                                 whole_grain + skip_end_bytes, 0);
@@ -XXX,XX +XXX,XX @@ get_whole_cluster(BlockDriverState *bs, VmdkExtent *extent,
                 goto exit;
             }
         }
-        BLKDBG_EVENT(extent->file, BLKDBG_COW_WRITE);
+        BLKDBG_CO_EVENT(extent->file, BLKDBG_COW_WRITE);
         ret = bdrv_co_pwrite(extent->file, cluster_offset + skip_end_bytes,
                              cluster_bytes - skip_end_bytes,
                              whole_grain + skip_end_bytes, 0);
@@ -XXX,XX +XXX,XX @@ vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data, uint32_t offset)
 {
     offset = cpu_to_le32(offset);
     /* update L2 table */
-    BLKDBG_EVENT(extent->file, BLKDBG_L2_UPDATE);
+    BLKDBG_CO_EVENT(extent->file, BLKDBG_L2_UPDATE);
     if (bdrv_co_pwrite(extent->file,
                        ((int64_t)m_data->l2_offset * 512)
                            + (m_data->l2_index * sizeof(offset)),
@@ -XXX,XX +XXX,XX @@ get_cluster_offset(BlockDriverState *bs, VmdkExtent *extent,
         }
     }
     l2_table = (char *)extent->l2_cache + (min_index * l2_size_bytes);
-    BLKDBG_EVENT(extent->file, BLKDBG_L2_LOAD);
+    BLKDBG_CO_EVENT(extent->file, BLKDBG_L2_LOAD);
     if (bdrv_co_pread(extent->file,
                 (int64_t)l2_offset * 512,
                 l2_size_bytes,
@@ -XXX,XX +XXX,XX @@ vmdk_write_extent(VmdkExtent *extent, int64_t cluster_offset,
         n_bytes = buf_len + sizeof(VmdkGrainMarker);
         qemu_iovec_init_buf(&local_qiov, data, n_bytes);
 
-        BLKDBG_EVENT(extent->file, BLKDBG_WRITE_COMPRESSED);
+        BLKDBG_CO_EVENT(extent->file, BLKDBG_WRITE_COMPRESSED);
     } else {
         qemu_iovec_init(&local_qiov, qiov->niov);
         qemu_iovec_concat(&local_qiov, qiov, qiov_offset, n_bytes);
 
-        BLKDBG_EVENT(extent->file, BLKDBG_WRITE_AIO);
+        BLKDBG_CO_EVENT(extent->file, BLKDBG_WRITE_AIO);
     }
 
     write_offset = cluster_offset + offset_in_cluster;
@@ -XXX,XX +XXX,XX @@ vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
 
 
     if (!extent->compressed) {
-        BLKDBG_EVENT(extent->file, BLKDBG_READ_AIO);
+        BLKDBG_CO_EVENT(extent->file, BLKDBG_READ_AIO);
         ret = bdrv_co_preadv(extent->file,
                              cluster_offset + offset_in_cluster, bytes,
                              qiov, 0);
@@ -XXX,XX +XXX,XX @@ vmdk_read_extent(VmdkExtent *extent, int64_t cluster_offset,
     buf_bytes = cluster_bytes * 2;
     cluster_buf = g_malloc(buf_bytes);
     uncomp_buf = g_malloc(cluster_bytes);
-    BLKDBG_EVENT(extent->file, BLKDBG_READ_COMPRESSED);
+    BLKDBG_CO_EVENT(extent->file, BLKDBG_READ_COMPRESSED);
     ret = bdrv_co_pread(extent->file, cluster_offset, buf_bytes, cluster_buf,
                         0);
     if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ vmdk_co_preadv(BlockDriverState *bs, int64_t offset, int64_t bytes,
                 qemu_iovec_concat(&local_qiov, qiov, bytes_done, n_bytes);
 
                 /* qcow2 emits this on bs->file instead of bs->backing */
-                BLKDBG_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
+                BLKDBG_CO_EVENT(bs->file, BLKDBG_READ_BACKING_AIO);
                 ret = bdrv_co_preadv(bs->backing, offset, n_bytes,
                                      &local_qiov, 0);
                 if (ret < 0) {
@@ -XXX,XX +XXX,XX @@ vmdk_co_check(BlockDriverState *bs, BdrvCheckResult *result, BdrvCheckMode fix)
     BDRVVmdkState *s = bs->opaque;
     VmdkExtent *extent = NULL;
     int64_t sector_num = 0;
-    int64_t total_sectors = bdrv_nb_sectors(bs);
+    int64_t total_sectors = bdrv_co_nb_sectors(bs);
     int ret;
     uint64_t cluster_offset;
 
-- 
2.41.0