VMM: Added includes to virtio_lguest_helpers.c for our implementation of virtio-mmio
[akaros.git] / user / vmm / virtio_lguest_helpers.c
1 /* Virtio helper functions from linux/tools/lguest/lguest.c
2  *
3  * Copyright (C) 1991-2016, the Linux Kernel authors
4  *
5  * Author:
6  *  Rusty Russell <rusty@rustcorp.com.au>
7  *
8  * This program is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU General Public License as
10  * published by the Free Software Foundation; either version 2 of
11  * the License, or (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * Original linux/tools/lguest/lguest.c:
19  *   https://github.com/torvalds/linux/blob/v4.5/tools/lguest/lguest.c
20  *   most recent hash on the file as of v4.5 tag:
21  *     e523caa601f4a7c2fa1ecd040db921baf7453798
22  */
23
24
25 #include <sys/eventfd.h>
26 #include <sys/uio.h>
27 #include <ros/arch/membar.h>
28 #include <vmm/virtio.h>
29 #include <vmm/virtio_ids.h>
30 #include <vmm/virtio_config.h>
31
32 /*L:200
33  * Device Handling.
34  *
35  * When the Guest gives us a buffer, it sends an array of addresses and sizes.
36  * We need to make sure it's not trying to reach into the Launcher itself, so
37  * we have a convenient routine which checks it and exits with an error message
38  * if something funny is going on:
39  */
40 static void *_check_pointer(struct device *d,
41                             unsigned long addr, unsigned int size,
42                             unsigned int line)
43 {
44         /*
45          * Check if the requested address and size exceeds the allocated memory,
46          * or addr + size wraps around.
47          */
48         if ((addr + size) > guest_limit || (addr + size) < addr)
49                 bad_driver(d, "%s:%i: Invalid address %#lx",
50                            __FILE__, line, addr);
51         /*
52          * We return a pointer for the caller's convenience, now we know it's
53          * safe to use.
54          */
55         return from_guest_phys(addr);
56 }
57
58
59 /*
60  * Each buffer in the virtqueues is actually a chain of descriptors.  This
61  * function returns the next descriptor in the chain, or vq->vring.num if we're
62  * at the end.
63  */
64 static unsigned next_desc(struct device *d, struct vring_desc *desc,
65                           unsigned int i, unsigned int max)
66 {
67         unsigned int next;
68
69         /* If this descriptor says it doesn't chain, we're done. */
70         if (!(desc[i].flags & VRING_DESC_F_NEXT))
71                 return max;
72
73         /* Check they're not leading us off end of descriptors. */
74         next = desc[i].next;
75         /* Make sure compiler knows to grab that: we don't want it changing! */
76         wmb();
77
78         if (next >= max)
79                 bad_driver(d, "Desc next is %u", next);
80
81         return next;
82 }
83
84 /*
85  * After we've used one of their buffers, we tell the Guest about it.  Sometime
86  * later we'll want to send them an interrupt using trigger_irq(); note that
87  * wait_for_vq_desc() does that for us if it has to wait.
88  */
89 static void add_used(struct virtqueue *vq, unsigned int head, int len)
90 {
91         struct vring_used_elem *used;
92
93         /*
94          * The virtqueue contains a ring of used buffers.  Get a pointer to the
95          * next entry in that used ring.
96          */
97         used = &vq->vring.used->ring[vq->vring.used->idx % vq->vring.num];
98         used->id = head;
99         used->len = len;
100         /* Make sure buffer is written before we update index. */
101         wmb();
102         vq->vring.used->idx++;
103         vq->pending_used++;
104 }
105
106 /*
107  * This looks in the virtqueue for the first available buffer, and converts
108  * it to an iovec for convenient access.  Since descriptors consist of some
109  * number of output then some number of input descriptors, it's actually two
110  * iovecs, but we pack them into one and note how many of each there were.
111  *
112  * This function waits if necessary, and returns the descriptor number found.
113  */
114 static unsigned wait_for_vq_desc(struct virtqueue *vq,
115                                  struct iovec iov[],
116                                  unsigned int *out_num, unsigned int *in_num)
117 {
118         unsigned int i, head, max;
119         struct vring_desc *desc;
120         u16 last_avail = lg_last_avail(vq);
121
122         /*
123          * 2.4.7.1:
124          *
125          *   The driver MUST handle spurious interrupts from the device.
126          *
127          * That's why this is a while loop.
128          */
129
130         /* There's nothing available? */
131         while (last_avail == vq->vring.avail->idx) {
132                 u64 event;
133
134                 /*
135                  * Since we're about to sleep, now is a good time to tell the
136                  * Guest about what we've used up to now.
137                  */
138                 trigger_irq(vq);
139
140                 /* OK, now we need to know about added descriptors. */
141                 vq->vring.used->flags &= ~VRING_USED_F_NO_NOTIFY;
142
143                 /*
144                  * They could have slipped one in as we were doing that: make
145                  * sure it's written, then check again.
146                  */
147                 mb();
148                 if (last_avail != vq->vring.avail->idx) {
149                         vq->vring.used->flags |= VRING_USED_F_NO_NOTIFY;
150                         break;
151                 }
152
153                 /* Nothing new?  Wait for eventfd to tell us they refilled. */
154                 if (read(vq->eventfd, &event, sizeof(event)) != sizeof(event))
155                         errx(1, "Event read failed?");
156
157                 /* We don't need to be notified again. */
158                 vq->vring.used->flags |= VRING_USED_F_NO_NOTIFY;
159         }
160
161         /* Check it isn't doing very strange things with descriptor numbers. */
162         if ((u16)(vq->vring.avail->idx - last_avail) > vq->vring.num)
163                 bad_driver_vq(vq, "Guest moved used index from %u to %u",
164                               last_avail, vq->vring.avail->idx);
165
166         /*
167          * Make sure we read the descriptor number *after* we read the ring
168          * update; don't let the cpu or compiler change the order.
169          */
170         rmb();
171
172         /*
173          * Grab the next descriptor number they're advertising, and increment
174          * the index we've seen.
175          */
176         head = vq->vring.avail->ring[last_avail % vq->vring.num];
177         lg_last_avail(vq)++;
178
179         /* If their number is silly, that's a fatal mistake. */
180         if (head >= vq->vring.num)
181                 bad_driver_vq(vq, "Guest says index %u is available", head);
182
183         /* When we start there are none of either input nor output. */
184         *out_num = *in_num = 0;
185
186         max = vq->vring.num;
187         desc = vq->vring.desc;
188         i = head;
189
190         /*
191          * We have to read the descriptor after we read the descriptor number,
192          * but there's a data dependency there so the CPU shouldn't reorder
193          * that: no rmb() required.
194          */
195
196         do {
197                 /*
198                  * If this is an indirect entry, then this buffer contains a
199                  * descriptor table which we handle as if it's any normal
200                  * descriptor chain.
201                  */
202                 if (desc[i].flags & VRING_DESC_F_INDIRECT) {
203                         /* 2.4.5.3.1:
204                          *
205                          *  The driver MUST NOT set the VIRTQ_DESC_F_INDIRECT
206                          *  flag unless the VIRTIO_F_INDIRECT_DESC feature was
207                          *  negotiated.
208                          */
209                         if (!(vq->dev->features_accepted &
210                               (1<<VIRTIO_RING_F_INDIRECT_DESC)))
211                                 bad_driver_vq(vq, "vq indirect not negotiated");
212
213                         /*
214                          * 2.4.5.3.1:
215                          *
216                          *   The driver MUST NOT set the VIRTQ_DESC_F_INDIRECT
217                          *   flag within an indirect descriptor (ie. only one
218                          *   table per descriptor).
219                          */
220                         if (desc != vq->vring.desc)
221                                 bad_driver_vq(vq, "Indirect within indirect");
222
223                         /*
224                          * Proposed update VIRTIO-134 spells this out:
225                          *
226                          *   A driver MUST NOT set both VIRTQ_DESC_F_INDIRECT
227                          *   and VIRTQ_DESC_F_NEXT in flags.
228                          */
229                         if (desc[i].flags & VRING_DESC_F_NEXT)
230                                 bad_driver_vq(vq, "indirect and next together");
231
232                         if (desc[i].len % sizeof(struct vring_desc))
233                                 bad_driver_vq(vq,
234                                               "Invalid size for indirect table");
235                         /*
236                          * 2.4.5.3.2:
237                          *
238                          *  The device MUST ignore the write-only flag
239                          *  (flags&VIRTQ_DESC_F_WRITE) in the descriptor that
240                          *  refers to an indirect table.
241                          *
242                          * We ignore it here: :)
243                          */
244
245                         max = desc[i].len / sizeof(struct vring_desc);
246                         desc = check_pointer(vq->dev, desc[i].addr, desc[i].len);
247                         i = 0;
248
249                         /* 2.4.5.3.1:
250                          *
251                          *  A driver MUST NOT create a descriptor chain longer
252                          *  than the Queue Size of the device.
253                          */
254                         if (max > vq->pci_config.queue_size)
255                                 bad_driver_vq(vq,
256                                               "indirect has too many entries");
257                 }
258
259                 /* Grab the first descriptor, and check it's OK. */
260                 iov[*out_num + *in_num].iov_len = desc[i].len;
261                 iov[*out_num + *in_num].iov_base
262                         = check_pointer(vq->dev, desc[i].addr, desc[i].len);
263                 /* If this is an input descriptor, increment that count. */
264                 if (desc[i].flags & VRING_DESC_F_WRITE)
265                         (*in_num)++;
266                 else {
267                         /*
268                          * If it's an output descriptor, they're all supposed
269                          * to come before any input descriptors.
270                          */
271                         if (*in_num)
272                                 bad_driver_vq(vq,
273                                               "Descriptor has out after in");
274                         (*out_num)++;
275                 }
276
277                 /* If we've got too many, that implies a descriptor loop. */
278                 if (*out_num + *in_num > max)
279                         bad_driver_vq(vq, "Looped descriptor");
280         } while ((i = next_desc(vq->dev, desc, i, max)) != max);
281
282         return head;
283 }
284
285 /*
286  * 4.1.4.3.2:
287  *
288  *  The driver MUST configure the other virtqueue fields before
289  *  enabling the virtqueue with queue_enable.
290  *
291  * When they enable the virtqueue, we check that their setup is valid.
292  */
293 static void check_virtqueue(struct device *d, struct virtqueue *vq)
294 {
295         /* Because lguest is 32 bit, all the descriptor high bits must be 0 */
296         if (vq->pci_config.queue_desc_hi
297             || vq->pci_config.queue_avail_hi
298             || vq->pci_config.queue_used_hi)
299                 bad_driver_vq(vq, "invalid 64-bit queue address");
300
301         /*
302          * 2.4.1:
303          *
304          *  The driver MUST ensure that the physical address of the first byte
305          *  of each virtqueue part is a multiple of the specified alignment
306          *  value in the above table.
307          */
308         if (vq->pci_config.queue_desc_lo % 16
309             || vq->pci_config.queue_avail_lo % 2
310             || vq->pci_config.queue_used_lo % 4)
311                 bad_driver_vq(vq, "invalid alignment in queue addresses");
312
313         /* Initialize the virtqueue and check they're all in range. */
314         vq->vring.num = vq->pci_config.queue_size;
315         vq->vring.desc = check_pointer(vq->dev,
316                                        vq->pci_config.queue_desc_lo,
317                                        sizeof(*vq->vring.desc) * vq->vring.num);
318         vq->vring.avail = check_pointer(vq->dev,
319                                         vq->pci_config.queue_avail_lo,
320                                         sizeof(*vq->vring.avail)
321                                         + (sizeof(vq->vring.avail->ring[0])
322                                            * vq->vring.num));
323         vq->vring.used = check_pointer(vq->dev,
324                                        vq->pci_config.queue_used_lo,
325                                        sizeof(*vq->vring.used)
326                                        + (sizeof(vq->vring.used->ring[0])
327                                           * vq->vring.num));
328
329         /*
330          * 2.4.9.1:
331          *
332          *   The driver MUST initialize flags in the used ring to 0
333          *   when allocating the used ring.
334          */
335         if (vq->vring.used->flags != 0)
336                 bad_driver_vq(vq, "invalid initial used.flags %#x",
337                               vq->vring.used->flags);
338 }