2 * vfio based device assignment support
4 * Copyright Red Hat, Inc. 2012
7 * Alex Williamson <alex.williamson@redhat.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.
12 * Based on qemu-kvm device-assignment:
13 * Adapted for KVM by Qumranet.
14 * Copyright (c) 2007, Neocleus, Alex Novik (alex@neocleus.com)
15 * Copyright (c) 2007, Neocleus, Guy Zana (guy@neocleus.com)
16 * Copyright (C) 2008, Qumranet, Amit Shah (amit.shah@qumranet.com)
17 * Copyright (C) 2008, Red Hat, Amit Shah (amit.shah@redhat.com)
18 * Copyright (C) 2008, IBM, Muli Ben-Yehuda (muli@il.ibm.com)
21 #include "qemu/osdep.h"
22 #include <linux/vfio.h>
23 #include <sys/ioctl.h>
25 #include "hw/pci/msi.h"
26 #include "hw/pci/msix.h"
27 #include "hw/pci/pci_bridge.h"
28 #include "qemu/error-report.h"
29 #include "qemu/range.h"
30 #include "sysemu/kvm.h"
31 #include "sysemu/sysemu.h"
35 #define MSIX_CAP_LENGTH 12
37 static void vfio_disable_interrupts(VFIOPCIDevice
*vdev
);
38 static void vfio_mmap_set_enabled(VFIOPCIDevice
*vdev
, bool enabled
);
41 * Disabling BAR mmaping can be slow, but toggling it around INTx can
42 * also be a huge overhead. We try to get the best of both worlds by
43 * waiting until an interrupt to disable mmaps (subsequent transitions
44 * to the same state are effectively no overhead). If the interrupt has
45 * been serviced and the time gap is long enough, we re-enable mmaps for
46 * performance. This works well for things like graphics cards, which
47 * may not use their interrupt at all and are penalized to an unusable
48 * level by read/write BAR traps. Other devices, like NICs, have more
49 * regular interrupts and see much better latency by staying in non-mmap
50 * mode. We therefore set the default mmap_timeout such that a ping
51 * is just enough to keep the mmap disabled. Users can experiment with
52 * other options with the x-intx-mmap-timeout-ms parameter (a value of
53 * zero disables the timer).
55 static void vfio_intx_mmap_enable(void *opaque
)
57 VFIOPCIDevice
*vdev
= opaque
;
59 if (vdev
->intx
.pending
) {
60 timer_mod(vdev
->intx
.mmap_timer
,
61 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + vdev
->intx
.mmap_timeout
);
65 vfio_mmap_set_enabled(vdev
, true);
68 static void vfio_intx_interrupt(void *opaque
)
70 VFIOPCIDevice
*vdev
= opaque
;
72 if (!event_notifier_test_and_clear(&vdev
->intx
.interrupt
)) {
76 trace_vfio_intx_interrupt(vdev
->vbasedev
.name
, 'A' + vdev
->intx
.pin
);
78 vdev
->intx
.pending
= true;
79 pci_irq_assert(&vdev
->pdev
);
80 vfio_mmap_set_enabled(vdev
, false);
81 if (vdev
->intx
.mmap_timeout
) {
82 timer_mod(vdev
->intx
.mmap_timer
,
83 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) + vdev
->intx
.mmap_timeout
);
87 static void vfio_intx_eoi(VFIODevice
*vbasedev
)
89 VFIOPCIDevice
*vdev
= container_of(vbasedev
, VFIOPCIDevice
, vbasedev
);
91 if (!vdev
->intx
.pending
) {
95 trace_vfio_intx_eoi(vbasedev
->name
);
97 vdev
->intx
.pending
= false;
98 pci_irq_deassert(&vdev
->pdev
);
99 vfio_unmask_single_irqindex(vbasedev
, VFIO_PCI_INTX_IRQ_INDEX
);
102 static void vfio_intx_enable_kvm(VFIOPCIDevice
*vdev
)
105 struct kvm_irqfd irqfd
= {
106 .fd
= event_notifier_get_fd(&vdev
->intx
.interrupt
),
107 .gsi
= vdev
->intx
.route
.irq
,
108 .flags
= KVM_IRQFD_FLAG_RESAMPLE
,
110 struct vfio_irq_set
*irq_set
;
114 if (vdev
->no_kvm_intx
|| !kvm_irqfds_enabled() ||
115 vdev
->intx
.route
.mode
!= PCI_INTX_ENABLED
||
116 !kvm_resamplefds_enabled()) {
120 /* Get to a known interrupt state */
121 qemu_set_fd_handler(irqfd
.fd
, NULL
, NULL
, vdev
);
122 vfio_mask_single_irqindex(&vdev
->vbasedev
, VFIO_PCI_INTX_IRQ_INDEX
);
123 vdev
->intx
.pending
= false;
124 pci_irq_deassert(&vdev
->pdev
);
126 /* Get an eventfd for resample/unmask */
127 if (event_notifier_init(&vdev
->intx
.unmask
, 0)) {
128 error_report("vfio: Error: event_notifier_init failed eoi");
132 /* KVM triggers it, VFIO listens for it */
133 irqfd
.resamplefd
= event_notifier_get_fd(&vdev
->intx
.unmask
);
135 if (kvm_vm_ioctl(kvm_state
, KVM_IRQFD
, &irqfd
)) {
136 error_report("vfio: Error: Failed to setup resample irqfd: %m");
140 argsz
= sizeof(*irq_set
) + sizeof(*pfd
);
142 irq_set
= g_malloc0(argsz
);
143 irq_set
->argsz
= argsz
;
144 irq_set
->flags
= VFIO_IRQ_SET_DATA_EVENTFD
| VFIO_IRQ_SET_ACTION_UNMASK
;
145 irq_set
->index
= VFIO_PCI_INTX_IRQ_INDEX
;
148 pfd
= (int32_t *)&irq_set
->data
;
150 *pfd
= irqfd
.resamplefd
;
152 ret
= ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_SET_IRQS
, irq_set
);
155 error_report("vfio: Error: Failed to setup INTx unmask fd: %m");
160 vfio_unmask_single_irqindex(&vdev
->vbasedev
, VFIO_PCI_INTX_IRQ_INDEX
);
162 vdev
->intx
.kvm_accel
= true;
164 trace_vfio_intx_enable_kvm(vdev
->vbasedev
.name
);
169 irqfd
.flags
= KVM_IRQFD_FLAG_DEASSIGN
;
170 kvm_vm_ioctl(kvm_state
, KVM_IRQFD
, &irqfd
);
172 event_notifier_cleanup(&vdev
->intx
.unmask
);
174 qemu_set_fd_handler(irqfd
.fd
, vfio_intx_interrupt
, NULL
, vdev
);
175 vfio_unmask_single_irqindex(&vdev
->vbasedev
, VFIO_PCI_INTX_IRQ_INDEX
);
179 static void vfio_intx_disable_kvm(VFIOPCIDevice
*vdev
)
182 struct kvm_irqfd irqfd
= {
183 .fd
= event_notifier_get_fd(&vdev
->intx
.interrupt
),
184 .gsi
= vdev
->intx
.route
.irq
,
185 .flags
= KVM_IRQFD_FLAG_DEASSIGN
,
188 if (!vdev
->intx
.kvm_accel
) {
193 * Get to a known state, hardware masked, QEMU ready to accept new
194 * interrupts, QEMU IRQ de-asserted.
196 vfio_mask_single_irqindex(&vdev
->vbasedev
, VFIO_PCI_INTX_IRQ_INDEX
);
197 vdev
->intx
.pending
= false;
198 pci_irq_deassert(&vdev
->pdev
);
200 /* Tell KVM to stop listening for an INTx irqfd */
201 if (kvm_vm_ioctl(kvm_state
, KVM_IRQFD
, &irqfd
)) {
202 error_report("vfio: Error: Failed to disable INTx irqfd: %m");
205 /* We only need to close the eventfd for VFIO to cleanup the kernel side */
206 event_notifier_cleanup(&vdev
->intx
.unmask
);
208 /* QEMU starts listening for interrupt events. */
209 qemu_set_fd_handler(irqfd
.fd
, vfio_intx_interrupt
, NULL
, vdev
);
211 vdev
->intx
.kvm_accel
= false;
213 /* If we've missed an event, let it re-fire through QEMU */
214 vfio_unmask_single_irqindex(&vdev
->vbasedev
, VFIO_PCI_INTX_IRQ_INDEX
);
216 trace_vfio_intx_disable_kvm(vdev
->vbasedev
.name
);
220 static void vfio_intx_update(PCIDevice
*pdev
)
222 VFIOPCIDevice
*vdev
= DO_UPCAST(VFIOPCIDevice
, pdev
, pdev
);
225 if (vdev
->interrupt
!= VFIO_INT_INTx
) {
229 route
= pci_device_route_intx_to_irq(&vdev
->pdev
, vdev
->intx
.pin
);
231 if (!pci_intx_route_changed(&vdev
->intx
.route
, &route
)) {
232 return; /* Nothing changed */
235 trace_vfio_intx_update(vdev
->vbasedev
.name
,
236 vdev
->intx
.route
.irq
, route
.irq
);
238 vfio_intx_disable_kvm(vdev
);
240 vdev
->intx
.route
= route
;
242 if (route
.mode
!= PCI_INTX_ENABLED
) {
246 vfio_intx_enable_kvm(vdev
);
248 /* Re-enable the interrupt in cased we missed an EOI */
249 vfio_intx_eoi(&vdev
->vbasedev
);
252 static int vfio_intx_enable(VFIOPCIDevice
*vdev
)
254 uint8_t pin
= vfio_pci_read_config(&vdev
->pdev
, PCI_INTERRUPT_PIN
, 1);
256 struct vfio_irq_set
*irq_set
;
263 vfio_disable_interrupts(vdev
);
265 vdev
->intx
.pin
= pin
- 1; /* Pin A (1) -> irq[0] */
266 pci_config_set_interrupt_pin(vdev
->pdev
.config
, pin
);
270 * Only conditional to avoid generating error messages on platforms
271 * where we won't actually use the result anyway.
273 if (kvm_irqfds_enabled() && kvm_resamplefds_enabled()) {
274 vdev
->intx
.route
= pci_device_route_intx_to_irq(&vdev
->pdev
,
279 ret
= event_notifier_init(&vdev
->intx
.interrupt
, 0);
281 error_report("vfio: Error: event_notifier_init failed");
285 argsz
= sizeof(*irq_set
) + sizeof(*pfd
);
287 irq_set
= g_malloc0(argsz
);
288 irq_set
->argsz
= argsz
;
289 irq_set
->flags
= VFIO_IRQ_SET_DATA_EVENTFD
| VFIO_IRQ_SET_ACTION_TRIGGER
;
290 irq_set
->index
= VFIO_PCI_INTX_IRQ_INDEX
;
293 pfd
= (int32_t *)&irq_set
->data
;
295 *pfd
= event_notifier_get_fd(&vdev
->intx
.interrupt
);
296 qemu_set_fd_handler(*pfd
, vfio_intx_interrupt
, NULL
, vdev
);
298 ret
= ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_SET_IRQS
, irq_set
);
301 error_report("vfio: Error: Failed to setup INTx fd: %m");
302 qemu_set_fd_handler(*pfd
, NULL
, NULL
, vdev
);
303 event_notifier_cleanup(&vdev
->intx
.interrupt
);
307 vfio_intx_enable_kvm(vdev
);
309 vdev
->interrupt
= VFIO_INT_INTx
;
311 trace_vfio_intx_enable(vdev
->vbasedev
.name
);
316 static void vfio_intx_disable(VFIOPCIDevice
*vdev
)
320 timer_del(vdev
->intx
.mmap_timer
);
321 vfio_intx_disable_kvm(vdev
);
322 vfio_disable_irqindex(&vdev
->vbasedev
, VFIO_PCI_INTX_IRQ_INDEX
);
323 vdev
->intx
.pending
= false;
324 pci_irq_deassert(&vdev
->pdev
);
325 vfio_mmap_set_enabled(vdev
, true);
327 fd
= event_notifier_get_fd(&vdev
->intx
.interrupt
);
328 qemu_set_fd_handler(fd
, NULL
, NULL
, vdev
);
329 event_notifier_cleanup(&vdev
->intx
.interrupt
);
331 vdev
->interrupt
= VFIO_INT_NONE
;
333 trace_vfio_intx_disable(vdev
->vbasedev
.name
);
339 static void vfio_msi_interrupt(void *opaque
)
341 VFIOMSIVector
*vector
= opaque
;
342 VFIOPCIDevice
*vdev
= vector
->vdev
;
343 MSIMessage (*get_msg
)(PCIDevice
*dev
, unsigned vector
);
344 void (*notify
)(PCIDevice
*dev
, unsigned vector
);
346 int nr
= vector
- vdev
->msi_vectors
;
348 if (!event_notifier_test_and_clear(&vector
->interrupt
)) {
352 if (vdev
->interrupt
== VFIO_INT_MSIX
) {
353 get_msg
= msix_get_message
;
354 notify
= msix_notify
;
356 /* A masked vector firing needs to use the PBA, enable it */
357 if (msix_is_masked(&vdev
->pdev
, nr
)) {
358 set_bit(nr
, vdev
->msix
->pending
);
359 memory_region_set_enabled(&vdev
->pdev
.msix_pba_mmio
, true);
360 trace_vfio_msix_pba_enable(vdev
->vbasedev
.name
);
362 } else if (vdev
->interrupt
== VFIO_INT_MSI
) {
363 get_msg
= msi_get_message
;
369 msg
= get_msg(&vdev
->pdev
, nr
);
370 trace_vfio_msi_interrupt(vdev
->vbasedev
.name
, nr
, msg
.address
, msg
.data
);
371 notify(&vdev
->pdev
, nr
);
374 static int vfio_enable_vectors(VFIOPCIDevice
*vdev
, bool msix
)
376 struct vfio_irq_set
*irq_set
;
377 int ret
= 0, i
, argsz
;
380 argsz
= sizeof(*irq_set
) + (vdev
->nr_vectors
* sizeof(*fds
));
382 irq_set
= g_malloc0(argsz
);
383 irq_set
->argsz
= argsz
;
384 irq_set
->flags
= VFIO_IRQ_SET_DATA_EVENTFD
| VFIO_IRQ_SET_ACTION_TRIGGER
;
385 irq_set
->index
= msix
? VFIO_PCI_MSIX_IRQ_INDEX
: VFIO_PCI_MSI_IRQ_INDEX
;
387 irq_set
->count
= vdev
->nr_vectors
;
388 fds
= (int32_t *)&irq_set
->data
;
390 for (i
= 0; i
< vdev
->nr_vectors
; i
++) {
394 * MSI vs MSI-X - The guest has direct access to MSI mask and pending
395 * bits, therefore we always use the KVM signaling path when setup.
396 * MSI-X mask and pending bits are emulated, so we want to use the
397 * KVM signaling path only when configured and unmasked.
399 if (vdev
->msi_vectors
[i
].use
) {
400 if (vdev
->msi_vectors
[i
].virq
< 0 ||
401 (msix
&& msix_is_masked(&vdev
->pdev
, i
))) {
402 fd
= event_notifier_get_fd(&vdev
->msi_vectors
[i
].interrupt
);
404 fd
= event_notifier_get_fd(&vdev
->msi_vectors
[i
].kvm_interrupt
);
411 ret
= ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_SET_IRQS
, irq_set
);
418 static void vfio_add_kvm_msi_virq(VFIOPCIDevice
*vdev
, VFIOMSIVector
*vector
,
419 MSIMessage
*msg
, bool msix
)
423 if ((msix
&& vdev
->no_kvm_msix
) || (!msix
&& vdev
->no_kvm_msi
) || !msg
) {
427 if (event_notifier_init(&vector
->kvm_interrupt
, 0)) {
431 virq
= kvm_irqchip_add_msi_route(kvm_state
, *msg
, &vdev
->pdev
);
433 event_notifier_cleanup(&vector
->kvm_interrupt
);
437 if (kvm_irqchip_add_irqfd_notifier_gsi(kvm_state
, &vector
->kvm_interrupt
,
439 kvm_irqchip_release_virq(kvm_state
, virq
);
440 event_notifier_cleanup(&vector
->kvm_interrupt
);
447 static void vfio_remove_kvm_msi_virq(VFIOMSIVector
*vector
)
449 kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state
, &vector
->kvm_interrupt
,
451 kvm_irqchip_release_virq(kvm_state
, vector
->virq
);
453 event_notifier_cleanup(&vector
->kvm_interrupt
);
456 static void vfio_update_kvm_msi_virq(VFIOMSIVector
*vector
, MSIMessage msg
,
459 kvm_irqchip_update_msi_route(kvm_state
, vector
->virq
, msg
, pdev
);
462 static int vfio_msix_vector_do_use(PCIDevice
*pdev
, unsigned int nr
,
463 MSIMessage
*msg
, IOHandler
*handler
)
465 VFIOPCIDevice
*vdev
= DO_UPCAST(VFIOPCIDevice
, pdev
, pdev
);
466 VFIOMSIVector
*vector
;
469 trace_vfio_msix_vector_do_use(vdev
->vbasedev
.name
, nr
);
471 vector
= &vdev
->msi_vectors
[nr
];
476 if (event_notifier_init(&vector
->interrupt
, 0)) {
477 error_report("vfio: Error: event_notifier_init failed");
480 msix_vector_use(pdev
, nr
);
483 qemu_set_fd_handler(event_notifier_get_fd(&vector
->interrupt
),
484 handler
, NULL
, vector
);
487 * Attempt to enable route through KVM irqchip,
488 * default to userspace handling if unavailable.
490 if (vector
->virq
>= 0) {
492 vfio_remove_kvm_msi_virq(vector
);
494 vfio_update_kvm_msi_virq(vector
, *msg
, pdev
);
497 vfio_add_kvm_msi_virq(vdev
, vector
, msg
, true);
501 * We don't want to have the host allocate all possible MSI vectors
502 * for a device if they're not in use, so we shutdown and incrementally
503 * increase them as needed.
505 if (vdev
->nr_vectors
< nr
+ 1) {
506 vfio_disable_irqindex(&vdev
->vbasedev
, VFIO_PCI_MSIX_IRQ_INDEX
);
507 vdev
->nr_vectors
= nr
+ 1;
508 ret
= vfio_enable_vectors(vdev
, true);
510 error_report("vfio: failed to enable vectors, %d", ret
);
514 struct vfio_irq_set
*irq_set
;
517 argsz
= sizeof(*irq_set
) + sizeof(*pfd
);
519 irq_set
= g_malloc0(argsz
);
520 irq_set
->argsz
= argsz
;
521 irq_set
->flags
= VFIO_IRQ_SET_DATA_EVENTFD
|
522 VFIO_IRQ_SET_ACTION_TRIGGER
;
523 irq_set
->index
= VFIO_PCI_MSIX_IRQ_INDEX
;
526 pfd
= (int32_t *)&irq_set
->data
;
528 if (vector
->virq
>= 0) {
529 *pfd
= event_notifier_get_fd(&vector
->kvm_interrupt
);
531 *pfd
= event_notifier_get_fd(&vector
->interrupt
);
534 ret
= ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_SET_IRQS
, irq_set
);
537 error_report("vfio: failed to modify vector, %d", ret
);
541 /* Disable PBA emulation when nothing more is pending. */
542 clear_bit(nr
, vdev
->msix
->pending
);
543 if (find_first_bit(vdev
->msix
->pending
,
544 vdev
->nr_vectors
) == vdev
->nr_vectors
) {
545 memory_region_set_enabled(&vdev
->pdev
.msix_pba_mmio
, false);
546 trace_vfio_msix_pba_disable(vdev
->vbasedev
.name
);
552 static int vfio_msix_vector_use(PCIDevice
*pdev
,
553 unsigned int nr
, MSIMessage msg
)
555 return vfio_msix_vector_do_use(pdev
, nr
, &msg
, vfio_msi_interrupt
);
558 static void vfio_msix_vector_release(PCIDevice
*pdev
, unsigned int nr
)
560 VFIOPCIDevice
*vdev
= DO_UPCAST(VFIOPCIDevice
, pdev
, pdev
);
561 VFIOMSIVector
*vector
= &vdev
->msi_vectors
[nr
];
563 trace_vfio_msix_vector_release(vdev
->vbasedev
.name
, nr
);
566 * There are still old guests that mask and unmask vectors on every
567 * interrupt. If we're using QEMU bypass with a KVM irqfd, leave all of
568 * the KVM setup in place, simply switch VFIO to use the non-bypass
569 * eventfd. We'll then fire the interrupt through QEMU and the MSI-X
570 * core will mask the interrupt and set pending bits, allowing it to
571 * be re-asserted on unmask. Nothing to do if already using QEMU mode.
573 if (vector
->virq
>= 0) {
575 struct vfio_irq_set
*irq_set
;
578 argsz
= sizeof(*irq_set
) + sizeof(*pfd
);
580 irq_set
= g_malloc0(argsz
);
581 irq_set
->argsz
= argsz
;
582 irq_set
->flags
= VFIO_IRQ_SET_DATA_EVENTFD
|
583 VFIO_IRQ_SET_ACTION_TRIGGER
;
584 irq_set
->index
= VFIO_PCI_MSIX_IRQ_INDEX
;
587 pfd
= (int32_t *)&irq_set
->data
;
589 *pfd
= event_notifier_get_fd(&vector
->interrupt
);
591 ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_SET_IRQS
, irq_set
);
597 static void vfio_msix_enable(VFIOPCIDevice
*vdev
)
599 vfio_disable_interrupts(vdev
);
601 vdev
->msi_vectors
= g_new0(VFIOMSIVector
, vdev
->msix
->entries
);
603 vdev
->interrupt
= VFIO_INT_MSIX
;
606 * Some communication channels between VF & PF or PF & fw rely on the
607 * physical state of the device and expect that enabling MSI-X from the
608 * guest enables the same on the host. When our guest is Linux, the
609 * guest driver call to pci_enable_msix() sets the enabling bit in the
610 * MSI-X capability, but leaves the vector table masked. We therefore
611 * can't rely on a vector_use callback (from request_irq() in the guest)
612 * to switch the physical device into MSI-X mode because that may come a
613 * long time after pci_enable_msix(). This code enables vector 0 with
614 * triggering to userspace, then immediately release the vector, leaving
615 * the physical device with no vectors enabled, but MSI-X enabled, just
616 * like the guest view.
618 vfio_msix_vector_do_use(&vdev
->pdev
, 0, NULL
, NULL
);
619 vfio_msix_vector_release(&vdev
->pdev
, 0);
621 if (msix_set_vector_notifiers(&vdev
->pdev
, vfio_msix_vector_use
,
622 vfio_msix_vector_release
, NULL
)) {
623 error_report("vfio: msix_set_vector_notifiers failed");
626 trace_vfio_msix_enable(vdev
->vbasedev
.name
);
629 static void vfio_msi_enable(VFIOPCIDevice
*vdev
)
633 vfio_disable_interrupts(vdev
);
635 vdev
->nr_vectors
= msi_nr_vectors_allocated(&vdev
->pdev
);
637 vdev
->msi_vectors
= g_new0(VFIOMSIVector
, vdev
->nr_vectors
);
639 for (i
= 0; i
< vdev
->nr_vectors
; i
++) {
640 VFIOMSIVector
*vector
= &vdev
->msi_vectors
[i
];
641 MSIMessage msg
= msi_get_message(&vdev
->pdev
, i
);
647 if (event_notifier_init(&vector
->interrupt
, 0)) {
648 error_report("vfio: Error: event_notifier_init failed");
651 qemu_set_fd_handler(event_notifier_get_fd(&vector
->interrupt
),
652 vfio_msi_interrupt
, NULL
, vector
);
655 * Attempt to enable route through KVM irqchip,
656 * default to userspace handling if unavailable.
658 vfio_add_kvm_msi_virq(vdev
, vector
, &msg
, false);
661 /* Set interrupt type prior to possible interrupts */
662 vdev
->interrupt
= VFIO_INT_MSI
;
664 ret
= vfio_enable_vectors(vdev
, false);
667 error_report("vfio: Error: Failed to setup MSI fds: %m");
668 } else if (ret
!= vdev
->nr_vectors
) {
669 error_report("vfio: Error: Failed to enable %d "
670 "MSI vectors, retry with %d", vdev
->nr_vectors
, ret
);
673 for (i
= 0; i
< vdev
->nr_vectors
; i
++) {
674 VFIOMSIVector
*vector
= &vdev
->msi_vectors
[i
];
675 if (vector
->virq
>= 0) {
676 vfio_remove_kvm_msi_virq(vector
);
678 qemu_set_fd_handler(event_notifier_get_fd(&vector
->interrupt
),
680 event_notifier_cleanup(&vector
->interrupt
);
683 g_free(vdev
->msi_vectors
);
685 if (ret
> 0 && ret
!= vdev
->nr_vectors
) {
686 vdev
->nr_vectors
= ret
;
689 vdev
->nr_vectors
= 0;
692 * Failing to setup MSI doesn't really fall within any specification.
693 * Let's try leaving interrupts disabled and hope the guest figures
694 * out to fall back to INTx for this device.
696 error_report("vfio: Error: Failed to enable MSI");
697 vdev
->interrupt
= VFIO_INT_NONE
;
702 trace_vfio_msi_enable(vdev
->vbasedev
.name
, vdev
->nr_vectors
);
705 static void vfio_msi_disable_common(VFIOPCIDevice
*vdev
)
709 for (i
= 0; i
< vdev
->nr_vectors
; i
++) {
710 VFIOMSIVector
*vector
= &vdev
->msi_vectors
[i
];
711 if (vdev
->msi_vectors
[i
].use
) {
712 if (vector
->virq
>= 0) {
713 vfio_remove_kvm_msi_virq(vector
);
715 qemu_set_fd_handler(event_notifier_get_fd(&vector
->interrupt
),
717 event_notifier_cleanup(&vector
->interrupt
);
721 g_free(vdev
->msi_vectors
);
722 vdev
->msi_vectors
= NULL
;
723 vdev
->nr_vectors
= 0;
724 vdev
->interrupt
= VFIO_INT_NONE
;
726 vfio_intx_enable(vdev
);
729 static void vfio_msix_disable(VFIOPCIDevice
*vdev
)
733 msix_unset_vector_notifiers(&vdev
->pdev
);
736 * MSI-X will only release vectors if MSI-X is still enabled on the
737 * device, check through the rest and release it ourselves if necessary.
739 for (i
= 0; i
< vdev
->nr_vectors
; i
++) {
740 if (vdev
->msi_vectors
[i
].use
) {
741 vfio_msix_vector_release(&vdev
->pdev
, i
);
742 msix_vector_unuse(&vdev
->pdev
, i
);
746 if (vdev
->nr_vectors
) {
747 vfio_disable_irqindex(&vdev
->vbasedev
, VFIO_PCI_MSIX_IRQ_INDEX
);
750 vfio_msi_disable_common(vdev
);
752 memset(vdev
->msix
->pending
, 0,
753 BITS_TO_LONGS(vdev
->msix
->entries
) * sizeof(unsigned long));
755 trace_vfio_msix_disable(vdev
->vbasedev
.name
);
758 static void vfio_msi_disable(VFIOPCIDevice
*vdev
)
760 vfio_disable_irqindex(&vdev
->vbasedev
, VFIO_PCI_MSI_IRQ_INDEX
);
761 vfio_msi_disable_common(vdev
);
763 trace_vfio_msi_disable(vdev
->vbasedev
.name
);
766 static void vfio_update_msi(VFIOPCIDevice
*vdev
)
770 for (i
= 0; i
< vdev
->nr_vectors
; i
++) {
771 VFIOMSIVector
*vector
= &vdev
->msi_vectors
[i
];
774 if (!vector
->use
|| vector
->virq
< 0) {
778 msg
= msi_get_message(&vdev
->pdev
, i
);
779 vfio_update_kvm_msi_virq(vector
, msg
, &vdev
->pdev
);
783 static void vfio_pci_load_rom(VFIOPCIDevice
*vdev
)
785 struct vfio_region_info
*reg_info
;
790 if (vfio_get_region_info(&vdev
->vbasedev
,
791 VFIO_PCI_ROM_REGION_INDEX
, ®_info
)) {
792 error_report("vfio: Error getting ROM info: %m");
796 trace_vfio_pci_load_rom(vdev
->vbasedev
.name
, (unsigned long)reg_info
->size
,
797 (unsigned long)reg_info
->offset
,
798 (unsigned long)reg_info
->flags
);
800 vdev
->rom_size
= size
= reg_info
->size
;
801 vdev
->rom_offset
= reg_info
->offset
;
805 if (!vdev
->rom_size
) {
806 vdev
->rom_read_failed
= true;
807 error_report("vfio-pci: Cannot read device rom at "
808 "%s", vdev
->vbasedev
.name
);
809 error_printf("Device option ROM contents are probably invalid "
810 "(check dmesg).\nSkip option ROM probe with rombar=0, "
811 "or load from file with romfile=\n");
815 vdev
->rom
= g_malloc(size
);
816 memset(vdev
->rom
, 0xff, size
);
819 bytes
= pread(vdev
->vbasedev
.fd
, vdev
->rom
+ off
,
820 size
, vdev
->rom_offset
+ off
);
823 } else if (bytes
> 0) {
827 if (errno
== EINTR
|| errno
== EAGAIN
) {
830 error_report("vfio: Error reading device ROM: %m");
836 * Test the ROM signature against our device, if the vendor is correct
837 * but the device ID doesn't match, store the correct device ID and
838 * recompute the checksum. Intel IGD devices need this and are known
839 * to have bogus checksums so we can't simply adjust the checksum.
841 if (pci_get_word(vdev
->rom
) == 0xaa55 &&
842 pci_get_word(vdev
->rom
+ 0x18) + 8 < vdev
->rom_size
&&
843 !memcmp(vdev
->rom
+ pci_get_word(vdev
->rom
+ 0x18), "PCIR", 4)) {
846 vid
= pci_get_word(vdev
->rom
+ pci_get_word(vdev
->rom
+ 0x18) + 4);
847 did
= pci_get_word(vdev
->rom
+ pci_get_word(vdev
->rom
+ 0x18) + 6);
849 if (vid
== vdev
->vendor_id
&& did
!= vdev
->device_id
) {
851 uint8_t csum
, *data
= vdev
->rom
;
853 pci_set_word(vdev
->rom
+ pci_get_word(vdev
->rom
+ 0x18) + 6,
857 for (csum
= 0, i
= 0; i
< vdev
->rom_size
; i
++) {
866 static uint64_t vfio_rom_read(void *opaque
, hwaddr addr
, unsigned size
)
868 VFIOPCIDevice
*vdev
= opaque
;
877 /* Load the ROM lazily when the guest tries to read it */
878 if (unlikely(!vdev
->rom
&& !vdev
->rom_read_failed
)) {
879 vfio_pci_load_rom(vdev
);
882 memcpy(&val
, vdev
->rom
+ addr
,
883 (addr
< vdev
->rom_size
) ? MIN(size
, vdev
->rom_size
- addr
) : 0);
890 data
= le16_to_cpu(val
.word
);
893 data
= le32_to_cpu(val
.dword
);
896 hw_error("vfio: unsupported read size, %d bytes\n", size
);
900 trace_vfio_rom_read(vdev
->vbasedev
.name
, addr
, size
, data
);
905 static void vfio_rom_write(void *opaque
, hwaddr addr
,
906 uint64_t data
, unsigned size
)
910 static const MemoryRegionOps vfio_rom_ops
= {
911 .read
= vfio_rom_read
,
912 .write
= vfio_rom_write
,
913 .endianness
= DEVICE_LITTLE_ENDIAN
,
916 static void vfio_pci_size_rom(VFIOPCIDevice
*vdev
)
918 uint32_t orig
, size
= cpu_to_le32((uint32_t)PCI_ROM_ADDRESS_MASK
);
919 off_t offset
= vdev
->config_offset
+ PCI_ROM_ADDRESS
;
920 DeviceState
*dev
= DEVICE(vdev
);
922 int fd
= vdev
->vbasedev
.fd
;
924 if (vdev
->pdev
.romfile
|| !vdev
->pdev
.rom_bar
) {
925 /* Since pci handles romfile, just print a message and return */
926 if (vfio_blacklist_opt_rom(vdev
) && vdev
->pdev
.romfile
) {
927 error_printf("Warning : Device at %s is known to cause system instability issues during option rom execution. Proceeding anyway since user specified romfile\n",
928 vdev
->vbasedev
.name
);
934 * Use the same size ROM BAR as the physical device. The contents
935 * will get filled in later when the guest tries to read it.
937 if (pread(fd
, &orig
, 4, offset
) != 4 ||
938 pwrite(fd
, &size
, 4, offset
) != 4 ||
939 pread(fd
, &size
, 4, offset
) != 4 ||
940 pwrite(fd
, &orig
, 4, offset
) != 4) {
941 error_report("%s(%s) failed: %m", __func__
, vdev
->vbasedev
.name
);
945 size
= ~(le32_to_cpu(size
) & PCI_ROM_ADDRESS_MASK
) + 1;
951 if (vfio_blacklist_opt_rom(vdev
)) {
952 if (dev
->opts
&& qemu_opt_get(dev
->opts
, "rombar")) {
953 error_printf("Warning : Device at %s is known to cause system instability issues during option rom execution. Proceeding anyway since user specified non zero value for rombar\n",
954 vdev
->vbasedev
.name
);
956 error_printf("Warning : Rom loading for device at %s has been disabled due to system instability issues. Specify rombar=1 or romfile to force\n",
957 vdev
->vbasedev
.name
);
962 trace_vfio_pci_size_rom(vdev
->vbasedev
.name
, size
);
964 name
= g_strdup_printf("vfio[%s].rom", vdev
->vbasedev
.name
);
966 memory_region_init_io(&vdev
->pdev
.rom
, OBJECT(vdev
),
967 &vfio_rom_ops
, vdev
, name
, size
);
970 pci_register_bar(&vdev
->pdev
, PCI_ROM_SLOT
,
971 PCI_BASE_ADDRESS_SPACE_MEMORY
, &vdev
->pdev
.rom
);
973 vdev
->pdev
.has_rom
= true;
974 vdev
->rom_read_failed
= false;
977 void vfio_vga_write(void *opaque
, hwaddr addr
,
978 uint64_t data
, unsigned size
)
980 VFIOVGARegion
*region
= opaque
;
981 VFIOVGA
*vga
= container_of(region
, VFIOVGA
, region
[region
->nr
]);
988 off_t offset
= vga
->fd_offset
+ region
->offset
+ addr
;
995 buf
.word
= cpu_to_le16(data
);
998 buf
.dword
= cpu_to_le32(data
);
1001 hw_error("vfio: unsupported write size, %d bytes", size
);
1005 if (pwrite(vga
->fd
, &buf
, size
, offset
) != size
) {
1006 error_report("%s(,0x%"HWADDR_PRIx
", 0x%"PRIx64
", %d) failed: %m",
1007 __func__
, region
->offset
+ addr
, data
, size
);
1010 trace_vfio_vga_write(region
->offset
+ addr
, data
, size
);
1013 uint64_t vfio_vga_read(void *opaque
, hwaddr addr
, unsigned size
)
1015 VFIOVGARegion
*region
= opaque
;
1016 VFIOVGA
*vga
= container_of(region
, VFIOVGA
, region
[region
->nr
]);
1024 off_t offset
= vga
->fd_offset
+ region
->offset
+ addr
;
1026 if (pread(vga
->fd
, &buf
, size
, offset
) != size
) {
1027 error_report("%s(,0x%"HWADDR_PRIx
", %d) failed: %m",
1028 __func__
, region
->offset
+ addr
, size
);
1029 return (uint64_t)-1;
1037 data
= le16_to_cpu(buf
.word
);
1040 data
= le32_to_cpu(buf
.dword
);
1043 hw_error("vfio: unsupported read size, %d bytes", size
);
1047 trace_vfio_vga_read(region
->offset
+ addr
, size
, data
);
1052 static const MemoryRegionOps vfio_vga_ops
= {
1053 .read
= vfio_vga_read
,
1054 .write
= vfio_vga_write
,
1055 .endianness
= DEVICE_LITTLE_ENDIAN
,
1061 uint32_t vfio_pci_read_config(PCIDevice
*pdev
, uint32_t addr
, int len
)
1063 VFIOPCIDevice
*vdev
= DO_UPCAST(VFIOPCIDevice
, pdev
, pdev
);
1064 uint32_t emu_bits
= 0, emu_val
= 0, phys_val
= 0, val
;
1066 memcpy(&emu_bits
, vdev
->emulated_config_bits
+ addr
, len
);
1067 emu_bits
= le32_to_cpu(emu_bits
);
1070 emu_val
= pci_default_read_config(pdev
, addr
, len
);
1073 if (~emu_bits
& (0xffffffffU
>> (32 - len
* 8))) {
1076 ret
= pread(vdev
->vbasedev
.fd
, &phys_val
, len
,
1077 vdev
->config_offset
+ addr
);
1079 error_report("%s(%s, 0x%x, 0x%x) failed: %m",
1080 __func__
, vdev
->vbasedev
.name
, addr
, len
);
1083 phys_val
= le32_to_cpu(phys_val
);
1086 val
= (emu_val
& emu_bits
) | (phys_val
& ~emu_bits
);
1088 trace_vfio_pci_read_config(vdev
->vbasedev
.name
, addr
, len
, val
);
1093 void vfio_pci_write_config(PCIDevice
*pdev
,
1094 uint32_t addr
, uint32_t val
, int len
)
1096 VFIOPCIDevice
*vdev
= DO_UPCAST(VFIOPCIDevice
, pdev
, pdev
);
1097 uint32_t val_le
= cpu_to_le32(val
);
1099 trace_vfio_pci_write_config(vdev
->vbasedev
.name
, addr
, val
, len
);
1101 /* Write everything to VFIO, let it filter out what we can't write */
1102 if (pwrite(vdev
->vbasedev
.fd
, &val_le
, len
, vdev
->config_offset
+ addr
)
1104 error_report("%s(%s, 0x%x, 0x%x, 0x%x) failed: %m",
1105 __func__
, vdev
->vbasedev
.name
, addr
, val
, len
);
1108 /* MSI/MSI-X Enabling/Disabling */
1109 if (pdev
->cap_present
& QEMU_PCI_CAP_MSI
&&
1110 ranges_overlap(addr
, len
, pdev
->msi_cap
, vdev
->msi_cap_size
)) {
1111 int is_enabled
, was_enabled
= msi_enabled(pdev
);
1113 pci_default_write_config(pdev
, addr
, val
, len
);
1115 is_enabled
= msi_enabled(pdev
);
1119 vfio_msi_enable(vdev
);
1123 vfio_msi_disable(vdev
);
1125 vfio_update_msi(vdev
);
1128 } else if (pdev
->cap_present
& QEMU_PCI_CAP_MSIX
&&
1129 ranges_overlap(addr
, len
, pdev
->msix_cap
, MSIX_CAP_LENGTH
)) {
1130 int is_enabled
, was_enabled
= msix_enabled(pdev
);
1132 pci_default_write_config(pdev
, addr
, val
, len
);
1134 is_enabled
= msix_enabled(pdev
);
1136 if (!was_enabled
&& is_enabled
) {
1137 vfio_msix_enable(vdev
);
1138 } else if (was_enabled
&& !is_enabled
) {
1139 vfio_msix_disable(vdev
);
1142 /* Write everything to QEMU to keep emulated bits correct */
1143 pci_default_write_config(pdev
, addr
, val
, len
);
1150 static void vfio_disable_interrupts(VFIOPCIDevice
*vdev
)
1153 * More complicated than it looks. Disabling MSI/X transitions the
1154 * device to INTx mode (if supported). Therefore we need to first
1155 * disable MSI/X and then cleanup by disabling INTx.
1157 if (vdev
->interrupt
== VFIO_INT_MSIX
) {
1158 vfio_msix_disable(vdev
);
1159 } else if (vdev
->interrupt
== VFIO_INT_MSI
) {
1160 vfio_msi_disable(vdev
);
1163 if (vdev
->interrupt
== VFIO_INT_INTx
) {
1164 vfio_intx_disable(vdev
);
1168 static int vfio_msi_setup(VFIOPCIDevice
*vdev
, int pos
)
1171 bool msi_64bit
, msi_maskbit
;
1174 if (pread(vdev
->vbasedev
.fd
, &ctrl
, sizeof(ctrl
),
1175 vdev
->config_offset
+ pos
+ PCI_CAP_FLAGS
) != sizeof(ctrl
)) {
1178 ctrl
= le16_to_cpu(ctrl
);
1180 msi_64bit
= !!(ctrl
& PCI_MSI_FLAGS_64BIT
);
1181 msi_maskbit
= !!(ctrl
& PCI_MSI_FLAGS_MASKBIT
);
1182 entries
= 1 << ((ctrl
& PCI_MSI_FLAGS_QMASK
) >> 1);
1184 trace_vfio_msi_setup(vdev
->vbasedev
.name
, pos
);
1186 ret
= msi_init(&vdev
->pdev
, pos
, entries
, msi_64bit
, msi_maskbit
);
1188 if (ret
== -ENOTSUP
) {
1191 error_report("vfio: msi_init failed");
1194 vdev
->msi_cap_size
= 0xa + (msi_maskbit
? 0xa : 0) + (msi_64bit
? 0x4 : 0);
1199 static void vfio_pci_fixup_msix_region(VFIOPCIDevice
*vdev
)
1202 VFIORegion
*region
= &vdev
->bars
[vdev
->msix
->table_bar
].region
;
1205 * We expect to find a single mmap covering the whole BAR, anything else
1206 * means it's either unsupported or already setup.
1208 if (region
->nr_mmaps
!= 1 || region
->mmaps
[0].offset
||
1209 region
->size
!= region
->mmaps
[0].size
) {
1213 /* MSI-X table start and end aligned to host page size */
1214 start
= vdev
->msix
->table_offset
& qemu_real_host_page_mask
;
1215 end
= REAL_HOST_PAGE_ALIGN((uint64_t)vdev
->msix
->table_offset
+
1216 (vdev
->msix
->entries
* PCI_MSIX_ENTRY_SIZE
));
1219 * Does the MSI-X table cover the beginning of the BAR? The whole BAR?
1220 * NB - Host page size is necessarily a power of two and so is the PCI
1221 * BAR (not counting EA yet), therefore if we have host page aligned
1222 * @start and @end, then any remainder of the BAR before or after those
1223 * must be at least host page sized and therefore mmap'able.
1226 if (end
>= region
->size
) {
1227 region
->nr_mmaps
= 0;
1228 g_free(region
->mmaps
);
1229 region
->mmaps
= NULL
;
1230 trace_vfio_msix_fixup(vdev
->vbasedev
.name
,
1231 vdev
->msix
->table_bar
, 0, 0);
1233 region
->mmaps
[0].offset
= end
;
1234 region
->mmaps
[0].size
= region
->size
- end
;
1235 trace_vfio_msix_fixup(vdev
->vbasedev
.name
,
1236 vdev
->msix
->table_bar
, region
->mmaps
[0].offset
,
1237 region
->mmaps
[0].offset
+ region
->mmaps
[0].size
);
1240 /* Maybe it's aligned at the end of the BAR */
1241 } else if (end
>= region
->size
) {
1242 region
->mmaps
[0].size
= start
;
1243 trace_vfio_msix_fixup(vdev
->vbasedev
.name
,
1244 vdev
->msix
->table_bar
, region
->mmaps
[0].offset
,
1245 region
->mmaps
[0].offset
+ region
->mmaps
[0].size
);
1247 /* Otherwise it must split the BAR */
1249 region
->nr_mmaps
= 2;
1250 region
->mmaps
= g_renew(VFIOMmap
, region
->mmaps
, 2);
1252 memcpy(®ion
->mmaps
[1], ®ion
->mmaps
[0], sizeof(VFIOMmap
));
1254 region
->mmaps
[0].size
= start
;
1255 trace_vfio_msix_fixup(vdev
->vbasedev
.name
,
1256 vdev
->msix
->table_bar
, region
->mmaps
[0].offset
,
1257 region
->mmaps
[0].offset
+ region
->mmaps
[0].size
);
1259 region
->mmaps
[1].offset
= end
;
1260 region
->mmaps
[1].size
= region
->size
- end
;
1261 trace_vfio_msix_fixup(vdev
->vbasedev
.name
,
1262 vdev
->msix
->table_bar
, region
->mmaps
[1].offset
,
1263 region
->mmaps
[1].offset
+ region
->mmaps
[1].size
);
1268 * We don't have any control over how pci_add_capability() inserts
1269 * capabilities into the chain. In order to setup MSI-X we need a
1270 * MemoryRegion for the BAR. In order to setup the BAR and not
1271 * attempt to mmap the MSI-X table area, which VFIO won't allow, we
1272 * need to first look for where the MSI-X table lives. So we
1273 * unfortunately split MSI-X setup across two functions.
1275 static int vfio_msix_early_setup(VFIOPCIDevice
*vdev
)
1279 uint32_t table
, pba
;
1280 int fd
= vdev
->vbasedev
.fd
;
1283 pos
= pci_find_capability(&vdev
->pdev
, PCI_CAP_ID_MSIX
);
1288 if (pread(fd
, &ctrl
, sizeof(ctrl
),
1289 vdev
->config_offset
+ pos
+ PCI_MSIX_FLAGS
) != sizeof(ctrl
)) {
1293 if (pread(fd
, &table
, sizeof(table
),
1294 vdev
->config_offset
+ pos
+ PCI_MSIX_TABLE
) != sizeof(table
)) {
1298 if (pread(fd
, &pba
, sizeof(pba
),
1299 vdev
->config_offset
+ pos
+ PCI_MSIX_PBA
) != sizeof(pba
)) {
1303 ctrl
= le16_to_cpu(ctrl
);
1304 table
= le32_to_cpu(table
);
1305 pba
= le32_to_cpu(pba
);
1307 msix
= g_malloc0(sizeof(*msix
));
1308 msix
->table_bar
= table
& PCI_MSIX_FLAGS_BIRMASK
;
1309 msix
->table_offset
= table
& ~PCI_MSIX_FLAGS_BIRMASK
;
1310 msix
->pba_bar
= pba
& PCI_MSIX_FLAGS_BIRMASK
;
1311 msix
->pba_offset
= pba
& ~PCI_MSIX_FLAGS_BIRMASK
;
1312 msix
->entries
= (ctrl
& PCI_MSIX_FLAGS_QSIZE
) + 1;
1315 * Test the size of the pba_offset variable and catch if it extends outside
1316 * of the specified BAR. If it is the case, we need to apply a hardware
1317 * specific quirk if the device is known or we have a broken configuration.
1319 if (msix
->pba_offset
>= vdev
->bars
[msix
->pba_bar
].region
.size
) {
1321 * Chelsio T5 Virtual Function devices are encoded as 0x58xx for T5
1322 * adapters. The T5 hardware returns an incorrect value of 0x8000 for
1323 * the VF PBA offset while the BAR itself is only 8k. The correct value
1324 * is 0x1000, so we hard code that here.
1326 if (vdev
->vendor_id
== PCI_VENDOR_ID_CHELSIO
&&
1327 (vdev
->device_id
& 0xff00) == 0x5800) {
1328 msix
->pba_offset
= 0x1000;
1330 error_report("vfio: Hardware reports invalid configuration, "
1331 "MSIX PBA outside of specified BAR");
1337 trace_vfio_msix_early_setup(vdev
->vbasedev
.name
, pos
, msix
->table_bar
,
1338 msix
->table_offset
, msix
->entries
);
1341 vfio_pci_fixup_msix_region(vdev
);
1346 static int vfio_msix_setup(VFIOPCIDevice
*vdev
, int pos
)
1350 vdev
->msix
->pending
= g_malloc0(BITS_TO_LONGS(vdev
->msix
->entries
) *
1351 sizeof(unsigned long));
1352 ret
= msix_init(&vdev
->pdev
, vdev
->msix
->entries
,
1353 vdev
->bars
[vdev
->msix
->table_bar
].region
.mem
,
1354 vdev
->msix
->table_bar
, vdev
->msix
->table_offset
,
1355 vdev
->bars
[vdev
->msix
->pba_bar
].region
.mem
,
1356 vdev
->msix
->pba_bar
, vdev
->msix
->pba_offset
, pos
);
1358 if (ret
== -ENOTSUP
) {
1361 error_report("vfio: msix_init failed");
1366 * The PCI spec suggests that devices provide additional alignment for
1367 * MSI-X structures and avoid overlapping non-MSI-X related registers.
1368 * For an assigned device, this hopefully means that emulation of MSI-X
1369 * structures does not affect the performance of the device. If devices
1370 * fail to provide that alignment, a significant performance penalty may
1371 * result, for instance Mellanox MT27500 VFs:
1372 * http://www.spinics.net/lists/kvm/msg125881.html
1374 * The PBA is simply not that important for such a serious regression and
1375 * most drivers do not appear to look at it. The solution for this is to
1376 * disable the PBA MemoryRegion unless it's being used. We disable it
1377 * here and only enable it if a masked vector fires through QEMU. As the
1378 * vector-use notifier is called, which occurs on unmask, we test whether
1379 * PBA emulation is needed and again disable if not.
1381 memory_region_set_enabled(&vdev
->pdev
.msix_pba_mmio
, false);
1386 static void vfio_teardown_msi(VFIOPCIDevice
*vdev
)
1388 msi_uninit(&vdev
->pdev
);
1391 msix_uninit(&vdev
->pdev
,
1392 vdev
->bars
[vdev
->msix
->table_bar
].region
.mem
,
1393 vdev
->bars
[vdev
->msix
->pba_bar
].region
.mem
);
1394 g_free(vdev
->msix
->pending
);
1401 static void vfio_mmap_set_enabled(VFIOPCIDevice
*vdev
, bool enabled
)
1405 for (i
= 0; i
< PCI_ROM_SLOT
; i
++) {
1406 vfio_region_mmaps_set_enabled(&vdev
->bars
[i
].region
, enabled
);
1410 static void vfio_bar_setup(VFIOPCIDevice
*vdev
, int nr
)
1412 VFIOBAR
*bar
= &vdev
->bars
[nr
];
1418 /* Skip both unimplemented BARs and the upper half of 64bit BARS. */
1419 if (!bar
->region
.size
) {
1423 /* Determine what type of BAR this is for registration */
1424 ret
= pread(vdev
->vbasedev
.fd
, &pci_bar
, sizeof(pci_bar
),
1425 vdev
->config_offset
+ PCI_BASE_ADDRESS_0
+ (4 * nr
));
1426 if (ret
!= sizeof(pci_bar
)) {
1427 error_report("vfio: Failed to read BAR %d (%m)", nr
);
1431 pci_bar
= le32_to_cpu(pci_bar
);
1432 bar
->ioport
= (pci_bar
& PCI_BASE_ADDRESS_SPACE_IO
);
1433 bar
->mem64
= bar
->ioport
? 0 : (pci_bar
& PCI_BASE_ADDRESS_MEM_TYPE_64
);
1434 type
= pci_bar
& (bar
->ioport
? ~PCI_BASE_ADDRESS_IO_MASK
:
1435 ~PCI_BASE_ADDRESS_MEM_MASK
);
1437 if (vfio_region_mmap(&bar
->region
)) {
1438 error_report("Failed to mmap %s BAR %d. Performance may be slow",
1439 vdev
->vbasedev
.name
, nr
);
1442 pci_register_bar(&vdev
->pdev
, nr
, type
, bar
->region
.mem
);
1445 static void vfio_bars_setup(VFIOPCIDevice
*vdev
)
1449 for (i
= 0; i
< PCI_ROM_SLOT
; i
++) {
1450 vfio_bar_setup(vdev
, i
);
1454 static void vfio_bars_exit(VFIOPCIDevice
*vdev
)
1458 for (i
= 0; i
< PCI_ROM_SLOT
; i
++) {
1459 vfio_bar_quirk_exit(vdev
, i
);
1460 vfio_region_exit(&vdev
->bars
[i
].region
);
1464 pci_unregister_vga(&vdev
->pdev
);
1465 vfio_vga_quirk_exit(vdev
);
1469 static void vfio_bars_finalize(VFIOPCIDevice
*vdev
)
1473 for (i
= 0; i
< PCI_ROM_SLOT
; i
++) {
1474 vfio_bar_quirk_finalize(vdev
, i
);
1475 vfio_region_finalize(&vdev
->bars
[i
].region
);
1479 vfio_vga_quirk_finalize(vdev
);
1480 for (i
= 0; i
< ARRAY_SIZE(vdev
->vga
->region
); i
++) {
1481 object_unparent(OBJECT(&vdev
->vga
->region
[i
].mem
));
1490 static uint8_t vfio_std_cap_max_size(PCIDevice
*pdev
, uint8_t pos
)
1493 uint16_t next
= PCI_CONFIG_SPACE_SIZE
;
1495 for (tmp
= pdev
->config
[PCI_CAPABILITY_LIST
]; tmp
;
1496 tmp
= pdev
->config
[tmp
+ PCI_CAP_LIST_NEXT
]) {
1497 if (tmp
> pos
&& tmp
< next
) {
1505 static void vfio_set_word_bits(uint8_t *buf
, uint16_t val
, uint16_t mask
)
1507 pci_set_word(buf
, (pci_get_word(buf
) & ~mask
) | val
);
1510 static void vfio_add_emulated_word(VFIOPCIDevice
*vdev
, int pos
,
1511 uint16_t val
, uint16_t mask
)
1513 vfio_set_word_bits(vdev
->pdev
.config
+ pos
, val
, mask
);
1514 vfio_set_word_bits(vdev
->pdev
.wmask
+ pos
, ~mask
, mask
);
1515 vfio_set_word_bits(vdev
->emulated_config_bits
+ pos
, mask
, mask
);
1518 static void vfio_set_long_bits(uint8_t *buf
, uint32_t val
, uint32_t mask
)
1520 pci_set_long(buf
, (pci_get_long(buf
) & ~mask
) | val
);
1523 static void vfio_add_emulated_long(VFIOPCIDevice
*vdev
, int pos
,
1524 uint32_t val
, uint32_t mask
)
1526 vfio_set_long_bits(vdev
->pdev
.config
+ pos
, val
, mask
);
1527 vfio_set_long_bits(vdev
->pdev
.wmask
+ pos
, ~mask
, mask
);
1528 vfio_set_long_bits(vdev
->emulated_config_bits
+ pos
, mask
, mask
);
1531 static int vfio_setup_pcie_cap(VFIOPCIDevice
*vdev
, int pos
, uint8_t size
)
1536 flags
= pci_get_word(vdev
->pdev
.config
+ pos
+ PCI_CAP_FLAGS
);
1537 type
= (flags
& PCI_EXP_FLAGS_TYPE
) >> 4;
1539 if (type
!= PCI_EXP_TYPE_ENDPOINT
&&
1540 type
!= PCI_EXP_TYPE_LEG_END
&&
1541 type
!= PCI_EXP_TYPE_RC_END
) {
1543 error_report("vfio: Assignment of PCIe type 0x%x "
1544 "devices is not currently supported", type
);
1548 if (!pci_bus_is_express(vdev
->pdev
.bus
)) {
1549 PCIBus
*bus
= vdev
->pdev
.bus
;
1553 * Traditionally PCI device assignment exposes the PCIe capability
1554 * as-is on non-express buses. The reason being that some drivers
1555 * simply assume that it's there, for example tg3. However when
1556 * we're running on a native PCIe machine type, like Q35, we need
1557 * to hide the PCIe capability. The reason for this is twofold;
1558 * first Windows guests get a Code 10 error when the PCIe capability
1559 * is exposed in this configuration. Therefore express devices won't
1560 * work at all unless they're attached to express buses in the VM.
1561 * Second, a native PCIe machine introduces the possibility of fine
1562 * granularity IOMMUs supporting both translation and isolation.
1563 * Guest code to discover the IOMMU visibility of a device, such as
1564 * IOMMU grouping code on Linux, is very aware of device types and
1565 * valid transitions between bus types. An express device on a non-
1566 * express bus is not a valid combination on bare metal systems.
1568 * Drivers that require a PCIe capability to make the device
1569 * functional are simply going to need to have their devices placed
1570 * on a PCIe bus in the VM.
1572 while (!pci_bus_is_root(bus
)) {
1573 bridge
= pci_bridge_get_device(bus
);
1577 if (pci_bus_is_express(bus
)) {
1581 } else if (pci_bus_is_root(vdev
->pdev
.bus
)) {
1583 * On a Root Complex bus Endpoints become Root Complex Integrated
1584 * Endpoints, which changes the type and clears the LNK & LNK2 fields.
1586 if (type
== PCI_EXP_TYPE_ENDPOINT
) {
1587 vfio_add_emulated_word(vdev
, pos
+ PCI_CAP_FLAGS
,
1588 PCI_EXP_TYPE_RC_END
<< 4,
1589 PCI_EXP_FLAGS_TYPE
);
1591 /* Link Capabilities, Status, and Control goes away */
1592 if (size
> PCI_EXP_LNKCTL
) {
1593 vfio_add_emulated_long(vdev
, pos
+ PCI_EXP_LNKCAP
, 0, ~0);
1594 vfio_add_emulated_word(vdev
, pos
+ PCI_EXP_LNKCTL
, 0, ~0);
1595 vfio_add_emulated_word(vdev
, pos
+ PCI_EXP_LNKSTA
, 0, ~0);
1597 #ifndef PCI_EXP_LNKCAP2
1598 #define PCI_EXP_LNKCAP2 44
1600 #ifndef PCI_EXP_LNKSTA2
1601 #define PCI_EXP_LNKSTA2 50
1603 /* Link 2 Capabilities, Status, and Control goes away */
1604 if (size
> PCI_EXP_LNKCAP2
) {
1605 vfio_add_emulated_long(vdev
, pos
+ PCI_EXP_LNKCAP2
, 0, ~0);
1606 vfio_add_emulated_word(vdev
, pos
+ PCI_EXP_LNKCTL2
, 0, ~0);
1607 vfio_add_emulated_word(vdev
, pos
+ PCI_EXP_LNKSTA2
, 0, ~0);
1611 } else if (type
== PCI_EXP_TYPE_LEG_END
) {
1613 * Legacy endpoints don't belong on the root complex. Windows
1614 * seems to be happier with devices if we skip the capability.
1621 * Convert Root Complex Integrated Endpoints to regular endpoints.
1622 * These devices don't support LNK/LNK2 capabilities, so make them up.
1624 if (type
== PCI_EXP_TYPE_RC_END
) {
1625 vfio_add_emulated_word(vdev
, pos
+ PCI_CAP_FLAGS
,
1626 PCI_EXP_TYPE_ENDPOINT
<< 4,
1627 PCI_EXP_FLAGS_TYPE
);
1628 vfio_add_emulated_long(vdev
, pos
+ PCI_EXP_LNKCAP
,
1629 PCI_EXP_LNK_MLW_1
| PCI_EXP_LNK_LS_25
, ~0);
1630 vfio_add_emulated_word(vdev
, pos
+ PCI_EXP_LNKCTL
, 0, ~0);
1633 /* Mark the Link Status bits as emulated to allow virtual negotiation */
1634 vfio_add_emulated_word(vdev
, pos
+ PCI_EXP_LNKSTA
,
1635 pci_get_word(vdev
->pdev
.config
+ pos
+
1637 PCI_EXP_LNKCAP_MLW
| PCI_EXP_LNKCAP_SLS
);
1640 pos
= pci_add_capability(&vdev
->pdev
, PCI_CAP_ID_EXP
, pos
, size
);
1642 vdev
->pdev
.exp
.exp_cap
= pos
;
1648 static void vfio_check_pcie_flr(VFIOPCIDevice
*vdev
, uint8_t pos
)
1650 uint32_t cap
= pci_get_long(vdev
->pdev
.config
+ pos
+ PCI_EXP_DEVCAP
);
1652 if (cap
& PCI_EXP_DEVCAP_FLR
) {
1653 trace_vfio_check_pcie_flr(vdev
->vbasedev
.name
);
1654 vdev
->has_flr
= true;
1658 static void vfio_check_pm_reset(VFIOPCIDevice
*vdev
, uint8_t pos
)
1660 uint16_t csr
= pci_get_word(vdev
->pdev
.config
+ pos
+ PCI_PM_CTRL
);
1662 if (!(csr
& PCI_PM_CTRL_NO_SOFT_RESET
)) {
1663 trace_vfio_check_pm_reset(vdev
->vbasedev
.name
);
1664 vdev
->has_pm_reset
= true;
1668 static void vfio_check_af_flr(VFIOPCIDevice
*vdev
, uint8_t pos
)
1670 uint8_t cap
= pci_get_byte(vdev
->pdev
.config
+ pos
+ PCI_AF_CAP
);
1672 if ((cap
& PCI_AF_CAP_TP
) && (cap
& PCI_AF_CAP_FLR
)) {
1673 trace_vfio_check_af_flr(vdev
->vbasedev
.name
);
1674 vdev
->has_flr
= true;
1678 static int vfio_add_std_cap(VFIOPCIDevice
*vdev
, uint8_t pos
)
1680 PCIDevice
*pdev
= &vdev
->pdev
;
1681 uint8_t cap_id
, next
, size
;
1684 cap_id
= pdev
->config
[pos
];
1685 next
= pdev
->config
[pos
+ PCI_CAP_LIST_NEXT
];
1688 * If it becomes important to configure capabilities to their actual
1689 * size, use this as the default when it's something we don't recognize.
1690 * Since QEMU doesn't actually handle many of the config accesses,
1691 * exact size doesn't seem worthwhile.
1693 size
= vfio_std_cap_max_size(pdev
, pos
);
1696 * pci_add_capability always inserts the new capability at the head
1697 * of the chain. Therefore to end up with a chain that matches the
1698 * physical device, we insert from the end by making this recursive.
1699 * This is also why we pre-calculate size above as cached config space
1700 * will be changed as we unwind the stack.
1703 ret
= vfio_add_std_cap(vdev
, next
);
1708 /* Begin the rebuild, use QEMU emulated list bits */
1709 pdev
->config
[PCI_CAPABILITY_LIST
] = 0;
1710 vdev
->emulated_config_bits
[PCI_CAPABILITY_LIST
] = 0xff;
1711 vdev
->emulated_config_bits
[PCI_STATUS
] |= PCI_STATUS_CAP_LIST
;
1714 /* Use emulated next pointer to allow dropping caps */
1715 pci_set_byte(vdev
->emulated_config_bits
+ pos
+ PCI_CAP_LIST_NEXT
, 0xff);
1718 case PCI_CAP_ID_MSI
:
1719 ret
= vfio_msi_setup(vdev
, pos
);
1721 case PCI_CAP_ID_EXP
:
1722 vfio_check_pcie_flr(vdev
, pos
);
1723 ret
= vfio_setup_pcie_cap(vdev
, pos
, size
);
1725 case PCI_CAP_ID_MSIX
:
1726 ret
= vfio_msix_setup(vdev
, pos
);
1729 vfio_check_pm_reset(vdev
, pos
);
1731 ret
= pci_add_capability(pdev
, cap_id
, pos
, size
);
1734 vfio_check_af_flr(vdev
, pos
);
1735 ret
= pci_add_capability(pdev
, cap_id
, pos
, size
);
1738 ret
= pci_add_capability(pdev
, cap_id
, pos
, size
);
1743 error_report("vfio: %s Error adding PCI capability "
1744 "0x%x[0x%x]@0x%x: %d", vdev
->vbasedev
.name
,
1745 cap_id
, size
, pos
, ret
);
1752 static int vfio_add_capabilities(VFIOPCIDevice
*vdev
)
1754 PCIDevice
*pdev
= &vdev
->pdev
;
1756 if (!(pdev
->config
[PCI_STATUS
] & PCI_STATUS_CAP_LIST
) ||
1757 !pdev
->config
[PCI_CAPABILITY_LIST
]) {
1758 return 0; /* Nothing to add */
1761 return vfio_add_std_cap(vdev
, pdev
->config
[PCI_CAPABILITY_LIST
]);
1764 static void vfio_pci_pre_reset(VFIOPCIDevice
*vdev
)
1766 PCIDevice
*pdev
= &vdev
->pdev
;
1769 vfio_disable_interrupts(vdev
);
1771 /* Make sure the device is in D0 */
1776 pmcsr
= vfio_pci_read_config(pdev
, vdev
->pm_cap
+ PCI_PM_CTRL
, 2);
1777 state
= pmcsr
& PCI_PM_CTRL_STATE_MASK
;
1779 pmcsr
&= ~PCI_PM_CTRL_STATE_MASK
;
1780 vfio_pci_write_config(pdev
, vdev
->pm_cap
+ PCI_PM_CTRL
, pmcsr
, 2);
1781 /* vfio handles the necessary delay here */
1782 pmcsr
= vfio_pci_read_config(pdev
, vdev
->pm_cap
+ PCI_PM_CTRL
, 2);
1783 state
= pmcsr
& PCI_PM_CTRL_STATE_MASK
;
1785 error_report("vfio: Unable to power on device, stuck in D%d",
1792 * Stop any ongoing DMA by disconecting I/O, MMIO, and bus master.
1793 * Also put INTx Disable in known state.
1795 cmd
= vfio_pci_read_config(pdev
, PCI_COMMAND
, 2);
1796 cmd
&= ~(PCI_COMMAND_IO
| PCI_COMMAND_MEMORY
| PCI_COMMAND_MASTER
|
1797 PCI_COMMAND_INTX_DISABLE
);
1798 vfio_pci_write_config(pdev
, PCI_COMMAND
, cmd
, 2);
1801 static void vfio_pci_post_reset(VFIOPCIDevice
*vdev
)
1803 vfio_intx_enable(vdev
);
1806 static bool vfio_pci_host_match(PCIHostDeviceAddress
*addr
, const char *name
)
1810 sprintf(tmp
, "%04x:%02x:%02x.%1x", addr
->domain
,
1811 addr
->bus
, addr
->slot
, addr
->function
);
1813 return (strcmp(tmp
, name
) == 0);
1816 static int vfio_pci_hot_reset(VFIOPCIDevice
*vdev
, bool single
)
1819 struct vfio_pci_hot_reset_info
*info
;
1820 struct vfio_pci_dependent_device
*devices
;
1821 struct vfio_pci_hot_reset
*reset
;
1826 trace_vfio_pci_hot_reset(vdev
->vbasedev
.name
, single
? "one" : "multi");
1828 vfio_pci_pre_reset(vdev
);
1829 vdev
->vbasedev
.needs_reset
= false;
1831 info
= g_malloc0(sizeof(*info
));
1832 info
->argsz
= sizeof(*info
);
1834 ret
= ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_GET_PCI_HOT_RESET_INFO
, info
);
1835 if (ret
&& errno
!= ENOSPC
) {
1837 if (!vdev
->has_pm_reset
) {
1838 error_report("vfio: Cannot reset device %s, "
1839 "no available reset mechanism.", vdev
->vbasedev
.name
);
1844 count
= info
->count
;
1845 info
= g_realloc(info
, sizeof(*info
) + (count
* sizeof(*devices
)));
1846 info
->argsz
= sizeof(*info
) + (count
* sizeof(*devices
));
1847 devices
= &info
->devices
[0];
1849 ret
= ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_GET_PCI_HOT_RESET_INFO
, info
);
1852 error_report("vfio: hot reset info failed: %m");
1856 trace_vfio_pci_hot_reset_has_dep_devices(vdev
->vbasedev
.name
);
1858 /* Verify that we have all the groups required */
1859 for (i
= 0; i
< info
->count
; i
++) {
1860 PCIHostDeviceAddress host
;
1862 VFIODevice
*vbasedev_iter
;
1864 host
.domain
= devices
[i
].segment
;
1865 host
.bus
= devices
[i
].bus
;
1866 host
.slot
= PCI_SLOT(devices
[i
].devfn
);
1867 host
.function
= PCI_FUNC(devices
[i
].devfn
);
1869 trace_vfio_pci_hot_reset_dep_devices(host
.domain
,
1870 host
.bus
, host
.slot
, host
.function
, devices
[i
].group_id
);
1872 if (vfio_pci_host_match(&host
, vdev
->vbasedev
.name
)) {
1876 QLIST_FOREACH(group
, &vfio_group_list
, next
) {
1877 if (group
->groupid
== devices
[i
].group_id
) {
1883 if (!vdev
->has_pm_reset
) {
1884 error_report("vfio: Cannot reset device %s, "
1885 "depends on group %d which is not owned.",
1886 vdev
->vbasedev
.name
, devices
[i
].group_id
);
1892 /* Prep dependent devices for reset and clear our marker. */
1893 QLIST_FOREACH(vbasedev_iter
, &group
->device_list
, next
) {
1894 if (vbasedev_iter
->type
!= VFIO_DEVICE_TYPE_PCI
) {
1897 tmp
= container_of(vbasedev_iter
, VFIOPCIDevice
, vbasedev
);
1898 if (vfio_pci_host_match(&host
, tmp
->vbasedev
.name
)) {
1903 vfio_pci_pre_reset(tmp
);
1904 tmp
->vbasedev
.needs_reset
= false;
1911 if (!single
&& !multi
) {
1916 /* Determine how many group fds need to be passed */
1918 QLIST_FOREACH(group
, &vfio_group_list
, next
) {
1919 for (i
= 0; i
< info
->count
; i
++) {
1920 if (group
->groupid
== devices
[i
].group_id
) {
1927 reset
= g_malloc0(sizeof(*reset
) + (count
* sizeof(*fds
)));
1928 reset
->argsz
= sizeof(*reset
) + (count
* sizeof(*fds
));
1929 fds
= &reset
->group_fds
[0];
1931 /* Fill in group fds */
1932 QLIST_FOREACH(group
, &vfio_group_list
, next
) {
1933 for (i
= 0; i
< info
->count
; i
++) {
1934 if (group
->groupid
== devices
[i
].group_id
) {
1935 fds
[reset
->count
++] = group
->fd
;
1942 ret
= ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_PCI_HOT_RESET
, reset
);
1945 trace_vfio_pci_hot_reset_result(vdev
->vbasedev
.name
,
1946 ret
? "%m" : "Success");
1949 /* Re-enable INTx on affected devices */
1950 for (i
= 0; i
< info
->count
; i
++) {
1951 PCIHostDeviceAddress host
;
1953 VFIODevice
*vbasedev_iter
;
1955 host
.domain
= devices
[i
].segment
;
1956 host
.bus
= devices
[i
].bus
;
1957 host
.slot
= PCI_SLOT(devices
[i
].devfn
);
1958 host
.function
= PCI_FUNC(devices
[i
].devfn
);
1960 if (vfio_pci_host_match(&host
, vdev
->vbasedev
.name
)) {
1964 QLIST_FOREACH(group
, &vfio_group_list
, next
) {
1965 if (group
->groupid
== devices
[i
].group_id
) {
1974 QLIST_FOREACH(vbasedev_iter
, &group
->device_list
, next
) {
1975 if (vbasedev_iter
->type
!= VFIO_DEVICE_TYPE_PCI
) {
1978 tmp
= container_of(vbasedev_iter
, VFIOPCIDevice
, vbasedev
);
1979 if (vfio_pci_host_match(&host
, tmp
->vbasedev
.name
)) {
1980 vfio_pci_post_reset(tmp
);
1986 vfio_pci_post_reset(vdev
);
1993 * We want to differentiate hot reset of mulitple in-use devices vs hot reset
1994 * of a single in-use device. VFIO_DEVICE_RESET will already handle the case
1995 * of doing hot resets when there is only a single device per bus. The in-use
1996 * here refers to how many VFIODevices are affected. A hot reset that affects
1997 * multiple devices, but only a single in-use device, means that we can call
1998 * it from our bus ->reset() callback since the extent is effectively a single
1999 * device. This allows us to make use of it in the hotplug path. When there
2000 * are multiple in-use devices, we can only trigger the hot reset during a
2001 * system reset and thus from our reset handler. We separate _one vs _multi
2002 * here so that we don't overlap and do a double reset on the system reset
2003 * path where both our reset handler and ->reset() callback are used. Calling
2004 * _one() will only do a hot reset for the one in-use devices case, calling
2005 * _multi() will do nothing if a _one() would have been sufficient.
2007 static int vfio_pci_hot_reset_one(VFIOPCIDevice
*vdev
)
2009 return vfio_pci_hot_reset(vdev
, true);
2012 static int vfio_pci_hot_reset_multi(VFIODevice
*vbasedev
)
2014 VFIOPCIDevice
*vdev
= container_of(vbasedev
, VFIOPCIDevice
, vbasedev
);
2015 return vfio_pci_hot_reset(vdev
, false);
2018 static void vfio_pci_compute_needs_reset(VFIODevice
*vbasedev
)
2020 VFIOPCIDevice
*vdev
= container_of(vbasedev
, VFIOPCIDevice
, vbasedev
);
2021 if (!vbasedev
->reset_works
|| (!vdev
->has_flr
&& vdev
->has_pm_reset
)) {
2022 vbasedev
->needs_reset
= true;
2026 static VFIODeviceOps vfio_pci_ops
= {
2027 .vfio_compute_needs_reset
= vfio_pci_compute_needs_reset
,
2028 .vfio_hot_reset_multi
= vfio_pci_hot_reset_multi
,
2029 .vfio_eoi
= vfio_intx_eoi
,
2032 int vfio_populate_vga(VFIOPCIDevice
*vdev
)
2034 VFIODevice
*vbasedev
= &vdev
->vbasedev
;
2035 struct vfio_region_info
*reg_info
;
2038 ret
= vfio_get_region_info(vbasedev
, VFIO_PCI_VGA_REGION_INDEX
, ®_info
);
2043 if (!(reg_info
->flags
& VFIO_REGION_INFO_FLAG_READ
) ||
2044 !(reg_info
->flags
& VFIO_REGION_INFO_FLAG_WRITE
) ||
2045 reg_info
->size
< 0xbffff + 1) {
2046 error_report("vfio: Unexpected VGA info, flags 0x%lx, size 0x%lx",
2047 (unsigned long)reg_info
->flags
,
2048 (unsigned long)reg_info
->size
);
2053 vdev
->vga
= g_new0(VFIOVGA
, 1);
2055 vdev
->vga
->fd_offset
= reg_info
->offset
;
2056 vdev
->vga
->fd
= vdev
->vbasedev
.fd
;
2060 vdev
->vga
->region
[QEMU_PCI_VGA_MEM
].offset
= QEMU_PCI_VGA_MEM_BASE
;
2061 vdev
->vga
->region
[QEMU_PCI_VGA_MEM
].nr
= QEMU_PCI_VGA_MEM
;
2062 QLIST_INIT(&vdev
->vga
->region
[QEMU_PCI_VGA_MEM
].quirks
);
2064 memory_region_init_io(&vdev
->vga
->region
[QEMU_PCI_VGA_MEM
].mem
,
2065 OBJECT(vdev
), &vfio_vga_ops
,
2066 &vdev
->vga
->region
[QEMU_PCI_VGA_MEM
],
2067 "vfio-vga-mmio@0xa0000",
2068 QEMU_PCI_VGA_MEM_SIZE
);
2070 vdev
->vga
->region
[QEMU_PCI_VGA_IO_LO
].offset
= QEMU_PCI_VGA_IO_LO_BASE
;
2071 vdev
->vga
->region
[QEMU_PCI_VGA_IO_LO
].nr
= QEMU_PCI_VGA_IO_LO
;
2072 QLIST_INIT(&vdev
->vga
->region
[QEMU_PCI_VGA_IO_LO
].quirks
);
2074 memory_region_init_io(&vdev
->vga
->region
[QEMU_PCI_VGA_IO_LO
].mem
,
2075 OBJECT(vdev
), &vfio_vga_ops
,
2076 &vdev
->vga
->region
[QEMU_PCI_VGA_IO_LO
],
2077 "vfio-vga-io@0x3b0",
2078 QEMU_PCI_VGA_IO_LO_SIZE
);
2080 vdev
->vga
->region
[QEMU_PCI_VGA_IO_HI
].offset
= QEMU_PCI_VGA_IO_HI_BASE
;
2081 vdev
->vga
->region
[QEMU_PCI_VGA_IO_HI
].nr
= QEMU_PCI_VGA_IO_HI
;
2082 QLIST_INIT(&vdev
->vga
->region
[QEMU_PCI_VGA_IO_HI
].quirks
);
2084 memory_region_init_io(&vdev
->vga
->region
[QEMU_PCI_VGA_IO_HI
].mem
,
2085 OBJECT(vdev
), &vfio_vga_ops
,
2086 &vdev
->vga
->region
[QEMU_PCI_VGA_IO_HI
],
2087 "vfio-vga-io@0x3c0",
2088 QEMU_PCI_VGA_IO_HI_SIZE
);
2090 pci_register_vga(&vdev
->pdev
, &vdev
->vga
->region
[QEMU_PCI_VGA_MEM
].mem
,
2091 &vdev
->vga
->region
[QEMU_PCI_VGA_IO_LO
].mem
,
2092 &vdev
->vga
->region
[QEMU_PCI_VGA_IO_HI
].mem
);
2097 static int vfio_populate_device(VFIOPCIDevice
*vdev
)
2099 VFIODevice
*vbasedev
= &vdev
->vbasedev
;
2100 struct vfio_region_info
*reg_info
;
2101 struct vfio_irq_info irq_info
= { .argsz
= sizeof(irq_info
) };
2104 /* Sanity check device */
2105 if (!(vbasedev
->flags
& VFIO_DEVICE_FLAGS_PCI
)) {
2106 error_report("vfio: Um, this isn't a PCI device");
2110 if (vbasedev
->num_regions
< VFIO_PCI_CONFIG_REGION_INDEX
+ 1) {
2111 error_report("vfio: unexpected number of io regions %u",
2112 vbasedev
->num_regions
);
2116 if (vbasedev
->num_irqs
< VFIO_PCI_MSIX_IRQ_INDEX
+ 1) {
2117 error_report("vfio: unexpected number of irqs %u", vbasedev
->num_irqs
);
2121 for (i
= VFIO_PCI_BAR0_REGION_INDEX
; i
< VFIO_PCI_ROM_REGION_INDEX
; i
++) {
2122 char *name
= g_strdup_printf("%s BAR %d", vbasedev
->name
, i
);
2124 ret
= vfio_region_setup(OBJECT(vdev
), vbasedev
,
2125 &vdev
->bars
[i
].region
, i
, name
);
2129 error_report("vfio: Error getting region %d info: %m", i
);
2133 QLIST_INIT(&vdev
->bars
[i
].quirks
);
2136 ret
= vfio_get_region_info(vbasedev
,
2137 VFIO_PCI_CONFIG_REGION_INDEX
, ®_info
);
2139 error_report("vfio: Error getting config info: %m");
2143 trace_vfio_populate_device_config(vdev
->vbasedev
.name
,
2144 (unsigned long)reg_info
->size
,
2145 (unsigned long)reg_info
->offset
,
2146 (unsigned long)reg_info
->flags
);
2148 vdev
->config_size
= reg_info
->size
;
2149 if (vdev
->config_size
== PCI_CONFIG_SPACE_SIZE
) {
2150 vdev
->pdev
.cap_present
&= ~QEMU_PCI_CAP_EXPRESS
;
2152 vdev
->config_offset
= reg_info
->offset
;
2156 if (vdev
->features
& VFIO_FEATURE_ENABLE_VGA
) {
2157 ret
= vfio_populate_vga(vdev
);
2160 "vfio: Device does not support requested feature x-vga");
2165 irq_info
.index
= VFIO_PCI_ERR_IRQ_INDEX
;
2167 ret
= ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_GET_IRQ_INFO
, &irq_info
);
2169 /* This can fail for an old kernel or legacy PCI dev */
2170 trace_vfio_populate_device_get_irq_info_failure();
2172 } else if (irq_info
.count
== 1) {
2173 vdev
->pci_aer
= true;
2175 error_report("vfio: %s "
2176 "Could not enable error recovery for the device",
2184 static void vfio_put_device(VFIOPCIDevice
*vdev
)
2186 g_free(vdev
->vbasedev
.name
);
2189 vfio_put_base_device(&vdev
->vbasedev
);
2192 static void vfio_err_notifier_handler(void *opaque
)
2194 VFIOPCIDevice
*vdev
= opaque
;
2196 if (!event_notifier_test_and_clear(&vdev
->err_notifier
)) {
2201 * TBD. Retrieve the error details and decide what action
2202 * needs to be taken. One of the actions could be to pass
2203 * the error to the guest and have the guest driver recover
2204 * from the error. This requires that PCIe capabilities be
2205 * exposed to the guest. For now, we just terminate the
2206 * guest to contain the error.
2209 error_report("%s(%s) Unrecoverable error detected. Please collect any data possible and then kill the guest", __func__
, vdev
->vbasedev
.name
);
2211 vm_stop(RUN_STATE_INTERNAL_ERROR
);
2215 * Registers error notifier for devices supporting error recovery.
2216 * If we encounter a failure in this function, we report an error
2217 * and continue after disabling error recovery support for the
2220 static void vfio_register_err_notifier(VFIOPCIDevice
*vdev
)
2224 struct vfio_irq_set
*irq_set
;
2227 if (!vdev
->pci_aer
) {
2231 if (event_notifier_init(&vdev
->err_notifier
, 0)) {
2232 error_report("vfio: Unable to init event notifier for error detection");
2233 vdev
->pci_aer
= false;
2237 argsz
= sizeof(*irq_set
) + sizeof(*pfd
);
2239 irq_set
= g_malloc0(argsz
);
2240 irq_set
->argsz
= argsz
;
2241 irq_set
->flags
= VFIO_IRQ_SET_DATA_EVENTFD
|
2242 VFIO_IRQ_SET_ACTION_TRIGGER
;
2243 irq_set
->index
= VFIO_PCI_ERR_IRQ_INDEX
;
2246 pfd
= (int32_t *)&irq_set
->data
;
2248 *pfd
= event_notifier_get_fd(&vdev
->err_notifier
);
2249 qemu_set_fd_handler(*pfd
, vfio_err_notifier_handler
, NULL
, vdev
);
2251 ret
= ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_SET_IRQS
, irq_set
);
2253 error_report("vfio: Failed to set up error notification");
2254 qemu_set_fd_handler(*pfd
, NULL
, NULL
, vdev
);
2255 event_notifier_cleanup(&vdev
->err_notifier
);
2256 vdev
->pci_aer
= false;
2261 static void vfio_unregister_err_notifier(VFIOPCIDevice
*vdev
)
2264 struct vfio_irq_set
*irq_set
;
2268 if (!vdev
->pci_aer
) {
2272 argsz
= sizeof(*irq_set
) + sizeof(*pfd
);
2274 irq_set
= g_malloc0(argsz
);
2275 irq_set
->argsz
= argsz
;
2276 irq_set
->flags
= VFIO_IRQ_SET_DATA_EVENTFD
|
2277 VFIO_IRQ_SET_ACTION_TRIGGER
;
2278 irq_set
->index
= VFIO_PCI_ERR_IRQ_INDEX
;
2281 pfd
= (int32_t *)&irq_set
->data
;
2284 ret
= ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_SET_IRQS
, irq_set
);
2286 error_report("vfio: Failed to de-assign error fd: %m");
2289 qemu_set_fd_handler(event_notifier_get_fd(&vdev
->err_notifier
),
2291 event_notifier_cleanup(&vdev
->err_notifier
);
2294 static void vfio_req_notifier_handler(void *opaque
)
2296 VFIOPCIDevice
*vdev
= opaque
;
2298 if (!event_notifier_test_and_clear(&vdev
->req_notifier
)) {
2302 qdev_unplug(&vdev
->pdev
.qdev
, NULL
);
2305 static void vfio_register_req_notifier(VFIOPCIDevice
*vdev
)
2307 struct vfio_irq_info irq_info
= { .argsz
= sizeof(irq_info
),
2308 .index
= VFIO_PCI_REQ_IRQ_INDEX
};
2310 struct vfio_irq_set
*irq_set
;
2313 if (!(vdev
->features
& VFIO_FEATURE_ENABLE_REQ
)) {
2317 if (ioctl(vdev
->vbasedev
.fd
,
2318 VFIO_DEVICE_GET_IRQ_INFO
, &irq_info
) < 0 || irq_info
.count
< 1) {
2322 if (event_notifier_init(&vdev
->req_notifier
, 0)) {
2323 error_report("vfio: Unable to init event notifier for device request");
2327 argsz
= sizeof(*irq_set
) + sizeof(*pfd
);
2329 irq_set
= g_malloc0(argsz
);
2330 irq_set
->argsz
= argsz
;
2331 irq_set
->flags
= VFIO_IRQ_SET_DATA_EVENTFD
|
2332 VFIO_IRQ_SET_ACTION_TRIGGER
;
2333 irq_set
->index
= VFIO_PCI_REQ_IRQ_INDEX
;
2336 pfd
= (int32_t *)&irq_set
->data
;
2338 *pfd
= event_notifier_get_fd(&vdev
->req_notifier
);
2339 qemu_set_fd_handler(*pfd
, vfio_req_notifier_handler
, NULL
, vdev
);
2341 if (ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_SET_IRQS
, irq_set
)) {
2342 error_report("vfio: Failed to set up device request notification");
2343 qemu_set_fd_handler(*pfd
, NULL
, NULL
, vdev
);
2344 event_notifier_cleanup(&vdev
->req_notifier
);
2346 vdev
->req_enabled
= true;
2352 static void vfio_unregister_req_notifier(VFIOPCIDevice
*vdev
)
2355 struct vfio_irq_set
*irq_set
;
2358 if (!vdev
->req_enabled
) {
2362 argsz
= sizeof(*irq_set
) + sizeof(*pfd
);
2364 irq_set
= g_malloc0(argsz
);
2365 irq_set
->argsz
= argsz
;
2366 irq_set
->flags
= VFIO_IRQ_SET_DATA_EVENTFD
|
2367 VFIO_IRQ_SET_ACTION_TRIGGER
;
2368 irq_set
->index
= VFIO_PCI_REQ_IRQ_INDEX
;
2371 pfd
= (int32_t *)&irq_set
->data
;
2374 if (ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_SET_IRQS
, irq_set
)) {
2375 error_report("vfio: Failed to de-assign device request fd: %m");
2378 qemu_set_fd_handler(event_notifier_get_fd(&vdev
->req_notifier
),
2380 event_notifier_cleanup(&vdev
->req_notifier
);
2382 vdev
->req_enabled
= false;
2385 static int vfio_initfn(PCIDevice
*pdev
)
2387 VFIOPCIDevice
*vdev
= DO_UPCAST(VFIOPCIDevice
, pdev
, pdev
);
2388 VFIODevice
*vbasedev_iter
;
2390 char *tmp
, group_path
[PATH_MAX
], *group_name
;
2396 if (!vdev
->vbasedev
.sysfsdev
) {
2397 vdev
->vbasedev
.sysfsdev
=
2398 g_strdup_printf("/sys/bus/pci/devices/%04x:%02x:%02x.%01x",
2399 vdev
->host
.domain
, vdev
->host
.bus
,
2400 vdev
->host
.slot
, vdev
->host
.function
);
2403 if (stat(vdev
->vbasedev
.sysfsdev
, &st
) < 0) {
2404 error_report("vfio: error: no such host device: %s",
2405 vdev
->vbasedev
.sysfsdev
);
2409 vdev
->vbasedev
.name
= g_strdup(basename(vdev
->vbasedev
.sysfsdev
));
2410 vdev
->vbasedev
.ops
= &vfio_pci_ops
;
2411 vdev
->vbasedev
.type
= VFIO_DEVICE_TYPE_PCI
;
2413 tmp
= g_strdup_printf("%s/iommu_group", vdev
->vbasedev
.sysfsdev
);
2414 len
= readlink(tmp
, group_path
, sizeof(group_path
));
2417 if (len
<= 0 || len
>= sizeof(group_path
)) {
2418 error_report("vfio: error no iommu_group for device");
2419 return len
< 0 ? -errno
: -ENAMETOOLONG
;
2422 group_path
[len
] = 0;
2424 group_name
= basename(group_path
);
2425 if (sscanf(group_name
, "%d", &groupid
) != 1) {
2426 error_report("vfio: error reading %s: %m", group_path
);
2430 trace_vfio_initfn(vdev
->vbasedev
.name
, groupid
);
2432 group
= vfio_get_group(groupid
, pci_device_iommu_address_space(pdev
));
2434 error_report("vfio: failed to get group %d", groupid
);
2438 QLIST_FOREACH(vbasedev_iter
, &group
->device_list
, next
) {
2439 if (strcmp(vbasedev_iter
->name
, vdev
->vbasedev
.name
) == 0) {
2440 error_report("vfio: error: device %s is already attached",
2441 vdev
->vbasedev
.name
);
2442 vfio_put_group(group
);
2447 ret
= vfio_get_device(group
, vdev
->vbasedev
.name
, &vdev
->vbasedev
);
2449 error_report("vfio: failed to get device %s", vdev
->vbasedev
.name
);
2450 vfio_put_group(group
);
2454 ret
= vfio_populate_device(vdev
);
2459 /* Get a copy of config space */
2460 ret
= pread(vdev
->vbasedev
.fd
, vdev
->pdev
.config
,
2461 MIN(pci_config_size(&vdev
->pdev
), vdev
->config_size
),
2462 vdev
->config_offset
);
2463 if (ret
< (int)MIN(pci_config_size(&vdev
->pdev
), vdev
->config_size
)) {
2464 ret
= ret
< 0 ? -errno
: -EFAULT
;
2465 error_report("vfio: Failed to read device config space");
2469 /* vfio emulates a lot for us, but some bits need extra love */
2470 vdev
->emulated_config_bits
= g_malloc0(vdev
->config_size
);
2472 /* QEMU can choose to expose the ROM or not */
2473 memset(vdev
->emulated_config_bits
+ PCI_ROM_ADDRESS
, 0xff, 4);
2476 * The PCI spec reserves vendor ID 0xffff as an invalid value. The
2477 * device ID is managed by the vendor and need only be a 16-bit value.
2478 * Allow any 16-bit value for subsystem so they can be hidden or changed.
2480 if (vdev
->vendor_id
!= PCI_ANY_ID
) {
2481 if (vdev
->vendor_id
>= 0xffff) {
2482 error_report("vfio: Invalid PCI vendor ID provided");
2485 vfio_add_emulated_word(vdev
, PCI_VENDOR_ID
, vdev
->vendor_id
, ~0);
2486 trace_vfio_pci_emulated_vendor_id(vdev
->vbasedev
.name
, vdev
->vendor_id
);
2488 vdev
->vendor_id
= pci_get_word(pdev
->config
+ PCI_VENDOR_ID
);
2491 if (vdev
->device_id
!= PCI_ANY_ID
) {
2492 if (vdev
->device_id
> 0xffff) {
2493 error_report("vfio: Invalid PCI device ID provided");
2496 vfio_add_emulated_word(vdev
, PCI_DEVICE_ID
, vdev
->device_id
, ~0);
2497 trace_vfio_pci_emulated_device_id(vdev
->vbasedev
.name
, vdev
->device_id
);
2499 vdev
->device_id
= pci_get_word(pdev
->config
+ PCI_DEVICE_ID
);
2502 if (vdev
->sub_vendor_id
!= PCI_ANY_ID
) {
2503 if (vdev
->sub_vendor_id
> 0xffff) {
2504 error_report("vfio: Invalid PCI subsystem vendor ID provided");
2507 vfio_add_emulated_word(vdev
, PCI_SUBSYSTEM_VENDOR_ID
,
2508 vdev
->sub_vendor_id
, ~0);
2509 trace_vfio_pci_emulated_sub_vendor_id(vdev
->vbasedev
.name
,
2510 vdev
->sub_vendor_id
);
2513 if (vdev
->sub_device_id
!= PCI_ANY_ID
) {
2514 if (vdev
->sub_device_id
> 0xffff) {
2515 error_report("vfio: Invalid PCI subsystem device ID provided");
2518 vfio_add_emulated_word(vdev
, PCI_SUBSYSTEM_ID
, vdev
->sub_device_id
, ~0);
2519 trace_vfio_pci_emulated_sub_device_id(vdev
->vbasedev
.name
,
2520 vdev
->sub_device_id
);
2523 /* QEMU can change multi-function devices to single function, or reverse */
2524 vdev
->emulated_config_bits
[PCI_HEADER_TYPE
] =
2525 PCI_HEADER_TYPE_MULTI_FUNCTION
;
2527 /* Restore or clear multifunction, this is always controlled by QEMU */
2528 if (vdev
->pdev
.cap_present
& QEMU_PCI_CAP_MULTIFUNCTION
) {
2529 vdev
->pdev
.config
[PCI_HEADER_TYPE
] |= PCI_HEADER_TYPE_MULTI_FUNCTION
;
2531 vdev
->pdev
.config
[PCI_HEADER_TYPE
] &= ~PCI_HEADER_TYPE_MULTI_FUNCTION
;
2535 * Clear host resource mapping info. If we choose not to register a
2536 * BAR, such as might be the case with the option ROM, we can get
2537 * confusing, unwritable, residual addresses from the host here.
2539 memset(&vdev
->pdev
.config
[PCI_BASE_ADDRESS_0
], 0, 24);
2540 memset(&vdev
->pdev
.config
[PCI_ROM_ADDRESS
], 0, 4);
2542 vfio_pci_size_rom(vdev
);
2544 ret
= vfio_msix_early_setup(vdev
);
2549 vfio_bars_setup(vdev
);
2551 ret
= vfio_add_capabilities(vdev
);
2557 vfio_vga_quirk_setup(vdev
);
2560 for (i
= 0; i
< PCI_ROM_SLOT
; i
++) {
2561 vfio_bar_quirk_setup(vdev
, i
);
2564 if (!vdev
->igd_opregion
&&
2565 vdev
->features
& VFIO_FEATURE_ENABLE_IGD_OPREGION
) {
2566 struct vfio_region_info
*opregion
;
2568 if (vdev
->pdev
.qdev
.hotplugged
) {
2569 error_report("Cannot support IGD OpRegion feature on hotplugged "
2570 "device %s", vdev
->vbasedev
.name
);
2575 ret
= vfio_get_dev_region_info(&vdev
->vbasedev
,
2576 VFIO_REGION_TYPE_PCI_VENDOR_TYPE
| PCI_VENDOR_ID_INTEL
,
2577 VFIO_REGION_SUBTYPE_INTEL_IGD_OPREGION
, &opregion
);
2579 error_report("Device %s does not support requested IGD OpRegion "
2580 "feature", vdev
->vbasedev
.name
);
2584 ret
= vfio_pci_igd_opregion_init(vdev
, opregion
);
2587 error_report("Device %s IGD OpRegion initialization failed",
2588 vdev
->vbasedev
.name
);
2593 /* QEMU emulates all of MSI & MSIX */
2594 if (pdev
->cap_present
& QEMU_PCI_CAP_MSIX
) {
2595 memset(vdev
->emulated_config_bits
+ pdev
->msix_cap
, 0xff,
2599 if (pdev
->cap_present
& QEMU_PCI_CAP_MSI
) {
2600 memset(vdev
->emulated_config_bits
+ pdev
->msi_cap
, 0xff,
2601 vdev
->msi_cap_size
);
2604 if (vfio_pci_read_config(&vdev
->pdev
, PCI_INTERRUPT_PIN
, 1)) {
2605 vdev
->intx
.mmap_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
,
2606 vfio_intx_mmap_enable
, vdev
);
2607 pci_device_set_intx_routing_notifier(&vdev
->pdev
, vfio_intx_update
);
2608 ret
= vfio_intx_enable(vdev
);
2614 vfio_register_err_notifier(vdev
);
2615 vfio_register_req_notifier(vdev
);
2616 vfio_setup_resetfn_quirk(vdev
);
2621 pci_device_set_intx_routing_notifier(&vdev
->pdev
, NULL
);
2622 vfio_teardown_msi(vdev
);
2623 vfio_bars_exit(vdev
);
2627 static void vfio_instance_finalize(Object
*obj
)
2629 PCIDevice
*pci_dev
= PCI_DEVICE(obj
);
2630 VFIOPCIDevice
*vdev
= DO_UPCAST(VFIOPCIDevice
, pdev
, pci_dev
);
2631 VFIOGroup
*group
= vdev
->vbasedev
.group
;
2633 vfio_bars_finalize(vdev
);
2634 g_free(vdev
->emulated_config_bits
);
2637 * XXX Leaking igd_opregion is not an oversight, we can't remove the
2638 * fw_cfg entry therefore leaking this allocation seems like the safest
2641 * g_free(vdev->igd_opregion);
2643 vfio_put_device(vdev
);
2644 vfio_put_group(group
);
2647 static void vfio_exitfn(PCIDevice
*pdev
)
2649 VFIOPCIDevice
*vdev
= DO_UPCAST(VFIOPCIDevice
, pdev
, pdev
);
2651 vfio_unregister_req_notifier(vdev
);
2652 vfio_unregister_err_notifier(vdev
);
2653 pci_device_set_intx_routing_notifier(&vdev
->pdev
, NULL
);
2654 vfio_disable_interrupts(vdev
);
2655 if (vdev
->intx
.mmap_timer
) {
2656 timer_free(vdev
->intx
.mmap_timer
);
2658 vfio_teardown_msi(vdev
);
2659 vfio_bars_exit(vdev
);
2662 static void vfio_pci_reset(DeviceState
*dev
)
2664 PCIDevice
*pdev
= DO_UPCAST(PCIDevice
, qdev
, dev
);
2665 VFIOPCIDevice
*vdev
= DO_UPCAST(VFIOPCIDevice
, pdev
, pdev
);
2667 trace_vfio_pci_reset(vdev
->vbasedev
.name
);
2669 vfio_pci_pre_reset(vdev
);
2671 if (vdev
->resetfn
&& !vdev
->resetfn(vdev
)) {
2675 if (vdev
->vbasedev
.reset_works
&&
2676 (vdev
->has_flr
|| !vdev
->has_pm_reset
) &&
2677 !ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_RESET
)) {
2678 trace_vfio_pci_reset_flr(vdev
->vbasedev
.name
);
2682 /* See if we can do our own bus reset */
2683 if (!vfio_pci_hot_reset_one(vdev
)) {
2687 /* If nothing else works and the device supports PM reset, use it */
2688 if (vdev
->vbasedev
.reset_works
&& vdev
->has_pm_reset
&&
2689 !ioctl(vdev
->vbasedev
.fd
, VFIO_DEVICE_RESET
)) {
2690 trace_vfio_pci_reset_pm(vdev
->vbasedev
.name
);
2695 vfio_pci_post_reset(vdev
);
2698 static void vfio_instance_init(Object
*obj
)
2700 PCIDevice
*pci_dev
= PCI_DEVICE(obj
);
2701 VFIOPCIDevice
*vdev
= DO_UPCAST(VFIOPCIDevice
, pdev
, PCI_DEVICE(obj
));
2703 device_add_bootindex_property(obj
, &vdev
->bootindex
,
2705 &pci_dev
->qdev
, NULL
);
2708 static Property vfio_pci_dev_properties
[] = {
2709 DEFINE_PROP_PCI_HOST_DEVADDR("host", VFIOPCIDevice
, host
),
2710 DEFINE_PROP_STRING("sysfsdev", VFIOPCIDevice
, vbasedev
.sysfsdev
),
2711 DEFINE_PROP_UINT32("x-intx-mmap-timeout-ms", VFIOPCIDevice
,
2712 intx
.mmap_timeout
, 1100),
2713 DEFINE_PROP_BIT("x-vga", VFIOPCIDevice
, features
,
2714 VFIO_FEATURE_ENABLE_VGA_BIT
, false),
2715 DEFINE_PROP_BIT("x-req", VFIOPCIDevice
, features
,
2716 VFIO_FEATURE_ENABLE_REQ_BIT
, true),
2717 DEFINE_PROP_BIT("x-igd-opregion", VFIOPCIDevice
, features
,
2718 VFIO_FEATURE_ENABLE_IGD_OPREGION_BIT
, false),
2719 DEFINE_PROP_BOOL("x-no-mmap", VFIOPCIDevice
, vbasedev
.no_mmap
, false),
2720 DEFINE_PROP_BOOL("x-no-kvm-intx", VFIOPCIDevice
, no_kvm_intx
, false),
2721 DEFINE_PROP_BOOL("x-no-kvm-msi", VFIOPCIDevice
, no_kvm_msi
, false),
2722 DEFINE_PROP_BOOL("x-no-kvm-msix", VFIOPCIDevice
, no_kvm_msix
, false),
2723 DEFINE_PROP_UINT32("x-pci-vendor-id", VFIOPCIDevice
, vendor_id
, PCI_ANY_ID
),
2724 DEFINE_PROP_UINT32("x-pci-device-id", VFIOPCIDevice
, device_id
, PCI_ANY_ID
),
2725 DEFINE_PROP_UINT32("x-pci-sub-vendor-id", VFIOPCIDevice
,
2726 sub_vendor_id
, PCI_ANY_ID
),
2727 DEFINE_PROP_UINT32("x-pci-sub-device-id", VFIOPCIDevice
,
2728 sub_device_id
, PCI_ANY_ID
),
2729 DEFINE_PROP_UINT32("x-igd-gms", VFIOPCIDevice
, igd_gms
, 0),
2731 * TODO - support passed fds... is this necessary?
2732 * DEFINE_PROP_STRING("vfiofd", VFIOPCIDevice, vfiofd_name),
2733 * DEFINE_PROP_STRING("vfiogroupfd, VFIOPCIDevice, vfiogroupfd_name),
2735 DEFINE_PROP_END_OF_LIST(),
2738 static const VMStateDescription vfio_pci_vmstate
= {
2743 static void vfio_pci_dev_class_init(ObjectClass
*klass
, void *data
)
2745 DeviceClass
*dc
= DEVICE_CLASS(klass
);
2746 PCIDeviceClass
*pdc
= PCI_DEVICE_CLASS(klass
);
2748 dc
->reset
= vfio_pci_reset
;
2749 dc
->props
= vfio_pci_dev_properties
;
2750 dc
->vmsd
= &vfio_pci_vmstate
;
2751 dc
->desc
= "VFIO-based PCI device assignment";
2752 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
2753 pdc
->init
= vfio_initfn
;
2754 pdc
->exit
= vfio_exitfn
;
2755 pdc
->config_read
= vfio_pci_read_config
;
2756 pdc
->config_write
= vfio_pci_write_config
;
2757 pdc
->is_express
= 1; /* We might be */
2760 static const TypeInfo vfio_pci_dev_info
= {
2762 .parent
= TYPE_PCI_DEVICE
,
2763 .instance_size
= sizeof(VFIOPCIDevice
),
2764 .class_init
= vfio_pci_dev_class_init
,
2765 .instance_init
= vfio_instance_init
,
2766 .instance_finalize
= vfio_instance_finalize
,
2769 static void register_vfio_pci_dev_type(void)
2771 type_register_static(&vfio_pci_dev_info
);
2774 type_init(register_vfio_pci_dev_type
)