hw/vfio/iommufd.c

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