backends/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 "sysemu/iommufd.h"
  15 #include "qapi/error.h"
  16 #include "qemu/module.h"
  17 #include "qom/object_interfaces.h"
  18 #include "qemu/error-report.h"
  19 #include "monitor/monitor.h"
  20 #include "trace.h"
  21 #include <sys/ioctl.h>
  22 #include <linux/iommufd.h>
  23
  24 static void iommufd_backend_init(Object *obj)
  25 {
  26     IOMMUFDBackend *be = IOMMUFD_BACKEND(obj);
  27
  28     be->fd = -1;
  29     be->users = 0;
  30     be->owned = true;
  31 }
  32
  33 static void iommufd_backend_finalize(Object *obj)
  34 {
  35     IOMMUFDBackend *be = IOMMUFD_BACKEND(obj);
  36
  37     if (be->owned) {
  38         close(be->fd);
  39         be->fd = -1;
  40     }
  41 }
  42
  43 static void iommufd_backend_set_fd(Object *obj, const char *str, Error **errp)
  44 {
  45     ERRP_GUARD();
  46     IOMMUFDBackend *be = IOMMUFD_BACKEND(obj);
  47     int fd = -1;
  48
  49     fd = monitor_fd_param(monitor_cur(), str, errp);
  50     if (fd == -1) {
  51         error_prepend(errp, "Could not parse remote object fd %s:", str);
  52         return;
  53     }
  54     be->fd = fd;
  55     be->owned = false;
  56     trace_iommu_backend_set_fd(be->fd);
  57 }
  58
  59 static bool iommufd_backend_can_be_deleted(UserCreatable *uc)
  60 {
  61     IOMMUFDBackend *be = IOMMUFD_BACKEND(uc);
  62
  63     return !be->users;
  64 }
  65
  66 static void iommufd_backend_class_init(ObjectClass *oc, void *data)
  67 {
  68     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
  69
  70     ucc->can_be_deleted = iommufd_backend_can_be_deleted;
  71
  72     object_class_property_add_str(oc, "fd", NULL, iommufd_backend_set_fd);
  73 }
  74
  75 bool iommufd_backend_connect(IOMMUFDBackend *be, Error **errp)
  76 {
  77     int fd;
  78
  79     if (be->owned && !be->users) {
  80         fd = qemu_open_old("/dev/iommu", O_RDWR);
  81         if (fd < 0) {
  82             error_setg_errno(errp, errno, "/dev/iommu opening failed");
  83             return false;
  84         }
  85         be->fd = fd;
  86     }
  87     be->users++;
  88
  89     trace_iommufd_backend_connect(be->fd, be->owned, be->users);
  90     return true;
  91 }
  92
  93 void iommufd_backend_disconnect(IOMMUFDBackend *be)
  94 {
  95     if (!be->users) {
  96         goto out;
  97     }
  98     be->users--;
  99     if (!be->users && be->owned) {
 100         close(be->fd);
 101         be->fd = -1;
 102     }
 103 out:
 104     trace_iommufd_backend_disconnect(be->fd, be->users);
 105 }
 106
 107 bool iommufd_backend_alloc_ioas(IOMMUFDBackend *be, uint32_t *ioas_id,
 108                                 Error **errp)
 109 {
 110     int fd = be->fd;
 111     struct iommu_ioas_alloc alloc_data  = {
 112         .size = sizeof(alloc_data),
 113         .flags = 0,
 114     };
 115
 116     if (ioctl(fd, IOMMU_IOAS_ALLOC, &alloc_data)) {
 117         error_setg_errno(errp, errno, "Failed to allocate ioas");
 118         return false;
 119     }
 120
 121     *ioas_id = alloc_data.out_ioas_id;
 122     trace_iommufd_backend_alloc_ioas(fd, *ioas_id);
 123
 124     return true;
 125 }
 126
 127 void iommufd_backend_free_id(IOMMUFDBackend *be, uint32_t id)
 128 {
 129     int ret, fd = be->fd;
 130     struct iommu_destroy des = {
 131         .size = sizeof(des),
 132         .id = id,
 133     };
 134
 135     ret = ioctl(fd, IOMMU_DESTROY, &des);
 136     trace_iommufd_backend_free_id(fd, id, ret);
 137     if (ret) {
 138         error_report("Failed to free id: %u %m", id);
 139     }
 140 }
 141
 142 int iommufd_backend_map_dma(IOMMUFDBackend *be, uint32_t ioas_id, hwaddr iova,
 143                             ram_addr_t size, void *vaddr, bool readonly)
 144 {
 145     int ret, fd = be->fd;
 146     struct iommu_ioas_map map = {
 147         .size = sizeof(map),
 148         .flags = IOMMU_IOAS_MAP_READABLE |
 149                  IOMMU_IOAS_MAP_FIXED_IOVA,
 150         .ioas_id = ioas_id,
 151         .__reserved = 0,
 152         .user_va = (uintptr_t)vaddr,
 153         .iova = iova,
 154         .length = size,
 155     };
 156
 157     if (!readonly) {
 158         map.flags |= IOMMU_IOAS_MAP_WRITEABLE;
 159     }
 160
 161     ret = ioctl(fd, IOMMU_IOAS_MAP, &map);
 162     trace_iommufd_backend_map_dma(fd, ioas_id, iova, size,
 163                                   vaddr, readonly, ret);
 164     if (ret) {
 165         ret = -errno;
 166
 167         /* TODO: Not support mapping hardware PCI BAR region for now. */
 168         if (errno == EFAULT) {
 169             warn_report("IOMMU_IOAS_MAP failed: %m, PCI BAR?");
 170         } else {
 171             error_report("IOMMU_IOAS_MAP failed: %m");
 172         }
 173     }
 174     return ret;
 175 }
 176
 177 int iommufd_backend_unmap_dma(IOMMUFDBackend *be, uint32_t ioas_id,
 178                               hwaddr iova, ram_addr_t size)
 179 {
 180     int ret, fd = be->fd;
 181     struct iommu_ioas_unmap unmap = {
 182         .size = sizeof(unmap),
 183         .ioas_id = ioas_id,
 184         .iova = iova,
 185         .length = size,
 186     };
 187
 188     ret = ioctl(fd, IOMMU_IOAS_UNMAP, &unmap);
 189     /*
 190      * IOMMUFD takes mapping as some kind of object, unmapping
 191      * nonexistent mapping is treated as deleting a nonexistent
 192      * object and return ENOENT. This is different from legacy
 193      * backend which allows it. vIOMMU may trigger a lot of
 194      * redundant unmapping, to avoid flush the log, treat them
 195      * as succeess for IOMMUFD just like legacy backend.
 196      */
 197     if (ret && errno == ENOENT) {
 198         trace_iommufd_backend_unmap_dma_non_exist(fd, ioas_id, iova, size, ret);
 199         ret = 0;
 200     } else {
 201         trace_iommufd_backend_unmap_dma(fd, ioas_id, iova, size, ret);
 202     }
 203
 204     if (ret) {
 205         ret = -errno;
 206         error_report("IOMMU_IOAS_UNMAP failed: %m");
 207     }
 208     return ret;
 209 }
 210
 211 static const TypeInfo iommufd_backend_info = {
 212     .name = TYPE_IOMMUFD_BACKEND,
 213     .parent = TYPE_OBJECT,
 214     .instance_size = sizeof(IOMMUFDBackend),
 215     .instance_init = iommufd_backend_init,
 216     .instance_finalize = iommufd_backend_finalize,
 217     .class_size = sizeof(IOMMUFDBackendClass),
 218     .class_init = iommufd_backend_class_init,
 219     .interfaces = (InterfaceInfo[]) {
 220         { TYPE_USER_CREATABLE },
 221         { }
 222     }
 223 };
 224
 225 static void register_types(void)
 226 {
 227     type_register_static(&iommufd_backend_info);
 228 }
 229
 230 type_init(register_types);