xemu-project/xemu
1
0
Fork 0
mirror of https://github.com/xemu-project/xemu.git synced 2024-11-28 05:50:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

virtio-mmio: convert to ioeventfd callbacks

Browse Source 
Convert to the new interface.

Signed-off-by: Cornelia Huck <cornelia.huck@de.ibm.com>
Reviewed-by: Fam Zheng <famz@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
This commit is contained in:
Cornelia Huck 2016-06-10 11:04:13 +02:00 committed by Michael S. Tsirkin
parent 9f06e71a56
commit c0971bcb7c
1 changed files with 41 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -93,90 +93,59 @@ typedef struct {
bool ioeventfd_started;
} VirtIOMMIOProxy;
static int virtio_mmio_set_host_notifier_internal(VirtIOMMIOProxy *proxy,
int n, bool assign,
bool set_handler)
static bool virtio_mmio_ioeventfd_started(DeviceState *d)
{
VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
VirtQueue *vq = virtio_get_queue(vdev, n);
EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
int r = 0;
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)
{
VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
return !kvm_eventfds_enabled() || proxy->ioeventfd_disabled;
}
static void virtio_mmio_ioeventfd_set_disabled(DeviceState *d, bool disabled)
{
VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
proxy->ioeventfd_disabled = disabled;
}
static int virtio_mmio_ioeventfd_assign(DeviceState *d,
EventNotifier *notifier,
int n, bool assign)
{
VirtIOMMIOProxy *proxy = VIRTIO_MMIO(d);
if (assign) {
r = event_notifier_init(notifier, 1);
if (r < 0) {
error_report("%s: unable to init event notifier: %d",
__func__, r);
return r;
}
virtio_queue_set_host_notifier_fd_handler(vq, true, set_handler);
memory_region_add_eventfd(&proxy->iomem, VIRTIO_MMIO_QUEUENOTIFY, 4,
true, n, notifier);
} else {
memory_region_del_eventfd(&proxy->iomem, VIRTIO_MMIO_QUEUENOTIFY, 4,
true, n, notifier);
virtio_queue_set_host_notifier_fd_handler(vq, false, false);
event_notifier_cleanup(notifier);
}
return r;
return 0;
}
static void virtio_mmio_start_ioeventfd(VirtIOMMIOProxy *proxy)
{
VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
int n, r;
if (!kvm_eventfds_enabled() ||
proxy->ioeventfd_disabled ||
proxy->ioeventfd_started) {
return;
}
for (n = 0; n < VIRTIO_QUEUE_MAX; n++) {
if (!virtio_queue_get_num(vdev, n)) {
continue;
}
r = virtio_mmio_set_host_notifier_internal(proxy, n, true, true);
if (r < 0) {
goto assign_error;
}
}
proxy->ioeventfd_started = true;
return;
assign_error:
while (--n >= 0) {
if (!virtio_queue_get_num(vdev, n)) {
continue;
}
r = virtio_mmio_set_host_notifier_internal(proxy, n, false, false);
assert(r >= 0);
}
proxy->ioeventfd_started = false;
error_report("%s: failed. Fallback to a userspace (slower).", __func__);
virtio_bus_start_ioeventfd(&proxy->bus);
}
static void virtio_mmio_stop_ioeventfd(VirtIOMMIOProxy *proxy)
{
int r;
int n;
VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
if (!proxy->ioeventfd_started) {
return;
}
for (n = 0; n < VIRTIO_QUEUE_MAX; n++) {
if (!virtio_queue_get_num(vdev, n)) {
continue;
}
r = virtio_mmio_set_host_notifier_internal(proxy, n, false, false);
assert(r >= 0);
}
proxy->ioeventfd_started = false;
virtio_bus_stop_ioeventfd(&proxy->bus);
}
static uint64_t virtio_mmio_read(void *opaque, hwaddr offset, unsigned size)
@ -498,25 +467,6 @@ assign_error:
return r;
}
static int virtio_mmio_set_host_notifier(DeviceState *opaque, int n,
bool assign)
{
VirtIOMMIOProxy *proxy = VIRTIO_MMIO(opaque);
/* Stop using ioeventfd for virtqueue kick if the device starts using host
* notifiers. This makes it easy to avoid stepping on each others' toes.
*/
proxy->ioeventfd_disabled = assign;
if (assign) {
virtio_mmio_stop_ioeventfd(proxy);
}
/* We don't need to start here: it's not needed because backend
* currently only stops on status change away from ok,
* reset, vmstop and such. If we do add code to start here,
* need to check vmstate, device state etc. */
return virtio_mmio_set_host_notifier_internal(proxy, n, assign, false);
}
/* virtio-mmio device */
static void virtio_mmio_realizefn(DeviceState *d, Error **errp)
@ -558,8 +508,12 @@ static void virtio_mmio_bus_class_init(ObjectClass *klass, void *data)
k->notify = virtio_mmio_update_irq;
k->save_config = virtio_mmio_save_config;
k->load_config = virtio_mmio_load_config;
k->set_host_notifier = virtio_mmio_set_host_notifier;
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_set_disabled = virtio_mmio_ioeventfd_set_disabled;
k->ioeventfd_assign = virtio_mmio_ioeventfd_assign;
k->has_variable_vring_alignment = true;
bus_class->max_dev = 1;
}