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 /* 57 * Generator for VFIO selftests fixture variants that replicate across all 58 * possible IOMMU modes. Tests must define FIXTURE_VARIANT_ADD_IOMMU_MODE() 59 * which should then use FIXTURE_VARIANT_ADD() to create the variant. 60 */ 61 #define FIXTURE_VARIANT_ADD_ALL_IOMMU_MODES(...) \ 62 FIXTURE_VARIANT_ADD_IOMMU_MODE(vfio_type1_iommu, ##__VA_ARGS__); \ 63 FIXTURE_VARIANT_ADD_IOMMU_MODE(vfio_type1v2_iommu, ##__VA_ARGS__) 64 65 struct vfio_pci_bar { 66 struct vfio_region_info info; 67 void *vaddr; 68 }; 69 70 typedef u64 iova_t; 71 72 #define INVALID_IOVA UINT64_MAX 73 74 struct vfio_dma_region { 75 struct list_head link; 76 void *vaddr; 77 iova_t iova; 78 u64 size; 79 }; 80 81 struct vfio_pci_device; 82 83 struct vfio_pci_driver_ops { 84 const char *name; 85 86 /** 87 * @probe() - Check if the driver supports the given device. 88 * 89 * Return: 0 on success, non-0 on failure. 90 */ 91 int (*probe)(struct vfio_pci_device *device); 92 93 /** 94 * @init() - Initialize the driver for @device. 95 * 96 * Must be called after device->driver.region has been initialized. 97 */ 98 void (*init)(struct vfio_pci_device *device); 99 100 /** 101 * remove() - Deinitialize the driver for @device. 102 */ 103 void (*remove)(struct vfio_pci_device *device); 104 105 /** 106 * memcpy_start() - Kick off @count repeated memcpy operations from 107 * [@src, @src + @size) to [@dst, @dst + @size). 108 * 109 * Guarantees: 110 * - The device will attempt DMA reads on [src, src + size). 111 * - The device will attempt DMA writes on [dst, dst + size). 112 * - The device will not generate any interrupts. 113 * 114 * memcpy_start() returns immediately, it does not wait for the 115 * copies to complete. 116 */ 117 void (*memcpy_start)(struct vfio_pci_device *device, 118 iova_t src, iova_t dst, u64 size, u64 count); 119 120 /** 121 * memcpy_wait() - Wait until the memcpy operations started by 122 * memcpy_start() have finished. 123 * 124 * Guarantees: 125 * - All in-flight DMAs initiated by memcpy_start() are fully complete 126 * before memcpy_wait() returns. 127 * 128 * Returns non-0 if the driver detects that an error occurred during the 129 * memcpy, 0 otherwise. 130 */ 131 int (*memcpy_wait)(struct vfio_pci_device *device); 132 133 /** 134 * send_msi() - Make the device send the MSI device->driver.msi. 135 * 136 * Guarantees: 137 * - The device will send the MSI once. 138 */ 139 void (*send_msi)(struct vfio_pci_device *device); 140 }; 141 142 struct vfio_pci_driver { 143 const struct vfio_pci_driver_ops *ops; 144 bool initialized; 145 bool memcpy_in_progress; 146 147 /* Region to be used by the driver (e.g. for in-memory descriptors) */ 148 struct vfio_dma_region region; 149 150 /* The maximum size that can be passed to memcpy_start(). */ 151 u64 max_memcpy_size; 152 153 /* The maximum count that can be passed to memcpy_start(). */ 154 u64 max_memcpy_count; 155 156 /* The MSI vector the device will signal in ops->send_msi(). */ 157 int msi; 158 }; 159 160 struct vfio_pci_device { 161 int fd; 162 163 const struct vfio_iommu_mode *iommu_mode; 164 int group_fd; 165 int container_fd; 166 167 struct vfio_device_info info; 168 struct vfio_region_info config_space; 169 struct vfio_pci_bar bars[PCI_STD_NUM_BARS]; 170 171 struct vfio_irq_info msi_info; 172 struct vfio_irq_info msix_info; 173 174 struct list_head dma_regions; 175 176 /* eventfds for MSI and MSI-x interrupts */ 177 int msi_eventfds[PCI_MSIX_FLAGS_QSIZE + 1]; 178 179 struct vfio_pci_driver driver; 180 }; 181 182 /* 183 * Return the BDF string of the device that the test should use. 184 * 185 * If a BDF string is provided by the user on the command line (as the last 186 * element of argv[]), then this function will return that and decrement argc 187 * by 1. 188 * 189 * Otherwise this function will attempt to use the environment variable 190 * $VFIO_SELFTESTS_BDF. 191 * 192 * If BDF cannot be determined then the test will exit with KSFT_SKIP. 193 */ 194 const char *vfio_selftests_get_bdf(int *argc, char *argv[]); 195 const char *vfio_pci_get_cdev_path(const char *bdf); 196 197 extern const char *default_iommu_mode; 198 199 struct vfio_pci_device *vfio_pci_device_init(const char *bdf, const char *iommu_mode); 200 void vfio_pci_device_cleanup(struct vfio_pci_device *device); 201 void vfio_pci_device_reset(struct vfio_pci_device *device); 202 203 void vfio_pci_dma_map(struct vfio_pci_device *device, 204 struct vfio_dma_region *region); 205 void vfio_pci_dma_unmap(struct vfio_pci_device *device, 206 struct vfio_dma_region *region); 207 208 void vfio_pci_config_access(struct vfio_pci_device *device, bool write, 209 size_t config, size_t size, void *data); 210 211 #define vfio_pci_config_read(_device, _offset, _type) ({ \ 212 _type __data; \ 213 vfio_pci_config_access((_device), false, _offset, sizeof(__data), &__data); \ 214 __data; \ 215 }) 216 217 #define vfio_pci_config_readb(_d, _o) vfio_pci_config_read(_d, _o, u8) 218 #define vfio_pci_config_readw(_d, _o) vfio_pci_config_read(_d, _o, u16) 219 #define vfio_pci_config_readl(_d, _o) vfio_pci_config_read(_d, _o, u32) 220 221 #define vfio_pci_config_write(_device, _offset, _value, _type) do { \ 222 _type __data = (_value); \ 223 vfio_pci_config_access((_device), true, _offset, sizeof(_type), &__data); \ 224 } while (0) 225 226 #define vfio_pci_config_writeb(_d, _o, _v) vfio_pci_config_write(_d, _o, _v, u8) 227 #define vfio_pci_config_writew(_d, _o, _v) vfio_pci_config_write(_d, _o, _v, u16) 228 #define vfio_pci_config_writel(_d, _o, _v) vfio_pci_config_write(_d, _o, _v, u32) 229 230 void vfio_pci_irq_enable(struct vfio_pci_device *device, u32 index, 231 u32 vector, int count); 232 void vfio_pci_irq_disable(struct vfio_pci_device *device, u32 index); 233 void vfio_pci_irq_trigger(struct vfio_pci_device *device, u32 index, u32 vector); 234 235 static inline void fcntl_set_nonblock(int fd) 236 { 237 int r; 238 239 r = fcntl(fd, F_GETFL, 0); 240 VFIO_ASSERT_NE(r, -1, "F_GETFL failed for fd %d\n", fd); 241 242 r = fcntl(fd, F_SETFL, r | O_NONBLOCK); 243 VFIO_ASSERT_NE(r, -1, "F_SETFL O_NONBLOCK failed for fd %d\n", fd); 244 } 245 246 static inline void vfio_pci_msi_enable(struct vfio_pci_device *device, 247 u32 vector, int count) 248 { 249 vfio_pci_irq_enable(device, VFIO_PCI_MSI_IRQ_INDEX, vector, count); 250 } 251 252 static inline void vfio_pci_msi_disable(struct vfio_pci_device *device) 253 { 254 vfio_pci_irq_disable(device, VFIO_PCI_MSI_IRQ_INDEX); 255 } 256 257 static inline void vfio_pci_msix_enable(struct vfio_pci_device *device, 258 u32 vector, int count) 259 { 260 vfio_pci_irq_enable(device, VFIO_PCI_MSIX_IRQ_INDEX, vector, count); 261 } 262 263 static inline void vfio_pci_msix_disable(struct vfio_pci_device *device) 264 { 265 vfio_pci_irq_disable(device, VFIO_PCI_MSIX_IRQ_INDEX); 266 } 267 268 iova_t __to_iova(struct vfio_pci_device *device, void *vaddr); 269 iova_t to_iova(struct vfio_pci_device *device, void *vaddr); 270 271 static inline bool vfio_pci_device_match(struct vfio_pci_device *device, 272 u16 vendor_id, u16 device_id) 273 { 274 return (vendor_id == vfio_pci_config_readw(device, PCI_VENDOR_ID)) && 275 (device_id == vfio_pci_config_readw(device, PCI_DEVICE_ID)); 276 } 277 278 void vfio_pci_driver_probe(struct vfio_pci_device *device); 279 void vfio_pci_driver_init(struct vfio_pci_device *device); 280 void vfio_pci_driver_remove(struct vfio_pci_device *device); 281 int vfio_pci_driver_memcpy(struct vfio_pci_device *device, 282 iova_t src, iova_t dst, u64 size); 283 void vfio_pci_driver_memcpy_start(struct vfio_pci_device *device, 284 iova_t src, iova_t dst, u64 size, 285 u64 count); 286 int vfio_pci_driver_memcpy_wait(struct vfio_pci_device *device); 287 void vfio_pci_driver_send_msi(struct vfio_pci_device *device); 288 289 #endif /* SELFTESTS_VFIO_LIB_INCLUDE_VFIO_UTIL_H */ 290