All of lore.kernel.org
 help / color / mirror / Atom feed
From: Alessio Belle <Alessio.Belle@imgtec.com>
To: "igt-dev@lists.freedesktop.org" <igt-dev@lists.freedesktop.org>,
	Luigi Santivetti <Luigi.Santivetti@imgtec.com>
Cc: Brajesh Gupta <Brajesh.Gupta@imgtec.com>
Subject: Re: [PATCH i-g-t v2] tests/imagination: add more heap info and static areas query tests
Date: Mon, 16 Nov 2026 16:46:57 +0000	[thread overview]
Message-ID: <2f8a676328ea9620e7bc44f15e2b4468cdd76fcc.camel@imgtec.com> (raw)
In-Reply-To: <20261116-b4-heap-static-area-info-get-v2-1-0afb0bfbb07e@imgtec.com>

On Mon, 2026-11-16 at 13:05 +0000, Luigi Santivetti wrote:
> Test the following combination of properties:
> 
>   P01. Make 1 ioctl call to query either heaps or static data
>   P02. Make 2 ioctl calls to query either heaps or static data
>   P03. UMD(stride) > KMD(stride)
>   P04. UMD(count) > KMD(count)
>   P05. UMD(count) < KMD(count)
>   P06. count is zero
>   P07. stride is too small
>   P08. retrieve the legacy value of KMD(stride)
>   P09. retrieve the legacy value of KMD(count)
>   P10. retrieve the value of KMD(stride)
>   P11. retrieve the value of KMD(count), where count is:
>        - for heaps, defined in the UAPI as DRM_PVR_HEAP_COUNT
>        - for static data areas, only known to the kernel
>   P12. count is UMD(DRM_PVR_HEAP_COUNT)
> 
> DRM_PVR_DEV_QUERY_HEAP_INFO_GET:
> 
>        |P01|P02|P03|P04|P05|P06|P07|P08|P09|P10|P11|P12|
>    T1  |  X|   |   |   |   |  X|   |   |   |   |   |   |
>    T2  |  X|   |   |   |   |   |  X|   |   |   |   |   |
>    T3  |  X|   |   |   |   |   |   |   |   |   |   |  X|
>    T4  |  X|   |   |   |   |   |   |  X|  X|   |   |   |
>    T5  |   |  X|   |   |   |   |   |   |   |  X|  X|   |
>    T6  |   |  X|   |   |   |   |   |  X|  X|   |   |   |
>    T7  |   |  X|   |   |  X|   |   |   |   |   |   |   |
>    T8  |   |  X|   |  X|   |   |   |   |   |   |   |   |
>    T9  |   |  X|  X|   |   |   |   |   |   |   |   |   |
> 
> DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET:
> 
>        |P01|P02|P03|P04|P05|P06|P07|P08|P09|P10|P11|P12|
>    T1  |  X|   |   |   |   |  X|   |   |   |   |   |   |
>    T2  |  X|   |   |   |   |   |  X|   |   |   |   |   |
>    T3  | -------------------- N/A -------------------- |
>    T4  |  X|   |   |   |   |   |   |  X|  X|   |   |   |
>    T5  |   |  X|   |   |   |   |   |   |   |  X|  X|   |
>    T6  |   |  X|   |   |   |   |   |  X|  X|   |   |   |
>    T7  |   |  X|   |   |  X|   |   |   |   |   |   |   |
>    T8  |   |  X|   |  X|   |   |   |   |   |   |   |   |
>    T9  |   |  X|  X|   |   |   |   |   |   |   |   |   |
> 
> Signed-off-by: Luigi Santivetti <luigi.santivetti@imgtec.com>

Reviewed-by: Alessio Belle <alessio.belle@imgtec.com>

Thanks,
Alessio

> ---
> This patch depends on one kernel series that is not yet merged:
> 
>   https://lore.kernel.org/all/20261104-ioctl-query-count-stride-fixes-v1-0-2bf86dd7cf29@imgtec.com/
> ---
> Changes in v2:
> - s/count-umd-gt-kmd/count-umd-lt-kmd in heap info query, thank you Alessio
> - Link to v1: https://patch.msgid.link/20261105-b4-heap-static-area-info-get-v1-1-8d5aa15a5e30@imgtec.com
> ---
>  tests/imagination/pvr_heap_info.c | 585 ++++++++++++++++++++++++++++++++++++++
>  1 file changed, 585 insertions(+)
> 
> diff --git a/tests/imagination/pvr_heap_info.c b/tests/imagination/pvr_heap_info.c
> index fa8591a97..9b98d5cbd 100644
> --- a/tests/imagination/pvr_heap_info.c
> +++ b/tests/imagination/pvr_heap_info.c
> @@ -28,6 +28,10 @@ int igt_main()
>  		fd = drm_open_driver(DRIVER_POWERVR);
>  	}
>  
> +	/***********************************************************************
> +	   DRM_PVR_DEV_QUERY_HEAP_INFO_GET
> +	 ***********************************************************************/
> +
>  	igt_describe("Test getting the size of an array from the kernel");
>  	igt_subtest("heap-info-get-size")
>  	{
> @@ -123,6 +127,309 @@ int igt_main()
>  		free(heaps);
>  	}
>  
> +/* Value of stride and count as defined in the first released version of the UAPI. */
> +#define LEGACY_STRIDE (offsetof(struct drm_pvr_heap, page_size_log2) + sizeof(heaps->page_size_log2))
> +#define LEGACY_COUNT (DRM_PVR_HEAP_TRANSFER_FRAG + 1)
> +
> +	igt_describe("Query, with one ioctl call, zero DRM PVR heaps");
> +	igt_subtest("heap-info-get-1-count-zero")
> +	{
> +		struct drm_pvr_heap heaps = { 0 };
> +		struct drm_pvr_dev_query_heap_info query = {
> +			.heaps = DRM_PVR_OBJ_ARRAY(0, &heaps),
> +		};
> +
> +		igt_assert(!query.heaps.count &&
> +			   query.heaps.stride &&
> +			   query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.heaps.count ||
> +			    query.heaps.stride != sizeof(heaps) ||
> +			    query.heaps.array != (uintptr_t)&heaps);
> +	}
> +
> +	igt_describe("Query, with one ioctl call, one heap using an invalid stride");
> +	igt_subtest("heap-info-get-1-stride-too-small")
> +	{
> +		struct drm_pvr_heap heaps = { 0 };
> +		struct drm_pvr_dev_query_heap_info query = {
> +			.heaps = DRM_PVR_OBJ_ARRAY(1, &heaps),
> +		};
> +
> +		query.heaps.stride = 1;
> +
> +		igt_assert(query.heaps.count &&
> +			   query.heaps.stride &&
> +			   query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, EINVAL);
> +	}
> +
> +	igt_describe("Query, with one ioctl call, all heaps known to userspace");
> +	igt_subtest("heap-info-get-1")
> +	{
> +		struct drm_pvr_heap heaps[DRM_PVR_HEAP_COUNT] = { 0 };
> +		struct drm_pvr_dev_query_heap_info query = {
> +			.heaps = DRM_PVR_OBJ_ARRAY(ARRAY_SIZE(heaps), heaps),
> +		};
> +
> +		igt_assert(DRM_PVR_HEAP_COUNT == ARRAY_SIZE(heaps));
> +		igt_assert(query.heaps.count == DRM_PVR_HEAP_COUNT &&
> +			   query.heaps.stride == sizeof(*heaps) &&
> +			   query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.heaps.count > DRM_PVR_HEAP_COUNT ||
> +			    query.heaps.stride != sizeof(*heaps) ||
> +			    query.heaps.array != (uintptr_t)heaps);
> +	}
> +
> +	igt_describe("Query, with one ioctl call, the legacy value of stride and count");
> +	igt_subtest("heap-info-get-1-legacy")
> +	{
> +		struct drm_pvr_dev_query_heap_info query = { 0 };
> +		struct drm_pvr_heap *heaps = NULL;
> +
> +		igt_assert(!query.heaps.count &&
> +			   !query.heaps.stride &&
> +			   !query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.heaps.count != LEGACY_COUNT ||
> +			    query.heaps.stride != LEGACY_STRIDE ||
> +			    query.heaps.array);
> +	}
> +
> +	igt_describe("Query, with two ioctl calls, all heaps known to the kernel");
> +	igt_subtest("heap-info-get-2")
> +	{
> +		struct drm_pvr_dev_query_heap_info query = {
> +			.heaps = { .stride = ~0U, .count = ~0U, },
> +		};
> +		uint32_t ioctl1_count = ~0U, ioctl1_stride = ~0U;
> +		struct drm_pvr_heap *heaps = NULL;
> +
> +		igt_assert(query.heaps.count &&
> +			   query.heaps.stride &&
> +			   !query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.heaps.count == ~0U ||
> +			    query.heaps.stride == ~0U ||
> +			    query.heaps.array);
> +
> +		ioctl1_stride = query.heaps.stride;
> +		ioctl1_count = query.heaps.count;
> +
> +		heaps = calloc(ioctl1_count, ioctl1_stride);
> +		igt_fail_on(!heaps);
> +
> +		query.heaps = (struct drm_pvr_obj_array)
> +			DRM_PVR_OBJ_ARRAY(query.heaps.count, heaps);
> +
> +		igt_assert(query.heaps.count &&
> +			   query.heaps.stride &&
> +			   query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.heaps.count != ioctl1_count ||
> +			    query.heaps.stride != ioctl1_stride ||
> +			    query.heaps.array != (uintptr_t)heaps);
> +
> +		free(heaps);
> +	}
> +
> +	igt_describe("Query, with two ioctl calls, the legacy value of stride and count");
> +	igt_subtest("heap-info-get-2-legacy")
> +	{
> +		struct drm_pvr_dev_query_heap_info query = { 0 };
> +		struct drm_pvr_heap *heaps = NULL;
> +
> +		igt_assert(!query.heaps.count &&
> +			   !query.heaps.stride &&
> +			   !query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.heaps.count != LEGACY_COUNT ||
> +			    query.heaps.stride != LEGACY_STRIDE ||
> +			    query.heaps.array);
> +
> +		heaps = calloc(query.heaps.count, sizeof(*heaps));
> +		igt_fail_on(!heaps);
> +
> +		query.heaps = (struct drm_pvr_obj_array)
> +			DRM_PVR_OBJ_ARRAY(query.heaps.count, heaps);
> +
> +		igt_assert(query.heaps.count &&
> +			   query.heaps.stride &&
> +			   query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.heaps.count != LEGACY_COUNT ||
> +			    query.heaps.stride != LEGACY_STRIDE ||
> +			    query.heaps.array != (uintptr_t)heaps);
> +
> +		free(heaps);
> +	}
> +
> +	igt_describe("Query, with two ioctl calls, heaps where UMD(count) < KMD(count)");
> +	igt_subtest("heap-info-get-2-count-umd-lt-kmd")
> +	{
> +		struct drm_pvr_dev_query_heap_info query = {
> +			.heaps = { .stride = ~0U, .count = ~0U, },
> +		};
> +		uint32_t umd_count, kmd_count;
> +
> +		igt_assert(query.heaps.count &&
> +			   query.heaps.stride &&
> +			   !query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.heaps.count == ~0U ||
> +			    query.heaps.stride == ~0U ||
> +			    query.heaps.array);
> +
> +		kmd_count = query.heaps.count;
> +		umd_count = kmd_count - 1;
> +
> +		igt_assert(kmd_count && umd_count < kmd_count);
> +
> +		for (uint32_t count = umd_count; count; count--) {
> +			struct drm_pvr_heap *heaps = calloc(count, sizeof(*heaps));
> +			query = (struct drm_pvr_dev_query_heap_info){
> +				.heaps = DRM_PVR_OBJ_ARRAY(count, heaps),
> +			};
> +
> +			igt_assert(query.heaps.count < kmd_count &&
> +				   query.heaps.stride &&
> +				   query.heaps.array);
> +
> +			igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +						sizeof(query), &query, 0);
> +
> +			igt_fail_on(query.heaps.count != count ||
> +				    query.heaps.stride != sizeof(*heaps) ||
> +				    query.heaps.array != (uintptr_t)heaps);
> +
> +			free(heaps);
> +		}
> +	}
> +
> +	igt_describe("Query, with two ioctl calls, heaps where UMD(count) > KMD(count)");
> +	igt_subtest("heap-info-get-2-count-umd-gt-kmd")
> +	{
> +		struct drm_pvr_dev_query_heap_info query = {
> +			.heaps = { .stride = ~0U, .count = ~0U, },
> +		};
> +		uint32_t umd_count, kmd_count;
> +
> +		igt_assert(query.heaps.count &&
> +			   query.heaps.stride &&
> +			   !query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.heaps.count == ~0U ||
> +			    query.heaps.stride == ~0U ||
> +			    query.heaps.array);
> +
> +		kmd_count = query.heaps.count;
> +		umd_count = kmd_count * 2;
> +
> +		igt_assert(kmd_count && umd_count > kmd_count);
> +
> +		for (uint32_t count = umd_count; count > kmd_count; count--) {
> +			struct drm_pvr_heap *heaps = calloc(count, sizeof(*heaps));
> +			query = (struct drm_pvr_dev_query_heap_info){
> +				.heaps = DRM_PVR_OBJ_ARRAY(count, heaps),
> +			};
> +
> +			igt_assert(query.heaps.count > kmd_count &&
> +				   query.heaps.stride &&
> +				   query.heaps.array);
> +
> +			igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +						sizeof(query), &query, 0);
> +
> +			igt_fail_on(query.heaps.count != kmd_count ||
> +				    query.heaps.stride != sizeof(*heaps) ||
> +				    query.heaps.array != (uintptr_t)heaps);
> +
> +			free(heaps);
> +		}
> +	}
> +
> +	igt_describe("Query, with two ioctl calls, heaps where UMD(stride) > KMD(stride)");
> +	igt_subtest("heap-info-get-2-stride-umd-gt-kmd")
> +	{
> +		struct drm_pvr_dev_query_heap_info query = {
> +			.heaps = { .stride = ~0U, .count = ~0U, },
> +		};
> +		struct drm_pvr_heap heaps = { 0 };
> +		uint32_t umd_stride, kmd_stride;
> +
> +		igt_assert(query.heaps.count &&
> +			   query.heaps.stride &&
> +			   !query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.heaps.count == ~0U ||
> +			    query.heaps.stride == ~0U ||
> +			    query.heaps.array);
> +
> +		kmd_stride = query.heaps.stride;
> +		umd_stride = ALIGN(kmd_stride + 1, sizeof(uint64_t));
> +
> +		igt_assert(kmd_stride && umd_stride > kmd_stride);
> +
> +		query = (struct drm_pvr_dev_query_heap_info){
> +			.heaps = {
> +				.count = 1,
> +				.stride = umd_stride,
> +				.array = (uintptr_t)&heaps,
> +			},
> +		};
> +
> +		igt_assert(query.heaps.count &&
> +			   query.heaps.stride > kmd_stride &&
> +			   query.heaps.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_HEAP_INFO_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.heaps.count != 1 ||
> +			    query.heaps.stride != umd_stride ||
> +			    query.heaps.array != (uintptr_t)&heaps);
> +	}
> +
> +#undef LEGACY_STRIDE
> +#undef LEGACY_COUNT
> +
> +	/***********************************************************************
> +	   DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET
> +	 ***********************************************************************/
> +
>  	igt_describe("Test validity of static data areas");
>  	igt_subtest("heap-info-static-data-areas-valid")
>  	{
> @@ -162,6 +469,284 @@ int igt_main()
>  		free(static_data_areas);
>  	}
>  
> +/* Value of stride and count as defined in the first released version of the UAPI. */
> +#define LEGACY_STRIDE (offsetof(struct drm_pvr_static_data_area, offset) + sizeof(areas->offset))
> +#define LEGACY_COUNT (5U)
> +
> +	igt_describe("Query, with one ioctl call, zero static areas");
> +	igt_subtest("heap-info-static-data-areas-get-1-count-zero")
> +	{
> +		struct drm_pvr_static_data_area areas = { 0 };
> +		struct drm_pvr_dev_query_static_data_areas query = {
> +			.static_data_areas = DRM_PVR_OBJ_ARRAY(0, &areas),
> +		};
> +
> +		igt_assert(!query.static_data_areas.count &&
> +			   query.static_data_areas.stride &&
> +			   query.static_data_areas.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.static_data_areas.count ||
> +			    query.static_data_areas.stride != sizeof(areas) ||
> +			    query.static_data_areas.array != (uintptr_t)&areas);
> +	}
> +
> +	igt_describe("Query, with one ioctl call, one static area using an invalid stride");
> +	igt_subtest("heap-info-static-data-areas-get-1-stride-too-small")
> +	{
> +		struct drm_pvr_static_data_area areas = { 0 };
> +		struct drm_pvr_dev_query_static_data_areas query = {
> +			.static_data_areas = DRM_PVR_OBJ_ARRAY(1, &areas),
> +		};
> +
> +		query.static_data_areas.stride = 1;
> +
> +		igt_assert(query.static_data_areas.count &&
> +			   query.static_data_areas.stride &&
> +			   query.static_data_areas.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +					sizeof(query), &query, EINVAL);
> +	}
> +
> +	igt_describe("Query, with one ioctl call, the legacy value of stride and count");
> +	igt_subtest("heap-info-static-data-areas-get-1-legacy")
> +	{
> +		struct drm_pvr_dev_query_static_data_areas query = { 0 };
> +		struct drm_pvr_static_data_area *areas = NULL;
> +
> +		igt_assert(!query.static_data_areas.count &&
> +			   !query.static_data_areas.stride &&
> +			   !query.static_data_areas.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.static_data_areas.count != LEGACY_COUNT ||
> +			    query.static_data_areas.stride != LEGACY_STRIDE ||
> +			    query.static_data_areas.array);
> +	}
> +
> +	igt_describe("Query, with two ioctl calls, all static areas known to the kernel");
> +	igt_subtest("heap-info-static-data-areas-get-2")
> +	{
> +		struct drm_pvr_dev_query_static_data_areas query = {
> +			.static_data_areas = { .stride = ~0U, .count = ~0U, },
> +		};
> +		uint32_t ioctl1_count = ~0U, ioctl1_stride = ~0U;
> +		struct drm_pvr_static_data_area *areas = NULL;
> +
> +		igt_assert(query.static_data_areas.count &&
> +			   query.static_data_areas.stride &&
> +			   !query.static_data_areas.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.static_data_areas.stride == ~0U ||
> +			    query.static_data_areas.count == ~0U ||
> +			    query.static_data_areas.array);
> +
> +		ioctl1_stride = query.static_data_areas.stride;
> +		ioctl1_count = query.static_data_areas.count;
> +
> +		areas = calloc(ioctl1_count, ioctl1_stride);
> +		igt_fail_on(!areas);
> +
> +		query.static_data_areas = (struct drm_pvr_obj_array)
> +			DRM_PVR_OBJ_ARRAY(query.static_data_areas.count, areas);
> +
> +		igt_assert(query.static_data_areas.count &&
> +			   query.static_data_areas.stride &&
> +			   query.static_data_areas.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.static_data_areas.count != ioctl1_count ||
> +			    query.static_data_areas.stride != ioctl1_stride ||
> +			    query.static_data_areas.array != (uintptr_t)areas);
> +
> +		free(areas);
> +	}
> +
> +	igt_describe("Query, with two ioctl calls, the legacy value of stride and count");
> +	igt_subtest("heap-info-static-data-areas-get-2-legacy")
> +	{
> +		struct drm_pvr_dev_query_static_data_areas query = { 0 };
> +		struct drm_pvr_static_data_area *areas = NULL;
> +
> +		igt_assert(!query.static_data_areas.count &&
> +			   !query.static_data_areas.stride &&
> +			   !query.static_data_areas.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.static_data_areas.count != LEGACY_COUNT ||
> +			    query.static_data_areas.stride != LEGACY_STRIDE ||
> +			    query.static_data_areas.array);
> +
> +		areas = calloc(query.static_data_areas.count, sizeof(*areas));
> +		igt_fail_on(!areas);
> +
> +		query.static_data_areas = (struct drm_pvr_obj_array)
> +			DRM_PVR_OBJ_ARRAY(query.static_data_areas.count, areas);
> +
> +		igt_assert(query.static_data_areas.count &&
> +			   query.static_data_areas.stride &&
> +			   query.static_data_areas.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.static_data_areas.count != LEGACY_COUNT ||
> +			    query.static_data_areas.stride != LEGACY_STRIDE ||
> +			    query.static_data_areas.array != (uintptr_t)areas);
> +
> +		free(areas);
> +	}
> +
> +	igt_describe("Query, with two ioctl calls, static areas where UMD(count) < KMD(count)");
> +	igt_subtest("heap-info-static-data-areas-get-2-count-umd-lt-kmd")
> +	{
> +		struct drm_pvr_dev_query_static_data_areas query = {
> +			.static_data_areas = { .stride = ~0U, .count = ~0U, },
> +		};
> +		uint32_t umd_count, kmd_count;
> +
> +		igt_assert(query.static_data_areas.count &&
> +			   query.static_data_areas.stride &&
> +			   !query.static_data_areas.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.static_data_areas.count == ~0U ||
> +			    query.static_data_areas.stride == ~0U ||
> +			    query.static_data_areas.array);
> +
> +		kmd_count = query.static_data_areas.count;
> +		umd_count = kmd_count - 1;
> +
> +		igt_assert(kmd_count && umd_count < kmd_count);
> +
> +		for (uint32_t count = umd_count; count; count--) {
> +			struct drm_pvr_static_data_area *areas = calloc(count, sizeof(*areas));
> +			query = (struct drm_pvr_dev_query_static_data_areas){
> +				.static_data_areas = DRM_PVR_OBJ_ARRAY(count, areas),
> +			};
> +
> +			igt_assert(query.static_data_areas.count < kmd_count &&
> +				   query.static_data_areas.stride &&
> +				   query.static_data_areas.array);
> +
> +			igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +						sizeof(query), &query, 0);
> +
> +			igt_fail_on(query.static_data_areas.count != count ||
> +				    query.static_data_areas.stride != sizeof(*areas) ||
> +				    query.static_data_areas.array != (uintptr_t)areas);
> +
> +			free(areas);
> +		}
> +	}
> +
> +	igt_describe("Query, with two ioctl calls, static areas where UMD(count) > KMD(count)");
> +	igt_subtest("heap-info-static-data-areas-get-2-count-umd-gt-kmd")
> +	{
> +		struct drm_pvr_dev_query_static_data_areas query = {
> +			.static_data_areas = { .stride = ~0U, .count = ~0U, },
> +		};
> +		uint32_t umd_count, kmd_count;
> +
> +		igt_assert(query.static_data_areas.count &&
> +			   query.static_data_areas.stride &&
> +			   !query.static_data_areas.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.static_data_areas.count == ~0U ||
> +			    query.static_data_areas.stride == ~0U ||
> +			    query.static_data_areas.array);
> +
> +		kmd_count = query.static_data_areas.count;
> +		umd_count = kmd_count * 2;
> +
> +		igt_assert(kmd_count && umd_count > kmd_count);
> +
> +		for (uint32_t count = umd_count; count > kmd_count; count--) {
> +			struct drm_pvr_static_data_area *areas = calloc(count, sizeof(*areas));
> +			query = (struct drm_pvr_dev_query_static_data_areas){
> +				.static_data_areas = DRM_PVR_OBJ_ARRAY(count, areas),
> +			};
> +
> +			igt_assert(query.static_data_areas.count > kmd_count &&
> +				   query.static_data_areas.stride &&
> +				   query.static_data_areas.array);
> +
> +			igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +						sizeof(query), &query, 0);
> +
> +			igt_fail_on(query.static_data_areas.count != kmd_count ||
> +				    query.static_data_areas.stride != sizeof(*areas) ||
> +				    query.static_data_areas.array != (uintptr_t)areas);
> +
> +			free(areas);
> +		}
> +	}
> +
> +	igt_describe("Query, with two ioctl calls, static areas where UMD(stride) > KMD(stride)");
> +	igt_subtest("heap-info-static-data-areas-get-2-stride-umd-gt-kmd")
> +	{
> +		struct drm_pvr_dev_query_static_data_areas query = {
> +			.static_data_areas = { .stride = ~0U, .count = ~0U, },
> +		};
> +		struct drm_pvr_static_data_area areas = { 0 };
> +		uint32_t umd_stride, kmd_stride;
> +
> +		igt_assert(query.static_data_areas.count &&
> +			   query.static_data_areas.stride &&
> +			   !query.static_data_areas.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.static_data_areas.count == ~0U ||
> +			    query.static_data_areas.stride == ~0U ||
> +			    query.static_data_areas.array);
> +
> +		kmd_stride = query.static_data_areas.stride;
> +		umd_stride = ALIGN(kmd_stride + 1, sizeof(uint64_t));
> +
> +		igt_assert(kmd_stride && umd_stride > kmd_stride);
> +
> +		query = (struct drm_pvr_dev_query_static_data_areas){
> +			.static_data_areas = {
> +				.count = 1,
> +				.stride = umd_stride,
> +				.array = (uintptr_t)&areas,
> +			},
> +		};
> +
> +		igt_assert(query.static_data_areas.count &&
> +			   query.static_data_areas.stride > kmd_stride &&
> +			   query.static_data_areas.array);
> +
> +		igt_pvr_ioctl_dev_query(fd, DRM_PVR_DEV_QUERY_STATIC_DATA_AREAS_GET,
> +					sizeof(query), &query, 0);
> +
> +		igt_fail_on(query.static_data_areas.count != 1 ||
> +			    query.static_data_areas.stride != umd_stride ||
> +			    query.static_data_areas.array != (uintptr_t)&areas);
> +	}
> +
> +#undef LEGACY_STRIDE
> +#undef LEGACY_COUNT
> +
>  	igt_fixture()
>  	{
>  		drm_close_driver(fd);
> 
> ---
> base-commit: a946c7a2536db43501127e3dc6339e68bd1d6112
> change-id: 20261105-b4-heap-static-area-info-get-bb20556406f2
> 
> Best regards,
> --  
> Luigi Santivetti <luigi.santivetti@imgtec.com>
> 


  reply	other threads:[~2026-11-16 16:48 UTC|newest]

Thread overview: 3+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-16 13:05 [PATCH i-g-t v2] tests/imagination: add more heap info and static areas query tests Luigi Santivetti
2026-11-16 16:46 ` Alessio Belle [this message]
2026-11-16 23:24 ` ✗ Fi.CI.BAT: failure for tests/imagination: add more heap info and static areas query tests (rev2) Patchwork

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=2f8a676328ea9620e7bc44f15e2b4468cdd76fcc.camel@imgtec.com \
    --to=alessio.belle@imgtec.com \
    --cc=Brajesh.Gupta@imgtec.com \
    --cc=Luigi.Santivetti@imgtec.com \
    --cc=igt-dev@lists.freedesktop.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.