Skip to content

Commit c4e496d

Browse files
Xu Yilunjgunthorpe
Xu Yilun
authored and
jgunthorpe
committed
iommufd/selftest: Explicitly skip tests for inapplicable variant
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>
1 parent 651f733 commit c4e496d

1 file changed

Lines changed: 176 additions & 187 deletions

File tree

‎tools/testing/selftests/iommu/iommufd.c‎

Lines changed: 176 additions & 187 deletions
Original file line numberDiff line numberDiff line change
@@ -2806,35 +2806,32 @@ TEST_F(iommufd_viommu, viommu_alloc_nested_iopf)
28062806
uint32_t fault_fd;
28072807
uint32_t vdev_id;
28082808

2809-
if (self->device_id) {
2810-
test_ioctl_fault_alloc(&fault_id, &fault_fd);
2811-
test_err_hwpt_alloc_iopf(
2812-
ENOENT, dev_id, viommu_id, UINT32_MAX,
2813-
IOMMU_HWPT_FAULT_ID_VALID, &iopf_hwpt_id,
2814-
IOMMU_HWPT_DATA_SELFTEST, &data, sizeof(data));
2815-
test_err_hwpt_alloc_iopf(
2816-
EOPNOTSUPP, dev_id, viommu_id, fault_id,
2817-
IOMMU_HWPT_FAULT_ID_VALID | (1 << 31), &iopf_hwpt_id,
2818-
IOMMU_HWPT_DATA_SELFTEST, &data, sizeof(data));
2819-
test_cmd_hwpt_alloc_iopf(
2820-
dev_id, viommu_id, fault_id, IOMMU_HWPT_FAULT_ID_VALID,
2821-
&iopf_hwpt_id, IOMMU_HWPT_DATA_SELFTEST, &data,
2822-
sizeof(data));
2809+
if (!dev_id)
2810+
SKIP(return, "Skipping test for variant no_viommu");
28232811

2824-
/* Must allocate vdevice before attaching to a nested hwpt */
2825-
test_err_mock_domain_replace(ENOENT, self->stdev_id,
2826-
iopf_hwpt_id);
2827-
test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id);
2828-
test_cmd_mock_domain_replace(self->stdev_id, iopf_hwpt_id);
2829-
EXPECT_ERRNO(EBUSY,
2830-
_test_ioctl_destroy(self->fd, iopf_hwpt_id));
2831-
test_cmd_trigger_iopf(dev_id, fault_fd);
2812+
test_ioctl_fault_alloc(&fault_id, &fault_fd);
2813+
test_err_hwpt_alloc_iopf(ENOENT, dev_id, viommu_id, UINT32_MAX,
2814+
IOMMU_HWPT_FAULT_ID_VALID, &iopf_hwpt_id,
2815+
IOMMU_HWPT_DATA_SELFTEST, &data, sizeof(data));
2816+
test_err_hwpt_alloc_iopf(EOPNOTSUPP, dev_id, viommu_id, fault_id,
2817+
IOMMU_HWPT_FAULT_ID_VALID | (1 << 31),
2818+
&iopf_hwpt_id, IOMMU_HWPT_DATA_SELFTEST, &data,
2819+
sizeof(data));
2820+
test_cmd_hwpt_alloc_iopf(dev_id, viommu_id, fault_id,
2821+
IOMMU_HWPT_FAULT_ID_VALID, &iopf_hwpt_id,
2822+
IOMMU_HWPT_DATA_SELFTEST, &data, sizeof(data));
28322823

2833-
test_cmd_mock_domain_replace(self->stdev_id, self->ioas_id);
2834-
test_ioctl_destroy(iopf_hwpt_id);
2835-
close(fault_fd);
2836-
test_ioctl_destroy(fault_id);
2837-
}
2824+
/* Must allocate vdevice before attaching to a nested hwpt */
2825+
test_err_mock_domain_replace(ENOENT, self->stdev_id, iopf_hwpt_id);
2826+
test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id);
2827+
test_cmd_mock_domain_replace(self->stdev_id, iopf_hwpt_id);
2828+
EXPECT_ERRNO(EBUSY, _test_ioctl_destroy(self->fd, iopf_hwpt_id));
2829+
test_cmd_trigger_iopf(dev_id, fault_fd);
2830+
2831+
test_cmd_mock_domain_replace(self->stdev_id, self->ioas_id);
2832+
test_ioctl_destroy(iopf_hwpt_id);
2833+
close(fault_fd);
2834+
test_ioctl_destroy(fault_id);
28382835
}
28392836

28402837
TEST_F(iommufd_viommu, viommu_alloc_with_data)
@@ -2929,169 +2926,161 @@ TEST_F(iommufd_viommu, vdevice_cache)
29292926
uint32_t vdev_id = 0;
29302927
uint32_t num_inv;
29312928

2932-
if (dev_id) {
2933-
test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id);
2934-
2935-
test_cmd_dev_check_cache_all(dev_id,
2936-
IOMMU_TEST_DEV_CACHE_DEFAULT);
2937-
2938-
/* Check data_type by passing zero-length array */
2939-
num_inv = 0;
2940-
test_cmd_viommu_invalidate(viommu_id, inv_reqs,
2941-
sizeof(*inv_reqs), &num_inv);
2942-
assert(!num_inv);
2943-
2944-
/* Negative test: Invalid data_type */
2945-
num_inv = 1;
2946-
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
2947-
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST_INVALID,
2948-
sizeof(*inv_reqs), &num_inv);
2949-
assert(!num_inv);
2950-
2951-
/* Negative test: structure size sanity */
2952-
num_inv = 1;
2953-
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
2954-
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
2955-
sizeof(*inv_reqs) + 1, &num_inv);
2956-
assert(!num_inv);
2957-
2958-
num_inv = 1;
2959-
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
2960-
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
2961-
1, &num_inv);
2962-
assert(!num_inv);
2963-
2964-
/* Negative test: invalid flag is passed */
2965-
num_inv = 1;
2966-
inv_reqs[0].flags = 0xffffffff;
2967-
inv_reqs[0].vdev_id = 0x99;
2968-
test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs,
2969-
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
2970-
sizeof(*inv_reqs), &num_inv);
2971-
assert(!num_inv);
2972-
2973-
/* Negative test: invalid data_uptr when array is not empty */
2974-
num_inv = 1;
2975-
inv_reqs[0].flags = 0;
2976-
inv_reqs[0].vdev_id = 0x99;
2977-
test_err_viommu_invalidate(EINVAL, viommu_id, NULL,
2978-
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
2979-
sizeof(*inv_reqs), &num_inv);
2980-
assert(!num_inv);
2981-
2982-
/* Negative test: invalid entry_len when array is not empty */
2983-
num_inv = 1;
2984-
inv_reqs[0].flags = 0;
2985-
inv_reqs[0].vdev_id = 0x99;
2986-
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
2987-
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
2988-
0, &num_inv);
2989-
assert(!num_inv);
2990-
2991-
/* Negative test: invalid cache_id */
2992-
num_inv = 1;
2993-
inv_reqs[0].flags = 0;
2994-
inv_reqs[0].vdev_id = 0x99;
2995-
inv_reqs[0].cache_id = MOCK_DEV_CACHE_ID_MAX + 1;
2996-
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
2997-
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
2998-
sizeof(*inv_reqs), &num_inv);
2999-
assert(!num_inv);
2929+
if (!dev_id)
2930+
SKIP(return, "Skipping test for variant no_viommu");
30002931

3001-
/* Negative test: invalid vdev_id */
3002-
num_inv = 1;
3003-
inv_reqs[0].flags = 0;
3004-
inv_reqs[0].vdev_id = 0x9;
3005-
inv_reqs[0].cache_id = 0;
3006-
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
3007-
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
3008-
sizeof(*inv_reqs), &num_inv);
3009-
assert(!num_inv);
2932+
test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id);
2933+
2934+
test_cmd_dev_check_cache_all(dev_id, IOMMU_TEST_DEV_CACHE_DEFAULT);
2935+
2936+
/* Check data_type by passing zero-length array */
2937+
num_inv = 0;
2938+
test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs),
2939+
&num_inv);
2940+
assert(!num_inv);
2941+
2942+
/* Negative test: Invalid data_type */
2943+
num_inv = 1;
2944+
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
2945+
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST_INVALID,
2946+
sizeof(*inv_reqs), &num_inv);
2947+
assert(!num_inv);
2948+
2949+
/* Negative test: structure size sanity */
2950+
num_inv = 1;
2951+
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
2952+
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
2953+
sizeof(*inv_reqs) + 1, &num_inv);
2954+
assert(!num_inv);
2955+
2956+
num_inv = 1;
2957+
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
2958+
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 1,
2959+
&num_inv);
2960+
assert(!num_inv);
2961+
2962+
/* Negative test: invalid flag is passed */
2963+
num_inv = 1;
2964+
inv_reqs[0].flags = 0xffffffff;
2965+
inv_reqs[0].vdev_id = 0x99;
2966+
test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs,
2967+
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
2968+
sizeof(*inv_reqs), &num_inv);
2969+
assert(!num_inv);
2970+
2971+
/* Negative test: invalid data_uptr when array is not empty */
2972+
num_inv = 1;
2973+
inv_reqs[0].flags = 0;
2974+
inv_reqs[0].vdev_id = 0x99;
2975+
test_err_viommu_invalidate(EINVAL, viommu_id, NULL,
2976+
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
2977+
sizeof(*inv_reqs), &num_inv);
2978+
assert(!num_inv);
2979+
2980+
/* Negative test: invalid entry_len when array is not empty */
2981+
num_inv = 1;
2982+
inv_reqs[0].flags = 0;
2983+
inv_reqs[0].vdev_id = 0x99;
2984+
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
2985+
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 0,
2986+
&num_inv);
2987+
assert(!num_inv);
2988+
2989+
/* Negative test: invalid cache_id */
2990+
num_inv = 1;
2991+
inv_reqs[0].flags = 0;
2992+
inv_reqs[0].vdev_id = 0x99;
2993+
inv_reqs[0].cache_id = MOCK_DEV_CACHE_ID_MAX + 1;
2994+
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
2995+
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
2996+
sizeof(*inv_reqs), &num_inv);
2997+
assert(!num_inv);
2998+
2999+
/* Negative test: invalid vdev_id */
3000+
num_inv = 1;
3001+
inv_reqs[0].flags = 0;
3002+
inv_reqs[0].vdev_id = 0x9;
3003+
inv_reqs[0].cache_id = 0;
3004+
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
3005+
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
3006+
sizeof(*inv_reqs), &num_inv);
3007+
assert(!num_inv);
30103008

3011-
/*
3012-
* Invalidate the 1st cache entry but fail the 2nd request
3013-
* due to invalid flags configuration in the 2nd request.
3014-
*/
3015-
num_inv = 2;
3016-
inv_reqs[0].flags = 0;
3017-
inv_reqs[0].vdev_id = 0x99;
3018-
inv_reqs[0].cache_id = 0;
3019-
inv_reqs[1].flags = 0xffffffff;
3020-
inv_reqs[1].vdev_id = 0x99;
3021-
inv_reqs[1].cache_id = 1;
3022-
test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs,
3023-
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
3024-
sizeof(*inv_reqs), &num_inv);
3025-
assert(num_inv == 1);
3026-
test_cmd_dev_check_cache(dev_id, 0, 0);
3027-
test_cmd_dev_check_cache(dev_id, 1,
3028-
IOMMU_TEST_DEV_CACHE_DEFAULT);
3029-
test_cmd_dev_check_cache(dev_id, 2,
3030-
IOMMU_TEST_DEV_CACHE_DEFAULT);
3031-
test_cmd_dev_check_cache(dev_id, 3,
3032-
IOMMU_TEST_DEV_CACHE_DEFAULT);
3033-
3034-
/*
3035-
* Invalidate the 1st cache entry but fail the 2nd request
3036-
* due to invalid cache_id configuration in the 2nd request.
3037-
*/
3038-
num_inv = 2;
3039-
inv_reqs[0].flags = 0;
3040-
inv_reqs[0].vdev_id = 0x99;
3041-
inv_reqs[0].cache_id = 0;
3042-
inv_reqs[1].flags = 0;
3043-
inv_reqs[1].vdev_id = 0x99;
3044-
inv_reqs[1].cache_id = MOCK_DEV_CACHE_ID_MAX + 1;
3045-
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
3046-
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
3047-
sizeof(*inv_reqs), &num_inv);
3048-
assert(num_inv == 1);
3049-
test_cmd_dev_check_cache(dev_id, 0, 0);
3050-
test_cmd_dev_check_cache(dev_id, 1,
3051-
IOMMU_TEST_DEV_CACHE_DEFAULT);
3052-
test_cmd_dev_check_cache(dev_id, 2,
3053-
IOMMU_TEST_DEV_CACHE_DEFAULT);
3054-
test_cmd_dev_check_cache(dev_id, 3,
3055-
IOMMU_TEST_DEV_CACHE_DEFAULT);
3056-
3057-
/* Invalidate the 2nd cache entry and verify */
3058-
num_inv = 1;
3059-
inv_reqs[0].flags = 0;
3060-
inv_reqs[0].vdev_id = 0x99;
3061-
inv_reqs[0].cache_id = 1;
3062-
test_cmd_viommu_invalidate(viommu_id, inv_reqs,
3063-
sizeof(*inv_reqs), &num_inv);
3064-
assert(num_inv == 1);
3065-
test_cmd_dev_check_cache(dev_id, 0, 0);
3066-
test_cmd_dev_check_cache(dev_id, 1, 0);
3067-
test_cmd_dev_check_cache(dev_id, 2,
3068-
IOMMU_TEST_DEV_CACHE_DEFAULT);
3069-
test_cmd_dev_check_cache(dev_id, 3,
3070-
IOMMU_TEST_DEV_CACHE_DEFAULT);
3071-
3072-
/* Invalidate the 3rd and 4th cache entries and verify */
3073-
num_inv = 2;
3074-
inv_reqs[0].flags = 0;
3075-
inv_reqs[0].vdev_id = 0x99;
3076-
inv_reqs[0].cache_id = 2;
3077-
inv_reqs[1].flags = 0;
3078-
inv_reqs[1].vdev_id = 0x99;
3079-
inv_reqs[1].cache_id = 3;
3080-
test_cmd_viommu_invalidate(viommu_id, inv_reqs,
3081-
sizeof(*inv_reqs), &num_inv);
3082-
assert(num_inv == 2);
3083-
test_cmd_dev_check_cache_all(dev_id, 0);
3009+
/*
3010+
* Invalidate the 1st cache entry but fail the 2nd request
3011+
* due to invalid flags configuration in the 2nd request.
3012+
*/
3013+
num_inv = 2;
3014+
inv_reqs[0].flags = 0;
3015+
inv_reqs[0].vdev_id = 0x99;
3016+
inv_reqs[0].cache_id = 0;
3017+
inv_reqs[1].flags = 0xffffffff;
3018+
inv_reqs[1].vdev_id = 0x99;
3019+
inv_reqs[1].cache_id = 1;
3020+
test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs,
3021+
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
3022+
sizeof(*inv_reqs), &num_inv);
3023+
assert(num_inv == 1);
3024+
test_cmd_dev_check_cache(dev_id, 0, 0);
3025+
test_cmd_dev_check_cache(dev_id, 1, IOMMU_TEST_DEV_CACHE_DEFAULT);
3026+
test_cmd_dev_check_cache(dev_id, 2, IOMMU_TEST_DEV_CACHE_DEFAULT);
3027+
test_cmd_dev_check_cache(dev_id, 3, IOMMU_TEST_DEV_CACHE_DEFAULT);
30843028

3085-
/* Invalidate all cache entries for nested_dev_id[1] and verify */
3086-
num_inv = 1;
3087-
inv_reqs[0].vdev_id = 0x99;
3088-
inv_reqs[0].flags = IOMMU_TEST_INVALIDATE_FLAG_ALL;
3089-
test_cmd_viommu_invalidate(viommu_id, inv_reqs,
3090-
sizeof(*inv_reqs), &num_inv);
3091-
assert(num_inv == 1);
3092-
test_cmd_dev_check_cache_all(dev_id, 0);
3093-
test_ioctl_destroy(vdev_id);
3094-
}
3029+
/*
3030+
* Invalidate the 1st cache entry but fail the 2nd request
3031+
* due to invalid cache_id configuration in the 2nd request.
3032+
*/
3033+
num_inv = 2;
3034+
inv_reqs[0].flags = 0;
3035+
inv_reqs[0].vdev_id = 0x99;
3036+
inv_reqs[0].cache_id = 0;
3037+
inv_reqs[1].flags = 0;
3038+
inv_reqs[1].vdev_id = 0x99;
3039+
inv_reqs[1].cache_id = MOCK_DEV_CACHE_ID_MAX + 1;
3040+
test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs,
3041+
IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST,
3042+
sizeof(*inv_reqs), &num_inv);
3043+
assert(num_inv == 1);
3044+
test_cmd_dev_check_cache(dev_id, 0, 0);
3045+
test_cmd_dev_check_cache(dev_id, 1, IOMMU_TEST_DEV_CACHE_DEFAULT);
3046+
test_cmd_dev_check_cache(dev_id, 2, IOMMU_TEST_DEV_CACHE_DEFAULT);
3047+
test_cmd_dev_check_cache(dev_id, 3, IOMMU_TEST_DEV_CACHE_DEFAULT);
3048+
3049+
/* Invalidate the 2nd cache entry and verify */
3050+
num_inv = 1;
3051+
inv_reqs[0].flags = 0;
3052+
inv_reqs[0].vdev_id = 0x99;
3053+
inv_reqs[0].cache_id = 1;
3054+
test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs),
3055+
&num_inv);
3056+
assert(num_inv == 1);
3057+
test_cmd_dev_check_cache(dev_id, 0, 0);
3058+
test_cmd_dev_check_cache(dev_id, 1, 0);
3059+
test_cmd_dev_check_cache(dev_id, 2, IOMMU_TEST_DEV_CACHE_DEFAULT);
3060+
test_cmd_dev_check_cache(dev_id, 3, IOMMU_TEST_DEV_CACHE_DEFAULT);
3061+
3062+
/* Invalidate the 3rd and 4th cache entries and verify */
3063+
num_inv = 2;
3064+
inv_reqs[0].flags = 0;
3065+
inv_reqs[0].vdev_id = 0x99;
3066+
inv_reqs[0].cache_id = 2;
3067+
inv_reqs[1].flags = 0;
3068+
inv_reqs[1].vdev_id = 0x99;
3069+
inv_reqs[1].cache_id = 3;
3070+
test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs),
3071+
&num_inv);
3072+
assert(num_inv == 2);
3073+
test_cmd_dev_check_cache_all(dev_id, 0);
3074+
3075+
/* Invalidate all cache entries for nested_dev_id[1] and verify */
3076+
num_inv = 1;
3077+
inv_reqs[0].vdev_id = 0x99;
3078+
inv_reqs[0].flags = IOMMU_TEST_INVALIDATE_FLAG_ALL;
3079+
test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs),
3080+
&num_inv);
3081+
assert(num_inv == 1);
3082+
test_cmd_dev_check_cache_all(dev_id, 0);
3083+
test_ioctl_destroy(vdev_id);
30953084
}
30963085

30973086
TEST_F(iommufd_viommu, hw_queue)

0 commit comments

Comments
 (0)