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