tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

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>

authored by

Xu Yilun and committed by
Jason Gunthorpe c4e496d4 651f7336

+164 -175
+164 -175
tools/testing/selftests/iommu/iommufd.c
··· 2806 2806 uint32_t fault_fd; 2807 2807 uint32_t vdev_id; 2808 2808 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"); 2823 2811 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)); 2832 2823 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); 2838 2835 } 2839 2836 2840 2837 TEST_F(iommufd_viommu, viommu_alloc_with_data) ··· 2926 2929 uint32_t vdev_id = 0; 2927 2930 uint32_t num_inv; 2928 2931 2929 - if (dev_id) { 2930 - test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id); 2932 + if (!dev_id) 2933 + SKIP(return, "Skipping test for variant no_viommu"); 2931 2934 2932 - test_cmd_dev_check_cache_all(dev_id, 2933 - IOMMU_TEST_DEV_CACHE_DEFAULT); 2935 + test_cmd_vdevice_alloc(viommu_id, dev_id, 0x99, &vdev_id); 2934 2936 2935 - /* Check data_type by passing zero-length array */ 2936 - num_inv = 0; 2937 - test_cmd_viommu_invalidate(viommu_id, inv_reqs, 2938 - sizeof(*inv_reqs), &num_inv); 2939 - assert(!num_inv); 2937 + test_cmd_dev_check_cache_all(dev_id, IOMMU_TEST_DEV_CACHE_DEFAULT); 2940 2938 2941 - /* Negative test: Invalid data_type */ 2942 - num_inv = 1; 2943 - test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 2944 - IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST_INVALID, 2945 - sizeof(*inv_reqs), &num_inv); 2946 - assert(!num_inv); 2939 + /* Check data_type by passing zero-length array */ 2940 + num_inv = 0; 2941 + test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs), 2942 + &num_inv); 2943 + assert(!num_inv); 2947 2944 2948 - /* Negative test: structure size sanity */ 2949 - num_inv = 1; 2950 - test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 2951 - IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 2952 - sizeof(*inv_reqs) + 1, &num_inv); 2953 - assert(!num_inv); 2945 + /* Negative test: Invalid data_type */ 2946 + num_inv = 1; 2947 + test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 2948 + IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST_INVALID, 2949 + sizeof(*inv_reqs), &num_inv); 2950 + assert(!num_inv); 2954 2951 2955 - num_inv = 1; 2956 - test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 2957 - IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 2958 - 1, &num_inv); 2959 - assert(!num_inv); 2952 + /* Negative test: structure size sanity */ 2953 + num_inv = 1; 2954 + test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 2955 + IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 2956 + sizeof(*inv_reqs) + 1, &num_inv); 2957 + assert(!num_inv); 2960 2958 2961 - /* Negative test: invalid flag is passed */ 2962 - num_inv = 1; 2963 - inv_reqs[0].flags = 0xffffffff; 2964 - inv_reqs[0].vdev_id = 0x99; 2965 - test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs, 2966 - IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 2967 - sizeof(*inv_reqs), &num_inv); 2968 - assert(!num_inv); 2959 + num_inv = 1; 2960 + test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 2961 + IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 1, 2962 + &num_inv); 2963 + assert(!num_inv); 2969 2964 2970 - /* Negative test: invalid data_uptr when array is not empty */ 2971 - num_inv = 1; 2972 - inv_reqs[0].flags = 0; 2973 - inv_reqs[0].vdev_id = 0x99; 2974 - test_err_viommu_invalidate(EINVAL, viommu_id, NULL, 2975 - IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 2976 - sizeof(*inv_reqs), &num_inv); 2977 - assert(!num_inv); 2965 + /* Negative test: invalid flag is passed */ 2966 + num_inv = 1; 2967 + inv_reqs[0].flags = 0xffffffff; 2968 + inv_reqs[0].vdev_id = 0x99; 2969 + test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs, 2970 + IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 2971 + sizeof(*inv_reqs), &num_inv); 2972 + assert(!num_inv); 2978 2973 2979 - /* Negative test: invalid entry_len when array is not empty */ 2980 - num_inv = 1; 2981 - inv_reqs[0].flags = 0; 2982 - inv_reqs[0].vdev_id = 0x99; 2983 - test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 2984 - IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 2985 - 0, &num_inv); 2986 - assert(!num_inv); 2974 + /* Negative test: invalid data_uptr when array is not empty */ 2975 + num_inv = 1; 2976 + inv_reqs[0].flags = 0; 2977 + inv_reqs[0].vdev_id = 0x99; 2978 + test_err_viommu_invalidate(EINVAL, viommu_id, NULL, 2979 + IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 2980 + sizeof(*inv_reqs), &num_inv); 2981 + assert(!num_inv); 2987 2982 2988 - /* Negative test: invalid cache_id */ 2989 - num_inv = 1; 2990 - inv_reqs[0].flags = 0; 2991 - inv_reqs[0].vdev_id = 0x99; 2992 - inv_reqs[0].cache_id = MOCK_DEV_CACHE_ID_MAX + 1; 2993 - test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 2994 - IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 2995 - sizeof(*inv_reqs), &num_inv); 2996 - assert(!num_inv); 2983 + /* Negative test: invalid entry_len when array is not empty */ 2984 + num_inv = 1; 2985 + inv_reqs[0].flags = 0; 2986 + inv_reqs[0].vdev_id = 0x99; 2987 + test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 2988 + IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 0, 2989 + &num_inv); 2990 + assert(!num_inv); 2997 2991 2998 - /* Negative test: invalid vdev_id */ 2999 - num_inv = 1; 3000 - inv_reqs[0].flags = 0; 3001 - inv_reqs[0].vdev_id = 0x9; 3002 - inv_reqs[0].cache_id = 0; 3003 - test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 3004 - IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 3005 - sizeof(*inv_reqs), &num_inv); 3006 - assert(!num_inv); 2992 + /* Negative test: invalid cache_id */ 2993 + num_inv = 1; 2994 + inv_reqs[0].flags = 0; 2995 + inv_reqs[0].vdev_id = 0x99; 2996 + inv_reqs[0].cache_id = MOCK_DEV_CACHE_ID_MAX + 1; 2997 + test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 2998 + IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 2999 + sizeof(*inv_reqs), &num_inv); 3000 + assert(!num_inv); 3007 3001 3008 - /* 3009 - * Invalidate the 1st cache entry but fail the 2nd request 3010 - * due to invalid flags configuration in the 2nd request. 3011 - */ 3012 - num_inv = 2; 3013 - inv_reqs[0].flags = 0; 3014 - inv_reqs[0].vdev_id = 0x99; 3015 - inv_reqs[0].cache_id = 0; 3016 - inv_reqs[1].flags = 0xffffffff; 3017 - inv_reqs[1].vdev_id = 0x99; 3018 - inv_reqs[1].cache_id = 1; 3019 - test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs, 3020 - IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 3021 - sizeof(*inv_reqs), &num_inv); 3022 - assert(num_inv == 1); 3023 - test_cmd_dev_check_cache(dev_id, 0, 0); 3024 - test_cmd_dev_check_cache(dev_id, 1, 3025 - IOMMU_TEST_DEV_CACHE_DEFAULT); 3026 - test_cmd_dev_check_cache(dev_id, 2, 3027 - IOMMU_TEST_DEV_CACHE_DEFAULT); 3028 - test_cmd_dev_check_cache(dev_id, 3, 3029 - IOMMU_TEST_DEV_CACHE_DEFAULT); 3002 + /* Negative test: invalid vdev_id */ 3003 + num_inv = 1; 3004 + inv_reqs[0].flags = 0; 3005 + inv_reqs[0].vdev_id = 0x9; 3006 + inv_reqs[0].cache_id = 0; 3007 + test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 3008 + IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 3009 + sizeof(*inv_reqs), &num_inv); 3010 + assert(!num_inv); 3030 3011 3031 - /* 3032 - * Invalidate the 1st cache entry but fail the 2nd request 3033 - * due to invalid cache_id configuration in the 2nd request. 3034 - */ 3035 - num_inv = 2; 3036 - inv_reqs[0].flags = 0; 3037 - inv_reqs[0].vdev_id = 0x99; 3038 - inv_reqs[0].cache_id = 0; 3039 - inv_reqs[1].flags = 0; 3040 - inv_reqs[1].vdev_id = 0x99; 3041 - inv_reqs[1].cache_id = MOCK_DEV_CACHE_ID_MAX + 1; 3042 - test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 3043 - IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 3044 - sizeof(*inv_reqs), &num_inv); 3045 - assert(num_inv == 1); 3046 - test_cmd_dev_check_cache(dev_id, 0, 0); 3047 - test_cmd_dev_check_cache(dev_id, 1, 3048 - IOMMU_TEST_DEV_CACHE_DEFAULT); 3049 - test_cmd_dev_check_cache(dev_id, 2, 3050 - IOMMU_TEST_DEV_CACHE_DEFAULT); 3051 - test_cmd_dev_check_cache(dev_id, 3, 3052 - IOMMU_TEST_DEV_CACHE_DEFAULT); 3012 + /* 3013 + * Invalidate the 1st cache entry but fail the 2nd request 3014 + * due to invalid flags configuration in the 2nd request. 3015 + */ 3016 + num_inv = 2; 3017 + inv_reqs[0].flags = 0; 3018 + inv_reqs[0].vdev_id = 0x99; 3019 + inv_reqs[0].cache_id = 0; 3020 + inv_reqs[1].flags = 0xffffffff; 3021 + inv_reqs[1].vdev_id = 0x99; 3022 + inv_reqs[1].cache_id = 1; 3023 + test_err_viommu_invalidate(EOPNOTSUPP, viommu_id, inv_reqs, 3024 + IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 3025 + sizeof(*inv_reqs), &num_inv); 3026 + assert(num_inv == 1); 3027 + test_cmd_dev_check_cache(dev_id, 0, 0); 3028 + test_cmd_dev_check_cache(dev_id, 1, IOMMU_TEST_DEV_CACHE_DEFAULT); 3029 + test_cmd_dev_check_cache(dev_id, 2, IOMMU_TEST_DEV_CACHE_DEFAULT); 3030 + test_cmd_dev_check_cache(dev_id, 3, IOMMU_TEST_DEV_CACHE_DEFAULT); 3053 3031 3054 - /* Invalidate the 2nd cache entry and verify */ 3055 - num_inv = 1; 3056 - inv_reqs[0].flags = 0; 3057 - inv_reqs[0].vdev_id = 0x99; 3058 - inv_reqs[0].cache_id = 1; 3059 - test_cmd_viommu_invalidate(viommu_id, inv_reqs, 3060 - sizeof(*inv_reqs), &num_inv); 3061 - assert(num_inv == 1); 3062 - test_cmd_dev_check_cache(dev_id, 0, 0); 3063 - test_cmd_dev_check_cache(dev_id, 1, 0); 3064 - test_cmd_dev_check_cache(dev_id, 2, 3065 - IOMMU_TEST_DEV_CACHE_DEFAULT); 3066 - test_cmd_dev_check_cache(dev_id, 3, 3067 - IOMMU_TEST_DEV_CACHE_DEFAULT); 3032 + /* 3033 + * Invalidate the 1st cache entry but fail the 2nd request 3034 + * due to invalid cache_id configuration in the 2nd request. 3035 + */ 3036 + num_inv = 2; 3037 + inv_reqs[0].flags = 0; 3038 + inv_reqs[0].vdev_id = 0x99; 3039 + inv_reqs[0].cache_id = 0; 3040 + inv_reqs[1].flags = 0; 3041 + inv_reqs[1].vdev_id = 0x99; 3042 + inv_reqs[1].cache_id = MOCK_DEV_CACHE_ID_MAX + 1; 3043 + test_err_viommu_invalidate(EINVAL, viommu_id, inv_reqs, 3044 + IOMMU_VIOMMU_INVALIDATE_DATA_SELFTEST, 3045 + sizeof(*inv_reqs), &num_inv); 3046 + assert(num_inv == 1); 3047 + test_cmd_dev_check_cache(dev_id, 0, 0); 3048 + test_cmd_dev_check_cache(dev_id, 1, IOMMU_TEST_DEV_CACHE_DEFAULT); 3049 + test_cmd_dev_check_cache(dev_id, 2, IOMMU_TEST_DEV_CACHE_DEFAULT); 3050 + test_cmd_dev_check_cache(dev_id, 3, IOMMU_TEST_DEV_CACHE_DEFAULT); 3068 3051 3069 - /* Invalidate the 3rd and 4th cache entries and verify */ 3070 - num_inv = 2; 3071 - inv_reqs[0].flags = 0; 3072 - inv_reqs[0].vdev_id = 0x99; 3073 - inv_reqs[0].cache_id = 2; 3074 - inv_reqs[1].flags = 0; 3075 - inv_reqs[1].vdev_id = 0x99; 3076 - inv_reqs[1].cache_id = 3; 3077 - test_cmd_viommu_invalidate(viommu_id, inv_reqs, 3078 - sizeof(*inv_reqs), &num_inv); 3079 - assert(num_inv == 2); 3080 - test_cmd_dev_check_cache_all(dev_id, 0); 3052 + /* Invalidate the 2nd cache entry and verify */ 3053 + num_inv = 1; 3054 + inv_reqs[0].flags = 0; 3055 + inv_reqs[0].vdev_id = 0x99; 3056 + inv_reqs[0].cache_id = 1; 3057 + test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs), 3058 + &num_inv); 3059 + assert(num_inv == 1); 3060 + test_cmd_dev_check_cache(dev_id, 0, 0); 3061 + test_cmd_dev_check_cache(dev_id, 1, 0); 3062 + test_cmd_dev_check_cache(dev_id, 2, IOMMU_TEST_DEV_CACHE_DEFAULT); 3063 + test_cmd_dev_check_cache(dev_id, 3, IOMMU_TEST_DEV_CACHE_DEFAULT); 3081 3064 3082 - /* Invalidate all cache entries for nested_dev_id[1] and verify */ 3083 - num_inv = 1; 3084 - inv_reqs[0].vdev_id = 0x99; 3085 - inv_reqs[0].flags = IOMMU_TEST_INVALIDATE_FLAG_ALL; 3086 - test_cmd_viommu_invalidate(viommu_id, inv_reqs, 3087 - sizeof(*inv_reqs), &num_inv); 3088 - assert(num_inv == 1); 3089 - test_cmd_dev_check_cache_all(dev_id, 0); 3090 - test_ioctl_destroy(vdev_id); 3091 - } 3065 + /* Invalidate the 3rd and 4th cache entries and verify */ 3066 + num_inv = 2; 3067 + inv_reqs[0].flags = 0; 3068 + inv_reqs[0].vdev_id = 0x99; 3069 + inv_reqs[0].cache_id = 2; 3070 + inv_reqs[1].flags = 0; 3071 + inv_reqs[1].vdev_id = 0x99; 3072 + inv_reqs[1].cache_id = 3; 3073 + test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs), 3074 + &num_inv); 3075 + assert(num_inv == 2); 3076 + test_cmd_dev_check_cache_all(dev_id, 0); 3077 + 3078 + /* Invalidate all cache entries for nested_dev_id[1] and verify */ 3079 + num_inv = 1; 3080 + inv_reqs[0].vdev_id = 0x99; 3081 + inv_reqs[0].flags = IOMMU_TEST_INVALIDATE_FLAG_ALL; 3082 + test_cmd_viommu_invalidate(viommu_id, inv_reqs, sizeof(*inv_reqs), 3083 + &num_inv); 3084 + assert(num_inv == 1); 3085 + test_cmd_dev_check_cache_all(dev_id, 0); 3086 + test_ioctl_destroy(vdev_id); 3092 3087 } 3093 3088 3094 3089 TEST_F(iommufd_viommu, hw_queue)