Commit 831c37a5 authored by David Matlack's avatar David Matlack Committed by Alex Williamson
Browse files

vfio: selftests: Stop passing device for IOMMU operations 



Drop the struct vfio_pci_device wrappers for IOMMU map/unmap functions
and require tests to directly call iommu_map(), iommu_unmap(), etc. This
results in more concise code, and also makes it clear the map operations
are happening on a struct iommu, not necessarily on a specific device,
especially when multi-device tests are introduced.

Do the same for iova_allocator_init() as that function only needs the
struct iommu, not struct vfio_pci_device.

Reviewed-by: default avatarAlex Mastro <amastro@fb.com>
Tested-by: default avatarAlex Mastro <amastro@fb.com>
Reviewed-by: default avatarRaghavendra Rao Ananta <rananta@google.com>
Signed-off-by: default avatarDavid Matlack <dmatlack@google.com>
Link: https://lore.kernel.org/r/20251126231733.3302983-14-dmatlack@google.com


Signed-off-by: default avatarAlex Williamson <alex@shazbot.org>
parent 2607a436

tools/testing/selftests/vfio/lib/include/vfio_util.h

+1 −43
Original line number Diff line number Diff line
@@ -260,52 +260,10 @@ void vfio_pci_device_cleanup(struct vfio_pci_device *device); 


void vfio_pci_device_reset(struct vfio_pci_device *device);



static inline struct iommu_iova_range *vfio_pci_iova_ranges(struct vfio_pci_device *device,

							    u32 *nranges)

{

	return iommu_iova_ranges(device->iommu, nranges);

}



struct iova_allocator *iova_allocator_init(struct vfio_pci_device *device);

struct iova_allocator *iova_allocator_init(struct iommu *iommu);

void iova_allocator_cleanup(struct iova_allocator *allocator);

iova_t iova_allocator_alloc(struct iova_allocator *allocator, size_t size);



static inline int __vfio_pci_dma_map(struct vfio_pci_device *device,

				     struct dma_region *region)

{

	return __iommu_map(device->iommu, region);

}



static inline void vfio_pci_dma_map(struct vfio_pci_device *device,

				    struct dma_region *region)

{

	VFIO_ASSERT_EQ(__vfio_pci_dma_map(device, region), 0);

}



static inline int __vfio_pci_dma_unmap(struct vfio_pci_device *device,

				       struct dma_region *region,

				       u64 *unmapped)

{

	return __iommu_unmap(device->iommu, region, unmapped);

}



static inline void vfio_pci_dma_unmap(struct vfio_pci_device *device,

				      struct dma_region *region)

{

	VFIO_ASSERT_EQ(__vfio_pci_dma_unmap(device, region, NULL), 0);

}



static inline int __vfio_pci_dma_unmap_all(struct vfio_pci_device *device,

					   u64 *unmapped)

{

	return __iommu_unmap_all(device->iommu, unmapped);

}



static inline void vfio_pci_dma_unmap_all(struct vfio_pci_device *device)

{

	VFIO_ASSERT_EQ(__vfio_pci_dma_unmap_all(device, NULL), 0);

}



void vfio_pci_config_access(struct vfio_pci_device *device, bool write,

			    size_t config, size_t size, void *data);

tools/testing/selftests/vfio/lib/iova_allocator.c

+2 −2
Original line number Diff line number Diff line
@@ -21,13 +21,13 @@ 


#include <vfio_util.h>



struct iova_allocator *iova_allocator_init(struct vfio_pci_device *device)

struct iova_allocator *iova_allocator_init(struct iommu *iommu)

{

	struct iova_allocator *allocator;

	struct iommu_iova_range *ranges;

	u32 nranges;



	ranges = vfio_pci_iova_ranges(device, &nranges);

	ranges = iommu_iova_ranges(iommu, &nranges);

	VFIO_ASSERT_NOT_NULL(ranges);



	allocator = malloc(sizeof(*allocator));

tools/testing/selftests/vfio/vfio_dma_mapping_test.c

+10 −10
Original line number Diff line number Diff line
@@ -122,7 +122,7 @@ FIXTURE_SETUP(vfio_dma_mapping_test) 
{

	self->iommu = iommu_init(variant->iommu_mode);

	self->device = vfio_pci_device_init(device_bdf, self->iommu);

	self->iova_allocator = iova_allocator_init(self->device);

	self->iova_allocator = iova_allocator_init(self->iommu);

}



FIXTURE_TEARDOWN(vfio_dma_mapping_test)
@@ -153,7 +153,7 @@ TEST_F(vfio_dma_mapping_test, dma_map_unmap) 
	region.iova = iova_allocator_alloc(self->iova_allocator, size);

	region.size = size;



	vfio_pci_dma_map(self->device, &region);

	iommu_map(self->iommu, &region);

	printf("Mapped HVA %p (size 0x%lx) at IOVA 0x%lx\n", region.vaddr, size, region.iova);



	ASSERT_EQ(region.iova, to_iova(self->device, region.vaddr));
@@ -195,7 +195,7 @@ TEST_F(vfio_dma_mapping_test, dma_map_unmap) 
	}



unmap:

	rc = __vfio_pci_dma_unmap(self->device, &region, &unmapped);

	rc = __iommu_unmap(self->iommu, &region, &unmapped);

	ASSERT_EQ(rc, 0);

	ASSERT_EQ(unmapped, region.size);

	printf("Unmapped IOVA 0x%lx\n", region.iova);
@@ -245,7 +245,7 @@ FIXTURE_SETUP(vfio_dma_map_limit_test) 
			     MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);

	ASSERT_NE(region->vaddr, MAP_FAILED);



	ranges = vfio_pci_iova_ranges(self->device, &nranges);

	ranges = iommu_iova_ranges(self->iommu, &nranges);

	VFIO_ASSERT_NOT_NULL(ranges);

	last_iova = ranges[nranges - 1].last;

	free(ranges);
@@ -268,10 +268,10 @@ TEST_F(vfio_dma_map_limit_test, unmap_range) 
	u64 unmapped;

	int rc;



	vfio_pci_dma_map(self->device, region);

	iommu_map(self->iommu, region);

	ASSERT_EQ(region->iova, to_iova(self->device, region->vaddr));



	rc = __vfio_pci_dma_unmap(self->device, region, &unmapped);

	rc = __iommu_unmap(self->iommu, region, &unmapped);

	ASSERT_EQ(rc, 0);

	ASSERT_EQ(unmapped, region->size);

}
@@ -282,10 +282,10 @@ TEST_F(vfio_dma_map_limit_test, unmap_all) 
	u64 unmapped;

	int rc;



	vfio_pci_dma_map(self->device, region);

	iommu_map(self->iommu, region);

	ASSERT_EQ(region->iova, to_iova(self->device, region->vaddr));



	rc = __vfio_pci_dma_unmap_all(self->device, &unmapped);

	rc = __iommu_unmap_all(self->iommu, &unmapped);

	ASSERT_EQ(rc, 0);

	ASSERT_EQ(unmapped, region->size);

}
@@ -298,10 +298,10 @@ TEST_F(vfio_dma_map_limit_test, overflow) 
	region->iova = ~(iova_t)0 & ~(region->size - 1);

	region->size = self->mmap_size;



	rc = __vfio_pci_dma_map(self->device, region);

	rc = __iommu_map(self->iommu, region);

	ASSERT_EQ(rc, -EOVERFLOW);



	rc = __vfio_pci_dma_unmap(self->device, region, NULL);

	rc = __iommu_unmap(self->iommu, region, NULL);

	ASSERT_EQ(rc, -EOVERFLOW);

}

tools/testing/selftests/vfio/vfio_pci_driver_test.c

+9 −10
Original line number Diff line number Diff line
@@ -18,7 +18,7 @@ static const char *device_bdf; 
	ASSERT_EQ(EAGAIN, errno);			\

} while (0)



static void region_setup(struct vfio_pci_device *device,

static void region_setup(struct iommu *iommu,

			 struct iova_allocator *iova_allocator,

			 struct dma_region *region, u64 size)

{
@@ -33,13 +33,12 @@ static void region_setup(struct vfio_pci_device *device, 
	region->iova = iova_allocator_alloc(iova_allocator, size);

	region->size = size;



	vfio_pci_dma_map(device, region);

	iommu_map(iommu, region);

}



static void region_teardown(struct vfio_pci_device *device,

			    struct dma_region *region)

static void region_teardown(struct iommu *iommu, struct dma_region *region)

{

	vfio_pci_dma_unmap(device, region);

	iommu_unmap(iommu, region);

	VFIO_ASSERT_EQ(munmap(region->vaddr, region->size), 0);

}
@@ -76,12 +75,12 @@ FIXTURE_SETUP(vfio_pci_driver_test) 


	self->iommu = iommu_init(variant->iommu_mode);

	self->device = vfio_pci_device_init(device_bdf, self->iommu);

	self->iova_allocator = iova_allocator_init(self->device);

	self->iova_allocator = iova_allocator_init(self->iommu);



	driver = &self->device->driver;



	region_setup(self->device, self->iova_allocator, &self->memcpy_region, SZ_1G);

	region_setup(self->device, self->iova_allocator, &driver->region, SZ_2M);

	region_setup(self->iommu, self->iova_allocator, &self->memcpy_region, SZ_1G);

	region_setup(self->iommu, self->iova_allocator, &driver->region, SZ_2M);



	/* Any IOVA that doesn't overlap memcpy_region and driver->region. */

	self->unmapped_iova = iova_allocator_alloc(self->iova_allocator, SZ_1G);
@@ -110,8 +109,8 @@ FIXTURE_TEARDOWN(vfio_pci_driver_test) 


	vfio_pci_driver_remove(self->device);



	region_teardown(self->device, &self->memcpy_region);

	region_teardown(self->device, &driver->region);

	region_teardown(self->iommu, &self->memcpy_region);

	region_teardown(self->iommu, &driver->region);



	iova_allocator_cleanup(self->iova_allocator);

	vfio_pci_device_cleanup(self->device);