block: AioContext management, part 2
cover block: AioContext management, part 2
Recently, a few bugs were reported that resulted from an inconsistent state regarding AioContexts. Block nodes can end up in different contexts than their users expect - the AioContext of a node can even change under the feet of a device with no way for the device to forbid this. We recently added a few basic checks to scsi-disk and virtio-blk, but they are by far not enough.
Part 1 solved the first half of the problem and made sure that AioContext changes are propagated through the graph as necessary, so that a bdrv_set_aio_context() correctly pulls everything that uses the node into the right context.
This is part 2 that fixes the second half: Attaching new child nodes where the parent and child are already in different AioContexts. This operation may only succeed if we can move one of the node into the context of the other node.
After applying this series, unchecked bdrv_set_aio_context() doesn't exist any more and all users call functions that make sure that the AioContext assignments across the graph stays consistent.
Kevin Wolf (15):
test-block-iothread: Check filter node in test_propagate_mirror
block: Add Error to blk_set_aio_context()
block: Add BlockBackend.ctx
block: Add qdev_prop_drive_iothread property type
scsi-disk: Use qdev_prop_drive_iothread
block: Adjust AioContexts when attaching nodes
test-block-iothread: Test adding parent to iothread node
test-block-iothread: BlockBackend AioContext across root node change
block: Move node without parents to main AioContext
blockdev: Use bdrv_try_set_aio_context() for monitor commands
block: Remove wrong bdrv_set_aio_context() calls
virtio-scsi-test: Test attaching new overlay with iothreads
iotests: Attach new devices to node in non-default iothread
test-bdrv-drain: Use bdrv_try_set_aio_context()
block: Remove bdrv_set_aio_context()
docs/devel/multiple-iothreads.txt | 4 +- include/block/block.h | 9 --- include/block/block_int.h | 1 + include/hw/block/block.h | 7 +- include/hw/qdev-properties.h | 3 + include/hw/scsi/scsi.h | 1 + include/sysemu/block-backend.h | 5 +- tests/libqtest.h | 11 ++++ block.c | 70 ++++++++++++++------ block/backup.c | 3 +- block/block-backend.c | 47 +++++++++----- block/commit.c | 13 ++-- block/crypto.c | 3 +- block/mirror.c | 4 +- block/parallels.c | 3 +- block/qcow.c | 3 +- block/qcow2.c | 6 +- block/qed.c | 3 +- block/sheepdog.c | 3 +- block/vdi.c | 3 +- block/vhdx.c | 3 +- block/vmdk.c | 3 +- block/vpc.c | 3 +- blockdev.c | 48 ++++++++------ blockjob.c | 12 +++- hmp.c | 3 +- hw/block/dataplane/virtio-blk.c | 12 +++- hw/block/dataplane/xen-block.c | 6 +- hw/block/fdc.c | 2 +- hw/block/xen-block.c | 2 +- hw/core/qdev-properties-system.c | 41 +++++++++++- hw/ide/qdev.c | 2 +- hw/scsi/scsi-disk.c | 24 ++++--- hw/scsi/virtio-scsi.c | 25 ++++--- migration/block.c | 3 +- nbd/server.c | 5 +- tests/libqtest.c | 19 ++++++ tests/test-bdrv-drain.c | 50 +++++++------- tests/test-bdrv-graph-mod.c | 5 +- tests/test-block-backend.c | 4 +- tests/test-block-iothread.c | 104 +++++++++++++++++++++++++----- tests/test-blockjob.c | 2 +- tests/test-throttle.c | 6 +- tests/virtio-scsi-test.c | 62 ++++++++++++++++++ tests/qemu-iotests/051 | 24 +++++++ tests/qemu-iotests/051.out | 3 + tests/qemu-iotests/051.pc.out | 27 ++++++++ tests/qemu-iotests/240.out | 2 +- 48 files changed, 531 insertions(+), 173 deletions(-)
Signature · 1 line
2.20.1
PATCH 1/15 test-block-iothread: Check filter node in test_propagate_mirror
Just make the test cover the AioContext of the filter node as well.
--- tests/test-block-iothread.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
tests/test-block-iothread.c +6 -1
@@ -593,7 +593,7 @@ static void test_propagate_mirror(void)IOThread *iothread =iothread_new ();AioContext *ctx =iothread_get_aio_context (iothread);AioContext *main_ctx =qemu_get_aio_context (); -BlockDriverState *src, *target; +BlockDriverState *src, *target, *filter;BlockBackend *blk;Job *job;Error *local_err =NULL ;
@@ -610,11 +610,13 @@ static void test_propagate_mirror(void) false,"filter_node" ,MIRROR_COPY_MODE_BACKGROUND , &error_abort); job =job_get ("job0" ); + filter =bdrv_find_node ("filter_node" );/* Change the AioContext of src */ bdrv_try_set_aio_context (src, ctx, &error_abort);g_assert (bdrv_get_aio_context (src) == ctx);g_assert (bdrv_get_aio_context (target) == ctx); +g_assert (bdrv_get_aio_context (filter) == ctx);g_assert (job->aio_context == ctx);/* Change the AioContext of target */
@@ -623,6 +625,7 @@ static void test_propagate_mirror(void)aio_context_release (ctx);g_assert (bdrv_get_aio_context (src) == main_ctx);g_assert (bdrv_get_aio_context (target) == main_ctx); +g_assert (bdrv_get_aio_context (filter) == main_ctx);/* With a BlockBackend on src, changing target must fail */ blk =blk_new (0 ,BLK_PERM_ALL );
@@ -635,6 +638,7 @@ static void test_propagate_mirror(void)g_assert (blk_get_aio_context (blk) == main_ctx);g_assert (bdrv_get_aio_context (src) == main_ctx);g_assert (bdrv_get_aio_context (target) == main_ctx); +g_assert (bdrv_get_aio_context (filter) == main_ctx);/* ...unless we explicitly allow it */ aio_context_acquire (ctx);
@@ -645,6 +649,7 @@ static void test_propagate_mirror(void)g_assert (blk_get_aio_context (blk) == ctx);g_assert (bdrv_get_aio_context (src) == ctx);g_assert (bdrv_get_aio_context (target) == ctx); +g_assert (bdrv_get_aio_context (filter) == ctx);job_cancel_sync_all ();
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH 01/15] test-block-iothread: Check filter node in test_propagate_mirror
Quoted 7 lines · Kevin Wolf
Just make the test cover the AioContext of the filter node as well.
Signed-off-by Kevin Wolf <[email protected]>--- tests/test-block-iothread.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
PATCH 2/15 block: Add Error to blk_set_aio_context()
In reply to Kevin WolfAdd an Error parameter to blk_set_aio_context() and use bdrv_child_try_set_aio_context() internally to check whether all involved nodes can actually support the AioContext switch.
--- include/sysemu/block-backend.h | 3 ++- block/block-backend.c | 26 ++++++++++++++++---------- hw/block/dataplane/virtio-blk.c | 12 +++++++++--- hw/block/dataplane/xen-block.c | 6 ++++-- hw/scsi/virtio-scsi.c | 10 +++++++--- tests/test-bdrv-drain.c | 8 ++++---- tests/test-block-iothread.c | 22 +++++++++++----------- 7 files changed, 53 insertions(+), 34 deletions(-)
include/sysemu/block-backend.h +2 -1
@@ -208,7 +208,8 @@ void blk_op_unblock(BlockBackend *blk, BlockOpType op, Error *reason);void blk_op_block_all (BlockBackend *blk,Error *reason);void blk_op_unblock_all (BlockBackend *blk,Error *reason);AioContext *blk_get_aio_context (BlockBackend *blk); -void blk_set_aio_context (BlockBackend *blk,AioContext *new_context); +int blk_set_aio_context (BlockBackend *blk,AioContext *new_context, +Error **errp);void blk_add_aio_context_notifier (BlockBackend *blk,void (*attached_aio_context)(AioContext *new_context,void *opaque),void (*detach_aio_context)(void *opaque),void *opaque);
block/block-backend.c +16 -10
@@ -1866,30 +1866,36 @@ static AioContext *blk_aiocb_get_aio_context(BlockAIOCB *acb)return blk_get_aio_context (blk_acb->blk); } -static void blk_do_set_aio_context (BlockBackend *blk,AioContext *new_context, -bool update_root_node) +static int blk_do_set_aio_context (BlockBackend *blk,AioContext *new_context, +bool update_root_node,Error **errp) {BlockDriverState *bs =blk_bs (blk);ThrottleGroupMember *tgm = &blk->public.throttle_group_member; +int ret;if (bs) { +if (update_root_node) { + ret =bdrv_child_try_set_aio_context (bs, new_context, blk->root, + errp); +if (ret <0 ) { +return ret; + } + }if (tgm->throttle_state) {bdrv_drained_begin (bs);throttle_group_detach_aio_context (tgm);throttle_group_attach_aio_context (tgm, new_context);bdrv_drained_end (bs); } -if (update_root_node) { -GSList *ignore =g_slist_prepend (NULL , blk->root); -bdrv_set_aio_context_ignore (bs, new_context, &ignore); -g_slist_free (ignore); - } } + +return 0 ; } -void blk_set_aio_context (BlockBackend *blk,AioContext *new_context) +int blk_set_aio_context (BlockBackend *blk,AioContext *new_context, +Error **errp) { -blk_do_set_aio_context (blk, new_context, true); +return blk_do_set_aio_context (blk, new_context, true, errp); } static bool blk_root_can_set_aio_ctx(BdrvChild *child, AioContext *ctx,
@@ -1916,7 +1922,7 @@ static void blk_root_set_aio_ctx(BdrvChild *child, AioContext *ctx, GSList **ignore) {BlockBackend *blk = child->opaque; -blk_do_set_aio_context (blk, ctx, false); +blk_do_set_aio_context (blk, ctx, false, &error_abort); } void blk_add_aio_context_notifier(BlockBackend *blk,
hw/block/dataplane/virtio-blk.c +9 -3
@@ -173,6 +173,7 @@ int virtio_blk_data_plane_start(VirtIODevice *vdev)VirtioBusClass *k =VIRTIO_BUS_GET_CLASS (qbus);unsigned i;unsigned nvqs = s->conf->num_queues; +Error *local_err =NULL ;int r;if (vblk->dataplane_started || s->starting) {
@@ -212,7 +213,11 @@ int virtio_blk_data_plane_start(VirtIODevice *vdev) vblk->dataplane_started = true;trace_virtio_blk_data_plane_start (s); -blk_set_aio_context (s->conf->conf.blk, s->ctx); + r =blk_set_aio_context (s->conf->conf.blk, s->ctx, &local_err); +if (r <0 ) { +error_report_err (local_err); + goto fail_guest_notifiers; + }/* Kick right away to begin processing requests already in vring */ for (i =0 ; i < nvqs; i++) {
@@ -281,8 +286,9 @@ void virtio_blk_data_plane_stop(VirtIODevice *vdev)aio_context_acquire (s->ctx);aio_wait_bh_oneshot (s->ctx, virtio_blk_data_plane_stop_bh, s); -/* Drain and switch bs back to the QEMU main loop */ -blk_set_aio_context (s->conf->conf.blk,qemu_get_aio_context ()); +/* Drain and try to switch bs back to the QEMU main loop. If other users +* keep the BlockBackend in the iothread, that's ok */ +blk_set_aio_context (s->conf->conf.blk,qemu_get_aio_context (),NULL );aio_context_release (s->ctx);
hw/block/dataplane/xen-block.c +4 -2
@@ -682,7 +682,8 @@ void xen_block_dataplane_stop(XenBlockDataPlane *dataplane) }aio_context_acquire (dataplane->ctx); -blk_set_aio_context (dataplane->blk,qemu_get_aio_context ()); +/* Xen doesn't have multiple users for nodes, so this can't fail */ +blk_set_aio_context (dataplane->blk,qemu_get_aio_context (), &error_abort);aio_context_release (dataplane->ctx); xendev = dataplane->xendev;
@@ -811,7 +812,8 @@ void xen_block_dataplane_start(XenBlockDataPlane *dataplane, }aio_context_acquire (dataplane->ctx); -blk_set_aio_context (dataplane->blk, dataplane->ctx); +/* If other users keep the BlockBackend in the iothread, that's ok */ +blk_set_aio_context (dataplane->blk, dataplane->ctx,NULL );aio_context_release (dataplane->ctx);return ;
hw/scsi/virtio-scsi.c +7 -3
@@ -795,6 +795,7 @@ static void virtio_scsi_hotplug(HotplugHandler *hotplug_dev, DeviceState *dev,VirtIODevice *vdev =VIRTIO_DEVICE (hotplug_dev);VirtIOSCSI *s =VIRTIO_SCSI (vdev);SCSIDevice *sd =SCSI_DEVICE (dev); +int ret;if (s->ctx && !s->dataplane_fenced) {AioContext *ctx;
@@ -808,9 +809,11 @@ static void virtio_scsi_hotplug(HotplugHandler *hotplug_dev, DeviceState *dev,return ; }virtio_scsi_acquire (s); -blk_set_aio_context (sd->conf.blk, s->ctx); + ret =blk_set_aio_context (sd->conf.blk, s->ctx, errp);virtio_scsi_release (s); - +if (ret <0 ) { +return ; + } }if (virtio_vdev_has_feature (vdev,VIRTIO_SCSI_F_HOTPLUG )) {
@@ -839,7 +842,8 @@ static void virtio_scsi_hotunplug(HotplugHandler *hotplug_dev, DeviceState *dev,if (s->ctx) {virtio_scsi_acquire (s); -blk_set_aio_context (sd->conf.blk,qemu_get_aio_context ()); +/* If other users keep the BlockBackend in the iothread, that's ok */ +blk_set_aio_context (sd->conf.blk,qemu_get_aio_context (),NULL );virtio_scsi_release (s); }
tests/test-bdrv-drain.c +4 -4
@@ -678,7 +678,7 @@ static void test_iothread_common(enum drain_type drain_type, int drain_thread) s = bs->opaque;blk_insert_bs (blk, bs, &error_abort); -blk_set_aio_context (blk, ctx_a); +blk_set_aio_context (blk, ctx_a, &error_abort);aio_context_acquire (ctx_a); s->bh_indirection_ctx = ctx_b;
@@ -742,7 +742,7 @@ static void test_iothread_common(enum drain_type drain_type, int drain_thread) }aio_context_acquire (ctx_a); -blk_set_aio_context (blk,qemu_get_aio_context ()); +blk_set_aio_context (blk,qemu_get_aio_context (), &error_abort);aio_context_release (ctx_a);bdrv_unref (bs);
@@ -903,7 +903,7 @@ static void test_blockjob_common_drain_node(enum drain_type drain_type,if (use_iothread) { iothread =iothread_new (); ctx =iothread_get_aio_context (iothread); -blk_set_aio_context (blk_src, ctx); +blk_set_aio_context (blk_src, ctx, &error_abort); }else { ctx =qemu_get_aio_context (); }
@@ -1001,7 +1001,7 @@ static void test_blockjob_common_drain_node(enum drain_type drain_type, g_assert_cmpint(ret, ==, (result == TEST_JOB_SUCCESS ? 0 : -EIO));if (use_iothread) { -blk_set_aio_context (blk_src,qemu_get_aio_context ()); +blk_set_aio_context (blk_src,qemu_get_aio_context (), &error_abort); }aio_context_release (ctx);
tests/test-block-iothread.c +11 -11
@@ -342,14 +342,14 @@ static void test_sync_op(const void *opaque)blk_insert_bs (blk, bs, &error_abort); c =QLIST_FIRST (&bs->parents); -blk_set_aio_context (blk, ctx); +blk_set_aio_context (blk, ctx, &error_abort);aio_context_acquire (ctx); t->fn (c);if (t->blkfn) { t->blkfn (blk); }aio_context_release (ctx); -blk_set_aio_context (blk,qemu_get_aio_context ()); +blk_set_aio_context (blk,qemu_get_aio_context (), &error_abort);bdrv_unref (bs);blk_unref (blk);
@@ -428,7 +428,7 @@ static void test_attach_blockjob(void)aio_poll (qemu_get_aio_context (), false); } -blk_set_aio_context (blk, ctx); +blk_set_aio_context (blk, ctx, &error_abort); tjob->n =0 ;while (tjob->n ==0 ) {
@@ -436,7 +436,7 @@ static void test_attach_blockjob(void) }aio_context_acquire (ctx); -blk_set_aio_context (blk,qemu_get_aio_context ()); +blk_set_aio_context (blk,qemu_get_aio_context (), &error_abort);aio_context_release (ctx); tjob->n =0 ;
@@ -444,7 +444,7 @@ static void test_attach_blockjob(void)aio_poll (qemu_get_aio_context (), false); } -blk_set_aio_context (blk, ctx); +blk_set_aio_context (blk, ctx, &error_abort); tjob->n =0 ;while (tjob->n ==0 ) {
@@ -453,7 +453,7 @@ static void test_attach_blockjob(void)aio_context_acquire (ctx);job_complete_sync (&tjob->common.job, &error_abort); -blk_set_aio_context (blk,qemu_get_aio_context ()); +blk_set_aio_context (blk,qemu_get_aio_context (), &error_abort);aio_context_release (ctx);bdrv_unref (bs);
@@ -497,7 +497,7 @@ static void test_propagate_basic(void) bs_verify =bdrv_open (NULL ,NULL , options,BDRV_O_RDWR , &error_abort);/* Switch the AioContext */ -blk_set_aio_context (blk, ctx); +blk_set_aio_context (blk, ctx, &error_abort);g_assert (blk_get_aio_context (blk) == ctx);g_assert (bdrv_get_aio_context (bs_a) == ctx);g_assert (bdrv_get_aio_context (bs_verify) == ctx);
@@ -505,7 +505,7 @@ static void test_propagate_basic(void)/* Switch the AioContext back */ ctx =qemu_get_aio_context (); -blk_set_aio_context (blk, ctx); +blk_set_aio_context (blk, ctx, &error_abort);g_assert (blk_get_aio_context (blk) == ctx);g_assert (bdrv_get_aio_context (bs_a) == ctx);g_assert (bdrv_get_aio_context (bs_verify) == ctx);
@@ -565,7 +565,7 @@ static void test_propagate_diamond(void)blk_insert_bs (blk, bs_verify, &error_abort);/* Switch the AioContext */ -blk_set_aio_context (blk, ctx); +blk_set_aio_context (blk, ctx, &error_abort);g_assert (blk_get_aio_context (blk) == ctx);g_assert (bdrv_get_aio_context (bs_verify) == ctx);g_assert (bdrv_get_aio_context (bs_a) == ctx);
@@ -574,7 +574,7 @@ static void test_propagate_diamond(void)/* Switch the AioContext back */ ctx =qemu_get_aio_context (); -blk_set_aio_context (blk, ctx); +blk_set_aio_context (blk, ctx, &error_abort);g_assert (blk_get_aio_context (blk) == ctx);g_assert (bdrv_get_aio_context (bs_verify) == ctx);g_assert (bdrv_get_aio_context (bs_a) == ctx);
@@ -654,7 +654,7 @@ static void test_propagate_mirror(void)job_cancel_sync_all ();aio_context_acquire (ctx); -blk_set_aio_context (blk, main_ctx); +blk_set_aio_context (blk, main_ctx, &error_abort);bdrv_try_set_aio_context (target, main_ctx, &error_abort);aio_context_release (ctx);
Signature · 1 line
2.20.1
PATCH 3/15 block: Add BlockBackend.ctx
In reply to Kevin WolfThis adds a new parameter to blk_new() which requires its callers to declare from which AioContext this BlockBackend is going to be used (or the locks of which AioContext need to be taken anyway).
The given context is only stored and kept up to date when changing AioContexts. Actually applying the stored AioContext to the root node is saved for another commit.
--- include/sysemu/block-backend.h | 2 +- block.c | 2 +- block/backup.c | 3 ++- block/block-backend.c | 18 +++++++++++++++--- block/commit.c | 11 +++++++---- block/crypto.c | 3 ++- block/mirror.c | 3 ++- block/parallels.c | 3 ++- block/qcow.c | 3 ++- block/qcow2.c | 6 ++++-- block/qed.c | 3 ++- block/sheepdog.c | 3 ++- block/vdi.c | 3 ++- block/vhdx.c | 3 ++- block/vmdk.c | 3 ++- block/vpc.c | 3 ++- blockdev.c | 4 ++-- blockjob.c | 2 +- hmp.c | 3 ++- hw/block/fdc.c | 2 +- hw/block/xen-block.c | 2 +- hw/core/qdev-properties-system.c | 4 +++- hw/ide/qdev.c | 2 +- hw/scsi/scsi-disk.c | 2 +- migration/block.c | 3 ++- nbd/server.c | 5 +++-- tests/test-bdrv-drain.c | 30 +++++++++++++++--------------- tests/test-bdrv-graph-mod.c | 5 +++-- tests/test-block-backend.c | 4 ++-- tests/test-block-iothread.c | 10 +++++----- tests/test-blockjob.c | 2 +- tests/test-throttle.c | 6 +++--- 32 files changed, 96 insertions(+), 62 deletions(-)
include/sysemu/block-backend.h +1 -1
@@ -76,7 +76,7 @@ typedef struct BlockBackendPublic {ThrottleGroupMember throttle_group_member; } BlockBackendPublic; -BlockBackend *blk_new (uint64_t perm,uint64_t shared_perm); +BlockBackend *blk_new (AioContext *ctx,uint64_t perm,uint64_t shared_perm);BlockBackend *blk_new_open (const char *filename,const char *reference,QDict *options,int flags,Error **errp);int blk_get_refcnt (BlockBackend *blk);
block.c +1 -1
@@ -2878,7 +2878,7 @@ static BlockDriverState *bdrv_open_inherit(const char *filename,/* 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 (0 ,BLK_PERM_ALL ); + file =blk_new (bdrv_get_aio_context (file_bs),0 ,BLK_PERM_ALL );blk_insert_bs (file, file_bs, &local_err);bdrv_unref (file_bs);if (local_err) {
block/backup.c +2 -1
@@ -640,7 +640,8 @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs, }/* The target must match the source in size, so no resize here either */ - job->target =blk_new (BLK_PERM_WRITE , + job->target =blk_new (job->common.job.aio_context, +BLK_PERM_WRITE ,BLK_PERM_CONSISTENT_READ |BLK_PERM_WRITE |BLK_PERM_WRITE_UNCHANGED |BLK_PERM_GRAPH_MOD ); ret =blk_insert_bs (job->target, target, errp);
block/block-backend.c +15 -3
@@ -42,6 +42,7 @@ struct BlockBackend {char *name;int refcnt;BdrvChild *root; +AioContext *ctx;DriveInfo *legacy_dinfo;/* null unless created by drive_new() */ QTAILQ_ENTRY (BlockBackend) link;/* for block_backends */ QTAILQ_ENTRY (BlockBackend) monitor_link;/* for monitor_block_backends */
@@ -322,12 +323,13 @@ static const BdrvChildRole child_root = {* * Return the new BlockBackend on success, null on failure. */ -BlockBackend *blk_new (uint64_t perm,uint64_t shared_perm) +BlockBackend *blk_new (AioContext *ctx,uint64_t perm,uint64_t shared_perm) {BlockBackend *blk; blk =g_new0 (BlockBackend,1 ); blk->refcnt =1 ; + blk->ctx = ctx; blk->perm = perm; blk->shared_perm = shared_perm;blk_set_enable_write_cache (blk, true);
@@ -347,6 +349,7 @@ BlockBackend *blk_new(uint64_t perm, uint64_t shared_perm)/* * Creates a new BlockBackend, opens a new BlockDriverState, and connects both. +* The new BlockBackend is in the main AioContext. * * Just as with bdrv_open(), after having called this function the reference to * @options belongs to the block layer (even on failure).
@@ -382,7 +385,7 @@ BlockBackend *blk_new_open(const char *filename, const char *reference, perm |=BLK_PERM_RESIZE ; } - blk =blk_new (perm,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (), perm,BLK_PERM_ALL ); bs =bdrv_open (filename, reference, options, flags, errp);if (!bs) {blk_unref (blk);
@@ -1857,7 +1860,15 @@ void blk_op_unblock_all(BlockBackend *blk, Error *reason)AioContext *blk_get_aio_context (BlockBackend *blk) { -return bdrv_get_aio_context (blk_bs (blk)); +BlockDriverState *bs =blk_bs (blk); + +/* FIXME The AioContext of bs and blk can be inconsistent. For the moment, +* we prefer the one of bs for compatibility. */ +if (bs) { +return bdrv_get_aio_context (blk_bs (blk)); + } + +return blk->ctx; }static AioContext *blk_aiocb_get_aio_context (BlockAIOCB *acb)
@@ -1889,6 +1900,7 @@ static int blk_do_set_aio_context(BlockBackend *blk, AioContext *new_context, } } + blk->ctx = new_context;return 0 ; }
block/commit.c +7 -4
@@ -338,7 +338,8 @@ void commit_start(const char *job_id, BlockDriverState *bs, goto fail; } - s->base =blk_new (BLK_PERM_CONSISTENT_READ + s->base =blk_new (s->common.job.aio_context, +BLK_PERM_CONSISTENT_READ |BLK_PERM_WRITE |BLK_PERM_RESIZE , BLK_PERM_CONSISTENT_READ
@@ -351,7 +352,7 @@ void commit_start(const char *job_id, BlockDriverState *bs, s->base_bs = base;/* Required permissions are already taken with block_job_add_bdrv() */ - s->top =blk_new (0 ,BLK_PERM_ALL ); + s->top =blk_new (s->common.job.aio_context,0 ,BLK_PERM_ALL ); ret =blk_insert_bs (s->top, top, errp);if (ret <0 ) { goto fail;
@@ -395,6 +396,7 @@ int bdrv_commit(BlockDriverState *bs)BlockDriverState *backing_file_bs =NULL ;BlockDriverState *commit_top_bs =NULL ;BlockDriver *drv = bs->drv; +AioContext *ctx;int64_t offset, length, backing_length;int ro;int64_t n;
@@ -422,8 +424,9 @@ int bdrv_commit(BlockDriverState *bs) } } - src =blk_new (BLK_PERM_CONSISTENT_READ ,BLK_PERM_ALL ); - backing =blk_new (BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); + ctx =bdrv_get_aio_context (bs); + src =blk_new (ctx,BLK_PERM_CONSISTENT_READ ,BLK_PERM_ALL ); + backing =blk_new (ctx,BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (src, bs, &local_err);if (ret <0 ) {
block/crypto.c +2 -1
@@ -257,7 +257,8 @@ static int block_crypto_co_create_generic(BlockDriverState *bs,QCryptoBlock *crypto =NULL ;struct BlockCryptoCreateData data; - blk =blk_new (BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); + blk =blk_new (bdrv_get_aio_context (bs), +BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (blk, bs, errp);if (ret <0 ) {
block/mirror.c +2 -1
@@ -1584,7 +1584,8 @@ static void mirror_start_job(const char *job_id, BlockDriverState *bs,* We can allow anything except resize there.*/ target_is_backing =bdrv_chain_contains (bs, target); target_graph_mod = (backing_mode !=MIRROR_LEAVE_BACKING_CHAIN ); - s->target = blk_new(BLK_PERM_WRITE | BLK_PERM_RESIZE | + s->target = blk_new(s->common.job.aio_context, + BLK_PERM_WRITE | BLK_PERM_RESIZE | (target_graph_mod ? BLK_PERM_GRAPH_MOD : 0), BLK_PERM_WRITE_UNCHANGED | (target_is_backing ? BLK_PERM_CONSISTENT_READ |
block/parallels.c +2 -1
@@ -554,7 +554,8 @@ static int coroutine_fn parallels_co_create(BlockdevCreateOptions* opts,return -EIO ; } - blk =blk_new (BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); + blk =blk_new (bdrv_get_aio_context (bs), +BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (blk, bs, errp);if (ret <0 ) { goto out;
block/qcow.c +2 -1
@@ -844,7 +844,8 @@ static int coroutine_fn qcow_co_create(BlockdevCreateOptions *opts,return -EIO ; } - qcow_blk =blk_new (BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); + qcow_blk =blk_new (bdrv_get_aio_context (bs), +BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (qcow_blk, bs, errp);if (ret <0 ) { goto exit;
block/qcow2.c +4 -2
@@ -3103,7 +3103,8 @@ qcow2_co_create(BlockdevCreateOptions *create_options, Error **errp) }/* Create BlockBackend to write to the image */ - blk =blk_new (BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); + blk =blk_new (bdrv_get_aio_context (bs), +BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (blk, bs, errp);if (ret <0 ) { goto out;
@@ -5100,7 +5101,8 @@ static int qcow2_amend_options(BlockDriverState *bs, QemuOpts *opts, }if (new_size) { -BlockBackend *blk =blk_new (BLK_PERM_RESIZE ,BLK_PERM_ALL ); +BlockBackend *blk =blk_new (bdrv_get_aio_context (bs), +BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (blk, bs, errp);if (ret <0 ) {blk_unref (blk);
block/qed.c +2 -1
@@ -649,7 +649,8 @@ static int coroutine_fn bdrv_qed_co_create(BlockdevCreateOptions *opts,return -EIO ; } - blk =blk_new (BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); + blk =blk_new (bdrv_get_aio_context (bs), +BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (blk, bs, errp);if (ret <0 ) { goto out;
block/sheepdog.c +2 -1
@@ -1800,7 +1800,8 @@ static int sd_prealloc(BlockDriverState *bs, int64_t old_size, int64_t new_size,void *buf =NULL ;int ret; - blk =blk_new (BLK_PERM_CONSISTENT_READ |BLK_PERM_WRITE |BLK_PERM_RESIZE , + blk =blk_new (bdrv_get_aio_context (bs), +BLK_PERM_CONSISTENT_READ |BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (blk, bs, errp);
block/vdi.c +2 -1
@@ -803,7 +803,8 @@ static int coroutine_fn vdi_co_do_create(BlockdevCreateOptions *create_options, goto exit; } - blk =blk_new (BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); + blk =blk_new (bdrv_get_aio_context (bs_file), +BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (blk, bs_file, errp);if (ret <0 ) { goto exit;
block/vhdx.c +2 -1
@@ -1900,7 +1900,8 @@ static int coroutine_fn vhdx_co_create(BlockdevCreateOptions *opts,return -EIO ; } - blk =blk_new (BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); + blk =blk_new (bdrv_get_aio_context (bs), +BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (blk, bs, errp);if (ret <0 ) { goto delete_and_exit;
block/vmdk.c +2 -1
@@ -2356,7 +2356,8 @@ static BlockBackend *vmdk_co_create_cb(int64_t size, int idx,if (!bs) {return NULL ; } - blk =blk_new (BLK_PERM_CONSISTENT_READ |BLK_PERM_WRITE |BLK_PERM_RESIZE , + blk =blk_new (bdrv_get_aio_context (bs), +BLK_PERM_CONSISTENT_READ |BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL );if (blk_insert_bs (blk, bs, errp)) {bdrv_unref (bs);
block/vpc.c +2 -1
@@ -1011,7 +1011,8 @@ static int coroutine_fn vpc_co_create(BlockdevCreateOptions *opts,return -EIO ; } - blk =blk_new (BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); + blk =blk_new (bdrv_get_aio_context (bs), +BLK_PERM_WRITE |BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (blk, bs, errp);if (ret <0 ) { goto out;
blockdev.c +2 -2
@@ -574,7 +574,7 @@ static BlockBackend *blockdev_init(const char *file, QDict *bs_opts,if ((!file || !*file) && !qdict_size (bs_opts)) {BlockBackendRootState *blk_rs; - blk =blk_new (0 ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL ); blk_rs =blk_get_root_state (blk); blk_rs->open_flags = bdrv_flags; blk_rs->read_only = read_only;
@@ -3138,7 +3138,7 @@ void qmp_block_resize(bool has_device, const char *device, goto out; } - blk =blk_new (BLK_PERM_RESIZE ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),BLK_PERM_RESIZE ,BLK_PERM_ALL ); ret =blk_insert_bs (blk, bs, errp);if (ret <0 ) { goto out;
blockjob.c +1 -1
@@ -392,7 +392,7 @@ void *block_job_create(const char *job_id, const BlockJobDriver *driver, job_id =bdrv_get_device_name (bs); } - blk =blk_new (perm, shared_perm); + blk =blk_new (bdrv_get_aio_context (bs), perm, shared_perm); ret =blk_insert_bs (blk, bs, errp);if (ret <0 ) {blk_unref (blk);
hmp.c +2 -1
@@ -2560,7 +2560,8 @@ void hmp_qemu_io(Monitor *mon, const QDict *qdict)if (!blk) {BlockDriverState *bs =bdrv_lookup_bs (NULL , device, &err);if (bs) { - blk = local_blk =blk_new (0 ,BLK_PERM_ALL ); + blk = local_blk =blk_new (bdrv_get_aio_context (bs), +0 ,BLK_PERM_ALL ); ret =blk_insert_bs (blk, bs, &err);if (ret <0 ) { goto fail;
hw/block/fdc.c +1 -1
@@ -538,7 +538,7 @@ static void floppy_drive_realize(DeviceState *qdev, Error **errp)if (!dev->conf.blk) {/* Anonymous BlockBackend for an empty drive */ - dev->conf.blk =blk_new (0 ,BLK_PERM_ALL ); + dev->conf.blk =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL ); ret =blk_attach_dev (dev->conf.blk, qdev);assert (ret ==0 ); }
hw/block/xen-block.c +1 -1
@@ -609,7 +609,7 @@ static void xen_cdrom_realize(XenBlockDevice *blockdev, Error **errp)int rc;/* Set up an empty drive */ - conf->blk =blk_new (0 ,BLK_PERM_ALL ); + conf->blk =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL ); rc =blk_attach_dev (conf->blk,DEVICE (blockdev));if (!rc) {
hw/core/qdev-properties-system.c +3 -1
@@ -80,7 +80,9 @@ static void parse_drive(DeviceState *dev, const char *str, void **ptr,if (!blk) {BlockDriverState *bs =bdrv_lookup_bs (NULL , str,NULL );if (bs) { - blk =blk_new (0 ,BLK_PERM_ALL ); +/* BlockBackends of devices start in the main context and are only +* later moved into another context if the device supports that. */ + blk =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL ); blk_created = true; ret =blk_insert_bs (blk, bs, errp);
hw/ide/qdev.c +1 -1
@@ -168,7 +168,7 @@ static void ide_dev_initfn(IDEDevice *dev, IDEDriveKind kind, Error **errp)return ; }else {/* Anonymous BlockBackend for an empty drive */ - dev->conf.blk =blk_new (0 ,BLK_PERM_ALL ); + dev->conf.blk =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL ); ret =blk_attach_dev (dev->conf.blk, &dev->qdev);assert (ret ==0 ); }
hw/scsi/scsi-disk.c +1 -1
@@ -2417,7 +2417,7 @@ static void scsi_cd_realize(SCSIDevice *dev, Error **errp)if (!dev->conf.blk) {/* Anonymous BlockBackend for an empty drive. As we put it into * dev->conf, qdev takes care of detaching on unplug. */ - dev->conf.blk =blk_new (0 ,BLK_PERM_ALL ); + dev->conf.blk =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL ); ret =blk_attach_dev (dev->conf.blk, &dev->qdev);assert (ret ==0 ); }
migration/block.c +2 -1
@@ -417,7 +417,8 @@ static int init_blk_migration(QEMUFile *f) } bmds =g_new0 (BlkMigDevState,1 ); - bmds->blk =blk_new (BLK_PERM_CONSISTENT_READ ,BLK_PERM_ALL ); + bmds->blk =blk_new (qemu_get_aio_context (), +BLK_PERM_CONSISTENT_READ ,BLK_PERM_ALL ); bmds->blk_name =g_strdup (bdrv_get_device_name (bs)); bmds->bulk_completed =0 ; bmds->total_sectors = sectors;
nbd/server.c +3 -2
@@ -1484,8 +1484,9 @@ NBDExport *nbd_export_new(BlockDriverState *bs, uint64_t dev_offset,if ((nbdflags &NBD_FLAG_READ_ONLY ) ==0 ) { perm |=BLK_PERM_WRITE ; } - blk =blk_new (perm,BLK_PERM_CONSISTENT_READ |BLK_PERM_WRITE_UNCHANGED | -BLK_PERM_WRITE |BLK_PERM_GRAPH_MOD ); + blk =blk_new (bdrv_get_aio_context (bs), perm, +BLK_PERM_CONSISTENT_READ |BLK_PERM_WRITE_UNCHANGED | +BLK_PERM_WRITE |BLK_PERM_GRAPH_MOD ); ret =blk_insert_bs (blk, bs, errp);if (ret <0 ) { goto fail;
tests/test-bdrv-drain.c +15 -15
@@ -206,7 +206,7 @@ static void test_drv_cb_common(enum drain_type drain_type, bool recursive)QEMUIOVector qiov =QEMU_IOVEC_INIT_BUF (qiov,NULL ,0 ); - blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); bs =bdrv_new_open_driver (&bdrv_test,"test-node" ,BDRV_O_RDWR , &error_abort); s = bs->opaque;
@@ -290,7 +290,7 @@ static void test_quiesce_common(enum drain_type drain_type, bool recursive)BlockBackend *blk;BlockDriverState *bs, *backing; - blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); bs =bdrv_new_open_driver (&bdrv_test,"test-node" ,BDRV_O_RDWR , &error_abort);blk_insert_bs (blk, bs, &error_abort);
@@ -353,7 +353,7 @@ static void test_nested(void)BDRVTestState *s, *backing_s;enum drain_type outer, inner; - blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); bs =bdrv_new_open_driver (&bdrv_test,"test-node" ,BDRV_O_RDWR , &error_abort); s = bs->opaque;
@@ -402,13 +402,13 @@ static void test_multiparent(void)BlockDriverState *bs_a, *bs_b, *backing;BDRVTestState *a_s, *b_s, *backing_s; - blk_a =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk_a =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); bs_a =bdrv_new_open_driver (&bdrv_test,"test-node-a" ,BDRV_O_RDWR , &error_abort); a_s = bs_a->opaque;blk_insert_bs (blk_a, bs_a, &error_abort); - blk_b =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk_b =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); bs_b =bdrv_new_open_driver (&bdrv_test,"test-node-b" ,BDRV_O_RDWR , &error_abort); b_s = bs_b->opaque;
@@ -475,13 +475,13 @@ static void test_graph_change_drain_subtree(void)BlockDriverState *bs_a, *bs_b, *backing;BDRVTestState *a_s, *b_s, *backing_s; - blk_a =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk_a =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); bs_a =bdrv_new_open_driver (&bdrv_test,"test-node-a" ,BDRV_O_RDWR , &error_abort); a_s = bs_a->opaque;blk_insert_bs (blk_a, bs_a, &error_abort); - blk_b =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk_b =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); bs_b =bdrv_new_open_driver (&bdrv_test,"test-node-b" ,BDRV_O_RDWR , &error_abort); b_s = bs_b->opaque;
@@ -555,7 +555,7 @@ static void test_graph_change_drain_all(void)BDRVTestState *a_s, *b_s;/* Create node A with a BlockBackend */ - blk_a =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk_a =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); bs_a =bdrv_new_open_driver (&bdrv_test,"test-node-a" ,BDRV_O_RDWR , &error_abort); a_s = bs_a->opaque;
@@ -571,7 +571,7 @@ static void test_graph_change_drain_all(void) g_assert_cmpint(a_s->drain_count, ==, 1);/* Create node B with a BlockBackend */ - blk_b =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk_b =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); bs_b =bdrv_new_open_driver (&bdrv_test,"test-node-b" ,BDRV_O_RDWR , &error_abort); b_s = bs_b->opaque;
@@ -672,7 +672,7 @@ static void test_iothread_common(enum drain_type drain_type, int drain_thread) goto out; } - blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); bs =bdrv_new_open_driver (&bdrv_test,"test-node" ,BDRV_O_RDWR , &error_abort); s = bs->opaque;
@@ -883,7 +883,7 @@ static void test_blockjob_common_drain_node(enum drain_type drain_type,bdrv_set_backing_hd (src, src_backing, &error_abort);bdrv_unref (src_backing); - blk_src =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk_src =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL );blk_insert_bs (blk_src, src_overlay, &error_abort);switch (drain_node) {
@@ -910,7 +910,7 @@ static void test_blockjob_common_drain_node(enum drain_type drain_type, target =bdrv_new_open_driver (&bdrv_test,"target" ,BDRV_O_RDWR , &error_abort); - blk_target =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk_target =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL );blk_insert_bs (blk_target, target, &error_abort);aio_context_acquire (ctx);
@@ -1205,7 +1205,7 @@ static void do_test_delete_by_drain(bool detach_instead_of_delete, &error_abort);bdrv_attach_child (bs, null_bs,"null-child" , &child_file, &error_abort); - blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL );blk_insert_bs (blk, bs, &error_abort);/* Referenced by blk now */
@@ -1368,7 +1368,7 @@ static void test_detach_indirect(bool by_parent_cb) c =bdrv_new_open_driver (&bdrv_test,"c" ,BDRV_O_RDWR , &error_abort);/* blk is a BB for parent-a */ - blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL );blk_insert_bs (blk, parent_a, &error_abort);bdrv_unref (parent_a);
@@ -1466,7 +1466,7 @@ static void test_append_to_drained(void)BlockDriverState *base, *overlay;BDRVTestState *base_s, *overlay_s; - blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); base =bdrv_new_open_driver (&bdrv_test,"base" ,BDRV_O_RDWR , &error_abort); base_s = base->opaque;blk_insert_bs (blk, base, &error_abort);
tests/test-bdrv-graph-mod.c +3 -2
@@ -102,7 +102,8 @@ static void test_update_perm_tree(void) {Error *local_err =NULL ; -BlockBackend *root =blk_new (BLK_PERM_WRITE |BLK_PERM_CONSISTENT_READ , +BlockBackend *root =blk_new (qemu_get_aio_context (), +BLK_PERM_WRITE |BLK_PERM_CONSISTENT_READ ,BLK_PERM_ALL & ~BLK_PERM_WRITE );BlockDriverState *bs =no_perm_node ("node" );BlockDriverState *filter =pass_through_node ("filter" );
@@ -166,7 +167,7 @@ static void test_update_perm_tree(void)*/ static void test_should_update_child (void ) { -BlockBackend *root =blk_new (0 ,BLK_PERM_ALL ); +BlockBackend *root =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL );BlockDriverState *bs =no_perm_node ("node" );BlockDriverState *filter =no_perm_node ("filter" );BlockDriverState *target =no_perm_node ("target" );
tests/test-block-backend.c +2 -2
@@ -37,7 +37,7 @@ static void test_drain_aio_error_flush_cb(void *opaque, int ret)static void test_drain_aio_error (void ) { -BlockBackend *blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); +BlockBackend *blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL );BlockAIOCB *acb;bool completed = false;
@@ -53,7 +53,7 @@ static void test_drain_aio_error(void)static void test_drain_all_aio_error (void ) { -BlockBackend *blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); +BlockBackend *blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL );BlockAIOCB *acb;bool completed = false;
tests/test-block-iothread.c +5 -5
@@ -336,7 +336,7 @@ static void test_sync_op(const void *opaque)BlockDriverState *bs;BdrvChild *c; - blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),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 ;blk_insert_bs (blk, bs, &error_abort);
@@ -415,7 +415,7 @@ static void test_attach_blockjob(void)BlockDriverState *bs;TestBlockJob *tjob; - blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),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);
@@ -481,7 +481,7 @@ static void test_propagate_basic(void)QDict *options;/* Create bs_a and its BlockBackend */ - blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL ); bs_a =bdrv_new_open_driver (&bdrv_test,"bs_a" ,BDRV_O_RDWR , &error_abort);blk_insert_bs (blk, bs_a, &error_abort);
@@ -561,7 +561,7 @@ static void test_propagate_diamond(void)qdict_put_str (options,"raw" ,"bs_c" ); bs_verify =bdrv_open (NULL ,NULL , options,BDRV_O_RDWR , &error_abort); - blk =blk_new (BLK_PERM_ALL ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL );blk_insert_bs (blk, bs_verify, &error_abort);/* Switch the AioContext */
@@ -628,7 +628,7 @@ static void test_propagate_mirror(void)g_assert (bdrv_get_aio_context (filter) == main_ctx);/* With a BlockBackend on src, changing target must fail */ - blk =blk_new (0 ,BLK_PERM_ALL ); + blk =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL );blk_insert_bs (blk, src, &error_abort);bdrv_try_set_aio_context (target, ctx, &local_err);
tests/test-blockjob.c +1 -1
@@ -68,7 +68,7 @@ static BlockJob *do_test_id(BlockBackend *blk, const char *id,static BlockBackend *create_blk (const char *name) {/* No I/O is performed on this device */ -BlockBackend *blk =blk_new (0 ,BLK_PERM_ALL ); +BlockBackend *blk =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL );BlockDriverState *bs; bs =bdrv_open ("null-co://" ,NULL ,NULL ,0 , &error_abort);
tests/test-throttle.c +3 -3
@@ -675,9 +675,9 @@ static void test_groups(void)ThrottleGroupMember *tgm1, *tgm2, *tgm3;/* No actual I/O is performed on these devices */ - blk1 =blk_new (0 ,BLK_PERM_ALL ); - blk2 =blk_new (0 ,BLK_PERM_ALL ); - blk3 =blk_new (0 ,BLK_PERM_ALL ); + blk1 =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL ); + blk2 =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL ); + blk3 =blk_new (qemu_get_aio_context (),0 ,BLK_PERM_ALL ); blkp1 =blk_get_public (blk1); blkp2 =blk_get_public (blk2);
Signature · 1 line
2.20.1
PATCH 4/15 block: Add qdev_prop_drive_iothread property type
In reply to Kevin WolfSome qdev block devices have support for iothreads and take care of the AioContext they are running in, but most devices don't know about any of this. For the latter category, the qdev drive property must make sure that their BlockBackend is in the main AioContext.
Unfortunately, while the current code just does the same thing for devices that do support iothreads, this is not correct and it would show as soon as we actually try to keep a consistent AioContext assignment across all nodes and users of a block graph subtree: If a node is already in a non-default AioContext because of one of its users, attaching a new device should still be possible if that device can work in the same AioContext. Switching the node back to the main context first and only then into the device AioContext causes failure (because the existing user wouldn't allow the switch to the main context).
So devices that support iothreads need a different kind of drive property that leaves the node in its current AioContext, but by using this type, the device promises to check later that it can work with this context.
This patch adds the qdev infrastructure that allows devices to signal that they handle iothreads and qdev should leave the AioContext alone.
--- include/hw/block/block.h | 7 ++++-- include/hw/qdev-properties.h | 3 +++ hw/core/qdev-properties-system.c | 43 ++++++++++++++++++++++++++++---- 3 files changed, 46 insertions(+), 7 deletions(-)
include/hw/block/block.h +5 -2
@@ -45,8 +45,7 @@ static inline unsigned int get_physical_block_exp(BlockConf *conf)return exp; } -#define DEFINE_BLOCK_PROPERTIES (_state, _conf) \ - DEFINE_PROP_DRIVE("drive", _state, _conf.blk), \ +#define DEFINE_BLOCK_PROPERTIES_BASE (_state, _conf) \ DEFINE_PROP_BLOCKSIZE("logical_block_size", _state, \ _conf.logical_block_size), \ DEFINE_PROP_BLOCKSIZE("physical_block_size", _state, \
@@ -59,6 +58,10 @@ static inline unsigned int get_physical_block_exp(BlockConf *conf) ON_OFF_AUTO_AUTO), \ DEFINE_PROP_BOOL("share-rw", _state, _conf.share_rw, false) +#define DEFINE_BLOCK_PROPERTIES (_state, _conf) \ + DEFINE_PROP_DRIVE("drive", _state, _conf.blk), \ + DEFINE_BLOCK_PROPERTIES_BASE(_state, _conf) +#define DEFINE_BLOCK_CHS_PROPERTIES (_state, _conf) \ DEFINE_PROP_UINT32("cyls", _state, _conf.cyls, 0), \ DEFINE_PROP_UINT32("heads", _state, _conf.heads, 0), \
include/hw/qdev-properties.h +3 -0
@@ -28,6 +28,7 @@ extern const PropertyInfo qdev_prop_blockdev_on_error;extern const PropertyInfo qdev_prop_bios_chs_trans;extern const PropertyInfo qdev_prop_fdc_drive_type;extern const PropertyInfo qdev_prop_drive; +extern const PropertyInfo qdev_prop_drive_iothread;extern const PropertyInfo qdev_prop_netdev;extern const PropertyInfo qdev_prop_pci_devfn;extern const PropertyInfo qdev_prop_blocksize;
@@ -198,6 +199,8 @@ extern const PropertyInfo qdev_prop_pcie_link_width; DEFINE_PROP(_n, _s, _f, qdev_prop_netdev, NICPeers)#define DEFINE_PROP_DRIVE (_n, _s, _f) \ DEFINE_PROP(_n, _s, _f, qdev_prop_drive, BlockBackend *) +#define DEFINE_PROP_DRIVE_IOTHREAD (_n, _s, _f) \ + DEFINE_PROP(_n, _s, _f, qdev_prop_drive_iothread, BlockBackend *)#define DEFINE_PROP_MACADDR (_n, _s, _f) \ DEFINE_PROP(_n, _s, _f, qdev_prop_macaddr, MACAddr)#define DEFINE_PROP_ON_OFF_AUTO (_n, _s, _f, _d) \
hw/core/qdev-properties-system.c +38 -5
73 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH 5/15 scsi-disk: Use qdev_prop_drive_iothread
In reply to Kevin WolfThis makes use of qdev_prop_drive_iothread for scsi-disk so that the disk can be attached to a node that is already in the target AioContext. We need to check that the HBA actually supports iothreads, otherwise scsi-disk must make sure that the node is already in the main AioContext.
This changes the error message for conflicting iothread settings. Previously, virtio-scsi produced the error message, now it comes from blk_set_aio_context(). Update a test case accordingly.
--- include/hw/scsi/scsi.h | 1 + hw/scsi/scsi-disk.c | 22 +++++++++++++++------- hw/scsi/virtio-scsi.c | 15 ++++++++------- tests/qemu-iotests/240.out | 2 +- 4 files changed, 25 insertions(+), 15 deletions(-)
include/hw/scsi/scsi.h +1 -0
@@ -88,6 +88,7 @@ struct SCSIDeviceint scsi_version;int default_scsi_version;bool needs_vpd_bl_emulation; +bool hba_supports_iothread; };extern const VMStateDescription vmstate_scsi_device;
hw/scsi/scsi-disk.c +15 -7
@@ -2336,6 +2336,13 @@ static void scsi_realize(SCSIDevice *dev, Error **errp)return ; } +if (blk_get_aio_context (s->qdev.conf.blk) !=qemu_get_aio_context () && + !s->qdev.hba_supports_iothread) + { +error_setg (errp,"HBA does not support iothreads" ); +return ; + } +if (dev->type ==TYPE_DISK ) {if (!blkconf_geometry (&dev->conf,NULL ,65535 ,255 ,255 , errp)) {return ;
@@ -2929,13 +2936,14 @@ static const TypeInfo scsi_disk_base_info = { .abstract = true, }; -#define DEFINE_SCSI_DISK_PROPERTIES () \ - DEFINE_BLOCK_PROPERTIES(SCSIDiskState, qdev.conf), \ - DEFINE_BLOCK_ERROR_PROPERTIES(SCSIDiskState, qdev.conf), \ - DEFINE_PROP_STRING("ver", SCSIDiskState, version), \ - DEFINE_PROP_STRING("serial", SCSIDiskState, serial), \ - DEFINE_PROP_STRING("vendor", SCSIDiskState, vendor), \ - DEFINE_PROP_STRING("product", SCSIDiskState, product), \ +#define DEFINE_SCSI_DISK_PROPERTIES () \ + DEFINE_PROP_DRIVE_IOTHREAD("drive", SCSIDiskState, qdev.conf.blk), \ + DEFINE_BLOCK_PROPERTIES_BASE(SCSIDiskState, qdev.conf), \ + DEFINE_BLOCK_ERROR_PROPERTIES(SCSIDiskState, qdev.conf), \ + DEFINE_PROP_STRING("ver", SCSIDiskState, version), \ + DEFINE_PROP_STRING("serial", SCSIDiskState, serial), \ + DEFINE_PROP_STRING("vendor", SCSIDiskState, vendor), \ + DEFINE_PROP_STRING("product", SCSIDiskState, product), \ DEFINE_PROP_STRING("device_id", SCSIDiskState, device_id)
hw/scsi/virtio-scsi.c +8 -7
@@ -789,6 +789,13 @@ static void virtio_scsi_change(SCSIBus *bus, SCSIDevice *dev, SCSISense sense) } } +static void virtio_scsi_pre_hotplug (HotplugHandler *hotplug_dev, +DeviceState *dev,Error **errp) +{ +SCSIDevice *sd =SCSI_DEVICE (dev); + sd->hba_supports_iothread = true; +} +static void virtio_scsi_hotplug (HotplugHandler *hotplug_dev,DeviceState *dev,Error **errp) {
@@ -798,16 +805,9 @@ static void virtio_scsi_hotplug(HotplugHandler *hotplug_dev, DeviceState *dev,int ret;if (s->ctx && !s->dataplane_fenced) { -AioContext *ctx;if (blk_op_is_blocked (sd->conf.blk,BLOCK_OP_TYPE_DATAPLANE , errp)) {return ; } - ctx =blk_get_aio_context (sd->conf.blk); -if (ctx != s->ctx && ctx !=qemu_get_aio_context ()) { -error_setg (errp,"Cannot attach a blockdev that is using " -"a different iothread" ); -return ; - }virtio_scsi_acquire (s); ret =blk_set_aio_context (sd->conf.blk, s->ctx, errp);virtio_scsi_release (s);
@@ -990,6 +990,7 @@ static void virtio_scsi_class_init(ObjectClass *klass, void *data) vdc->reset = virtio_scsi_reset; vdc->start_ioeventfd = virtio_scsi_dataplane_start; vdc->stop_ioeventfd = virtio_scsi_dataplane_stop; + hc->pre_plug = virtio_scsi_pre_hotplug; hc->plug = virtio_scsi_hotplug; hc->unplug = virtio_scsi_hotunplug; }
tests/qemu-iotests/240.out +1 -1
@@ -43,7 +43,7 @@ QMP_VERSION {"return": {}} {"return": {}} {"return": {}} -{"error": {"class": "GenericError", "desc": "Cannot attach a blockdev that is using a different iothread"}} +{"error": {"class": "GenericError", "desc": "Cannot change iothread of active block backend"}} {"return": {}} {"return": {}} {"return": {}}
Signature · 1 line
2.20.1
PATCH 6/15 block: Adjust AioContexts when attaching nodes
In reply to Kevin WolfSo far, we only made sure that updating the AioContext of a node affected the whole subtree. However, if a node is newly attached to a new parent, we also need to make sure that both the subtree of the node and the parent are in the same AioContext. This tries to move the new child node to the parent AioContext and returns an error if this isn't possible.
BlockBackends now actually apply their AioContext to their root node.
--- include/block/block_int.h | 1 + block.c | 33 ++++++++++++++++++++++++++++++++- block/block-backend.c | 9 ++++----- blockjob.c | 10 ++++++++-- tests/test-bdrv-drain.c | 6 ++++-- 5 files changed, 49 insertions(+), 10 deletions(-)
include/block/block_int.h +1 -0
@@ -1163,6 +1163,7 @@ void hmp_drive_add_node(Monitor *mon, const char *optstr);BdrvChild *bdrv_root_attach_child (BlockDriverState *child_bs,const char *child_name,const BdrvChildRole *child_role, +AioContext *ctx,uint64_t perm,uint64_t shared_perm,void *opaque,Error **errp);void bdrv_root_unref_child (BdrvChild *child);
block.c +32 -1
@@ -2243,13 +2243,17 @@ static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs) } } +/* The caller must hold the AioContext lock @child_bs, but not that of @ctx +* (unless @child_bs is already in @ctx). */ BdrvChild *bdrv_root_attach_child (BlockDriverState *child_bs,const char *child_name,const BdrvChildRole *child_role, +AioContext *ctx,uint64_t perm,uint64_t shared_perm,void *opaque,Error **errp) {BdrvChild *child; +Error *local_err =NULL ;int ret; ret =bdrv_check_update_perm (child_bs,NULL , perm, shared_perm,NULL , errp);
@@ -2268,12 +2272,39 @@ BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs, .opaque = opaque, }; +/* If the AioContexts don't match, first try to move the subtree of +* child_bs into the AioContext of the new parent. If this doesn't work, +* try moving the parent into the AioContext of child_bs instead. */ +if (bdrv_get_aio_context (child_bs) != ctx) { + ret =bdrv_try_set_aio_context (child_bs, ctx, &local_err); +if (ret <0 && child_role->can_set_aio_ctx) { +GSList *ignore =g_slist_prepend (NULL , child);; + ctx =bdrv_get_aio_context (child_bs); +if (child_role->can_set_aio_ctx (child, ctx, &ignore,NULL )) { +error_free (local_err); + ret =0 ; +g_slist_free (ignore); + ignore =g_slist_prepend (NULL , child);; + child_role->set_aio_ctx (child, ctx, &ignore); + } +g_slist_free (ignore); + } +if (ret <0 ) { +error_propagate (errp, local_err); +g_free (child); +bdrv_abort_perm_update (child_bs); +return NULL ; + } + } +/* This performs the matching bdrv_set_perm() for the above check. */ bdrv_replace_child (child, child_bs);return child; } +/* If @parent_bs and @child_bs are in different AioContexts, the caller must +* hold the AioContext lock for @child_bs, but not for @parent_bs. */ BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs, BlockDriverState *child_bs, const char *child_name,
@@ -2286,11 +2317,11 @@ BdrvChild *bdrv_attach_child(BlockDriverState *parent_bs,bdrv_get_cumulative_perm (parent_bs, &perm, &shared_perm);assert (parent_bs->drv); -assert (bdrv_get_aio_context (parent_bs) ==bdrv_get_aio_context (child_bs));bdrv_child_perm (parent_bs, child_bs,NULL , child_role,NULL , perm, shared_perm, &perm, &shared_perm); child =bdrv_root_attach_child (child_bs, child_name, child_role, +bdrv_get_aio_context (parent_bs), perm, shared_perm, parent_bs, errp);if (child ==NULL ) {return NULL ;
block/block-backend.c +4 -5
@@ -392,7 +392,7 @@ BlockBackend *blk_new_open(const char *filename, const char *reference,return NULL ; } - blk->root =bdrv_root_attach_child (bs,"root" , &child_root, + blk->root =bdrv_root_attach_child (bs,"root" , &child_root, blk->ctx, perm,BLK_PERM_ALL , blk, errp);if (!blk->root) {bdrv_unref (bs);
@@ -803,7 +803,7 @@ void blk_remove_bs(BlockBackend *blk)int blk_insert_bs (BlockBackend *blk,BlockDriverState *bs,Error **errp) {ThrottleGroupMember *tgm = &blk->public.throttle_group_member; - blk->root =bdrv_root_attach_child (bs,"root" , &child_root, + blk->root =bdrv_root_attach_child (bs,"root" , &child_root, blk->ctx, blk->perm, blk->shared_perm, blk, errp);if (blk->root ==NULL ) {return -EPERM ;
@@ -1862,10 +1862,9 @@ AioContext *blk_get_aio_context(BlockBackend *blk) {BlockDriverState *bs =blk_bs (blk); -/* FIXME The AioContext of bs and blk can be inconsistent. For the moment, -* we prefer the one of bs for compatibility. */ if (bs) { -return bdrv_get_aio_context (blk_bs (blk)); +AioContext *ctx =bdrv_get_aio_context (blk_bs (blk)); +assert (ctx == blk->ctx); }return blk->ctx;
blockjob.c +8 -2
@@ -204,8 +204,14 @@ int block_job_add_bdrv(BlockJob *job, const char *name, BlockDriverState *bs, {BdrvChild *c; - c =bdrv_root_attach_child (bs, name, &child_job, perm, shared_perm, - job, errp); +if (job->job.aio_context !=qemu_get_aio_context ()) { +aio_context_release (job->job.aio_context); + } + c =bdrv_root_attach_child (bs, name, &child_job, job->job.aio_context, + perm, shared_perm, job, errp); +if (job->job.aio_context !=qemu_get_aio_context ()) { +aio_context_acquire (job->job.aio_context); + }if (c ==NULL ) {return -EPERM ; }
tests/test-bdrv-drain.c +4 -2
@@ -912,6 +912,7 @@ static void test_blockjob_common_drain_node(enum drain_type drain_type, &error_abort); blk_target =blk_new (qemu_get_aio_context (),BLK_PERM_ALL ,BLK_PERM_ALL );blk_insert_bs (blk_target, target, &error_abort); +blk_set_allow_aio_context_change (blk_target, true);aio_context_acquire (ctx); tjob = block_job_create("job0", &test_job_driver, NULL, src,
@@ -972,7 +973,7 @@ static void test_blockjob_common_drain_node(enum drain_type drain_type,g_assert_false (job->job.paused);g_assert_true (job->job.busy);/* We're in qemu_co_sleep_ns() */ -do_drain_begin (drain_type, target); +do_drain_begin_unlocked (drain_type, target);if (drain_type ==BDRV_DRAIN_ALL ) {/* bdrv_drain_all() drains both src and target */
@@ -983,7 +984,7 @@ static void test_blockjob_common_drain_node(enum drain_type drain_type,g_assert_true (job->job.paused);g_assert_false (job->job.busy);/* The job is paused */ -do_drain_end (drain_type, target); +do_drain_end_unlocked (drain_type, target);if (use_iothread) {/* paused is reset in the I/O thread, wait for it */
@@ -1002,6 +1003,7 @@ static void test_blockjob_common_drain_node(enum drain_type drain_type,if (use_iothread) {blk_set_aio_context (blk_src,qemu_get_aio_context (), &error_abort); +blk_set_aio_context (blk_target,qemu_get_aio_context (), &error_abort); }aio_context_release (ctx);
Signature · 1 line
2.20.1
PATCH 7/15 test-block-iothread: Test adding parent to iothread node
In reply to Kevin WolfOpening a new parent node for a node that has already been moved into a different AioContext must cause the new parent ot move into the same context.
--- tests/test-block-iothread.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
tests/test-block-iothread.c +33 -0
@@ -663,6 +663,38 @@ static void test_propagate_mirror(void)bdrv_unref (target); } +static void test_attach_second_node (void ) +{ +IOThread *iothread =iothread_new (); +AioContext *ctx =iothread_get_aio_context (iothread); +AioContext *main_ctx =qemu_get_aio_context (); +BlockBackend *blk; +BlockDriverState *bs, *filter; +QDict *options; + + 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); + + options =qdict_new (); +qdict_put_str (options,"driver" ,"raw" ); +qdict_put_str (options,"file" ,"base" ); + + filter =bdrv_open (NULL ,NULL , options,BDRV_O_RDWR , &error_abort); +g_assert (blk_get_aio_context (blk) == ctx); +g_assert (bdrv_get_aio_context (bs) == ctx); +g_assert (bdrv_get_aio_context (filter) == ctx); + +blk_set_aio_context (blk, main_ctx, &error_abort); +g_assert (blk_get_aio_context (blk) == main_ctx); +g_assert (bdrv_get_aio_context (bs) == main_ctx); +g_assert (bdrv_get_aio_context (filter) == main_ctx); + +bdrv_unref (filter); +bdrv_unref (bs); +blk_unref (blk); +} +int main (int argc,char **argv) {int i;
@@ -678,6 +710,7 @@ int main(int argc, char **argv) }g_test_add_func ("/attach/blockjob" , test_attach_blockjob); +g_test_add_func ("/attach/second_node" , test_attach_second_node);g_test_add_func ("/propagate/basic" , test_propagate_basic);g_test_add_func ("/propagate/diamond" , test_propagate_diamond);g_test_add_func ("/propagate/mirror" , test_propagate_mirror);
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH 07/15] test-block-iothread: Test adding parent to iothread node
Quoted 2 lines · Kevin Wolf
Opening a new parent node for a node that has already been moved into a different AioContext must cause the new parent ot move into the same
to
Quoted 7 lines
context.
Signed-off-by Kevin Wolf <[email protected]>--- tests/test-block-iothread.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
PATCH 8/15 test-block-iothread: BlockBackend AioContext across root node change
In reply to Kevin WolfTest that BlockBackends preserve their assigned AioContext even when the root node goes away. Inserting a new root node will move it to the right AioContext.
--- tests/test-block-iothread.c | 33 +++++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
tests/test-block-iothread.c +33 -0
@@ -695,6 +695,38 @@ static void test_attach_second_node(void)blk_unref (blk); } +static void test_attach_preserve_blk_ctx (void ) +{ +IOThread *iothread =iothread_new (); +AioContext *ctx =iothread_get_aio_context (iothread); +BlockBackend *blk; +BlockDriverState *bs; + + 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 ; + +/* Add node to BlockBackend that has an iothread context assigned */ +blk_insert_bs (blk, bs, &error_abort); +g_assert (blk_get_aio_context (blk) == ctx); +g_assert (bdrv_get_aio_context (bs) == ctx); + +/* Remove the node again */ +blk_remove_bs (blk); +/* TODO bs should move back to main context here */ +g_assert (blk_get_aio_context (blk) == ctx); +g_assert (bdrv_get_aio_context (bs) == ctx); + +/* Re-attach the node */ +blk_insert_bs (blk, bs, &error_abort); +g_assert (blk_get_aio_context (blk) == ctx); +g_assert (bdrv_get_aio_context (bs) == ctx); + +blk_set_aio_context (blk,qemu_get_aio_context (), &error_abort); +bdrv_unref (bs); +blk_unref (blk); +} +int main (int argc,char **argv) {int i;
@@ -711,6 +743,7 @@ int main(int argc, char **argv)g_test_add_func ("/attach/blockjob" , test_attach_blockjob);g_test_add_func ("/attach/second_node" , test_attach_second_node); +g_test_add_func ("/attach/preserve_blk_ctx" , test_attach_preserve_blk_ctx);g_test_add_func ("/propagate/basic" , test_propagate_basic);g_test_add_func ("/propagate/diamond" , test_propagate_diamond);g_test_add_func ("/propagate/mirror" , test_propagate_mirror);
Signature · 1 line
2.20.1
PATCH 9/15 block: Move node without parents to main AioContext
In reply to Kevin WolfA node should only be in a non-default AioContext if a user is attached to it that requires this. When the last parent of a node is gone, it can move back to the main AioContext.
--- block.c | 4 ++++ tests/test-bdrv-drain.c | 2 +- tests/test-block-iothread.c | 3 +-- 3 files changed, 6 insertions(+), 3 deletions(-)
block.c +4 -0
@@ -2235,6 +2235,10 @@ static void bdrv_replace_child(BdrvChild *child, BlockDriverState *new_bs)bdrv_get_cumulative_perm (old_bs, &perm, &shared_perm);bdrv_check_perm (old_bs,NULL , perm, shared_perm,NULL , &error_abort);bdrv_set_perm (old_bs, perm, shared_perm); + +/* When the parent requiring a non-default AioContext is removed, the +* node moves back to the main AioContext */ +bdrv_try_set_aio_context (old_bs,qemu_get_aio_context (),NULL ); }if (new_bs) {
tests/test-bdrv-drain.c +1 -1
@@ -1003,7 +1003,7 @@ static void test_blockjob_common_drain_node(enum drain_type drain_type,if (use_iothread) {blk_set_aio_context (blk_src,qemu_get_aio_context (), &error_abort); -blk_set_aio_context (blk_target,qemu_get_aio_context (), &error_abort); +assert (blk_get_aio_context (blk_target) ==qemu_get_aio_context ()); }aio_context_release (ctx);
tests/test-block-iothread.c +1 -2
@@ -713,9 +713,8 @@ static void test_attach_preserve_blk_ctx(void)/* Remove the node again */ blk_remove_bs (blk); -/* TODO bs should move back to main context here */ g_assert (blk_get_aio_context (blk) == ctx); -g_assert (bdrv_get_aio_context (bs) == ctx); +g_assert (bdrv_get_aio_context (bs) ==qemu_get_aio_context ());/* Re-attach the node */ blk_insert_bs (blk, bs, &error_abort);
Signature · 1 line
2.20.1
PATCH 10/15 blockdev: Use bdrv_try_set_aio_context() for monitor commands
In reply to Kevin WolfMonitor commands can handle errors, so they can easily be converted to using the safer bdrv_try_set_aio_context() function.
--- blockdev.c | 44 ++++++++++++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 16 deletions(-)
blockdev.c +28 -16
@@ -1535,6 +1535,7 @@ static void external_snapshot_prepare(BlkActionState *common,DO_UPCAST (ExternalSnapshotState, common, common);TransactionAction *action = common->action;AioContext *aio_context; +int ret;/* 'blockdev-snapshot' and 'blockdev-snapshot-sync' have similar * purpose but a different set of parameters */
@@ -1674,7 +1675,10 @@ static void external_snapshot_prepare(BlkActionState *common, goto out; } -bdrv_set_aio_context (state->new_bs, aio_context); + ret =bdrv_try_set_aio_context (state->new_bs, aio_context, errp); +if (ret <0 ) { + goto out; + }/* This removes our old bs and adds the new bs. This is an operation that * can fail, so we need to do it in .prepare; undoing it for abort is
@@ -3424,6 +3428,7 @@ static BlockJob *do_drive_backup(DriveBackup *backup, JobTxn *txn,int flags, job_flags =JOB_DEFAULT ;int64_t size;bool set_backing_hd = false; +int ret;if (!backup->has_speed) { backup->speed =0 ;
@@ -3520,7 +3525,11 @@ static BlockJob *do_drive_backup(DriveBackup *backup, JobTxn *txn, goto out; } -bdrv_set_aio_context (target_bs, aio_context); + ret =bdrv_try_set_aio_context (target_bs, aio_context, errp); +if (ret <0 ) { +bdrv_unref (target_bs); + goto out; + }if (set_backing_hd) {bdrv_set_backing_hd (target_bs, source, &local_err);
@@ -3592,6 +3601,7 @@ BlockJob *do_blockdev_backup(BlockdevBackup *backup, JobTxn *txn,AioContext *aio_context;BlockJob *job =NULL ;int job_flags =JOB_DEFAULT ; +int ret;if (!backup->has_speed) { backup->speed =0 ;
@@ -3628,16 +3638,9 @@ BlockJob *do_blockdev_backup(BlockdevBackup *backup, JobTxn *txn, goto out; } -if (bdrv_get_aio_context (target_bs) != aio_context) { -if (!bdrv_has_blk (target_bs)) { -/* The target BDS is not attached, we can safely move it to another -* AioContext. */ -bdrv_set_aio_context (target_bs, aio_context); - }else { -error_setg (errp,"Target is attached to a different thread from " -"source." ); - goto out; - } + ret =bdrv_try_set_aio_context (target_bs, aio_context, errp); +if (ret <0 ) { + goto out; }if (backup->has_bitmap) {
@@ -3810,6 +3813,7 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp)int flags;int64_t size;const char *format = arg->format; +int ret; bs =qmp_get_root_bs (arg->device, errp);if (!bs) {
@@ -3910,7 +3914,11 @@ void qmp_drive_mirror(DriveMirror *arg, Error **errp) goto out; } -bdrv_set_aio_context (target_bs, aio_context); + ret =bdrv_try_set_aio_context (target_bs, aio_context, errp); +if (ret <0 ) { +bdrv_unref (target_bs); + goto out; + } blockdev_mirror_common(arg->has_job_id ? arg->job_id : NULL, bs, target_bs, arg->has_replaces, arg->replaces, arg->sync,
@@ -3954,6 +3962,7 @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id,AioContext *aio_context;BlockMirrorBackingMode backing_mode =MIRROR_LEAVE_BACKING_CHAIN ;Error *local_err =NULL ; +int ret; bs =qmp_get_root_bs (device, errp);if (!bs) {
@@ -3968,7 +3977,10 @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id, aio_context =bdrv_get_aio_context (bs);aio_context_acquire (aio_context); -bdrv_set_aio_context (target_bs, aio_context); + ret =bdrv_try_set_aio_context (target_bs, aio_context, errp); +if (ret <0 ) { + goto out; + } blockdev_mirror_common(has_job_id ? job_id : NULL, bs, target_bs, has_replaces, replaces, sync, backing_mode,
@@ -3984,7 +3996,7 @@ void qmp_blockdev_mirror(bool has_job_id, const char *job_id, has_auto_dismiss, auto_dismiss, &local_err);error_propagate (errp, local_err); - +out:aio_context_release (aio_context); }
@@ -4474,7 +4486,7 @@ void qmp_x_blockdev_set_iothread(const char *node_name, StrOrNull *iothread, old_context =bdrv_get_aio_context (bs);aio_context_acquire (old_context); -bdrv_set_aio_context (bs, new_context); +bdrv_try_set_aio_context (bs, new_context, errp);aio_context_release (old_context); }
Signature · 1 line
2.20.1
PATCH 11/15 block: Remove wrong bdrv_set_aio_context() calls
In reply to Kevin WolfThe mirror and commit block jobs use bdrv_set_aio_context() to move their filter node into the right AioContext before hooking it up in the graph. Similarly, bdrv_open_backing_file() explicitly moves the backing file node into the right AioContext first.
This isn't necessary any more, they get automatically moved into the right context now when attaching them.
However, in the case of bdrv_open_backing_file() with a node reference, it's actually not only unnecessary, but even wrong: The unchecked bdrv_set_aio_context() changes the AioContext of the child node even if other parents require it to retain the old context. So this is not only a simplification, but a bug fix, too.
--- block.c | 1 - block/commit.c | 2 -- block/mirror.c | 1 - 3 files changed, 4 deletions(-)
block.c +0 -1
@@ -2539,7 +2539,6 @@ int bdrv_open_backing_file(BlockDriverState *bs, QDict *parent_options, ret = -EINVAL ; goto free_exit; } -bdrv_set_aio_context (backing_hd,bdrv_get_aio_context (bs));if (implicit_backing) {bdrv_refresh_filename (backing_hd);
block/commit.c +0 -2
@@ -301,7 +301,6 @@ void commit_start(const char *job_id, BlockDriverState *bs, commit_top_bs->implicit = true; } commit_top_bs->total_sectors = top->total_sectors; -bdrv_set_aio_context (commit_top_bs,bdrv_get_aio_context (top));bdrv_append (commit_top_bs, top, &local_err);if (local_err) {
@@ -443,7 +442,6 @@ int bdrv_commit(BlockDriverState *bs)error_report_err (local_err); goto ro_cleanup; } -bdrv_set_aio_context (commit_top_bs,bdrv_get_aio_context (backing_file_bs));bdrv_set_backing_hd (commit_top_bs, backing_file_bs, &error_abort);bdrv_set_backing_hd (bs, commit_top_bs, &error_abort);
block/mirror.c +0 -1
@@ -1543,7 +1543,6 @@ static void mirror_start_job(const char *job_id, BlockDriverState *bs,BDRV_REQ_NO_FALLBACK ; bs_opaque =g_new0 (MirrorBDSOpaque,1 ); mirror_top_bs->opaque = bs_opaque; -bdrv_set_aio_context (mirror_top_bs,bdrv_get_aio_context (bs));/* bdrv_append takes ownership of the mirror_top_bs reference, need to keep * it alive until block_job_create() succeeds even if bs has no parent. */
Signature · 1 line
2.20.1
PATCH 12/15 virtio-scsi-test: Test attaching new overlay with iothreads
In reply to Kevin WolfThis tests that blockdev-add can correctly add a qcow2 overlay to an image used by a virtio-scsi disk in an iothread. The interesting point here is whether the newly added node gets correctly moved into the iothread AioContext.
If it isn't, we get an assertion failure in virtio-scsi while processing the next request:
virtio_scsi_ctx_check: Assertion `blk_get_aio_context(d->conf.blk) == s->ctx' failed.
--- tests/libqtest.h | 11 +++++++ tests/libqtest.c | 19 ++++++++++++ tests/virtio-scsi-test.c | 62 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 92 insertions(+)
tests/libqtest.h +11 -0
@@ -619,6 +619,17 @@ static inline void qtest_end(void)QDict *qmp (const char *fmt, ...)GCC_FMT_ATTR (1 ,2 );/** +* qmp_assert_success: +* @fmt...: QMP message to send to qemu, formatted like +* qobject_from_jsonf_nofail(). See parse_escape() for what's +* supported after '%'. +* +* Sends a QMP message to QEMU and asserts that a 'return' key is present in +* the response. +*/ +void qmp_assert_success(const char *fmt, ...) GCC_FMT_ATTR(1, 2); + +/* * qmp_eventwait: * @s: #event event to wait for. *
tests/libqtest.c +19 -0
@@ -1038,6 +1038,25 @@ QDict *qmp(const char *fmt, ...)return response; } +void qmp_assert_success (const char *fmt, ...) +{ +va_list ap; +QDict *response; + +va_start (ap, fmt); + response =qtest_vqmp (global_qtest, fmt, ap); +va_end (ap); + +g_assert (response); +if (!qdict_haskey (response,"return" )) { +QString *s =qobject_to_json_pretty (QOBJECT (response)); +g_test_message ("%s" ,qstring_get_str (s)); +qobject_unref (s); + } +g_assert (qdict_haskey (response,"return" )); +qobject_unref (response); +} +char *hmp (const char *fmt, ...) {va_list ap;
tests/virtio-scsi-test.c +62 -0
80 lines not on this page · raw message
Signature · 1 line
2.20.1
PATCH 13/15 iotests: Attach new devices to node in non-default iothread
In reply to Kevin WolfThis tests that devices refuse to be attached to a node that has already been moved to a different iothread if they can't be or aren't configured to work in the same iothread.
--- tests/qemu-iotests/051 | 24 ++++++++++++++++++++++++ tests/qemu-iotests/051.out | 3 +++ tests/qemu-iotests/051.pc.out | 27 +++++++++++++++++++++++++++ 3 files changed, 54 insertions(+)
tests/qemu-iotests/051 +24 -0
@@ -191,6 +191,30 @@ case "$QEMU_DEFAULT_MACHINE" in ;; esac +echo +echo === Attach to node in non-default iothread === +echo + +case "$QEMU_DEFAULT_MACHINE" in + pc) + iothread="-drive file=$TEST_IMG,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" + + # Can't add a device in the main thread while virtio-scsi0 uses the node + run_qemu $iothread -device ide-hd,drive=disk,share-rw=on + run_qemu $iothread -device virtio-blk-pci,drive=disk,share-rw=on + run_qemu $iothread -device lsi53c895a,id=lsi0 -device scsi-hd,bus=lsi0.0,drive=disk,share-rw=on + run_qemu $iothread -device virtio-scsi,id=virtio-scsi1 -device scsi-hd,bus=virtio-scsi1.0,drive=disk,share-rw=on + + # virtio-blk enables the iothread only when the driver initialises the + # device, so a second virtio-blk device can't be added even with the + # same iothread. virtio-scsi allows this. + run_qemu $iothread -device virtio-blk-pci,drive=disk,iohtread=iothread0,share-rw=on + run_qemu $iothread -device virtio-scsi,id=virtio-scsi1,iothread=thread0 -device scsi-hd,bus=virtio-scsi1.0,drive=disk,share-rw=on + ;; + *) + ;; +esac + echo echo === Read-only === echo
tests/qemu-iotests/051.out +3 -0
@@ -137,6 +137,9 @@ QEMU X.Y.Z monitor - type 'help' for more information (qemu) QEMU_PROG: -drive if=virtio: Device needs media, but drive is empty +=== Attach to node in non-default iothread === + + === Read-only === Testing: -drive file=TEST_DIR/t.qcow2,if=virtio,readonly=on
tests/qemu-iotests/051.pc.out +27 -0
@@ -173,6 +173,33 @@ QEMU X.Y.Z monitor - type 'help' for more information (qemu) QEMU_PROG: -device scsi-hd,drive=disk: Device needs media, but drive is empty +=== Attach to node in non-default iothread === + +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) 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) 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 +(qemu) QEMU_PROG: -device scsi-hd,bus=lsi0.0,drive=disk,share-rw=on: HBA does not support iothreads + +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 -device scsi-hd,bus=virtio-scsi1.0,drive=disk,share-rw=on +QEMU X.Y.Z monitor - type 'help' for more information +(qemu) QEMU_PROG: -device scsi-hd,bus=virtio-scsi1.0,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,iohtread=iothread0,share-rw=on +QEMU X.Y.Z monitor - type 'help' for more information +(qemu) QEMU_PROG: -device virtio-blk-pci,drive=disk,iohtread=iothread0,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 +(qemu) quit + + === Read-only === Testing: -drive file=TEST_DIR/t.qcow2,if=floppy,readonly=on
Signature · 1 line
2.20.1
PATCH 14/15 test-bdrv-drain: Use bdrv_try_set_aio_context()
In reply to Kevin WolfNo reason to use the unchecked version in tests, even more so when these are the last callers of bdrv_set_aio_context() outside of block.c.
--- tests/test-bdrv-drain.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
tests/test-bdrv-drain.c +3 -3
@@ -1515,16 +1515,16 @@ static void test_set_aio_context(void) &error_abort);bdrv_drained_begin (bs); -bdrv_set_aio_context (bs, ctx_a); +bdrv_try_set_aio_context (bs, ctx_a, &error_abort);aio_context_acquire (ctx_a);bdrv_drained_end (bs);bdrv_drained_begin (bs); -bdrv_set_aio_context (bs, ctx_b); +bdrv_try_set_aio_context (bs, ctx_b, &error_abort);aio_context_release (ctx_a);aio_context_acquire (ctx_b); -bdrv_set_aio_context (bs,qemu_get_aio_context ()); +bdrv_try_set_aio_context (bs,qemu_get_aio_context (), &error_abort);aio_context_release (ctx_b);bdrv_drained_end (bs);
Signature · 1 line
2.20.1
PATCH 15/15 block: Remove bdrv_set_aio_context()
In reply to Kevin WolfAll callers of bdrv_set_aio_context() are eliminated now, they have moved to bdrv_try_set_aio_context() and related safe functions. Remove bdrv_set_aio_context().
With this, we can now know that the .set_aio_ctx callback must be present in bdrv_set_aio_context_ignore() because bdrv_can_set_aio_context() would have returned false previously, so instead of checking the condition, we can assert it.
--- docs/devel/multiple-iothreads.txt | 4 ++-- include/block/block.h | 9 --------- block.c | 30 ++++++++++++++---------------- 3 files changed, 16 insertions(+), 27 deletions(-)
docs/devel/multiple-iothreads.txt +2 -2
@@ -109,7 +109,7 @@ The AioContext originates from the QEMU block layer, even though nowadays AioContext is a generic event loop that can be used by any QEMU subsystem. The block layer has support for AioContext integrated. Each BlockDriverState -is associated with an AioContext using bdrv_set_aio_context() and +is associated with an AioContext using bdrv_try_set_aio_context() and bdrv_get_aio_context(). This allows block layer code to process I/O inside the right AioContext. Other subsystems may wish to follow a similar approach.
@@ -134,5 +134,5 @@ Long-running jobs (usually in the form of coroutines) are best scheduled in the BlockDriverState's AioContext to avoid the need to acquire/release around each bdrv_*() call. The functions bdrv_add/remove_aio_context_notifier, or alternatively blk_add/remove_aio_context_notifier if you use BlockBackends, -can be used to get a notification whenever bdrv_set_aio_context() moves a +can be used to get a notification whenever bdrv_try_set_aio_context() moves a BlockDriverState to a different AioContext.
include/block/block.h +0 -9
@@ -583,15 +583,6 @@ AioContext *bdrv_get_aio_context(BlockDriverState *bs);*/ void bdrv_coroutine_enter (BlockDriverState *bs,Coroutine *co); -/** -* bdrv_set_aio_context: -* -* Changes the #AioContext used for fd handlers, timers, and BHs by this -* BlockDriverState and all its children. -* -* This function must be called with iothread lock held. -*/ -void bdrv_set_aio_context (BlockDriverState *bs,AioContext *new_context);void bdrv_set_aio_context_ignore (BlockDriverState *bs,AioContext *new_context,GSList **ignore); int bdrv_try_set_aio_context(BlockDriverState *bs, AioContext *ctx,
block.c +14 -16
@@ -5791,8 +5791,17 @@ static void bdrv_attach_aio_context(BlockDriverState *bs, bs->walking_aio_notifiers = false; } -/* @ignore will accumulate all visited BdrvChild object. The caller is -* responsible for freeing the list afterwards. */ +/* +* Changes the AioContext used for fd handlers, timers, and BHs by this +* BlockDriverState and all its children and parents. +* +* The caller must own the AioContext lock for the old AioContext of bs, but it +* must not own the AioContext lock for new_context (unless new_context is the +* same as the current context of bs). +* +* @ignore will accumulate all visited BdrvChild object. The caller is +* responsible for freeing the list afterwards. +*/ void bdrv_set_aio_context_ignore (BlockDriverState *bs,AioContext *new_context,GSList **ignore) {
@@ -5815,10 +5824,9 @@ void bdrv_set_aio_context_ignore(BlockDriverState *bs,if (g_slist_find (*ignore, child)) {continue ; } -if (child->role->set_aio_ctx) { - *ignore =g_slist_prepend (*ignore, child); - child->role->set_aio_ctx (child, new_context, ignore); - } +assert (child->role->set_aio_ctx); + *ignore =g_slist_prepend (*ignore, child); + child->role->set_aio_ctx (child, new_context, ignore); }bdrv_detach_aio_context (bs);
@@ -5832,16 +5840,6 @@ void bdrv_set_aio_context_ignore(BlockDriverState *bs,aio_context_release (new_context); } -/* The caller must own the AioContext lock for the old AioContext of bs, but it -* must not own the AioContext lock for new_context (unless new_context is -* the same as the current context of bs). */ -void bdrv_set_aio_context (BlockDriverState *bs,AioContext *new_context) -{ -GSList *ignore_list =NULL ; -bdrv_set_aio_context_ignore (bs, new_context, &ignore_list); -g_slist_free (ignore_list); -} -static bool bdrv_parent_can_set_aio_context (BdrvChild *c,AioContext *ctx,GSList **ignore,Error **errp) {
Signature · 1 line
2.20.1
Patchew URL: https://patchew.org/QEMU/[email protected]/
Patchew URL: https://patchew.org/QEMU/[email protected]/
Hi,
This series seems to have some coding style problems. See output below for more information:
Subject: [Qemu-devel] [PATCH 00/15] block: AioContext management, part 2
Type: series
Message-id: [email protected]
=== TEST SCRIPT BEGIN ===
#!/bin/bash
git rev-parse base > /dev/null || exit 0
git config --local diff.renamelimit 0
git config --local diff.renames True
git config --local diff.algorithm histogram./scripts/checkpatch.pl --mailback base..
=== TEST SCRIPT END ===
Updating 3c8cf5a9c21ff8782164d1def7f44bd888713384
Switched to a new branch 'test'
6ca27a5 block: Remove bdrv_set_aio_context()
984ba6d test-bdrv-drain: Use bdrv_try_set_aio_context()
b054561 iotests: Attach new devices to node in non-default iothread 98252b3 virtio-scsi-test: Test attaching new overlay with iothreads 7f6cd93 block: Remove wrong bdrv_set_aio_context() calls
0419720 blockdev: Use bdrv_try_set_aio_context() for monitor commands 26a1acf block: Move node without parents to main AioContext cd2b0d7 test-block-iothread: BlockBackend AioContext across root node change 5a4c60c test-block-iothread: Test adding parent to iothread node 1767a79 block: Adjust AioContexts when attaching nodes
16a9345 scsi-disk: Use qdev_prop_drive_iothread
cc6b17c block: Add qdev_prop_drive_iothread property type 2e30704 block: Add BlockBackend.ctx
15a3e30 block: Add Error to blk_set_aio_context()
88715f0 test-block-iothread: Check filter node in test_propagate_mirror
=== OUTPUT BEGIN ===
1/15 Checking commit 88715f0ee897 (test-block-iothread: Check filter node in test_propagate_mirror) 2/15 Checking commit 15a3e308457c (block: Add Error to blk_set_aio_context())
WARNING: Block comments use a leading /* on a separate line
#104: FILE: hw/block/dataplane/virtio-blk.c:289:
+ /* Drain and try to switch bs back to the QEMU main loop. If other users
WARNING: Block comments use a trailing */ on a separate line #105: FILE: hw/block/dataplane/virtio-blk.c:290:
+ * keep the BlockBackend in the iothread, that's ok */
total: 0 errors, 2 warnings, 259 lines checked
Patch 2/15 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
3/15 Checking commit 2e30704b8e57 (block: Add BlockBackend.ctx)
WARNING: Block comments use a leading /* on a separate line #96: FILE: block/block-backend.c:1865:
+ /* FIXME The AioContext of bs and blk can be inconsistent. For the moment,
WARNING: Block comments use a trailing */ on a separate line #97: FILE: block/block-backend.c:1866:
+ * we prefer the one of bs for compatibility. */
WARNING: Block comments use a leading /* on a separate line #405: FILE: hw/core/qdev-properties-system.c:83:
+ /* BlockBackends of devices start in the main context and are only
WARNING: Block comments use a trailing */ on a separate line #406: FILE: hw/core/qdev-properties-system.c:84:
+ * later moved into another context if the device supports that. */
WARNING: line over 80 characters
#647: FILE: tests/test-block-backend.c:40:
+ BlockBackend *blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
WARNING: line over 80 characters
#656: FILE: tests/test-block-backend.c:56:
+ BlockBackend *blk = blk_new(qemu_get_aio_context(), BLK_PERM_ALL, BLK_PERM_ALL);
total: 0 errors, 6 warnings, 533 lines checked
Patch 3/15 has style problems, please review. If any of these errors are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
4/15 Checking commit cc6b17c2c35e (block: Add qdev_prop_drive_iothread property type)
ERROR: Macros with complex values should be enclosed in parenthesis #133: FILE: include/hw/block/block.h:61:
+#define DEFINE_BLOCK_PROPERTIES(_state, _conf) \
+ DEFINE_PROP_DRIVE("drive", _state, _conf.blk), \
+ DEFINE_BLOCK_PROPERTIES_BASE(_state, _conf)
total: 1 errors, 0 warnings, 107 lines checked
Patch 4/15 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
5/15 Checking commit 16a934533950 (scsi-disk: Use qdev_prop_drive_iothread)
ERROR: Macros with complex values should be enclosed in parenthesis #49: FILE: hw/scsi/scsi-disk.c:2939:
+#define DEFINE_SCSI_DISK_PROPERTIES() \
+ DEFINE_PROP_DRIVE_IOTHREAD("drive", SCSIDiskState, qdev.conf.blk), \
+ DEFINE_BLOCK_PROPERTIES_BASE(SCSIDiskState, qdev.conf), \
+ DEFINE_BLOCK_ERROR_PROPERTIES(SCSIDiskState, qdev.conf), \
+ DEFINE_PROP_STRING("ver", SCSIDiskState, version), \
+ DEFINE_PROP_STRING("serial", SCSIDiskState, serial), \
+ DEFINE_PROP_STRING("vendor", SCSIDiskState, vendor), \
+ DEFINE_PROP_STRING("product", SCSIDiskState, product), \ DEFINE_PROP_STRING("device_id", SCSIDiskState, device_id)
total: 1 errors, 0 warnings, 85 lines checked
Patch 5/15 has style problems, please review. If any of these errors are false positives report them to the maintainer, see CHECKPATCH in MAINTAINERS.
6/15 Checking commit 1767a7917e97 (block: Adjust AioContexts when attaching nodes)
WARNING: Block comments use a leading /* on a separate line
#27: FILE: block.c:2246:
+/* The caller must hold the AioContext lock @child_bs, but not that of @ctx
WARNING: Block comments use a trailing */ on a separate line #28: FILE: block.c:2247:
+ * (unless @child_bs is already in @ctx). */
WARNING: Block comments use a leading /* on a separate line #45: FILE: block.c:2275:
+ /* If the AioContexts don't match, first try to move the subtree of
WARNING: Block comments use a trailing */ on a separate line #47: FILE: block.c:2277:
+ * try moving the parent into the AioContext of child_bs instead. */
WARNING: Block comments use a leading /* on a separate line
#76: FILE: block.c:2306:
+/* If @parent_bs and @child_bs are in different AioContexts, the caller must
WARNING: Block comments use a trailing */ on a separate line #77: FILE: block.c:2307:
+ * hold the AioContext lock for @child_bs, but not for @parent_bs. */
total: 0 errors, 6 warnings, 149 lines checked
Patch 6/15 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
7/15 Checking commit 5a4c60c72bfc (test-block-iothread: Test adding parent to iothread node) 8/15 Checking commit cd2b0d787e1b (test-block-iothread: BlockBackend AioContext across root node change) 9/15 Checking commit 26a1acffbe16 (block: Move node without parents to main AioContext)
WARNING: Block comments use a leading /* on a separate line
#23: FILE: block.c:2239:
+ /* When the parent requiring a non-default AioContext is removed, the
WARNING: Block comments use a trailing */ on a separate line #24: FILE: block.c:2240:
+ * node moves back to the main AioContext */
total: 0 errors, 2 warnings, 28 lines checked
Patch 9/15 has style problems, please review. If any of these errors
are false positives report them to the maintainer, see
CHECKPATCH in MAINTAINERS.
10/15 Checking commit 0419720e7eb2 (blockdev: Use bdrv_try_set_aio_context() for monitor commands) 11/15 Checking commit 7f6cd93a5e95 (block: Remove wrong bdrv_set_aio_context() calls) 12/15 Checking commit 98252b3fe05c (virtio-scsi-test: Test attaching new overlay with iothreads) 13/15 Checking commit b0545619fcbb (iotests: Attach new devices to node in non-default iothread) 14/15 Checking commit 984ba6d265e1 (test-bdrv-drain: Use bdrv_try_set_aio_context()) 15/15 Checking commit 6ca27a5484fa (block: Remove bdrv_set_aio_context())
=== OUTPUT END ===
Test command exited with code: 1
The full log is available at
http://patchew.org/logs/[email protected]/testing.checkpatch/?type=message.
---
Email generated automatically by Patchew [https://patchew.org/].
Please send your feedback to [email protected]
PATCH 1/1 nbd-server: Call blk_set_allow_aio_context_change()
In reply to Kevin WolfThe NBD server uses an AioContext notifier, so it can tolerate that its BlockBackend is switched to a different AioContext. Before we start actually calling bdrv_try_set_aio_context(), which checks for consistency, outside of test cases, we need to make sure that the NBD server actually allows this.
--- nbd/server.c | 1 + tests/qemu-iotests/240 | 21 +++++++++++++++++++++ tests/qemu-iotests/240.out | 13 +++++++++++++ 3 files changed, 35 insertions(+)
nbd/server.c +1 -0
@@ -1491,6 +1491,7 @@ NBDExport *nbd_export_new(BlockDriverState *bs, uint64_t dev_offset, goto fail; }blk_set_enable_write_cache (blk, !writethrough); +blk_set_allow_aio_context_change (blk, true); exp->refcount =1 ;QTAILQ_INIT (&exp->clients);
tests/qemu-iotests/240 +21 -0
@@ -27,6 +27,12 @@ echo "QA output created by $seq" status=1 # failure is the default! +_cleanup() +{ + rm -f "$TEST_DIR/nbd" +} +trap "_cleanup; exit \$status" 0 1 2 3 15 + # get standard environment, filters and checks . ./common.rc . ./common.filter
@@ -122,6 +128,21 @@ run_qemu <<EOF { "execute": "quit"} EOF +echo +echo === Attach a SCSI disks using the same block device as a NBD server === +echo + +run_qemu <<EOF +{ "execute": "qmp_capabilities" } +{ "execute": "blockdev-add", "arguments": {"driver": "null-co", "node-name": "hd0", "read-only": true}} +{ "execute": "nbd-server-start", "arguments": {"addr":{"type":"unix","data":{"path":"$TEST_DIR/nbd"}}}} +{ "execute": "nbd-server-add", "arguments": {"device":"hd0"}} +{ "execute": "object-add", "arguments": {"qom-type": "iothread", "id": "iothread0"}} +{ "execute": "device_add", "arguments": {"id": "scsi0", "driver": "${virtio_scsi}", "iothread": "iothread0"}} +{ "execute": "device_add", "arguments": {"id": "scsi-hd0", "driver": "scsi-hd", "drive": "hd0", "bus": "scsi0.0"}} +{ "execute": "quit"} +EOF + # success, all done echo "*** done" rm -f $seq.full
tests/qemu-iotests/240.out +13 -0
@@ -51,4 +51,17 @@ QMP_VERSION {"return": {}} {"return": {}} {"return": {}} + +=== Attach a SCSI disks using the same block device as a NBD server === + +Testing: +QMP_VERSION +{"return": {}} +{"return": {}} +{"return": {}} +{"return": {}} +{"return": {}} +{"return": {}} +{"return": {}} +{"return": {}} *** done
Signature · 1 line
2.20.1
Re: [Qemu-devel] [PATCH 1.5/15] nbd-server: Call blk_set_allow_aio_context_change()
Quoted 6 lines · Kevin Wolf
The NBD server uses an AioContext notifier, so it can tolerate that its BlockBackend is switched to a different AioContext. Before we start actually calling
bdrv_try_set_aio_context(), which checks for consistency, outside of test cases, we need to make sure that the NBD server actually allows this.
Quoted 7 lines
Signed-off-by Kevin Wolf <[email protected]>--- nbd/server.c | 1 + tests/qemu-iotests/240 | 21 +++++++++++++++++++++ tests/qemu-iotests/240.out | 13 +++++++++++++ 3 files changed, 35 insertions(+)
Signature · 3 lines
Eric Blake, Principal Software Engineer Red Hat, Inc. +1-919-301-3226 Virtualization: qemu.org | libvirt.org
Kevin Wolf
AppliedAm 23.05.2019 um 18:00 hat Kevin Wolf geschrieben:
Quoted 12 lines
Recently, a few bugs were reported that resulted from an inconsistent state regarding AioContexts. Block nodes can end up in different contexts than their users expect - the AioContext of a node can even change under the feet of a device with no way for the device to forbid this. We recently added a few basic checks to scsi-disk and virtio-blk, but they are by far not enough.
Part 1 solved the first half of the problem and made sure that AioContext changes are propagated through the graph as necessary, so that a
bdrv_set_aio_context()correctly pulls everything that uses the node into the right context.
Quoted 8 lines
This is part 2 that fixes the second half: Attaching new child nodes where the parent and child are already in different AioContexts. This operation may only succeed if we can move one of the node into the context of the other node.
After applying this series, unchecked
bdrv_set_aio_context()doesn't exist any more and all users call functions that make sure that the AioContext assignments across the graph stays consistent.
Applied to the block branch.
Kevin