Skip to contentSkip to conversation

tests/intel/xe_compute: Add VM page fault property reporting test

PATCH In review [email protected] 2 participants 3 messages Mar 26

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 tests/intel/xe_compute: Add VM page fault property reporting test

From: Nishit Sharma <[email protected]>

Add new subtest 'vm-get-property-pagefault-reporting' to validate the DRM_IOCTL_XE_VM_GET_PROPERTY ioctl for querying VM page fault information.

This test exercises the kernel's page fault tracking mechanism for VMs created with fault-mode enabled. It verifies:
- Initial page fault count is zero for newly created VMs
- Page faults are correctly tracked and reported after triggering
- Reported fault count respects the maximum limit (≤50 faults)
- All reported faults maintain consistent fault address, access type, and fault type
- VM isolation is maintained (faults in VM1 don't affect VM2)

---
 tests/intel/xe_compute.c | 167 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)
tests/intel/xe_compute.c +167 -0
index 762e66fcd..673e8ad36 100644
@@ -25,6 +25,7 @@
 #define LOOP_DURATION_2s	(1000000ull * 2)
 #define DURATION_MARGIN		0.2
 #define MIN_BUSYNESS		95.0
+#define EXEC_SYNC_VAL		0x676767
 
 bool sriov_enabled;
 
@@ -510,6 +511,169 @@ test_compute_square(int fd)
 		      "GPU not supported\n");
 }
 
+static void print_pf(struct xe_vm_fault *fault)
+{
+	igt_debug("FAULT:\n");
+	igt_debug("address = 0x%08x%08x\n",
+		  upper_32_bits(fault->address),
+		  lower_32_bits(fault->address));
+	igt_debug("address precision = %u\n", fault->address_precision);
+	igt_debug("access type = %u\n", fault->access_type);
+	igt_debug("fault type = %u\n", fault->fault_type);
+	igt_debug("fault level = %u\n", fault->fault_level);
+	igt_debug("\n");
+}
+
+/**
+ * SUBTEST: vm-get-property-pagefault-reporting
+ * Description: Test VM page fault reporting via xe_vm_get_property ioctl
+ * Functionality: VM page fault isolation and query
+ * Test category: functionality test
+ */
+static void test_vm_pagefault_reporting(void)
+{
+	struct drm_xe_engine_class_instance *hwe;
+	struct drm_xe_vm_get_property query = {0};
+	struct xe_vm_fault *faults_1, f0, f;
+	uint32_t vm1, vm2;
+	uint32_t exec_queue1;
+	uint64_t addr = 0x1a0000;
+	struct drm_xe_sync sync = {
+		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+	};
+	struct drm_xe_exec exec = {};
+	uint64_t *sync_val;
+	int fd, fault_count, final_fault_count, check_count;
+	uint32_t bo;
+	bool found_compute = false;
+
+	fd = drm_open_driver(DRIVER_XE);
+	xe_device_get(fd);
+
+	igt_require(xe_has_vram(fd)); /* Fault mode typically needs VRAM */
+
+	/* Create fault-mode VM1 */
+	vm1 = xe_vm_create(fd, DRM_XE_VM_CREATE_FLAG_LR_MODE |
+			   DRM_XE_VM_CREATE_FLAG_FAULT_MODE, 0);
+	igt_assert(vm1);
+
+	/* Step 1: Query initial pagefault count (should be 0) */
+	query.vm_id = vm1;
+	query.property = DRM_XE_VM_GET_PROPERTY_FAULTS;
+	query.data = 0;
+	query.size = 0;
+
+	xe_vm_get_property(fd, vm1, &query);
+	igt_assert_eq(query.size, 0);
+
+	if (query.size > 0) {
+		faults_1 = malloc(query.size);
+		igt_assert(faults_1);
+		query.data = to_user_pointer(faults_1);
+		xe_vm_get_property(fd, vm1, &query);
+	}
+
+	fault_count = query.size / sizeof(struct xe_vm_fault);
+	f0 = faults_1[0];
+
+	for (int i = 0; i < fault_count; i++) {
+		f = faults_1[i];
+		print_pf(&f);
+		igt_assert_eq(f.address, f0.address);
+		igt_assert_eq(f.access_type, f0.access_type);
+		igt_assert_eq(f.fault_type, f0.fault_type);
+	}
+	free(faults_1);
+
+	/* Step 2: Trigger a page fault via compute job */
+	xe_for_each_engine(fd, hwe) {
+		if (hwe->engine_class != DRM_XE_ENGINE_CLASS_COMPUTE)
+			continue;
+		found_compute = true;
+
+		exec_queue1 = xe_exec_queue_create(fd, vm1, hwe, 0);
+		sync_val = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
+		igt_assert(sync_val != MAP_FAILED);
+		*sync_val = 0;
+		sync.addr = to_user_pointer(sync_val);
+
+		/* Create a faulting job (access unmapped address) */
+		bo = xe_bo_create(fd, vm1, 4096, vram_if_possible(fd, 0), 0);
+		exec.exec_queue_id = exec_queue1;
+		exec.num_batch_buffer = 1;
+		exec.address = addr; /* Unmapped - will fault */
+		exec.syncs = to_user_pointer(&sync);
+
+		/* This exec should trigger page fault */
+		igt_ioctl(fd, DRM_IOCTL_XE_EXEC, &exec);
+
+		/* Wait for fault handling */
+		usleep(100000); /* 100ms for page fault to be recorded */
+
+		gem_close(fd, bo);
+
+		/* Step 3: Query pagefault count after fault */
+		faults_1 = malloc(query.size);
+		igt_assert(faults_1);
+		query.data = to_user_pointer(faults_1);
+		query.size = 0;
+		xe_vm_get_property(fd, vm1, &query);
+		igt_assert_lt(0, query.size);
+
+		if (query.size > 0) {
+			faults_1 = malloc(query.size);
+			igt_assert(faults_1);
+			query.data = to_user_pointer(faults_1);
+			xe_vm_get_property(fd, vm1, &query);
+			igt_assert_lt(0, query.size);
+
+			final_fault_count = query.size / sizeof(struct xe_vm_fault);
+			check_count = final_fault_count > 50 ? 50 : final_fault_count;
+			f0 = faults_1[0];
+
+			for (int i = 0; i < check_count; i++) {
+				f = faults_1[i];
+				print_pf(&f);
+				igt_assert_eq(f.address, f0.address);
+				igt_assert_eq(f.access_type, f0.access_type);
+				igt_assert_eq(f.fault_type, f0.fault_type);
+			}
+			free(faults_1);
+		}
+
+		munmap(sync_val, 4096);
+		xe_exec_queue_destroy(fd, exec_queue1);
+	}
+	igt_require(found_compute);
+
+	/* Step 4: Create VM2 for isolation test */
+	vm2 = xe_vm_create(fd, DRM_XE_VM_CREATE_FLAG_LR_MODE |
+			   DRM_XE_VM_CREATE_FLAG_FAULT_MODE, 0);
+	igt_assert(vm2);
+
+	query.vm_id = vm2;
+	query.property = DRM_XE_VM_GET_PROPERTY_FAULTS;
+	query.data = 0;
+	query.size = 0;
+	xe_vm_get_property(fd, vm1, &query);
+	igt_assert_eq(query.size, 0);
+
+	if (query.size > 0) {
+		faults_1 = malloc(query.size);
+		igt_assert(faults_1);
+		query.data = to_user_pointer(faults_1);
+		xe_vm_get_property(fd, vm1, &query);
+		igt_assert_lt(0, query.size);
+		free(faults_1);
+	}
+
+	/* Cleanup */
+	xe_vm_destroy(fd, vm1);
+	xe_vm_destroy(fd, vm2);
+	drm_close_driver(fd);
+}
+
 /**
  * SUBTEST: compute-square-userenv
  * Mega feature: Compute
@@ -717,6 +881,9 @@ int igt_main()
 		test_eu_busy(5 * LOOP_DURATION_2s);
 	}
 
+	igt_subtest("vm-get-property-pagefault-reporting")
+		test_vm_pagefault_reporting();
+
 	igt_fixture() {
 		if (!sriov_enabled)
 			igt_restore_ccs_mode(ccs_mode, ARRAY_SIZE(ccs_mode));
Signature · 1 line
2.43.0
#1 lore raw
Quoted 37 lines

-----Original Message-----
From: igt-dev <[email protected]> On Behalf Of [email protected]
Sent: 26 March 2026 11:36 AM
To: [email protected]; Cavitt, Jonathan <[email protected]>
Subject: [PATCH i-g-t] tests/intel/xe_compute: Add VM page fault property reporting test

From: Nishit Sharma <[email protected]>

Add new subtest 'vm-get-property-pagefault-reporting' to validate the DRM_IOCTL_XE_VM_GET_PROPERTY ioctl for querying VM page fault information.

This test exercises the kernel's page fault tracking mechanism for VMs created with fault-mode enabled. It verifies:
- Initial page fault count is zero for newly created VMs
- Page faults are correctly tracked and reported after triggering
- Reported fault count respects the maximum limit (≤50 faults)
- All reported faults maintain consistent fault address, access type, and fault type
- VM isolation is maintained (faults in VM1 don't affect VM2)

---
 tests/intel/xe_compute.c | 167
+++++++++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)
tests/intel/xe_compute.c index renamed from tests/intel/xe_compute.c +0 -0

762e66fcd..673e8ad36 100644

tests/intel/xe_compute.c line 28

Quoted 4 lines
tests/intel/xe_compute.c +1 -0
@@ -25,6 +25,7 @@
 #define LOOP_DURATION_2s	(1000000ull * 2)
 #define DURATION_MARGIN		0.2
 #define MIN_BUSYNESS		95.0
+#define EXEC_SYNC_VAL		0x676767

Define but never used.

Quoted 54 lines
tests/intel/xe_compute.c +46 -0
 bool sriov_enabled;
 
@@ -510,6 +511,169 @@ test_compute_square(int fd)
 		      "GPU not supported\n");
 }
 
+static void print_pf(struct xe_vm_fault *fault) {
+	igt_debug("FAULT:\n");
+	igt_debug("address = 0x%08x%08x\n",
+		  upper_32_bits(fault->address),
+		  lower_32_bits(fault->address));
+	igt_debug("address precision = %u\n", fault->address_precision);
+	igt_debug("access type = %u\n", fault->access_type);
+	igt_debug("fault type = %u\n", fault->fault_type);
+	igt_debug("fault level = %u\n", fault->fault_level);
+	igt_debug("\n");
+}
+
+/**
+ * SUBTEST: vm-get-property-pagefault-reporting
+ * Description: Test VM page fault reporting via xe_vm_get_property
+ioctl
+ * Functionality: VM page fault isolation and query
+ * Test category: functionality test
+ */
+static void test_vm_pagefault_reporting(void) {
+	struct drm_xe_engine_class_instance *hwe;
+	struct drm_xe_vm_get_property query = {0};
+	struct xe_vm_fault *faults_1, f0, f;
+	uint32_t vm1, vm2;
+	uint32_t exec_queue1;
+	uint64_t addr = 0x1a0000;
+	struct drm_xe_sync sync = {
+		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+	};
+	struct drm_xe_exec exec = {};
+	uint64_t *sync_val;
+	int fd, fault_count, final_fault_count, check_count;
+	uint32_t bo;
+	bool found_compute = false;
+
+	fd = drm_open_driver(DRIVER_XE);
+	xe_device_get(fd);
+
+	igt_require(xe_has_vram(fd)); /* Fault mode typically needs VRAM */
+
+	/* Create fault-mode VM1 */
+	vm1 = xe_vm_create(fd, DRM_XE_VM_CREATE_FLAG_LR_MODE |
+			   DRM_XE_VM_CREATE_FLAG_FAULT_MODE, 0);
+	igt_assert(vm1);
+

tests/intel/xe_compute.c test_compute_square(int fd) · line 569

Quoted 10 lines
tests/intel/xe_compute.c +10 -0
+	/* Step 1: Query initial pagefault count (should be 0) */
+	query.vm_id = vm1;
+	query.property = DRM_XE_VM_GET_PROPERTY_FAULTS;
+	query.data = 0;
+	query.size = 0;
+
+	xe_vm_get_property(fd, vm1, &query);
+	igt_assert_eq(query.size, 0);
+
+	if (query.size > 0) {

If the above assert is true then it would never go into this condition, if not the test would fail at the assert. Please check this. Is that the above should be igt_assert_neq?

Quoted 33 lines
tests/intel/xe_compute.c +32 -0
+		faults_1 = malloc(query.size);
+		igt_assert(faults_1);
+		query.data = to_user_pointer(faults_1);
+		xe_vm_get_property(fd, vm1, &query);
+	}
+
+	fault_count = query.size / sizeof(struct xe_vm_fault);
+	f0 = faults_1[0];
+Until, this query.size is creating problem, check this out.
+	for (int i = 0; i < fault_count; i++) {
+		f = faults_1[i];
+		print_pf(&f);
+		igt_assert_eq(f.address, f0.address);
+		igt_assert_eq(f.access_type, f0.access_type);
+		igt_assert_eq(f.fault_type, f0.fault_type);
+	}
+	free(faults_1);
+
+	/* Step 2: Trigger a page fault via compute job */
+	xe_for_each_engine(fd, hwe) {
+		if (hwe->engine_class != DRM_XE_ENGINE_CLASS_COMPUTE)
+			continue;
+		found_compute = true;
+
+		exec_queue1 = xe_exec_queue_create(fd, vm1, hwe, 0);
+		sync_val = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED |
 MAP_ANON, -1, 0);
+		igt_assert(sync_val != MAP_FAILED);
+		*sync_val = 0;
+		sync.addr = to_user_pointer(sync_val);
+
+		/* Create a faulting job (access unmapped address) */
+		bo = xe_bo_create(fd, vm1, 4096, vram_if_possible(fd, 0), 0);

tests/intel/xe_compute.c test_compute_square(int fd) · line 612

Quoted 10 lines
tests/intel/xe_compute.c +10 -0
+		exec.exec_queue_id = exec_queue1;
+		exec.num_batch_buffer = 1;
+		exec.address = addr; /* Unmapped - will fault */
+		exec.syncs = to_user_pointer(&sync);
+
+		/* This exec should trigger page fault */
+		igt_ioctl(fd, DRM_IOCTL_XE_EXEC, &exec);
+
+		/* Wait for fault handling */
+		usleep(100000); /* 100ms for page fault to be recorded */

Instead of usleep, you can wait on wait_user_ufence.

tests/intel/xe_compute.c test_compute_square(int fd) · line 624

Quoted 12 lines
tests/intel/xe_compute.c +12 -0
+
+		gem_close(fd, bo);
+
+		/* Step 3: Query pagefault count after fault */
+		faults_1 = malloc(query.size);
+		igt_assert(faults_1);
+		query.data = to_user_pointer(faults_1);
+		query.size = 0;
+		xe_vm_get_property(fd, vm1, &query);
+		igt_assert_lt(0, query.size);
+
+		if (query.size > 0) {

No need of this if condition as you are asserting above, check this once.

Quoted 27 lines
tests/intel/xe_compute.c +25 -0
+			faults_1 = malloc(query.size);
+			igt_assert(faults_1);
+			query.data = to_user_pointer(faults_1);
+			xe_vm_get_property(fd, vm1, &query);
+			igt_assert_lt(0, query.size);
+
+			final_fault_count = query.size / sizeof(struct
 xe_vm_fault);
+			check_count = final_fault_count > 50 ? 50 :
 final_fault_count;
+			f0 = faults_1[0];
+
+			for (int i = 0; i < check_count; i++) {
+				f = faults_1[i];
+				print_pf(&f);
+				igt_assert_eq(f.address, f0.address);
+				igt_assert_eq(f.access_type, f0.access_type);
+				igt_assert_eq(f.fault_type, f0.fault_type);
+			}
+			free(faults_1);
+		}
+
+		munmap(sync_val, 4096);
+		xe_exec_queue_destroy(fd, exec_queue1);
+	}
+	igt_require(found_compute);
+

tests/intel/xe_compute.c test_compute_square(int fd) · line 659

Quoted 10 lines
tests/intel/xe_compute.c +10 -0
+	/* Step 4: Create VM2 for isolation test */
+	vm2 = xe_vm_create(fd, DRM_XE_VM_CREATE_FLAG_LR_MODE |
+			   DRM_XE_VM_CREATE_FLAG_FAULT_MODE, 0);
+	igt_assert(vm2);
+
+	query.vm_id = vm2;
+	query.property = DRM_XE_VM_GET_PROPERTY_FAULTS;
+	query.data = 0;
+	query.size = 0;
+	xe_vm_get_property(fd, vm1, &query);

You are creating vm2 and getting vm1 property.

tests/intel/xe_compute.c test_compute_square(int fd) · line 663

Quoted 2 lines
tests/intel/xe_compute.c +2 -0
+	igt_assert_eq(query.size, 0);
+

Same problem related to query.size as above.

tests/intel/xe_compute.c test_compute_square(int fd) · line 574

Quoted 5 lines
tests/intel/xe_compute.c +5 -0
+	if (query.size > 0) {
+		faults_1 = malloc(query.size);
+		igt_assert(faults_1);
+		query.data = to_user_pointer(faults_1);
+		xe_vm_get_property(fd, vm1, &query);

Trying to use vm1 ??

Quoted 26 lines
tests/intel/xe_compute.c +13 -0
+		igt_assert_lt(0, query.size);
+		free(faults_1);
+	}
+
+	/* Cleanup */
+	xe_vm_destroy(fd, vm1);
+	xe_vm_destroy(fd, vm2);
+	drm_close_driver(fd);
+}
+
 /**
  * SUBTEST: compute-square-userenv
  * Mega feature: Compute
@@ -717,6 +881,9 @@ int igt_main()
 		test_eu_busy(5 * LOOP_DURATION_2s);
 	}
 
+	igt_subtest("vm-get-property-pagefault-reporting")
+		test_vm_pagefault_reporting();
+
 	igt_fixture() {
 		if (!sriov_enabled)
 			igt_restore_ccs_mode(ccs_mode,

ARRAY_SIZE(ccs_mode));
--
2.43.0

#2 lore raw
Quoted 249 lines

-----Original Message-----
From: Dandamudi, Priyanka
Sent: 26 March 2026 12:23 PM
To: '[email protected]' <[email protected]>; igt- [email protected]; Cavitt, Jonathan <[email protected]>
Subject: RE: [PATCH i-g-t] tests/intel/xe_compute: Add VM page fault property reporting test

Quoted 35 lines

-----Original Message-----
From: igt-dev <[email protected]> On Behalf Of [email protected]
Sent: 26 March 2026 11:36 AM
To: [email protected]; Cavitt, Jonathan <[email protected]>
Subject: [PATCH i-g-t] tests/intel/xe_compute: Add VM page fault property reporting test

From: Nishit Sharma <[email protected]>

Add new subtest 'vm-get-property-pagefault-reporting' to validate the DRM_IOCTL_XE_VM_GET_PROPERTY ioctl for querying VM page fault information.

This test exercises the kernel's page fault tracking mechanism for VMs created with fault-mode enabled. It verifies:
- Initial page fault count is zero for newly created VMs
- Page faults are correctly tracked and reported after triggering
- Reported fault count respects the maximum limit (≤50 faults)
- All reported faults maintain consistent fault address, access type, and fault type
- VM isolation is maintained (faults in VM1 don't affect VM2)

---
 tests/intel/xe_compute.c | 167
+++++++++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)
tests/intel/xe_compute.c index renamed from tests/intel/xe_compute.c +0 -0

762e66fcd..673e8ad36 100644

tests/intel/xe_compute.c line 28

Quoted 4 lines
tests/intel/xe_compute.c +1 -0
@@ -25,6 +25,7 @@
 #define LOOP_DURATION_2s	(1000000ull * 2)
 #define DURATION_MARGIN		0.2
 #define MIN_BUSYNESS		95.0
+#define EXEC_SYNC_VAL		0x676767

Define but never used.

Quoted 54 lines
tests/intel/xe_compute.c +46 -0
 bool sriov_enabled;
 
@@ -510,6 +511,169 @@ test_compute_square(int fd)
 		      "GPU not supported\n");
 }
 
+static void print_pf(struct xe_vm_fault *fault) {
+	igt_debug("FAULT:\n");
+	igt_debug("address = 0x%08x%08x\n",
+		  upper_32_bits(fault->address),
+		  lower_32_bits(fault->address));
+	igt_debug("address precision = %u\n", fault->address_precision);
+	igt_debug("access type = %u\n", fault->access_type);
+	igt_debug("fault type = %u\n", fault->fault_type);
+	igt_debug("fault level = %u\n", fault->fault_level);
+	igt_debug("\n");
+}
+
+/**
+ * SUBTEST: vm-get-property-pagefault-reporting
+ * Description: Test VM page fault reporting via xe_vm_get_property
+ioctl
+ * Functionality: VM page fault isolation and query
+ * Test category: functionality test
+ */
+static void test_vm_pagefault_reporting(void) {
+	struct drm_xe_engine_class_instance *hwe;
+	struct drm_xe_vm_get_property query = {0};
+	struct xe_vm_fault *faults_1, f0, f;
+	uint32_t vm1, vm2;
+	uint32_t exec_queue1;
+	uint64_t addr = 0x1a0000;
+	struct drm_xe_sync sync = {
+		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+	};
+	struct drm_xe_exec exec = {};
+	uint64_t *sync_val;
+	int fd, fault_count, final_fault_count, check_count;
+	uint32_t bo;
+	bool found_compute = false;
+
+	fd = drm_open_driver(DRIVER_XE);
+	xe_device_get(fd);
+
+	igt_require(xe_has_vram(fd)); /* Fault mode typically needs VRAM */
+
+	/* Create fault-mode VM1 */
+	vm1 = xe_vm_create(fd, DRM_XE_VM_CREATE_FLAG_LR_MODE |
+			   DRM_XE_VM_CREATE_FLAG_FAULT_MODE, 0);
+	igt_assert(vm1);
+

tests/intel/xe_compute.c test_compute_square(int fd) · line 569

Quoted 10 lines
tests/intel/xe_compute.c +10 -0
+	/* Step 1: Query initial pagefault count (should be 0) */
+	query.vm_id = vm1;
+	query.property = DRM_XE_VM_GET_PROPERTY_FAULTS;
+	query.data = 0;
+	query.size = 0;
+
+	xe_vm_get_property(fd, vm1, &query);
+	igt_assert_eq(query.size, 0);
+
+	if (query.size > 0) {

If the above assert is true then it would never go into this condition, if not the test would fail at the assert.
Please check this. Is that the above should be igt_assert_neq?

Quoted 33 lines
tests/intel/xe_compute.c +32 -0
+		faults_1 = malloc(query.size);
+		igt_assert(faults_1);
+		query.data = to_user_pointer(faults_1);
+		xe_vm_get_property(fd, vm1, &query);
+	}
+
+	fault_count = query.size / sizeof(struct xe_vm_fault);
+	f0 = faults_1[0];
+Until, this query.size is creating problem, check this out.
+	for (int i = 0; i < fault_count; i++) {
+		f = faults_1[i];
+		print_pf(&f);
+		igt_assert_eq(f.address, f0.address);
+		igt_assert_eq(f.access_type, f0.access_type);
+		igt_assert_eq(f.fault_type, f0.fault_type);
+	}
+	free(faults_1);
+
+	/* Step 2: Trigger a page fault via compute job */
+	xe_for_each_engine(fd, hwe) {
+		if (hwe->engine_class != DRM_XE_ENGINE_CLASS_COMPUTE)
+			continue;
+		found_compute = true;
+
+		exec_queue1 = xe_exec_queue_create(fd, vm1, hwe, 0);
+		sync_val = mmap(NULL, 4096, PROT_WRITE, MAP_SHARED |
 MAP_ANON, -1, 0);
+		igt_assert(sync_val != MAP_FAILED);
+		*sync_val = 0;
+		sync.addr = to_user_pointer(sync_val);
+
+		/* Create a faulting job (access unmapped address) */
+		bo = xe_bo_create(fd, vm1, 4096, vram_if_possible(fd, 0), 0);

tests/intel/xe_compute.c test_compute_square(int fd) · line 612

Quoted 10 lines
tests/intel/xe_compute.c +10 -0
+		exec.exec_queue_id = exec_queue1;
+		exec.num_batch_buffer = 1;
+		exec.address = addr; /* Unmapped - will fault */
+		exec.syncs = to_user_pointer(&sync);
+
+		/* This exec should trigger page fault */
+		igt_ioctl(fd, DRM_IOCTL_XE_EXEC, &exec);
+
+		/* Wait for fault handling */
+		usleep(100000); /* 100ms for page fault to be recorded */

Instead of usleep, you can wait on wait_user_ufence.

tests/intel/xe_compute.c test_compute_square(int fd) · line 624

Quoted 12 lines
tests/intel/xe_compute.c +12 -0
+
+		gem_close(fd, bo);
+
+		/* Step 3: Query pagefault count after fault */
+		faults_1 = malloc(query.size);
+		igt_assert(faults_1);
+		query.data = to_user_pointer(faults_1);
+		query.size = 0;
+		xe_vm_get_property(fd, vm1, &query);
+		igt_assert_lt(0, query.size);
+
+		if (query.size > 0) {

No need of this if condition as you are asserting above, check this once.

Quoted 27 lines
tests/intel/xe_compute.c +25 -0
+			faults_1 = malloc(query.size);
+			igt_assert(faults_1);
+			query.data = to_user_pointer(faults_1);
+			xe_vm_get_property(fd, vm1, &query);
+			igt_assert_lt(0, query.size);
+
+			final_fault_count = query.size / sizeof(struct
 xe_vm_fault);
+			check_count = final_fault_count > 50 ? 50 :
 final_fault_count;
+			f0 = faults_1[0];
+
+			for (int i = 0; i < check_count; i++) {
+				f = faults_1[i];
+				print_pf(&f);
+				igt_assert_eq(f.address, f0.address);
+				igt_assert_eq(f.access_type, f0.access_type);
+				igt_assert_eq(f.fault_type, f0.fault_type);
+			}
+			free(faults_1);
+		}
+
+		munmap(sync_val, 4096);
+		xe_exec_queue_destroy(fd, exec_queue1);
+	}
+	igt_require(found_compute);
+

tests/intel/xe_compute.c test_compute_square(int fd) · line 659

Quoted 10 lines
tests/intel/xe_compute.c +10 -0
+	/* Step 4: Create VM2 for isolation test */
+	vm2 = xe_vm_create(fd, DRM_XE_VM_CREATE_FLAG_LR_MODE |
+			   DRM_XE_VM_CREATE_FLAG_FAULT_MODE, 0);
+	igt_assert(vm2);
+
+	query.vm_id = vm2;
+	query.property = DRM_XE_VM_GET_PROPERTY_FAULTS;
+	query.data = 0;
+	query.size = 0;
+	xe_vm_get_property(fd, vm1, &query);

You are creating vm2 and getting vm1 property.

tests/intel/xe_compute.c test_compute_square(int fd) · line 663

Quoted 2 lines
tests/intel/xe_compute.c +2 -0
+	igt_assert_eq(query.size, 0);
+

Same problem related to query.size as above.

tests/intel/xe_compute.c test_compute_square(int fd) · line 574

Quoted 5 lines
tests/intel/xe_compute.c +5 -0
+	if (query.size > 0) {
+		faults_1 = malloc(query.size);
+		igt_assert(faults_1);
+		query.data = to_user_pointer(faults_1);
+		xe_vm_get_property(fd, vm1, &query);

Trying to use vm1 ??

Quoted 26 lines
tests/intel/xe_compute.c +13 -0
+		igt_assert_lt(0, query.size);
+		free(faults_1);
+	}
+
+	/* Cleanup */
+	xe_vm_destroy(fd, vm1);
+	xe_vm_destroy(fd, vm2);
+	drm_close_driver(fd);
+}
+
 /**
  * SUBTEST: compute-square-userenv
  * Mega feature: Compute
@@ -717,6 +881,9 @@ int igt_main()
 		test_eu_busy(5 * LOOP_DURATION_2s);
 	}
 
+	igt_subtest("vm-get-property-pagefault-reporting")
+		test_vm_pagefault_reporting();
+
 	igt_fixture() {
 		if (!sriov_enabled)
 			igt_restore_ccs_mode(ccs_mode,

ARRAY_SIZE(ccs_mode));
--
2.43.0