Fix virtio migration
[qemu/ar7.git] / hw / virtio / virtio.c
blob0603793e34e956311a0181980e6e8fa6fcc92cea
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"
16 #include "trace.h"
17 #include "exec/address-spaces.h"
18 #include "qemu/error-report.h"
19 #include "hw/virtio/virtio.h"
20 #include "qemu/atomic.h"
21 #include "hw/virtio/virtio-bus.h"
22 #include "migration/migration.h"
23 #include "hw/virtio/virtio-access.h"
26 * The alignment to use between consumer and producer parts of vring.
27 * x86 pagesize again. This is the default, used by transports like PCI
28 * which don't provide a means for the guest to tell the host the alignment.
30 #define VIRTIO_PCI_VRING_ALIGN 4096
32 typedef struct VRingDesc
34 uint64_t addr;
35 uint32_t len;
36 uint16_t flags;
37 uint16_t next;
38 } VRingDesc;
40 typedef struct VRingAvail
42 uint16_t flags;
43 uint16_t idx;
44 uint16_t ring[0];
45 } VRingAvail;
47 typedef struct VRingUsedElem
49 uint32_t id;
50 uint32_t len;
51 } VRingUsedElem;
53 typedef struct VRingUsed
55 uint16_t flags;
56 uint16_t idx;
57 VRingUsedElem ring[0];
58 } VRingUsed;
60 typedef struct VRing
62 unsigned int num;
63 unsigned int num_default;
64 unsigned int align;
65 hwaddr desc;
66 hwaddr avail;
67 hwaddr used;
68 } VRing;
70 struct VirtQueue
72 VRing vring;
73 uint16_t last_avail_idx;
74 /* Last used index value we have signalled on */
75 uint16_t signalled_used;
77 /* Last used index value we have signalled on */
78 bool signalled_used_valid;
80 /* Notification enabled? */
81 bool notification;
83 uint16_t queue_index;
85 int inuse;
87 uint16_t vector;
88 void (*handle_output)(VirtIODevice *vdev, VirtQueue *vq);
89 VirtIODevice *vdev;
90 EventNotifier guest_notifier;
91 EventNotifier host_notifier;
92 QLIST_ENTRY(VirtQueue) node;
95 /* virt queue functions */
96 void virtio_queue_update_rings(VirtIODevice *vdev, int n)
98 VRing *vring = &vdev->vq[n].vring;
100 if (!vring->desc) {
101 /* not yet setup -> nothing to do */
102 return;
104 vring->avail = vring->desc + vring->num * sizeof(VRingDesc);
105 vring->used = vring_align(vring->avail +
106 offsetof(VRingAvail, ring[vring->num]),
107 vring->align);
110 static inline uint64_t vring_desc_addr(VirtIODevice *vdev, hwaddr desc_pa,
111 int i)
113 hwaddr pa;
114 pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, addr);
115 return virtio_ldq_phys(vdev, pa);
118 static inline uint32_t vring_desc_len(VirtIODevice *vdev, hwaddr desc_pa, int i)
120 hwaddr pa;
121 pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, len);
122 return virtio_ldl_phys(vdev, pa);
125 static inline uint16_t vring_desc_flags(VirtIODevice *vdev, hwaddr desc_pa,
126 int i)
128 hwaddr pa;
129 pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, flags);
130 return virtio_lduw_phys(vdev, pa);
133 static inline uint16_t vring_desc_next(VirtIODevice *vdev, hwaddr desc_pa,
134 int i)
136 hwaddr pa;
137 pa = desc_pa + sizeof(VRingDesc) * i + offsetof(VRingDesc, next);
138 return virtio_lduw_phys(vdev, pa);
141 static inline uint16_t vring_avail_flags(VirtQueue *vq)
143 hwaddr pa;
144 pa = vq->vring.avail + offsetof(VRingAvail, flags);
145 return virtio_lduw_phys(vq->vdev, pa);
148 static inline uint16_t vring_avail_idx(VirtQueue *vq)
150 hwaddr pa;
151 pa = vq->vring.avail + offsetof(VRingAvail, idx);
152 return virtio_lduw_phys(vq->vdev, pa);
155 static inline uint16_t vring_avail_ring(VirtQueue *vq, int i)
157 hwaddr pa;
158 pa = vq->vring.avail + offsetof(VRingAvail, ring[i]);
159 return virtio_lduw_phys(vq->vdev, pa);
162 static inline uint16_t vring_get_used_event(VirtQueue *vq)
164 return vring_avail_ring(vq, vq->vring.num);
167 static inline void vring_used_ring_id(VirtQueue *vq, int i, uint32_t val)
169 hwaddr pa;
170 pa = vq->vring.used + offsetof(VRingUsed, ring[i].id);
171 virtio_stl_phys(vq->vdev, pa, val);
174 static inline void vring_used_ring_len(VirtQueue *vq, int i, uint32_t val)
176 hwaddr pa;
177 pa = vq->vring.used + offsetof(VRingUsed, ring[i].len);
178 virtio_stl_phys(vq->vdev, pa, val);
181 static uint16_t vring_used_idx(VirtQueue *vq)
183 hwaddr pa;
184 pa = vq->vring.used + offsetof(VRingUsed, idx);
185 return virtio_lduw_phys(vq->vdev, pa);
188 static inline void vring_used_idx_set(VirtQueue *vq, uint16_t val)
190 hwaddr pa;
191 pa = vq->vring.used + offsetof(VRingUsed, idx);
192 virtio_stw_phys(vq->vdev, pa, val);
195 static inline void vring_used_flags_set_bit(VirtQueue *vq, int mask)
197 VirtIODevice *vdev = vq->vdev;
198 hwaddr pa;
199 pa = vq->vring.used + offsetof(VRingUsed, flags);
200 virtio_stw_phys(vdev, pa, virtio_lduw_phys(vdev, pa) | mask);
203 static inline void vring_used_flags_unset_bit(VirtQueue *vq, int mask)
205 VirtIODevice *vdev = vq->vdev;
206 hwaddr pa;
207 pa = vq->vring.used + offsetof(VRingUsed, flags);
208 virtio_stw_phys(vdev, pa, virtio_lduw_phys(vdev, pa) & ~mask);
211 static inline void vring_set_avail_event(VirtQueue *vq, uint16_t val)
213 hwaddr pa;
214 if (!vq->notification) {
215 return;
217 pa = vq->vring.used + offsetof(VRingUsed, ring[vq->vring.num]);
218 virtio_stw_phys(vq->vdev, pa, val);
221 void virtio_queue_set_notification(VirtQueue *vq, int enable)
223 vq->notification = enable;
224 if (virtio_vdev_has_feature(vq->vdev, VIRTIO_RING_F_EVENT_IDX)) {
225 vring_set_avail_event(vq, vring_avail_idx(vq));
226 } else if (enable) {
227 vring_used_flags_unset_bit(vq, VRING_USED_F_NO_NOTIFY);
228 } else {
229 vring_used_flags_set_bit(vq, VRING_USED_F_NO_NOTIFY);
231 if (enable) {
232 /* Expose avail event/used flags before caller checks the avail idx. */
233 smp_mb();
237 int virtio_queue_ready(VirtQueue *vq)
239 return vq->vring.avail != 0;
242 int virtio_queue_empty(VirtQueue *vq)
244 return vring_avail_idx(vq) == vq->last_avail_idx;
247 static void virtqueue_unmap_sg(VirtQueue *vq, const VirtQueueElement *elem,
248 unsigned int len)
250 unsigned int offset;
251 int i;
253 offset = 0;
254 for (i = 0; i < elem->in_num; i++) {
255 size_t size = MIN(len - offset, elem->in_sg[i].iov_len);
257 cpu_physical_memory_unmap(elem->in_sg[i].iov_base,
258 elem->in_sg[i].iov_len,
259 1, size);
261 offset += size;
264 for (i = 0; i < elem->out_num; i++)
265 cpu_physical_memory_unmap(elem->out_sg[i].iov_base,
266 elem->out_sg[i].iov_len,
267 0, elem->out_sg[i].iov_len);
270 void virtqueue_discard(VirtQueue *vq, const VirtQueueElement *elem,
271 unsigned int len)
273 vq->last_avail_idx--;
274 virtqueue_unmap_sg(vq, elem, len);
277 void virtqueue_fill(VirtQueue *vq, const VirtQueueElement *elem,
278 unsigned int len, unsigned int idx)
280 trace_virtqueue_fill(vq, elem, len, idx);
282 virtqueue_unmap_sg(vq, elem, len);
284 idx = (idx + vring_used_idx(vq)) % vq->vring.num;
286 /* Get a pointer to the next entry in the used ring. */
287 vring_used_ring_id(vq, idx, elem->index);
288 vring_used_ring_len(vq, idx, len);
291 void virtqueue_flush(VirtQueue *vq, unsigned int count)
293 uint16_t old, new;
294 /* Make sure buffer is written before we update index. */
295 smp_wmb();
296 trace_virtqueue_flush(vq, count);
297 old = vring_used_idx(vq);
298 new = old + count;
299 vring_used_idx_set(vq, new);
300 vq->inuse -= count;
301 if (unlikely((int16_t)(new - vq->signalled_used) < (uint16_t)(new - old)))
302 vq->signalled_used_valid = false;
305 void virtqueue_push(VirtQueue *vq, const VirtQueueElement *elem,
306 unsigned int len)
308 virtqueue_fill(vq, elem, len, 0);
309 virtqueue_flush(vq, 1);
312 static int virtqueue_num_heads(VirtQueue *vq, unsigned int idx)
314 uint16_t num_heads = vring_avail_idx(vq) - idx;
316 /* Check it isn't doing very strange things with descriptor numbers. */
317 if (num_heads > vq->vring.num) {
318 error_report("Guest moved used index from %u to %u",
319 idx, vring_avail_idx(vq));
320 exit(1);
322 /* On success, callers read a descriptor at vq->last_avail_idx.
323 * Make sure descriptor read does not bypass avail index read. */
324 if (num_heads) {
325 smp_rmb();
328 return num_heads;
331 static unsigned int virtqueue_get_head(VirtQueue *vq, unsigned int idx)
333 unsigned int head;
335 /* Grab the next descriptor number they're advertising, and increment
336 * the index we've seen. */
337 head = vring_avail_ring(vq, idx % vq->vring.num);
339 /* If their number is silly, that's a fatal mistake. */
340 if (head >= vq->vring.num) {
341 error_report("Guest says index %u is available", head);
342 exit(1);
345 return head;
348 static unsigned virtqueue_next_desc(VirtIODevice *vdev, hwaddr desc_pa,
349 unsigned int i, unsigned int max)
351 unsigned int next;
353 /* If this descriptor says it doesn't chain, we're done. */
354 if (!(vring_desc_flags(vdev, desc_pa, i) & VRING_DESC_F_NEXT)) {
355 return max;
358 /* Check they're not leading us off end of descriptors. */
359 next = vring_desc_next(vdev, desc_pa, i);
360 /* Make sure compiler knows to grab that: we don't want it changing! */
361 smp_wmb();
363 if (next >= max) {
364 error_report("Desc next is %u", next);
365 exit(1);
368 return next;
371 void virtqueue_get_avail_bytes(VirtQueue *vq, unsigned int *in_bytes,
372 unsigned int *out_bytes,
373 unsigned max_in_bytes, unsigned max_out_bytes)
375 unsigned int idx;
376 unsigned int total_bufs, in_total, out_total;
378 idx = vq->last_avail_idx;
380 total_bufs = in_total = out_total = 0;
381 while (virtqueue_num_heads(vq, idx)) {
382 VirtIODevice *vdev = vq->vdev;
383 unsigned int max, num_bufs, indirect = 0;
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;
392 if (vring_desc_flags(vdev, desc_pa, i) & VRING_DESC_F_INDIRECT) {
393 if (vring_desc_len(vdev, desc_pa, i) % sizeof(VRingDesc)) {
394 error_report("Invalid size for indirect buffer table");
395 exit(1);
398 /* If we've got too many, that implies a descriptor loop. */
399 if (num_bufs >= max) {
400 error_report("Looped descriptor");
401 exit(1);
404 /* loop over the indirect descriptor table */
405 indirect = 1;
406 max = vring_desc_len(vdev, desc_pa, i) / sizeof(VRingDesc);
407 desc_pa = vring_desc_addr(vdev, desc_pa, i);
408 num_bufs = i = 0;
411 do {
412 /* If we've got too many, that implies a descriptor loop. */
413 if (++num_bufs > max) {
414 error_report("Looped descriptor");
415 exit(1);
418 if (vring_desc_flags(vdev, desc_pa, i) & VRING_DESC_F_WRITE) {
419 in_total += vring_desc_len(vdev, desc_pa, i);
420 } else {
421 out_total += vring_desc_len(vdev, desc_pa, i);
423 if (in_total >= max_in_bytes && out_total >= max_out_bytes) {
424 goto done;
426 } while ((i = virtqueue_next_desc(vdev, desc_pa, i, max)) != max);
428 if (!indirect)
429 total_bufs = num_bufs;
430 else
431 total_bufs++;
433 done:
434 if (in_bytes) {
435 *in_bytes = in_total;
437 if (out_bytes) {
438 *out_bytes = out_total;
442 int virtqueue_avail_bytes(VirtQueue *vq, unsigned int in_bytes,
443 unsigned int out_bytes)
445 unsigned int in_total, out_total;
447 virtqueue_get_avail_bytes(vq, &in_total, &out_total, in_bytes, out_bytes);
448 return in_bytes <= in_total && out_bytes <= out_total;
451 static void virtqueue_map_iovec(struct iovec *sg, hwaddr *addr,
452 unsigned int *num_sg, unsigned int max_size,
453 int is_write)
455 unsigned int i;
456 hwaddr len;
458 /* Note: this function MUST validate input, some callers
459 * are passing in num_sg values received over the network.
461 /* TODO: teach all callers that this can fail, and return failure instead
462 * of asserting here.
463 * When we do, we might be able to re-enable NDEBUG below.
465 #ifdef NDEBUG
466 #error building with NDEBUG is not supported
467 #endif
468 assert(*num_sg <= max_size);
470 for (i = 0; i < *num_sg; i++) {
471 len = sg[i].iov_len;
472 sg[i].iov_base = cpu_physical_memory_map(addr[i], &len, is_write);
473 if (!sg[i].iov_base) {
474 error_report("virtio: error trying to map MMIO memory");
475 exit(1);
477 if (len == sg[i].iov_len) {
478 continue;
480 if (*num_sg >= max_size) {
481 error_report("virtio: memory split makes iovec too large");
482 exit(1);
484 memmove(sg + i + 1, sg + i, sizeof(*sg) * (*num_sg - i));
485 memmove(addr + i + 1, addr + i, sizeof(*addr) * (*num_sg - i));
486 assert(len < sg[i + 1].iov_len);
487 sg[i].iov_len = len;
488 addr[i + 1] += len;
489 sg[i + 1].iov_len -= len;
490 ++*num_sg;
494 void virtqueue_map(VirtQueueElement *elem)
496 virtqueue_map_iovec(elem->in_sg, elem->in_addr, &elem->in_num,
497 MIN(ARRAY_SIZE(elem->in_sg), ARRAY_SIZE(elem->in_addr)),
499 virtqueue_map_iovec(elem->out_sg, elem->out_addr, &elem->out_num,
500 MIN(ARRAY_SIZE(elem->out_sg), ARRAY_SIZE(elem->out_addr)),
504 int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem)
506 unsigned int i, head, max;
507 hwaddr desc_pa = vq->vring.desc;
508 VirtIODevice *vdev = vq->vdev;
510 if (!virtqueue_num_heads(vq, vq->last_avail_idx))
511 return 0;
513 /* When we start there are none of either input nor output. */
514 elem->out_num = elem->in_num = 0;
516 max = vq->vring.num;
518 i = head = virtqueue_get_head(vq, vq->last_avail_idx++);
519 if (virtio_vdev_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX)) {
520 vring_set_avail_event(vq, vq->last_avail_idx);
523 if (vring_desc_flags(vdev, desc_pa, i) & VRING_DESC_F_INDIRECT) {
524 if (vring_desc_len(vdev, desc_pa, i) % sizeof(VRingDesc)) {
525 error_report("Invalid size for indirect buffer table");
526 exit(1);
529 /* loop over the indirect descriptor table */
530 max = vring_desc_len(vdev, desc_pa, i) / sizeof(VRingDesc);
531 desc_pa = vring_desc_addr(vdev, desc_pa, i);
532 i = 0;
535 /* Collect all the descriptors */
536 do {
537 struct iovec *sg;
539 if (vring_desc_flags(vdev, desc_pa, i) & VRING_DESC_F_WRITE) {
540 if (elem->in_num >= ARRAY_SIZE(elem->in_sg)) {
541 error_report("Too many write descriptors in indirect table");
542 exit(1);
544 elem->in_addr[elem->in_num] = vring_desc_addr(vdev, desc_pa, i);
545 sg = &elem->in_sg[elem->in_num++];
546 } else {
547 if (elem->out_num >= ARRAY_SIZE(elem->out_sg)) {
548 error_report("Too many read descriptors in indirect table");
549 exit(1);
551 elem->out_addr[elem->out_num] = vring_desc_addr(vdev, desc_pa, i);
552 sg = &elem->out_sg[elem->out_num++];
555 sg->iov_len = vring_desc_len(vdev, desc_pa, i);
557 /* If we've got too many, that implies a descriptor loop. */
558 if ((elem->in_num + elem->out_num) > max) {
559 error_report("Looped descriptor");
560 exit(1);
562 } while ((i = virtqueue_next_desc(vdev, desc_pa, i, max)) != max);
564 /* Now map what we have collected */
565 virtqueue_map(elem);
567 elem->index = head;
569 vq->inuse++;
571 trace_virtqueue_pop(vq, elem, elem->in_num, elem->out_num);
572 return elem->in_num + elem->out_num;
575 /* virtio device */
576 static void virtio_notify_vector(VirtIODevice *vdev, uint16_t vector)
578 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
579 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
581 if (k->notify) {
582 k->notify(qbus->parent, vector);
586 void virtio_update_irq(VirtIODevice *vdev)
588 virtio_notify_vector(vdev, VIRTIO_NO_VECTOR);
591 static int virtio_validate_features(VirtIODevice *vdev)
593 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
595 if (k->validate_features) {
596 return k->validate_features(vdev);
597 } else {
598 return 0;
602 int virtio_set_status(VirtIODevice *vdev, uint8_t val)
604 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
605 trace_virtio_set_status(vdev, val);
607 if (virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1)) {
608 if (!(vdev->status & VIRTIO_CONFIG_S_FEATURES_OK) &&
609 val & VIRTIO_CONFIG_S_FEATURES_OK) {
610 int ret = virtio_validate_features(vdev);
612 if (ret) {
613 return ret;
617 if (k->set_status) {
618 k->set_status(vdev, val);
620 vdev->status = val;
621 return 0;
624 bool target_words_bigendian(void);
625 static enum virtio_device_endian virtio_default_endian(void)
627 if (target_words_bigendian()) {
628 return VIRTIO_DEVICE_ENDIAN_BIG;
629 } else {
630 return VIRTIO_DEVICE_ENDIAN_LITTLE;
634 static enum virtio_device_endian virtio_current_cpu_endian(void)
636 CPUClass *cc = CPU_GET_CLASS(current_cpu);
638 if (cc->virtio_is_big_endian(current_cpu)) {
639 return VIRTIO_DEVICE_ENDIAN_BIG;
640 } else {
641 return VIRTIO_DEVICE_ENDIAN_LITTLE;
645 void virtio_reset(void *opaque)
647 VirtIODevice *vdev = opaque;
648 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
649 int i;
651 virtio_set_status(vdev, 0);
652 if (current_cpu) {
653 /* Guest initiated reset */
654 vdev->device_endian = virtio_current_cpu_endian();
655 } else {
656 /* System reset */
657 vdev->device_endian = virtio_default_endian();
660 if (k->reset) {
661 k->reset(vdev);
664 vdev->guest_features = 0;
665 vdev->queue_sel = 0;
666 vdev->status = 0;
667 vdev->isr = 0;
668 vdev->config_vector = VIRTIO_NO_VECTOR;
669 virtio_notify_vector(vdev, vdev->config_vector);
671 for(i = 0; i < VIRTIO_QUEUE_MAX; i++) {
672 vdev->vq[i].vring.desc = 0;
673 vdev->vq[i].vring.avail = 0;
674 vdev->vq[i].vring.used = 0;
675 vdev->vq[i].last_avail_idx = 0;
676 virtio_queue_set_vector(vdev, i, VIRTIO_NO_VECTOR);
677 vdev->vq[i].signalled_used = 0;
678 vdev->vq[i].signalled_used_valid = false;
679 vdev->vq[i].notification = true;
680 vdev->vq[i].vring.num = vdev->vq[i].vring.num_default;
684 uint32_t virtio_config_readb(VirtIODevice *vdev, uint32_t addr)
686 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
687 uint8_t val;
689 if (addr + sizeof(val) > vdev->config_len) {
690 return (uint32_t)-1;
693 k->get_config(vdev, vdev->config);
695 val = ldub_p(vdev->config + addr);
696 return val;
699 uint32_t virtio_config_readw(VirtIODevice *vdev, uint32_t addr)
701 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
702 uint16_t val;
704 if (addr + sizeof(val) > vdev->config_len) {
705 return (uint32_t)-1;
708 k->get_config(vdev, vdev->config);
710 val = lduw_p(vdev->config + addr);
711 return val;
714 uint32_t virtio_config_readl(VirtIODevice *vdev, uint32_t addr)
716 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
717 uint32_t val;
719 if (addr + sizeof(val) > vdev->config_len) {
720 return (uint32_t)-1;
723 k->get_config(vdev, vdev->config);
725 val = ldl_p(vdev->config + addr);
726 return val;
729 void virtio_config_writeb(VirtIODevice *vdev, uint32_t addr, uint32_t data)
731 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
732 uint8_t val = data;
734 if (addr + sizeof(val) > vdev->config_len) {
735 return;
738 stb_p(vdev->config + addr, val);
740 if (k->set_config) {
741 k->set_config(vdev, vdev->config);
745 void virtio_config_writew(VirtIODevice *vdev, uint32_t addr, uint32_t data)
747 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
748 uint16_t val = data;
750 if (addr + sizeof(val) > vdev->config_len) {
751 return;
754 stw_p(vdev->config + addr, val);
756 if (k->set_config) {
757 k->set_config(vdev, vdev->config);
761 void virtio_config_writel(VirtIODevice *vdev, uint32_t addr, uint32_t data)
763 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
764 uint32_t val = data;
766 if (addr + sizeof(val) > vdev->config_len) {
767 return;
770 stl_p(vdev->config + addr, val);
772 if (k->set_config) {
773 k->set_config(vdev, vdev->config);
777 uint32_t virtio_config_modern_readb(VirtIODevice *vdev, uint32_t addr)
779 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
780 uint8_t val;
782 if (addr + sizeof(val) > vdev->config_len) {
783 return (uint32_t)-1;
786 k->get_config(vdev, vdev->config);
788 val = ldub_p(vdev->config + addr);
789 return val;
792 uint32_t virtio_config_modern_readw(VirtIODevice *vdev, uint32_t addr)
794 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
795 uint16_t val;
797 if (addr + sizeof(val) > vdev->config_len) {
798 return (uint32_t)-1;
801 k->get_config(vdev, vdev->config);
803 val = lduw_le_p(vdev->config + addr);
804 return val;
807 uint32_t virtio_config_modern_readl(VirtIODevice *vdev, uint32_t addr)
809 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
810 uint32_t val;
812 if (addr + sizeof(val) > vdev->config_len) {
813 return (uint32_t)-1;
816 k->get_config(vdev, vdev->config);
818 val = ldl_le_p(vdev->config + addr);
819 return val;
822 void virtio_config_modern_writeb(VirtIODevice *vdev,
823 uint32_t addr, uint32_t data)
825 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
826 uint8_t val = data;
828 if (addr + sizeof(val) > vdev->config_len) {
829 return;
832 stb_p(vdev->config + addr, val);
834 if (k->set_config) {
835 k->set_config(vdev, vdev->config);
839 void virtio_config_modern_writew(VirtIODevice *vdev,
840 uint32_t addr, uint32_t data)
842 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
843 uint16_t val = data;
845 if (addr + sizeof(val) > vdev->config_len) {
846 return;
849 stw_le_p(vdev->config + addr, val);
851 if (k->set_config) {
852 k->set_config(vdev, vdev->config);
856 void virtio_config_modern_writel(VirtIODevice *vdev,
857 uint32_t addr, uint32_t data)
859 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
860 uint32_t val = data;
862 if (addr + sizeof(val) > vdev->config_len) {
863 return;
866 stl_le_p(vdev->config + addr, val);
868 if (k->set_config) {
869 k->set_config(vdev, vdev->config);
873 void virtio_queue_set_addr(VirtIODevice *vdev, int n, hwaddr addr)
875 vdev->vq[n].vring.desc = addr;
876 virtio_queue_update_rings(vdev, n);
879 hwaddr virtio_queue_get_addr(VirtIODevice *vdev, int n)
881 return vdev->vq[n].vring.desc;
884 void virtio_queue_set_rings(VirtIODevice *vdev, int n, hwaddr desc,
885 hwaddr avail, hwaddr used)
887 vdev->vq[n].vring.desc = desc;
888 vdev->vq[n].vring.avail = avail;
889 vdev->vq[n].vring.used = used;
892 void virtio_queue_set_num(VirtIODevice *vdev, int n, int num)
894 /* Don't allow guest to flip queue between existent and
895 * nonexistent states, or to set it to an invalid size.
897 if (!!num != !!vdev->vq[n].vring.num ||
898 num > VIRTQUEUE_MAX_SIZE ||
899 num < 0) {
900 return;
902 vdev->vq[n].vring.num = num;
905 VirtQueue *virtio_vector_first_queue(VirtIODevice *vdev, uint16_t vector)
907 return QLIST_FIRST(&vdev->vector_queues[vector]);
910 VirtQueue *virtio_vector_next_queue(VirtQueue *vq)
912 return QLIST_NEXT(vq, node);
915 int virtio_queue_get_num(VirtIODevice *vdev, int n)
917 return vdev->vq[n].vring.num;
920 int virtio_get_num_queues(VirtIODevice *vdev)
922 int i;
924 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
925 if (!virtio_queue_get_num(vdev, i)) {
926 break;
930 return i;
933 int virtio_queue_get_id(VirtQueue *vq)
935 VirtIODevice *vdev = vq->vdev;
936 assert(vq >= &vdev->vq[0] && vq < &vdev->vq[VIRTIO_QUEUE_MAX]);
937 return vq - &vdev->vq[0];
940 void virtio_queue_set_align(VirtIODevice *vdev, int n, int align)
942 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
943 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
945 /* virtio-1 compliant devices cannot change the alignment */
946 if (virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1)) {
947 error_report("tried to modify queue alignment for virtio-1 device");
948 return;
950 /* Check that the transport told us it was going to do this
951 * (so a buggy transport will immediately assert rather than
952 * silently failing to migrate this state)
954 assert(k->has_variable_vring_alignment);
956 vdev->vq[n].vring.align = align;
957 virtio_queue_update_rings(vdev, n);
960 void virtio_queue_notify_vq(VirtQueue *vq)
962 if (vq->vring.desc && vq->handle_output) {
963 VirtIODevice *vdev = vq->vdev;
965 trace_virtio_queue_notify(vdev, vq - vdev->vq, vq);
966 vq->handle_output(vdev, vq);
970 void virtio_queue_notify(VirtIODevice *vdev, int n)
972 virtio_queue_notify_vq(&vdev->vq[n]);
975 uint16_t virtio_queue_vector(VirtIODevice *vdev, int n)
977 return n < VIRTIO_QUEUE_MAX ? vdev->vq[n].vector :
978 VIRTIO_NO_VECTOR;
981 void virtio_queue_set_vector(VirtIODevice *vdev, int n, uint16_t vector)
983 VirtQueue *vq = &vdev->vq[n];
985 if (n < VIRTIO_QUEUE_MAX) {
986 if (vdev->vector_queues &&
987 vdev->vq[n].vector != VIRTIO_NO_VECTOR) {
988 QLIST_REMOVE(vq, node);
990 vdev->vq[n].vector = vector;
991 if (vdev->vector_queues &&
992 vector != VIRTIO_NO_VECTOR) {
993 QLIST_INSERT_HEAD(&vdev->vector_queues[vector], vq, node);
998 VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
999 void (*handle_output)(VirtIODevice *, VirtQueue *))
1001 int i;
1003 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1004 if (vdev->vq[i].vring.num == 0)
1005 break;
1008 if (i == VIRTIO_QUEUE_MAX || queue_size > VIRTQUEUE_MAX_SIZE)
1009 abort();
1011 vdev->vq[i].vring.num = queue_size;
1012 vdev->vq[i].vring.num_default = queue_size;
1013 vdev->vq[i].vring.align = VIRTIO_PCI_VRING_ALIGN;
1014 vdev->vq[i].handle_output = handle_output;
1016 return &vdev->vq[i];
1019 void virtio_del_queue(VirtIODevice *vdev, int n)
1021 if (n < 0 || n >= VIRTIO_QUEUE_MAX) {
1022 abort();
1025 vdev->vq[n].vring.num = 0;
1026 vdev->vq[n].vring.num_default = 0;
1029 void virtio_irq(VirtQueue *vq)
1031 trace_virtio_irq(vq);
1032 vq->vdev->isr |= 0x01;
1033 virtio_notify_vector(vq->vdev, vq->vector);
1036 static bool vring_notify(VirtIODevice *vdev, VirtQueue *vq)
1038 uint16_t old, new;
1039 bool v;
1040 /* We need to expose used array entries before checking used event. */
1041 smp_mb();
1042 /* Always notify when queue is empty (when feature acknowledge) */
1043 if (virtio_vdev_has_feature(vdev, VIRTIO_F_NOTIFY_ON_EMPTY) &&
1044 !vq->inuse && vring_avail_idx(vq) == vq->last_avail_idx) {
1045 return true;
1048 if (!virtio_vdev_has_feature(vdev, VIRTIO_RING_F_EVENT_IDX)) {
1049 return !(vring_avail_flags(vq) & VRING_AVAIL_F_NO_INTERRUPT);
1052 v = vq->signalled_used_valid;
1053 vq->signalled_used_valid = true;
1054 old = vq->signalled_used;
1055 new = vq->signalled_used = vring_used_idx(vq);
1056 return !v || vring_need_event(vring_get_used_event(vq), new, old);
1059 void virtio_notify(VirtIODevice *vdev, VirtQueue *vq)
1061 if (!vring_notify(vdev, vq)) {
1062 return;
1065 trace_virtio_notify(vdev, vq);
1066 vdev->isr |= 0x01;
1067 virtio_notify_vector(vdev, vq->vector);
1070 void virtio_notify_config(VirtIODevice *vdev)
1072 if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK))
1073 return;
1075 vdev->isr |= 0x03;
1076 vdev->generation++;
1077 virtio_notify_vector(vdev, vdev->config_vector);
1080 static bool virtio_device_endian_needed(void *opaque)
1082 VirtIODevice *vdev = opaque;
1084 assert(vdev->device_endian != VIRTIO_DEVICE_ENDIAN_UNKNOWN);
1085 if (!virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1)) {
1086 return vdev->device_endian != virtio_default_endian();
1088 /* Devices conforming to VIRTIO 1.0 or later are always LE. */
1089 return vdev->device_endian != VIRTIO_DEVICE_ENDIAN_LITTLE;
1092 static bool virtio_64bit_features_needed(void *opaque)
1094 VirtIODevice *vdev = opaque;
1096 return (vdev->host_features >> 32) != 0;
1099 static bool virtio_virtqueue_needed(void *opaque)
1101 VirtIODevice *vdev = opaque;
1103 return virtio_host_has_feature(vdev, VIRTIO_F_VERSION_1);
1106 static bool virtio_ringsize_needed(void *opaque)
1108 VirtIODevice *vdev = opaque;
1109 int i;
1111 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1112 if (vdev->vq[i].vring.num != vdev->vq[i].vring.num_default) {
1113 return true;
1116 return false;
1119 static bool virtio_extra_state_needed(void *opaque)
1121 VirtIODevice *vdev = opaque;
1122 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1123 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1125 return k->has_extra_state &&
1126 k->has_extra_state(qbus->parent);
1129 static const VMStateDescription vmstate_virtqueue = {
1130 .name = "virtqueue_state",
1131 .version_id = 1,
1132 .minimum_version_id = 1,
1133 .fields = (VMStateField[]) {
1134 VMSTATE_UINT64(vring.avail, struct VirtQueue),
1135 VMSTATE_UINT64(vring.used, struct VirtQueue),
1136 VMSTATE_END_OF_LIST()
1140 static const VMStateDescription vmstate_virtio_virtqueues = {
1141 .name = "virtio/virtqueues",
1142 .version_id = 1,
1143 .minimum_version_id = 1,
1144 .needed = &virtio_virtqueue_needed,
1145 .fields = (VMStateField[]) {
1146 VMSTATE_STRUCT_VARRAY_POINTER_KNOWN(vq, struct VirtIODevice,
1147 VIRTIO_QUEUE_MAX, 0, vmstate_virtqueue, VirtQueue),
1148 VMSTATE_END_OF_LIST()
1152 static const VMStateDescription vmstate_ringsize = {
1153 .name = "ringsize_state",
1154 .version_id = 1,
1155 .minimum_version_id = 1,
1156 .fields = (VMStateField[]) {
1157 VMSTATE_UINT32(vring.num_default, struct VirtQueue),
1158 VMSTATE_END_OF_LIST()
1162 static const VMStateDescription vmstate_virtio_ringsize = {
1163 .name = "virtio/ringsize",
1164 .version_id = 1,
1165 .minimum_version_id = 1,
1166 .needed = &virtio_ringsize_needed,
1167 .fields = (VMStateField[]) {
1168 VMSTATE_STRUCT_VARRAY_POINTER_KNOWN(vq, struct VirtIODevice,
1169 VIRTIO_QUEUE_MAX, 0, vmstate_ringsize, VirtQueue),
1170 VMSTATE_END_OF_LIST()
1174 static int get_extra_state(QEMUFile *f, void *pv, size_t size)
1176 VirtIODevice *vdev = pv;
1177 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1178 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1180 if (!k->load_extra_state) {
1181 return -1;
1182 } else {
1183 return k->load_extra_state(qbus->parent, f);
1187 static void put_extra_state(QEMUFile *f, void *pv, size_t size)
1189 VirtIODevice *vdev = pv;
1190 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1191 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1193 k->save_extra_state(qbus->parent, f);
1196 static const VMStateInfo vmstate_info_extra_state = {
1197 .name = "virtqueue_extra_state",
1198 .get = get_extra_state,
1199 .put = put_extra_state,
1202 static const VMStateDescription vmstate_virtio_extra_state = {
1203 .name = "virtio/extra_state",
1204 .version_id = 1,
1205 .minimum_version_id = 1,
1206 .needed = &virtio_extra_state_needed,
1207 .fields = (VMStateField[]) {
1209 .name = "extra_state",
1210 .version_id = 0,
1211 .field_exists = NULL,
1212 .size = 0,
1213 .info = &vmstate_info_extra_state,
1214 .flags = VMS_SINGLE,
1215 .offset = 0,
1217 VMSTATE_END_OF_LIST()
1221 static const VMStateDescription vmstate_virtio_device_endian = {
1222 .name = "virtio/device_endian",
1223 .version_id = 1,
1224 .minimum_version_id = 1,
1225 .needed = &virtio_device_endian_needed,
1226 .fields = (VMStateField[]) {
1227 VMSTATE_UINT8(device_endian, VirtIODevice),
1228 VMSTATE_END_OF_LIST()
1232 static const VMStateDescription vmstate_virtio_64bit_features = {
1233 .name = "virtio/64bit_features",
1234 .version_id = 1,
1235 .minimum_version_id = 1,
1236 .needed = &virtio_64bit_features_needed,
1237 .fields = (VMStateField[]) {
1238 VMSTATE_UINT64(guest_features, VirtIODevice),
1239 VMSTATE_END_OF_LIST()
1243 static const VMStateDescription vmstate_virtio = {
1244 .name = "virtio",
1245 .version_id = 1,
1246 .minimum_version_id = 1,
1247 .minimum_version_id_old = 1,
1248 .fields = (VMStateField[]) {
1249 VMSTATE_END_OF_LIST()
1251 .subsections = (const VMStateDescription*[]) {
1252 &vmstate_virtio_device_endian,
1253 &vmstate_virtio_64bit_features,
1254 &vmstate_virtio_virtqueues,
1255 &vmstate_virtio_ringsize,
1256 &vmstate_virtio_extra_state,
1257 NULL
1261 void virtio_save(VirtIODevice *vdev, QEMUFile *f)
1263 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1264 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1265 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
1266 uint32_t guest_features_lo = (vdev->guest_features & 0xffffffff);
1267 int i;
1269 if (k->save_config) {
1270 k->save_config(qbus->parent, f);
1273 qemu_put_8s(f, &vdev->status);
1274 qemu_put_8s(f, &vdev->isr);
1275 qemu_put_be16s(f, &vdev->queue_sel);
1276 qemu_put_be32s(f, &guest_features_lo);
1277 qemu_put_be32(f, vdev->config_len);
1278 qemu_put_buffer(f, vdev->config, vdev->config_len);
1280 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1281 if (vdev->vq[i].vring.num == 0)
1282 break;
1285 qemu_put_be32(f, i);
1287 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1288 if (vdev->vq[i].vring.num == 0)
1289 break;
1291 qemu_put_be32(f, vdev->vq[i].vring.num);
1292 if (k->has_variable_vring_alignment) {
1293 qemu_put_be32(f, vdev->vq[i].vring.align);
1295 /* XXX virtio-1 devices */
1296 qemu_put_be64(f, vdev->vq[i].vring.desc);
1297 qemu_put_be16s(f, &vdev->vq[i].last_avail_idx);
1298 if (k->save_queue) {
1299 k->save_queue(qbus->parent, i, f);
1303 if (vdc->save != NULL) {
1304 vdc->save(vdev, f);
1307 /* Subsections */
1308 vmstate_save_state(f, &vmstate_virtio, vdev, NULL);
1311 static int virtio_set_features_nocheck(VirtIODevice *vdev, uint64_t val)
1313 VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
1314 bool bad = (val & ~(vdev->host_features)) != 0;
1316 val &= vdev->host_features;
1317 if (k->set_features) {
1318 k->set_features(vdev, val);
1320 vdev->guest_features = val;
1321 return bad ? -1 : 0;
1324 int virtio_set_features(VirtIODevice *vdev, uint64_t val)
1327 * The driver must not attempt to set features after feature negotiation
1328 * has finished.
1330 if (vdev->status & VIRTIO_CONFIG_S_FEATURES_OK) {
1331 return -EINVAL;
1333 return virtio_set_features_nocheck(vdev, val);
1336 int virtio_load(VirtIODevice *vdev, QEMUFile *f, int version_id)
1338 int i, ret;
1339 int32_t config_len;
1340 uint32_t num;
1341 uint32_t features;
1342 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1343 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1344 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(vdev);
1347 * We poison the endianness to ensure it does not get used before
1348 * subsections have been loaded.
1350 vdev->device_endian = VIRTIO_DEVICE_ENDIAN_UNKNOWN;
1352 if (k->load_config) {
1353 ret = k->load_config(qbus->parent, f);
1354 if (ret)
1355 return ret;
1358 qemu_get_8s(f, &vdev->status);
1359 qemu_get_8s(f, &vdev->isr);
1360 qemu_get_be16s(f, &vdev->queue_sel);
1361 if (vdev->queue_sel >= VIRTIO_QUEUE_MAX) {
1362 return -1;
1364 qemu_get_be32s(f, &features);
1366 config_len = qemu_get_be32(f);
1369 * There are cases where the incoming config can be bigger or smaller
1370 * than what we have; so load what we have space for, and skip
1371 * any excess that's in the stream.
1373 qemu_get_buffer(f, vdev->config, MIN(config_len, vdev->config_len));
1375 while (config_len > vdev->config_len) {
1376 qemu_get_byte(f);
1377 config_len--;
1380 num = qemu_get_be32(f);
1382 if (num > VIRTIO_QUEUE_MAX) {
1383 error_report("Invalid number of virtqueues: 0x%x", num);
1384 return -1;
1387 for (i = 0; i < num; i++) {
1388 vdev->vq[i].vring.num = qemu_get_be32(f);
1389 if (k->has_variable_vring_alignment) {
1390 vdev->vq[i].vring.align = qemu_get_be32(f);
1392 vdev->vq[i].vring.desc = qemu_get_be64(f);
1393 qemu_get_be16s(f, &vdev->vq[i].last_avail_idx);
1394 vdev->vq[i].signalled_used_valid = false;
1395 vdev->vq[i].notification = true;
1397 if (vdev->vq[i].vring.desc) {
1398 /* XXX virtio-1 devices */
1399 virtio_queue_update_rings(vdev, i);
1400 } else if (vdev->vq[i].last_avail_idx) {
1401 error_report("VQ %d address 0x0 "
1402 "inconsistent with Host index 0x%x",
1403 i, vdev->vq[i].last_avail_idx);
1404 return -1;
1406 if (k->load_queue) {
1407 ret = k->load_queue(qbus->parent, i, f);
1408 if (ret)
1409 return ret;
1413 virtio_notify_vector(vdev, VIRTIO_NO_VECTOR);
1415 if (vdc->load != NULL) {
1416 ret = vdc->load(vdev, f, version_id);
1417 if (ret) {
1418 return ret;
1422 /* Subsections */
1423 ret = vmstate_load_state(f, &vmstate_virtio, vdev, 1);
1424 if (ret) {
1425 return ret;
1428 if (vdev->device_endian == VIRTIO_DEVICE_ENDIAN_UNKNOWN) {
1429 vdev->device_endian = virtio_default_endian();
1432 if (virtio_64bit_features_needed(vdev)) {
1434 * Subsection load filled vdev->guest_features. Run them
1435 * through virtio_set_features to sanity-check them against
1436 * host_features.
1438 uint64_t features64 = vdev->guest_features;
1439 if (virtio_set_features_nocheck(vdev, features64) < 0) {
1440 error_report("Features 0x%" PRIx64 " unsupported. "
1441 "Allowed features: 0x%" PRIx64,
1442 features64, vdev->host_features);
1443 return -1;
1445 } else {
1446 if (virtio_set_features_nocheck(vdev, features) < 0) {
1447 error_report("Features 0x%x unsupported. "
1448 "Allowed features: 0x%" PRIx64,
1449 features, vdev->host_features);
1450 return -1;
1454 for (i = 0; i < num; i++) {
1455 if (vdev->vq[i].vring.desc) {
1456 uint16_t nheads;
1457 nheads = vring_avail_idx(&vdev->vq[i]) - vdev->vq[i].last_avail_idx;
1458 /* Check it isn't doing strange things with descriptor numbers. */
1459 if (nheads > vdev->vq[i].vring.num) {
1460 error_report("VQ %d size 0x%x Guest index 0x%x "
1461 "inconsistent with Host index 0x%x: delta 0x%x",
1462 i, vdev->vq[i].vring.num,
1463 vring_avail_idx(&vdev->vq[i]),
1464 vdev->vq[i].last_avail_idx, nheads);
1465 return -1;
1470 return 0;
1473 void virtio_cleanup(VirtIODevice *vdev)
1475 qemu_del_vm_change_state_handler(vdev->vmstate);
1476 g_free(vdev->config);
1477 g_free(vdev->vq);
1478 g_free(vdev->vector_queues);
1481 static void virtio_vmstate_change(void *opaque, int running, RunState state)
1483 VirtIODevice *vdev = opaque;
1484 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1485 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1486 bool backend_run = running && (vdev->status & VIRTIO_CONFIG_S_DRIVER_OK);
1487 vdev->vm_running = running;
1489 if (backend_run) {
1490 virtio_set_status(vdev, vdev->status);
1493 if (k->vmstate_change) {
1494 k->vmstate_change(qbus->parent, backend_run);
1497 if (!backend_run) {
1498 virtio_set_status(vdev, vdev->status);
1502 void virtio_instance_init_common(Object *proxy_obj, void *data,
1503 size_t vdev_size, const char *vdev_name)
1505 DeviceState *vdev = data;
1507 object_initialize(vdev, vdev_size, vdev_name);
1508 object_property_add_child(proxy_obj, "virtio-backend", OBJECT(vdev), NULL);
1509 object_unref(OBJECT(vdev));
1510 qdev_alias_all_properties(vdev, proxy_obj);
1513 void virtio_init(VirtIODevice *vdev, const char *name,
1514 uint16_t device_id, size_t config_size)
1516 BusState *qbus = qdev_get_parent_bus(DEVICE(vdev));
1517 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(qbus);
1518 int i;
1519 int nvectors = k->query_nvectors ? k->query_nvectors(qbus->parent) : 0;
1521 if (nvectors) {
1522 vdev->vector_queues =
1523 g_malloc0(sizeof(*vdev->vector_queues) * nvectors);
1526 vdev->device_id = device_id;
1527 vdev->status = 0;
1528 vdev->isr = 0;
1529 vdev->queue_sel = 0;
1530 vdev->config_vector = VIRTIO_NO_VECTOR;
1531 vdev->vq = g_malloc0(sizeof(VirtQueue) * VIRTIO_QUEUE_MAX);
1532 vdev->vm_running = runstate_is_running();
1533 for (i = 0; i < VIRTIO_QUEUE_MAX; i++) {
1534 vdev->vq[i].vector = VIRTIO_NO_VECTOR;
1535 vdev->vq[i].vdev = vdev;
1536 vdev->vq[i].queue_index = i;
1539 vdev->name = name;
1540 vdev->config_len = config_size;
1541 if (vdev->config_len) {
1542 vdev->config = g_malloc0(config_size);
1543 } else {
1544 vdev->config = NULL;
1546 vdev->vmstate = qemu_add_vm_change_state_handler(virtio_vmstate_change,
1547 vdev);
1548 vdev->device_endian = virtio_default_endian();
1551 hwaddr virtio_queue_get_desc_addr(VirtIODevice *vdev, int n)
1553 return vdev->vq[n].vring.desc;
1556 hwaddr virtio_queue_get_avail_addr(VirtIODevice *vdev, int n)
1558 return vdev->vq[n].vring.avail;
1561 hwaddr virtio_queue_get_used_addr(VirtIODevice *vdev, int n)
1563 return vdev->vq[n].vring.used;
1566 hwaddr virtio_queue_get_ring_addr(VirtIODevice *vdev, int n)
1568 return vdev->vq[n].vring.desc;
1571 hwaddr virtio_queue_get_desc_size(VirtIODevice *vdev, int n)
1573 return sizeof(VRingDesc) * vdev->vq[n].vring.num;
1576 hwaddr virtio_queue_get_avail_size(VirtIODevice *vdev, int n)
1578 return offsetof(VRingAvail, ring) +
1579 sizeof(uint16_t) * vdev->vq[n].vring.num;
1582 hwaddr virtio_queue_get_used_size(VirtIODevice *vdev, int n)
1584 return offsetof(VRingUsed, ring) +
1585 sizeof(VRingUsedElem) * vdev->vq[n].vring.num;
1588 hwaddr virtio_queue_get_ring_size(VirtIODevice *vdev, int n)
1590 return vdev->vq[n].vring.used - vdev->vq[n].vring.desc +
1591 virtio_queue_get_used_size(vdev, n);
1594 uint16_t virtio_queue_get_last_avail_idx(VirtIODevice *vdev, int n)
1596 return vdev->vq[n].last_avail_idx;
1599 void virtio_queue_set_last_avail_idx(VirtIODevice *vdev, int n, uint16_t idx)
1601 vdev->vq[n].last_avail_idx = idx;
1604 void virtio_queue_invalidate_signalled_used(VirtIODevice *vdev, int n)
1606 vdev->vq[n].signalled_used_valid = false;
1609 VirtQueue *virtio_get_queue(VirtIODevice *vdev, int n)
1611 return vdev->vq + n;
1614 uint16_t virtio_get_queue_index(VirtQueue *vq)
1616 return vq->queue_index;
1619 static void virtio_queue_guest_notifier_read(EventNotifier *n)
1621 VirtQueue *vq = container_of(n, VirtQueue, guest_notifier);
1622 if (event_notifier_test_and_clear(n)) {
1623 virtio_irq(vq);
1627 void virtio_queue_set_guest_notifier_fd_handler(VirtQueue *vq, bool assign,
1628 bool with_irqfd)
1630 if (assign && !with_irqfd) {
1631 event_notifier_set_handler(&vq->guest_notifier,
1632 virtio_queue_guest_notifier_read);
1633 } else {
1634 event_notifier_set_handler(&vq->guest_notifier, NULL);
1636 if (!assign) {
1637 /* Test and clear notifier before closing it,
1638 * in case poll callback didn't have time to run. */
1639 virtio_queue_guest_notifier_read(&vq->guest_notifier);
1643 EventNotifier *virtio_queue_get_guest_notifier(VirtQueue *vq)
1645 return &vq->guest_notifier;
1648 static void virtio_queue_host_notifier_read(EventNotifier *n)
1650 VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
1651 if (event_notifier_test_and_clear(n)) {
1652 virtio_queue_notify_vq(vq);
1656 void virtio_queue_set_host_notifier_fd_handler(VirtQueue *vq, bool assign,
1657 bool set_handler)
1659 if (assign && set_handler) {
1660 event_notifier_set_handler(&vq->host_notifier,
1661 virtio_queue_host_notifier_read);
1662 } else {
1663 event_notifier_set_handler(&vq->host_notifier, NULL);
1665 if (!assign) {
1666 /* Test and clear notifier before after disabling event,
1667 * in case poll callback didn't have time to run. */
1668 virtio_queue_host_notifier_read(&vq->host_notifier);
1672 EventNotifier *virtio_queue_get_host_notifier(VirtQueue *vq)
1674 return &vq->host_notifier;
1677 void virtio_device_set_child_bus_name(VirtIODevice *vdev, char *bus_name)
1679 g_free(vdev->bus_name);
1680 vdev->bus_name = g_strdup(bus_name);
1683 static void virtio_device_realize(DeviceState *dev, Error **errp)
1685 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1686 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(dev);
1687 Error *err = NULL;
1689 if (vdc->realize != NULL) {
1690 vdc->realize(dev, &err);
1691 if (err != NULL) {
1692 error_propagate(errp, err);
1693 return;
1697 virtio_bus_device_plugged(vdev, &err);
1698 if (err != NULL) {
1699 error_propagate(errp, err);
1700 return;
1704 static void virtio_device_unrealize(DeviceState *dev, Error **errp)
1706 VirtIODevice *vdev = VIRTIO_DEVICE(dev);
1707 VirtioDeviceClass *vdc = VIRTIO_DEVICE_GET_CLASS(dev);
1708 Error *err = NULL;
1710 virtio_bus_device_unplugged(vdev);
1712 if (vdc->unrealize != NULL) {
1713 vdc->unrealize(dev, &err);
1714 if (err != NULL) {
1715 error_propagate(errp, err);
1716 return;
1720 g_free(vdev->bus_name);
1721 vdev->bus_name = NULL;
1724 static Property virtio_properties[] = {
1725 DEFINE_VIRTIO_COMMON_FEATURES(VirtIODevice, host_features),
1726 DEFINE_PROP_END_OF_LIST(),
1729 static void virtio_device_class_init(ObjectClass *klass, void *data)
1731 /* Set the default value here. */
1732 DeviceClass *dc = DEVICE_CLASS(klass);
1734 dc->realize = virtio_device_realize;
1735 dc->unrealize = virtio_device_unrealize;
1736 dc->bus_type = TYPE_VIRTIO_BUS;
1737 dc->props = virtio_properties;
1740 static const TypeInfo virtio_device_info = {
1741 .name = TYPE_VIRTIO_DEVICE,
1742 .parent = TYPE_DEVICE,
1743 .instance_size = sizeof(VirtIODevice),
1744 .class_init = virtio_device_class_init,
1745 .abstract = true,
1746 .class_size = sizeof(VirtioDeviceClass),
1749 static void virtio_register_types(void)
1751 type_register_static(&virtio_device_info);
1754 type_init(virtio_register_types)