OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

virtio: move ioeventfd_started flag to VirtioBusState 

This simplifies the code and removes the ioeventfd_started
and ioeventfd_set_started callback.  The only difference is
in how virtio-ccw handles an error---it doesn't disable
ioeventfd forever anymore.  It was the only backend to do
so, and if desired this behavior should be implemented in

virtio-bus.c.

Instead of ioeventfd_started, the ioeventfd_assign callback now
determines whether the virtio bus supports host notifiers.

Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
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:06 +02:00 committed by Michael S. Tsirkin
parent 4ddcc2d5cb
commit b13d396227
10 changed files with 16 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
hw/block/dataplane/virtio-blk.c
View File

@ -93,7 +93,7 @@ void virtio_blk_data_plane_create(VirtIODevice *vdev, VirtIOBlkConf *conf,
}
/* Don't try if transport does not support notifiers. */
if (!k->set_guest_notifiers || !k->ioeventfd_started) {
if (!k->set_guest_notifiers || !k->ioeventfd_assign) {
error_setg(errp,
"device is incompatible with dataplane "
"(transport does not support notifiers)");

21
hw/s390x/virtio-ccw.c
View File

@ -59,25 +59,6 @@ static void virtio_ccw_stop_ioeventfd(VirtioCcwDevice *dev)
virtio_bus_stop_ioeventfd(&dev->bus);
}
static bool virtio_ccw_ioeventfd_started(DeviceState *d)
{
VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
return dev->ioeventfd_started;
}
static void virtio_ccw_ioeventfd_set_started(DeviceState *d, bool started,
bool err)
{
VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
dev->ioeventfd_started = started;
if (err) {
/* Disable ioeventfd for this device. */
dev->flags &= ~VIRTIO_CCW_FLAG_USE_IOEVENTFD;
}
}
static bool virtio_ccw_ioeventfd_disabled(DeviceState *d)
{
VirtioCcwDevice *dev = VIRTIO_CCW_DEVICE(d);
@ -1608,8 +1589,6 @@ static void virtio_ccw_bus_class_init(ObjectClass *klass, void *data)
k->pre_plugged = virtio_ccw_pre_plugged;
k->device_plugged = virtio_ccw_device_plugged;
k->device_unplugged = virtio_ccw_device_unplugged;
k->ioeventfd_started = virtio_ccw_ioeventfd_started;
k->ioeventfd_set_started = virtio_ccw_ioeventfd_set_started;
k->ioeventfd_disabled = virtio_ccw_ioeventfd_disabled;
k->ioeventfd_assign = virtio_ccw_ioeventfd_assign;
}

1
hw/s390x/virtio-ccw.h
View File

@ -86,7 +86,6 @@ struct VirtioCcwDevice {
int revision;
uint32_t max_rev;
VirtioBusState bus;
bool ioeventfd_started;
uint32_t flags;
uint8_t thinint_isc;
AdapterRoutes routes;

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

@ -31,7 +31,7 @@ void virtio_scsi_set_iothread(VirtIOSCSI *s, IOThread *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_started) {
if (!k->set_guest_notifiers || !k->ioeventfd_assign) {
fprintf(stderr, "virtio-scsi: Failed to set iothread "
"(transport does not support notifiers)");
exit(1);

2
hw/virtio/vhost.c
View File

@ -1190,7 +1190,7 @@ int vhost_dev_enable_notifiers(struct vhost_dev *hdev, VirtIODevice *vdev)
VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus);
int i, r, e;
if (!k->ioeventfd_started) {
if (!k->ioeventfd_assign) {
error_report("binding does not support host notifiers");
r = -ENOSYS;
goto fail;

14
hw/virtio/virtio-bus.c
View File

@ -192,10 +192,10 @@ void virtio_bus_start_ioeventfd(VirtioBusState *bus)
VirtIODevice *vdev;
int n, r;
if (!k->ioeventfd_started || k->ioeventfd_started(proxy)) {
if (!k->ioeventfd_assign || k->ioeventfd_disabled(proxy)) {
return;
}
if (bus->ioeventfd_disabled || k->ioeventfd_disabled(proxy)) {
if (bus->ioeventfd_started || bus->ioeventfd_disabled) {
return;
}
vdev = virtio_bus_get_device(bus);
@ -208,7 +208,7 @@ void virtio_bus_start_ioeventfd(VirtioBusState *bus)
goto assign_error;
}
}
k->ioeventfd_set_started(proxy, true, false);
bus->ioeventfd_started = true;
return;
assign_error:
@ -220,18 +220,16 @@ assign_error:
r = set_host_notifier_internal(proxy, bus, n, false, false);
assert(r >= 0);
}
k->ioeventfd_set_started(proxy, false, true);
error_report("%s: failed. Fallback to userspace (slower).", __func__);
}
void virtio_bus_stop_ioeventfd(VirtioBusState *bus)
{
VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(bus);
DeviceState *proxy = DEVICE(BUS(bus)->parent);
VirtIODevice *vdev;
int n, r;
if (!k->ioeventfd_started || !k->ioeventfd_started(proxy)) {
if (!bus->ioeventfd_started) {
return;
}
vdev = virtio_bus_get_device(bus);
@ -242,7 +240,7 @@ void virtio_bus_stop_ioeventfd(VirtioBusState *bus)
r = set_host_notifier_internal(proxy, bus, n, false, false);
assert(r >= 0);
}
k->ioeventfd_set_started(proxy, false, false);
bus->ioeventfd_started = false;
}
/*
@ -254,7 +252,7 @@ int virtio_bus_set_host_notifier(VirtioBusState *bus, int n, bool assign)
VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(bus);
DeviceState *proxy = DEVICE(BUS(bus)->parent);
if (!k->ioeventfd_started) {
if (!k->ioeventfd_assign) {
return -ENOSYS;
}
bus->ioeventfd_disabled = assign;

18
hw/virtio/virtio-mmio.c
View File

@ -89,25 +89,9 @@ typedef struct {
uint32_t guest_page_shift;
/* virtio-bus */
VirtioBusState bus;
bool ioeventfd_started;
bool format_transport_address;
} VirtIOMMIOProxy;
static bool virtio_mmio_ioeventfd_started(DeviceState *d)
{
VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
return proxy->ioeventfd_started;
}
static void virtio_mmio_ioeventfd_set_started(DeviceState *d, bool started,
bool err)
{
VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
proxy->ioeventfd_started = started;
}
static bool virtio_mmio_ioeventfd_disabled(DeviceState *d)
{
return !kvm_eventfds_enabled();
@ -547,8 +531,6 @@ static void virtio_mmio_bus_class_init(ObjectClass *klass, void *data)
k->save_config = virtio_mmio_save_config;
k->load_config = virtio_mmio_load_config;
k->set_guest_notifiers = virtio_mmio_set_guest_notifiers;
k->ioeventfd_started = virtio_mmio_ioeventfd_started;
k->ioeventfd_set_started = virtio_mmio_ioeventfd_set_started;
k->ioeventfd_disabled = virtio_mmio_ioeventfd_disabled;
k->ioeventfd_assign = virtio_mmio_ioeventfd_assign;
k->has_variable_vring_alignment = true;

17
hw/virtio/virtio-pci.c
View File

@ -262,21 +262,6 @@ static int virtio_pci_load_queue(DeviceState *d, int n, QEMUFile *f)
return 0;
}
static bool virtio_pci_ioeventfd_started(DeviceState *d)
{
VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
return proxy->ioeventfd_started;
}
static void virtio_pci_ioeventfd_set_started(DeviceState *d, bool started,
bool err)
{
VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
proxy->ioeventfd_started = started;
}
static bool virtio_pci_ioeventfd_disabled(DeviceState *d)
{
VirtIOPCIProxy *proxy = to_virtio_pci_proxy(d);
@ -2531,8 +2516,6 @@ static void virtio_pci_bus_class_init(ObjectClass *klass, void *data)
k->device_plugged = virtio_pci_device_plugged;
k->device_unplugged = virtio_pci_device_unplugged;
k->query_nvectors = virtio_pci_query_nvectors;
k->ioeventfd_started = virtio_pci_ioeventfd_started;
k->ioeventfd_set_started = virtio_pci_ioeventfd_set_started;
k->ioeventfd_disabled = virtio_pci_ioeventfd_disabled;
k->ioeventfd_assign = virtio_pci_ioeventfd_assign;
}

1
hw/virtio/virtio-pci.h
View File

@ -158,7 +158,6 @@ struct VirtIOPCIProxy {
uint32_t guest_features[2];
VirtIOPCIQueue vqs[VIRTIO_QUEUE_MAX];
bool ioeventfd_started;
VirtIOIRQFD *vector_irqfd;
int nvqs_with_notifiers;
VirtioBusState bus;

17
include/hw/virtio/virtio-bus.h
View File

@ -70,17 +70,9 @@ typedef struct VirtioBusClass {
void (*device_unplugged)(DeviceState *d);
int (*query_nvectors)(DeviceState *d);
/*
* ioeventfd handling: if the transport implements ioeventfd_started,
* it must implement the other ioeventfd callbacks as well
* ioeventfd handling: if the transport implements ioeventfd_assign,
* it must implement ioeventfd_disabled as well.
*/
/* Returns true if the ioeventfd has been started for the device. */
bool (*ioeventfd_started)(DeviceState *d);
/*
* Sets the 'ioeventfd started' state after the ioeventfd has been
* started/stopped for the device. err signifies whether an error
* had occurred.
*/
void (*ioeventfd_set_started)(DeviceState *d, bool started, bool err);
/* Returns true if the ioeventfd has been disabled for the device. */
bool (*ioeventfd_disabled)(DeviceState *d);
/*
@ -106,6 +98,11 @@ struct VirtioBusState {
* or dataplane.
*/
bool ioeventfd_disabled;
/*
* Set if ioeventfd has been started.
*/
bool ioeventfd_started;
};
void virtio_bus_device_plugged(VirtIODevice *vdev, Error **errp);