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
iommufd_backend_init(Object * obj)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
iommufd_backend_finalize(Object * obj)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
iommufd_backend_set_fd(Object * obj,const char * str,Error ** errp)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
iommufd_backend_can_be_deleted(UserCreatable * uc)60 static bool iommufd_backend_can_be_deleted(UserCreatable *uc)
61 {
62 IOMMUFDBackend *be = IOMMUFD_BACKEND(uc);
63
64 return !be->users;
65 }
66
iommufd_backend_class_init(ObjectClass * oc,void * data)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
iommufd_backend_connect(IOMMUFDBackend * be,Error ** errp)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
iommufd_backend_disconnect(IOMMUFDBackend * be)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
iommufd_backend_alloc_ioas(IOMMUFDBackend * be,uint32_t * ioas_id,Error ** errp)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
iommufd_backend_free_id(IOMMUFDBackend * be,uint32_t id)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
iommufd_backend_map_dma(IOMMUFDBackend * be,uint32_t ioas_id,hwaddr iova,ram_addr_t size,void * vaddr,bool readonly)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
iommufd_backend_unmap_dma(IOMMUFDBackend * be,uint32_t ioas_id,hwaddr iova,ram_addr_t size)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
iommufd_backend_alloc_hwpt(IOMMUFDBackend * be,uint32_t dev_id,uint32_t pt_id,uint32_t flags,uint32_t data_type,uint32_t data_len,void * data_ptr,uint32_t * out_hwpt,Error ** errp)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
iommufd_backend_set_dirty_tracking(IOMMUFDBackend * be,uint32_t hwpt_id,bool start,Error ** errp)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
iommufd_backend_get_dirty_bitmap(IOMMUFDBackend * be,uint32_t hwpt_id,uint64_t iova,ram_addr_t size,uint64_t page_size,uint64_t * data,Error ** errp)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
iommufd_backend_get_device_info(IOMMUFDBackend * be,uint32_t devid,uint32_t * type,void * data,uint32_t len,uint64_t * caps,Error ** errp)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
hiod_iommufd_get_cap(HostIOMMUDevice * hiod,int cap,Error ** errp)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
hiod_iommufd_class_init(ObjectClass * oc,void * data)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)
361