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 "hw/vfio/vfio-common.h"
  22 #include <sys/ioctl.h>
  23 #include <linux/iommufd.h>
  24
  25 static void iommufd_backend_init(Object *obj)
  26 {
  27     IOMMUFDBackend *be = IOMMUFD_BACKEND(obj);
  28
  29     be->fd = -1;
  30     be->users = 0;
  31     be->owned = true;
  32 }
  33
  34 static void iommufd_backend_finalize(Object *obj)
  35 {
  36     IOMMUFDBackend *be = IOMMUFD_BACKEND(obj);
  37
  38     if (be->owned) {
  39         close(be->fd);
  40         be->fd = -1;
  41     }
  42 }
  43
  44 static void iommufd_backend_set_fd(Object *obj, const char *str, Error **errp)
  45 {
  46     ERRP_GUARD();
  47     IOMMUFDBackend *be = IOMMUFD_BACKEND(obj);
  48     int fd = -1;
  49
  50     fd = monitor_fd_param(monitor_cur(), str, errp);
  51     if (fd == -1) {
  52         error_prepend(errp, "Could not parse remote object fd %s:", str);
  53         return;
  54     }
  55     be->fd = fd;
  56     be->owned = false;
  57     trace_iommu_backend_set_fd(be->fd);
  58 }
  59
  60 static bool iommufd_backend_can_be_deleted(UserCreatable *uc)
  61 {
  62     IOMMUFDBackend *be = IOMMUFD_BACKEND(uc);
  63
  64     return !be->users;
  65 }
  66
  67 static void iommufd_backend_class_init(ObjectClass *oc, void *data)
  68 {
  69     UserCreatableClass *ucc = USER_CREATABLE_CLASS(oc);
  70
  71     ucc->can_be_deleted = iommufd_backend_can_be_deleted;
  72
  73     object_class_property_add_str(oc, "fd", NULL, iommufd_backend_set_fd);
  74 }
  75
  76 bool iommufd_backend_connect(IOMMUFDBackend *be, Error **errp)
  77 {
  78     int fd;
  79
  80     if (be->owned && !be->users) {
  81         fd = qemu_open("/dev/iommu", O_RDWR, errp);
  82         if (fd < 0) {
  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 bool iommufd_backend_alloc_hwpt(IOMMUFDBackend *be, uint32_t dev_id,
 212                                 uint32_t pt_id, uint32_t flags,
 213                                 uint32_t data_type, uint32_t data_len,
 214                                 void *data_ptr, uint32_t *out_hwpt,
 215                                 Error **errp)
 216 {
 217     int ret, fd = be->fd;
 218     struct iommu_hwpt_alloc alloc_hwpt = {
 219         .size = sizeof(struct iommu_hwpt_alloc),
 220         .flags = flags,
 221         .dev_id = dev_id,
 222         .pt_id = pt_id,
 223         .data_type = data_type,
 224         .data_len = data_len,
 225         .data_uptr = (uintptr_t)data_ptr,
 226     };
 227
 228     ret = ioctl(fd, IOMMU_HWPT_ALLOC, &alloc_hwpt);
 229     trace_iommufd_backend_alloc_hwpt(fd, dev_id, pt_id, flags, data_type,
 230                                      data_len, (uintptr_t)data_ptr,
 231                                      alloc_hwpt.out_hwpt_id, ret);
 232     if (ret) {
 233         error_setg_errno(errp, errno, "Failed to allocate hwpt");
 234         return false;
 235     }
 236
 237     *out_hwpt = alloc_hwpt.out_hwpt_id;
 238     return true;
 239 }
 240
 241 bool iommufd_backend_set_dirty_tracking(IOMMUFDBackend *be,
 242                                         uint32_t hwpt_id, bool start,
 243                                         Error **errp)
 244 {
 245     int ret;
 246     struct iommu_hwpt_set_dirty_tracking set_dirty = {
 247             .size = sizeof(set_dirty),
 248             .hwpt_id = hwpt_id,
 249             .flags = start ? IOMMU_HWPT_DIRTY_TRACKING_ENABLE : 0,
 250     };
 251
 252     ret = ioctl(be->fd, IOMMU_HWPT_SET_DIRTY_TRACKING, &set_dirty);
 253     trace_iommufd_backend_set_dirty(be->fd, hwpt_id, start, ret ? errno : 0);
 254     if (ret) {
 255         error_setg_errno(errp, errno,
 256                          "IOMMU_HWPT_SET_DIRTY_TRACKING(hwpt_id %u) failed",
 257                          hwpt_id);
 258         return false;
 259     }
 260
 261     return true;
 262 }
 263
 264 bool iommufd_backend_get_dirty_bitmap(IOMMUFDBackend *be,
 265                                       uint32_t hwpt_id,
 266                                       uint64_t iova, ram_addr_t size,
 267                                       uint64_t page_size, uint64_t *data,
 268                                       Error **errp)
 269 {
 270     int ret;
 271     struct iommu_hwpt_get_dirty_bitmap get_dirty_bitmap = {
 272         .size = sizeof(get_dirty_bitmap),
 273         .hwpt_id = hwpt_id,
 274         .iova = iova,
 275         .length = size,
 276         .page_size = page_size,
 277         .data = (uintptr_t)data,
 278     };
 279
 280     ret = ioctl(be->fd, IOMMU_HWPT_GET_DIRTY_BITMAP, &get_dirty_bitmap);
 281     trace_iommufd_backend_get_dirty_bitmap(be->fd, hwpt_id, iova, size,
 282                                            page_size, ret ? errno : 0);
 283     if (ret) {
 284         error_setg_errno(errp, errno,
 285                          "IOMMU_HWPT_GET_DIRTY_BITMAP (iova: 0x%"HWADDR_PRIx
 286                          " size: 0x"RAM_ADDR_FMT") failed", iova, size);
 287         return false;
 288     }
 289
 290     return true;
 291 }
 292
 293 bool iommufd_backend_get_device_info(IOMMUFDBackend *be, uint32_t devid,
 294                                      uint32_t *type, void *data, uint32_t len,
 295                                      uint64_t *caps, Error **errp)
 296 {
 297     struct iommu_hw_info info = {
 298         .size = sizeof(info),
 299         .dev_id = devid,
 300         .data_len = len,
 301         .data_uptr = (uintptr_t)data,
 302     };
 303
 304     if (ioctl(be->fd, IOMMU_GET_HW_INFO, &info)) {
 305         error_setg_errno(errp, errno, "Failed to get hardware info");
 306         return false;
 307     }
 308
 309     g_assert(type);
 310     *type = info.out_data_type;
 311     g_assert(caps);
 312     *caps = info.out_capabilities;
 313
 314     return true;
 315 }
 316
 317 static int hiod_iommufd_get_cap(HostIOMMUDevice *hiod, int cap, Error **errp)
 318 {
 319     HostIOMMUDeviceCaps *caps = &hiod->caps;
 320
 321     switch (cap) {
 322     case HOST_IOMMU_DEVICE_CAP_IOMMU_TYPE:
 323         return caps->type;
 324     case HOST_IOMMU_DEVICE_CAP_AW_BITS:
 325         return vfio_device_get_aw_bits(hiod->agent);
 326     default:
 327         error_setg(errp, "%s: unsupported capability %x", hiod->name, cap);
 328         return -EINVAL;
 329     }
 330 }
 331
 332 static void hiod_iommufd_class_init(ObjectClass *oc, void *data)
 333 {
 334     HostIOMMUDeviceClass *hioc = HOST_IOMMU_DEVICE_CLASS(oc);
 335
 336     hioc->get_cap = hiod_iommufd_get_cap;
 337 };
 338
 339 static const TypeInfo types[] = {
 340     {
 341         .name = TYPE_IOMMUFD_BACKEND,
 342         .parent = TYPE_OBJECT,
 343         .instance_size = sizeof(IOMMUFDBackend),
 344         .instance_init = iommufd_backend_init,
 345         .instance_finalize = iommufd_backend_finalize,
 346         .class_size = sizeof(IOMMUFDBackendClass),
 347         .class_init = iommufd_backend_class_init,
 348         .interfaces = (InterfaceInfo[]) {
 349             { TYPE_USER_CREATABLE },
 350             { }
 351         }
 352     }, {
 353         .name = TYPE_HOST_IOMMU_DEVICE_IOMMUFD,
 354         .parent = TYPE_HOST_IOMMU_DEVICE,
 355         .class_init = hiod_iommufd_class_init,
 356         .abstract = true,
 357     }
 358 };
 359
 360 DEFINE_TYPES(types)