1/* SPDX-License-Identifier: GPL-2.0-only */
2/*
3 * Copyright (C) 2012 Red Hat, Inc. All rights reserved.
4 * Author: Alex Williamson <alex.williamson@redhat.com>
5 */
6#ifndef __VFIO_VFIO_H__
7#define __VFIO_VFIO_H__
8
9#include <linux/file.h>
10#include <linux/device.h>
11#include <linux/cdev.h>
12#include <linux/module.h>
13#include <linux/vfio.h>
14
15struct iommufd_ctx;
16struct iommu_group;
17struct vfio_container;
18
19struct vfio_device_file {
20 struct vfio_device *device;
21 struct vfio_group *group;
22
23 u8 access_granted;
24 u32 devid; /* only valid when iommufd is valid */
25 spinlock_t kvm_ref_lock; /* protect kvm field */
26 struct kvm *kvm;
27 struct iommufd_ctx *iommufd; /* protected by struct vfio_device_set::lock */
28};
29
30void vfio_device_put_registration(struct vfio_device *device);
31bool vfio_device_try_get_registration(struct vfio_device *device);
32int vfio_df_open(struct vfio_device_file *df);
33void vfio_df_close(struct vfio_device_file *df);
34struct vfio_device_file *
35vfio_allocate_device_file(struct vfio_device *device);
36
37extern const struct file_operations vfio_device_fops;
38
39#ifdef CONFIG_VFIO_NOIOMMU
40extern bool vfio_noiommu __read_mostly;
41#else
42enum { vfio_noiommu = false };
43#endif
44
45enum vfio_group_type {
46 /*
47 * Physical device with IOMMU backing.
48 */
49 VFIO_IOMMU,
50
51 /*
52 * Virtual device without IOMMU backing. The VFIO core fakes up an
53 * iommu_group as the iommu_group sysfs interface is part of the
54 * userspace ABI. The user of these devices must not be able to
55 * directly trigger unmediated DMA.
56 */
57 VFIO_EMULATED_IOMMU,
58
59 /*
60 * Physical device without IOMMU backing. The VFIO core fakes up an
61 * iommu_group as the iommu_group sysfs interface is part of the
62 * userspace ABI. Users can trigger unmediated DMA by the device,
63 * usage is highly dangerous, requires an explicit opt-in and will
64 * taint the kernel.
65 */
66 VFIO_NO_IOMMU,
67};
68
69#if IS_ENABLED(CONFIG_VFIO_GROUP)
70struct vfio_group {
71 struct device dev;
72 struct cdev cdev;
73 /*
74 * When drivers is non-zero a driver is attached to the struct device
75 * that provided the iommu_group and thus the iommu_group is a valid
76 * pointer. When drivers is 0 the driver is being detached. Once users
77 * reaches 0 then the iommu_group is invalid.
78 */
79 refcount_t drivers;
80 unsigned int container_users;
81 struct iommu_group *iommu_group;
82 struct vfio_container *container;
83 struct list_head device_list;
84 struct mutex device_lock;
85 struct list_head vfio_next;
86#if IS_ENABLED(CONFIG_VFIO_CONTAINER)
87 struct list_head container_next;
88#endif
89 enum vfio_group_type type;
90 struct mutex group_lock;
91 struct kvm *kvm;
92 struct file *opened_file;
93 struct blocking_notifier_head notifier;
94 struct iommufd_ctx *iommufd;
95 spinlock_t kvm_ref_lock;
96 unsigned int cdev_device_open_cnt;
97};
98
99int vfio_device_block_group(struct vfio_device *device);
100void vfio_device_unblock_group(struct vfio_device *device);
101int vfio_device_set_group(struct vfio_device *device,
102 enum vfio_group_type type);
103void vfio_device_remove_group(struct vfio_device *device);
104void vfio_device_group_register(struct vfio_device *device);
105void vfio_device_group_unregister(struct vfio_device *device);
106int vfio_device_group_use_iommu(struct vfio_device *device);
107void vfio_device_group_unuse_iommu(struct vfio_device *device);
108void vfio_df_group_close(struct vfio_device_file *df);
109struct vfio_group *vfio_group_from_file(struct file *file);
110bool vfio_group_enforced_coherent(struct vfio_group *group);
111void vfio_group_set_kvm(struct vfio_group *group, struct kvm *kvm);
112bool vfio_device_has_container(struct vfio_device *device);
113int __init vfio_group_init(void);
114void vfio_group_cleanup(void);
115
116static inline bool vfio_device_is_noiommu(struct vfio_device *vdev)
117{
118 return IS_ENABLED(CONFIG_VFIO_NOIOMMU) &&
119 vdev->group->type == VFIO_NO_IOMMU;
120}
121#else
122struct vfio_group;
123
124static inline int vfio_device_block_group(struct vfio_device *device)
125{
126 return 0;
127}
128
129static inline void vfio_device_unblock_group(struct vfio_device *device)
130{
131}
132
133static inline int vfio_device_set_group(struct vfio_device *device,
134 enum vfio_group_type type)
135{
136 return 0;
137}
138
139static inline void vfio_device_remove_group(struct vfio_device *device)
140{
141}
142
143static inline void vfio_device_group_register(struct vfio_device *device)
144{
145}
146
147static inline void vfio_device_group_unregister(struct vfio_device *device)
148{
149}
150
151static inline int vfio_device_group_use_iommu(struct vfio_device *device)
152{
153 return -EOPNOTSUPP;
154}
155
156static inline void vfio_device_group_unuse_iommu(struct vfio_device *device)
157{
158}
159
160static inline void vfio_df_group_close(struct vfio_device_file *df)
161{
162}
163
164static inline struct vfio_group *vfio_group_from_file(struct file *file)
165{
166 return NULL;
167}
168
169static inline bool vfio_group_enforced_coherent(struct vfio_group *group)
170{
171 return true;
172}
173
174static inline void vfio_group_set_kvm(struct vfio_group *group, struct kvm *kvm)
175{
176}
177
178static inline bool vfio_device_has_container(struct vfio_device *device)
179{
180 return false;
181}
182
183static inline int __init vfio_group_init(void)
184{
185 return 0;
186}
187
188static inline void vfio_group_cleanup(void)
189{
190}
191
192static inline bool vfio_device_is_noiommu(struct vfio_device *vdev)
193{
194 return false;
195}
196#endif /* CONFIG_VFIO_GROUP */
197
198#if IS_ENABLED(CONFIG_VFIO_CONTAINER)
199/**
200 * struct vfio_iommu_driver_ops - VFIO IOMMU driver callbacks
201 */
202struct vfio_iommu_driver_ops {
203 char *name;
204 struct module *owner;
205 void *(*open)(unsigned long arg);
206 void (*release)(void *iommu_data);
207 long (*ioctl)(void *iommu_data, unsigned int cmd,
208 unsigned long arg);
209 int (*attach_group)(void *iommu_data,
210 struct iommu_group *group,
211 enum vfio_group_type);
212 void (*detach_group)(void *iommu_data,
213 struct iommu_group *group);
214 int (*pin_pages)(void *iommu_data,
215 struct iommu_group *group,
216 dma_addr_t user_iova,
217 int npage, int prot,
218 struct page **pages);
219 void (*unpin_pages)(void *iommu_data,
220 dma_addr_t user_iova, int npage);
221 void (*register_device)(void *iommu_data,
222 struct vfio_device *vdev);
223 void (*unregister_device)(void *iommu_data,
224 struct vfio_device *vdev);
225 int (*dma_rw)(void *iommu_data, dma_addr_t user_iova,
226 void *data, size_t count, bool write);
227 struct iommu_domain *(*group_iommu_domain)(void *iommu_data,
228 struct iommu_group *group);
229};
230
231struct vfio_iommu_driver {
232 const struct vfio_iommu_driver_ops *ops;
233 struct list_head vfio_next;
234};
235
236int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops);
237void vfio_unregister_iommu_driver(const struct vfio_iommu_driver_ops *ops);
238
239struct vfio_container *vfio_container_from_file(struct file *filep);
240int vfio_group_use_container(struct vfio_group *group);
241void vfio_group_unuse_container(struct vfio_group *group);
242int vfio_container_attach_group(struct vfio_container *container,
243 struct vfio_group *group);
244void vfio_group_detach_container(struct vfio_group *group);
245void vfio_device_container_register(struct vfio_device *device);
246void vfio_device_container_unregister(struct vfio_device *device);
247int vfio_device_container_pin_pages(struct vfio_device *device,
248 dma_addr_t iova, int npage,
249 int prot, struct page **pages);
250void vfio_device_container_unpin_pages(struct vfio_device *device,
251 dma_addr_t iova, int npage);
252int vfio_device_container_dma_rw(struct vfio_device *device,
253 dma_addr_t iova, void *data,
254 size_t len, bool write);
255
256int __init vfio_container_init(void);
257void vfio_container_cleanup(void);
258#else
259static inline struct vfio_container *
260vfio_container_from_file(struct file *filep)
261{
262 return NULL;
263}
264
265static inline int vfio_group_use_container(struct vfio_group *group)
266{
267 return -EOPNOTSUPP;
268}
269
270static inline void vfio_group_unuse_container(struct vfio_group *group)
271{
272}
273
274static inline int vfio_container_attach_group(struct vfio_container *container,
275 struct vfio_group *group)
276{
277 return -EOPNOTSUPP;
278}
279
280static inline void vfio_group_detach_container(struct vfio_group *group)
281{
282}
283
284static inline void vfio_device_container_register(struct vfio_device *device)
285{
286}
287
288static inline void vfio_device_container_unregister(struct vfio_device *device)
289{
290}
291
292static inline int vfio_device_container_pin_pages(struct vfio_device *device,
293 dma_addr_t iova, int npage,
294 int prot, struct page **pages)
295{
296 return -EOPNOTSUPP;
297}
298
299static inline void vfio_device_container_unpin_pages(struct vfio_device *device,
300 dma_addr_t iova, int npage)
301{
302}
303
304static inline int vfio_device_container_dma_rw(struct vfio_device *device,
305 dma_addr_t iova, void *data,
306 size_t len, bool write)
307{
308 return -EOPNOTSUPP;
309}
310
311static inline int vfio_container_init(void)
312{
313 return 0;
314}
315static inline void vfio_container_cleanup(void)
316{
317}
318#endif
319
320#if IS_ENABLED(CONFIG_IOMMUFD)
321bool vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev,
322 struct iommufd_ctx *ictx);
323int vfio_df_iommufd_bind(struct vfio_device_file *df);
324void vfio_df_iommufd_unbind(struct vfio_device_file *df);
325int vfio_iommufd_compat_attach_ioas(struct vfio_device *device,
326 struct iommufd_ctx *ictx);
327#else
328static inline bool
329vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev,
330 struct iommufd_ctx *ictx)
331{
332 return false;
333}
334
335static inline int vfio_df_iommufd_bind(struct vfio_device_file *fd)
336{
337 return -EOPNOTSUPP;
338}
339
340static inline void vfio_df_iommufd_unbind(struct vfio_device_file *df)
341{
342}
343
344static inline int
345vfio_iommufd_compat_attach_ioas(struct vfio_device *device,
346 struct iommufd_ctx *ictx)
347{
348 return -EOPNOTSUPP;
349}
350#endif
351
352int vfio_df_ioctl_attach_pt(struct vfio_device_file *df,
353 struct vfio_device_attach_iommufd_pt __user *arg);
354int vfio_df_ioctl_detach_pt(struct vfio_device_file *df,
355 struct vfio_device_detach_iommufd_pt __user *arg);
356
357#if IS_ENABLED(CONFIG_VFIO_DEVICE_CDEV)
358void vfio_init_device_cdev(struct vfio_device *device);
359
360static inline int vfio_device_add(struct vfio_device *device)
361{
362 /* cdev does not support noiommu device */
363 if (vfio_device_is_noiommu(vdev: device))
364 return device_add(dev: &device->device);
365 vfio_init_device_cdev(device);
366 return cdev_device_add(cdev: &device->cdev, dev: &device->device);
367}
368
369static inline void vfio_device_del(struct vfio_device *device)
370{
371 if (vfio_device_is_noiommu(vdev: device))
372 device_del(dev: &device->device);
373 else
374 cdev_device_del(cdev: &device->cdev, dev: &device->device);
375}
376
377int vfio_device_fops_cdev_open(struct inode *inode, struct file *filep);
378long vfio_df_ioctl_bind_iommufd(struct vfio_device_file *df,
379 struct vfio_device_bind_iommufd __user *arg);
380void vfio_df_unbind_iommufd(struct vfio_device_file *df);
381int vfio_cdev_init(struct class *device_class);
382void vfio_cdev_cleanup(void);
383#else
384static inline void vfio_init_device_cdev(struct vfio_device *device)
385{
386}
387
388static inline int vfio_device_add(struct vfio_device *device)
389{
390 return device_add(&device->device);
391}
392
393static inline void vfio_device_del(struct vfio_device *device)
394{
395 device_del(&device->device);
396}
397
398static inline int vfio_device_fops_cdev_open(struct inode *inode,
399 struct file *filep)
400{
401 return 0;
402}
403
404static inline long vfio_df_ioctl_bind_iommufd(struct vfio_device_file *df,
405 struct vfio_device_bind_iommufd __user *arg)
406{
407 return -ENOTTY;
408}
409
410static inline void vfio_df_unbind_iommufd(struct vfio_device_file *df)
411{
412}
413
414static inline int vfio_cdev_init(struct class *device_class)
415{
416 return 0;
417}
418
419static inline void vfio_cdev_cleanup(void)
420{
421}
422#endif /* CONFIG_VFIO_DEVICE_CDEV */
423
424#if IS_ENABLED(CONFIG_VFIO_VIRQFD)
425int __init vfio_virqfd_init(void);
426void vfio_virqfd_exit(void);
427#else
428static inline int __init vfio_virqfd_init(void)
429{
430 return 0;
431}
432static inline void vfio_virqfd_exit(void)
433{
434}
435#endif
436
437#if IS_ENABLED(CONFIG_KVM)
438void vfio_device_get_kvm_safe(struct vfio_device *device, struct kvm *kvm);
439void vfio_device_put_kvm(struct vfio_device *device);
440#else
441static inline void vfio_device_get_kvm_safe(struct vfio_device *device,
442 struct kvm *kvm)
443{
444}
445
446static inline void vfio_device_put_kvm(struct vfio_device *device)
447{
448}
449#endif
450
451#ifdef CONFIG_VFIO_DEBUGFS
452void vfio_debugfs_create_root(void);
453void vfio_debugfs_remove_root(void);
454
455void vfio_device_debugfs_init(struct vfio_device *vdev);
456void vfio_device_debugfs_exit(struct vfio_device *vdev);
457#else
458static inline void vfio_debugfs_create_root(void) { }
459static inline void vfio_debugfs_remove_root(void) { }
460
461static inline void vfio_device_debugfs_init(struct vfio_device *vdev) { }
462static inline void vfio_device_debugfs_exit(struct vfio_device *vdev) { }
463#endif /* CONFIG_VFIO_DEBUGFS */
464
465#endif
466

source code of linux/drivers/vfio/vfio.h