ShuriZma
/
xqemu
mirror of https://github.com/xqemu/xqemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

virtio: use standard-headers 

Drop a bunch of code duplicated from virtio_config.h and virtio_ring.h.
This makes us rename event index accessors which conflict,
as reusing the ones from virtio_ring.h isn't trivial.

Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Reviewed-by: Thomas Huth <thuth@linux.vnet.ibm.com>
This commit is contained in:
Michael S. Tsirkin 2015-02-16 22:35:46 +01:00
parent 4fbe0f322d
commit e9600c6ca9
3 changed files with 8 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
hw/9pfs/virtio-9p.h
View File

@ -8,6 +8,7 @@
#include <sys/resource.h> #include <sys/resource.h>
#include <glib.h> #include <glib.h>
#include "hw/virtio/virtio.h" #include "hw/virtio/virtio.h"
#include "hw/virtio/virtio-9p.h"
#include "fsdev/file-op-9p.h" #include "fsdev/file-op-9p.h"
#include "fsdev/virtio-9p-marshal.h" #include "fsdev/virtio-9p-marshal.h"
#include "qemu/thread.h" #include "qemu/thread.h"

23
hw/virtio/virtio.c
View File

@ -155,7 +155,7 @@ static inline uint16_t vring_avail_ring(VirtQueue *vq, int i)
return virtio_lduw_phys(vq->vdev, pa); return virtio_lduw_phys(vq->vdev, pa);
} }
static inline uint16_t vring_used_event(VirtQueue *vq) static inline uint16_t vring_get_used_event(VirtQueue *vq)
{ {
return vring_avail_ring(vq, vq->vring.num); return vring_avail_ring(vq, vq->vring.num);
} }
@ -204,7 +204,7 @@ static inline void vring_used_flags_unset_bit(VirtQueue *vq, int mask)
virtio_stw_phys(vdev, pa, virtio_lduw_phys(vdev, pa) & ~mask); virtio_stw_phys(vdev, pa, virtio_lduw_phys(vdev, pa) & ~mask);
} }
static inline void vring_avail_event(VirtQueue *vq, uint16_t val) static inline void vring_set_avail_event(VirtQueue *vq, uint16_t val)
{ {
hwaddr pa; hwaddr pa;
if (!vq->notification) { if (!vq->notification) {
@ -218,7 +218,7 @@ void virtio_queue_set_notification(VirtQueue *vq, int enable)
{ {
vq->notification = enable; vq->notification = enable;
if (vq->vdev->guest_features & (1 << VIRTIO_RING_F_EVENT_IDX)) { if (vq->vdev->guest_features & (1 << VIRTIO_RING_F_EVENT_IDX)) {
vring_avail_event(vq, vring_avail_idx(vq)); vring_set_avail_event(vq, vring_avail_idx(vq));
} else if (enable) { } else if (enable) {
vring_used_flags_unset_bit(vq, VRING_USED_F_NO_NOTIFY); vring_used_flags_unset_bit(vq, VRING_USED_F_NO_NOTIFY);
} else { } else {
@ -469,7 +469,7 @@ int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem)
i = head = virtqueue_get_head(vq, vq->last_avail_idx++); i = head = virtqueue_get_head(vq, vq->last_avail_idx++);
if (vdev->guest_features & (1 << VIRTIO_RING_F_EVENT_IDX)) { if (vdev->guest_features & (1 << VIRTIO_RING_F_EVENT_IDX)) {
vring_avail_event(vq, vq->last_avail_idx); vring_set_avail_event(vq, vq->last_avail_idx);
} }
if (vring_desc_flags(vdev, desc_pa, i) & VRING_DESC_F_INDIRECT) { if (vring_desc_flags(vdev, desc_pa, i) & VRING_DESC_F_INDIRECT) {
@ -819,19 +819,6 @@ void virtio_irq(VirtQueue *vq)
virtio_notify_vector(vq->vdev, vq->vector); virtio_notify_vector(vq->vdev, vq->vector);
} }
/* Assuming a given event_idx value from the other size, if
* we have just incremented index from old to new_idx,
* should we trigger an event? */
static inline int vring_need_event(uint16_t event, uint16_t new, uint16_t old)
{
/* Note: Xen has similar logic for notification hold-off
* in include/xen/interface/io/ring.h with req_event and req_prod
* corresponding to event_idx + 1 and new respectively.
* Note also that req_event and req_prod in Xen start at 1,
* event indexes in virtio start at 0. */
return (uint16_t)(new - event - 1) < (uint16_t)(new - old);
}
static bool vring_notify(VirtIODevice *vdev, VirtQueue *vq) static bool vring_notify(VirtIODevice *vdev, VirtQueue *vq)
{ {
uint16_t old, new; uint16_t old, new;
@ -852,7 +839,7 @@ static bool vring_notify(VirtIODevice *vdev, VirtQueue *vq)
vq->signalled_used_valid = true; vq->signalled_used_valid = true;
old = vq->signalled_used; old = vq->signalled_used;
new = vq->signalled_used = vring_used_idx(vq); new = vq->signalled_used = vring_used_idx(vq);
return !v || vring_need_event(vring_used_event(vq), new, old); return !v || vring_need_event(vring_get_used_event(vq), new, old);
} }
void virtio_notify(VirtIODevice *vdev, VirtQueue *vq) void virtio_notify(VirtIODevice *vdev, VirtQueue *vq)

48
include/hw/virtio/virtio.h
View File

@ -19,56 +19,12 @@
#include "hw/qdev.h" #include "hw/qdev.h"
#include "sysemu/sysemu.h" #include "sysemu/sysemu.h"
#include "qemu/event_notifier.h" #include "qemu/event_notifier.h"
#ifdef CONFIG_VIRTFS #include "standard-headers/linux/virtio_config.h"
#include "hw/virtio/virtio-9p.h" #include "standard-headers/linux/virtio_ring.h"
#endif
/* from Linux's linux/virtio_config.h */
/* Status byte for guest to report progress, and synchronize features. */
/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
#define VIRTIO_CONFIG_S_ACKNOWLEDGE 1
/* We have found a driver for the device. */
#define VIRTIO_CONFIG_S_DRIVER 2
/* Driver has used its parts of the config, and is happy */
#define VIRTIO_CONFIG_S_DRIVER_OK 4
/* We've given up on this device. */
#define VIRTIO_CONFIG_S_FAILED 0x80
/* Some virtio feature bits (currently bits 28 through 31) are reserved for the
* transport being used (eg. virtio_ring), the rest are per-device feature bits. */
#define VIRTIO_TRANSPORT_F_START 28
#define VIRTIO_TRANSPORT_F_END 32
/* We notify when the ring is completely used, even if the guest is suppressing
* callbacks */
#define VIRTIO_F_NOTIFY_ON_EMPTY 24
/* Can the device handle any descriptor layout? */
#define VIRTIO_F_ANY_LAYOUT 27
/* We support indirect buffer descriptors */
#define VIRTIO_RING_F_INDIRECT_DESC 28
/* The Guest publishes the used index for which it expects an interrupt
* at the end of the avail ring. Host should ignore the avail->flags field. */
/* The Host publishes the avail index for which it expects a kick
* at the end of the used ring. Guest should ignore the used->flags field. */
#define VIRTIO_RING_F_EVENT_IDX 29
/* A guest should never accept this. It implies negotiation is broken. */ /* A guest should never accept this. It implies negotiation is broken. */
#define VIRTIO_F_BAD_FEATURE 30 #define VIRTIO_F_BAD_FEATURE 30
/* from Linux's linux/virtio_ring.h */
/* This marks a buffer as continuing via the next field. */
#define VRING_DESC_F_NEXT 1
/* This marks a buffer as write-only (otherwise read-only). */
#define VRING_DESC_F_WRITE 2
/* This means the buffer contains a list of buffer descriptors. */
#define VRING_DESC_F_INDIRECT 4
/* This means don't notify other side when buffer added. */
#define VRING_USED_F_NO_NOTIFY 1
/* This means don't interrupt guest when buffer consumed. */
#define VRING_AVAIL_F_NO_INTERRUPT 1
struct VirtQueue; struct VirtQueue;
static inline hwaddr vring_align(hwaddr addr, static inline hwaddr vring_align(hwaddr addr,