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

virtio-scsi: 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 1c627137)

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

It detects some errors better:

    $ qemu-system-x86_64 -object iothread,id=io \
          -device virtio-scsi-pci,ioeventfd=off,iothread=io
    qemu-system-x86_64: -device virtio-scsi-pci,ioeventfd=off,iothread=io:
    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 9ffe337c

hw/scsi/virtio-scsi-dataplane.c

+34 −22
Original line number Diff line number Diff line
@@ -12,6 +12,7 @@ 
 */



#include "qemu/osdep.h"

#include "qapi/error.h"

#include "hw/virtio/virtio-scsi.h"

#include "qemu/error-report.h"

#include "sysemu/block-backend.h"
@@ -21,20 +22,30 @@ 
#include "hw/virtio/virtio-access.h"



/* Context: QEMU global mutex held */

void virtio_scsi_set_iothread(VirtIOSCSI *s, IOThread *iothread)

void virtio_scsi_dataplane_setup(VirtIOSCSI *s, Error **errp)

{

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

    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);

    VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);

    VirtIODevice *vdev = VIRTIO_DEVICE(s);

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

    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);



    assert(!s->ctx);

    s->ctx = iothread_get_aio_context(vs->conf.iothread);



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

    if (vs->conf.iothread) {

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

        fprintf(stderr, "virtio-scsi: Failed to set iothread "

            error_setg(errp,

                       "device is incompatible with iothread "

                       "(transport does not support notifiers)");

        exit(1);

            return;

        }

        if (!virtio_device_ioeventfd_enabled(vdev)) {

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

            return;

        }

        s->ctx = iothread_get_aio_context(vs->conf.iothread);

    } else {

        if (!virtio_device_ioeventfd_enabled(vdev)) {

            return;

        }

        s->ctx = qemu_get_aio_context();

    }

}
@@ -105,19 +116,19 @@ static void virtio_scsi_clear_aio(VirtIOSCSI *s) 
}



/* Context: QEMU global mutex held */

void virtio_scsi_dataplane_start(VirtIOSCSI *s)

int virtio_scsi_dataplane_start(VirtIODevice *vdev)

{

    int i;

    int rc;

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

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

    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);

    VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);

    VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);

    VirtIOSCSI *s = VIRTIO_SCSI(vdev);



    if (s->dataplane_started ||

        s->dataplane_starting ||

        s->dataplane_fenced ||

        s->ctx != iothread_get_aio_context(vs->conf.iothread)) {

        return;

        s->dataplane_fenced) {

        return 0;

    }



    s->dataplane_starting = true;
@@ -152,7 +163,7 @@ void virtio_scsi_dataplane_start(VirtIOSCSI *s) 
    s->dataplane_starting = false;

    s->dataplane_started = true;

    aio_context_release(s->ctx);

    return;

    return 0;



fail_vrings:

    virtio_scsi_clear_aio(s);
@@ -165,14 +176,16 @@ fail_guest_notifiers: 
    s->dataplane_fenced = true;

    s->dataplane_starting = false;

    s->dataplane_started = true;

    return -ENOSYS;

}



/* Context: QEMU global mutex held */

void virtio_scsi_dataplane_stop(VirtIOSCSI *s)

void virtio_scsi_dataplane_stop(VirtIODevice *vdev)

{

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

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

    VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);

    VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(s);

    VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);

    VirtIOSCSI *s = VIRTIO_SCSI(vdev);

    int i;



    if (!s->dataplane_started || s->dataplane_stopping) {
@@ -186,7 +199,6 @@ void virtio_scsi_dataplane_stop(VirtIOSCSI *s) 
        return;

    }

    s->dataplane_stopping = true;

    assert(s->ctx == iothread_get_aio_context(vs->conf.iothread));



    aio_context_acquire(s->ctx);

hw/scsi/virtio-scsi.c

+11 −13
Original line number Diff line number Diff line
@@ -434,7 +434,7 @@ static void virtio_scsi_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq) 
    VirtIOSCSI *s = (VirtIOSCSI *)vdev;



    if (s->ctx) {

        virtio_scsi_dataplane_start(s);

        virtio_device_start_ioeventfd(vdev);

        if (!s->dataplane_fenced) {

            return;

        }
@@ -610,7 +610,7 @@ static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq) 
    VirtIOSCSI *s = (VirtIOSCSI *)vdev;



    if (s->ctx) {

        virtio_scsi_dataplane_start(s);

        virtio_device_start_ioeventfd(vdev);

        if (!s->dataplane_fenced) {

            return;

        }
@@ -669,9 +669,7 @@ static void virtio_scsi_reset(VirtIODevice *vdev) 
    VirtIOSCSI *s = VIRTIO_SCSI(vdev);

    VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);



    if (s->ctx) {

        virtio_scsi_dataplane_stop(s);

    }

    assert(!s->dataplane_started);

    s->resetting++;

    qbus_reset_all(&s->bus.qbus);

    s->resetting--;
@@ -749,7 +747,7 @@ static void virtio_scsi_handle_event(VirtIODevice *vdev, VirtQueue *vq) 
    VirtIOSCSI *s = VIRTIO_SCSI(vdev);



    if (s->ctx) {

        virtio_scsi_dataplane_start(s);

        virtio_device_start_ioeventfd(vdev);

        if (!s->dataplane_fenced) {

            return;

        }
@@ -848,14 +846,10 @@ void virtio_scsi_common_realize(DeviceState *dev, Error **errp, 
    s->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE;

    s->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE;



    s->ctrl_vq = virtio_add_queue_aio(vdev, VIRTIO_SCSI_VQ_SIZE, ctrl);

    s->event_vq = virtio_add_queue_aio(vdev, VIRTIO_SCSI_VQ_SIZE, evt);

    s->ctrl_vq = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE, ctrl);

    s->event_vq = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE, evt);

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

        s->cmd_vqs[i] = virtio_add_queue_aio(vdev, VIRTIO_SCSI_VQ_SIZE, cmd);

    }



    if (s->conf.iothread) {

        virtio_scsi_set_iothread(VIRTIO_SCSI(s), s->conf.iothread);

        s->cmd_vqs[i] = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE, cmd);

    }

}
@@ -885,6 +879,8 @@ static void virtio_scsi_device_realize(DeviceState *dev, Error **errp) 
            return;

        }

    }



    virtio_scsi_dataplane_setup(s, errp);

}



static void virtio_scsi_instance_init(Object *obj)
@@ -957,6 +953,8 @@ static void virtio_scsi_class_init(ObjectClass *klass, void *data) 
    vdc->set_config = virtio_scsi_set_config;

    vdc->get_features = virtio_scsi_get_features;

    vdc->reset = virtio_scsi_reset;

    vdc->start_ioeventfd = virtio_scsi_dataplane_start;

    vdc->stop_ioeventfd = virtio_scsi_dataplane_stop;

    hc->plug = virtio_scsi_hotplug;

    hc->unplug = virtio_scsi_hotunplug;

}

include/hw/virtio/virtio-scsi.h

+3 −3
Original line number Diff line number Diff line
@@ -134,9 +134,9 @@ void virtio_scsi_free_req(VirtIOSCSIReq *req); 
void virtio_scsi_push_event(VirtIOSCSI *s, SCSIDevice *dev,

                            uint32_t event, uint32_t reason);



void virtio_scsi_set_iothread(VirtIOSCSI *s, IOThread *iothread);

void virtio_scsi_dataplane_start(VirtIOSCSI *s);

void virtio_scsi_dataplane_stop(VirtIOSCSI *s);

void virtio_scsi_dataplane_setup(VirtIOSCSI *s, Error **errp);

int virtio_scsi_dataplane_start(VirtIODevice *s);

void virtio_scsi_dataplane_stop(VirtIODevice *s);

void virtio_scsi_dataplane_notify(VirtIODevice *vdev, VirtIOSCSIReq *req);



#endif /* QEMU_VIRTIO_SCSI_H */