1 /* taken from linux source 3.15 at include/uapi/linux/virtio_ring.h */
2 #ifndef _UAPI_LINUX_VIRTIO_RING_H
3 #define _UAPI_LINUX_VIRTIO_RING_H
4 /* An interface for efficient virtio implementation, currently for use by KVM
5 * and lguest, but hopefully others soon. Do NOT change this since it will
6 * break existing servers and clients.
7 *
8 * This header is BSD licensed so anyone can use the definitions to implement
9 * compatible drivers/servers.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of IBM nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * SUCH DAMAGE.
33 *
34 * Copyright Rusty Russell IBM Corporation 2007. */
35 #include <stdint.h>
36 #include <lk/pow2.h>
37
38 /* This marks a buffer as continuing via the next field. */
39 #define VRING_DESC_F_NEXT 1
40 /* This marks a buffer as write-only (otherwise read-only). */
41 #define VRING_DESC_F_WRITE 2
42 /* This means the buffer contains a list of buffer descriptors. */
43 #define VRING_DESC_F_INDIRECT 4
44
45 /* The Host uses this in used->flags to advise the Guest: don't kick me when
46 * you add a buffer. It's unreliable, so it's simply an optimization. Guest
47 * will still kick if it's out of buffers. */
48 #define VRING_USED_F_NO_NOTIFY 1
49 /* The Guest uses this in avail->flags to advise the Host: don't interrupt me
50 * when you consume a buffer. It's unreliable, so it's simply an
51 * optimization. */
52 #define VRING_AVAIL_F_NO_INTERRUPT 1
53
54 /* We support indirect buffer descriptors */
55 #define VIRTIO_RING_F_INDIRECT_DESC 28
56
57 /* The Guest publishes the used index for which it expects an interrupt
58 * at the end of the avail ring. Host should ignore the avail->flags field. */
59 /* The Host publishes the avail index for which it expects a kick
60 * at the end of the used ring. Guest should ignore the used->flags field. */
61 #define VIRTIO_RING_F_EVENT_IDX 29
62
63 /* Virtio ring descriptors: 16 bytes. These can chain together via "next". */
64 struct vring_desc {
65 /* Address (guest-physical). */
66 uint64_t addr;
67 /* Length. */
68 uint32_t len;
69 /* The flags as indicated above. */
70 uint16_t flags;
71 /* We chain unused descriptors via this, too */
72 uint16_t next;
73 };
74
75 struct vring_avail {
76 uint16_t flags;
77 uint16_t idx;
78 uint16_t ring[];
79 };
80
81 /* u32 is used here for ids for padding reasons. */
82 struct vring_used_elem {
83 /* Index of start of used descriptor chain. */
84 uint32_t id;
85 /* Total length of the descriptor chain which was used (written to) */
86 uint32_t len;
87 };
88
89 struct vring_used {
90 uint16_t flags;
91 uint16_t idx;
92 struct vring_used_elem ring[];
93 };
94
95 struct vring {
96 uint32_t num;
97 uint32_t num_mask;
98
99 uint16_t free_list; /* head of a free list of descriptors per ring. 0xffff is NULL */
100 uint16_t free_count;
101
102 uint16_t last_used;
103
104 struct vring_desc *desc;
105
106 struct vring_avail *avail;
107
108 struct vring_used *used;
109 };
110
111 /* The standard layout for the ring is a continuous chunk of memory which looks
112 * like this. We assume num is a power of 2.
113 *
114 * struct vring
115 * {
116 * // The actual descriptors (16 bytes each)
117 * struct vring_desc desc[num];
118 *
119 * // A ring of available descriptor heads with free-running index.
120 * uint16_t avail_flags;
121 * uint16_t avail_idx;
122 * uint16_t available[num];
123 * uint16_t used_event_idx;
124 *
125 * // Padding to the next align boundary.
126 * char pad[];
127 *
128 * // A ring of used descriptor heads with free-running index.
129 * uint16_t used_flags;
130 * uint16_t used_idx;
131 * struct vring_used_elem used[num];
132 * uint16_t avail_event_idx;
133 * };
134 */
135 /* We publish the used event index at the end of the available ring, and vice
136 * versa. They are at the end for backwards compatibility. */
137 #define vring_used_event(vr) ((vr)->avail->ring[(vr)->num])
138 #define vring_avail_event(vr) (*(uint16_t *)&(vr)->used->ring[(vr)->num])
139
vring_init(struct vring * vr,unsigned int num,void * p,unsigned long align)140 static inline void vring_init(struct vring *vr, unsigned int num, void *p,
141 unsigned long align) {
142 vr->num = num;
143 vr->num_mask = (1 << log2_uint(num)) - 1;
144 vr->free_list = 0xffff;
145 vr->free_count = 0;
146 vr->last_used = 0;
147 vr->desc = p;
148 vr->avail = p + num*sizeof(struct vring_desc);
149 vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + sizeof(uint16_t)
150 + align-1) & ~(align - 1));
151 }
152
vring_size(unsigned int num,unsigned long align)153 static inline unsigned vring_size(unsigned int num, unsigned long align) {
154 return ((sizeof(struct vring_desc) * num + sizeof(uint16_t) * (3 + num)
155 + align - 1) & ~(align - 1))
156 + sizeof(uint16_t) * 3 + sizeof(struct vring_used_elem) * num;
157 }
158
159 /* The following is used with USED_EVENT_IDX and AVAIL_EVENT_IDX */
160 /* Assuming a given event_idx value from the other size, if
161 * we have just incremented index from old to new_idx,
162 * should we trigger an event? */
vring_need_event(uint16_t event_idx,uint16_t new_idx,uint16_t old)163 static inline int vring_need_event(uint16_t event_idx, uint16_t new_idx, uint16_t old) {
164 /* Note: Xen has similar logic for notification hold-off
165 * in include/xen/interface/io/ring.h with req_event and req_prod
166 * corresponding to event_idx + 1 and new_idx respectively.
167 * Note also that req_event and req_prod in Xen start at 1,
168 * event indexes in virtio start at 0. */
169 return (uint16_t)(new_idx - event_idx - 1) < (uint16_t)(new_idx - old);
170 }
171
172 #endif /* _UAPI_LINUX_VIRTIO_RING_H */
173
174