Skip to contentSkip to conversation

tests/intel/xe_vm: Add support for overcommit tests

PATCH Superseded Sobin Thomas 3 participants 8 messages Apr 8 – Apr 16

v10 of 13 Superseded Latest is v13 →

lore
Share & tools
lore
#0 lore raw

v10 cover tests/intel/xe_vm: Add support for overcommit tests

Current tests focus on VM creation and basic mode selection, but do not cover overcommit scenarios.

This change adds tests to verify overcommit behavior across different VM modes.

Non-fault mode tests:
- vram-lr-defer: DEFER_BACKING rejects overcommit at bind time
- vram-lr-external-nodefer: Long-running mode with an external BO and no deferred backing
- vram-no-lr: Non-long-running mode

Fault mode tests:
- vram-lr-fault: Fault handling allows graceful overcommit via page faults
- vram-lr-fault-no-overcommit: Verifies NO_VM_OVERCOMMIT blocks same-VM BO eviction during VM_BIND, while still allowing eviction during page-fault OOM handling

These tests validate that VMs respond correctly to memory pressure based on their configuration—by rejecting at bind time, failing during execution, or handling overcommit gracefully via page faults.

Currently, overcommit behavior is tested for VRAM only.

--------------------------------------
Link (historical context):
https://patchwork.freedesktop.org/series/161557/

Sobin Thomas (3):
drm-uapi/xe: sync with kernel header lib/xe: Add failable variant of xe_vm_bind_lr_sync() tests/intel/xe_vm: Add support for overcommit tests

 include/drm-uapi/xe_drm.h |  22 +--
 lib/xe/xe_ioctl.c         |  35 ++--
 lib/xe/xe_ioctl.h         |   2 +
 tests/intel/xe_vm.c       | 358 +++++++++++++++++++++++++++++++++++++-
 4 files changed, 395 insertions(+), 22 deletions(-)
Signature · 1 line
2.52.0
#1 lore raw

PATCH v10 1/2 lib/xe: Add failable variant of xe_vm_bind_lr_sync()

Add __xe_vm_bind_lr_sync helper function which returns standard error codes instead of asserting on failure. This allows calling function to handle VM bind failures explicitly while preserving the existing xe_vm_bind_lr_sync() wrapper for tests. This enables callers that expect bind / overcommit failures.

v7: Introduced xe_vm_bind_lr_sync_failable (Thomas)
v8: Modified xe_vm_bind_lr_sync_failable and xe_vm_bind_lr_sync to call

    __xe_vm_bind_lr_sync

v9: Removed redundant typecast and removed xe_vm_bind_lr_sync_failable

---
 lib/xe/xe_ioctl.c | 35 +++++++++++++++++++++++++----------
 lib/xe/xe_ioctl.h |  2 ++
 2 files changed, 27 insertions(+), 10 deletions(-)
lib/xe/xe_ioctl.c +25 -10
index 7a8444095..bf5c80b71 100644
@@ -827,23 +827,38 @@ void xe_vm_madvise(int fd, uint32_t vm, uint64_t addr, uint64_t range,
 }
 
 #define	BIND_SYNC_VAL	0x686868
-void xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo, uint64_t offset,
-			uint64_t addr, uint64_t size, uint32_t flags)
+int __xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo, uint64_t offset,
+			 uint64_t addr, uint64_t size, uint32_t flags)
 {
-	volatile uint64_t *sync_addr = malloc(sizeof(*sync_addr));
+	uint64_t *sync_addr = malloc(sizeof(*sync_addr));
 	struct drm_xe_sync sync = {
 		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
 		.type = DRM_XE_SYNC_TYPE_USER_FENCE,
-		.addr = to_user_pointer((uint64_t *)sync_addr),
+		.addr = to_user_pointer(sync_addr),
 		.timeline_value = BIND_SYNC_VAL,
 	};
-
-	igt_assert(!!sync_addr);
-	xe_vm_bind_async_flags(fd, vm, 0, bo, 0, addr, size, &sync, 1, flags);
-	if (*sync_addr != BIND_SYNC_VAL)
-		xe_wait_ufence(fd, (uint64_t *)sync_addr, BIND_SYNC_VAL, 0, NSEC_PER_SEC * 10);
+	int ret = 0;
+
+	if (!sync_addr)
+		return -ENOMEM;
+	WRITE_ONCE(*sync_addr, 0);
+	ret = __xe_vm_bind(fd, vm, 0, bo, offset, addr, size, DRM_XE_VM_BIND_OP_MAP, flags,
+			   &sync, 1, 0,  DEFAULT_PAT_INDEX, 0);
+	if (ret)
+		goto out;
+
+	if (READ_ONCE(*sync_addr) != BIND_SYNC_VAL)
+		xe_wait_ufence(fd, sync_addr, BIND_SYNC_VAL, 0, NSEC_PER_SEC * 10);
 	/* Only free if the wait succeeds */
-	free((void *)sync_addr);
+out:
+	free(sync_addr);
+	return ret;
+}
+
+void xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo, uint64_t offset,
+			uint64_t addr, uint64_t size, uint32_t flags)
+{
+	igt_assert_eq(__xe_vm_bind_lr_sync(fd, vm, bo, offset, addr, size, flags), 0);
 }
 
 void xe_vm_unbind_lr_sync(int fd, uint32_t vm, uint64_t offset,
lib/xe/xe_ioctl.h +2 -0
index 4ac526a8e..e81f79bbb 100644
@@ -118,6 +118,8 @@ struct drm_xe_mem_range_attr
 void xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo,
 			uint64_t offset, uint64_t addr,
 			uint64_t size, uint32_t flags);
+int __xe_vm_bind_lr_sync(int fd, uint32_t vm, uint32_t bo, uint64_t offset,
+			 uint64_t addr, uint64_t size, uint32_t flags);
 void xe_vm_unbind_lr_sync(int fd, uint32_t vm, uint64_t offset,
 			  uint64_t addr, uint64_t size);
 #endif /* XE_IOCTL_H */
Signature · 1 line
2.52.0
#2 lore raw

PATCH v10 2/2 tests/intel/xe_vm: Add support for overcommit tests

In reply to Sobin Thomas

Current tests focus on VM creation with basic mode selection and do not support overcommit scenarios.

This change adds tests to verify overcommit behavior across different VM modes.

Non-fault mode tests:
- vram-lr-defer: DEFER_BACKING rejects overcommit at bind time
- vram-lr-external-nodefer: Long-running mode with external BO and no defer backing
- vram-no-lr: Non-LR mode

Fault mode tests:
- vram-lr-fault: Fault handling allows graceful overcommit via page faults
- vram-lr-fault-no-overcommit: Verifies NO_VM_OVERCOMMIT blocks same-VM BO eviction during VM_BIND while still allowing eviction during pagefault OOM

These tests validate that VMs handle memory pressure appropriately based on their configuration—rejecting at bind, failing at exec, or handling it gracefully via page faults.

v2 - Added Additional test cases for LR mode and No Overcommit.

v3 - Refactored into single api call based on the VM / BO Flags.

v5 - Addressed review comments (reset sync objects and nits).
Added check in cleanup
v6 - Replaced __xe_vm_bind with xe_vm_bind_lr_sync and refactored. v7 - Add failable xe_vm_bind_lr_sync to handle the failure in the
vm bind in case over commit happens.
v9 - Replaced xe_vm_bind_lr_sync_failable with __xe_vm_bind_lr_sync v10 - Add ENOSPC error, moved BO map after bind is completed.
Removed special casing LR Mode.

---
 tests/intel/xe_vm.c | 358 +++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 357 insertions(+), 1 deletion(-)
tests/intel/xe_vm.c +357 -1
index d75b0730d..9c8ab15a3 100644
@@ -20,6 +20,7 @@
 #include "xe/xe_query.h"
 #include "xe/xe_spin.h"
 #include <string.h>
+#define USER_FENCE_VALUE 0xdeadbeefdeadbeefull
 
 static uint32_t
 addr_low(uint64_t addr)
@@ -2376,6 +2377,350 @@ static void invalid_vm_id(int fd)
 	do_ioctl_err(fd, DRM_IOCTL_XE_VM_DESTROY, &destroy, ENOENT);
 }
 
+static void create_data_bos(int fd, uint32_t vm, uint32_t *bos,
+			    int num_bos, uint64_t nf_bo_size, bool use_vram, uint64_t data_addr,
+			    bool *overcommit_detected, uint32_t bo_flags, int gt_id)
+{
+	uint32_t placement = use_vram ? vram_memory(fd, gt_id) : system_memory(fd);
+
+	for (int i = 0; i < num_bos; i++) {
+		int bind_err;
+		int create_ret = 0;
+
+		/* Create BO using the case's create function */
+		create_ret = __xe_bo_create(fd, vm, nf_bo_size, placement,
+					    bo_flags, NULL, &bos[i]);
+
+		if (create_ret) {
+			if (create_ret == -ENOMEM || create_ret == -ENOSPC) {
+				*overcommit_detected = true;
+				igt_debug("BO create failed at %d/%d with error %d (%s) - overcommit detected\n",
+					  i, num_bos, -create_ret, strerror(-create_ret));
+				break;
+			}
+			igt_assert_f(0, "Unexpected BO create error %d (%s)\n", -create_ret,
+				     strerror(-create_ret));
+		}
+
+		bind_err = __xe_vm_bind_lr_sync(fd, vm, bos[i], 0, data_addr + (i * nf_bo_size),
+						nf_bo_size, 0);
+		if (bind_err) {
+			if (bind_err == -ENOMEM || bind_err == -ENOSPC) {
+				*overcommit_detected = true;
+				igt_debug("BO bind failed - error %d (%s) overcommit detected\n",
+					  -bind_err, strerror(-bind_err));
+				break;
+			}
+			igt_assert_f(0, "Unexpected BO bind error %d (%s)\n", -bind_err,
+				     strerror(-bind_err));
+		}
+
+		igt_debug("Created and bound BO %d/%d at 0x%llx\n",
+			  i + 1, num_bos,
+			  (unsigned long long)(data_addr + (i * nf_bo_size)));
+	}
+}
+
+static void verify_bo(int fd, uint32_t *bos, int num_bos, uint64_t nf_bo_size, uint64_t stride)
+{
+	for (int i = 0; i < num_bos; i++) {
+		uint32_t *verify_data;
+		int errors = 0;
+
+		verify_data = xe_bo_map(fd, bos[i], nf_bo_size);
+		igt_assert(verify_data);
+
+		for (int off = 0; off < nf_bo_size; off += stride) {
+			uint32_t expected = 0xBB;
+			uint32_t actual = *(uint32_t *)((char *)verify_data + off);
+
+			if (actual != expected) {
+				if (errors < 5)
+					igt_debug("Mismatch at BO %d offset 0x%llx",
+						  i, (unsigned long long)off);
+				errors++;
+			}
+		}
+
+		munmap(verify_data, nf_bo_size);
+		igt_assert_f(errors == 0, "Data verification failed for BO %d with %d errors\n",
+			     i, errors);
+	}
+}
+
+static void bind_userptr_fault_mode(int fd, uint32_t vm, uint32_t bind_exec_queue, void *userptr,
+				    uint64_t addr, uint64_t size, struct drm_xe_sync *bind_sync,
+				    uint64_t *sync_mem)
+{
+	*sync_mem = 0;
+	bind_sync->addr = to_user_pointer(sync_mem);
+	xe_vm_bind_userptr_async(fd, vm, bind_exec_queue, to_user_pointer(userptr),
+				 addr, size, bind_sync, 1);
+	xe_wait_ufence(fd, sync_mem, USER_FENCE_VALUE, bind_exec_queue, NSEC_PER_SEC);
+}
+
+/**
+ * SUBTEST: overcommit-fault-%s
+ * Description: Test VM overcommit behavior in fault mode with %arg[1] configuration
+ * Functionality: overcommit
+ * Test category: functionality test
+ *
+ * arg[1]:
+ *
+ * @vram-lr-fault:VRAM with LR and fault mode, expects exec to pass
+ * @vram-lr-fault-no-overcommit:VRAM with LR, fault and NO_VM_OVERCOMMIT, expects bind rejection
+ */
+
+/**
+ * SUBTEST: overcommit-nonfault-%s
+ * Description: Test VM overcommit behavior in nonfault mode with %arg[1] configuration
+ * Functionality: overcommit
+ * Test category: functionality test
+ *
+ * arg[1]:
+ *
+ * @vram-lr-defer:VRAM with LR and defer backing, expects bind rejection
+ * @vram-lr-external-nodefer:VRAM with LR and external BO without defer, expects exec fail
+ * @vram-no-lr:VRAM without LR mode, expects exec to fail
+ */
+struct vm_overcommit_case {
+	const char *name;
+	uint32_t vm_flags;
+	uint32_t bo_flags;
+	bool use_vram;
+	uint64_t data_addr;
+	int overcommit_mult;
+};
+
+static const struct vm_overcommit_case overcommit_cases[] = {
+	/* Case 1: DEFER_BACKING */
+	{
+		.name = "vram-lr-defer",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE,
+		.bo_flags = DRM_XE_GEM_CREATE_FLAG_DEFER_BACKING |
+			    DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
+		.use_vram = true,
+		.data_addr = 0x1a0000,
+		.overcommit_mult = 2,
+	},
+	/* Case 1b: External BO without defer backing */
+	{
+		.name = "vram-lr-external-nodefer",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE,
+		.bo_flags = DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
+		.use_vram = true,
+		.data_addr = 0x1a0000,
+		.overcommit_mult = 2,
+	},
+	/* Case 2: LR + FAULT - should not fail on exec */
+	{
+		.name = "vram-lr-fault",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE |
+			    DRM_XE_VM_CREATE_FLAG_FAULT_MODE,
+		.bo_flags = DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
+		.use_vram = true,
+		.data_addr = 0x300000000,
+		.overcommit_mult = 2,
+	},
+	/* Case 3: !LR - overcommit should fail on exec */
+	{
+		.name = "vram-no-lr",
+		.vm_flags = 0,
+		.bo_flags = DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
+		.use_vram = true,
+		.data_addr = 0x300000000,
+		.overcommit_mult = 2,
+	},
+	/* Case 4: LR + FAULT + NO_VM_OVERCOMMIT */
+	{
+		.name = "vram-lr-fault-no-overcommit",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_NO_VM_OVERCOMMIT | DRM_XE_VM_CREATE_FLAG_LR_MODE |
+			    DRM_XE_VM_CREATE_FLAG_FAULT_MODE,
+		.bo_flags = DRM_XE_GEM_CREATE_FLAG_DEFER_BACKING |
+			    DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,
+		.use_vram = true,
+		.data_addr = 0x300000000,
+		.overcommit_mult = 2,
+	},
+	{ }
+};
+
+static void
+test_vm_overcommit(int fd, struct drm_xe_engine_class_instance *eci,
+		   const struct vm_overcommit_case *c,
+		   uint64_t system_size, uint64_t vram_size)
+{
+	uint32_t vm = 0, *bos, batch_bo = 0, exec_queue = 0, bind_exec_queue = 0;
+	bool is_fault_mode = (c->vm_flags & DRM_XE_VM_CREATE_FLAG_FAULT_MODE) != 0;
+	uint64_t sync_addr = 0x101a0000, batch_addr = 0x200000000;
+	uint64_t overcommit_size, off, data_addr;
+	size_t sync_size, nf_bo_size = 64 * 1024 * 1024;
+	uint64_t stride = 1024 * 1024, base_size;
+	int64_t timeout = 20 * NSEC_PER_SEC;
+	int i, num_bos, bind_err;
+	bool overcommit_detected = false;
+	struct drm_xe_sync bind_sync[1] = {
+		{
+			.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+			.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+			.timeline_value = USER_FENCE_VALUE
+		},
+	};
+	struct drm_xe_sync exec_sync[1] = {
+		{
+			.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+			.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+			.timeline_value = USER_FENCE_VALUE,
+			.handle = 0,
+		},
+	};
+	struct drm_xe_exec exec = {
+		.num_batch_buffer = 1,
+		.num_syncs = 1,
+		.syncs = to_user_pointer(exec_sync),
+	};
+	struct {
+		uint32_t batch[16];
+		uint64_t pad;
+		uint32_t data;
+		uint64_t vm_sync;
+	} *batch_data = NULL;
+	uint64_t *user_fence_sync = NULL;
+
+	data_addr = c->data_addr;
+	base_size = c->use_vram ? vram_size : system_size;
+	overcommit_size = ALIGN((uint64_t)(base_size * c->overcommit_mult), 4096);
+
+	num_bos = (overcommit_size / nf_bo_size) + 1;
+	bos = calloc(num_bos, sizeof(*bos));
+	igt_assert(bos);
+
+	igt_debug("Overcommit test: allocating %d BOs of %llu MB each",
+		  num_bos, (unsigned long long)(nf_bo_size >> 20));
+	igt_debug(" total=%llu MB, vram=%llu MB\n",
+		  (unsigned long long)(num_bos * nf_bo_size >> 20),
+		  (unsigned long long)(vram_size >> 20));
+	/* Create VM with appropriate flags */
+	vm = xe_vm_create(fd, c->vm_flags, 0);
+	igt_assert(vm);
+
+	bind_exec_queue = xe_bind_exec_queue_create(fd, vm, 0);
+	sync_size = xe_bb_size(fd, sizeof(uint64_t) * num_bos);
+	user_fence_sync = mmap(NULL, sync_size, PROT_READ | PROT_WRITE,
+			       MAP_SHARED | MAP_ANONYMOUS, -1, 0);
+	igt_assert(user_fence_sync != MAP_FAILED);
+	memset(user_fence_sync, 0, sync_size);
+	exec_sync->addr = to_user_pointer(&user_fence_sync[0]);
+
+	/* Create and bind data BOs */
+	create_data_bos(fd, vm, bos, num_bos, nf_bo_size, c->use_vram, data_addr,
+			&overcommit_detected, c->bo_flags, eci->gt_id);
+
+	if (overcommit_detected) {
+		igt_debug("Overcommit correctly rejected at BO creation/bind (created %d BOs)\n",
+			  num_bos);
+		goto cleanup;
+	}
+
+	/*
+	 * Create batch buffer first in SRAM as focus is to
+	 * check overcommit in VRAM
+	 */
+	batch_bo = xe_bo_create(fd, vm, 0x1000, system_memory(fd), 0);
+
+	igt_debug("Mapping the created BO");
+	batch_data = xe_bo_map(fd, batch_bo, 0x1000);
+	igt_assert(batch_data);
+	memset(batch_data, 0, 0x1000);
+
+	/*
+	 * Fault mode requires sync_addr to be GPU visible via the VM
+	 * CPU local address are not accessible to GPU Page tables
+	 */
+	if (is_fault_mode) {
+		bind_userptr_fault_mode(fd, vm, bind_exec_queue, user_fence_sync, sync_addr,
+					sync_size, bind_sync, &batch_data->vm_sync);
+		exec_sync->addr = sync_addr;
+	}
+	batch_data->vm_sync = 0;
+	bind_err = __xe_vm_bind_lr_sync(fd, vm, batch_bo, 0, batch_addr, 0x1000, 0);
+	if (bind_err) {
+		if (bind_err == -ENOMEM || bind_err == -ENOSPC) {
+			igt_debug("Setting overcommit to true\n");
+			overcommit_detected = true;
+			goto cleanup;
+		} else { /* Assert any bind error other than -ENOMEM */
+			igt_assert_f(0, "Unexpected bind error %d (%s)\n", -bind_err,
+				     strerror(-bind_err));
+		}
+	}
+
+	igt_debug("VM binds done - batch_bo at 0x%llx\n", (unsigned long long)batch_addr);
+	/* Create exec queue */
+	exec_queue = xe_exec_queue_create(fd, vm, eci, 0);
+
+	/* Use GPU to write to each BO */
+	for (i = 0; i < num_bos; i++) {
+		igt_debug("Writing to BO %d/%d via GPU\n", i + 1, num_bos);
+
+		for (off = 0; off < nf_bo_size; off += stride) {
+			uint64_t target_addr = data_addr + (i * nf_bo_size) + off;
+			int b_idx = 0, res = 0;
+
+			batch_data->batch[b_idx++] = MI_STORE_DWORD_IMM_GEN4;
+			batch_data->batch[b_idx++] = target_addr & 0xFFFFFFFF;
+			batch_data->batch[b_idx++] = (target_addr >> 32) & 0xFFFFFFFF;
+			batch_data->batch[b_idx++] = 0xBB;
+			batch_data->batch[b_idx++] = MI_BATCH_BUFFER_END;
+
+			/* Submit batch */
+			exec.exec_queue_id = exec_queue;
+			exec.address = batch_addr;
+
+			res = igt_ioctl(fd, DRM_IOCTL_XE_EXEC, &exec);
+			if (res != 0) {
+				if (errno == ENOMEM || errno == ENOSPC) {
+					igt_debug("Expected fault/error: %d (%s)\n",
+						  errno, strerror(errno));
+					goto cleanup;
+				}
+				igt_assert_f(0, "Unexpected exec error: %d\n", errno);
+			}
+			xe_wait_ufence(fd, &user_fence_sync[0], USER_FENCE_VALUE, exec_queue,
+				       timeout);
+			user_fence_sync[0] = 0;
+		}
+		igt_debug("Accessed BO %d/%d via GPU\n", i + 1, num_bos);
+	}
+	igt_debug("All batches submitted - waiting for GPU completion\n");
+
+	/* Verify GPU writes */
+	verify_bo(fd, bos, num_bos, nf_bo_size, stride);
+
+cleanup:
+	/* Cleanup */
+	if (exec_queue)
+		xe_exec_queue_destroy(fd, exec_queue);
+	if (bind_exec_queue)
+		xe_exec_queue_destroy(fd, bind_exec_queue);
+	if (batch_data)
+		munmap(batch_data, 0x1000);
+	if (batch_bo)
+		gem_close(fd, batch_bo);
+
+	munmap(user_fence_sync, sync_size);
+
+	if (bos) {
+		for (i = 0; i < num_bos; i++) {
+			if (bos[i])
+				gem_close(fd, bos[i]);
+		}
+		free(bos);
+	}
+	if (vm > 0)
+		xe_vm_destroy(fd, vm);
+}
+
 /**
  * SUBTEST: out-of-memory
  * Description: Test if vm_bind ioctl results in oom
@@ -2385,7 +2730,6 @@ static void invalid_vm_id(int fd)
  */
 static void test_oom(int fd)
 {
-#define USER_FENCE_VALUE 0xdeadbeefdeadbeefull
 #define BO_SIZE xe_bb_size(fd, SZ_512M)
 #define MAX_BUFS ((int)(xe_visible_vram_size(fd, 0) / BO_SIZE))
 	uint64_t addr = 0x1a0000;
@@ -3115,6 +3459,18 @@ int igt_main()
 			test_get_property(fd, f->test);
 	}
 
+	for (int i = 0; overcommit_cases[i].name; i++) {
+		const struct vm_overcommit_case *c = &overcommit_cases[i];
+		const char *mode = (c->vm_flags & DRM_XE_VM_CREATE_FLAG_FAULT_MODE) ?
+					"fault" : "nonfault";
+		igt_subtest_f("overcommit-%s-%s", mode, c->name) {
+			igt_require(xe_has_vram(fd));
+			igt_assert(xe_visible_vram_size(fd, 0));
+			test_vm_overcommit(fd, hwe, c, (igt_get_avail_ram_mb() << 20),
+					   xe_visible_vram_size(fd, 0));
+		}
+	}
+
 	igt_fixture()
 		drm_close_driver(fd);
 }
Signature · 1 line
2.52.0
#3 lore raw

Hi!

Quoted 32 lines · Sobin Thomas

Current tests focus on VM creation with basic mode selection and do not
support overcommit scenarios.

This change adds tests to verify overcommit behavior across different VM
modes.

Non-fault mode tests:
 - vram-lr-defer: DEFER_BACKING rejects overcommit at bind time
 - vram-lr-external-nodefer: Long-running mode with external BO and no defer backing
 - vram-no-lr: Non-LR mode

Fault mode tests:
 - vram-lr-fault: Fault handling allows graceful overcommit via page faults
 - vram-lr-fault-no-overcommit: Verifies NO_VM_OVERCOMMIT blocks same-VM
   BO eviction during VM_BIND while still allowing eviction during pagefault OOM

These tests validate that VMs handle memory pressure appropriately based
on their configuration—rejecting at bind, failing at exec, or handling
it gracefully via page faults.

v2 - Added Additional test cases for LR mode and No Overcommit.

v3 - Refactored into single api call  based on the VM / BO Flags.

Quoted 8 lines

v5 - Addressed review comments (reset sync objects and nits). Added check in cleanup
v6 - Replaced __xe_vm_bind with xe_vm_bind_lr_sync and refactored. v7 - Add failable xe_vm_bind_lr_sync to handle the failure in the vm bind in case over commit happens.
v9 - Replaced xe_vm_bind_lr_sync_failable with __xe_vm_bind_lr_sync v10 - Add ENOSPC error, moved BO map after bind is completed. Removed special casing LR Mode.

The naming printed out from "xe_vm --l" becomes

overcommit-nonfault-vram-lr-defer
overcommit-nonfault-vram-lr-external-nodefer
overcommit-fault-vram-lr-fault
overcommit-nonfault-vram-no-lr
overcommit-fault-vram-lr-fault-no-overcommit

Some tests appear to duplicate "fault" in the name. Is that intentional?

The test "overcommit-fault-vram-lr-fault-no-overcommit" fails on my system. Was it properly tested?

Some more comments below.

Quoted 307 lines

---
 tests/intel/xe_vm.c | 358
+++++++++++++++++++++++++++++++++++++++++++-

 1 file changed, 357 insertions(+), 1 deletion(-)
tests/intel/xe_vm.c +1 -0
index d75b0730d..9c8ab15a3 100644
@@ -20,6 +20,7 @@
  #include "xe/xe_query.h"
  #include "xe/xe_spin.h"
  #include <string.h>
+#define USER_FENCE_VALUE 0xdeadbeefdeadbeefull


 static uint32_t
 addr_low(uint64_t addr)

tests/intel/xe_vm.c +0 -0
@@ -2376,6 +2377,350 @@ static void invalid_vm_id(int fd)
  	do_ioctl_err(fd, DRM_IOCTL_XE_VM_DESTROY, &destroy, ENOENT);
  }

tests/intel/xe_vm.c +2 -0
+static void create_data_bos(int fd, uint32_t vm, uint32_t *bos,
+			    int num_bos, uint64_t nf_bo_size, bool

use_vram, uint64_t data_addr,

tests/intel/xe_vm.c +1 -0
+			    bool *overcommit_detected, uint32_t

bo_flags, int gt_id)

tests/intel/xe_vm.c +2 -0
+{
+	uint32_t placement = use_vram ? vram_memory(fd, gt_id) :

system_memory(fd);

tests/intel/xe_vm.c +7 -0
+
+	for (int i = 0; i < num_bos; i++) {
+		int bind_err;
+		int create_ret = 0;
+
+		/* Create BO using the case's create function */
+		create_ret = __xe_bo_create(fd, vm, nf_bo_size,

placement,

tests/intel/xe_vm.c +1 -0
+					    bo_flags, NULL,

&bos[i]);

tests/intel/xe_vm.c +3 -0
+
+		if (create_ret) {
+			if (create_ret == -ENOMEM || create_ret == -

ENOSPC) {

tests/intel/xe_vm.c +2 -0
+				*overcommit_detected = true;
+				igt_debug("BO create failed at %d/%d

with error %d (%s) - overcommit detected\n",

tests/intel/xe_vm.c +1 -0
+					  i, num_bos, -create_ret,

strerror(-create_ret));

tests/intel/xe_vm.c +3 -0
+				break;
+			}
+			igt_assert_f(0, "Unexpected BO create error

%d (%s)\n", -create_ret,

tests/intel/xe_vm.c +4 -0
+				     strerror(-create_ret));
+		}
+
+		bind_err = __xe_vm_bind_lr_sync(fd, vm, bos[i], 0,

data_addr + (i * nf_bo_size),

tests/intel/xe_vm.c +3 -0
+						nf_bo_size, 0);
+		if (bind_err) {
+			if (bind_err == -ENOMEM || bind_err == -

ENOSPC) {

tests/intel/xe_vm.c +2 -0
+				*overcommit_detected = true;
+				igt_debug("BO bind failed - error %d

(%s) overcommit detected\n",

tests/intel/xe_vm.c +1 -0
+					  -bind_err, strerror(-

bind_err));

tests/intel/xe_vm.c +3 -0
+				break;
+			}
+			igt_assert_f(0, "Unexpected BO bind error %d

(%s)\n", -bind_err,

tests/intel/xe_vm.c +6 -0
+				     strerror(-bind_err));
+		}
+
+		igt_debug("Created and bound BO %d/%d at 0x%llx\n",
+			  i + 1, num_bos,
+			  (unsigned long long)(data_addr + (i *

nf_bo_size)));

tests/intel/xe_vm.c +4 -0
+	}
+}
+
+static void verify_bo(int fd, uint32_t *bos, int num_bos, uint64_t

nf_bo_size, uint64_t stride)

tests/intel/xe_vm.c +11 -0
+{
+	for (int i = 0; i < num_bos; i++) {
+		uint32_t *verify_data;
+		int errors = 0;
+
+		verify_data = xe_bo_map(fd, bos[i], nf_bo_size);
+		igt_assert(verify_data);
+
+		for (int off = 0; off < nf_bo_size; off += stride) {
+			uint32_t expected = 0xBB;
+			uint32_t actual = *(uint32_t *)((char

*)verify_data + off);

tests/intel/xe_vm.c +4 -0
+
+			if (actual != expected) {
+				if (errors < 5)
+					igt_debug("Mismatch at BO %d

offset 0x%llx",

tests/intel/xe_vm.c +1 -0
+						  i, (unsigned long

long)off);

tests/intel/xe_vm.c +6 -0
+				errors++;
+			}
+		}
+
+		munmap(verify_data, nf_bo_size);
+		igt_assert_f(errors == 0, "Data verification failed

for BO %d with %d errors\n",

tests/intel/xe_vm.c +5 -0
+			     i, errors);
+	}
+}
+
+static void bind_userptr_fault_mode(int fd, uint32_t vm, uint32_t

bind_exec_queue, void *userptr,

tests/intel/xe_vm.c +1 -0
+				    uint64_t addr, uint64_t size,

struct drm_xe_sync *bind_sync,

tests/intel/xe_vm.c +5 -0
+				    uint64_t *sync_mem)
+{
+	*sync_mem = 0;
+	bind_sync->addr = to_user_pointer(sync_mem);
+	xe_vm_bind_userptr_async(fd, vm, bind_exec_queue,

to_user_pointer(userptr),

tests/intel/xe_vm.c +2 -0
+				 addr, size, bind_sync, 1);
+	xe_wait_ufence(fd, sync_mem, USER_FENCE_VALUE,

bind_exec_queue, NSEC_PER_SEC);

tests/intel/xe_vm.c +5 -0
+}
+
+/**
+ * SUBTEST: overcommit-fault-%s
+ * Description: Test VM overcommit behavior in fault mode with

%arg[1] configuration
+ * Functionality: overcommit
+ * Test category: functionality test
+ *
+ * arg[1]:
+ *
+ * @vram-lr-fault:VRAM with LR and fault mode, expects exec to pass
+ * @vram-lr-fault-no-overcommit:VRAM with LR, fault and NO_VM_OVERCOMMIT, expects bind rejection
+ */

tests/intel/xe_vm.c +4 -0
+
+/**
+ * SUBTEST: overcommit-nonfault-%s
+ * Description: Test VM overcommit behavior in nonfault mode with

%arg[1] configuration
+ * Functionality: overcommit
+ * Test category: functionality test
+ *
+ * arg[1]:
+ *
+ * @vram-lr-defer:VRAM with LR and defer backing, expects bind rejection
+ * @vram-lr-external-nodefer:VRAM with LR and external BO without defer, expects exec fail
+ * @vram-no-lr:VRAM without LR mode, expects exec to fail
+ */

tests/intel/xe_vm.c +16 -0
+struct vm_overcommit_case {
+	const char *name;
+	uint32_t vm_flags;
+	uint32_t bo_flags;
+	bool use_vram;
+	uint64_t data_addr;
+	int overcommit_mult;
+};
+
+static const struct vm_overcommit_case overcommit_cases[] = {
+	/* Case 1: DEFER_BACKING */
+	{
+		.name = "vram-lr-defer",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE,
+		.bo_flags = DRM_XE_GEM_CREATE_FLAG_DEFER_BACKING |
+			   

DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,

tests/intel/xe_vm.c +9 -0
+		.use_vram = true,
+		.data_addr = 0x1a0000,
+		.overcommit_mult = 2,
+	},
+	/* Case 1b: External BO without defer backing */
+	{
+		.name = "vram-lr-external-nodefer",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE,
+		.bo_flags =

DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,

tests/intel/xe_vm.c +10 -0
+		.use_vram = true,
+		.data_addr = 0x1a0000,
+		.overcommit_mult = 2,
+	},
+	/* Case 2: LR + FAULT - should not fail on exec */
+	{
+		.name = "vram-lr-fault",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE |
+			    DRM_XE_VM_CREATE_FLAG_FAULT_MODE,
+		.bo_flags =

DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,

tests/intel/xe_vm.c +9 -0
+		.use_vram = true,
+		.data_addr = 0x300000000,
+		.overcommit_mult = 2,
+	},
+	/* Case 3: !LR - overcommit should fail on exec */
+	{
+		.name = "vram-no-lr",
+		.vm_flags = 0,
+		.bo_flags =

DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,

tests/intel/xe_vm.c +8 -0
+		.use_vram = true,
+		.data_addr = 0x300000000,
+		.overcommit_mult = 2,
+	},
+	/* Case 4: LR + FAULT + NO_VM_OVERCOMMIT */
+	{
+		.name = "vram-lr-fault-no-overcommit",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_NO_VM_OVERCOMMIT |

DRM_XE_VM_CREATE_FLAG_LR_MODE |

tests/intel/xe_vm.c +3 -0
+			    DRM_XE_VM_CREATE_FLAG_FAULT_MODE,
+		.bo_flags = DRM_XE_GEM_CREATE_FLAG_DEFER_BACKING |
+			   

DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,

tests/intel/xe_vm.c +13 -0
+		.use_vram = true,
+		.data_addr = 0x300000000,
+		.overcommit_mult = 2,
+	},
+	{ }
+};
+
+static void
+test_vm_overcommit(int fd, struct drm_xe_engine_class_instance *eci,
+		   const struct vm_overcommit_case *c,
+		   uint64_t system_size, uint64_t vram_size)
+{
+	uint32_t vm = 0, *bos, batch_bo = 0, exec_queue = 0,

bind_exec_queue = 0;

tests/intel/xe_vm.c +1 -0
+	bool is_fault_mode = (c->vm_flags &

DRM_XE_VM_CREATE_FLAG_FAULT_MODE) != 0;

tests/intel/xe_vm.c +38 -0
+	uint64_t sync_addr = 0x101a0000, batch_addr = 0x200000000;
+	uint64_t overcommit_size, off, data_addr;
+	size_t sync_size, nf_bo_size = 64 * 1024 * 1024;
+	uint64_t stride = 1024 * 1024, base_size;
+	int64_t timeout = 20 * NSEC_PER_SEC;
+	int i, num_bos, bind_err;
+	bool overcommit_detected = false;
+	struct drm_xe_sync bind_sync[1] = {
+		{
+			.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+			.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+			.timeline_value = USER_FENCE_VALUE
+		},
+	};
+	struct drm_xe_sync exec_sync[1] = {
+		{
+			.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+			.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+			.timeline_value = USER_FENCE_VALUE,
+			.handle = 0,
+		},
+	};
+	struct drm_xe_exec exec = {
+		.num_batch_buffer = 1,
+		.num_syncs = 1,
+		.syncs = to_user_pointer(exec_sync),
+	};
+	struct {
+		uint32_t batch[16];
+		uint64_t pad;
+		uint32_t data;
+		uint64_t vm_sync;
+	} *batch_data = NULL;
+	uint64_t *user_fence_sync = NULL;
+
+	data_addr = c->data_addr;
+	base_size = c->use_vram ? vram_size : system_size;
+	overcommit_size = ALIGN((uint64_t)(base_size * c-
Quoted 1 line

overcommit_mult), 4096);

tests/intel/xe_vm.c +6 -0
+
+	num_bos = (overcommit_size / nf_bo_size) + 1;
+	bos = calloc(num_bos, sizeof(*bos));
+	igt_assert(bos);
+
+	igt_debug("Overcommit test: allocating %d BOs of %llu MB

each",

tests/intel/xe_vm.c +11 -0
+		  num_bos, (unsigned long long)(nf_bo_size >> 20));
+	igt_debug(" total=%llu MB, vram=%llu MB\n",
+		  (unsigned long long)(num_bos * nf_bo_size >> 20),
+		  (unsigned long long)(vram_size >> 20));
+	/* Create VM with appropriate flags */
+	vm = xe_vm_create(fd, c->vm_flags, 0);
+	igt_assert(vm);
+
+	bind_exec_queue = xe_bind_exec_queue_create(fd, vm, 0);
+	sync_size = xe_bb_size(fd, sizeof(uint64_t) * num_bos);
+	user_fence_sync = mmap(NULL, sync_size, PROT_READ |

PROT_WRITE,

tests/intel/xe_vm.c +7 -0
+			       MAP_SHARED | MAP_ANONYMOUS, -1, 0);
+	igt_assert(user_fence_sync != MAP_FAILED);
+	memset(user_fence_sync, 0, sync_size);
+	exec_sync->addr = to_user_pointer(&user_fence_sync[0]);
+
+	/* Create and bind data BOs */
+	create_data_bos(fd, vm, bos, num_bos, nf_bo_size, c-
Quoted 1 line

use_vram, data_addr,

tests/intel/xe_vm.c +1 -0
+			&overcommit_detected, c->bo_flags, eci-
Quoted 1 line

gt_id);

tests/intel/xe_vm.c +3 -0
+
+	if (overcommit_detected) {
+		igt_debug("Overcommit correctly rejected at BO

creation/bind (created %d BOs)\n",

tests/intel/xe_vm.c static void invalid_vm_id(int fd) · line 2621

Quoted 1 line
tests/intel/xe_vm.c +1 -0
+			  num_bos);

Shouldn't there be a check for each test where overcommit is expected to fail that it actually gets an overcommit error at the correct location? Like exec() or vm_bind(). Also that it *doesn't* get an overcommit error where it shouldn't.

Quoted 25 lines
tests/intel/xe_vm.c +8 -0
+		goto cleanup;
+	}
+
+	/*
+	 * Create batch buffer first in SRAM as focus is to
+	 * check overcommit in VRAM
+	 */
+	batch_bo = xe_bo_create(fd, vm, 0x1000, system_memory(fd),

0);

tests/intel/xe_vm.c +8 -0
+
+	igt_debug("Mapping the created BO");
+	batch_data = xe_bo_map(fd, batch_bo, 0x1000);
+	igt_assert(batch_data);
+	memset(batch_data, 0, 0x1000);
+
+	/*
+	 * Fault mode requires sync_addr to be GPU visible via the

VM

tests/intel/xe_vm.c +4 -0
+	 * CPU local address are not accessible to GPU Page tables
+	 */
+	if (is_fault_mode) {
+		bind_userptr_fault_mode(fd, vm, bind_exec_queue,

user_fence_sync, sync_addr,

tests/intel/xe_vm.c +1 -0
+					sync_size, bind_sync,

&batch_data->vm_sync);

tests/intel/xe_vm.c

Quoted 2 lines
tests/intel/xe_vm.c +2 -0
+		exec_sync->addr = sync_addr;
+	}

Here's another special-casing. The above requirement is not specific to fault-mode.

Quoted 66 lines
tests/intel/xe_vm.c +2 -0
+	batch_data->vm_sync = 0;
+	bind_err = __xe_vm_bind_lr_sync(fd, vm, batch_bo, 0,

batch_addr, 0x1000, 0);

tests/intel/xe_vm.c +6 -0
+	if (bind_err) {
+		if (bind_err == -ENOMEM || bind_err == -ENOSPC) {
+			igt_debug("Setting overcommit to true\n");
+			overcommit_detected = true;
+			goto cleanup;
+		} else { /* Assert any bind error other than -ENOMEM

*/

tests/intel/xe_vm.c +1 -0
+			igt_assert_f(0, "Unexpected bind error %d

(%s)\n", -bind_err,

tests/intel/xe_vm.c +5 -0
+				     strerror(-bind_err));
+		}
+	}
+
+	igt_debug("VM binds done - batch_bo at 0x%llx\n", (unsigned

long long)batch_addr);

tests/intel/xe_vm.c +6 -0
+	/* Create exec queue */
+	exec_queue = xe_exec_queue_create(fd, vm, eci, 0);
+
+	/* Use GPU to write to each BO */
+	for (i = 0; i < num_bos; i++) {
+		igt_debug("Writing to BO %d/%d via GPU\n", i + 1,

num_bos);

tests/intel/xe_vm.c +3 -0
+
+		for (off = 0; off < nf_bo_size; off += stride) {
+			uint64_t target_addr = data_addr + (i *

nf_bo_size) + off;

tests/intel/xe_vm.c +3 -0
+			int b_idx = 0, res = 0;
+
+			batch_data->batch[b_idx++] =

MI_STORE_DWORD_IMM_GEN4;

tests/intel/xe_vm.c +1 -0
+			batch_data->batch[b_idx++] = target_addr &

0xFFFFFFFF;

tests/intel/xe_vm.c +1 -0
+			batch_data->batch[b_idx++] = (target_addr >>

32) & 0xFFFFFFFF;

tests/intel/xe_vm.c +2 -0
+			batch_data->batch[b_idx++] = 0xBB;
+			batch_data->batch[b_idx++] =

MI_BATCH_BUFFER_END;

tests/intel/xe_vm.c +6 -0
+
+			/* Submit batch */
+			exec.exec_queue_id = exec_queue;
+			exec.address = batch_addr;
+
+			res = igt_ioctl(fd, DRM_IOCTL_XE_EXEC,

&exec);

tests/intel/xe_vm.c +2 -0
+			if (res != 0) {
+				if (errno == ENOMEM || errno ==

ENOSPC) {

tests/intel/xe_vm.c +1 -0
+					igt_debug("Expected

fault/error: %d (%s)\n",

tests/intel/xe_vm.c +1 -0
+						  errno,

strerror(errno));

tests/intel/xe_vm.c +3 -0
+					goto cleanup;
+				}
+				igt_assert_f(0, "Unexpected exec

error: %d\n", errno);

tests/intel/xe_vm.c +2 -0
+			}
+			xe_wait_ufence(fd, &user_fence_sync[0],

USER_FENCE_VALUE, exec_queue,

tests/intel/xe_vm.c +4 -0
+				       timeout);
+			user_fence_sync[0] = 0;
+		}
+		igt_debug("Accessed BO %d/%d via GPU\n", i + 1,

num_bos);

tests/intel/xe_vm.c

Quoted 1 line
tests/intel/xe_vm.c +1 -0
+	}

If a test fails with overcommit during the bind phase, then the exec phase is never executed. Is that intentional, or can the exec phase be run on the bos that actually got bound?

Thanks,
Thomas

Quoted 64 lines
tests/intel/xe_vm.c +1 -0
+	igt_debug("All batches submitted - waiting for GPU

completion\n");

tests/intel/xe_vm.c +28 -0
+
+	/* Verify GPU writes */
+	verify_bo(fd, bos, num_bos, nf_bo_size, stride);
+
+cleanup:
+	/* Cleanup */
+	if (exec_queue)
+		xe_exec_queue_destroy(fd, exec_queue);
+	if (bind_exec_queue)
+		xe_exec_queue_destroy(fd, bind_exec_queue);
+	if (batch_data)
+		munmap(batch_data, 0x1000);
+	if (batch_bo)
+		gem_close(fd, batch_bo);
+
+	munmap(user_fence_sync, sync_size);
+
+	if (bos) {
+		for (i = 0; i < num_bos; i++) {
+			if (bos[i])
+				gem_close(fd, bos[i]);
+		}
+		free(bos);
+	}
+	if (vm > 0)
+		xe_vm_destroy(fd, vm);
+}
+

 /**
  * SUBTEST: out-of-memory
  * Description: Test if vm_bind ioctl results in oom

tests/intel/xe_vm.c +0 -1
@@ -2385,7 +2730,6 @@ static void invalid_vm_id(int fd)
   */
  static void test_oom(int fd)
  {
-#define USER_FENCE_VALUE 0xdeadbeefdeadbeefull
  #define BO_SIZE xe_bb_size(fd, SZ_512M)
  #define MAX_BUFS ((int)(xe_visible_vram_size(fd, 0) / BO_SIZE))
  	uint64_t addr = 0x1a0000;
@@ -3115,6 +3459,18 @@ int igt_main()
  			test_get_property(fd, f->test);
  	}

tests/intel/xe_vm.c +2 -0
+	for (int i = 0; overcommit_cases[i].name; i++) {
+		const struct vm_overcommit_case *c =

&overcommit_cases[i];

tests/intel/xe_vm.c +1 -0
+		const char *mode = (c->vm_flags &

DRM_XE_VM_CREATE_FLAG_FAULT_MODE) ?

tests/intel/xe_vm.c +5 -0
+					"fault" : "nonfault";
+		igt_subtest_f("overcommit-%s-%s", mode, c->name) {
+			igt_require(xe_has_vram(fd));
+			igt_assert(xe_visible_vram_size(fd, 0));
+			test_vm_overcommit(fd, hwe, c,

(igt_get_avail_ram_mb() << 20),

tests/intel/xe_vm.c +1 -0
+					   xe_visible_vram_size(fd,

0));

tests/intel/xe_vm.c +3 -0
+		}
+	}
+

  igt_fixture()
  drm_close_driver(fd);
 }

#4 lore raw

Hi Thomas,

Thanks a lot for the detailed review and for testing the patch.

Quoted 47 lines · Thomas

Hi!

Quoted 32 lines · Sobin Thomas

Current tests focus on VM creation with basic mode selection and do not
support overcommit scenarios.

This change adds tests to verify overcommit behavior across different VM
modes.

Non-fault mode tests:
 - vram-lr-defer: DEFER_BACKING rejects overcommit at bind time
 - vram-lr-external-nodefer: Long-running mode with external BO and no defer backing
 - vram-no-lr: Non-LR mode

Fault mode tests:
 - vram-lr-fault: Fault handling allows graceful overcommit via page faults
 - vram-lr-fault-no-overcommit: Verifies NO_VM_OVERCOMMIT blocks
same-VM
   BO eviction during VM_BIND while still allowing eviction during pagefault OOM

These tests validate that VMs handle memory pressure appropriately based
on their configuration—rejecting at bind, failing at exec, or handling
it gracefully via page faults.

v2 - Added Additional test cases for LR mode and No Overcommit.

v3 - Refactored into single api call  based on the VM / BO Flags.

Quoted 8 lines

v5 - Addressed review comments (reset sync objects and nits).
     Added check in cleanup
v6 - Replaced __xe_vm_bind with xe_vm_bind_lr_sync and refactored. v7 - Add failable xe_vm_bind_lr_sync to handle the failure in the
     vm bind in case over commit happens.
v9 - Replaced xe_vm_bind_lr_sync_failable with __xe_vm_bind_lr_sync v10 - Add ENOSPC error, moved BO map after bind is completed.
      Removed special casing LR Mode.

The naming printed out from "xe_vm --l" becomes

Quoted 8 lines

overcommit-nonfault-vram-lr-defer
overcommit-nonfault-vram-lr-external-nodefer
overcommit-fault-vram-lr-fault
overcommit-nonfault-vram-no-lr
overcommit-fault-vram-lr-fault-no-overcommit

Some tests appear to duplicate "fault" in the name. Is that intentional?

There was additional print. Will fix it.

Quoted 3 lines

The test "overcommit-fault-vram-lr-fault-no-overcommit" fails on my system. Was it properly tested?

Thanks for pointing this I will cross  check , However I have tested this on PVC and and other platforms Also CI results was positive.

Quoted 304 lines

Some more comments below.

Quoted 302 lines
---
  tests/intel/xe_vm.c | 358
+++++++++++++++++++++++++++++++++++++++++++-
  1 file changed, 357 insertions(+), 1 deletion(-)
tests/intel/xe_vm.c +13 -0
index d75b0730d..9c8ab15a3 100644
@@ -20,6 +20,7 @@
  #include "xe/xe_query.h"
  #include "xe/xe_spin.h"
  #include <string.h>
+#define USER_FENCE_VALUE 0xdeadbeefdeadbeefull
 
  static uint32_t
  addr_low(uint64_t addr)
@@ -2376,6 +2377,350 @@ static void invalid_vm_id(int fd)
  	do_ioctl_err(fd, DRM_IOCTL_XE_VM_DESTROY, &destroy, ENOENT);
  }
 
+static void create_data_bos(int fd, uint32_t vm, uint32_t *bos,
+			    int num_bos, uint64_t nf_bo_size, bool
 use_vram, uint64_t data_addr,
+			    bool *overcommit_detected, uint32_t
 bo_flags, int gt_id)
+{
+	uint32_t placement = use_vram ? vram_memory(fd, gt_id) :
 system_memory(fd);
+
+	for (int i = 0; i < num_bos; i++) {
+		int bind_err;
+		int create_ret = 0;
+
+		/* Create BO using the case's create function */
+		create_ret = __xe_bo_create(fd, vm, nf_bo_size,

placement,

tests/intel/xe_vm.c +1 -0
+					    bo_flags, NULL,

&bos[i]);

tests/intel/xe_vm.c +3 -0
+
+		if (create_ret) {
+			if (create_ret == -ENOMEM || create_ret == -

ENOSPC) {

tests/intel/xe_vm.c +2 -0
+				*overcommit_detected = true;
+				igt_debug("BO create failed at %d/%d

with error %d (%s) - overcommit detected\n",

tests/intel/xe_vm.c +1 -0
+					  i, num_bos, -create_ret,

strerror(-create_ret));

tests/intel/xe_vm.c +3 -0
+				break;
+			}
+			igt_assert_f(0, "Unexpected BO create error

%d (%s)\n", -create_ret,

tests/intel/xe_vm.c +4 -0
+				     strerror(-create_ret));
+		}
+
+		bind_err = __xe_vm_bind_lr_sync(fd, vm, bos[i], 0,

data_addr + (i * nf_bo_size),

tests/intel/xe_vm.c +3 -0
+						nf_bo_size, 0);
+		if (bind_err) {
+			if (bind_err == -ENOMEM || bind_err == -

ENOSPC) {

tests/intel/xe_vm.c +2 -0
+				*overcommit_detected = true;
+				igt_debug("BO bind failed - error %d

(%s) overcommit detected\n",

tests/intel/xe_vm.c +1 -0
+					  -bind_err, strerror(-

bind_err));

tests/intel/xe_vm.c +3 -0
+				break;
+			}
+			igt_assert_f(0, "Unexpected BO bind error %d

(%s)\n", -bind_err,

tests/intel/xe_vm.c +6 -0
+				     strerror(-bind_err));
+		}
+
+		igt_debug("Created and bound BO %d/%d at 0x%llx\n",
+			  i + 1, num_bos,
+			  (unsigned long long)(data_addr + (i *

nf_bo_size)));

tests/intel/xe_vm.c +4 -0
+	}
+}
+
+static void verify_bo(int fd, uint32_t *bos, int num_bos, uint64_t

nf_bo_size, uint64_t stride)

tests/intel/xe_vm.c +11 -0
+{
+	for (int i = 0; i < num_bos; i++) {
+		uint32_t *verify_data;
+		int errors = 0;
+
+		verify_data = xe_bo_map(fd, bos[i], nf_bo_size);
+		igt_assert(verify_data);
+
+		for (int off = 0; off < nf_bo_size; off += stride) {
+			uint32_t expected = 0xBB;
+			uint32_t actual = *(uint32_t *)((char

*)verify_data + off);

tests/intel/xe_vm.c +4 -0
+
+			if (actual != expected) {
+				if (errors < 5)
+					igt_debug("Mismatch at BO %d

offset 0x%llx",

tests/intel/xe_vm.c +1 -0
+						  i, (unsigned long

long)off);

tests/intel/xe_vm.c +6 -0
+				errors++;
+			}
+		}
+
+		munmap(verify_data, nf_bo_size);
+		igt_assert_f(errors == 0, "Data verification failed

for BO %d with %d errors\n",

tests/intel/xe_vm.c +5 -0
+			     i, errors);
+	}
+}
+
+static void bind_userptr_fault_mode(int fd, uint32_t vm, uint32_t

bind_exec_queue, void *userptr,

tests/intel/xe_vm.c +1 -0
+				    uint64_t addr, uint64_t size,

struct drm_xe_sync *bind_sync,

tests/intel/xe_vm.c +5 -0
+				    uint64_t *sync_mem)
+{
+	*sync_mem = 0;
+	bind_sync->addr = to_user_pointer(sync_mem);
+	xe_vm_bind_userptr_async(fd, vm, bind_exec_queue,

to_user_pointer(userptr),

tests/intel/xe_vm.c +2 -0
+				 addr, size, bind_sync, 1);
+	xe_wait_ufence(fd, sync_mem, USER_FENCE_VALUE,

bind_exec_queue, NSEC_PER_SEC);

tests/intel/xe_vm.c +5 -0
+}
+
+/**
+ * SUBTEST: overcommit-fault-%s
+ * Description: Test VM overcommit behavior in fault mode with

%arg[1] configuration
+ * Functionality: overcommit
+ * Test category: functionality test
+ *
+ * arg[1]:
+ *
+ * @vram-lr-fault:VRAM with LR and fault mode, expects exec to pass
+ * @vram-lr-fault-no-overcommit:VRAM with LR, fault and NO_VM_OVERCOMMIT, expects bind rejection
+ */

tests/intel/xe_vm.c +4 -0
+
+/**
+ * SUBTEST: overcommit-nonfault-%s
+ * Description: Test VM overcommit behavior in nonfault mode with

%arg[1] configuration
+ * Functionality: overcommit
+ * Test category: functionality test
+ *
+ * arg[1]:
+ *
+ * @vram-lr-defer:VRAM with LR and defer backing, expects bind rejection
+ * @vram-lr-external-nodefer:VRAM with LR and external BO without defer, expects exec fail
+ * @vram-no-lr:VRAM without LR mode, expects exec to fail
+ */

tests/intel/xe_vm.c +16 -0
+struct vm_overcommit_case {
+	const char *name;
+	uint32_t vm_flags;
+	uint32_t bo_flags;
+	bool use_vram;
+	uint64_t data_addr;
+	int overcommit_mult;
+};
+
+static const struct vm_overcommit_case overcommit_cases[] = {
+	/* Case 1: DEFER_BACKING */
+	{
+		.name = "vram-lr-defer",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE,
+		.bo_flags = DRM_XE_GEM_CREATE_FLAG_DEFER_BACKING |
+			

DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,

tests/intel/xe_vm.c +9 -0
+		.use_vram = true,
+		.data_addr = 0x1a0000,
+		.overcommit_mult = 2,
+	},
+	/* Case 1b: External BO without defer backing */
+	{
+		.name = "vram-lr-external-nodefer",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE,
+		.bo_flags =

DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,

tests/intel/xe_vm.c +10 -0
+		.use_vram = true,
+		.data_addr = 0x1a0000,
+		.overcommit_mult = 2,
+	},
+	/* Case 2: LR + FAULT - should not fail on exec */
+	{
+		.name = "vram-lr-fault",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_LR_MODE |
+			    DRM_XE_VM_CREATE_FLAG_FAULT_MODE,
+		.bo_flags =

DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,

tests/intel/xe_vm.c +9 -0
+		.use_vram = true,
+		.data_addr = 0x300000000,
+		.overcommit_mult = 2,
+	},
+	/* Case 3: !LR - overcommit should fail on exec */
+	{
+		.name = "vram-no-lr",
+		.vm_flags = 0,
+		.bo_flags =

DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,

tests/intel/xe_vm.c +8 -0
+		.use_vram = true,
+		.data_addr = 0x300000000,
+		.overcommit_mult = 2,
+	},
+	/* Case 4: LR + FAULT + NO_VM_OVERCOMMIT */
+	{
+		.name = "vram-lr-fault-no-overcommit",
+		.vm_flags = DRM_XE_VM_CREATE_FLAG_NO_VM_OVERCOMMIT |

DRM_XE_VM_CREATE_FLAG_LR_MODE |

tests/intel/xe_vm.c +3 -0
+			    DRM_XE_VM_CREATE_FLAG_FAULT_MODE,
+		.bo_flags = DRM_XE_GEM_CREATE_FLAG_DEFER_BACKING |
+			

DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM,

tests/intel/xe_vm.c +13 -0
+		.use_vram = true,
+		.data_addr = 0x300000000,
+		.overcommit_mult = 2,
+	},
+	{ }
+};
+
+static void
+test_vm_overcommit(int fd, struct drm_xe_engine_class_instance *eci,
+		   const struct vm_overcommit_case *c,
+		   uint64_t system_size, uint64_t vram_size)
+{
+	uint32_t vm = 0, *bos, batch_bo = 0, exec_queue = 0,

bind_exec_queue = 0;

tests/intel/xe_vm.c +1 -0
+	bool is_fault_mode = (c->vm_flags &

DRM_XE_VM_CREATE_FLAG_FAULT_MODE) != 0;

tests/intel/xe_vm.c +38 -0
+	uint64_t sync_addr = 0x101a0000, batch_addr = 0x200000000;
+	uint64_t overcommit_size, off, data_addr;
+	size_t sync_size, nf_bo_size = 64 * 1024 * 1024;
+	uint64_t stride = 1024 * 1024, base_size;
+	int64_t timeout = 20 * NSEC_PER_SEC;
+	int i, num_bos, bind_err;
+	bool overcommit_detected = false;
+	struct drm_xe_sync bind_sync[1] = {
+		{
+			.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+			.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+			.timeline_value = USER_FENCE_VALUE
+		},
+	};
+	struct drm_xe_sync exec_sync[1] = {
+		{
+			.type = DRM_XE_SYNC_TYPE_USER_FENCE,
+			.flags = DRM_XE_SYNC_FLAG_SIGNAL,
+			.timeline_value = USER_FENCE_VALUE,
+			.handle = 0,
+		},
+	};
+	struct drm_xe_exec exec = {
+		.num_batch_buffer = 1,
+		.num_syncs = 1,
+		.syncs = to_user_pointer(exec_sync),
+	};
+	struct {
+		uint32_t batch[16];
+		uint64_t pad;
+		uint32_t data;
+		uint64_t vm_sync;
+	} *batch_data = NULL;
+	uint64_t *user_fence_sync = NULL;
+
+	data_addr = c->data_addr;
+	base_size = c->use_vram ? vram_size : system_size;
+	overcommit_size = ALIGN((uint64_t)(base_size * c-
Quoted 1 line

overcommit_mult), 4096);

tests/intel/xe_vm.c +6 -0
+
+	num_bos = (overcommit_size / nf_bo_size) + 1;
+	bos = calloc(num_bos, sizeof(*bos));
+	igt_assert(bos);
+
+	igt_debug("Overcommit test: allocating %d BOs of %llu MB

each",

tests/intel/xe_vm.c +11 -0
+		  num_bos, (unsigned long long)(nf_bo_size >> 20));
+	igt_debug(" total=%llu MB, vram=%llu MB\n",
+		  (unsigned long long)(num_bos * nf_bo_size >> 20),
+		  (unsigned long long)(vram_size >> 20));
+	/* Create VM with appropriate flags */
+	vm = xe_vm_create(fd, c->vm_flags, 0);
+	igt_assert(vm);
+
+	bind_exec_queue = xe_bind_exec_queue_create(fd, vm, 0);
+	sync_size = xe_bb_size(fd, sizeof(uint64_t) * num_bos);
+	user_fence_sync = mmap(NULL, sync_size, PROT_READ |

PROT_WRITE,

tests/intel/xe_vm.c +7 -0
+			       MAP_SHARED | MAP_ANONYMOUS, -1, 0);
+	igt_assert(user_fence_sync != MAP_FAILED);
+	memset(user_fence_sync, 0, sync_size);
+	exec_sync->addr = to_user_pointer(&user_fence_sync[0]);
+
+	/* Create and bind data BOs */
+	create_data_bos(fd, vm, bos, num_bos, nf_bo_size, c-
Quoted 1 line

use_vram, data_addr,

tests/intel/xe_vm.c +1 -0
+			&overcommit_detected, c->bo_flags, eci-
Quoted 1 line

gt_id);

Quoted 10 lines

tests/intel/xe_vm.c static void invalid_vm_id(int fd) · line 2621

Quoted 5 lines
tests/intel/xe_vm.c +3 -0
+
+	if (overcommit_detected) {
+		igt_debug("Overcommit correctly rejected at BO

creation/bind (created %d BOs)\n",

tests/intel/xe_vm.c +1 -0
+			  num_bos);

Shouldn't there be a check for each test where overcommit is expected to fail that it actually gets an overcommit error at the correct location? Like exec() or vm_bind(). Also that it *doesn't* get an overcommit error where it shouldn't.

Currently this test only detects that overcommit occured, but does not verify where it happened will update the test to explicitly

track and assert the expected failure stage per configuration.

Quoted 95 lines
Quoted 26 lines
tests/intel/xe_vm.c +8 -0
+		goto cleanup;
+	}
+
+	/*
+	 * Create batch buffer first in SRAM as focus is to
+	 * check overcommit in VRAM
+	 */
+	batch_bo = xe_bo_create(fd, vm, 0x1000, system_memory(fd),

0);

tests/intel/xe_vm.c +8 -0
+
+	igt_debug("Mapping the created BO");
+	batch_data = xe_bo_map(fd, batch_bo, 0x1000);
+	igt_assert(batch_data);
+	memset(batch_data, 0, 0x1000);
+
+	/*
+	 * Fault mode requires sync_addr to be GPU visible via the

VM

tests/intel/xe_vm.c +4 -0
+	 * CPU local address are not accessible to GPU Page tables
+	 */
+	if (is_fault_mode) {
+		bind_userptr_fault_mode(fd, vm, bind_exec_queue,

user_fence_sync, sync_addr,

tests/intel/xe_vm.c +1 -0
+					sync_size, bind_sync,

&batch_data->vm_sync);

tests/intel/xe_vm.c

Quoted 2 lines
tests/intel/xe_vm.c +2 -0
+		exec_sync->addr = sync_addr;
+	}

Here's another special-casing. The above requirement is not specific to fault-mode.

Will make exec_sync->addr = sync_addr; across all modes .

Quoted 62 lines
tests/intel/xe_vm.c +2 -0
+	batch_data->vm_sync = 0;
+	bind_err = __xe_vm_bind_lr_sync(fd, vm, batch_bo, 0,

batch_addr, 0x1000, 0);

tests/intel/xe_vm.c +6 -0
+	if (bind_err) {
+		if (bind_err == -ENOMEM || bind_err == -ENOSPC) {
+			igt_debug("Setting overcommit to true\n");
+			overcommit_detected = true;
+			goto cleanup;
+		} else { /* Assert any bind error other than -ENOMEM

*/

tests/intel/xe_vm.c +1 -0
+			igt_assert_f(0, "Unexpected bind error %d

(%s)\n", -bind_err,

tests/intel/xe_vm.c +5 -0
+				     strerror(-bind_err));
+		}
+	}
+
+	igt_debug("VM binds done - batch_bo at 0x%llx\n", (unsigned

long long)batch_addr);

tests/intel/xe_vm.c +6 -0
+	/* Create exec queue */
+	exec_queue = xe_exec_queue_create(fd, vm, eci, 0);
+
+	/* Use GPU to write to each BO */
+	for (i = 0; i < num_bos; i++) {
+		igt_debug("Writing to BO %d/%d via GPU\n", i + 1,

num_bos);

tests/intel/xe_vm.c +3 -0
+
+		for (off = 0; off < nf_bo_size; off += stride) {
+			uint64_t target_addr = data_addr + (i *

nf_bo_size) + off;

tests/intel/xe_vm.c +3 -0
+			int b_idx = 0, res = 0;
+
+			batch_data->batch[b_idx++] =

MI_STORE_DWORD_IMM_GEN4;

tests/intel/xe_vm.c +1 -0
+			batch_data->batch[b_idx++] = target_addr &

0xFFFFFFFF;

tests/intel/xe_vm.c +1 -0
+			batch_data->batch[b_idx++] = (target_addr >>

32) & 0xFFFFFFFF;

tests/intel/xe_vm.c +2 -0
+			batch_data->batch[b_idx++] = 0xBB;
+			batch_data->batch[b_idx++] =

MI_BATCH_BUFFER_END;

tests/intel/xe_vm.c +6 -0
+
+			/* Submit batch */
+			exec.exec_queue_id = exec_queue;
+			exec.address = batch_addr;
+
+			res = igt_ioctl(fd, DRM_IOCTL_XE_EXEC,

&exec);

tests/intel/xe_vm.c +2 -0
+			if (res != 0) {
+				if (errno == ENOMEM || errno ==

ENOSPC) {

tests/intel/xe_vm.c +1 -0
+					igt_debug("Expected

fault/error: %d (%s)\n",

tests/intel/xe_vm.c +1 -0
+						  errno,

strerror(errno));

tests/intel/xe_vm.c +3 -0
+					goto cleanup;
+				}
+				igt_assert_f(0, "Unexpected exec

error: %d\n", errno);

tests/intel/xe_vm.c +2 -0
+			}
+			xe_wait_ufence(fd, &user_fence_sync[0],

USER_FENCE_VALUE, exec_queue,

tests/intel/xe_vm.c +1 -0
+				       timeout);
Quoted 8 lines

tests/intel/xe_vm.c

Quoted 5 lines
tests/intel/xe_vm.c +3 -0
+			user_fence_sync[0] = 0;
+		}
+		igt_debug("Accessed BO %d/%d via GPU\n", i + 1,

num_bos);

tests/intel/xe_vm.c +1 -0
+	}

If a test fails with overcommit during the bind phase, then the exec phase is never executed. Is that intentional, or can the exec phase be run on the bos that actually got bound?

At present we are focusing on overcommit detect and exiting the test case with the message.

Will try to check if we can exec bounded bos.

Quoted 69 lines

Thanks,
Thomas

Quoted 64 lines
tests/intel/xe_vm.c +1 -0
+	igt_debug("All batches submitted - waiting for GPU

completion\n");

tests/intel/xe_vm.c +31 -1
+
+	/* Verify GPU writes */
+	verify_bo(fd, bos, num_bos, nf_bo_size, stride);
+
+cleanup:
+	/* Cleanup */
+	if (exec_queue)
+		xe_exec_queue_destroy(fd, exec_queue);
+	if (bind_exec_queue)
+		xe_exec_queue_destroy(fd, bind_exec_queue);
+	if (batch_data)
+		munmap(batch_data, 0x1000);
+	if (batch_bo)
+		gem_close(fd, batch_bo);
+
+	munmap(user_fence_sync, sync_size);
+
+	if (bos) {
+		for (i = 0; i < num_bos; i++) {
+			if (bos[i])
+				gem_close(fd, bos[i]);
+		}
+		free(bos);
+	}
+	if (vm > 0)
+		xe_vm_destroy(fd, vm);
+}
+
  /**
   * SUBTEST: out-of-memory
   * Description: Test if vm_bind ioctl results in oom
@@ -2385,7 +2730,6 @@ static void invalid_vm_id(int fd)
   */
  static void test_oom(int fd)
  {
-#define USER_FENCE_VALUE 0xdeadbeefdeadbeefull
  #define BO_SIZE xe_bb_size(fd, SZ_512M)
  #define MAX_BUFS ((int)(xe_visible_vram_size(fd, 0) / BO_SIZE))
  	uint64_t addr = 0x1a0000;
@@ -3115,6 +3459,18 @@ int igt_main()
  			test_get_property(fd, f->test);
  	}
 
+	for (int i = 0; overcommit_cases[i].name; i++) {
+		const struct vm_overcommit_case *c =
 &overcommit_cases[i];
+		const char *mode = (c->vm_flags &

DRM_XE_VM_CREATE_FLAG_FAULT_MODE) ?

tests/intel/xe_vm.c +5 -0
+					"fault" : "nonfault";
+		igt_subtest_f("overcommit-%s-%s", mode, c->name) {
+			igt_require(xe_has_vram(fd));
+			igt_assert(xe_visible_vram_size(fd, 0));
+			test_vm_overcommit(fd, hwe, c,

(igt_get_avail_ram_mb() << 20),

tests/intel/xe_vm.c +1 -0
+					   xe_visible_vram_size(fd,

0));

tests/intel/xe_vm.c +3 -0
+		}
+	}
+
  	igt_fixture()
  		drm_close_driver(fd);
  }
#5 lore raw

✓ Xe.CI.BAT: success for tests/intel/xe_vm: Add support for overcommit tests (rev6)

In reply to Sobin Thomas
== Series Details ==

== Series Details ==

Series: tests/intel/xe_vm: Add support for overcommit tests (rev6)
URL : https://patchwork.freedesktop.org/series/163579/
State : success

== Summary ==

CI Bug Log - changes from XEIGT_8851_BAT -> XEIGTPW_14943_BAT
====================================================

Summary
-------

**SUCCESS**

No regressions found.

Participating hosts (14 -> 14)
------------------------------

No changes in participating hosts

Known issues
------------

Here are the changes found in XEIGTPW_14943_BAT that come from known issues:

### IGT changes ###

#### Issues hit ####

* igt@core_hotunplug@unbind-rebind:
- bat-bmg-2: [PASS][1] -> [ABORT][2] ([Intel XE#7249] / [Intel XE#7578])
[1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/bat-bmg-2/igt@[email protected]
[2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/bat-bmg-2/igt@[email protected]

* igt@xe_pat@pat-index-xe2@render:
- bat-ptl-vm: [PASS][3] -> [DMESG-WARN][4] ([Intel XE#7110]) +1 other test dmesg-warn
[3]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/bat-ptl-vm/igt@xe_pat@[email protected]
[4]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/bat-ptl-vm/igt@xe_pat@[email protected]

[Intel XE#7110]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7110
[Intel XE#7249]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7249
[Intel XE#7578]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7578

Build changes
-------------

* IGT: IGT_8851 -> IGTPW_14943

IGTPW_14943: 14943
IGT_8851: 8851
xe-4860-5ee75b2816df74bfe606d4dfc061547d5cda4ebf: 5ee75b2816df74bfe606d4dfc061547d5cda4ebf

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/index.html

#6 lore raw

✗ i915.CI.BAT: failure for tests/intel/xe_vm: Add support for overcommit tests (rev6)

In reply to Sobin Thomas
== Series Details ==

== Series Details ==

Series: tests/intel/xe_vm: Add support for overcommit tests (rev6)
URL : https://patchwork.freedesktop.org/series/163579/
State : failure

== Summary ==

CI Bug Log - changes from IGT_8851 -> IGTPW_14943
====================================================

Summary
-------

**FAILURE**

Serious unknown changes coming with IGTPW_14943 absolutely need to be verified manually.

If you think the reported changes have nothing to do with the changes
introduced in IGTPW_14943, please notify your bug team ([email protected]) to allow them to document this new failure mode, which will reduce false positives in CI.

External URL: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/index.html

Participating hosts (42 -> 39)
------------------------------

Missing (3): bat-dg2-13 fi-snb-2520m bat-adls-6

Possible new issues
-------------------

Here are the unknown changes that may have been introduced in IGTPW_14943:

### IGT changes ###

#### Possible regressions ####

* igt@i915_selftest@live@requests:
- bat-atsm-1: [PASS][1] -> [INCOMPLETE][2]
[1]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8851/bat-atsm-1/igt@i915_selftest@[email protected]
[2]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/bat-atsm-1/igt@i915_selftest@[email protected]

Known issues
------------

Here are the changes found in IGTPW_14943 that come from known issues:

### IGT changes ###

#### Issues hit ####

* igt@core_debugfs@read-all-entries:
- bat-adlp-9: [PASS][3] -> [DMESG-WARN][4] ([i915#15673])
[3]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8851/bat-adlp-9/igt@[email protected]
[4]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/bat-adlp-9/igt@[email protected]

* igt@dmabuf@all-tests@dma_fence_chain:
- fi-glk-j4005: NOTRUN -> [SKIP][5]
[5]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/fi-glk-j4005/igt@dmabuf@all-tests@dma_fence_chain.html

* igt@gem_lmem_swapping@parallel-random-engines:
- fi-glk-j4005: NOTRUN -> [SKIP][6] ([i915#4613]) +3 other tests skip
[6]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/fi-glk-j4005/igt@[email protected]

* igt@i915_selftest@live:
- bat-mtlp-8: [PASS][7] -> [DMESG-FAIL][8] ([i915#12061]) +1 other test dmesg-fail
[7]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8851/bat-mtlp-8/igt@[email protected]
[8]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/bat-mtlp-8/igt@[email protected]

* igt@i915_selftest@live@workarounds:
- bat-dg2-14: [PASS][9] -> [DMESG-FAIL][10] ([i915#12061]) +1 other test dmesg-fail
[9]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8851/bat-dg2-14/igt@i915_selftest@[email protected]
[10]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/bat-dg2-14/igt@i915_selftest@[email protected]
- bat-mtlp-9: [PASS][11] -> [DMESG-FAIL][12] ([i915#12061]) +1 other test dmesg-fail
[11]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8851/bat-mtlp-9/igt@i915_selftest@[email protected]
[12]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/bat-mtlp-9/igt@i915_selftest@[email protected]

#### Possible fixes ####

* igt@core_auth@basic-auth:
- bat-adlp-9: [DMESG-WARN][13] ([i915#15673]) -> [PASS][14]
[13]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8851/bat-adlp-9/igt@[email protected]
[14]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/bat-adlp-9/igt@[email protected]

* igt@prime_vgem@basic-gtt:
- fi-glk-j4005: [ABORT][15] ([i915#15773]) -> [PASS][16]
[15]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8851/fi-glk-j4005/igt@[email protected]
[16]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/fi-glk-j4005/igt@[email protected]

#### Warnings ####

* igt@i915_selftest@live:
- bat-atsm-1: [DMESG-FAIL][17] ([i915#12061]) -> [INCOMPLETE][18] ([i915#12061])
[17]: https://intel-gfx-ci.01.org/tree/drm-tip/IGT_8851/bat-atsm-1/igt@[email protected]
[18]: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/bat-atsm-1/igt@[email protected]

[i915#12061]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/12061
[i915#15673]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15673
[i915#15773]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/15773
[i915#4613]: https://gitlab.freedesktop.org/drm/i915/kernel/-/issues/4613

Build changes
-------------

* CI: CI-20190529 -> None
* IGT: IGT_8851 -> IGTPW_14943
* Linux: CI_DRM_18296 -> CI_DRM_18298

CI-20190529: 20190529
CI_DRM_18296: 994d34e9b0e78a8c9f5768d55529bdf194654793 @ git://anongit.freedesktop.org/gfx-ci/linux
CI_DRM_18298: 3a7f2775c2f880223cea81a9e0994cabad42c061 @ git://anongit.freedesktop.org/gfx-ci/linux
IGTPW_14943: 14943
IGT_8851: 8851

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/drm-tip/IGTPW_14943/index.html

#7 lore raw

✗ Xe.CI.FULL: failure for tests/intel/xe_vm: Add support for overcommit tests (rev6)

In reply to Sobin Thomas
== Series Details ==

== Series Details ==

Series: tests/intel/xe_vm: Add support for overcommit tests (rev6)
URL : https://patchwork.freedesktop.org/series/163579/
State : failure

== Summary ==

CI Bug Log - changes from XEIGT_8851_FULL -> XEIGTPW_14943_FULL
====================================================

Summary
-------

**FAILURE**

Serious unknown changes coming with XEIGTPW_14943_FULL absolutely need to be verified manually.

If you think the reported changes have nothing to do with the changes
introduced in XEIGTPW_14943_FULL, please notify your bug team ([email protected]) to allow them to document this new failure mode, which will reduce false positives in CI.

Participating hosts (2 -> 2)
------------------------------

No changes in participating hosts

Possible new issues
-------------------

Here are the unknown changes that may have been introduced in XEIGTPW_14943_FULL:

### IGT changes ###

#### Possible regressions ####

* igt@xe_fault_injection@probe-fail-guc-xe_guc_mmio_send_recv:
- shard-bmg: [PASS][1] -> [DMESG-WARN][2]
[1]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-3/igt@xe_fault_injection@probe-fail-guc-xe_guc_mmio_send_recv.html
[2]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-2/igt@xe_fault_injection@probe-fail-guc-xe_guc_mmio_send_recv.html

* igt@xe_vm@overcommit-nonfault-vram-lr-external-nodefer (NEW):
- shard-lnl: NOTRUN -> [SKIP][3] +4 other tests skip
[3]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-lnl-5/igt@[email protected]

New tests
---------

New tests have been introduced between XEIGT_8851_FULL and XEIGTPW_14943_FULL:

### New IGT tests (5) ###

* igt@xe_vm@overcommit-fault-vram-lr-fault:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0, 13.45] s

* igt@xe_vm@overcommit-fault-vram-lr-fault-no-overcommit:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0, 5.45] s

* igt@xe_vm@overcommit-nonfault-vram-lr-defer:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0, 0.48] s

* igt@xe_vm@overcommit-nonfault-vram-lr-external-nodefer:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0, 2.90] s

* igt@xe_vm@overcommit-nonfault-vram-no-lr:
- Statuses : 1 pass(s) 1 skip(s)
- Exec time: [0.0, 2.55] s

Known issues
------------

Here are the changes found in XEIGTPW_14943_FULL that come from known issues:

### IGT changes ###

#### Issues hit ####

* igt@kms_big_fb@linear-32bpp-rotate-270:
- shard-bmg: NOTRUN -> [SKIP][4] ([Intel XE#2327]) +1 other test skip
[4]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-4/igt@[email protected]

* igt@kms_big_fb@linear-max-hw-stride-32bpp-rotate-0-hflip:
- shard-bmg: NOTRUN -> [SKIP][5] ([Intel XE#7059] / [Intel XE#7085]) +1 other test skip
[5]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-1/igt@[email protected]

* igt@kms_big_fb@y-tiled-max-hw-stride-32bpp-rotate-180:
- shard-bmg: NOTRUN -> [SKIP][6] ([Intel XE#1124]) +3 other tests skip
[6]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-1/igt@[email protected]

* igt@kms_bw@linear-tiling-2-displays-3840x2160p:
- shard-bmg: NOTRUN -> [SKIP][7] ([Intel XE#367] / [Intel XE#7354])
[7]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]

* igt@kms_ccs@crc-primary-suspend-y-tiled-gen12-rc-ccs:
- shard-bmg: NOTRUN -> [SKIP][8] ([Intel XE#3432])
[8]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@[email protected]

* igt@kms_ccs@crc-sprite-planes-basic-4-tiled-mtl-rc-ccs:
- shard-bmg: NOTRUN -> [SKIP][9] ([Intel XE#2887]) +3 other tests skip
[9]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-8/igt@[email protected]

* igt@kms_chamelium_hpd@dp-hpd-after-hibernate:
- shard-bmg: NOTRUN -> [SKIP][10] ([Intel XE#2252]) +1 other test skip
[10]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@[email protected]

* igt@kms_content_protection@dp-mst-type-0-hdcp14:
- shard-bmg: NOTRUN -> [SKIP][11] ([Intel XE#6974])
[11]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]

* igt@kms_content_protection@srm@pipe-a-dp-2:
- shard-bmg: NOTRUN -> [FAIL][12] ([Intel XE#1178] / [Intel XE#3304] / [Intel XE#7374]) +1 other test fail
[12]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-9/igt@kms_content_protection@[email protected]

* igt@kms_content_protection@uevent-hdcp14:
- shard-bmg: NOTRUN -> [FAIL][13] ([Intel XE#6707] / [Intel XE#7439]) +1 other test fail
[13]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-4/igt@[email protected]

* igt@kms_cursor_crc@cursor-rapid-movement-128x42:
- shard-bmg: NOTRUN -> [SKIP][14] ([Intel XE#2320]) +1 other test skip
[14]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@[email protected]

* igt@kms_cursor_legacy@cursor-vs-flip-varying-size:
- shard-bmg: [PASS][15] -> [DMESG-WARN][16] ([Intel XE#5354])
[15]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-10/igt@[email protected]
[16]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-5/igt@[email protected]

* igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions:
- shard-bmg: NOTRUN -> [SKIP][17] ([Intel XE#2286] / [Intel XE#6035])
[17]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@kms_cursor_legacy@short-busy-flip-before-cursor-atomic-transitions.html

* igt@kms_flip@flip-vs-expired-vblank-interruptible@b-edp1:
- shard-lnl: [PASS][18] -> [FAIL][19] ([Intel XE#301]) +1 other test fail
[18]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-lnl-2/igt@kms_flip@[email protected]
[19]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-lnl-6/igt@kms_flip@[email protected]

* igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-16bpp-yftile-downscaling:
- shard-bmg: NOTRUN -> [SKIP][20] ([Intel XE#7178] / [Intel XE#7351])
[20]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-6/igt@kms_flip_scaled_crc@flip-64bpp-yftile-to-16bpp-yftile-downscaling.html

* igt@kms_frontbuffer_tracking@fbc-2p-scndscrn-cur-indfb-draw-blt:
- shard-bmg: NOTRUN -> [SKIP][21] ([Intel XE#4141]) +5 other tests skip
[21]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-8/igt@[email protected]

* igt@kms_frontbuffer_tracking@fbcdrrs-1p-offscreen-pri-shrfb-draw-blt:
- shard-bmg: NOTRUN -> [SKIP][22] ([Intel XE#2311]) +10 other tests skip
[22]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-9/igt@kms_frontbuffer_tracking@fbcdrrs-1p-offscreen-pri-shrfb-draw-blt.html

* igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-mmap-wc:
- shard-bmg: NOTRUN -> [SKIP][23] ([Intel XE#2313]) +9 other tests skip
[23]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-10/igt@kms_frontbuffer_tracking@fbcpsr-1p-offscreen-pri-indfb-draw-mmap-wc.html

* igt@kms_frontbuffer_tracking@psr-abgr161616f-draw-blt:
- shard-bmg: NOTRUN -> [SKIP][24] ([Intel XE#7061] / [Intel XE#7356])
[24]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@[email protected]

* igt@kms_multipipe_modeset@basic-max-pipe-crc-check:
- shard-bmg: NOTRUN -> [SKIP][25] ([Intel XE#7591])
[25]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-9/igt@[email protected]

* igt@kms_plane_multiple@2x-tiling-y:
- shard-bmg: NOTRUN -> [SKIP][26] ([Intel XE#5021] / [Intel XE#7377])
[26]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-8/igt@[email protected]

* igt@kms_plane_scaling@planes-upscale-20x20-downscale-factor-0-5@pipe-b:
- shard-bmg: NOTRUN -> [SKIP][27] ([Intel XE#2763] / [Intel XE#6886]) +4 other tests skip
[27]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@kms_plane_scaling@[email protected]

* igt@kms_pm_dc@dc5-dpms:
- shard-lnl: [PASS][28] -> [FAIL][29] ([Intel XE#7340] / [Intel XE#7504])
[28]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-lnl-7/igt@[email protected]
[29]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-lnl-4/igt@[email protected]

* igt@kms_psr2_sf@fbc-pr-overlay-plane-move-continuous-exceed-fully-sf:
- shard-bmg: NOTRUN -> [SKIP][30] ([Intel XE#1489]) +1 other test skip
[30]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-8/igt@kms_psr2_sf@fbc-pr-overlay-plane-move-continuous-exceed-fully-sf.html

* igt@kms_psr2_su@frontbuffer-xrgb8888:
- shard-bmg: NOTRUN -> [SKIP][31] ([Intel XE#2387] / [Intel XE#7429])
[31]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-1/igt@[email protected]

* igt@kms_psr@psr2-no-drrs:
- shard-bmg: NOTRUN -> [SKIP][32] ([Intel XE#2234] / [Intel XE#2850]) +3 other tests skip
[32]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-10/igt@[email protected]

* igt@kms_psr_stress_test@flip-primary-invalidate-overlay:
- shard-bmg: NOTRUN -> [SKIP][33] ([Intel XE#1406] / [Intel XE#2414])
[33]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-8/igt@[email protected]

* igt@kms_vrr@flipline:
- shard-bmg: NOTRUN -> [SKIP][34] ([Intel XE#1499])
[34]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-8/igt@[email protected]

* igt@kms_vrr@seamless-rr-switch-virtual@pipe-a-edp-1:
- shard-lnl: [PASS][35] -> [FAIL][36] ([Intel XE#2142]) +1 other test fail
[35]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-lnl-5/igt@kms_vrr@[email protected]
[36]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-lnl-4/igt@kms_vrr@[email protected]

* igt@xe_eudebug@basic-vms:
- shard-bmg: NOTRUN -> [SKIP][37] ([Intel XE#7636]) +5 other tests skip
[37]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-1/igt@[email protected]

* igt@xe_exec_basic@multigpu-no-exec-bindexecqueue:
- shard-bmg: NOTRUN -> [SKIP][38] ([Intel XE#2322] / [Intel XE#7372]) +4 other tests skip
[38]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@[email protected]

* igt@xe_exec_fault_mode@many-multi-queue-rebind-prefetch:
- shard-bmg: NOTRUN -> [SKIP][39] ([Intel XE#7136]) +4 other tests skip
[39]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-1/igt@[email protected]

* igt@xe_exec_multi_queue@few-execs-preempt-mode-userptr-invalidate:
- shard-bmg: NOTRUN -> [SKIP][40] ([Intel XE#6874]) +11 other tests skip
[40]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@xe_exec_multi_queue@few-execs-preempt-mode-userptr-invalidate.html

* igt@xe_exec_threads@threads-multi-queue-mixed-userptr-invalidate-race:
- shard-bmg: NOTRUN -> [SKIP][41] ([Intel XE#7138]) +1 other test skip
[41]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-8/igt@xe_exec_threads@threads-multi-queue-mixed-userptr-invalidate-race.html

* igt@xe_mmap@small-bar:
- shard-bmg: NOTRUN -> [SKIP][42] ([Intel XE#586] / [Intel XE#7323] / [Intel XE#7384])
[42]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-6/igt@[email protected]

* igt@xe_multigpu_svm@mgpu-latency-copy-basic:
- shard-bmg: NOTRUN -> [SKIP][43] ([Intel XE#6964])
[43]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-1/igt@[email protected]

* igt@xe_pat@xa-app-transient-media-off:
- shard-bmg: NOTRUN -> [SKIP][44] ([Intel XE#7590])
[44]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]

* igt@xe_pxp@pxp-termination-key-update-post-termination-irq:
- shard-bmg: NOTRUN -> [SKIP][45] ([Intel XE#4733] / [Intel XE#7417]) +1 other test skip
[45]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]

* igt@xe_query@multigpu-query-oa-units:
- shard-bmg: NOTRUN -> [SKIP][46] ([Intel XE#944])
[46]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]

* igt@xe_sriov_flr@flr-vfs-parallel:
- shard-bmg: [PASS][47] -> [FAIL][48] ([Intel XE#6569])
[47]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-3/igt@[email protected]
[48]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]

* igt@xe_sriov_scheduling@equal-throughput@numvfs-random:
- shard-bmg: [PASS][49] -> [FAIL][50] ([Intel XE#5937]) +2 other tests fail
[49]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-8/igt@xe_sriov_scheduling@[email protected]
[50]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-10/igt@xe_sriov_scheduling@[email protected]

#### Possible fixes ####

* igt@kms_atomic_transition@plane-all-transition-nonblocking:
- shard-bmg: [INCOMPLETE][51] -> [PASS][52] +1 other test pass
[51]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-2/igt@[email protected]
[52]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@[email protected]

* igt@kms_cursor_legacy@flip-vs-cursor-atomic:
- shard-bmg: [FAIL][53] ([Intel XE#7571]) -> [PASS][54] +1 other test pass
[53]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-7/igt@[email protected]
[54]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]

* igt@kms_cursor_legacy@flip-vs-cursor-atomic-transitions:
- shard-bmg: [FAIL][55] -> [PASS][56]
[55]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-7/igt@[email protected]
[56]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]

* igt@kms_hdmi_inject@inject-audio:
- shard-bmg: [SKIP][57] ([Intel XE#7308]) -> [PASS][58]
[57]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-10/igt@[email protected]
[58]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-6/igt@[email protected]

* igt@kms_pm_dc@dc6-psr:
- shard-lnl: [FAIL][59] ([Intel XE#7340]) -> [PASS][60]
[59]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-lnl-1/igt@[email protected]
[60]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-lnl-6/igt@[email protected]

* igt@kms_rotation_crc@primary-4-tiled-reflect-x-0:
- shard-bmg: [ABORT][61] ([Intel XE#7200]) -> [PASS][62]
[61]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-1/igt@[email protected]
[62]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]

* igt@xe_module_load@load:
- shard-bmg: ([PASS][63], [PASS][64], [PASS][65], [PASS][66], [PASS][67], [SKIP][68], [PASS][69], [PASS][70], [PASS][71], [PASS][72], [PASS][73], [PASS][74], [PASS][75], [PASS][76], [PASS][77], [PASS][78], [PASS][79], [PASS][80], [PASS][81], [PASS][82], [PASS][83], [PASS][84], [PASS][85], [PASS][86], [PASS][87]) ([Intel XE#2457] / [Intel XE#7405]) -> ([PASS][88], [PASS][89], [PASS][90], [PASS][91], [PASS][92], [PASS][93], [PASS][94], [PASS][95], [PASS][96], [PASS][97], [PASS][98], [PASS][99], [PASS][100], [PASS][101], [PASS][102], [PASS][103], [PASS][104], [PASS][105], [PASS][106], [PASS][107], [PASS][108], [PASS][109], [PASS][110], [PASS][111], [PASS][112])
[63]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-5/igt@[email protected]
[64]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-6/igt@[email protected]
[65]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-2/igt@[email protected]
[66]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-3/igt@[email protected]
[67]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-3/igt@[email protected]
[68]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-2/igt@[email protected]
[69]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-2/igt@[email protected]
[70]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-9/igt@[email protected]
[71]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-9/igt@[email protected]
[72]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-9/igt@[email protected]
[73]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-3/igt@[email protected]
[74]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-7/igt@[email protected]
[75]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-7/igt@[email protected]
[76]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-7/igt@[email protected]
[77]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-1/igt@[email protected]
[78]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-1/igt@[email protected]
[79]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-1/igt@[email protected]
[80]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-10/igt@[email protected]
[81]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-10/igt@[email protected]
[82]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-10/igt@[email protected]
[83]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-8/igt@[email protected]
[84]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-8/igt@[email protected]
[85]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-8/igt@[email protected]
[86]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-5/igt@[email protected]
[87]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-5/igt@[email protected]
[88]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-5/igt@[email protected]
[89]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-6/igt@[email protected]
[90]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-4/igt@[email protected]
[91]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-6/igt@[email protected]
[92]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-4/igt@[email protected]
[93]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-8/igt@[email protected]
[94]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-8/igt@[email protected]
[95]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-1/igt@[email protected]
[96]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-1/igt@[email protected]
[97]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-9/igt@[email protected]
[98]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-5/igt@[email protected]
[99]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]
[100]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@[email protected]
[101]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@[email protected]
[102]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]
[103]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-2/igt@[email protected]
[104]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-1/igt@[email protected]
[105]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-7/igt@[email protected]
[106]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-5/igt@[email protected]
[107]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-2/igt@[email protected]
[108]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-10/igt@[email protected]
[109]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-10/igt@[email protected]
[110]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-8/igt@[email protected]
[111]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-9/igt@[email protected]
[112]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@[email protected]

* igt@xe_sriov_flr@flr-vf1-clear:
- shard-bmg: [FAIL][113] ([Intel XE#6569]) -> [PASS][114]
[113]: https://intel-gfx-ci.01.org/tree/intel-xe/IGT_8851/shard-bmg-1/igt@[email protected]
[114]: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/shard-bmg-3/igt@[email protected]

[Intel XE#1124]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1124
[Intel XE#1178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1178
[Intel XE#1406]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1406
[Intel XE#1489]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1489
[Intel XE#1499]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/1499
[Intel XE#2142]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2142
[Intel XE#2234]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2234
[Intel XE#2252]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2252
[Intel XE#2286]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2286
[Intel XE#2311]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2311
[Intel XE#2313]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2313
[Intel XE#2320]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2320
[Intel XE#2322]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2322
[Intel XE#2327]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2327
[Intel XE#2387]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2387
[Intel XE#2414]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2414
[Intel XE#2457]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2457
[Intel XE#2763]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2763
[Intel XE#2850]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2850
[Intel XE#2887]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/2887
[Intel XE#301]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/301
[Intel XE#3304]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3304
[Intel XE#3432]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/3432
[Intel XE#367]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/367
[Intel XE#4141]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4141
[Intel XE#4733]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/4733
[Intel XE#5021]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5021
[Intel XE#5354]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5354
[Intel XE#586]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/586
[Intel XE#5937]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/5937
[Intel XE#6035]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6035
[Intel XE#6569]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6569
[Intel XE#6707]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6707
[Intel XE#6874]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6874
[Intel XE#6886]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6886
[Intel XE#6964]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6964
[Intel XE#6974]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/6974
[Intel XE#7059]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7059
[Intel XE#7061]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7061
[Intel XE#7085]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7085
[Intel XE#7136]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7136
[Intel XE#7138]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7138
[Intel XE#7178]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7178
[Intel XE#7200]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7200
[Intel XE#7308]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7308
[Intel XE#7323]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7323
[Intel XE#7340]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7340
[Intel XE#7351]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7351
[Intel XE#7354]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7354
[Intel XE#7356]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7356
[Intel XE#7372]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7372
[Intel XE#7374]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7374
[Intel XE#7377]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7377
[Intel XE#7384]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7384
[Intel XE#7405]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7405
[Intel XE#7417]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7417
[Intel XE#7429]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7429
[Intel XE#7439]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7439
[Intel XE#7504]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7504
[Intel XE#7571]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7571
[Intel XE#7590]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7590
[Intel XE#7591]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7591
[Intel XE#7636]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/7636
[Intel XE#944]: https://gitlab.freedesktop.org/drm/xe/kernel/issues/944

Build changes
-------------

* IGT: IGT_8851 -> IGTPW_14943

IGTPW_14943: 14943
IGT_8851: 8851
xe-4860-5ee75b2816df74bfe606d4dfc061547d5cda4ebf: 5ee75b2816df74bfe606d4dfc061547d5cda4ebf

== Logs ==

For more details see: https://intel-gfx-ci.01.org/tree/intel-xe/IGTPW_14943/index.html