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);
99 /* DeviceState to VirtIOPCIProxy. For use off data-path. TODO: use QOM. */
100 static inline VirtIOPCIProxy
*to_virtio_pci_proxy(DeviceState
*d
)
102 return container_of(d
, VirtIOPCIProxy
, pci_dev
.qdev
);
105 /* DeviceState to VirtIOPCIProxy. Note: used on datapath,
106 * be careful and test performance if you change this.
108 static inline VirtIOPCIProxy
*to_virtio_pci_proxy_fast(DeviceState
*d
)
110 return container_of(d
, VirtIOPCIProxy
, pci_dev
.qdev
);
113 static void virtio_pci_notify(DeviceState
*d
, uint16_t vector
)
115 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy_fast(d
);
116 if (msix_enabled(&proxy
->pci_dev
))
117 msix_notify(&proxy
->pci_dev
, vector
);
119 qemu_set_irq(proxy
->pci_dev
.irq
[0], proxy
->vdev
->isr
& 1);
122 static void virtio_pci_save_config(DeviceState
*d
, QEMUFile
*f
)
124 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy(d
);
125 pci_device_save(&proxy
->pci_dev
, f
);
126 msix_save(&proxy
->pci_dev
, f
);
127 if (msix_present(&proxy
->pci_dev
))
128 qemu_put_be16(f
, proxy
->vdev
->config_vector
);
131 static void virtio_pci_save_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
133 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy(d
);
134 if (msix_present(&proxy
->pci_dev
))
135 qemu_put_be16(f
, virtio_queue_vector(proxy
->vdev
, n
));
138 static int virtio_pci_load_config(DeviceState
*d
, QEMUFile
*f
)
140 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy(d
);
142 ret
= pci_device_load(&proxy
->pci_dev
, f
);
146 msix_unuse_all_vectors(&proxy
->pci_dev
);
147 msix_load(&proxy
->pci_dev
, f
);
148 if (msix_present(&proxy
->pci_dev
)) {
149 qemu_get_be16s(f
, &proxy
->vdev
->config_vector
);
151 proxy
->vdev
->config_vector
= VIRTIO_NO_VECTOR
;
153 if (proxy
->vdev
->config_vector
!= VIRTIO_NO_VECTOR
) {
154 return msix_vector_use(&proxy
->pci_dev
, proxy
->vdev
->config_vector
);
159 static int virtio_pci_load_queue(DeviceState
*d
, int n
, QEMUFile
*f
)
161 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy(d
);
163 if (msix_present(&proxy
->pci_dev
)) {
164 qemu_get_be16s(f
, &vector
);
166 vector
= VIRTIO_NO_VECTOR
;
168 virtio_queue_set_vector(proxy
->vdev
, n
, vector
);
169 if (vector
!= VIRTIO_NO_VECTOR
) {
170 return msix_vector_use(&proxy
->pci_dev
, vector
);
175 static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy
*proxy
,
176 int n
, bool assign
, bool set_handler
)
178 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, n
);
179 EventNotifier
*notifier
= virtio_queue_get_host_notifier(vq
);
183 r
= event_notifier_init(notifier
, 1);
185 error_report("%s: unable to init event notifier: %d",
189 virtio_queue_set_host_notifier_fd_handler(vq
, true, set_handler
);
190 memory_region_add_eventfd(&proxy
->bar
, VIRTIO_PCI_QUEUE_NOTIFY
, 2,
193 memory_region_del_eventfd(&proxy
->bar
, VIRTIO_PCI_QUEUE_NOTIFY
, 2,
195 virtio_queue_set_host_notifier_fd_handler(vq
, false, false);
196 event_notifier_cleanup(notifier
);
201 static void virtio_pci_start_ioeventfd(VirtIOPCIProxy
*proxy
)
205 if (!(proxy
->flags
& VIRTIO_PCI_FLAG_USE_IOEVENTFD
) ||
206 proxy
->ioeventfd_disabled
||
207 proxy
->ioeventfd_started
) {
211 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
212 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
216 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, true, true);
221 proxy
->ioeventfd_started
= true;
226 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
230 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, false, false);
233 proxy
->ioeventfd_started
= false;
234 error_report("%s: failed. Fallback to a userspace (slower).", __func__
);
237 static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy
*proxy
)
242 if (!proxy
->ioeventfd_started
) {
246 for (n
= 0; n
< VIRTIO_PCI_QUEUE_MAX
; n
++) {
247 if (!virtio_queue_get_num(proxy
->vdev
, n
)) {
251 r
= virtio_pci_set_host_notifier_internal(proxy
, n
, false, false);
254 proxy
->ioeventfd_started
= false;
257 void virtio_pci_reset(DeviceState
*d
)
259 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy(d
);
260 virtio_pci_stop_ioeventfd(proxy
);
261 virtio_reset(proxy
->vdev
);
262 msix_unuse_all_vectors(&proxy
->pci_dev
);
263 proxy
->flags
&= ~VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
266 static void virtio_ioport_write(void *opaque
, uint32_t addr
, uint32_t val
)
268 VirtIOPCIProxy
*proxy
= opaque
;
269 VirtIODevice
*vdev
= proxy
->vdev
;
273 case VIRTIO_PCI_GUEST_FEATURES
:
274 /* Guest does not negotiate properly? We have to assume nothing. */
275 if (val
& (1 << VIRTIO_F_BAD_FEATURE
)) {
276 val
= vdev
->bad_features
? vdev
->bad_features(vdev
) : 0;
278 virtio_set_features(vdev
, val
);
280 case VIRTIO_PCI_QUEUE_PFN
:
281 pa
= (hwaddr
)val
<< VIRTIO_PCI_QUEUE_ADDR_SHIFT
;
283 virtio_pci_stop_ioeventfd(proxy
);
284 virtio_reset(proxy
->vdev
);
285 msix_unuse_all_vectors(&proxy
->pci_dev
);
288 virtio_queue_set_addr(vdev
, vdev
->queue_sel
, pa
);
290 case VIRTIO_PCI_QUEUE_SEL
:
291 if (val
< VIRTIO_PCI_QUEUE_MAX
)
292 vdev
->queue_sel
= val
;
294 case VIRTIO_PCI_QUEUE_NOTIFY
:
295 if (val
< VIRTIO_PCI_QUEUE_MAX
) {
296 virtio_queue_notify(vdev
, val
);
299 case VIRTIO_PCI_STATUS
:
300 if (!(val
& VIRTIO_CONFIG_S_DRIVER_OK
)) {
301 virtio_pci_stop_ioeventfd(proxy
);
304 virtio_set_status(vdev
, val
& 0xFF);
306 if (val
& VIRTIO_CONFIG_S_DRIVER_OK
) {
307 virtio_pci_start_ioeventfd(proxy
);
310 if (vdev
->status
== 0) {
311 virtio_reset(proxy
->vdev
);
312 msix_unuse_all_vectors(&proxy
->pci_dev
);
315 /* Linux before 2.6.34 sets the device as OK without enabling
316 the PCI device bus master bit. In this case we need to disable
317 some safety checks. */
318 if ((val
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
319 !(proxy
->pci_dev
.config
[PCI_COMMAND
] & PCI_COMMAND_MASTER
)) {
320 proxy
->flags
|= VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
323 case VIRTIO_MSI_CONFIG_VECTOR
:
324 msix_vector_unuse(&proxy
->pci_dev
, vdev
->config_vector
);
325 /* Make it possible for guest to discover an error took place. */
326 if (msix_vector_use(&proxy
->pci_dev
, val
) < 0)
327 val
= VIRTIO_NO_VECTOR
;
328 vdev
->config_vector
= val
;
330 case VIRTIO_MSI_QUEUE_VECTOR
:
331 msix_vector_unuse(&proxy
->pci_dev
,
332 virtio_queue_vector(vdev
, vdev
->queue_sel
));
333 /* Make it possible for guest to discover an error took place. */
334 if (msix_vector_use(&proxy
->pci_dev
, val
) < 0)
335 val
= VIRTIO_NO_VECTOR
;
336 virtio_queue_set_vector(vdev
, vdev
->queue_sel
, val
);
339 error_report("%s: unexpected address 0x%x value 0x%x",
340 __func__
, addr
, val
);
345 static uint32_t virtio_ioport_read(VirtIOPCIProxy
*proxy
, uint32_t addr
)
347 VirtIODevice
*vdev
= proxy
->vdev
;
348 uint32_t ret
= 0xFFFFFFFF;
351 case VIRTIO_PCI_HOST_FEATURES
:
352 ret
= proxy
->host_features
;
354 case VIRTIO_PCI_GUEST_FEATURES
:
355 ret
= vdev
->guest_features
;
357 case VIRTIO_PCI_QUEUE_PFN
:
358 ret
= virtio_queue_get_addr(vdev
, vdev
->queue_sel
)
359 >> VIRTIO_PCI_QUEUE_ADDR_SHIFT
;
361 case VIRTIO_PCI_QUEUE_NUM
:
362 ret
= virtio_queue_get_num(vdev
, vdev
->queue_sel
);
364 case VIRTIO_PCI_QUEUE_SEL
:
365 ret
= vdev
->queue_sel
;
367 case VIRTIO_PCI_STATUS
:
371 /* reading from the ISR also clears it. */
374 qemu_set_irq(proxy
->pci_dev
.irq
[0], 0);
376 case VIRTIO_MSI_CONFIG_VECTOR
:
377 ret
= vdev
->config_vector
;
379 case VIRTIO_MSI_QUEUE_VECTOR
:
380 ret
= virtio_queue_vector(vdev
, vdev
->queue_sel
);
389 static uint64_t virtio_pci_config_read(void *opaque
, hwaddr addr
,
392 VirtIOPCIProxy
*proxy
= opaque
;
393 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
396 return virtio_ioport_read(proxy
, addr
);
402 val
= virtio_config_readb(proxy
->vdev
, addr
);
405 val
= virtio_config_readw(proxy
->vdev
, addr
);
406 if (virtio_is_big_endian()) {
411 val
= virtio_config_readl(proxy
->vdev
, addr
);
412 if (virtio_is_big_endian()) {
420 static void virtio_pci_config_write(void *opaque
, hwaddr addr
,
421 uint64_t val
, unsigned size
)
423 VirtIOPCIProxy
*proxy
= opaque
;
424 uint32_t config
= VIRTIO_PCI_CONFIG(&proxy
->pci_dev
);
426 virtio_ioport_write(proxy
, addr
, val
);
431 * Virtio-PCI is odd. Ioports are LE but config space is target native
436 virtio_config_writeb(proxy
->vdev
, addr
, val
);
439 if (virtio_is_big_endian()) {
442 virtio_config_writew(proxy
->vdev
, addr
, val
);
445 if (virtio_is_big_endian()) {
448 virtio_config_writel(proxy
->vdev
, addr
, val
);
453 static const MemoryRegionOps virtio_pci_config_ops
= {
454 .read
= virtio_pci_config_read
,
455 .write
= virtio_pci_config_write
,
457 .min_access_size
= 1,
458 .max_access_size
= 4,
460 .endianness
= DEVICE_LITTLE_ENDIAN
,
463 static void virtio_write_config(PCIDevice
*pci_dev
, uint32_t address
,
464 uint32_t val
, int len
)
466 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
468 pci_default_write_config(pci_dev
, address
, val
, len
);
470 if (range_covers_byte(address
, len
, PCI_COMMAND
) &&
471 !(pci_dev
->config
[PCI_COMMAND
] & PCI_COMMAND_MASTER
) &&
472 !(proxy
->flags
& VIRTIO_PCI_FLAG_BUS_MASTER_BUG
)) {
473 virtio_pci_stop_ioeventfd(proxy
);
474 virtio_set_status(proxy
->vdev
,
475 proxy
->vdev
->status
& ~VIRTIO_CONFIG_S_DRIVER_OK
);
479 static unsigned virtio_pci_get_features(DeviceState
*d
)
481 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy(d
);
482 return proxy
->host_features
;
485 static int kvm_virtio_pci_vq_vector_use(VirtIOPCIProxy
*proxy
,
486 unsigned int queue_no
,
490 VirtIOIRQFD
*irqfd
= &proxy
->vector_irqfd
[vector
];
493 if (irqfd
->users
== 0) {
494 ret
= kvm_irqchip_add_msi_route(kvm_state
, msg
);
504 static void kvm_virtio_pci_vq_vector_release(VirtIOPCIProxy
*proxy
,
507 VirtIOIRQFD
*irqfd
= &proxy
->vector_irqfd
[vector
];
508 if (--irqfd
->users
== 0) {
509 kvm_irqchip_release_virq(kvm_state
, irqfd
->virq
);
513 static int kvm_virtio_pci_irqfd_use(VirtIOPCIProxy
*proxy
,
514 unsigned int queue_no
,
517 VirtIOIRQFD
*irqfd
= &proxy
->vector_irqfd
[vector
];
518 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, queue_no
);
519 EventNotifier
*n
= virtio_queue_get_guest_notifier(vq
);
521 ret
= kvm_irqchip_add_irqfd_notifier(kvm_state
, n
, irqfd
->virq
);
525 static void kvm_virtio_pci_irqfd_release(VirtIOPCIProxy
*proxy
,
526 unsigned int queue_no
,
529 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, queue_no
);
530 EventNotifier
*n
= virtio_queue_get_guest_notifier(vq
);
531 VirtIOIRQFD
*irqfd
= &proxy
->vector_irqfd
[vector
];
534 ret
= kvm_irqchip_remove_irqfd_notifier(kvm_state
, n
, irqfd
->virq
);
538 static int kvm_virtio_pci_vector_use(VirtIOPCIProxy
*proxy
, int nvqs
)
540 PCIDevice
*dev
= &proxy
->pci_dev
;
541 VirtIODevice
*vdev
= proxy
->vdev
;
546 for (queue_no
= 0; queue_no
< nvqs
; queue_no
++) {
547 if (!virtio_queue_get_num(vdev
, queue_no
)) {
550 vector
= virtio_queue_vector(vdev
, queue_no
);
551 if (vector
>= msix_nr_vectors_allocated(dev
)) {
554 msg
= msix_get_message(dev
, vector
);
555 ret
= kvm_virtio_pci_vq_vector_use(proxy
, queue_no
, vector
, msg
);
559 /* If guest supports masking, set up irqfd now.
560 * Otherwise, delay until unmasked in the frontend.
562 if (proxy
->vdev
->guest_notifier_mask
) {
563 ret
= kvm_virtio_pci_irqfd_use(proxy
, queue_no
, vector
);
565 kvm_virtio_pci_vq_vector_release(proxy
, vector
);
573 while (--queue_no
>= 0) {
574 vector
= virtio_queue_vector(vdev
, queue_no
);
575 if (vector
>= msix_nr_vectors_allocated(dev
)) {
578 if (proxy
->vdev
->guest_notifier_mask
) {
579 kvm_virtio_pci_irqfd_release(proxy
, queue_no
, vector
);
581 kvm_virtio_pci_vq_vector_release(proxy
, vector
);
586 static void kvm_virtio_pci_vector_release(VirtIOPCIProxy
*proxy
, int nvqs
)
588 PCIDevice
*dev
= &proxy
->pci_dev
;
589 VirtIODevice
*vdev
= proxy
->vdev
;
593 for (queue_no
= 0; queue_no
< nvqs
; queue_no
++) {
594 if (!virtio_queue_get_num(vdev
, queue_no
)) {
597 vector
= virtio_queue_vector(vdev
, queue_no
);
598 if (vector
>= msix_nr_vectors_allocated(dev
)) {
601 /* If guest supports masking, clean up irqfd now.
602 * Otherwise, it was cleaned when masked in the frontend.
604 if (proxy
->vdev
->guest_notifier_mask
) {
605 kvm_virtio_pci_irqfd_release(proxy
, queue_no
, vector
);
607 kvm_virtio_pci_vq_vector_release(proxy
, vector
);
611 static int kvm_virtio_pci_vq_vector_unmask(VirtIOPCIProxy
*proxy
,
612 unsigned int queue_no
,
616 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, queue_no
);
617 EventNotifier
*n
= virtio_queue_get_guest_notifier(vq
);
618 VirtIOIRQFD
*irqfd
= &proxy
->vector_irqfd
[vector
];
621 if (irqfd
->msg
.data
!= msg
.data
|| irqfd
->msg
.address
!= msg
.address
) {
622 ret
= kvm_irqchip_update_msi_route(kvm_state
, irqfd
->virq
, msg
);
628 /* If guest supports masking, irqfd is already setup, unmask it.
629 * Otherwise, set it up now.
631 if (proxy
->vdev
->guest_notifier_mask
) {
632 proxy
->vdev
->guest_notifier_mask(proxy
->vdev
, queue_no
, false);
633 /* Test after unmasking to avoid losing events. */
634 if (proxy
->vdev
->guest_notifier_pending
&&
635 proxy
->vdev
->guest_notifier_pending(proxy
->vdev
, queue_no
)) {
636 event_notifier_set(n
);
639 ret
= kvm_virtio_pci_irqfd_use(proxy
, queue_no
, vector
);
644 static void kvm_virtio_pci_vq_vector_mask(VirtIOPCIProxy
*proxy
,
645 unsigned int queue_no
,
648 /* If guest supports masking, keep irqfd but mask it.
649 * Otherwise, clean it up now.
651 if (proxy
->vdev
->guest_notifier_mask
) {
652 proxy
->vdev
->guest_notifier_mask(proxy
->vdev
, queue_no
, true);
654 kvm_virtio_pci_irqfd_release(proxy
, queue_no
, vector
);
658 static int kvm_virtio_pci_vector_unmask(PCIDevice
*dev
, unsigned vector
,
661 VirtIOPCIProxy
*proxy
= container_of(dev
, VirtIOPCIProxy
, pci_dev
);
662 VirtIODevice
*vdev
= proxy
->vdev
;
665 for (queue_no
= 0; queue_no
< proxy
->nvqs_with_notifiers
; queue_no
++) {
666 if (!virtio_queue_get_num(vdev
, queue_no
)) {
669 if (virtio_queue_vector(vdev
, queue_no
) != vector
) {
672 ret
= kvm_virtio_pci_vq_vector_unmask(proxy
, queue_no
, vector
, msg
);
680 while (--queue_no
>= 0) {
681 if (virtio_queue_vector(vdev
, queue_no
) != vector
) {
684 kvm_virtio_pci_vq_vector_mask(proxy
, queue_no
, vector
);
689 static void kvm_virtio_pci_vector_mask(PCIDevice
*dev
, unsigned vector
)
691 VirtIOPCIProxy
*proxy
= container_of(dev
, VirtIOPCIProxy
, pci_dev
);
692 VirtIODevice
*vdev
= proxy
->vdev
;
695 for (queue_no
= 0; queue_no
< proxy
->nvqs_with_notifiers
; queue_no
++) {
696 if (!virtio_queue_get_num(vdev
, queue_no
)) {
699 if (virtio_queue_vector(vdev
, queue_no
) != vector
) {
702 kvm_virtio_pci_vq_vector_mask(proxy
, queue_no
, vector
);
706 static void kvm_virtio_pci_vector_poll(PCIDevice
*dev
,
707 unsigned int vector_start
,
708 unsigned int vector_end
)
710 VirtIOPCIProxy
*proxy
= container_of(dev
, VirtIOPCIProxy
, pci_dev
);
711 VirtIODevice
*vdev
= proxy
->vdev
;
714 EventNotifier
*notifier
;
717 for (queue_no
= 0; queue_no
< proxy
->nvqs_with_notifiers
; queue_no
++) {
718 if (!virtio_queue_get_num(vdev
, queue_no
)) {
721 vector
= virtio_queue_vector(vdev
, queue_no
);
722 if (vector
< vector_start
|| vector
>= vector_end
||
723 !msix_is_masked(dev
, vector
)) {
726 vq
= virtio_get_queue(vdev
, queue_no
);
727 notifier
= virtio_queue_get_guest_notifier(vq
);
728 if (vdev
->guest_notifier_pending
) {
729 if (vdev
->guest_notifier_pending(vdev
, queue_no
)) {
730 msix_set_pending(dev
, vector
);
732 } else if (event_notifier_test_and_clear(notifier
)) {
733 msix_set_pending(dev
, vector
);
738 static int virtio_pci_set_guest_notifier(DeviceState
*d
, int n
, bool assign
,
741 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy(d
);
742 VirtQueue
*vq
= virtio_get_queue(proxy
->vdev
, n
);
743 EventNotifier
*notifier
= virtio_queue_get_guest_notifier(vq
);
746 int r
= event_notifier_init(notifier
, 0);
750 virtio_queue_set_guest_notifier_fd_handler(vq
, true, with_irqfd
);
752 virtio_queue_set_guest_notifier_fd_handler(vq
, false, with_irqfd
);
753 event_notifier_cleanup(notifier
);
759 static bool virtio_pci_query_guest_notifiers(DeviceState
*d
)
761 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy(d
);
762 return msix_enabled(&proxy
->pci_dev
);
765 static int virtio_pci_set_guest_notifiers(DeviceState
*d
, int nvqs
, bool assign
)
767 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy(d
);
768 VirtIODevice
*vdev
= proxy
->vdev
;
770 bool with_irqfd
= msix_enabled(&proxy
->pci_dev
) &&
771 kvm_msi_via_irqfd_enabled();
773 nvqs
= MIN(nvqs
, VIRTIO_PCI_QUEUE_MAX
);
775 /* When deassigning, pass a consistent nvqs value
776 * to avoid leaking notifiers.
778 assert(assign
|| nvqs
== proxy
->nvqs_with_notifiers
);
780 proxy
->nvqs_with_notifiers
= nvqs
;
782 /* Must unset vector notifier while guest notifier is still assigned */
783 if (proxy
->vector_irqfd
&& !assign
) {
784 msix_unset_vector_notifiers(&proxy
->pci_dev
);
785 kvm_virtio_pci_vector_release(proxy
, nvqs
);
786 g_free(proxy
->vector_irqfd
);
787 proxy
->vector_irqfd
= NULL
;
790 for (n
= 0; n
< nvqs
; n
++) {
791 if (!virtio_queue_get_num(vdev
, n
)) {
795 r
= virtio_pci_set_guest_notifier(d
, n
, assign
,
796 kvm_msi_via_irqfd_enabled());
802 /* Must set vector notifier after guest notifier has been assigned */
803 if (with_irqfd
&& assign
) {
804 proxy
->vector_irqfd
=
805 g_malloc0(sizeof(*proxy
->vector_irqfd
) *
806 msix_nr_vectors_allocated(&proxy
->pci_dev
));
807 r
= kvm_virtio_pci_vector_use(proxy
, nvqs
);
811 r
= msix_set_vector_notifiers(&proxy
->pci_dev
,
812 kvm_virtio_pci_vector_unmask
,
813 kvm_virtio_pci_vector_mask
,
814 kvm_virtio_pci_vector_poll
);
816 goto notifiers_error
;
824 kvm_virtio_pci_vector_release(proxy
, nvqs
);
827 /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
830 virtio_pci_set_guest_notifier(d
, n
, !assign
, with_irqfd
);
835 static int virtio_pci_set_host_notifier(DeviceState
*d
, int n
, bool assign
)
837 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy(d
);
839 /* Stop using ioeventfd for virtqueue kick if the device starts using host
840 * notifiers. This makes it easy to avoid stepping on each others' toes.
842 proxy
->ioeventfd_disabled
= assign
;
844 virtio_pci_stop_ioeventfd(proxy
);
846 /* We don't need to start here: it's not needed because backend
847 * currently only stops on status change away from ok,
848 * reset, vmstop and such. If we do add code to start here,
849 * need to check vmstate, device state etc. */
850 return virtio_pci_set_host_notifier_internal(proxy
, n
, assign
, false);
853 static void virtio_pci_vmstate_change(DeviceState
*d
, bool running
)
855 VirtIOPCIProxy
*proxy
= to_virtio_pci_proxy(d
);
858 /* Try to find out if the guest has bus master disabled, but is
859 in ready state. Then we have a buggy guest OS. */
860 if ((proxy
->vdev
->status
& VIRTIO_CONFIG_S_DRIVER_OK
) &&
861 !(proxy
->pci_dev
.config
[PCI_COMMAND
] & PCI_COMMAND_MASTER
)) {
862 proxy
->flags
|= VIRTIO_PCI_FLAG_BUS_MASTER_BUG
;
864 virtio_pci_start_ioeventfd(proxy
);
866 virtio_pci_stop_ioeventfd(proxy
);
870 static const VirtIOBindings virtio_pci_bindings
= {
871 .notify
= virtio_pci_notify
,
872 .save_config
= virtio_pci_save_config
,
873 .load_config
= virtio_pci_load_config
,
874 .save_queue
= virtio_pci_save_queue
,
875 .load_queue
= virtio_pci_load_queue
,
876 .get_features
= virtio_pci_get_features
,
877 .query_guest_notifiers
= virtio_pci_query_guest_notifiers
,
878 .set_host_notifier
= virtio_pci_set_host_notifier
,
879 .set_guest_notifiers
= virtio_pci_set_guest_notifiers
,
880 .vmstate_change
= virtio_pci_vmstate_change
,
883 void virtio_init_pci(VirtIOPCIProxy
*proxy
, VirtIODevice
*vdev
)
890 config
= proxy
->pci_dev
.config
;
892 if (proxy
->class_code
) {
893 pci_config_set_class(config
, proxy
->class_code
);
895 pci_set_word(config
+ PCI_SUBSYSTEM_VENDOR_ID
,
896 pci_get_word(config
+ PCI_VENDOR_ID
));
897 pci_set_word(config
+ PCI_SUBSYSTEM_ID
, vdev
->device_id
);
898 config
[PCI_INTERRUPT_PIN
] = 1;
900 if (vdev
->nvectors
&&
901 msix_init_exclusive_bar(&proxy
->pci_dev
, vdev
->nvectors
, 1)) {
905 proxy
->pci_dev
.config_write
= virtio_write_config
;
907 size
= VIRTIO_PCI_REGION_SIZE(&proxy
->pci_dev
) + vdev
->config_len
;
909 size
= 1 << qemu_fls(size
);
911 memory_region_init_io(&proxy
->bar
, &virtio_pci_config_ops
, proxy
,
913 pci_register_bar(&proxy
->pci_dev
, 0, PCI_BASE_ADDRESS_SPACE_IO
,
916 if (!kvm_has_many_ioeventfds()) {
917 proxy
->flags
&= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD
;
920 virtio_bind_device(vdev
, &virtio_pci_bindings
, DEVICE(proxy
));
921 proxy
->host_features
|= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY
;
922 proxy
->host_features
|= 0x1 << VIRTIO_F_BAD_FEATURE
;
923 proxy
->host_features
= vdev
->get_features(vdev
, proxy
->host_features
);
926 static int virtio_blk_init_pci(PCIDevice
*pci_dev
)
928 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
931 if (proxy
->class_code
!= PCI_CLASS_STORAGE_SCSI
&&
932 proxy
->class_code
!= PCI_CLASS_STORAGE_OTHER
)
933 proxy
->class_code
= PCI_CLASS_STORAGE_SCSI
;
935 vdev
= virtio_blk_init(&pci_dev
->qdev
, &proxy
->blk
);
939 vdev
->nvectors
= proxy
->nvectors
;
940 virtio_init_pci(proxy
, vdev
);
941 /* make the actual value visible */
942 proxy
->nvectors
= vdev
->nvectors
;
946 static void virtio_exit_pci(PCIDevice
*pci_dev
)
948 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
950 memory_region_destroy(&proxy
->bar
);
951 msix_uninit_exclusive_bar(pci_dev
);
954 static void virtio_blk_exit_pci(PCIDevice
*pci_dev
)
956 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
958 virtio_pci_stop_ioeventfd(proxy
);
959 virtio_blk_exit(proxy
->vdev
);
960 virtio_exit_pci(pci_dev
);
963 static int virtio_serial_init_pci(PCIDevice
*pci_dev
)
965 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
968 if (proxy
->class_code
!= PCI_CLASS_COMMUNICATION_OTHER
&&
969 proxy
->class_code
!= PCI_CLASS_DISPLAY_OTHER
&& /* qemu 0.10 */
970 proxy
->class_code
!= PCI_CLASS_OTHERS
) /* qemu-kvm */
971 proxy
->class_code
= PCI_CLASS_COMMUNICATION_OTHER
;
973 vdev
= virtio_serial_init(&pci_dev
->qdev
, &proxy
->serial
);
977 vdev
->nvectors
= proxy
->nvectors
== DEV_NVECTORS_UNSPECIFIED
978 ? proxy
->serial
.max_virtserial_ports
+ 1
980 virtio_init_pci(proxy
, vdev
);
981 proxy
->nvectors
= vdev
->nvectors
;
985 static void virtio_serial_exit_pci(PCIDevice
*pci_dev
)
987 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
989 virtio_pci_stop_ioeventfd(proxy
);
990 virtio_serial_exit(proxy
->vdev
);
991 virtio_exit_pci(pci_dev
);
994 static int virtio_net_init_pci(PCIDevice
*pci_dev
)
996 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
999 vdev
= virtio_net_init(&pci_dev
->qdev
, &proxy
->nic
, &proxy
->net
);
1001 vdev
->nvectors
= proxy
->nvectors
;
1002 virtio_init_pci(proxy
, vdev
);
1004 /* make the actual value visible */
1005 proxy
->nvectors
= vdev
->nvectors
;
1009 static void virtio_net_exit_pci(PCIDevice
*pci_dev
)
1011 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
1013 virtio_pci_stop_ioeventfd(proxy
);
1014 virtio_net_exit(proxy
->vdev
);
1015 virtio_exit_pci(pci_dev
);
1018 static int virtio_balloon_init_pci(PCIDevice
*pci_dev
)
1020 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
1023 if (proxy
->class_code
!= PCI_CLASS_OTHERS
&&
1024 proxy
->class_code
!= PCI_CLASS_MEMORY_RAM
) { /* qemu < 1.1 */
1025 proxy
->class_code
= PCI_CLASS_OTHERS
;
1028 vdev
= virtio_balloon_init(&pci_dev
->qdev
);
1032 virtio_init_pci(proxy
, vdev
);
1036 static void virtio_balloon_exit_pci(PCIDevice
*pci_dev
)
1038 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
1040 virtio_pci_stop_ioeventfd(proxy
);
1041 virtio_balloon_exit(proxy
->vdev
);
1042 virtio_exit_pci(pci_dev
);
1045 static int virtio_rng_init_pci(PCIDevice
*pci_dev
)
1047 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
1050 if (proxy
->rng
.rng
== NULL
) {
1051 proxy
->rng
.default_backend
= RNG_RANDOM(object_new(TYPE_RNG_RANDOM
));
1053 object_property_add_child(OBJECT(pci_dev
),
1055 OBJECT(proxy
->rng
.default_backend
),
1058 object_property_set_link(OBJECT(pci_dev
),
1059 OBJECT(proxy
->rng
.default_backend
),
1063 vdev
= virtio_rng_init(&pci_dev
->qdev
, &proxy
->rng
);
1067 virtio_init_pci(proxy
, vdev
);
1071 static void virtio_rng_exit_pci(PCIDevice
*pci_dev
)
1073 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
1075 virtio_pci_stop_ioeventfd(proxy
);
1076 virtio_rng_exit(proxy
->vdev
);
1077 virtio_exit_pci(pci_dev
);
1080 static Property virtio_blk_properties
[] = {
1081 DEFINE_PROP_HEX32("class", VirtIOPCIProxy
, class_code
, 0),
1082 DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy
, blk
.conf
),
1083 DEFINE_BLOCK_CHS_PROPERTIES(VirtIOPCIProxy
, blk
.conf
),
1084 DEFINE_PROP_STRING("serial", VirtIOPCIProxy
, blk
.serial
),
1086 DEFINE_PROP_BIT("scsi", VirtIOPCIProxy
, blk
.scsi
, 0, true),
1088 DEFINE_PROP_BIT("config-wce", VirtIOPCIProxy
, blk
.config_wce
, 0, true),
1089 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, true),
1090 #ifdef CONFIG_VIRTIO_BLK_DATA_PLANE
1091 DEFINE_PROP_BIT("x-data-plane", VirtIOPCIProxy
, blk
.data_plane
, 0, false),
1093 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, 2),
1094 DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy
, host_features
),
1095 DEFINE_PROP_END_OF_LIST(),
1098 static void virtio_blk_class_init(ObjectClass
*klass
, void *data
)
1100 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1101 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1103 k
->init
= virtio_blk_init_pci
;
1104 k
->exit
= virtio_blk_exit_pci
;
1105 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
1106 k
->device_id
= PCI_DEVICE_ID_VIRTIO_BLOCK
;
1107 k
->revision
= VIRTIO_PCI_ABI_VERSION
;
1108 k
->class_id
= PCI_CLASS_STORAGE_SCSI
;
1109 dc
->reset
= virtio_pci_reset
;
1110 dc
->props
= virtio_blk_properties
;
1113 static const TypeInfo virtio_blk_info
= {
1114 .name
= "virtio-blk-pci",
1115 .parent
= TYPE_PCI_DEVICE
,
1116 .instance_size
= sizeof(VirtIOPCIProxy
),
1117 .class_init
= virtio_blk_class_init
,
1120 static Property virtio_net_properties
[] = {
1121 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, false),
1122 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, 3),
1123 DEFINE_VIRTIO_NET_FEATURES(VirtIOPCIProxy
, host_features
),
1124 DEFINE_NIC_PROPERTIES(VirtIOPCIProxy
, nic
),
1125 DEFINE_PROP_UINT32("x-txtimer", VirtIOPCIProxy
, net
.txtimer
, TX_TIMER_INTERVAL
),
1126 DEFINE_PROP_INT32("x-txburst", VirtIOPCIProxy
, net
.txburst
, TX_BURST
),
1127 DEFINE_PROP_STRING("tx", VirtIOPCIProxy
, net
.tx
),
1128 DEFINE_PROP_END_OF_LIST(),
1131 static void virtio_net_class_init(ObjectClass
*klass
, void *data
)
1133 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1134 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1136 k
->init
= virtio_net_init_pci
;
1137 k
->exit
= virtio_net_exit_pci
;
1138 k
->romfile
= "pxe-virtio.rom";
1139 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
1140 k
->device_id
= PCI_DEVICE_ID_VIRTIO_NET
;
1141 k
->revision
= VIRTIO_PCI_ABI_VERSION
;
1142 k
->class_id
= PCI_CLASS_NETWORK_ETHERNET
;
1143 dc
->reset
= virtio_pci_reset
;
1144 dc
->props
= virtio_net_properties
;
1147 static const TypeInfo virtio_net_info
= {
1148 .name
= "virtio-net-pci",
1149 .parent
= TYPE_PCI_DEVICE
,
1150 .instance_size
= sizeof(VirtIOPCIProxy
),
1151 .class_init
= virtio_net_class_init
,
1154 static Property virtio_serial_properties
[] = {
1155 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, true),
1156 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, DEV_NVECTORS_UNSPECIFIED
),
1157 DEFINE_PROP_HEX32("class", VirtIOPCIProxy
, class_code
, 0),
1158 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy
, host_features
),
1159 DEFINE_PROP_UINT32("max_ports", VirtIOPCIProxy
, serial
.max_virtserial_ports
, 31),
1160 DEFINE_PROP_END_OF_LIST(),
1163 static void virtio_serial_class_init(ObjectClass
*klass
, void *data
)
1165 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1166 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1168 k
->init
= virtio_serial_init_pci
;
1169 k
->exit
= virtio_serial_exit_pci
;
1170 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
1171 k
->device_id
= PCI_DEVICE_ID_VIRTIO_CONSOLE
;
1172 k
->revision
= VIRTIO_PCI_ABI_VERSION
;
1173 k
->class_id
= PCI_CLASS_COMMUNICATION_OTHER
;
1174 dc
->reset
= virtio_pci_reset
;
1175 dc
->props
= virtio_serial_properties
;
1178 static const TypeInfo virtio_serial_info
= {
1179 .name
= "virtio-serial-pci",
1180 .parent
= TYPE_PCI_DEVICE
,
1181 .instance_size
= sizeof(VirtIOPCIProxy
),
1182 .class_init
= virtio_serial_class_init
,
1185 static Property virtio_balloon_properties
[] = {
1186 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy
, host_features
),
1187 DEFINE_PROP_HEX32("class", VirtIOPCIProxy
, class_code
, 0),
1188 DEFINE_PROP_END_OF_LIST(),
1191 static void virtio_balloon_class_init(ObjectClass
*klass
, void *data
)
1193 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1194 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1196 k
->init
= virtio_balloon_init_pci
;
1197 k
->exit
= virtio_balloon_exit_pci
;
1198 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
1199 k
->device_id
= PCI_DEVICE_ID_VIRTIO_BALLOON
;
1200 k
->revision
= VIRTIO_PCI_ABI_VERSION
;
1201 k
->class_id
= PCI_CLASS_OTHERS
;
1202 dc
->reset
= virtio_pci_reset
;
1203 dc
->props
= virtio_balloon_properties
;
1206 static const TypeInfo virtio_balloon_info
= {
1207 .name
= "virtio-balloon-pci",
1208 .parent
= TYPE_PCI_DEVICE
,
1209 .instance_size
= sizeof(VirtIOPCIProxy
),
1210 .class_init
= virtio_balloon_class_init
,
1213 static void virtio_rng_initfn(Object
*obj
)
1215 PCIDevice
*pci_dev
= PCI_DEVICE(obj
);
1216 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
1218 object_property_add_link(obj
, "rng", TYPE_RNG_BACKEND
,
1219 (Object
**)&proxy
->rng
.rng
, NULL
);
1222 static Property virtio_rng_properties
[] = {
1223 DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy
, host_features
),
1224 /* Set a default rate limit of 2^47 bytes per minute or roughly 2TB/s. If
1225 you have an entropy source capable of generating more entropy than this
1226 and you can pass it through via virtio-rng, then hats off to you. Until
1227 then, this is unlimited for all practical purposes.
1229 DEFINE_PROP_UINT64("max-bytes", VirtIOPCIProxy
, rng
.max_bytes
, INT64_MAX
),
1230 DEFINE_PROP_UINT32("period", VirtIOPCIProxy
, rng
.period_ms
, 1 << 16),
1231 DEFINE_PROP_END_OF_LIST(),
1234 static void virtio_rng_class_init(ObjectClass
*klass
, void *data
)
1236 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1237 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1239 k
->init
= virtio_rng_init_pci
;
1240 k
->exit
= virtio_rng_exit_pci
;
1241 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
1242 k
->device_id
= PCI_DEVICE_ID_VIRTIO_RNG
;
1243 k
->revision
= VIRTIO_PCI_ABI_VERSION
;
1244 k
->class_id
= PCI_CLASS_OTHERS
;
1245 dc
->reset
= virtio_pci_reset
;
1246 dc
->props
= virtio_rng_properties
;
1249 static const TypeInfo virtio_rng_info
= {
1250 .name
= "virtio-rng-pci",
1251 .parent
= TYPE_PCI_DEVICE
,
1252 .instance_size
= sizeof(VirtIOPCIProxy
),
1253 .instance_init
= virtio_rng_initfn
,
1254 .class_init
= virtio_rng_class_init
,
1257 static int virtio_scsi_init_pci(PCIDevice
*pci_dev
)
1259 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
1262 vdev
= virtio_scsi_init(&pci_dev
->qdev
, &proxy
->scsi
);
1267 vdev
->nvectors
= proxy
->nvectors
== DEV_NVECTORS_UNSPECIFIED
1268 ? proxy
->scsi
.num_queues
+ 3
1270 virtio_init_pci(proxy
, vdev
);
1272 /* make the actual value visible */
1273 proxy
->nvectors
= vdev
->nvectors
;
1277 static void virtio_scsi_exit_pci(PCIDevice
*pci_dev
)
1279 VirtIOPCIProxy
*proxy
= DO_UPCAST(VirtIOPCIProxy
, pci_dev
, pci_dev
);
1281 virtio_scsi_exit(proxy
->vdev
);
1282 virtio_exit_pci(pci_dev
);
1285 static Property virtio_scsi_properties
[] = {
1286 DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy
, flags
, VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT
, true),
1287 DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy
, nvectors
, DEV_NVECTORS_UNSPECIFIED
),
1288 DEFINE_VIRTIO_SCSI_PROPERTIES(VirtIOPCIProxy
, host_features
, scsi
),
1289 DEFINE_PROP_END_OF_LIST(),
1292 static void virtio_scsi_class_init(ObjectClass
*klass
, void *data
)
1294 DeviceClass
*dc
= DEVICE_CLASS(klass
);
1295 PCIDeviceClass
*k
= PCI_DEVICE_CLASS(klass
);
1297 k
->init
= virtio_scsi_init_pci
;
1298 k
->exit
= virtio_scsi_exit_pci
;
1299 k
->vendor_id
= PCI_VENDOR_ID_REDHAT_QUMRANET
;
1300 k
->device_id
= PCI_DEVICE_ID_VIRTIO_SCSI
;
1302 k
->class_id
= PCI_CLASS_STORAGE_SCSI
;
1303 dc
->reset
= virtio_pci_reset
;
1304 dc
->props
= virtio_scsi_properties
;
1307 static const TypeInfo virtio_scsi_info
= {
1308 .name
= "virtio-scsi-pci",
1309 .parent
= TYPE_PCI_DEVICE
,
1310 .instance_size
= sizeof(VirtIOPCIProxy
),
1311 .class_init
= virtio_scsi_class_init
,
1314 static void virtio_pci_register_types(void)
1316 type_register_static(&virtio_blk_info
);
1317 type_register_static(&virtio_net_info
);
1318 type_register_static(&virtio_serial_info
);
1319 type_register_static(&virtio_balloon_info
);
1320 type_register_static(&virtio_scsi_info
);
1321 type_register_static(&virtio_rng_info
);
1324 type_init(virtio_pci_register_types
)