Skip to contentSkip to conversation

eudebug: uapi changes on connect and metadata

PATCH In review Mika Kuoppala 2 participants 23 messages Jan 12 Library code

lore
Share & tools
lore
#0 lore raw

cover eudebug: uapi changes on connect and metadata

Hi,

Here are the patches that should bring the igt/eudebug in sync with https://gitlab.freedesktop.org/miku/kernel/-/tree/eudebug-v6

Majority of changes are due to connection opening changes and metadata rework.

-Mika

Christoph Manszewski (11):
tests/intel/xe_eudebug_sriov: Align expected return code tests/xe_eudebug: Adapt basic-read-event
lib/xe_eudebug: Adapt to vm_bind debug data tests/xe_eudebug: Adapt basic-vm-bind and remove
basic-vm-bind-extended
tests/xe_eudebug: Adapt some ufence reliant tests to new vm_bind event
interface
tests/xe_eudebug: Adapt vm-bind-clear* subtests to debug data lib/xe_eudebug: Remove unused xe_eudebug_client_vm_bind wrappers tests/xe_eudebug: Add vm-bind-debug-data-ufence subtest lib/intel_batchbuffer: Add dummy OP_DEBUG_DATA operation to

    __xe_alloc_bind_ops

tests/xe_eudebug_online: Adapt set-breakpoint test to work with new vm
bind event interface
tests/xe_eudebug_online: Adapt several subtests to work with new vm
bind event interface

Mika Kuoppala (10):
lib/xe/xe_eudebug: Dont compare if everything filtered lib/xe/xe_eudebug: Make sure debugger drains events lib/xe/xe_eudebug: Avoid matching if event is filtered
eudebug: Remove metadata tests
eudebug: Remove EVENT_OPEN and adjust tests tests/intel/xe_eudebug: Fix connect-user test tests/intel/xe_eudebug: Mold ufence reconnect test to disconnect lib/xe/xe_eudebug: Add callback for session work tests/intel/xe_eudebug: Add render node testing
eudebug: Update xe_drm_eudebug.h uapi

 .../drm-uapi-experimental/xe_drm_eudebug.h    |  266 ++--
 include/drm-uapi/xe_drm.h                     |   36 +
 lib/intel_batchbuffer.c                       |   82 +-
 lib/xe/xe_eudebug.c                           | 1038 +++++++-------
 lib/xe/xe_eudebug.h                           |   88 +-
 tests/intel/xe_eudebug.c                      | 1211 ++++++++---------
 tests/intel/xe_eudebug_online.c               |  304 ++---
 tests/intel/xe_eudebug_sriov.c                |    2 +-
 8 files changed, 1495 insertions(+), 1532 deletions(-)
Signature · 1 line
2.43.0
#1 lore raw

PATCH 1/21 lib/xe/xe_eudebug: Dont compare if everything filtered

If all events are filtered, we can omit comparing. Otherwise client might not have had any events and it will assert of not finding any.

Previously this worked as one event was guaranteed always which was client open. This event does not exists anymore.

---
 lib/xe/xe_eudebug.c | 5 +++++
 1 file changed, 5 insertions(+)
lib/xe/xe_eudebug.c +5 -0
index 2abee7ba25..0f09bc8a19 100644
@@ -1021,6 +1021,11 @@ void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *log1,
 	igt_assert(log1);
 	igt_assert(log2);
 
+	if (filter == XE_EUDEBUG_FILTER_ALL) {
+		igt_debug("info: filtering everything, skipping compare\n");
+		return;
+	}
+
 	xe_eudebug_for_each_event(ev1, log1) {
 		if (ev1->type == DRM_XE_EUDEBUG_EVENT_OPEN &&
 		    ev1->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
Signature · 1 line
2.43.0
#2 lore raw

PATCH 2/21 lib/xe/xe_eudebug: Make sure debugger drains events

In reply to Mika Kuoppala

Do not exit from debugger worker until poll timeouts as otherwise session can nuke the worker too early and some events might get dropped.

---
 lib/xe/xe_eudebug.c             | 66 ++++++++++++++++++++++++---------
 lib/xe/xe_eudebug.h             |  7 ++--
 tests/intel/xe_eudebug_online.c |  4 +-
 3 files changed, 54 insertions(+), 23 deletions(-)
lib/xe/xe_eudebug.c +48 -18
index 0f09bc8a19..7c2c9505d1 100644
@@ -1146,8 +1146,12 @@ static void *debugger_worker_loop(void *data)
 	sa.sa_flags |= SA_SIGINFO;
 	igt_assert_eq(sigaction(SIGTERM, &sa, NULL), 0);
 
+	WRITE_ONCE(d->worker_state, DEBUGGER_WORKER_RUNNING);
+
 	do {
 		p.fd = d->fd;
+		p.revents = 0;
+
 		ret = poll(&p, 1, timeout_ms);
 		if (d->received_sigint) {
 			d->handled_sigint = true;
@@ -1163,10 +1167,18 @@ static void *debugger_worker_loop(void *data)
 			}
 
 			igt_info("poll failed with errno %d\n", errno);
-			break;
+			goto out;
+		}
+
+		/* only exit after timeout to not miss events */
+		if (ret == 0 &&
+		    READ_ONCE(d->worker_state) != DEBUGGER_WORKER_RUNNING) {
+			igt_debug("debugger worker quitting with state %d\n",
+				  READ_ONCE(d->worker_state));
+			goto out;
 		}
 
-		if (ret == 1 && (p.revents & POLLIN)) {
+		if (ret == 1 && p.revents & POLLIN) {
 			int err = xe_eudebug_read_event(d->fd, e);
 
 			if (!err) {
@@ -1178,10 +1190,22 @@ static void *debugger_worker_loop(void *data)
 				igt_info("xe_eudebug_read_event returned %d\n", ret);
 			}
 		}
-	} while ((ret && READ_ONCE(d->worker_state) == DEBUGGER_WORKER_QUITTING) ||
-		 READ_ONCE(d->worker_state) == DEBUGGER_WORKER_ACTIVE);
 
-	d->worker_state = DEBUGGER_WORKER_INACTIVE;
+		if (ret == 1 && p.revents & POLLHUP) {
+			igt_info("debugger connection hangup\n");
+			goto out;
+		}
+
+		if (ret == 1 && p.revents & POLLNVAL) {
+			igt_info("debugger fd invalid\n");
+			goto out;
+		}
+	} while (1);
+
+out:
+	WRITE_ONCE(d->worker_state, DEBUGGER_WORKER_FINISHED);
+
+	igt_debug("debugger worker finished\n");
 
 	return NULL;
 }
@@ -1234,6 +1258,8 @@ xe_eudebug_debugger_create(int master_fd, uint64_t flags, void *data)
 	d->handled_sigint = false;
 	d->received_signal = false;
 
+	WRITE_ONCE(d->worker_state, DEBUGGER_WORKER_INIT);
+
 	return d;
 }
 
@@ -1254,7 +1280,7 @@ static void debugger_destroy_triggers(struct xe_eudebug_debugger *d)
  */
 void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d)
 {
-	if (d->worker_state != DEBUGGER_WORKER_INACTIVE)
+	if (READ_ONCE(d->worker_state) != DEBUGGER_WORKER_FINISHED)
 		xe_eudebug_debugger_stop_worker(d);
 
 	if (d->target_pid)
@@ -1380,10 +1406,12 @@ void xe_eudebug_debugger_start_worker(struct xe_eudebug_debugger *d)
 {
 	int ret;
 
-	d->worker_state = DEBUGGER_WORKER_ACTIVE;
 	ret = pthread_create(&d->worker_thread, NULL, &debugger_worker_loop, d);
 
 	igt_assert_f(ret == 0, "Debugger worker thread creation failed!");
+
+	while(READ_ONCE(d->worker_state) != DEBUGGER_WORKER_RUNNING)
+		;
 }
 
 /**
@@ -1396,23 +1424,23 @@ void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d)
 {
 	const int timeout_s = 3;
 	struct timespec t = {};
-	int ret;
-
-	igt_assert_neq(d->worker_state, DEBUGGER_WORKER_INACTIVE);
+	int ret = 0;
 
-	d->worker_state = DEBUGGER_WORKER_QUITTING; /* First time be polite. */
-	igt_assert_eq(clock_gettime(CLOCK_REALTIME, &t), 0);
-	t.tv_sec += timeout_s;
+	if (READ_ONCE(d->worker_state) == DEBUGGER_WORKER_RUNNING) {
+		/* First time be polite. */
+		WRITE_ONCE(d->worker_state, DEBUGGER_WORKER_SHOULD_QUIT);
+		igt_assert_eq(clock_gettime(CLOCK_REALTIME, &t), 0);
+		t.tv_sec += timeout_s;
 
-	ret = pthread_timedjoin_np(d->worker_thread, NULL, &t);
+		ret = pthread_timedjoin_np(d->worker_thread, NULL, &t);
+	}
 
 	if (ret == ETIMEDOUT) {
-		d->worker_state = DEBUGGER_WORKER_INACTIVE;
-		ret = pthread_join(d->worker_thread, NULL);
+		igt_info("DEBUGGER STATE %d FORCING\n", READ_ONCE(d->worker_state));
+		WRITE_ONCE(d->worker_state, DEBUGGER_WORKER_FINISHED);
 	}
 
-	igt_assert_f(ret == 0 || ret != ESRCH,
-		     "pthread join failed with error %d!\n", ret);
+	pthread_join(d->worker_thread, NULL);
 
 	event_log_sort(d->log);
 }
@@ -1720,6 +1748,8 @@ void xe_eudebug_session_run(struct xe_eudebug_session *s)
 
 	xe_eudebug_debugger_stop_worker(debugger);
 
+	xe_eudebug_client_stop(client);
+
 	xe_eudebug_event_log_print(debugger->log, true);
 	xe_eudebug_event_log_print(client->log, true);
 }
lib/xe/xe_eudebug.h +4 -3
index f1a2da4d84..ef9dacf0d2 100644
@@ -20,9 +20,10 @@ struct xe_eudebug_event_log {
 };
 
 enum xe_eudebug_debugger_worker_state {
-	DEBUGGER_WORKER_INACTIVE = 0,
-	DEBUGGER_WORKER_ACTIVE,
-	DEBUGGER_WORKER_QUITTING,
+	DEBUGGER_WORKER_INIT = 0,
+	DEBUGGER_WORKER_RUNNING,
+	DEBUGGER_WORKER_SHOULD_QUIT,
+	DEBUGGER_WORKER_FINISHED,
 };
 
 struct xe_eudebug_debugger {
tests/intel/xe_eudebug_online.c +2 -2
index ff6c5ff19b..e59b99ee99 100644
@@ -1690,8 +1690,8 @@ static void test_set_breakpoint_online_sigint_debugger(int fd,
 			usleep(1000);
 		close(s->debugger->fd);
 
-		igt_assert_eq(READ_ONCE(s->debugger->worker_state), DEBUGGER_WORKER_ACTIVE);
-		WRITE_ONCE(s->debugger->worker_state, DEBUGGER_WORKER_INACTIVE);
+		igt_assert_eq(READ_ONCE(s->debugger->worker_state), DEBUGGER_WORKER_RUNNING);
+		WRITE_ONCE(s->debugger->worker_state, DEBUGGER_WORKER_SHOULD_QUIT);
 
 		xe_eudebug_client_wait_done(s->client);
 
Signature · 1 line
2.43.0
#3 lore raw

PATCH 3/21 lib/xe/xe_eudebug: Avoid matching if event is filtered

In reply to Mika Kuoppala

Bail out early if event is filtered instead of hitting assert of not finding it.

---
 lib/xe/xe_eudebug.c | 8 ++++++++
 1 file changed, 8 insertions(+)
lib/xe/xe_eudebug.c +8 -0
index 7c2c9505d1..31e4f9c486 100644
@@ -1027,9 +1027,17 @@ void xe_eudebug_event_log_compare(struct xe_eudebug_event_log *log1,
 	}
 
 	xe_eudebug_for_each_event(ev1, log1) {
+		if (XE_EUDEBUG_EVENT_IS_FILTERED(ev1->type, filter))
+			continue;
+
 		if (ev1->type == DRM_XE_EUDEBUG_EVENT_OPEN &&
 		    ev1->flags & DRM_XE_EUDEBUG_EVENT_CREATE) {
 			ev2 = event_type_match(log2, ev1, ev2);
+			if (!ev2)
+				igt_debug("match failed to find type %d, seqno %llu\n",
+					  ev1->type, ev1->seqno);
+
+			igt_assert(ev2);
 
 			compare_client(log1, ev1, log2, ev2, filter);
 			compare_client(log2, ev2, log1, ev1, filter);
Signature · 1 line
2.43.0
#4 lore raw

PATCH 4/21 tests/intel/xe_eudebug_sriov: Align expected return code

In reply to Mika Kuoppala

From: Christoph Manszewski <[email protected]>

Align with kernel commit 387aba39b7be (drm/xe/pf: Allow to lockdown the PF using custom guard).

---
 tests/intel/xe_eudebug_sriov.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tests/intel/xe_eudebug_sriov.c +1 -1
index 1f150d0efe..8b318d48b0 100644
@@ -71,7 +71,7 @@ static void test_deny_eudebug(int fd)
 
 	sysfs = igt_sysfs_open(fd);
 	igt_assert_fd(sysfs);
-	igt_assert_eq(igt_sysfs_printf(sysfs, "device/enable_eudebug", "1"), -EPERM);
+	igt_assert_eq(igt_sysfs_printf(sysfs, "device/enable_eudebug", "1"), -EBUSY);
 	close(sysfs);
 }
 
Signature · 1 line
2.43.0
Reviewed-by on v1 4/21
#5 lore raw

RE: [PATCH i-g-t 04/21] tests/intel/xe_eudebug_sriov: Align expected return code

Quoted 40 lines

-----Original Message-----
From: Mika Kuoppala <[email protected]>
Sent: Monday, January 12, 2026 2:00 PM
To: [email protected]
Cc: Manszewski, Christoph <[email protected]>; Piatkowski, Dominik Karol <[email protected]>; Patelczyk, Maciej <[email protected]>; Maslak, Jan <[email protected]>; Kempczynski, Zbigniew <[email protected]>; Mika Kuoppala <[email protected]>
Subject: [PATCH i-g-t 04/21] tests/intel/xe_eudebug_sriov: Align expected return code

From: Christoph Manszewski <[email protected]>

Align with kernel commit 387aba39b7be (drm/xe/pf: Allow to lockdown the PF using custom guard).

---
 tests/intel/xe_eudebug_sriov.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
tests/intel/xe_eudebug_sriov.c +1 -1
index 1f150d0efe..8b318d48b0 100644
@@ -71,7 +71,7 @@ static void test_deny_eudebug(int fd)
 
 	sysfs = igt_sysfs_open(fd);
 	igt_assert_fd(sysfs);
-	igt_assert_eq(igt_sysfs_printf(sysfs, "device/enable_eudebug", "1"), -
 EPERM);
+	igt_assert_eq(igt_sysfs_printf(sysfs, "device/enable_eudebug", "1"), -
 EBUSY);
 	close(sysfs);

}

--
2.43.0

#6 lore raw

PATCH 5/21 eudebug: Remove metadata tests

In reply to Mika Kuoppala

Metadata will be reworked. Remove.

---
 .../drm-uapi-experimental/xe_drm_eudebug.h    |  98 --------
 lib/xe/xe_eudebug.c                           | 184 +--------------
 lib/xe/xe_eudebug.h                           |  10 -
 tests/intel/xe_eudebug.c                      | 209 +-----------------
 tests/intel/xe_eudebug_online.c               |  87 --------
 5 files changed, 9 insertions(+), 579 deletions(-)
include/drm-uapi-experimental/xe_drm_eudebug.h +0 -98
index 5aeb6a7352..73e4f418f5 100644
@@ -31,29 +31,6 @@ extern "C" {
 
 /* ... */
 
-struct drm_xe_vm_bind_op_ext_attach_debug {
-	/** @base: base user extension */
-	struct drm_xe_user_extension base;
-
-	/** @id: Debug object id from create metadata */
-	__u64 metadata_id;
-
-	/** @flags: Flags */
-	__u64 flags;
-
-	/** @cookie: Cookie */
-	__u64 cookie;
-
-	/** @reserved: Reserved */
-	__u64 reserved;
-};
-
-/* ... */
-
-#define XE_VM_BIND_OP_EXTENSIONS_ATTACH_DEBUG 0
-
-/* ... */
-
 #define   DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG		3
 #define     DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE		(1 << 0)
 
@@ -76,54 +53,6 @@ struct drm_xe_eudebug_connect {
 	__u32 version; /* output: current ABI (ioctl / events) version */
 };
 
-/*
- * struct drm_xe_debug_metadata_create - Create debug metadata
- *
- * Add a region of user memory to be marked as debug metadata.
- * When the debugger attaches, the metadata regions will be delivered
- * for debugger. Debugger can then map these regions to help decode
- * the program state.
- *
- * Returns handle to created metadata entry.
- */
-struct drm_xe_debug_metadata_create {
-	/** @extensions: Pointer to the first extension struct, if any */
-	__u64 extensions;
-
-#define DRM_XE_DEBUG_METADATA_ELF_BINARY     0
-#define DRM_XE_DEBUG_METADATA_PROGRAM_MODULE 1
-#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_MODULE_AREA 2
-#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SBA_AREA 3
-#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA 4
-#define WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_NUM (1 + \
-	  WORK_IN_PROGRESS_DRM_XE_DEBUG_METADATA_SIP_AREA)
-
-	/** @type: Type of metadata */
-	__u64 type;
-
-	/** @user_addr: pointer to start of the metadata */
-	__u64 user_addr;
-
-	/** @len: length, in bytes of the medata */
-	__u64 len;
-
-	/** @metadata_id: created metadata handle (out) */
-	__u32 metadata_id;
-};
-
-/**
- * struct drm_xe_debug_metadata_destroy - Destroy debug metadata
- *
- * Destroy debug metadata.
- */
-struct drm_xe_debug_metadata_destroy {
-	/** @extensions: Pointer to the first extension struct, if any */
-	__u64 extensions;
-
-	/** @metadata_id: metadata handle to destroy */
-	__u32 metadata_id;
-};
-
 /* XXX: END section moved from xe_drm.h as temporary solution */
 
 /**
@@ -309,33 +238,6 @@ struct drm_xe_eudebug_vm_open {
 	__u64 timeout_ns;
 };
 
-struct drm_xe_eudebug_read_metadata {
-	__u64 client_handle;
-	__u64 metadata_handle;
-	__u32 flags;
-	__u32 reserved;
-	__u64 ptr;
-	__u64 size;
-};
-
-struct drm_xe_eudebug_event_metadata {
-	struct drm_xe_eudebug_event base;
-
-	__u64 client_handle;
-	__u64 metadata_handle;
-	/* XXX: Refer to xe_drm.h for fields */
-	__u64 type;
-	__u64 len;
-};
-
-struct drm_xe_eudebug_event_vm_bind_op_metadata {
-	struct drm_xe_eudebug_event base;
-	__u64 vm_bind_op_ref_seqno; /* *_event_vm_bind_op.base.seqno */
-
-	__u64 metadata_handle;
-	__u64 metadata_cookie;
-};
-
 struct drm_xe_eudebug_event_pagefault {
 	struct drm_xe_eudebug_event base;
 
lib/xe/xe_eudebug.c +4 -180

274 lines not on this page · raw message

lib/xe/xe_eudebug.h +0 -10
index ef9dacf0d2..0706023121 100644
@@ -170,8 +170,6 @@ next_event(struct drm_xe_eudebug_event *e, struct xe_eudebug_event_log *l)
 #define XE_EUDEBUG_FILTER_EVENT_VM_BIND			BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND)
 #define XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP		BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP)
 #define XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE		BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)
-#define XE_EUDEBUG_FILTER_EVENT_METADATA		BIT(DRM_XE_EUDEBUG_EVENT_METADATA)
-#define XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP_METADATA	BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA)
 #define XE_EUDEBUG_FILTER_EVENT_PAGEFAULT		BIT(DRM_XE_EUDEBUG_EVENT_PAGEFAULT)
 #define XE_EUDEBUG_FILTER_ALL				GENMASK(DRM_XE_EUDEBUG_EVENT_PAGEFAULT, 0)
 #define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f)		((1UL << (_e)) & (_f))
@@ -237,9 +235,6 @@ void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t ev
 					uint64_t ref_seqno, uint64_t *op_ref_seqno,
 					uint64_t addr, uint64_t range,
 					uint64_t num_extensions);
-void xe_eudebug_client_vm_bind_op_metadata_event(struct xe_eudebug_client *c,
-						 uint32_t event_flags, uint64_t op_ref_seqno,
-						 uint64_t metadata_handle, uint64_t metadata_cookie);
 void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client *c, uint32_t event_flags,
 					    uint64_t ref_seqno);
 void xe_eudebug_ack_ufence(int debugfd,
@@ -260,11 +255,6 @@ void xe_eudebug_client_vm_unbind_flags(struct xe_eudebug_client *c, int fd,
 void xe_eudebug_client_vm_unbind(struct xe_eudebug_client *c, int fd, uint32_t vm,
 				 uint64_t offset, uint64_t addr, uint64_t size);
 
-uint32_t xe_eudebug_client_metadata_create(struct xe_eudebug_client *c, int fd,
-					   int type, size_t len, void *data);
-void xe_eudebug_client_metadata_destroy(struct xe_eudebug_client *c, int fd,
-					uint32_t id, int type, size_t len);
-
 struct xe_eudebug_session *xe_eudebug_session_create(int fd,
 						     xe_eudebug_client_work_fn work,
 						     unsigned int flags,
tests/intel/xe_eudebug.c +5 -204

267 lines not on this page · raw message

tests/intel/xe_eudebug_online.c +0 -87

170 lines not on this page · raw message

Signature · 1 line
2.43.0
#7 lore raw

PATCH 6/21 eudebug: Remove EVENT_OPEN and adjust tests

In reply to Mika Kuoppala

eudebug connections are against drm client filedescriptor instead of the whole process (pid). This simplifies access control as in order to gain access to the drm clients file descriptor, the debugger either has delivered fd through pipe or gone through proc/<pid>/fs to find it.

Start with removing client_handles from all events. Put client->fd into the xe_eudebug_client structure as it is singleton and immutable through client lifetime now.

The discovery tests have strong assumption how connection works, disable them now until lib/xe_eudebug.c can accommodate.

With this in place basic-connect/basic-close/basic-client works.

v2: __xe_eudebug_connect helper (Christoph)

---
 .../drm-uapi-experimental/xe_drm_eudebug.h    |  46 +-
 lib/xe/xe_eudebug.c                           | 462 ++++++++++--------
 lib/xe/xe_eudebug.h                           |  26 +-
 tests/intel/xe_eudebug.c                      | 390 +++++++--------
 tests/intel/xe_eudebug_online.c               | 151 ++----
 5 files changed, 496 insertions(+), 579 deletions(-)
include/drm-uapi-experimental/xe_drm_eudebug.h +12 -34
index 73e4f418f5..a9aa87f564 100644
@@ -19,19 +19,13 @@ extern "C" {
  */
 
 /* XXX: BEGIN section moved from xe_drm.h as temporary solution */
-#define DRM_XE_EUDEBUG_CONNECT		0x0e
-#define DRM_XE_DEBUG_METADATA_CREATE	0x0f
-#define DRM_XE_DEBUG_METADATA_DESTROY	0x10
-
-/* ... */
 
+#define DRM_XE_EUDEBUG_CONNECT		0x0f
 #define DRM_IOCTL_XE_EUDEBUG_CONNECT		DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_EUDEBUG_CONNECT, struct drm_xe_eudebug_connect)
-#define DRM_IOCTL_XE_DEBUG_METADATA_CREATE	 DRM_IOWR(DRM_COMMAND_BASE + DRM_XE_DEBUG_METADATA_CREATE, struct drm_xe_debug_metadata_create)
-#define DRM_IOCTL_XE_DEBUG_METADATA_DESTROY	 DRM_IOW(DRM_COMMAND_BASE + DRM_XE_DEBUG_METADATA_DESTROY, struct drm_xe_debug_metadata_destroy)
 
 /* ... */
 
-#define   DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG		3
+#define   DRM_XE_EXEC_QUEUE_SET_PROPERTY_EUDEBUG		6
 #define     DRM_XE_EXEC_QUEUE_EUDEBUG_FLAG_ENABLE		(1 << 0)
 
 /* ... */
@@ -47,7 +41,7 @@ struct drm_xe_eudebug_connect {
 	/** @extensions: Pointer to the first extension struct, if any */
 	__u64 extensions;
 
-	__u64 pid; /* input: Target process ID */
+	__u64 fd; /* Target drm client fd */
 	__u32 flags; /* MBZ */
 
 	__u32 version; /* output: current ABI (ioctl / events) version */
@@ -73,16 +67,15 @@ struct drm_xe_eudebug_event {
 	__u16 type;
 #define DRM_XE_EUDEBUG_EVENT_NONE		0
 #define DRM_XE_EUDEBUG_EVENT_READ		1
-#define DRM_XE_EUDEBUG_EVENT_OPEN		2
-#define DRM_XE_EUDEBUG_EVENT_VM			3
-#define DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE		4
-#define DRM_XE_EUDEBUG_EVENT_EU_ATTENTION	5
-#define DRM_XE_EUDEBUG_EVENT_VM_BIND		6
-#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP		7
-#define DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE	8
-#define DRM_XE_EUDEBUG_EVENT_METADATA		9
-#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA 10
-#define DRM_XE_EUDEBUG_EVENT_PAGEFAULT		11
+#define DRM_XE_EUDEBUG_EVENT_VM			2
+#define DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE		3
+#define DRM_XE_EUDEBUG_EVENT_EU_ATTENTION	4
+#define DRM_XE_EUDEBUG_EVENT_VM_BIND		5
+#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP		6
+#define DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE	7
+#define DRM_XE_EUDEBUG_EVENT_METADATA		8
+#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA 9
+#define DRM_XE_EUDEBUG_EVENT_PAGEFAULT		10
 
 	__u16 flags;
 #define DRM_XE_EUDEBUG_EVENT_CREATE		(1 << 0)
@@ -94,23 +87,15 @@ struct drm_xe_eudebug_event {
 	__u64 reserved;
 };
 
-struct drm_xe_eudebug_event_client {
-	struct drm_xe_eudebug_event base;
-
-	__u64 client_handle; /* This is unique per debug connection */
-};
-
 struct drm_xe_eudebug_event_vm {
 	struct drm_xe_eudebug_event base;
 
-	__u64 client_handle;
 	__u64 vm_handle;
 };
 
 struct drm_xe_eudebug_event_exec_queue {
 	struct drm_xe_eudebug_event base;
 
-	__u64 client_handle;
 	__u64 vm_handle;
 	__u64 exec_queue_handle;
 	__u32 engine_class;
@@ -121,7 +106,6 @@ struct drm_xe_eudebug_event_exec_queue {
 struct drm_xe_eudebug_event_eu_attention {
 	struct drm_xe_eudebug_event base;
 
-	__u64 client_handle;
 	__u64 exec_queue_handle;
 	__u64 lrc_handle;
 	__u32 flags;
@@ -130,7 +114,6 @@ struct drm_xe_eudebug_event_eu_attention {
 };
 
 struct drm_xe_eudebug_eu_control {
-	__u64 client_handle;
 
 #define DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL	0
 #define DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED		1
@@ -191,7 +174,6 @@ struct drm_xe_eudebug_eu_control {
 struct drm_xe_eudebug_event_vm_bind {
 	struct drm_xe_eudebug_event base;
 
-	__u64 client_handle;
 	__u64 vm_handle;
 
 	__u32 flags;
@@ -224,9 +206,6 @@ struct drm_xe_eudebug_vm_open {
 	/** @extensions: Pointer to the first extension struct, if any */
 	__u64 extensions;
 
-	/** @client_handle: id of client */
-	__u64 client_handle;
-
 	/** @vm_handle: id of vm */
 	__u64 vm_handle;
 
@@ -241,7 +220,6 @@ struct drm_xe_eudebug_vm_open {
 struct drm_xe_eudebug_event_pagefault {
 	struct drm_xe_eudebug_event base;
 
-	__u64 client_handle;
 	__u64 exec_queue_handle;
 	__u64 lrc_handle;
 	__u32 flags;
lib/xe/xe_eudebug.c +247 -215

924 lines not on this page · raw message

lib/xe/xe_eudebug.h +13 -13
index 0706023121..ea7b320a27 100644
@@ -38,6 +38,7 @@ struct xe_eudebug_debugger {
 	uint64_t event_count;
 
 	uint64_t target_pid;
+	int target_fd;
 
 	struct igt_list_head triggers;
 
@@ -54,6 +55,7 @@ struct xe_eudebug_debugger {
 };
 
 struct xe_eudebug_client {
+	int fd;
 	int pid;
 	uint64_t seqno;
 	uint64_t flags;
@@ -162,7 +164,6 @@ next_event(struct drm_xe_eudebug_event *e, struct xe_eudebug_event_log *l)
 
 #define XE_EUDEBUG_FILTER_EVENT_NONE			BIT(DRM_XE_EUDEBUG_EVENT_NONE)
 #define XE_EUDEBUG_FILTER_EVENT_READ			BIT(DRM_XE_EUDEBUG_EVENT_READ)
-#define XE_EUDEBUG_FILTER_EVENT_OPEN			BIT(DRM_XE_EUDEBUG_EVENT_OPEN)
 #define XE_EUDEBUG_FILTER_EVENT_VM			BIT(DRM_XE_EUDEBUG_EVENT_VM)
 #define XE_EUDEBUG_FILTER_EVENT_EXEC_QUEUE		BIT(DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE)
 #define XE_EUDEBUG_FILTER_EVENT_EXEC_QUEUE_PLACEMENTS	BIT(DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS)
@@ -174,7 +175,7 @@ next_event(struct drm_xe_eudebug_event *e, struct xe_eudebug_event_log *l)
 #define XE_EUDEBUG_FILTER_ALL				GENMASK(DRM_XE_EUDEBUG_EVENT_PAGEFAULT, 0)
 #define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f)		((1UL << (_e)) & (_f))
 
-int xe_eudebug_connect(int fd, pid_t pid, uint32_t flags);
+int xe_eudebug_fd_for_pid(pid_t pid);
 const char *xe_eudebug_event_to_str(struct drm_xe_eudebug_event *e, char *buf, size_t len);
 struct drm_xe_eudebug_event *
 xe_eudebug_event_log_find_seqno(struct xe_eudebug_event_log *l, uint64_t seqno);
@@ -191,6 +192,7 @@ bool xe_eudebug_debugger_available(int fd);
 struct xe_eudebug_debugger *
 xe_eudebug_debugger_create(int xe, uint64_t flags, void *data);
 void xe_eudebug_debugger_destroy(struct xe_eudebug_debugger *d);
+int __xe_eudebug_connect(int master_fd, int target_fd, pid_t target_pid, int flags);
 int xe_eudebug_debugger_attach(struct xe_eudebug_debugger *d, struct xe_eudebug_client *c);
 void xe_eudebug_debugger_start_worker(struct xe_eudebug_debugger *d);
 void xe_eudebug_debugger_stop_worker(struct xe_eudebug_debugger *d);
@@ -219,16 +221,14 @@ void xe_eudebug_client_set_data(struct xe_eudebug_client *c, void *ptr);
 int __xe_eudebug_enable_getset(int fd, bool *old, bool *new);
 bool xe_eudebug_enable(int fd, bool enable);
 
-int xe_eudebug_client_open_driver(struct xe_eudebug_client *c);
-void xe_eudebug_client_close_driver(struct xe_eudebug_client *c, int fd);
-uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c, int fd,
+uint32_t xe_eudebug_client_vm_create(struct xe_eudebug_client *c,
 				     uint32_t flags, uint64_t ext);
-void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, int fd, uint32_t vm);
-uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c, int fd,
+void xe_eudebug_client_vm_destroy(struct xe_eudebug_client *c, uint32_t vm);
+uint32_t xe_eudebug_client_exec_queue_create(struct xe_eudebug_client *c,
 					     struct drm_xe_exec_queue_create *create);
-void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c, int fd,
+void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c,
 					  struct drm_xe_exec_queue_create *create);
-void xe_eudebug_client_vm_bind_event(struct xe_eudebug_client *c, uint32_t event_flags, int fd,
+void xe_eudebug_client_vm_bind_event(struct xe_eudebug_client *c, uint32_t event_flags,
 				     uint32_t vm, uint32_t bind_flags,
 				     uint32_t num_ops, uint64_t *ref_seqno);
 void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t event_flags,
@@ -240,19 +240,19 @@ void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client *c, uint32_
 void xe_eudebug_ack_ufence(int debugfd,
 			   const struct drm_xe_eudebug_event_vm_bind_ufence *f);
 
-void xe_eudebug_client_vm_bind_flags(struct xe_eudebug_client *c, int fd, uint32_t vm,
+void xe_eudebug_client_vm_bind_flags(struct xe_eudebug_client *c, uint32_t vm,
 				     uint32_t bo, uint64_t offset,
 				     uint64_t addr, uint64_t size, uint32_t flags,
 				     struct drm_xe_sync *sync, uint32_t num_syncs,
 				     uint64_t op_ext);
-void xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, int fd, uint32_t vm,
+void xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, uint32_t vm,
 			       uint32_t bo, uint64_t offset,
 			       uint64_t addr, uint64_t size);
-void xe_eudebug_client_vm_unbind_flags(struct xe_eudebug_client *c, int fd,
+void xe_eudebug_client_vm_unbind_flags(struct xe_eudebug_client *c,
 				       uint32_t vm, uint64_t offset,
 				       uint64_t addr, uint64_t size, uint32_t flags,
 				       struct drm_xe_sync *sync, uint32_t num_syncs);
-void xe_eudebug_client_vm_unbind(struct xe_eudebug_client *c, int fd, uint32_t vm,
+void xe_eudebug_client_vm_unbind(struct xe_eudebug_client *c, uint32_t vm,
 				 uint64_t offset, uint64_t addr, uint64_t size);
 
 struct xe_eudebug_session *xe_eudebug_session_create(int fd,
tests/intel/xe_eudebug.c +172 -218

928 lines not on this page · raw message

tests/intel/xe_eudebug_online.c +52 -99

450 lines not on this page · raw message

Signature · 1 line
2.43.0
#8 lore raw

PATCH 7/21 tests/xe_eudebug: Adapt basic-read-event

In reply to Mika Kuoppala

From: Christoph Manszewski <[email protected]>

Adapt basic-read-event test to rely on vm create/destroy events for positive test path since client create/destroy events are no longer present.

Also update the assert for blocking event_read ioctl with no events to expect -ETIMEDOUT

---
 tests/intel/xe_eudebug.c | 34 +++++++++++++++++++++-------------
 1 file changed, 21 insertions(+), 13 deletions(-)
tests/intel/xe_eudebug.c +21 -13
index 8d673b68bb..3c7a13f6fe 100644
@@ -55,15 +55,16 @@ static void test_sysfs_toggle(int fd)
 #define STAGE_PRE_DEBUG_RESOURCES_DONE	1
 #define STAGE_DISCOVERY_DONE		2
 
-#define CREATE_VMS			(1 << 0)
-#define CREATE_EXEC_QUEUES		(1 << 1)
-#define VM_BIND				(1 << 2)
-#define VM_BIND_VM_DESTROY		(1 << 3)
-#define VM_BIND_EXTENDED		(1 << 4)
-#define VM_BIND_OP_MAP_USERPTR		(1 << 5)
-#define VM_BIND_DELAY_UFENCE_ACK	(1 << 6)
-#define VM_BIND_UFENCE_RECONNECT	(1 << 7)
-#define VM_BIND_UFENCE_SIGINT_CLIENT	(1 << 8)
+#define CREATE_VM			(1 << 0)
+#define CREATE_VMS			(1 << 1)
+#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_RECONNECT	(1 << 8)
+#define VM_BIND_UFENCE_SIGINT_CLIENT	(1 << 9)
 #define TEST_FAULTABLE			(1 << 30)
 #define TEST_DISCOVERY			(1 << 31)
 
@@ -379,6 +380,11 @@ static void run_basic_client(struct xe_eudebug_client *c)
 {
 	int i;
 
+	if (c->flags & CREATE_VM) {
+		int vm = xe_eudebug_client_vm_create(c, DRM_XE_VM_CREATE_FLAG_LR_MODE, 0);
+		xe_eudebug_client_vm_destroy(c, vm);
+	}
+
 	if (c->flags & CREATE_VMS) {
 		const uint32_t flags[] = {
 			DRM_XE_VM_CREATE_FLAG_SCRATCH_PAGE | DRM_XE_VM_CREATE_FLAG_LR_MODE,
@@ -775,7 +781,7 @@ static void test_read_event(int fd)
 	event = calloc(1, MAX_EVENT_SIZE);
 	igt_assert(event);
 
-	c = xe_eudebug_client_create(fd, run_basic_client, 0, NULL);
+	c = xe_eudebug_client_create(fd, run_basic_client, CREATE_VM, NULL);
 	d = xe_eudebug_debugger_create(fd, 0, NULL);
 
 	igt_assert_eq(xe_eudebug_debugger_attach(d, c), 0);
@@ -784,14 +790,15 @@ static void test_read_event(int fd)
 	/* Negative read event - no events to read */
 	event->len = MAX_EVENT_SIZE;
 	event->type = DRM_XE_EUDEBUG_EVENT_READ;
-	igt_assert_eq(read_event(d->fd, event), -ENOENT);
+	igt_assert_eq(read_event(d->fd, event), -ETIMEDOUT);
 
 	xe_eudebug_client_start(c);
 
-	/* Positive read event - client create */
+	/* Positive read event - vm create */
 	igt_assert_eq(poll_event(d->fd, 500), 1);
 	event->type = DRM_XE_EUDEBUG_EVENT_READ;
 	igt_assert_eq(read_event(d->fd, event), 0);
+	igt_assert_eq(event->type, DRM_XE_EUDEBUG_EVENT_VM);
 	igt_assert_eq(event->flags, DRM_XE_EUDEBUG_EVENT_CREATE);
 
 	igt_assert_eq(poll_event(d->fd, 500), 1);
@@ -826,8 +833,9 @@ static void test_read_event(int fd)
 	/* event->len should now contain exact len */
 	igt_assert_lt(sizeof(*event), event->len);
 
-	/* Positive read event - client destroy */
+	/* Positive read event - vm destroy */
 	igt_assert_eq(read_event(d->fd, event), 0);
+	igt_assert_eq(event->type, DRM_XE_EUDEBUG_EVENT_VM);
 	igt_assert_eq(event->flags, DRM_XE_EUDEBUG_EVENT_DESTROY);
 
 	fcntl(d->fd, F_SETFL, fcntl(d->fd, F_GETFL) | O_NONBLOCK);
Signature · 1 line
2.43.0
#9 lore raw

PATCH 8/21 tests/intel/xe_eudebug: Fix connect-user test

In reply to Mika Kuoppala

We changed from connecting to pid into connecting into a filedescriptor of a drm client. As the access checks are now in a filedescriptor level we get EBADFD instead of EACCESS. Adjust to new error returns.

---
 tests/intel/xe_eudebug.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
tests/intel/xe_eudebug.c +2 -2
index 3c7a13f6fe..1bb30a1cad 100644
@@ -637,7 +637,7 @@ static void test_connect_user(int fd)
 	test[0].skip = !pwd;
 	test[0].u[P_GDB] = u1;
 	test[0].g[P_GDB] = g1;
-	test[0].ret = -EACCES;
+	test[0].ret = -EBADFD;
 	test[0].desc = "User GDB to Root App";
 
 	test[1].skip = !pwd;
@@ -659,7 +659,7 @@ static void test_connect_user(int fd)
 	test[3].g[P_APP] = g1;
 	test[3].u[P_GDB] = u2;
 	test[3].g[P_GDB] = g2;
-	test[3].ret = -EACCES;
+	test[3].ret = -EBADFD;
 	test[3].desc = "User GDB to Other User App";
 
 	if (!pwd2)
Signature · 1 line
2.43.0
#10 lore raw

PATCH 9/21 tests/intel/xe_eudebug: Mold ufence reconnect test to disconnect

In reply to Mika Kuoppala

If debugger disconnects, the driver will automatically ack all ufences as we have 1:1 mapping between debuggers and drm clients.

In old way of connecting, reconnecting test made sense but it does not anymore.

Convert the test to just disconnect the debugger.

---
 tests/intel/xe_eudebug.c | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)
tests/intel/xe_eudebug.c +7 -9
index 1bb30a1cad..353828f673 100644
@@ -63,7 +63,7 @@ static void test_sysfs_toggle(int fd)
 #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_RECONNECT	(1 << 8)
+#define VM_BIND_UFENCE_DISCONNECT	(1 << 8)
 #define VM_BIND_UFENCE_SIGINT_CLIENT	(1 << 9)
 #define TEST_FAULTABLE			(1 << 30)
 #define TEST_DISCOVERY			(1 << 31)
@@ -1920,7 +1920,7 @@ static int wait_for_ufence_events(struct ufence_priv *priv, int timeout_ms)
  * Description:
  *	Give user fence in application and check if delayed ufence ack works
  *
- * SUBTEST: basic-vm-bind-ufence-reconnect
+ * SUBTEST: basic-vm-bind-ufence-disconnect
  * Functionality: VM bind event
  * Description:
  *	Give user fence in application, hold it, drop the debugger connection and check if anything
@@ -1964,11 +1964,9 @@ static void test_basic_ufence(int fd, unsigned int flags)
 		kill(c->pid, SIGINT);
 		c->pid = 0;
 		c->done = 1;
-	} else if (flags & VM_BIND_UFENCE_RECONNECT) {
-		filter = XE_EUDEBUG_FILTER_EVENT_VM_BIND | XE_EUDEBUG_FILTER_EVENT_VM;
-		xe_eudebug_debugger_detach(d);
-		xe_eudebug_client_wait_done(c);
-		igt_assert_eq(xe_eudebug_debugger_attach(d, c), 0);
+	} else if (flags & VM_BIND_UFENCE_DISCONNECT) {
+		filter = XE_EUDEBUG_FILTER_ALL;
+		close(s->debugger->fd);
 	} else {
 		ack_fences(d);
 	}
@@ -2648,8 +2646,8 @@ int igt_main()
 	igt_subtest("basic-vm-bind-ufence-delay-ack")
 		test_basic_ufence(fd, VM_BIND_DELAY_UFENCE_ACK);
 
-	igt_subtest("basic-vm-bind-ufence-reconnect")
-		test_basic_ufence(fd, VM_BIND_UFENCE_RECONNECT);
+	igt_subtest("basic-vm-bind-ufence-disconnect")
+		test_basic_ufence(fd, VM_BIND_UFENCE_DISCONNECT);
 
 	igt_subtest("basic-vm-bind-ufence-sigint-client")
 		test_basic_ufence(fd, VM_BIND_UFENCE_SIGINT_CLIENT);
Signature · 1 line
2.43.0
#11 lore raw

PATCH 10/21 lib/xe_eudebug: Adapt to vm_bind debug data

In reply to Mika Kuoppala

From: Christoph Manszewski <[email protected]>

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. Add a wrapper for the newly added vm bind operations and don't store OP_[MAP|UNMAP] events in the client log.

---
 include/drm-uapi/xe_drm.h |  36 +++++
 lib/xe/xe_eudebug.c       | 287 ++++++++++++++++++++++++++++++++++++--
 lib/xe/xe_eudebug.h       |  20 +++
 3 files changed, 335 insertions(+), 8 deletions(-)
include/drm-uapi/xe_drm.h +36 -0
index 077e66a682..13add4fb8d 100644
@@ -6,6 +6,8 @@
 #ifndef _UAPI_XE_DRM_H_
 #define _UAPI_XE_DRM_H_
 
+#include <linux/limits.h>
+
 #include "drm.h"
 
 #if defined(__cplusplus)
@@ -1007,6 +1009,35 @@ struct drm_xe_vm_destroy {
 	__u64 reserved[2];
 };
 
+struct drm_xe_vm_bind_op_ext_debug_data {
+	/** @base: base user extension */
+	struct drm_xe_user_extension base;
+
+	/** @addr: Address of the metadata mapping */
+	__u64 addr;
+
+	/** @range: Range of the metadata mapping */
+	__u64 range;
+
+#define DRM_XE_VM_BIND_DEBUG_DATA_FLAG_PSEUDO (1 << 0)
+	/** @flags: Debug metadata flags */
+	__u64 flags;
+
+	/** @offset: Offset into the debug data file, MBZ for DEBUG_PSEUDO */
+	__u32 offset;
+
+	/** @reserved: Reserved */
+	__u32 reserved;
+
+	union {
+#define DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_MODULE_AREA	0x1
+#define DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_SBA_AREA	0x2
+#define DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_SIP_AREA	0x3
+		__u64 pseudopath;
+		char pathname[PATH_MAX];
+	};
+};
+
 /**
  * struct drm_xe_vm_bind_op - run bind operations
  *
@@ -1016,6 +1047,8 @@ struct drm_xe_vm_destroy {
  *  - %DRM_XE_VM_BIND_OP_MAP_USERPTR
  *  - %DRM_XE_VM_BIND_OP_UNMAP_ALL
  *  - %DRM_XE_VM_BIND_OP_PREFETCH
+ *  - %DRM_XE_VM_BIND_OP_ADD_DEBUG_DATA
+ *  - %DRM_XE_VM_BIND_OP_REMOVE_DEBUG_DATA
  *
  * and the @flags can be:
  *  - %DRM_XE_VM_BIND_FLAG_READONLY - Setup the page tables as read-only
@@ -1059,6 +1092,7 @@ struct drm_xe_vm_destroy {
  *    the memory region advised by madvise.
  */
 struct drm_xe_vm_bind_op {
+#define	XE_VM_BIND_OP_EXTENSIONS_DEBUG_DATA 0
 	/** @extensions: Pointer to the first extension struct, if any */
 	__u64 extensions;
 
@@ -1150,6 +1184,8 @@ struct drm_xe_vm_bind_op {
 #define DRM_XE_VM_BIND_OP_MAP_USERPTR	0x2
 #define DRM_XE_VM_BIND_OP_UNMAP_ALL	0x3
 #define DRM_XE_VM_BIND_OP_PREFETCH	0x4
+#define DRM_XE_VM_BIND_OP_ADD_DEBUG_DATA	0x5
+#define DRM_XE_VM_BIND_OP_REMOVE_DEBUG_DATA	0x6
 	/** @op: Bind operation to perform */
 	__u32 op;
 
lib/xe/xe_eudebug.c +279 -8

320 lines not on this page · raw message

lib/xe/xe_eudebug.h +20 -0
index ea7b320a27..a53bd99dc0 100644
@@ -255,6 +255,26 @@ void xe_eudebug_client_vm_unbind_flags(struct xe_eudebug_client *c,
 void xe_eudebug_client_vm_unbind(struct xe_eudebug_client *c, uint32_t vm,
 				 uint64_t offset, uint64_t addr, uint64_t size);
 
+void xe_eudebug_client_vm_bind_debug_data_add(struct xe_eudebug_client *c, uint32_t vm,
+					      uint32_t offset, uint64_t addr, uint64_t range,
+					      uint64_t pseudopath, char *path,
+					      struct drm_xe_sync *sync, uint32_t num_syncs);
+void xe_eudebug_client_vm_bind_debug_data_remove(struct xe_eudebug_client *c, uint32_t vm,
+						 uint64_t addr, uint64_t range);
+
+void xe_eudebug_client_vm_bind_array(struct xe_eudebug_client *c,
+				     uint32_t vm, uint32_t exec_queue,
+				     struct drm_xe_vm_bind_op *bind_ops,
+				     uint32_t num_binds, struct drm_xe_sync *sync,
+				     uint32_t num_syncs);
+void xe_eudebug_client_vm_bind_map_with_debug_data(struct xe_eudebug_client *c, uint32_t vm,
+						   uint64_t addr, uint64_t range,
+						   uint32_t bo, uint64_t bo_offset,
+						   char *path, uint64_t pseudopath, uint32_t offset,
+						   struct drm_xe_sync *sync, uint32_t num_syncs);
+void xe_eudebug_client_vm_bind_unmap_with_debug_data(struct xe_eudebug_client *c, uint32_t vm,
+						     uint64_t addr, uint64_t range);
+
 struct xe_eudebug_session *xe_eudebug_session_create(int fd,
 						     xe_eudebug_client_work_fn work,
 						     unsigned int flags,
Signature · 1 line
2.43.0
#12 lore raw

PATCH 11/21 tests/xe_eudebug: Adapt basic-vm-bind and remove basic-vm-bind-extended

In reply to Mika Kuoppala

From: Christoph Manszewski <[email protected]>

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.

---
 tests/intel/xe_eudebug.c | 154 ++++++++++-----------------------------
 1 file changed, 39 insertions(+), 115 deletions(-)
tests/intel/xe_eudebug.c +39 -115
index 353828f673..e9efb47da8 100644
@@ -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);
 
Signature · 1 line
2.43.0
#13 lore raw

PATCH 12/21 tests/xe_eudebug: Adapt some ufence reliant tests to new vm_bind event interface

In reply to Mika Kuoppala

From: Christoph Manszewski <[email protected]>

EU debug no longer relays events for VM_BIND_OP_[MAP|UNMAP] operations, this includes ufence events for binds that perorm only these operations. Instead it reports newly added 'VM_BIND_OP_DEBUG_DATA_[ADD|REMOVE]' operations through the event interface and ufence events if a ufence for these operations was provided.

Perform neccessary debug data operations to enable the following subtests:
- basic-vm-bind-ufence*
- vma-ufence*
- basic-vm-acccess*

---
 tests/intel/xe_eudebug.c | 96 +++++++++++++++++++++++++---------------
 1 file changed, 60 insertions(+), 36 deletions(-)
tests/intel/xe_eudebug.c +60 -36
index e9efb47da8..fed9a47405 100644
@@ -236,27 +236,40 @@ static struct bind_list *create_bind_list(int fd, uint32_t bo_placement,
 	bl->vm = vm;
 	bl->bo = vm_create_objects(fd, bo_placement, vm, bo_size, n);
 	bl->n = n;
-	bl->bind_ops = calloc(n, sizeof(*bl->bind_ops));
+	bl->bind_ops = calloc(n * 2, sizeof(*bl->bind_ops));
 	igt_assert(bl->bind_ops);
 
 	for (i = 0; i < n; i++) {
-		struct drm_xe_vm_bind_op *o = &bl->bind_ops[i];
+		struct drm_xe_vm_bind_op *om = &bl->bind_ops[i * 2], *od = &bl->bind_ops[i * 2 + 1];
+		struct drm_xe_vm_bind_op_ext_debug_data *op_ext;
 
 		if (is_userptr) {
-			o->userptr = (uintptr_t)bl->bo[i].userptr;
-			o->op = DRM_XE_VM_BIND_OP_MAP_USERPTR;
+			om->userptr = (uintptr_t)bl->bo[i].userptr;
+			om->op = DRM_XE_VM_BIND_OP_MAP_USERPTR;
 		} else {
-			o->obj = bl->bo[i].fd;
-			o->op = DRM_XE_VM_BIND_OP_MAP;
+			om->obj = bl->bo[i].fd;
+			om->op = DRM_XE_VM_BIND_OP_MAP;
 		}
 
-		o->range = bo_size;
-		o->addr = BO_ADDR + 2 * i * bo_size;
-		o->pat_index = intel_get_pat_idx_wb(fd);
+		om->range = bo_size;
+		om->addr = BO_ADDR + 2 * i * bo_size;
+		om->pat_index = intel_get_pat_idx_wb(fd);
+
+		/* debug data */
+		op_ext = calloc(1, sizeof(*op_ext));
+		op_ext->base.name = XE_VM_BIND_OP_EXTENSIONS_DEBUG_DATA;
+		op_ext->flags = DRM_XE_VM_BIND_DEBUG_DATA_FLAG_PSEUDO;
+		op_ext->pseudopath = DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_MODULE_AREA;
+		op_ext->addr = om->addr;
+		op_ext->range = om->range;
+
+		od->extensions = to_user_pointer(op_ext);
+		od->op = DRM_XE_VM_BIND_OP_ADD_DEBUG_DATA;
+		od->pat_index = intel_get_pat_idx_wb(fd);
 	}
 
 	for (i = 0; i < bl->n; i++) {
-		struct drm_xe_vm_bind_op *o = &bl->bind_ops[i];
+		struct drm_xe_vm_bind_op *o = &bl->bind_ops[i * 2];
 
 		igt_debug("bo %d: addr 0x%llx, range 0x%llx\n", i, o->addr, o->range);
 		bo_prime(fd, o);
@@ -273,9 +286,7 @@ static void do_bind_list(struct xe_eudebug_client *c,
 		.flags = DRM_XE_SYNC_FLAG_SIGNAL,
 		.timeline_value = 1337,
 	};
-	uint64_t ref_seqno = 0, op_ref_seqno = 0;
 	uint64_t *fence_data;
-	int i;
 
 	if (sync) {
 		fence_data = aligned_alloc(xe_get_default_alignment(c->fd),
@@ -285,16 +296,8 @@ static void do_bind_list(struct xe_eudebug_client *c,
 		memset(fence_data, 0, sizeof(*fence_data));
 	}
 
-	xe_vm_bind_array(c->fd, bl->vm, 0, bl->bind_ops, bl->n, &uf_sync, sync ? 1 : 0);
-	xe_eudebug_client_vm_bind_event(c, DRM_XE_EUDEBUG_EVENT_STATE_CHANGE,
-					bl->vm, 0, bl->n, &ref_seqno);
-	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_vm_bind_array(c, bl->vm, 0, bl->bind_ops, bl->n * 2, &uf_sync,
+					sync ? 1 : 0);
 
 	if (sync) {
 		xe_wait_ufence(c->fd, fence_data, uf_sync.timeline_value, 0,
@@ -308,14 +311,33 @@ static void free_bind_list(struct xe_eudebug_client *c, struct bind_list *bl)
 	unsigned int i;
 
 	for (i = 0; i < bl->n; i++) {
-		igt_debug("%d: checking 0x%llx (%lld)\n",
-			  i, bl->bind_ops[i].addr, bl->bind_ops[i].addr);
-		bo_check(c->fd, &bl->bind_ops[i]);
-		if (bl->bind_ops[i].op == DRM_XE_VM_BIND_OP_MAP_USERPTR)
+		struct drm_xe_vm_bind_op *om = &bl->bind_ops[i * 2], *od = &bl->bind_ops[i * 2 + 1];
+		struct drm_xe_vm_bind_op_ext_debug_data *op_ext;
+		igt_debug("%d: checking 0x%llx (%lld)\n", i, om->addr, om->addr);
+
+		bo_check(c->fd, om);
+
+		om->op = DRM_XE_VM_BIND_OP_UNMAP;
+		om->obj = 0;
+		od->op = DRM_XE_VM_BIND_OP_REMOVE_DEBUG_DATA;
+
+		op_ext = from_user_pointer(od->extensions);
+		op_ext->offset = 0;
+		op_ext->flags = 0;
+		memset(op_ext->pathname, 0, sizeof(op_ext->pathname));
+	}
+
+	xe_eudebug_client_vm_bind_array(c, bl->vm, 0, bl->bind_ops, bl->n * 2, NULL, 0);
+
+	for (i = 0; i < bl->n; i++) {
+		struct drm_xe_vm_bind_op *om = &bl->bind_ops[i * 2], *od = &bl->bind_ops[i * 2 + 1];
+		struct drm_xe_vm_bind_op_ext_debug_data *op_ext;
+
+		if (om->op == DRM_XE_VM_BIND_OP_MAP_USERPTR)
 			free(bl->bo[i].userptr);
-		xe_eudebug_client_vm_unbind(c, bl->vm, 0,
-					    bl->bind_ops[i].addr,
-					    bl->bind_ops[i].range);
+
+		op_ext = from_user_pointer(od->extensions);
+		free(op_ext);
 	}
 
 	free(bl->bind_ops);
@@ -1353,7 +1375,7 @@ static void vm_access_client(struct xe_eudebug_client *c)
 		do_bind_list(c, bl, true);
 
 		for (i = 0; i < bl->n; i++)
-			xe_eudebug_client_wait_stage(c, bl->bind_ops[i].addr);
+			xe_eudebug_client_wait_stage(c, bl->bind_ops[i * 2].addr);
 
 		free_bind_list(c, bl);
 	}
@@ -1734,8 +1756,9 @@ static void basic_ufence_client(struct xe_eudebug_client *c)
 	for (int i = 0; i < n; i++) {
 		struct ufence_bind *b = &binds[i];
 
-		xe_eudebug_client_vm_bind_flags(c, vm, bo, 0, b->addr, b->range, 0,
-						&b->f, 1, 0);
+		xe_eudebug_client_vm_bind_map_with_debug_data(c, vm, b->addr, b->range, bo, 0, NULL,
+							      DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_MODULE_AREA,
+							      0, &b->f, 1);
 	}
 
 	client_wait_ufences(c, binds, n);
@@ -1743,7 +1766,7 @@ static void basic_ufence_client(struct xe_eudebug_client *c)
 	for (int i = 0; i < n; i++) {
 		struct ufence_bind *b = &binds[i];
 
-		xe_eudebug_client_vm_unbind(c, vm, 0, b->addr, b->range);
+		xe_eudebug_client_vm_bind_unmap_with_debug_data(c, vm, b->addr, b->range);
 	}
 
 	destroy_binds_with_ufence(binds, n);
@@ -2231,8 +2254,9 @@ static void vma_ufence_client(struct xe_eudebug_client *c)
 	for (int i = 0; i < n; i++) {
 		struct ufence_bind *b = &binds[i];
 
-		xe_eudebug_client_vm_bind_flags(c, vm, bo[i], 0, b->addr, b->range, 0,
-						&b->f, 1, 0);
+		xe_eudebug_client_vm_bind_map_with_debug_data(c, vm, b->addr, b->range, bo[i], 0, NULL,
+							      DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_MODULE_AREA,
+							      0, &b->f, 1);
 	}
 
 	/* Wait for acks on ufences */
@@ -2256,7 +2280,7 @@ static void vma_ufence_client(struct xe_eudebug_client *c)
 	for (int i = 0; i < n; i++) {
 		struct ufence_bind *b = &binds[i];
 
-		xe_eudebug_client_vm_unbind(c, vm, 0, b->addr, b->range);
+		xe_eudebug_client_vm_bind_unmap_with_debug_data(c, vm, b->addr, b->range);
 	}
 
 	destroy_binds_with_ufence(binds, n);
Signature · 1 line
2.43.0
#14 lore raw

PATCH 13/21 tests/xe_eudebug: Adapt vm-bind-clear* subtests to debug data

In reply to Mika Kuoppala

From: Christoph Manszewski <[email protected]>

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 vm-bind-clear* subtests by appending the newly added ops to each regular map/unmap operation.

---
 tests/intel/xe_eudebug.c | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)
tests/intel/xe_eudebug.c +10 -6
index fed9a47405..3cd1f61f7b 100644
@@ -2030,8 +2030,10 @@ static void *vm_bind_clear_thread(void *data)
 		clean_bo = xe_bo_create(c->fd, vm, bo_size, priv->region,
 					DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
 		memset(fence_data, 0, sizeof(*fence_data));
-		xe_eudebug_client_vm_bind_flags(c, vm, clean_bo, 0, clean_offset, bo_size,
-						0, &uf_sync, 1, 0);
+		xe_eudebug_client_vm_bind_map_with_debug_data(c, vm, clean_offset, bo_size,
+							      clean_bo, 0, NULL,
+							      DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_MODULE_AREA,
+							      0, &uf_sync, 1);
 		xe_wait_ufence(c->fd, fence_data, uf_sync.timeline_value, 0,
 			       XE_EUDEBUG_DEFAULT_TIMEOUT_SEC * NSEC_PER_SEC);
 
@@ -2039,8 +2041,10 @@ static void *vm_bind_clear_thread(void *data)
 		batch_bo = xe_bo_create(c->fd, vm, bo_size, priv->region,
 					DRM_XE_GEM_CREATE_FLAG_NEEDS_VISIBLE_VRAM);
 		memset(fence_data, 0, sizeof(*fence_data));
-		xe_eudebug_client_vm_bind_flags(c, vm, batch_bo, 0, batch_offset, bo_size,
-						0, &uf_sync, 1, 0);
+		xe_eudebug_client_vm_bind_map_with_debug_data(c, vm, batch_offset, bo_size,
+							      batch_bo, 0, NULL,
+							      DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_MODULE_AREA,
+							      0, &uf_sync, 1);
 		xe_wait_ufence(c->fd, fence_data, uf_sync.timeline_value, 0,
 			       XE_EUDEBUG_DEFAULT_TIMEOUT_SEC * NSEC_PER_SEC);
 
@@ -2077,10 +2081,10 @@ static void *vm_bind_clear_thread(void *data)
 		xe_eudebug_client_exec_queue_destroy(c, &eq_create);
 		munmap(map, bo_size);
 
-		xe_eudebug_client_vm_unbind(c, vm, 0, batch_offset, bo_size);
+		xe_eudebug_client_vm_bind_unmap_with_debug_data(c, vm, batch_offset, bo_size);
 		gem_close(c->fd, batch_bo);
 
-		xe_eudebug_client_vm_unbind(c, vm, 0, clean_offset, bo_size);
+		xe_eudebug_client_vm_bind_unmap_with_debug_data(c, vm, clean_offset, bo_size);
 		gem_close(c->fd, clean_bo);
 
 		count++;
Signature · 1 line
2.43.0
#15 lore raw

PATCH 14/21 lib/xe_eudebug: Remove unused xe_eudebug_client_vm_bind wrappers

In reply to Mika Kuoppala

From: Christoph Manszewski <[email protected]>

EU debug no longer relays events for VM_BIND_OP_[MAP|UNMAP] operations. Remove the old xe_eudebug_client_vm_bind wrappers that were supposed to track these events in the client (test) side log.

v2: discovery vm bind makes no sense in current form (Mika)

---
 lib/xe/xe_eudebug.c      | 96 ----------------------------------------
 lib/xe/xe_eudebug.h      | 15 -------
 tests/intel/xe_eudebug.c | 10 -----
 3 files changed, 121 deletions(-)
lib/xe/xe_eudebug.c +0 -96
index 7c4ef80e4c..1774e01f6f 100644
@@ -2227,102 +2227,6 @@ static void _xe_eudebug_client_vm_bind(struct xe_eudebug_client *c,
 		      0);
 }
 
-/**
- * xe_eudebug_client_vm_bind_flags
- * @c: pointer to xe_eudebug_client structure
- * @vm: vm handle
- * @bo: buffer object handle
- * @offset: offset within buffer object
- * @addr: ppgtt address
- * @size: size of the binding
- * @flags: vm_bind flags
- * @sync: sync objects
- * @num_syncs: number of sync objects
- * @op_ext: BIND_OP extensions
- *
- * Calls xe vm_bind ioctl and logs the corresponding event in client's event log.
- */
-void xe_eudebug_client_vm_bind_flags(struct xe_eudebug_client *c, uint32_t vm,
-				     uint32_t bo, uint64_t offset,
-				     uint64_t addr, uint64_t size, uint32_t flags,
-				     struct drm_xe_sync *sync, uint32_t num_syncs,
-				     uint64_t op_ext)
-{
-	igt_assert(c);
-	_xe_eudebug_client_vm_bind(c, vm, bo, offset, addr, size,
-				   DRM_XE_VM_BIND_OP_MAP, flags,
-				   sync, num_syncs, op_ext);
-}
-
-/**
- * xe_eudebug_client_vm_bind
- * @c: pointer to xe_eudebug_client structure
- * @vm: vm handle
- * @bo: buffer object handle
- * @offset: offset within buffer object
- * @addr: ppgtt address
- * @size: size of the binding
- *
- * Calls xe vm_bind ioctl and logs the corresponding event in client's event log.
- */
-void xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, uint32_t vm,
-			       uint32_t bo, uint64_t offset,
-			       uint64_t addr, uint64_t size)
-{
-	const uint32_t flags = 0;
-	struct drm_xe_sync *sync = NULL;
-	const uint32_t num_syncs = 0;
-	const uint64_t op_ext = 0;
-
-	xe_eudebug_client_vm_bind_flags(c, vm, bo, offset, addr, size, flags, sync, num_syncs,
-					op_ext);
-}
-
-/**
- * xe_eudebug_client_vm_unbind_flags
- * @c: pointer to xe_eudebug_client structure
- * @vm: vm handle
- * @offset: offset
- * @addr: ppgtt address
- * @size: size of the binding
- * @flags: vm_bind flags
- * @sync: sync objects
- * @num_syncs: number of sync objects
- *
- * Calls xe vm_unbind ioctl and logs the corresponding event in client's event log.
- */
-void xe_eudebug_client_vm_unbind_flags(struct xe_eudebug_client *c,
-				       uint32_t vm, uint64_t offset,
-				       uint64_t addr, uint64_t size, uint32_t flags,
-				       struct drm_xe_sync *sync, uint32_t num_syncs)
-{
-	igt_assert(c);
-	_xe_eudebug_client_vm_bind(c, vm, 0, offset, addr, size,
-				   DRM_XE_VM_BIND_OP_UNMAP, flags,
-				   sync, num_syncs, 0);
-}
-
-/**
- * xe_eudebug_client_vm_unbind
- * @c: pointer to xe_eudebug_client structure
- * @vm: vm handle
- * @offset: offset
- * @addr: ppgtt address
- * @size: size of the binding
- *
- * Calls xe vm_unbind ioctl and logs the corresponding event in client's event log.
- */
-void xe_eudebug_client_vm_unbind(struct xe_eudebug_client *c, uint32_t vm,
-				 uint64_t offset, uint64_t addr, uint64_t size)
-{
-	const uint32_t flags = 0;
-	struct drm_xe_sync *sync = NULL;
-	const uint32_t num_syncs = 0;
-
-	xe_eudebug_client_vm_unbind_flags(c, vm, offset, addr, size,
-					  flags, sync, num_syncs);
-}
-
 /**
  * xe_eudebug_client_vm_bind_debug_data_add
  * @c: pointer to xe_eudebug_client structure
lib/xe/xe_eudebug.h +0 -15
index a53bd99dc0..d191f8be8d 100644
@@ -240,21 +240,6 @@ void xe_eudebug_client_vm_bind_ufence_event(struct xe_eudebug_client *c, uint32_
 void xe_eudebug_ack_ufence(int debugfd,
 			   const struct drm_xe_eudebug_event_vm_bind_ufence *f);
 
-void xe_eudebug_client_vm_bind_flags(struct xe_eudebug_client *c, uint32_t vm,
-				     uint32_t bo, uint64_t offset,
-				     uint64_t addr, uint64_t size, uint32_t flags,
-				     struct drm_xe_sync *sync, uint32_t num_syncs,
-				     uint64_t op_ext);
-void xe_eudebug_client_vm_bind(struct xe_eudebug_client *c, uint32_t vm,
-			       uint32_t bo, uint64_t offset,
-			       uint64_t addr, uint64_t size);
-void xe_eudebug_client_vm_unbind_flags(struct xe_eudebug_client *c,
-				       uint32_t vm, uint64_t offset,
-				       uint64_t addr, uint64_t size, uint32_t flags,
-				       struct drm_xe_sync *sync, uint32_t num_syncs);
-void xe_eudebug_client_vm_unbind(struct xe_eudebug_client *c, uint32_t vm,
-				 uint64_t offset, uint64_t addr, uint64_t size);
-
 void xe_eudebug_client_vm_bind_debug_data_add(struct xe_eudebug_client *c, uint32_t vm,
 					      uint32_t offset, uint64_t addr, uint64_t range,
 					      uint64_t pseudopath, char *path,
tests/intel/xe_eudebug.c +0 -10
index 3cd1f61f7b..bdd1996f38 100644
@@ -951,13 +951,11 @@ static void test_basic_discovery(int fd, unsigned int flags, bool match_opposite
 #define PRIMARY_THREAD			(1 << 0)
 #define DISCOVERY_CLOSE_CLIENT		(1 << 1)
 #define DISCOVERY_DESTROY_RESOURCES	(1 << 2)
-#define DISCOVERY_VM_BIND		(1 << 3)
 #define DISCOVERY_SIGINT		(1 << 4)
 static void run_discovery_client(struct xe_eudebug_client *c)
 {
 	int fd[RESOURCE_COUNT], i;
 	bool skip_sleep = c->flags & (DISCOVERY_DESTROY_RESOURCES | DISCOVERY_CLOSE_CLIENT);
-	uint64_t addr = 0x1a0000;
 
 	srand(getpid());
 
@@ -999,11 +997,6 @@ static void run_discovery_client(struct xe_eudebug_client *c)
 
 			xe_eudebug_client_exec_queue_create(c, &create);
 
-			if (c->flags & DISCOVERY_VM_BIND) {
-				xe_eudebug_client_vm_bind(c, vm, bo, 0, addr, bo_size);
-				addr += bo_size;
-			}
-
 			if (c->flags & DISCOVERY_DESTROY_RESOURCES) {
 				xe_eudebug_client_exec_queue_destroy(c, &create);
 				xe_eudebug_client_vm_destroy(c, create.vm_id);
@@ -2622,9 +2615,6 @@ int igt_main()
 	igt_subtest("discovery-race")
 		test_race_discovery(fd, 0, 4);
 
-	igt_subtest("discovery-race-vmbind")
-		test_race_discovery(fd, DISCOVERY_VM_BIND, 4);
-
 	igt_subtest("discovery-race-sigint")
 		test_race_discovery(fd, DISCOVERY_SIGINT, 1);
 
Signature · 1 line
2.43.0
#16 lore raw

PATCH 15/21 tests/xe_eudebug: Add vm-bind-debug-data-ufence subtest

In reply to Mika Kuoppala

From: Christoph Manszewski <[email protected]>

Add a subtest for the newly introduced debug data passing interface. Debug data (formery metadata) used to be attached as an extension to VM_BIND_OP_MAP operations. As dedicated VM_BIND_OP_DEBUG_DATA_[ADD|REMOVE] operations got introduced for debug data passing, this subtest provides basic coverage for this new interface.

v2: squash in uapi changes (Mika)

---
 .../drm-uapi-experimental/xe_drm_eudebug.h    |  33 +-
 lib/xe/xe_eudebug.c                           |  32 +-
 lib/xe/xe_eudebug.h                           |   5 +-
 tests/intel/xe_eudebug.c                      | 314 ++++++++++++++++--
 tests/intel/xe_eudebug_online.c               |   6 +-
 5 files changed, 325 insertions(+), 65 deletions(-)
include/drm-uapi-experimental/xe_drm_eudebug.h +19 -14
index a9aa87f564..43b8d12b47 100644
@@ -69,13 +69,11 @@ struct drm_xe_eudebug_event {
 #define DRM_XE_EUDEBUG_EVENT_READ		1
 #define DRM_XE_EUDEBUG_EVENT_VM			2
 #define DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE		3
-#define DRM_XE_EUDEBUG_EVENT_EU_ATTENTION	4
-#define DRM_XE_EUDEBUG_EVENT_VM_BIND		5
-#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP		6
-#define DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE	7
-#define DRM_XE_EUDEBUG_EVENT_METADATA		8
-#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_METADATA 9
-#define DRM_XE_EUDEBUG_EVENT_PAGEFAULT		10
+#define DRM_XE_EUDEBUG_EVENT_VM_BIND		4
+#define DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA 5
+#define DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE	6
+#define DRM_XE_EUDEBUG_EVENT_EU_ATTENTION	7
+#define DRM_XE_EUDEBUG_EVENT_PAGEFAULT		8
 
 	__u16 flags;
 #define DRM_XE_EUDEBUG_EVENT_CREATE		(1 << 0)
@@ -182,13 +180,20 @@ struct drm_xe_eudebug_event_vm_bind {
 	__u32 num_binds;
 };
 
-struct drm_xe_eudebug_event_vm_bind_op {
-	struct drm_xe_eudebug_event base;
-	__u64 vm_bind_ref_seqno; /* *_event_vm_bind.base.seqno */
-	__u64 num_extensions;
-
-	__u64 addr; /* XXX: Zero for unmap all? */
-	__u64 range; /* XXX: Zero for unmap all? */
+struct drm_xe_eudebug_event_vm_bind_op_debug_data {
+        struct drm_xe_eudebug_event base;
+        __u64 vm_bind_ref_seqno; /* *_event_vm_bind.base.seqno */
+        __u64 num_extensions;
+
+        __u64 addr;
+        __u64 range;
+        __u64 flags;
+        __u32 offset;
+        __u32 reserved;
+        union {
+                __u64 pseudopath;
+                char pathname[PATH_MAX];
+        };
 };
 
 struct drm_xe_eudebug_event_vm_bind_ufence {
lib/xe/xe_eudebug.c +18 -14
index 1774e01f6f..f441a3c824 100644
@@ -86,8 +86,8 @@ static const char *type_to_str(unsigned int type)
 		return "exec_queue";
 	case DRM_XE_EUDEBUG_EVENT_VM_BIND:
 		return "vm_bind";
-	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP:
-		return "vm_bind_op";
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA:
+		return "vm_bind_op_debug_data";
 	case DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE:
 		return "vm_bind_ufence";
 	case DRM_XE_EUDEBUG_EVENT_EU_ATTENTION:
@@ -150,8 +150,9 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *bu
 			evmb->vm_handle, evmb->flags, evmb->num_binds);
 		break;
 	}
-	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
-		struct drm_xe_eudebug_event_vm_bind_op *op = igt_container_of(e, op, base);
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA: {
+		struct drm_xe_eudebug_event_vm_bind_op_debug_data *op =
+			igt_container_of(e, op, base);
 
 		sprintf(buf, "vm_bind_ref_seqno=%lld, addr=%016llx, range=%llu num_extensions=%llu",
 			op->vm_bind_ref_seqno, op->addr, op->range, op->num_extensions);
@@ -599,9 +600,11 @@ static int match_fields(struct drm_xe_eudebug_event *a, void *data)
 			ret = 1;
 		break;
 	}
-	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
-		struct drm_xe_eudebug_event_vm_bind_op *ea = igt_container_of(a, ea, base);
-		struct drm_xe_eudebug_event_vm_bind_op *eb = igt_container_of(b, eb, base);
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA: {
+		struct drm_xe_eudebug_event_vm_bind_op_debug_data *ea =
+			igt_container_of(a, ea, base);
+		struct drm_xe_eudebug_event_vm_bind_op_debug_data *eb =
+			igt_container_of(b, eb, base);
 
 		if (ea->addr == eb->addr && ea->range == eb->range &&
 		    ea->num_extensions == eb->num_extensions)
@@ -637,8 +640,8 @@ static int match_client_handle(struct drm_xe_eudebug_event *e, void *data)
 		return 1;
 		break;
 	}
-	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
-		struct drm_xe_eudebug_event_vm_bind_op *eo = igt_container_of(e, eo, base);
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA: {
+		struct drm_xe_eudebug_event_vm_bind_op_debug_data *eo = igt_container_of(e, eo, base);
 
 		if (eo->vm_bind_ref_seqno == *bind_seqno) {
 			*bind_op_seqno = eo->base.seqno;
@@ -700,9 +703,10 @@ static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
 			return 1;
 		break;
 	}
-	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP: {
-		struct drm_xe_eudebug_event_vm_bind_op *avmb = igt_container_of(e, avmb, base);
-		struct drm_xe_eudebug_event_vm_bind_op *filter = data;
+	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA: {
+		struct drm_xe_eudebug_event_vm_bind_op_debug_data *avmb =
+			igt_container_of(e, avmb, base);
+		struct drm_xe_eudebug_event_vm_bind_op_debug_data *filter = data;
 
 		if (avmb->addr == filter->addr &&
 		    avmb->range == filter->range)
@@ -2105,12 +2109,12 @@ void xe_eudebug_client_vm_bind_op_event(struct xe_eudebug_client *c, uint32_t ev
 					uint64_t addr, uint64_t range,
 					uint64_t num_extensions)
 {
-	struct drm_xe_eudebug_event_vm_bind_op op;
+	struct drm_xe_eudebug_event_vm_bind_op_debug_data op = { 0 };
 
 	igt_assert(c);
 	igt_assert(op_ref_seqno);
 
-	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP,
+	base_event(c, to_base(op), DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA,
 		   event_flags, sizeof(op));
 	op.vm_bind_ref_seqno = bind_ref_seqno;
 	op.addr = addr;
lib/xe/xe_eudebug.h +2 -3
index d191f8be8d..acf5bf601d 100644
@@ -166,11 +166,10 @@ next_event(struct drm_xe_eudebug_event *e, struct xe_eudebug_event_log *l)
 #define XE_EUDEBUG_FILTER_EVENT_READ			BIT(DRM_XE_EUDEBUG_EVENT_READ)
 #define XE_EUDEBUG_FILTER_EVENT_VM			BIT(DRM_XE_EUDEBUG_EVENT_VM)
 #define XE_EUDEBUG_FILTER_EVENT_EXEC_QUEUE		BIT(DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE)
-#define XE_EUDEBUG_FILTER_EVENT_EXEC_QUEUE_PLACEMENTS	BIT(DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE_PLACEMENTS)
-#define XE_EUDEBUG_FILTER_EVENT_EU_ATTENTION		BIT(DRM_XE_EUDEBUG_EVENT_EU_ATTENTION)
 #define XE_EUDEBUG_FILTER_EVENT_VM_BIND			BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND)
-#define XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP		BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP)
+#define XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP_DEBUG_DATA		BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA)
 #define XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE		BIT(DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE)
+#define XE_EUDEBUG_FILTER_EVENT_EU_ATTENTION		BIT(DRM_XE_EUDEBUG_EVENT_EU_ATTENTION)
 #define XE_EUDEBUG_FILTER_EVENT_PAGEFAULT		BIT(DRM_XE_EUDEBUG_EVENT_PAGEFAULT)
 #define XE_EUDEBUG_FILTER_ALL				GENMASK(DRM_XE_EUDEBUG_EVENT_PAGEFAULT, 0)
 #define XE_EUDEBUG_EVENT_IS_FILTERED(_e, _f)		((1UL << (_e)) & (_f))
tests/intel/xe_eudebug.c +283 -31

456 lines not on this page · raw message

tests/intel/xe_eudebug_online.c +3 -3
index c4e9ff2fce..34a8ff26e9 100644
@@ -1254,7 +1254,7 @@ static void online_session_check(struct xe_eudebug_session *s, int flags)
 	int pagefault_threads = 0;
 
 	xe_eudebug_session_check(s, true, XE_EUDEBUG_FILTER_EVENT_VM_BIND |
-					  XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP |
+					  XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP_DEBUG_DATA |
 					  XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE);
 
 	bitmask_size = query_attention_bitmask_size(s->debugger->master_fd, data->hwe.gt_id);
@@ -1949,7 +1949,7 @@ static void test_interrupt_other(int fd, struct drm_xe_engine_class_instance *hw
 	xe_eudebug_event_log_print(debugee->log, true);
 
 	xe_eudebug_session_check(s, true, XE_EUDEBUG_FILTER_EVENT_VM_BIND |
-				 XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP |
+				 XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP_DEBUG_DATA |
 				 XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE);
 
 	xe_eudebug_client_destroy(debugee);
@@ -2160,7 +2160,7 @@ static void test_interrupt_reconnect(int fd, struct drm_xe_engine_class_instance
 	xe_eudebug_event_log_print(s->client->log, true);
 
 	xe_eudebug_session_check(s, true, XE_EUDEBUG_FILTER_EVENT_VM_BIND |
-					  XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP |
+					  XE_EUDEBUG_FILTER_EVENT_VM_BIND_OP_DEBUG_DATA |
 					  XE_EUDEBUG_FILTER_EVENT_VM_BIND_UFENCE);
 
 	/* We expect workload reset, so no attention should be raised */
Signature · 1 line
2.43.0
#17 lore raw

PATCH 16/21 lib/intel_batchbuffer: Add dummy OP_DEBUG_DATA operation to __xe_alloc_bind_ops

In reply to Mika Kuoppala

From: Christoph Manszewski <[email protected]>

xe_eudebug_online tests rely on ufence blocking/acking by the debugger to set the breakpoint bit on a client shader instruction before the workload is executed. Ufence events and debugger blocking/acking is no longer present for binds that only contain 'OP_MAP' operations - at least a single 'OP_ADD_DEBUG_DATA' has to be present to trigger this functionality. Make it possible to inject a dummy debug data vm bind operation to the list of bind operations during bb execution.

---
 lib/intel_batchbuffer.c | 82 +++++++++++++++++++++++++----------------
 1 file changed, 51 insertions(+), 31 deletions(-)
lib/intel_batchbuffer.c +51 -31
index 3b25a385b7..5e5cf0b136 100644
@@ -1355,42 +1355,71 @@ void intel_bb_destroy(struct intel_bb *ibb)
 #define XE_OBJ_PXP_BIT (0x100)
 #define XE_OBJ_PXP(rsvd1) ((rsvd1) & (XE_OBJ_PXP_BIT))
 
-static struct drm_xe_vm_bind_op *xe_alloc_bind_ops(struct intel_bb *ibb,
-						   uint32_t op, uint32_t flags,
-						   uint32_t prefetch_region)
+static struct drm_xe_vm_bind_op *__xe_alloc_bind_ops(struct intel_bb *ibb,
+						     uint32_t op, uint32_t flags,
+						     uint32_t prefetch_region,
+						     bool dummy_debug_data)
 {
 	struct drm_i915_gem_exec_object2 **objects = ibb->objects;
-	struct drm_xe_vm_bind_op *bind_ops, *ops;
+	struct drm_xe_vm_bind_op *bind_ops, *bind_op, *ret;
 	bool set_obj = (op & 0xffff) == DRM_XE_VM_BIND_OP_MAP;
 
-	bind_ops = calloc(ibb->num_objects, sizeof(*bind_ops));
+	ret = bind_ops = calloc(ibb->num_objects + (dummy_debug_data ? 1 : 0), sizeof(*bind_ops));
 	igt_assert(bind_ops);
 
+	if (dummy_debug_data) {
+		struct drm_xe_vm_bind_op_ext_debug_data *op_ext;
+
+		bind_op = &bind_ops[0];
+
+		op_ext = calloc(1, sizeof(*op_ext));
+		op_ext->base.name = XE_VM_BIND_OP_EXTENSIONS_DEBUG_DATA;
+		op_ext->flags = DRM_XE_VM_BIND_DEBUG_DATA_FLAG_PSEUDO;
+		op_ext->pseudopath = DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_SIP_AREA;
+		op_ext->addr = 0;
+		op_ext->range = 1;
+
+		bind_op->op = (op == DRM_XE_VM_BIND_OP_MAP ?
+			DRM_XE_VM_BIND_OP_ADD_DEBUG_DATA :
+			DRM_XE_VM_BIND_OP_REMOVE_DEBUG_DATA);
+		bind_op->extensions = to_user_pointer(op_ext);
+		bind_op->pat_index = intel_get_pat_idx_wb(ibb->fd);
+
+		bind_ops = &bind_ops[1];
+	}
+
 	igt_debug("bind_ops: %s\n", set_obj ? "MAP" : "UNMAP");
 	for (int i = 0; i < ibb->num_objects; i++) {
-		ops = &bind_ops[i];
+		bind_op = &bind_ops[i];
 
 		if (set_obj)
-			ops->obj = objects[i]->handle;
+			bind_op->obj = objects[i]->handle;
 
-		ops->op = op;
-		ops->flags = flags;
+		bind_op->op = op;
+		bind_op->flags = flags;
 
 		if (XE_OBJ_PXP(objects[i]->rsvd1))
-			ops->flags |= DRM_XE_VM_BIND_FLAG_CHECK_PXP;
-		ops->obj_offset = 0;
-		ops->addr = objects[i]->offset;
-		ops->range = XE_OBJ_SIZE(objects[i]->rsvd1);
-		ops->prefetch_mem_region_instance = prefetch_region;
+			bind_op->flags |= DRM_XE_VM_BIND_FLAG_CHECK_PXP;
+		bind_op->obj_offset = 0;
+		bind_op->addr = objects[i]->offset;
+		bind_op->range = XE_OBJ_SIZE(objects[i]->rsvd1);
+		bind_op->prefetch_mem_region_instance = prefetch_region;
 		if (set_obj)
-			ops->pat_index = XE_OBJ_PAT_IDX(objects[i]->rsvd1);
+			bind_op->pat_index = XE_OBJ_PAT_IDX(objects[i]->rsvd1);
 
 		igt_debug("  [%d]: handle: %u, offset: %llx, size: %llx pat_index: %u\n",
-			  i, ops->obj, (long long)ops->addr, (long long)ops->range,
-			  ops->pat_index);
+			  i, bind_op->obj, (long long)bind_op->addr, (long long)bind_op->range,
+			  bind_op->pat_index);
 	}
 
-	return bind_ops;
+	return ret;
+}
+
+static struct drm_xe_vm_bind_op *xe_alloc_bind_ops(struct intel_bb *ibb,
+						   uint32_t op, uint32_t flags,
+						   uint32_t prefetch_region)
+{
+	return __xe_alloc_bind_ops(ibb, op, flags, prefetch_region, false);
 }
 
 static void __unbind_xe_objects(struct intel_bb *ibb)
@@ -2633,19 +2662,10 @@ __xe_lr_bb_exec(struct intel_bb *ibb, uint64_t flags, bool sync)
 	syncs[0].addr = vm_sync_addr;
 	syncs[1].addr = exec_sync_addr;
 
-	if (ibb->num_objects > 1) {
-		bind_ops = xe_alloc_bind_ops(ibb, DRM_XE_VM_BIND_OP_MAP, 0, 0);
-		xe_vm_bind_array(ibb->fd, ibb->vm_id, 0, bind_ops,
-				 ibb->num_objects, syncs, 1);
-		free(bind_ops);
-	} else {
-		igt_debug("bind: MAP\n");
-		igt_debug("  handle: %u, offset: %llx, size: %llx\n",
-			  ibb->handle, (long long)ibb->batch_offset,
-			  (long long)ibb->size);
-		xe_vm_bind_async(ibb->fd, ibb->vm_id, 0, ibb->handle, 0,
-				 ibb->batch_offset, ibb->size, syncs, 1);
-	}
+	bind_ops = __xe_alloc_bind_ops(ibb, DRM_XE_VM_BIND_OP_MAP, 0, 0, true);
+	xe_vm_bind_array(ibb->fd, ibb->vm_id, 0, bind_ops, ibb->num_objects + 1, syncs, 1);
+	free(from_user_pointer(bind_ops[0].extensions));
+	free(bind_ops);
 
 	/* use default vm_bind_exec_queue */
 	xe_wait_ufence(ibb->fd, &sync_data->vm_sync, USER_FENCE_VALUE, 0, -1);
Signature · 1 line
2.43.0
#18 lore raw

PATCH 17/21 tests/xe_eudebug_online: Adapt set-breakpoint test to work with new vm bind event interface

In reply to Mika Kuoppala

From: Christoph Manszewski <[email protected]>

Metadata used to be a standalone kernel resource created with a dedicated ioctl and carried a binary blob as payload. The set-breakpoint testcase relies on metadata resource creation events for bb ppgtt address and size passing.

After rework the (now called) debug data can only be passed to the debugger by mapping it to a vm. Convert the test to use this new interface.

---
 tests/intel/xe_eudebug_online.c | 37 +++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
tests/intel/xe_eudebug_online.c +37 -0
index 34a8ff26e9..a9fa150114 100644
@@ -875,6 +875,32 @@ static void vm_open_trigger(struct xe_eudebug_debugger *d,
 	pthread_mutex_unlock(&data->mutex);
 }
 
+static void online_debug_data_trigger(struct xe_eudebug_debugger *d, struct drm_xe_eudebug_event *e)
+{
+	struct drm_xe_eudebug_event_vm_bind_op_debug_data *ed = (void *)e;
+	struct online_debug_data *data = d->ptr;
+
+	if (!(e->flags & DRM_XE_EUDEBUG_EVENT_CREATE))
+		return;
+
+	igt_assert(ed->flags & DRM_XE_VM_BIND_DEBUG_DATA_FLAG_PSEUDO);
+
+	pthread_mutex_lock(&data->mutex);
+	switch (ed->pseudopath) {
+	case DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_SBA_AREA:
+		data->bb_offset = ed->addr;
+		data->bb_size = ed->range;
+		break;
+	case DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_MODULE_AREA:
+		data->target_offset = ed->addr;
+		data->target_size = ed->range;
+		break;
+	default:
+		break;
+	}
+	pthread_mutex_unlock(&data->mutex);
+}
+
 static void overwrite_immediate_value_in_common_target_write(int vm_fd, uint64_t offset,
 							     uint32_t old_val, uint32_t new_val)
 {
@@ -1081,6 +1107,13 @@ static void run_online_client(struct xe_eudebug_client *c)
 
 	create.vm_id = xe_eudebug_client_vm_create(c, vm_flags, 0);
 
+	xe_eudebug_client_vm_bind_debug_data_add(c, create.vm_id, 0, bb_offset, bb_size,
+						 DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_SBA_AREA,
+						 NULL, NULL, 0);
+	xe_eudebug_client_vm_bind_debug_data_add(c, create.vm_id, 0, target_offset, buf->size,
+						 DRM_XE_VM_BIND_DEBUG_DATA_PSEUDO_MODULE_AREA,
+						 NULL, NULL, 0);
+
 	xe_eudebug_client_exec_queue_create(c, &create);
 
 	ibb = xe_bb_create_on_offset(c->fd,
@@ -1126,6 +1159,8 @@ static void run_online_client(struct xe_eudebug_client *c)
 	intel_bb_destroy(ibb);
 
 	xe_eudebug_client_exec_queue_destroy(c, &create);
+	xe_eudebug_client_vm_bind_debug_data_remove(c, create.vm_id, bb_offset, bb_size);
+	xe_eudebug_client_vm_bind_debug_data_remove(c, create.vm_id, target_offset, buf->size);
 	xe_eudebug_client_vm_destroy(c, create.vm_id);
 
 	intel_buf_destroy(buf);
@@ -1493,6 +1528,8 @@ static void test_set_breakpoint_online(int fd, struct drm_xe_engine_class_instan
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
 					exec_queue_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA,
+					online_debug_data_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
 					ufence_ack_set_bp_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
Signature · 1 line
2.43.0
#19 lore raw

PATCH 18/21 tests/xe_eudebug_online: Adapt several subtests to work with new vm bind event interface

In reply to Mika Kuoppala

From: Christoph Manszewski <[email protected]>

Add 'online_debug_data_trigger' to multiple test functions to adapt the following subtests to the new debug data passing mechanism:
- interrupt-all*
- tdctl-parameters
- single-step*
- writes-caching*

---
 tests/intel/xe_eudebug_online.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)
tests/intel/xe_eudebug_online.c +12 -0
index a9fa150114..473c362470 100644
@@ -1596,6 +1596,8 @@ static void test_set_breakpoint_online_sigint_debugger(int fd,
 						ufence_ack_set_bp_trigger);
 		xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 						eu_attention_resume_trigger);
+		xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA,
+						online_debug_data_trigger);
 
 		igt_assert_eq(xe_eudebug_debugger_attach(s->debugger, s->client), 0);
 		xe_eudebug_debugger_start_worker(s->debugger);
@@ -1716,6 +1718,8 @@ static void test_pagefault_online(int fd, struct drm_xe_engine_class_instance *h
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 					eu_attention_resume_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA,
+					online_debug_data_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
 					ufence_ack_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_PAGEFAULT,
@@ -1851,6 +1855,8 @@ static void test_interrupt_all(int fd, struct drm_xe_engine_class_instance *hwe,
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 					eu_attention_resume_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA,
+					online_debug_data_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
 					ufence_ack_trigger);
 
@@ -2024,6 +2030,8 @@ static void test_tdctl_parameters(int fd, struct drm_xe_engine_class_instance *h
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 					eu_attention_resume_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA,
+					online_debug_data_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
 					ufence_ack_trigger);
 
@@ -2237,6 +2245,8 @@ static void test_single_step(int fd, struct drm_xe_engine_class_instance *hwe, i
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 					eu_attention_resume_single_step_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA,
+					online_debug_data_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
 					ufence_ack_trigger);
 
@@ -2334,6 +2344,8 @@ static void test_caching(int fd, struct drm_xe_engine_class_instance *hwe, int f
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 					eu_attention_resume_caching_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
+	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA,
+					online_debug_data_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
 					ufence_ack_trigger);
 
Signature · 1 line
2.43.0
#20 lore raw

PATCH 19/21 lib/xe/xe_eudebug: Add callback for session work

In reply to Mika Kuoppala

If there was a need for special handling during session, multiple tests baked in the session setup and teardown into their own boilerplates.

Instead of this, introduce a callback to handle session work so that tests can avoid the same boilerplate just in order to have control during the session.

make test_basic_ufence to showcase the new functionality.

TODO: convert other tests

---
 lib/xe/xe_eudebug.c             | 20 ++++++---
 lib/xe/xe_eudebug.h             | 15 +++++--
 tests/intel/xe_eudebug.c        | 75 +++++++++++++++++----------------
 tests/intel/xe_eudebug_online.c | 35 ++++++++-------
 4 files changed, 84 insertions(+), 61 deletions(-)
lib/xe/xe_eudebug.c +15 -5
index f441a3c824..7c1ac38d9c 100644
@@ -1744,7 +1744,8 @@ void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage)
 /**
  * xe_eudebug_session_create:
  * @fd: Xe file descriptor
- * @work: function passed to the xe_eudebug_client_create
+ * @client_work: function passed to the xe_eudebug_client_create
+ * @session_work: function to add extra session handling (if any)
  * @flags: flags passed to client and debugger
  * @test_private: test's  data, allocated with MAP_SHARED | MAP_ANONYMOUS,
  * passed to client and debugger. Can be NULL.
@@ -1752,7 +1753,8 @@ void xe_eudebug_client_wait_stage(struct xe_eudebug_client *c, uint64_t stage)
  * Creates session together with client and debugger structures.
  */
 struct xe_eudebug_session *xe_eudebug_session_create(int fd,
-						     xe_eudebug_client_work_fn work,
+						     xe_eudebug_client_work_fn client_work,
+						     xe_eudebug_session_work_fn session_work,
 						     unsigned int flags,
 						     void *test_private)
 {
@@ -1761,9 +1763,11 @@ struct xe_eudebug_session *xe_eudebug_session_create(int fd,
 	s = calloc(1, sizeof(*s));
 	igt_assert(s);
 
-	s->client = xe_eudebug_client_create(fd, work, flags, test_private);
+	s->client = xe_eudebug_client_create(fd, client_work, flags, test_private);
 	s->debugger = xe_eudebug_debugger_create(fd, flags, test_private);
+	s->priv = test_private;
 	s->flags = flags;
+	s->session_work = session_work;
 
 	return s;
 }
@@ -1773,8 +1777,10 @@ struct xe_eudebug_session *xe_eudebug_session_create(int fd,
  * @s: pointer to xe_eudebug_session structure
  *
  * Attaches debugger to client's proccess, starts debugger's
- * async event reader, starts client and once client finish
- * it stops debugger worker.
+ * async event reader, starts client. If session work was provided,
+ * it will do extra session work with that callback.
+ * Then session will wait client to finish and stop debugger
+ * and the proceeding with teardown.
  */
 void xe_eudebug_session_run(struct xe_eudebug_session *s)
 {
@@ -1786,6 +1792,10 @@ void xe_eudebug_session_run(struct xe_eudebug_session *s)
 	xe_eudebug_debugger_start_worker(debugger);
 
 	xe_eudebug_client_start(client);
+
+	if (s->session_work)
+		s->session_work(s);
+
 	xe_eudebug_client_wait_done(client);
 
 	xe_eudebug_debugger_stop_worker(debugger);
lib/xe/xe_eudebug.h +11 -4
index acf5bf601d..95d0d023b8 100644
@@ -79,16 +79,22 @@ struct xe_eudebug_client {
 	pthread_mutex_t lock;
 };
 
+struct xe_eudebug_session;
+
+typedef void (*xe_eudebug_client_work_fn)(struct xe_eudebug_client *);
+typedef void (*xe_eudebug_trigger_fn)(struct xe_eudebug_debugger *,
+				      struct drm_xe_eudebug_event *);
+typedef void (*xe_eudebug_session_work_fn)(struct xe_eudebug_session *);
+
 struct xe_eudebug_session {
 	uint64_t flags;
+	xe_eudebug_session_work_fn session_work;
+	void *priv;
+
 	struct xe_eudebug_client *client;
 	struct xe_eudebug_debugger *debugger;
 };
 
-typedef void (*xe_eudebug_client_work_fn)(struct xe_eudebug_client *);
-typedef void (*xe_eudebug_trigger_fn)(struct xe_eudebug_debugger *,
-				      struct drm_xe_eudebug_event *);
-
 #define xe_eudebug_for_each_engine(fd__, hwe__) \
 	xe_for_each_engine(fd__, hwe__) \
 		if (hwe__->engine_class == DRM_XE_ENGINE_CLASS_RENDER || \
@@ -261,6 +267,7 @@ void xe_eudebug_client_vm_bind_unmap_with_debug_data(struct xe_eudebug_client *c
 
 struct xe_eudebug_session *xe_eudebug_session_create(int fd,
 						     xe_eudebug_client_work_fn work,
+						     xe_eudebug_session_work_fn session_work,
 						     unsigned int flags,
 						     void *test_private);
 void xe_eudebug_session_destroy(struct xe_eudebug_session *s);
tests/intel/xe_eudebug.c +39 -36

141 lines not on this page · raw message

tests/intel/xe_eudebug_online.c +19 -16
index 473c362470..b1690a7397 100644
@@ -1487,8 +1487,9 @@ static void test_basic_online(int fd, struct drm_xe_engine_class_instance *hwe,
 	struct xe_eudebug_session *s;
 	struct online_debug_data *data;
 
+
 	data = online_debug_data_create(fd, hwe, flags);
-	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
 
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 					eu_attention_debug_trigger);
@@ -1524,7 +1525,8 @@ static void test_set_breakpoint_online(int fd, struct drm_xe_engine_class_instan
 	igt_require(!(flags & FAULTABLE_VM) || !xe_supports_faults(fd));
 
 	data = online_debug_data_create(fd, hwe, flags);
-	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
+
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
 					exec_queue_trigger);
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_VM, vm_open_trigger);
@@ -1585,7 +1587,8 @@ static void test_set_breakpoint_online_sigint_debugger(int fd,
 		igt_debug("Loop %d: SIGINT after %" PRIu64 " us\n", loop_count, sleep_time);
 
 		data = online_debug_data_create(fd, hwe, flags);
-		s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+		s = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
+
 		s->client->allow_dead_client = true;
 
 		xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
@@ -1709,7 +1712,7 @@ static void test_pagefault_online(int fd, struct drm_xe_engine_class_instance *h
 
 		data->max_subslices_per_slice = DIV_ROUND_UP(max_ss, max_sl);
 	}
-	s = xe_eudebug_session_create(fd, run_online_client, data->flags, data);
+	s = xe_eudebug_session_create(fd, run_online_client, NULL, data->flags, data);
 
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
 					exec_queue_trigger);
@@ -1747,7 +1750,8 @@ static void test_preemption(int fd, struct drm_xe_engine_class_instance *hwe)
 	struct xe_eudebug_client *other;
 
 	data = online_debug_data_create(fd, hwe, flags);
-	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
+
 	other = xe_eudebug_client_create(fd, run_online_client, SHADER_NOP, data);
 
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
@@ -1792,7 +1796,7 @@ static void test_reset_with_attention_online(int fd, struct drm_xe_engine_class_
 	struct online_debug_data *data;
 
 	data = online_debug_data_create(fd, hwe, flags);
-	s1 = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s1 = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
 
 	xe_eudebug_debugger_add_trigger(s1->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 					eu_attention_reset_trigger);
@@ -1802,7 +1806,7 @@ static void test_reset_with_attention_online(int fd, struct drm_xe_engine_class_
 	xe_eudebug_session_run(s1);
 	xe_eudebug_session_destroy(s1);
 
-	s2 = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s2 = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
 	xe_eudebug_debugger_add_trigger(s2->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 					eu_attention_resume_trigger);
 	xe_eudebug_debugger_add_trigger(s2->debugger, DRM_XE_EUDEBUG_EVENT_VM_BIND_UFENCE,
@@ -1846,7 +1850,7 @@ static void test_interrupt_all(int fd, struct drm_xe_engine_class_instance *hwe,
 	igt_require(!(flags & FAULTABLE_VM) || !xe_supports_faults(fd));
 
 	data = online_debug_data_create(fd, hwe, flags);
-	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
 
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
 					exec_queue_trigger);
@@ -1934,7 +1938,7 @@ static void test_interrupt_other(int fd, struct drm_xe_engine_class_instance *hw
 	int val;
 
 	data = online_debug_data_create(fd, hwe, flags);
-	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
 
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
 					exec_queue_trigger);
@@ -2021,7 +2025,7 @@ static void test_tdctl_parameters(int fd, struct drm_xe_engine_class_instance *h
 	igt_assert(attention_bitmask);
 
 	data = online_debug_data_create(fd, hwe, flags);
-	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
 
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
 					exec_queue_trigger);
@@ -2164,7 +2168,7 @@ static void test_interrupt_reconnect(int fd, struct drm_xe_engine_class_instance
 	uint32_t val;
 
 	data = online_debug_data_create(fd, hwe, flags);
-	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
 
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EXEC_QUEUE,
 					exec_queue_trigger);
@@ -2238,7 +2242,7 @@ static void test_single_step(int fd, struct drm_xe_engine_class_instance *hwe, i
 	struct online_debug_data *data;
 
 	data = online_debug_data_create(fd, hwe, flags);
-	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
 
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 					eu_attention_debug_trigger);
@@ -2286,8 +2290,7 @@ static void test_debugger_reopen(int fd, struct drm_xe_engine_class_instance *hw
 	struct online_debug_data *data;
 
 	data = online_debug_data_create(fd, hwe, flags);
-
-	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
 
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 					eu_attention_debug_trigger);
@@ -2337,7 +2340,7 @@ static void test_caching(int fd, struct drm_xe_engine_class_instance *hwe, int f
 		igt_skip_on_f(!xe_has_vram(fd), "Device does not have VRAM.\n");
 
 	data = online_debug_data_create(fd, hwe, flags);
-	s = xe_eudebug_session_create(fd, run_online_client, flags, data);
+	s = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data);
 
 	xe_eudebug_debugger_add_trigger(s->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 					eu_attention_debug_trigger);
@@ -2463,7 +2466,7 @@ static void test_many_sessions_on_tiles(int fd, bool multi_tile)
 
 	for (i = 0; i < n; i++) {
 		data[i] = online_debug_data_create(fd, hwe[i], flags);
-		s[i] = xe_eudebug_session_create(fd, run_online_client, flags, data[i]);
+		s[i] = xe_eudebug_session_create(fd, run_online_client, NULL, flags, data[i]);
 
 		xe_eudebug_debugger_add_trigger(s[i]->debugger, DRM_XE_EUDEBUG_EVENT_EU_ATTENTION,
 						eu_attention_debug_trigger);
Signature · 1 line
2.43.0
#21 lore raw

PATCH 20/21 tests/intel/xe_eudebug: Add render node testing

In reply to Mika Kuoppala

We need basic-connect to also check if render node is available for connection.

---
 tests/intel/xe_eudebug.c | 41 ++++++++++++++++++++++++++++++++++------
 1 file changed, 35 insertions(+), 6 deletions(-)
tests/intel/xe_eudebug.c +35 -6
index 4e7ba0348d..01410f3197 100644
@@ -460,6 +460,9 @@ static int __debug_connect(int fd, int *debugfd, struct drm_xe_eudebug_connect *
 	return ret;
 }
 
+
+#define TEST_CONNECT_RENDER BIT(0)
+
 /**
  * SUBTEST: basic-connect
  * Functionality: attach
@@ -467,23 +470,34 @@ static int __debug_connect(int fd, int *debugfd, struct drm_xe_eudebug_connect *
  *	Exercise XE_EUDEBUG_CONNECT ioctl with passing
  *	valid and invalid params.
  */
-static void test_connect(int fd)
+static void test_connect(int fd, unsigned int flags)
 {
 	struct drm_xe_eudebug_connect param = {};
-	int debugfd, ret;
+	int debugfd, ret, render_fd, target_fd;
 	pid_t *pid;
 
 	pid = mmap(NULL, sizeof(pid_t), PROT_WRITE,
 		   MAP_SHARED | MAP_ANON, -1, 0);
 
+	if (flags & TEST_CONNECT_RENDER)
+		render_fd = drm_open_driver_render(DRIVER_XE);
+
 	/* get fresh unrelated pid */
-	igt_fork(child, 1)
+	igt_fork(child, 1) {
+		if (flags & TEST_CONNECT_RENDER)
+			close(fd);
 		*pid = getpid();
+		igt_info("client in pid %d\n", *pid);
+		sleep(5);
+	}
 
-	igt_waitchildren();
-	param.fd = xe_eudebug_fd_for_pid(*pid);
+	/* XXX build a sync mechanism */
+	sleep(1);
+	target_fd = xe_eudebug_fd_for_pid(*pid);
+	igt_assert(target_fd >= 0);
 	munmap(pid, sizeof(pid_t));
 
+	param.fd = target_fd + random() + 1;
 	ret = __debug_connect(fd, &debugfd, &param);
 	igt_assert(debugfd == -1);
 	igt_assert_eq(ret, -EBADFD);
@@ -493,7 +507,15 @@ static void test_connect(int fd)
 	igt_assert(debugfd == -1);
 	igt_assert_eq(ret, -EINVAL);
 
+	param.fd = target_fd;
+	ret = __debug_connect(fd, &debugfd, &param);
+	igt_assert_neq(debugfd, -1);
+	igt_assert_eq(ret, 0);
+
+	close(debugfd);
+
 	param.fd = xe_eudebug_fd_for_pid(getpid());
+	igt_assert((int)param.fd >= 0);
 	param.version = -1;
 	ret = __debug_connect(fd, &debugfd, &param);
 	igt_assert(debugfd == -1);
@@ -517,6 +539,10 @@ static void test_connect(int fd)
 	igt_assert_eq(ret, 0);
 
 	close(debugfd);
+	if (flags & TEST_CONNECT_RENDER)
+		close(render_fd);
+
+	igt_waitchildren();
 }
 
 static void switch_user(__uid_t uid, __gid_t gid)
@@ -2789,7 +2815,10 @@ int igt_main()
 		test_sysfs_toggle(fd);
 
 	igt_subtest("basic-connect")
-		test_connect(fd);
+		test_connect(fd, 0);
+
+	igt_subtest("basic-connect-render")
+		test_connect(fd, TEST_CONNECT_RENDER);
 
 	igt_subtest("connect-user")
 		test_connect_user(fd);
Signature · 1 line
2.43.0
#22 lore raw

PATCH 21/21 eudebug: Update xe_drm_eudebug.h uapi

In reply to Mika Kuoppala

Take into account bind event member naming change from num_binds to num_bind_ops. Also documentation and ordering changes for eudebug uapi.

---
 .../drm-uapi-experimental/xe_drm_eudebug.h    | 155 ++++++++++--------
 lib/xe/xe_eudebug.c                           |  14 +-
 2 files changed, 98 insertions(+), 71 deletions(-)
include/drm-uapi-experimental/xe_drm_eudebug.h +91 -64
index 43b8d12b47..56a2f6aac9 100644
@@ -55,12 +55,34 @@ struct drm_xe_eudebug_connect {
  * This ioctl is available in debug version 1.
  */
 #define DRM_XE_EUDEBUG_IOCTL_READ_EVENT		_IO('j', 0x0)
-#define DRM_XE_EUDEBUG_IOCTL_EU_CONTROL		_IOWR('j', 0x2, struct drm_xe_eudebug_eu_control)
-#define DRM_XE_EUDEBUG_IOCTL_ACK_EVENT		_IOW('j', 0x4, struct drm_xe_eudebug_ack_event)
-#define DRM_XE_EUDEBUG_IOCTL_VM_OPEN		_IOW('j', 0x1, struct drm_xe_eudebug_vm_open)
-#define DRM_XE_EUDEBUG_IOCTL_READ_METADATA	_IOWR('j', 0x3, struct drm_xe_eudebug_read_metadata)
+#define DRM_XE_EUDEBUG_IOCTL_ACK_EVENT		_IOW('j', 0x1, struct drm_xe_eudebug_ack_event)
+#define DRM_XE_EUDEBUG_IOCTL_VM_OPEN		_IOW('j', 0x2, struct drm_xe_eudebug_vm_open)
+#define DRM_XE_EUDEBUG_IOCTL_EU_CONTROL		_IOWR('j', 0x3, struct drm_xe_eudebug_eu_control)
 
-/* XXX: Document events to match their internal counterparts when moved to xe_drm.h */
+/**
+ * struct drm_xe_eudebug_event - Base type of event delivered by xe_eudebug.
+ * @len: Length of event, including the base, of event.
+ * @type: Event type
+ * @flags: Flags for the event
+ * @seqno: Sequence number
+ * @reserved: MBZ
+ *
+ * Base event for xe_eudebug interface. To initiate a read, type
+ * needs to be set to DRM_XE_EUDEBUG_EVENT_READ and length
+ * need to be set by userspace to what has been allocated as max.
+ * On successful return the event len will be deliver or -EMSGSIZE
+ * if it does not fit. Seqno can be used to form a timeline
+ * as event delivery order does not guarantee event creation
+ * order.
+ *
+ * flags will indicate if resource was created, destroyed
+ * or its state changed.
+ *
+ * if DRM_XE_EUDEBUG_EVENT_NEED_ACK is set, the xe_eudebug
+ * will held the said resource until it is acked by userspace
+ * using another acking ioctl with the seqno of said event.
+ *
+ */
 struct drm_xe_eudebug_event {
 	__u32 len;
 
@@ -85,6 +107,12 @@ struct drm_xe_eudebug_event {
 	__u64 reserved;
 };
 
+/**
+ * struct drm_xe_eudebug_event_vm - VM resource event
+ * @vm_handle: Handle of a vm that was created/destroyed
+ *
+ * Resource creation/destruction event for a VM.
+ */
 struct drm_xe_eudebug_event_vm {
 	struct drm_xe_eudebug_event base;
 
@@ -101,55 +129,29 @@ struct drm_xe_eudebug_event_exec_queue {
 	__u64 lrc_handle[];
 };
 
-struct drm_xe_eudebug_event_eu_attention {
-	struct drm_xe_eudebug_event base;
-
-	__u64 exec_queue_handle;
-	__u64 lrc_handle;
-	__u32 flags;
-	__u32 bitmask_size;
-	__u8 bitmask[];
-};
-
-struct drm_xe_eudebug_eu_control {
-
-#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL	0
-#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED		1
-#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME		2
-	__u32 cmd;
-	__u32 flags;
-
-	__u64 seqno;
-
-	__u64 exec_queue_handle;
-	__u64 lrc_handle;
-	__u32 reserved;
-	__u32 bitmask_size;
-	__u64 bitmask_ptr;
-};
-
 /*
- *  When client (debuggee) does vm_bind_ioctl() following event
- *  sequence will be created (for the debugger):
+ * When the client (debuggee) calls the vm_bind_ioctl with the
+ * DRM_XE_VM_BIND_OP_[ADD|REMOVE]_DEBUG_DATA operation, the following event
+ * sequence will be created (for the debugger):
  *
  *  ┌───────────────────────┐
- *  │  EVENT_VM_BIND        ├───────┬─┬─┐
- *  └───────────────────────┘       │ │ │
- *      ┌───────────────────────┐   │ │ │
- *      │ EVENT_VM_BIND_OP #1   ├───┘ │ │
- *      └───────────────────────┘     │ │
- *                 ...                │ │
- *      ┌───────────────────────┐     │ │
- *      │ EVENT_VM_BIND_OP #n   ├─────┘ │
- *      └───────────────────────┘       │
- *                                      │
- *      ┌───────────────────────┐       │
- *      │ EVENT_UFENCE          ├───────┘
- *      └───────────────────────┘
+ *  │  EVENT_VM_BIND        ├──────────────────┬─┬┄┐
+ *  └───────────────────────┘                  │ │ ┊
+ *      ┌──────────────────────────────────┐   │ │ ┊
+ *      │ EVENT_VM_BIND_OP_DEBUG_DATA #1   ├───┘ │ ┊
+ *      └──────────────────────────────────┘     │ ┊
+ *                      ...                      │ ┊
+ *      ┌──────────────────────────────────┐     │ ┊
+ *      │ EVENT_VM_BIND_OP_DEBUG_DATA #n   ├─────┘ ┊
+ *      └──────────────────────────────────┘       ┊
+ *                                                 ┊
+ *      ┌┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┐       ┊
+ *      ┊ EVENT_UFENCE                     ├┄┄┄┄┄┄┄┘
+ *      └┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄┘
  *
  * All the events below VM_BIND will reference the VM_BIND
  * they associate with, by field .vm_bind_ref_seqno.
- * event_ufence will only be included if the client did
+ * EVENT_UFENCE will only be included if the client did
  * attach sync of type UFENCE into its vm_bind_ioctl().
  *
  * When EVENT_UFENCE is sent by the driver, all the OPs of
@@ -173,27 +175,26 @@ struct drm_xe_eudebug_event_vm_bind {
 	struct drm_xe_eudebug_event base;
 
 	__u64 vm_handle;
-
 	__u32 flags;
 #define DRM_XE_EUDEBUG_EVENT_VM_BIND_FLAG_UFENCE (1 << 0)
 
-	__u32 num_binds;
+	__u32 num_bind_ops;
 };
 
 struct drm_xe_eudebug_event_vm_bind_op_debug_data {
-        struct drm_xe_eudebug_event base;
-        __u64 vm_bind_ref_seqno; /* *_event_vm_bind.base.seqno */
-        __u64 num_extensions;
-
-        __u64 addr;
-        __u64 range;
-        __u64 flags;
-        __u32 offset;
-        __u32 reserved;
-        union {
-                __u64 pseudopath;
-                char pathname[PATH_MAX];
-        };
+	struct drm_xe_eudebug_event base;
+	__u64 vm_bind_ref_seqno; /* *_event_vm_bind.base.seqno */
+	__u64 num_extensions;
+
+	__u64 addr;
+	__u64 range;
+	__u64 flags;
+	__u32 offset;
+	__u32 reserved;
+	union {
+		__u64 pseudopath;
+		char pathname[PATH_MAX];
+	};
 };
 
 struct drm_xe_eudebug_event_vm_bind_ufence {
@@ -217,11 +218,37 @@ struct drm_xe_eudebug_vm_open {
 	/** @flags: flags */
 	__u64 flags;
 
-#define DRM_XE_EUDEBUG_VM_SYNC_MAX_TIMEOUT_NSECS (10ULL * NSEC_PER_SEC)
 	/** @timeout_ns: Timeout value in nanoseconds operations (fsync) */
 	__u64 timeout_ns;
 };
 
+struct drm_xe_eudebug_eu_control {
+
+#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_INTERRUPT_ALL	0
+#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_STOPPED		1
+#define DRM_XE_EUDEBUG_EU_CONTROL_CMD_RESUME		2
+	__u32 cmd;
+	__u32 flags;
+
+	__u64 seqno;
+
+	__u64 exec_queue_handle;
+	__u64 lrc_handle;
+	__u32 reserved;
+	__u32 bitmask_size;
+	__u64 bitmask_ptr;
+};
+
+struct drm_xe_eudebug_event_eu_attention {
+	struct drm_xe_eudebug_event base;
+
+	__u64 exec_queue_handle;
+	__u64 lrc_handle;
+	__u32 flags;
+	__u32 bitmask_size;
+	__u8 bitmask[];
+};
+
 struct drm_xe_eudebug_event_pagefault {
 	struct drm_xe_eudebug_event base;
 
lib/xe/xe_eudebug.c +7 -7
index 7c1ac38d9c..1e3cdfe048 100644
@@ -146,8 +146,8 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *bu
 	case DRM_XE_EUDEBUG_EVENT_VM_BIND: {
 		struct drm_xe_eudebug_event_vm_bind *evmb = igt_container_of(e, evmb, base);
 
-		sprintf(buf, "vm_handle=%llu, flags=0x%x, num_binds=%u",
-			evmb->vm_handle, evmb->flags, evmb->num_binds);
+		sprintf(buf, "vm_handle=%llu, flags=0x%x, num_bind_ops=%u",
+			evmb->vm_handle, evmb->flags, evmb->num_bind_ops);
 		break;
 	}
 	case DRM_XE_EUDEBUG_EVENT_VM_BIND_OP_DEBUG_DATA: {
@@ -596,7 +596,7 @@ static int match_fields(struct drm_xe_eudebug_event *a, void *data)
 		struct drm_xe_eudebug_event_vm_bind *ea = igt_container_of(a, ea, base);
 		struct drm_xe_eudebug_event_vm_bind *eb = igt_container_of(b, eb, base);
 
-		if (ea->num_binds == eb->num_binds)
+		if (ea->num_bind_ops == eb->num_bind_ops)
 			ret = 1;
 		break;
 	}
@@ -699,7 +699,7 @@ static int match_opposite_resource(struct drm_xe_eudebug_event *e, void *data)
 		struct drm_xe_eudebug_event_vm_bind *filter = data;
 
 		if (evmb->vm_handle == filter->vm_handle &&
-		    evmb->num_binds == filter->num_binds)
+		    evmb->num_bind_ops == filter->num_bind_ops)
 			return 1;
 		break;
 	}
@@ -2077,14 +2077,14 @@ void xe_eudebug_client_exec_queue_destroy(struct xe_eudebug_client *c,
  * @event_flags: base event flags
  * @vm: vm handle
  * @bind_flags: bind flags of vm_bind_event
- * @num_binds: number of bind (operations) for event
+ * @num_binds_ops: number of bind (operations) for event
  * @ref_seqno: base vm bind reference seqno
  * Logs vm bind event in client's event log.
  */
 void xe_eudebug_client_vm_bind_event(struct xe_eudebug_client *c,
 				     uint32_t event_flags,
 				     uint32_t vm, uint32_t bind_flags,
-				     uint32_t num_binds, u64 *ref_seqno)
+				     uint32_t num_bind_ops, u64 *ref_seqno)
 {
 	struct drm_xe_eudebug_event_vm_bind evmb;
 
@@ -2095,7 +2095,7 @@ void xe_eudebug_client_vm_bind_event(struct xe_eudebug_client *c,
 		   event_flags, sizeof(evmb));
 	evmb.vm_handle = vm;
 	evmb.flags = bind_flags;
-	evmb.num_binds = num_binds;
+	evmb.num_bind_ops = num_bind_ops;
 
 	*ref_seqno = evmb.base.seqno;
 
Signature · 1 line
2.43.0