xref: /qemu/hw/vfio/iommufd.c (revision 9c707525) 
1 /*
2  * iommufd container backend
3  *
4  * Copyright (C) 2023 Intel Corporation.
5  * Copyright Red Hat, Inc. 2023
6  *
7  * Authors: Yi Liu <yi.l.liu@intel.com>
8  *          Eric Auger <eric.auger@redhat.com>
9  *
10  * SPDX-License-Identifier: GPL-2.0-or-later
11  */
12 
13 #include "qemu/osdep.h"
14 #include <sys/ioctl.h>
15 #include <linux/vfio.h>
16 #include <linux/iommufd.h>
17 
18 #include "hw/vfio/vfio-common.h"
19 #include "qemu/error-report.h"
20 #include "trace.h"
21 #include "qapi/error.h"
22 #include "sysemu/iommufd.h"
23 #include "hw/qdev-core.h"
24 #include "sysemu/reset.h"
25 #include "qemu/cutils.h"
26 #include "qemu/chardev_open.h"
27 #include "pci.h"
28 
29 static int iommufd_cdev_map(const VFIOContainerBase *bcontainer, hwaddr iova,
30                             ram_addr_t size, void *vaddr, bool readonly)
31 {
32     const VFIOIOMMUFDContainer *container =
33         container_of(bcontainer, VFIOIOMMUFDContainer, bcontainer);
34 
35     return iommufd_backend_map_dma(container->be,
36                                    container->ioas_id,
37                                    iova, size, vaddr, readonly);
38 }
39 
40 static int iommufd_cdev_unmap(const VFIOContainerBase *bcontainer,
41                               hwaddr iova, ram_addr_t size,
42                               IOMMUTLBEntry *iotlb)
43 {
44     const VFIOIOMMUFDContainer *container =
45         container_of(bcontainer, VFIOIOMMUFDContainer, bcontainer);
46 
47     /* TODO: Handle dma_unmap_bitmap with iotlb args (migration) */
48     return iommufd_backend_unmap_dma(container->be,
49                                      container->ioas_id, iova, size);
50 }
51 
52 static int iommufd_cdev_kvm_device_add(VFIODevice *vbasedev, Error **errp)
53 {
54     return vfio_kvm_device_add_fd(vbasedev->fd, errp);
55 }
56 
57 static void iommufd_cdev_kvm_device_del(VFIODevice *vbasedev)
58 {
59     Error *err = NULL;
60 
61     if (vfio_kvm_device_del_fd(vbasedev->fd, &err)) {
62         error_report_err(err);
63     }
64 }
65 
66 static int iommufd_cdev_connect_and_bind(VFIODevice *vbasedev, Error **errp)
67 {
68     IOMMUFDBackend *iommufd = vbasedev->iommufd;
69     struct vfio_device_bind_iommufd bind = {
70         .argsz = sizeof(bind),
71         .flags = 0,
72     };
73     int ret;
74 
75     ret = iommufd_backend_connect(iommufd, errp);
76     if (ret) {
77         return ret;
78     }
79 
80     /*
81      * Add device to kvm-vfio to be prepared for the tracking
82      * in KVM. Especially for some emulated devices, it requires
83      * to have kvm information in the device open.
84      */
85     ret = iommufd_cdev_kvm_device_add(vbasedev, errp);
86     if (ret) {
87         goto err_kvm_device_add;
88     }
89 
90     /* Bind device to iommufd */
91     bind.iommufd = iommufd->fd;
92     ret = ioctl(vbasedev->fd, VFIO_DEVICE_BIND_IOMMUFD, &bind);
93     if (ret) {
94         error_setg_errno(errp, errno, "error bind device fd=%d to iommufd=%d",
95                          vbasedev->fd, bind.iommufd);
96         goto err_bind;
97     }
98 
99     vbasedev->devid = bind.out_devid;
100     trace_iommufd_cdev_connect_and_bind(bind.iommufd, vbasedev->name,
101                                         vbasedev->fd, vbasedev->devid);
102     return ret;
103 err_bind:
104     iommufd_cdev_kvm_device_del(vbasedev);
105 err_kvm_device_add:
106     iommufd_backend_disconnect(iommufd);
107     return ret;
108 }
109 
110 static void iommufd_cdev_unbind_and_disconnect(VFIODevice *vbasedev)
111 {
112     /* Unbind is automatically conducted when device fd is closed */
113     iommufd_cdev_kvm_device_del(vbasedev);
114     iommufd_backend_disconnect(vbasedev->iommufd);
115 }
116 
117 static int iommufd_cdev_getfd(const char *sysfs_path, Error **errp)
118 {
119     ERRP_GUARD();
120     long int ret = -ENOTTY;
121     char *path, *vfio_dev_path = NULL, *vfio_path = NULL;
122     DIR *dir = NULL;
123     struct dirent *dent;
124     gchar *contents;
125     gsize length;
126     int major, minor;
127     dev_t vfio_devt;
128 
129     path = g_strdup_printf("%s/vfio-dev", sysfs_path);
130     dir = opendir(path);
131     if (!dir) {
132         error_setg_errno(errp, errno, "couldn't open directory %s", path);
133         goto out_free_path;
134     }
135 
136     while ((dent = readdir(dir))) {
137         if (!strncmp(dent->d_name, "vfio", 4)) {
138             vfio_dev_path = g_strdup_printf("%s/%s/dev", path, dent->d_name);
139             break;
140         }
141     }
142 
143     if (!vfio_dev_path) {
144         error_setg(errp, "failed to find vfio-dev/vfioX/dev");
145         goto out_close_dir;
146     }
147 
148     if (!g_file_get_contents(vfio_dev_path, &contents, &length, NULL)) {
149         error_setg(errp, "failed to load \"%s\"", vfio_dev_path);
150         goto out_free_dev_path;
151     }
152 
153     if (sscanf(contents, "%d:%d", &major, &minor) != 2) {
154         error_setg(errp, "failed to get major:minor for \"%s\"", vfio_dev_path);
155         goto out_free_dev_path;
156     }
157     g_free(contents);
158     vfio_devt = makedev(major, minor);
159 
160     vfio_path = g_strdup_printf("/dev/vfio/devices/%s", dent->d_name);
161     ret = open_cdev(vfio_path, vfio_devt);
162     if (ret < 0) {
163         error_setg(errp, "Failed to open %s", vfio_path);
164     }
165 
166     trace_iommufd_cdev_getfd(vfio_path, ret);
167     g_free(vfio_path);
168 
169 out_free_dev_path:
170     g_free(vfio_dev_path);
171 out_close_dir:
172     closedir(dir);
173 out_free_path:
174     if (*errp) {
175         error_prepend(errp, VFIO_MSG_PREFIX, path);
176     }
177     g_free(path);
178 
179     return ret;
180 }
181 
182 static int iommufd_cdev_attach_ioas_hwpt(VFIODevice *vbasedev, uint32_t id,
183                                          Error **errp)
184 {
185     int ret, iommufd = vbasedev->iommufd->fd;
186     struct vfio_device_attach_iommufd_pt attach_data = {
187         .argsz = sizeof(attach_data),
188         .flags = 0,
189         .pt_id = id,
190     };
191 
192     /* Attach device to an IOAS or hwpt within iommufd */
193     ret = ioctl(vbasedev->fd, VFIO_DEVICE_ATTACH_IOMMUFD_PT, &attach_data);
194     if (ret) {
195         error_setg_errno(errp, errno,
196                          "[iommufd=%d] error attach %s (%d) to id=%d",
197                          iommufd, vbasedev->name, vbasedev->fd, id);
198     } else {
199         trace_iommufd_cdev_attach_ioas_hwpt(iommufd, vbasedev->name,
200                                             vbasedev->fd, id);
201     }
202     return ret;
203 }
204 
205 static int iommufd_cdev_detach_ioas_hwpt(VFIODevice *vbasedev, Error **errp)
206 {
207     int ret, iommufd = vbasedev->iommufd->fd;
208     struct vfio_device_detach_iommufd_pt detach_data = {
209         .argsz = sizeof(detach_data),
210         .flags = 0,
211     };
212 
213     ret = ioctl(vbasedev->fd, VFIO_DEVICE_DETACH_IOMMUFD_PT, &detach_data);
214     if (ret) {
215         error_setg_errno(errp, errno, "detach %s failed", vbasedev->name);
216     } else {
217         trace_iommufd_cdev_detach_ioas_hwpt(iommufd, vbasedev->name);
218     }
219     return ret;
220 }
221 
222 static int iommufd_cdev_attach_container(VFIODevice *vbasedev,
223                                          VFIOIOMMUFDContainer *container,
224                                          Error **errp)
225 {
226     return iommufd_cdev_attach_ioas_hwpt(vbasedev, container->ioas_id, errp);
227 }
228 
229 static void iommufd_cdev_detach_container(VFIODevice *vbasedev,
230                                           VFIOIOMMUFDContainer *container)
231 {
232     Error *err = NULL;
233 
234     if (iommufd_cdev_detach_ioas_hwpt(vbasedev, &err)) {
235         error_report_err(err);
236     }
237 }
238 
239 static void iommufd_cdev_container_destroy(VFIOIOMMUFDContainer *container)
240 {
241     VFIOContainerBase *bcontainer = &container->bcontainer;
242 
243     if (!QLIST_EMPTY(&bcontainer->device_list)) {
244         return;
245     }
246     memory_listener_unregister(&bcontainer->listener);
247     vfio_container_destroy(bcontainer);
248     iommufd_backend_free_id(container->be, container->ioas_id);
249     g_free(container);
250 }
251 
252 static int iommufd_cdev_ram_block_discard_disable(bool state)
253 {
254     /*
255      * We support coordinated discarding of RAM via the RamDiscardManager.
256      */
257     return ram_block_uncoordinated_discard_disable(state);
258 }
259 
260 static int iommufd_cdev_get_info_iova_range(VFIOIOMMUFDContainer *container,
261                                             uint32_t ioas_id, Error **errp)
262 {
263     VFIOContainerBase *bcontainer = &container->bcontainer;
264     struct iommu_ioas_iova_ranges *info;
265     struct iommu_iova_range *iova_ranges;
266     int ret, sz, fd = container->be->fd;
267 
268     info = g_malloc0(sizeof(*info));
269     info->size = sizeof(*info);
270     info->ioas_id = ioas_id;
271 
272     ret = ioctl(fd, IOMMU_IOAS_IOVA_RANGES, info);
273     if (ret && errno != EMSGSIZE) {
274         goto error;
275     }
276 
277     sz = info->num_iovas * sizeof(struct iommu_iova_range);
278     info = g_realloc(info, sizeof(*info) + sz);
279     info->allowed_iovas = (uintptr_t)(info + 1);
280 
281     ret = ioctl(fd, IOMMU_IOAS_IOVA_RANGES, info);
282     if (ret) {
283         goto error;
284     }
285 
286     iova_ranges = (struct iommu_iova_range *)(uintptr_t)info->allowed_iovas;
287 
288     for (int i = 0; i < info->num_iovas; i++) {
289         Range *range = g_new(Range, 1);
290 
291         range_set_bounds(range, iova_ranges[i].start, iova_ranges[i].last);
292         bcontainer->iova_ranges =
293             range_list_insert(bcontainer->iova_ranges, range);
294     }
295     bcontainer->pgsizes = info->out_iova_alignment;
296 
297     g_free(info);
298     return 0;
299 
300 error:
301     ret = -errno;
302     g_free(info);
303     error_setg_errno(errp, errno, "Cannot get IOVA ranges");
304     return ret;
305 }
306 
307 static int iommufd_cdev_attach(const char *name, VFIODevice *vbasedev,
308                                AddressSpace *as, Error **errp)
309 {
310     VFIOContainerBase *bcontainer;
311     VFIOIOMMUFDContainer *container;
312     VFIOAddressSpace *space;
313     struct vfio_device_info dev_info = { .argsz = sizeof(dev_info) };
314     int ret, devfd;
315     uint32_t ioas_id;
316     Error *err = NULL;
317     const VFIOIOMMUClass *iommufd_vioc =
318         VFIO_IOMMU_CLASS(object_class_by_name(TYPE_VFIO_IOMMU_IOMMUFD));
319 
320     if (vbasedev->fd < 0) {
321         devfd = iommufd_cdev_getfd(vbasedev->sysfsdev, errp);
322         if (devfd < 0) {
323             return devfd;
324         }
325         vbasedev->fd = devfd;
326     } else {
327         devfd = vbasedev->fd;
328     }
329 
330     ret = iommufd_cdev_connect_and_bind(vbasedev, errp);
331     if (ret) {
332         goto err_connect_bind;
333     }
334 
335     space = vfio_get_address_space(as);
336 
337     /* try to attach to an existing container in this space */
338     QLIST_FOREACH(bcontainer, &space->containers, next) {
339         container = container_of(bcontainer, VFIOIOMMUFDContainer, bcontainer);
340         if (bcontainer->ops != iommufd_vioc ||
341             vbasedev->iommufd != container->be) {
342             continue;
343         }
344         if (iommufd_cdev_attach_container(vbasedev, container, &err)) {
345             const char *msg = error_get_pretty(err);
346 
347             trace_iommufd_cdev_fail_attach_existing_container(msg);
348             error_free(err);
349             err = NULL;
350         } else {
351             ret = iommufd_cdev_ram_block_discard_disable(true);
352             if (ret) {
353                 error_setg(errp,
354                               "Cannot set discarding of RAM broken (%d)", ret);
355                 goto err_discard_disable;
356             }
357             goto found_container;
358         }
359     }
360 
361     /* Need to allocate a new dedicated container */
362     ret = iommufd_backend_alloc_ioas(vbasedev->iommufd, &ioas_id, errp);
363     if (ret < 0) {
364         goto err_alloc_ioas;
365     }
366 
367     trace_iommufd_cdev_alloc_ioas(vbasedev->iommufd->fd, ioas_id);
368 
369     container = g_malloc0(sizeof(*container));
370     container->be = vbasedev->iommufd;
371     container->ioas_id = ioas_id;
372 
373     bcontainer = &container->bcontainer;
374     vfio_container_init(bcontainer, space, iommufd_vioc);
375     QLIST_INSERT_HEAD(&space->containers, bcontainer, next);
376 
377     ret = iommufd_cdev_attach_container(vbasedev, container, errp);
378     if (ret) {
379         goto err_attach_container;
380     }
381 
382     ret = iommufd_cdev_ram_block_discard_disable(true);
383     if (ret) {
384         goto err_discard_disable;
385     }
386 
387     ret = iommufd_cdev_get_info_iova_range(container, ioas_id, &err);
388     if (ret) {
389         error_append_hint(&err,
390                    "Fallback to default 64bit IOVA range and 4K page size\n");
391         warn_report_err(err);
392         err = NULL;
393         bcontainer->pgsizes = qemu_real_host_page_size();
394     }
395 
396     bcontainer->listener = vfio_memory_listener;
397     memory_listener_register(&bcontainer->listener, bcontainer->space->as);
398 
399     if (bcontainer->error) {
400         ret = -1;
401         error_propagate_prepend(errp, bcontainer->error,
402                                 "memory listener initialization failed: ");
403         goto err_listener_register;
404     }
405 
406     bcontainer->initialized = true;
407 
408 found_container:
409     ret = ioctl(devfd, VFIO_DEVICE_GET_INFO, &dev_info);
410     if (ret) {
411         error_setg_errno(errp, errno, "error getting device info");
412         goto err_listener_register;
413     }
414 
415     ret = vfio_cpr_register_container(bcontainer, errp);
416     if (ret) {
417         goto err_listener_register;
418     }
419 
420     /*
421      * TODO: examine RAM_BLOCK_DISCARD stuff, should we do group level
422      * for discarding incompatibility check as well?
423      */
424     if (vbasedev->ram_block_discard_allowed) {
425         iommufd_cdev_ram_block_discard_disable(false);
426     }
427 
428     vbasedev->group = 0;
429     vbasedev->num_irqs = dev_info.num_irqs;
430     vbasedev->num_regions = dev_info.num_regions;
431     vbasedev->flags = dev_info.flags;
432     vbasedev->reset_works = !!(dev_info.flags & VFIO_DEVICE_FLAGS_RESET);
433     vbasedev->bcontainer = bcontainer;
434     QLIST_INSERT_HEAD(&bcontainer->device_list, vbasedev, container_next);
435     QLIST_INSERT_HEAD(&vfio_device_list, vbasedev, global_next);
436 
437     trace_iommufd_cdev_device_info(vbasedev->name, devfd, vbasedev->num_irqs,
438                                    vbasedev->num_regions, vbasedev->flags);
439     return 0;
440 
441 err_listener_register:
442     iommufd_cdev_ram_block_discard_disable(false);
443 err_discard_disable:
444     iommufd_cdev_detach_container(vbasedev, container);
445 err_attach_container:
446     iommufd_cdev_container_destroy(container);
447 err_alloc_ioas:
448     vfio_put_address_space(space);
449     iommufd_cdev_unbind_and_disconnect(vbasedev);
450 err_connect_bind:
451     close(vbasedev->fd);
452     return ret;
453 }
454 
455 static void iommufd_cdev_detach(VFIODevice *vbasedev)
456 {
457     VFIOContainerBase *bcontainer = vbasedev->bcontainer;
458     VFIOAddressSpace *space = bcontainer->space;
459     VFIOIOMMUFDContainer *container = container_of(bcontainer,
460                                                    VFIOIOMMUFDContainer,
461                                                    bcontainer);
462     QLIST_REMOVE(vbasedev, global_next);
463     QLIST_REMOVE(vbasedev, container_next);
464     vbasedev->bcontainer = NULL;
465 
466     if (!vbasedev->ram_block_discard_allowed) {
467         iommufd_cdev_ram_block_discard_disable(false);
468     }
469 
470     vfio_cpr_unregister_container(bcontainer);
471     iommufd_cdev_detach_container(vbasedev, container);
472     iommufd_cdev_container_destroy(container);
473     vfio_put_address_space(space);
474 
475     iommufd_cdev_unbind_and_disconnect(vbasedev);
476     close(vbasedev->fd);
477 }
478 
479 static VFIODevice *iommufd_cdev_pci_find_by_devid(__u32 devid)
480 {
481     VFIODevice *vbasedev_iter;
482     const VFIOIOMMUClass *iommufd_vioc =
483         VFIO_IOMMU_CLASS(object_class_by_name(TYPE_VFIO_IOMMU_IOMMUFD));
484 
485     QLIST_FOREACH(vbasedev_iter, &vfio_device_list, global_next) {
486         if (vbasedev_iter->bcontainer->ops != iommufd_vioc) {
487             continue;
488         }
489         if (devid == vbasedev_iter->devid) {
490             return vbasedev_iter;
491         }
492     }
493     return NULL;
494 }
495 
496 static VFIOPCIDevice *
497 iommufd_cdev_dep_get_realized_vpdev(struct vfio_pci_dependent_device *dep_dev,
498                                     VFIODevice *reset_dev)
499 {
500     VFIODevice *vbasedev_tmp;
501 
502     if (dep_dev->devid == reset_dev->devid ||
503         dep_dev->devid == VFIO_PCI_DEVID_OWNED) {
504         return NULL;
505     }
506 
507     vbasedev_tmp = iommufd_cdev_pci_find_by_devid(dep_dev->devid);
508     if (!vbasedev_tmp || !vbasedev_tmp->dev->realized ||
509         vbasedev_tmp->type != VFIO_DEVICE_TYPE_PCI) {
510         return NULL;
511     }
512 
513     return container_of(vbasedev_tmp, VFIOPCIDevice, vbasedev);
514 }
515 
516 static int iommufd_cdev_pci_hot_reset(VFIODevice *vbasedev, bool single)
517 {
518     VFIOPCIDevice *vdev = container_of(vbasedev, VFIOPCIDevice, vbasedev);
519     struct vfio_pci_hot_reset_info *info = NULL;
520     struct vfio_pci_dependent_device *devices;
521     struct vfio_pci_hot_reset *reset;
522     int ret, i;
523     bool multi = false;
524 
525     trace_vfio_pci_hot_reset(vdev->vbasedev.name, single ? "one" : "multi");
526 
527     if (!single) {
528         vfio_pci_pre_reset(vdev);
529     }
530     vdev->vbasedev.needs_reset = false;
531 
532     ret = vfio_pci_get_pci_hot_reset_info(vdev, &info);
533 
534     if (ret) {
535         goto out_single;
536     }
537 
538     assert(info->flags & VFIO_PCI_HOT_RESET_FLAG_DEV_ID);
539 
540     devices = &info->devices[0];
541 
542     if (!(info->flags & VFIO_PCI_HOT_RESET_FLAG_DEV_ID_OWNED)) {
543         if (!vdev->has_pm_reset) {
544             for (i = 0; i < info->count; i++) {
545                 if (devices[i].devid == VFIO_PCI_DEVID_NOT_OWNED) {
546                     error_report("vfio: Cannot reset device %s, "
547                                  "depends on device %04x:%02x:%02x.%x "
548                                  "which is not owned.",
549                                  vdev->vbasedev.name, devices[i].segment,
550                                  devices[i].bus, PCI_SLOT(devices[i].devfn),
551                                  PCI_FUNC(devices[i].devfn));
552                 }
553             }
554         }
555         ret = -EPERM;
556         goto out_single;
557     }
558 
559     trace_vfio_pci_hot_reset_has_dep_devices(vdev->vbasedev.name);
560 
561     for (i = 0; i < info->count; i++) {
562         VFIOPCIDevice *tmp;
563 
564         trace_iommufd_cdev_pci_hot_reset_dep_devices(devices[i].segment,
565                                                      devices[i].bus,
566                                                      PCI_SLOT(devices[i].devfn),
567                                                      PCI_FUNC(devices[i].devfn),
568                                                      devices[i].devid);
569 
570         /*
571          * If a VFIO cdev device is resettable, all the dependent devices
572          * are either bound to same iommufd or within same iommu_groups as
573          * one of the iommufd bound devices.
574          */
575         assert(devices[i].devid != VFIO_PCI_DEVID_NOT_OWNED);
576 
577         tmp = iommufd_cdev_dep_get_realized_vpdev(&devices[i], &vdev->vbasedev);
578         if (!tmp) {
579             continue;
580         }
581 
582         if (single) {
583             ret = -EINVAL;
584             goto out_single;
585         }
586         vfio_pci_pre_reset(tmp);
587         tmp->vbasedev.needs_reset = false;
588         multi = true;
589     }
590 
591     if (!single && !multi) {
592         ret = -EINVAL;
593         goto out_single;
594     }
595 
596     /* Use zero length array for hot reset with iommufd backend */
597     reset = g_malloc0(sizeof(*reset));
598     reset->argsz = sizeof(*reset);
599 
600      /* Bus reset! */
601     ret = ioctl(vdev->vbasedev.fd, VFIO_DEVICE_PCI_HOT_RESET, reset);
602     g_free(reset);
603     if (ret) {
604         ret = -errno;
605     }
606 
607     trace_vfio_pci_hot_reset_result(vdev->vbasedev.name,
608                                     ret ? strerror(errno) : "Success");
609 
610     /* Re-enable INTx on affected devices */
611     for (i = 0; i < info->count; i++) {
612         VFIOPCIDevice *tmp;
613 
614         tmp = iommufd_cdev_dep_get_realized_vpdev(&devices[i], &vdev->vbasedev);
615         if (!tmp) {
616             continue;
617         }
618         vfio_pci_post_reset(tmp);
619     }
620 out_single:
621     if (!single) {
622         vfio_pci_post_reset(vdev);
623     }
624     g_free(info);
625 
626     return ret;
627 }
628 
629 static void vfio_iommu_iommufd_class_init(ObjectClass *klass, void *data)
630 {
631     VFIOIOMMUClass *vioc = VFIO_IOMMU_CLASS(klass);
632 
633     vioc->dma_map = iommufd_cdev_map;
634     vioc->dma_unmap = iommufd_cdev_unmap;
635     vioc->attach_device = iommufd_cdev_attach;
636     vioc->detach_device = iommufd_cdev_detach;
637     vioc->pci_hot_reset = iommufd_cdev_pci_hot_reset;
638 };
639 
640 static const TypeInfo types[] = {
641     {
642         .name = TYPE_VFIO_IOMMU_IOMMUFD,
643         .parent = TYPE_VFIO_IOMMU,
644         .class_init = vfio_iommu_iommufd_class_init,
645     },
646 };
647 
648 DEFINE_TYPES(types)
649