projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'ntfs3_for_6.5' of https://github.com/Paragon-Software-Group/linux-ntfs3
[linux-block.git] / drivers / vfio / vfio.h
CommitLineData
8cc02d22
CH		 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 */
e3bb4de0
JG		 6#ifndef __VFIO_VFIO_H__
7#define __VFIO_VFIO_H__
8
9eefba80 9#include <linux/file.h>
e3bb4de0
JG		 10#include <linux/device.h>
11#include <linux/cdev.h>
12#include <linux/module.h>
c9a397ce 13#include <linux/vfio.h>
e3bb4de0 14
2a3dab19 15struct iommufd_ctx;
e3bb4de0 16struct iommu_group;
cdc71fe4 17struct vfio_container;
8cc02d22 18
9eefba80
YL		 19void vfio_device_put_registration(struct vfio_device *device);
20bool vfio_device_try_get_registration(struct vfio_device *device);
b0d2d569 21int vfio_device_open(struct vfio_device *device, struct iommufd_ctx *iommufd);
9eefba80
YL		 22void vfio_device_close(struct vfio_device *device,
23 struct iommufd_ctx *iommufd);
24
25extern const struct file_operations vfio_device_fops;
26
c3c0fa9d
CH		 27enum vfio_group_type {
28 /*
29 * Physical device with IOMMU backing.
30 */
31 VFIO_IOMMU,
32
33 /*
34 * Virtual device without IOMMU backing. The VFIO core fakes up an
35 * iommu_group as the iommu_group sysfs interface is part of the
36 * userspace ABI. The user of these devices must not be able to
37 * directly trigger unmediated DMA.
38 */
39 VFIO_EMULATED_IOMMU,
40
41 /*
42 * Physical device without IOMMU backing. The VFIO core fakes up an
43 * iommu_group as the iommu_group sysfs interface is part of the
44 * userspace ABI. Users can trigger unmediated DMA by the device,
45 * usage is highly dangerous, requires an explicit opt-in and will
46 * taint the kernel.
47 */
48 VFIO_NO_IOMMU,
49};
50
cdc71fe4
JG		 51struct vfio_group {
52 struct device dev;
53 struct cdev cdev;
ca5f21b2
JG		 54 /*
55 * When drivers is non-zero a driver is attached to the struct device
56 * that provided the iommu_group and thus the iommu_group is a valid
57 * pointer. When drivers is 0 the driver is being detached. Once users
58 * reaches 0 then the iommu_group is invalid.
59 */
60 refcount_t drivers;
cdc71fe4
JG		 61 unsigned int container_users;
62 struct iommu_group *iommu_group;
63 struct vfio_container *container;
64 struct list_head device_list;
65 struct mutex device_lock;
66 struct list_head vfio_next;
e5a9ec7e 67#if IS_ENABLED(CONFIG_VFIO_CONTAINER)
cdc71fe4 68 struct list_head container_next;
e5a9ec7e 69#endif
cdc71fe4 70 enum vfio_group_type type;
c82e81ab 71 struct mutex group_lock;
cdc71fe4
JG		 72 struct kvm *kvm;
73 struct file *opened_file;
74 struct blocking_notifier_head notifier;
2a3dab19 75 struct iommufd_ctx *iommufd;
2b48f52f 76 spinlock_t kvm_ref_lock;
cdc71fe4
JG		 77};
78
9eefba80
YL		 79int vfio_device_set_group(struct vfio_device *device,
80 enum vfio_group_type type);
81void vfio_device_remove_group(struct vfio_device *device);
82void vfio_device_group_register(struct vfio_device *device);
83void vfio_device_group_unregister(struct vfio_device *device);
84int vfio_device_group_use_iommu(struct vfio_device *device);
85void vfio_device_group_unuse_iommu(struct vfio_device *device);
86void vfio_device_group_close(struct vfio_device *device);
87bool vfio_device_has_container(struct vfio_device *device);
88int __init vfio_group_init(void);
89void vfio_group_cleanup(void);
90
c9a397ce
JG		 91static inline bool vfio_device_is_noiommu(struct vfio_device *vdev)
92{
93 return IS_ENABLED(CONFIG_VFIO_NOIOMMU) &&
94 vdev->group->type == VFIO_NO_IOMMU;
95}
96
e5a9ec7e 97#if IS_ENABLED(CONFIG_VFIO_CONTAINER)
8cc02d22
CH		 98/**
99 * struct vfio_iommu_driver_ops - VFIO IOMMU driver callbacks
100 */
101struct vfio_iommu_driver_ops {
102 char *name;
103 struct module *owner;
104 void *(*open)(unsigned long arg);
105 void (*release)(void *iommu_data);
106 long (*ioctl)(void *iommu_data, unsigned int cmd,
107 unsigned long arg);
108 int (*attach_group)(void *iommu_data,
c3c0fa9d
CH		 109 struct iommu_group *group,
110 enum vfio_group_type);
8cc02d22
CH		 111 void (*detach_group)(void *iommu_data,
112 struct iommu_group *group);
113 int (*pin_pages)(void *iommu_data,
114 struct iommu_group *group,
44abdd16 115 dma_addr_t user_iova,
8cc02d22 116 int npage, int prot,
34a255e6 117 struct page **pages);
e8f90717 118 void (*unpin_pages)(void *iommu_data,
44abdd16 119 dma_addr_t user_iova, int npage);
8cfc5b60
JG		 120 void (*register_device)(void *iommu_data,
121 struct vfio_device *vdev);
122 void (*unregister_device)(void *iommu_data,
123 struct vfio_device *vdev);
8cc02d22
CH		 124 int (*dma_rw)(void *iommu_data, dma_addr_t user_iova,
125 void *data, size_t count, bool write);
126 struct iommu_domain *(*group_iommu_domain)(void *iommu_data,
127 struct iommu_group *group);
8cc02d22
CH		 128};
129
cdc71fe4
JG		 130struct vfio_iommu_driver {
131 const struct vfio_iommu_driver_ops *ops;
132 struct list_head vfio_next;
133};
134
8cc02d22
CH		 135int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops);
136void vfio_unregister_iommu_driver(const struct vfio_iommu_driver_ops *ops);
e3bb4de0 137
cdc71fe4 138struct vfio_container *vfio_container_from_file(struct file *filep);
04f930c3
JG		 139int vfio_group_use_container(struct vfio_group *group);
140void vfio_group_unuse_container(struct vfio_group *group);
cdc71fe4
JG		 141int vfio_container_attach_group(struct vfio_container *container,
142 struct vfio_group *group);
143void vfio_group_detach_container(struct vfio_group *group);
144void vfio_device_container_register(struct vfio_device *device);
145void vfio_device_container_unregister(struct vfio_device *device);
8da7a0e7
YL		 146int vfio_device_container_pin_pages(struct vfio_device *device,
147 dma_addr_t iova, int npage,
148 int prot, struct page **pages);
149void vfio_device_container_unpin_pages(struct vfio_device *device,
150 dma_addr_t iova, int npage);
151int vfio_device_container_dma_rw(struct vfio_device *device,
152 dma_addr_t iova, void *data,
153 size_t len, bool write);
4741f2e9 154
cdc71fe4
JG		 155int __init vfio_container_init(void);
156void vfio_container_cleanup(void);
e5a9ec7e
JG		 157#else
158static inline struct vfio_container *
159vfio_container_from_file(struct file *filep)
160{
161 return NULL;
162}
163
164static inline int vfio_group_use_container(struct vfio_group *group)
165{
166 return -EOPNOTSUPP;
167}
168
169static inline void vfio_group_unuse_container(struct vfio_group *group)
170{
171}
172
173static inline int vfio_container_attach_group(struct vfio_container *container,
174 struct vfio_group *group)
175{
176 return -EOPNOTSUPP;
177}
178
179static inline void vfio_group_detach_container(struct vfio_group *group)
180{
181}
182
183static inline void vfio_device_container_register(struct vfio_device *device)
184{
185}
186
187static inline void vfio_device_container_unregister(struct vfio_device *device)
188{
189}
190
8da7a0e7
YL		 191static inline int vfio_device_container_pin_pages(struct vfio_device *device,
192 dma_addr_t iova, int npage,
193 int prot, struct page **pages)
e5a9ec7e
JG		 194{
195 return -EOPNOTSUPP;
196}
197
8da7a0e7
YL		 198static inline void vfio_device_container_unpin_pages(struct vfio_device *device,
199 dma_addr_t iova, int npage)
e5a9ec7e
JG		 200{
201}
202
8da7a0e7
YL		 203static inline int vfio_device_container_dma_rw(struct vfio_device *device,
204 dma_addr_t iova, void *data,
205 size_t len, bool write)
e5a9ec7e
JG		 206{
207 return -EOPNOTSUPP;
208}
209
210static inline int vfio_container_init(void)
211{
212 return 0;
213}
214static inline void vfio_container_cleanup(void)
215{
216}
217#endif
cdc71fe4 218
a4d1f91d
JG		 219#if IS_ENABLED(CONFIG_IOMMUFD)
220int vfio_iommufd_bind(struct vfio_device *device, struct iommufd_ctx *ictx);
221void vfio_iommufd_unbind(struct vfio_device *device);
222#else
223static inline int vfio_iommufd_bind(struct vfio_device *device,
224 struct iommufd_ctx *ictx)
225{
226 return -EOPNOTSUPP;
227}
228
229static inline void vfio_iommufd_unbind(struct vfio_device *device)
230{
231}
232#endif
233
e2d55709
JG		 234#if IS_ENABLED(CONFIG_VFIO_VIRQFD)
235int __init vfio_virqfd_init(void);
236void vfio_virqfd_exit(void);
237#else
238static inline int __init vfio_virqfd_init(void)
239{
240 return 0;
241}
242static inline void vfio_virqfd_exit(void)
243{
244}
245#endif
246
cdc71fe4
JG		 247#ifdef CONFIG_VFIO_NOIOMMU
248extern bool vfio_noiommu __read_mostly;
249#else
250enum { vfio_noiommu = false };
251#endif
252
2b48f52f
MR		 253#ifdef CONFIG_HAVE_KVM
254void _vfio_device_get_kvm_safe(struct vfio_device *device, struct kvm *kvm);
255void vfio_device_put_kvm(struct vfio_device *device);
256#else
257static inline void _vfio_device_get_kvm_safe(struct vfio_device *device,
258 struct kvm *kvm)
259{
260}
261
262static inline void vfio_device_put_kvm(struct vfio_device *device)
263{
264}
265#endif
266
e3bb4de0 267#endif
Linux 6.x block layer and io_uring tree(s)