4 * Copyright IBM, Corp. 2007
5 * Copyright (c) 2009 CodeSourcery
8 * Anthony Liguori <aliguori@us.ibm.com>
9 * Paul Brook <paul@codesourcery.com>
11 * This work is licensed under the terms of the GNU GPL, version 2. See
12 * the COPYING file in the top-level directory.
14 * Contributions after 2012-01-13 are licensed under the terms of the
15 * GNU GPL, version 2 or (at your option) any later version.
21 #include "virtio-blk.h"
22 #include "virtio-net.h"
23 #include "virtio-serial.h"
24 #include "virtio-scsi.h"
26 #include "qemu/error-report.h"
30 #include "sysemu/kvm.h"
31 #include "sysemu/blockdev.h"
32 #include "virtio-pci.h"
33 #include "qemu/range.h"
35 /* from Linux's linux/virtio_pci.h */
37 /* A 32-bit r/o bitmask of the features supported by the host */
38 #define VIRTIO_PCI_HOST_FEATURES 0
40 /* A 32-bit r/w bitmask of features activated by the guest */
41 #define VIRTIO_PCI_GUEST_FEATURES 4
43 /* A 32-bit r/w PFN for the currently selected queue */
44 #define VIRTIO_PCI_QUEUE_PFN 8
46 /* A 16-bit r/o queue size for the currently selected queue */
47 #define VIRTIO_PCI_QUEUE_NUM 12
49 /* A 16-bit r/w queue selector */
50 #define VIRTIO_PCI_QUEUE_SEL 14
52 /* A 16-bit r/w queue notifier */
53 #define VIRTIO_PCI_QUEUE_NOTIFY 16
55 /* An 8-bit device status register. */
56 #define VIRTIO_PCI_STATUS 18
58 /* An 8-bit r/o interrupt status register. Reading the value will return the
59 * current contents of the ISR and will also clear it. This is effectively
60 * a read-and-acknowledge. */
61 #define VIRTIO_PCI_ISR 19
63 /* MSI-X registers: only enabled if MSI-X is enabled. */
64 /* A 16-bit vector for configuration changes. */
65 #define VIRTIO_MSI_CONFIG_VECTOR 20
66 /* A 16-bit vector for selected queue notifications. */
67 #define VIRTIO_MSI_QUEUE_VECTOR 22
69 /* Config space size */
70 #define VIRTIO_PCI_CONFIG_NOMSI 20
71 #define VIRTIO_PCI_CONFIG_MSI 24
72 #define VIRTIO_PCI_REGION_SIZE(dev) (msix_present(dev) ? \
73 VIRTIO_PCI_CONFIG_MSI : \
74 VIRTIO_PCI_CONFIG_NOMSI)
76 /* The remaining space is defined by each driver as the per-driver
77 * configuration space */
78 #define VIRTIO_PCI_CONFIG(dev) (msix_enabled(dev) ? \
79 VIRTIO_PCI_CONFIG_MSI : \
80 VIRTIO_PCI_CONFIG_NOMSI)
82 /* How many bits to shift physical queue address written to QUEUE_PFN.
83 * 12 is historical, and due to x86 page size. */
84 #define VIRTIO_PCI_QUEUE_ADDR_SHIFT 12
86 /* Flags track per-device state like workarounds for quirks in older guests. */
87 #define VIRTIO_PCI_FLAG_BUS_MASTER_BUG (1 << 0)
89 /* QEMU doesn't strictly need write barriers since everything runs in
90 * lock-step. We'll leave the calls to wmb() in though to make it obvious for
91 * KVM or if kqemu gets SMP support.
93 #define wmb() do { } while (0)
95 /* HACK for virtio to determine if it's running a big endian guest */
96 bool virtio_is_big_endian(void);
100 static void virtio_pci_notify(void *opaque
, uint16_t vector
)
102 VirtIOPCIProxy
*proxy
= opaque
;
103 if (msix_enabled(&proxy
->pci_dev
))
104 msix_notify(&proxy
->pci_dev
, vector
);
106 qemu_set_irq(proxy
->pci_dev
.irq
[0], proxy
->vdev
->isr
& 1);
109 static void virtio_pci_save_config(void * opaque
, QEMUFile
*f
)
111 VirtIOPCIProxy
*proxy
= opaque
;
112 pci_device_save(&proxy
->pci_dev
, f
);
113 msix_save(&proxy
->pci_dev
, f
);
114 if (msix_present(&proxy
->pci_dev
))
115 qemu_put_be16(f
, proxy
->vdev
->config_vector
);
118 static void virtio_pci_save_queue(void * opaque
, int n
, QEMUFile
*f
)
120 VirtIOPCIProxy
*proxy
= opaque
;
121 if (msix_present(&proxy
->pci_dev
))
122 qemu_put_be16(f
, virtio_queue_vector(proxy
->vdev
, n
));
125 static int virtio_pci_load_config(void * opaque
, QEMUFile
*f
)
127 VirtIOPCIProxy
*proxy
= opaque
;
129 ret
= pci_device_load(&proxy
->pci_dev
, f
);
133 msix_unuse_all_vectors(&proxy
->pci_dev
);
134 msix_load(&proxy
->pci_dev
, f
);
135 if (msix_present(&proxy
->pci_dev
)) {
136 qemu_get_be16s(f
, &proxy
->vdev
->config_vector
);
138 proxy
->vdev
->config_vector
= VIRTIO_NO_VECTOR
;
140 if (proxy
->vdev
->config_vector
!= VIRTIO_NO_VECTOR
) {
141 return msix_vector_use(&proxy
->pci_dev
, proxy
->vdev
->config_vector
);
146 static int virtio_pci_load_queue(void * opaque
, int n
, QEMUFile
*f
)
148 VirtIOPCIProxy
*proxy
= opaque
;
150 if (msix_present(&proxy
->pci_dev
)) {
151 qemu_get_be16s(f
, &vector
);
153 vector
= VIRTIO_NO_VECTOR
;
155 virtio_queue_set_vector(proxy
->vdev
, n
, vector
);
156 if (vector
!= VIRTIO_NO_VECTOR
) {
157 return msix_vector_use(&proxy
->pci_dev
, vector
);
162 static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy
*proxy
,
163 int n
, bool assign
, bool set_handler
)
165 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, n
);
166 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
170 r
= event_notifier_init(notifier
, 1);
172 error_report("%s: unable to init event notifier: %d",
176 virtio_queue_set_host_notifier_fd_handler(vq
, true, set_handler
);
177 memory_region_add_eventfd(&proxy
->bar
, VIRTIO_PCI_QUEUE_NOTIFY
, 2,
180 memory_region_del_eventfd(&proxy
->bar
, VIRTIO_PCI_QUEUE_NOTIFY
, 2,
182 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
183 event_notifier_cleanup(notifier
);
188 static void virtio_pci_start_ioeventfd(VirtIOPCIProxy
*proxy
)
192 if (!(proxy
->flags
& VIRTIO_PCI_FLAG_USE_IOEVENTFD
) ||
193 proxy
->ioeventfd_disabled
||
194 proxy
->ioeventfd_started
) {
198 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
199 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
203 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, true, true);
208 proxy
->ioeventfd_started
= true;
213 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
217 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, false, false);
220 proxy
->ioeventfd_started
= false;
221 error_report("%s: failed. Fallback to a userspace (slower).", __func__
);
224 static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy
*proxy
)
229 if (!proxy
->ioeventfd_started
) {
233 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
234 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
238 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, false, false);
241 proxy
->ioeventfd_started
= false;
244 void virtio_pci_reset(DeviceState
*d
)
246 VirtIOPCIProxy
*proxy
= container_of(d
, VirtIOPCIProxy
, pci_dev
.qdev
);
247 virtio_pci_stop_ioeventfd(proxy
);
248 virtio_reset(proxy
->vdev
);
249 msix_unuse_all_vectors(&proxy
->pci_dev
);
250 proxy
->flags
&= ~VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
253 static void virtio_ioport_write(void *opaque
, uint32_t addr
, uint32_t val
)
255 VirtIOPCIProxy
*proxy
= opaque
;
256 VirtIODevice
*vdev
= proxy
->vdev
;
260 case VIRTIO_PCI_GUEST_FEATURES
:
261 /* Guest does not negotiate properly? We have to assume nothing. */
262 if (val
& (1 << VIRTIO_F_BAD_FEATURE
)) {
263 val
= vdev
->bad_features
? vdev
->bad_features(vdev
) : 0;
265 virtio_set_features(vdev
, val
);
267 case VIRTIO_PCI_QUEUE_PFN
:
268 pa
= (hwaddr
)val
<< VIRTIO_PCI_QUEUE_ADDR_SHIFT
;
270 virtio_pci_stop_ioeventfd(proxy
);
271 virtio_reset(proxy
->vdev
);
272 msix_unuse_all_vectors(&proxy
->pci_dev
);
275 virtio_queue_set_addr(vdev
, vdev
->queue_sel
, pa
);
277 case VIRTIO_PCI_QUEUE_SEL
:
278 if (val
< VIRTIO_PCI_QUEUE_MAX
)
279 vdev
->queue_sel
= val
;
281 case VIRTIO_PCI_QUEUE_NOTIFY
:
282 if (val
< VIRTIO_PCI_QUEUE_MAX
) {
283 virtio_queue_notify(vdev
, val
);
286 case VIRTIO_PCI_STATUS
:
287 if (!(val
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
288 virtio_pci_stop_ioeventfd(proxy
);
291 virtio_set_status(vdev
, val
& 0xFF);
293 if (val
& VIRTIO_CONFIG_S_DRIVER_OK
) {
294 virtio_pci_start_ioeventfd(proxy
);
297 if (vdev
->status
== 0) {
298 virtio_reset(proxy
->vdev
);
299 msix_unuse_all_vectors(&proxy
->pci_dev
);
302 /* Linux before 2.6.34 sets the device as OK without enabling
303 the PCI device bus master bit. In this case we need to disable
304 some safety checks. */
305 if ((val
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
306 !(proxy
->pci_dev
.config
[PCI_COMMAND
] & PCI_COMMAND_MASTER
)) {
307 proxy
->flags
|= VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
310 case VIRTIO_MSI_CONFIG_VECTOR
:
311 msix_vector_unuse(&proxy
->pci_dev
, vdev
->config_vector
);
312 /* Make it possible for guest to discover an error took place. */
313 if (msix_vector_use(&proxy
->pci_dev
, val
) < 0)
314 val
= VIRTIO_NO_VECTOR
;
315 vdev
->config_vector
= val
;
317 case VIRTIO_MSI_QUEUE_VECTOR
:
318 msix_vector_unuse(&proxy
->pci_dev
,
319 virtio_queue_vector(vdev
, vdev
->queue_sel
));
320 /* Make it possible for guest to discover an error took place. */
321 if (msix_vector_use(&proxy
->pci_dev
, val
) < 0)
322 val
= VIRTIO_NO_VECTOR
;
323 virtio_queue_set_vector(vdev
, vdev
->queue_sel
, val
);
326 error_report("%s: unexpected address 0x%x value 0x%x",
327 __func__
, addr
, val
);
332 static uint32_t virtio_ioport_read(VirtIOPCIProxy
*proxy
, uint32_t addr
)
334 VirtIODevice
*vdev
= proxy
->vdev
;
335 uint32_t ret
= 0xFFFFFFFF;
338 case VIRTIO_PCI_HOST_FEATURES
:
339 ret
= proxy
->host_features
;
341 case VIRTIO_PCI_GUEST_FEATURES
:
342 ret
= vdev
->guest_features
;
344 case VIRTIO_PCI_QUEUE_PFN
:
345 ret
= virtio_queue_get_addr(vdev
, vdev
->queue_sel
)
346 >> VIRTIO_PCI_QUEUE_ADDR_SHIFT
;
348 case VIRTIO_PCI_QUEUE_NUM
:
349 ret
= virtio_queue_get_num(vdev
, vdev
->queue_sel
);
351 case VIRTIO_PCI_QUEUE_SEL
:
352 ret
= vdev
->queue_sel
;
354 case VIRTIO_PCI_STATUS
:
358 /* reading from the ISR also clears it. */
361 qemu_set_irq(proxy
->pci_dev
.irq
[0], 0);
363 case VIRTIO_MSI_CONFIG_VECTOR
:
364 ret
= vdev
->config_vector
;
366 case VIRTIO_MSI_QUEUE_VECTOR
:
367 ret
= virtio_queue_vector(vdev
, vdev
->queue_sel
);
376 static uint64_t virtio_pci_config_read(void *opaque
, hwaddr addr
,
379 VirtIOPCIProxy
*proxy
= opaque
;
380 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
383 return virtio_ioport_read(proxy
, addr
);
389 val
= virtio_config_readb(proxy
->vdev
, addr
);
392 val
= virtio_config_readw(proxy
->vdev
, addr
);
393 if (virtio_is_big_endian()) {
398 val
= virtio_config_readl(proxy
->vdev
, addr
);
399 if (virtio_is_big_endian()) {
407 static void virtio_pci_config_write(void *opaque
, hwaddr addr
,
408 uint64_t val
, unsigned size
)
410 VirtIOPCIProxy
*proxy
= opaque
;
411 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
413 virtio_ioport_write(proxy
, addr
, val
);
418 * Virtio-PCI is odd. Ioports are LE but config space is target native
423 virtio_config_writeb(proxy
->vdev
, addr
, val
);
426 if (virtio_is_big_endian()) {
429 virtio_config_writew(proxy
->vdev
, addr
, val
);
432 if (virtio_is_big_endian()) {
435 virtio_config_writel(proxy
->vdev
, addr
, val
);
440 static const MemoryRegionOps virtio_pci_config_ops
= {
441 .read
= virtio_pci_config_read
,
442 .write
= virtio_pci_config_write
,
444 .min_access_size
= 1,
445 .max_access_size
= 4,
447 .endianness
= DEVICE_LITTLE_ENDIAN
,
450 static void virtio_write_config(PCIDevice
*pci_dev
, uint32_t address
,
451 uint32_t val
, int len
)
453 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
455 pci_default_write_config(pci_dev
, address
, val
, len
);
457 if (range_covers_byte(address
, len
, PCI_COMMAND
) &&
458 !(pci_dev
->config
[PCI_COMMAND
] & PCI_COMMAND_MASTER
) &&
459 !(proxy
->flags
& VIRTIO_PCI_FLAG_BUS_MASTER_BUG
)) {
460 virtio_pci_stop_ioeventfd(proxy
);
461 virtio_set_status(proxy
->vdev
,
462 proxy
->vdev
->status
& ~VIRTIO_CONFIG_S_DRIVER_OK
);
466 static unsigned virtio_pci_get_features(void *opaque
)
468 VirtIOPCIProxy
*proxy
= opaque
;
469 return proxy
->host_features
;
472 static int kvm_virtio_pci_vq_vector_use(VirtIOPCIProxy
*proxy
,
473 unsigned int queue_no
,
477 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, queue_no
);
478 EventNotifier
*n
= virtio_queue_get_guest_notifier(vq
);
479 VirtIOIRQFD
*irqfd
= &proxy
->vector_irqfd
[vector
];
482 if (irqfd
->users
== 0) {
483 ret
= kvm_irqchip_add_msi_route(kvm_state
, msg
);
491 ret
= kvm_irqchip_add_irqfd_notifier(kvm_state
, n
, irqfd
->virq
);
493 if (--irqfd
->users
== 0) {
494 kvm_irqchip_release_virq(kvm_state
, irqfd
->virq
);
499 virtio_queue_set_guest_notifier_fd_handler(vq
, true, true);
503 static void kvm_virtio_pci_vq_vector_release(VirtIOPCIProxy
*proxy
,
504 unsigned int queue_no
,
507 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, queue_no
);
508 EventNotifier
*n
= virtio_queue_get_guest_notifier(vq
);
509 VirtIOIRQFD
*irqfd
= &proxy
->vector_irqfd
[vector
];
512 ret
= kvm_irqchip_remove_irqfd_notifier(kvm_state
, n
, irqfd
->virq
);
515 if (--irqfd
->users
== 0) {
516 kvm_irqchip_release_virq(kvm_state
, irqfd
->virq
);
519 virtio_queue_set_guest_notifier_fd_handler(vq
, true, false);
522 static int kvm_virtio_pci_vector_use(PCIDevice
*dev
, unsigned vector
,
525 VirtIOPCIProxy
*proxy
= container_of(dev
, VirtIOPCIProxy
, pci_dev
);
526 VirtIODevice
*vdev
= proxy
->vdev
;
529 for (queue_no
= 0; queue_no
< VIRTIO_PCI_QUEUE_MAX
; queue_no
++) {
530 if (!virtio_queue_get_num(vdev
, queue_no
)) {
533 if (virtio_queue_vector(vdev
, queue_no
) != vector
) {
536 ret
= kvm_virtio_pci_vq_vector_use(proxy
, queue_no
, vector
, msg
);
544 while (--queue_no
>= 0) {
545 if (virtio_queue_vector(vdev
, queue_no
) != vector
) {
548 kvm_virtio_pci_vq_vector_release(proxy
, queue_no
, vector
);
553 static void kvm_virtio_pci_vector_release(PCIDevice
*dev
, unsigned vector
)
555 VirtIOPCIProxy
*proxy
= container_of(dev
, VirtIOPCIProxy
, pci_dev
);
556 VirtIODevice
*vdev
= proxy
->vdev
;
559 for (queue_no
= 0; queue_no
< VIRTIO_PCI_QUEUE_MAX
; queue_no
++) {
560 if (!virtio_queue_get_num(vdev
, queue_no
)) {
563 if (virtio_queue_vector(vdev
, queue_no
) != vector
) {
566 kvm_virtio_pci_vq_vector_release(proxy
, queue_no
, vector
);
570 static int virtio_pci_set_guest_notifier(void *opaque
, int n
, bool assign
)
572 VirtIOPCIProxy
*proxy
= opaque
;
573 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, n
);
574 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
577 int r
= event_notifier_init(notifier
, 0);
581 virtio_queue_set_guest_notifier_fd_handler(vq
, true, false);
583 virtio_queue_set_guest_notifier_fd_handler(vq
, false, false);
584 event_notifier_cleanup(notifier
);
590 static bool virtio_pci_query_guest_notifiers(void *opaque
)
592 VirtIOPCIProxy
*proxy
= opaque
;
593 return msix_enabled(&proxy
->pci_dev
);
596 static int virtio_pci_set_guest_notifiers(void *opaque
, bool assign
)
598 VirtIOPCIProxy
*proxy
= opaque
;
599 VirtIODevice
*vdev
= proxy
->vdev
;
602 /* Must unset vector notifier while guest notifier is still assigned */
603 if (kvm_msi_via_irqfd_enabled() && !assign
) {
604 msix_unset_vector_notifiers(&proxy
->pci_dev
);
605 g_free(proxy
->vector_irqfd
);
606 proxy
->vector_irqfd
= NULL
;
609 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
610 if (!virtio_queue_get_num(vdev
, n
)) {
614 r
= virtio_pci_set_guest_notifier(opaque
, n
, assign
);
620 /* Must set vector notifier after guest notifier has been assigned */
621 if (kvm_msi_via_irqfd_enabled() && assign
) {
622 proxy
->vector_irqfd
=
623 g_malloc0(sizeof(*proxy
->vector_irqfd
) *
624 msix_nr_vectors_allocated(&proxy
->pci_dev
));
625 r
= msix_set_vector_notifiers(&proxy
->pci_dev
,
626 kvm_virtio_pci_vector_use
,
627 kvm_virtio_pci_vector_release
);
636 /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
639 virtio_pci_set_guest_notifier(opaque
, n
, !assign
);
644 static int virtio_pci_set_host_notifier(void *opaque
, int n
, bool assign
)
646 VirtIOPCIProxy
*proxy
= opaque
;
648 /* Stop using ioeventfd for virtqueue kick if the device starts using host
649 * notifiers. This makes it easy to avoid stepping on each others' toes.
651 proxy
->ioeventfd_disabled
= assign
;
653 virtio_pci_stop_ioeventfd(proxy
);
655 /* We don't need to start here: it's not needed because backend
656 * currently only stops on status change away from ok,
657 * reset, vmstop and such. If we do add code to start here,
658 * need to check vmstate, device state etc. */
659 return virtio_pci_set_host_notifier_internal(proxy
, n
, assign
, false);
662 static void virtio_pci_vmstate_change(void *opaque
, bool running
)
664 VirtIOPCIProxy
*proxy
= opaque
;
667 /* Try to find out if the guest has bus master disabled, but is
668 in ready state. Then we have a buggy guest OS. */
669 if ((proxy
->vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
670 !(proxy
->pci_dev
.config
[PCI_COMMAND
] & PCI_COMMAND_MASTER
)) {
671 proxy
->flags
|= VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
673 virtio_pci_start_ioeventfd(proxy
);
675 virtio_pci_stop_ioeventfd(proxy
);
679 static const VirtIOBindings virtio_pci_bindings
= {
680 .notify
= virtio_pci_notify
,
681 .save_config
= virtio_pci_save_config
,
682 .load_config
= virtio_pci_load_config
,
683 .save_queue
= virtio_pci_save_queue
,
684 .load_queue
= virtio_pci_load_queue
,
685 .get_features
= virtio_pci_get_features
,
686 .query_guest_notifiers
= virtio_pci_query_guest_notifiers
,
687 .set_host_notifier
= virtio_pci_set_host_notifier
,
688 .set_guest_notifiers
= virtio_pci_set_guest_notifiers
,
689 .vmstate_change
= virtio_pci_vmstate_change
,
692 void virtio_init_pci(VirtIOPCIProxy
*proxy
, VirtIODevice
*vdev
)
699 config
= proxy
->pci_dev
.config
;
701 if (proxy
->class_code
) {
702 pci_config_set_class(config
, proxy
->class_code
);
704 pci_set_word(config
+ PCI_SUBSYSTEM_VENDOR_ID
,
705 pci_get_word(config
+ PCI_VENDOR_ID
));
706 pci_set_word(config
+ PCI_SUBSYSTEM_ID
, vdev
->device_id
);
707 config
[PCI_INTERRUPT_PIN
] = 1;
709 if (vdev
->nvectors
&&
710 msix_init_exclusive_bar(&proxy
->pci_dev
, vdev
->nvectors
, 1)) {
714 proxy
->pci_dev
.config_write
= virtio_write_config
;
716 size
= VIRTIO_PCI_REGION_SIZE(&proxy
->pci_dev
) + vdev
->config_len
;
718 size
= 1 << qemu_fls(size
);
720 memory_region_init_io(&proxy
->bar
, &virtio_pci_config_ops
, proxy
,
722 pci_register_bar(&proxy
->pci_dev
, 0, PCI_BASE_ADDRESS_SPACE_IO
,
725 if (!kvm_has_many_ioeventfds()) {
726 proxy
->flags
&= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD
;
729 virtio_bind_device(vdev
, &virtio_pci_bindings
, proxy
);
730 proxy
->host_features
|= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY
;
731 proxy
->host_features
|= 0x1 << VIRTIO_F_BAD_FEATURE
;
732 proxy
->host_features
= vdev
->get_features(vdev
, proxy
->host_features
);
735 static int virtio_blk_init_pci(PCIDevice
*pci_dev
)
737 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
740 if (proxy
->class_code
!= PCI_CLASS_STORAGE_SCSI
&&
741 proxy
->class_code
!= PCI_CLASS_STORAGE_OTHER
)
742 proxy
->class_code
= PCI_CLASS_STORAGE_SCSI
;
744 vdev
= virtio_blk_init(&pci_dev
->qdev
, &proxy
->blk
);
748 vdev
->nvectors
= proxy
->nvectors
;
749 virtio_init_pci(proxy
, vdev
);
750 /* make the actual value visible */
751 proxy
->nvectors
= vdev
->nvectors
;
755 static void virtio_exit_pci(PCIDevice
*pci_dev
)
757 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
759 memory_region_destroy(&proxy
->bar
);
760 msix_uninit_exclusive_bar(pci_dev
);
763 static void virtio_blk_exit_pci(PCIDevice
*pci_dev
)
765 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
767 virtio_pci_stop_ioeventfd(proxy
);
768 virtio_blk_exit(proxy
->vdev
);
769 virtio_exit_pci(pci_dev
);
772 static int virtio_serial_init_pci(PCIDevice
*pci_dev
)
774 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
777 if (proxy
->class_code
!= PCI_CLASS_COMMUNICATION_OTHER
&&
778 proxy
->class_code
!= PCI_CLASS_DISPLAY_OTHER
&& /* qemu 0.10 */
779 proxy
->class_code
!= PCI_CLASS_OTHERS
) /* qemu-kvm */
780 proxy
->class_code
= PCI_CLASS_COMMUNICATION_OTHER
;
782 vdev
= virtio_serial_init(&pci_dev
->qdev
, &proxy
->serial
);
786 vdev
->nvectors
= proxy
->nvectors
== DEV_NVECTORS_UNSPECIFIED
787 ? proxy
->serial
.max_virtserial_ports
+ 1
789 virtio_init_pci(proxy
, vdev
);
790 proxy
->nvectors
= vdev
->nvectors
;
794 static void virtio_serial_exit_pci(PCIDevice
*pci_dev
)
796 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
798 virtio_pci_stop_ioeventfd(proxy
);
799 virtio_serial_exit(proxy
->vdev
);
800 virtio_exit_pci(pci_dev
);
803 static int virtio_net_init_pci(PCIDevice
*pci_dev
)
805 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
808 vdev
= virtio_net_init(&pci_dev
->qdev
, &proxy
->nic
, &proxy
->net
);
810 vdev
->nvectors
= proxy
->nvectors
;
811 virtio_init_pci(proxy
, vdev
);
813 /* make the actual value visible */
814 proxy
->nvectors
= vdev
->nvectors
;
818 static void virtio_net_exit_pci(PCIDevice
*pci_dev
)
820 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
822 virtio_pci_stop_ioeventfd(proxy
);
823 virtio_net_exit(proxy
->vdev
);
824 virtio_exit_pci(pci_dev
);
827 static int virtio_balloon_init_pci(PCIDevice
*pci_dev
)
829 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
832 if (proxy
->class_code
!= PCI_CLASS_OTHERS
&&
833 proxy
->class_code
!= PCI_CLASS_MEMORY_RAM
) { /* qemu < 1.1 */
834 proxy
->class_code
= PCI_CLASS_OTHERS
;
837 vdev
= virtio_balloon_init(&pci_dev
->qdev
);
841 virtio_init_pci(proxy
, vdev
);
845 static void virtio_balloon_exit_pci(PCIDevice
*pci_dev
)
847 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
849 virtio_pci_stop_ioeventfd(proxy
);
850 virtio_balloon_exit(proxy
->vdev
);
851 virtio_exit_pci(pci_dev
);
854 static int virtio_rng_init_pci(PCIDevice
*pci_dev
)
856 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
859 if (proxy
->rng
.rng
== NULL
) {
860 proxy
->rng
.default_backend
= RNG_RANDOM(object_new(TYPE_RNG_RANDOM
));
862 object_property_add_child(OBJECT(pci_dev
),
864 OBJECT(proxy
->rng
.default_backend
),
867 object_property_set_link(OBJECT(pci_dev
),
868 OBJECT(proxy
->rng
.default_backend
),
872 vdev
= virtio_rng_init(&pci_dev
->qdev
, &proxy
->rng
);
876 virtio_init_pci(proxy
, vdev
);
880 static void virtio_rng_exit_pci(PCIDevice
*pci_dev
)
882 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
884 virtio_pci_stop_ioeventfd(proxy
);
885 virtio_rng_exit(proxy
->vdev
);
886 virtio_exit_pci(pci_dev
);
889 static Property virtio_blk_properties
[] = {
890 DEFINE_PROP_HEX32("class", VirtIOPCIProxy
, class_code
, 0),
891 DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy
, blk
.conf
),
892 DEFINE_BLOCK_CHS_PROPERTIES(VirtIOPCIProxy
, blk
.conf
),
893 DEFINE_PROP_STRING("serial", VirtIOPCIProxy
, blk
.serial
),
895 DEFINE_PROP_BIT("scsi", VirtIOPCIProxy
, blk
.scsi
, 0, true),
897 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, true),
898 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, 2),
899 DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy
, host_features
),
900 DEFINE_PROP_END_OF_LIST(),
903 static void virtio_blk_class_init(ObjectClass
*klass
, void *data
)
905 DeviceClass
*dc
= DEVICE_CLASS(klass
);
906 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
908 k
->init
= virtio_blk_init_pci
;
909 k
->exit
= virtio_blk_exit_pci
;
910 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
911 k
->device_id
= PCI_DEVICE_ID_VIRTIO_BLOCK
;
912 k
->revision
= VIRTIO_PCI_ABI_VERSION
;
913 k
->class_id
= PCI_CLASS_STORAGE_SCSI
;
914 dc
->reset
= virtio_pci_reset
;
915 dc
->props
= virtio_blk_properties
;
918 static TypeInfo virtio_blk_info
= {
919 .name
= "virtio-blk-pci",
920 .parent
= TYPE_PCI_DEVICE
,
921 .instance_size
= sizeof(VirtIOPCIProxy
),
922 .class_init
= virtio_blk_class_init
,
925 static Property virtio_net_properties
[] = {
926 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, false),
927 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, 3),
928 DEFINE_VIRTIO_NET_FEATURES(VirtIOPCIProxy
, host_features
),
929 DEFINE_NIC_PROPERTIES(VirtIOPCIProxy
, nic
),
930 DEFINE_PROP_UINT32("x-txtimer", VirtIOPCIProxy
, net
.txtimer
, TX_TIMER_INTERVAL
),
931 DEFINE_PROP_INT32("x-txburst", VirtIOPCIProxy
, net
.txburst
, TX_BURST
),
932 DEFINE_PROP_STRING("tx", VirtIOPCIProxy
, net
.tx
),
933 DEFINE_PROP_END_OF_LIST(),
936 static void virtio_net_class_init(ObjectClass
*klass
, void *data
)
938 DeviceClass
*dc
= DEVICE_CLASS(klass
);
939 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
941 k
->init
= virtio_net_init_pci
;
942 k
->exit
= virtio_net_exit_pci
;
943 k
->romfile
= "pxe-virtio.rom";
944 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
945 k
->device_id
= PCI_DEVICE_ID_VIRTIO_NET
;
946 k
->revision
= VIRTIO_PCI_ABI_VERSION
;
947 k
->class_id
= PCI_CLASS_NETWORK_ETHERNET
;
948 dc
->reset
= virtio_pci_reset
;
949 dc
->props
= virtio_net_properties
;
952 static TypeInfo virtio_net_info
= {
953 .name
= "virtio-net-pci",
954 .parent
= TYPE_PCI_DEVICE
,
955 .instance_size
= sizeof(VirtIOPCIProxy
),
956 .class_init
= virtio_net_class_init
,
959 static Property virtio_serial_properties
[] = {
960 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, true),
961 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, DEV_NVECTORS_UNSPECIFIED
),
962 DEFINE_PROP_HEX32("class", VirtIOPCIProxy
, class_code
, 0),
963 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy
, host_features
),
964 DEFINE_PROP_UINT32("max_ports", VirtIOPCIProxy
, serial
.max_virtserial_ports
, 31),
965 DEFINE_PROP_END_OF_LIST(),
968 static void virtio_serial_class_init(ObjectClass
*klass
, void *data
)
970 DeviceClass
*dc
= DEVICE_CLASS(klass
);
971 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
973 k
->init
= virtio_serial_init_pci
;
974 k
->exit
= virtio_serial_exit_pci
;
975 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
976 k
->device_id
= PCI_DEVICE_ID_VIRTIO_CONSOLE
;
977 k
->revision
= VIRTIO_PCI_ABI_VERSION
;
978 k
->class_id
= PCI_CLASS_COMMUNICATION_OTHER
;
979 dc
->reset
= virtio_pci_reset
;
980 dc
->props
= virtio_serial_properties
;
983 static TypeInfo virtio_serial_info
= {
984 .name
= "virtio-serial-pci",
985 .parent
= TYPE_PCI_DEVICE
,
986 .instance_size
= sizeof(VirtIOPCIProxy
),
987 .class_init
= virtio_serial_class_init
,
990 static Property virtio_balloon_properties
[] = {
991 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy
, host_features
),
992 DEFINE_PROP_HEX32("class", VirtIOPCIProxy
, class_code
, 0),
993 DEFINE_PROP_END_OF_LIST(),
996 static void virtio_balloon_class_init(ObjectClass
*klass
, void *data
)
998 DeviceClass
*dc
= DEVICE_CLASS(klass
);
999 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1001 k
->init
= virtio_balloon_init_pci
;
1002 k
->exit
= virtio_balloon_exit_pci
;
1003 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
1004 k
->device_id
= PCI_DEVICE_ID_VIRTIO_BALLOON
;
1005 k
->revision
= VIRTIO_PCI_ABI_VERSION
;
1006 k
->class_id
= PCI_CLASS_OTHERS
;
1007 dc
->reset
= virtio_pci_reset
;
1008 dc
->props
= virtio_balloon_properties
;
1011 static TypeInfo virtio_balloon_info
= {
1012 .name
= "virtio-balloon-pci",
1013 .parent
= TYPE_PCI_DEVICE
,
1014 .instance_size
= sizeof(VirtIOPCIProxy
),
1015 .class_init
= virtio_balloon_class_init
,
1018 static void virtio_rng_initfn(Object
*obj
)
1020 PCIDevice
*pci_dev
= PCI_DEVICE(obj
);
1021 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
1023 object_property_add_link(obj
, "rng", TYPE_RNG_BACKEND
,
1024 (Object
**)&proxy
->rng
.rng
, NULL
);
1027 static Property virtio_rng_properties
[] = {
1028 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy
, host_features
),
1029 /* Set a default rate limit of 2^47 bytes per minute or roughly 2TB/s. If
1030 you have an entropy source capable of generating more entropy than this
1031 and you can pass it through via virtio-rng, then hats off to you. Until
1032 then, this is unlimited for all practical purposes.
1034 DEFINE_PROP_UINT64("max-bytes", VirtIOPCIProxy
, rng
.max_bytes
, INT64_MAX
),
1035 DEFINE_PROP_UINT32("period", VirtIOPCIProxy
, rng
.period_ms
, 1 << 16),
1036 DEFINE_PROP_END_OF_LIST(),
1039 static void virtio_rng_class_init(ObjectClass
*klass
, void *data
)
1041 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1042 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1044 k
->init
= virtio_rng_init_pci
;
1045 k
->exit
= virtio_rng_exit_pci
;
1046 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
1047 k
->device_id
= PCI_DEVICE_ID_VIRTIO_RNG
;
1048 k
->revision
= VIRTIO_PCI_ABI_VERSION
;
1049 k
->class_id
= PCI_CLASS_OTHERS
;
1050 dc
->reset
= virtio_pci_reset
;
1051 dc
->props
= virtio_rng_properties
;
1054 static TypeInfo virtio_rng_info
= {
1055 .name
= "virtio-rng-pci",
1056 .parent
= TYPE_PCI_DEVICE
,
1057 .instance_size
= sizeof(VirtIOPCIProxy
),
1058 .instance_init
= virtio_rng_initfn
,
1059 .class_init
= virtio_rng_class_init
,
1062 static int virtio_scsi_init_pci(PCIDevice
*pci_dev
)
1064 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
1067 vdev
= virtio_scsi_init(&pci_dev
->qdev
, &proxy
->scsi
);
1072 vdev
->nvectors
= proxy
->nvectors
== DEV_NVECTORS_UNSPECIFIED
1073 ? proxy
->scsi
.num_queues
+ 3
1075 virtio_init_pci(proxy
, vdev
);
1077 /* make the actual value visible */
1078 proxy
->nvectors
= vdev
->nvectors
;
1082 static void virtio_scsi_exit_pci(PCIDevice
*pci_dev
)
1084 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
1086 virtio_scsi_exit(proxy
->vdev
);
1087 virtio_exit_pci(pci_dev
);
1090 static Property virtio_scsi_properties
[] = {
1091 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, true),
1092 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, DEV_NVECTORS_UNSPECIFIED
),
1093 DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOPCIProxy
, host_features
, scsi
),
1094 DEFINE_PROP_END_OF_LIST(),
1097 static void virtio_scsi_class_init(ObjectClass
*klass
, void *data
)
1099 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1100 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1102 k
->init
= virtio_scsi_init_pci
;
1103 k
->exit
= virtio_scsi_exit_pci
;
1104 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
1105 k
->device_id
= PCI_DEVICE_ID_VIRTIO_SCSI
;
1107 k
->class_id
= PCI_CLASS_STORAGE_SCSI
;
1108 dc
->reset
= virtio_pci_reset
;
1109 dc
->props
= virtio_scsi_properties
;
1112 static TypeInfo virtio_scsi_info
= {
1113 .name
= "virtio-scsi-pci",
1114 .parent
= TYPE_PCI_DEVICE
,
1115 .instance_size
= sizeof(VirtIOPCIProxy
),
1116 .class_init
= virtio_scsi_class_init
,
1119 static void virtio_pci_register_types(void)
1121 type_register_static(&virtio_blk_info
);
1122 type_register_static(&virtio_net_info
);
1123 type_register_static(&virtio_serial_info
);
1124 type_register_static(&virtio_balloon_info
);
1125 type_register_static(&virtio_scsi_info
);
1126 type_register_static(&virtio_rng_info
);
1129 type_init(virtio_pci_register_types
)