input-linux: factor out input_linux_handle_mouse
[qemu/ar7.git] / hw / virtio / virtio.c
blob18153d5a3995e3a1c9bfad2a408dbca602a5ef18
1 /*
2 * Virtio Support
4 * Copyright IBM, Corp. 2007
6 * Authors:
7 * Anthony Liguori <aliguori@us.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2. See
10 * the COPYING file in the top-level directory.
14 #include "qemu/osdep.h"
15 #include "qapi/error.h"
16 #include "qemu-common.h"
17 #include "cpu.h"
18 #include "trace.h"
19 #include "exec/address-spaces.h"
20 #include "qemu/error-report.h"
21 #include "hw/virtio/virtio.h"
22 #include "qemu/atomic.h"
23 #include "hw/virtio/virtio-bus.h"
24 #include "migration/migration.h"
25 #include "hw/virtio/virtio-access.h"
28 * The alignment to use between consumer and producer parts of vring.
29 * x86 pagesize again. This is the default, used by transports like PCI
30 * which don't provide a means for the guest to tell the host the alignment.
32 #define VIRTIO_PCI_VRING_ALIGN 4096
34 typedef struct VRingDesc
36 uint64_t addr;
37 uint32_t len;
38 uint16_t flags;
39 uint16_t next;
40 } VRingDesc;
42 typedef struct VRingAvail
44 uint16_t flags;
45 uint16_t idx;
46 uint16_t ring[0];
47 } VRingAvail;
49 typedef struct VRingUsedElem
51 uint32_t id;
52 uint32_t len;
53 } VRingUsedElem;
55 typedef struct VRingUsed
57 uint16_t flags;
58 uint16_t idx;
59 VRingUsedElem ring[0];
60 } VRingUsed;
62 typedef struct VRing
64 unsigned int num;
65 unsigned int num_default;
66 unsigned int align;
67 hwaddr desc;
68 hwaddr avail;
69 hwaddr used;
70 } VRing;
72 struct VirtQueue
74 VRing vring;
76 /* Next head to pop */
77 uint16_t last_avail_idx;
79 /* Last avail_idx read from VQ. */
80 uint16_t shadow_avail_idx;
82 uint16_t used_idx;
84 /* Last used index value we have signalled on */
85 uint16_t signalled_used;
87 /* Last used index value we have signalled on */
88 bool signalled_used_valid;
90 /* Notification enabled? */
91 bool notification;
93 uint16_t queue_index;
95 int inuse;
97 uint16_t vector;
98 void (*handle_output)(VirtIODevice *vdev, VirtQueue *vq);
99 void (*handle_aio_output)(VirtIODevice *vdev, VirtQueue *vq);
100 VirtIODevice *vdev;
101 EventNotifier guest_notifier;
102 EventNotifier host_notifier;
103 QLIST_ENTRY(VirtQueue) node;
106 /* virt queue functions */
107 void virtio_queue_update_rings(VirtIODevice *vdev, int n)
109 VRing *vring = &vdev->vq[n].vring;
111 if (!vring->desc) {
112 /* not yet setup -> nothing to do */
113 return;
115 vring->avail = vring->desc + vring->num * sizeof(VRingDesc);
116 vring->used = vring_align(vring->avail +
117 offsetof(VRingAvail, ring[vring->num]),
118 vring->align);
121 static void vring_desc_read(VirtIODevice *vdev, VRingDesc *desc,
122 hwaddr desc_pa, int i)
124 address_space_read(&address_space_memory, desc_pa + i * sizeof(VRingDesc),
125 MEMTXATTRS_UNSPECIFIED, (void *)desc, sizeof(VRingDesc));
126 virtio_tswap64s(vdev, &desc->addr);
127 virtio_tswap32s(vdev, &desc->len);
128 virtio_tswap16s(vdev, &desc->flags);
129 virtio_tswap16s(vdev, &desc->next);
132 static inline uint16_t vring_avail_flags(VirtQueue *vq)
134 hwaddr pa;
135 pa = vq->vring.avail + offsetof(VRingAvail, flags);
136 return virtio_lduw_phys(vq->vdev, pa);
139 static inline uint16_t vring_avail_idx(VirtQueue *vq)
141 hwaddr pa;
142 pa = vq->vring.avail + offsetof(VRingAvail, idx);
143 vq->shadow_avail_idx = virtio_lduw_phys(vq->vdev, pa);
144 return vq->shadow_avail_idx;
147 static inline uint16_t vring_avail_ring(VirtQueue *vq, int i)
149 hwaddr pa;
150 pa = vq->vring.avail + offsetof(VRingAvail, ring[i]);
151 return virtio_lduw_phys(vq->vdev, pa);
154 static inline uint16_t vring_get_used_event(VirtQueue *vq)
156 return vring_avail_ring(vq, vq->vring.num);
159 static inline void vring_used_write(VirtQueue *vq, VRingUsedElem *uelem,
160 int i)
162 hwaddr pa;
163 virtio_tswap32s(vq->vdev, &uelem->id);
164 virtio_tswap32s(vq->vdev, &uelem->len);
165 pa = vq->vring.used + offsetof(VRingUsed, ring[i]);
166 address_space_write(&address_space_memory, pa, MEMTXATTRS_UNSPECIFIED,
167 (void *)uelem, sizeof(VRingUsedElem));
170 static uint16_t vring_used_idx(VirtQueue *vq)
172 hwaddr pa;
173 pa = vq->vring.used + offsetof(VRingUsed, idx);
174 return virtio_lduw_phys(vq->vdev, pa);
177 static inline void vring_used_idx_set(VirtQueue *vq, uint16_t val)
179 hwaddr pa;
180 pa = vq->vring.used + offsetof(VRingUsed, idx);
181 virtio_stw_phys(vq->vdev, pa, val);
182 vq->used_idx = val;
185 static inline void vring_used_flags_set_bit(VirtQueue *vq, int mask)
187 VirtIODevice *vdev = vq->vdev;
188 hwaddr pa;
189 pa = vq->vring.used + offsetof(VRingUsed, flags);
190 virtio_stw_phys(vdev, pa, virtio_lduw_phys(vdev, pa) | mask);
193 static inline void vring_used_flags_unset_bit(VirtQueue *vq, int mask)
195 VirtIODevice *vdev = vq->vdev;
196 hwaddr pa;
197 pa = vq->vring.used + offsetof(VRingUsed, flags);
198 virtio_stw_phys(vdev, pa, virtio_lduw_phys(vdev, pa) & ~mask);
201 static inline void vring_set_avail_event(VirtQueue *vq, uint16_t val)
203 hwaddr pa;
204 if (!vq->notification) {
205 return;
207 pa = vq->vring.used + offsetof(VRingUsed, ring[vq->vring.num]);
208 virtio_stw_phys(vq->vdev, pa, val);
211 void virtio_queue_set_notification(VirtQueue *vq, int enable)
213 vq->notification = enable;
214 if (virtio_vdev_has_feature(vq->vdev, VIRTIO_RING_F_EVENT_IDX)) {
215 vring_set_avail_event(vq, vring_avail_idx(vq));
216 } else if (enable) {
217 vring_used_flags_unset_bit(vq, VRING_USED_F_NO_NOTIFY);
218 } else {
219 vring_used_flags_set_bit(vq, VRING_USED_F_NO_NOTIFY);
221 if (enable) {
222 /* Expose avail event/used flags before caller checks the avail idx. */
223 smp_mb();
227 int virtio_queue_ready(VirtQueue *vq)
229 return vq->vring.avail != 0;
232 /* Fetch avail_idx from VQ memory only when we really need to know if
233 * guest has added some buffers. */
234 int virtio_queue_empty(VirtQueue *vq)
236 if (vq->shadow_avail_idx != vq->last_avail_idx) {
237 return 0;
240 return vring_avail_idx(vq) == vq->last_avail_idx;
243 static void virtqueue_unmap_sg(VirtQueue *vq, const VirtQueueElement *elem,
244 unsigned int len)
246 unsigned int offset;
247 int i;
249 offset = 0;
250 for (i = 0; i < elem->in_num; i++) {
251 size_t size = MIN(len - offset, elem->in_sg[i].iov_len);
253 cpu_physical_memory_unmap(elem->in_sg[i].iov_base,
254 elem->in_sg[i].iov_len,
255 1, size);
257 offset += size;
260 for (i = 0; i < elem->out_num; i++)
261 cpu_physical_memory_unmap(elem->out_sg[i].iov_base,
262 elem->out_sg[i].iov_len,
263 0, elem->out_sg[i].iov_len);
266 void virtqueue_discard(VirtQueue *vq, const VirtQueueElement *elem,
267 unsigned int len)
269 vq->last_avail_idx--;
270 virtqueue_unmap_sg(vq, elem, len);
273 void virtqueue_fill(VirtQueue *vq, const VirtQueueElement *elem,
274 unsigned int len, unsigned int idx)
276 VRingUsedElem uelem;
278 trace_virtqueue_fill(vq, elem, len, idx);
280 virtqueue_unmap_sg(vq, elem, len);
282 idx = (idx + vq->used_idx) % vq->vring.num;
284 uelem.id = elem->index;
285 uelem.len = len;
286 vring_used_write(vq, &uelem, idx);
289 void virtqueue_flush(VirtQueue *vq, unsigned int count)
291 uint16_t old, new;
292 /* Make sure buffer is written before we update index. */
293 smp_wmb();
294 trace_virtqueue_flush(vq, count);
295 old = vq->used_idx;
296 new = old + count;
297 vring_used_idx_set(vq, new);
298 vq->inuse -= count;
299 if (unlikely((int16_t)(new - vq->signalled_used) < (uint16_t)(new - old)))
300 vq->signalled_used_valid = false;
303 void virtqueue_push(VirtQueue *vq, const VirtQueueElement *elem,
304 unsigned int len)
306 virtqueue_fill(vq, elem, len, 0);
307 virtqueue_flush(vq, 1);
310 static int virtqueue_num_heads(VirtQueue *vq, unsigned int idx)
312 uint16_t num_heads = vring_avail_idx(vq) - idx;
314 /* Check it isn't doing very strange things with descriptor numbers. */
315 if (num_heads > vq->vring.num) {
316 error_report("Guest moved used index from %u to %u",
317 idx, vq->shadow_avail_idx);
318 exit(1);
320 /* On success, callers read a descriptor at vq->last_avail_idx.
321 * Make sure descriptor read does not bypass avail index read. */
322 if (num_heads) {
323 smp_rmb();
326 return num_heads;
329 static unsigned int virtqueue_get_head(VirtQueue *vq, unsigned int idx)
331 unsigned int head;
333 /* Grab the next descriptor number they're advertising, and increment
334 * the index we've seen. */
335 head = vring_avail_ring(vq, idx % vq->vring.num);
337 /* If their number is silly, that's a fatal mistake. */
338 if (head >= vq->vring.num) {
339 error_report("Guest says index %u is available", head);
340 exit(1);
343 return head;
346 static unsigned virtqueue_read_next_desc(VirtIODevice *vdev, VRingDesc *desc,
347 hwaddr desc_pa, unsigned int max)
349 unsigned int next;
351 /* If this descriptor says it doesn't chain, we're done. */
352 if (!(desc->flags & VRING_DESC_F_NEXT)) {
353 return max;
356 /* Check they're not leading us off end of descriptors. */
357 next = desc->next;
358 /* Make sure compiler knows to grab that: we don't want it changing! */
359 smp_wmb();
361 if (next >= max) {
362 error_report("Desc next is %u", next);
363 exit(1);
366 vring_desc_read(vdev, desc, desc_pa, next);
367 return next;
370 void virtqueue_get_avail_bytes(VirtQueue *vq, unsigned int *in_bytes,
371 unsigned int *out_bytes,
372 unsigned max_in_bytes, unsigned max_out_bytes)
374 unsigned int idx;
375 unsigned int total_bufs, in_total, out_total;
377 idx = vq->last_avail_idx;
379 total_bufs = in_total = out_total = 0;
380 while (virtqueue_num_heads(vq, idx)) {
381 VirtIODevice *vdev = vq->vdev;
382 unsigned int max, num_bufs, indirect = 0;
383 VRingDesc desc;
384 hwaddr desc_pa;
385 int i;
387 max = vq->vring.num;
388 num_bufs = total_bufs;
389 i = virtqueue_get_head(vq, idx++);
390 desc_pa = vq->vring.desc;
391 vring_desc_read(vdev, &desc, desc_pa, i);
393 if (desc.flags & VRING_DESC_F_INDIRECT) {
394 if (desc.len % sizeof(VRingDesc)) {
395 error_report("Invalid size for indirect buffer table");
396 exit(1);
399 /* If we've got too many, that implies a descriptor loop. */
400 if (num_bufs >= max) {
401 error_report("Looped descriptor");
402 exit(1);
405 /* loop over the indirect descriptor table */
406 indirect = 1;
407 max = desc.len / sizeof(VRingDesc);
408 desc_pa = desc.addr;
409 num_bufs = i = 0;
410 vring_desc_read(vdev, &desc, desc_pa, i);
413 do {
414 /* If we've got too many, that implies a descriptor loop. */
415 if (++num_bufs > max) {
416 error_report("Looped descriptor");
417 exit(1);
420 if (desc.flags & VRING_DESC_F_WRITE) {
421 in_total += desc.len;
422 } else {
423 out_total += desc.len;
425 if (in_total >= max_in_bytes && out_total >= max_out_bytes) {
426 goto done;
428 } while ((i = virtqueue_read_next_desc(vdev, &desc, desc_pa, max)) != max);
430 if (!indirect)
431 total_bufs = num_bufs;
432 else
433 total_bufs++;
435 done:
436 if (in_bytes) {
437 *in_bytes = in_total;
439 if (out_bytes) {
440 *out_bytes = out_total;
444 int virtqueue_avail_bytes(VirtQueue *vq, unsigned int in_bytes,
445 unsigned int out_bytes)
447 unsigned int in_total, out_total;
449 virtqueue_get_avail_bytes(vq, &in_total, &out_total, in_bytes, out_bytes);
450 return in_bytes <= in_total && out_bytes <= out_total;
453 static void virtqueue_map_desc(unsigned int *p_num_sg, hwaddr *addr, struct iovec *iov,
454 unsigned int max_num_sg, bool is_write,
455 hwaddr pa, size_t sz)
457 unsigned num_sg = *p_num_sg;
458 assert(num_sg <= max_num_sg);
460 while (sz) {
461 hwaddr len = sz;
463 if (num_sg == max_num_sg) {
464 error_report("virtio: too many write descriptors in indirect table");
465 exit(1);
468 iov[num_sg].iov_base = cpu_physical_memory_map(pa, &len, is_write);
469 iov[num_sg].iov_len = len;
470 addr[num_sg] = pa;
472 sz -= len;
473 pa += len;
474 num_sg++;
476 *p_num_sg = num_sg;
479 static void virtqueue_map_iovec(struct iovec *sg, hwaddr *addr,
480 unsigned int *num_sg, unsigned int max_size,
481 int is_write)
483 unsigned int i;
484 hwaddr len;
486 /* Note: this function MUST validate input, some callers
487 * are passing in num_sg values received over the network.
489 /* TODO: teach all callers that this can fail, and return failure instead
490 * of asserting here.
491 * When we do, we might be able to re-enable NDEBUG below.
493 #ifdef NDEBUG
494 #error building with NDEBUG is not supported
495 #endif
496 assert(*num_sg <= max_size);
498 for (i = 0; i < *num_sg; i++) {
499 len = sg[i].iov_len;
500 sg[i].iov_base = cpu_physical_memory_map(addr[i], &len, is_write);
501 if (!sg[i].iov_base) {
502 error_report("virtio: error trying to map MMIO memory");
503 exit(1);
505 if (len != sg[i].iov_len) {
506 error_report("virtio: unexpected memory split");
507 exit(1);
512 void virtqueue_map(VirtQueueElement *elem)
514 virtqueue_map_iovec(elem->in_sg, elem->in_addr, &elem->in_num,
515 VIRTQUEUE_MAX_SIZE, 1);
516 virtqueue_map_iovec(elem->out_sg, elem->out_addr, &elem->out_num,
517 VIRTQUEUE_MAX_SIZE, 0);
520 void *virtqueue_alloc_element(size_t sz, unsigned out_num, unsigned in_num)
522 VirtQueueElement *elem;
523 size_t in_addr_ofs = QEMU_ALIGN_UP(sz, __alignof__(elem->in_addr[0]));
524 size_t out_addr_ofs = in_addr_ofs + in_num * sizeof(elem->in_addr[0]);
525 size_t out_addr_end = out_addr_ofs + out_num * sizeof(elem->out_addr[0]);
526 size_t in_sg_ofs = QEMU_ALIGN_UP(out_addr_end, __alignof__(elem->in_sg[0]));
527 size_t out_sg_ofs = in_sg_ofs + in_num * sizeof(elem->in_sg[0]);
528 size_t out_sg_end = out_sg_ofs + out_num * sizeof(elem->out_sg[0]);
530 assert(sz >= sizeof(VirtQueueElement));
531 elem = g_malloc(out_sg_end);
532 elem->out_num = out_num;
533 elem->in_num = in_num;
534 elem->in_addr = (void *)elem + in_addr_ofs;
535 elem->out_addr = (void *)elem + out_addr_ofs;
536 elem->in_sg = (void *)elem + in_sg_ofs;
537 elem->out_sg = (void *)elem + out_sg_ofs;
538 return elem;
541 void *virtqueue_pop(VirtQueue *vq, size_t sz)
543 unsigned int i, head, max;
544 hwaddr desc_pa = vq->vring.desc;
545 VirtIODevice *vdev = vq->vdev;
546 VirtQueueElement *elem;
547 unsigned out_num, in_num;
548 hwaddr addr[VIRTQUEUE_MAX_SIZE];
549 struct iovec iov[VIRTQUEUE_MAX_SIZE];
550 VRingDesc desc;
552 if (virtio_queue_empty(vq)) {
553 return NULL;
555 /* Needed after virtio_queue_empty(), see comment in
556 * virtqueue_num_heads(). */
557 smp_rmb();
559 /* When we start there are none of either input nor output. */
560 out_num = in_num = 0;
562 max = vq->vring.num;
564 i = head = virtqueue_get_head(vq, vq->last_avail_idx++);
565 if (virtio_vdev_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX)) {
566 vring_set_avail_event(vq, vq->last_avail_idx);
569 vring_desc_read(vdev, &desc, desc_pa, i);
570 if (desc.flags & VRING_DESC_F_INDIRECT) {
571 if (desc.len % sizeof(VRingDesc)) {
572 error_report("Invalid size for indirect buffer table");
573 exit(1);
576 /* loop over the indirect descriptor table */
577 max = desc.len / sizeof(VRingDesc);
578 desc_pa = desc.addr;
579 i = 0;
580 vring_desc_read(vdev, &desc, desc_pa, i);
583 /* Collect all the descriptors */
584 do {
585 if (desc.flags & VRING_DESC_F_WRITE) {
586 virtqueue_map_desc(&in_num, addr + out_num, iov + out_num,
587 VIRTQUEUE_MAX_SIZE - out_num, true, desc.addr, desc.len);
588 } else {
589 if (in_num) {
590 error_report("Incorrect order for descriptors");
591 exit(1);
593 virtqueue_map_desc(&out_num, addr, iov,
594 VIRTQUEUE_MAX_SIZE, false, desc.addr, desc.len);
597 /* If we've got too many, that implies a descriptor loop. */
598 if ((in_num + out_num) > max) {
599 error_report("Looped descriptor");
600 exit(1);
602 } while ((i = virtqueue_read_next_desc(vdev, &desc, desc_pa, max)) != max);
604 /* Now copy what we have collected and mapped */
605 elem = virtqueue_alloc_element(sz, out_num, in_num);
606 elem->index = head;
607 for (i = 0; i < out_num; i++) {
608 elem->out_addr[i] = addr[i];
609 elem->out_sg[i] = iov[i];
611 for (i = 0; i < in_num; i++) {
612 elem->in_addr[i] = addr[out_num + i];
613 elem->in_sg[i] = iov[out_num + i];
616 vq->inuse++;
618 trace_virtqueue_pop(vq, elem, elem->in_num, elem->out_num);
619 return elem;
622 /* Reading and writing a structure directly to QEMUFile is *awful*, but
623 * it is what QEMU has always done by mistake. We can change it sooner
624 * or later by bumping the version number of the affected vm states.
625 * In the meanwhile, since the in-memory layout of VirtQueueElement
626 * has changed, we need to marshal to and from the layout that was
627 * used before the change.
629 typedef struct VirtQueueElementOld {
630 unsigned int index;
631 unsigned int out_num;
632 unsigned int in_num;
633 hwaddr in_addr[VIRTQUEUE_MAX_SIZE];
634 hwaddr out_addr[VIRTQUEUE_MAX_SIZE];
635 struct iovec in_sg[VIRTQUEUE_MAX_SIZE];
636 struct iovec out_sg[VIRTQUEUE_MAX_SIZE];
637 } VirtQueueElementOld;
639 void *qemu_get_virtqueue_element(QEMUFile *f, size_t sz)
641 VirtQueueElement *elem;
642 VirtQueueElementOld data;
643 int i;
645 qemu_get_buffer(f, (uint8_t *)&data, sizeof(VirtQueueElementOld));
647 elem = virtqueue_alloc_element(sz, data.out_num, data.in_num);
648 elem->index = data.index;
650 for (i = 0; i < elem->in_num; i++) {
651 elem->in_addr[i] = data.in_addr[i];
654 for (i = 0; i < elem->out_num; i++) {
655 elem->out_addr[i] = data.out_addr[i];
658 for (i = 0; i < elem->in_num; i++) {
659 /* Base is overwritten by virtqueue_map. */
660 elem->in_sg[i].iov_base = 0;
661 elem->in_sg[i].iov_len = data.in_sg[i].iov_len;
664 for (i = 0; i < elem->out_num; i++) {
665 /* Base is overwritten by virtqueue_map. */
666 elem->out_sg[i].iov_base = 0;
667 elem->out_sg[i].iov_len = data.out_sg[i].iov_len;
670 virtqueue_map(elem);
671 return elem;
674 void qemu_put_virtqueue_element(QEMUFile *f, VirtQueueElement *elem)
676 VirtQueueElementOld data;
677 int i;
679 memset(&data, 0, sizeof(data));
680 data.index = elem->index;
681 data.in_num = elem->in_num;
682 data.out_num = elem->out_num;
684 for (i = 0; i < elem->in_num; i++) {
685 data.in_addr[i] = elem->in_addr[i];
688 for (i = 0; i < elem->out_num; i++) {
689 data.out_addr[i] = elem->out_addr[i];
692 for (i = 0; i < elem->in_num; i++) {
693 /* Base is overwritten by virtqueue_map when loading. Do not
694 * save it, as it would leak the QEMU address space layout. */
695 data.in_sg[i].iov_len = elem->in_sg[i].iov_len;
698 for (i = 0; i < elem->out_num; i++) {
699 /* Do not save iov_base as above. */
700 data.out_sg[i].iov_len = elem->out_sg[i].iov_len;
702 qemu_put_buffer(f, (uint8_t *)&data, sizeof(VirtQueueElementOld));
705 /* virtio device */
706 static void virtio_notify_vector(VirtIODevice *vdev, uint16_t vector)
708 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
709 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
711 if (k->notify) {
712 k->notify(qbus->parent, vector);
716 void virtio_update_irq(VirtIODevice *vdev)
718 virtio_notify_vector(vdev, VIRTIO_NO_VECTOR);
721 static int virtio_validate_features(VirtIODevice *vdev)
723 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
725 if (k->validate_features) {
726 return k->validate_features(vdev);
727 } else {
728 return 0;
732 int virtio_set_status(VirtIODevice *vdev, uint8_t val)
734 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
735 trace_virtio_set_status(vdev, val);
737 if (virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1)) {
738 if (!(vdev->status & VIRTIO_CONFIG_S_FEATURES_OK) &&
739 val & VIRTIO_CONFIG_S_FEATURES_OK) {
740 int ret = virtio_validate_features(vdev);
742 if (ret) {
743 return ret;
747 if (k->set_status) {
748 k->set_status(vdev, val);
750 vdev->status = val;
751 return 0;
754 bool target_words_bigendian(void);
755 static enum virtio_device_endian virtio_default_endian(void)
757 if (target_words_bigendian()) {
758 return VIRTIO_DEVICE_ENDIAN_BIG;
759 } else {
760 return VIRTIO_DEVICE_ENDIAN_LITTLE;
764 static enum virtio_device_endian virtio_current_cpu_endian(void)
766 CPUClass *cc = CPU_GET_CLASS(current_cpu);
768 if (cc->virtio_is_big_endian(current_cpu)) {
769 return VIRTIO_DEVICE_ENDIAN_BIG;
770 } else {
771 return VIRTIO_DEVICE_ENDIAN_LITTLE;
775 void virtio_reset(void *opaque)
777 VirtIODevice *vdev = opaque;
778 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
779 int i;
781 virtio_set_status(vdev, 0);
782 if (current_cpu) {
783 /* Guest initiated reset */
784 vdev->device_endian = virtio_current_cpu_endian();
785 } else {
786 /* System reset */
787 vdev->device_endian = virtio_default_endian();
790 if (k->reset) {
791 k->reset(vdev);
794 vdev->guest_features = 0;
795 vdev->queue_sel = 0;
796 vdev->status = 0;
797 vdev->isr = 0;
798 vdev->config_vector = VIRTIO_NO_VECTOR;
799 virtio_notify_vector(vdev, vdev->config_vector);
801 for(i = 0; i < VIRTIO_QUEUE_MAX; i++) {
802 vdev->vq[i].vring.desc = 0;
803 vdev->vq[i].vring.avail = 0;
804 vdev->vq[i].vring.used = 0;
805 vdev->vq[i].last_avail_idx = 0;
806 vdev->vq[i].shadow_avail_idx = 0;
807 vdev->vq[i].used_idx = 0;
808 virtio_queue_set_vector(vdev, i, VIRTIO_NO_VECTOR);
809 vdev->vq[i].signalled_used = 0;
810 vdev->vq[i].signalled_used_valid = false;
811 vdev->vq[i].notification = true;
812 vdev->vq[i].vring.num = vdev->vq[i].vring.num_default;
816 uint32_t virtio_config_readb(VirtIODevice *vdev, uint32_t addr)
818 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
819 uint8_t val;
821 if (addr + sizeof(val) > vdev->config_len) {
822 return (uint32_t)-1;
825 k->get_config(vdev, vdev->config);
827 val = ldub_p(vdev->config + addr);
828 return val;
831 uint32_t virtio_config_readw(VirtIODevice *vdev, uint32_t addr)
833 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
834 uint16_t val;
836 if (addr + sizeof(val) > vdev->config_len) {
837 return (uint32_t)-1;
840 k->get_config(vdev, vdev->config);
842 val = lduw_p(vdev->config + addr);
843 return val;
846 uint32_t virtio_config_readl(VirtIODevice *vdev, uint32_t addr)
848 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
849 uint32_t val;
851 if (addr + sizeof(val) > vdev->config_len) {
852 return (uint32_t)-1;
855 k->get_config(vdev, vdev->config);
857 val = ldl_p(vdev->config + addr);
858 return val;
861 void virtio_config_writeb(VirtIODevice *vdev, uint32_t addr, uint32_t data)
863 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
864 uint8_t val = data;
866 if (addr + sizeof(val) > vdev->config_len) {
867 return;
870 stb_p(vdev->config + addr, val);
872 if (k->set_config) {
873 k->set_config(vdev, vdev->config);
877 void virtio_config_writew(VirtIODevice *vdev, uint32_t addr, uint32_t data)
879 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
880 uint16_t val = data;
882 if (addr + sizeof(val) > vdev->config_len) {
883 return;
886 stw_p(vdev->config + addr, val);
888 if (k->set_config) {
889 k->set_config(vdev, vdev->config);
893 void virtio_config_writel(VirtIODevice *vdev, uint32_t addr, uint32_t data)
895 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
896 uint32_t val = data;
898 if (addr + sizeof(val) > vdev->config_len) {
899 return;
902 stl_p(vdev->config + addr, val);
904 if (k->set_config) {
905 k->set_config(vdev, vdev->config);
909 uint32_t virtio_config_modern_readb(VirtIODevice *vdev, uint32_t addr)
911 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
912 uint8_t val;
914 if (addr + sizeof(val) > vdev->config_len) {
915 return (uint32_t)-1;
918 k->get_config(vdev, vdev->config);
920 val = ldub_p(vdev->config + addr);
921 return val;
924 uint32_t virtio_config_modern_readw(VirtIODevice *vdev, uint32_t addr)
926 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
927 uint16_t val;
929 if (addr + sizeof(val) > vdev->config_len) {
930 return (uint32_t)-1;
933 k->get_config(vdev, vdev->config);
935 val = lduw_le_p(vdev->config + addr);
936 return val;
939 uint32_t virtio_config_modern_readl(VirtIODevice *vdev, uint32_t addr)
941 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
942 uint32_t val;
944 if (addr + sizeof(val) > vdev->config_len) {
945 return (uint32_t)-1;
948 k->get_config(vdev, vdev->config);
950 val = ldl_le_p(vdev->config + addr);
951 return val;
954 void virtio_config_modern_writeb(VirtIODevice *vdev,
955 uint32_t addr, uint32_t data)
957 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
958 uint8_t val = data;
960 if (addr + sizeof(val) > vdev->config_len) {
961 return;
964 stb_p(vdev->config + addr, val);
966 if (k->set_config) {
967 k->set_config(vdev, vdev->config);
971 void virtio_config_modern_writew(VirtIODevice *vdev,
972 uint32_t addr, uint32_t data)
974 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
975 uint16_t val = data;
977 if (addr + sizeof(val) > vdev->config_len) {
978 return;
981 stw_le_p(vdev->config + addr, val);
983 if (k->set_config) {
984 k->set_config(vdev, vdev->config);
988 void virtio_config_modern_writel(VirtIODevice *vdev,
989 uint32_t addr, uint32_t data)
991 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
992 uint32_t val = data;
994 if (addr + sizeof(val) > vdev->config_len) {
995 return;
998 stl_le_p(vdev->config + addr, val);
1000 if (k->set_config) {
1001 k->set_config(vdev, vdev->config);
1005 void virtio_queue_set_addr(VirtIODevice *vdev, int n, hwaddr addr)
1007 vdev->vq[n].vring.desc = addr;
1008 virtio_queue_update_rings(vdev, n);
1011 hwaddr virtio_queue_get_addr(VirtIODevice *vdev, int n)
1013 return vdev->vq[n].vring.desc;
1016 void virtio_queue_set_rings(VirtIODevice *vdev, int n, hwaddr desc,
1017 hwaddr avail, hwaddr used)
1019 vdev->vq[n].vring.desc = desc;
1020 vdev->vq[n].vring.avail = avail;
1021 vdev->vq[n].vring.used = used;
1024 void virtio_queue_set_num(VirtIODevice *vdev, int n, int num)
1026 /* Don't allow guest to flip queue between existent and
1027 * nonexistent states, or to set it to an invalid size.
1029 if (!!num != !!vdev->vq[n].vring.num ||
1030 num > VIRTQUEUE_MAX_SIZE ||
1031 num < 0) {
1032 return;
1034 vdev->vq[n].vring.num = num;
1037 VirtQueue *virtio_vector_first_queue(VirtIODevice *vdev, uint16_t vector)
1039 return QLIST_FIRST(&vdev->vector_queues[vector]);
1042 VirtQueue *virtio_vector_next_queue(VirtQueue *vq)
1044 return QLIST_NEXT(vq, node);
1047 int virtio_queue_get_num(VirtIODevice *vdev, int n)
1049 return vdev->vq[n].vring.num;
1052 int virtio_get_num_queues(VirtIODevice *vdev)
1054 int i;
1056 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1057 if (!virtio_queue_get_num(vdev, i)) {
1058 break;
1062 return i;
1065 void virtio_queue_set_align(VirtIODevice *vdev, int n, int align)
1067 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1068 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1070 /* virtio-1 compliant devices cannot change the alignment */
1071 if (virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1)) {
1072 error_report("tried to modify queue alignment for virtio-1 device");
1073 return;
1075 /* Check that the transport told us it was going to do this
1076 * (so a buggy transport will immediately assert rather than
1077 * silently failing to migrate this state)
1079 assert(k->has_variable_vring_alignment);
1081 vdev->vq[n].vring.align = align;
1082 virtio_queue_update_rings(vdev, n);
1085 static void virtio_queue_notify_aio_vq(VirtQueue *vq)
1087 if (vq->vring.desc && vq->handle_aio_output) {
1088 VirtIODevice *vdev = vq->vdev;
1090 trace_virtio_queue_notify(vdev, vq - vdev->vq, vq);
1091 vq->handle_aio_output(vdev, vq);
1095 static void virtio_queue_notify_vq(VirtQueue *vq)
1097 if (vq->vring.desc && vq->handle_output) {
1098 VirtIODevice *vdev = vq->vdev;
1100 trace_virtio_queue_notify(vdev, vq - vdev->vq, vq);
1101 vq->handle_output(vdev, vq);
1105 void virtio_queue_notify(VirtIODevice *vdev, int n)
1107 virtio_queue_notify_vq(&vdev->vq[n]);
1110 uint16_t virtio_queue_vector(VirtIODevice *vdev, int n)
1112 return n < VIRTIO_QUEUE_MAX ? vdev->vq[n].vector :
1113 VIRTIO_NO_VECTOR;
1116 void virtio_queue_set_vector(VirtIODevice *vdev, int n, uint16_t vector)
1118 VirtQueue *vq = &vdev->vq[n];
1120 if (n < VIRTIO_QUEUE_MAX) {
1121 if (vdev->vector_queues &&
1122 vdev->vq[n].vector != VIRTIO_NO_VECTOR) {
1123 QLIST_REMOVE(vq, node);
1125 vdev->vq[n].vector = vector;
1126 if (vdev->vector_queues &&
1127 vector != VIRTIO_NO_VECTOR) {
1128 QLIST_INSERT_HEAD(&vdev->vector_queues[vector], vq, node);
1133 VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
1134 void (*handle_output)(VirtIODevice *, VirtQueue *))
1136 int i;
1138 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1139 if (vdev->vq[i].vring.num == 0)
1140 break;
1143 if (i == VIRTIO_QUEUE_MAX || queue_size > VIRTQUEUE_MAX_SIZE)
1144 abort();
1146 vdev->vq[i].vring.num = queue_size;
1147 vdev->vq[i].vring.num_default = queue_size;
1148 vdev->vq[i].vring.align = VIRTIO_PCI_VRING_ALIGN;
1149 vdev->vq[i].handle_output = handle_output;
1150 vdev->vq[i].handle_aio_output = NULL;
1152 return &vdev->vq[i];
1155 void virtio_del_queue(VirtIODevice *vdev, int n)
1157 if (n < 0 || n >= VIRTIO_QUEUE_MAX) {
1158 abort();
1161 vdev->vq[n].vring.num = 0;
1162 vdev->vq[n].vring.num_default = 0;
1165 void virtio_irq(VirtQueue *vq)
1167 trace_virtio_irq(vq);
1168 vq->vdev->isr |= 0x01;
1169 virtio_notify_vector(vq->vdev, vq->vector);
1172 bool virtio_should_notify(VirtIODevice *vdev, VirtQueue *vq)
1174 uint16_t old, new;
1175 bool v;
1176 /* We need to expose used array entries before checking used event. */
1177 smp_mb();
1178 /* Always notify when queue is empty (when feature acknowledge) */
1179 if (virtio_vdev_has_feature(vdev, VIRTIO_F_NOTIFY_ON_EMPTY) &&
1180 !vq->inuse && virtio_queue_empty(vq)) {
1181 return true;
1184 if (!virtio_vdev_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX)) {
1185 return !(vring_avail_flags(vq) & VRING_AVAIL_F_NO_INTERRUPT);
1188 v = vq->signalled_used_valid;
1189 vq->signalled_used_valid = true;
1190 old = vq->signalled_used;
1191 new = vq->signalled_used = vq->used_idx;
1192 return !v || vring_need_event(vring_get_used_event(vq), new, old);
1195 void virtio_notify(VirtIODevice *vdev, VirtQueue *vq)
1197 if (!virtio_should_notify(vdev, vq)) {
1198 return;
1201 trace_virtio_notify(vdev, vq);
1202 vdev->isr |= 0x01;
1203 virtio_notify_vector(vdev, vq->vector);
1206 void virtio_notify_config(VirtIODevice *vdev)
1208 if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))
1209 return;
1211 vdev->isr |= 0x03;
1212 vdev->generation++;
1213 virtio_notify_vector(vdev, vdev->config_vector);
1216 static bool virtio_device_endian_needed(void *opaque)
1218 VirtIODevice *vdev = opaque;
1220 assert(vdev->device_endian != VIRTIO_DEVICE_ENDIAN_UNKNOWN);
1221 if (!virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1)) {
1222 return vdev->device_endian != virtio_default_endian();
1224 /* Devices conforming to VIRTIO 1.0 or later are always LE. */
1225 return vdev->device_endian != VIRTIO_DEVICE_ENDIAN_LITTLE;
1228 static bool virtio_64bit_features_needed(void *opaque)
1230 VirtIODevice *vdev = opaque;
1232 return (vdev->host_features >> 32) != 0;
1235 static bool virtio_virtqueue_needed(void *opaque)
1237 VirtIODevice *vdev = opaque;
1239 return virtio_host_has_feature(vdev, VIRTIO_F_VERSION_1);
1242 static bool virtio_ringsize_needed(void *opaque)
1244 VirtIODevice *vdev = opaque;
1245 int i;
1247 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1248 if (vdev->vq[i].vring.num != vdev->vq[i].vring.num_default) {
1249 return true;
1252 return false;
1255 static bool virtio_extra_state_needed(void *opaque)
1257 VirtIODevice *vdev = opaque;
1258 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1259 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1261 return k->has_extra_state &&
1262 k->has_extra_state(qbus->parent);
1265 static const VMStateDescription vmstate_virtqueue = {
1266 .name = "virtqueue_state",
1267 .version_id = 1,
1268 .minimum_version_id = 1,
1269 .fields = (VMStateField[]) {
1270 VMSTATE_UINT64(vring.avail, struct VirtQueue),
1271 VMSTATE_UINT64(vring.used, struct VirtQueue),
1272 VMSTATE_END_OF_LIST()
1276 static const VMStateDescription vmstate_virtio_virtqueues = {
1277 .name = "virtio/virtqueues",
1278 .version_id = 1,
1279 .minimum_version_id = 1,
1280 .needed = &virtio_virtqueue_needed,
1281 .fields = (VMStateField[]) {
1282 VMSTATE_STRUCT_VARRAY_POINTER_KNOWN(vq, struct VirtIODevice,
1283 VIRTIO_QUEUE_MAX, 0, vmstate_virtqueue, VirtQueue),
1284 VMSTATE_END_OF_LIST()
1288 static const VMStateDescription vmstate_ringsize = {
1289 .name = "ringsize_state",
1290 .version_id = 1,
1291 .minimum_version_id = 1,
1292 .fields = (VMStateField[]) {
1293 VMSTATE_UINT32(vring.num_default, struct VirtQueue),
1294 VMSTATE_END_OF_LIST()
1298 static const VMStateDescription vmstate_virtio_ringsize = {
1299 .name = "virtio/ringsize",
1300 .version_id = 1,
1301 .minimum_version_id = 1,
1302 .needed = &virtio_ringsize_needed,
1303 .fields = (VMStateField[]) {
1304 VMSTATE_STRUCT_VARRAY_POINTER_KNOWN(vq, struct VirtIODevice,
1305 VIRTIO_QUEUE_MAX, 0, vmstate_ringsize, VirtQueue),
1306 VMSTATE_END_OF_LIST()
1310 static int get_extra_state(QEMUFile *f, void *pv, size_t size)
1312 VirtIODevice *vdev = pv;
1313 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1314 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1316 if (!k->load_extra_state) {
1317 return -1;
1318 } else {
1319 return k->load_extra_state(qbus->parent, f);
1323 static void put_extra_state(QEMUFile *f, void *pv, size_t size)
1325 VirtIODevice *vdev = pv;
1326 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1327 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1329 k->save_extra_state(qbus->parent, f);
1332 static const VMStateInfo vmstate_info_extra_state = {
1333 .name = "virtqueue_extra_state",
1334 .get = get_extra_state,
1335 .put = put_extra_state,
1338 static const VMStateDescription vmstate_virtio_extra_state = {
1339 .name = "virtio/extra_state",
1340 .version_id = 1,
1341 .minimum_version_id = 1,
1342 .needed = &virtio_extra_state_needed,
1343 .fields = (VMStateField[]) {
1345 .name = "extra_state",
1346 .version_id = 0,
1347 .field_exists = NULL,
1348 .size = 0,
1349 .info = &vmstate_info_extra_state,
1350 .flags = VMS_SINGLE,
1351 .offset = 0,
1353 VMSTATE_END_OF_LIST()
1357 static const VMStateDescription vmstate_virtio_device_endian = {
1358 .name = "virtio/device_endian",
1359 .version_id = 1,
1360 .minimum_version_id = 1,
1361 .needed = &virtio_device_endian_needed,
1362 .fields = (VMStateField[]) {
1363 VMSTATE_UINT8(device_endian, VirtIODevice),
1364 VMSTATE_END_OF_LIST()
1368 static const VMStateDescription vmstate_virtio_64bit_features = {
1369 .name = "virtio/64bit_features",
1370 .version_id = 1,
1371 .minimum_version_id = 1,
1372 .needed = &virtio_64bit_features_needed,
1373 .fields = (VMStateField[]) {
1374 VMSTATE_UINT64(guest_features, VirtIODevice),
1375 VMSTATE_END_OF_LIST()
1379 static const VMStateDescription vmstate_virtio = {
1380 .name = "virtio",
1381 .version_id = 1,
1382 .minimum_version_id = 1,
1383 .minimum_version_id_old = 1,
1384 .fields = (VMStateField[]) {
1385 VMSTATE_END_OF_LIST()
1387 .subsections = (const VMStateDescription*[]) {
1388 &vmstate_virtio_device_endian,
1389 &vmstate_virtio_64bit_features,
1390 &vmstate_virtio_virtqueues,
1391 &vmstate_virtio_ringsize,
1392 &vmstate_virtio_extra_state,
1393 NULL
1397 void virtio_save(VirtIODevice *vdev, QEMUFile *f)
1399 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1400 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1401 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
1402 uint32_t guest_features_lo = (vdev->guest_features & 0xffffffff);
1403 int i;
1405 if (k->save_config) {
1406 k->save_config(qbus->parent, f);
1409 qemu_put_8s(f, &vdev->status);
1410 qemu_put_8s(f, &vdev->isr);
1411 qemu_put_be16s(f, &vdev->queue_sel);
1412 qemu_put_be32s(f, &guest_features_lo);
1413 qemu_put_be32(f, vdev->config_len);
1414 qemu_put_buffer(f, vdev->config, vdev->config_len);
1416 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1417 if (vdev->vq[i].vring.num == 0)
1418 break;
1421 qemu_put_be32(f, i);
1423 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1424 if (vdev->vq[i].vring.num == 0)
1425 break;
1427 qemu_put_be32(f, vdev->vq[i].vring.num);
1428 if (k->has_variable_vring_alignment) {
1429 qemu_put_be32(f, vdev->vq[i].vring.align);
1431 /* XXX virtio-1 devices */
1432 qemu_put_be64(f, vdev->vq[i].vring.desc);
1433 qemu_put_be16s(f, &vdev->vq[i].last_avail_idx);
1434 if (k->save_queue) {
1435 k->save_queue(qbus->parent, i, f);
1439 if (vdc->save != NULL) {
1440 vdc->save(vdev, f);
1443 /* Subsections */
1444 vmstate_save_state(f, &vmstate_virtio, vdev, NULL);
1447 static int virtio_set_features_nocheck(VirtIODevice *vdev, uint64_t val)
1449 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
1450 bool bad = (val & ~(vdev->host_features)) != 0;
1452 val &= vdev->host_features;
1453 if (k->set_features) {
1454 k->set_features(vdev, val);
1456 vdev->guest_features = val;
1457 return bad ? -1 : 0;
1460 int virtio_set_features(VirtIODevice *vdev, uint64_t val)
1463 * The driver must not attempt to set features after feature negotiation
1464 * has finished.
1466 if (vdev->status & VIRTIO_CONFIG_S_FEATURES_OK) {
1467 return -EINVAL;
1469 return virtio_set_features_nocheck(vdev, val);
1472 int virtio_load(VirtIODevice *vdev, QEMUFile *f, int version_id)
1474 int i, ret;
1475 int32_t config_len;
1476 uint32_t num;
1477 uint32_t features;
1478 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1479 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1480 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
1483 * We poison the endianness to ensure it does not get used before
1484 * subsections have been loaded.
1486 vdev->device_endian = VIRTIO_DEVICE_ENDIAN_UNKNOWN;
1488 if (k->load_config) {
1489 ret = k->load_config(qbus->parent, f);
1490 if (ret)
1491 return ret;
1494 qemu_get_8s(f, &vdev->status);
1495 qemu_get_8s(f, &vdev->isr);
1496 qemu_get_be16s(f, &vdev->queue_sel);
1497 if (vdev->queue_sel >= VIRTIO_QUEUE_MAX) {
1498 return -1;
1500 qemu_get_be32s(f, &features);
1503 * Temporarily set guest_features low bits - needed by
1504 * virtio net load code testing for VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
1505 * VIRTIO_NET_F_GUEST_ANNOUNCE and VIRTIO_NET_F_CTRL_VQ.
1507 * Note: devices should always test host features in future - don't create
1508 * new dependencies like this.
1510 vdev->guest_features = features;
1512 config_len = qemu_get_be32(f);
1515 * There are cases where the incoming config can be bigger or smaller
1516 * than what we have; so load what we have space for, and skip
1517 * any excess that's in the stream.
1519 qemu_get_buffer(f, vdev->config, MIN(config_len, vdev->config_len));
1521 while (config_len > vdev->config_len) {
1522 qemu_get_byte(f);
1523 config_len--;
1526 num = qemu_get_be32(f);
1528 if (num > VIRTIO_QUEUE_MAX) {
1529 error_report("Invalid number of virtqueues: 0x%x", num);
1530 return -1;
1533 for (i = 0; i < num; i++) {
1534 vdev->vq[i].vring.num = qemu_get_be32(f);
1535 if (k->has_variable_vring_alignment) {
1536 vdev->vq[i].vring.align = qemu_get_be32(f);
1538 vdev->vq[i].vring.desc = qemu_get_be64(f);
1539 qemu_get_be16s(f, &vdev->vq[i].last_avail_idx);
1540 vdev->vq[i].signalled_used_valid = false;
1541 vdev->vq[i].notification = true;
1543 if (vdev->vq[i].vring.desc) {
1544 /* XXX virtio-1 devices */
1545 virtio_queue_update_rings(vdev, i);
1546 } else if (vdev->vq[i].last_avail_idx) {
1547 error_report("VQ %d address 0x0 "
1548 "inconsistent with Host index 0x%x",
1549 i, vdev->vq[i].last_avail_idx);
1550 return -1;
1552 if (k->load_queue) {
1553 ret = k->load_queue(qbus->parent, i, f);
1554 if (ret)
1555 return ret;
1559 virtio_notify_vector(vdev, VIRTIO_NO_VECTOR);
1561 if (vdc->load != NULL) {
1562 ret = vdc->load(vdev, f, version_id);
1563 if (ret) {
1564 return ret;
1568 /* Subsections */
1569 ret = vmstate_load_state(f, &vmstate_virtio, vdev, 1);
1570 if (ret) {
1571 return ret;
1574 if (vdev->device_endian == VIRTIO_DEVICE_ENDIAN_UNKNOWN) {
1575 vdev->device_endian = virtio_default_endian();
1578 if (virtio_64bit_features_needed(vdev)) {
1580 * Subsection load filled vdev->guest_features. Run them
1581 * through virtio_set_features to sanity-check them against
1582 * host_features.
1584 uint64_t features64 = vdev->guest_features;
1585 if (virtio_set_features_nocheck(vdev, features64) < 0) {
1586 error_report("Features 0x%" PRIx64 " unsupported. "
1587 "Allowed features: 0x%" PRIx64,
1588 features64, vdev->host_features);
1589 return -1;
1591 } else {
1592 if (virtio_set_features_nocheck(vdev, features) < 0) {
1593 error_report("Features 0x%x unsupported. "
1594 "Allowed features: 0x%" PRIx64,
1595 features, vdev->host_features);
1596 return -1;
1600 for (i = 0; i < num; i++) {
1601 if (vdev->vq[i].vring.desc) {
1602 uint16_t nheads;
1603 nheads = vring_avail_idx(&vdev->vq[i]) - vdev->vq[i].last_avail_idx;
1604 /* Check it isn't doing strange things with descriptor numbers. */
1605 if (nheads > vdev->vq[i].vring.num) {
1606 error_report("VQ %d size 0x%x Guest index 0x%x "
1607 "inconsistent with Host index 0x%x: delta 0x%x",
1608 i, vdev->vq[i].vring.num,
1609 vring_avail_idx(&vdev->vq[i]),
1610 vdev->vq[i].last_avail_idx, nheads);
1611 return -1;
1613 vdev->vq[i].used_idx = vring_used_idx(&vdev->vq[i]);
1614 vdev->vq[i].shadow_avail_idx = vring_avail_idx(&vdev->vq[i]);
1618 return 0;
1621 void virtio_cleanup(VirtIODevice *vdev)
1623 qemu_del_vm_change_state_handler(vdev->vmstate);
1624 g_free(vdev->config);
1625 g_free(vdev->vq);
1626 g_free(vdev->vector_queues);
1629 static void virtio_vmstate_change(void *opaque, int running, RunState state)
1631 VirtIODevice *vdev = opaque;
1632 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1633 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1634 bool backend_run = running && (vdev->status & VIRTIO_CONFIG_S_DRIVER_OK);
1635 vdev->vm_running = running;
1637 if (backend_run) {
1638 virtio_set_status(vdev, vdev->status);
1641 if (k->vmstate_change) {
1642 k->vmstate_change(qbus->parent, backend_run);
1645 if (!backend_run) {
1646 virtio_set_status(vdev, vdev->status);
1650 void virtio_instance_init_common(Object *proxy_obj, void *data,
1651 size_t vdev_size, const char *vdev_name)
1653 DeviceState *vdev = data;
1655 object_initialize(vdev, vdev_size, vdev_name);
1656 object_property_add_child(proxy_obj, "virtio-backend", OBJECT(vdev), NULL);
1657 object_unref(OBJECT(vdev));
1658 qdev_alias_all_properties(vdev, proxy_obj);
1661 void virtio_init(VirtIODevice *vdev, const char *name,
1662 uint16_t device_id, size_t config_size)
1664 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1665 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1666 int i;
1667 int nvectors = k->query_nvectors ? k->query_nvectors(qbus->parent) : 0;
1669 if (nvectors) {
1670 vdev->vector_queues =
1671 g_malloc0(sizeof(*vdev->vector_queues) * nvectors);
1674 vdev->device_id = device_id;
1675 vdev->status = 0;
1676 vdev->isr = 0;
1677 vdev->queue_sel = 0;
1678 vdev->config_vector = VIRTIO_NO_VECTOR;
1679 vdev->vq = g_malloc0(sizeof(VirtQueue) * VIRTIO_QUEUE_MAX);
1680 vdev->vm_running = runstate_is_running();
1681 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1682 vdev->vq[i].vector = VIRTIO_NO_VECTOR;
1683 vdev->vq[i].vdev = vdev;
1684 vdev->vq[i].queue_index = i;
1687 vdev->name = name;
1688 vdev->config_len = config_size;
1689 if (vdev->config_len) {
1690 vdev->config = g_malloc0(config_size);
1691 } else {
1692 vdev->config = NULL;
1694 vdev->vmstate = qemu_add_vm_change_state_handler(virtio_vmstate_change,
1695 vdev);
1696 vdev->device_endian = virtio_default_endian();
1697 vdev->use_guest_notifier_mask = true;
1700 hwaddr virtio_queue_get_desc_addr(VirtIODevice *vdev, int n)
1702 return vdev->vq[n].vring.desc;
1705 hwaddr virtio_queue_get_avail_addr(VirtIODevice *vdev, int n)
1707 return vdev->vq[n].vring.avail;
1710 hwaddr virtio_queue_get_used_addr(VirtIODevice *vdev, int n)
1712 return vdev->vq[n].vring.used;
1715 hwaddr virtio_queue_get_ring_addr(VirtIODevice *vdev, int n)
1717 return vdev->vq[n].vring.desc;
1720 hwaddr virtio_queue_get_desc_size(VirtIODevice *vdev, int n)
1722 return sizeof(VRingDesc) * vdev->vq[n].vring.num;
1725 hwaddr virtio_queue_get_avail_size(VirtIODevice *vdev, int n)
1727 return offsetof(VRingAvail, ring) +
1728 sizeof(uint16_t) * vdev->vq[n].vring.num;
1731 hwaddr virtio_queue_get_used_size(VirtIODevice *vdev, int n)
1733 return offsetof(VRingUsed, ring) +
1734 sizeof(VRingUsedElem) * vdev->vq[n].vring.num;
1737 hwaddr virtio_queue_get_ring_size(VirtIODevice *vdev, int n)
1739 return vdev->vq[n].vring.used - vdev->vq[n].vring.desc +
1740 virtio_queue_get_used_size(vdev, n);
1743 uint16_t virtio_queue_get_last_avail_idx(VirtIODevice *vdev, int n)
1745 return vdev->vq[n].last_avail_idx;
1748 void virtio_queue_set_last_avail_idx(VirtIODevice *vdev, int n, uint16_t idx)
1750 vdev->vq[n].last_avail_idx = idx;
1751 vdev->vq[n].shadow_avail_idx = idx;
1754 void virtio_queue_invalidate_signalled_used(VirtIODevice *vdev, int n)
1756 vdev->vq[n].signalled_used_valid = false;
1759 VirtQueue *virtio_get_queue(VirtIODevice *vdev, int n)
1761 return vdev->vq + n;
1764 uint16_t virtio_get_queue_index(VirtQueue *vq)
1766 return vq->queue_index;
1769 static void virtio_queue_guest_notifier_read(EventNotifier *n)
1771 VirtQueue *vq = container_of(n, VirtQueue, guest_notifier);
1772 if (event_notifier_test_and_clear(n)) {
1773 virtio_irq(vq);
1777 void virtio_queue_set_guest_notifier_fd_handler(VirtQueue *vq, bool assign,
1778 bool with_irqfd)
1780 if (assign && !with_irqfd) {
1781 event_notifier_set_handler(&vq->guest_notifier, false,
1782 virtio_queue_guest_notifier_read);
1783 } else {
1784 event_notifier_set_handler(&vq->guest_notifier, false, NULL);
1786 if (!assign) {
1787 /* Test and clear notifier before closing it,
1788 * in case poll callback didn't have time to run. */
1789 virtio_queue_guest_notifier_read(&vq->guest_notifier);
1793 EventNotifier *virtio_queue_get_guest_notifier(VirtQueue *vq)
1795 return &vq->guest_notifier;
1798 static void virtio_queue_host_notifier_aio_read(EventNotifier *n)
1800 VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
1801 if (event_notifier_test_and_clear(n)) {
1802 virtio_queue_notify_aio_vq(vq);
1806 void virtio_queue_aio_set_host_notifier_handler(VirtQueue *vq, AioContext *ctx,
1807 void (*handle_output)(VirtIODevice *,
1808 VirtQueue *))
1810 if (handle_output) {
1811 vq->handle_aio_output = handle_output;
1812 aio_set_event_notifier(ctx, &vq->host_notifier, true,
1813 virtio_queue_host_notifier_aio_read);
1814 } else {
1815 aio_set_event_notifier(ctx, &vq->host_notifier, true, NULL);
1816 /* Test and clear notifier before after disabling event,
1817 * in case poll callback didn't have time to run. */
1818 virtio_queue_host_notifier_aio_read(&vq->host_notifier);
1819 vq->handle_aio_output = NULL;
1823 static void virtio_queue_host_notifier_read(EventNotifier *n)
1825 VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
1826 if (event_notifier_test_and_clear(n)) {
1827 virtio_queue_notify_vq(vq);
1831 void virtio_queue_set_host_notifier_fd_handler(VirtQueue *vq, bool assign,
1832 bool set_handler)
1834 if (assign && set_handler) {
1835 event_notifier_set_handler(&vq->host_notifier, true,
1836 virtio_queue_host_notifier_read);
1837 } else {
1838 event_notifier_set_handler(&vq->host_notifier, true, NULL);
1840 if (!assign) {
1841 /* Test and clear notifier before after disabling event,
1842 * in case poll callback didn't have time to run. */
1843 virtio_queue_host_notifier_read(&vq->host_notifier);
1847 EventNotifier *virtio_queue_get_host_notifier(VirtQueue *vq)
1849 return &vq->host_notifier;
1852 void virtio_device_set_child_bus_name(VirtIODevice *vdev, char *bus_name)
1854 g_free(vdev->bus_name);
1855 vdev->bus_name = g_strdup(bus_name);
1858 static void virtio_device_realize(DeviceState *dev, Error **errp)
1860 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1861 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(dev);
1862 Error *err = NULL;
1864 if (vdc->realize != NULL) {
1865 vdc->realize(dev, &err);
1866 if (err != NULL) {
1867 error_propagate(errp, err);
1868 return;
1872 virtio_bus_device_plugged(vdev, &err);
1873 if (err != NULL) {
1874 error_propagate(errp, err);
1875 return;
1879 static void virtio_device_unrealize(DeviceState *dev, Error **errp)
1881 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1882 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(dev);
1883 Error *err = NULL;
1885 virtio_bus_device_unplugged(vdev);
1887 if (vdc->unrealize != NULL) {
1888 vdc->unrealize(dev, &err);
1889 if (err != NULL) {
1890 error_propagate(errp, err);
1891 return;
1895 g_free(vdev->bus_name);
1896 vdev->bus_name = NULL;
1899 static Property virtio_properties[] = {
1900 DEFINE_VIRTIO_COMMON_FEATURES(VirtIODevice, host_features),
1901 DEFINE_PROP_END_OF_LIST(),
1904 static void virtio_device_class_init(ObjectClass *klass, void *data)
1906 /* Set the default value here. */
1907 DeviceClass *dc = DEVICE_CLASS(klass);
1909 dc->realize = virtio_device_realize;
1910 dc->unrealize = virtio_device_unrealize;
1911 dc->bus_type = TYPE_VIRTIO_BUS;
1912 dc->props = virtio_properties;
1915 static const TypeInfo virtio_device_info = {
1916 .name = TYPE_VIRTIO_DEVICE,
1917 .parent = TYPE_DEVICE,
1918 .instance_size = sizeof(VirtIODevice),
1919 .class_init = virtio_device_class_init,
1920 .abstract = true,
1921 .class_size = sizeof(VirtioDeviceClass),
1924 static void virtio_register_types(void)
1926 type_register_static(&virtio_device_info);
1929 type_init(virtio_register_types)