Commit 02eca50c authored by Asias He's avatar Asias He Committed by Will Deacon
Browse files

kvm tools: Rework on virtio transport abstraction.



This patch reworks on virtio transport abstraction.

* Move virtio transport operations to virtio operations and drop
  virtio/trans.c This makes the abstraction much cleaner.

* Rename struct virtio_trans to struct virtio_device

  struct virtio_trans {
       void                    *virtio;
       enum virtio_trans_type  type;
       struct virtio_trans_ops *trans_ops;
       struct virtio_ops       *virtio_ops;
  };

  struct virtio_device {
       void                    *virtio;
       struct virtio_ops       *ops;
  };

  The virtio_trans struct is bit confusing since it also includes virtio
  operations.

* Introduce virtio_init()
  To init device, e.g.
  Before:
	virtio_trans_init()
	ndev->vtrans.trans_ops->init()
	ndev->vtrans.virtio_ops = &net_dev_virtio_ops
  After:
	virtio_init()

Signed-off-by: default avatarAsias He <asias.hejun@gmail.com>
Signed-off-by: default avatarPekka Enberg <penberg@kernel.org>
parent 9ff91339
......@@ -59,7 +59,6 @@ OBJS += virtio/net.o
OBJS += virtio/rng.o
OBJS += virtio/balloon.o
OBJS += virtio/pci.o
OBJS += virtio/trans.o
OBJS += disk/blk.o
OBJS += disk/qcow.o
OBJS += disk/raw.o
......
......@@ -3,7 +3,6 @@
#include "kvm/virtio.h"
#include "kvm/pci.h"
#include "kvm/threadpool.h"
#include "kvm/virtio-trans.h"
#include <sys/types.h>
#include <dirent.h>
......@@ -42,7 +41,7 @@ struct p9_dev_job {
struct p9_dev {
struct list_head list;
struct virtio_trans vtrans;
struct virtio_device vdev;
struct virtio_9p_config *config;
u32 features;
......
......@@ -2,7 +2,6 @@
#define KVM__VIRTIO_PCI_H
#include "kvm/pci.h"
#include "kvm/virtio-trans.h"
#include <linux/types.h>
......@@ -12,7 +11,7 @@
struct kvm;
struct virtio_pci_ioevent_param {
struct virtio_trans *vtrans;
struct virtio_device *vdev;
u32 vq;
};
......@@ -38,12 +37,10 @@ struct virtio_pci {
struct virtio_pci_ioevent_param ioeventfds[VIRTIO_PCI_MAX_VQ];
};
int virtio_pci__init(struct kvm *kvm, struct virtio_trans *vtrans, void *dev,
int device_id, int subsys_id, int class);
int virtio_pci__exit(struct kvm *kvm, struct virtio_trans *vtrans);
int virtio_pci__signal_vq(struct kvm *kvm, struct virtio_trans *vtrans, u32 vq);
int virtio_pci__signal_config(struct kvm *kvm, struct virtio_trans *vtrans);
struct virtio_trans_ops *virtio_pci__get_trans_ops(void);
int virtio_pci__signal_vq(struct kvm *kvm, struct virtio_device *vdev, u32 vq);
int virtio_pci__signal_config(struct kvm *kvm, struct virtio_device *vdev);
int virtio_pci__exit(struct kvm *kvm, struct virtio_device *vdev);
int virtio_pci__init(struct kvm *kvm, void *dev, struct virtio_device *vdev,
int device_id, int subsys_id, int class);
#endif
#ifndef KVM__VIRTIO_TRANS_H
#define KVM__VIRTIO_TRANS_H
#include "kvm/kvm.h"
enum virtio_trans_type {
VIRTIO_PCI,
};
struct virtio_trans;
struct virtio_ops {
void (*set_config)(struct kvm *kvm, void *dev, u8 data, u32 offset);
u8 (*get_config)(struct kvm *kvm, void *dev, u32 offset);
u32 (*get_host_features)(struct kvm *kvm, void *dev);
void (*set_guest_features)(struct kvm *kvm, void *dev, u32 features);
int (*init_vq)(struct kvm *kvm, void *dev, u32 vq, u32 pfn);
int (*notify_vq)(struct kvm *kvm, void *dev, u32 vq);
int (*get_pfn_vq)(struct kvm *kvm, void *dev, u32 vq);
int (*get_size_vq)(struct kvm *kvm, void *dev, u32 vq);
void (*notify_vq_gsi)(struct kvm *kvm, void *dev, u32 vq, u32 gsi);
void (*notify_vq_eventfd)(struct kvm *kvm, void *dev, u32 vq, u32 efd);
};
struct virtio_trans_ops {
int (*init)(struct kvm *kvm, struct virtio_trans *vtrans, void *dev, int device_id,
int subsys_id, int class);
int (*uninit)(struct kvm *kvm, struct virtio_trans *vtrans);
int (*signal_vq)(struct kvm *kvm, struct virtio_trans *virtio_trans, u32 queueid);
int (*signal_config)(struct kvm *kvm, struct virtio_trans *virtio_trans);
};
struct virtio_trans {
void *virtio;
enum virtio_trans_type type;
struct virtio_trans_ops *trans_ops;
struct virtio_ops *virtio_ops;
};
int virtio_trans_init(struct virtio_trans *vtrans, enum virtio_trans_type type);
#endif
\ No newline at end of file
......@@ -64,4 +64,36 @@ u16 virt_queue__get_inout_iov(struct kvm *kvm, struct virt_queue *queue,
u16 *in, u16 *out);
int virtio__get_dev_specific_field(int offset, bool msix, u32 *config_off);
enum virtio_trans {
VIRTIO_PCI,
VIRTIO_MMIO,
};
struct virtio_device {
void *virtio;
struct virtio_ops *ops;
};
struct virtio_ops {
void (*set_config)(struct kvm *kvm, void *dev, u8 data, u32 offset);
u8 (*get_config)(struct kvm *kvm, void *dev, u32 offset);
u32 (*get_host_features)(struct kvm *kvm, void *dev);
void (*set_guest_features)(struct kvm *kvm, void *dev, u32 features);
int (*init_vq)(struct kvm *kvm, void *dev, u32 vq, u32 pfn);
int (*notify_vq)(struct kvm *kvm, void *dev, u32 vq);
int (*get_pfn_vq)(struct kvm *kvm, void *dev, u32 vq);
int (*get_size_vq)(struct kvm *kvm, void *dev, u32 vq);
int (*set_size_vq)(struct kvm *kvm, void *dev, u32 vq, int size);
void (*notify_vq_gsi)(struct kvm *kvm, void *dev, u32 vq, u32 gsi);
void (*notify_vq_eventfd)(struct kvm *kvm, void *dev, u32 vq, u32 efd);
int (*signal_vq)(struct kvm *kvm, struct virtio_device *vdev, u32 queueid);
int (*signal_config)(struct kvm *kvm, struct virtio_device *vdev);
int (*init)(struct kvm *kvm, void *dev, struct virtio_device *vdev,
int device_id, int subsys_id, int class);
int (*exit)(struct kvm *kvm, struct virtio_device *vdev);
};
int virtio_init(struct kvm *kvm, void *dev, struct virtio_device *vdev,
struct virtio_ops *ops, enum virtio_trans trans,
int device_id, int subsys_id, int class);
#endif /* KVM__VIRTIO_H */
......@@ -1168,7 +1168,7 @@ static void virtio_p9_do_io(struct kvm *kvm, void *param)
while (virt_queue__available(vq)) {
virtio_p9_do_io_request(kvm, job);
p9dev->vtrans.trans_ops->signal_vq(kvm, &p9dev->vtrans, vq - p9dev->vqs);
p9dev->vdev.ops->signal_vq(kvm, &p9dev->vdev, vq - p9dev->vqs);
}
}
......@@ -1260,10 +1260,8 @@ int virtio_9p__init(struct kvm *kvm)
struct p9_dev *p9dev;
list_for_each_entry(p9dev, &devs, list) {
virtio_trans_init(&p9dev->vtrans, VIRTIO_PCI);
p9dev->vtrans.trans_ops->init(kvm, &p9dev->vtrans, p9dev,
PCI_DEVICE_ID_VIRTIO_P9, VIRTIO_ID_9P, PCI_CLASS_P9);
p9dev->vtrans.virtio_ops = &p9_dev_virtio_ops;
virtio_init(kvm, p9dev, &p9dev->vdev, &p9_dev_virtio_ops,
VIRTIO_PCI, PCI_DEVICE_ID_VIRTIO_P9, VIRTIO_ID_9P, PCI_CLASS_P9);
}
return 0;
......
......@@ -8,7 +8,6 @@
#include "kvm/pci.h"
#include "kvm/threadpool.h"
#include "kvm/guest_compat.h"
#include "kvm/virtio-trans.h"
#include "kvm/kvm-ipc.h"
#include <linux/virtio_ring.h>
......@@ -31,7 +30,7 @@
struct bln_dev {
struct list_head list;
struct virtio_trans vtrans;
struct virtio_device vdev;
u32 features;
......@@ -116,13 +115,13 @@ static void virtio_bln_do_io(struct kvm *kvm, void *param)
if (vq == &bdev.vqs[VIRTIO_BLN_STATS]) {
virtio_bln_do_stat_request(kvm, &bdev, vq);
bdev.vtrans.trans_ops->signal_vq(kvm, &bdev.vtrans, VIRTIO_BLN_STATS);
bdev.vdev.ops->signal_vq(kvm, &bdev.vdev, VIRTIO_BLN_STATS);
return;
}
while (virt_queue__available(vq)) {
virtio_bln_do_io_request(kvm, &bdev, vq);
bdev.vtrans.trans_ops->signal_vq(kvm, &bdev.vtrans, vq - bdev.vqs);
bdev.vdev.ops->signal_vq(kvm, &bdev.vdev, vq - bdev.vqs);
}
}
......@@ -132,7 +131,7 @@ static int virtio_bln__collect_stats(void)
virt_queue__set_used_elem(&bdev.vqs[VIRTIO_BLN_STATS], bdev.cur_stat_head,
sizeof(struct virtio_balloon_stat));
bdev.vtrans.trans_ops->signal_vq(kvm, &bdev.vtrans, VIRTIO_BLN_STATS);
bdev.vdev.ops->signal_vq(kvm, &bdev.vdev, VIRTIO_BLN_STATS);
if (read(bdev.stat_waitfd, &tmp, sizeof(tmp)) <= 0)
return -EFAULT;
......@@ -173,7 +172,7 @@ static void handle_mem(int fd, u32 type, u32 len, u8 *msg)
}
/* Notify that the configuration space has changed */
bdev.vtrans.trans_ops->signal_config(kvm, &bdev.vtrans);
bdev.vdev.ops->signal_config(kvm, &bdev.vdev);
}
static void set_config(struct kvm *kvm, void *dev, u8 data, u32 offset)
......@@ -260,10 +259,8 @@ void virtio_bln__init(struct kvm *kvm)
bdev.stat_waitfd = eventfd(0, 0);
memset(&bdev.config, 0, sizeof(struct virtio_balloon_config));
virtio_trans_init(&bdev.vtrans, VIRTIO_PCI);
bdev.vtrans.trans_ops->init(kvm, &bdev.vtrans, &bdev, PCI_DEVICE_ID_VIRTIO_BLN,
VIRTIO_ID_BALLOON, PCI_CLASS_BLN);
bdev.vtrans.virtio_ops = &bln_dev_virtio_ops;
virtio_init(kvm, &bdev, &bdev.vdev, &bln_dev_virtio_ops,
VIRTIO_PCI, PCI_DEVICE_ID_VIRTIO_BLN, VIRTIO_ID_BALLOON, PCI_CLASS_BLN);
if (compat_id != -1)
compat_id = compat__add_message("virtio-balloon device was not detected",
......
......@@ -11,7 +11,6 @@
#include "kvm/guest_compat.h"
#include "kvm/virtio-pci.h"
#include "kvm/virtio.h"
#include "kvm/virtio-trans.h"
#include <linux/virtio_ring.h>
#include <linux/virtio_blk.h>
......@@ -44,7 +43,7 @@ struct blk_dev {
struct list_head list;
struct list_head req_list;
struct virtio_trans vtrans;
struct virtio_device vdev;
struct virtio_blk_config blk_config;
struct disk_image *disk;
u32 features;
......@@ -72,7 +71,7 @@ void virtio_blk_complete(void *param, long len)
mutex_unlock(&bdev->mutex);
if (virtio_queue__should_signal(&bdev->vqs[queueid]))
bdev->vtrans.trans_ops->signal_vq(req->kvm, &bdev->vtrans, queueid);
bdev->vdev.ops->signal_vq(req->kvm, &bdev->vdev, queueid);
}
static void virtio_blk_do_io_request(struct kvm *kvm, struct blk_dev_req *req)
......@@ -230,10 +229,8 @@ static int virtio_blk__init_one(struct kvm *kvm, struct disk_image *disk)
},
};
virtio_trans_init(&bdev->vtrans, VIRTIO_PCI);
bdev->vtrans.trans_ops->init(kvm, &bdev->vtrans, bdev, PCI_DEVICE_ID_VIRTIO_BLK,
VIRTIO_ID_BLOCK, PCI_CLASS_BLK);
bdev->vtrans.virtio_ops = &blk_dev_virtio_ops;
virtio_init(kvm, bdev, &bdev->vdev, &blk_dev_virtio_ops,
VIRTIO_PCI, PCI_DEVICE_ID_VIRTIO_BLK, VIRTIO_ID_BLOCK, PCI_CLASS_BLK);
list_add_tail(&bdev->list, &bdevs);
......
......@@ -11,7 +11,6 @@
#include "kvm/threadpool.h"
#include "kvm/irq.h"
#include "kvm/guest_compat.h"
#include "kvm/virtio-trans.h"
#include <linux/virtio_console.h>
#include <linux/virtio_ring.h>
......@@ -32,7 +31,7 @@
struct con_dev {
pthread_mutex_t mutex;
struct virtio_trans vtrans;
struct virtio_device vdev;
struct virt_queue vqs[VIRTIO_CONSOLE_NUM_QUEUES];
struct virtio_console_config config;
u32 features;
......@@ -71,7 +70,7 @@ static void virtio_console__inject_interrupt_callback(struct kvm *kvm, void *par
head = virt_queue__get_iov(vq, iov, &out, &in, kvm);
len = term_getc_iov(CONSOLE_VIRTIO, iov, in, 0);
virt_queue__set_used_elem(vq, head, len);
cdev.vtrans.trans_ops->signal_vq(kvm, &cdev.vtrans, vq - cdev.vqs);
cdev.vdev.ops->signal_vq(kvm, &cdev.vdev, vq - cdev.vqs);
}
mutex_unlock(&cdev.mutex);
......@@ -187,12 +186,8 @@ static struct virtio_ops con_dev_virtio_ops = (struct virtio_ops) {
void virtio_console__init(struct kvm *kvm)
{
virtio_trans_init(&cdev.vtrans, VIRTIO_PCI);
cdev.vtrans.trans_ops->init(kvm, &cdev.vtrans, &cdev, PCI_DEVICE_ID_VIRTIO_CONSOLE,
VIRTIO_ID_CONSOLE, PCI_CLASS_CONSOLE);
cdev.vtrans.virtio_ops = &con_dev_virtio_ops;
virtio_init(kvm, &cdev, &cdev.vdev, &con_dev_virtio_ops,
VIRTIO_PCI, PCI_DEVICE_ID_VIRTIO_CONSOLE, VIRTIO_ID_CONSOLE, PCI_CLASS_CONSOLE);
if (compat_id != -1)
compat_id = compat__add_message("virtio-console device was not detected",
"While you have requested a virtio-console device, "
......
#include <linux/virtio_ring.h>
#include <linux/types.h>
#include <sys/uio.h>
#include <stdlib.h>
#include "kvm/barrier.h"
#include "kvm/kvm.h"
#include "kvm/virtio.h"
#include "kvm/virtio-pci.h"
#include "kvm/util.h"
#include "kvm/kvm.h"
struct vring_used_elem *virt_queue__set_used_elem(struct virt_queue *queue, u32 head, u32 len)
{
......@@ -156,3 +159,29 @@ bool virtio_queue__should_signal(struct virt_queue *vq)
return false;
}
int virtio_init(struct kvm *kvm, void *dev, struct virtio_device *vdev,
struct virtio_ops *ops, enum virtio_trans trans,
int device_id, int subsys_id, int class)
{
void *virtio;
switch (trans) {
case VIRTIO_PCI:
virtio = calloc(sizeof(struct virtio_pci), 1);
if (!virtio)
return -ENOMEM;
vdev->virtio = virtio;
vdev->ops = ops;
vdev->ops->signal_vq = virtio_pci__signal_vq;
vdev->ops->signal_config = virtio_pci__signal_config;
vdev->ops->init = virtio_pci__init;
vdev->ops->exit = virtio_pci__exit;
vdev->ops->init(kvm, dev, vdev, device_id, subsys_id, class);
break;
default:
return -1;
};
return 0;
}
......@@ -8,7 +8,6 @@
#include "kvm/irq.h"
#include "kvm/uip.h"
#include "kvm/guest_compat.h"
#include "kvm/virtio-trans.h"
#include <linux/vhost.h>
#include <linux/virtio_net.h>
......@@ -43,7 +42,7 @@ struct net_dev_operations {
struct net_dev {
pthread_mutex_t mutex;
struct virtio_trans vtrans;
struct virtio_device vdev;
struct list_head list;
struct virt_queue vqs[VIRTIO_NET_NUM_QUEUES];
......@@ -98,8 +97,8 @@ static void *virtio_net_rx_thread(void *p)
/* We should interrupt guest right now, otherwise latency is huge. */
if (virtio_queue__should_signal(&ndev->vqs[VIRTIO_NET_RX_QUEUE]))
ndev->vtrans.trans_ops->signal_vq(kvm, &ndev->vtrans,
VIRTIO_NET_RX_QUEUE);
ndev->vdev.ops->signal_vq(kvm, &ndev->vdev,
VIRTIO_NET_RX_QUEUE);
}
}
......@@ -134,7 +133,7 @@ static void *virtio_net_tx_thread(void *p)
}
if (virtio_queue__should_signal(&ndev->vqs[VIRTIO_NET_TX_QUEUE]))
ndev->vtrans.trans_ops->signal_vq(kvm, &ndev->vtrans, VIRTIO_NET_TX_QUEUE);
ndev->vdev.ops->signal_vq(kvm, &ndev->vdev, VIRTIO_NET_TX_QUEUE);
}
pthread_exit(NULL);
......@@ -527,10 +526,8 @@ void virtio_net__init(const struct virtio_net_params *params)
ndev->ops = &uip_ops;
}
virtio_trans_init(&ndev->vtrans, VIRTIO_PCI);
ndev->vtrans.trans_ops->init(kvm, &ndev->vtrans, ndev, PCI_DEVICE_ID_VIRTIO_NET,
VIRTIO_ID_NET, PCI_CLASS_NET);
ndev->vtrans.virtio_ops = &net_dev_virtio_ops;
virtio_init(kvm, ndev, &ndev->vdev, &net_dev_virtio_ops,
VIRTIO_PCI, PCI_DEVICE_ID_VIRTIO_NET, VIRTIO_ID_NET, PCI_CLASS_NET);
if (params->vhost)
virtio_net__vhost_init(params->kvm, ndev);
......
......@@ -6,39 +6,27 @@
#include "kvm/irq.h"
#include "kvm/virtio.h"
#include "kvm/ioeventfd.h"
#include "kvm/virtio-trans.h"
#include <linux/virtio_pci.h>
#include <linux/byteorder.h>
#include <string.h>
struct virtio_trans_ops *virtio_pci__get_trans_ops(void)
{
static struct virtio_trans_ops virtio_pci_trans = (struct virtio_trans_ops) {
.signal_vq = virtio_pci__signal_vq,
.signal_config = virtio_pci__signal_config,
.init = virtio_pci__init,
.uninit = virtio_pci__exit,
};
return &virtio_pci_trans;
};
static void virtio_pci__ioevent_callback(struct kvm *kvm, void *param)
{
struct virtio_pci_ioevent_param *ioeventfd = param;
struct virtio_pci *vpci = ioeventfd->vtrans->virtio;
struct virtio_pci *vpci = ioeventfd->vdev->virtio;
ioeventfd->vtrans->virtio_ops->notify_vq(kvm, vpci->dev, ioeventfd->vq);
ioeventfd->vdev->ops->notify_vq(kvm, vpci->dev, ioeventfd->vq);
}
static int virtio_pci__init_ioeventfd(struct kvm *kvm, struct virtio_trans *vtrans, u32 vq)
static int virtio_pci__init_ioeventfd(struct kvm *kvm, struct virtio_device *vdev, u32 vq)
{
struct ioevent ioevent;
struct virtio_pci *vpci = vtrans->virtio;
struct virtio_pci *vpci = vdev->virtio;
int r;
vpci->ioeventfds[vq] = (struct virtio_pci_ioevent_param) {
.vtrans = vtrans,
.vdev = vdev,
.vq = vq,
};
......@@ -56,8 +44,8 @@ static int virtio_pci__init_ioeventfd(struct kvm *kvm, struct virtio_trans *vtra
if (r)
return r;
if (vtrans->virtio_ops->notify_vq_eventfd)
vtrans->virtio_ops->notify_vq_eventfd(kvm, vpci->dev, vq, ioevent.fd);
if (vdev->ops->notify_vq_eventfd)
vdev->ops->notify_vq_eventfd(kvm, vpci->dev, vq, ioevent.fd);
return 0;
}
......@@ -67,11 +55,11 @@ static inline bool virtio_pci__msix_enabled(struct virtio_pci *vpci)
return vpci->pci_hdr.msix.ctrl & cpu_to_le16(PCI_MSIX_FLAGS_ENABLE);
}
static bool virtio_pci__specific_io_in(struct kvm *kvm, struct virtio_trans *vtrans, u16 port,
static bool virtio_pci__specific_io_in(struct kvm *kvm, struct virtio_device *vdev, u16 port,
void *data, int size, int offset)
{
u32 config_offset;
struct virtio_pci *vpci = vtrans->virtio;
struct virtio_pci *vpci = vdev->virtio;
int type = virtio__get_dev_specific_field(offset - 20,
virtio_pci__msix_enabled(vpci),
&config_offset);
......@@ -89,7 +77,7 @@ static bool virtio_pci__specific_io_in(struct kvm *kvm, struct virtio_trans *vtr
} else if (type == VIRTIO_PCI_O_CONFIG) {
u8 cfg;
cfg = vtrans->virtio_ops->get_config(kvm, vpci->dev, config_offset);
cfg = vdev->ops->get_config(kvm, vpci->dev, config_offset);
ioport__write8(data, cfg);
return true;
}
......@@ -101,25 +89,25 @@ static bool virtio_pci__io_in(struct ioport *ioport, struct kvm *kvm, u16 port,
{
unsigned long offset;
bool ret = true;
struct virtio_trans *vtrans;
struct virtio_device *vdev;
struct virtio_pci *vpci;
u32 val;
vtrans = ioport->priv;
vpci = vtrans->virtio;
vdev = ioport->priv;
vpci = vdev->virtio;
offset = port - vpci->base_addr;
switch (offset) {
case VIRTIO_PCI_HOST_FEATURES:
val = vtrans->virtio_ops->get_host_features(kvm, vpci->dev);
val = vdev->ops->get_host_features(kvm, vpci->dev);
ioport__write32(data, val);
break;
case VIRTIO_PCI_QUEUE_PFN:
val = vtrans->virtio_ops->get_pfn_vq(kvm, vpci->dev, vpci->queue_selector);
val = vdev->ops->get_pfn_vq(kvm, vpci->dev, vpci->queue_selector);
ioport__write32(data, val);
break;
case VIRTIO_PCI_QUEUE_NUM:
val = vtrans->virtio_ops->get_size_vq(kvm, vpci->dev, vpci->queue_selector);
val = vdev->ops->get_size_vq(kvm, vpci->dev, vpci->queue_selector);
ioport__write16(data, val);
break;
case VIRTIO_PCI_STATUS:
......@@ -131,17 +119,17 @@ static bool virtio_pci__io_in(struct ioport *ioport, struct kvm *kvm, u16 port,
vpci->isr = VIRTIO_IRQ_LOW;
break;
default:
ret = virtio_pci__specific_io_in(kvm, vtrans, port, data, size, offset);
ret = virtio_pci__specific_io_in(kvm, vdev, port, data, size, offset);
break;
};
return ret;
}
static bool virtio_pci__specific_io_out(struct kvm *kvm, struct virtio_trans *vtrans, u16 port,
static bool virtio_pci__specific_io_out(struct kvm *kvm, struct virtio_device *vdev, u16 port,
void *data, int size, int offset)
{
struct virtio_pci *vpci = vtrans->virtio;
struct virtio_pci *vpci = vdev->virtio;
u32 config_offset, gsi, vec;
int type = virtio__get_dev_specific_field(offset - 20, virtio_pci__msix_enabled(vpci),
&config_offset);
......@@ -159,15 +147,15 @@ static bool virtio_pci__specific_io_out(struct kvm *kvm, struct virtio_trans *vt
gsi = irq__add_msix_route(kvm, &vpci->msix_table[vec].msg);
vpci->gsis[vpci->queue_selector] = gsi;
if (vtrans->virtio_ops->notify_vq_gsi)
vtrans->virtio_ops->notify_vq_gsi(kvm, vpci->dev,
if (vdev->ops->notify_vq_gsi)
vdev->ops->notify_vq_gsi(kvm, vpci->dev,
vpci->queue_selector, gsi);
break;
};
return true;
} else if (type == VIRTIO_PCI_O_CONFIG) {
vtrans->virtio_ops->set_config(kvm, vpci->dev, *(u8 *)data, config_offset);
vdev->ops->set_config(kvm, vpci->dev, *(u8 *)data, config_offset);
return true;
}
......@@ -179,36 +167,36 @@ static bool virtio_pci__io_out(struct ioport *ioport, struct kvm *kvm, u16 port,
{
unsigned long offset;
bool ret = true;
struct virtio_trans *vtrans;
struct virtio_device *vdev;
struct virtio_pci *vpci;
u32 val;
vtrans = ioport->priv;
vpci = vtrans->virtio;
vdev = ioport->priv;
vpci = vdev->virtio;
offset = port - vpci->base_addr;
switch (offset) {
case VIRTIO_PCI_GUEST_FEATURES:
val = ioport__read32(data);
vtrans->virtio_ops->set_guest_features(kvm, vpci->dev, val);
vdev->ops->set_guest_features(kvm, vpci->dev, val);
break;
case VIRTIO_PCI_QUEUE_PFN:
val = ioport__read32(data);
virtio_pci__init_ioeventfd(kvm, vtrans, vpci->queue_selector);
vtrans->virtio_ops->init_vq(kvm, vpci->dev, vpci->queue_selector, val);
virtio_pci__init_ioeventfd(kvm, vdev, vpci->queue_selector);
vdev->ops->init_vq(kvm, vpci->dev, vpci->queue_selector, val);
break;
case VIRTIO_PCI_QUEUE_SEL:
vpci->queue_selector = ioport__read16(data);
break;
case VIRTIO_PCI_QUEUE_NOTIFY:
val = ioport__read16(data);
vtrans->virtio_ops->notify_vq(kvm, vpci->dev, val);
vdev->ops->notify_vq(kvm, vpci->dev, val);
break;
case VIRTIO_PCI_STATUS:
vpci->status = ioport__read8(data);
break;
default:
ret = virtio_pci__specific_io_out(kvm, vtrans, port, data, size, offset);
ret = virtio_pci__specific_io_out(kvm, vdev, port, data, size, offset);
break;
};
......@@ -240,9 +228,9 @@ static void callback_mmio_table(u64 addr, u8 *data, u32 len, u8 is_write, void *
memcpy(data, table + addr - offset, len);
}
int virtio_pci__signal_vq(struct kvm *kvm, struct virtio_trans *vtrans, u32 vq)
int virtio_pci__signal_vq(struct kvm *kvm, struct virtio_device *vdev, u32 vq)
{
struct virtio_pci *vpci = vtrans->virtio;
struct virtio_pci *vpci = vdev->virtio;
int tbl = vpci->vq_vector[vq];
if (virtio_pci__msix_enabled(vpci)) {
......@@ -261,9 +249,9 @@ int virtio_pci__signal_vq(struct kvm *kvm, struct virtio_trans *vtrans, u32 vq)
return 0;
}