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.
14 #include "qemu/osdep.h"
15 #include "qapi/error.h"
16 #include "qemu-common.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"
26 #include "sysemu/dma.h"
29 * The alignment to use between consumer and producer parts of vring.
30 * x86 pagesize again. This is the default, used by transports like PCI
31 * which don't provide a means for the guest to tell the host the alignment.
33 #define VIRTIO_PCI_VRING_ALIGN 4096
35 typedef struct VRingDesc
43 typedef struct VRingAvail
50 typedef struct VRingUsedElem
56 typedef struct VRingUsed
60 VRingUsedElem ring
[0];
63 typedef struct VRingMemoryRegionCaches
{
65 MemoryRegionCache desc
;
66 MemoryRegionCache avail
;
67 MemoryRegionCache used
;
68 } VRingMemoryRegionCaches
;
73 unsigned int num_default
;
78 VRingMemoryRegionCaches
*caches
;
85 /* Next head to pop */
86 uint16_t last_avail_idx
;
88 /* Last avail_idx read from VQ. */
89 uint16_t shadow_avail_idx
;
93 /* Last used index value we have signalled on */
94 uint16_t signalled_used
;
96 /* Last used index value we have signalled on */
97 bool signalled_used_valid
;
99 /* Notification enabled? */
102 uint16_t queue_index
;
107 VirtIOHandleOutput handle_output
;
108 VirtIOHandleAIOOutput handle_aio_output
;
110 EventNotifier guest_notifier
;
111 EventNotifier host_notifier
;
112 QLIST_ENTRY(VirtQueue
) node
;
115 static void virtio_free_region_cache(VRingMemoryRegionCaches
*caches
)
121 address_space_cache_destroy(&caches
->desc
);
122 address_space_cache_destroy(&caches
->avail
);
123 address_space_cache_destroy(&caches
->used
);
127 static void virtio_init_region_cache(VirtIODevice
*vdev
, int n
)
129 VirtQueue
*vq
= &vdev
->vq
[n
];
130 VRingMemoryRegionCaches
*old
= vq
->vring
.caches
;
131 VRingMemoryRegionCaches
*new;
136 event_size
= virtio_vdev_has_feature(vq
->vdev
, VIRTIO_RING_F_EVENT_IDX
) ? 2 : 0;
138 addr
= vq
->vring
.desc
;
142 new = g_new0(VRingMemoryRegionCaches
, 1);
143 size
= virtio_queue_get_desc_size(vdev
, n
);
144 len
= address_space_cache_init(&new->desc
, vdev
->dma_as
,
147 virtio_error(vdev
, "Cannot map desc");
151 size
= virtio_queue_get_used_size(vdev
, n
) + event_size
;
152 len
= address_space_cache_init(&new->used
, vdev
->dma_as
,
153 vq
->vring
.used
, size
, true);
155 virtio_error(vdev
, "Cannot map used");
159 size
= virtio_queue_get_avail_size(vdev
, n
) + event_size
;
160 len
= address_space_cache_init(&new->avail
, vdev
->dma_as
,
161 vq
->vring
.avail
, size
, false);
163 virtio_error(vdev
, "Cannot map avail");
167 atomic_rcu_set(&vq
->vring
.caches
, new);
169 call_rcu(old
, virtio_free_region_cache
, rcu
);
174 address_space_cache_destroy(&new->used
);
176 address_space_cache_destroy(&new->desc
);
181 /* virt queue functions */
182 void virtio_queue_update_rings(VirtIODevice
*vdev
, int n
)
184 VRing
*vring
= &vdev
->vq
[n
].vring
;
187 /* not yet setup -> nothing to do */
190 vring
->avail
= vring
->desc
+ vring
->num
* sizeof(VRingDesc
);
191 vring
->used
= vring_align(vring
->avail
+
192 offsetof(VRingAvail
, ring
[vring
->num
]),
194 virtio_init_region_cache(vdev
, n
);
197 /* Called within rcu_read_lock(). */
198 static void vring_desc_read(VirtIODevice
*vdev
, VRingDesc
*desc
,
199 MemoryRegionCache
*cache
, int i
)
201 address_space_read_cached(cache
, i
* sizeof(VRingDesc
),
202 desc
, sizeof(VRingDesc
));
203 virtio_tswap64s(vdev
, &desc
->addr
);
204 virtio_tswap32s(vdev
, &desc
->len
);
205 virtio_tswap16s(vdev
, &desc
->flags
);
206 virtio_tswap16s(vdev
, &desc
->next
);
209 static VRingMemoryRegionCaches
*vring_get_region_caches(struct VirtQueue
*vq
)
211 VRingMemoryRegionCaches
*caches
= atomic_rcu_read(&vq
->vring
.caches
);
212 assert(caches
!= NULL
);
215 /* Called within rcu_read_lock(). */
216 static inline uint16_t vring_avail_flags(VirtQueue
*vq
)
218 VRingMemoryRegionCaches
*caches
= vring_get_region_caches(vq
);
219 hwaddr pa
= offsetof(VRingAvail
, flags
);
220 return virtio_lduw_phys_cached(vq
->vdev
, &caches
->avail
, pa
);
223 /* Called within rcu_read_lock(). */
224 static inline uint16_t vring_avail_idx(VirtQueue
*vq
)
226 VRingMemoryRegionCaches
*caches
= vring_get_region_caches(vq
);
227 hwaddr pa
= offsetof(VRingAvail
, idx
);
228 vq
->shadow_avail_idx
= virtio_lduw_phys_cached(vq
->vdev
, &caches
->avail
, pa
);
229 return vq
->shadow_avail_idx
;
232 /* Called within rcu_read_lock(). */
233 static inline uint16_t vring_avail_ring(VirtQueue
*vq
, int i
)
235 VRingMemoryRegionCaches
*caches
= vring_get_region_caches(vq
);
236 hwaddr pa
= offsetof(VRingAvail
, ring
[i
]);
237 return virtio_lduw_phys_cached(vq
->vdev
, &caches
->avail
, pa
);
240 /* Called within rcu_read_lock(). */
241 static inline uint16_t vring_get_used_event(VirtQueue
*vq
)
243 return vring_avail_ring(vq
, vq
->vring
.num
);
246 /* Called within rcu_read_lock(). */
247 static inline void vring_used_write(VirtQueue
*vq
, VRingUsedElem
*uelem
,
250 VRingMemoryRegionCaches
*caches
= vring_get_region_caches(vq
);
251 hwaddr pa
= offsetof(VRingUsed
, ring
[i
]);
252 virtio_tswap32s(vq
->vdev
, &uelem
->id
);
253 virtio_tswap32s(vq
->vdev
, &uelem
->len
);
254 address_space_write_cached(&caches
->used
, pa
, uelem
, sizeof(VRingUsedElem
));
255 address_space_cache_invalidate(&caches
->used
, pa
, sizeof(VRingUsedElem
));
258 /* Called within rcu_read_lock(). */
259 static uint16_t vring_used_idx(VirtQueue
*vq
)
261 VRingMemoryRegionCaches
*caches
= vring_get_region_caches(vq
);
262 hwaddr pa
= offsetof(VRingUsed
, idx
);
263 return virtio_lduw_phys_cached(vq
->vdev
, &caches
->used
, pa
);
266 /* Called within rcu_read_lock(). */
267 static inline void vring_used_idx_set(VirtQueue
*vq
, uint16_t val
)
269 VRingMemoryRegionCaches
*caches
= vring_get_region_caches(vq
);
270 hwaddr pa
= offsetof(VRingUsed
, idx
);
271 virtio_stw_phys_cached(vq
->vdev
, &caches
->used
, pa
, val
);
272 address_space_cache_invalidate(&caches
->used
, pa
, sizeof(val
));
276 /* Called within rcu_read_lock(). */
277 static inline void vring_used_flags_set_bit(VirtQueue
*vq
, int mask
)
279 VRingMemoryRegionCaches
*caches
= vring_get_region_caches(vq
);
280 VirtIODevice
*vdev
= vq
->vdev
;
281 hwaddr pa
= offsetof(VRingUsed
, flags
);
282 uint16_t flags
= virtio_lduw_phys_cached(vq
->vdev
, &caches
->used
, pa
);
284 virtio_stw_phys_cached(vdev
, &caches
->used
, pa
, flags
| mask
);
285 address_space_cache_invalidate(&caches
->used
, pa
, sizeof(flags
));
288 /* Called within rcu_read_lock(). */
289 static inline void vring_used_flags_unset_bit(VirtQueue
*vq
, int mask
)
291 VRingMemoryRegionCaches
*caches
= vring_get_region_caches(vq
);
292 VirtIODevice
*vdev
= vq
->vdev
;
293 hwaddr pa
= offsetof(VRingUsed
, flags
);
294 uint16_t flags
= virtio_lduw_phys_cached(vq
->vdev
, &caches
->used
, pa
);
296 virtio_stw_phys_cached(vdev
, &caches
->used
, pa
, flags
& ~mask
);
297 address_space_cache_invalidate(&caches
->used
, pa
, sizeof(flags
));
300 /* Called within rcu_read_lock(). */
301 static inline void vring_set_avail_event(VirtQueue
*vq
, uint16_t val
)
303 VRingMemoryRegionCaches
*caches
;
305 if (!vq
->notification
) {
309 caches
= vring_get_region_caches(vq
);
310 pa
= offsetof(VRingUsed
, ring
[vq
->vring
.num
]);
311 virtio_stw_phys_cached(vq
->vdev
, &caches
->used
, pa
, val
);
312 address_space_cache_invalidate(&caches
->used
, pa
, sizeof(val
));
315 void virtio_queue_set_notification(VirtQueue
*vq
, int enable
)
317 vq
->notification
= enable
;
319 if (!vq
->vring
.desc
) {
324 if (virtio_vdev_has_feature(vq
->vdev
, VIRTIO_RING_F_EVENT_IDX
)) {
325 vring_set_avail_event(vq
, vring_avail_idx(vq
));
327 vring_used_flags_unset_bit(vq
, VRING_USED_F_NO_NOTIFY
);
329 vring_used_flags_set_bit(vq
, VRING_USED_F_NO_NOTIFY
);
332 /* Expose avail event/used flags before caller checks the avail idx. */
338 int virtio_queue_ready(VirtQueue
*vq
)
340 return vq
->vring
.avail
!= 0;
343 /* Fetch avail_idx from VQ memory only when we really need to know if
344 * guest has added some buffers.
345 * Called within rcu_read_lock(). */
346 static int virtio_queue_empty_rcu(VirtQueue
*vq
)
348 if (unlikely(!vq
->vring
.avail
)) {
352 if (vq
->shadow_avail_idx
!= vq
->last_avail_idx
) {
356 return vring_avail_idx(vq
) == vq
->last_avail_idx
;
359 int virtio_queue_empty(VirtQueue
*vq
)
363 if (unlikely(!vq
->vring
.avail
)) {
367 if (vq
->shadow_avail_idx
!= vq
->last_avail_idx
) {
372 empty
= vring_avail_idx(vq
) == vq
->last_avail_idx
;
377 static void virtqueue_unmap_sg(VirtQueue
*vq
, const VirtQueueElement
*elem
,
380 AddressSpace
*dma_as
= vq
->vdev
->dma_as
;
385 for (i
= 0; i
< elem
->in_num
; i
++) {
386 size_t size
= MIN(len
- offset
, elem
->in_sg
[i
].iov_len
);
388 dma_memory_unmap(dma_as
, elem
->in_sg
[i
].iov_base
,
389 elem
->in_sg
[i
].iov_len
,
390 DMA_DIRECTION_FROM_DEVICE
, size
);
395 for (i
= 0; i
< elem
->out_num
; i
++)
396 dma_memory_unmap(dma_as
, elem
->out_sg
[i
].iov_base
,
397 elem
->out_sg
[i
].iov_len
,
398 DMA_DIRECTION_TO_DEVICE
,
399 elem
->out_sg
[i
].iov_len
);
402 /* virtqueue_detach_element:
403 * @vq: The #VirtQueue
404 * @elem: The #VirtQueueElement
405 * @len: number of bytes written
407 * Detach the element from the virtqueue. This function is suitable for device
408 * reset or other situations where a #VirtQueueElement is simply freed and will
409 * not be pushed or discarded.
411 void virtqueue_detach_element(VirtQueue
*vq
, const VirtQueueElement
*elem
,
415 virtqueue_unmap_sg(vq
, elem
, len
);
419 * @vq: The #VirtQueue
420 * @elem: The #VirtQueueElement
421 * @len: number of bytes written
423 * Pretend the most recent element wasn't popped from the virtqueue. The next
424 * call to virtqueue_pop() will refetch the element.
426 void virtqueue_unpop(VirtQueue
*vq
, const VirtQueueElement
*elem
,
429 vq
->last_avail_idx
--;
430 virtqueue_detach_element(vq
, elem
, len
);
434 * @vq: The #VirtQueue
435 * @num: Number of elements to push back
437 * Pretend that elements weren't popped from the virtqueue. The next
438 * virtqueue_pop() will refetch the oldest element.
440 * Use virtqueue_unpop() instead if you have a VirtQueueElement.
442 * Returns: true on success, false if @num is greater than the number of in use
445 bool virtqueue_rewind(VirtQueue
*vq
, unsigned int num
)
447 if (num
> vq
->inuse
) {
450 vq
->last_avail_idx
-= num
;
455 /* Called within rcu_read_lock(). */
456 void virtqueue_fill(VirtQueue
*vq
, const VirtQueueElement
*elem
,
457 unsigned int len
, unsigned int idx
)
461 trace_virtqueue_fill(vq
, elem
, len
, idx
);
463 virtqueue_unmap_sg(vq
, elem
, len
);
465 if (unlikely(vq
->vdev
->broken
)) {
469 if (unlikely(!vq
->vring
.used
)) {
473 idx
= (idx
+ vq
->used_idx
) % vq
->vring
.num
;
475 uelem
.id
= elem
->index
;
477 vring_used_write(vq
, &uelem
, idx
);
480 /* Called within rcu_read_lock(). */
481 void virtqueue_flush(VirtQueue
*vq
, unsigned int count
)
485 if (unlikely(vq
->vdev
->broken
)) {
490 if (unlikely(!vq
->vring
.used
)) {
494 /* Make sure buffer is written before we update index. */
496 trace_virtqueue_flush(vq
, count
);
499 vring_used_idx_set(vq
, new);
501 if (unlikely((int16_t)(new - vq
->signalled_used
) < (uint16_t)(new - old
)))
502 vq
->signalled_used_valid
= false;
505 void virtqueue_push(VirtQueue
*vq
, const VirtQueueElement
*elem
,
509 virtqueue_fill(vq
, elem
, len
, 0);
510 virtqueue_flush(vq
, 1);
514 /* Called within rcu_read_lock(). */
515 static int virtqueue_num_heads(VirtQueue
*vq
, unsigned int idx
)
517 uint16_t num_heads
= vring_avail_idx(vq
) - idx
;
519 /* Check it isn't doing very strange things with descriptor numbers. */
520 if (num_heads
> vq
->vring
.num
) {
521 virtio_error(vq
->vdev
, "Guest moved used index from %u to %u",
522 idx
, vq
->shadow_avail_idx
);
525 /* On success, callers read a descriptor at vq->last_avail_idx.
526 * Make sure descriptor read does not bypass avail index read. */
534 /* Called within rcu_read_lock(). */
535 static bool virtqueue_get_head(VirtQueue
*vq
, unsigned int idx
,
538 /* Grab the next descriptor number they're advertising, and increment
539 * the index we've seen. */
540 *head
= vring_avail_ring(vq
, idx
% vq
->vring
.num
);
542 /* If their number is silly, that's a fatal mistake. */
543 if (*head
>= vq
->vring
.num
) {
544 virtio_error(vq
->vdev
, "Guest says index %u is available", *head
);
552 VIRTQUEUE_READ_DESC_ERROR
= -1,
553 VIRTQUEUE_READ_DESC_DONE
= 0, /* end of chain */
554 VIRTQUEUE_READ_DESC_MORE
= 1, /* more buffers in chain */
557 static int virtqueue_read_next_desc(VirtIODevice
*vdev
, VRingDesc
*desc
,
558 MemoryRegionCache
*desc_cache
, unsigned int max
,
561 /* If this descriptor says it doesn't chain, we're done. */
562 if (!(desc
->flags
& VRING_DESC_F_NEXT
)) {
563 return VIRTQUEUE_READ_DESC_DONE
;
566 /* Check they're not leading us off end of descriptors. */
568 /* Make sure compiler knows to grab that: we don't want it changing! */
572 virtio_error(vdev
, "Desc next is %u", *next
);
573 return VIRTQUEUE_READ_DESC_ERROR
;
576 vring_desc_read(vdev
, desc
, desc_cache
, *next
);
577 return VIRTQUEUE_READ_DESC_MORE
;
580 void virtqueue_get_avail_bytes(VirtQueue
*vq
, unsigned int *in_bytes
,
581 unsigned int *out_bytes
,
582 unsigned max_in_bytes
, unsigned max_out_bytes
)
584 VirtIODevice
*vdev
= vq
->vdev
;
585 unsigned int max
, idx
;
586 unsigned int total_bufs
, in_total
, out_total
;
587 VRingMemoryRegionCaches
*caches
;
588 MemoryRegionCache indirect_desc_cache
= MEMORY_REGION_CACHE_INVALID
;
592 if (unlikely(!vq
->vring
.desc
)) {
603 idx
= vq
->last_avail_idx
;
604 total_bufs
= in_total
= out_total
= 0;
607 caches
= vring_get_region_caches(vq
);
608 if (caches
->desc
.len
< max
* sizeof(VRingDesc
)) {
609 virtio_error(vdev
, "Cannot map descriptor ring");
613 while ((rc
= virtqueue_num_heads(vq
, idx
)) > 0) {
614 MemoryRegionCache
*desc_cache
= &caches
->desc
;
615 unsigned int num_bufs
;
619 num_bufs
= total_bufs
;
621 if (!virtqueue_get_head(vq
, idx
++, &i
)) {
625 vring_desc_read(vdev
, &desc
, desc_cache
, i
);
627 if (desc
.flags
& VRING_DESC_F_INDIRECT
) {
628 if (desc
.len
% sizeof(VRingDesc
)) {
629 virtio_error(vdev
, "Invalid size for indirect buffer table");
633 /* If we've got too many, that implies a descriptor loop. */
634 if (num_bufs
>= max
) {
635 virtio_error(vdev
, "Looped descriptor");
639 /* loop over the indirect descriptor table */
640 len
= address_space_cache_init(&indirect_desc_cache
,
642 desc
.addr
, desc
.len
, false);
643 desc_cache
= &indirect_desc_cache
;
644 if (len
< desc
.len
) {
645 virtio_error(vdev
, "Cannot map indirect buffer");
649 max
= desc
.len
/ sizeof(VRingDesc
);
651 vring_desc_read(vdev
, &desc
, desc_cache
, i
);
655 /* If we've got too many, that implies a descriptor loop. */
656 if (++num_bufs
> max
) {
657 virtio_error(vdev
, "Looped descriptor");
661 if (desc
.flags
& VRING_DESC_F_WRITE
) {
662 in_total
+= desc
.len
;
664 out_total
+= desc
.len
;
666 if (in_total
>= max_in_bytes
&& out_total
>= max_out_bytes
) {
670 rc
= virtqueue_read_next_desc(vdev
, &desc
, desc_cache
, max
, &i
);
671 } while (rc
== VIRTQUEUE_READ_DESC_MORE
);
673 if (rc
== VIRTQUEUE_READ_DESC_ERROR
) {
677 if (desc_cache
== &indirect_desc_cache
) {
678 address_space_cache_destroy(&indirect_desc_cache
);
681 total_bufs
= num_bufs
;
690 address_space_cache_destroy(&indirect_desc_cache
);
692 *in_bytes
= in_total
;
695 *out_bytes
= out_total
;
701 in_total
= out_total
= 0;
705 int virtqueue_avail_bytes(VirtQueue
*vq
, unsigned int in_bytes
,
706 unsigned int out_bytes
)
708 unsigned int in_total
, out_total
;
710 virtqueue_get_avail_bytes(vq
, &in_total
, &out_total
, in_bytes
, out_bytes
);
711 return in_bytes
<= in_total
&& out_bytes
<= out_total
;
714 static bool virtqueue_map_desc(VirtIODevice
*vdev
, unsigned int *p_num_sg
,
715 hwaddr
*addr
, struct iovec
*iov
,
716 unsigned int max_num_sg
, bool is_write
,
717 hwaddr pa
, size_t sz
)
720 unsigned num_sg
= *p_num_sg
;
721 assert(num_sg
<= max_num_sg
);
724 virtio_error(vdev
, "virtio: zero sized buffers are not allowed");
731 if (num_sg
== max_num_sg
) {
732 virtio_error(vdev
, "virtio: too many write descriptors in "
737 iov
[num_sg
].iov_base
= dma_memory_map(vdev
->dma_as
, pa
, &len
,
739 DMA_DIRECTION_FROM_DEVICE
:
740 DMA_DIRECTION_TO_DEVICE
);
741 if (!iov
[num_sg
].iov_base
) {
742 virtio_error(vdev
, "virtio: bogus descriptor or out of resources");
746 iov
[num_sg
].iov_len
= len
;
760 /* Only used by error code paths before we have a VirtQueueElement (therefore
761 * virtqueue_unmap_sg() can't be used). Assumes buffers weren't written to
764 static void virtqueue_undo_map_desc(unsigned int out_num
, unsigned int in_num
,
769 for (i
= 0; i
< out_num
+ in_num
; i
++) {
770 int is_write
= i
>= out_num
;
772 cpu_physical_memory_unmap(iov
->iov_base
, iov
->iov_len
, is_write
, 0);
777 static void virtqueue_map_iovec(VirtIODevice
*vdev
, struct iovec
*sg
,
778 hwaddr
*addr
, unsigned int *num_sg
,
784 for (i
= 0; i
< *num_sg
; i
++) {
786 sg
[i
].iov_base
= dma_memory_map(vdev
->dma_as
,
787 addr
[i
], &len
, is_write
?
788 DMA_DIRECTION_FROM_DEVICE
:
789 DMA_DIRECTION_TO_DEVICE
);
790 if (!sg
[i
].iov_base
) {
791 error_report("virtio: error trying to map MMIO memory");
794 if (len
!= sg
[i
].iov_len
) {
795 error_report("virtio: unexpected memory split");
801 void virtqueue_map(VirtIODevice
*vdev
, VirtQueueElement
*elem
)
803 virtqueue_map_iovec(vdev
, elem
->in_sg
, elem
->in_addr
, &elem
->in_num
, 1);
804 virtqueue_map_iovec(vdev
, elem
->out_sg
, elem
->out_addr
, &elem
->out_num
, 0);
807 static void *virtqueue_alloc_element(size_t sz
, unsigned out_num
, unsigned in_num
)
809 VirtQueueElement
*elem
;
810 size_t in_addr_ofs
= QEMU_ALIGN_UP(sz
, __alignof__(elem
->in_addr
[0]));
811 size_t out_addr_ofs
= in_addr_ofs
+ in_num
* sizeof(elem
->in_addr
[0]);
812 size_t out_addr_end
= out_addr_ofs
+ out_num
* sizeof(elem
->out_addr
[0]);
813 size_t in_sg_ofs
= QEMU_ALIGN_UP(out_addr_end
, __alignof__(elem
->in_sg
[0]));
814 size_t out_sg_ofs
= in_sg_ofs
+ in_num
* sizeof(elem
->in_sg
[0]);
815 size_t out_sg_end
= out_sg_ofs
+ out_num
* sizeof(elem
->out_sg
[0]);
817 assert(sz
>= sizeof(VirtQueueElement
));
818 elem
= g_malloc(out_sg_end
);
819 elem
->out_num
= out_num
;
820 elem
->in_num
= in_num
;
821 elem
->in_addr
= (void *)elem
+ in_addr_ofs
;
822 elem
->out_addr
= (void *)elem
+ out_addr_ofs
;
823 elem
->in_sg
= (void *)elem
+ in_sg_ofs
;
824 elem
->out_sg
= (void *)elem
+ out_sg_ofs
;
828 void *virtqueue_pop(VirtQueue
*vq
, size_t sz
)
830 unsigned int i
, head
, max
;
831 VRingMemoryRegionCaches
*caches
;
832 MemoryRegionCache indirect_desc_cache
= MEMORY_REGION_CACHE_INVALID
;
833 MemoryRegionCache
*desc_cache
;
835 VirtIODevice
*vdev
= vq
->vdev
;
836 VirtQueueElement
*elem
= NULL
;
837 unsigned out_num
, in_num
;
838 hwaddr addr
[VIRTQUEUE_MAX_SIZE
];
839 struct iovec iov
[VIRTQUEUE_MAX_SIZE
];
843 if (unlikely(vdev
->broken
)) {
847 if (virtio_queue_empty_rcu(vq
)) {
850 /* Needed after virtio_queue_empty(), see comment in
851 * virtqueue_num_heads(). */
854 /* When we start there are none of either input nor output. */
855 out_num
= in_num
= 0;
859 if (vq
->inuse
>= vq
->vring
.num
) {
860 virtio_error(vdev
, "Virtqueue size exceeded");
864 if (!virtqueue_get_head(vq
, vq
->last_avail_idx
++, &head
)) {
868 if (virtio_vdev_has_feature(vdev
, VIRTIO_RING_F_EVENT_IDX
)) {
869 vring_set_avail_event(vq
, vq
->last_avail_idx
);
874 caches
= vring_get_region_caches(vq
);
875 if (caches
->desc
.len
< max
* sizeof(VRingDesc
)) {
876 virtio_error(vdev
, "Cannot map descriptor ring");
880 desc_cache
= &caches
->desc
;
881 vring_desc_read(vdev
, &desc
, desc_cache
, i
);
882 if (desc
.flags
& VRING_DESC_F_INDIRECT
) {
883 if (desc
.len
% sizeof(VRingDesc
)) {
884 virtio_error(vdev
, "Invalid size for indirect buffer table");
888 /* loop over the indirect descriptor table */
889 len
= address_space_cache_init(&indirect_desc_cache
, vdev
->dma_as
,
890 desc
.addr
, desc
.len
, false);
891 desc_cache
= &indirect_desc_cache
;
892 if (len
< desc
.len
) {
893 virtio_error(vdev
, "Cannot map indirect buffer");
897 max
= desc
.len
/ sizeof(VRingDesc
);
899 vring_desc_read(vdev
, &desc
, desc_cache
, i
);
902 /* Collect all the descriptors */
906 if (desc
.flags
& VRING_DESC_F_WRITE
) {
907 map_ok
= virtqueue_map_desc(vdev
, &in_num
, addr
+ out_num
,
909 VIRTQUEUE_MAX_SIZE
- out_num
, true,
910 desc
.addr
, desc
.len
);
913 virtio_error(vdev
, "Incorrect order for descriptors");
916 map_ok
= virtqueue_map_desc(vdev
, &out_num
, addr
, iov
,
917 VIRTQUEUE_MAX_SIZE
, false,
918 desc
.addr
, desc
.len
);
924 /* If we've got too many, that implies a descriptor loop. */
925 if ((in_num
+ out_num
) > max
) {
926 virtio_error(vdev
, "Looped descriptor");
930 rc
= virtqueue_read_next_desc(vdev
, &desc
, desc_cache
, max
, &i
);
931 } while (rc
== VIRTQUEUE_READ_DESC_MORE
);
933 if (rc
== VIRTQUEUE_READ_DESC_ERROR
) {
937 /* Now copy what we have collected and mapped */
938 elem
= virtqueue_alloc_element(sz
, out_num
, in_num
);
940 for (i
= 0; i
< out_num
; i
++) {
941 elem
->out_addr
[i
] = addr
[i
];
942 elem
->out_sg
[i
] = iov
[i
];
944 for (i
= 0; i
< in_num
; i
++) {
945 elem
->in_addr
[i
] = addr
[out_num
+ i
];
946 elem
->in_sg
[i
] = iov
[out_num
+ i
];
951 trace_virtqueue_pop(vq
, elem
, elem
->in_num
, elem
->out_num
);
953 address_space_cache_destroy(&indirect_desc_cache
);
959 virtqueue_undo_map_desc(out_num
, in_num
, iov
);
963 /* virtqueue_drop_all:
964 * @vq: The #VirtQueue
965 * Drops all queued buffers and indicates them to the guest
966 * as if they are done. Useful when buffers can not be
967 * processed but must be returned to the guest.
969 unsigned int virtqueue_drop_all(VirtQueue
*vq
)
971 unsigned int dropped
= 0;
972 VirtQueueElement elem
= {};
973 VirtIODevice
*vdev
= vq
->vdev
;
974 bool fEventIdx
= virtio_vdev_has_feature(vdev
, VIRTIO_RING_F_EVENT_IDX
);
976 if (unlikely(vdev
->broken
)) {
980 while (!virtio_queue_empty(vq
) && vq
->inuse
< vq
->vring
.num
) {
981 /* works similar to virtqueue_pop but does not map buffers
982 * and does not allocate any memory */
984 if (!virtqueue_get_head(vq
, vq
->last_avail_idx
, &elem
.index
)) {
988 vq
->last_avail_idx
++;
990 vring_set_avail_event(vq
, vq
->last_avail_idx
);
992 /* immediately push the element, nothing to unmap
993 * as both in_num and out_num are set to 0 */
994 virtqueue_push(vq
, &elem
, 0);
1001 /* Reading and writing a structure directly to QEMUFile is *awful*, but
1002 * it is what QEMU has always done by mistake. We can change it sooner
1003 * or later by bumping the version number of the affected vm states.
1004 * In the meanwhile, since the in-memory layout of VirtQueueElement
1005 * has changed, we need to marshal to and from the layout that was
1006 * used before the change.
1008 typedef struct VirtQueueElementOld
{
1010 unsigned int out_num
;
1011 unsigned int in_num
;
1012 hwaddr in_addr
[VIRTQUEUE_MAX_SIZE
];
1013 hwaddr out_addr
[VIRTQUEUE_MAX_SIZE
];
1014 struct iovec in_sg
[VIRTQUEUE_MAX_SIZE
];
1015 struct iovec out_sg
[VIRTQUEUE_MAX_SIZE
];
1016 } VirtQueueElementOld
;
1018 void *qemu_get_virtqueue_element(VirtIODevice
*vdev
, QEMUFile
*f
, size_t sz
)
1020 VirtQueueElement
*elem
;
1021 VirtQueueElementOld data
;
1024 qemu_get_buffer(f
, (uint8_t *)&data
, sizeof(VirtQueueElementOld
));
1026 /* TODO: teach all callers that this can fail, and return failure instead
1027 * of asserting here.
1028 * When we do, we might be able to re-enable NDEBUG below.
1031 #error building with NDEBUG is not supported
1033 assert(ARRAY_SIZE(data
.in_addr
) >= data
.in_num
);
1034 assert(ARRAY_SIZE(data
.out_addr
) >= data
.out_num
);
1036 elem
= virtqueue_alloc_element(sz
, data
.out_num
, data
.in_num
);
1037 elem
->index
= data
.index
;
1039 for (i
= 0; i
< elem
->in_num
; i
++) {
1040 elem
->in_addr
[i
] = data
.in_addr
[i
];
1043 for (i
= 0; i
< elem
->out_num
; i
++) {
1044 elem
->out_addr
[i
] = data
.out_addr
[i
];
1047 for (i
= 0; i
< elem
->in_num
; i
++) {
1048 /* Base is overwritten by virtqueue_map. */
1049 elem
->in_sg
[i
].iov_base
= 0;
1050 elem
->in_sg
[i
].iov_len
= data
.in_sg
[i
].iov_len
;
1053 for (i
= 0; i
< elem
->out_num
; i
++) {
1054 /* Base is overwritten by virtqueue_map. */
1055 elem
->out_sg
[i
].iov_base
= 0;
1056 elem
->out_sg
[i
].iov_len
= data
.out_sg
[i
].iov_len
;
1059 virtqueue_map(vdev
, elem
);
1063 void qemu_put_virtqueue_element(QEMUFile
*f
, VirtQueueElement
*elem
)
1065 VirtQueueElementOld data
;
1068 memset(&data
, 0, sizeof(data
));
1069 data
.index
= elem
->index
;
1070 data
.in_num
= elem
->in_num
;
1071 data
.out_num
= elem
->out_num
;
1073 for (i
= 0; i
< elem
->in_num
; i
++) {
1074 data
.in_addr
[i
] = elem
->in_addr
[i
];
1077 for (i
= 0; i
< elem
->out_num
; i
++) {
1078 data
.out_addr
[i
] = elem
->out_addr
[i
];
1081 for (i
= 0; i
< elem
->in_num
; i
++) {
1082 /* Base is overwritten by virtqueue_map when loading. Do not
1083 * save it, as it would leak the QEMU address space layout. */
1084 data
.in_sg
[i
].iov_len
= elem
->in_sg
[i
].iov_len
;
1087 for (i
= 0; i
< elem
->out_num
; i
++) {
1088 /* Do not save iov_base as above. */
1089 data
.out_sg
[i
].iov_len
= elem
->out_sg
[i
].iov_len
;
1091 qemu_put_buffer(f
, (uint8_t *)&data
, sizeof(VirtQueueElementOld
));
1095 static void virtio_notify_vector(VirtIODevice
*vdev
, uint16_t vector
)
1097 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
1098 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
1100 if (unlikely(vdev
->broken
)) {
1105 k
->notify(qbus
->parent
, vector
);
1109 void virtio_update_irq(VirtIODevice
*vdev
)
1111 virtio_notify_vector(vdev
, VIRTIO_NO_VECTOR
);
1114 static int virtio_validate_features(VirtIODevice
*vdev
)
1116 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1118 if (virtio_host_has_feature(vdev
, VIRTIO_F_IOMMU_PLATFORM
) &&
1119 !virtio_vdev_has_feature(vdev
, VIRTIO_F_IOMMU_PLATFORM
)) {
1123 if (k
->validate_features
) {
1124 return k
->validate_features(vdev
);
1130 int virtio_set_status(VirtIODevice
*vdev
, uint8_t val
)
1132 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1133 trace_virtio_set_status(vdev
, val
);
1135 if (virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
1136 if (!(vdev
->status
& VIRTIO_CONFIG_S_FEATURES_OK
) &&
1137 val
& VIRTIO_CONFIG_S_FEATURES_OK
) {
1138 int ret
= virtio_validate_features(vdev
);
1145 if (k
->set_status
) {
1146 k
->set_status(vdev
, val
);
1152 bool target_words_bigendian(void);
1153 static enum virtio_device_endian
virtio_default_endian(void)
1155 if (target_words_bigendian()) {
1156 return VIRTIO_DEVICE_ENDIAN_BIG
;
1158 return VIRTIO_DEVICE_ENDIAN_LITTLE
;
1162 static enum virtio_device_endian
virtio_current_cpu_endian(void)
1164 CPUClass
*cc
= CPU_GET_CLASS(current_cpu
);
1166 if (cc
->virtio_is_big_endian(current_cpu
)) {
1167 return VIRTIO_DEVICE_ENDIAN_BIG
;
1169 return VIRTIO_DEVICE_ENDIAN_LITTLE
;
1173 static void virtio_virtqueue_reset_region_cache(struct VirtQueue
*vq
)
1175 VRingMemoryRegionCaches
*caches
;
1177 caches
= atomic_read(&vq
->vring
.caches
);
1178 atomic_rcu_set(&vq
->vring
.caches
, NULL
);
1180 call_rcu(caches
, virtio_free_region_cache
, rcu
);
1184 void virtio_reset(void *opaque
)
1186 VirtIODevice
*vdev
= opaque
;
1187 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1190 virtio_set_status(vdev
, 0);
1192 /* Guest initiated reset */
1193 vdev
->device_endian
= virtio_current_cpu_endian();
1196 vdev
->device_endian
= virtio_default_endian();
1203 vdev
->broken
= false;
1204 vdev
->guest_features
= 0;
1205 vdev
->queue_sel
= 0;
1207 atomic_set(&vdev
->isr
, 0);
1208 vdev
->config_vector
= VIRTIO_NO_VECTOR
;
1209 virtio_notify_vector(vdev
, vdev
->config_vector
);
1211 for(i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1212 vdev
->vq
[i
].vring
.desc
= 0;
1213 vdev
->vq
[i
].vring
.avail
= 0;
1214 vdev
->vq
[i
].vring
.used
= 0;
1215 vdev
->vq
[i
].last_avail_idx
= 0;
1216 vdev
->vq
[i
].shadow_avail_idx
= 0;
1217 vdev
->vq
[i
].used_idx
= 0;
1218 virtio_queue_set_vector(vdev
, i
, VIRTIO_NO_VECTOR
);
1219 vdev
->vq
[i
].signalled_used
= 0;
1220 vdev
->vq
[i
].signalled_used_valid
= false;
1221 vdev
->vq
[i
].notification
= true;
1222 vdev
->vq
[i
].vring
.num
= vdev
->vq
[i
].vring
.num_default
;
1223 vdev
->vq
[i
].inuse
= 0;
1224 virtio_virtqueue_reset_region_cache(&vdev
->vq
[i
]);
1228 uint32_t virtio_config_readb(VirtIODevice
*vdev
, uint32_t addr
)
1230 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1233 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1234 return (uint32_t)-1;
1237 k
->get_config(vdev
, vdev
->config
);
1239 val
= ldub_p(vdev
->config
+ addr
);
1243 uint32_t virtio_config_readw(VirtIODevice
*vdev
, uint32_t addr
)
1245 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1248 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1249 return (uint32_t)-1;
1252 k
->get_config(vdev
, vdev
->config
);
1254 val
= lduw_p(vdev
->config
+ addr
);
1258 uint32_t virtio_config_readl(VirtIODevice
*vdev
, uint32_t addr
)
1260 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1263 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1264 return (uint32_t)-1;
1267 k
->get_config(vdev
, vdev
->config
);
1269 val
= ldl_p(vdev
->config
+ addr
);
1273 void virtio_config_writeb(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
)
1275 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1278 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1282 stb_p(vdev
->config
+ addr
, val
);
1284 if (k
->set_config
) {
1285 k
->set_config(vdev
, vdev
->config
);
1289 void virtio_config_writew(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
)
1291 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1292 uint16_t val
= data
;
1294 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1298 stw_p(vdev
->config
+ addr
, val
);
1300 if (k
->set_config
) {
1301 k
->set_config(vdev
, vdev
->config
);
1305 void virtio_config_writel(VirtIODevice
*vdev
, uint32_t addr
, uint32_t data
)
1307 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1308 uint32_t val
= data
;
1310 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1314 stl_p(vdev
->config
+ addr
, val
);
1316 if (k
->set_config
) {
1317 k
->set_config(vdev
, vdev
->config
);
1321 uint32_t virtio_config_modern_readb(VirtIODevice
*vdev
, uint32_t addr
)
1323 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1326 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1327 return (uint32_t)-1;
1330 k
->get_config(vdev
, vdev
->config
);
1332 val
= ldub_p(vdev
->config
+ addr
);
1336 uint32_t virtio_config_modern_readw(VirtIODevice
*vdev
, uint32_t addr
)
1338 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1341 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1342 return (uint32_t)-1;
1345 k
->get_config(vdev
, vdev
->config
);
1347 val
= lduw_le_p(vdev
->config
+ addr
);
1351 uint32_t virtio_config_modern_readl(VirtIODevice
*vdev
, uint32_t addr
)
1353 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1356 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1357 return (uint32_t)-1;
1360 k
->get_config(vdev
, vdev
->config
);
1362 val
= ldl_le_p(vdev
->config
+ addr
);
1366 void virtio_config_modern_writeb(VirtIODevice
*vdev
,
1367 uint32_t addr
, uint32_t data
)
1369 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1372 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1376 stb_p(vdev
->config
+ addr
, val
);
1378 if (k
->set_config
) {
1379 k
->set_config(vdev
, vdev
->config
);
1383 void virtio_config_modern_writew(VirtIODevice
*vdev
,
1384 uint32_t addr
, uint32_t data
)
1386 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1387 uint16_t val
= data
;
1389 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1393 stw_le_p(vdev
->config
+ addr
, val
);
1395 if (k
->set_config
) {
1396 k
->set_config(vdev
, vdev
->config
);
1400 void virtio_config_modern_writel(VirtIODevice
*vdev
,
1401 uint32_t addr
, uint32_t data
)
1403 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1404 uint32_t val
= data
;
1406 if (addr
+ sizeof(val
) > vdev
->config_len
) {
1410 stl_le_p(vdev
->config
+ addr
, val
);
1412 if (k
->set_config
) {
1413 k
->set_config(vdev
, vdev
->config
);
1417 void virtio_queue_set_addr(VirtIODevice
*vdev
, int n
, hwaddr addr
)
1419 vdev
->vq
[n
].vring
.desc
= addr
;
1420 virtio_queue_update_rings(vdev
, n
);
1423 hwaddr
virtio_queue_get_addr(VirtIODevice
*vdev
, int n
)
1425 return vdev
->vq
[n
].vring
.desc
;
1428 void virtio_queue_set_rings(VirtIODevice
*vdev
, int n
, hwaddr desc
,
1429 hwaddr avail
, hwaddr used
)
1431 vdev
->vq
[n
].vring
.desc
= desc
;
1432 vdev
->vq
[n
].vring
.avail
= avail
;
1433 vdev
->vq
[n
].vring
.used
= used
;
1434 virtio_init_region_cache(vdev
, n
);
1437 void virtio_queue_set_num(VirtIODevice
*vdev
, int n
, int num
)
1439 /* Don't allow guest to flip queue between existent and
1440 * nonexistent states, or to set it to an invalid size.
1442 if (!!num
!= !!vdev
->vq
[n
].vring
.num
||
1443 num
> VIRTQUEUE_MAX_SIZE
||
1447 vdev
->vq
[n
].vring
.num
= num
;
1450 VirtQueue
*virtio_vector_first_queue(VirtIODevice
*vdev
, uint16_t vector
)
1452 return QLIST_FIRST(&vdev
->vector_queues
[vector
]);
1455 VirtQueue
*virtio_vector_next_queue(VirtQueue
*vq
)
1457 return QLIST_NEXT(vq
, node
);
1460 int virtio_queue_get_num(VirtIODevice
*vdev
, int n
)
1462 return vdev
->vq
[n
].vring
.num
;
1465 int virtio_queue_get_max_num(VirtIODevice
*vdev
, int n
)
1467 return vdev
->vq
[n
].vring
.num_default
;
1470 int virtio_get_num_queues(VirtIODevice
*vdev
)
1474 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1475 if (!virtio_queue_get_num(vdev
, i
)) {
1483 void virtio_queue_set_align(VirtIODevice
*vdev
, int n
, int align
)
1485 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
1486 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
1488 /* virtio-1 compliant devices cannot change the alignment */
1489 if (virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
1490 error_report("tried to modify queue alignment for virtio-1 device");
1493 /* Check that the transport told us it was going to do this
1494 * (so a buggy transport will immediately assert rather than
1495 * silently failing to migrate this state)
1497 assert(k
->has_variable_vring_alignment
);
1499 vdev
->vq
[n
].vring
.align
= align
;
1500 virtio_queue_update_rings(vdev
, n
);
1503 static bool virtio_queue_notify_aio_vq(VirtQueue
*vq
)
1505 if (vq
->vring
.desc
&& vq
->handle_aio_output
) {
1506 VirtIODevice
*vdev
= vq
->vdev
;
1508 trace_virtio_queue_notify(vdev
, vq
- vdev
->vq
, vq
);
1509 return vq
->handle_aio_output(vdev
, vq
);
1515 static void virtio_queue_notify_vq(VirtQueue
*vq
)
1517 if (vq
->vring
.desc
&& vq
->handle_output
) {
1518 VirtIODevice
*vdev
= vq
->vdev
;
1520 if (unlikely(vdev
->broken
)) {
1524 trace_virtio_queue_notify(vdev
, vq
- vdev
->vq
, vq
);
1525 vq
->handle_output(vdev
, vq
);
1529 void virtio_queue_notify(VirtIODevice
*vdev
, int n
)
1531 virtio_queue_notify_vq(&vdev
->vq
[n
]);
1534 uint16_t virtio_queue_vector(VirtIODevice
*vdev
, int n
)
1536 return n
< VIRTIO_QUEUE_MAX
? vdev
->vq
[n
].vector
:
1540 void virtio_queue_set_vector(VirtIODevice
*vdev
, int n
, uint16_t vector
)
1542 VirtQueue
*vq
= &vdev
->vq
[n
];
1544 if (n
< VIRTIO_QUEUE_MAX
) {
1545 if (vdev
->vector_queues
&&
1546 vdev
->vq
[n
].vector
!= VIRTIO_NO_VECTOR
) {
1547 QLIST_REMOVE(vq
, node
);
1549 vdev
->vq
[n
].vector
= vector
;
1550 if (vdev
->vector_queues
&&
1551 vector
!= VIRTIO_NO_VECTOR
) {
1552 QLIST_INSERT_HEAD(&vdev
->vector_queues
[vector
], vq
, node
);
1557 VirtQueue
*virtio_add_queue(VirtIODevice
*vdev
, int queue_size
,
1558 VirtIOHandleOutput handle_output
)
1562 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1563 if (vdev
->vq
[i
].vring
.num
== 0)
1567 if (i
== VIRTIO_QUEUE_MAX
|| queue_size
> VIRTQUEUE_MAX_SIZE
)
1570 vdev
->vq
[i
].vring
.num
= queue_size
;
1571 vdev
->vq
[i
].vring
.num_default
= queue_size
;
1572 vdev
->vq
[i
].vring
.align
= VIRTIO_PCI_VRING_ALIGN
;
1573 vdev
->vq
[i
].handle_output
= handle_output
;
1574 vdev
->vq
[i
].handle_aio_output
= NULL
;
1576 return &vdev
->vq
[i
];
1579 void virtio_del_queue(VirtIODevice
*vdev
, int n
)
1581 if (n
< 0 || n
>= VIRTIO_QUEUE_MAX
) {
1585 vdev
->vq
[n
].vring
.num
= 0;
1586 vdev
->vq
[n
].vring
.num_default
= 0;
1589 static void virtio_set_isr(VirtIODevice
*vdev
, int value
)
1591 uint8_t old
= atomic_read(&vdev
->isr
);
1593 /* Do not write ISR if it does not change, so that its cacheline remains
1594 * shared in the common case where the guest does not read it.
1596 if ((old
& value
) != value
) {
1597 atomic_or(&vdev
->isr
, value
);
1601 /* Called within rcu_read_lock(). */
1602 static bool virtio_should_notify(VirtIODevice
*vdev
, VirtQueue
*vq
)
1606 /* We need to expose used array entries before checking used event. */
1608 /* Always notify when queue is empty (when feature acknowledge) */
1609 if (virtio_vdev_has_feature(vdev
, VIRTIO_F_NOTIFY_ON_EMPTY
) &&
1610 !vq
->inuse
&& virtio_queue_empty(vq
)) {
1614 if (!virtio_vdev_has_feature(vdev
, VIRTIO_RING_F_EVENT_IDX
)) {
1615 return !(vring_avail_flags(vq
) & VRING_AVAIL_F_NO_INTERRUPT
);
1618 v
= vq
->signalled_used_valid
;
1619 vq
->signalled_used_valid
= true;
1620 old
= vq
->signalled_used
;
1621 new = vq
->signalled_used
= vq
->used_idx
;
1622 return !v
|| vring_need_event(vring_get_used_event(vq
), new, old
);
1625 void virtio_notify_irqfd(VirtIODevice
*vdev
, VirtQueue
*vq
)
1629 should_notify
= virtio_should_notify(vdev
, vq
);
1632 if (!should_notify
) {
1636 trace_virtio_notify_irqfd(vdev
, vq
);
1639 * virtio spec 1.0 says ISR bit 0 should be ignored with MSI, but
1640 * windows drivers included in virtio-win 1.8.0 (circa 2015) are
1641 * incorrectly polling this bit during crashdump and hibernation
1642 * in MSI mode, causing a hang if this bit is never updated.
1643 * Recent releases of Windows do not really shut down, but rather
1644 * log out and hibernate to make the next startup faster. Hence,
1645 * this manifested as a more serious hang during shutdown with
1647 * Next driver release from 2016 fixed this problem, so working around it
1648 * is not a must, but it's easy to do so let's do it here.
1650 * Note: it's safe to update ISR from any thread as it was switched
1651 * to an atomic operation.
1653 virtio_set_isr(vq
->vdev
, 0x1);
1654 event_notifier_set(&vq
->guest_notifier
);
1657 static void virtio_irq(VirtQueue
*vq
)
1659 virtio_set_isr(vq
->vdev
, 0x1);
1660 virtio_notify_vector(vq
->vdev
, vq
->vector
);
1663 void virtio_notify(VirtIODevice
*vdev
, VirtQueue
*vq
)
1667 should_notify
= virtio_should_notify(vdev
, vq
);
1670 if (!should_notify
) {
1674 trace_virtio_notify(vdev
, vq
);
1678 void virtio_notify_config(VirtIODevice
*vdev
)
1680 if (!(vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
))
1683 virtio_set_isr(vdev
, 0x3);
1685 virtio_notify_vector(vdev
, vdev
->config_vector
);
1688 static bool virtio_device_endian_needed(void *opaque
)
1690 VirtIODevice
*vdev
= opaque
;
1692 assert(vdev
->device_endian
!= VIRTIO_DEVICE_ENDIAN_UNKNOWN
);
1693 if (!virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
1694 return vdev
->device_endian
!= virtio_default_endian();
1696 /* Devices conforming to VIRTIO 1.0 or later are always LE. */
1697 return vdev
->device_endian
!= VIRTIO_DEVICE_ENDIAN_LITTLE
;
1700 static bool virtio_64bit_features_needed(void *opaque
)
1702 VirtIODevice
*vdev
= opaque
;
1704 return (vdev
->host_features
>> 32) != 0;
1707 static bool virtio_virtqueue_needed(void *opaque
)
1709 VirtIODevice
*vdev
= opaque
;
1711 return virtio_host_has_feature(vdev
, VIRTIO_F_VERSION_1
);
1714 static bool virtio_ringsize_needed(void *opaque
)
1716 VirtIODevice
*vdev
= opaque
;
1719 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1720 if (vdev
->vq
[i
].vring
.num
!= vdev
->vq
[i
].vring
.num_default
) {
1727 static bool virtio_extra_state_needed(void *opaque
)
1729 VirtIODevice
*vdev
= opaque
;
1730 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
1731 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
1733 return k
->has_extra_state
&&
1734 k
->has_extra_state(qbus
->parent
);
1737 static bool virtio_broken_needed(void *opaque
)
1739 VirtIODevice
*vdev
= opaque
;
1741 return vdev
->broken
;
1744 static const VMStateDescription vmstate_virtqueue
= {
1745 .name
= "virtqueue_state",
1747 .minimum_version_id
= 1,
1748 .fields
= (VMStateField
[]) {
1749 VMSTATE_UINT64(vring
.avail
, struct VirtQueue
),
1750 VMSTATE_UINT64(vring
.used
, struct VirtQueue
),
1751 VMSTATE_END_OF_LIST()
1755 static const VMStateDescription vmstate_virtio_virtqueues
= {
1756 .name
= "virtio/virtqueues",
1758 .minimum_version_id
= 1,
1759 .needed
= &virtio_virtqueue_needed
,
1760 .fields
= (VMStateField
[]) {
1761 VMSTATE_STRUCT_VARRAY_POINTER_KNOWN(vq
, struct VirtIODevice
,
1762 VIRTIO_QUEUE_MAX
, 0, vmstate_virtqueue
, VirtQueue
),
1763 VMSTATE_END_OF_LIST()
1767 static const VMStateDescription vmstate_ringsize
= {
1768 .name
= "ringsize_state",
1770 .minimum_version_id
= 1,
1771 .fields
= (VMStateField
[]) {
1772 VMSTATE_UINT32(vring
.num_default
, struct VirtQueue
),
1773 VMSTATE_END_OF_LIST()
1777 static const VMStateDescription vmstate_virtio_ringsize
= {
1778 .name
= "virtio/ringsize",
1780 .minimum_version_id
= 1,
1781 .needed
= &virtio_ringsize_needed
,
1782 .fields
= (VMStateField
[]) {
1783 VMSTATE_STRUCT_VARRAY_POINTER_KNOWN(vq
, struct VirtIODevice
,
1784 VIRTIO_QUEUE_MAX
, 0, vmstate_ringsize
, VirtQueue
),
1785 VMSTATE_END_OF_LIST()
1789 static int get_extra_state(QEMUFile
*f
, void *pv
, size_t size
,
1790 VMStateField
*field
)
1792 VirtIODevice
*vdev
= pv
;
1793 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
1794 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
1796 if (!k
->load_extra_state
) {
1799 return k
->load_extra_state(qbus
->parent
, f
);
1803 static int put_extra_state(QEMUFile
*f
, void *pv
, size_t size
,
1804 VMStateField
*field
, QJSON
*vmdesc
)
1806 VirtIODevice
*vdev
= pv
;
1807 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
1808 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
1810 k
->save_extra_state(qbus
->parent
, f
);
1814 static const VMStateInfo vmstate_info_extra_state
= {
1815 .name
= "virtqueue_extra_state",
1816 .get
= get_extra_state
,
1817 .put
= put_extra_state
,
1820 static const VMStateDescription vmstate_virtio_extra_state
= {
1821 .name
= "virtio/extra_state",
1823 .minimum_version_id
= 1,
1824 .needed
= &virtio_extra_state_needed
,
1825 .fields
= (VMStateField
[]) {
1827 .name
= "extra_state",
1829 .field_exists
= NULL
,
1831 .info
= &vmstate_info_extra_state
,
1832 .flags
= VMS_SINGLE
,
1835 VMSTATE_END_OF_LIST()
1839 static const VMStateDescription vmstate_virtio_device_endian
= {
1840 .name
= "virtio/device_endian",
1842 .minimum_version_id
= 1,
1843 .needed
= &virtio_device_endian_needed
,
1844 .fields
= (VMStateField
[]) {
1845 VMSTATE_UINT8(device_endian
, VirtIODevice
),
1846 VMSTATE_END_OF_LIST()
1850 static const VMStateDescription vmstate_virtio_64bit_features
= {
1851 .name
= "virtio/64bit_features",
1853 .minimum_version_id
= 1,
1854 .needed
= &virtio_64bit_features_needed
,
1855 .fields
= (VMStateField
[]) {
1856 VMSTATE_UINT64(guest_features
, VirtIODevice
),
1857 VMSTATE_END_OF_LIST()
1861 static const VMStateDescription vmstate_virtio_broken
= {
1862 .name
= "virtio/broken",
1864 .minimum_version_id
= 1,
1865 .needed
= &virtio_broken_needed
,
1866 .fields
= (VMStateField
[]) {
1867 VMSTATE_BOOL(broken
, VirtIODevice
),
1868 VMSTATE_END_OF_LIST()
1872 static const VMStateDescription vmstate_virtio
= {
1875 .minimum_version_id
= 1,
1876 .minimum_version_id_old
= 1,
1877 .fields
= (VMStateField
[]) {
1878 VMSTATE_END_OF_LIST()
1880 .subsections
= (const VMStateDescription
*[]) {
1881 &vmstate_virtio_device_endian
,
1882 &vmstate_virtio_64bit_features
,
1883 &vmstate_virtio_virtqueues
,
1884 &vmstate_virtio_ringsize
,
1885 &vmstate_virtio_broken
,
1886 &vmstate_virtio_extra_state
,
1891 void virtio_save(VirtIODevice
*vdev
, QEMUFile
*f
)
1893 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
1894 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
1895 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1896 uint32_t guest_features_lo
= (vdev
->guest_features
& 0xffffffff);
1899 if (k
->save_config
) {
1900 k
->save_config(qbus
->parent
, f
);
1903 qemu_put_8s(f
, &vdev
->status
);
1904 qemu_put_8s(f
, &vdev
->isr
);
1905 qemu_put_be16s(f
, &vdev
->queue_sel
);
1906 qemu_put_be32s(f
, &guest_features_lo
);
1907 qemu_put_be32(f
, vdev
->config_len
);
1908 qemu_put_buffer(f
, vdev
->config
, vdev
->config_len
);
1910 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1911 if (vdev
->vq
[i
].vring
.num
== 0)
1915 qemu_put_be32(f
, i
);
1917 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
1918 if (vdev
->vq
[i
].vring
.num
== 0)
1921 qemu_put_be32(f
, vdev
->vq
[i
].vring
.num
);
1922 if (k
->has_variable_vring_alignment
) {
1923 qemu_put_be32(f
, vdev
->vq
[i
].vring
.align
);
1926 * Save desc now, the rest of the ring addresses are saved in
1927 * subsections for VIRTIO-1 devices.
1929 qemu_put_be64(f
, vdev
->vq
[i
].vring
.desc
);
1930 qemu_put_be16s(f
, &vdev
->vq
[i
].last_avail_idx
);
1931 if (k
->save_queue
) {
1932 k
->save_queue(qbus
->parent
, i
, f
);
1936 if (vdc
->save
!= NULL
) {
1941 vmstate_save_state(f
, vdc
->vmsd
, vdev
, NULL
);
1945 vmstate_save_state(f
, &vmstate_virtio
, vdev
, NULL
);
1948 /* A wrapper for use as a VMState .put function */
1949 static int virtio_device_put(QEMUFile
*f
, void *opaque
, size_t size
,
1950 VMStateField
*field
, QJSON
*vmdesc
)
1952 virtio_save(VIRTIO_DEVICE(opaque
), f
);
1957 /* A wrapper for use as a VMState .get function */
1958 static int virtio_device_get(QEMUFile
*f
, void *opaque
, size_t size
,
1959 VMStateField
*field
)
1961 VirtIODevice
*vdev
= VIRTIO_DEVICE(opaque
);
1962 DeviceClass
*dc
= DEVICE_CLASS(VIRTIO_DEVICE_GET_CLASS(vdev
));
1964 return virtio_load(vdev
, f
, dc
->vmsd
->version_id
);
1967 const VMStateInfo virtio_vmstate_info
= {
1969 .get
= virtio_device_get
,
1970 .put
= virtio_device_put
,
1973 static int virtio_set_features_nocheck(VirtIODevice
*vdev
, uint64_t val
)
1975 VirtioDeviceClass
*k
= VIRTIO_DEVICE_GET_CLASS(vdev
);
1976 bool bad
= (val
& ~(vdev
->host_features
)) != 0;
1978 val
&= vdev
->host_features
;
1979 if (k
->set_features
) {
1980 k
->set_features(vdev
, val
);
1982 vdev
->guest_features
= val
;
1983 return bad
? -1 : 0;
1986 int virtio_set_features(VirtIODevice
*vdev
, uint64_t val
)
1989 * The driver must not attempt to set features after feature negotiation
1992 if (vdev
->status
& VIRTIO_CONFIG_S_FEATURES_OK
) {
1995 return virtio_set_features_nocheck(vdev
, val
);
1998 int virtio_load(VirtIODevice
*vdev
, QEMUFile
*f
, int version_id
)
2004 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
2005 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
2006 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(vdev
);
2009 * We poison the endianness to ensure it does not get used before
2010 * subsections have been loaded.
2012 vdev
->device_endian
= VIRTIO_DEVICE_ENDIAN_UNKNOWN
;
2014 if (k
->load_config
) {
2015 ret
= k
->load_config(qbus
->parent
, f
);
2020 qemu_get_8s(f
, &vdev
->status
);
2021 qemu_get_8s(f
, &vdev
->isr
);
2022 qemu_get_be16s(f
, &vdev
->queue_sel
);
2023 if (vdev
->queue_sel
>= VIRTIO_QUEUE_MAX
) {
2026 qemu_get_be32s(f
, &features
);
2029 * Temporarily set guest_features low bits - needed by
2030 * virtio net load code testing for VIRTIO_NET_F_CTRL_GUEST_OFFLOADS
2031 * VIRTIO_NET_F_GUEST_ANNOUNCE and VIRTIO_NET_F_CTRL_VQ.
2033 * Note: devices should always test host features in future - don't create
2034 * new dependencies like this.
2036 vdev
->guest_features
= features
;
2038 config_len
= qemu_get_be32(f
);
2041 * There are cases where the incoming config can be bigger or smaller
2042 * than what we have; so load what we have space for, and skip
2043 * any excess that's in the stream.
2045 qemu_get_buffer(f
, vdev
->config
, MIN(config_len
, vdev
->config_len
));
2047 while (config_len
> vdev
->config_len
) {
2052 num
= qemu_get_be32(f
);
2054 if (num
> VIRTIO_QUEUE_MAX
) {
2055 error_report("Invalid number of virtqueues: 0x%x", num
);
2059 for (i
= 0; i
< num
; i
++) {
2060 vdev
->vq
[i
].vring
.num
= qemu_get_be32(f
);
2061 if (k
->has_variable_vring_alignment
) {
2062 vdev
->vq
[i
].vring
.align
= qemu_get_be32(f
);
2064 vdev
->vq
[i
].vring
.desc
= qemu_get_be64(f
);
2065 qemu_get_be16s(f
, &vdev
->vq
[i
].last_avail_idx
);
2066 vdev
->vq
[i
].signalled_used_valid
= false;
2067 vdev
->vq
[i
].notification
= true;
2069 if (!vdev
->vq
[i
].vring
.desc
&& vdev
->vq
[i
].last_avail_idx
) {
2070 error_report("VQ %d address 0x0 "
2071 "inconsistent with Host index 0x%x",
2072 i
, vdev
->vq
[i
].last_avail_idx
);
2075 if (k
->load_queue
) {
2076 ret
= k
->load_queue(qbus
->parent
, i
, f
);
2082 virtio_notify_vector(vdev
, VIRTIO_NO_VECTOR
);
2084 if (vdc
->load
!= NULL
) {
2085 ret
= vdc
->load(vdev
, f
, version_id
);
2092 ret
= vmstate_load_state(f
, vdc
->vmsd
, vdev
, version_id
);
2099 ret
= vmstate_load_state(f
, &vmstate_virtio
, vdev
, 1);
2104 if (vdev
->device_endian
== VIRTIO_DEVICE_ENDIAN_UNKNOWN
) {
2105 vdev
->device_endian
= virtio_default_endian();
2108 if (virtio_64bit_features_needed(vdev
)) {
2110 * Subsection load filled vdev->guest_features. Run them
2111 * through virtio_set_features to sanity-check them against
2114 uint64_t features64
= vdev
->guest_features
;
2115 if (virtio_set_features_nocheck(vdev
, features64
) < 0) {
2116 error_report("Features 0x%" PRIx64
" unsupported. "
2117 "Allowed features: 0x%" PRIx64
,
2118 features64
, vdev
->host_features
);
2122 if (virtio_set_features_nocheck(vdev
, features
) < 0) {
2123 error_report("Features 0x%x unsupported. "
2124 "Allowed features: 0x%" PRIx64
,
2125 features
, vdev
->host_features
);
2131 for (i
= 0; i
< num
; i
++) {
2132 if (vdev
->vq
[i
].vring
.desc
) {
2136 * VIRTIO-1 devices migrate desc, used, and avail ring addresses so
2137 * only the region cache needs to be set up. Legacy devices need
2138 * to calculate used and avail ring addresses based on the desc
2141 if (virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
2142 virtio_init_region_cache(vdev
, i
);
2144 virtio_queue_update_rings(vdev
, i
);
2147 nheads
= vring_avail_idx(&vdev
->vq
[i
]) - vdev
->vq
[i
].last_avail_idx
;
2148 /* Check it isn't doing strange things with descriptor numbers. */
2149 if (nheads
> vdev
->vq
[i
].vring
.num
) {
2150 error_report("VQ %d size 0x%x Guest index 0x%x "
2151 "inconsistent with Host index 0x%x: delta 0x%x",
2152 i
, vdev
->vq
[i
].vring
.num
,
2153 vring_avail_idx(&vdev
->vq
[i
]),
2154 vdev
->vq
[i
].last_avail_idx
, nheads
);
2157 vdev
->vq
[i
].used_idx
= vring_used_idx(&vdev
->vq
[i
]);
2158 vdev
->vq
[i
].shadow_avail_idx
= vring_avail_idx(&vdev
->vq
[i
]);
2161 * Some devices migrate VirtQueueElements that have been popped
2162 * from the avail ring but not yet returned to the used ring.
2163 * Since max ring size < UINT16_MAX it's safe to use modulo
2164 * UINT16_MAX + 1 subtraction.
2166 vdev
->vq
[i
].inuse
= (uint16_t)(vdev
->vq
[i
].last_avail_idx
-
2167 vdev
->vq
[i
].used_idx
);
2168 if (vdev
->vq
[i
].inuse
> vdev
->vq
[i
].vring
.num
) {
2169 error_report("VQ %d size 0x%x < last_avail_idx 0x%x - "
2171 i
, vdev
->vq
[i
].vring
.num
,
2172 vdev
->vq
[i
].last_avail_idx
,
2173 vdev
->vq
[i
].used_idx
);
2183 void virtio_cleanup(VirtIODevice
*vdev
)
2185 qemu_del_vm_change_state_handler(vdev
->vmstate
);
2188 static void virtio_vmstate_change(void *opaque
, int running
, RunState state
)
2190 VirtIODevice
*vdev
= opaque
;
2191 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
2192 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
2193 bool backend_run
= running
&& (vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
);
2194 vdev
->vm_running
= running
;
2197 virtio_set_status(vdev
, vdev
->status
);
2200 if (k
->vmstate_change
) {
2201 k
->vmstate_change(qbus
->parent
, backend_run
);
2205 virtio_set_status(vdev
, vdev
->status
);
2209 void virtio_instance_init_common(Object
*proxy_obj
, void *data
,
2210 size_t vdev_size
, const char *vdev_name
)
2212 DeviceState
*vdev
= data
;
2214 object_initialize(vdev
, vdev_size
, vdev_name
);
2215 object_property_add_child(proxy_obj
, "virtio-backend", OBJECT(vdev
), NULL
);
2216 object_unref(OBJECT(vdev
));
2217 qdev_alias_all_properties(vdev
, proxy_obj
);
2220 void virtio_init(VirtIODevice
*vdev
, const char *name
,
2221 uint16_t device_id
, size_t config_size
)
2223 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
2224 VirtioBusClass
*k
= VIRTIO_BUS_GET_CLASS(qbus
);
2226 int nvectors
= k
->query_nvectors
? k
->query_nvectors(qbus
->parent
) : 0;
2229 vdev
->vector_queues
=
2230 g_malloc0(sizeof(*vdev
->vector_queues
) * nvectors
);
2233 vdev
->device_id
= device_id
;
2235 atomic_set(&vdev
->isr
, 0);
2236 vdev
->queue_sel
= 0;
2237 vdev
->config_vector
= VIRTIO_NO_VECTOR
;
2238 vdev
->vq
= g_malloc0(sizeof(VirtQueue
) * VIRTIO_QUEUE_MAX
);
2239 vdev
->vm_running
= runstate_is_running();
2240 vdev
->broken
= false;
2241 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
2242 vdev
->vq
[i
].vector
= VIRTIO_NO_VECTOR
;
2243 vdev
->vq
[i
].vdev
= vdev
;
2244 vdev
->vq
[i
].queue_index
= i
;
2248 vdev
->config_len
= config_size
;
2249 if (vdev
->config_len
) {
2250 vdev
->config
= g_malloc0(config_size
);
2252 vdev
->config
= NULL
;
2254 vdev
->vmstate
= qemu_add_vm_change_state_handler(virtio_vmstate_change
,
2256 vdev
->device_endian
= virtio_default_endian();
2257 vdev
->use_guest_notifier_mask
= true;
2260 hwaddr
virtio_queue_get_desc_addr(VirtIODevice
*vdev
, int n
)
2262 return vdev
->vq
[n
].vring
.desc
;
2265 hwaddr
virtio_queue_get_avail_addr(VirtIODevice
*vdev
, int n
)
2267 return vdev
->vq
[n
].vring
.avail
;
2270 hwaddr
virtio_queue_get_used_addr(VirtIODevice
*vdev
, int n
)
2272 return vdev
->vq
[n
].vring
.used
;
2275 hwaddr
virtio_queue_get_desc_size(VirtIODevice
*vdev
, int n
)
2277 return sizeof(VRingDesc
) * vdev
->vq
[n
].vring
.num
;
2280 hwaddr
virtio_queue_get_avail_size(VirtIODevice
*vdev
, int n
)
2282 return offsetof(VRingAvail
, ring
) +
2283 sizeof(uint16_t) * vdev
->vq
[n
].vring
.num
;
2286 hwaddr
virtio_queue_get_used_size(VirtIODevice
*vdev
, int n
)
2288 return offsetof(VRingUsed
, ring
) +
2289 sizeof(VRingUsedElem
) * vdev
->vq
[n
].vring
.num
;
2292 uint16_t virtio_queue_get_last_avail_idx(VirtIODevice
*vdev
, int n
)
2294 return vdev
->vq
[n
].last_avail_idx
;
2297 void virtio_queue_set_last_avail_idx(VirtIODevice
*vdev
, int n
, uint16_t idx
)
2299 vdev
->vq
[n
].last_avail_idx
= idx
;
2300 vdev
->vq
[n
].shadow_avail_idx
= idx
;
2303 void virtio_queue_update_used_idx(VirtIODevice
*vdev
, int n
)
2306 if (vdev
->vq
[n
].vring
.desc
) {
2307 vdev
->vq
[n
].used_idx
= vring_used_idx(&vdev
->vq
[n
]);
2312 void virtio_queue_invalidate_signalled_used(VirtIODevice
*vdev
, int n
)
2314 vdev
->vq
[n
].signalled_used_valid
= false;
2317 VirtQueue
*virtio_get_queue(VirtIODevice
*vdev
, int n
)
2319 return vdev
->vq
+ n
;
2322 uint16_t virtio_get_queue_index(VirtQueue
*vq
)
2324 return vq
->queue_index
;
2327 static void virtio_queue_guest_notifier_read(EventNotifier
*n
)
2329 VirtQueue
*vq
= container_of(n
, VirtQueue
, guest_notifier
);
2330 if (event_notifier_test_and_clear(n
)) {
2335 void virtio_queue_set_guest_notifier_fd_handler(VirtQueue
*vq
, bool assign
,
2338 if (assign
&& !with_irqfd
) {
2339 event_notifier_set_handler(&vq
->guest_notifier
,
2340 virtio_queue_guest_notifier_read
);
2342 event_notifier_set_handler(&vq
->guest_notifier
, NULL
);
2345 /* Test and clear notifier before closing it,
2346 * in case poll callback didn't have time to run. */
2347 virtio_queue_guest_notifier_read(&vq
->guest_notifier
);
2351 EventNotifier
*virtio_queue_get_guest_notifier(VirtQueue
*vq
)
2353 return &vq
->guest_notifier
;
2356 static void virtio_queue_host_notifier_aio_read(EventNotifier
*n
)
2358 VirtQueue
*vq
= container_of(n
, VirtQueue
, host_notifier
);
2359 if (event_notifier_test_and_clear(n
)) {
2360 virtio_queue_notify_aio_vq(vq
);
2364 static void virtio_queue_host_notifier_aio_poll_begin(EventNotifier
*n
)
2366 VirtQueue
*vq
= container_of(n
, VirtQueue
, host_notifier
);
2368 virtio_queue_set_notification(vq
, 0);
2371 static bool virtio_queue_host_notifier_aio_poll(void *opaque
)
2373 EventNotifier
*n
= opaque
;
2374 VirtQueue
*vq
= container_of(n
, VirtQueue
, host_notifier
);
2377 if (!vq
->vring
.desc
|| virtio_queue_empty(vq
)) {
2381 progress
= virtio_queue_notify_aio_vq(vq
);
2383 /* In case the handler function re-enabled notifications */
2384 virtio_queue_set_notification(vq
, 0);
2388 static void virtio_queue_host_notifier_aio_poll_end(EventNotifier
*n
)
2390 VirtQueue
*vq
= container_of(n
, VirtQueue
, host_notifier
);
2392 /* Caller polls once more after this to catch requests that race with us */
2393 virtio_queue_set_notification(vq
, 1);
2396 void virtio_queue_aio_set_host_notifier_handler(VirtQueue
*vq
, AioContext
*ctx
,
2397 VirtIOHandleAIOOutput handle_output
)
2399 if (handle_output
) {
2400 vq
->handle_aio_output
= handle_output
;
2401 aio_set_event_notifier(ctx
, &vq
->host_notifier
, true,
2402 virtio_queue_host_notifier_aio_read
,
2403 virtio_queue_host_notifier_aio_poll
);
2404 aio_set_event_notifier_poll(ctx
, &vq
->host_notifier
,
2405 virtio_queue_host_notifier_aio_poll_begin
,
2406 virtio_queue_host_notifier_aio_poll_end
);
2408 aio_set_event_notifier(ctx
, &vq
->host_notifier
, true, NULL
, NULL
);
2409 /* Test and clear notifier before after disabling event,
2410 * in case poll callback didn't have time to run. */
2411 virtio_queue_host_notifier_aio_read(&vq
->host_notifier
);
2412 vq
->handle_aio_output
= NULL
;
2416 void virtio_queue_host_notifier_read(EventNotifier
*n
)
2418 VirtQueue
*vq
= container_of(n
, VirtQueue
, host_notifier
);
2419 if (event_notifier_test_and_clear(n
)) {
2420 virtio_queue_notify_vq(vq
);
2424 EventNotifier
*virtio_queue_get_host_notifier(VirtQueue
*vq
)
2426 return &vq
->host_notifier
;
2429 void virtio_device_set_child_bus_name(VirtIODevice
*vdev
, char *bus_name
)
2431 g_free(vdev
->bus_name
);
2432 vdev
->bus_name
= g_strdup(bus_name
);
2435 void GCC_FMT_ATTR(2, 3) virtio_error(VirtIODevice
*vdev
, const char *fmt
, ...)
2440 error_vreport(fmt
, ap
);
2443 vdev
->broken
= true;
2445 if (virtio_vdev_has_feature(vdev
, VIRTIO_F_VERSION_1
)) {
2446 virtio_set_status(vdev
, vdev
->status
| VIRTIO_CONFIG_S_NEEDS_RESET
);
2447 virtio_notify_config(vdev
);
2451 static void virtio_memory_listener_commit(MemoryListener
*listener
)
2453 VirtIODevice
*vdev
= container_of(listener
, VirtIODevice
, listener
);
2456 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
2457 if (vdev
->vq
[i
].vring
.num
== 0) {
2460 virtio_init_region_cache(vdev
, i
);
2464 static void virtio_device_realize(DeviceState
*dev
, Error
**errp
)
2466 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
2467 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(dev
);
2470 /* Devices should either use vmsd or the load/save methods */
2471 assert(!vdc
->vmsd
|| !vdc
->load
);
2473 if (vdc
->realize
!= NULL
) {
2474 vdc
->realize(dev
, &err
);
2476 error_propagate(errp
, err
);
2481 virtio_bus_device_plugged(vdev
, &err
);
2483 error_propagate(errp
, err
);
2487 vdev
->listener
.commit
= virtio_memory_listener_commit
;
2488 memory_listener_register(&vdev
->listener
, vdev
->dma_as
);
2491 static void virtio_device_unrealize(DeviceState
*dev
, Error
**errp
)
2493 VirtIODevice
*vdev
= VIRTIO_DEVICE(dev
);
2494 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_GET_CLASS(dev
);
2497 virtio_bus_device_unplugged(vdev
);
2499 if (vdc
->unrealize
!= NULL
) {
2500 vdc
->unrealize(dev
, &err
);
2502 error_propagate(errp
, err
);
2507 g_free(vdev
->bus_name
);
2508 vdev
->bus_name
= NULL
;
2511 static void virtio_device_free_virtqueues(VirtIODevice
*vdev
)
2518 for (i
= 0; i
< VIRTIO_QUEUE_MAX
; i
++) {
2519 if (vdev
->vq
[i
].vring
.num
== 0) {
2522 virtio_virtqueue_reset_region_cache(&vdev
->vq
[i
]);
2527 static void virtio_device_instance_finalize(Object
*obj
)
2529 VirtIODevice
*vdev
= VIRTIO_DEVICE(obj
);
2531 memory_listener_unregister(&vdev
->listener
);
2532 virtio_device_free_virtqueues(vdev
);
2534 g_free(vdev
->config
);
2535 g_free(vdev
->vector_queues
);
2538 static Property virtio_properties
[] = {
2539 DEFINE_VIRTIO_COMMON_FEATURES(VirtIODevice
, host_features
),
2540 DEFINE_PROP_END_OF_LIST(),
2543 static int virtio_device_start_ioeventfd_impl(VirtIODevice
*vdev
)
2545 VirtioBusState
*qbus
= VIRTIO_BUS(qdev_get_parent_bus(DEVICE(vdev
)));
2548 for (n
= 0; n
< VIRTIO_QUEUE_MAX
; n
++) {
2549 VirtQueue
*vq
= &vdev
->vq
[n
];
2550 if (!virtio_queue_get_num(vdev
, n
)) {
2553 r
= virtio_bus_set_host_notifier(qbus
, n
, true);
2558 event_notifier_set_handler(&vq
->host_notifier
,
2559 virtio_queue_host_notifier_read
);
2562 for (n
= 0; n
< VIRTIO_QUEUE_MAX
; n
++) {
2563 /* Kick right away to begin processing requests already in vring */
2564 VirtQueue
*vq
= &vdev
->vq
[n
];
2565 if (!vq
->vring
.num
) {
2568 event_notifier_set(&vq
->host_notifier
);
2574 VirtQueue
*vq
= &vdev
->vq
[n
];
2575 if (!virtio_queue_get_num(vdev
, n
)) {
2579 event_notifier_set_handler(&vq
->host_notifier
, NULL
);
2580 r
= virtio_bus_set_host_notifier(qbus
, n
, false);
2586 int virtio_device_start_ioeventfd(VirtIODevice
*vdev
)
2588 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
2589 VirtioBusState
*vbus
= VIRTIO_BUS(qbus
);
2591 return virtio_bus_start_ioeventfd(vbus
);
2594 static void virtio_device_stop_ioeventfd_impl(VirtIODevice
*vdev
)
2596 VirtioBusState
*qbus
= VIRTIO_BUS(qdev_get_parent_bus(DEVICE(vdev
)));
2599 for (n
= 0; n
< VIRTIO_QUEUE_MAX
; n
++) {
2600 VirtQueue
*vq
= &vdev
->vq
[n
];
2602 if (!virtio_queue_get_num(vdev
, n
)) {
2605 event_notifier_set_handler(&vq
->host_notifier
, NULL
);
2606 r
= virtio_bus_set_host_notifier(qbus
, n
, false);
2611 void virtio_device_stop_ioeventfd(VirtIODevice
*vdev
)
2613 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
2614 VirtioBusState
*vbus
= VIRTIO_BUS(qbus
);
2616 virtio_bus_stop_ioeventfd(vbus
);
2619 int virtio_device_grab_ioeventfd(VirtIODevice
*vdev
)
2621 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
2622 VirtioBusState
*vbus
= VIRTIO_BUS(qbus
);
2624 return virtio_bus_grab_ioeventfd(vbus
);
2627 void virtio_device_release_ioeventfd(VirtIODevice
*vdev
)
2629 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
2630 VirtioBusState
*vbus
= VIRTIO_BUS(qbus
);
2632 virtio_bus_release_ioeventfd(vbus
);
2635 static void virtio_device_class_init(ObjectClass
*klass
, void *data
)
2637 /* Set the default value here. */
2638 VirtioDeviceClass
*vdc
= VIRTIO_DEVICE_CLASS(klass
);
2639 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2641 dc
->realize
= virtio_device_realize
;
2642 dc
->unrealize
= virtio_device_unrealize
;
2643 dc
->bus_type
= TYPE_VIRTIO_BUS
;
2644 dc
->props
= virtio_properties
;
2645 vdc
->start_ioeventfd
= virtio_device_start_ioeventfd_impl
;
2646 vdc
->stop_ioeventfd
= virtio_device_stop_ioeventfd_impl
;
2648 vdc
->legacy_features
|= VIRTIO_LEGACY_FEATURES
;
2651 bool virtio_device_ioeventfd_enabled(VirtIODevice
*vdev
)
2653 BusState
*qbus
= qdev_get_parent_bus(DEVICE(vdev
));
2654 VirtioBusState
*vbus
= VIRTIO_BUS(qbus
);
2656 return virtio_bus_ioeventfd_enabled(vbus
);
2659 static const TypeInfo virtio_device_info
= {
2660 .name
= TYPE_VIRTIO_DEVICE
,
2661 .parent
= TYPE_DEVICE
,
2662 .instance_size
= sizeof(VirtIODevice
),
2663 .class_init
= virtio_device_class_init
,
2664 .instance_finalize
= virtio_device_instance_finalize
,
2666 .class_size
= sizeof(VirtioDeviceClass
),
2669 static void virtio_register_types(void)
2671 type_register_static(&virtio_device_info
);
2674 type_init(virtio_register_types
)