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/device.h> 10 #include <linux/cdev.h> 11 #include <linux/module.h> 12 13 struct iommu_group; 14 struct vfio_device; 15 struct vfio_container; 16 17 enum vfio_group_type { 18 /* 19 * Physical device with IOMMU backing. 20 */ 21 VFIO_IOMMU, 22 23 /* 24 * Virtual device without IOMMU backing. The VFIO core fakes up an 25 * iommu_group as the iommu_group sysfs interface is part of the 26 * userspace ABI. The user of these devices must not be able to 27 * directly trigger unmediated DMA. 28 */ 29 VFIO_EMULATED_IOMMU, 30 31 /* 32 * Physical device without IOMMU backing. The VFIO core fakes up an 33 * iommu_group as the iommu_group sysfs interface is part of the 34 * userspace ABI. Users can trigger unmediated DMA by the device, 35 * usage is highly dangerous, requires an explicit opt-in and will 36 * taint the kernel. 37 */ 38 VFIO_NO_IOMMU, 39 }; 40 41 struct vfio_group { 42 struct device dev; 43 struct cdev cdev; 44 /* 45 * When drivers is non-zero a driver is attached to the struct device 46 * that provided the iommu_group and thus the iommu_group is a valid 47 * pointer. When drivers is 0 the driver is being detached. Once users 48 * reaches 0 then the iommu_group is invalid. 49 */ 50 refcount_t drivers; 51 unsigned int container_users; 52 struct iommu_group *iommu_group; 53 struct vfio_container *container; 54 struct list_head device_list; 55 struct mutex device_lock; 56 struct list_head vfio_next; 57 struct list_head container_next; 58 enum vfio_group_type type; 59 struct mutex group_lock; 60 struct kvm *kvm; 61 struct file *opened_file; 62 struct blocking_notifier_head notifier; 63 }; 64 65 /* events for the backend driver notify callback */ 66 enum vfio_iommu_notify_type { 67 VFIO_IOMMU_CONTAINER_CLOSE = 0, 68 }; 69 70 /** 71 * struct vfio_iommu_driver_ops - VFIO IOMMU driver callbacks 72 */ 73 struct vfio_iommu_driver_ops { 74 char *name; 75 struct module *owner; 76 void *(*open)(unsigned long arg); 77 void (*release)(void *iommu_data); 78 long (*ioctl)(void *iommu_data, unsigned int cmd, 79 unsigned long arg); 80 int (*attach_group)(void *iommu_data, 81 struct iommu_group *group, 82 enum vfio_group_type); 83 void (*detach_group)(void *iommu_data, 84 struct iommu_group *group); 85 int (*pin_pages)(void *iommu_data, 86 struct iommu_group *group, 87 dma_addr_t user_iova, 88 int npage, int prot, 89 struct page **pages); 90 void (*unpin_pages)(void *iommu_data, 91 dma_addr_t user_iova, int npage); 92 void (*register_device)(void *iommu_data, 93 struct vfio_device *vdev); 94 void (*unregister_device)(void *iommu_data, 95 struct vfio_device *vdev); 96 int (*dma_rw)(void *iommu_data, dma_addr_t user_iova, 97 void *data, size_t count, bool write); 98 struct iommu_domain *(*group_iommu_domain)(void *iommu_data, 99 struct iommu_group *group); 100 void (*notify)(void *iommu_data, 101 enum vfio_iommu_notify_type event); 102 }; 103 104 struct vfio_iommu_driver { 105 const struct vfio_iommu_driver_ops *ops; 106 struct list_head vfio_next; 107 }; 108 109 int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops); 110 void vfio_unregister_iommu_driver(const struct vfio_iommu_driver_ops *ops); 111 112 bool vfio_assert_device_open(struct vfio_device *device); 113 114 struct vfio_container *vfio_container_from_file(struct file *filep); 115 int vfio_device_assign_container(struct vfio_device *device); 116 void vfio_device_unassign_container(struct vfio_device *device); 117 int vfio_container_attach_group(struct vfio_container *container, 118 struct vfio_group *group); 119 void vfio_group_detach_container(struct vfio_group *group); 120 void vfio_device_container_register(struct vfio_device *device); 121 void vfio_device_container_unregister(struct vfio_device *device); 122 long vfio_container_ioctl_check_extension(struct vfio_container *container, 123 unsigned long arg); 124 int __init vfio_container_init(void); 125 void vfio_container_cleanup(void); 126 127 #ifdef CONFIG_VFIO_NOIOMMU 128 extern bool vfio_noiommu __read_mostly; 129 #else 130 enum { vfio_noiommu = false }; 131 #endif 132 133 #endif 134