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.
19 #include "virtio-blk.h"
20 #include "virtio-net.h"
21 #include "virtio-serial.h"
23 #include "qemu-error.h"
30 /* from Linux's linux/virtio_pci.h */
32 /* A 32-bit r/o bitmask of the features supported by the host */
33 #define VIRTIO_PCI_HOST_FEATURES 0
35 /* A 32-bit r/w bitmask of features activated by the guest */
36 #define VIRTIO_PCI_GUEST_FEATURES 4
38 /* A 32-bit r/w PFN for the currently selected queue */
39 #define VIRTIO_PCI_QUEUE_PFN 8
41 /* A 16-bit r/o queue size for the currently selected queue */
42 #define VIRTIO_PCI_QUEUE_NUM 12
44 /* A 16-bit r/w queue selector */
45 #define VIRTIO_PCI_QUEUE_SEL 14
47 /* A 16-bit r/w queue notifier */
48 #define VIRTIO_PCI_QUEUE_NOTIFY 16
50 /* An 8-bit device status register. */
51 #define VIRTIO_PCI_STATUS 18
53 /* An 8-bit r/o interrupt status register. Reading the value will return the
54 * current contents of the ISR and will also clear it. This is effectively
55 * a read-and-acknowledge. */
56 #define VIRTIO_PCI_ISR 19
58 /* MSI-X registers: only enabled if MSI-X is enabled. */
59 /* A 16-bit vector for configuration changes. */
60 #define VIRTIO_MSI_CONFIG_VECTOR 20
61 /* A 16-bit vector for selected queue notifications. */
62 #define VIRTIO_MSI_QUEUE_VECTOR 22
64 /* Config space size */
65 #define VIRTIO_PCI_CONFIG_NOMSI 20
66 #define VIRTIO_PCI_CONFIG_MSI 24
67 #define VIRTIO_PCI_REGION_SIZE(dev) (msix_present(dev) ? \
68 VIRTIO_PCI_CONFIG_MSI : \
69 VIRTIO_PCI_CONFIG_NOMSI)
71 /* The remaining space is defined by each driver as the per-driver
72 * configuration space */
73 #define VIRTIO_PCI_CONFIG(dev) (msix_enabled(dev) ? \
74 VIRTIO_PCI_CONFIG_MSI : \
75 VIRTIO_PCI_CONFIG_NOMSI)
77 /* Virtio ABI version, if we increment this, we break the guest driver. */
78 #define VIRTIO_PCI_ABI_VERSION 0
80 /* How many bits to shift physical queue address written to QUEUE_PFN.
81 * 12 is historical, and due to x86 page size. */
82 #define VIRTIO_PCI_QUEUE_ADDR_SHIFT 12
84 /* Flags track per-device state like workarounds for quirks in older guests. */
85 #define VIRTIO_PCI_FLAG_BUS_MASTER_BUG (1 << 0)
87 /* Performance improves when virtqueue kick processing is decoupled from the
88 * vcpu thread using ioeventfd for some devices. */
89 #define VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT 1
90 #define VIRTIO_PCI_FLAG_USE_IOEVENTFD (1 << VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT)
92 /* QEMU doesn't strictly need write barriers since everything runs in
93 * lock-step. We'll leave the calls to wmb() in though to make it obvious for
94 * KVM or if kqemu gets SMP support.
96 #define wmb() do { } while (0)
109 uint32_t host_features
;
113 virtio_serial_conf serial
;
115 bool ioeventfd_disabled
;
116 bool ioeventfd_started
;
121 static void virtio_pci_notify(void *opaque
, uint16_t vector
)
123 VirtIOPCIProxy
*proxy
= opaque
;
124 if (msix_enabled(&proxy
->pci_dev
))
125 msix_notify(&proxy
->pci_dev
, vector
);
127 qemu_set_irq(proxy
->pci_dev
.irq
[0], proxy
->vdev
->isr
& 1);
130 static void virtio_pci_save_config(void * opaque
, QEMUFile
*f
)
132 VirtIOPCIProxy
*proxy
= opaque
;
133 pci_device_save(&proxy
->pci_dev
, f
);
134 msix_save(&proxy
->pci_dev
, f
);
135 if (msix_present(&proxy
->pci_dev
))
136 qemu_put_be16(f
, proxy
->vdev
->config_vector
);
139 static void virtio_pci_save_queue(void * opaque
, int n
, QEMUFile
*f
)
141 VirtIOPCIProxy
*proxy
= opaque
;
142 if (msix_present(&proxy
->pci_dev
))
143 qemu_put_be16(f
, virtio_queue_vector(proxy
->vdev
, n
));
146 static int virtio_pci_load_config(void * opaque
, QEMUFile
*f
)
148 VirtIOPCIProxy
*proxy
= opaque
;
150 ret
= pci_device_load(&proxy
->pci_dev
, f
);
154 msix_load(&proxy
->pci_dev
, f
);
155 if (msix_present(&proxy
->pci_dev
)) {
156 qemu_get_be16s(f
, &proxy
->vdev
->config_vector
);
158 proxy
->vdev
->config_vector
= VIRTIO_NO_VECTOR
;
160 if (proxy
->vdev
->config_vector
!= VIRTIO_NO_VECTOR
) {
161 return msix_vector_use(&proxy
->pci_dev
, proxy
->vdev
->config_vector
);
166 static int virtio_pci_load_queue(void * opaque
, int n
, QEMUFile
*f
)
168 VirtIOPCIProxy
*proxy
= opaque
;
170 if (msix_present(&proxy
->pci_dev
)) {
171 qemu_get_be16s(f
, &vector
);
173 vector
= VIRTIO_NO_VECTOR
;
175 virtio_queue_set_vector(proxy
->vdev
, n
, vector
);
176 if (vector
!= VIRTIO_NO_VECTOR
) {
177 return msix_vector_use(&proxy
->pci_dev
, vector
);
182 static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy
*proxy
,
185 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, n
);
186 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
189 r
= event_notifier_init(notifier
, 1);
191 error_report("%s: unable to init event notifier: %d",
195 r
= kvm_set_ioeventfd_pio_word(event_notifier_get_fd(notifier
),
196 proxy
->addr
+ VIRTIO_PCI_QUEUE_NOTIFY
,
199 error_report("%s: unable to map ioeventfd: %d",
201 event_notifier_cleanup(notifier
);
204 r
= kvm_set_ioeventfd_pio_word(event_notifier_get_fd(notifier
),
205 proxy
->addr
+ VIRTIO_PCI_QUEUE_NOTIFY
,
208 error_report("%s: unable to unmap ioeventfd: %d",
213 /* Handle the race condition where the guest kicked and we deassigned
214 * before we got around to handling the kick.
216 if (event_notifier_test_and_clear(notifier
)) {
217 virtio_queue_notify_vq(vq
);
220 event_notifier_cleanup(notifier
);
225 static void virtio_pci_host_notifier_read(void *opaque
)
227 VirtQueue
*vq
= opaque
;
228 EventNotifier
*n
= virtio_queue_get_host_notifier(vq
);
229 if (event_notifier_test_and_clear(n
)) {
230 virtio_queue_notify_vq(vq
);
234 static void virtio_pci_set_host_notifier_fd_handler(VirtIOPCIProxy
*proxy
,
237 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, n
);
238 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
240 qemu_set_fd_handler(event_notifier_get_fd(notifier
),
241 virtio_pci_host_notifier_read
, NULL
, vq
);
243 qemu_set_fd_handler(event_notifier_get_fd(notifier
),
248 static void virtio_pci_start_ioeventfd(VirtIOPCIProxy
*proxy
)
252 if (!(proxy
->flags
& VIRTIO_PCI_FLAG_USE_IOEVENTFD
) ||
253 proxy
->ioeventfd_disabled
||
254 proxy
->ioeventfd_started
) {
258 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
259 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
263 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, true);
268 virtio_pci_set_host_notifier_fd_handler(proxy
, n
, true);
270 proxy
->ioeventfd_started
= true;
275 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
279 virtio_pci_set_host_notifier_fd_handler(proxy
, n
, false);
280 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, false);
283 proxy
->ioeventfd_started
= false;
284 error_report("%s: failed. Fallback to a userspace (slower).", __func__
);
287 static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy
*proxy
)
292 if (!proxy
->ioeventfd_started
) {
296 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
297 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
301 virtio_pci_set_host_notifier_fd_handler(proxy
, n
, false);
302 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, false);
305 proxy
->ioeventfd_started
= false;
308 static void virtio_pci_reset(DeviceState
*d
)
310 VirtIOPCIProxy
*proxy
= container_of(d
, VirtIOPCIProxy
, pci_dev
.qdev
);
311 virtio_pci_stop_ioeventfd(proxy
);
312 virtio_reset(proxy
->vdev
);
313 msix_reset(&proxy
->pci_dev
);
314 proxy
->flags
&= ~VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
317 static void virtio_ioport_write(void *opaque
, uint32_t addr
, uint32_t val
)
319 VirtIOPCIProxy
*proxy
= opaque
;
320 VirtIODevice
*vdev
= proxy
->vdev
;
321 target_phys_addr_t pa
;
324 case VIRTIO_PCI_GUEST_FEATURES
:
325 /* Guest does not negotiate properly? We have to assume nothing. */
326 if (val
& (1 << VIRTIO_F_BAD_FEATURE
)) {
327 if (vdev
->bad_features
)
328 val
= proxy
->host_features
& vdev
->bad_features(vdev
);
332 if (vdev
->set_features
)
333 vdev
->set_features(vdev
, val
);
334 vdev
->guest_features
= val
;
336 case VIRTIO_PCI_QUEUE_PFN
:
337 pa
= (target_phys_addr_t
)val
<< VIRTIO_PCI_QUEUE_ADDR_SHIFT
;
339 virtio_pci_stop_ioeventfd(proxy
);
340 virtio_reset(proxy
->vdev
);
341 msix_unuse_all_vectors(&proxy
->pci_dev
);
344 virtio_queue_set_addr(vdev
, vdev
->queue_sel
, pa
);
346 case VIRTIO_PCI_QUEUE_SEL
:
347 if (val
< VIRTIO_PCI_QUEUE_MAX
)
348 vdev
->queue_sel
= val
;
350 case VIRTIO_PCI_QUEUE_NOTIFY
:
351 if (val
< VIRTIO_PCI_QUEUE_MAX
) {
352 virtio_queue_notify(vdev
, val
);
355 case VIRTIO_PCI_STATUS
:
356 if (!(val
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
357 virtio_pci_stop_ioeventfd(proxy
);
360 virtio_set_status(vdev
, val
& 0xFF);
362 if (val
& VIRTIO_CONFIG_S_DRIVER_OK
) {
363 virtio_pci_start_ioeventfd(proxy
);
366 if (vdev
->status
== 0) {
367 virtio_reset(proxy
->vdev
);
368 msix_unuse_all_vectors(&proxy
->pci_dev
);
371 /* Linux before 2.6.34 sets the device as OK without enabling
372 the PCI device bus master bit. In this case we need to disable
373 some safety checks. */
374 if ((val
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
375 !(proxy
->pci_dev
.config
[PCI_COMMAND
] & PCI_COMMAND_MASTER
)) {
376 proxy
->flags
|= VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
379 case VIRTIO_MSI_CONFIG_VECTOR
:
380 msix_vector_unuse(&proxy
->pci_dev
, vdev
->config_vector
);
381 /* Make it possible for guest to discover an error took place. */
382 if (msix_vector_use(&proxy
->pci_dev
, val
) < 0)
383 val
= VIRTIO_NO_VECTOR
;
384 vdev
->config_vector
= val
;
386 case VIRTIO_MSI_QUEUE_VECTOR
:
387 msix_vector_unuse(&proxy
->pci_dev
,
388 virtio_queue_vector(vdev
, vdev
->queue_sel
));
389 /* Make it possible for guest to discover an error took place. */
390 if (msix_vector_use(&proxy
->pci_dev
, val
) < 0)
391 val
= VIRTIO_NO_VECTOR
;
392 virtio_queue_set_vector(vdev
, vdev
->queue_sel
, val
);
395 error_report("%s: unexpected address 0x%x value 0x%x",
396 __func__
, addr
, val
);
401 static uint32_t virtio_ioport_read(VirtIOPCIProxy
*proxy
, uint32_t addr
)
403 VirtIODevice
*vdev
= proxy
->vdev
;
404 uint32_t ret
= 0xFFFFFFFF;
407 case VIRTIO_PCI_HOST_FEATURES
:
408 ret
= proxy
->host_features
;
410 case VIRTIO_PCI_GUEST_FEATURES
:
411 ret
= vdev
->guest_features
;
413 case VIRTIO_PCI_QUEUE_PFN
:
414 ret
= virtio_queue_get_addr(vdev
, vdev
->queue_sel
)
415 >> VIRTIO_PCI_QUEUE_ADDR_SHIFT
;
417 case VIRTIO_PCI_QUEUE_NUM
:
418 ret
= virtio_queue_get_num(vdev
, vdev
->queue_sel
);
420 case VIRTIO_PCI_QUEUE_SEL
:
421 ret
= vdev
->queue_sel
;
423 case VIRTIO_PCI_STATUS
:
427 /* reading from the ISR also clears it. */
430 qemu_set_irq(proxy
->pci_dev
.irq
[0], 0);
432 case VIRTIO_MSI_CONFIG_VECTOR
:
433 ret
= vdev
->config_vector
;
435 case VIRTIO_MSI_QUEUE_VECTOR
:
436 ret
= virtio_queue_vector(vdev
, vdev
->queue_sel
);
445 static uint32_t virtio_pci_config_readb(void *opaque
, uint32_t addr
)
447 VirtIOPCIProxy
*proxy
= opaque
;
448 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
451 return virtio_ioport_read(proxy
, addr
);
453 return virtio_config_readb(proxy
->vdev
, addr
);
456 static uint32_t virtio_pci_config_readw(void *opaque
, uint32_t addr
)
458 VirtIOPCIProxy
*proxy
= opaque
;
459 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
462 return virtio_ioport_read(proxy
, addr
);
464 return virtio_config_readw(proxy
->vdev
, addr
);
467 static uint32_t virtio_pci_config_readl(void *opaque
, uint32_t addr
)
469 VirtIOPCIProxy
*proxy
= opaque
;
470 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
473 return virtio_ioport_read(proxy
, addr
);
475 return virtio_config_readl(proxy
->vdev
, addr
);
478 static void virtio_pci_config_writeb(void *opaque
, uint32_t addr
, uint32_t val
)
480 VirtIOPCIProxy
*proxy
= opaque
;
481 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
484 virtio_ioport_write(proxy
, addr
, val
);
488 virtio_config_writeb(proxy
->vdev
, addr
, val
);
491 static void virtio_pci_config_writew(void *opaque
, uint32_t addr
, uint32_t val
)
493 VirtIOPCIProxy
*proxy
= opaque
;
494 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
497 virtio_ioport_write(proxy
, addr
, val
);
501 virtio_config_writew(proxy
->vdev
, addr
, val
);
504 static void virtio_pci_config_writel(void *opaque
, uint32_t addr
, uint32_t val
)
506 VirtIOPCIProxy
*proxy
= opaque
;
507 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
510 virtio_ioport_write(proxy
, addr
, val
);
514 virtio_config_writel(proxy
->vdev
, addr
, val
);
517 static void virtio_map(PCIDevice
*pci_dev
, int region_num
,
518 pcibus_t addr
, pcibus_t size
, int type
)
520 VirtIOPCIProxy
*proxy
= container_of(pci_dev
, VirtIOPCIProxy
, pci_dev
);
521 VirtIODevice
*vdev
= proxy
->vdev
;
522 unsigned config_len
= VIRTIO_PCI_REGION_SIZE(pci_dev
) + vdev
->config_len
;
526 register_ioport_write(addr
, config_len
, 1, virtio_pci_config_writeb
, proxy
);
527 register_ioport_write(addr
, config_len
, 2, virtio_pci_config_writew
, proxy
);
528 register_ioport_write(addr
, config_len
, 4, virtio_pci_config_writel
, proxy
);
529 register_ioport_read(addr
, config_len
, 1, virtio_pci_config_readb
, proxy
);
530 register_ioport_read(addr
, config_len
, 2, virtio_pci_config_readw
, proxy
);
531 register_ioport_read(addr
, config_len
, 4, virtio_pci_config_readl
, proxy
);
533 if (vdev
->config_len
)
534 vdev
->get_config(vdev
, vdev
->config
);
537 static void virtio_write_config(PCIDevice
*pci_dev
, uint32_t address
,
538 uint32_t val
, int len
)
540 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
542 if (PCI_COMMAND
== address
) {
543 if (!(val
& PCI_COMMAND_MASTER
)) {
544 if (!(proxy
->flags
& VIRTIO_PCI_FLAG_BUS_MASTER_BUG
)) {
545 virtio_pci_stop_ioeventfd(proxy
);
546 virtio_set_status(proxy
->vdev
,
547 proxy
->vdev
->status
& ~VIRTIO_CONFIG_S_DRIVER_OK
);
552 pci_default_write_config(pci_dev
, address
, val
, len
);
553 msix_write_config(pci_dev
, address
, val
, len
);
556 static unsigned virtio_pci_get_features(void *opaque
)
558 VirtIOPCIProxy
*proxy
= opaque
;
559 return proxy
->host_features
;
562 static void virtio_pci_guest_notifier_read(void *opaque
)
564 VirtQueue
*vq
= opaque
;
565 EventNotifier
*n
= virtio_queue_get_guest_notifier(vq
);
566 if (event_notifier_test_and_clear(n
)) {
571 static int virtio_pci_set_guest_notifier(void *opaque
, int n
, bool assign
)
573 VirtIOPCIProxy
*proxy
= opaque
;
574 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, n
);
575 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
578 int r
= event_notifier_init(notifier
, 0);
582 qemu_set_fd_handler(event_notifier_get_fd(notifier
),
583 virtio_pci_guest_notifier_read
, NULL
, vq
);
585 qemu_set_fd_handler(event_notifier_get_fd(notifier
),
587 event_notifier_cleanup(notifier
);
593 static bool virtio_pci_query_guest_notifiers(void *opaque
)
595 VirtIOPCIProxy
*proxy
= opaque
;
596 return msix_enabled(&proxy
->pci_dev
);
599 static int virtio_pci_set_guest_notifiers(void *opaque
, bool assign
)
601 VirtIOPCIProxy
*proxy
= opaque
;
602 VirtIODevice
*vdev
= proxy
->vdev
;
605 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
606 if (!virtio_queue_get_num(vdev
, n
)) {
610 r
= virtio_pci_set_guest_notifier(opaque
, n
, assign
);
619 /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
621 virtio_pci_set_guest_notifier(opaque
, n
, !assign
);
626 static int virtio_pci_set_host_notifier(void *opaque
, int n
, bool assign
)
628 VirtIOPCIProxy
*proxy
= opaque
;
630 /* Stop using ioeventfd for virtqueue kick if the device starts using host
631 * notifiers. This makes it easy to avoid stepping on each others' toes.
633 proxy
->ioeventfd_disabled
= assign
;
635 virtio_pci_stop_ioeventfd(proxy
);
637 /* We don't need to start here: it's not needed because backend
638 * currently only stops on status change away from ok,
639 * reset, vmstop and such. If we do add code to start here,
640 * need to check vmstate, device state etc. */
641 return virtio_pci_set_host_notifier_internal(proxy
, n
, assign
);
644 static void virtio_pci_vmstate_change(void *opaque
, bool running
)
646 VirtIOPCIProxy
*proxy
= opaque
;
649 /* Try to find out if the guest has bus master disabled, but is
650 in ready state. Then we have a buggy guest OS. */
651 if ((proxy
->vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
652 !(proxy
->pci_dev
.config
[PCI_COMMAND
] & PCI_COMMAND_MASTER
)) {
653 proxy
->flags
|= VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
655 virtio_pci_start_ioeventfd(proxy
);
657 virtio_pci_stop_ioeventfd(proxy
);
661 static const VirtIOBindings virtio_pci_bindings
= {
662 .notify
= virtio_pci_notify
,
663 .save_config
= virtio_pci_save_config
,
664 .load_config
= virtio_pci_load_config
,
665 .save_queue
= virtio_pci_save_queue
,
666 .load_queue
= virtio_pci_load_queue
,
667 .get_features
= virtio_pci_get_features
,
668 .query_guest_notifiers
= virtio_pci_query_guest_notifiers
,
669 .set_host_notifier
= virtio_pci_set_host_notifier
,
670 .set_guest_notifiers
= virtio_pci_set_guest_notifiers
,
671 .vmstate_change
= virtio_pci_vmstate_change
,
674 static void virtio_init_pci(VirtIOPCIProxy
*proxy
, VirtIODevice
*vdev
)
681 config
= proxy
->pci_dev
.config
;
683 if (proxy
->class_code
) {
684 pci_config_set_class(config
, proxy
->class_code
);
686 pci_set_word(config
+ 0x2c, pci_get_word(config
+ PCI_VENDOR_ID
));
687 pci_set_word(config
+ 0x2e, vdev
->device_id
);
690 if (vdev
->nvectors
&& !msix_init(&proxy
->pci_dev
, vdev
->nvectors
, 1, 0)) {
691 pci_register_bar(&proxy
->pci_dev
, 1,
692 msix_bar_size(&proxy
->pci_dev
),
693 PCI_BASE_ADDRESS_SPACE_MEMORY
,
698 proxy
->pci_dev
.config_write
= virtio_write_config
;
700 size
= VIRTIO_PCI_REGION_SIZE(&proxy
->pci_dev
) + vdev
->config_len
;
702 size
= 1 << qemu_fls(size
);
704 pci_register_bar(&proxy
->pci_dev
, 0, size
, PCI_BASE_ADDRESS_SPACE_IO
,
707 if (!kvm_has_many_ioeventfds()) {
708 proxy
->flags
&= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD
;
711 virtio_bind_device(vdev
, &virtio_pci_bindings
, proxy
);
712 proxy
->host_features
|= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY
;
713 proxy
->host_features
|= 0x1 << VIRTIO_F_BAD_FEATURE
;
714 proxy
->host_features
= vdev
->get_features(vdev
, proxy
->host_features
);
717 static int virtio_blk_init_pci(PCIDevice
*pci_dev
)
719 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
722 if (proxy
->class_code
!= PCI_CLASS_STORAGE_SCSI
&&
723 proxy
->class_code
!= PCI_CLASS_STORAGE_OTHER
)
724 proxy
->class_code
= PCI_CLASS_STORAGE_SCSI
;
726 vdev
= virtio_blk_init(&pci_dev
->qdev
, &proxy
->block
);
730 vdev
->nvectors
= proxy
->nvectors
;
731 virtio_init_pci(proxy
, vdev
);
732 /* make the actual value visible */
733 proxy
->nvectors
= vdev
->nvectors
;
737 static int virtio_exit_pci(PCIDevice
*pci_dev
)
739 return msix_uninit(pci_dev
);
742 static int virtio_blk_exit_pci(PCIDevice
*pci_dev
)
744 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
746 virtio_pci_stop_ioeventfd(proxy
);
747 virtio_blk_exit(proxy
->vdev
);
748 blockdev_mark_auto_del(proxy
->block
.bs
);
749 return virtio_exit_pci(pci_dev
);
752 static int virtio_serial_init_pci(PCIDevice
*pci_dev
)
754 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
757 if (proxy
->class_code
!= PCI_CLASS_COMMUNICATION_OTHER
&&
758 proxy
->class_code
!= PCI_CLASS_DISPLAY_OTHER
&& /* qemu 0.10 */
759 proxy
->class_code
!= PCI_CLASS_OTHERS
) /* qemu-kvm */
760 proxy
->class_code
= PCI_CLASS_COMMUNICATION_OTHER
;
762 vdev
= virtio_serial_init(&pci_dev
->qdev
, &proxy
->serial
);
766 vdev
->nvectors
= proxy
->nvectors
== DEV_NVECTORS_UNSPECIFIED
767 ? proxy
->serial
.max_virtserial_ports
+ 1
769 virtio_init_pci(proxy
, vdev
);
770 proxy
->nvectors
= vdev
->nvectors
;
774 static int virtio_serial_exit_pci(PCIDevice
*pci_dev
)
776 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
778 virtio_pci_stop_ioeventfd(proxy
);
779 virtio_serial_exit(proxy
->vdev
);
780 return virtio_exit_pci(pci_dev
);
783 static int virtio_net_init_pci(PCIDevice
*pci_dev
)
785 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
788 vdev
= virtio_net_init(&pci_dev
->qdev
, &proxy
->nic
, &proxy
->net
);
790 vdev
->nvectors
= proxy
->nvectors
;
791 virtio_init_pci(proxy
, vdev
);
793 /* make the actual value visible */
794 proxy
->nvectors
= vdev
->nvectors
;
798 static int virtio_net_exit_pci(PCIDevice
*pci_dev
)
800 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
802 virtio_pci_stop_ioeventfd(proxy
);
803 virtio_net_exit(proxy
->vdev
);
804 return virtio_exit_pci(pci_dev
);
807 static int virtio_balloon_init_pci(PCIDevice
*pci_dev
)
809 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
812 vdev
= virtio_balloon_init(&pci_dev
->qdev
);
813 virtio_init_pci(proxy
, vdev
);
818 static int virtio_9p_init_pci(PCIDevice
*pci_dev
)
820 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
823 vdev
= virtio_9p_init(&pci_dev
->qdev
, &proxy
->fsconf
);
824 vdev
->nvectors
= proxy
->nvectors
;
825 virtio_init_pci(proxy
, vdev
);
826 /* make the actual value visible */
827 proxy
->nvectors
= vdev
->nvectors
;
832 static PCIDeviceInfo virtio_info
[] = {
834 .qdev
.name
= "virtio-blk-pci",
835 .qdev
.alias
= "virtio-blk",
836 .qdev
.size
= sizeof(VirtIOPCIProxy
),
837 .init
= virtio_blk_init_pci
,
838 .exit
= virtio_blk_exit_pci
,
839 .vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
,
840 .device_id
= PCI_DEVICE_ID_VIRTIO_BLOCK
,
841 .revision
= VIRTIO_PCI_ABI_VERSION
,
842 .class_id
= PCI_CLASS_STORAGE_SCSI
,
843 .qdev
.props
= (Property
[]) {
844 DEFINE_PROP_HEX32("class", VirtIOPCIProxy
, class_code
, 0),
845 DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy
, block
),
846 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
,
847 VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, true),
848 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, 2),
849 DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy
, host_features
),
850 DEFINE_PROP_END_OF_LIST(),
852 .qdev
.reset
= virtio_pci_reset
,
854 .qdev
.name
= "virtio-net-pci",
855 .qdev
.alias
= "virtio-net",
856 .qdev
.size
= sizeof(VirtIOPCIProxy
),
857 .init
= virtio_net_init_pci
,
858 .exit
= virtio_net_exit_pci
,
859 .romfile
= "pxe-virtio.rom",
860 .vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
,
861 .device_id
= PCI_DEVICE_ID_VIRTIO_NET
,
862 .revision
= VIRTIO_PCI_ABI_VERSION
,
863 .class_id
= PCI_CLASS_NETWORK_ETHERNET
,
864 .qdev
.props
= (Property
[]) {
865 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
,
866 VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, false),
867 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, 3),
868 DEFINE_VIRTIO_NET_FEATURES(VirtIOPCIProxy
, host_features
),
869 DEFINE_NIC_PROPERTIES(VirtIOPCIProxy
, nic
),
870 DEFINE_PROP_UINT32("x-txtimer", VirtIOPCIProxy
,
871 net
.txtimer
, TX_TIMER_INTERVAL
),
872 DEFINE_PROP_INT32("x-txburst", VirtIOPCIProxy
,
873 net
.txburst
, TX_BURST
),
874 DEFINE_PROP_STRING("tx", VirtIOPCIProxy
, net
.tx
),
875 DEFINE_PROP_END_OF_LIST(),
877 .qdev
.reset
= virtio_pci_reset
,
879 .qdev
.name
= "virtio-serial-pci",
880 .qdev
.alias
= "virtio-serial",
881 .qdev
.size
= sizeof(VirtIOPCIProxy
),
882 .init
= virtio_serial_init_pci
,
883 .exit
= virtio_serial_exit_pci
,
884 .vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
,
885 .device_id
= PCI_DEVICE_ID_VIRTIO_CONSOLE
,
886 .revision
= VIRTIO_PCI_ABI_VERSION
,
887 .class_id
= PCI_CLASS_COMMUNICATION_OTHER
,
888 .qdev
.props
= (Property
[]) {
889 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
,
890 VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, true),
891 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
,
892 DEV_NVECTORS_UNSPECIFIED
),
893 DEFINE_PROP_HEX32("class", VirtIOPCIProxy
, class_code
, 0),
894 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy
, host_features
),
895 DEFINE_PROP_UINT32("max_ports", VirtIOPCIProxy
,
896 serial
.max_virtserial_ports
, 31),
897 DEFINE_PROP_END_OF_LIST(),
899 .qdev
.reset
= virtio_pci_reset
,
901 .qdev
.name
= "virtio-balloon-pci",
902 .qdev
.alias
= "virtio-balloon",
903 .qdev
.size
= sizeof(VirtIOPCIProxy
),
904 .init
= virtio_balloon_init_pci
,
905 .exit
= virtio_exit_pci
,
906 .vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
,
907 .device_id
= PCI_DEVICE_ID_VIRTIO_BALLOON
,
908 .revision
= VIRTIO_PCI_ABI_VERSION
,
909 .class_id
= PCI_CLASS_MEMORY_RAM
,
910 .qdev
.props
= (Property
[]) {
911 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy
, host_features
),
912 DEFINE_PROP_END_OF_LIST(),
914 .qdev
.reset
= virtio_pci_reset
,
917 .qdev
.name
= "virtio-9p-pci",
918 .qdev
.alias
= "virtio-9p",
919 .qdev
.size
= sizeof(VirtIOPCIProxy
),
920 .init
= virtio_9p_init_pci
,
921 .vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
,
923 .revision
= VIRTIO_PCI_ABI_VERSION
,
925 .qdev
.props
= (Property
[]) {
926 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, 2),
927 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy
, host_features
),
928 DEFINE_PROP_STRING("mount_tag", VirtIOPCIProxy
, fsconf
.tag
),
929 DEFINE_PROP_STRING("fsdev", VirtIOPCIProxy
, fsconf
.fsdev_id
),
930 DEFINE_PROP_END_OF_LIST(),
938 static void virtio_pci_register_devices(void)
940 pci_qdev_register_many(virtio_info
);
943 device_init(virtio_pci_register_devices
)