eudebug: uapi changes on connect and metadata
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
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
@@ -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
PATCH 2/21 lib/xe/xe_eudebug: Make sure debugger drains events
In reply to Mika KuoppalaDo 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
@@ -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
@@ -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
@@ -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
PATCH 3/21 lib/xe/xe_eudebug: Avoid matching if event is filtered
In reply to Mika KuoppalaBail 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
@@ -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
PATCH 4/21 tests/intel/xe_eudebug_sriov: Align expected return code
In reply to Mika KuoppalaFrom: 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
@@ -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
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 codeFrom: Christoph Manszewski <[email protected]>
Align with kernel commit
387aba39b7be(drm/xe/pf: Allow to lockdown the PF using custom guard).Signed-off-by Christoph Manszewski <[email protected]>Signed-off-by Mika Kuoppala <[email protected]>--- tests/intel/xe_eudebug_sriov.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)tests/intel/xe_eudebug_sriov.c +1
-1@@ -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
PATCH 5/21 eudebug: Remove metadata tests
In reply to Mika KuoppalaMetadata 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
@@ -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
@@ -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
PATCH 6/21 eudebug: Remove EVENT_OPEN and adjust tests
In reply to Mika Kuoppalaeudebug 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
@@ -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
@@ -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
PATCH 7/21 tests/xe_eudebug: Adapt basic-read-event
In reply to Mika KuoppalaFrom: 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
@@ -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
PATCH 8/21 tests/intel/xe_eudebug: Fix connect-user test
In reply to Mika KuoppalaWe 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
@@ -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
PATCH 9/21 tests/intel/xe_eudebug: Mold ufence reconnect test to disconnect
In reply to Mika KuoppalaIf 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
@@ -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
PATCH 10/21 lib/xe_eudebug: Adapt to vm_bind debug data
In reply to Mika KuoppalaFrom: 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
@@ -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
@@ -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
PATCH 11/21 tests/xe_eudebug: Adapt basic-vm-bind and remove basic-vm-bind-extended
In reply to Mika KuoppalaFrom: 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
@@ -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
PATCH 12/21 tests/xe_eudebug: Adapt some ufence reliant tests to new vm_bind event interface
In reply to Mika KuoppalaFrom: 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
@@ -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
PATCH 13/21 tests/xe_eudebug: Adapt vm-bind-clear* subtests to debug data
In reply to Mika KuoppalaFrom: 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
@@ -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
PATCH 14/21 lib/xe_eudebug: Remove unused xe_eudebug_client_vm_bind wrappers
In reply to Mika KuoppalaFrom: 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
@@ -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
@@ -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
@@ -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
PATCH 15/21 tests/xe_eudebug: Add vm-bind-debug-data-ufence subtest
In reply to Mika KuoppalaFrom: 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
@@ -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
@@ -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
@@ -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
@@ -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 *hwxe_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_instancexe_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
PATCH 16/21 lib/intel_batchbuffer: Add dummy OP_DEBUG_DATA operation to __xe_alloc_bind_ops
In reply to Mika KuoppalaFrom: 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
@@ -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
PATCH 17/21 tests/xe_eudebug_online: Adapt set-breakpoint test to work with new vm bind event interface
In reply to Mika KuoppalaFrom: 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
@@ -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_instanxe_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
PATCH 18/21 tests/xe_eudebug_online: Adapt several subtests to work with new vm bind event interface
In reply to Mika KuoppalaFrom: 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
@@ -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 *hxe_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 *hxe_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, ixe_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 fxe_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
PATCH 19/21 lib/xe/xe_eudebug: Add callback for session work
In reply to Mika KuoppalaIf 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
@@ -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
@@ -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 *cstruct 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
@@ -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_instanigt_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 *hwint 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 *higt_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_instanceuint32_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, istruct 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 *hwstruct 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 figt_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
PATCH 20/21 tests/intel/xe_eudebug: Add render node testing
In reply to Mika KuoppalaWe 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
@@ -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, ¶m);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, ¶m); +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, ¶m);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
PATCH 21/21 eudebug: Update xe_drm_eudebug.h uapi
In reply to Mika KuoppalaTake 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
@@ -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
@@ -146,8 +146,8 @@ static const char *event_members_to_str(struct drm_xe_eudebug_event *e, char *bucase 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