Commit 97896a48 authored by Kevin Wolf's avatar Kevin Wolf
Browse files

block: Add Error to blk_set_aio_context() 



Add 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.

Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
parent 45e92a90

block/block-backend.c

+16 −10
Original line number Diff line number Diff line
@@ -1865,30 +1865,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,
@@ -1915,7 +1921,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
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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
Original line number Diff line number Diff line
@@ -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);

    }

include/sysemu/block-backend.h

+2 −1
Original line number Diff line number Diff line
@@ -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);