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>

diff --git a/tools/testing/selftests/iommu/iommufd.c b/tools/testing/selftests/iommu/iommufd.c
index 9d6c6fbbebb41e8e4ee66eda14fe9ac8ebe544b8..d16fd9928b31fe2ccd49612026a2439e379cc907 100644 (file)
--- a/tools/testing/selftests/iommu/iommufd.c
+++ b/tools/testing/selftests/iommu/iommufd.c
@@ -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);
-
-               test_cmd_dev_check_cache_all(dev_id,
-                                            IOMMU_TEST_DEV_CACHE_DEFAULT);
-
-               /* 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: 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);
-
-               /* 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);
-
-               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 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 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 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 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);
+       if (!dev_id)
+               SKIP(return, "Skipping test for variant no_viommu");
 
-               /* 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);
+       test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id);
+
+       test_cmd_dev_check_cache_all(dev_id, IOMMU_TEST_DEV_CACHE_DEFAULT);
+
+       /* 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: 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);
+
+       /* 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);
+
+       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 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 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 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 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 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 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 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 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 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 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 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 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 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 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)