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: Asias He <asias.hejun@gmail.com>
Signed-off-by: Pekka Enberg <penberg@kernel.org>

diff --git a/tools/kvm/Makefile b/tools/kvm/Makefile
index 0a9c2ccfc000a6a0f6a7d3039321e03a186bbb6c..38d4788b113af3dd490367dab4bfec4992ab3a31 100644 (file)
--- a/tools/kvm/Makefile
+++ b/tools/kvm/Makefile
@@ -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

diff --git a/tools/kvm/include/kvm/virtio-9p.h b/tools/kvm/include/kvm/virtio-9p.h
index ac3dc45976b421d3cc53a480e3a59e663f7038ac..fdf676c413f70bdc61db03af94f2d38cb94d1e4f 100644 (file)
--- a/tools/kvm/include/kvm/virtio-9p.h
+++ b/tools/kvm/include/kvm/virtio-9p.h
@@ -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;

diff --git a/tools/kvm/include/kvm/virtio-pci.h b/tools/kvm/include/kvm/virtio-pci.h
index 7133314b8b3a3670869a42e6e5c15bcdfe8548d0..9e036b24ed9700446835cd36b2a1f3431d8eb1db 100644 (file)
--- a/tools/kvm/include/kvm/virtio-pci.h
+++ b/tools/kvm/include/kvm/virtio-pci.h
@@ -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

diff --git a/tools/kvm/include/kvm/virtio-trans.h b/tools/kvm/include/kvm/virtio-trans.h
deleted file mode 100644 (file)
index f2e433f..0000000
--- a/tools/kvm/include/kvm/virtio-trans.h
+++ /dev/null
@@ -1,44 +0,0 @@
-#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

diff --git a/tools/kvm/include/kvm/virtio.h b/tools/kvm/include/kvm/virtio.h
index 610f4d00fd68331d0ea45790e0e2bdb255698c00..db2a86e35415cd6659f788e019c4af913ba71cc6 100644 (file)
--- a/tools/kvm/include/kvm/virtio.h
+++ b/tools/kvm/include/kvm/virtio.h
@@ -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 */

diff --git a/tools/kvm/virtio/9p.c b/tools/kvm/virtio/9p.c
index 28f5ed794b28bcc60592f3a4b1341bb85d585a58..fd6cf54363c394911089be65d892c6a4937c9071 100644 (file)
--- a/tools/kvm/virtio/9p.c
+++ b/tools/kvm/virtio/9p.c
@@ -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;

diff --git a/tools/kvm/virtio/balloon.c b/tools/kvm/virtio/balloon.c
index 09044d0eb0e9b5432eeaf987f24e784699dc8412..45bd8d342e78e7c116eb7e6841b773d95d7c262a 100644 (file)
--- a/tools/kvm/virtio/balloon.c
+++ b/tools/kvm/virtio/balloon.c
@@ -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",

diff --git a/tools/kvm/virtio/blk.c b/tools/kvm/virtio/blk.c
index c230dd463475a3dbecbd28859a0b5c0094377f7b..f3cb6cf1087603127277f43ef6e3d2e6f7a68c1d 100644 (file)
--- a/tools/kvm/virtio/blk.c
+++ b/tools/kvm/virtio/blk.c
@@ -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);
 

diff --git a/tools/kvm/virtio/console.c b/tools/kvm/virtio/console.c
index 245cebb72edd9b35cf682ed598e63a2cfb37ae4c..173c312c950bb01b0c48798f2af794f030ba6914 100644 (file)
--- a/tools/kvm/virtio/console.c
+++ b/tools/kvm/virtio/console.c
@@ -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, "

diff --git a/tools/kvm/virtio/core.c b/tools/kvm/virtio/core.c
index c68572cf02d7143e178b7d50a14c6e10bc361f5f..20b90be9154f4f8f14c15967b9ba591331c39708 100644 (file)
--- a/tools/kvm/virtio/core.c
+++ b/tools/kvm/virtio/core.c
@@ -1,11 +1,14 @@
 #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;
+}

diff --git a/tools/kvm/virtio/net.c b/tools/kvm/virtio/net.c
index 5e297089f09376609d772dc29a6c89fecc4f4a1f..33bf6238e81a9c6b8bd52d537ca692ea7199ed59 100644 (file)
--- a/tools/kvm/virtio/net.c
+++ b/tools/kvm/virtio/net.c
@@ -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);

diff --git a/tools/kvm/virtio/pci.c b/tools/kvm/virtio/pci.c
index 529e30dbd73e272c6a6ed0595b85cc7c74451784..bdc09f5cfb256a9cbc1f3de60cd8828ec63d4743 100644 (file)
--- a/tools/kvm/virtio/pci.c
+++ b/tools/kvm/virtio/pci.c
@@ -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;
 }
 
-int virtio_pci__signal_config(struct kvm *kvm, struct virtio_trans *vtrans)
+int virtio_pci__signal_config(struct kvm *kvm, struct virtio_device *vdev)
 {
-       struct virtio_pci *vpci = vtrans->virtio;
+       struct virtio_pci *vpci = vdev->virtio;
        int tbl = vpci->config_vector;
 
        if (virtio_pci__msix_enabled(vpci)) {
@@ -283,22 +271,23 @@ int virtio_pci__signal_config(struct kvm *kvm, struct virtio_trans *vtrans)
        return 0;
 }
 
-int virtio_pci__init(struct kvm *kvm, struct virtio_trans *vtrans, void *dev,
-                       int device_id, int subsys_id, int class)
+int virtio_pci__init(struct kvm *kvm, void *dev, struct virtio_device *vdev,
+                    int device_id, int subsys_id, int class)
 {
-       struct virtio_pci *vpci = vtrans->virtio;
+       struct virtio_pci *vpci = vdev->virtio;
        u8 pin, line, ndev;
        int r;
 
        vpci->dev = dev;
        vpci->msix_io_block = pci_get_io_space_block(PCI_IO_SIZE * 2);
 
-       r = ioport__register(IOPORT_EMPTY, &virtio_pci__io_ops, IOPORT_SIZE, vtrans);
+       r = ioport__register(IOPORT_EMPTY, &virtio_pci__io_ops, IOPORT_SIZE, vdev);
        if (r < 0)
                return r;
 
        vpci->base_addr = (u16)r;
-       r = kvm__register_mmio(kvm, vpci->msix_io_block, PCI_IO_SIZE, false, callback_mmio_table, vpci);
+       r = kvm__register_mmio(kvm, vpci->msix_io_block, PCI_IO_SIZE, false,
+                              callback_mmio_table, vpci);
        if (r < 0)
                goto free_ioport;
 
@@ -365,9 +354,9 @@ free_ioport:
        return r;
 }
 
-int virtio_pci__exit(struct kvm *kvm, struct virtio_trans *vtrans)
+int virtio_pci__exit(struct kvm *kvm, struct virtio_device *vdev)
 {
-       struct virtio_pci *vpci = vtrans->virtio;
+       struct virtio_pci *vpci = vdev->virtio;
        int i;
 
        kvm__deregister_mmio(kvm, vpci->msix_io_block);
@@ -377,4 +366,4 @@ int virtio_pci__exit(struct kvm *kvm, struct virtio_trans *vtrans)
                ioeventfd__del_event(vpci->base_addr + VIRTIO_PCI_QUEUE_NOTIFY, i);
 
        return 0;
-}
\ No newline at end of file
+}

diff --git a/tools/kvm/virtio/rng.c b/tools/kvm/virtio/rng.c
index a942ebdd7f137327d9d74e93dadd90b014be0fa6..105a4298406c8b6409d6dd4f2b6d9c3f6a46e961 100644 (file)
--- a/tools/kvm/virtio/rng.c
+++ b/tools/kvm/virtio/rng.c
@@ -7,7 +7,6 @@
 #include "kvm/kvm.h"
 #include "kvm/threadpool.h"
 #include "kvm/guest_compat.h"
-#include "kvm/virtio-trans.h"
 
 #include <linux/virtio_ring.h>
 #include <linux/virtio_rng.h>
@@ -30,7 +29,7 @@ struct rng_dev_job {
 
 struct rng_dev {
        struct list_head        list;
-       struct virtio_trans     vtrans;
+       struct virtio_device    vdev;
 
        int                     fd;
 
@@ -87,7 +86,7 @@ static void virtio_rng_do_io(struct kvm *kvm, void *param)
        while (virt_queue__available(vq))
                virtio_rng_do_io_request(kvm, rdev, vq);
 
-       rdev->vtrans.trans_ops->signal_vq(kvm, &rdev->vtrans, vq - rdev->vqs);
+       rdev->vdev.ops->signal_vq(kvm, &rdev->vdev, vq - rdev->vqs);
 }
 
 static int init_vq(struct kvm *kvm, void *dev, u32 vq, u32 pfn)
@@ -164,14 +163,11 @@ int virtio_rng__init(struct kvm *kvm)
                goto cleanup;
        }
 
-       virtio_trans_init(&rdev->vtrans, VIRTIO_PCI);
-       r = rdev->vtrans.trans_ops->init(kvm, &rdev->vtrans, rdev, PCI_DEVICE_ID_VIRTIO_RNG,
-                                       VIRTIO_ID_RNG, PCI_CLASS_RNG);
+       r = virtio_init(kvm, rdev, &rdev->vdev, &rng_dev_virtio_ops,
+                       VIRTIO_PCI, PCI_DEVICE_ID_VIRTIO_RNG, VIRTIO_ID_RNG, PCI_CLASS_RNG);
        if (r < 0)
                goto cleanup;
 
-       rdev->vtrans.virtio_ops = &rng_dev_virtio_ops;
-
        list_add_tail(&rdev->list, &rdevs);
 
        if (compat_id != -1)
@@ -195,7 +191,7 @@ int virtio_rng__exit(struct kvm *kvm)
 
        list_for_each_entry_safe(rdev, tmp, &rdevs, list) {
                list_del(&rdev->list);
-               rdev->vtrans.trans_ops->uninit(kvm, &rdev->vtrans);
+               rdev->vdev.ops->exit(kvm, &rdev->vdev);
                free(rdev);
        }
 

diff --git a/tools/kvm/virtio/trans.c b/tools/kvm/virtio/trans.c
deleted file mode 100644 (file)
index cd4fc7e..0000000
--- a/tools/kvm/virtio/trans.c
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "kvm/virtio-trans.h"
-
-#include "kvm/virtio-pci.h"
-#include "kvm/util.h"
-
-#include <stdlib.h>
-
-int virtio_trans_init(struct virtio_trans *vtrans, enum virtio_trans_type type)
-{
-       void *trans;
-
-       switch (type) {
-       case VIRTIO_PCI:
-               trans = calloc(sizeof(struct virtio_pci), 1);
-               if (!trans)
-                       return -ENOMEM;
-               vtrans->virtio = trans;
-               vtrans->trans_ops = virtio_pci__get_trans_ops();
-       default:
-               return -1;
-       };
-
-       return 0;
-}
\ No newline at end of file