Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 iommufd_ctx *iommufd;
94 spinlock_t kvm_ref_lock;
95 unsigned int cdev_device_open_cnt;
96};
97
98int vfio_device_block_group(struct vfio_device *device);
99void vfio_device_unblock_group(struct vfio_device *device);
100int vfio_device_set_group(struct vfio_device *device,
101 enum vfio_group_type type);
102void vfio_device_remove_group(struct vfio_device *device);
103void vfio_device_group_register(struct vfio_device *device);
104void vfio_device_group_unregister(struct vfio_device *device);
105int vfio_device_group_use_iommu(struct vfio_device *device);
106void vfio_device_group_unuse_iommu(struct vfio_device *device);
107void vfio_df_group_close(struct vfio_device_file *df);
108struct vfio_group *vfio_group_from_file(struct file *file);
109bool vfio_group_enforced_coherent(struct vfio_group *group);
110void vfio_group_set_kvm(struct vfio_group *group, struct kvm *kvm);
111bool vfio_device_has_container(struct vfio_device *device);
112int __init vfio_group_init(void);
113void vfio_group_cleanup(void);
114
115static inline bool vfio_device_is_noiommu(struct vfio_device *vdev)
116{
117 return IS_ENABLED(CONFIG_VFIO_NOIOMMU) &&
118 vdev->group->type == VFIO_NO_IOMMU;
119}
120#else
121struct vfio_group;
122
123static inline int vfio_device_block_group(struct vfio_device *device)
124{
125 return 0;
126}
127
128static inline void vfio_device_unblock_group(struct vfio_device *device)
129{
130}
131
132static inline int vfio_device_set_group(struct vfio_device *device,
133 enum vfio_group_type type)
134{
135 return 0;
136}
137
138static inline void vfio_device_remove_group(struct vfio_device *device)
139{
140}
141
142static inline void vfio_device_group_register(struct vfio_device *device)
143{
144}
145
146static inline void vfio_device_group_unregister(struct vfio_device *device)
147{
148}
149
150static inline int vfio_device_group_use_iommu(struct vfio_device *device)
151{
152 return -EOPNOTSUPP;
153}
154
155static inline void vfio_device_group_unuse_iommu(struct vfio_device *device)
156{
157}
158
159static inline void vfio_df_group_close(struct vfio_device_file *df)
160{
161}
162
163static inline struct vfio_group *vfio_group_from_file(struct file *file)
164{
165 return NULL;
166}
167
168static inline bool vfio_group_enforced_coherent(struct vfio_group *group)
169{
170 return true;
171}
172
173static inline void vfio_group_set_kvm(struct vfio_group *group, struct kvm *kvm)
174{
175}
176
177static inline bool vfio_device_has_container(struct vfio_device *device)
178{
179 return false;
180}
181
182static inline int __init vfio_group_init(void)
183{
184 return 0;
185}
186
187static inline void vfio_group_cleanup(void)
188{
189}
190
191static inline bool vfio_device_is_noiommu(struct vfio_device *vdev)
192{
193 return false;
194}
195#endif /* CONFIG_VFIO_GROUP */
196
197#if IS_ENABLED(CONFIG_VFIO_CONTAINER)
198/**
199 * struct vfio_iommu_driver_ops - VFIO IOMMU driver callbacks
200 */
201struct vfio_iommu_driver_ops {
202 char *name;
203 struct module *owner;
204 void *(*open)(unsigned long arg);
205 void (*release)(void *iommu_data);
206 long (*ioctl)(void *iommu_data, unsigned int cmd,
207 unsigned long arg);
208 int (*attach_group)(void *iommu_data,
209 struct iommu_group *group,
210 enum vfio_group_type);
211 void (*detach_group)(void *iommu_data,
212 struct iommu_group *group);
213 int (*pin_pages)(void *iommu_data,
214 struct iommu_group *group,
215 dma_addr_t user_iova,
216 int npage, int prot,
217 struct page **pages);
218 void (*unpin_pages)(void *iommu_data,
219 dma_addr_t user_iova, int npage);
220 void (*register_device)(void *iommu_data,
221 struct vfio_device *vdev);
222 void (*unregister_device)(void *iommu_data,
223 struct vfio_device *vdev);
224 int (*dma_rw)(void *iommu_data, dma_addr_t user_iova,
225 void *data, size_t count, bool write);
226 struct iommu_domain *(*group_iommu_domain)(void *iommu_data,
227 struct iommu_group *group);
228};
229
230struct vfio_iommu_driver {
231 const struct vfio_iommu_driver_ops *ops;
232 struct list_head vfio_next;
233};
234
235int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops);
236void vfio_unregister_iommu_driver(const struct vfio_iommu_driver_ops *ops);
237
238struct vfio_container *vfio_container_from_file(struct file *filep);
239int vfio_group_use_container(struct vfio_group *group);
240void vfio_group_unuse_container(struct vfio_group *group);
241int vfio_container_attach_group(struct vfio_container *container,
242 struct vfio_group *group);
243void vfio_group_detach_container(struct vfio_group *group);
244void vfio_device_container_register(struct vfio_device *device);
245void vfio_device_container_unregister(struct vfio_device *device);
246int vfio_device_container_pin_pages(struct vfio_device *device,
247 dma_addr_t iova, int npage,
248 int prot, struct page **pages);
249void vfio_device_container_unpin_pages(struct vfio_device *device,
250 dma_addr_t iova, int npage);
251int vfio_device_container_dma_rw(struct vfio_device *device,
252 dma_addr_t iova, void *data,
253 size_t len, bool write);
254
255int __init vfio_container_init(void);
256void vfio_container_cleanup(void);
257#else
258static inline struct vfio_container *
259vfio_container_from_file(struct file *filep)
260{
261 return NULL;
262}
263
264static inline int vfio_group_use_container(struct vfio_group *group)
265{
266 return -EOPNOTSUPP;
267}
268
269static inline void vfio_group_unuse_container(struct vfio_group *group)
270{
271}
272
273static inline int vfio_container_attach_group(struct vfio_container *container,
274 struct vfio_group *group)
275{
276 return -EOPNOTSUPP;
277}
278
279static inline void vfio_group_detach_container(struct vfio_group *group)
280{
281}
282
283static inline void vfio_device_container_register(struct vfio_device *device)
284{
285}
286
287static inline void vfio_device_container_unregister(struct vfio_device *device)
288{
289}
290
291static inline int vfio_device_container_pin_pages(struct vfio_device *device,
292 dma_addr_t iova, int npage,
293 int prot, struct page **pages)
294{
295 return -EOPNOTSUPP;
296}
297
298static inline void vfio_device_container_unpin_pages(struct vfio_device *device,
299 dma_addr_t iova, int npage)
300{
301}
302
303static inline int vfio_device_container_dma_rw(struct vfio_device *device,
304 dma_addr_t iova, void *data,
305 size_t len, bool write)
306{
307 return -EOPNOTSUPP;
308}
309
310static inline int vfio_container_init(void)
311{
312 return 0;
313}
314static inline void vfio_container_cleanup(void)
315{
316}
317#endif
318
319#if IS_ENABLED(CONFIG_IOMMUFD)
320bool vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev,
321 struct iommufd_ctx *ictx);
322int vfio_df_iommufd_bind(struct vfio_device_file *df);
323void vfio_df_iommufd_unbind(struct vfio_device_file *df);
324int vfio_iommufd_compat_attach_ioas(struct vfio_device *device,
325 struct iommufd_ctx *ictx);
326#else
327static inline bool
328vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev,
329 struct iommufd_ctx *ictx)
330{
331 return false;
332}
333
334static inline int vfio_df_iommufd_bind(struct vfio_device_file *fd)
335{
336 return -EOPNOTSUPP;
337}
338
339static inline void vfio_df_iommufd_unbind(struct vfio_device_file *df)
340{
341}
342
343static inline int
344vfio_iommufd_compat_attach_ioas(struct vfio_device *device,
345 struct iommufd_ctx *ictx)
346{
347 return -EOPNOTSUPP;
348}
349#endif
350
351int vfio_df_ioctl_attach_pt(struct vfio_device_file *df,
352 struct vfio_device_attach_iommufd_pt __user *arg);
353int vfio_df_ioctl_detach_pt(struct vfio_device_file *df,
354 struct vfio_device_detach_iommufd_pt __user *arg);
355
356#if IS_ENABLED(CONFIG_VFIO_DEVICE_CDEV)
357void vfio_init_device_cdev(struct vfio_device *device);
358
359static inline int vfio_device_add(struct vfio_device *device)
360{
361 /* cdev does not support noiommu device */
362 if (vfio_device_is_noiommu(device))
363 return device_add(&device->device);
364 vfio_init_device_cdev(device);
365 return cdev_device_add(&device->cdev, &device->device);
366}
367
368static inline void vfio_device_del(struct vfio_device *device)
369{
370 if (vfio_device_is_noiommu(device))
371 device_del(&device->device);
372 else
373 cdev_device_del(&device->cdev, &device->device);
374}
375
376int vfio_device_fops_cdev_open(struct inode *inode, struct file *filep);
377long vfio_df_ioctl_bind_iommufd(struct vfio_device_file *df,
378 struct vfio_device_bind_iommufd __user *arg);
379void vfio_df_unbind_iommufd(struct vfio_device_file *df);
380int vfio_cdev_init(void);
381void vfio_cdev_cleanup(void);
382#else
383static inline void vfio_init_device_cdev(struct vfio_device *device)
384{
385}
386
387static inline int vfio_device_add(struct vfio_device *device)
388{
389 return device_add(&device->device);
390}
391
392static inline void vfio_device_del(struct vfio_device *device)
393{
394 device_del(&device->device);
395}
396
397static inline int vfio_device_fops_cdev_open(struct inode *inode,
398 struct file *filep)
399{
400 return 0;
401}
402
403static inline long vfio_df_ioctl_bind_iommufd(struct vfio_device_file *df,
404 struct vfio_device_bind_iommufd __user *arg)
405{
406 return -ENOTTY;
407}
408
409static inline void vfio_df_unbind_iommufd(struct vfio_device_file *df)
410{
411}
412
413static inline int vfio_cdev_init(void)
414{
415 return 0;
416}
417
418static inline void vfio_cdev_cleanup(void)
419{
420}
421#endif /* CONFIG_VFIO_DEVICE_CDEV */
422
423#if IS_ENABLED(CONFIG_VFIO_VIRQFD)
424int __init vfio_virqfd_init(void);
425void vfio_virqfd_exit(void);
426#else
427static inline int __init vfio_virqfd_init(void)
428{
429 return 0;
430}
431static inline void vfio_virqfd_exit(void)
432{
433}
434#endif
435
436#if IS_ENABLED(CONFIG_KVM)
437void vfio_device_get_kvm_safe(struct vfio_device *device, struct kvm *kvm);
438void vfio_device_put_kvm(struct vfio_device *device);
439#else
440static inline void vfio_device_get_kvm_safe(struct vfio_device *device,
441 struct kvm *kvm)
442{
443}
444
445static inline void vfio_device_put_kvm(struct vfio_device *device)
446{
447}
448#endif
449
450#ifdef CONFIG_VFIO_DEBUGFS
451void vfio_debugfs_create_root(void);
452void vfio_debugfs_remove_root(void);
453
454void vfio_device_debugfs_init(struct vfio_device *vdev);
455void vfio_device_debugfs_exit(struct vfio_device *vdev);
456#else
457static inline void vfio_debugfs_create_root(void) { }
458static inline void vfio_debugfs_remove_root(void) { }
459
460static inline void vfio_device_debugfs_init(struct vfio_device *vdev) { }
461static inline void vfio_device_debugfs_exit(struct vfio_device *vdev) { }
462#endif /* CONFIG_VFIO_DEBUGFS */
463
464#endif