VMM: Remove the old virtio (XCC)
authorMichael Taufen <mtaufen@gmail.com>
Tue, 3 May 2016 22:06:34 +0000 (15:06 -0700)
committerBarret Rhoden <brho@cs.berkeley.edu>
Fri, 13 May 2016 14:42:56 +0000 (10:42 -0400)
Signed-off-by: Michael Taufen <mtaufen@gmail.com>
Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
18 files changed:
kern/include/ros/virtio_ring.h [deleted file]
user/vmm/include/vmm/virtio.h [deleted file]
user/vmm/include/vmm/virtio_9p.h [deleted file]
user/vmm/include/vmm/virtio_balloon.h [deleted file]
user/vmm/include/vmm/virtio_blk.h [deleted file]
user/vmm/include/vmm/virtio_config.h [deleted file]
user/vmm/include/vmm/virtio_console.h [deleted file]
user/vmm/include/vmm/virtio_ids.h [deleted file]
user/vmm/include/vmm/virtio_input.h [deleted file]
user/vmm/include/vmm/virtio_mmio.h [deleted file]
user/vmm/include/vmm/virtio_net.h [deleted file]
user/vmm/include/vmm/virtio_pci.h [deleted file]
user/vmm/include/vmm/virtio_ring.h [deleted file]
user/vmm/include/vmm/virtio_rng.h [deleted file]
user/vmm/include/vmm/virtio_scsi.h [deleted file]
user/vmm/include/vmm/virtio_types.h [deleted file]
user/vmm/virtio-mmio.c [deleted file]
user/vmm/virtio_ring.c [deleted file]

diff --git a/kern/include/ros/virtio_ring.h b/kern/include/ros/virtio_ring.h
deleted file mode 100644 (file)
index bc5ac14..0000000
+++ /dev/null
@@ -1,160 +0,0 @@
-#pragma once
-
-/* An interface for efficient virtio implementation, currently for use by KVM
- * and lguest, but hopefully others soon.  Do NOT change this since it will
- * break existing servers and clients.
- *
- * This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * Copyright Rusty Russell IBM Corporation 2007. */
-
-/* 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
-
-/* The Host uses this in used->flags to advise the Guest: don't kick me when
- * you add a buffer.  It's unreliable, so it's simply an optimization.  Guest
- * will still kick if it's out of buffers. */
-#define VRING_USED_F_NO_NOTIFY 1
-/* The Guest uses this in avail->flags to advise the Host: don't interrupt me
- * when you consume a buffer.  It's unreliable, so it's simply an
- * optimization.  */
-#define VRING_AVAIL_F_NO_INTERRUPT     1
-
-/* 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
-
-/* Virtio ring descriptors: 16 bytes.  These can chain together via "next". */
-struct vring_desc {
-       /* Address (guest-physical). */
-       uint64_t addr;
-       /* Length. */
-       uint32_t len;
-       /* The flags as indicated above. */
-       uint16_t flags;
-       /* We chain unused descriptors via this, too */
-       uint16_t next;
-};
-
-struct vring_avail {
-       uint16_t flags;
-       uint16_t idx;
-       uint16_t ring[];
-};
-
-/* u32 is used here for ids for padding reasons. */
-struct vring_used_elem {
-       /* Index of start of used descriptor chain. */
-       uint32_t id;
-       /* Total length of the descriptor chain which was used (written to) */
-       uint32_t len;
-};
-
-struct vring_used {
-       uint16_t flags;
-       uint16_t idx;
-       struct vring_used_elem ring[];
-};
-
-struct vring {
-       unsigned int num;
-
-       struct vring_desc *desc;
-
-       struct vring_avail *avail;
-
-       struct vring_used *used;
-};
-
-/* The standard layout for the ring is a continuous chunk of memory which looks
- * like this.  We assume num is a power of 2.
- *
- * struct vring
- * {
- *     // The actual descriptors (16 bytes each)
- *     struct vring_desc desc[num];
- *
- *     // A ring of available descriptor heads with free-running index.
- *     uint16_t avail_flags;
- *     uint16_t avail_idx;
- *     uint16_t available[num];
- *     uint16_t used_event_idx;
- *
- *     // Padding to the next align boundary.
- *     char pad[];
- *
- *     // A ring of used descriptor heads with free-running index.
- *     uint16_t used_flags;
- *     uint16_t used_idx;
- *     struct vring_used_elem used[num];
- *     uint16_t avail_event_idx;
- * };
- */
-/* We publish the used event index at the end of the available ring, and vice
- * versa. They are at the end for backwards compatibility. */
-#define vring_used_event(vr) ((vr)->avail->ring[(vr)->num])
-#define vring_avail_event(vr) (*(uint16_t *)&(vr)->used->ring[(vr)->num])
-
-static inline void vring_init(struct vring *vr, unsigned int num, void *p,
-                             unsigned long align)
-{
-       vr->num = num;
-       vr->desc = p;
-       vr->avail = p + num*sizeof(struct vring_desc);
-       vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + sizeof(uint16_t)
-               + align-1) & ~(align - 1));
-}
-
-static inline unsigned vring_size(unsigned int num, unsigned long align)
-{
-       return ((sizeof(struct vring_desc) * num + sizeof(uint16_t) * (3 + num)
-                + align - 1) & ~(align - 1))
-               + sizeof(uint16_t) * 3 + sizeof(struct vring_used_elem) * num;
-}
-
-/* The following is used with USED_EVENT_IDX and AVAIL_EVENT_IDX */
-/* 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_idx, uint16_t new_idx, 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_idx 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_idx - event_idx - 1) < (uint16_t)(new_idx - old);
-}
diff --git a/user/vmm/include/vmm/virtio.h b/user/vmm/include/vmm/virtio.h
deleted file mode 100644 (file)
index d92d722..0000000
+++ /dev/null
@@ -1,135 +0,0 @@
-#pragma once
-
-#include <ros/arch/membar.h>
-#include <ros/arch/mmu.h>
-#include <ros/virtio_ring.h>
-#include <ros/common.h>
-
-#include <stddef.h>
-#include <stdbool.h>
-
-/* this is just an iov but we're going to keep the type for now, in case
- * we want it at some point.
- */
-struct scatterlist {
-       void *v;
-       int length;
-};
-
-#define unlikely(x) (x)
-#define virtio_rmb(x) rmb()
-#define virtio_wmb(x) wmb()
-#define virtio_mb(x) mb()
-
-#define sg_phys(x) ((uintptr_t)x)
-#define virt_to_phys(x) ((uintptr_t)x)
-
-struct virtqueue *vring_new_virtqueue(unsigned int index,
-                                     unsigned int num,
-                                     unsigned int vring_align,
-                                     bool weak_barriers,
-                                     void *pages,
-                                     bool (*notify)(struct virtqueue *),
-                                     void (*callback)(struct virtqueue *),
-                                     const char *name);
-
-int virtqueue_add_outbuf_avail(struct virtqueue *vq,
-                        struct scatterlist sg[], unsigned int num,
-                        void *data,
-                              int opts); // Opts only used in kernel functions.
-unsigned int virtqueue_get_vring_size(struct virtqueue *_vq);
-void *virtqueue_get_buf_used(struct virtqueue *_vq, unsigned int *len);
-int virtqueue_add_inbuf_avail(struct virtqueue *vq,
-                       struct scatterlist sg[], unsigned int num,
-                             void *data, int opts);
-
-/* linux-isms we may or may not ever care about. */
-#define __user
-#define __force
-#define __cold
-
-int avail(struct virtqueue *_vq);
-void showvq(struct virtqueue *_vq);
-void showdesc(struct virtqueue *_vq, uint16_t head);
-int virtio_get_buf_avail_start(struct virtqueue *_vq, uint16_t *last_avail_idx, struct scatterlist **sgp, int *sgplen);
-void virtio_get_buf_avail_done(struct virtqueue *_vq, uint16_t last_avail_idx, int id, int len);
-void showscatterlist(struct scatterlist *sg, int num);
-
-unsigned int wait_for_vq_desc(struct virtqueue *vq,
-                                struct scatterlist iov[],
-                                unsigned int *out_num, unsigned int *in_num);
-void add_used(struct virtqueue *vq, unsigned int head, int len);
-
-/**
- * virtqueue - a queue to register buffers for sending or receiving.
- * @list: the chain of virtqueues for this device
- * @callback: the function to call when buffers are consumed (can be NULL).
- * @name: the name of this virtqueue (mainly for debugging)
- * @vdev: the virtio device this queue was created for.
- * @priv: a pointer for the virtqueue implementation to use.
- * @index: the zero-based ordinal number for this queue.
- * @num_free: number of elements we expect to be able to fit.
- *
- * A note on @num_free: with indirect buffers, each buffer needs one
- * element in the queue, otherwise a buffer will need one element per
- * sg element.
- */
-struct virtqueue {
-       void (*callback)(struct virtqueue *vq);
-       const char *name;
-       unsigned int index;
-       unsigned int num_free;
-       void *priv;
-};
-
-int virtqueue_add_outbuf(struct virtqueue *vq,
-                        struct scatterlist sg[], unsigned int num,
-                        void *data,
-                        int flags);
-
-int virtqueue_add_inbuf(struct virtqueue *vq,
-                       struct scatterlist sg[], unsigned int num,
-                       void *data,
-                       int flags);
-
-int virtqueue_add_sgs(struct virtqueue *vq,
-                     struct scatterlist *sgs[],
-                     unsigned int out_sgs,
-                     unsigned int in_sgs,
-                     void *data,
-                     int flags);
-
-bool virtqueue_kick(struct virtqueue *vq);
-
-bool virtqueue_kick_prepare(struct virtqueue *vq);
-
-bool virtqueue_notify(struct virtqueue *vq);
-
-void *virtqueue_get_buf(struct virtqueue *vq, unsigned int *len);
-
-void virtqueue_disable_cb(struct virtqueue *vq);
-
-bool virtqueue_enable_cb(struct virtqueue *vq);
-
-unsigned virtqueue_enable_cb_prepare(struct virtqueue *vq);
-
-bool virtqueue_poll(struct virtqueue *vq, unsigned);
-
-bool virtqueue_enable_cb_delayed(struct virtqueue *vq);
-
-void *virtqueue_detach_unused_buf(struct virtqueue *vq);
-
-unsigned int virtqueue_get_vring_size(struct virtqueue *vq);
-
-bool virtqueue_is_broken(struct virtqueue *vq);
-void virtqueue_close(struct virtqueue *vq);
-
-static inline uint32_t read32(const volatile void *addr)
-{
-       return *(const volatile uint32_t *)addr;
-}
-
-static inline void write32(volatile void *addr, uint32_t value)
-{
-       *(volatile uint32_t *)addr = value;
-}
diff --git a/user/vmm/include/vmm/virtio_9p.h b/user/vmm/include/vmm/virtio_9p.h
deleted file mode 100644 (file)
index 767bf66..0000000
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-/* This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE. */
-#include <linux/types.h>
-#include <linux/virtio_ids.h>
-#include <linux/virtio_config.h>
-
-/* The feature bitmap for virtio 9P */
-
-/* The mount point is specified in a config variable */
-#define VIRTIO_9P_MOUNT_TAG 0
-
-struct virtio_9p_config {
-       /* length of the tag name */
-       __u16 tag_len;
-       /* non-NULL terminated tag name */
-       __u8 tag[0];
-} __attribute__((packed));
diff --git a/user/vmm/include/vmm/virtio_balloon.h b/user/vmm/include/vmm/virtio_balloon.h
deleted file mode 100644 (file)
index 79f18d7..0000000
+++ /dev/null
@@ -1,81 +0,0 @@
-#pragma once
-/* This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE. */
-#include <linux/types.h>
-#include <linux/virtio_types.h>
-#include <linux/virtio_ids.h>
-#include <linux/virtio_config.h>
-
-/* The feature bitmap for virtio balloon */
-#define VIRTIO_BALLOON_F_MUST_TELL_HOST        0 /* Tell before reclaiming pages */
-#define VIRTIO_BALLOON_F_STATS_VQ      1 /* Memory Stats virtqueue */
-#define VIRTIO_BALLOON_F_DEFLATE_ON_OOM        2 /* Deflate balloon on OOM */
-
-/* Size of a PFN in the balloon interface. */
-#define VIRTIO_BALLOON_PFN_SHIFT 12
-
-struct virtio_balloon_config {
-       /* Number of pages host wants Guest to give up. */
-       __u32 num_pages;
-       /* Number of pages we've actually got in balloon. */
-       __u32 actual;
-};
-
-#define VIRTIO_BALLOON_S_SWAP_IN  0   /* Amount of memory swapped in */
-#define VIRTIO_BALLOON_S_SWAP_OUT 1   /* Amount of memory swapped out */
-#define VIRTIO_BALLOON_S_MAJFLT   2   /* Number of major faults */
-#define VIRTIO_BALLOON_S_MINFLT   3   /* Number of minor faults */
-#define VIRTIO_BALLOON_S_MEMFREE  4   /* Total amount of free memory */
-#define VIRTIO_BALLOON_S_MEMTOT   5   /* Total amount of memory */
-#define VIRTIO_BALLOON_S_NR       6
-
-/*
- * Memory statistics structure.
- * Driver fills an array of these structures and passes to device.
- *
- * NOTE: fields are laid out in a way that would make compiler add padding
- * between and after fields, so we have to use compiler-specific attributes to
- * pack it, to disable this padding. This also often causes compiler to
- * generate suboptimal code.
- *
- * We maintain this statistics structure format for backwards compatibility,
- * but don't follow this example.
- *
- * If implementing a similar structure, do something like the below instead:
- *     struct virtio_balloon_stat {
- *         __virtio16 tag;
- *         __u8 reserved[6];
- *         __virtio64 val;
- *     };
- *
- * In other words, add explicit reserved fields to align field and
- * structure boundaries at field size, avoiding compiler padding
- * without the packed attribute.
- */
-struct virtio_balloon_stat {
-       __virtio16 tag;
-       __virtio64 val;
-} __attribute__((packed));
diff --git a/user/vmm/include/vmm/virtio_blk.h b/user/vmm/include/vmm/virtio_blk.h
deleted file mode 100644 (file)
index 58a4dc8..0000000
+++ /dev/null
@@ -1,147 +0,0 @@
-#pragma once
-/* This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE. */
-#include <linux/types.h>
-#include <linux/virtio_ids.h>
-#include <linux/virtio_config.h>
-#include <linux/virtio_types.h>
-
-/* Feature bits */
-#define VIRTIO_BLK_F_SIZE_MAX  1       /* Indicates maximum segment size */
-#define VIRTIO_BLK_F_SEG_MAX   2       /* Indicates maximum # of segments */
-#define VIRTIO_BLK_F_GEOMETRY  4       /* Legacy geometry available  */
-#define VIRTIO_BLK_F_RO                5       /* Disk is read-only */
-#define VIRTIO_BLK_F_BLK_SIZE  6       /* Block size of disk is available*/
-#define VIRTIO_BLK_F_TOPOLOGY  10      /* Topology information is available */
-#define VIRTIO_BLK_F_MQ                12      /* support more than one vq */
-
-/* Legacy feature bits */
-#ifndef VIRTIO_BLK_NO_LEGACY
-#define VIRTIO_BLK_F_BARRIER   0       /* Does host support barriers? */
-#define VIRTIO_BLK_F_SCSI      7       /* Supports scsi command passthru */
-#define VIRTIO_BLK_F_WCE       9       /* Writeback mode enabled after reset */
-#define VIRTIO_BLK_F_CONFIG_WCE        11      /* Writeback mode available in config */
-#ifndef __KERNEL__
-/* Old (deprecated) name for VIRTIO_BLK_F_WCE. */
-#define VIRTIO_BLK_F_FLUSH VIRTIO_BLK_F_WCE
-#endif
-#endif /* !VIRTIO_BLK_NO_LEGACY */
-
-#define VIRTIO_BLK_ID_BYTES    20      /* ID string length */
-
-struct virtio_blk_config {
-       /* The capacity (in 512-byte sectors). */
-       __u64 capacity;
-       /* The maximum segment size (if VIRTIO_BLK_F_SIZE_MAX) */
-       __u32 size_max;
-       /* The maximum number of segments (if VIRTIO_BLK_F_SEG_MAX) */
-       __u32 seg_max;
-       /* geometry of the device (if VIRTIO_BLK_F_GEOMETRY) */
-       struct virtio_blk_geometry {
-               __u16 cylinders;
-               __u8 heads;
-               __u8 sectors;
-       } geometry;
-
-       /* block size of device (if VIRTIO_BLK_F_BLK_SIZE) */
-       __u32 blk_size;
-
-       /* the next 4 entries are guarded by VIRTIO_BLK_F_TOPOLOGY  */
-       /* exponent for physical block per logical block. */
-       __u8 physical_block_exp;
-       /* alignment offset in logical blocks. */
-       __u8 alignment_offset;
-       /* minimum I/O size without performance penalty in logical blocks. */
-       __u16 min_io_size;
-       /* optimal sustained I/O size in logical blocks. */
-       __u32 opt_io_size;
-
-       /* writeback mode (if VIRTIO_BLK_F_CONFIG_WCE) */
-       __u8 wce;
-       __u8 unused;
-
-       /* number of vqs, only available when VIRTIO_BLK_F_MQ is set */
-       __u16 num_queues;
-} __attribute__((packed));
-
-/*
- * Command types
- *
- * Usage is a bit tricky as some bits are used as flags and some are not.
- *
- * Rules:
- *   VIRTIO_BLK_T_OUT may be combined with VIRTIO_BLK_T_SCSI_CMD or
- *   VIRTIO_BLK_T_BARRIER.  VIRTIO_BLK_T_FLUSH is a command of its own
- *   and may not be combined with any of the other flags.
- */
-
-/* These two define direction. */
-#define VIRTIO_BLK_T_IN                0
-#define VIRTIO_BLK_T_OUT       1
-
-#ifndef VIRTIO_BLK_NO_LEGACY
-/* This bit says it's a scsi command, not an actual read or write. */
-#define VIRTIO_BLK_T_SCSI_CMD  2
-#endif /* VIRTIO_BLK_NO_LEGACY */
-
-/* Cache flush command */
-#define VIRTIO_BLK_T_FLUSH     4
-
-/* Get device ID command */
-#define VIRTIO_BLK_T_GET_ID    8
-
-#ifndef VIRTIO_BLK_NO_LEGACY
-/* Barrier before this op. */
-#define VIRTIO_BLK_T_BARRIER   0x80000000
-#endif /* !VIRTIO_BLK_NO_LEGACY */
-
-/*
- * This comes first in the read scatter-gather list.
- * For legacy virtio, if VIRTIO_F_ANY_LAYOUT is not negotiated,
- * this is the first element of the read scatter-gather list.
- */
-struct virtio_blk_outhdr {
-       /* VIRTIO_BLK_T* */
-       __virtio32 type;
-       /* io priority. */
-       __virtio32 ioprio;
-       /* Sector (ie. 512 byte offset) */
-       __virtio64 sector;
-};
-
-#ifndef VIRTIO_BLK_NO_LEGACY
-struct virtio_scsi_inhdr {
-       __virtio32 errors;
-       __virtio32 data_len;
-       __virtio32 sense_len;
-       __virtio32 residual;
-};
-#endif /* !VIRTIO_BLK_NO_LEGACY */
-
-/* And this is the final byte of the write scatter-gather list. */
-#define VIRTIO_BLK_S_OK                0
-#define VIRTIO_BLK_S_IOERR     1
-#define VIRTIO_BLK_S_UNSUPP    2
diff --git a/user/vmm/include/vmm/virtio_config.h b/user/vmm/include/vmm/virtio_config.h
deleted file mode 100644 (file)
index 6defe65..0000000
+++ /dev/null
@@ -1,60 +0,0 @@
-#pragma once
-/* This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so
- * anyone can use the definitions to implement compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE. */
-
-/* Virtio devices use a standardized configuration space to define their
- * features and pass configuration information, but each implementation can
- * store and access that space differently. */
-
-/* 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
-/* Driver has finished configuring features */
-#define VIRTIO_CONFIG_S_FEATURES_OK    8
-/* We've given up on this device. */
-#define VIRTIO_CONFIG_S_FAILED         0x80
-
-/* Some virtio feature bits (currently bits 28 through 32) 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         33
-
-#ifndef VIRTIO_CONFIG_NO_LEGACY
-/* Do we get callbacks when the ring is completely used, even if we've
- * suppressed them? */
-#define VIRTIO_F_NOTIFY_ON_EMPTY       24
-
-/* Can the device handle any descriptor layout? */
-#define VIRTIO_F_ANY_LAYOUT            27
-#endif /* VIRTIO_CONFIG_NO_LEGACY */
-
-/* v1.0 compliant. */
-#define VIRTIO_F_VERSION_1             32
diff --git a/user/vmm/include/vmm/virtio_console.h b/user/vmm/include/vmm/virtio_console.h
deleted file mode 100644 (file)
index ca83672..0000000
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
- * This header, excluding the #ifdef __KERNEL__ part, is BSD licensed so
- * anyone can use the definitions to implement compatible drivers/servers:
- *
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * Copyright (C) Red Hat, Inc., 2009, 2010, 2011
- * Copyright (C) Amit Shah <amit.shah@redhat.com>, 2009, 2010, 2011
- */
-#pragma once
-#include <linux/types.h>
-#include <linux/virtio_types.h>
-#include <linux/virtio_ids.h>
-#include <linux/virtio_config.h>
-
-/* Feature bits */
-#define VIRTIO_CONSOLE_F_SIZE  0       /* Does host provide console size? */
-#define VIRTIO_CONSOLE_F_MULTIPORT 1   /* Does host provide multiple ports? */
-#define VIRTIO_CONSOLE_F_EMERG_WRITE 2 /* Does host support emergency write? */
-
-#define VIRTIO_CONSOLE_BAD_ID          (~(__u32)0)
-
-struct virtio_console_config {
-       /* colums of the screens */
-       __u16 cols;
-       /* rows of the screens */
-       __u16 rows;
-       /* max. number of ports this device can hold */
-       __u32 max_nr_ports;
-       /* emergency write register */
-       __u32 emerg_wr;
-} __attribute__((packed));
-
-/*
- * A message that's passed between the Host and the Guest for a
- * particular port.
- */
-struct virtio_console_control {
-       __virtio32 id;          /* Port number */
-       __virtio16 event;       /* The kind of control event (see below) */
-       __virtio16 value;       /* Extra information for the key */
-};
-
-/* Some events for control messages */
-#define VIRTIO_CONSOLE_DEVICE_READY    0
-#define VIRTIO_CONSOLE_PORT_ADD                1
-#define VIRTIO_CONSOLE_PORT_REMOVE     2
-#define VIRTIO_CONSOLE_PORT_READY      3
-#define VIRTIO_CONSOLE_CONSOLE_PORT    4
-#define VIRTIO_CONSOLE_RESIZE          5
-#define VIRTIO_CONSOLE_PORT_OPEN       6
-#define VIRTIO_CONSOLE_PORT_NAME       7
diff --git a/user/vmm/include/vmm/virtio_ids.h b/user/vmm/include/vmm/virtio_ids.h
deleted file mode 100644 (file)
index 259f082..0000000
+++ /dev/null
@@ -1,41 +0,0 @@
-#pragma once
-/*
- * Virtio IDs
- *
- * This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE. */
-
-#define VIRTIO_ID_NET          1 /* virtio net */
-#define VIRTIO_ID_BLOCK                2 /* virtio block */
-#define VIRTIO_ID_CONSOLE      3 /* virtio console */
-#define VIRTIO_ID_RNG          4 /* virtio rng */
-#define VIRTIO_ID_BALLOON      5 /* virtio balloon */
-#define VIRTIO_ID_RPMSG                7 /* virtio remote processor messaging */
-#define VIRTIO_ID_SCSI         8 /* virtio scsi */
-#define VIRTIO_ID_9P           9 /* 9p virtio console */
-#define VIRTIO_ID_RPROC_SERIAL 11 /* virtio remoteproc serial link */
-#define VIRTIO_ID_CAIF        12 /* Virtio caif */
-#define VIRTIO_ID_INPUT        18 /* virtio input */
diff --git a/user/vmm/include/vmm/virtio_input.h b/user/vmm/include/vmm/virtio_input.h
deleted file mode 100644 (file)
index 089e121..0000000
+++ /dev/null
@@ -1,73 +0,0 @@
-#pragma once
-/* This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
- * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
- * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
- * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE. */
-
-#include <linux/types.h>
-
-enum virtio_input_config_select {
-       VIRTIO_INPUT_CFG_UNSET      = 0x00,
-       VIRTIO_INPUT_CFG_ID_NAME    = 0x01,
-       VIRTIO_INPUT_CFG_ID_SERIAL  = 0x02,
-       VIRTIO_INPUT_CFG_ID_DEVIDS  = 0x03,
-       VIRTIO_INPUT_CFG_PROP_BITS  = 0x10,
-       VIRTIO_INPUT_CFG_EV_BITS    = 0x11,
-       VIRTIO_INPUT_CFG_ABS_INFO   = 0x12,
-};
-
-struct virtio_input_absinfo {
-       __u32 min;
-       __u32 max;
-       __u32 fuzz;
-       __u32 flat;
-       __u32 res;
-};
-
-struct virtio_input_devids {
-       __u16 bustype;
-       __u16 vendor;
-       __u16 product;
-       __u16 version;
-};
-
-struct virtio_input_config {
-       __u8    select;
-       __u8    subsel;
-       __u8    size;
-       __u8    reserved[5];
-       union {
-               char string[128];
-               __u8 bitmap[128];
-               struct virtio_input_absinfo abs;
-               struct virtio_input_devids ids;
-       } u;
-};
-
-struct virtio_input_event {
-       __le16 type;
-       __le16 code;
-       __le32 value;
-};
diff --git a/user/vmm/include/vmm/virtio_mmio.h b/user/vmm/include/vmm/virtio_mmio.h
deleted file mode 100644 (file)
index 4f93fbd..0000000
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- * Virtio platform device driver
- *
- * Copyright 2011, ARM Ltd.
- *
- * Based on Virtio PCI driver by Anthony Liguori, copyright IBM Corp. 2007
- *
- * This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#pragma once
-
-#include <vmm/sched.h>
-
-/*
- * Control registers
- */
-
-/* Magic value ("virt" string) - Read Only */
-#define VIRTIO_MMIO_MAGIC_VALUE                0x000
-
-/* Virtio device version - Read Only */
-#define VIRTIO_MMIO_VERSION            0x004
-
-/* Virtio device ID - Read Only */
-#define VIRTIO_MMIO_DEVICE_ID          0x008
-
-/* Virtio vendor ID - Read Only */
-#define VIRTIO_MMIO_VENDOR_ID          0x00c
-
-/* Bitmask of the features supported by the device (host)
- * (32 bits per set) - Read Only */
-#define VIRTIO_MMIO_DEVICE_FEATURES    0x010
-
-/* Device (host) features set selector - Write Only */
-#define VIRTIO_MMIO_DEVICE_FEATURES_SEL        0x014
-
-/* Bitmask of features activated by the driver (guest)
- * (32 bits per set) - Write Only */
-#define VIRTIO_MMIO_DRIVER_FEATURES    0x020
-
-/* Activated features set selector - Write Only */
-#define VIRTIO_MMIO_DRIVER_FEATURES_SEL        0x024
-
-
-#ifndef VIRTIO_MMIO_NO_LEGACY /* LEGACY DEVICES ONLY! */
-
-/* Guest's memory page size in bytes - Write Only */
-#define VIRTIO_MMIO_GUEST_PAGE_SIZE    0x028
-
-#endif
-
-
-/* Queue selector - Write Only */
-#define VIRTIO_MMIO_QUEUE_SEL          0x030
-
-/* Maximum size of the currently selected queue - Read Only */
-#define VIRTIO_MMIO_QUEUE_NUM_MAX      0x034
-
-/* Queue size for the currently selected queue - Write Only */
-#define VIRTIO_MMIO_QUEUE_NUM          0x038
-
-
-#ifndef VIRTIO_MMIO_NO_LEGACY /* LEGACY DEVICES ONLY! */
-
-/* Used Ring alignment for the currently selected queue - Write Only */
-#define VIRTIO_MMIO_QUEUE_ALIGN                0x03c
-
-/* Guest's PFN for the currently selected queue - Read Write */
-#define VIRTIO_MMIO_QUEUE_PFN          0x040
-
-#endif
-
-
-/* Ready bit for the currently selected queue - Read Write */
-#define VIRTIO_MMIO_QUEUE_READY                0x044
-
-/* Queue notifier - Write Only */
-#define VIRTIO_MMIO_QUEUE_NOTIFY       0x050
-
-/* Interrupt status - Read Only */
-#define VIRTIO_MMIO_INTERRUPT_STATUS   0x060
-
-/* Interrupt acknowledge - Write Only */
-#define VIRTIO_MMIO_INTERRUPT_ACK      0x064
-
-/* Device status register - Read Write */
-#define VIRTIO_MMIO_STATUS             0x070
-
-/* Selected queue's Descriptor Table address, 64 bits in two halves */
-#define VIRTIO_MMIO_QUEUE_DESC_LOW     0x080
-#define VIRTIO_MMIO_QUEUE_DESC_HIGH    0x084
-
-/* Selected queue's Available Ring address, 64 bits in two halves */
-#define VIRTIO_MMIO_QUEUE_AVAIL_LOW    0x090
-#define VIRTIO_MMIO_QUEUE_AVAIL_HIGH   0x094
-
-/* Selected queue's Used Ring address, 64 bits in two halves */
-#define VIRTIO_MMIO_QUEUE_USED_LOW     0x0a0
-#define VIRTIO_MMIO_QUEUE_USED_HIGH    0x0a4
-
-/* Configuration atomicity value */
-#define VIRTIO_MMIO_CONFIG_GENERATION  0x0fc
-
-/* The config space is defined by each driver as
- * the per-driver configuration space - Read Write */
-#define VIRTIO_MMIO_CONFIG             0x100
-
-/*
- * Interrupt flags (re: interrupt status & acknowledge registers)
- */
-
-#define VIRTIO_MMIO_INT_VRING          (1 << 0)
-#define VIRTIO_MMIO_INT_CONFIG         (1 << 1)
-
-// A vq defines on queue attached to a device. It has a function, started as a thread;
-// an arg, for arbitrary use; qnum, which is an indicator of how much memory is given
-// to the queue; a pointer to the thread that gets started when the queue is notified;
-// a physical frame number, which is process virtual to the vmm; an isr (not used yet);
-// status; and a pointer to the virtio struct.
-struct vq {
-       char *name;
-       /* Start this as a thread when a matching virtio is discovered. */
-       void (*func)(void *arg);
-       void *arg;
-       int maxqnum; // how many things the q gets? or something. 
-       int qnum; 
-       int qalign;
-       /* filled in by virtio probing. */
-       uint64_t pfn;
-       uint32_t isr; // not used yet but ...
-       uint32_t status;
-       uint64_t qdesc;
-       uint64_t qavail;
-       uint64_t qused;
-       void *virtio;
-};
-
-// a vqdev has a name; magic number; features ( we MUST have features);
-// and an array of vqs.
-struct vqdev {
-       /* Set up usually as a static initializer */
-       char *name;
-       uint32_t dev; // e.g. VIRTIO_ID_CONSOLE);
-       uint64_t device_features, driver_features;
-       int numvqs;
-       struct vq vqs[];
-};
-
-
-/* This struct is passed to a virtio thread when it is started. It includes
- * needed info and the vqdev arg. This seems overkill but we may need to add to it.
- */
-struct virtio_threadarg {
-       struct vq *arg;
-};
-
-void dumpvirtio_mmio(FILE *f, uint64_t gpa);
-void register_virtio_mmio(struct vqdev *v, uint64_t virtio_base);
-int virtio_mmio(struct guest_thread *vm_thread, uint64_t gpa, int destreg,
-                uint64_t *regp, int store);
-void virtio_mmio_set_vring_irq(void);
diff --git a/user/vmm/include/vmm/virtio_net.h b/user/vmm/include/vmm/virtio_net.h
deleted file mode 100644 (file)
index 33c9203..0000000
+++ /dev/null
@@ -1,226 +0,0 @@
-#pragma once
-/* This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE. */
-#include <linux/types.h>
-#include <linux/virtio_ids.h>
-#include <linux/virtio_config.h>
-#include <linux/virtio_types.h>
-#include <linux/if_ether.h>
-
-/* The feature bitmap for virtio net */
-#define VIRTIO_NET_F_CSUM      0       /* Host handles pkts w/ partial csum */
-#define VIRTIO_NET_F_GUEST_CSUM        1       /* Guest handles pkts w/ partial csum */
-#define VIRTIO_NET_F_MAC       5       /* Host has given MAC address. */
-#define VIRTIO_NET_F_GUEST_TSO4        7       /* Guest can handle TSOv4 in. */
-#define VIRTIO_NET_F_GUEST_TSO6        8       /* Guest can handle TSOv6 in. */
-#define VIRTIO_NET_F_GUEST_ECN 9       /* Guest can handle TSO[6] w/ ECN in. */
-#define VIRTIO_NET_F_GUEST_UFO 10      /* Guest can handle UFO in. */
-#define VIRTIO_NET_F_HOST_TSO4 11      /* Host can handle TSOv4 in. */
-#define VIRTIO_NET_F_HOST_TSO6 12      /* Host can handle TSOv6 in. */
-#define VIRTIO_NET_F_HOST_ECN  13      /* Host can handle TSO[6] w/ ECN in. */
-#define VIRTIO_NET_F_HOST_UFO  14      /* Host can handle UFO in. */
-#define VIRTIO_NET_F_MRG_RXBUF 15      /* Host can merge receive buffers. */
-#define VIRTIO_NET_F_STATUS    16      /* virtio_net_config.status available */
-#define VIRTIO_NET_F_CTRL_VQ   17      /* Control channel available */
-#define VIRTIO_NET_F_CTRL_RX   18      /* Control channel RX mode support */
-#define VIRTIO_NET_F_CTRL_VLAN 19      /* Control channel VLAN filtering */
-#define VIRTIO_NET_F_CTRL_RX_EXTRA 20  /* Extra RX mode control support */
-#define VIRTIO_NET_F_GUEST_ANNOUNCE 21 /* Guest can announce device on the
-                                        * network */
-#define VIRTIO_NET_F_MQ        22      /* Device supports Receive Flow
-                                        * Steering */
-#define VIRTIO_NET_F_CTRL_MAC_ADDR 23  /* Set MAC address */
-
-#ifndef VIRTIO_NET_NO_LEGACY
-#define VIRTIO_NET_F_GSO       6       /* Host handles pkts w/ any GSO type */
-#endif /* VIRTIO_NET_NO_LEGACY */
-
-#define VIRTIO_NET_S_LINK_UP   1       /* Link is up */
-#define VIRTIO_NET_S_ANNOUNCE  2       /* Announcement is needed */
-
-struct virtio_net_config {
-       /* The config defining mac address (if VIRTIO_NET_F_MAC) */
-       __u8 mac[ETH_ALEN];
-       /* See VIRTIO_NET_F_STATUS and VIRTIO_NET_S_* above */
-       __u16 status;
-       /* Maximum number of each of transmit and receive queues;
-        * see VIRTIO_NET_F_MQ and VIRTIO_NET_CTRL_MQ.
-        * Legal values are between 1 and 0x8000
-        */
-       __u16 max_virtqueue_pairs;
-} __attribute__((packed));
-
-/*
- * This header comes first in the scatter-gather list.  If you don't
- * specify GSO or CSUM features, you can simply ignore the header.
- *
- * This is bitwise-equivalent to the legacy struct virtio_net_hdr_mrg_rxbuf,
- * only flattened.
- */
-struct virtio_net_hdr_v1 {
-#define VIRTIO_NET_HDR_F_NEEDS_CSUM    1       /* Use csum_start, csum_offset */
-#define VIRTIO_NET_HDR_F_DATA_VALID    2       /* Csum is valid */
-       __u8 flags;
-#define VIRTIO_NET_HDR_GSO_NONE                0       /* Not a GSO frame */
-#define VIRTIO_NET_HDR_GSO_TCPV4       1       /* GSO frame, IPv4 TCP (TSO) */
-#define VIRTIO_NET_HDR_GSO_UDP         3       /* GSO frame, IPv4 UDP (UFO) */
-#define VIRTIO_NET_HDR_GSO_TCPV6       4       /* GSO frame, IPv6 TCP */
-#define VIRTIO_NET_HDR_GSO_ECN         0x80    /* TCP has ECN set */
-       __u8 gso_type;
-       __virtio16 hdr_len;     /* Ethernet + IP + tcp/udp hdrs */
-       __virtio16 gso_size;    /* Bytes to append to hdr_len per frame */
-       __virtio16 csum_start;  /* Position to start checksumming from */
-       __virtio16 csum_offset; /* Offset after that to place checksum */
-       __virtio16 num_buffers; /* Number of merged rx buffers */
-};
-
-#ifndef VIRTIO_NET_NO_LEGACY
-/* This header comes first in the scatter-gather list.
- * For legacy virtio, if VIRTIO_F_ANY_LAYOUT is not negotiated, it must
- * be the first element of the scatter-gather list.  If you don't
- * specify GSO or CSUM features, you can simply ignore the header. */
-struct virtio_net_hdr {
-       /* See VIRTIO_NET_HDR_F_* */
-       __u8 flags;
-       /* See VIRTIO_NET_HDR_GSO_* */
-       __u8 gso_type;
-       __virtio16 hdr_len;             /* Ethernet + IP + tcp/udp hdrs */
-       __virtio16 gso_size;            /* Bytes to append to hdr_len per frame */
-       __virtio16 csum_start;  /* Position to start checksumming from */
-       __virtio16 csum_offset; /* Offset after that to place checksum */
-};
-
-/* This is the version of the header to use when the MRG_RXBUF
- * feature has been negotiated. */
-struct virtio_net_hdr_mrg_rxbuf {
-       struct virtio_net_hdr hdr;
-       __virtio16 num_buffers; /* Number of merged rx buffers */
-};
-#endif /* ...VIRTIO_NET_NO_LEGACY */
-
-/*
- * Control virtqueue data structures
- *
- * The control virtqueue expects a header in the first sg entry
- * and an ack/status response in the last entry.  Data for the
- * command goes in between.
- */
-struct virtio_net_ctrl_hdr {
-       __u8 class;
-       __u8 cmd;
-} __attribute__((packed));
-
-typedef __u8 virtio_net_ctrl_ack;
-
-#define VIRTIO_NET_OK     0
-#define VIRTIO_NET_ERR    1
-
-/*
- * Control the RX mode, ie. promisucous, allmulti, etc...
- * All commands require an "out" sg entry containing a 1 byte
- * state value, zero = disable, non-zero = enable.  Commands
- * 0 and 1 are supported with the VIRTIO_NET_F_CTRL_RX feature.
- * Commands 2-5 are added with VIRTIO_NET_F_CTRL_RX_EXTRA.
- */
-#define VIRTIO_NET_CTRL_RX    0
- #define VIRTIO_NET_CTRL_RX_PROMISC      0
- #define VIRTIO_NET_CTRL_RX_ALLMULTI     1
- #define VIRTIO_NET_CTRL_RX_ALLUNI       2
- #define VIRTIO_NET_CTRL_RX_NOMULTI      3
- #define VIRTIO_NET_CTRL_RX_NOUNI        4
- #define VIRTIO_NET_CTRL_RX_NOBCAST      5
-
-/*
- * Control the MAC
- *
- * The MAC filter table is managed by the hypervisor, the guest should
- * assume the size is infinite.  Filtering should be considered
- * non-perfect, ie. based on hypervisor resources, the guest may
- * received packets from sources not specified in the filter list.
- *
- * In addition to the class/cmd header, the TABLE_SET command requires
- * two out scatterlists.  Each contains a 4 byte count of entries followed
- * by a concatenated byte stream of the ETH_ALEN MAC addresses.  The
- * first sg list contains unicast addresses, the second is for multicast.
- * This functionality is present if the VIRTIO_NET_F_CTRL_RX feature
- * is available.
- *
- * The ADDR_SET command requests one out scatterlist, it contains a
- * 6 bytes MAC address. This functionality is present if the
- * VIRTIO_NET_F_CTRL_MAC_ADDR feature is available.
- */
-struct virtio_net_ctrl_mac {
-       __virtio32 entries;
-       __u8 macs[][ETH_ALEN];
-} __attribute__((packed));
-
-#define VIRTIO_NET_CTRL_MAC    1
- #define VIRTIO_NET_CTRL_MAC_TABLE_SET        0
- #define VIRTIO_NET_CTRL_MAC_ADDR_SET         1
-
-/*
- * Control VLAN filtering
- *
- * The VLAN filter table is controlled via a simple ADD/DEL interface.
- * VLAN IDs not added may be filterd by the hypervisor.  Del is the
- * opposite of add.  Both commands expect an out entry containing a 2
- * byte VLAN ID.  VLAN filterting is available with the
- * VIRTIO_NET_F_CTRL_VLAN feature bit.
- */
-#define VIRTIO_NET_CTRL_VLAN       2
- #define VIRTIO_NET_CTRL_VLAN_ADD             0
- #define VIRTIO_NET_CTRL_VLAN_DEL             1
-
-/*
- * Control link announce acknowledgement
- *
- * The command VIRTIO_NET_CTRL_ANNOUNCE_ACK is used to indicate that
- * driver has recevied the notification; device would clear the
- * VIRTIO_NET_S_ANNOUNCE bit in the status field after it receives
- * this command.
- */
-#define VIRTIO_NET_CTRL_ANNOUNCE       3
- #define VIRTIO_NET_CTRL_ANNOUNCE_ACK         0
-
-/*
- * Control Receive Flow Steering
- *
- * The command VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET
- * enables Receive Flow Steering, specifying the number of the transmit and
- * receive queues that will be used. After the command is consumed and acked by
- * the device, the device will not steer new packets on receive virtqueues
- * other than specified nor read from transmit virtqueues other than specified.
- * Accordingly, driver should not transmit new packets  on virtqueues other than
- * specified.
- */
-struct virtio_net_ctrl_mq {
-       __virtio16 virtqueue_pairs;
-};
-
-#define VIRTIO_NET_CTRL_MQ   4
- #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET        0
- #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN        1
- #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX        0x8000
diff --git a/user/vmm/include/vmm/virtio_pci.h b/user/vmm/include/vmm/virtio_pci.h
deleted file mode 100644 (file)
index 15be71c..0000000
+++ /dev/null
@@ -1,190 +0,0 @@
-/*
- * Virtio PCI driver
- *
- * This module allows virtio devices to be used over a virtual PCI device.
- * This can be used with QEMU based VMMs like KVM or Xen.
- *
- * Copyright IBM Corp. 2007
- *
- * Authors:
- *  Anthony Liguori  <aliguori@us.ibm.com>
- *
- * This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#pragma once
-
-#include <linux/types.h>
-
-#ifndef VIRTIO_PCI_NO_LEGACY
-
-/* A 32-bit r/o bitmask of the features supported by the host */
-#define VIRTIO_PCI_HOST_FEATURES       0
-
-/* A 32-bit r/w bitmask of features activated by the guest */
-#define VIRTIO_PCI_GUEST_FEATURES      4
-
-/* A 32-bit r/w PFN for the currently selected queue */
-#define VIRTIO_PCI_QUEUE_PFN           8
-
-/* A 16-bit r/o queue size for the currently selected queue */
-#define VIRTIO_PCI_QUEUE_NUM           12
-
-/* A 16-bit r/w queue selector */
-#define VIRTIO_PCI_QUEUE_SEL           14
-
-/* A 16-bit r/w queue notifier */
-#define VIRTIO_PCI_QUEUE_NOTIFY                16
-
-/* An 8-bit device status register.  */
-#define VIRTIO_PCI_STATUS              18
-
-/* An 8-bit r/o interrupt status register.  Reading the value will return the
- * current contents of the ISR and will also clear it.  This is effectively
- * a read-and-acknowledge. */
-#define VIRTIO_PCI_ISR                 19
-
-/* MSI-X registers: only enabled if MSI-X is enabled. */
-/* A 16-bit vector for configuration changes. */
-#define VIRTIO_MSI_CONFIG_VECTOR        20
-/* A 16-bit vector for selected queue notifications. */
-#define VIRTIO_MSI_QUEUE_VECTOR         22
-
-/* The remaining space is defined by each driver as the per-driver
- * configuration space */
-#define VIRTIO_PCI_CONFIG_OFF(msix_enabled)    ((msix_enabled) ? 24 : 20)
-/* Deprecated: please use VIRTIO_PCI_CONFIG_OFF instead */
-#define VIRTIO_PCI_CONFIG(dev) VIRTIO_PCI_CONFIG_OFF((dev)->msix_enabled)
-
-/* Virtio ABI version, this must match exactly */
-#define VIRTIO_PCI_ABI_VERSION         0
-
-/* How many bits to shift physical queue address written to QUEUE_PFN.
- * 12 is historical, and due to x86 page size. */
-#define VIRTIO_PCI_QUEUE_ADDR_SHIFT    12
-
-/* The alignment to use between consumer and producer parts of vring.
- * x86 pagesize again. */
-#define VIRTIO_PCI_VRING_ALIGN         4096
-
-#endif /* VIRTIO_PCI_NO_LEGACY */
-
-/* The bit of the ISR which indicates a device configuration change. */
-#define VIRTIO_PCI_ISR_CONFIG          0x2
-/* Vector value used to disable MSI for queue */
-#define VIRTIO_MSI_NO_VECTOR            0xffff
-
-#ifndef VIRTIO_PCI_NO_MODERN
-
-/* IDs for different capabilities.  Must all exist. */
-
-/* Common configuration */
-#define VIRTIO_PCI_CAP_COMMON_CFG      1
-/* Notifications */
-#define VIRTIO_PCI_CAP_NOTIFY_CFG      2
-/* ISR access */
-#define VIRTIO_PCI_CAP_ISR_CFG         3
-/* Device specific configuration */
-#define VIRTIO_PCI_CAP_DEVICE_CFG      4
-/* PCI configuration access */
-#define VIRTIO_PCI_CAP_PCI_CFG         5
-
-/* This is the PCI capability header: */
-struct virtio_pci_cap {
-       __u8 cap_vndr;          /* Generic PCI field: PCI_CAP_ID_VNDR */
-       __u8 cap_next;          /* Generic PCI field: next ptr. */
-       __u8 cap_len;           /* Generic PCI field: capability length */
-       __u8 cfg_type;          /* Identifies the structure. */
-       __u8 bar;               /* Where to find it. */
-       __u8 padding[3];        /* Pad to full dword. */
-       __le32 offset;          /* Offset within bar. */
-       __le32 length;          /* Length of the structure, in bytes. */
-};
-
-struct virtio_pci_notify_cap {
-       struct virtio_pci_cap cap;
-       __le32 notify_off_multiplier;   /* Multiplier for queue_notify_off. */
-};
-
-/* Fields in VIRTIO_PCI_CAP_COMMON_CFG: */
-struct virtio_pci_common_cfg {
-       /* About the whole device. */
-       __le32 device_feature_select;   /* read-write */
-       __le32 device_feature;          /* read-only */
-       __le32 guest_feature_select;    /* read-write */
-       __le32 guest_feature;           /* read-write */
-       __le16 msix_config;             /* read-write */
-       __le16 num_queues;              /* read-only */
-       __u8 device_status;             /* read-write */
-       __u8 config_generation;         /* read-only */
-
-       /* About a specific virtqueue. */
-       __le16 queue_select;            /* read-write */
-       __le16 queue_size;              /* read-write, power of 2. */
-       __le16 queue_msix_vector;       /* read-write */
-       __le16 queue_enable;            /* read-write */
-       __le16 queue_notify_off;        /* read-only */
-       __le32 queue_desc_lo;           /* read-write */
-       __le32 queue_desc_hi;           /* read-write */
-       __le32 queue_avail_lo;          /* read-write */
-       __le32 queue_avail_hi;          /* read-write */
-       __le32 queue_used_lo;           /* read-write */
-       __le32 queue_used_hi;           /* read-write */
-};
-
-/* Macro versions of offsets for the Old Timers! */
-#define VIRTIO_PCI_CAP_VNDR            0
-#define VIRTIO_PCI_CAP_NEXT            1
-#define VIRTIO_PCI_CAP_LEN             2
-#define VIRTIO_PCI_CAP_CFG_TYPE                3
-#define VIRTIO_PCI_CAP_BAR             4
-#define VIRTIO_PCI_CAP_OFFSET          8
-#define VIRTIO_PCI_CAP_LENGTH          12
-
-#define VIRTIO_PCI_NOTIFY_CAP_MULT     16
-
-#define VIRTIO_PCI_COMMON_DFSELECT     0
-#define VIRTIO_PCI_COMMON_DF           4
-#define VIRTIO_PCI_COMMON_GFSELECT     8
-#define VIRTIO_PCI_COMMON_GF           12
-#define VIRTIO_PCI_COMMON_MSIX         16
-#define VIRTIO_PCI_COMMON_NUMQ         18
-#define VIRTIO_PCI_COMMON_STATUS       20
-#define VIRTIO_PCI_COMMON_CFGGENERATION        21
-#define VIRTIO_PCI_COMMON_Q_SELECT     22
-#define VIRTIO_PCI_COMMON_Q_SIZE       24
-#define VIRTIO_PCI_COMMON_Q_MSIX       26
-#define VIRTIO_PCI_COMMON_Q_ENABLE     28
-#define VIRTIO_PCI_COMMON_Q_NOFF       30
-#define VIRTIO_PCI_COMMON_Q_DESCLO     32
-#define VIRTIO_PCI_COMMON_Q_DESCHI     36
-#define VIRTIO_PCI_COMMON_Q_AVAILLO    40
-#define VIRTIO_PCI_COMMON_Q_AVAILHI    44
-#define VIRTIO_PCI_COMMON_Q_USEDLO     48
-#define VIRTIO_PCI_COMMON_Q_USEDHI     52
-
-#endif /* VIRTIO_PCI_NO_MODERN */
diff --git a/user/vmm/include/vmm/virtio_ring.h b/user/vmm/include/vmm/virtio_ring.h
deleted file mode 100644 (file)
index b5234f9..0000000
+++ /dev/null
@@ -1,168 +0,0 @@
-#pragma once
-/* An interface for efficient virtio implementation, currently for use by KVM
- * and lguest, but hopefully others soon.  Do NOT change this since it will
- * break existing servers and clients.
- *
- * This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * Copyright Rusty Russell IBM Corporation 2007. */
-#include <linux/types.h>
-#include <linux/virtio_types.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
-
-/* The Host uses this in used->flags to advise the Guest: don't kick me when
- * you add a buffer.  It's unreliable, so it's simply an optimization.  Guest
- * will still kick if it's out of buffers. */
-#define VRING_USED_F_NO_NOTIFY 1
-/* The Guest uses this in avail->flags to advise the Host: don't interrupt me
- * when you consume a buffer.  It's unreliable, so it's simply an
- * optimization.  */
-#define VRING_AVAIL_F_NO_INTERRUPT     1
-
-/* 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
-
-/* Virtio ring descriptors: 16 bytes.  These can chain together via "next". */
-struct vring_desc {
-       /* Address (guest-physical). */
-       __virtio64 addr;
-       /* Length. */
-       __virtio32 len;
-       /* The flags as indicated above. */
-       __virtio16 flags;
-       /* We chain unused descriptors via this, too */
-       __virtio16 next;
-};
-
-struct vring_avail {
-       __virtio16 flags;
-       __virtio16 idx;
-       __virtio16 ring[];
-};
-
-/* u32 is used here for ids for padding reasons. */
-struct vring_used_elem {
-       /* Index of start of used descriptor chain. */
-       __virtio32 id;
-       /* Total length of the descriptor chain which was used (written to) */
-       __virtio32 len;
-};
-
-struct vring_used {
-       __virtio16 flags;
-       __virtio16 idx;
-       struct vring_used_elem ring[];
-};
-
-struct vring {
-       unsigned int num;
-
-       struct vring_desc *desc;
-
-       struct vring_avail *avail;
-
-       struct vring_used *used;
-};
-
-/* Alignment requirements for vring elements.
- * When using pre-virtio 1.0 layout, these fall out naturally.
- */
-#define VRING_AVAIL_ALIGN_SIZE 2
-#define VRING_USED_ALIGN_SIZE 4
-#define VRING_DESC_ALIGN_SIZE 16
-
-/* The standard layout for the ring is a continuous chunk of memory which looks
- * like this.  We assume num is a power of 2.
- *
- * struct vring
- * {
- *     // The actual descriptors (16 bytes each)
- *     struct vring_desc desc[num];
- *
- *     // A ring of available descriptor heads with free-running index.
- *     __virtio16 avail_flags;
- *     __virtio16 avail_idx;
- *     __virtio16 available[num];
- *     __virtio16 used_event_idx;
- *
- *     // Padding to the next align boundary.
- *     char pad[];
- *
- *     // A ring of used descriptor heads with free-running index.
- *     __virtio16 used_flags;
- *     __virtio16 used_idx;
- *     struct vring_used_elem used[num];
- *     __virtio16 avail_event_idx;
- * };
- */
-/* We publish the used event index at the end of the available ring, and vice
- * versa. They are at the end for backwards compatibility. */
-#define vring_used_event(vr) ((vr)->avail->ring[(vr)->num])
-#define vring_avail_event(vr) (*(__virtio16 *)&(vr)->used->ring[(vr)->num])
-
-static inline void vring_init(struct vring *vr, unsigned int num, void *p,
-                             unsigned long align)
-{
-       vr->num = num;
-       vr->desc = p;
-       vr->avail = p + num*sizeof(struct vring_desc);
-       vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + sizeof(__virtio16)
-               + align-1) & ~(align - 1));
-}
-
-static inline unsigned vring_size(unsigned int num, unsigned long align)
-{
-       return ((sizeof(struct vring_desc) * num + sizeof(__virtio16) * (3 + num)
-                + align - 1) & ~(align - 1))
-               + sizeof(__virtio16) * 3 + sizeof(struct vring_used_elem) * num;
-}
-
-/* The following is used with USED_EVENT_IDX and AVAIL_EVENT_IDX */
-/* Assuming a given event_idx value from the other side, if
- * we have just incremented index from old to new_idx,
- * should we trigger an event? */
-static inline int vring_need_event(__u16 event_idx, __u16 new_idx, __u16 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_idx respectively.
-        * Note also that req_event and req_prod in Xen start at 1,
-        * event indexes in virtio start at 0. */
-       return (__u16)(new_idx - event_idx - 1) < (__u16)(new_idx - old);
-}
diff --git a/user/vmm/include/vmm/virtio_rng.h b/user/vmm/include/vmm/virtio_rng.h
deleted file mode 100644 (file)
index ec07b37..0000000
+++ /dev/null
@@ -1,5 +0,0 @@
-#pragma once
-/* This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers. */
-#include <linux/virtio_ids.h>
-#include <linux/virtio_config.h>
diff --git a/user/vmm/include/vmm/virtio_scsi.h b/user/vmm/include/vmm/virtio_scsi.h
deleted file mode 100644 (file)
index 1f6249f..0000000
+++ /dev/null
@@ -1,168 +0,0 @@
-/*
- * This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *
- * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- */
-
-#pragma once
-
-#include <linux/virtio_types.h>
-
-/* Default values of the CDB and sense data size configuration fields */
-#define VIRTIO_SCSI_CDB_DEFAULT_SIZE   32
-#define VIRTIO_SCSI_SENSE_DEFAULT_SIZE 96
-
-#ifndef VIRTIO_SCSI_CDB_SIZE
-#define VIRTIO_SCSI_CDB_SIZE VIRTIO_SCSI_CDB_DEFAULT_SIZE
-#endif
-#ifndef VIRTIO_SCSI_SENSE_SIZE
-#define VIRTIO_SCSI_SENSE_SIZE VIRTIO_SCSI_SENSE_DEFAULT_SIZE
-#endif
-
-/* SCSI command request, followed by data-out */
-struct virtio_scsi_cmd_req {
-       __u8 lun[8];            /* Logical Unit Number */
-       __virtio64 tag;         /* Command identifier */
-       __u8 task_attr;         /* Task attribute */
-       __u8 prio;              /* SAM command priority field */
-       __u8 crn;
-       __u8 cdb[VIRTIO_SCSI_CDB_SIZE];
-} __attribute__((packed));
-
-/* SCSI command request, followed by protection information */
-struct virtio_scsi_cmd_req_pi {
-       __u8 lun[8];            /* Logical Unit Number */
-       __virtio64 tag;         /* Command identifier */
-       __u8 task_attr;         /* Task attribute */
-       __u8 prio;              /* SAM command priority field */
-       __u8 crn;
-       __virtio32 pi_bytesout; /* DataOUT PI Number of bytes */
-       __virtio32 pi_bytesin;          /* DataIN PI Number of bytes */
-       __u8 cdb[VIRTIO_SCSI_CDB_SIZE];
-} __attribute__((packed));
-
-/* Response, followed by sense data and data-in */
-struct virtio_scsi_cmd_resp {
-       __virtio32 sense_len;           /* Sense data length */
-       __virtio32 resid;               /* Residual bytes in data buffer */
-       __virtio16 status_qualifier;    /* Status qualifier */
-       __u8 status;            /* Command completion status */
-       __u8 response;          /* Response values */
-       __u8 sense[VIRTIO_SCSI_SENSE_SIZE];
-} __attribute__((packed));
-
-/* Task Management Request */
-struct virtio_scsi_ctrl_tmf_req {
-       __virtio32 type;
-       __virtio32 subtype;
-       __u8 lun[8];
-       __virtio64 tag;
-} __attribute__((packed));
-
-struct virtio_scsi_ctrl_tmf_resp {
-       __u8 response;
-} __attribute__((packed));
-
-/* Asynchronous notification query/subscription */
-struct virtio_scsi_ctrl_an_req {
-       __virtio32 type;
-       __u8 lun[8];
-       __virtio32 event_requested;
-} __attribute__((packed));
-
-struct virtio_scsi_ctrl_an_resp {
-       __virtio32 event_actual;
-       __u8 response;
-} __attribute__((packed));
-
-struct virtio_scsi_event {
-       __virtio32 event;
-       __u8 lun[8];
-       __virtio32 reason;
-} __attribute__((packed));
-
-struct virtio_scsi_config {
-       __u32 num_queues;
-       __u32 seg_max;
-       __u32 max_sectors;
-       __u32 cmd_per_lun;
-       __u32 event_info_size;
-       __u32 sense_size;
-       __u32 cdb_size;
-       __u16 max_channel;
-       __u16 max_target;
-       __u32 max_lun;
-} __attribute__((packed));
-
-/* Feature Bits */
-#define VIRTIO_SCSI_F_INOUT                    0
-#define VIRTIO_SCSI_F_HOTPLUG                  1
-#define VIRTIO_SCSI_F_CHANGE                   2
-#define VIRTIO_SCSI_F_T10_PI                   3
-
-/* Response codes */
-#define VIRTIO_SCSI_S_OK                       0
-#define VIRTIO_SCSI_S_OVERRUN                  1
-#define VIRTIO_SCSI_S_ABORTED                  2
-#define VIRTIO_SCSI_S_BAD_TARGET               3
-#define VIRTIO_SCSI_S_RESET                    4
-#define VIRTIO_SCSI_S_BUSY                     5
-#define VIRTIO_SCSI_S_TRANSPORT_FAILURE        6
-#define VIRTIO_SCSI_S_TARGET_FAILURE           7
-#define VIRTIO_SCSI_S_NEXUS_FAILURE            8
-#define VIRTIO_SCSI_S_FAILURE                  9
-#define VIRTIO_SCSI_S_FUNCTION_SUCCEEDED       10
-#define VIRTIO_SCSI_S_FUNCTION_REJECTED        11
-#define VIRTIO_SCSI_S_INCORRECT_LUN            12
-
-/* Controlq type codes.  */
-#define VIRTIO_SCSI_T_TMF                      0
-#define VIRTIO_SCSI_T_AN_QUERY                 1
-#define VIRTIO_SCSI_T_AN_SUBSCRIBE             2
-
-/* Valid TMF subtypes.  */
-#define VIRTIO_SCSI_T_TMF_ABORT_TASK           0
-#define VIRTIO_SCSI_T_TMF_ABORT_TASK_SET       1
-#define VIRTIO_SCSI_T_TMF_CLEAR_ACA            2
-#define VIRTIO_SCSI_T_TMF_CLEAR_TASK_SET       3
-#define VIRTIO_SCSI_T_TMF_I_T_NEXUS_RESET      4
-#define VIRTIO_SCSI_T_TMF_LOGICAL_UNIT_RESET   5
-#define VIRTIO_SCSI_T_TMF_QUERY_TASK           6
-#define VIRTIO_SCSI_T_TMF_QUERY_TASK_SET       7
-
-/* Events.  */
-#define VIRTIO_SCSI_T_EVENTS_MISSED            0x80000000
-#define VIRTIO_SCSI_T_NO_EVENT                 0
-#define VIRTIO_SCSI_T_TRANSPORT_RESET          1
-#define VIRTIO_SCSI_T_ASYNC_NOTIFY             2
-#define VIRTIO_SCSI_T_PARAM_CHANGE             3
-
-/* Reasons of transport reset event */
-#define VIRTIO_SCSI_EVT_RESET_HARD             0
-#define VIRTIO_SCSI_EVT_RESET_RESCAN           1
-#define VIRTIO_SCSI_EVT_RESET_REMOVED          2
-
-#define VIRTIO_SCSI_S_SIMPLE                   0
-#define VIRTIO_SCSI_S_ORDERED                  1
-#define VIRTIO_SCSI_S_HEAD                     2
-#define VIRTIO_SCSI_S_ACA                      3
diff --git a/user/vmm/include/vmm/virtio_types.h b/user/vmm/include/vmm/virtio_types.h
deleted file mode 100644 (file)
index 78014fa..0000000
+++ /dev/null
@@ -1,43 +0,0 @@
-#pragma once
-/* Type definitions for virtio implementations.
- *
- * This header is BSD licensed so anyone can use the definitions to implement
- * compatible drivers/servers.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of IBM nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * Copyright (C) 2014 Red Hat, Inc.
- * Author: Michael S. Tsirkin <mst@redhat.com>
- */
-#include <linux/types.h>
-
-/*
- * __virtio{16,32,64} have the following meaning:
- * - __u{16,32,64} for virtio devices in legacy mode, accessed in native endian
- * - __le{16,32,64} for standard-compliant virtio devices
- */
-
-typedef __u16 __bitwise__ __virtio16;
-typedef __u32 __bitwise__ __virtio32;
-typedef __u64 __bitwise__ __virtio64;
diff --git a/user/vmm/virtio-mmio.c b/user/vmm/virtio-mmio.c
deleted file mode 100644 (file)
index ec7cb6e..0000000
+++ /dev/null
@@ -1,426 +0,0 @@
-/*
- * Virtio MMIO bindings
- *
- * Copyright (c) 2011 Linaro Limited
- *
- * Author:
- *  Peter Maydell <peter.maydell@linaro.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <stdio.h>
-#include <sys/types.h>
-#include <pthread.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <parlib/arch/arch.h>
-#include <parlib/ros_debug.h>
-#include <unistd.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/uio.h>
-#include <stdint.h>
-#include <err.h>
-#include <sys/mman.h>
-#include <vmm/vmm.h>
-#include <vmm/virtio.h>
-#include <vmm/virtio_mmio.h>
-#include <vmm/virtio_ids.h>
-#include <vmm/virtio_config.h>
-#include <vmm/sched.h>
-
-int debug_virtio_mmio = 0;
-#define DPRINTF(fmt, ...) \
-       if (debug_virtio_mmio) { printf("virtio_mmio: " fmt , ## __VA_ARGS__); }
-
-
-#define VIRT_MAGIC 0x74726976 /* 'virt' */
-/* version is a real mess. A real mess. I don't understand it at all. Let's stick with 1, which sucks, 
- * instead of 2, which seems to be not supported right. I think.
- */
-#define VIRT_VERSION 1
-#define VIRT_VENDOR 0x554D4551 /* 'QEMU' */
-
-
-typedef struct {
-       int state; // not used yet. */
-       uint64_t bar;
-       uint32_t status;
-       uint32_t isr;
-       int qsel; // queue we are on.
-       int pagesize;
-       int page_shift;
-       int device_features_word; // if this is 1, use the high 32 bits. 
-       int driver_features_word;
-       struct vqdev *vqdev;
-} mmiostate;
-
-/* TODO: probably embed this in the struct virtual_machine */
-static mmiostate mmio;
-
-void register_virtio_mmio(struct vqdev *vqdev, uint64_t virtio_base)
-{
-       mmio.bar = virtio_base;
-       mmio.vqdev = vqdev;
-}
-
-char *virtio_names[] = {
-       [VIRTIO_MMIO_MAGIC_VALUE] "VIRTIO_MMIO_MAGIC_VALUE",
-       [VIRTIO_MMIO_VERSION] "VIRTIO_MMIO_VERSION",
-       [VIRTIO_MMIO_DEVICE_ID] "VIRTIO_MMIO_DEVICE_ID",
-       [VIRTIO_MMIO_VENDOR_ID] "VIRTIO_MMIO_VENDOR_ID",
-       [VIRTIO_MMIO_DEVICE_FEATURES] "VIRTIO_MMIO_DEVICE_FEATURES",
-       [VIRTIO_MMIO_DEVICE_FEATURES_SEL] "VIRTIO_MMIO_DEVICE_FEATURES_SEL",
-       [VIRTIO_MMIO_DRIVER_FEATURES] "VIRTIO_MMIO_DRIVER_FEATURES",
-       [VIRTIO_MMIO_DRIVER_FEATURES_SEL] "VIRTIO_MMIO_DRIVER_FEATURES_SEL",
-       [VIRTIO_MMIO_GUEST_PAGE_SIZE] "VIRTIO_MMIO_GUEST_PAGE_SIZE",
-       [VIRTIO_MMIO_QUEUE_SEL] "VIRTIO_MMIO_QUEUE_SEL",
-       [VIRTIO_MMIO_QUEUE_NUM_MAX] "VIRTIO_MMIO_QUEUE_NUM_MAX",
-       [VIRTIO_MMIO_QUEUE_NUM] "VIRTIO_MMIO_QUEUE_NUM",
-       [VIRTIO_MMIO_QUEUE_ALIGN] "VIRTIO_MMIO_QUEUE_ALIGN",
-       [VIRTIO_MMIO_QUEUE_PFN] "VIRTIO_MMIO_QUEUE_PFN",
-       [VIRTIO_MMIO_QUEUE_READY] "VIRTIO_MMIO_QUEUE_READY",
-       [VIRTIO_MMIO_QUEUE_NOTIFY] "VIRTIO_MMIO_QUEUE_NOTIFY",
-       [VIRTIO_MMIO_INTERRUPT_STATUS] "VIRTIO_MMIO_INTERRUPT_STATUS",
-       [VIRTIO_MMIO_INTERRUPT_ACK] "VIRTIO_MMIO_INTERRUPT_ACK",
-       [VIRTIO_MMIO_STATUS] "VIRTIO_MMIO_STATUS",
-       [VIRTIO_MMIO_QUEUE_DESC_LOW] "VIRTIO_MMIO_QUEUE_DESC_LOW",
-       [VIRTIO_MMIO_QUEUE_DESC_HIGH] "VIRTIO_MMIO_QUEUE_DESC_HIGH",
-       [VIRTIO_MMIO_QUEUE_AVAIL_LOW] "VIRTIO_MMIO_QUEUE_AVAIL_LOW",
-       [VIRTIO_MMIO_QUEUE_AVAIL_HIGH] "VIRTIO_MMIO_QUEUE_AVAIL_HIGH",
-       [VIRTIO_MMIO_QUEUE_USED_LOW] "VIRTIO_MMIO_QUEUE_USED_LOW",
-       [VIRTIO_MMIO_QUEUE_USED_HIGH] "VIRTIO_MMIO_QUEUE_USED_HIGH",
-       [VIRTIO_MMIO_CONFIG_GENERATION] "VIRTIO_MMIO_CONFIG_GENERATION",
-};
-
-/* We're going to attempt to make mmio stateless, since the real machine is in
- * the guest kernel. From what we know so far, all IO to the mmio space is 32 bits.
- */
-static uint32_t virtio_mmio_read(struct virtual_machine *vm, uint64_t gpa)
-{
-
-       unsigned int offset = gpa - mmio.bar;
-       uint32_t low;
-       
-       DPRINTF("virtio_mmio_read offset %s 0x%x\n", virtio_names[offset],(int)offset);
-
-       /* If no backend is present, we treat most registers as
-        * read-as-zero, except for the magic number, version and
-        * vendor ID. This is not strictly sanctioned by the virtio
-        * spec, but it allows us to provide transports with no backend
-        * plugged in which don't confuse Linux's virtio code: the
-        * probe won't complain about the bad magic number, but the
-        * device ID of zero means no backend will claim it.
-        */
-       if (mmio.vqdev->numvqs == 0) {
-               switch (offset) {
-               case VIRTIO_MMIO_MAGIC_VALUE:
-                       return VIRT_MAGIC;
-               case VIRTIO_MMIO_VERSION:
-                       return VIRT_VERSION;
-               case VIRTIO_MMIO_VENDOR_ID:
-                       return VIRT_VENDOR;
-               default:
-                       return 0;
-               }
-       }
-
-
-    // WTF? Does this happen? 
-    if (offset >= VIRTIO_MMIO_CONFIG) {
-           fprintf(stderr, "Whoa. %p Reading past mmio config space? What gives?\n", gpa);
-           return -1;
-#if 0
-           offset -= VIRTIO_MMIO_CONFIG;
-           switch (size) {
-           case 1:
-                   return virtio_config_readb(vdev, offset);
-           case 2:
-                   return virtio_config_readw(vdev, offset);
-           case 4:
-                   return virtio_config_readl(vdev, offset);
-           default:
-                   abort();
-           }
-#endif
-    }
-
-#if 0
-    if (size != 4) {
-        DPRINTF("wrong size access to register!\n");
-        return 0;
-    }
-#endif
-    switch (offset) {
-    case VIRTIO_MMIO_MAGIC_VALUE:
-           return VIRT_MAGIC;
-    case VIRTIO_MMIO_VERSION:
-           return VIRT_VERSION;
-    case VIRTIO_MMIO_DEVICE_ID:
-           return mmio.vqdev->dev;
-    case VIRTIO_MMIO_VENDOR_ID:
-           return VIRT_VENDOR;
-    case VIRTIO_MMIO_DEVICE_FEATURES:
-       low = mmio.vqdev->device_features >> ((mmio.device_features_word) ? 32 : 0);
-       DPRINTF("RETURN from 0x%x 32 bits of word %s : 0x%x \n", mmio.vqdev->device_features, 
-                               mmio.device_features_word ? "high" : "low", low);
-           return low;
-    case VIRTIO_MMIO_QUEUE_NUM_MAX:
-           DPRINTF("For q %d, qnum is %d\n", mmio.qsel, mmio.vqdev->vqs[mmio.qsel].qnum);
-           return mmio.vqdev->vqs[mmio.qsel].maxqnum;
-    case VIRTIO_MMIO_QUEUE_PFN:
-           return mmio.vqdev->vqs[mmio.qsel].pfn;
-    case VIRTIO_MMIO_INTERRUPT_STATUS:
-               // pretty sure this is per-mmio, not per-q. 
-       //fprintf(stderr, "MMIO ISR 0x%08x\n", mmio.isr);
-       //fprintf(stderr, "GPA IS 0x%016x\n", gpa);
-       //fprintf(stderr, "mmio.bar IS 0x%016x\n", mmio.bar);
-               return mmio.isr;
-           //return mmio.vqdev->vqs[mmio.qsel].isr;
-    case VIRTIO_MMIO_STATUS:
-           return mmio.vqdev->vqs[mmio.qsel].status;
-    case VIRTIO_MMIO_DEVICE_FEATURES_SEL:
-    case VIRTIO_MMIO_DRIVER_FEATURES:
-    case VIRTIO_MMIO_DRIVER_FEATURES_SEL:
-    case VIRTIO_MMIO_GUEST_PAGE_SIZE:
-    case VIRTIO_MMIO_QUEUE_SEL:
-    case VIRTIO_MMIO_QUEUE_NUM:
-    case VIRTIO_MMIO_QUEUE_ALIGN:
-    case VIRTIO_MMIO_QUEUE_READY:
-    case VIRTIO_MMIO_INTERRUPT_ACK:
-           fprintf(stderr, "read of write-only register@%p\n", (void *)gpa);
-        return 0;
-    default:
-           fprintf(stderr, "bad register offset@%p\n", (void *)gpa);
-        return 0;
-    }
-    return 0;
-}
-
-static void virtio_mmio_write(struct virtual_machine *vm, uint64_t gpa,
-                              uint32_t value)
-{
-       uint64_t val64;
-       uint32_t low, high;
-       unsigned int offset = gpa - mmio.bar;
-       
-       DPRINTF("virtio_mmio_write offset %s 0x%x value 0x%x\n", virtio_names[offset], (int)offset, value);
-
-    if (offset >= VIRTIO_MMIO_CONFIG) {
-           fprintf(stderr, "Whoa. %p Writing past mmio config space? What gives?\n", gpa);
-#if 0
-        offset -= VIRTIO_MMIO_CONFIG;
-        switch (size) {
-        case 1:
-            virtio_config_writeb(vdev, offset, value);
-            break;
-        case 2:
-            virtio_config_writew(vdev, offset, value);
-            break;
-        case 4:
-            virtio_config_writel(vdev, offset, value);
-            break;
-        default:
-            abort();
-        }
-#endif
-        return;
-    }
-#if 0
-    if (size != 4) {
-        DPRINTF("wrong size access to register!\n");
-        return;
-    }
-#endif
-    switch (offset) {
-    case VIRTIO_MMIO_DEVICE_FEATURES_SEL:
-        mmio.device_features_word = value;
-        break;
-    case VIRTIO_MMIO_DEVICE_FEATURES:
-       if (mmio.device_features_word) {
-           /* changing the high word. */
-           low = mmio.vqdev->device_features;
-           high = value;
-       } else {
-           /* changing the low word. */
-           high = (mmio.vqdev->device_features >> 32);
-           low = value;
-       }
-       mmio.vqdev->device_features = ((uint64_t)high << 32) | low;
-       DPRINTF("Set VIRTIO_MMIO_DEVICE_FEATURES to %p\n", mmio.vqdev->device_features);
-       break;
-    case VIRTIO_MMIO_DRIVER_FEATURES:
-       if (mmio.driver_features_word) {
-           /* changing the high word. */
-           low = mmio.vqdev->driver_features;
-           high = value;
-       } else {
-           /* changing the low word. */
-           high = (mmio.vqdev->driver_features >> 32);
-           low = value;
-       }
-       mmio.vqdev->driver_features = ((uint64_t)high << 32) | low;
-       DPRINTF("Set VIRTIO_MMIO_DRIVER_FEATURES to %p\n", mmio.vqdev->driver_features);
-        break;
-    case VIRTIO_MMIO_DRIVER_FEATURES_SEL:
-           mmio.driver_features_word = value;
-        break;
-
-    case VIRTIO_MMIO_GUEST_PAGE_SIZE:
-           mmio.pagesize = value;
-           DPRINTF("guest page size %d bytes\n", mmio.pagesize);
-        break;
-    case VIRTIO_MMIO_QUEUE_SEL:
-           /* don't check it here. Check it on use. Or maybe check it here. Who knows. */
-           if (value < mmio.vqdev->numvqs)
-                   mmio.qsel = value;
-           else
-                   mmio.qsel = -1;
-           break;
-    case VIRTIO_MMIO_QUEUE_NUM:
-       mmio.vqdev->vqs[mmio.qsel].qnum = value;
-        break;
-    case VIRTIO_MMIO_QUEUE_ALIGN:
-       mmio.vqdev->vqs[mmio.qsel].qalign = value;
-        break;
-    case VIRTIO_MMIO_QUEUE_PFN:
-       // failure of vision: they used 32 bit numbers. Geez.
-       // v2 is better, we'll do v1 for now.
-       mmio.vqdev->vqs[mmio.qsel].pfn = value;
-                   // let's kick off the thread and see how it goes?
-                   struct virtio_threadarg *va = malloc(sizeof(*va));
-                   va->arg = &mmio.vqdev->vqs[mmio.qsel];
-
-                   va->arg->virtio = vring_new_virtqueue(mmio.qsel, 
-                                                         mmio.vqdev->vqs[mmio.qsel].qnum,
-                                                         mmio.vqdev->vqs[mmio.qsel].qalign,
-                                                         false, // weak_barriers
-                                                         (void *)(mmio.vqdev->vqs[mmio.qsel].pfn * mmio.vqdev->vqs[mmio.qsel].qalign),
-                                                         NULL, NULL, /* callbacks */
-                                                         mmio.vqdev->vqs[mmio.qsel].name);
-                   fprintf(stderr, "START THE THREAD. pfn is 0x%x, virtio is %p\n", mmio.pagesize, va->arg->virtio);
-                       vmm_run_task(vm, va->arg->func, va);
-        break;
-    case VIRTIO_MMIO_QUEUE_NOTIFY:
-           if (value < mmio.vqdev->numvqs) {
-                   mmio.qsel = value;
-           }
-        break;
-    case VIRTIO_MMIO_INTERRUPT_ACK:
-       mmio.isr &= ~value;
-       // I think we're suppose to do stuff here but the hell with it for now.
-        //virtio_update_irq(vdev);
-        break;
-    case VIRTIO_MMIO_STATUS:
-        if (!(value & VIRTIO_CONFIG_S_DRIVER_OK)) {
-            printf("VIRTIO_MMIO_STATUS write: NOT OK! 0x%x\n", value);
-        }
-
-       mmio.status |= value & 0xff;
-
-        if (value & VIRTIO_CONFIG_S_DRIVER_OK) {
-            printf("VIRTIO_MMIO_STATUS write: OK! 0x%x\n", value);
-        }
-
-        break;
-    case VIRTIO_MMIO_QUEUE_DESC_LOW:
-           val64 = mmio.vqdev->vqs[mmio.qsel].qdesc;
-           val64 = val64 >> 32;
-           val64 = (val64 <<32) | value;
-           mmio.vqdev->vqs[mmio.qsel].qdesc = val64;
-           DPRINTF("qdesc set low result 0xx%x\n", val64);
-           break;
-           
-    case VIRTIO_MMIO_QUEUE_DESC_HIGH:
-           val64 = (uint32_t) mmio.vqdev->vqs[mmio.qsel].qdesc;
-           mmio.vqdev->vqs[mmio.qsel].qdesc = (((uint64_t) value) <<32) | val64;
-           DPRINTF("qdesc set high result 0xx%x\n", mmio.vqdev->vqs[mmio.qsel].qdesc);
-           break;
-           
-/* Selected queue's Available Ring address, 64 bits in two halves */
-    case VIRTIO_MMIO_QUEUE_AVAIL_LOW:
-           val64 = mmio.vqdev->vqs[mmio.qsel].qavail;
-           val64 = val64 >> 32;
-           val64 = (val64 <<32) | value;
-           mmio.vqdev->vqs[mmio.qsel].qavail = val64;
-           DPRINTF("qavail set low result 0xx%x\n", val64);
-           break;
-    case VIRTIO_MMIO_QUEUE_AVAIL_HIGH:
-           val64 = (uint32_t) mmio.vqdev->vqs[mmio.qsel].qavail;
-           mmio.vqdev->vqs[mmio.qsel].qavail = (((uint64_t) value) <<32) | val64;
-           DPRINTF("qavail set high result 0xx%x\n", mmio.vqdev->vqs[mmio.qsel].qavail);
-           break;
-           
-/* Selected queue's Used Ring address, 64 bits in two halves */
-    case VIRTIO_MMIO_QUEUE_USED_LOW:
-           val64 = mmio.vqdev->vqs[mmio.qsel].qused;
-           val64 = val64 >> 32;
-           val64 = (val64 <<32) | value;
-           mmio.vqdev->vqs[mmio.qsel].qused = val64;
-           DPRINTF("qused set low result 0xx%x\n", val64);
-           break;
-    case VIRTIO_MMIO_QUEUE_USED_HIGH:
-           val64 = (uint32_t) mmio.vqdev->vqs[mmio.qsel].qused;
-           mmio.vqdev->vqs[mmio.qsel].qused = (((uint64_t) value) <<32) | val64;
-           DPRINTF("qused set used result 0xx%x\n", mmio.vqdev->vqs[mmio.qsel].qused);
-           break;
-           
-       // for v2. 
-    case VIRTIO_MMIO_QUEUE_READY:
-           if (value) {
-                   // let's kick off the thread and see how it goes?
-                   struct virtio_threadarg *va = malloc(sizeof(*va));
-                   va->arg = &mmio.vqdev->vqs[mmio.qsel];
-                   va->arg->virtio = (void *)(va->arg->pfn * mmio.pagesize);
-                   fprintf(stderr, "START THE THREAD. pfn is 0x%x, virtio is %p\n", mmio.pagesize, va->arg->virtio);
-                       vmm_run_task(vm, va->arg->func, va);
-           }
-           break;
-
-    case VIRTIO_MMIO_MAGIC_VALUE:
-    case VIRTIO_MMIO_VERSION:
-    case VIRTIO_MMIO_DEVICE_ID:
-    case VIRTIO_MMIO_VENDOR_ID:
-//    case VIRTIO_MMIO_HOSTFEATURES:
-    case VIRTIO_MMIO_QUEUE_NUM_MAX:
-    case VIRTIO_MMIO_INTERRUPT_STATUS:
-        DPRINTF("write to readonly register\n");
-        break;
-
-    default:
-        DPRINTF("bad register offset 0x%x\n", offset);
-    }
-
-}
-
-void virtio_mmio_set_vring_irq(void)
-{
-       mmio.isr |= VIRTIO_MMIO_INT_VRING;
-}
-
-int virtio_mmio(struct guest_thread *gth, uint64_t gpa, int destreg,
-                uint64_t *regp, int store)
-{
-       if (store) {
-               virtio_mmio_write(gth_to_vm(gth), gpa, *regp);
-               DPRINTF("Write: mov %s to %s @%p val %p\n", regname(destreg),
-                       virtio_names[(uint8_t)gpa], gpa, *regp);
-       } else {
-               *regp = virtio_mmio_read(gth_to_vm(gth), gpa);
-               DPRINTF("Read: Set %s from %s @%p to %p\n", regname(destreg),
-                       virtio_names[(uint8_t)gpa], gpa, *regp);
-       }
-
-}
diff --git a/user/vmm/virtio_ring.c b/user/vmm/virtio_ring.c
deleted file mode 100644 (file)
index 762a8e0..0000000
+++ /dev/null
@@ -1,1130 +0,0 @@
-/* Virtio ring implementation.
- *
- *  Copyright 2007 Rusty Russell IBM Corporation
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- */
-#include <stdio.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-#include <unistd.h>
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/uio.h>
-#include <stdint.h>
-#include <err.h>
-#include <sys/mman.h>
-#include <parlib/uthread.h>
-#include <parlib/ros_debug.h>
-#include <vmm/virtio.h>
-
-#define BAD_RING(_vq, fmt, args...)                            \
-       do {                                                    \
-       fprintf(stderr, "%s:"fmt, (_vq)->vq.name, ##args);      \
-       while (1); \
-       } while (0)
-/* Caller is supposed to guarantee no reentry. */
-#define START_USE(_vq)                                         \
-       do {                                                    \
-               if ((_vq)->in_use){                             \
-                       fprintf(stderr, "%s:in_use = %i\n",     \
-                             (_vq)->vq.name, (_vq)->in_use);   \
-                       exit(1);                                \
-               }                                               \
-               (_vq)->in_use = __LINE__;                       \
-       } while (0)
-#define BUG_ON(x) do { if (x) {fprintf(stderr, "bug\n"); while (1);} } while (0)
-#define END_USE(_vq) \
-       do { BUG_ON(!(_vq)->in_use); (_vq)->in_use = 0; } while(0)
-
-int vringdebug = 0;
-
-struct vring_virtqueue {
-       struct virtqueue vq;
-
-       /* Actual memory layout for this queue */
-       struct vring vring;
-
-       /* Can we use weak barriers? */
-       bool weak_barriers;
-
-       /* Other side has made a mess, don't try any more. */
-       bool broken;
-
-       /* Host supports indirect buffers */
-       bool indirect;
-
-       /* Host publishes avail event idx */
-       bool event;
-
-       /* Head of free buffer list. */
-       unsigned int free_head;
-       /* Number we've added since last sync. */
-       unsigned int num_added;
-
-       /* Last used index we've seen. */
-       uint16_t last_used_idx;
-
-       uint16_t last_avail_idx;
-
-       /* How to notify other side. FIXME: commonalize hcalls! */
-        bool(*notify) (struct virtqueue * vq);
-
-       /* They're supposed to lock for us. */
-       unsigned int in_use;
-
-       /* Figure out if their kicks are too delayed. */
-       bool last_add_time_valid;
-       uint64_t last_add_time;
-
-       /* Tokens for callbacks. */
-       void *data[];
-};
-
-/* Return the container/struct holding the object 'ptr' points to */
-
-#define container_of(ptr, type, member) ({                                     \
-       (type*)((char*)ptr - offsetof(type, member));                             \
-})
-#define to_vvq(_vq) container_of(_vq, struct vring_virtqueue, vq)
-
-static inline struct scatterlist *sg_next_chained(struct scatterlist *sg,
-                                                                                                 unsigned int *count)
-{
-       return NULL;
-}
-
-static inline struct scatterlist *sg_next_arr(struct scatterlist *sg,
-                                                                                         unsigned int *count)
-{
-       if (--(*count) == 0)
-               return NULL;
-       return sg + 1;
-}
-
-/* Set up an indirect table of descriptors and add it to the queue. */
-static inline int vring_add_indirect(struct vring_virtqueue *vq,
-                                                                        struct scatterlist *sgs[],
-                                                                        struct scatterlist *(*next)
-                                                                         (struct scatterlist *, unsigned int *),
-                                                                        unsigned int total_sg,
-                                                                        unsigned int total_out,
-                                                                        unsigned int total_in,
-                                                                        unsigned int out_sgs,
-                                                                        unsigned int in_sgs, int flags)
-{
-       struct vring_desc *desc;
-       unsigned head;
-       struct scatterlist *sg;
-       int i, n;
-
-       /*
-        * We require lowmem mappings for the descriptors because
-        * otherwise virt_to_phys will give us bogus addresses in the
-        * virtqueue.
-        */
-       flags = 0;
-
-       desc = calloc(total_sg, sizeof(struct vring_desc));
-       if (!desc)
-               return -ENOMEM;
-
-       /* Transfer entries from the sg lists into the indirect page */
-       i = 0;
-       for (n = 0; n < out_sgs; n++) {
-               for (sg = sgs[n]; sg; sg = next(sg, &total_out)) {
-                       desc[i].flags = VRING_DESC_F_NEXT;
-                       desc[i].addr = sg_phys(sg->v);
-                       desc[i].len = sg->length;
-                       desc[i].next = i + 1;
-                       i++;
-               }
-       }
-       for (; n < (out_sgs + in_sgs); n++) {
-               for (sg = sgs[n]; sg; sg = next(sg, &total_in)) {
-                       desc[i].flags = VRING_DESC_F_NEXT | VRING_DESC_F_WRITE;
-                       desc[i].addr = sg_phys(sg->v);
-                       desc[i].len = sg->length;
-                       desc[i].next = i + 1;
-                       i++;
-               }
-       }
-       BUG_ON(i != total_sg);
-
-       /* Last one doesn't continue. */
-       desc[i - 1].flags &= ~VRING_DESC_F_NEXT;
-       desc[i - 1].next = 0;
-
-       /* We're about to use a buffer */
-       vq->vq.num_free--;
-
-       /* Use a single buffer which doesn't continue */
-       head = vq->free_head;
-       vq->vring.desc[head].flags = VRING_DESC_F_INDIRECT;
-       vq->vring.desc[head].addr = virt_to_phys(desc);
-       /* kmemleak gives a false positive, as it's hidden by virt_to_phys */
-       //kmemleak_ignore(desc);
-       vq->vring.desc[head].len = i * sizeof(struct vring_desc);
-
-       /* Update free pointer */
-       vq->free_head = vq->vring.desc[head].next;
-
-       return head;
-}
-
-static inline int virtqueue_add_avail(struct virtqueue *_vq,
-                                                               struct scatterlist *sgs[],
-                                                               struct scatterlist *(*next)
-                                                                (struct scatterlist *, unsigned int *),
-                                                               unsigned int total_out,
-                                                               unsigned int total_in,
-                                                               unsigned int out_sgs,
-                                                               unsigned int in_sgs, void *data, int flags)
-{
-       int canary;
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       struct scatterlist *sg;
-       unsigned int i, n, avail, prev = 0, total_sg;
-       int head;
-
-       START_USE(vq);
-
-       BUG_ON(data == NULL);
-
-#ifdef DEBUG
-       {
-               ktime_t now = ktime_get();
-
-               /* No kick or get, with .1 second between?  Warn. */
-               if (vq->last_add_time_valid)
-                       WARN_ON(ktime_to_ms(ktime_sub(now, vq->last_add_time))
-                                       > 100);
-               vq->last_add_time = now;
-               vq->last_add_time_valid = true;
-       }
-#endif
-
-       total_sg = total_in + total_out;
-
-       /* If the host supports indirect descriptor tables, and we have multiple
-        * buffers, then go indirect. FIXME: tune this threshold */
-       if (vq->indirect && total_sg > 1 && vq->vq.num_free) {
-               head = vring_add_indirect(vq, sgs, next, total_sg, total_out,
-                                         total_in, out_sgs, in_sgs, flags);
-               if (head >= 0)
-                       goto add_head;
-       }
-
-       BUG_ON(total_sg > vq->vring.num);
-       BUG_ON(total_sg == 0);
-       canary = vq->vq.num_free;
-
-       if (vq->vq.num_free < total_sg) {
-               if (vringdebug) fprintf(stderr, "Can't add buf len %i - avail = %i\n",
-                                total_sg, vq->vq.num_free);
-               /* FIXME: for historical reasons, we force a notify here if
-                * there are outgoing parts to the buffer.  Presumably the
-                * host should service the ring ASAP. */
-               if (out_sgs)
-                       vq->notify(&vq->vq);
-               END_USE(vq);
-               return -ENOSPC;
-       }
-       /* We're about to use some buffers from the free list. */
-       vq->vq.num_free -= total_sg;
-
-       head = i = vq->free_head;
-       for (n = 0; n < out_sgs; n++) {
-               for (sg = sgs[n]; sg; sg = next(sg, &total_out)) {
-                       vq->vring.desc[i].flags = VRING_DESC_F_NEXT;
-                       vq->vring.desc[i].addr = sg_phys(sg->v);
-                       vq->vring.desc[i].len = sg->length;
-                       prev = i;
-                       i = vq->vring.desc[i].next;
-               }
-       }
-       for (; n < (out_sgs + in_sgs); n++) {
-               for (sg = sgs[n]; sg; sg = next(sg, &total_in)) {
-                       vq->vring.desc[i].flags = VRING_DESC_F_NEXT | VRING_DESC_F_WRITE;
-                       vq->vring.desc[i].addr = sg_phys(sg->v);
-                       vq->vring.desc[i].len = sg->length;
-                       prev = i;
-                       i = vq->vring.desc[i].next;
-               }
-       }
-
-       /* Last one doesn't continue. */
-       vq->vring.desc[prev].flags &= ~VRING_DESC_F_NEXT;
-
-       /* Update free pointer */
-       vq->free_head = i;
-add_head:
-       /* Set token. */
-       vq->data[head] = data;
-       /* Put entry in available array (but don't update avail->idx until they
-        * do sync). */
-       avail = (vq->vring.avail->idx & (vq->vring.num - 1));
-       vq->vring.avail->ring[avail] = head;
-       /* Descriptors and available array need to be set before we expose the
-        * new available array entries. */
-       virtio_wmb(vq->weak_barriers);
-       vq->vring.avail->idx++;
-       vq->num_added++;
-
-       /* This is very unlikely, but theoretically possible.  Kick
-        * just in case. */
-       if (unlikely(vq->num_added == (1 << 16) - 1))
-               virtqueue_kick(_vq);
-
-       if (vringdebug) fprintf(stderr, "Added buffer head %i to %p\n", head, vq);
-       END_USE(vq);
-       BUG_ON(vq->vq.num_free > canary);
-       return 0;
-}
-
-/**
- * virtqueue_add_outbuf_avail - expose output buffers to other end
- * @vq: the struct virtqueue we're talking about.
- * @sgs: array of scatterlists (need not be terminated!)
- * @num: the number of scatterlists readable by other side
- * @data: the token identifying the buffer.
- * @gfp: how to do memory allocations (if necessary).
- *
- * Caller must ensure we don't call this with other virtqueue operations
- * at the same time (except where noted).
- *
- * Returns zero or a negative error (ie. ENOSPC, ENOMEM).
- */
-int virtqueue_add_outbuf_avail(struct virtqueue *vq,
-                                                struct scatterlist sg[], unsigned int num,
-                                                void *data, int flags)
-{
-       return virtqueue_add_avail(vq, &sg, sg_next_arr, num, 0, 1, 0, data, flags);
-}
-
-/**
- * virtqueue_add_inbuf_avail - expose input buffers to other end
- * @vq: the struct virtqueue we're talking about.
- * @sgs: array of scatterlists (need not be terminated!)
- * @num: the number of scatterlists writable by other side
- * @data: the token identifying the buffer.
- * @gfp: how to do memory allocations (if necessary).
- *
- * Caller must ensure we don't call this with other virtqueue operations
- * at the same time (except where noted).
- *
- * Returns zero or a negative error (ie. ENOSPC, ENOMEM).
- */
-int virtqueue_add_inbuf_avail(struct virtqueue *vq,
-                                               struct scatterlist sg[], unsigned int num,
-                                               void *data, int flags)
-{
-       return virtqueue_add_avail(vq, &sg, sg_next_arr, 0, num, 0, 1, data, flags);
-}
-
-/**
- * virtqueue_kick_prepare - first half of split virtqueue_kick call.
- * @vq: the struct virtqueue
- *
- * Instead of virtqueue_kick(), you can do:
- *     if (virtqueue_kick_prepare(vq))
- *             virtqueue_notify(vq);
- *
- * This is sometimes useful because the virtqueue_kick_prepare() needs
- * to be serialized, but the actual virtqueue_notify() call does not.
- */
-bool virtqueue_kick_prepare(struct virtqueue * _vq)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       uint16_t new, old;
-       bool needs_kick;
-
-       START_USE(vq);
-       /* We need to expose available array entries before checking avail
-        * event. */
-       virtio_mb(vq->weak_barriers);
-
-       old = vq->vring.avail->idx - vq->num_added;
-       new = vq->vring.avail->idx;
-       vq->num_added = 0;
-
-#ifdef DEBUG
-       if (vq->last_add_time_valid) {
-               WARN_ON(ktime_to_ms(ktime_sub(ktime_get(), vq->last_add_time)) > 100);
-       }
-       vq->last_add_time_valid = false;
-#endif
-
-       if (vq->event) {
-               needs_kick = vring_need_event(vring_avail_event(&vq->vring), new, old);
-       } else {
-               needs_kick = !(vq->vring.used->flags & VRING_USED_F_NO_NOTIFY);
-       }
-       END_USE(vq);
-       return needs_kick;
-}
-
-/**
- * virtqueue_notify - second half of split virtqueue_kick call.
- * @vq: the struct virtqueue
- *
- * This does not need to be serialized.
- *
- * Returns false if host notify failed or queue is broken, otherwise true.
- */
-bool virtqueue_notify(struct virtqueue * _vq)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-
-       if (unlikely(vq->broken))
-               return false;
-
-       /* Prod other side to tell it about changes. */
-       if (!vq->notify(_vq)) {
-               vq->broken = true;
-               return false;
-       }
-       return true;
-}
-
-/**
- * virtqueue_kick - update after add_buf
- * @vq: the struct virtqueue
- *
- * After one or more virtqueue_add_* calls, invoke this to kick
- * the other side.
- *
- * Caller must ensure we don't call this with other virtqueue
- * operations at the same time (except where noted).
- *
- * Returns false if kick failed, otherwise true.
- */
-bool virtqueue_kick(struct virtqueue * vq)
-{
-       if (virtqueue_kick_prepare(vq))
-               return virtqueue_notify(vq);
-       return true;
-}
-
-static void detach_buf(struct vring_virtqueue *vq, unsigned int head)
-{
-       unsigned int i;
-
-       /* Clear data ptr. */
-       vq->data[head] = NULL;
-
-       /* Put back on free list: find end */
-       i = head;
-
-       /* Free the indirect table */
-       if (vq->vring.desc[i].flags & VRING_DESC_F_INDIRECT) ;  //kfree(phys_to_virt(vq->vring.desc[i].addr));
-
-       while (vq->vring.desc[i].flags & VRING_DESC_F_NEXT) {
-               i = vq->vring.desc[i].next;
-               vq->vq.num_free++;
-       }
-
-       vq->vring.desc[i].next = vq->free_head;
-       vq->free_head = head;
-       /* Plus final descriptor */
-       vq->vq.num_free++;
-}
-
-static inline bool more_used(const struct vring_virtqueue *vq)
-{
-       return vq->last_used_idx != vq->vring.used->idx;
-}
-
-/**
- * virtqueue_get_buf_used - get the next used buffer
- * @vq: the struct virtqueue we're talking about.
- * @len: the length written into the buffer
- *
- * If the driver wrote data into the buffer, @len will be set to the
- * amount written.  This means you don't need to clear the buffer
- * beforehand to ensure there's no data leakage in the case of short
- * writes.
- *
- * Caller must ensure we don't call this with other virtqueue
- * operations at the same time (except where noted).
- *
- * Returns NULL if there are no used buffers, or the "data" token
- * handed to virtqueue_add_*().
- */
-void *virtqueue_get_buf_used(struct virtqueue *_vq, unsigned int *len)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       void *ret;
-       unsigned int i;
-       uint16_t last_used;
-
-       START_USE(vq);
-
-       if (unlikely(vq->broken)) {
-               END_USE(vq);
-               return NULL;
-       }
-
-       if (!more_used(vq)) {
-               if (vringdebug) fprintf(stderr, "No more buffers in queue\n");
-               END_USE(vq);
-               return NULL;
-       }
-
-       /* Only get used array entries after they have been exposed by host. */
-       virtio_rmb(vq->weak_barriers);
-
-       last_used = (vq->last_used_idx & (vq->vring.num - 1));
-       i = vq->vring.used->ring[last_used].id;
-       *len = vq->vring.used->ring[last_used].len;
-
-       if (unlikely(i >= vq->vring.num)) {
-               BAD_RING(vq, "id %u out of range\n", i);
-               return NULL;
-       }
-       if (unlikely(!vq->data[i])) {
-               BAD_RING(vq, "id %u is not a head!\n", i);
-               return NULL;
-       }
-
-       /* detach_buf clears data, so grab it now. */
-       ret = vq->data[i];
-       detach_buf(vq, i);
-       vq->last_used_idx++;
-       /* If we expect an interrupt for the next entry, tell host
-        * by writing event index and flush out the write before
-        * the read in the next get_buf call. */
-       if (!(vq->vring.avail->flags & VRING_AVAIL_F_NO_INTERRUPT)) {
-               vring_used_event(&vq->vring) = vq->last_used_idx;
-               virtio_mb(vq->weak_barriers);
-       }
-#ifdef DEBUG
-       vq->last_add_time_valid = false;
-#endif
-
-       END_USE(vq);
-       return ret;
-}
-
-/**
- * virtqueue_disable_cb - disable callbacks
- * @vq: the struct virtqueue we're talking about.
- *
- * Note that this is not necessarily synchronous, hence unreliable and only
- * useful as an optimization.
- *
- * Unlike other operations, this need not be serialized.
- */
-void virtqueue_disable_cb(struct virtqueue *_vq)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-
-       vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
-}
-
-/**
- * virtqueue_enable_cb_prepare - restart callbacks after disable_cb
- * @vq: the struct virtqueue we're talking about.
- *
- * This re-enables callbacks; it returns current queue state
- * in an opaque unsigned value. This value should be later tested by
- * virtqueue_poll, to detect a possible race between the driver checking for
- * more work, and enabling callbacks.
- *
- * Caller must ensure we don't call this with other virtqueue
- * operations at the same time (except where noted).
- */
-unsigned virtqueue_enable_cb_prepare(struct virtqueue *_vq)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       uint16_t last_used_idx;
-
-       START_USE(vq);
-
-       /* We optimistically turn back on interrupts, then check if there was
-        * more to do. */
-       /* Depending on the VIRTIO_RING_F_EVENT_IDX feature, we need to
-        * either clear the flags bit or point the event index at the next
-        * entry. Always do both to keep code simple. */
-       vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
-       vring_used_event(&vq->vring) = last_used_idx = vq->last_used_idx;
-       END_USE(vq);
-       return last_used_idx;
-}
-
-/**
- * virtqueue_poll - query pending used buffers
- * @vq: the struct virtqueue we're talking about.
- * @last_used_idx: virtqueue state (from call to virtqueue_enable_cb_prepare).
- *
- * Returns "true" if there are pending used buffers in the queue.
- *
- * This does not need to be serialized.
- */
-bool virtqueue_poll_used(struct virtqueue * _vq, unsigned last_used_idx)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-
-       virtio_mb(vq->weak_barriers);
-       return (uint16_t) last_used_idx != vq->vring.used->idx;
-}
-
-/**
- * virtqueue_enable_cb - restart callbacks after disable_cb.
- * @vq: the struct virtqueue we're talking about.
- *
- * This re-enables callbacks; it returns "false" if there are pending
- * buffers in the queue, to detect a possible race between the driver
- * checking for more work, and enabling callbacks.
- *
- * Caller must ensure we don't call this with other virtqueue
- * operations at the same time (except where noted).
- */
-bool virtqueue_enable_cb(struct virtqueue * _vq)
-{
-       unsigned last_used_idx = virtqueue_enable_cb_prepare(_vq);
-       return !virtqueue_poll_used(_vq, last_used_idx);
-}
-
-/**
- * virtqueue_enable_cb_delayed - restart callbacks after disable_cb.
- * @vq: the struct virtqueue we're talking about.
- *
- * This re-enables callbacks but hints to the other side to delay
- * interrupts until most of the available buffers have been processed;
- * it returns "false" if there are many pending buffers in the queue,
- * to detect a possible race between the driver checking for more work,
- * and enabling callbacks.
- *
- * Caller must ensure we don't call this with other virtqueue
- * operations at the same time (except where noted).
- */
-bool virtqueue_enable_cb_delayed(struct virtqueue * _vq)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       uint16_t bufs;
-
-       START_USE(vq);
-
-       /* We optimistically turn back on interrupts, then check if there was
-        * more to do. */
-       /* Depending on the VIRTIO_RING_F_USED_EVENT_IDX feature, we need to
-        * either clear the flags bit or point the event index at the next
-        * entry. Always do both to keep code simple. */
-       vq->vring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
-       /* TODO: tune this threshold */
-       bufs = (uint16_t) (vq->vring.avail->idx - vq->last_used_idx) * 3 / 4;
-       vring_used_event(&vq->vring) = vq->last_used_idx + bufs;
-       virtio_mb(vq->weak_barriers);
-       if (unlikely((uint16_t) (vq->vring.used->idx - vq->last_used_idx) > bufs)) {
-               END_USE(vq);
-               return false;
-       }
-
-       END_USE(vq);
-       return true;
-}
-
-/**
- * virtqueue_detach_unused_buf - detach first unused buffer
- * @vq: the struct virtqueue we're talking about.
- *
- * Returns NULL or the "data" token handed to virtqueue_add_*().
- * This is not valid on an active queue; it is useful only for device
- * shutdown.
- */
-void *virtqueue_detach_unused_buf(struct virtqueue *_vq)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       unsigned int i;
-       void *buf;
-
-       START_USE(vq);
-
-       for (i = 0; i < vq->vring.num; i++) {
-               if (!vq->data[i])
-                       continue;
-               /* detach_buf clears data, so grab it now. */
-               buf = vq->data[i];
-               detach_buf(vq, i);
-               vq->vring.avail->idx--;
-               END_USE(vq);
-               return buf;
-       }
-       /* That should have freed everything. */
-       BUG_ON(vq->vq.num_free != vq->vring.num);
-
-       END_USE(vq);
-       return NULL;
-}
-
-struct virtqueue *vring_new_virtqueue(unsigned int index,
-                                                                         unsigned int num,
-                                                                         unsigned int vring_align,
-                                                                         bool weak_barriers,
-                                                                         void *pages,
-                                                                         bool(*notify) (struct virtqueue *),
-                                                                         void (*callback) (struct virtqueue *),
-                                                                         const char *name)
-{
-       struct vring_virtqueue *vq;
-       unsigned int i;
-
-       /* We assume num is a power of 2. */
-       if (num & (num - 1)) {
-               if (vringdebug) fprintf(stderr, "Bad virtqueue length %u\n", num);
-               exit(1);
-       }
-
-       vq = mmap((int*)4096, sizeof(*vq) + sizeof(void *) * num + 2*PGSIZE, PROT_READ | PROT_WRITE,
-                 MAP_ANONYMOUS, -1, 0);
-       if (vq == MAP_FAILED) {
-               perror("Unable to mmap vq");
-               exit(1);
-       }
-       fprintf(stderr, "VQ %p %d bytes \n", vq, num * vring_align); /* really? */
-       if (!vq)
-               return NULL;
-
-       // I *think* they correctly offset from vq for the vring? 
-       vring_init(&vq->vring, num, pages, vring_align);
-       fprintf(stderr, "done vring init\n");
-       vq->vq.callback = callback;
-       vq->vq.name = name;
-       vq->vq.num_free = num;
-       vq->vq.index = index;
-       vq->notify = notify;
-       vq->weak_barriers = weak_barriers;
-       vq->broken = false;
-       vq->last_used_idx = 0;
-       vq->num_added = 0;
-#ifdef DEBUG
-       vq->in_use = false;
-       vq->last_add_time_valid = false;
-#endif
-
-       vq->indirect = 0;       // virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC);
-       vq->event = 0;  //virtio_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX);
-
-       /* No callback?  Tell other side not to bother us. */
-       if (!callback)
-               vq->vring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
-
-       /* Put everything in free lists. */
-       vq->free_head = 0;
-       for (i = 0; i < num - 1; i++) {
-               vq->vring.desc[i].next = i + 1;
-               vq->data[i] = NULL;
-       }
-       vq->data[i] = NULL;
-
-       return &vq->vq;
-}
-
-void vring_del_virtqueue(struct virtqueue *vq)
-{
-
-}
-
-#if 0
-/* Manipulates transport-specific feature bits. */
-void vring_transport_features(struct virtio_device *vdev)
-{
-       unsigned int i;
-
-       for (i = VIRTIO_TRANSPORT_F_START; i < VIRTIO_TRANSPORT_F_END; i++) {
-               switch (i) {
-                       case VIRTIO_RING_F_INDIRECT_DESC:
-                               break;
-                       case VIRTIO_RING_F_EVENT_IDX:
-                               break;
-                       default:
-                               /* We don't understand this bit. */
-                               clear_bit(i, vdev->features);
-               }
-       }
-}
-#endif
-/**
- * virtqueue_get_vring_size - return the size of the virtqueue's vring
- * @vq: the struct virtqueue containing the vring of interest.
- *
- * Returns the size of the vring.  This is mainly used for boasting to
- * userspace.  Unlike other operations, this need not be serialized.
- */
-unsigned int virtqueue_get_vring_size(struct virtqueue *_vq)
-{
-
-       struct vring_virtqueue *vq = to_vvq(_vq);
-
-       return vq->vring.num;
-}
-
-bool virtqueue_is_broken(struct virtqueue * _vq)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-
-       return vq->broken;
-}
-
-
-/* new stuff. This is now more symmetric. */
-
-int avail(struct virtqueue *_vq)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       return vq->vring.avail->idx;
-}
-
-void showvq(struct virtqueue *_vq)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       struct vring_desc *desc = vq->vring.desc;
-       struct vring_avail *a = vq->vring.avail;
-       struct vring_used *u = vq->vring.used;
-
-//     int i;
-       fprintf(stderr, "vq %p, desc %p, avail %p, used %p broken %d\n", vq, desc, a, u, vq->broken);
-       fprintf(stderr, "vq; %s, index 0x%x, num_free 0x%x, priv %p\n", vq->vq.name, vq->vq.index, vq->vq.num_free, vq->vq.priv);
-       fprintf(stderr, "avail: flags 0x%x idx 0x%x\n", a->flags, a->idx);
-       fprintf(stderr, "used: flags 0x%x idx 0x%x \n", u->flags, u->idx);
-}
-
-void showdesc(struct virtqueue *_vq, uint16_t head)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       struct vring_desc *d = &vq->vring.desc[head];
-
-       while (1) {
-               fprintf(stderr, "%d(%p): %p 0x%x 0x%x[", head, d, (void *)d->addr, d->len, d->flags);
-               if (d->flags & VRING_DESC_F_WRITE)
-                       fprintf(stderr, "W");
-               else
-                       fprintf(stderr, "R");
-               if (d->flags & VRING_DESC_F_INDIRECT)
-                       fprintf(stderr, "I");
-               fprintf(stderr, "]");
-               if (d->flags & VRING_DESC_F_NEXT)
-                       fprintf(stderr, "->0x%x,", d->next);
-               else
-                       break;
-               d++;
-               head++;
-               head = head & (vq->vring.num - 1);
-       }
-       fprintf(stderr, "\n");
-
-}
-
-/* This gets the next entry in the queue as one sglist.
- * we should probably mirror the
- * in linux virtio they have all kinds of tricks they play to avoid
- * vmexits and such on virtio. I don't care. The whole point of this is
- * to avoid vmexits but leave the VMMCP active on the cores. We're
- * going to be in a core rich world and putting in timesharing hacks
- * makes no sense.
- */
-int virtio_get_buf_avail_start(struct virtqueue *_vq, uint16_t *last_avail_idx, struct scatterlist **sgp, int *sgplen)
-{
-       struct scatterlist *sg;
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       uint16_t avail_idx, i, head;
-       int sglen;
-//     int err;
-
-       avail_idx = vq->vring.avail->idx;
-
-       if (*last_avail_idx == avail_idx)
-               return vq->vring.num;
-
-       /* coherence here: Only get avail ring entries after they have been exposed by guest. */
-
-       i = *last_avail_idx & (vq->vring.num - 1);
-
-       head = vq->vring.avail->ring[i];
-
-       if (head >= vq->vring.num) {
-               if (vringdebug) fprintf(stderr, "Guest says index %u > %u is available",
-                          head, vq->vring.num);
-               return -EINVAL;
-       }
-
-       (*last_avail_idx)++;
-
-       struct vring_desc *d = vq->vring.desc;
-       for(i = head, sglen = 1; d[i].flags & VRING_DESC_F_NEXT; sglen++) {
-               i++;
-               i = i & (vq->vring.num - 1);
-       }
-
-       if (sgp) {
-               if (vringdebug) fprintf(stderr, "entry @%d is %d long\n", head, sglen);
-
-               sg = calloc(sglen, sizeof(*sg));
-               *sgp = sg;
-               *sgplen = sglen;
-
-               for(i = head; sglen; sglen--) {
-                       sg->v = (void *)d[i].addr;
-                       sg->length = d[i].len;
-                       i++;
-                       sg++;
-                       i = i & (vq->vring.num - 1);
-               }
-       }
-       return head;
-}
-
-
-void virtio_get_buf_avail_done(struct virtqueue *_vq, uint16_t last_avail_idx, int id, int len)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       /* consume it. */
-       struct vring_used *u = vq->vring.used;
-       u->ring[u->idx].id = id;
-       u->ring[u->idx].len = len;
-       u->idx = (u->idx + 1) % vq->vring.num;
-}
-
-#define lg_last_avail(vq)      ((vq)->last_avail_idx)
-#define guest_limit ((1ULL<<48)-1)
-/*L:200
- * Device Handling.
- *
- * When the Guest gives us a buffer, it sends an array of addresses and sizes.
- * We need to make sure it's not trying to reach into the Launcher itself, so
- * we have a convenient routine which checks it and exits with an error message
- * if something funny is going on:
- */
-static void *_check_pointer(unsigned long addr, unsigned int size,
-                           unsigned int line)
-{
-       /*
-        * Check if the requested address and size exceeds the allocated memory,
-        * or addr + size wraps around.
-        */
-       if ((addr + size) > guest_limit || (addr + size) < addr)
-               errx(1, "%s:%i: Invalid address %#lx", __FILE__, line, addr);
-       /*
-        * We return a pointer for the caller's convenience, now we know it's
-        * safe to use.
-        */
-       return (void *)addr;
-}
-/* A macro which transparently hands the line number to the real function. */
-#define check_pointer(addr,size) _check_pointer(addr, size, __LINE__)
-
-/*
- * Each buffer in the virtqueues is actually a chain of descriptors.  This
- * function returns the next descriptor in the chain, or vq->vring.num if we're
- * at the end.
- */
-static unsigned next_desc(struct vring_desc *desc,
-                         unsigned int i, unsigned int max)
-{
-       unsigned int next;
-
-       /* If this descriptor says it doesn't chain, we're done. */
-       if (!(desc[i].flags & VRING_DESC_F_NEXT))
-               return max;
-
-       /* Check they're not leading us off end of descriptors. */
-       next = desc[i].next;
-       /* Make sure compiler knows to grab that: we don't want it changing! */
-       wmb();
-
-       if (next >= max)
-               errx(1, "Desc next is %u", next);
-
-       return next;
-}
-
-/*
- * This looks in the virtqueue for the first available buffer, and converts
- * it to an iovec for convenient access.  Since descriptors consist of some
- * number of output then some number of input descriptors, it's actually two
- * iovecs, but we pack them into one and note how many of each there were.
- *
- * This function waits if necessary, and returns the descriptor number found.
- */
-unsigned int wait_for_vq_desc(struct virtqueue *_vq,
-                                struct scatterlist iov[],
-                                unsigned int *out_num, unsigned int *in_num)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       unsigned int i, head, max;
-       struct vring_desc *desc;
-       uint16_t last_avail = lg_last_avail(vq);
-       int j = 0;
-
-       if (vringdebug){
-               fprintf(stderr, "out_num %p in_num %p\n", out_num, in_num);
-               fprintf(stderr, "va %p vq->vring %p\n", vq, vq->vring);
-       }
-       *out_num = *in_num = 0;
-       /* There's nothing available? */
-       j = 0;
-       while (last_avail == vq->vring.avail->idx) {
-               //uint64_t event;
-               if (virtqueue_is_broken(_vq)) {
-                       return 0;
-               }
-
-               /*
-                * Since we're about to sleep, now is a good time to tell the
-                * Guest about what we've used up to now.
-
-               trigger_irq(vq);
-                */
-               /* OK, now we need to know about added descriptors. */
-               vq->vring.used->flags &= ~VRING_USED_F_NO_NOTIFY;
-
-               /*
-                * They could have slipped one in as we were doing that: make
-                * sure it's written, then check again.
-                */
-               mb();
-               if (last_avail != vq->vring.avail->idx) {
-                       vq->vring.used->flags |= VRING_USED_F_NO_NOTIFY;
-                       break;
-               }
-
-               /* Nothing new?  Wait for eventfd to tell us they refilled. *
-               if (read(vq->eventfd, &event, sizeof(event)) != sizeof(event))
-                       errx(1, "Event read failed?");
-               */
-               /* We don't need to be notified again. */
-               vq->vring.used->flags |= VRING_USED_F_NO_NOTIFY;
-       }
-
-       /* Check it isn't doing very strange things with descriptor numbers. */
-//showvq(_vq);
-//fprintf(stderr, "out of loop %d.", j++); (void)getchar();
-       if ((uint16_t)(vq->vring.avail->idx - last_avail) > vq->vring.num)
-               errx(1, "Guest moved used index from %u to %u",
-                    last_avail, vq->vring.avail->idx);
-
-       /*
-        * Make sure we read the descriptor number *after* we read the ring
-        * update; don't let the cpu or compiler change the order.
-        */
-       rmb();
-
-       /*
-        * Grab the next descriptor number they're advertising, and increment
-        * the index we've seen.
-        */
-       head = vq->vring.avail->ring[last_avail % vq->vring.num];
-       lg_last_avail(vq)++;
-
-       /* If their number is silly, that's a fatal mistake. */
-       if (head >= vq->vring.num)
-               errx(1, "Guest says index %u is available", head);
-
-       /* When we start there are none of either input nor output. */
-       *out_num = *in_num = 0;
-
-       max = vq->vring.num;
-       desc = vq->vring.desc;
-       i = head;
-
-       /*
-        * We have to read the descriptor after we read the descriptor number,
-        * but there's a data dependency there so the CPU shouldn't reorder
-        * that: no rmb() required.
-        */
-
-       /*
-        * If this is an indirect entry, then this buffer contains a descriptor
-        * table which we handle as if it's any normal descriptor chain.
-        */
-       if (desc[i].flags & VRING_DESC_F_INDIRECT) {
-               if (desc[i].len % sizeof(struct vring_desc))
-                       errx(1, "Invalid size for indirect buffer table");
-
-               max = desc[i].len / sizeof(struct vring_desc);
-               // take our chances.
-               desc = check_pointer(desc[i].addr, desc[i].len);
-               i = 0;
-       }
-
-
-       do {
-               /* Grab the first descriptor, and check it's OK. */
-               iov[*out_num + *in_num].length = desc[i].len;
-               iov[*out_num + *in_num].v
-                       = check_pointer(desc[i].addr, desc[i].len);
-               /* If this is an input descriptor, increment that count. */
-               if (desc[i].flags & VRING_DESC_F_WRITE)
-                       (*in_num)++;
-               else {
-                       /*
-                        * If it's an output descriptor, they're all supposed
-                        * to come before any input descriptors.
-                        */
-                       if (*in_num)
-                               errx(1, "Descriptor has out after in");
-                       (*out_num)++;
-               }
-
-               /* If we've got too many, that implies a descriptor loop. */
-               if (*out_num + *in_num > max)
-                       errx(1, "Looped descriptor");
-       } while ((i = next_desc(desc, i, max)) != max);
-
-       if (vringdebug) fprintf(stderr, "RETURN head %d\n", head); 
-       return head;
-}
-
-/*
- * After we've used one of their buffers, we tell the Guest about it.  Sometime
- * later we'll want to send them an interrupt using trigger_irq(); note that
- * wait_for_vq_desc() does that for us if it has to wait.
- */
-void add_used(struct virtqueue *_vq, unsigned int head, int len)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       struct vring_used_elem *used;
-
-       /*
-        * The virtqueue contains a ring of used buffers.  Get a pointer to the
-        * next entry in that used ring.
-        */
-       used = &vq->vring.used->ring[vq->vring.used->idx % vq->vring.num];
-       used->id = head;
-       used->len = len;
-       /* Make sure buffer is written before we update index. */
-       wmb();
-       vq->vring.used->idx++;
-       if (vringdebug) fprintf(stderr, "USED IDX is now %d\n", vq->vring.used->idx);
-       //vq->pending_used++;
-}
-
-void showscatterlist(struct scatterlist *sg, int num)
-{
-       int i;
-       fprintf(stderr, "%p(0x%x)[", sg, num);
-       for(i = 0; i < num; i++)
-               fprintf(stderr, "[%p, 0x%x],", sg[i].v, sg[i].length);
-       fprintf(stderr, "]\n");
-}
-
-void virtqueue_close(struct virtqueue *_vq)
-{
-       struct vring_virtqueue *vq = to_vvq(_vq);
-       vq->broken = true;
-}