1 /*
2 * low level and IOMMU backend agnostic helpers used by VFIO devices,
3 * related to regions, interrupts, capabilities
4 *
5 * Copyright Red Hat, Inc. 2012
6 *
7 * Authors:
8 * Alex Williamson <alex.williamson@redhat.com>
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 qemu-kvm device-assignment:
14 * Adapted for KVM by Qumranet.
15 * Copyright (c) 2007, Neocleus, Alex Novik (alex@neocleus.com)
16 * Copyright (c) 2007, Neocleus, Guy Zana (guy@neocleus.com)
17 * Copyright (C) 2008, Qumranet, Amit Shah (amit.shah@qumranet.com)
18 * Copyright (C) 2008, Red Hat, Amit Shah (amit.shah@redhat.com)
19 * Copyright (C) 2008, IBM, Muli Ben-Yehuda (muli@il.ibm.com)
20 */
21
22 #include "qemu/osdep.h"
23 #include <sys/ioctl.h>
24
25 #include "hw/vfio/vfio-common.h"
26 #include "hw/hw.h"
27 #include "trace.h"
28 #include "qapi/error.h"
29 #include "qemu/error-report.h"
30 #include "monitor/monitor.h"
31
32 /*
33 * Common VFIO interrupt disable
34 */
vfio_disable_irqindex(VFIODevice * vbasedev,int index)35 void vfio_disable_irqindex(VFIODevice *vbasedev, int index)
36 {
37 struct vfio_irq_set irq_set = {
38 .argsz = sizeof(irq_set),
39 .flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_TRIGGER,
40 .index = index,
41 .start = 0,
42 .count = 0,
43 };
44
45 ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set);
46 }
47
vfio_unmask_single_irqindex(VFIODevice * vbasedev,int index)48 void vfio_unmask_single_irqindex(VFIODevice *vbasedev, int index)
49 {
50 struct vfio_irq_set irq_set = {
51 .argsz = sizeof(irq_set),
52 .flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_UNMASK,
53 .index = index,
54 .start = 0,
55 .count = 1,
56 };
57
58 ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set);
59 }
60
vfio_mask_single_irqindex(VFIODevice * vbasedev,int index)61 void vfio_mask_single_irqindex(VFIODevice *vbasedev, int index)
62 {
63 struct vfio_irq_set irq_set = {
64 .argsz = sizeof(irq_set),
65 .flags = VFIO_IRQ_SET_DATA_NONE | VFIO_IRQ_SET_ACTION_MASK,
66 .index = index,
67 .start = 0,
68 .count = 1,
69 };
70
71 ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, &irq_set);
72 }
73
action_to_str(int action)74 static inline const char *action_to_str(int action)
75 {
76 switch (action) {
77 case VFIO_IRQ_SET_ACTION_MASK:
78 return "MASK";
79 case VFIO_IRQ_SET_ACTION_UNMASK:
80 return "UNMASK";
81 case VFIO_IRQ_SET_ACTION_TRIGGER:
82 return "TRIGGER";
83 default:
84 return "UNKNOWN ACTION";
85 }
86 }
87
index_to_str(VFIODevice * vbasedev,int index)88 static const char *index_to_str(VFIODevice *vbasedev, int index)
89 {
90 if (vbasedev->type != VFIO_DEVICE_TYPE_PCI) {
91 return NULL;
92 }
93
94 switch (index) {
95 case VFIO_PCI_INTX_IRQ_INDEX:
96 return "INTX";
97 case VFIO_PCI_MSI_IRQ_INDEX:
98 return "MSI";
99 case VFIO_PCI_MSIX_IRQ_INDEX:
100 return "MSIX";
101 case VFIO_PCI_ERR_IRQ_INDEX:
102 return "ERR";
103 case VFIO_PCI_REQ_IRQ_INDEX:
104 return "REQ";
105 default:
106 return NULL;
107 }
108 }
109
vfio_set_irq_signaling(VFIODevice * vbasedev,int index,int subindex,int action,int fd,Error ** errp)110 int vfio_set_irq_signaling(VFIODevice *vbasedev, int index, int subindex,
111 int action, int fd, Error **errp)
112 {
113 ERRP_GUARD();
114 struct vfio_irq_set *irq_set;
115 int argsz, ret = 0;
116 const char *name;
117 int32_t *pfd;
118
119 argsz = sizeof(*irq_set) + sizeof(*pfd);
120
121 irq_set = g_malloc0(argsz);
122 irq_set->argsz = argsz;
123 irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | action;
124 irq_set->index = index;
125 irq_set->start = subindex;
126 irq_set->count = 1;
127 pfd = (int32_t *)&irq_set->data;
128 *pfd = fd;
129
130 if (ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, irq_set)) {
131 ret = -errno;
132 }
133 g_free(irq_set);
134
135 if (!ret) {
136 return 0;
137 }
138
139 error_setg_errno(errp, -ret, "VFIO_DEVICE_SET_IRQS failure");
140
141 name = index_to_str(vbasedev, index);
142 if (name) {
143 error_prepend(errp, "%s-%d: ", name, subindex);
144 } else {
145 error_prepend(errp, "index %d-%d: ", index, subindex);
146 }
147 error_prepend(errp,
148 "Failed to %s %s eventfd signaling for interrupt ",
149 fd < 0 ? "tear down" : "set up", action_to_str(action));
150 return ret;
151 }
152
153 /*
154 * IO Port/MMIO - Beware of the endians, VFIO is always little endian
155 */
vfio_region_write(void * opaque,hwaddr addr,uint64_t data,unsigned size)156 void vfio_region_write(void *opaque, hwaddr addr,
157 uint64_t data, unsigned size)
158 {
159 VFIORegion *region = opaque;
160 VFIODevice *vbasedev = region->vbasedev;
161 union {
162 uint8_t byte;
163 uint16_t word;
164 uint32_t dword;
165 uint64_t qword;
166 } buf;
167
168 switch (size) {
169 case 1:
170 buf.byte = data;
171 break;
172 case 2:
173 buf.word = cpu_to_le16(data);
174 break;
175 case 4:
176 buf.dword = cpu_to_le32(data);
177 break;
178 case 8:
179 buf.qword = cpu_to_le64(data);
180 break;
181 default:
182 hw_error("vfio: unsupported write size, %u bytes", size);
183 break;
184 }
185
186 if (pwrite(vbasedev->fd, &buf, size, region->fd_offset + addr) != size) {
187 error_report("%s(%s:region%d+0x%"HWADDR_PRIx", 0x%"PRIx64
188 ",%d) failed: %m",
189 __func__, vbasedev->name, region->nr,
190 addr, data, size);
191 }
192
193 trace_vfio_region_write(vbasedev->name, region->nr, addr, data, size);
194
195 /*
196 * A read or write to a BAR always signals an INTx EOI. This will
197 * do nothing if not pending (including not in INTx mode). We assume
198 * that a BAR access is in response to an interrupt and that BAR
199 * accesses will service the interrupt. Unfortunately, we don't know
200 * which access will service the interrupt, so we're potentially
201 * getting quite a few host interrupts per guest interrupt.
202 */
203 vbasedev->ops->vfio_eoi(vbasedev);
204 }
205
vfio_region_read(void * opaque,hwaddr addr,unsigned size)206 uint64_t vfio_region_read(void *opaque,
207 hwaddr addr, unsigned size)
208 {
209 VFIORegion *region = opaque;
210 VFIODevice *vbasedev = region->vbasedev;
211 union {
212 uint8_t byte;
213 uint16_t word;
214 uint32_t dword;
215 uint64_t qword;
216 } buf;
217 uint64_t data = 0;
218
219 if (pread(vbasedev->fd, &buf, size, region->fd_offset + addr) != size) {
220 error_report("%s(%s:region%d+0x%"HWADDR_PRIx", %d) failed: %m",
221 __func__, vbasedev->name, region->nr,
222 addr, size);
223 return (uint64_t)-1;
224 }
225 switch (size) {
226 case 1:
227 data = buf.byte;
228 break;
229 case 2:
230 data = le16_to_cpu(buf.word);
231 break;
232 case 4:
233 data = le32_to_cpu(buf.dword);
234 break;
235 case 8:
236 data = le64_to_cpu(buf.qword);
237 break;
238 default:
239 hw_error("vfio: unsupported read size, %u bytes", size);
240 break;
241 }
242
243 trace_vfio_region_read(vbasedev->name, region->nr, addr, size, data);
244
245 /* Same as write above */
246 vbasedev->ops->vfio_eoi(vbasedev);
247
248 return data;
249 }
250
251 const MemoryRegionOps vfio_region_ops = {
252 .read = vfio_region_read,
253 .write = vfio_region_write,
254 .endianness = DEVICE_LITTLE_ENDIAN,
255 .valid = {
256 .min_access_size = 1,
257 .max_access_size = 8,
258 },
259 .impl = {
260 .min_access_size = 1,
261 .max_access_size = 8,
262 },
263 };
264
vfio_bitmap_alloc(VFIOBitmap * vbmap,hwaddr size)265 int vfio_bitmap_alloc(VFIOBitmap *vbmap, hwaddr size)
266 {
267 vbmap->pages = REAL_HOST_PAGE_ALIGN(size) / qemu_real_host_page_size();
268 vbmap->size = ROUND_UP(vbmap->pages, sizeof(__u64) * BITS_PER_BYTE) /
269 BITS_PER_BYTE;
270 vbmap->bitmap = g_try_malloc0(vbmap->size);
271 if (!vbmap->bitmap) {
272 return -ENOMEM;
273 }
274
275 return 0;
276 }
277
278 struct vfio_info_cap_header *
vfio_get_cap(void * ptr,uint32_t cap_offset,uint16_t id)279 vfio_get_cap(void *ptr, uint32_t cap_offset, uint16_t id)
280 {
281 struct vfio_info_cap_header *hdr;
282
283 for (hdr = ptr + cap_offset; hdr != ptr; hdr = ptr + hdr->next) {
284 if (hdr->id == id) {
285 return hdr;
286 }
287 }
288
289 return NULL;
290 }
291
292 struct vfio_info_cap_header *
vfio_get_region_info_cap(struct vfio_region_info * info,uint16_t id)293 vfio_get_region_info_cap(struct vfio_region_info *info, uint16_t id)
294 {
295 if (!(info->flags & VFIO_REGION_INFO_FLAG_CAPS)) {
296 return NULL;
297 }
298
299 return vfio_get_cap((void *)info, info->cap_offset, id);
300 }
301
302 struct vfio_info_cap_header *
vfio_get_device_info_cap(struct vfio_device_info * info,uint16_t id)303 vfio_get_device_info_cap(struct vfio_device_info *info, uint16_t id)
304 {
305 if (!(info->flags & VFIO_DEVICE_FLAGS_CAPS)) {
306 return NULL;
307 }
308
309 return vfio_get_cap((void *)info, info->cap_offset, id);
310 }
311
vfio_setup_region_sparse_mmaps(VFIORegion * region,struct vfio_region_info * info)312 static int vfio_setup_region_sparse_mmaps(VFIORegion *region,
313 struct vfio_region_info *info)
314 {
315 struct vfio_info_cap_header *hdr;
316 struct vfio_region_info_cap_sparse_mmap *sparse;
317 int i, j;
318
319 hdr = vfio_get_region_info_cap(info, VFIO_REGION_INFO_CAP_SPARSE_MMAP);
320 if (!hdr) {
321 return -ENODEV;
322 }
323
324 sparse = container_of(hdr, struct vfio_region_info_cap_sparse_mmap, header);
325
326 trace_vfio_region_sparse_mmap_header(region->vbasedev->name,
327 region->nr, sparse->nr_areas);
328
329 region->mmaps = g_new0(VFIOMmap, sparse->nr_areas);
330
331 for (i = 0, j = 0; i < sparse->nr_areas; i++) {
332 if (sparse->areas[i].size) {
333 trace_vfio_region_sparse_mmap_entry(i, sparse->areas[i].offset,
334 sparse->areas[i].offset +
335 sparse->areas[i].size - 1);
336 region->mmaps[j].offset = sparse->areas[i].offset;
337 region->mmaps[j].size = sparse->areas[i].size;
338 j++;
339 }
340 }
341
342 region->nr_mmaps = j;
343 region->mmaps = g_realloc(region->mmaps, j * sizeof(VFIOMmap));
344
345 return 0;
346 }
347
vfio_region_setup(Object * obj,VFIODevice * vbasedev,VFIORegion * region,int index,const char * name)348 int vfio_region_setup(Object *obj, VFIODevice *vbasedev, VFIORegion *region,
349 int index, const char *name)
350 {
351 struct vfio_region_info *info;
352 int ret;
353
354 ret = vfio_get_region_info(vbasedev, index, &info);
355 if (ret) {
356 return ret;
357 }
358
359 region->vbasedev = vbasedev;
360 region->flags = info->flags;
361 region->size = info->size;
362 region->fd_offset = info->offset;
363 region->nr = index;
364
365 if (region->size) {
366 region->mem = g_new0(MemoryRegion, 1);
367 memory_region_init_io(region->mem, obj, &vfio_region_ops,
368 region, name, region->size);
369
370 if (!vbasedev->no_mmap &&
371 region->flags & VFIO_REGION_INFO_FLAG_MMAP) {
372
373 ret = vfio_setup_region_sparse_mmaps(region, info);
374
375 if (ret) {
376 region->nr_mmaps = 1;
377 region->mmaps = g_new0(VFIOMmap, region->nr_mmaps);
378 region->mmaps[0].offset = 0;
379 region->mmaps[0].size = region->size;
380 }
381 }
382 }
383
384 g_free(info);
385
386 trace_vfio_region_setup(vbasedev->name, index, name,
387 region->flags, region->fd_offset, region->size);
388 return 0;
389 }
390
vfio_subregion_unmap(VFIORegion * region,int index)391 static void vfio_subregion_unmap(VFIORegion *region, int index)
392 {
393 trace_vfio_region_unmap(memory_region_name(®ion->mmaps[index].mem),
394 region->mmaps[index].offset,
395 region->mmaps[index].offset +
396 region->mmaps[index].size - 1);
397 memory_region_del_subregion(region->mem, ®ion->mmaps[index].mem);
398 munmap(region->mmaps[index].mmap, region->mmaps[index].size);
399 object_unparent(OBJECT(®ion->mmaps[index].mem));
400 region->mmaps[index].mmap = NULL;
401 }
402
vfio_region_mmap(VFIORegion * region)403 int vfio_region_mmap(VFIORegion *region)
404 {
405 int i, prot = 0;
406 char *name;
407
408 if (!region->mem) {
409 return 0;
410 }
411
412 prot |= region->flags & VFIO_REGION_INFO_FLAG_READ ? PROT_READ : 0;
413 prot |= region->flags & VFIO_REGION_INFO_FLAG_WRITE ? PROT_WRITE : 0;
414
415 for (i = 0; i < region->nr_mmaps; i++) {
416 region->mmaps[i].mmap = mmap(NULL, region->mmaps[i].size, prot,
417 MAP_SHARED, region->vbasedev->fd,
418 region->fd_offset +
419 region->mmaps[i].offset);
420 if (region->mmaps[i].mmap == MAP_FAILED) {
421 int ret = -errno;
422
423 trace_vfio_region_mmap_fault(memory_region_name(region->mem), i,
424 region->fd_offset +
425 region->mmaps[i].offset,
426 region->fd_offset +
427 region->mmaps[i].offset +
428 region->mmaps[i].size - 1, ret);
429
430 region->mmaps[i].mmap = NULL;
431
432 for (i--; i >= 0; i--) {
433 vfio_subregion_unmap(region, i);
434 }
435
436 return ret;
437 }
438
439 name = g_strdup_printf("%s mmaps[%d]",
440 memory_region_name(region->mem), i);
441 memory_region_init_ram_device_ptr(®ion->mmaps[i].mem,
442 memory_region_owner(region->mem),
443 name, region->mmaps[i].size,
444 region->mmaps[i].mmap);
445 g_free(name);
446 memory_region_add_subregion(region->mem, region->mmaps[i].offset,
447 ®ion->mmaps[i].mem);
448
449 trace_vfio_region_mmap(memory_region_name(®ion->mmaps[i].mem),
450 region->mmaps[i].offset,
451 region->mmaps[i].offset +
452 region->mmaps[i].size - 1);
453 }
454
455 return 0;
456 }
457
vfio_region_unmap(VFIORegion * region)458 void vfio_region_unmap(VFIORegion *region)
459 {
460 int i;
461
462 if (!region->mem) {
463 return;
464 }
465
466 for (i = 0; i < region->nr_mmaps; i++) {
467 if (region->mmaps[i].mmap) {
468 vfio_subregion_unmap(region, i);
469 }
470 }
471 }
472
vfio_region_exit(VFIORegion * region)473 void vfio_region_exit(VFIORegion *region)
474 {
475 int i;
476
477 if (!region->mem) {
478 return;
479 }
480
481 for (i = 0; i < region->nr_mmaps; i++) {
482 if (region->mmaps[i].mmap) {
483 memory_region_del_subregion(region->mem, ®ion->mmaps[i].mem);
484 }
485 }
486
487 trace_vfio_region_exit(region->vbasedev->name, region->nr);
488 }
489
vfio_region_finalize(VFIORegion * region)490 void vfio_region_finalize(VFIORegion *region)
491 {
492 int i;
493
494 if (!region->mem) {
495 return;
496 }
497
498 for (i = 0; i < region->nr_mmaps; i++) {
499 if (region->mmaps[i].mmap) {
500 munmap(region->mmaps[i].mmap, region->mmaps[i].size);
501 object_unparent(OBJECT(®ion->mmaps[i].mem));
502 }
503 }
504
505 object_unparent(OBJECT(region->mem));
506
507 g_free(region->mem);
508 g_free(region->mmaps);
509
510 trace_vfio_region_finalize(region->vbasedev->name, region->nr);
511
512 region->mem = NULL;
513 region->mmaps = NULL;
514 region->nr_mmaps = 0;
515 region->size = 0;
516 region->flags = 0;
517 region->nr = 0;
518 }
519
vfio_region_mmaps_set_enabled(VFIORegion * region,bool enabled)520 void vfio_region_mmaps_set_enabled(VFIORegion *region, bool enabled)
521 {
522 int i;
523
524 if (!region->mem) {
525 return;
526 }
527
528 for (i = 0; i < region->nr_mmaps; i++) {
529 if (region->mmaps[i].mmap) {
530 memory_region_set_enabled(®ion->mmaps[i].mem, enabled);
531 }
532 }
533
534 trace_vfio_region_mmaps_set_enabled(memory_region_name(region->mem),
535 enabled);
536 }
537
vfio_get_region_info(VFIODevice * vbasedev,int index,struct vfio_region_info ** info)538 int vfio_get_region_info(VFIODevice *vbasedev, int index,
539 struct vfio_region_info **info)
540 {
541 size_t argsz = sizeof(struct vfio_region_info);
542
543 *info = g_malloc0(argsz);
544
545 (*info)->index = index;
546 retry:
547 (*info)->argsz = argsz;
548
549 if (ioctl(vbasedev->fd, VFIO_DEVICE_GET_REGION_INFO, *info)) {
550 g_free(*info);
551 *info = NULL;
552 return -errno;
553 }
554
555 if ((*info)->argsz > argsz) {
556 argsz = (*info)->argsz;
557 *info = g_realloc(*info, argsz);
558
559 goto retry;
560 }
561
562 return 0;
563 }
564
vfio_get_dev_region_info(VFIODevice * vbasedev,uint32_t type,uint32_t subtype,struct vfio_region_info ** info)565 int vfio_get_dev_region_info(VFIODevice *vbasedev, uint32_t type,
566 uint32_t subtype, struct vfio_region_info **info)
567 {
568 int i;
569
570 for (i = 0; i < vbasedev->num_regions; i++) {
571 struct vfio_info_cap_header *hdr;
572 struct vfio_region_info_cap_type *cap_type;
573
574 if (vfio_get_region_info(vbasedev, i, info)) {
575 continue;
576 }
577
578 hdr = vfio_get_region_info_cap(*info, VFIO_REGION_INFO_CAP_TYPE);
579 if (!hdr) {
580 g_free(*info);
581 continue;
582 }
583
584 cap_type = container_of(hdr, struct vfio_region_info_cap_type, header);
585
586 trace_vfio_get_dev_region(vbasedev->name, i,
587 cap_type->type, cap_type->subtype);
588
589 if (cap_type->type == type && cap_type->subtype == subtype) {
590 return 0;
591 }
592
593 g_free(*info);
594 }
595
596 *info = NULL;
597 return -ENODEV;
598 }
599
vfio_has_region_cap(VFIODevice * vbasedev,int region,uint16_t cap_type)600 bool vfio_has_region_cap(VFIODevice *vbasedev, int region, uint16_t cap_type)
601 {
602 struct vfio_region_info *info = NULL;
603 bool ret = false;
604
605 if (!vfio_get_region_info(vbasedev, region, &info)) {
606 if (vfio_get_region_info_cap(info, cap_type)) {
607 ret = true;
608 }
609 g_free(info);
610 }
611
612 return ret;
613 }
614
vfio_device_get_name(VFIODevice * vbasedev,Error ** errp)615 int vfio_device_get_name(VFIODevice *vbasedev, Error **errp)
616 {
617 ERRP_GUARD();
618 struct stat st;
619
620 if (vbasedev->fd < 0) {
621 if (stat(vbasedev->sysfsdev, &st) < 0) {
622 error_setg_errno(errp, errno, "no such host device");
623 error_prepend(errp, VFIO_MSG_PREFIX, vbasedev->sysfsdev);
624 return -errno;
625 }
626 /* User may specify a name, e.g: VFIO platform device */
627 if (!vbasedev->name) {
628 vbasedev->name = g_path_get_basename(vbasedev->sysfsdev);
629 }
630 } else {
631 if (!vbasedev->iommufd) {
632 error_setg(errp, "Use FD passing only with iommufd backend");
633 return -EINVAL;
634 }
635 /*
636 * Give a name with fd so any function printing out vbasedev->name
637 * will not break.
638 */
639 if (!vbasedev->name) {
640 vbasedev->name = g_strdup_printf("VFIO_FD%d", vbasedev->fd);
641 }
642 }
643
644 return 0;
645 }
646
vfio_device_set_fd(VFIODevice * vbasedev,const char * str,Error ** errp)647 void vfio_device_set_fd(VFIODevice *vbasedev, const char *str, Error **errp)
648 {
649 ERRP_GUARD();
650 int fd = monitor_fd_param(monitor_cur(), str, errp);
651
652 if (fd < 0) {
653 error_prepend(errp, "Could not parse remote object fd %s:", str);
654 return;
655 }
656 vbasedev->fd = fd;
657 }
658
vfio_device_init(VFIODevice * vbasedev,int type,VFIODeviceOps * ops,DeviceState * dev,bool ram_discard)659 void vfio_device_init(VFIODevice *vbasedev, int type, VFIODeviceOps *ops,
660 DeviceState *dev, bool ram_discard)
661 {
662 vbasedev->type = type;
663 vbasedev->ops = ops;
664 vbasedev->dev = dev;
665 vbasedev->fd = -1;
666
667 vbasedev->ram_block_discard_allowed = ram_discard;
668 }
669