Commit 7156cd9e authored by Nicolin Chen's avatar Nicolin Chen Committed by Jason Gunthorpe
Browse files

iommufd/selftest: Add IOMMU_VIOMMU_ALLOC test coverage 

Add a new iommufd_viommu FIXTURE and setup it up with a vIOMMU object.

Any new vIOMMU feature will be added as a TEST_F under that.

Link: https://patch.msgid.link/r/abe267c9d004b29cb1712ceba2f378209d4b7e01.1730836219.git.nicolinc@nvidia.com


Reviewed-by: default avatarKevin Tian <kevin.tian@intel.com>
Signed-off-by: default avatarNicolin Chen <nicolinc@nvidia.com>
Signed-off-by: default avatarJason Gunthorpe <jgg@nvidia.com>
parent db70827a

tools/testing/selftests/iommu/iommufd.c

+137 −0
Original line number Diff line number Diff line
@@ -133,6 +133,7 @@ TEST_F(iommufd, cmd_length) 
	TEST_LENGTH(iommu_option, IOMMU_OPTION, val64);

	TEST_LENGTH(iommu_vfio_ioas, IOMMU_VFIO_IOAS, __reserved);

	TEST_LENGTH(iommu_ioas_map_file, IOMMU_IOAS_MAP_FILE, iova);

	TEST_LENGTH(iommu_viommu_alloc, IOMMU_VIOMMU_ALLOC, out_viommu_id);

#undef TEST_LENGTH

}
@@ -2480,4 +2481,140 @@ TEST_F(vfio_compat_mock_domain, huge_map) 
	}

}



FIXTURE(iommufd_viommu)

{

	int fd;

	uint32_t ioas_id;

	uint32_t stdev_id;

	uint32_t hwpt_id;

	uint32_t nested_hwpt_id;

	uint32_t device_id;

	uint32_t viommu_id;

};



FIXTURE_VARIANT(iommufd_viommu)

{

	unsigned int viommu;

};



FIXTURE_SETUP(iommufd_viommu)

{

	self->fd = open("/dev/iommu", O_RDWR);

	ASSERT_NE(-1, self->fd);

	test_ioctl_ioas_alloc(&self->ioas_id);

	test_ioctl_set_default_memory_limit();



	if (variant->viommu) {

		struct iommu_hwpt_selftest data = {

			.iotlb = IOMMU_TEST_IOTLB_DEFAULT,

		};



		test_cmd_mock_domain(self->ioas_id, &self->stdev_id, NULL,

				     &self->device_id);



		/* Allocate a nesting parent hwpt */

		test_cmd_hwpt_alloc(self->device_id, self->ioas_id,

				    IOMMU_HWPT_ALLOC_NEST_PARENT,

				    &self->hwpt_id);



		/* Allocate a vIOMMU taking refcount of the parent hwpt */

		test_cmd_viommu_alloc(self->device_id, self->hwpt_id,

				      IOMMU_VIOMMU_TYPE_SELFTEST,

				      &self->viommu_id);



		/* Allocate a regular nested hwpt */

		test_cmd_hwpt_alloc_nested(self->device_id, self->viommu_id, 0,

					   &self->nested_hwpt_id,

					   IOMMU_HWPT_DATA_SELFTEST, &data,

					   sizeof(data));

	}

}



FIXTURE_TEARDOWN(iommufd_viommu)

{

	teardown_iommufd(self->fd, _metadata);

}



FIXTURE_VARIANT_ADD(iommufd_viommu, no_viommu)

{

	.viommu = 0,

};



FIXTURE_VARIANT_ADD(iommufd_viommu, mock_viommu)

{

	.viommu = 1,

};



TEST_F(iommufd_viommu, viommu_auto_destroy)

{

}



TEST_F(iommufd_viommu, viommu_negative_tests)

{

	uint32_t device_id = self->device_id;

	uint32_t ioas_id = self->ioas_id;

	uint32_t hwpt_id;



	if (self->device_id) {

		/* Negative test -- invalid hwpt (hwpt_id=0) */

		test_err_viommu_alloc(ENOENT, device_id, 0,

				      IOMMU_VIOMMU_TYPE_SELFTEST, NULL);



		/* Negative test -- not a nesting parent hwpt */

		test_cmd_hwpt_alloc(device_id, ioas_id, 0, &hwpt_id);

		test_err_viommu_alloc(EINVAL, device_id, hwpt_id,

				      IOMMU_VIOMMU_TYPE_SELFTEST, NULL);

		test_ioctl_destroy(hwpt_id);



		/* Negative test -- unsupported viommu type */

		test_err_viommu_alloc(EOPNOTSUPP, device_id, self->hwpt_id,

				      0xdead, NULL);

		EXPECT_ERRNO(EBUSY,

			     _test_ioctl_destroy(self->fd, self->hwpt_id));

		EXPECT_ERRNO(EBUSY,

			     _test_ioctl_destroy(self->fd, self->viommu_id));

	} else {

		test_err_viommu_alloc(ENOENT, self->device_id, self->hwpt_id,

				      IOMMU_VIOMMU_TYPE_SELFTEST, NULL);

	}

}



TEST_F(iommufd_viommu, viommu_alloc_nested_iopf)

{

	struct iommu_hwpt_selftest data = {

		.iotlb = IOMMU_TEST_IOTLB_DEFAULT,

	};

	uint32_t viommu_id = self->viommu_id;

	uint32_t dev_id = self->device_id;

	uint32_t iopf_hwpt_id;

	uint32_t fault_id;

	uint32_t fault_fd;



	if (self->device_id) {

		test_ioctl_fault_alloc(&fault_id, &fault_fd);

		test_err_hwpt_alloc_iopf(

			ENOENT, dev_id, viommu_id, UINT32_MAX,

			IOMMU_HWPT_FAULT_ID_VALID, &iopf_hwpt_id,

			IOMMU_HWPT_DATA_SELFTEST, &data, sizeof(data));

		test_err_hwpt_alloc_iopf(

			EOPNOTSUPP, dev_id, viommu_id, fault_id,

			IOMMU_HWPT_FAULT_ID_VALID | (1 << 31), &iopf_hwpt_id,

			IOMMU_HWPT_DATA_SELFTEST, &data, sizeof(data));

		test_cmd_hwpt_alloc_iopf(

			dev_id, viommu_id, fault_id, IOMMU_HWPT_FAULT_ID_VALID,

			&iopf_hwpt_id, IOMMU_HWPT_DATA_SELFTEST, &data,

			sizeof(data));



		test_cmd_mock_domain_replace(self->stdev_id, iopf_hwpt_id);

		EXPECT_ERRNO(EBUSY,

			     _test_ioctl_destroy(self->fd, iopf_hwpt_id));

		test_cmd_trigger_iopf(dev_id, fault_fd);



		test_cmd_mock_domain_replace(self->stdev_id, self->ioas_id);

		test_ioctl_destroy(iopf_hwpt_id);

		close(fault_fd);

		test_ioctl_destroy(fault_id);

	}

}



TEST_HARNESS_MAIN

tools/testing/selftests/iommu/iommufd_fail_nth.c

+11 −0
Original line number Diff line number Diff line
@@ -621,6 +621,7 @@ TEST_FAIL_NTH(basic_fail_nth, device) 
	uint32_t stdev_id;

	uint32_t idev_id;

	uint32_t hwpt_id;

	uint32_t viommu_id;

	__u64 iova;



	self->fd = open("/dev/iommu", O_RDWR);
@@ -663,6 +664,16 @@ TEST_FAIL_NTH(basic_fail_nth, device) 


	if (_test_cmd_mock_domain_replace(self->fd, stdev_id, hwpt_id, NULL))

		return -1;



	if (_test_cmd_hwpt_alloc(self->fd, idev_id, ioas_id, 0,

				 IOMMU_HWPT_ALLOC_NEST_PARENT, &hwpt_id,

				 IOMMU_HWPT_DATA_NONE, 0, 0))

		return -1;



	if (_test_cmd_viommu_alloc(self->fd, idev_id, hwpt_id,

				   IOMMU_VIOMMU_TYPE_SELFTEST, 0, &viommu_id))

		return -1;



	return 0;

}

tools/testing/selftests/iommu/iommufd_utils.h

+28 −0
Original line number Diff line number Diff line
@@ -819,3 +819,31 @@ static int _test_cmd_trigger_iopf(int fd, __u32 device_id, __u32 fault_fd) 


#define test_cmd_trigger_iopf(device_id, fault_fd) \

	ASSERT_EQ(0, _test_cmd_trigger_iopf(self->fd, device_id, fault_fd))



static int _test_cmd_viommu_alloc(int fd, __u32 device_id, __u32 hwpt_id,

				  __u32 type, __u32 flags, __u32 *viommu_id)

{

	struct iommu_viommu_alloc cmd = {

		.size = sizeof(cmd),

		.flags = flags,

		.type = type,

		.dev_id = device_id,

		.hwpt_id = hwpt_id,

	};

	int ret;



	ret = ioctl(fd, IOMMU_VIOMMU_ALLOC, &cmd);

	if (ret)

		return ret;

	if (viommu_id)

		*viommu_id = cmd.out_viommu_id;

	return 0;

}



#define test_cmd_viommu_alloc(device_id, hwpt_id, type, viommu_id)        \

	ASSERT_EQ(0, _test_cmd_viommu_alloc(self->fd, device_id, hwpt_id, \

					    type, 0, viommu_id))

#define test_err_viommu_alloc(_errno, device_id, hwpt_id, type, viommu_id) \

	EXPECT_ERRNO(_errno,                                               \

		     _test_cmd_viommu_alloc(self->fd, device_id, hwpt_id,  \

					    type, 0, viommu_id))