1 /* SPDX-License-Identifier: GPL-2.0-only */ 2 #ifndef SELFTESTS_VFIO_LIB_INCLUDE_VFIO_UTIL_H 3 #define SELFTESTS_VFIO_LIB_INCLUDE_VFIO_UTIL_H 4 5 #include <fcntl.h> 6 #include <string.h> 7 #include <linux/vfio.h> 8 #include <linux/list.h> 9 #include <linux/pci_regs.h> 10 11 #include "../../../kselftest.h" 12 13 #define VFIO_LOG_AND_EXIT(...) do { \ 14 fprintf(stderr, " " __VA_ARGS__); \ 15 fprintf(stderr, "\n"); \ 16 exit(KSFT_FAIL); \ 17 } while (0) 18 19 #define VFIO_ASSERT_OP(_lhs, _rhs, _op, ...) do { \ 20 typeof(_lhs) __lhs = (_lhs); \ 21 typeof(_rhs) __rhs = (_rhs); \ 22 \ 23 if (__lhs _op __rhs) \ 24 break; \ 25 \ 26 fprintf(stderr, "%s:%u: Assertion Failure\n\n", __FILE__, __LINE__); \ 27 fprintf(stderr, " Expression: " #_lhs " " #_op " " #_rhs "\n"); \ 28 fprintf(stderr, " Observed: %#lx %s %#lx\n", \ 29 (u64)__lhs, #_op, (u64)__rhs); \ 30 fprintf(stderr, " [errno: %d - %s]\n", errno, strerror(errno)); \ 31 VFIO_LOG_AND_EXIT(__VA_ARGS__); \ 32 } while (0) 33 34 #define VFIO_ASSERT_EQ(_a, _b, ...) VFIO_ASSERT_OP(_a, _b, ==, ##__VA_ARGS__) 35 #define VFIO_ASSERT_NE(_a, _b, ...) VFIO_ASSERT_OP(_a, _b, !=, ##__VA_ARGS__) 36 #define VFIO_ASSERT_LT(_a, _b, ...) VFIO_ASSERT_OP(_a, _b, <, ##__VA_ARGS__) 37 #define VFIO_ASSERT_LE(_a, _b, ...) VFIO_ASSERT_OP(_a, _b, <=, ##__VA_ARGS__) 38 #define VFIO_ASSERT_GT(_a, _b, ...) VFIO_ASSERT_OP(_a, _b, >, ##__VA_ARGS__) 39 #define VFIO_ASSERT_GE(_a, _b, ...) VFIO_ASSERT_OP(_a, _b, >=, ##__VA_ARGS__) 40 #define VFIO_ASSERT_TRUE(_a, ...) VFIO_ASSERT_NE(false, (_a), ##__VA_ARGS__) 41 #define VFIO_ASSERT_FALSE(_a, ...) VFIO_ASSERT_EQ(false, (_a), ##__VA_ARGS__) 42 #define VFIO_ASSERT_NULL(_a, ...) VFIO_ASSERT_EQ(NULL, _a, ##__VA_ARGS__) 43 #define VFIO_ASSERT_NOT_NULL(_a, ...) VFIO_ASSERT_NE(NULL, _a, ##__VA_ARGS__) 44 45 #define VFIO_FAIL(_fmt, ...) do { \ 46 fprintf(stderr, "%s:%u: FAIL\n\n", __FILE__, __LINE__); \ 47 VFIO_LOG_AND_EXIT(_fmt, ##__VA_ARGS__); \ 48 } while (0) 49 50 struct vfio_iommu_mode { 51 const char *name; 52 const char *container_path; 53 unsigned long iommu_type; 54 }; 55 56 struct vfio_pci_bar { 57 struct vfio_region_info info; 58 void *vaddr; 59 }; 60 61 typedef u64 iova_t; 62 63 #define INVALID_IOVA UINT64_MAX 64 65 struct vfio_dma_region { 66 struct list_head link; 67 void *vaddr; 68 iova_t iova; 69 u64 size; 70 }; 71 72 struct vfio_pci_device; 73 74 struct vfio_pci_driver_ops { 75 const char *name; 76 77 /** 78 * @probe() - Check if the driver supports the given device. 79 * 80 * Return: 0 on success, non-0 on failure. 81 */ 82 int (*probe)(struct vfio_pci_device *device); 83 84 /** 85 * @init() - Initialize the driver for @device. 86 * 87 * Must be called after device->driver.region has been initialized. 88 */ 89 void (*init)(struct vfio_pci_device *device); 90 91 /** 92 * remove() - Deinitialize the driver for @device. 93 */ 94 void (*remove)(struct vfio_pci_device *device); 95 96 /** 97 * memcpy_start() - Kick off @count repeated memcpy operations from 98 * [@src, @src + @size) to [@dst, @dst + @size). 99 * 100 * Guarantees: 101 * - The device will attempt DMA reads on [src, src + size). 102 * - The device will attempt DMA writes on [dst, dst + size). 103 * - The device will not generate any interrupts. 104 * 105 * memcpy_start() returns immediately, it does not wait for the 106 * copies to complete. 107 */ 108 void (*memcpy_start)(struct vfio_pci_device *device, 109 iova_t src, iova_t dst, u64 size, u64 count); 110 111 /** 112 * memcpy_wait() - Wait until the memcpy operations started by 113 * memcpy_start() have finished. 114 * 115 * Guarantees: 116 * - All in-flight DMAs initiated by memcpy_start() are fully complete 117 * before memcpy_wait() returns. 118 * 119 * Returns non-0 if the driver detects that an error occurred during the 120 * memcpy, 0 otherwise. 121 */ 122 int (*memcpy_wait)(struct vfio_pci_device *device); 123 124 /** 125 * send_msi() - Make the device send the MSI device->driver.msi. 126 * 127 * Guarantees: 128 * - The device will send the MSI once. 129 */ 130 void (*send_msi)(struct vfio_pci_device *device); 131 }; 132 133 struct vfio_pci_driver { 134 const struct vfio_pci_driver_ops *ops; 135 bool initialized; 136 bool memcpy_in_progress; 137 138 /* Region to be used by the driver (e.g. for in-memory descriptors) */ 139 struct vfio_dma_region region; 140 141 /* The maximum size that can be passed to memcpy_start(). */ 142 u64 max_memcpy_size; 143 144 /* The maximum count that can be passed to memcpy_start(). */ 145 u64 max_memcpy_count; 146 147 /* The MSI vector the device will signal in ops->send_msi(). */ 148 int msi; 149 }; 150 151 struct vfio_pci_device { 152 int fd; 153 154 const struct vfio_iommu_mode *iommu_mode; 155 int group_fd; 156 int container_fd; 157 158 struct vfio_device_info info; 159 struct vfio_region_info config_space; 160 struct vfio_pci_bar bars[PCI_STD_NUM_BARS]; 161 162 struct vfio_irq_info msi_info; 163 struct vfio_irq_info msix_info; 164 165 struct list_head dma_regions; 166 167 /* eventfds for MSI and MSI-x interrupts */ 168 int msi_eventfds[PCI_MSIX_FLAGS_QSIZE + 1]; 169 170 struct vfio_pci_driver driver; 171 }; 172 173 /* 174 * Return the BDF string of the device that the test should use. 175 * 176 * If a BDF string is provided by the user on the command line (as the last 177 * element of argv[]), then this function will return that and decrement argc 178 * by 1. 179 * 180 * Otherwise this function will attempt to use the environment variable 181 * $VFIO_SELFTESTS_BDF. 182 * 183 * If BDF cannot be determined then the test will exit with KSFT_SKIP. 184 */ 185 const char *vfio_selftests_get_bdf(int *argc, char *argv[]); 186 const char *vfio_pci_get_cdev_path(const char *bdf); 187 188 extern const char *default_iommu_mode; 189 190 struct vfio_pci_device *vfio_pci_device_init(const char *bdf, const char *iommu_mode); 191 void vfio_pci_device_cleanup(struct vfio_pci_device *device); 192 void vfio_pci_device_reset(struct vfio_pci_device *device); 193 194 void vfio_pci_dma_map(struct vfio_pci_device *device, 195 struct vfio_dma_region *region); 196 void vfio_pci_dma_unmap(struct vfio_pci_device *device, 197 struct vfio_dma_region *region); 198 199 void vfio_pci_config_access(struct vfio_pci_device *device, bool write, 200 size_t config, size_t size, void *data); 201 202 #define vfio_pci_config_read(_device, _offset, _type) ({ \ 203 _type __data; \ 204 vfio_pci_config_access((_device), false, _offset, sizeof(__data), &__data); \ 205 __data; \ 206 }) 207 208 #define vfio_pci_config_readb(_d, _o) vfio_pci_config_read(_d, _o, u8) 209 #define vfio_pci_config_readw(_d, _o) vfio_pci_config_read(_d, _o, u16) 210 #define vfio_pci_config_readl(_d, _o) vfio_pci_config_read(_d, _o, u32) 211 212 #define vfio_pci_config_write(_device, _offset, _value, _type) do { \ 213 _type __data = (_value); \ 214 vfio_pci_config_access((_device), true, _offset, sizeof(_type), &__data); \ 215 } while (0) 216 217 #define vfio_pci_config_writeb(_d, _o, _v) vfio_pci_config_write(_d, _o, _v, u8) 218 #define vfio_pci_config_writew(_d, _o, _v) vfio_pci_config_write(_d, _o, _v, u16) 219 #define vfio_pci_config_writel(_d, _o, _v) vfio_pci_config_write(_d, _o, _v, u32) 220 221 void vfio_pci_irq_enable(struct vfio_pci_device *device, u32 index, 222 u32 vector, int count); 223 void vfio_pci_irq_disable(struct vfio_pci_device *device, u32 index); 224 void vfio_pci_irq_trigger(struct vfio_pci_device *device, u32 index, u32 vector); 225 226 static inline void fcntl_set_nonblock(int fd) 227 { 228 int r; 229 230 r = fcntl(fd, F_GETFL, 0); 231 VFIO_ASSERT_NE(r, -1, "F_GETFL failed for fd %d\n", fd); 232 233 r = fcntl(fd, F_SETFL, r | O_NONBLOCK); 234 VFIO_ASSERT_NE(r, -1, "F_SETFL O_NONBLOCK failed for fd %d\n", fd); 235 } 236 237 static inline void vfio_pci_msi_enable(struct vfio_pci_device *device, 238 u32 vector, int count) 239 { 240 vfio_pci_irq_enable(device, VFIO_PCI_MSI_IRQ_INDEX, vector, count); 241 } 242 243 static inline void vfio_pci_msi_disable(struct vfio_pci_device *device) 244 { 245 vfio_pci_irq_disable(device, VFIO_PCI_MSI_IRQ_INDEX); 246 } 247 248 static inline void vfio_pci_msix_enable(struct vfio_pci_device *device, 249 u32 vector, int count) 250 { 251 vfio_pci_irq_enable(device, VFIO_PCI_MSIX_IRQ_INDEX, vector, count); 252 } 253 254 static inline void vfio_pci_msix_disable(struct vfio_pci_device *device) 255 { 256 vfio_pci_irq_disable(device, VFIO_PCI_MSIX_IRQ_INDEX); 257 } 258 259 iova_t __to_iova(struct vfio_pci_device *device, void *vaddr); 260 iova_t to_iova(struct vfio_pci_device *device, void *vaddr); 261 262 static inline bool vfio_pci_device_match(struct vfio_pci_device *device, 263 u16 vendor_id, u16 device_id) 264 { 265 return (vendor_id == vfio_pci_config_readw(device, PCI_VENDOR_ID)) && 266 (device_id == vfio_pci_config_readw(device, PCI_DEVICE_ID)); 267 } 268 269 void vfio_pci_driver_probe(struct vfio_pci_device *device); 270 void vfio_pci_driver_init(struct vfio_pci_device *device); 271 void vfio_pci_driver_remove(struct vfio_pci_device *device); 272 int vfio_pci_driver_memcpy(struct vfio_pci_device *device, 273 iova_t src, iova_t dst, u64 size); 274 void vfio_pci_driver_memcpy_start(struct vfio_pci_device *device, 275 iova_t src, iova_t dst, u64 size, 276 u64 count); 277 int vfio_pci_driver_memcpy_wait(struct vfio_pci_device *device); 278 void vfio_pci_driver_send_msi(struct vfio_pci_device *device); 279 280 #endif /* SELFTESTS_VFIO_LIB_INCLUDE_VFIO_UTIL_H */ 281