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(device)) 364 return device_add(&device->device); 365 vfio_init_device_cdev(device); 366 return cdev_device_add(&device->cdev, &device->device); 367} 368 369static inline void vfio_device_del(struct vfio_device *device) 370{ 371 if (vfio_device_is_noiommu(device)) 372 device_del(&device->device); 373 else 374 cdev_device_del(&device->cdev, &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