mirrors/linux
2
0
Fork 0
mirror of https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git synced 2026-05-20 06:21:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

iommufd/selftest: Explicitly skip tests for inapplicable variant

Browse Source 
no_viommu is not applicable for some viommu/vdevice tests. Explicitly
report the skipping, don't do it silently.

Opportunistically adjust the line wrappings after the indentation
changes using git clang-format.

Only add the prints. No functional change intended.

Link: https://patch.msgid.link/r/20250716070349.1807226-7-yilun.xu@linux.intel.com
Reviewed-by: Jason Gunthorpe <jgg@nvidia.com>
Reviewed-by: Kevin Tian <kevin.tian@intel.com>
Reviewed-by: Nicolin Chen <nicolinc@nvidia.com>
Tested-by: Nicolin Chen <nicolinc@nvidia.com>
Signed-off-by: Xu Yilun <yilun.xu@linux.intel.com>
Signed-off-by: Jason Gunthorpe <jgg@nvidia.com>
This commit is contained in:
Xu Yilun
2025-07-16 15:03:47 +08:00
committed by Jason Gunthorpe
parent 651f733675
commit c4e496d413
1 changed files with 164 additions and 175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

339
tools/testing/selftests/iommu/iommufd.c
View File

@@ -2806,35 +2806,32 @@ TEST_F(iommufd_viommu, viommu_alloc_nested_iopf)
uint32_t fault_fd;
uint32_t vdev_id;
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));
if (!dev_id)
SKIP(return, "Skipping test for variant no_viommu");
/* Must allocate vdevice before attaching to a nested hwpt */
test_err_mock_domain_replace(ENOENT, self->stdev_id,
iopf_hwpt_id);
test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id);
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_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, self->ioas_id);
test_ioctl_destroy(iopf_hwpt_id);
close(fault_fd);
test_ioctl_destroy(fault_id);
}
/* Must allocate vdevice before attaching to a nested hwpt */
test_err_mock_domain_replace(ENOENT, self->stdev_id, iopf_hwpt_id);
test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id);
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_F(iommufd_viommu, viommu_alloc_with_data)
@@ -2929,169 +2926,161 @@ TEST_F(iommufd_viommu, vdevice_cache)
uint32_t vdev_id = 0;
uint32_t num_inv;
if (dev_id) {
test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id);
if (!dev_id)
SKIP(return, "Skipping test for variant no_viommu");
test_cmd_dev_check_cache_all(dev_id,
IOMMU_TEST_DEV_CACHE_DEFAULT);
test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id);
/* Check data_type by passing zero-length array */
num_inv = 0;
test_cmd_viommu_invalidate(viommu_id, inv_reqs,
sizeof(*inv_reqs), &num_inv);
assert(!num_inv);
test_cmd_dev_check_cache_all(dev_id, IOMMU_TEST_DEV_CACHE_DEFAULT);
/* Negative test: Invalid data_type */
num_inv = 1;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST_INVALID,
sizeof(*inv_reqs), &num_inv);
assert(!num_inv);
/* Check data_type by passing zero-length array */
num_inv = 0;
test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs),
&num_inv);
assert(!num_inv);
/* Negative test: structure size sanity */
num_inv = 1;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs) + 1, &num_inv);
assert(!num_inv);
/* Negative test: Invalid data_type */
num_inv = 1;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST_INVALID,
sizeof(*inv_reqs), &num_inv);
assert(!num_inv);
num_inv = 1;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
1, &num_inv);
assert(!num_inv);
/* Negative test: structure size sanity */
num_inv = 1;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs) + 1, &num_inv);
assert(!num_inv);
/* Negative test: invalid flag is passed */
num_inv = 1;
inv_reqs[0].flags = 0xffffffff;
inv_reqs[0].vdev_id = 0x99;
test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(!num_inv);
num_inv = 1;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 1,
&num_inv);
assert(!num_inv);
/* Negative test: invalid data_uptr when array is not empty */
num_inv = 1;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
test_err_viommu_invalidate(EINVAL, viommu_id, NULL,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(!num_inv);
/* Negative test: invalid flag is passed */
num_inv = 1;
inv_reqs[0].flags = 0xffffffff;
inv_reqs[0].vdev_id = 0x99;
test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(!num_inv);
/* Negative test: invalid entry_len when array is not empty */
num_inv = 1;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
0, &num_inv);
assert(!num_inv);
/* Negative test: invalid data_uptr when array is not empty */
num_inv = 1;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
test_err_viommu_invalidate(EINVAL, viommu_id, NULL,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(!num_inv);
/* Negative test: invalid cache_id */
num_inv = 1;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].cache_id = MOCK_DEV_CACHE_ID_MAX + 1;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(!num_inv);
/* Negative test: invalid entry_len when array is not empty */
num_inv = 1;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 0,
&num_inv);
assert(!num_inv);
/* Negative test: invalid vdev_id */
num_inv = 1;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x9;
inv_reqs[0].cache_id = 0;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(!num_inv);
/* Negative test: invalid cache_id */
num_inv = 1;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].cache_id = MOCK_DEV_CACHE_ID_MAX + 1;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(!num_inv);
/*
* Invalidate the 1st cache entry but fail the 2nd request
* due to invalid flags configuration in the 2nd request.
*/
num_inv = 2;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].cache_id = 0;
inv_reqs[1].flags = 0xffffffff;
inv_reqs[1].vdev_id = 0x99;
inv_reqs[1].cache_id = 1;
test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(num_inv == 1);
test_cmd_dev_check_cache(dev_id, 0, 0);
test_cmd_dev_check_cache(dev_id, 1,
IOMMU_TEST_DEV_CACHE_DEFAULT);
test_cmd_dev_check_cache(dev_id, 2,
IOMMU_TEST_DEV_CACHE_DEFAULT);
test_cmd_dev_check_cache(dev_id, 3,
IOMMU_TEST_DEV_CACHE_DEFAULT);
/* Negative test: invalid vdev_id */
num_inv = 1;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x9;
inv_reqs[0].cache_id = 0;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(!num_inv);
/*
* Invalidate the 1st cache entry but fail the 2nd request
* due to invalid cache_id configuration in the 2nd request.
*/
num_inv = 2;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].cache_id = 0;
inv_reqs[1].flags = 0;
inv_reqs[1].vdev_id = 0x99;
inv_reqs[1].cache_id = MOCK_DEV_CACHE_ID_MAX + 1;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(num_inv == 1);
test_cmd_dev_check_cache(dev_id, 0, 0);
test_cmd_dev_check_cache(dev_id, 1,
IOMMU_TEST_DEV_CACHE_DEFAULT);
test_cmd_dev_check_cache(dev_id, 2,
IOMMU_TEST_DEV_CACHE_DEFAULT);
test_cmd_dev_check_cache(dev_id, 3,
IOMMU_TEST_DEV_CACHE_DEFAULT);
/*
* Invalidate the 1st cache entry but fail the 2nd request
* due to invalid flags configuration in the 2nd request.
*/
num_inv = 2;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].cache_id = 0;
inv_reqs[1].flags = 0xffffffff;
inv_reqs[1].vdev_id = 0x99;
inv_reqs[1].cache_id = 1;
test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(num_inv == 1);
test_cmd_dev_check_cache(dev_id, 0, 0);
test_cmd_dev_check_cache(dev_id, 1, IOMMU_TEST_DEV_CACHE_DEFAULT);
test_cmd_dev_check_cache(dev_id, 2, IOMMU_TEST_DEV_CACHE_DEFAULT);
test_cmd_dev_check_cache(dev_id, 3, IOMMU_TEST_DEV_CACHE_DEFAULT);
/* Invalidate the 2nd cache entry and verify */
num_inv = 1;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].cache_id = 1;
test_cmd_viommu_invalidate(viommu_id, inv_reqs,
sizeof(*inv_reqs), &num_inv);
assert(num_inv == 1);
test_cmd_dev_check_cache(dev_id, 0, 0);
test_cmd_dev_check_cache(dev_id, 1, 0);
test_cmd_dev_check_cache(dev_id, 2,
IOMMU_TEST_DEV_CACHE_DEFAULT);
test_cmd_dev_check_cache(dev_id, 3,
IOMMU_TEST_DEV_CACHE_DEFAULT);
/*
* Invalidate the 1st cache entry but fail the 2nd request
* due to invalid cache_id configuration in the 2nd request.
*/
num_inv = 2;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].cache_id = 0;
inv_reqs[1].flags = 0;
inv_reqs[1].vdev_id = 0x99;
inv_reqs[1].cache_id = MOCK_DEV_CACHE_ID_MAX + 1;
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
sizeof(*inv_reqs), &num_inv);
assert(num_inv == 1);
test_cmd_dev_check_cache(dev_id, 0, 0);
test_cmd_dev_check_cache(dev_id, 1, IOMMU_TEST_DEV_CACHE_DEFAULT);
test_cmd_dev_check_cache(dev_id, 2, IOMMU_TEST_DEV_CACHE_DEFAULT);
test_cmd_dev_check_cache(dev_id, 3, IOMMU_TEST_DEV_CACHE_DEFAULT);
/* Invalidate the 3rd and 4th cache entries and verify */
num_inv = 2;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].cache_id = 2;
inv_reqs[1].flags = 0;
inv_reqs[1].vdev_id = 0x99;
inv_reqs[1].cache_id = 3;
test_cmd_viommu_invalidate(viommu_id, inv_reqs,
sizeof(*inv_reqs), &num_inv);
assert(num_inv == 2);
test_cmd_dev_check_cache_all(dev_id, 0);
/* Invalidate the 2nd cache entry and verify */
num_inv = 1;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].cache_id = 1;
test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs),
&num_inv);
assert(num_inv == 1);
test_cmd_dev_check_cache(dev_id, 0, 0);
test_cmd_dev_check_cache(dev_id, 1, 0);
test_cmd_dev_check_cache(dev_id, 2, IOMMU_TEST_DEV_CACHE_DEFAULT);
test_cmd_dev_check_cache(dev_id, 3, IOMMU_TEST_DEV_CACHE_DEFAULT);
/* Invalidate all cache entries for nested_dev_id[1] and verify */
num_inv = 1;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].flags = IOMMU_TEST_INVALIDATE_FLAG_ALL;
test_cmd_viommu_invalidate(viommu_id, inv_reqs,
sizeof(*inv_reqs), &num_inv);
assert(num_inv == 1);
test_cmd_dev_check_cache_all(dev_id, 0);
test_ioctl_destroy(vdev_id);
}
/* Invalidate the 3rd and 4th cache entries and verify */
num_inv = 2;
inv_reqs[0].flags = 0;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].cache_id = 2;
inv_reqs[1].flags = 0;
inv_reqs[1].vdev_id = 0x99;
inv_reqs[1].cache_id = 3;
test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs),
&num_inv);
assert(num_inv == 2);
test_cmd_dev_check_cache_all(dev_id, 0);
/* Invalidate all cache entries for nested_dev_id[1] and verify */
num_inv = 1;
inv_reqs[0].vdev_id = 0x99;
inv_reqs[0].flags = IOMMU_TEST_INVALIDATE_FLAG_ALL;
test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs),
&num_inv);
assert(num_inv == 1);
test_cmd_dev_check_cache_all(dev_id, 0);
test_ioctl_destroy(vdev_id);
}
TEST_F(iommufd_viommu, hw_queue)