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 15 struct iommufd_ctx; 16 struct iommu_group; 17 struct vfio_container; 18 19 void vfio_device_put_registration(struct vfio_device *device); 20 bool vfio_device_try_get_registration(struct vfio_device *device); 21 int vfio_device_open(struct vfio_device *device, struct iommufd_ctx *iommufd); 22 void vfio_device_close(struct vfio_device *device, 23 struct iommufd_ctx *iommufd); 24 25 extern const struct file_operations vfio_device_fops; 26 27 enum 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 51 struct vfio_group { 52 struct device dev; 53 struct cdev cdev; 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; 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; 67 #if IS_ENABLED(CONFIG_VFIO_CONTAINER) 68 struct list_head container_next; 69 #endif 70 enum vfio_group_type type; 71 struct mutex group_lock; 72 struct kvm *kvm; 73 struct file *opened_file; 74 struct blocking_notifier_head notifier; 75 struct iommufd_ctx *iommufd; 76 spinlock_t kvm_ref_lock; 77 }; 78 79 int vfio_device_set_group(struct vfio_device *device, 80 enum vfio_group_type type); 81 void vfio_device_remove_group(struct vfio_device *device); 82 void vfio_device_group_register(struct vfio_device *device); 83 void vfio_device_group_unregister(struct vfio_device *device); 84 int vfio_device_group_use_iommu(struct vfio_device *device); 85 void vfio_device_group_unuse_iommu(struct vfio_device *device); 86 void vfio_device_group_close(struct vfio_device *device); 87 bool vfio_device_has_container(struct vfio_device *device); 88 int __init vfio_group_init(void); 89 void vfio_group_cleanup(void); 90 91 static 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 97 #if IS_ENABLED(CONFIG_VFIO_CONTAINER) 98 /** 99 * struct vfio_iommu_driver_ops - VFIO IOMMU driver callbacks 100 */ 101 struct 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, 109 struct iommu_group *group, 110 enum vfio_group_type); 111 void (*detach_group)(void *iommu_data, 112 struct iommu_group *group); 113 int (*pin_pages)(void *iommu_data, 114 struct iommu_group *group, 115 dma_addr_t user_iova, 116 int npage, int prot, 117 struct page **pages); 118 void (*unpin_pages)(void *iommu_data, 119 dma_addr_t user_iova, int npage); 120 void (*register_device)(void *iommu_data, 121 struct vfio_device *vdev); 122 void (*unregister_device)(void *iommu_data, 123 struct vfio_device *vdev); 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); 128 }; 129 130 struct vfio_iommu_driver { 131 const struct vfio_iommu_driver_ops *ops; 132 struct list_head vfio_next; 133 }; 134 135 int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops); 136 void vfio_unregister_iommu_driver(const struct vfio_iommu_driver_ops *ops); 137 138 struct vfio_container *vfio_container_from_file(struct file *filep); 139 int vfio_group_use_container(struct vfio_group *group); 140 void vfio_group_unuse_container(struct vfio_group *group); 141 int vfio_container_attach_group(struct vfio_container *container, 142 struct vfio_group *group); 143 void vfio_group_detach_container(struct vfio_group *group); 144 void vfio_device_container_register(struct vfio_device *device); 145 void vfio_device_container_unregister(struct vfio_device *device); 146 int vfio_device_container_pin_pages(struct vfio_device *device, 147 dma_addr_t iova, int npage, 148 int prot, struct page **pages); 149 void vfio_device_container_unpin_pages(struct vfio_device *device, 150 dma_addr_t iova, int npage); 151 int vfio_device_container_dma_rw(struct vfio_device *device, 152 dma_addr_t iova, void *data, 153 size_t len, bool write); 154 155 int __init vfio_container_init(void); 156 void vfio_container_cleanup(void); 157 #else 158 static inline struct vfio_container * 159 vfio_container_from_file(struct file *filep) 160 { 161 return NULL; 162 } 163 164 static inline int vfio_group_use_container(struct vfio_group *group) 165 { 166 return -EOPNOTSUPP; 167 } 168 169 static inline void vfio_group_unuse_container(struct vfio_group *group) 170 { 171 } 172 173 static inline int vfio_container_attach_group(struct vfio_container *container, 174 struct vfio_group *group) 175 { 176 return -EOPNOTSUPP; 177 } 178 179 static inline void vfio_group_detach_container(struct vfio_group *group) 180 { 181 } 182 183 static inline void vfio_device_container_register(struct vfio_device *device) 184 { 185 } 186 187 static inline void vfio_device_container_unregister(struct vfio_device *device) 188 { 189 } 190 191 static inline int vfio_device_container_pin_pages(struct vfio_device *device, 192 dma_addr_t iova, int npage, 193 int prot, struct page **pages) 194 { 195 return -EOPNOTSUPP; 196 } 197 198 static inline void vfio_device_container_unpin_pages(struct vfio_device *device, 199 dma_addr_t iova, int npage) 200 { 201 } 202 203 static inline int vfio_device_container_dma_rw(struct vfio_device *device, 204 dma_addr_t iova, void *data, 205 size_t len, bool write) 206 { 207 return -EOPNOTSUPP; 208 } 209 210 static inline int vfio_container_init(void) 211 { 212 return 0; 213 } 214 static inline void vfio_container_cleanup(void) 215 { 216 } 217 #endif 218 219 #if IS_ENABLED(CONFIG_IOMMUFD) 220 int vfio_iommufd_bind(struct vfio_device *device, struct iommufd_ctx *ictx); 221 void vfio_iommufd_unbind(struct vfio_device *device); 222 #else 223 static inline int vfio_iommufd_bind(struct vfio_device *device, 224 struct iommufd_ctx *ictx) 225 { 226 return -EOPNOTSUPP; 227 } 228 229 static inline void vfio_iommufd_unbind(struct vfio_device *device) 230 { 231 } 232 #endif 233 234 #if IS_ENABLED(CONFIG_VFIO_VIRQFD) 235 int __init vfio_virqfd_init(void); 236 void vfio_virqfd_exit(void); 237 #else 238 static inline int __init vfio_virqfd_init(void) 239 { 240 return 0; 241 } 242 static inline void vfio_virqfd_exit(void) 243 { 244 } 245 #endif 246 247 #ifdef CONFIG_VFIO_NOIOMMU 248 extern bool vfio_noiommu __read_mostly; 249 #else 250 enum { vfio_noiommu = false }; 251 #endif 252 253 #ifdef CONFIG_HAVE_KVM 254 void _vfio_device_get_kvm_safe(struct vfio_device *device, struct kvm *kvm); 255 void vfio_device_put_kvm(struct vfio_device *device); 256 #else 257 static inline void _vfio_device_get_kvm_safe(struct vfio_device *device, 258 struct kvm *kvm) 259 { 260 } 261 262 static inline void vfio_device_put_kvm(struct vfio_device *device) 263 { 264 } 265 #endif 266 267 #endif 268