david.venhoff/QEMU-Nyx-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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 1c627137c10ee2dcf59e0383ade8a9abfa2d4355)

- 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: Cornelia Huck <cornelia.huck@de.ibm.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
This commit is contained in:
Paolo Bonzini 2016-10-21 22:48:10 +02:00 committed by Michael S. Tsirkin
parent 9ffe337c08
commit ad07cd69ec
3 changed files with 48 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
hw/scsi/virtio-scsi-dataplane.c
View File

@ -12,6 +12,7 @@
*/ */
#include "qemu/osdep.h" #include "qemu/osdep.h"
#include "qapi/error.h"
#include "hw/virtio/virtio-scsi.h" #include "hw/virtio/virtio-scsi.h"
#include "qemu/error-report.h" #include "qemu/error-report.h"
#include "sysemu/block-backend.h" #include "sysemu/block-backend.h"
@ -21,20 +22,30 @@
#include "hw/virtio/virtio-access.h" #include "hw/virtio/virtio-access.h"
/* Context: QEMU global mutex held */ /* 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); 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); if (vs->conf.iothread) {
s->ctx = iothread_get_aio_context(vs->conf.iothread);
/* Don't try if transport does not support notifiers. */
if (!k->set_guest_notifiers || !k->ioeventfd_assign) { 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)"); "(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 */ /* Context: QEMU global mutex held */
void virtio_scsi_dataplane_start(VirtIOSCSI *s) int virtio_scsi_dataplane_start(VirtIODevice *vdev)
{ {
int i; int i;
int rc; 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); 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 || if (s->dataplane_started ||
s->dataplane_starting || s->dataplane_starting ||
s->dataplane_fenced || s->dataplane_fenced) {
s->ctx != iothread_get_aio_context(vs->conf.iothread)) { return 0;
return;
} }
s->dataplane_starting = true; s->dataplane_starting = true;
@ -152,7 +163,7 @@ void virtio_scsi_dataplane_start(VirtIOSCSI *s)
s->dataplane_starting = false; s->dataplane_starting = false;
s->dataplane_started = true; s->dataplane_started = true;
aio_context_release(s->ctx); aio_context_release(s->ctx);
return; return 0;
fail_vrings: fail_vrings:
virtio_scsi_clear_aio(s); virtio_scsi_clear_aio(s);
@ -165,14 +176,16 @@ fail_guest_notifiers:
s->dataplane_fenced = true; s->dataplane_fenced = true;
s->dataplane_starting = false; s->dataplane_starting = false;
s->dataplane_started = true; s->dataplane_started = true;
return -ENOSYS;
} }
/* Context: QEMU global mutex held */ /* 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); 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; int i;
if (!s->dataplane_started || s->dataplane_stopping) { if (!s->dataplane_started || s->dataplane_stopping) {
@ -186,7 +199,6 @@ void virtio_scsi_dataplane_stop(VirtIOSCSI *s)
return; return;
} }
s->dataplane_stopping = true; s->dataplane_stopping = true;
assert(s->ctx == iothread_get_aio_context(vs->conf.iothread));
aio_context_acquire(s->ctx); aio_context_acquire(s->ctx);

24
hw/scsi/virtio-scsi.c
View File

@ -434,7 +434,7 @@ static void virtio_scsi_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
VirtIOSCSI *s = (VirtIOSCSI *)vdev; VirtIOSCSI *s = (VirtIOSCSI *)vdev;
if (s->ctx) { if (s->ctx) {
virtio_scsi_dataplane_start(s); virtio_device_start_ioeventfd(vdev);
if (!s->dataplane_fenced) { if (!s->dataplane_fenced) {
return; return;
} }
@ -610,7 +610,7 @@ static void virtio_scsi_handle_cmd(VirtIODevice *vdev, VirtQueue *vq)
VirtIOSCSI *s = (VirtIOSCSI *)vdev; VirtIOSCSI *s = (VirtIOSCSI *)vdev;
if (s->ctx) { if (s->ctx) {
virtio_scsi_dataplane_start(s); virtio_device_start_ioeventfd(vdev);
if (!s->dataplane_fenced) { if (!s->dataplane_fenced) {
return; return;
} }
@ -669,9 +669,7 @@ static void virtio_scsi_reset(VirtIODevice *vdev)
VirtIOSCSI *s = VIRTIO_SCSI(vdev); VirtIOSCSI *s = VIRTIO_SCSI(vdev);
VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev); VirtIOSCSICommon *vs = VIRTIO_SCSI_COMMON(vdev);
if (s->ctx) { assert(!s->dataplane_started);
virtio_scsi_dataplane_stop(s);
}
s->resetting++; s->resetting++;
qbus_reset_all(&s->bus.qbus); qbus_reset_all(&s->bus.qbus);
s->resetting--; s->resetting--;
@ -749,7 +747,7 @@ static void virtio_scsi_handle_event(VirtIODevice *vdev, VirtQueue *vq)
VirtIOSCSI *s = VIRTIO_SCSI(vdev); VirtIOSCSI *s = VIRTIO_SCSI(vdev);
if (s->ctx) { if (s->ctx) {
virtio_scsi_dataplane_start(s); virtio_device_start_ioeventfd(vdev);
if (!s->dataplane_fenced) { if (!s->dataplane_fenced) {
return; return;
} }
@ -848,14 +846,10 @@ void virtio_scsi_common_realize(DeviceState *dev, Error **errp,
s->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE; s->sense_size = VIRTIO_SCSI_SENSE_DEFAULT_SIZE;
s->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE; s->cdb_size = VIRTIO_SCSI_CDB_DEFAULT_SIZE;
s->ctrl_vq = virtio_add_queue_aio(vdev, VIRTIO_SCSI_VQ_SIZE, ctrl); s->ctrl_vq = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE, ctrl);
s->event_vq = virtio_add_queue_aio(vdev, VIRTIO_SCSI_VQ_SIZE, evt); s->event_vq = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE, evt);
for (i = 0; i < s->conf.num_queues; i++) { for (i = 0; i < s->conf.num_queues; i++) {
s->cmd_vqs[i] = virtio_add_queue_aio(vdev, VIRTIO_SCSI_VQ_SIZE, cmd); s->cmd_vqs[i] = virtio_add_queue(vdev, VIRTIO_SCSI_VQ_SIZE, cmd);
}
if (s->conf.iothread) {
virtio_scsi_set_iothread(VIRTIO_SCSI(s), s->conf.iothread);
} }
} }
@ -885,6 +879,8 @@ static void virtio_scsi_device_realize(DeviceState *dev, Error **errp)
return; return;
} }
} }
virtio_scsi_dataplane_setup(s, errp);
} }
static void virtio_scsi_instance_init(Object *obj) 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->set_config = virtio_scsi_set_config;
vdc->get_features = virtio_scsi_get_features; vdc->get_features = virtio_scsi_get_features;
vdc->reset = virtio_scsi_reset; 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->plug = virtio_scsi_hotplug;
hc->unplug = virtio_scsi_hotunplug; hc->unplug = virtio_scsi_hotunplug;
} }

6
include/hw/virtio/virtio-scsi.h
View File

@ -134,9 +134,9 @@ void virtio_scsi_free_req(VirtIOSCSIReq *req);
void virtio_scsi_push_event(VirtIOSCSI *s, SCSIDevice *dev, void virtio_scsi_push_event(VirtIOSCSI *s, SCSIDevice *dev,
uint32_t event, uint32_t reason); uint32_t event, uint32_t reason);
void virtio_scsi_set_iothread(VirtIOSCSI *s, IOThread *iothread); void virtio_scsi_dataplane_setup(VirtIOSCSI *s, Error **errp);
void virtio_scsi_dataplane_start(VirtIOSCSI *s); int virtio_scsi_dataplane_start(VirtIODevice *s);
void virtio_scsi_dataplane_stop(VirtIOSCSI *s); void virtio_scsi_dataplane_stop(VirtIODevice *s);
void virtio_scsi_dataplane_notify(VirtIODevice *vdev, VirtIOSCSIReq *req); void virtio_scsi_dataplane_notify(VirtIODevice *vdev, VirtIOSCSIReq *req);
#endif /* QEMU_VIRTIO_SCSI_H */ #endif /* QEMU_VIRTIO_SCSI_H */