kernel -- Import virtio & virtio-block drivers.
[dragonfly.git] / sys / dev / virtual / virtio / virtio / virtqueue.c
1 /*-
2  * Copyright (c) 2011, Bryan Venteicher <bryanv@daemoninthecloset.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice unmodified, this list of conditions, and the following
10  *    disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/dev/virtio/virtqueue.c,v 1.2 2012/04/14 05:48:04 grehan Exp $
27  */
28
29 /*
30  * Implements the virtqueue interface as basically described
31  * in the original VirtIO paper.
32  */
33
34 #include <sys/param.h>
35 #include <sys/systm.h>
36 #include <sys/kernel.h>
37 #include <sys/malloc.h>
38 #include <sys/sglist.h>
39 #include <vm/vm.h>
40 #include <vm/pmap.h>
41 #include <sys/spinlock.h>
42 #include <sys/spinlock2.h>
43
44 #include <machine/cpu.h>
45 #include <machine/atomic.h>
46 #include <sys/bus.h>
47 #include <sys/rman.h>
48
49 #include "virtio.h"
50 #include "virtqueue.h"
51 #include "virtio_ring.h"
52
53 #include "virtio_bus_if.h"
54
55 struct virtqueue {
56         device_t                 vq_dev;
57         char                     vq_name[VIRTQUEUE_MAX_NAME_SZ];
58         uint16_t                 vq_queue_index;
59         uint16_t                 vq_nentries;
60         uint32_t                 vq_flags;
61
62 #define VIRTQUEUE_FLAG_EVENT_IDX 0x0002
63
64         int                      vq_alignment;
65         int                      vq_ring_size;
66         void                    *vq_ring_mem;
67
68         virtqueue_intr_t        *vq_intrhand;
69         void                    *vq_intrhand_arg;
70
71         struct vring             vq_ring;
72         uint16_t                 vq_free_cnt;
73         uint16_t                 vq_queued_cnt;
74         /*
75          * Head of the free chain in the descriptor table. If
76          * there are no free descriptors, this will be set to
77          * VQ_RING_DESC_CHAIN_END.
78          */
79         uint16_t                 vq_desc_head_idx;
80         /*
81          * Last consumed descriptor in the used table,
82          * trails vq_ring.used->idx.
83          */
84         uint16_t                 vq_used_cons_idx;
85
86         struct vq_desc_extra {
87                 void              *cookie;
88                 uint16_t           ndescs;
89         } vq_descx[0];
90 };
91
92 /*
93  * The maximum virtqueue size is 2^15. Use that value as the end of
94  * descriptor chain terminator since it will never be a valid index
95  * in the descriptor table. This is used to verify we are correctly
96  * handling vq_free_cnt.
97  */
98 #define VQ_RING_DESC_CHAIN_END 32768
99
100 #define VQASSERT(_vq, _exp, _msg, ...)                          \
101     KASSERT((_exp),("%s: %s - "_msg, __func__, (_vq)->vq_name,  \
102         ##__VA_ARGS__))
103
104 #define VQ_RING_ASSERT_VALID_IDX(_vq, _idx)                     \
105     VQASSERT((_vq), (_idx) < (_vq)->vq_nentries,                \
106         "invalid ring index: %d, max: %d", (_idx),              \
107         (_vq)->vq_nentries)
108
109 #define VQ_RING_ASSERT_CHAIN_TERM(_vq)                          \
110     VQASSERT((_vq), (_vq)->vq_desc_head_idx ==                  \
111         VQ_RING_DESC_CHAIN_END, "full ring terminated "         \
112         "incorrectly: head idx: %d", (_vq)->vq_desc_head_idx)
113
114 static void     vq_ring_init(struct virtqueue *);
115 static void     vq_ring_update_avail(struct virtqueue *, uint16_t);
116 static uint16_t vq_ring_enqueue_segments(struct virtqueue *,
117                     struct vring_desc *, uint16_t, struct sglist *, int, int);
118 static int      vq_ring_must_notify_host(struct virtqueue *);
119 static void     vq_ring_notify_host(struct virtqueue *);
120 static void     vq_ring_free_chain(struct virtqueue *, uint16_t);
121
122 uint64_t
123 virtqueue_filter_features(uint64_t features)
124 {
125         uint64_t mask;
126
127         mask = (1 << VIRTIO_TRANSPORT_F_START) - 1;
128         mask |= VIRTIO_RING_F_EVENT_IDX;
129
130         return (features & mask);
131 }
132
133 int
134 virtqueue_alloc(device_t dev, uint16_t queue, uint16_t size, int align,
135     vm_paddr_t highaddr, struct vq_alloc_info *info, struct virtqueue **vqp)
136 {
137         struct virtqueue *vq;
138         int error;
139
140         *vqp = NULL;
141         error = 0;
142
143         if (size == 0) {
144                 device_printf(dev,
145                     "virtqueue %d (%s) does not exist (size is zero)\n",
146                     queue, info->vqai_name);
147                 return (ENODEV);
148         } else if (!powerof2(size)) {
149                 device_printf(dev,
150                     "virtqueue %d (%s) size is not a power of 2: %d\n",
151                     queue, info->vqai_name, size);
152                 return (ENXIO);
153         }
154
155         vq = kmalloc(sizeof(struct virtqueue) +
156             size * sizeof(struct vq_desc_extra), M_DEVBUF, M_NOWAIT | M_ZERO);
157         if (vq == NULL) {
158                 device_printf(dev, "cannot allocate virtqueue\n");
159                 return (ENOMEM);
160         }
161
162         vq->vq_dev = dev;
163         strlcpy(vq->vq_name, info->vqai_name, sizeof(vq->vq_name));
164         vq->vq_queue_index = queue;
165         vq->vq_alignment = align;
166         vq->vq_nentries = size;
167         vq->vq_free_cnt = size;
168         vq->vq_intrhand = info->vqai_intr;
169         vq->vq_intrhand_arg = info->vqai_intr_arg;
170
171         if (VIRTIO_BUS_WITH_FEATURE(dev, VIRTIO_RING_F_EVENT_IDX) != 0)
172                 vq->vq_flags |= VIRTQUEUE_FLAG_EVENT_IDX;
173
174         vq->vq_ring_size = round_page(vring_size(size, align));
175         vq->vq_ring_mem = contigmalloc(vq->vq_ring_size, M_DEVBUF,
176             M_NOWAIT | M_ZERO, 0, highaddr, PAGE_SIZE, 0);
177         if (vq->vq_ring_mem == NULL) {
178                 device_printf(dev,
179                     "cannot allocate memory for virtqueue ring\n");
180                 error = ENOMEM;
181                 goto fail;
182         }
183
184         vq_ring_init(vq);
185         virtqueue_disable_intr(vq);
186
187         *vqp = vq;
188
189 fail:
190         if (error)
191                 virtqueue_free(vq);
192
193         return (error);
194 }
195
196 int
197 virtqueue_reinit(struct virtqueue *vq, uint16_t size)
198 {
199         struct vq_desc_extra *dxp;
200         int i;
201
202         if (vq->vq_nentries != size) {
203                 device_printf(vq->vq_dev,
204                     "%s: '%s' changed size; old=%hu, new=%hu\n",
205                     __func__, vq->vq_name, vq->vq_nentries, size);
206                 return (EINVAL);
207         }
208
209         /* Warn if the virtqueue was not properly cleaned up. */
210         if (vq->vq_free_cnt != vq->vq_nentries) {
211                 device_printf(vq->vq_dev,
212                     "%s: warning, '%s' virtqueue not empty, "
213                     "leaking %d entries\n", __func__, vq->vq_name,
214                     vq->vq_nentries - vq->vq_free_cnt);
215         }
216
217         vq->vq_desc_head_idx = 0;
218         vq->vq_used_cons_idx = 0;
219         vq->vq_queued_cnt = 0;
220         vq->vq_free_cnt = vq->vq_nentries;
221
222         /* To be safe, reset all our allocated memory. */
223         bzero(vq->vq_ring_mem, vq->vq_ring_size);
224         for (i = 0; i < vq->vq_nentries; i++) {
225                 dxp = &vq->vq_descx[i];
226                 dxp->cookie = NULL;
227                 dxp->ndescs = 0;
228         }
229
230         vq_ring_init(vq);
231         virtqueue_disable_intr(vq);
232
233         return (0);
234 }
235
236 void
237 virtqueue_free(struct virtqueue *vq)
238 {
239
240         if (vq->vq_free_cnt != vq->vq_nentries) {
241                 device_printf(vq->vq_dev, "%s: freeing non-empty virtqueue, "
242                     "leaking %d entries\n", vq->vq_name,
243                     vq->vq_nentries - vq->vq_free_cnt);
244         }
245
246         if (vq->vq_ring_mem != NULL) {
247                 contigfree(vq->vq_ring_mem, vq->vq_ring_size, M_DEVBUF);
248                 vq->vq_ring_size = 0;
249                 vq->vq_ring_mem = NULL;
250         }
251
252         kfree(vq, M_DEVBUF);
253 }
254
255 vm_paddr_t
256 virtqueue_paddr(struct virtqueue *vq)
257 {
258         return (vtophys(vq->vq_ring_mem));
259 }
260
261 int
262 virtqueue_size(struct virtqueue *vq)
263 {
264         return (vq->vq_nentries);
265 }
266
267 int
268 virtqueue_empty(struct virtqueue *vq)
269 {
270
271         return (vq->vq_nentries == vq->vq_free_cnt);
272 }
273
274 int
275 virtqueue_full(struct virtqueue *vq)
276 {
277
278         return (vq->vq_free_cnt == 0);
279 }
280
281 void
282 virtqueue_notify(struct virtqueue *vq, struct spinlock *interlock)
283 {
284         /* Ensure updated avail->idx is visible to host. */
285         cpu_mfence();
286
287         if (vq_ring_must_notify_host(vq)) {
288                 spin_unlock(interlock);
289                 vq_ring_notify_host(vq);
290                 spin_lock(interlock);
291         }
292         vq->vq_queued_cnt = 0;
293 }
294
295 int
296 virtqueue_nused(struct virtqueue *vq)
297 {
298         uint16_t used_idx, nused;
299
300         used_idx = vq->vq_ring.used->idx;
301         nused = (uint16_t)(used_idx - vq->vq_used_cons_idx);
302         VQASSERT(vq, nused <= vq->vq_nentries, "used more than available");
303
304         return (nused);
305 }
306
307 int
308 virtqueue_intr(struct virtqueue *vq)
309 {
310
311         if (vq->vq_intrhand == NULL ||
312             vq->vq_used_cons_idx == vq->vq_ring.used->idx)
313                 return (0);
314
315         vq->vq_intrhand(vq->vq_intrhand_arg);
316
317         return (1);
318 }
319
320 /*
321  * Enable interrupts on a given virtqueue. Returns 1 if there are
322  * additional entries to process on the virtqueue after we return.
323  */
324 int
325 virtqueue_enable_intr(struct virtqueue *vq)
326 {
327         /*
328          * Enable interrupts, making sure we get the latest
329          * index of what's already been consumed.
330          */
331         vq->vq_ring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
332         if (vq->vq_flags & VIRTQUEUE_FLAG_EVENT_IDX) {
333                 vring_used_event(&vq->vq_ring) = vq->vq_used_cons_idx;
334         } else {
335                vq->vq_ring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
336         }
337
338         cpu_mfence();
339
340         /*
341          * Additional items may have been consumed in the time between
342          * since we last checked and enabled interrupts above. Let our
343          * caller know so it processes the new entries.
344          */
345         if (vq->vq_used_cons_idx != vq->vq_ring.used->idx)
346                 return (1);
347
348         return (0);
349 }
350
351 int
352 virtqueue_postpone_intr(struct virtqueue *vq)
353 {
354         uint16_t ndesc;
355
356         /*
357          * Postpone until at least half of the available descriptors
358          * have been consumed.
359          *
360          * XXX Adaptive factor? (Linux uses 3/4)
361          */
362         ndesc = (uint16_t)(vq->vq_ring.avail->idx - vq->vq_used_cons_idx) / 2;
363
364         if (vq->vq_flags & VIRTQUEUE_FLAG_EVENT_IDX)
365                 vring_used_event(&vq->vq_ring) = vq->vq_used_cons_idx + ndesc;
366         else
367                 vq->vq_ring.avail->flags &= ~VRING_AVAIL_F_NO_INTERRUPT;
368
369         cpu_mfence();
370
371         /*
372          * Enough items may have already been consumed to meet our
373          * threshold since we last checked. Let our caller know so
374          * it processes the new entries.
375          */
376         if (virtqueue_nused(vq) > ndesc)
377                 return (1);
378
379         return (0);
380 }
381
382 void
383 virtqueue_disable_intr(struct virtqueue *vq)
384 {
385         /*
386          * Note this is only considered a hint to the host.
387          */
388         if ((vq->vq_flags & VIRTQUEUE_FLAG_EVENT_IDX) == 0)
389                 vq->vq_ring.avail->flags |= VRING_AVAIL_F_NO_INTERRUPT;
390 }
391
392 int
393 virtqueue_enqueue(struct virtqueue *vq, void *cookie, struct sglist *sg,
394     int readable, int writable)
395 {
396         struct vq_desc_extra *dxp;
397         int needed;
398         uint16_t head_idx, idx;
399
400         needed = readable + writable;
401
402         VQASSERT(vq, cookie != NULL, "enqueuing with no cookie");
403         VQASSERT(vq, needed == sg->sg_nseg,
404             "segment count mismatch, %d, %d", needed, sg->sg_nseg);
405
406         if (needed < 1)
407                 return (EINVAL);
408         if (vq->vq_free_cnt == 0)
409                 return (ENOSPC);
410         if (vq->vq_free_cnt < needed)
411                 return (EMSGSIZE);
412
413         head_idx = vq->vq_desc_head_idx;
414         VQ_RING_ASSERT_VALID_IDX(vq, head_idx);
415         dxp = &vq->vq_descx[head_idx];
416
417         VQASSERT(vq, dxp->cookie == NULL,
418             "cookie already exists for index %d", head_idx);
419         dxp->cookie = cookie;
420         dxp->ndescs = needed;
421
422         idx = vq_ring_enqueue_segments(vq, vq->vq_ring.desc, head_idx,
423             sg, readable, writable);
424
425         vq->vq_desc_head_idx = idx;
426         vq->vq_free_cnt -= needed;
427         if (vq->vq_free_cnt == 0)
428                 VQ_RING_ASSERT_CHAIN_TERM(vq);
429         else
430                 VQ_RING_ASSERT_VALID_IDX(vq, idx);
431
432         vq_ring_update_avail(vq, head_idx);
433
434         return (0);
435 }
436
437 void *
438 virtqueue_dequeue(struct virtqueue *vq, uint32_t *len)
439 {
440         struct vring_used_elem *uep;
441         void *cookie;
442         uint16_t used_idx, desc_idx;
443
444         if (vq->vq_used_cons_idx == vq->vq_ring.used->idx)
445                 return (NULL);
446
447         used_idx = vq->vq_used_cons_idx++ & (vq->vq_nentries - 1);
448         uep = &vq->vq_ring.used->ring[used_idx];
449
450         cpu_mfence();
451         desc_idx = (uint16_t) uep->id;
452         if (len != NULL)
453                 *len = uep->len;
454
455         vq_ring_free_chain(vq, desc_idx);
456
457         cookie = vq->vq_descx[desc_idx].cookie;
458         VQASSERT(vq, cookie != NULL, "no cookie for index %d", desc_idx);
459         vq->vq_descx[desc_idx].cookie = NULL;
460
461         return (cookie);
462 }
463
464 void *
465 virtqueue_poll(struct virtqueue *vq, uint32_t *len)
466 {
467         void *cookie;
468
469         /* We only poll the virtqueue when dumping to virtio-blk */
470         while ((cookie = virtqueue_dequeue(vq, len)) == NULL)
471                 ;       
472
473         return (cookie);
474 }
475
476 void *
477 virtqueue_drain(struct virtqueue *vq, int *last)
478 {
479         void *cookie;
480         int idx;
481
482         cookie = NULL;
483         idx = *last;
484
485         while (idx < vq->vq_nentries && cookie == NULL) {
486                 if ((cookie = vq->vq_descx[idx].cookie) != NULL) {
487                         vq->vq_descx[idx].cookie = NULL;
488                         /* Free chain to keep free count consistent. */
489                         vq_ring_free_chain(vq, idx);
490                 }
491                 idx++;
492         }
493
494         *last = idx;
495
496         return (cookie);
497 }
498
499 void
500 virtqueue_dump(struct virtqueue *vq)
501 {
502
503         if (vq == NULL)
504                 return;
505
506         kprintf("VQ: %s - size=%d; free=%d; used=%d; queued=%d; "
507             "desc_head_idx=%d; avail.idx=%d; used_cons_idx=%d; "
508             "used.idx=%d; avail.flags=0x%x; used.flags=0x%x\n",
509             vq->vq_name, vq->vq_nentries, vq->vq_free_cnt,
510             virtqueue_nused(vq), vq->vq_queued_cnt, vq->vq_desc_head_idx,
511             vq->vq_ring.avail->idx, vq->vq_used_cons_idx,
512             vq->vq_ring.used->idx, vq->vq_ring.avail->flags,
513             vq->vq_ring.used->flags);
514 }
515
516 static void
517 vq_ring_init(struct virtqueue *vq)
518 {
519         struct vring *vr;
520         char *ring_mem;
521         int i, size;
522
523         ring_mem = vq->vq_ring_mem;
524         size = vq->vq_nentries;
525         vr = &vq->vq_ring;
526
527         vring_init(vr, size, ring_mem, vq->vq_alignment);
528
529         for (i = 0; i < size - 1; i++)
530                 vr->desc[i].next = i + 1;
531         vr->desc[i].next = VQ_RING_DESC_CHAIN_END;
532 }
533
534 static void
535 vq_ring_update_avail(struct virtqueue *vq, uint16_t desc_idx)
536 {
537         uint16_t avail_idx;
538
539         /*
540          * Place the head of the descriptor chain into the next slot and make
541          * it usable to the host. The chain is made available now rather than
542          * deferring to virtqueue_notify() in the hopes that if the host is
543          * currently running on another CPU, we can keep it processing the new
544          * descriptor.
545          */
546         avail_idx = vq->vq_ring.avail->idx & (vq->vq_nentries - 1);
547         vq->vq_ring.avail->ring[avail_idx] = desc_idx;
548
549         cpu_mfence();
550         vq->vq_ring.avail->idx++;
551
552         /* Keep pending count until virtqueue_notify() for debugging. */
553         vq->vq_queued_cnt++;
554 }
555
556 static uint16_t
557 vq_ring_enqueue_segments(struct virtqueue *vq, struct vring_desc *desc,
558     uint16_t head_idx, struct sglist *sg, int readable, int writable)
559 {
560         struct sglist_seg *seg;
561         struct vring_desc *dp;
562         int i, needed;
563         uint16_t idx;
564
565         needed = readable + writable;
566
567         for (i = 0, idx = head_idx, seg = sg->sg_segs;
568              i < needed;
569              i++, idx = dp->next, seg++) {
570                 VQASSERT(vq, idx != VQ_RING_DESC_CHAIN_END,
571                     "premature end of free desc chain");
572
573                 dp = &desc[idx];
574                 dp->addr = seg->ss_paddr;
575                 dp->len = seg->ss_len;
576                 dp->flags = 0;
577
578                 if (i < needed - 1)
579                         dp->flags |= VRING_DESC_F_NEXT;
580                 if (i >= readable)
581                         dp->flags |= VRING_DESC_F_WRITE;
582         }
583
584         return (idx);
585 }
586
587 static int
588 vq_ring_must_notify_host(struct virtqueue *vq)
589 {
590         uint16_t new_idx, prev_idx, event_idx;
591
592         if (vq->vq_flags & VIRTQUEUE_FLAG_EVENT_IDX) {
593                 new_idx = vq->vq_ring.avail->idx;
594                 prev_idx = new_idx - vq->vq_queued_cnt;
595                 event_idx = vring_avail_event(&vq->vq_ring);
596
597                 return (vring_need_event(event_idx, new_idx, prev_idx) != 0);
598         }
599
600         return ((vq->vq_ring.used->flags & VRING_USED_F_NO_NOTIFY) == 0);
601 }
602
603 static void
604 vq_ring_notify_host(struct virtqueue *vq)
605 {
606         VIRTIO_BUS_NOTIFY_VQ(vq->vq_dev, vq->vq_queue_index);
607 }
608
609 static void
610 vq_ring_free_chain(struct virtqueue *vq, uint16_t desc_idx)
611 {
612         struct vring_desc *dp;
613         struct vq_desc_extra *dxp;
614
615         VQ_RING_ASSERT_VALID_IDX(vq, desc_idx);
616         dp = &vq->vq_ring.desc[desc_idx];
617         dxp = &vq->vq_descx[desc_idx];
618
619         if (vq->vq_free_cnt == 0)
620                 VQ_RING_ASSERT_CHAIN_TERM(vq);
621
622         vq->vq_free_cnt += dxp->ndescs;
623         dxp->ndescs--;
624
625         while (dp->flags & VRING_DESC_F_NEXT) {
626                 VQ_RING_ASSERT_VALID_IDX(vq, dp->next);
627                 dp = &vq->vq_ring.desc[dp->next];
628                 dxp->ndescs--;
629         }
630         VQASSERT(vq, dxp->ndescs == 0, "failed to free entire desc chain");
631
632         /*
633          * We must append the existing free chain, if any, to the end of
634          * newly freed chain. If the virtqueue was completely used, then
635          * head would be VQ_RING_DESC_CHAIN_END (ASSERTed above).
636          */
637         dp->next = vq->vq_desc_head_idx;
638         vq->vq_desc_head_idx = desc_idx;
639 }