1 // SPDX-License-Identifier: GPL-2.0-only 2 #include <sys/ioctl.h> 3 #include <sys/mman.h> 4 5 #include <linux/sizes.h> 6 #include <linux/vfio.h> 7 8 #include <vfio_util.h> 9 10 #include "../kselftest_harness.h" 11 12 static const char *device_bdf; 13 14 #define ASSERT_NO_MSI(_eventfd) do { \ 15 u64 __value; \ 16 \ 17 ASSERT_EQ(-1, read(_eventfd, &__value, 8)); \ 18 ASSERT_EQ(EAGAIN, errno); \ 19 } while (0) 20 21 static void region_setup(struct vfio_pci_device *device, 22 struct vfio_dma_region *region, u64 size) 23 { 24 const int flags = MAP_SHARED | MAP_ANONYMOUS; 25 const int prot = PROT_READ | PROT_WRITE; 26 void *vaddr; 27 28 vaddr = mmap(NULL, size, prot, flags, -1, 0); 29 VFIO_ASSERT_NE(vaddr, MAP_FAILED); 30 31 region->vaddr = vaddr; 32 region->iova = (u64)vaddr; 33 region->size = size; 34 35 vfio_pci_dma_map(device, region); 36 } 37 38 static void region_teardown(struct vfio_pci_device *device, 39 struct vfio_dma_region *region) 40 { 41 vfio_pci_dma_unmap(device, region); 42 VFIO_ASSERT_EQ(munmap(region->vaddr, region->size), 0); 43 } 44 45 FIXTURE(vfio_pci_driver_test) { 46 struct vfio_pci_device *device; 47 struct vfio_dma_region memcpy_region; 48 void *vaddr; 49 int msi_fd; 50 51 u64 size; 52 void *src; 53 void *dst; 54 iova_t src_iova; 55 iova_t dst_iova; 56 iova_t unmapped_iova; 57 }; 58 59 FIXTURE_VARIANT(vfio_pci_driver_test) { 60 const char *iommu_mode; 61 }; 62 63 #define FIXTURE_VARIANT_ADD_IOMMU_MODE(_iommu_mode) \ 64 FIXTURE_VARIANT_ADD(vfio_pci_driver_test, _iommu_mode) { \ 65 .iommu_mode = #_iommu_mode, \ 66 } 67 68 FIXTURE_VARIANT_ADD_ALL_IOMMU_MODES(); 69 70 FIXTURE_SETUP(vfio_pci_driver_test) 71 { 72 struct vfio_pci_driver *driver; 73 74 self->device = vfio_pci_device_init(device_bdf, variant->iommu_mode); 75 76 driver = &self->device->driver; 77 78 region_setup(self->device, &self->memcpy_region, SZ_1G); 79 region_setup(self->device, &driver->region, SZ_2M); 80 81 /* Any IOVA that doesn't overlap memcpy_region and driver->region. */ 82 self->unmapped_iova = 8UL * SZ_1G; 83 84 vfio_pci_driver_init(self->device); 85 self->msi_fd = self->device->msi_eventfds[driver->msi]; 86 87 /* 88 * Use the maximum size supported by the device for memcpy operations, 89 * slimmed down to fit into the memcpy region (divided by 2 so src and 90 * dst regions do not overlap). 91 */ 92 self->size = self->device->driver.max_memcpy_size; 93 self->size = min(self->size, self->memcpy_region.size / 2); 94 95 self->src = self->memcpy_region.vaddr; 96 self->dst = self->src + self->size; 97 98 self->src_iova = to_iova(self->device, self->src); 99 self->dst_iova = to_iova(self->device, self->dst); 100 } 101 102 FIXTURE_TEARDOWN(vfio_pci_driver_test) 103 { 104 struct vfio_pci_driver *driver = &self->device->driver; 105 106 vfio_pci_driver_remove(self->device); 107 108 region_teardown(self->device, &self->memcpy_region); 109 region_teardown(self->device, &driver->region); 110 111 vfio_pci_device_cleanup(self->device); 112 } 113 114 TEST_F(vfio_pci_driver_test, init_remove) 115 { 116 int i; 117 118 for (i = 0; i < 10; i++) { 119 vfio_pci_driver_remove(self->device); 120 vfio_pci_driver_init(self->device); 121 } 122 } 123 124 TEST_F(vfio_pci_driver_test, memcpy_success) 125 { 126 fcntl_set_nonblock(self->msi_fd); 127 128 memset(self->src, 'x', self->size); 129 memset(self->dst, 'y', self->size); 130 131 ASSERT_EQ(0, vfio_pci_driver_memcpy(self->device, 132 self->src_iova, 133 self->dst_iova, 134 self->size)); 135 136 ASSERT_EQ(0, memcmp(self->src, self->dst, self->size)); 137 ASSERT_NO_MSI(self->msi_fd); 138 } 139 140 TEST_F(vfio_pci_driver_test, memcpy_from_unmapped_iova) 141 { 142 fcntl_set_nonblock(self->msi_fd); 143 144 /* 145 * Ignore the return value since not all devices will detect and report 146 * accesses to unmapped IOVAs as errors. 147 */ 148 vfio_pci_driver_memcpy(self->device, self->unmapped_iova, 149 self->dst_iova, self->size); 150 151 ASSERT_NO_MSI(self->msi_fd); 152 } 153 154 TEST_F(vfio_pci_driver_test, memcpy_to_unmapped_iova) 155 { 156 fcntl_set_nonblock(self->msi_fd); 157 158 /* 159 * Ignore the return value since not all devices will detect and report 160 * accesses to unmapped IOVAs as errors. 161 */ 162 vfio_pci_driver_memcpy(self->device, self->src_iova, 163 self->unmapped_iova, self->size); 164 165 ASSERT_NO_MSI(self->msi_fd); 166 } 167 168 TEST_F(vfio_pci_driver_test, send_msi) 169 { 170 u64 value; 171 172 vfio_pci_driver_send_msi(self->device); 173 ASSERT_EQ(8, read(self->msi_fd, &value, 8)); 174 ASSERT_EQ(1, value); 175 } 176 177 TEST_F(vfio_pci_driver_test, mix_and_match) 178 { 179 u64 value; 180 int i; 181 182 for (i = 0; i < 10; i++) { 183 memset(self->src, 'x', self->size); 184 memset(self->dst, 'y', self->size); 185 186 ASSERT_EQ(0, vfio_pci_driver_memcpy(self->device, 187 self->src_iova, 188 self->dst_iova, 189 self->size)); 190 191 ASSERT_EQ(0, memcmp(self->src, self->dst, self->size)); 192 193 vfio_pci_driver_memcpy(self->device, 194 self->unmapped_iova, 195 self->dst_iova, 196 self->size); 197 198 vfio_pci_driver_send_msi(self->device); 199 ASSERT_EQ(8, read(self->msi_fd, &value, 8)); 200 ASSERT_EQ(1, value); 201 } 202 } 203 204 TEST_F_TIMEOUT(vfio_pci_driver_test, memcpy_storm, 60) 205 { 206 struct vfio_pci_driver *driver = &self->device->driver; 207 u64 total_size; 208 u64 count; 209 210 fcntl_set_nonblock(self->msi_fd); 211 212 /* 213 * Perform up to 250GiB worth of DMA reads and writes across several 214 * memcpy operations. Some devices can support even more but the test 215 * will take too long. 216 */ 217 total_size = 250UL * SZ_1G; 218 count = min(total_size / self->size, driver->max_memcpy_count); 219 220 printf("Kicking off %lu memcpys of size 0x%lx\n", count, self->size); 221 vfio_pci_driver_memcpy_start(self->device, 222 self->src_iova, 223 self->dst_iova, 224 self->size, count); 225 226 ASSERT_EQ(0, vfio_pci_driver_memcpy_wait(self->device)); 227 ASSERT_NO_MSI(self->msi_fd); 228 } 229 230 int main(int argc, char *argv[]) 231 { 232 struct vfio_pci_device *device; 233 234 device_bdf = vfio_selftests_get_bdf(&argc, argv); 235 236 device = vfio_pci_device_init(device_bdf, default_iommu_mode); 237 if (!device->driver.ops) { 238 fprintf(stderr, "No driver found for device %s\n", device_bdf); 239 return KSFT_SKIP; 240 } 241 vfio_pci_device_cleanup(device); 242 243 return test_harness_run(argc, argv); 244 } 245