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 struct 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 30 void vfio_device_put_registration(struct vfio_device *device); 31 bool vfio_device_try_get_registration(struct vfio_device *device); 32 int vfio_df_open(struct vfio_device_file *df); 33 void vfio_df_close(struct vfio_device_file *df); 34 struct vfio_device_file * 35 vfio_allocate_device_file(struct vfio_device *device); 36 37 extern const struct file_operations vfio_device_fops; 38 39 #ifdef CONFIG_VFIO_NOIOMMU 40 extern bool vfio_noiommu __read_mostly; 41 #else 42 enum { vfio_noiommu = false }; 43 #endif 44 45 enum 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) 70 struct 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 98 int vfio_device_block_group(struct vfio_device *device); 99 void vfio_device_unblock_group(struct vfio_device *device); 100 int vfio_device_set_group(struct vfio_device *device, 101 enum vfio_group_type type); 102 void vfio_device_remove_group(struct vfio_device *device); 103 void vfio_device_group_register(struct vfio_device *device); 104 void vfio_device_group_unregister(struct vfio_device *device); 105 int vfio_device_group_use_iommu(struct vfio_device *device); 106 void vfio_device_group_unuse_iommu(struct vfio_device *device); 107 void vfio_df_group_close(struct vfio_device_file *df); 108 struct vfio_group *vfio_group_from_file(struct file *file); 109 bool vfio_group_enforced_coherent(struct vfio_group *group); 110 void vfio_group_set_kvm(struct vfio_group *group, struct kvm *kvm); 111 bool vfio_device_has_container(struct vfio_device *device); 112 int __init vfio_group_init(void); 113 void vfio_group_cleanup(void); 114 115 #else 116 struct vfio_group; 117 118 static inline int vfio_device_block_group(struct vfio_device *device) 119 { 120 return 0; 121 } 122 123 static inline void vfio_device_unblock_group(struct vfio_device *device) 124 { 125 } 126 127 static inline int vfio_device_set_group(struct vfio_device *device, 128 enum vfio_group_type type) 129 { 130 return 0; 131 } 132 133 static inline void vfio_device_remove_group(struct vfio_device *device) 134 { 135 } 136 137 static inline void vfio_device_group_register(struct vfio_device *device) 138 { 139 } 140 141 static inline void vfio_device_group_unregister(struct vfio_device *device) 142 { 143 } 144 145 static inline int vfio_device_group_use_iommu(struct vfio_device *device) 146 { 147 return -EOPNOTSUPP; 148 } 149 150 static inline void vfio_device_group_unuse_iommu(struct vfio_device *device) 151 { 152 } 153 154 static inline void vfio_df_group_close(struct vfio_device_file *df) 155 { 156 } 157 158 static inline struct vfio_group *vfio_group_from_file(struct file *file) 159 { 160 return NULL; 161 } 162 163 static inline bool vfio_group_enforced_coherent(struct vfio_group *group) 164 { 165 return true; 166 } 167 168 static inline void vfio_group_set_kvm(struct vfio_group *group, struct kvm *kvm) 169 { 170 } 171 172 static inline bool vfio_device_has_container(struct vfio_device *device) 173 { 174 return false; 175 } 176 177 static inline int __init vfio_group_init(void) 178 { 179 return 0; 180 } 181 182 static inline void vfio_group_cleanup(void) 183 { 184 } 185 186 #endif /* CONFIG_VFIO_GROUP */ 187 188 static inline bool vfio_device_is_noiommu(struct vfio_device *vdev) 189 { 190 #if IS_ENABLED(CONFIG_VFIO_GROUP) 191 if (vdev->group && vdev->group->type == VFIO_NO_IOMMU) 192 return true; 193 #endif 194 195 return IS_ENABLED(CONFIG_IOMMUFD_NOIOMMU) && vdev->noiommu; 196 } 197 198 #if IS_ENABLED(CONFIG_VFIO_CONTAINER) 199 /** 200 * struct vfio_iommu_driver_ops - VFIO IOMMU driver callbacks 201 */ 202 struct 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 231 struct vfio_iommu_driver { 232 const struct vfio_iommu_driver_ops *ops; 233 struct list_head vfio_next; 234 }; 235 236 int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops); 237 void vfio_unregister_iommu_driver(const struct vfio_iommu_driver_ops *ops); 238 239 struct vfio_container *vfio_container_from_file(struct file *filep); 240 int vfio_group_use_container(struct vfio_group *group); 241 void vfio_group_unuse_container(struct vfio_group *group); 242 int vfio_container_attach_group(struct vfio_container *container, 243 struct vfio_group *group); 244 void vfio_group_detach_container(struct vfio_group *group); 245 void vfio_device_container_register(struct vfio_device *device); 246 void vfio_device_container_unregister(struct vfio_device *device); 247 int vfio_device_container_pin_pages(struct vfio_device *device, 248 dma_addr_t iova, int npage, 249 int prot, struct page **pages); 250 void vfio_device_container_unpin_pages(struct vfio_device *device, 251 dma_addr_t iova, int npage); 252 int vfio_device_container_dma_rw(struct vfio_device *device, 253 dma_addr_t iova, void *data, 254 size_t len, bool write); 255 256 int __init vfio_container_init(void); 257 void vfio_container_cleanup(void); 258 #else 259 static inline struct vfio_container * 260 vfio_container_from_file(struct file *filep) 261 { 262 return NULL; 263 } 264 265 static inline int vfio_group_use_container(struct vfio_group *group) 266 { 267 return -EOPNOTSUPP; 268 } 269 270 static inline void vfio_group_unuse_container(struct vfio_group *group) 271 { 272 } 273 274 static inline int vfio_container_attach_group(struct vfio_container *container, 275 struct vfio_group *group) 276 { 277 return -EOPNOTSUPP; 278 } 279 280 static inline void vfio_group_detach_container(struct vfio_group *group) 281 { 282 } 283 284 static inline void vfio_device_container_register(struct vfio_device *device) 285 { 286 } 287 288 static inline void vfio_device_container_unregister(struct vfio_device *device) 289 { 290 } 291 292 static 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 299 static inline void vfio_device_container_unpin_pages(struct vfio_device *device, 300 dma_addr_t iova, int npage) 301 { 302 } 303 304 static 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 311 static inline int vfio_container_init(void) 312 { 313 return 0; 314 } 315 static inline void vfio_container_cleanup(void) 316 { 317 } 318 #endif 319 320 #if IS_ENABLED(CONFIG_IOMMUFD) 321 bool vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev, 322 struct iommufd_ctx *ictx); 323 int vfio_df_iommufd_bind(struct vfio_device_file *df); 324 void vfio_df_iommufd_unbind(struct vfio_device_file *df); 325 int vfio_iommufd_compat_attach_ioas(struct vfio_device *device, 326 struct iommufd_ctx *ictx); 327 #else 328 static inline bool 329 vfio_iommufd_device_has_compat_ioas(struct vfio_device *vdev, 330 struct iommufd_ctx *ictx) 331 { 332 return false; 333 } 334 335 static inline int vfio_df_iommufd_bind(struct vfio_device_file *fd) 336 { 337 return -EOPNOTSUPP; 338 } 339 340 static inline void vfio_df_iommufd_unbind(struct vfio_device_file *df) 341 { 342 } 343 344 static inline int 345 vfio_iommufd_compat_attach_ioas(struct vfio_device *device, 346 struct iommufd_ctx *ictx) 347 { 348 return -EOPNOTSUPP; 349 } 350 #endif 351 352 int vfio_df_ioctl_attach_pt(struct vfio_device_file *df, 353 struct vfio_device_attach_iommufd_pt __user *arg); 354 int 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) 358 void vfio_init_device_cdev(struct vfio_device *device); 359 360 static inline int vfio_device_add(struct vfio_device *device) 361 { 362 vfio_init_device_cdev(device); 363 return cdev_device_add(&device->cdev, &device->device); 364 } 365 366 static inline void vfio_device_del(struct vfio_device *device) 367 { 368 cdev_device_del(&device->cdev, &device->device); 369 } 370 371 int vfio_device_fops_cdev_open(struct inode *inode, struct file *filep); 372 long vfio_df_ioctl_bind_iommufd(struct vfio_device_file *df, 373 struct vfio_device_bind_iommufd __user *arg); 374 void vfio_df_unbind_iommufd(struct vfio_device_file *df); 375 int vfio_cdev_init(void); 376 void vfio_cdev_cleanup(void); 377 #else 378 static inline void vfio_init_device_cdev(struct vfio_device *device) 379 { 380 } 381 382 static inline int vfio_device_add(struct vfio_device *device) 383 { 384 return device_add(&device->device); 385 } 386 387 static inline void vfio_device_del(struct vfio_device *device) 388 { 389 device_del(&device->device); 390 } 391 392 static inline int vfio_device_fops_cdev_open(struct inode *inode, 393 struct file *filep) 394 { 395 return 0; 396 } 397 398 static inline long vfio_df_ioctl_bind_iommufd(struct vfio_device_file *df, 399 struct vfio_device_bind_iommufd __user *arg) 400 { 401 return -ENOTTY; 402 } 403 404 static inline void vfio_df_unbind_iommufd(struct vfio_device_file *df) 405 { 406 } 407 408 static inline int vfio_cdev_init(void) 409 { 410 return 0; 411 } 412 413 static inline void vfio_cdev_cleanup(void) 414 { 415 } 416 #endif /* CONFIG_VFIO_DEVICE_CDEV */ 417 418 #if IS_ENABLED(CONFIG_VFIO_VIRQFD) 419 int __init vfio_virqfd_init(void); 420 void vfio_virqfd_exit(void); 421 #else 422 static inline int __init vfio_virqfd_init(void) 423 { 424 return 0; 425 } 426 static inline void vfio_virqfd_exit(void) 427 { 428 } 429 #endif 430 431 #if IS_ENABLED(CONFIG_KVM) 432 void vfio_device_get_kvm_safe(struct vfio_device *device, struct kvm *kvm); 433 void vfio_device_put_kvm(struct vfio_device *device); 434 #else 435 static inline void vfio_device_get_kvm_safe(struct vfio_device *device, 436 struct kvm *kvm) 437 { 438 } 439 440 static inline void vfio_device_put_kvm(struct vfio_device *device) 441 { 442 } 443 #endif 444 445 #ifdef CONFIG_VFIO_DEBUGFS 446 void vfio_debugfs_create_root(void); 447 void vfio_debugfs_remove_root(void); 448 449 void vfio_device_debugfs_init(struct vfio_device *vdev); 450 void vfio_device_debugfs_exit(struct vfio_device *vdev); 451 #else 452 static inline void vfio_debugfs_create_root(void) { } 453 static inline void vfio_debugfs_remove_root(void) { } 454 455 static inline void vfio_device_debugfs_init(struct vfio_device *vdev) { } 456 static inline void vfio_device_debugfs_exit(struct vfio_device *vdev) { } 457 #endif /* CONFIG_VFIO_DEBUGFS */ 458 459 #endif 460