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