The following changes since commit 005ad32358f12fe9313a4a01918a55e60d4f39e5:

Merge tag 'pull-tpm-2023-09-12-3' of https://github.com/stefanberger/qemu-tpm into staging (2023-09-13 13:41:57 -0400)

for you to fetch changes up to 5d96864b73225ee61b0dad7e928f0cddf14270fc:

block-coroutine-wrapper: use qemu_get_current_aio_context() (2023-09-15 15:49:14 +0200)

- Graph locking part 4 (node management)

- qemu-img map: report compressed data blocks

- block-backend: process I/O in the current AioContext

Andrey Drobyshev via (2):

block: add BDRV_BLOCK_COMPRESSED flag for bdrv_block_status()

qemu-img: map: report compressed data blocks

Kevin Wolf (21):

block: Remove unused BlockReopenQueueEntry.perms_checked

preallocate: Factor out preallocate_truncate_to_real_size()

preallocate: Don't poll during permission updates

block: Take AioContext lock for bdrv_append() more consistently

block: Introduce bdrv_schedule_unref()

block-coroutine-wrapper: Add no_co_wrapper_bdrv_wrlock functions

block-coroutine-wrapper: Allow arbitrary parameter names

block: Mark bdrv_replace_child_noperm() GRAPH_WRLOCK

block: Mark bdrv_replace_child_tran() GRAPH_WRLOCK

block: Mark bdrv_attach_child_common() GRAPH_WRLOCK

block: Call transaction callbacks with lock held

block: Mark bdrv_attach_child() GRAPH_WRLOCK

block: Mark bdrv_parent_perms_conflict() and callers GRAPH_RDLOCK

block: Mark bdrv_get_cumulative_perm() and callers GRAPH_RDLOCK

block: Mark bdrv_child_perm() GRAPH_RDLOCK

block: Mark bdrv_parent_cb_change_media() GRAPH_RDLOCK

block: Take graph rdlock in bdrv_drop_intermediate()

block: Take graph rdlock in bdrv_change_aio_context()

block: Mark bdrv_root_unref_child() GRAPH_WRLOCK

block: Mark bdrv_unref_child() GRAPH_WRLOCK

block: Mark bdrv_add/del_child() and caller GRAPH_WRLOCK

Stefan Hajnoczi (5):

block: remove AIOCBInfo->get_aio_context()

test-bdrv-drain: avoid race with BH in IOThread drain test

block-backend: process I/O in the current AioContext

block-backend: process zoned requests in the current AioContext

block-coroutine-wrapper: use qemu_get_current_aio_context()

qapi/block-core.json | 6 +-

include/block/aio.h | 1 -

include/block/block-common.h | 7 +

include/block/block-global-state.h | 32 +-

include/block/block-io.h | 1 -

include/block/block_int-common.h | 34 +-

include/block/block_int-global-state.h | 14 +-

include/sysemu/block-backend-global-state.h | 4 +-

block.c | 348 +++++++---

block/blklogwrites.c | 4 +

block/blkverify.c | 2 +

block/block-backend.c | 64 +-

block/copy-before-write.c | 10 +-

block/crypto.c | 6 +-

block/graph-lock.c | 26 +-

block/io.c | 23 +-

block/mirror.c | 8 +

block/preallocate.c | 133 ++--

block/qcow.c | 5 +-

block/qcow2.c | 7 +-

block/quorum.c | 23 +-

block/replication.c | 9 +

block/snapshot.c | 2 +

block/stream.c | 20 +-

block/vmdk.c | 15 +

blockdev.c | 23 +-

blockjob.c | 2 +

hw/nvme/ctrl.c | 7 -

qemu-img.c | 8 +-

softmmu/dma-helpers.c | 8 -

tests/unit/test-bdrv-drain.c | 31 +-

tests/unit/test-bdrv-graph-mod.c | 20 +

tests/unit/test-block-iothread.c | 3 +

util/thread-pool.c | 8 -

scripts/block-coroutine-wrapper.py | 24 +-

tests/qemu-iotests/051.pc.out | 6 +-

tests/qemu-iotests/122.out | 84 +--

tests/qemu-iotests/146.out | 780 +++++++++++------------

tests/qemu-iotests/154.out | 194 +++---

tests/qemu-iotests/179.out | 178 +++---

tests/qemu-iotests/209.out | 4 +-

tests/qemu-iotests/221.out | 16 +-

tests/qemu-iotests/223.out | 60 +-

tests/qemu-iotests/241.out | 10 +-

tests/qemu-iotests/244.out | 24 +-

tests/qemu-iotests/252.out | 10 +-

tests/qemu-iotests/253.out | 20 +-

tests/qemu-iotests/274.out | 48 +-

tests/qemu-iotests/tests/nbd-qemu-allocation.out | 16 +-

tests/qemu-iotests/tests/qemu-img-bitmaps.out | 24 +-

50 files changed, 1376 insertions(+), 1036 deletions(-)

This field has been unused since commit 72373e40fbc ('block:

bdrv_reopen_multiple: refresh permissions on updated graph').

Remove it.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Reviewed-by: Eric Blake <eblake@redhat.com>

Reviewed-by: Emanuele Giuseppe Esposito <eesposit@redhat.com>

block.c | 1 -

1 file changed, 1 deletion(-)

diff --git a/block.c b/block.c

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ static int bdrv_fill_options(QDict **options, const char *filename,

typedef struct BlockReopenQueueEntry {

bool prepared;

- bool perms_checked;

BDRVReopenState state;

QTAILQ_ENTRY(BlockReopenQueueEntry) entry;

} BlockReopenQueueEntry;

2.41.0

It's essentially the same code in preallocate_check_perm() and

preallocate_close(), except that the latter ignores errors.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Reviewed-by: Eric Blake <eblake@redhat.com>

Reviewed-by: Emanuele Giuseppe Esposito <eesposit@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Message-ID: <20230911094620.45040-3-kwolf@redhat.com>

block/preallocate.c | 48 +++++++++++++++++++++------------------------

1 file changed, 22 insertions(+), 26 deletions(-)

diff --git a/block/preallocate.c b/block/preallocate.c

--- a/block/preallocate.c

+++ b/block/preallocate.c

@@ -XXX,XX +XXX,XX @@ static int preallocate_open(BlockDriverState *bs, QDict *options, int flags,

-static void preallocate_close(BlockDriverState *bs)

+static int preallocate_truncate_to_real_size(BlockDriverState *bs, Error **errp)

- int ret;

BDRVPreallocateState *s = bs->opaque;

-

- if (s->data_end < 0) {

- return;

- }

+ int ret;

if (s->file_end < 0) {

s->file_end = bdrv_getlength(bs->file->bs);

if (s->file_end < 0) {

- return;

+ error_setg_errno(errp, -s->file_end, "Failed to get file length");

+ return s->file_end;

}

}

if (s->data_end < s->file_end) {

ret = bdrv_truncate(bs->file, s->data_end, true, PREALLOC_MODE_OFF, 0,

NULL);

- s->file_end = ret < 0 ? ret : s->data_end;

+ if (ret < 0) {

+ error_setg_errno(errp, -ret, "Failed to drop preallocation");

+ s->file_end = ret;

+ return ret;

+ }

+ s->file_end = s->data_end;

+ }

+

+ return 0;

+}

+

+static void preallocate_close(BlockDriverState *bs)

+{

+ BDRVPreallocateState *s = bs->opaque;

+

+ if (s->data_end >= 0) {

+ preallocate_truncate_to_real_size(bs, NULL);

@@ -XXX,XX +XXX,XX @@ static int preallocate_check_perm(BlockDriverState *bs,

* We should truncate in check_perm, as in set_perm bs->file->perm will

* be already changed, and we should not violate it.

*/

- if (s->file_end < 0) {

- s->file_end = bdrv_getlength(bs->file->bs);

- if (s->file_end < 0) {

- error_setg(errp, "Failed to get file length");

- return s->file_end;

- }

- }

-

- if (s->data_end < s->file_end) {

- int ret = bdrv_truncate(bs->file, s->data_end, true,

- PREALLOC_MODE_OFF, 0, NULL);

- if (ret < 0) {

- error_setg(errp, "Failed to drop preallocation");

- s->file_end = ret;

- return ret;

- }

- s->file_end = s->data_end;

- }

+ return preallocate_truncate_to_real_size(bs, errp);

}

2.41.0

When the permission related BlockDriver callbacks are called, we are in

the middle of an operation traversing the block graph. Polling in such a

place is a very bad idea because the graph could change in unexpected

ways. In the future, callers will also hold the graph lock, which is

likely to turn polling into a deadlock.

So we need to get rid of calls to functions like bdrv_getlength() or

bdrv_truncate() there as these functions poll internally. They are

currently used so that when no parent has write/resize permissions on

the image any more, the preallocate filter drops the extra preallocated

area in the image file and gives up write/resize permissions itself.

In order to achieve this without polling in .bdrv_check_perm, don't

immediately truncate the image, but only schedule a BH to do so. The

filter keeps the write/resize permissions a bit longer now until the BH

has executed.

There is one case in which delaying doesn't work: Reopening the image

read-only. In this case, bs->file will likely be reopened read-only,

too, so keeping write permissions a bit longer on it doesn't work. But

we can already cover this case in preallocate_reopen_prepare() and not

rely on the permission updates for it.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Reviewed-by: Eric Blake <eblake@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Message-ID: <20230911094620.45040-4-kwolf@redhat.com>

block/preallocate.c | 89 +++++++++++++++++++++++++++++++++++----------

1 file changed, 69 insertions(+), 20 deletions(-)

diff --git a/block/preallocate.c b/block/preallocate.c

--- a/block/preallocate.c

+++ b/block/preallocate.c

@@ -XXX,XX +XXX,XX @@ typedef struct BDRVPreallocateState {

* be invalid (< 0) when we don't have both exclusive BLK_PERM_RESIZE and

* BLK_PERM_WRITE permissions on file child.

*/

+

+ /* Gives up the resize permission on children when parents don't need it */

+ QEMUBH *drop_resize_bh;

} BDRVPreallocateState;

+static int preallocate_drop_resize(BlockDriverState *bs, Error **errp);

+static void preallocate_drop_resize_bh(void *opaque);

+

#define PREALLOCATE_OPT_PREALLOC_ALIGN "prealloc-align"

#define PREALLOCATE_OPT_PREALLOC_SIZE "prealloc-size"

static QemuOptsList runtime_opts = {

@@ -XXX,XX +XXX,XX @@ static int preallocate_open(BlockDriverState *bs, QDict *options, int flags,

* For this to work, mark them invalid.

*/

s->file_end = s->zero_start = s->data_end = -EINVAL;

+ s->drop_resize_bh = qemu_bh_new(preallocate_drop_resize_bh, bs);

ret = bdrv_open_file_child(NULL, options, "file", bs, errp);

if (ret < 0) {

@@ -XXX,XX +XXX,XX @@ static void preallocate_close(BlockDriverState *bs)

{

BDRVPreallocateState *s = bs->opaque;

+ qemu_bh_cancel(s->drop_resize_bh);

+ qemu_bh_delete(s->drop_resize_bh);

+

if (s->data_end >= 0) {

preallocate_truncate_to_real_size(bs, NULL);

}

@@ -XXX,XX +XXX,XX @@ static int preallocate_reopen_prepare(BDRVReopenState *reopen_state,

BlockReopenQueue *queue, Error **errp)

{

PreallocateOpts *opts = g_new0(PreallocateOpts, 1);

+ int ret;

if (!preallocate_absorb_opts(opts, reopen_state->options,

reopen_state->bs->file->bs, errp)) {

@@ -XXX,XX +XXX,XX @@ static int preallocate_reopen_prepare(BDRVReopenState *reopen_state,

return -EINVAL;

}

+ /*

+ * Drop the preallocation already here if reopening read-only. The child

+ * might also be reopened read-only and then scheduling a BH during the

+ * permission update is too late.

+ */

+ if ((reopen_state->flags & BDRV_O_RDWR) == 0) {

+ ret = preallocate_drop_resize(reopen_state->bs, errp);

+ if (ret < 0) {

+ g_free(opts);

+ return ret;

+ }

+ }

+

reopen_state->opaque = opts;

return 0;

@@ -XXX,XX +XXX,XX @@ preallocate_co_getlength(BlockDriverState *bs)

return ret;

-static int preallocate_check_perm(BlockDriverState *bs,

- uint64_t perm, uint64_t shared, Error **errp)

+static int preallocate_drop_resize(BlockDriverState *bs, Error **errp)

{

BDRVPreallocateState *s = bs->opaque;

+ int ret;

- if (s->data_end >= 0 && !can_write_resize(perm)) {

- /*

- * Lose permissions.

- * We should truncate in check_perm, as in set_perm bs->file->perm will

- * be already changed, and we should not violate it.

- */

- return preallocate_truncate_to_real_size(bs, errp);

+ if (s->data_end < 0) {

+ return 0;

+ }

+

+ /*

+ * Before switching children to be read-only, truncate them to remove

+ * the preallocation and let them have the real size.

+ */

+ ret = preallocate_truncate_to_real_size(bs, errp);

+ if (ret < 0) {

+ return ret;

}

+ /*

+ * We'll drop our permissions and will allow other users to take write and

+ * resize permissions (see preallocate_child_perm). Anyone will be able to

+ * change the child, so mark all states invalid. We'll regain control if a

+ * parent requests write access again.

+ */

+ s->data_end = s->file_end = s->zero_start = -EINVAL;

+

+ bdrv_graph_rdlock_main_loop();

+ bdrv_child_refresh_perms(bs, bs->file, NULL);

+ bdrv_graph_rdunlock_main_loop();

+

return 0;

+static void preallocate_drop_resize_bh(void *opaque)

+{

+ /*

+ * In case of errors, we'll simply keep the exclusive lock on the image

+ * indefinitely.

+ */

+ preallocate_drop_resize(opaque, NULL);

+}

+

static void preallocate_set_perm(BlockDriverState *bs,

uint64_t perm, uint64_t shared)

{

BDRVPreallocateState *s = bs->opaque;

if (can_write_resize(perm)) {

+ qemu_bh_cancel(s->drop_resize_bh);

if (s->data_end < 0) {

s->data_end = s->file_end = s->zero_start =

- bdrv_getlength(bs->file->bs);

+ bs->file->bs->total_sectors * BDRV_SECTOR_SIZE;

}

} else {

- /*

- * We drop our permissions, as well as allow shared

- * permissions (see preallocate_child_perm), anyone will be able to

- * change the child, so mark all states invalid. We'll regain control if

- * get good permissions back.

- */

- s->data_end = s->file_end = s->zero_start = -EINVAL;

+ qemu_bh_schedule(s->drop_resize_bh);

@@ -XXX,XX +XXX,XX @@ static void preallocate_child_perm(BlockDriverState *bs, BdrvChild *c,

BdrvChildRole role, BlockReopenQueue *reopen_queue,

uint64_t perm, uint64_t shared, uint64_t *nperm, uint64_t *nshared)

{

+ BDRVPreallocateState *s = bs->opaque;

+

bdrv_default_perms(bs, c, role, reopen_queue, perm, shared, nperm, nshared);

- if (can_write_resize(perm)) {

- /* This should come by default, but let's enforce: */

+ /*

+ * We need exclusive write and resize permissions on the child not only when

+ * the parent can write to it, but also after the parent gave up write

+ * permissions until preallocate_drop_resize() has completed.

+ */

+ if (can_write_resize(perm) || s->data_end != -EINVAL) {

*nperm |= BLK_PERM_WRITE | BLK_PERM_RESIZE;

/*

@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_preallocate_filter = {

.bdrv_co_flush = preallocate_co_flush,

.bdrv_co_truncate = preallocate_co_truncate,

- .bdrv_check_perm = preallocate_check_perm,

.bdrv_set_perm = preallocate_set_perm,

.bdrv_child_perm = preallocate_child_perm,

2.41.0

bdrv_unref() is called by a lot of places that need to hold the graph

lock (it naturally happens in the context of operations that change the

graph). However, bdrv_unref() takes the graph writer lock internally, so

it can't actually be called while already holding a graph lock without

causing a deadlock.

bdrv_unref() also can't just become GRAPH_WRLOCK because it drains the

node before closing it, and draining requires that the graph is

unlocked.

The solution is to defer deleting the node until we don't hold the lock

any more and draining is possible again.

Note that keeping images open for longer than necessary can create

problems, too: You can't open an image again before it is really closed

(if image locking didn't prevent it, it would cause corruption).

Reopening an image immediately happens at least during bdrv_open() and

bdrv_co_create().

In order to solve this problem, make sure to run the deferred unref in

bdrv_graph_wrunlock(), i.e. the first possible place where we can drain

again. This is also why bdrv_schedule_unref() is marked GRAPH_WRLOCK.

The output of iotest 051 is updated because the additional polling

changes the order of HMP output, resulting in a new "(qemu)" prompt in

the test output that was previously on a separate line and filtered out.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Message-ID: <20230911094620.45040-6-kwolf@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

include/block/block-global-state.h | 1 +

block.c | 17 +++++++++++++++++

block/graph-lock.c | 26 +++++++++++++++++++-------

tests/qemu-iotests/051.pc.out | 6 +++---

4 files changed, 40 insertions(+), 10 deletions(-)

@@ -XXX,XX +XXX,XX @@ void bdrv_graph_wrlock(BlockDriverState *bs)

void bdrv_graph_wrunlock(void)

{

GLOBAL_STATE_CODE();

- QEMU_LOCK_GUARD(&aio_context_list_lock);

assert(qatomic_read(&has_writer));

+ WITH_QEMU_LOCK_GUARD(&aio_context_list_lock) {

+ /*

+ * No need for memory barriers, this works in pair with

+ * the slow path of rdlock() and both take the lock.

+ */

+ qatomic_store_release(&has_writer, 0);

+

+ /* Wake up all coroutines that are waiting to read the graph */

+ qemu_co_enter_all(&reader_queue, &aio_context_list_lock);

+ }

+

/*

- * No need for memory barriers, this works in pair with

- * the slow path of rdlock() and both take the lock.

+ * Run any BHs that were scheduled during the wrlock section and that

+ * callers might expect to have finished (in particular, this is important

+ * for bdrv_schedule_unref()).

+ *

+ * Do this only after restarting coroutines so that nested event loops in

+ * BHs don't deadlock if their condition relies on the coroutine making

+ * progress.

*/

- qatomic_store_release(&has_writer, 0);

-

- /* Wake up all coroutine that are waiting to read the graph */

- qemu_co_enter_all(&reader_queue, &aio_context_list_lock);

+ aio_bh_poll(qemu_get_aio_context());

}

void coroutine_fn bdrv_graph_co_rdlock(void)

diff --git a/tests/qemu-iotests/051.pc.out b/tests/qemu-iotests/051.pc.out

index XXXXXXX..XXXXXXX 100644

--- a/tests/qemu-iotests/051.pc.out

+++ b/tests/qemu-iotests/051.pc.out

@@ -XXX,XX +XXX,XX @@ QEMU_PROG: -device scsi-hd,drive=disk: Device needs media, but drive is empty

Testing: -drive file=TEST_DIR/t.qcow2,if=none,node-name=disk -object iothread,id=thread0 -device virtio-scsi,iothread=thread0,id=virtio-scsi0 -device scsi-hd,bus=virtio-scsi0.0,drive=disk,share-rw=on -device ide-hd,drive=disk,share-rw=on

QEMU X.Y.Z monitor - type 'help' for more information

-QEMU_PROG: -device ide-hd,drive=disk,share-rw=on: Cannot change iothread of active block backend

+(qemu) QEMU_PROG: -device ide-hd,drive=disk,share-rw=on: Cannot change iothread of active block backend

Testing: -drive file=TEST_DIR/t.qcow2,if=none,node-name=disk -object iothread,id=thread0 -device virtio-scsi,iothread=thread0,id=virtio-scsi0 -device scsi-hd,bus=virtio-scsi0.0,drive=disk,share-rw=on -device virtio-blk-pci,drive=disk,share-rw=on

QEMU X.Y.Z monitor - type 'help' for more information

-QEMU_PROG: -device virtio-blk-pci,drive=disk,share-rw=on: Cannot change iothread of active block backend

+(qemu) QEMU_PROG: -device virtio-blk-pci,drive=disk,share-rw=on: Cannot change iothread of active block backend

Testing: -drive file=TEST_DIR/t.qcow2,if=none,node-name=disk -object iothread,id=thread0 -device virtio-scsi,iothread=thread0,id=virtio-scsi0 -device scsi-hd,bus=virtio-scsi0.0,drive=disk,share-rw=on -device lsi53c895a,id=lsi0 -device scsi-hd,bus=lsi0.0,drive=disk,share-rw=on

QEMU X.Y.Z monitor - type 'help' for more information

@@ -XXX,XX +XXX,XX @@ QEMU X.Y.Z monitor - type 'help' for more information

Testing: -drive file=TEST_DIR/t.qcow2,if=none,node-name=disk -object iothread,id=thread0 -device virtio-scsi,iothread=thread0,id=virtio-scsi0 -device scsi-hd,bus=virtio-scsi0.0,drive=disk,share-rw=on -device virtio-blk-pci,drive=disk,iothread=thread0,share-rw=on

QEMU X.Y.Z monitor - type 'help' for more information

-QEMU_PROG: -device virtio-blk-pci,drive=disk,iothread=thread0,share-rw=on: Cannot change iothread of active block backend

+(qemu) QEMU_PROG: -device virtio-blk-pci,drive=disk,iothread=thread0,share-rw=on: Cannot change iothread of active block backend

Testing: -drive file=TEST_DIR/t.qcow2,if=none,node-name=disk -object iothread,id=thread0 -device virtio-scsi,iothread=thread0,id=virtio-scsi0 -device scsi-hd,bus=virtio-scsi0.0,drive=disk,share-rw=on -device virtio-scsi,id=virtio-scsi1,iothread=thread0 -device scsi-hd,bus=virtio-scsi1.0,drive=disk,share-rw=on

QEMU X.Y.Z monitor - type 'help' for more information

2.41.0

Don't assume specific parameter names like 'bs' or 'blk' in the

generated code, but use the actual name.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Reviewed-by: Emanuele Giuseppe Esposito <eesposit@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Message-ID: <20230911094620.45040-8-kwolf@redhat.com>

scripts/block-coroutine-wrapper.py | 7 ++++---

1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/scripts/block-coroutine-wrapper.py b/scripts/block-coroutine-wrapper.py

--- a/scripts/block-coroutine-wrapper.py

+++ b/scripts/block-coroutine-wrapper.py

@@ -XXX,XX +XXX,XX @@ def __init__(self, wrapper_type: str, return_type: str, name: str,

def gen_ctx(self, prefix: str = '') -> str:

t = self.args[0].type

+ name = self.args[0].name

if t == 'BlockDriverState *':

- return f'bdrv_get_aio_context({prefix}bs)'

+ return f'bdrv_get_aio_context({prefix}{name})'

elif t == 'BdrvChild *':

- return f'bdrv_get_aio_context({prefix}child->bs)'

+ return f'bdrv_get_aio_context({prefix}{name}->bs)'

elif t == 'BlockBackend *':

- return f'blk_get_aio_context({prefix}blk)'

+ return f'blk_get_aio_context({prefix}{name})'

else:

return 'qemu_get_aio_context()'

2.41.0

Instead of taking the writer lock internally, require callers to already

hold it when calling bdrv_replace_child_noperm(). These callers will

typically already hold the graph lock once the locking work is

completed, which means that they can't call functions that take it

internally.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Reviewed-by: Emanuele Giuseppe Esposito <eesposit@redhat.com>

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>

Message-ID: <20230911094620.45040-9-kwolf@redhat.com>

block.c | 26 +++++++++++++++++++-------

1 file changed, 19 insertions(+), 7 deletions(-)

diff --git a/block.c b/block.c

--- a/block.c

+++ b/block.c

@@ -XXX,XX +XXX,XX @@ static BlockDriverState *bdrv_open_inherit(const char *filename,

static bool bdrv_recurse_has_child(BlockDriverState *bs,

BlockDriverState *child);

-static void bdrv_replace_child_noperm(BdrvChild *child,

- BlockDriverState *new_bs);

+static void GRAPH_WRLOCK

+bdrv_replace_child_noperm(BdrvChild *child, BlockDriverState *new_bs);

+

static void bdrv_remove_child(BdrvChild *child, Transaction *tran);

static int bdrv_reopen_prepare(BDRVReopenState *reopen_state,

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_abort(void *opaque)

BlockDriverState *new_bs = s->child->bs;

GLOBAL_STATE_CODE();

+ bdrv_graph_wrlock(s->old_bs);

+

/* old_bs reference is transparently moved from @s to @s->child */

if (!s->child->bs) {

/*

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_abort(void *opaque)

assert(s->child->quiesced_parent);

bdrv_replace_child_noperm(s->child, s->old_bs);

+

+ bdrv_graph_wrunlock();

bdrv_unref(new_bs);

}

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_tran(BdrvChild *child, BlockDriverState *new_bs,

if (new_bs) {

bdrv_ref(new_bs);

}

+

+ bdrv_graph_wrlock(new_bs);

bdrv_replace_child_noperm(child, new_bs);

+ bdrv_graph_wrunlock();

/* old_bs reference is transparently moved from @child to @s */

}

@@ -XXX,XX +XXX,XX @@ uint64_t bdrv_qapi_perm_to_blk_perm(BlockPermission qapi_perm)

* If @new_bs is non-NULL, the parent of @child must already be drained through

* @child and the caller must hold the AioContext lock for @new_bs.

*/

-static void bdrv_replace_child_noperm(BdrvChild *child,

- BlockDriverState *new_bs)

+static void GRAPH_WRLOCK

+bdrv_replace_child_noperm(BdrvChild *child, BlockDriverState *new_bs)

{

BlockDriverState *old_bs = child->bs;

int new_bs_quiesce_counter;

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,

assert(bdrv_get_aio_context(old_bs) == bdrv_get_aio_context(new_bs));

}

- /* TODO Pull this up into the callers to avoid polling here */

- bdrv_graph_wrlock(new_bs);

if (old_bs) {

if (child->klass->detach) {

child->klass->detach(child);

@@ -XXX,XX +XXX,XX @@ static void bdrv_replace_child_noperm(BdrvChild *child,

child->klass->attach(child);

}

}

- bdrv_graph_wrunlock();

/*

* If the parent was drained through this BdrvChild previously, but new_bs

@@ -XXX,XX +XXX,XX @@ static void bdrv_attach_child_common_abort(void *opaque)

BlockDriverState *bs = s->child->bs;

GLOBAL_STATE_CODE();

+

+ bdrv_graph_wrlock(NULL);

bdrv_replace_child_noperm(s->child, NULL);

+ bdrv_graph_wrunlock();

if (bdrv_get_aio_context(bs) != s->old_child_ctx) {

bdrv_try_change_aio_context(bs, s->old_child_ctx, NULL, &error_abort);

@@ -XXX,XX +XXX,XX @@ static BdrvChild *bdrv_attach_child_common(BlockDriverState *child_bs,

* a problem, we already did this), but it will still poll until the parent

* is fully quiesced, so it will not be negatively affected either.

*/

+ bdrv_graph_wrlock(child_bs);

bdrv_parent_drained_begin_single(new_child);