[PATCH i-g-t 11/21] tests/xe_eudebug: Adapt basic-vm-bind and remove basic-vm-bind-extended

[Mika Kuoppala <mika.kuoppala@linux.intel.com>]

From: Christoph Manszewski <christoph.manszewski@intel.com>

EU debug no longer relays events for VM_BIND_OP_[MAP|UNMAP] operations.
Instead it reports newly added 'VM_BIND_OP_DEBUG_DATA_[ADD|REMOVE]'
operations through the event interface. Convert the basic-vm-bind
subtest to use these newly introduced ops. Because debug data can't be
rebound and partially unbound, remove the basic-vm-bind-extended
subtest.

Signed-off-by: Christoph Manszewski <christoph.manszewski@intel.com>
Signed-off-by: Mika Kuoppala <mika.kuoppala@linux.intel.com>
---
 tests/intel/xe_eudebug.c | 154 ++++++++++-----------------------------
 1 file changed, 39 insertions(+), 115 deletions(-)

diff --git a/tests/intel/xe_eudebug.c b/tests/intel/xe_eudebug.c
index 353828f673..e9efb47da8 100644
--- a/tests/intel/xe_eudebug.c
+++ b/tests/intel/xe_eudebug.c
@@ -60,11 +60,10 @@ static void test_sysfs_toggle(int fd)
 #define CREATE_EXEC_QUEUES		(1 << 2)
 #define VM_BIND				(1 << 3)
 #define VM_BIND_VM_DESTROY		(1 << 4)
-#define VM_BIND_EXTENDED		(1 << 5)
-#define VM_BIND_OP_MAP_USERPTR		(1 << 6)
-#define VM_BIND_DELAY_UFENCE_ACK	(1 << 7)
-#define VM_BIND_UFENCE_DISCONNECT	(1 << 8)
-#define VM_BIND_UFENCE_SIGINT_CLIENT	(1 << 9)
+#define VM_BIND_OP_MAP_USERPTR		(1 << 5)
+#define VM_BIND_DELAY_UFENCE_ACK	(1 << 6)
+#define VM_BIND_UFENCE_DISCONNECT	(1 << 7)
+#define VM_BIND_UFENCE_SIGINT_CLIENT	(1 << 8)
 #define TEST_FAULTABLE			(1 << 30)
 #define TEST_DISCOVERY			(1 << 31)
 
@@ -74,41 +73,58 @@ static void test_sysfs_toggle(int fd)
 
 static void basic_vm_bind_client(struct xe_eudebug_client *c)
 {
-	struct drm_xe_vm_bind_op_ext_attach_debug *ext = NULL;
 	uint32_t vm = xe_eudebug_client_vm_create(c, DRM_XE_VM_CREATE_FLAG_LR_MODE, 0);
-	size_t bo_size = xe_get_default_alignment(c->fd);
 	bool test_discovery = c->flags & TEST_DISCOVERY;
-	uint32_t bo = xe_bo_create(c->fd, 0, bo_size,
-				   system_memory(c->fd), 0);
 	uint64_t addr = 0x1a0000;
+	size_t range = 0x1000;
 
-	xe_eudebug_client_vm_bind_flags(c, vm, bo, 0, addr,
-					bo_size, 0, NULL, 0, to_user_pointer(ext));
+	xe_eudebug_client_vm_bind_debug_data_add(c, vm, 0, addr, range,
+						 DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_MODULE_AREA,
+						 NULL, NULL, 0);
 
 	if (test_discovery) {
 		xe_eudebug_client_signal_stage(c, STAGE_PRE_DEBUG_RESOURCES_DONE);
 		xe_eudebug_client_wait_stage(c, STAGE_DISCOVERY_DONE);
 	}
 
-	xe_eudebug_client_vm_unbind(c, vm, 0, addr, bo_size);
+	xe_eudebug_client_vm_bind_debug_data_remove(c, vm, addr, range);
 
-	gem_close(c->fd, bo);
 	xe_eudebug_client_vm_destroy(c, vm);
 }
 
+static void vm_bind_add_debug_data(struct xe_eudebug_client *c, uint32_t vm,
+				   uint64_t addr, uint64_t range)
+{
+	struct drm_xe_vm_bind_op_ext_debug_data op_ext = { 0, };
+
+	op_ext.base.name = XE_VM_BIND_OP_EXTENSIONS_DEBUG_DATA;
+	op_ext.base.next_extension = 0;
+	op_ext.base.pad = 0;
+
+	op_ext.pseudopath = DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_MODULE_AREA;
+	op_ext.flags = DRM_XE_VM_BIND_DEBUG_DATA_FLAG_PSEUDO;
+
+	op_ext.addr = addr;
+	op_ext.range = range;
+	op_ext.offset = 0;
+	op_ext.reserved = 0;
+
+	___xe_vm_bind(c->fd, vm, 0, 0, 0, 0, 0,
+		      DRM_XE_VM_BIND_OP_ADD_DEBUG_DATA, 0, NULL, 0, 0,
+		      0, 0, to_user_pointer(&op_ext));
+}
+
 static void basic_vm_bind_vm_destroy_client(struct xe_eudebug_client *c)
 {
 	uint32_t vm = xe_eudebug_client_vm_create(c, DRM_XE_VM_CREATE_FLAG_LR_MODE, 0);
-	size_t bo_size = xe_get_default_alignment(c->fd);
 	bool test_discovery = c->flags & TEST_DISCOVERY;
-	uint32_t bo = xe_bo_create(c->fd, 0, bo_size,
-				   system_memory(c->fd), 0);
 	uint64_t addr = 0x1a0000;
+	uint64_t range = 0x1000;
 
 	if (test_discovery) {
 		vm = xe_vm_create(c->fd, DRM_XE_VM_CREATE_FLAG_LR_MODE, 0);
 
-		xe_vm_bind_async(c->fd, vm, 0, bo, 0, addr, bo_size, NULL, 0);
+		vm_bind_add_debug_data(c, vm, addr, range);
 
 		xe_vm_destroy(c->fd, vm);
 
@@ -116,11 +132,11 @@ static void basic_vm_bind_vm_destroy_client(struct xe_eudebug_client *c)
 		xe_eudebug_client_wait_stage(c, STAGE_DISCOVERY_DONE);
 	} else {
 		vm = xe_eudebug_client_vm_create(c, DRM_XE_VM_CREATE_FLAG_LR_MODE, 0);
-		xe_eudebug_client_vm_bind(c, vm, bo, 0, addr, bo_size);
+		xe_eudebug_client_vm_bind_debug_data_add(c, vm, 0, addr, range,
+							 DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_MODULE_AREA,
+							 NULL, NULL, 0);
 		xe_eudebug_client_vm_destroy(c, vm);
 	}
-
-	gem_close(c->fd, bo);
 }
 
 #define BO_ITEMS 4096
@@ -307,75 +323,6 @@ static void free_bind_list(struct xe_eudebug_client *c, struct bind_list *bl)
 	free(bl);
 }
 
-static void vm_bind_client(struct xe_eudebug_client *c)
-{
-	uint64_t op_ref_seqno, ref_seqno;
-	struct bind_list *bl;
-	bool test_discovery = c->flags & TEST_DISCOVERY;
-	size_t bo_size = 3 * xe_get_default_alignment(c->fd);
-	uint32_t bo[2] = {
-		xe_bo_create(c->fd, 0, bo_size, system_memory(c->fd), 0),
-		xe_bo_create(c->fd, 0, bo_size, system_memory(c->fd), 0),
-	};
-	uint32_t vm = xe_eudebug_client_vm_create(c, DRM_XE_VM_CREATE_FLAG_LR_MODE, 0);
-	uint64_t addr[] = {0x2a0000, 0x3a0000};
-	uint64_t rebind_bo_offset = 2 * bo_size / 3;
-	uint64_t size = bo_size / 3;
-	int i = 0;
-
-	if (test_discovery) {
-		xe_vm_bind_async(c->fd, vm, 0, bo[0], 0, addr[0], bo_size, NULL, 0);
-
-		xe_vm_unbind_async(c->fd, vm, 0, 0, addr[0] + size, size, NULL, 0);
-
-		xe_vm_bind_async(c->fd, vm, 0, bo[1], 0, addr[1], bo_size, NULL, 0);
-
-		xe_vm_bind_async(c->fd, vm, 0, bo[1], rebind_bo_offset, addr[1], size, NULL, 0);
-
-		bl = create_bind_list(c->fd, system_memory(c->fd), vm, 4, 0);
-		xe_vm_bind_array(c->fd, bl->vm, 0, bl->bind_ops, bl->n, NULL, 0);
-
-		xe_vm_unbind_all_async(c->fd, vm, 0, bo[0], NULL, 0);
-
-		xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
-						bl->vm, 0, bl->n + 2, &ref_seqno);
-
-		xe_eudebug_client_vm_bind_op_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, ref_seqno,
-						   &op_ref_seqno, addr[1], size, 0);
-		xe_eudebug_client_vm_bind_op_event(c, DRM_XE_EUDEBUG_EVENT_CREATE, ref_seqno,
-						   &op_ref_seqno, addr[1] + size, size * 2, 0);
-
-		for (i = 0; i < bl->n; i++)
-			xe_eudebug_client_vm_bind_op_event(c, DRM_XE_EUDEBUG_EVENT_CREATE,
-							   ref_seqno, &op_ref_seqno,
-							   bl->bind_ops[i].addr,
-							   bl->bind_ops[i].range, 0);
-
-		xe_eudebug_client_signal_stage(c, STAGE_PRE_DEBUG_RESOURCES_DONE);
-		xe_eudebug_client_wait_stage(c, STAGE_DISCOVERY_DONE);
-	} else {
-		xe_eudebug_client_vm_bind(c, vm, bo[0], 0, addr[0], bo_size);
-		xe_eudebug_client_vm_unbind(c, vm, 0, addr[0] + size, size);
-
-		xe_eudebug_client_vm_bind(c, vm, bo[1], 0, addr[1], bo_size);
-		xe_eudebug_client_vm_bind(c, vm, bo[1], rebind_bo_offset, addr[1], size);
-
-		bl = create_bind_list(c->fd, system_memory(c->fd), vm, 4, 0);
-		do_bind_list(c, bl, false);
-	}
-
-	xe_vm_unbind_all_async(c->fd, vm, 0, bo[1], NULL, 0);
-
-	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE, vm, 0,
-					1, &ref_seqno);
-	xe_eudebug_client_vm_bind_op_event(c, DRM_XE_EUDEBUG_EVENT_DESTROY, ref_seqno,
-					   &op_ref_seqno, 0, 0, 0);
-
-	gem_close(c->fd, bo[0]);
-	gem_close(c->fd, bo[1]);
-	xe_eudebug_client_vm_destroy(c, vm);
-}
-
 static void run_basic_client(struct xe_eudebug_client *c)
 {
 	int i;
@@ -432,9 +379,6 @@ static void run_basic_client(struct xe_eudebug_client *c)
 	if (c->flags & VM_BIND)
 		basic_vm_bind_client(c);
 
-	if (c->flags & VM_BIND_EXTENDED)
-		vm_bind_client(c);
-
 	if (c->flags & VM_BIND_VM_DESTROY)
 		basic_vm_bind_vm_destroy_client(c);
 }
@@ -891,20 +835,13 @@ static void test_read_event(int fd)
  * SUBTEST: basic-vm-bind
  * Functionality: VM bind event
  * Description:
- *	Attach the debugger to a process that performs synchronous vm bind
- *	and vm unbind.
+ *	Attach the debugger to a process that adds and removes vm debug data.
  *
  * SUBTEST: basic-vm-bind-vm-destroy
  * Functionality: VM bind event
  * Description:
- *	Attach the debugger to a process that performs vm bind, and destroys
- *	the vm without unbinding. Make sure that we don't get unbind events.
- *
- * SUBTEST: basic-vm-bind-extended
- * Functionality: VM bind event
- * Description:
- *	Attach the debugger to a process that performs bind, bind array, rebind,
- *	partial unbind, unbind and unbind all operations.
+ *	Attach the debugger to a process that adds vm debug data, and destroys the vm without
+ *	removing debug data. Make sure that we don't get debug data remove events.
  *
  * SUBTEST: multigpu-basic-client
  * Mega feature: MultiGPU
@@ -955,13 +892,6 @@ static void test_basic_sessions(int fd, unsigned int flags, int count, bool matc
  *	Attach the debugger to a process that performs vm bind, and destroys
  *	the vm without unbinding before attaching. Make sure that we don't get
  *	any bind/unbind and vm create/destroy events.
- *
- * SUBTEST: basic-vm-bind-extended-discovery
- * Functionality: VM bind event
- * Description:
- *	Attach the debugger to a process that performs bind, bind array, rebind,
- *	partial unbind, and unbind all operations before attaching. Ensure that
- *	we get a only a singe 'VM_BIND' event from the discovery worker.
  */
 static void test_basic_discovery(int fd, unsigned int flags, bool match_opposite)
 {
@@ -2661,12 +2591,6 @@ int igt_main()
 	igt_subtest("basic-vm-bind-vm-destroy-discovery")
 		test_basic_discovery(fd, VM_BIND_VM_DESTROY, false);
 
-	igt_subtest("basic-vm-bind-extended")
-		test_basic_sessions(fd, VM_BIND_EXTENDED, 1, true);
-
-	igt_subtest("basic-vm-bind-extended-discovery")
-		test_basic_discovery(fd, VM_BIND_EXTENDED, true);
-
 	igt_subtest("discovery-race")
 		test_race_discovery(fd, 0, 4);
 
-- 
2.43.0