]>
Commit | Line | Data |
---|---|---|
0ea2730b EA |
1 | /* |
2 | * vfio based device assignment support - platform devices | |
3 | * | |
4 | * Copyright Linaro Limited, 2014 | |
5 | * | |
6 | * Authors: | |
7 | * Kim Phillips <kim.phillips@linaro.org> | |
8 | * Eric Auger <eric.auger@linaro.org> | |
9 | * | |
10 | * This work is licensed under the terms of the GNU GPL, version 2. See | |
11 | * the COPYING file in the top-level directory. | |
12 | * | |
13 | * Based on vfio based PCI device assignment support: | |
14 | * Copyright Red Hat, Inc. 2012 | |
15 | */ | |
16 | ||
c6eacb1a | 17 | #include "qemu/osdep.h" |
da34e65c | 18 | #include "qapi/error.h" |
0ea2730b | 19 | #include <sys/ioctl.h> |
e2075277 | 20 | #include <linux/vfio.h> |
0ea2730b EA |
21 | |
22 | #include "hw/vfio/vfio-platform.h" | |
d6454270 | 23 | #include "migration/vmstate.h" |
0ea2730b | 24 | #include "qemu/error-report.h" |
6e8a355d | 25 | #include "qemu/lockable.h" |
db725815 | 26 | #include "qemu/main-loop.h" |
0b8fa32f | 27 | #include "qemu/module.h" |
0ea2730b | 28 | #include "qemu/range.h" |
0ea2730b | 29 | #include "exec/memory.h" |
d791937f | 30 | #include "exec/address-spaces.h" |
38559979 | 31 | #include "qemu/queue.h" |
0ea2730b EA |
32 | #include "hw/sysbus.h" |
33 | #include "trace.h" | |
64552b6b | 34 | #include "hw/irq.h" |
0ea2730b | 35 | #include "hw/platform-bus.h" |
a27bd6c7 | 36 | #include "hw/qdev-properties.h" |
fb5f8164 | 37 | #include "sysemu/kvm.h" |
0ea2730b | 38 | |
38559979 EA |
39 | /* |
40 | * Functions used whatever the injection method | |
41 | */ | |
42 | ||
a5b39cd3 EA |
43 | static inline bool vfio_irq_is_automasked(VFIOINTp *intp) |
44 | { | |
45 | return intp->flags & VFIO_IRQ_INFO_AUTOMASKED; | |
46 | } | |
47 | ||
38559979 EA |
48 | /** |
49 | * vfio_init_intp - allocate, initialize the IRQ struct pointer | |
50 | * and add it into the list of IRQs | |
51 | * @vbasedev: the VFIO device handle | |
52 | * @info: irq info struct retrieved from VFIO driver | |
5ff7419d | 53 | * @errp: error object |
38559979 EA |
54 | */ |
55 | static VFIOINTp *vfio_init_intp(VFIODevice *vbasedev, | |
5ff7419d | 56 | struct vfio_irq_info info, Error **errp) |
38559979 EA |
57 | { |
58 | int ret; | |
59 | VFIOPlatformDevice *vdev = | |
60 | container_of(vbasedev, VFIOPlatformDevice, vbasedev); | |
61 | SysBusDevice *sbdev = SYS_BUS_DEVICE(vdev); | |
62 | VFIOINTp *intp; | |
63 | ||
64 | intp = g_malloc0(sizeof(*intp)); | |
65 | intp->vdev = vdev; | |
66 | intp->pin = info.index; | |
67 | intp->flags = info.flags; | |
68 | intp->state = VFIO_IRQ_INACTIVE; | |
fb5f8164 | 69 | intp->kvm_accel = false; |
38559979 EA |
70 | |
71 | sysbus_init_irq(sbdev, &intp->qemuirq); | |
72 | ||
73 | /* Get an eventfd for trigger */ | |
b21e2380 | 74 | intp->interrupt = g_new0(EventNotifier, 1); |
a22313de | 75 | ret = event_notifier_init(intp->interrupt, 0); |
38559979 | 76 | if (ret) { |
a22313de | 77 | g_free(intp->interrupt); |
38559979 | 78 | g_free(intp); |
5ff7419d | 79 | error_setg_errno(errp, -ret, |
bf04ef35 | 80 | "failed to initialize trigger eventfd notifier"); |
38559979 EA |
81 | return NULL; |
82 | } | |
a5b39cd3 EA |
83 | if (vfio_irq_is_automasked(intp)) { |
84 | /* Get an eventfd for resample/unmask */ | |
b21e2380 | 85 | intp->unmask = g_new0(EventNotifier, 1); |
a5b39cd3 EA |
86 | ret = event_notifier_init(intp->unmask, 0); |
87 | if (ret) { | |
88 | g_free(intp->interrupt); | |
89 | g_free(intp->unmask); | |
90 | g_free(intp); | |
5ff7419d | 91 | error_setg_errno(errp, -ret, |
bf04ef35 | 92 | "failed to initialize resample eventfd notifier"); |
a5b39cd3 EA |
93 | return NULL; |
94 | } | |
fb5f8164 | 95 | } |
38559979 EA |
96 | |
97 | QLIST_INSERT_HEAD(&vdev->intp_list, intp, next); | |
98 | return intp; | |
99 | } | |
100 | ||
101 | /** | |
102 | * vfio_set_trigger_eventfd - set VFIO eventfd handling | |
103 | * | |
104 | * @intp: IRQ struct handle | |
105 | * @handler: handler to be called on eventfd signaling | |
106 | * | |
107 | * Setup VFIO signaling and attach an optional user-side handler | |
108 | * to the eventfd | |
109 | */ | |
110 | static int vfio_set_trigger_eventfd(VFIOINTp *intp, | |
111 | eventfd_user_side_handler_t handler) | |
112 | { | |
113 | VFIODevice *vbasedev = &intp->vdev->vbasedev; | |
201a7331 EA |
114 | int32_t fd = event_notifier_get_fd(intp->interrupt); |
115 | Error *err = NULL; | |
116 | int ret; | |
117 | ||
118 | qemu_set_fd_handler(fd, (IOHandler *)handler, NULL, intp); | |
119 | ||
120 | ret = vfio_set_irq_signaling(vbasedev, intp->pin, 0, | |
121 | VFIO_IRQ_SET_ACTION_TRIGGER, fd, &err); | |
122 | if (ret) { | |
123 | error_reportf_err(err, VFIO_MSG_PREFIX, vbasedev->name); | |
124 | qemu_set_fd_handler(fd, NULL, NULL, NULL); | |
38559979 | 125 | } |
201a7331 | 126 | |
38559979 EA |
127 | return ret; |
128 | } | |
129 | ||
130 | /* | |
131 | * Functions only used when eventfds are handled on user-side | |
132 | * ie. without irqfd | |
133 | */ | |
134 | ||
135 | /** | |
136 | * vfio_mmap_set_enabled - enable/disable the fast path mode | |
137 | * @vdev: the VFIO platform device | |
138 | * @enabled: the target mmap state | |
139 | * | |
140 | * enabled = true ~ fast path = MMIO region is mmaped (no KVM TRAP); | |
141 | * enabled = false ~ slow path = MMIO region is trapped and region callbacks | |
142 | * are called; slow path enables to trap the device IRQ status register reset | |
143 | */ | |
144 | ||
145 | static void vfio_mmap_set_enabled(VFIOPlatformDevice *vdev, bool enabled) | |
146 | { | |
147 | int i; | |
148 | ||
38559979 | 149 | for (i = 0; i < vdev->vbasedev.num_regions; i++) { |
db0da029 | 150 | vfio_region_mmaps_set_enabled(vdev->regions[i], enabled); |
38559979 EA |
151 | } |
152 | } | |
153 | ||
154 | /** | |
155 | * vfio_intp_mmap_enable - timer function, restores the fast path | |
156 | * if there is no more active IRQ | |
157 | * @opaque: actually points to the VFIO platform device | |
158 | * | |
631ba5a1 | 159 | * Called on mmap timer timeout, this function checks whether the |
38559979 EA |
160 | * IRQ is still active and if not, restores the fast path. |
161 | * by construction a single eventfd is handled at a time. | |
162 | * if the IRQ is still active, the timer is re-programmed. | |
163 | */ | |
164 | static void vfio_intp_mmap_enable(void *opaque) | |
165 | { | |
166 | VFIOINTp *tmp; | |
167 | VFIOPlatformDevice *vdev = (VFIOPlatformDevice *)opaque; | |
168 | ||
88eef597 | 169 | QEMU_LOCK_GUARD(&vdev->intp_mutex); |
38559979 EA |
170 | QLIST_FOREACH(tmp, &vdev->intp_list, next) { |
171 | if (tmp->state == VFIO_IRQ_ACTIVE) { | |
172 | trace_vfio_platform_intp_mmap_enable(tmp->pin); | |
173 | /* re-program the timer to check active status later */ | |
174 | timer_mod(vdev->mmap_timer, | |
175 | qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + | |
176 | vdev->mmap_timeout); | |
38559979 EA |
177 | return; |
178 | } | |
179 | } | |
180 | vfio_mmap_set_enabled(vdev, true); | |
38559979 EA |
181 | } |
182 | ||
183 | /** | |
184 | * vfio_intp_inject_pending_lockheld - Injects a pending IRQ | |
185 | * @opaque: opaque pointer, in practice the VFIOINTp handle | |
186 | * | |
187 | * The function is called on a previous IRQ completion, from | |
188 | * vfio_platform_eoi, while the intp_mutex is locked. | |
189 | * Also in such situation, the slow path already is set and | |
190 | * the mmap timer was already programmed. | |
191 | */ | |
192 | static void vfio_intp_inject_pending_lockheld(VFIOINTp *intp) | |
193 | { | |
194 | trace_vfio_platform_intp_inject_pending_lockheld(intp->pin, | |
a22313de | 195 | event_notifier_get_fd(intp->interrupt)); |
38559979 EA |
196 | |
197 | intp->state = VFIO_IRQ_ACTIVE; | |
198 | ||
199 | /* trigger the virtual IRQ */ | |
200 | qemu_set_irq(intp->qemuirq, 1); | |
201 | } | |
202 | ||
203 | /** | |
204 | * vfio_intp_interrupt - The user-side eventfd handler | |
205 | * @opaque: opaque pointer which in practice is the VFIOINTp handle | |
206 | * | |
207 | * the function is entered in event handler context: | |
208 | * the vIRQ is injected into the guest if there is no other active | |
209 | * or pending IRQ. | |
210 | */ | |
211 | static void vfio_intp_interrupt(VFIOINTp *intp) | |
212 | { | |
213 | int ret; | |
214 | VFIOINTp *tmp; | |
215 | VFIOPlatformDevice *vdev = intp->vdev; | |
216 | bool delay_handling = false; | |
217 | ||
6e8a355d | 218 | QEMU_LOCK_GUARD(&vdev->intp_mutex); |
38559979 EA |
219 | if (intp->state == VFIO_IRQ_INACTIVE) { |
220 | QLIST_FOREACH(tmp, &vdev->intp_list, next) { | |
221 | if (tmp->state == VFIO_IRQ_ACTIVE || | |
222 | tmp->state == VFIO_IRQ_PENDING) { | |
223 | delay_handling = true; | |
224 | break; | |
225 | } | |
226 | } | |
227 | } | |
228 | if (delay_handling) { | |
229 | /* | |
230 | * the new IRQ gets a pending status and is pushed in | |
231 | * the pending queue | |
232 | */ | |
233 | intp->state = VFIO_IRQ_PENDING; | |
234 | trace_vfio_intp_interrupt_set_pending(intp->pin); | |
235 | QSIMPLEQ_INSERT_TAIL(&vdev->pending_intp_queue, | |
236 | intp, pqnext); | |
9b83b004 | 237 | event_notifier_test_and_clear(intp->interrupt); |
38559979 EA |
238 | return; |
239 | } | |
240 | ||
241 | trace_vfio_platform_intp_interrupt(intp->pin, | |
a22313de | 242 | event_notifier_get_fd(intp->interrupt)); |
38559979 | 243 | |
a22313de | 244 | ret = event_notifier_test_and_clear(intp->interrupt); |
38559979 | 245 | if (!ret) { |
594fd211 | 246 | error_report("Error when clearing fd=%d (ret = %d)", |
a22313de | 247 | event_notifier_get_fd(intp->interrupt), ret); |
38559979 EA |
248 | } |
249 | ||
250 | intp->state = VFIO_IRQ_ACTIVE; | |
251 | ||
252 | /* sets slow path */ | |
253 | vfio_mmap_set_enabled(vdev, false); | |
254 | ||
255 | /* trigger the virtual IRQ */ | |
256 | qemu_set_irq(intp->qemuirq, 1); | |
257 | ||
258 | /* | |
259 | * Schedule the mmap timer which will restore fastpath when no IRQ | |
260 | * is active anymore | |
261 | */ | |
262 | if (vdev->mmap_timeout) { | |
263 | timer_mod(vdev->mmap_timer, | |
264 | qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + | |
265 | vdev->mmap_timeout); | |
266 | } | |
38559979 EA |
267 | } |
268 | ||
269 | /** | |
270 | * vfio_platform_eoi - IRQ completion routine | |
271 | * @vbasedev: the VFIO device handle | |
272 | * | |
273 | * De-asserts the active virtual IRQ and unmasks the physical IRQ | |
274 | * (effective for level sensitive IRQ auto-masked by the VFIO driver). | |
275 | * Then it handles next pending IRQ if any. | |
276 | * eoi function is called on the first access to any MMIO region | |
277 | * after an IRQ was triggered, trapped since slow path was set. | |
278 | * It is assumed this access corresponds to the IRQ status | |
279 | * register reset. With such a mechanism, a single IRQ can be | |
280 | * handled at a time since there is no way to know which IRQ | |
281 | * was completed by the guest (we would need additional details | |
282 | * about the IRQ status register mask). | |
283 | */ | |
284 | static void vfio_platform_eoi(VFIODevice *vbasedev) | |
285 | { | |
286 | VFIOINTp *intp; | |
287 | VFIOPlatformDevice *vdev = | |
288 | container_of(vbasedev, VFIOPlatformDevice, vbasedev); | |
289 | ||
88eef597 | 290 | QEMU_LOCK_GUARD(&vdev->intp_mutex); |
38559979 EA |
291 | QLIST_FOREACH(intp, &vdev->intp_list, next) { |
292 | if (intp->state == VFIO_IRQ_ACTIVE) { | |
293 | trace_vfio_platform_eoi(intp->pin, | |
a22313de | 294 | event_notifier_get_fd(intp->interrupt)); |
38559979 EA |
295 | intp->state = VFIO_IRQ_INACTIVE; |
296 | ||
297 | /* deassert the virtual IRQ */ | |
298 | qemu_set_irq(intp->qemuirq, 0); | |
299 | ||
a5b39cd3 | 300 | if (vfio_irq_is_automasked(intp)) { |
38559979 EA |
301 | /* unmasks the physical level-sensitive IRQ */ |
302 | vfio_unmask_single_irqindex(vbasedev, intp->pin); | |
303 | } | |
304 | ||
305 | /* a single IRQ can be active at a time */ | |
306 | break; | |
307 | } | |
308 | } | |
309 | /* in case there are pending IRQs, handle the first one */ | |
310 | if (!QSIMPLEQ_EMPTY(&vdev->pending_intp_queue)) { | |
311 | intp = QSIMPLEQ_FIRST(&vdev->pending_intp_queue); | |
312 | vfio_intp_inject_pending_lockheld(intp); | |
313 | QSIMPLEQ_REMOVE_HEAD(&vdev->pending_intp_queue, pqnext); | |
314 | } | |
38559979 EA |
315 | } |
316 | ||
317 | /** | |
318 | * vfio_start_eventfd_injection - starts the virtual IRQ injection using | |
319 | * user-side handled eventfds | |
58892b44 EA |
320 | * @sbdev: the sysbus device handle |
321 | * @irq: the qemu irq handle | |
38559979 EA |
322 | */ |
323 | ||
58892b44 | 324 | static void vfio_start_eventfd_injection(SysBusDevice *sbdev, qemu_irq irq) |
38559979 | 325 | { |
58892b44 EA |
326 | VFIOPlatformDevice *vdev = VFIO_PLATFORM_DEVICE(sbdev); |
327 | VFIOINTp *intp; | |
328 | ||
329 | QLIST_FOREACH(intp, &vdev->intp_list, next) { | |
330 | if (intp->qemuirq == irq) { | |
331 | break; | |
332 | } | |
333 | } | |
334 | assert(intp); | |
38559979 | 335 | |
201a7331 | 336 | if (vfio_set_trigger_eventfd(intp, vfio_intp_interrupt)) { |
58892b44 | 337 | abort(); |
38559979 | 338 | } |
38559979 EA |
339 | } |
340 | ||
fb5f8164 EA |
341 | /* |
342 | * Functions used for irqfd | |
343 | */ | |
344 | ||
345 | /** | |
346 | * vfio_set_resample_eventfd - sets the resamplefd for an IRQ | |
347 | * @intp: the IRQ struct handle | |
348 | * programs the VFIO driver to unmask this IRQ when the | |
349 | * intp->unmask eventfd is triggered | |
350 | */ | |
351 | static int vfio_set_resample_eventfd(VFIOINTp *intp) | |
352 | { | |
201a7331 | 353 | int32_t fd = event_notifier_get_fd(intp->unmask); |
fb5f8164 | 354 | VFIODevice *vbasedev = &intp->vdev->vbasedev; |
201a7331 EA |
355 | Error *err = NULL; |
356 | int ret; | |
357 | ||
358 | qemu_set_fd_handler(fd, NULL, NULL, NULL); | |
359 | ret = vfio_set_irq_signaling(vbasedev, intp->pin, 0, | |
360 | VFIO_IRQ_SET_ACTION_UNMASK, fd, &err); | |
361 | if (ret) { | |
362 | error_reportf_err(err, VFIO_MSG_PREFIX, vbasedev->name); | |
fb5f8164 EA |
363 | } |
364 | return ret; | |
365 | } | |
366 | ||
58892b44 EA |
367 | /** |
368 | * vfio_start_irqfd_injection - starts the virtual IRQ injection using | |
369 | * irqfd | |
370 | * | |
371 | * @sbdev: the sysbus device handle | |
372 | * @irq: the qemu irq handle | |
373 | * | |
374 | * In case the irqfd setup fails, we fallback to userspace handled eventfd | |
375 | */ | |
fb5f8164 EA |
376 | static void vfio_start_irqfd_injection(SysBusDevice *sbdev, qemu_irq irq) |
377 | { | |
378 | VFIOPlatformDevice *vdev = VFIO_PLATFORM_DEVICE(sbdev); | |
379 | VFIOINTp *intp; | |
380 | ||
381 | if (!kvm_irqfds_enabled() || !kvm_resamplefds_enabled() || | |
382 | !vdev->irqfd_allowed) { | |
58892b44 | 383 | goto fail_irqfd; |
fb5f8164 EA |
384 | } |
385 | ||
386 | QLIST_FOREACH(intp, &vdev->intp_list, next) { | |
387 | if (intp->qemuirq == irq) { | |
388 | break; | |
389 | } | |
390 | } | |
391 | assert(intp); | |
392 | ||
a22313de EA |
393 | if (kvm_irqchip_add_irqfd_notifier(kvm_state, intp->interrupt, |
394 | intp->unmask, irq) < 0) { | |
fb5f8164 EA |
395 | goto fail_irqfd; |
396 | } | |
397 | ||
398 | if (vfio_set_trigger_eventfd(intp, NULL) < 0) { | |
399 | goto fail_vfio; | |
400 | } | |
a5b39cd3 EA |
401 | if (vfio_irq_is_automasked(intp)) { |
402 | if (vfio_set_resample_eventfd(intp) < 0) { | |
403 | goto fail_vfio; | |
404 | } | |
405 | trace_vfio_platform_start_level_irqfd_injection(intp->pin, | |
406 | event_notifier_get_fd(intp->interrupt), | |
407 | event_notifier_get_fd(intp->unmask)); | |
408 | } else { | |
409 | trace_vfio_platform_start_edge_irqfd_injection(intp->pin, | |
410 | event_notifier_get_fd(intp->interrupt)); | |
fb5f8164 EA |
411 | } |
412 | ||
fb5f8164 EA |
413 | intp->kvm_accel = true; |
414 | ||
fb5f8164 EA |
415 | return; |
416 | fail_vfio: | |
a22313de | 417 | kvm_irqchip_remove_irqfd_notifier(kvm_state, intp->interrupt, irq); |
58892b44 | 418 | abort(); |
fb5f8164 | 419 | fail_irqfd: |
58892b44 | 420 | vfio_start_eventfd_injection(sbdev, irq); |
fb5f8164 EA |
421 | return; |
422 | } | |
423 | ||
0ea2730b EA |
424 | /* VFIO skeleton */ |
425 | ||
426 | static void vfio_platform_compute_needs_reset(VFIODevice *vbasedev) | |
427 | { | |
428 | vbasedev->needs_reset = true; | |
429 | } | |
430 | ||
431 | /* not implemented yet */ | |
432 | static int vfio_platform_hot_reset_multi(VFIODevice *vbasedev) | |
433 | { | |
434 | return -1; | |
435 | } | |
436 | ||
437 | /** | |
438 | * vfio_populate_device - Allocate and populate MMIO region | |
38559979 | 439 | * and IRQ structs according to driver returned information |
0ea2730b | 440 | * @vbasedev: the VFIO device handle |
5ff7419d | 441 | * @errp: error object |
0ea2730b EA |
442 | * |
443 | */ | |
5ff7419d | 444 | static int vfio_populate_device(VFIODevice *vbasedev, Error **errp) |
0ea2730b | 445 | { |
38559979 | 446 | VFIOINTp *intp, *tmp; |
0ea2730b EA |
447 | int i, ret = -1; |
448 | VFIOPlatformDevice *vdev = | |
449 | container_of(vbasedev, VFIOPlatformDevice, vbasedev); | |
450 | ||
451 | if (!(vbasedev->flags & VFIO_DEVICE_FLAGS_PLATFORM)) { | |
5ff7419d | 452 | error_setg(errp, "this isn't a platform device"); |
0ea2730b EA |
453 | return ret; |
454 | } | |
455 | ||
0b70743d | 456 | vdev->regions = g_new0(VFIORegion *, vbasedev->num_regions); |
0ea2730b EA |
457 | |
458 | for (i = 0; i < vbasedev->num_regions; i++) { | |
db0da029 | 459 | char *name = g_strdup_printf("VFIO %s region %d\n", vbasedev->name, i); |
0ea2730b | 460 | |
bdd81add | 461 | vdev->regions[i] = g_new0(VFIORegion, 1); |
db0da029 AW |
462 | ret = vfio_region_setup(OBJECT(vdev), vbasedev, |
463 | vdev->regions[i], i, name); | |
464 | g_free(name); | |
0ea2730b | 465 | if (ret) { |
5ff7419d | 466 | error_setg_errno(errp, -ret, "failed to get region %d info", i); |
0ea2730b EA |
467 | goto reg_error; |
468 | } | |
0ea2730b EA |
469 | } |
470 | ||
38559979 EA |
471 | vdev->mmap_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, |
472 | vfio_intp_mmap_enable, vdev); | |
473 | ||
474 | QSIMPLEQ_INIT(&vdev->pending_intp_queue); | |
475 | ||
476 | for (i = 0; i < vbasedev->num_irqs; i++) { | |
477 | struct vfio_irq_info irq = { .argsz = sizeof(irq) }; | |
478 | ||
479 | irq.index = i; | |
480 | ret = ioctl(vbasedev->fd, VFIO_DEVICE_GET_IRQ_INFO, &irq); | |
481 | if (ret) { | |
5ff7419d | 482 | error_setg_errno(errp, -ret, "failed to get device irq info"); |
38559979 EA |
483 | goto irq_err; |
484 | } else { | |
485 | trace_vfio_platform_populate_interrupts(irq.index, | |
486 | irq.count, | |
487 | irq.flags); | |
5ff7419d | 488 | intp = vfio_init_intp(vbasedev, irq, errp); |
38559979 | 489 | if (!intp) { |
0d84f47b | 490 | ret = -1; |
38559979 EA |
491 | goto irq_err; |
492 | } | |
493 | } | |
494 | } | |
0ea2730b | 495 | return 0; |
38559979 EA |
496 | irq_err: |
497 | timer_del(vdev->mmap_timer); | |
498 | QLIST_FOREACH_SAFE(intp, &vdev->intp_list, next, tmp) { | |
499 | QLIST_REMOVE(intp, next); | |
500 | g_free(intp); | |
501 | } | |
0ea2730b EA |
502 | reg_error: |
503 | for (i = 0; i < vbasedev->num_regions; i++) { | |
db0da029 AW |
504 | if (vdev->regions[i]) { |
505 | vfio_region_finalize(vdev->regions[i]); | |
506 | } | |
0ea2730b EA |
507 | g_free(vdev->regions[i]); |
508 | } | |
509 | g_free(vdev->regions); | |
510 | return ret; | |
511 | } | |
512 | ||
513 | /* specialized functions for VFIO Platform devices */ | |
514 | static VFIODeviceOps vfio_platform_ops = { | |
515 | .vfio_compute_needs_reset = vfio_platform_compute_needs_reset, | |
516 | .vfio_hot_reset_multi = vfio_platform_hot_reset_multi, | |
38559979 | 517 | .vfio_eoi = vfio_platform_eoi, |
0ea2730b EA |
518 | }; |
519 | ||
520 | /** | |
521 | * vfio_base_device_init - perform preliminary VFIO setup | |
522 | * @vbasedev: the VFIO device handle | |
9bdbfbd5 | 523 | * @errp: error object |
0ea2730b EA |
524 | * |
525 | * Implement the VFIO command sequence that allows to discover | |
526 | * assigned device resources: group extraction, device | |
527 | * fd retrieval, resource query. | |
528 | * Precondition: the device name must be initialized | |
529 | */ | |
9bdbfbd5 | 530 | static int vfio_base_device_init(VFIODevice *vbasedev, Error **errp) |
0ea2730b EA |
531 | { |
532 | VFIOGroup *group; | |
533 | VFIODevice *vbasedev_iter; | |
7df9381b | 534 | char *tmp, group_path[PATH_MAX], *group_name; |
0ea2730b EA |
535 | ssize_t len; |
536 | struct stat st; | |
537 | int groupid; | |
538 | int ret; | |
539 | ||
7df9381b AW |
540 | /* @sysfsdev takes precedence over @host */ |
541 | if (vbasedev->sysfsdev) { | |
542 | g_free(vbasedev->name); | |
3e015d81 | 543 | vbasedev->name = g_path_get_basename(vbasedev->sysfsdev); |
7df9381b AW |
544 | } else { |
545 | if (!vbasedev->name || strchr(vbasedev->name, '/')) { | |
9bdbfbd5 | 546 | error_setg(errp, "wrong host device name"); |
7df9381b AW |
547 | return -EINVAL; |
548 | } | |
0ea2730b | 549 | |
7df9381b AW |
550 | vbasedev->sysfsdev = g_strdup_printf("/sys/bus/platform/devices/%s", |
551 | vbasedev->name); | |
552 | } | |
0ea2730b | 553 | |
7df9381b | 554 | if (stat(vbasedev->sysfsdev, &st) < 0) { |
9bdbfbd5 EA |
555 | error_setg_errno(errp, errno, |
556 | "failed to get the sysfs host device file status"); | |
0ea2730b EA |
557 | return -errno; |
558 | } | |
559 | ||
7df9381b AW |
560 | tmp = g_strdup_printf("%s/iommu_group", vbasedev->sysfsdev); |
561 | len = readlink(tmp, group_path, sizeof(group_path)); | |
562 | g_free(tmp); | |
563 | ||
564 | if (len < 0 || len >= sizeof(group_path)) { | |
9bdbfbd5 EA |
565 | ret = len < 0 ? -errno : -ENAMETOOLONG; |
566 | error_setg_errno(errp, -ret, "no iommu_group found"); | |
567 | return ret; | |
0ea2730b EA |
568 | } |
569 | ||
7df9381b | 570 | group_path[len] = 0; |
0ea2730b | 571 | |
7df9381b | 572 | group_name = basename(group_path); |
0ea2730b | 573 | if (sscanf(group_name, "%d", &groupid) != 1) { |
9bdbfbd5 | 574 | error_setg_errno(errp, errno, "failed to read %s", group_path); |
0ea2730b EA |
575 | return -errno; |
576 | } | |
577 | ||
578 | trace_vfio_platform_base_device_init(vbasedev->name, groupid); | |
579 | ||
9bdbfbd5 | 580 | group = vfio_get_group(groupid, &address_space_memory, errp); |
0ea2730b | 581 | if (!group) { |
9bdbfbd5 | 582 | return -ENOENT; |
0ea2730b EA |
583 | } |
584 | ||
0ea2730b EA |
585 | QLIST_FOREACH(vbasedev_iter, &group->device_list, next) { |
586 | if (strcmp(vbasedev_iter->name, vbasedev->name) == 0) { | |
9bdbfbd5 | 587 | error_setg(errp, "device is already attached"); |
0ea2730b EA |
588 | vfio_put_group(group); |
589 | return -EBUSY; | |
590 | } | |
591 | } | |
9bdbfbd5 | 592 | ret = vfio_get_device(group, vbasedev->name, vbasedev, errp); |
0ea2730b | 593 | if (ret) { |
0ea2730b | 594 | vfio_put_group(group); |
9bdbfbd5 | 595 | return ret; |
0ea2730b EA |
596 | } |
597 | ||
9bdbfbd5 | 598 | ret = vfio_populate_device(vbasedev, errp); |
0ea2730b | 599 | if (ret) { |
0ea2730b EA |
600 | vfio_put_group(group); |
601 | } | |
602 | ||
603 | return ret; | |
604 | } | |
605 | ||
0ea2730b EA |
606 | /** |
607 | * vfio_platform_realize - the device realize function | |
608 | * @dev: device state pointer | |
609 | * @errp: error | |
610 | * | |
611 | * initialize the device, its memory regions and IRQ structures | |
612 | * IRQ are started separately | |
613 | */ | |
614 | static void vfio_platform_realize(DeviceState *dev, Error **errp) | |
615 | { | |
616 | VFIOPlatformDevice *vdev = VFIO_PLATFORM_DEVICE(dev); | |
617 | SysBusDevice *sbdev = SYS_BUS_DEVICE(dev); | |
618 | VFIODevice *vbasedev = &vdev->vbasedev; | |
619 | int i, ret; | |
620 | ||
621 | vbasedev->type = VFIO_DEVICE_TYPE_PLATFORM; | |
7da624e2 | 622 | vbasedev->dev = dev; |
0ea2730b EA |
623 | vbasedev->ops = &vfio_platform_ops; |
624 | ||
89202c6f EA |
625 | qemu_mutex_init(&vdev->intp_mutex); |
626 | ||
7df9381b AW |
627 | trace_vfio_platform_realize(vbasedev->sysfsdev ? |
628 | vbasedev->sysfsdev : vbasedev->name, | |
629 | vdev->compat); | |
0ea2730b | 630 | |
9bdbfbd5 | 631 | ret = vfio_base_device_init(vbasedev, errp); |
0ea2730b | 632 | if (ret) { |
9bdbfbd5 | 633 | goto out; |
0ea2730b EA |
634 | } |
635 | ||
a49531eb EA |
636 | if (!vdev->compat) { |
637 | GError *gerr = NULL; | |
638 | gchar *contents; | |
639 | gsize length; | |
640 | char *path; | |
641 | ||
642 | path = g_strdup_printf("%s/of_node/compatible", vbasedev->sysfsdev); | |
643 | if (!g_file_get_contents(path, &contents, &length, &gerr)) { | |
644 | error_setg(errp, "%s", gerr->message); | |
645 | g_error_free(gerr); | |
646 | g_free(path); | |
647 | return; | |
648 | } | |
649 | g_free(path); | |
650 | vdev->compat = contents; | |
651 | for (vdev->num_compat = 0; length; vdev->num_compat++) { | |
652 | size_t skip = strlen(contents) + 1; | |
653 | contents += skip; | |
654 | length -= skip; | |
655 | } | |
656 | } | |
657 | ||
0ea2730b | 658 | for (i = 0; i < vbasedev->num_regions; i++) { |
db0da029 | 659 | if (vfio_region_mmap(vdev->regions[i])) { |
e1eb292a MA |
660 | warn_report("%s mmap unsupported, performance may be slow", |
661 | memory_region_name(vdev->regions[i]->mem)); | |
db0da029 AW |
662 | } |
663 | sysbus_init_mmio(sbdev, vdev->regions[i]->mem); | |
0ea2730b | 664 | } |
9bdbfbd5 EA |
665 | out: |
666 | if (!ret) { | |
667 | return; | |
668 | } | |
669 | ||
670 | if (vdev->vbasedev.name) { | |
c3b8e3e0 | 671 | error_prepend(errp, VFIO_MSG_PREFIX, vdev->vbasedev.name); |
9bdbfbd5 EA |
672 | } else { |
673 | error_prepend(errp, "vfio error: "); | |
674 | } | |
0ea2730b EA |
675 | } |
676 | ||
677 | static const VMStateDescription vfio_platform_vmstate = { | |
da56e330 | 678 | .name = "vfio-platform", |
0ea2730b EA |
679 | .unmigratable = 1, |
680 | }; | |
681 | ||
682 | static Property vfio_platform_dev_properties[] = { | |
683 | DEFINE_PROP_STRING("host", VFIOPlatformDevice, vbasedev.name), | |
7df9381b | 684 | DEFINE_PROP_STRING("sysfsdev", VFIOPlatformDevice, vbasedev.sysfsdev), |
5e15d79b | 685 | DEFINE_PROP_BOOL("x-no-mmap", VFIOPlatformDevice, vbasedev.no_mmap, false), |
38559979 EA |
686 | DEFINE_PROP_UINT32("mmap-timeout-ms", VFIOPlatformDevice, |
687 | mmap_timeout, 1100), | |
fb5f8164 | 688 | DEFINE_PROP_BOOL("x-irqfd", VFIOPlatformDevice, irqfd_allowed, true), |
0ea2730b EA |
689 | DEFINE_PROP_END_OF_LIST(), |
690 | }; | |
691 | ||
692 | static void vfio_platform_class_init(ObjectClass *klass, void *data) | |
693 | { | |
694 | DeviceClass *dc = DEVICE_CLASS(klass); | |
fb5f8164 | 695 | SysBusDeviceClass *sbc = SYS_BUS_DEVICE_CLASS(klass); |
0ea2730b EA |
696 | |
697 | dc->realize = vfio_platform_realize; | |
4f67d30b | 698 | device_class_set_props(dc, vfio_platform_dev_properties); |
0ea2730b EA |
699 | dc->vmsd = &vfio_platform_vmstate; |
700 | dc->desc = "VFIO-based platform device assignment"; | |
fb5f8164 | 701 | sbc->connect_irq_notifier = vfio_start_irqfd_injection; |
0ea2730b | 702 | set_bit(DEVICE_CATEGORY_MISC, dc->categories); |
a49531eb EA |
703 | /* Supported by TYPE_VIRT_MACHINE */ |
704 | dc->user_creatable = true; | |
0ea2730b EA |
705 | } |
706 | ||
707 | static const TypeInfo vfio_platform_dev_info = { | |
708 | .name = TYPE_VFIO_PLATFORM, | |
709 | .parent = TYPE_SYS_BUS_DEVICE, | |
710 | .instance_size = sizeof(VFIOPlatformDevice), | |
711 | .class_init = vfio_platform_class_init, | |
712 | .class_size = sizeof(VFIOPlatformDeviceClass), | |
0ea2730b EA |
713 | }; |
714 | ||
715 | static void register_vfio_platform_dev_type(void) | |
716 | { | |
717 | type_register_static(&vfio_platform_dev_info); | |
718 | } | |
719 | ||
720 | type_init(register_vfio_platform_dev_type) |