4 * Copyright IBM, Corp. 2007
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.
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
40 typedef struct VRingAvail
47 typedef struct VRingUsedElem
53 typedef struct VRingUsed
57 VRingUsedElem ring
[0];
63 unsigned int num_default
;
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? */
88 void (*handle_output
)(VirtIODevice
*vdev
, VirtQueue
*vq
);
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
;
101 /* not yet setup -> nothing to do */
104 vring
->avail
= vring
->desc
+ vring
->num
* sizeof(VRingDesc
);
105 vring
->used
= vring_align(vring
->avail
+
106 offsetof(VRingAvail
, ring
[vring
->num
]),
110 static inline uint64_t vring_desc_addr(VirtIODevice
*vdev
, hwaddr desc_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
)
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
,
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
,
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
)
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
)
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
)
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
)
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
)
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
)
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
)
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
;
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
;
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
)
214 if (!vq
->notification
) {
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
));
227 vring_used_flags_unset_bit(vq
, VRING_USED_F_NO_NOTIFY
);
229 vring_used_flags_set_bit(vq
, VRING_USED_F_NO_NOTIFY
);
232 /* Expose avail event/used flags before caller checks the avail idx. */
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
,
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
,
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
,
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
)
294 /* Make sure buffer is written before we update index. */
296 trace_virtqueue_flush(vq
, count
);
297 old
= vring_used_idx(vq
);
299 vring_used_idx_set(vq
, new);
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
,
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
));
322 /* On success, callers read a descriptor at vq->last_avail_idx.
323 * Make sure descriptor read does not bypass avail index read. */
331 static unsigned int virtqueue_get_head(VirtQueue
*vq
, unsigned int idx
)
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
);
348 static unsigned virtqueue_next_desc(VirtIODevice
*vdev
, hwaddr desc_pa
,
349 unsigned int i
, unsigned int max
)
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
)) {
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! */
364 error_report("Desc next is %u", 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
)
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;
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");
398 /* If we've got too many, that implies a descriptor loop. */
399 if (num_bufs
>= max
) {
400 error_report("Looped descriptor");
404 /* loop over the indirect descriptor table */
406 max
= vring_desc_len(vdev
, desc_pa
, i
) / sizeof(VRingDesc
);
407 desc_pa
= vring_desc_addr(vdev
, desc_pa
, i
);
412 /* If we've got too many, that implies a descriptor loop. */
413 if (++num_bufs
> max
) {
414 error_report("Looped descriptor");
418 if (vring_desc_flags(vdev
, desc_pa
, i
) & VRING_DESC_F_WRITE
) {
419 in_total
+= vring_desc_len(vdev
, desc_pa
, i
);
421 out_total
+= vring_desc_len(vdev
, desc_pa
, i
);
423 if (in_total
>= max_in_bytes
&& out_total
>= max_out_bytes
) {
426 } while ((i
= virtqueue_next_desc(vdev
, desc_pa
, i
, max
)) != max
);
429 total_bufs
= num_bufs
;
435 *in_bytes
= in_total
;
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
,
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
463 * When we do, we might be able to re-enable NDEBUG below.
466 #error building with NDEBUG is not supported
468 assert(*num_sg
<= max_size
);
470 for (i
= 0; i
< *num_sg
; i
++) {
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");
477 if (len
== sg
[i
].iov_len
) {
480 if (*num_sg
>= max_size
) {
481 error_report("virtio: memory split makes iovec too large");
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
);
489 sg
[i
+ 1].iov_len
-= len
;
494 /* Deprecated: don't use in new code */
495 void virtqueue_map_sg(struct iovec
*sg
, hwaddr
*addr
,
496 size_t num_sg
, int is_write
)
498 virtqueue_map_iovec(sg
, addr
, &num_sg
, num_sg
, is_write
);
501 void virtqueue_map(VirtQueueElement
*elem
)
503 virtqueue_map_iovec(elem
->in_sg
, elem
->in_addr
, &elem
->in_num
,
504 MIN(ARRAY_SIZE(elem
->in_sg
), ARRAY_SIZE(elem
->in_addr
)),
506 virtqueue_map_iovec(elem
->out_sg
, elem
->out_addr
, &elem
->out_num
,
507 MIN(ARRAY_SIZE(elem
->out_sg
), ARRAY_SIZE(elem
->out_addr
)),
511 int virtqueue_pop(VirtQueue
*vq
, VirtQueueElement
*elem
)
513 unsigned int i
, head
, max
;
514 hwaddr desc_pa
= vq
->vring
.desc
;
515 VirtIODevice
*vdev
= vq
->vdev
;
517 if (!virtqueue_num_heads(vq
, vq
->last_avail_idx
))
520 /* When we start there are none of either input nor output. */
521 elem
->out_num
= elem
->in_num
= 0;
525 i
= head
= virtqueue_get_head(vq
, vq
->last_avail_idx
++);
526 if (virtio_vdev_has_feature(vdev
, VIRTIO_RING_F_EVENT_IDX
)) {
527 vring_set_avail_event(vq
, vq
->last_avail_idx
);
530 if (vring_desc_flags(vdev
, desc_pa
, i
) & VRING_DESC_F_INDIRECT
) {
531 if (vring_desc_len(vdev
, desc_pa
, i
) % sizeof(VRingDesc
)) {
532 error_report("Invalid size for indirect buffer table");
536 /* loop over the indirect descriptor table */
537 max
= vring_desc_len(vdev
, desc_pa
, i
) / sizeof(VRingDesc
);
538 desc_pa
= vring_desc_addr(vdev
, desc_pa
, i
);
542 /* Collect all the descriptors */
546 if (vring_desc_flags(vdev
, desc_pa
, i
) & VRING_DESC_F_WRITE
) {
547 if (elem
->in_num
>= ARRAY_SIZE(elem
->in_sg
)) {
548 error_report("Too many write descriptors in indirect table");
551 elem
->in_addr
[elem
->in_num
] = vring_desc_addr(vdev
, desc_pa
, i
);
552 sg
= &elem
->in_sg
[elem
->in_num
++];
554 if (elem
->out_num
>= ARRAY_SIZE(elem
->out_sg
)) {
555 error_report("Too many read descriptors in indirect table");
558 elem
->out_addr
[elem
->out_num
] = vring_desc_addr(vdev
, desc_pa
, i
);
559 sg
= &elem
->out_sg
[elem
->out_num
++];
562 sg
->iov_len
= vring_desc_len(vdev
, desc_pa
, i
);
564 /* If we've got too many, that implies a descriptor loop. */
565 if ((elem
->in_num
+ elem
->out_num
) > max
) {
566 error_report("Looped descriptor");
569 } while ((i
= virtqueue_next_desc(vdev
, desc_pa
, i
, max
)) != max
);
571 /* Now map what we have collected */
572 virtqueue_map_sg(elem
->in_sg
, elem
->in_addr
, elem
->in_num
, 1);
573 virtqueue_map_sg(elem
->out_sg
, elem
->out_addr
, elem
->out_num
, 0);
579 trace_virtqueue_pop(vq
, elem
, elem
->in_num
, elem
->out_num
);
580 return elem
->in_num
+ elem
->out_num
;
584 static void virtio_notify_vector(VirtIODevice
*vdev
, uint16_t vector
)
586 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
587 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
590 k
->notify(qbus
->parent
, vector
);
594 void virtio_update_irq(VirtIODevice
*vdev
)
596 virtio_notify_vector(vdev
, VIRTIO_NO_VECTOR
);
599 static int virtio_validate_features(VirtIODevice
*vdev
)
601 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
603 if (k
->validate_features
) {
604 return k
->validate_features(vdev
);
610 int virtio_set_status(VirtIODevice
*vdev
, uint8_t val
)
612 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
613 trace_virtio_set_status(vdev
, val
);
615 if (virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
616 if (!(vdev
->status
& VIRTIO_CONFIG_S_FEATURES_OK
) &&
617 val
& VIRTIO_CONFIG_S_FEATURES_OK
) {
618 int ret
= virtio_validate_features(vdev
);
626 k
->set_status(vdev
, val
);
632 bool target_words_bigendian(void);
633 static enum virtio_device_endian
virtio_default_endian(void)
635 if (target_words_bigendian()) {
636 return VIRTIO_DEVICE_ENDIAN_BIG
;
638 return VIRTIO_DEVICE_ENDIAN_LITTLE
;
642 static enum virtio_device_endian
virtio_current_cpu_endian(void)
644 CPUClass
*cc
= CPU_GET_CLASS(current_cpu
);
646 if (cc
->virtio_is_big_endian(current_cpu
)) {
647 return VIRTIO_DEVICE_ENDIAN_BIG
;
649 return VIRTIO_DEVICE_ENDIAN_LITTLE
;
653 void virtio_reset(void *opaque
)
655 VirtIODevice
*vdev
= opaque
;
656 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
659 virtio_set_status(vdev
, 0);
661 /* Guest initiated reset */
662 vdev
->device_endian
= virtio_current_cpu_endian();
665 vdev
->device_endian
= virtio_default_endian();
672 vdev
->guest_features
= 0;
676 vdev
->config_vector
= VIRTIO_NO_VECTOR
;
677 virtio_notify_vector(vdev
, vdev
->config_vector
);
679 for(i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
680 vdev
->vq
[i
].vring
.desc
= 0;
681 vdev
->vq
[i
].vring
.avail
= 0;
682 vdev
->vq
[i
].vring
.used
= 0;
683 vdev
->vq
[i
].last_avail_idx
= 0;
684 virtio_queue_set_vector(vdev
, i
, VIRTIO_NO_VECTOR
);
685 vdev
->vq
[i
].signalled_used
= 0;
686 vdev
->vq
[i
].signalled_used_valid
= false;
687 vdev
->vq
[i
].notification
= true;
688 vdev
->vq
[i
].vring
.num
= vdev
->vq
[i
].vring
.num_default
;
692 uint32_t virtio_config_readb(VirtIODevice
*vdev
, uint32_t addr
)
694 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
697 if (addr
+ sizeof(val
) > vdev
->config_len
) {
701 k
->get_config(vdev
, vdev
->config
);
703 val
= ldub_p(vdev
->config
+ addr
);
707 uint32_t virtio_config_readw(VirtIODevice
*vdev
, uint32_t addr
)
709 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
712 if (addr
+ sizeof(val
) > vdev
->config_len
) {
716 k
->get_config(vdev
, vdev
->config
);
718 val
= lduw_p(vdev
->config
+ addr
);
722 uint32_t virtio_config_readl(VirtIODevice
*vdev
, uint32_t addr
)
724 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
727 if (addr
+ sizeof(val
) > vdev
->config_len
) {
731 k
->get_config(vdev
, vdev
->config
);
733 val
= ldl_p(vdev
->config
+ addr
);
737 void virtio_config_writeb(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
)
739 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
742 if (addr
+ sizeof(val
) > vdev
->config_len
) {
746 stb_p(vdev
->config
+ addr
, val
);
749 k
->set_config(vdev
, vdev
->config
);
753 void virtio_config_writew(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
)
755 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
758 if (addr
+ sizeof(val
) > vdev
->config_len
) {
762 stw_p(vdev
->config
+ addr
, val
);
765 k
->set_config(vdev
, vdev
->config
);
769 void virtio_config_writel(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
)
771 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
774 if (addr
+ sizeof(val
) > vdev
->config_len
) {
778 stl_p(vdev
->config
+ addr
, val
);
781 k
->set_config(vdev
, vdev
->config
);
785 uint32_t virtio_config_modern_readb(VirtIODevice
*vdev
, uint32_t addr
)
787 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
790 if (addr
+ sizeof(val
) > vdev
->config_len
) {
794 k
->get_config(vdev
, vdev
->config
);
796 val
= ldub_p(vdev
->config
+ addr
);
800 uint32_t virtio_config_modern_readw(VirtIODevice
*vdev
, uint32_t addr
)
802 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
805 if (addr
+ sizeof(val
) > vdev
->config_len
) {
809 k
->get_config(vdev
, vdev
->config
);
811 val
= lduw_le_p(vdev
->config
+ addr
);
815 uint32_t virtio_config_modern_readl(VirtIODevice
*vdev
, uint32_t addr
)
817 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
820 if (addr
+ sizeof(val
) > vdev
->config_len
) {
824 k
->get_config(vdev
, vdev
->config
);
826 val
= ldl_le_p(vdev
->config
+ addr
);
830 void virtio_config_modern_writeb(VirtIODevice
*vdev
,
831 uint32_t addr
, uint32_t data
)
833 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
836 if (addr
+ sizeof(val
) > vdev
->config_len
) {
840 stb_p(vdev
->config
+ addr
, val
);
843 k
->set_config(vdev
, vdev
->config
);
847 void virtio_config_modern_writew(VirtIODevice
*vdev
,
848 uint32_t addr
, uint32_t data
)
850 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
853 if (addr
+ sizeof(val
) > vdev
->config_len
) {
857 stw_le_p(vdev
->config
+ addr
, val
);
860 k
->set_config(vdev
, vdev
->config
);
864 void virtio_config_modern_writel(VirtIODevice
*vdev
,
865 uint32_t addr
, uint32_t data
)
867 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
870 if (addr
+ sizeof(val
) > vdev
->config_len
) {
874 stl_le_p(vdev
->config
+ addr
, val
);
877 k
->set_config(vdev
, vdev
->config
);
881 void virtio_queue_set_addr(VirtIODevice
*vdev
, int n
, hwaddr addr
)
883 vdev
->vq
[n
].vring
.desc
= addr
;
884 virtio_queue_update_rings(vdev
, n
);
887 hwaddr
virtio_queue_get_addr(VirtIODevice
*vdev
, int n
)
889 return vdev
->vq
[n
].vring
.desc
;
892 void virtio_queue_set_rings(VirtIODevice
*vdev
, int n
, hwaddr desc
,
893 hwaddr avail
, hwaddr used
)
895 vdev
->vq
[n
].vring
.desc
= desc
;
896 vdev
->vq
[n
].vring
.avail
= avail
;
897 vdev
->vq
[n
].vring
.used
= used
;
900 void virtio_queue_set_num(VirtIODevice
*vdev
, int n
, int num
)
902 /* Don't allow guest to flip queue between existent and
903 * nonexistent states, or to set it to an invalid size.
905 if (!!num
!= !!vdev
->vq
[n
].vring
.num
||
906 num
> VIRTQUEUE_MAX_SIZE
||
910 vdev
->vq
[n
].vring
.num
= num
;
913 VirtQueue
*virtio_vector_first_queue(VirtIODevice
*vdev
, uint16_t vector
)
915 return QLIST_FIRST(&vdev
->vector_queues
[vector
]);
918 VirtQueue
*virtio_vector_next_queue(VirtQueue
*vq
)
920 return QLIST_NEXT(vq
, node
);
923 int virtio_queue_get_num(VirtIODevice
*vdev
, int n
)
925 return vdev
->vq
[n
].vring
.num
;
928 int virtio_get_num_queues(VirtIODevice
*vdev
)
932 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
933 if (!virtio_queue_get_num(vdev
, i
)) {
941 int virtio_queue_get_id(VirtQueue
*vq
)
943 VirtIODevice
*vdev
= vq
->vdev
;
944 assert(vq
>= &vdev
->vq
[0] && vq
< &vdev
->vq
[VIRTIO_QUEUE_MAX
]);
945 return vq
- &vdev
->vq
[0];
948 void virtio_queue_set_align(VirtIODevice
*vdev
, int n
, int align
)
950 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
951 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
953 /* virtio-1 compliant devices cannot change the alignment */
954 if (virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
955 error_report("tried to modify queue alignment for virtio-1 device");
958 /* Check that the transport told us it was going to do this
959 * (so a buggy transport will immediately assert rather than
960 * silently failing to migrate this state)
962 assert(k
->has_variable_vring_alignment
);
964 vdev
->vq
[n
].vring
.align
= align
;
965 virtio_queue_update_rings(vdev
, n
);
968 void virtio_queue_notify_vq(VirtQueue
*vq
)
970 if (vq
->vring
.desc
&& vq
->handle_output
) {
971 VirtIODevice
*vdev
= vq
->vdev
;
973 trace_virtio_queue_notify(vdev
, vq
- vdev
->vq
, vq
);
974 vq
->handle_output(vdev
, vq
);
978 void virtio_queue_notify(VirtIODevice
*vdev
, int n
)
980 virtio_queue_notify_vq(&vdev
->vq
[n
]);
983 uint16_t virtio_queue_vector(VirtIODevice
*vdev
, int n
)
985 return n
< VIRTIO_QUEUE_MAX
? vdev
->vq
[n
].vector
:
989 void virtio_queue_set_vector(VirtIODevice
*vdev
, int n
, uint16_t vector
)
991 VirtQueue
*vq
= &vdev
->vq
[n
];
993 if (n
< VIRTIO_QUEUE_MAX
) {
994 if (vdev
->vector_queues
&&
995 vdev
->vq
[n
].vector
!= VIRTIO_NO_VECTOR
) {
996 QLIST_REMOVE(vq
, node
);
998 vdev
->vq
[n
].vector
= vector
;
999 if (vdev
->vector_queues
&&
1000 vector
!= VIRTIO_NO_VECTOR
) {
1001 QLIST_INSERT_HEAD(&vdev
->vector_queues
[vector
], vq
, node
);
1006 VirtQueue
*virtio_add_queue(VirtIODevice
*vdev
, int queue_size
,
1007 void (*handle_output
)(VirtIODevice
*, VirtQueue
*))
1011 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1012 if (vdev
->vq
[i
].vring
.num
== 0)
1016 if (i
== VIRTIO_QUEUE_MAX
|| queue_size
> VIRTQUEUE_MAX_SIZE
)
1019 vdev
->vq
[i
].vring
.num
= queue_size
;
1020 vdev
->vq
[i
].vring
.num_default
= queue_size
;
1021 vdev
->vq
[i
].vring
.align
= VIRTIO_PCI_VRING_ALIGN
;
1022 vdev
->vq
[i
].handle_output
= handle_output
;
1024 return &vdev
->vq
[i
];
1027 void virtio_del_queue(VirtIODevice
*vdev
, int n
)
1029 if (n
< 0 || n
>= VIRTIO_QUEUE_MAX
) {
1033 vdev
->vq
[n
].vring
.num
= 0;
1034 vdev
->vq
[n
].vring
.num_default
= 0;
1037 void virtio_irq(VirtQueue
*vq
)
1039 trace_virtio_irq(vq
);
1040 vq
->vdev
->isr
|= 0x01;
1041 virtio_notify_vector(vq
->vdev
, vq
->vector
);
1044 static bool vring_notify(VirtIODevice
*vdev
, VirtQueue
*vq
)
1048 /* We need to expose used array entries before checking used event. */
1050 /* Always notify when queue is empty (when feature acknowledge) */
1051 if (virtio_vdev_has_feature(vdev
, VIRTIO_F_NOTIFY_ON_EMPTY
) &&
1052 !vq
->inuse
&& vring_avail_idx(vq
) == vq
->last_avail_idx
) {
1056 if (!virtio_vdev_has_feature(vdev
, VIRTIO_RING_F_EVENT_IDX
)) {
1057 return !(vring_avail_flags(vq
) & VRING_AVAIL_F_NO_INTERRUPT
);
1060 v
= vq
->signalled_used_valid
;
1061 vq
->signalled_used_valid
= true;
1062 old
= vq
->signalled_used
;
1063 new = vq
->signalled_used
= vring_used_idx(vq
);
1064 return !v
|| vring_need_event(vring_get_used_event(vq
), new, old
);
1067 void virtio_notify(VirtIODevice
*vdev
, VirtQueue
*vq
)
1069 if (!vring_notify(vdev
, vq
)) {
1073 trace_virtio_notify(vdev
, vq
);
1075 virtio_notify_vector(vdev
, vq
->vector
);
1078 void virtio_notify_config(VirtIODevice
*vdev
)
1080 if (!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
))
1085 virtio_notify_vector(vdev
, vdev
->config_vector
);
1088 static bool virtio_device_endian_needed(void *opaque
)
1090 VirtIODevice
*vdev
= opaque
;
1092 assert(vdev
->device_endian
!= VIRTIO_DEVICE_ENDIAN_UNKNOWN
);
1093 if (!virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
1094 return vdev
->device_endian
!= virtio_default_endian();
1096 /* Devices conforming to VIRTIO 1.0 or later are always LE. */
1097 return vdev
->device_endian
!= VIRTIO_DEVICE_ENDIAN_LITTLE
;
1100 static bool virtio_64bit_features_needed(void *opaque
)
1102 VirtIODevice
*vdev
= opaque
;
1104 return (vdev
->host_features
>> 32) != 0;
1107 static bool virtio_virtqueue_needed(void *opaque
)
1109 VirtIODevice
*vdev
= opaque
;
1111 return virtio_host_has_feature(vdev
, VIRTIO_F_VERSION_1
);
1114 static bool virtio_ringsize_needed(void *opaque
)
1116 VirtIODevice
*vdev
= opaque
;
1119 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1120 if (vdev
->vq
[i
].vring
.num
!= vdev
->vq
[i
].vring
.num_default
) {
1127 static void put_virtqueue_state(QEMUFile
*f
, void *pv
, size_t size
)
1129 VirtIODevice
*vdev
= pv
;
1132 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1133 qemu_put_be64(f
, vdev
->vq
[i
].vring
.avail
);
1134 qemu_put_be64(f
, vdev
->vq
[i
].vring
.used
);
1138 static int get_virtqueue_state(QEMUFile
*f
, void *pv
, size_t size
)
1140 VirtIODevice
*vdev
= pv
;
1143 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1144 vdev
->vq
[i
].vring
.avail
= qemu_get_be64(f
);
1145 vdev
->vq
[i
].vring
.used
= qemu_get_be64(f
);
1150 static VMStateInfo vmstate_info_virtqueue
= {
1151 .name
= "virtqueue_state",
1152 .get
= get_virtqueue_state
,
1153 .put
= put_virtqueue_state
,
1156 static const VMStateDescription vmstate_virtio_virtqueues
= {
1157 .name
= "virtio/virtqueues",
1159 .minimum_version_id
= 1,
1160 .needed
= &virtio_virtqueue_needed
,
1161 .fields
= (VMStateField
[]) {
1163 .name
= "virtqueues",
1165 .field_exists
= NULL
,
1167 .info
= &vmstate_info_virtqueue
,
1168 .flags
= VMS_SINGLE
,
1171 VMSTATE_END_OF_LIST()
1175 static void put_ringsize_state(QEMUFile
*f
, void *pv
, size_t size
)
1177 VirtIODevice
*vdev
= pv
;
1180 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1181 qemu_put_be32(f
, vdev
->vq
[i
].vring
.num_default
);
1185 static int get_ringsize_state(QEMUFile
*f
, void *pv
, size_t size
)
1187 VirtIODevice
*vdev
= pv
;
1190 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1191 vdev
->vq
[i
].vring
.num_default
= qemu_get_be32(f
);
1196 static VMStateInfo vmstate_info_ringsize
= {
1197 .name
= "ringsize_state",
1198 .get
= get_ringsize_state
,
1199 .put
= put_ringsize_state
,
1202 static const VMStateDescription vmstate_virtio_ringsize
= {
1203 .name
= "virtio/ringsize",
1205 .minimum_version_id
= 1,
1206 .needed
= &virtio_ringsize_needed
,
1207 .fields
= (VMStateField
[]) {
1211 .field_exists
= NULL
,
1213 .info
= &vmstate_info_ringsize
,
1214 .flags
= VMS_SINGLE
,
1217 VMSTATE_END_OF_LIST()
1221 static const VMStateDescription vmstate_virtio_device_endian
= {
1222 .name
= "virtio/device_endian",
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",
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
= {
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
,
1260 void virtio_save(VirtIODevice
*vdev
, QEMUFile
*f
)
1262 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
1263 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
1264 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1265 uint32_t guest_features_lo
= (vdev
->guest_features
& 0xffffffff);
1268 if (k
->save_config
) {
1269 k
->save_config(qbus
->parent
, f
);
1272 qemu_put_8s(f
, &vdev
->status
);
1273 qemu_put_8s(f
, &vdev
->isr
);
1274 qemu_put_be16s(f
, &vdev
->queue_sel
);
1275 qemu_put_be32s(f
, &guest_features_lo
);
1276 qemu_put_be32(f
, vdev
->config_len
);
1277 qemu_put_buffer(f
, vdev
->config
, vdev
->config_len
);
1279 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1280 if (vdev
->vq
[i
].vring
.num
== 0)
1284 qemu_put_be32(f
, i
);
1286 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1287 if (vdev
->vq
[i
].vring
.num
== 0)
1290 qemu_put_be32(f
, vdev
->vq
[i
].vring
.num
);
1291 if (k
->has_variable_vring_alignment
) {
1292 qemu_put_be32(f
, vdev
->vq
[i
].vring
.align
);
1294 /* XXX virtio-1 devices */
1295 qemu_put_be64(f
, vdev
->vq
[i
].vring
.desc
);
1296 qemu_put_be16s(f
, &vdev
->vq
[i
].last_avail_idx
);
1297 if (k
->save_queue
) {
1298 k
->save_queue(qbus
->parent
, i
, f
);
1302 if (vdc
->save
!= NULL
) {
1307 vmstate_save_state(f
, &vmstate_virtio
, vdev
, NULL
);
1310 static int virtio_set_features_nocheck(VirtIODevice
*vdev
, uint64_t val
)
1312 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1313 bool bad
= (val
& ~(vdev
->host_features
)) != 0;
1315 val
&= vdev
->host_features
;
1316 if (k
->set_features
) {
1317 k
->set_features(vdev
, val
);
1319 vdev
->guest_features
= val
;
1320 return bad
? -1 : 0;
1323 int virtio_set_features(VirtIODevice
*vdev
, uint64_t val
)
1326 * The driver must not attempt to set features after feature negotiation
1329 if (vdev
->status
& VIRTIO_CONFIG_S_FEATURES_OK
) {
1332 return virtio_set_features_nocheck(vdev
, val
);
1335 int virtio_load(VirtIODevice
*vdev
, QEMUFile
*f
, int version_id
)
1341 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
1342 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
1343 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1346 * We poison the endianness to ensure it does not get used before
1347 * subsections have been loaded.
1349 vdev
->device_endian
= VIRTIO_DEVICE_ENDIAN_UNKNOWN
;
1351 if (k
->load_config
) {
1352 ret
= k
->load_config(qbus
->parent
, f
);
1357 qemu_get_8s(f
, &vdev
->status
);
1358 qemu_get_8s(f
, &vdev
->isr
);
1359 qemu_get_be16s(f
, &vdev
->queue_sel
);
1360 if (vdev
->queue_sel
>= VIRTIO_QUEUE_MAX
) {
1363 qemu_get_be32s(f
, &features
);
1365 config_len
= qemu_get_be32(f
);
1368 * There are cases where the incoming config can be bigger or smaller
1369 * than what we have; so load what we have space for, and skip
1370 * any excess that's in the stream.
1372 qemu_get_buffer(f
, vdev
->config
, MIN(config_len
, vdev
->config_len
));
1374 while (config_len
> vdev
->config_len
) {
1379 num
= qemu_get_be32(f
);
1381 if (num
> VIRTIO_QUEUE_MAX
) {
1382 error_report("Invalid number of PCI queues: 0x%x", num
);
1386 for (i
= 0; i
< num
; i
++) {
1387 vdev
->vq
[i
].vring
.num
= qemu_get_be32(f
);
1388 if (k
->has_variable_vring_alignment
) {
1389 vdev
->vq
[i
].vring
.align
= qemu_get_be32(f
);
1391 vdev
->vq
[i
].vring
.desc
= qemu_get_be64(f
);
1392 qemu_get_be16s(f
, &vdev
->vq
[i
].last_avail_idx
);
1393 vdev
->vq
[i
].signalled_used_valid
= false;
1394 vdev
->vq
[i
].notification
= true;
1396 if (vdev
->vq
[i
].vring
.desc
) {
1397 /* XXX virtio-1 devices */
1398 virtio_queue_update_rings(vdev
, i
);
1399 } else if (vdev
->vq
[i
].last_avail_idx
) {
1400 error_report("VQ %d address 0x0 "
1401 "inconsistent with Host index 0x%x",
1402 i
, vdev
->vq
[i
].last_avail_idx
);
1405 if (k
->load_queue
) {
1406 ret
= k
->load_queue(qbus
->parent
, i
, f
);
1412 virtio_notify_vector(vdev
, VIRTIO_NO_VECTOR
);
1414 if (vdc
->load
!= NULL
) {
1415 ret
= vdc
->load(vdev
, f
, version_id
);
1422 ret
= vmstate_load_state(f
, &vmstate_virtio
, vdev
, 1);
1427 if (vdev
->device_endian
== VIRTIO_DEVICE_ENDIAN_UNKNOWN
) {
1428 vdev
->device_endian
= virtio_default_endian();
1431 if (virtio_64bit_features_needed(vdev
)) {
1433 * Subsection load filled vdev->guest_features. Run them
1434 * through virtio_set_features to sanity-check them against
1437 uint64_t features64
= vdev
->guest_features
;
1438 if (virtio_set_features_nocheck(vdev
, features64
) < 0) {
1439 error_report("Features 0x%" PRIx64
" unsupported. "
1440 "Allowed features: 0x%" PRIx64
,
1441 features64
, vdev
->host_features
);
1445 if (virtio_set_features_nocheck(vdev
, features
) < 0) {
1446 error_report("Features 0x%x unsupported. "
1447 "Allowed features: 0x%" PRIx64
,
1448 features
, vdev
->host_features
);
1453 for (i
= 0; i
< num
; i
++) {
1454 if (vdev
->vq
[i
].vring
.desc
) {
1456 nheads
= vring_avail_idx(&vdev
->vq
[i
]) - vdev
->vq
[i
].last_avail_idx
;
1457 /* Check it isn't doing strange things with descriptor numbers. */
1458 if (nheads
> vdev
->vq
[i
].vring
.num
) {
1459 error_report("VQ %d size 0x%x Guest index 0x%x "
1460 "inconsistent with Host index 0x%x: delta 0x%x",
1461 i
, vdev
->vq
[i
].vring
.num
,
1462 vring_avail_idx(&vdev
->vq
[i
]),
1463 vdev
->vq
[i
].last_avail_idx
, nheads
);
1472 void virtio_cleanup(VirtIODevice
*vdev
)
1474 qemu_del_vm_change_state_handler(vdev
->vmstate
);
1475 g_free(vdev
->config
);
1477 g_free(vdev
->vector_queues
);
1480 static void virtio_vmstate_change(void *opaque
, int running
, RunState state
)
1482 VirtIODevice
*vdev
= opaque
;
1483 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
1484 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
1485 bool backend_run
= running
&& (vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
);
1486 vdev
->vm_running
= running
;
1489 virtio_set_status(vdev
, vdev
->status
);
1492 if (k
->vmstate_change
) {
1493 k
->vmstate_change(qbus
->parent
, backend_run
);
1497 virtio_set_status(vdev
, vdev
->status
);
1501 void virtio_instance_init_common(Object
*proxy_obj
, void *data
,
1502 size_t vdev_size
, const char *vdev_name
)
1504 DeviceState
*vdev
= data
;
1506 object_initialize(vdev
, vdev_size
, vdev_name
);
1507 object_property_add_child(proxy_obj
, "virtio-backend", OBJECT(vdev
), NULL
);
1508 object_unref(OBJECT(vdev
));
1509 qdev_alias_all_properties(vdev
, proxy_obj
);
1512 void virtio_init(VirtIODevice
*vdev
, const char *name
,
1513 uint16_t device_id
, size_t config_size
)
1515 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
1516 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
1518 int nvectors
= k
->query_nvectors
? k
->query_nvectors(qbus
->parent
) : 0;
1521 vdev
->vector_queues
=
1522 g_malloc0(sizeof(*vdev
->vector_queues
) * nvectors
);
1525 vdev
->device_id
= device_id
;
1528 vdev
->queue_sel
= 0;
1529 vdev
->config_vector
= VIRTIO_NO_VECTOR
;
1530 vdev
->vq
= g_malloc0(sizeof(VirtQueue
) * VIRTIO_QUEUE_MAX
);
1531 vdev
->vm_running
= runstate_is_running();
1532 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1533 vdev
->vq
[i
].vector
= VIRTIO_NO_VECTOR
;
1534 vdev
->vq
[i
].vdev
= vdev
;
1535 vdev
->vq
[i
].queue_index
= i
;
1539 vdev
->config_len
= config_size
;
1540 if (vdev
->config_len
) {
1541 vdev
->config
= g_malloc0(config_size
);
1543 vdev
->config
= NULL
;
1545 vdev
->vmstate
= qemu_add_vm_change_state_handler(virtio_vmstate_change
,
1547 vdev
->device_endian
= virtio_default_endian();
1550 hwaddr
virtio_queue_get_desc_addr(VirtIODevice
*vdev
, int n
)
1552 return vdev
->vq
[n
].vring
.desc
;
1555 hwaddr
virtio_queue_get_avail_addr(VirtIODevice
*vdev
, int n
)
1557 return vdev
->vq
[n
].vring
.avail
;
1560 hwaddr
virtio_queue_get_used_addr(VirtIODevice
*vdev
, int n
)
1562 return vdev
->vq
[n
].vring
.used
;
1565 hwaddr
virtio_queue_get_ring_addr(VirtIODevice
*vdev
, int n
)
1567 return vdev
->vq
[n
].vring
.desc
;
1570 hwaddr
virtio_queue_get_desc_size(VirtIODevice
*vdev
, int n
)
1572 return sizeof(VRingDesc
) * vdev
->vq
[n
].vring
.num
;
1575 hwaddr
virtio_queue_get_avail_size(VirtIODevice
*vdev
, int n
)
1577 return offsetof(VRingAvail
, ring
) +
1578 sizeof(uint16_t) * vdev
->vq
[n
].vring
.num
;
1581 hwaddr
virtio_queue_get_used_size(VirtIODevice
*vdev
, int n
)
1583 return offsetof(VRingUsed
, ring
) +
1584 sizeof(VRingUsedElem
) * vdev
->vq
[n
].vring
.num
;
1587 hwaddr
virtio_queue_get_ring_size(VirtIODevice
*vdev
, int n
)
1589 return vdev
->vq
[n
].vring
.used
- vdev
->vq
[n
].vring
.desc
+
1590 virtio_queue_get_used_size(vdev
, n
);
1593 uint16_t virtio_queue_get_last_avail_idx(VirtIODevice
*vdev
, int n
)
1595 return vdev
->vq
[n
].last_avail_idx
;
1598 void virtio_queue_set_last_avail_idx(VirtIODevice
*vdev
, int n
, uint16_t idx
)
1600 vdev
->vq
[n
].last_avail_idx
= idx
;
1603 void virtio_queue_invalidate_signalled_used(VirtIODevice
*vdev
, int n
)
1605 vdev
->vq
[n
].signalled_used_valid
= false;
1608 VirtQueue
*virtio_get_queue(VirtIODevice
*vdev
, int n
)
1610 return vdev
->vq
+ n
;
1613 uint16_t virtio_get_queue_index(VirtQueue
*vq
)
1615 return vq
->queue_index
;
1618 static void virtio_queue_guest_notifier_read(EventNotifier
*n
)
1620 VirtQueue
*vq
= container_of(n
, VirtQueue
, guest_notifier
);
1621 if (event_notifier_test_and_clear(n
)) {
1626 void virtio_queue_set_guest_notifier_fd_handler(VirtQueue
*vq
, bool assign
,
1629 if (assign
&& !with_irqfd
) {
1630 event_notifier_set_handler(&vq
->guest_notifier
,
1631 virtio_queue_guest_notifier_read
);
1633 event_notifier_set_handler(&vq
->guest_notifier
, NULL
);
1636 /* Test and clear notifier before closing it,
1637 * in case poll callback didn't have time to run. */
1638 virtio_queue_guest_notifier_read(&vq
->guest_notifier
);
1642 EventNotifier
*virtio_queue_get_guest_notifier(VirtQueue
*vq
)
1644 return &vq
->guest_notifier
;
1647 static void virtio_queue_host_notifier_read(EventNotifier
*n
)
1649 VirtQueue
*vq
= container_of(n
, VirtQueue
, host_notifier
);
1650 if (event_notifier_test_and_clear(n
)) {
1651 virtio_queue_notify_vq(vq
);
1655 void virtio_queue_set_host_notifier_fd_handler(VirtQueue
*vq
, bool assign
,
1658 if (assign
&& set_handler
) {
1659 event_notifier_set_handler(&vq
->host_notifier
,
1660 virtio_queue_host_notifier_read
);
1662 event_notifier_set_handler(&vq
->host_notifier
, NULL
);
1665 /* Test and clear notifier before after disabling event,
1666 * in case poll callback didn't have time to run. */
1667 virtio_queue_host_notifier_read(&vq
->host_notifier
);
1671 EventNotifier
*virtio_queue_get_host_notifier(VirtQueue
*vq
)
1673 return &vq
->host_notifier
;
1676 void virtio_device_set_child_bus_name(VirtIODevice
*vdev
, char *bus_name
)
1678 g_free(vdev
->bus_name
);
1679 vdev
->bus_name
= g_strdup(bus_name
);
1682 static void virtio_device_realize(DeviceState
*dev
, Error
**errp
)
1684 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
1685 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(dev
);
1688 if (vdc
->realize
!= NULL
) {
1689 vdc
->realize(dev
, &err
);
1691 error_propagate(errp
, err
);
1696 virtio_bus_device_plugged(vdev
, &err
);
1698 error_propagate(errp
, err
);
1703 static void virtio_device_unrealize(DeviceState
*dev
, Error
**errp
)
1705 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
1706 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(dev
);
1709 virtio_bus_device_unplugged(vdev
);
1711 if (vdc
->unrealize
!= NULL
) {
1712 vdc
->unrealize(dev
, &err
);
1714 error_propagate(errp
, err
);
1719 g_free(vdev
->bus_name
);
1720 vdev
->bus_name
= NULL
;
1723 static Property virtio_properties
[] = {
1724 DEFINE_VIRTIO_COMMON_FEATURES(VirtIODevice
, host_features
),
1725 DEFINE_PROP_END_OF_LIST(),
1728 static void virtio_device_class_init(ObjectClass
*klass
, void *data
)
1730 /* Set the default value here. */
1731 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1733 dc
->realize
= virtio_device_realize
;
1734 dc
->unrealize
= virtio_device_unrealize
;
1735 dc
->bus_type
= TYPE_VIRTIO_BUS
;
1736 dc
->props
= virtio_properties
;
1739 static const TypeInfo virtio_device_info
= {
1740 .name
= TYPE_VIRTIO_DEVICE
,
1741 .parent
= TYPE_DEVICE
,
1742 .instance_size
= sizeof(VirtIODevice
),
1743 .class_init
= virtio_device_class_init
,
1745 .class_size
= sizeof(VirtioDeviceClass
),
1748 static void virtio_register_types(void)
1750 type_register_static(&virtio_device_info
);
1753 type_init(virtio_register_types
)