Commit 9ffe337c authored by Paolo Bonzini's avatar Paolo Bonzini Committed by Michael S. Tsirkin
Browse files

virtio-blk: always use dataplane path if ioeventfd is active 

Override start_ioeventfd and stop_ioeventfd to start/stop the
whole dataplane logic.  This has some positive side effects:

- no need anymore for virtio_add_queue_aio (i.e. a revert of
  commit 0ff841f6)

- no need anymore to switch from generic ioeventfd handlers to
  dataplane

It detects some errors better:

    $ qemu-system-x86_64 -object iothread,id=io \
          -drive id=null,file=null-aio://,if=none,format=raw

 \
          -device virtio-blk-pci,ioeventfd=off,iothread=io,drive=null
    qemu-system-x86_64: -device virtio-blk-pci,ioeventfd=off,iothread=io,drive=null:
    ioeventfd is required for iothread

while previously it would have started just fine.

Reviewed-by: default avatarCornelia Huck <cornelia.huck@de.ibm.com>
Signed-off-by: default avatarPaolo Bonzini <pbonzini@redhat.com>
Reviewed-by: default avatarMichael S. Tsirkin <mst@redhat.com>
Signed-off-by: default avatarMichael S. Tsirkin <mst@redhat.com>
parent 8e93cef1

hw/block/dataplane/virtio-blk.c

+45 −28
Original line number Diff line number Diff line
@@ -88,23 +88,28 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf, 


    *dataplane = NULL;



    if (!conf->iothread) {

        return;

    }



    /* Don't try if transport does not support notifiers. */

    if (conf->iothread) {

        if (!k->set_guest_notifiers || !k->ioeventfd_assign) {

            error_setg(errp,

                   "device is incompatible with dataplane "

                       "device is incompatible with iothread "

                       "(transport does not support notifiers)");

            return;

        }

        if (!virtio_device_ioeventfd_enabled(vdev)) {

            error_setg(errp, "ioeventfd is required for iothread");

            return;

        }



    /* If dataplane is (re-)enabled while the guest is running there could be

     * block jobs that can conflict.

        /* If dataplane is (re-)enabled while the guest is running there could

         * be block jobs that can conflict.

         */

        if (blk_op_is_blocked(conf->conf.blk, BLOCK_OP_TYPE_DATAPLANE, errp)) {

        error_prepend(errp, "cannot start dataplane thread: ");

            error_prepend(errp, "cannot start virtio-blk dataplane: ");

            return;

        }

    }

    /* Don't try if transport does not support notifiers. */

    if (!virtio_device_ioeventfd_enabled(vdev)) {

        return;

    }
@@ -112,9 +117,13 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf, 
    s->vdev = vdev;

    s->conf = conf;



    if (conf->iothread) {

        s->iothread = conf->iothread;

        object_ref(OBJECT(s->iothread));

        s->ctx = iothread_get_aio_context(s->iothread);

    } else {

        s->ctx = qemu_get_aio_context();

    }

    s->bh = aio_bh_new(s->ctx, notify_guest_bh, s);

    s->batch_notify_vqs = bitmap_new(conf->num_queues);
@@ -124,14 +133,19 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf, 
/* Context: QEMU global mutex held */

void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)

{

    VirtIOBlock *vblk;



    if (!s) {

        return;

    }



    virtio_blk_data_plane_stop(s);

    vblk = VIRTIO_BLK(s->vdev);

    assert(!vblk->dataplane_started);

    g_free(s->batch_notify_vqs);

    qemu_bh_delete(s->bh);

    if (s->iothread) {

        object_unref(OBJECT(s->iothread));

    }

    g_free(s);

}
@@ -147,17 +161,18 @@ static void virtio_blk_data_plane_handle_output(VirtIODevice *vdev, 
}



/* Context: QEMU global mutex held */

void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s)

int virtio_blk_data_plane_start(VirtIODevice *vdev)

{

    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s->vdev)));

    VirtIOBlock *vblk = VIRTIO_BLK(vdev);

    VirtIOBlockDataPlane *s = vblk->dataplane;

    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(vblk)));

    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);

    VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);

    unsigned i;

    unsigned nvqs = s->conf->num_queues;

    int r;



    if (vblk->dataplane_started || s->starting) {

        return;

        return 0;

    }



    s->starting = true;
@@ -204,20 +219,22 @@ void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s) 
                virtio_blk_data_plane_handle_output);

    }

    aio_context_release(s->ctx);

    return;

    return 0;



  fail_guest_notifiers:

    vblk->dataplane_disabled = true;

    s->starting = false;

    vblk->dataplane_started = true;

    return -ENOSYS;

}



/* Context: QEMU global mutex held */

void virtio_blk_data_plane_stop(VirtIOBlockDataPlane *s)

void virtio_blk_data_plane_stop(VirtIODevice *vdev)

{

    BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(s->vdev)));

    VirtIOBlock *vblk = VIRTIO_BLK(vdev);

    VirtIOBlockDataPlane *s = vblk->dataplane;

    BusState *qbus = qdev_get_parent_bus(DEVICE(vblk));

    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);

    VirtIOBlock *vblk = VIRTIO_BLK(s->vdev);

    unsigned i;

    unsigned nvqs = s->conf->num_queues;

hw/block/dataplane/virtio-blk.h

+3 −3
Original line number Diff line number Diff line
@@ -23,9 +23,9 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf, 
                                  VirtIOBlockDataPlane **dataplane,

                                  Error **errp);

void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s);

void virtio_blk_data_plane_start(VirtIOBlockDataPlane *s);

void virtio_blk_data_plane_stop(VirtIOBlockDataPlane *s);

void virtio_blk_data_plane_drain(VirtIOBlockDataPlane *s);

void virtio_blk_data_plane_notify(VirtIOBlockDataPlane *s, VirtQueue *vq);



int virtio_blk_data_plane_start(VirtIODevice *vdev);

void virtio_blk_data_plane_stop(VirtIODevice *vdev);



#endif /* HW_DATAPLANE_VIRTIO_BLK_H */

hw/block/virtio-blk.c

+7 −8
Original line number Diff line number Diff line
@@ -611,7 +611,7 @@ static void virtio_blk_handle_output(VirtIODevice *vdev, VirtQueue *vq) 
        /* Some guests kick before setting VIRTIO_CONFIG_S_DRIVER_OK so start

         * dataplane here instead of waiting for .set_status().

         */

        virtio_blk_data_plane_start(s->dataplane);

        virtio_device_start_ioeventfd(vdev);

        if (!s->dataplane_disabled) {

            return;

        }
@@ -687,11 +687,9 @@ static void virtio_blk_reset(VirtIODevice *vdev) 
        virtio_blk_free_request(req);

    }



    if (s->dataplane) {

        virtio_blk_data_plane_stop(s->dataplane);

    }

    aio_context_release(ctx);



    assert(!s->dataplane_started);

    blk_set_enable_write_cache(s->blk, s->original_wce);

}
@@ -789,9 +787,8 @@ static void virtio_blk_set_status(VirtIODevice *vdev, uint8_t status) 
{

    VirtIOBlock *s = VIRTIO_BLK(vdev);



    if (s->dataplane && !(status & (VIRTIO_CONFIG_S_DRIVER |

                                    VIRTIO_CONFIG_S_DRIVER_OK))) {

        virtio_blk_data_plane_stop(s->dataplane);

    if (!(status & (VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_DRIVER_OK))) {

        assert(!s->dataplane_started);

    }



    if (!(status & VIRTIO_CONFIG_S_DRIVER_OK)) {
@@ -919,7 +916,7 @@ static void virtio_blk_device_realize(DeviceState *dev, Error **errp) 
    s->sector_mask = (s->conf.conf.logical_block_size / BDRV_SECTOR_SIZE) - 1;



    for (i = 0; i < conf->num_queues; i++) {

        virtio_add_queue_aio(vdev, 128, virtio_blk_handle_output);

        virtio_add_queue(vdev, 128, virtio_blk_handle_output);

    }

    virtio_blk_data_plane_create(vdev, conf, &s->dataplane, &err);

    if (err != NULL) {
@@ -1002,6 +999,8 @@ static void virtio_blk_class_init(ObjectClass *klass, void *data) 
    vdc->reset = virtio_blk_reset;

    vdc->save = virtio_blk_save_device;

    vdc->load = virtio_blk_load_device;

    vdc->start_ioeventfd = virtio_blk_data_plane_start;

    vdc->stop_ioeventfd = virtio_blk_data_plane_stop;

}



static const TypeInfo virtio_blk_info = {