2 * vfio based device assignment support - platform devices
4 * Copyright Linaro Limited, 2014
7 * Kim Phillips <kim.phillips@linaro.org>
8 * Eric Auger <eric.auger@linaro.org>
10 * This work is licensed under the terms of the GNU GPL, version 2. See
11 * the COPYING file in the top-level directory.
13 * Based on vfio based PCI device assignment support:
14 * Copyright Red Hat, Inc. 2012
17 #include "qemu/osdep.h"
18 #include "qapi/error.h"
19 #include <sys/ioctl.h>
20 #include <linux/vfio.h>
22 #include "hw/vfio/vfio-platform.h"
23 #include "qemu/error-report.h"
24 #include "qemu/range.h"
25 #include "sysemu/sysemu.h"
26 #include "exec/memory.h"
27 #include "qemu/queue.h"
28 #include "hw/sysbus.h"
30 #include "hw/platform-bus.h"
31 #include "sysemu/kvm.h"
34 * Functions used whatever the injection method
37 static inline bool vfio_irq_is_automasked(VFIOINTp
*intp
)
39 return intp
->flags
& VFIO_IRQ_INFO_AUTOMASKED
;
43 * vfio_init_intp - allocate, initialize the IRQ struct pointer
44 * and add it into the list of IRQs
45 * @vbasedev: the VFIO device handle
46 * @info: irq info struct retrieved from VFIO driver
49 static VFIOINTp
*vfio_init_intp(VFIODevice
*vbasedev
,
50 struct vfio_irq_info info
, Error
**errp
)
53 VFIOPlatformDevice
*vdev
=
54 container_of(vbasedev
, VFIOPlatformDevice
, vbasedev
);
55 SysBusDevice
*sbdev
= SYS_BUS_DEVICE(vdev
);
58 intp
= g_malloc0(sizeof(*intp
));
60 intp
->pin
= info
.index
;
61 intp
->flags
= info
.flags
;
62 intp
->state
= VFIO_IRQ_INACTIVE
;
63 intp
->kvm_accel
= false;
65 sysbus_init_irq(sbdev
, &intp
->qemuirq
);
67 /* Get an eventfd for trigger */
68 intp
->interrupt
= g_malloc0(sizeof(EventNotifier
));
69 ret
= event_notifier_init(intp
->interrupt
, 0);
71 g_free(intp
->interrupt
);
73 error_setg_errno(errp
, -ret
,
74 "failed to initialize trigger eventd notifier");
77 if (vfio_irq_is_automasked(intp
)) {
78 /* Get an eventfd for resample/unmask */
79 intp
->unmask
= g_malloc0(sizeof(EventNotifier
));
80 ret
= event_notifier_init(intp
->unmask
, 0);
82 g_free(intp
->interrupt
);
85 error_setg_errno(errp
, -ret
,
86 "failed to initialize resample eventd notifier");
91 QLIST_INSERT_HEAD(&vdev
->intp_list
, intp
, next
);
96 * vfio_set_trigger_eventfd - set VFIO eventfd handling
98 * @intp: IRQ struct handle
99 * @handler: handler to be called on eventfd signaling
101 * Setup VFIO signaling and attach an optional user-side handler
104 static int vfio_set_trigger_eventfd(VFIOINTp
*intp
,
105 eventfd_user_side_handler_t handler
)
107 VFIODevice
*vbasedev
= &intp
->vdev
->vbasedev
;
108 struct vfio_irq_set
*irq_set
;
112 argsz
= sizeof(*irq_set
) + sizeof(*pfd
);
113 irq_set
= g_malloc0(argsz
);
114 irq_set
->argsz
= argsz
;
115 irq_set
->flags
= VFIO_IRQ_SET_DATA_EVENTFD
| VFIO_IRQ_SET_ACTION_TRIGGER
;
116 irq_set
->index
= intp
->pin
;
119 pfd
= (int32_t *)&irq_set
->data
;
120 *pfd
= event_notifier_get_fd(intp
->interrupt
);
121 qemu_set_fd_handler(*pfd
, (IOHandler
*)handler
, NULL
, intp
);
122 ret
= ioctl(vbasedev
->fd
, VFIO_DEVICE_SET_IRQS
, irq_set
);
125 error_report("vfio: Failed to set trigger eventfd: %m");
126 qemu_set_fd_handler(*pfd
, NULL
, NULL
, NULL
);
132 * Functions only used when eventfds are handled on user-side
137 * vfio_mmap_set_enabled - enable/disable the fast path mode
138 * @vdev: the VFIO platform device
139 * @enabled: the target mmap state
141 * enabled = true ~ fast path = MMIO region is mmaped (no KVM TRAP);
142 * enabled = false ~ slow path = MMIO region is trapped and region callbacks
143 * are called; slow path enables to trap the device IRQ status register reset
146 static void vfio_mmap_set_enabled(VFIOPlatformDevice
*vdev
, bool enabled
)
150 for (i
= 0; i
< vdev
->vbasedev
.num_regions
; i
++) {
151 vfio_region_mmaps_set_enabled(vdev
->regions
[i
], enabled
);
156 * vfio_intp_mmap_enable - timer function, restores the fast path
157 * if there is no more active IRQ
158 * @opaque: actually points to the VFIO platform device
160 * Called on mmap timer timout, this function checks whether the
161 * IRQ is still active and if not, restores the fast path.
162 * by construction a single eventfd is handled at a time.
163 * if the IRQ is still active, the timer is re-programmed.
165 static void vfio_intp_mmap_enable(void *opaque
)
168 VFIOPlatformDevice
*vdev
= (VFIOPlatformDevice
*)opaque
;
170 qemu_mutex_lock(&vdev
->intp_mutex
);
171 QLIST_FOREACH(tmp
, &vdev
->intp_list
, next
) {
172 if (tmp
->state
== VFIO_IRQ_ACTIVE
) {
173 trace_vfio_platform_intp_mmap_enable(tmp
->pin
);
174 /* re-program the timer to check active status later */
175 timer_mod(vdev
->mmap_timer
,
176 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
178 qemu_mutex_unlock(&vdev
->intp_mutex
);
182 vfio_mmap_set_enabled(vdev
, true);
183 qemu_mutex_unlock(&vdev
->intp_mutex
);
187 * vfio_intp_inject_pending_lockheld - Injects a pending IRQ
188 * @opaque: opaque pointer, in practice the VFIOINTp handle
190 * The function is called on a previous IRQ completion, from
191 * vfio_platform_eoi, while the intp_mutex is locked.
192 * Also in such situation, the slow path already is set and
193 * the mmap timer was already programmed.
195 static void vfio_intp_inject_pending_lockheld(VFIOINTp
*intp
)
197 trace_vfio_platform_intp_inject_pending_lockheld(intp
->pin
,
198 event_notifier_get_fd(intp
->interrupt
));
200 intp
->state
= VFIO_IRQ_ACTIVE
;
202 /* trigger the virtual IRQ */
203 qemu_set_irq(intp
->qemuirq
, 1);
207 * vfio_intp_interrupt - The user-side eventfd handler
208 * @opaque: opaque pointer which in practice is the VFIOINTp handle
210 * the function is entered in event handler context:
211 * the vIRQ is injected into the guest if there is no other active
214 static void vfio_intp_interrupt(VFIOINTp
*intp
)
218 VFIOPlatformDevice
*vdev
= intp
->vdev
;
219 bool delay_handling
= false;
221 qemu_mutex_lock(&vdev
->intp_mutex
);
222 if (intp
->state
== VFIO_IRQ_INACTIVE
) {
223 QLIST_FOREACH(tmp
, &vdev
->intp_list
, next
) {
224 if (tmp
->state
== VFIO_IRQ_ACTIVE
||
225 tmp
->state
== VFIO_IRQ_PENDING
) {
226 delay_handling
= true;
231 if (delay_handling
) {
233 * the new IRQ gets a pending status and is pushed in
236 intp
->state
= VFIO_IRQ_PENDING
;
237 trace_vfio_intp_interrupt_set_pending(intp
->pin
);
238 QSIMPLEQ_INSERT_TAIL(&vdev
->pending_intp_queue
,
240 ret
= event_notifier_test_and_clear(intp
->interrupt
);
241 qemu_mutex_unlock(&vdev
->intp_mutex
);
245 trace_vfio_platform_intp_interrupt(intp
->pin
,
246 event_notifier_get_fd(intp
->interrupt
));
248 ret
= event_notifier_test_and_clear(intp
->interrupt
);
250 error_report("Error when clearing fd=%d (ret = %d)",
251 event_notifier_get_fd(intp
->interrupt
), ret
);
254 intp
->state
= VFIO_IRQ_ACTIVE
;
257 vfio_mmap_set_enabled(vdev
, false);
259 /* trigger the virtual IRQ */
260 qemu_set_irq(intp
->qemuirq
, 1);
263 * Schedule the mmap timer which will restore fastpath when no IRQ
266 if (vdev
->mmap_timeout
) {
267 timer_mod(vdev
->mmap_timer
,
268 qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL
) +
271 qemu_mutex_unlock(&vdev
->intp_mutex
);
275 * vfio_platform_eoi - IRQ completion routine
276 * @vbasedev: the VFIO device handle
278 * De-asserts the active virtual IRQ and unmasks the physical IRQ
279 * (effective for level sensitive IRQ auto-masked by the VFIO driver).
280 * Then it handles next pending IRQ if any.
281 * eoi function is called on the first access to any MMIO region
282 * after an IRQ was triggered, trapped since slow path was set.
283 * It is assumed this access corresponds to the IRQ status
284 * register reset. With such a mechanism, a single IRQ can be
285 * handled at a time since there is no way to know which IRQ
286 * was completed by the guest (we would need additional details
287 * about the IRQ status register mask).
289 static void vfio_platform_eoi(VFIODevice
*vbasedev
)
292 VFIOPlatformDevice
*vdev
=
293 container_of(vbasedev
, VFIOPlatformDevice
, vbasedev
);
295 qemu_mutex_lock(&vdev
->intp_mutex
);
296 QLIST_FOREACH(intp
, &vdev
->intp_list
, next
) {
297 if (intp
->state
== VFIO_IRQ_ACTIVE
) {
298 trace_vfio_platform_eoi(intp
->pin
,
299 event_notifier_get_fd(intp
->interrupt
));
300 intp
->state
= VFIO_IRQ_INACTIVE
;
302 /* deassert the virtual IRQ */
303 qemu_set_irq(intp
->qemuirq
, 0);
305 if (vfio_irq_is_automasked(intp
)) {
306 /* unmasks the physical level-sensitive IRQ */
307 vfio_unmask_single_irqindex(vbasedev
, intp
->pin
);
310 /* a single IRQ can be active at a time */
314 /* in case there are pending IRQs, handle the first one */
315 if (!QSIMPLEQ_EMPTY(&vdev
->pending_intp_queue
)) {
316 intp
= QSIMPLEQ_FIRST(&vdev
->pending_intp_queue
);
317 vfio_intp_inject_pending_lockheld(intp
);
318 QSIMPLEQ_REMOVE_HEAD(&vdev
->pending_intp_queue
, pqnext
);
320 qemu_mutex_unlock(&vdev
->intp_mutex
);
324 * vfio_start_eventfd_injection - starts the virtual IRQ injection using
325 * user-side handled eventfds
326 * @sbdev: the sysbus device handle
327 * @irq: the qemu irq handle
330 static void vfio_start_eventfd_injection(SysBusDevice
*sbdev
, qemu_irq irq
)
333 VFIOPlatformDevice
*vdev
= VFIO_PLATFORM_DEVICE(sbdev
);
336 QLIST_FOREACH(intp
, &vdev
->intp_list
, next
) {
337 if (intp
->qemuirq
== irq
) {
343 ret
= vfio_set_trigger_eventfd(intp
, vfio_intp_interrupt
);
345 error_report("vfio: failed to start eventfd signaling for IRQ %d: %m",
352 * Functions used for irqfd
356 * vfio_set_resample_eventfd - sets the resamplefd for an IRQ
357 * @intp: the IRQ struct handle
358 * programs the VFIO driver to unmask this IRQ when the
359 * intp->unmask eventfd is triggered
361 static int vfio_set_resample_eventfd(VFIOINTp
*intp
)
363 VFIODevice
*vbasedev
= &intp
->vdev
->vbasedev
;
364 struct vfio_irq_set
*irq_set
;
368 argsz
= sizeof(*irq_set
) + sizeof(*pfd
);
369 irq_set
= g_malloc0(argsz
);
370 irq_set
->argsz
= argsz
;
371 irq_set
->flags
= VFIO_IRQ_SET_DATA_EVENTFD
| VFIO_IRQ_SET_ACTION_UNMASK
;
372 irq_set
->index
= intp
->pin
;
375 pfd
= (int32_t *)&irq_set
->data
;
376 *pfd
= event_notifier_get_fd(intp
->unmask
);
377 qemu_set_fd_handler(*pfd
, NULL
, NULL
, NULL
);
378 ret
= ioctl(vbasedev
->fd
, VFIO_DEVICE_SET_IRQS
, irq_set
);
381 error_report("vfio: Failed to set resample eventfd: %m");
387 * vfio_start_irqfd_injection - starts the virtual IRQ injection using
390 * @sbdev: the sysbus device handle
391 * @irq: the qemu irq handle
393 * In case the irqfd setup fails, we fallback to userspace handled eventfd
395 static void vfio_start_irqfd_injection(SysBusDevice
*sbdev
, qemu_irq irq
)
397 VFIOPlatformDevice
*vdev
= VFIO_PLATFORM_DEVICE(sbdev
);
400 if (!kvm_irqfds_enabled() || !kvm_resamplefds_enabled() ||
401 !vdev
->irqfd_allowed
) {
405 QLIST_FOREACH(intp
, &vdev
->intp_list
, next
) {
406 if (intp
->qemuirq
== irq
) {
412 if (kvm_irqchip_add_irqfd_notifier(kvm_state
, intp
->interrupt
,
413 intp
->unmask
, irq
) < 0) {
417 if (vfio_set_trigger_eventfd(intp
, NULL
) < 0) {
420 if (vfio_irq_is_automasked(intp
)) {
421 if (vfio_set_resample_eventfd(intp
) < 0) {
424 trace_vfio_platform_start_level_irqfd_injection(intp
->pin
,
425 event_notifier_get_fd(intp
->interrupt
),
426 event_notifier_get_fd(intp
->unmask
));
428 trace_vfio_platform_start_edge_irqfd_injection(intp
->pin
,
429 event_notifier_get_fd(intp
->interrupt
));
432 intp
->kvm_accel
= true;
436 kvm_irqchip_remove_irqfd_notifier(kvm_state
, intp
->interrupt
, irq
);
437 error_report("vfio: failed to start eventfd signaling for IRQ %d: %m",
441 vfio_start_eventfd_injection(sbdev
, irq
);
447 static void vfio_platform_compute_needs_reset(VFIODevice
*vbasedev
)
449 vbasedev
->needs_reset
= true;
452 /* not implemented yet */
453 static int vfio_platform_hot_reset_multi(VFIODevice
*vbasedev
)
459 * vfio_populate_device - Allocate and populate MMIO region
460 * and IRQ structs according to driver returned information
461 * @vbasedev: the VFIO device handle
462 * @errp: error object
465 static int vfio_populate_device(VFIODevice
*vbasedev
, Error
**errp
)
467 VFIOINTp
*intp
, *tmp
;
469 VFIOPlatformDevice
*vdev
=
470 container_of(vbasedev
, VFIOPlatformDevice
, vbasedev
);
472 if (!(vbasedev
->flags
& VFIO_DEVICE_FLAGS_PLATFORM
)) {
473 error_setg(errp
, "this isn't a platform device");
477 vdev
->regions
= g_new0(VFIORegion
*, vbasedev
->num_regions
);
479 for (i
= 0; i
< vbasedev
->num_regions
; i
++) {
480 char *name
= g_strdup_printf("VFIO %s region %d\n", vbasedev
->name
, i
);
482 vdev
->regions
[i
] = g_new0(VFIORegion
, 1);
483 ret
= vfio_region_setup(OBJECT(vdev
), vbasedev
,
484 vdev
->regions
[i
], i
, name
);
487 error_setg_errno(errp
, -ret
, "failed to get region %d info", i
);
492 vdev
->mmap_timer
= timer_new_ms(QEMU_CLOCK_VIRTUAL
,
493 vfio_intp_mmap_enable
, vdev
);
495 QSIMPLEQ_INIT(&vdev
->pending_intp_queue
);
497 for (i
= 0; i
< vbasedev
->num_irqs
; i
++) {
498 struct vfio_irq_info irq
= { .argsz
= sizeof(irq
) };
501 ret
= ioctl(vbasedev
->fd
, VFIO_DEVICE_GET_IRQ_INFO
, &irq
);
503 error_setg_errno(errp
, -ret
, "failed to get device irq info");
506 trace_vfio_platform_populate_interrupts(irq
.index
,
509 intp
= vfio_init_intp(vbasedev
, irq
, errp
);
518 timer_del(vdev
->mmap_timer
);
519 QLIST_FOREACH_SAFE(intp
, &vdev
->intp_list
, next
, tmp
) {
520 QLIST_REMOVE(intp
, next
);
524 for (i
= 0; i
< vbasedev
->num_regions
; i
++) {
525 if (vdev
->regions
[i
]) {
526 vfio_region_finalize(vdev
->regions
[i
]);
528 g_free(vdev
->regions
[i
]);
530 g_free(vdev
->regions
);
534 /* specialized functions for VFIO Platform devices */
535 static VFIODeviceOps vfio_platform_ops
= {
536 .vfio_compute_needs_reset
= vfio_platform_compute_needs_reset
,
537 .vfio_hot_reset_multi
= vfio_platform_hot_reset_multi
,
538 .vfio_eoi
= vfio_platform_eoi
,
542 * vfio_base_device_init - perform preliminary VFIO setup
543 * @vbasedev: the VFIO device handle
545 * Implement the VFIO command sequence that allows to discover
546 * assigned device resources: group extraction, device
547 * fd retrieval, resource query.
548 * Precondition: the device name must be initialized
550 static int vfio_base_device_init(VFIODevice
*vbasedev
)
553 VFIODevice
*vbasedev_iter
;
554 char *tmp
, group_path
[PATH_MAX
], *group_name
;
561 /* @sysfsdev takes precedence over @host */
562 if (vbasedev
->sysfsdev
) {
563 g_free(vbasedev
->name
);
564 vbasedev
->name
= g_strdup(basename(vbasedev
->sysfsdev
));
566 if (!vbasedev
->name
|| strchr(vbasedev
->name
, '/')) {
570 vbasedev
->sysfsdev
= g_strdup_printf("/sys/bus/platform/devices/%s",
574 if (stat(vbasedev
->sysfsdev
, &st
) < 0) {
575 error_report("vfio: error: no such host device: %s",
580 tmp
= g_strdup_printf("%s/iommu_group", vbasedev
->sysfsdev
);
581 len
= readlink(tmp
, group_path
, sizeof(group_path
));
584 if (len
< 0 || len
>= sizeof(group_path
)) {
585 error_report("vfio: error no iommu_group for device");
586 return len
< 0 ? -errno
: -ENAMETOOLONG
;
591 group_name
= basename(group_path
);
592 if (sscanf(group_name
, "%d", &groupid
) != 1) {
593 error_report("vfio: error reading %s: %m", group_path
);
597 trace_vfio_platform_base_device_init(vbasedev
->name
, groupid
);
599 group
= vfio_get_group(groupid
, &address_space_memory
, &err
);
605 QLIST_FOREACH(vbasedev_iter
, &group
->device_list
, next
) {
606 if (strcmp(vbasedev_iter
->name
, vbasedev
->name
) == 0) {
607 error_report("vfio: error: device %s is already attached",
609 vfio_put_group(group
);
613 ret
= vfio_get_device(group
, vbasedev
->name
, vbasedev
, &err
);
615 vfio_put_group(group
);
619 ret
= vfio_populate_device(vbasedev
, &err
);
621 vfio_put_group(group
);
626 error_reportf_err(err
, ERR_PREFIX
, vbasedev
->name
);
632 * vfio_platform_realize - the device realize function
633 * @dev: device state pointer
636 * initialize the device, its memory regions and IRQ structures
637 * IRQ are started separately
639 static void vfio_platform_realize(DeviceState
*dev
, Error
**errp
)
641 VFIOPlatformDevice
*vdev
= VFIO_PLATFORM_DEVICE(dev
);
642 SysBusDevice
*sbdev
= SYS_BUS_DEVICE(dev
);
643 VFIODevice
*vbasedev
= &vdev
->vbasedev
;
646 vbasedev
->type
= VFIO_DEVICE_TYPE_PLATFORM
;
647 vbasedev
->ops
= &vfio_platform_ops
;
649 trace_vfio_platform_realize(vbasedev
->sysfsdev
?
650 vbasedev
->sysfsdev
: vbasedev
->name
,
653 ret
= vfio_base_device_init(vbasedev
);
655 error_setg(errp
, "vfio: vfio_base_device_init failed for %s",
660 for (i
= 0; i
< vbasedev
->num_regions
; i
++) {
661 if (vfio_region_mmap(vdev
->regions
[i
])) {
662 error_report("%s mmap unsupported. Performance may be slow",
663 memory_region_name(vdev
->regions
[i
]->mem
));
665 sysbus_init_mmio(sbdev
, vdev
->regions
[i
]->mem
);
669 static const VMStateDescription vfio_platform_vmstate
= {
670 .name
= TYPE_VFIO_PLATFORM
,
674 static Property vfio_platform_dev_properties
[] = {
675 DEFINE_PROP_STRING("host", VFIOPlatformDevice
, vbasedev
.name
),
676 DEFINE_PROP_STRING("sysfsdev", VFIOPlatformDevice
, vbasedev
.sysfsdev
),
677 DEFINE_PROP_BOOL("x-no-mmap", VFIOPlatformDevice
, vbasedev
.no_mmap
, false),
678 DEFINE_PROP_UINT32("mmap-timeout-ms", VFIOPlatformDevice
,
680 DEFINE_PROP_BOOL("x-irqfd", VFIOPlatformDevice
, irqfd_allowed
, true),
681 DEFINE_PROP_END_OF_LIST(),
684 static void vfio_platform_class_init(ObjectClass
*klass
, void *data
)
686 DeviceClass
*dc
= DEVICE_CLASS(klass
);
687 SysBusDeviceClass
*sbc
= SYS_BUS_DEVICE_CLASS(klass
);
689 dc
->realize
= vfio_platform_realize
;
690 dc
->props
= vfio_platform_dev_properties
;
691 dc
->vmsd
= &vfio_platform_vmstate
;
692 dc
->desc
= "VFIO-based platform device assignment";
693 sbc
->connect_irq_notifier
= vfio_start_irqfd_injection
;
694 set_bit(DEVICE_CATEGORY_MISC
, dc
->categories
);
697 static const TypeInfo vfio_platform_dev_info
= {
698 .name
= TYPE_VFIO_PLATFORM
,
699 .parent
= TYPE_SYS_BUS_DEVICE
,
700 .instance_size
= sizeof(VFIOPlatformDevice
),
701 .class_init
= vfio_platform_class_init
,
702 .class_size
= sizeof(VFIOPlatformDeviceClass
),
706 static void register_vfio_platform_dev_type(void)
708 type_register_static(&vfio_platform_dev_info
);
711 type_init(register_vfio_platform_dev_type
)